rVM 0.0.5 → 0.0.6

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rVM
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Heinz N. Gies
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-06 00:00:00 +01:00
+date: 2008-07-06 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -26,15 +26,27 @@ files:
 - lib/rvm/classes
 - lib/rvm/classes/block.rb
 - lib/rvm/classes/boolean.rb
+- lib/rvm/classes/class.rb
 - lib/rvm/classes/error.rb
 - lib/rvm/classes/list.rb
 - lib/rvm/classes/number.rb
+- lib/rvm/classes/object.rb
 - lib/rvm/classes/string.rb
 - lib/rvm/classes.rb
 - lib/rvm/functions
 - lib/rvm/functions/all.rb
+- lib/rvm/functions/array
+- lib/rvm/functions/array/append.rb
+- lib/rvm/functions/array/set_at.rb
+- lib/rvm/functions/array.rb
 - lib/rvm/functions/general
 - lib/rvm/functions/general/cmp.rb
+- lib/rvm/functions/general/eq.rb
+- lib/rvm/functions/general/gt.rb
+- lib/rvm/functions/general/gte.rb
+- lib/rvm/functions/general/lt.rb
+- lib/rvm/functions/general/lte.rb
+- lib/rvm/functions/general/neq.rb
 - lib/rvm/functions/general.rb
 - lib/rvm/functions/io
 - lib/rvm/functions/io/print.rb
@@ -47,6 +59,9 @@ files:
 - lib/rvm/functions/list.rb
 - lib/rvm/functions/logic
 - lib/rvm/functions/logic/and.rb
+- lib/rvm/functions/logic/not.rb
+- lib/rvm/functions/logic/or.rb
+- lib/rvm/functions/logic.rb
 - lib/rvm/functions/math
 - lib/rvm/functions/math/add.rb
 - lib/rvm/functions/math/div.rb
@@ -55,6 +70,8 @@ files:
 - lib/rvm/functions/math/power.rb
 - lib/rvm/functions/math/sub.rb
 - lib/rvm/functions/math.rb
+- lib/rvm/functions/objects
+- lib/rvm/functions/objects/send.rb
 - lib/rvm/functions/string
 - lib/rvm/functions/string/ansi.rb
 - lib/rvm/functions/string/capstr.rb
@@ -68,17 +85,14 @@ files:
 - lib/rvm/interpreter.rb
 - lib/rvm/languages
 - lib/rvm/languages/brainfuck.rb
+- lib/rvm/languages/ecma.rb
 - lib/rvm/languages/math
 - lib/rvm/languages/math/compiler.rb
 - lib/rvm/languages/math/tokenizer.rb
 - lib/rvm/languages/math/tree.rb
 - lib/rvm/languages/math.rb
-- lib/rvm/languages/simple
-- lib/rvm/languages/simple/compiler.rb
-- lib/rvm/languages/simple/tokenizer.rb
-- lib/rvm/languages/simple/tree.rb
-- lib/rvm/languages/simple.rb
 - lib/rvm/languages.rb
+- lib/rvm/library.rb
 - lib/rvm/plugin.rb
 - lib/rvm.rb
 - README
@@ -104,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rmush
-rubygems_version: 1.0.1
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: A ruby based VM that lets one add secure scripting to ruby applications.

data/lib/rvm/languages/simple.rb

@@ -1,15 +0,0 @@
-require File.dirname(__FILE__) + '/simple/tokenizer'
-require File.dirname(__FILE__) + '/simple/tree'
-require File.dirname(__FILE__) + '/simple/compiler'
-require 'rvm/functions/math'
-module RVM
-	module Languages
-		class SimpleLanguage < Language
-			include Simple
-			def compile text
-			  Compiler.compile(Tree.generate(Tokenizer.tokenize(text)))
-			end
-			register_for :simple
-		end
-	end
-end

data/lib/rvm/languages/simple/compiler.rb

@@ -1,73 +0,0 @@
-module RVM
-  module Languages
-    module Simple
-      class Compiler
-        include RVM::Interpreter
-        FUNCTION_MAP = {
-					'+' => :add,
-					'-' => :sub,
-					'/' => :div,
-					'*' => :mul,
-					'^' => :power
-        }
-        def Compiler.compile tree
-          if tree.is_a? Array
-            compile(tree.first)
-          elsif tree.is_a? Hash
-            case tree[:type]
-							when :paren
-								compile tree[:content]
-              when :number
-              Interpreter.const(:number, tree[:number])
-              when :function
-              params = tree[:params].map {|p| compile(p)}
-              case tree[:op]
-                when '-'
-                FunctionCall.new :neg, params
-              else
-                FunctionCall.new tree[:op], params
-              end
-              when :ident
-              Interpreter::Variable.new(Interpreter.const(:string, tree[:ident]))
-              when :op
-              case tree[:op]
-                when ';'
-                s = Interpreter::Sequence.new()
-                if (tree[:left][:type] == :op) and (tree[:left][:op] == ';')
-                  s += compile(tree[:left])
-                else
-                  s << compile(tree[:left])
-                end
-                if (tree[:right][:type] == :op) and (tree[:right][:op] == ';')
-                  s += compile(tree[:right])
-                else
-                  s << compile(tree[:right])
-                end
-                when '='
-                case tree[:left][:type]
-                  when :ident
-                  Interpreter::Assignment.new(Interpreter.const(:string, tree[:left][:ident]),compile(tree[:right]))
-                  when :function
-                  body = Interpreter::Sequence.new()
-                  i = 0
-                  tree[:left][:params].each do |p|
-                    raise ArgumentError, "Bad ype for a function parameter: #{p[:type]} " if p[:type] != :ident
-                    body << Interpreter::Assignment.new(Interpreter.const(:string, p[:ident]), Interpreter::Parameter.new(Interpreter.const(:number, i)))
-										i += 1
-                  end
-                  body << compile(tree[:right])
-                  Interpreter::FunctionDefinition.new(Interpreter.const(:string, tree[:left][:op]), Interpreter.const(:block,body))
-                  
-                else
-                  raise ArgumentError, "Bad name for a variable!"
-                end
-              else
-                FunctionCall.new(FUNCTION_MAP[tree[:op]], [compile(tree[:left]),compile(tree[:right])])
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rvm/languages/simple/tokenizer.rb

@@ -1,75 +0,0 @@
-require 'strscan'
-module RVM
-  module Languages
-    module Simple
-      class Tokenizer
-        
-				def Tokenizer.tokenize str
-          s = StringScanner.new str
-          tokens = []
-          state = :number
-          paren_deepth = 0
-					block_deepth = 0
-          while not s.eos?
-            s.skip(/\s*/)
-            if state == :number
-              if s.scan(/[+-]+/)
-                t = s.matched.gsub('+','').gsub('--','')
-                if t == '-'
-                  tokens << [t, :function]
-                end
-              elsif s.scan(/[a-z][a-z0-9]*/i)
-                r = s.matched
-                if s.scan(/[(]/)      
-                  tokens << [r, :function] 
-                  paren_deepth += 1
-                else
-                  tokens << [r, :ident]
-                  state = :opperator
-                end
-              elsif s.scan(/[\d]+(\.\d+)?/i)
-                tokens << [s.matched, :number]
-                state = :opperator
-              elsif s.scan(/[(]/)
-                paren_deepth += 1
-                tokens << [s.matched, :paren_open]
-              elsif s.scan(/[{]/)
-                block_deepth += 1
-                tokens << [s.matched, :block_close]
-							else
-                raise "Unknown literal in term at positin #{s.pos}."
-              end
-            else
-              if s.scan(/[)]/)
-                paren_deepth -= 1
-                raise "Unmatched ')' parenthes at #{s.pos}" if paren_deepth < 0
-                tokens << [s.matched, :paren_close]
-              elsif s.scan(/[}]/)
-                block_deepth -= 1
-                raise "Unmatched '}' parenthes at #{s.pos}" if paren_deepth < 0
-                tokens << [s.matched, :block_close]
-              elsif s.scan(/,/)
-                tokens << [s.matched, :function_sep]
-                state = :number
-              elsif s.scan(/[*+\/^=-]/)
-                tokens << [s.matched, :opperator]
-                state = :number
-              elsif s.scan(/;/)
-                if paren_deepth == 0
-                  tokens << [s.matched, :opperator]
-                  state = :number
-                else
-                   raise "Expression sepperator enclosed in parenthes at #{s.pos}"
-                end
-              else
-                raise "Unknown literal in term at positin #{s.pos}."
-              end
-            end
-          end
-          tokens
-        end
-				
-      end
-    end
-  end
-end

data/lib/rvm/languages/simple/tree.rb

@@ -1,144 +0,0 @@
-module RVM
-  module Languages
-    module Simple
-      class Tree
-        PRIORITIES = {
-					
-          ';' => -100,
-          '{' => -50,
-					'=' => -50,
-					'(' => 0,
-					'+' => 10,
-					'-' => 10,
-					'*' => 20,
-					'/' => 20,
-					'^' => 30,
-        }
-        ASSOSICATIONS = {
-					'{' => :left,          
-					'+' => :left,
-					'-' => :left,
-					'*' => :left,
-					'/' => :left,
-					';' => :right,
-					'^' => :right,
-          '=' => :right
-        }
-				PARENS = {
-					'(' => ')',
-					'{' => '}'
-				}
-        def Tree.generate tokens
-          output = []
-          dbgoutput = []
-          pstack = []
-					stack = []
-          dbgstack = []
-					
-          while not tokens.empty?
-            token = tokens.shift
-            case token[1]
-              when :function 
-              fun = token[0]
-              stack << {:type => :function, :op => fun}
-              output << {:type => :function_end}
-              dbgoutput << ')'
-              dbgstack << fun
-              when :function_sep
-              while stack.last && (stack.last[:type] != :function)
-                output << stack.pop
-                dbgoutput << dbgstack.pop
-              end
-							#Parenthetes
-              when :paren_open
-              op = token[0]
-							pstack << op
-							stack << {:type => :paren, :op => op}
-							dbgstack << op
-              when :paren_close
-              while stack.last && (stack.last[:op] != ')')
-                output << stack.pop
-                dbgoutput << dbgstack.pop
-              end
-              stack.pop
-              dbgstack.pop
-              if stack.last && (stack.last[:type] == :function)
-                output << stack.pop
-                dbgoutput << dbgstack.pop
-              end
-							#Blocks
-              when :block_open
-              op = token[0]
-							pstack << op
-							stack << {:type => :block, :op => op}
-							dbgstack << op
-              when :block_close
-              while stack.last && (stack.last[:op] != '}')
-                output << stack.pop
-                dbgoutput << dbgstack.pop
-              end
-              stack.pop
-              dbgstack.pop
-							#numbers
-              when :number
-              output << {:type => :number, :number => token[0]}
-              dbgoutput << token[0]
-							#idents
-              when :ident
-              output << {:type => :ident, :ident => token[0]}
-              dbgoutput << token[0]
-							# opperators
-              when :opperator
-              op = token[0]
-              ass = ASSOSICATIONS[op]
-              o1p = PRIORITIES[op]
-              while stack.last && 
-               (((ass == :left) && (o1p <= PRIORITIES[stack.last[:op]])) || 
-               ((ass == :right) && (o1p < PRIORITIES[stack.last[:op]])))
-                output << stack.pop
-                dbgoutput << dbgstack.pop
-              end
-              stack << {:type => :op, :op => op}
-              dbgstack << op
-            else
-            end
-						if $DEBUG 
-							p dbgstack 
-							p dbgoutput
-						end
-          end
-          while not stack.empty?
-            output <<  stack.pop
-          end
-					p output if $DEBUG
-          gen_tree output
-        end
-        
-        private
-        def Tree.gen_tree data
-					p data if $DEBUG
-          item = data.pop
-					p item
-          case item[:type]
-            when :number, :ident
-            item
-            when :op
-            item[:right] = gen_tree(data)
-						item[:left] = gen_tree(data) 
-            item
-						when :paren, :block
-						item[:content] = gen_tree(data)
-						item
-            when :function
-            item[:params] = []
-            while data.last && data.last[:type] != :function_end
-              item[:params] << gen_tree(data)
-            end
-            data.pop
-            item
-          end
-        end
-      end
-    end
-  end
-end