rVM 0.0.3 → 0.0.4

data/README

@@ -0,0 +1,38 @@
+= rVM
+
+rVM is the implementation of a VirtualMachine in pure Ruby. To clarify, no virtual machine as in VMWare that lets you virtualize a computer. But rather like ruby 1.9 or JRuby that both implement a virtual machine (written in C or Java) to execute Ruby code.
+Just that rVM takes it the other way around, it is written in ruby and lets you execute code within ruby.
+
+= So what is so cool about that?
+
+For once, the challenge to pull this off ;P. Then it has on huge advantage. It makes it pretty easy to give ruby programs a interface for scripting.
+
+Now you might think 'wow cool but I could just use ruby!' that is right, and wrong. Imagine just short code snippets to make a query, perhaps you want to implement a SQL based language to let a user query data in your program? Also consider you want your website to allow user side scripts. I would not want to have ruby code executed for random visitors. Then again I might be more tempted to let them execute code within a VM that has no access to anything outside it's VM neither variables nor hardware nor memory.
+
+= Example
+
+
+The following example implements a pretty easy calculator using the the math language shipped with rVM. Set variables and are not used outside one line
+
+  require 'rubygems'
+  require 'rvm' # This loads the rVM gem
+  require 'rvm/languages/math'  #This loads the math plugin as well as the math function library
+  s =''
+  compiler = RVM::Languages[:math] #Lets get us the compiler
+  while s!= 'QUIT'
+    s=gets.chomp
+    puts compiler.compile(s).execute(RVM::Interpreter.env) # We pass an fresh enviroment as we don't need an environment.
+  end
+  
+Here one example that keeps set variables due to using one enviroment for all the calls.
+
+  require 'rubygems'
+  require 'rvm' # This loads the rVM gem
+  require 'rvm/languages/math'  #This loads the math plugin as well as the math function library
+  s =''
+  compiler = RVM::Languages[:math] #Lets get us the compiler
+  env = RVM::Interpreter.env
+  while s!= 'QUIT'
+    s=gets.chomp
+    puts compiler.compile(s).execute(env) # We pass an fresh enviroment as we don't need an environment.
+  end

data/lib/rvm/classes/string.rb

@@ -1,6 +1,6 @@
 module RVM
   module Classes
-    class String <String 
+    class String < ::String 
       extend Plugin
       plugin_host Classes
       register_for :string

data/lib/rvm/interpreter.rb

@@ -39,12 +39,13 @@ module RVM
         RVM::debug "data: #{data}\noldenv:#{oldenv}"
         @data = {
           :locals => {},
+          :functions => {},
           :caller => nil,
           :self => nil,
           :evaldeepth => 0,
           :params => []
         }.merge(data)
-        @prev = oldenv  || {}
+        @prev = oldenv || {}
         RVM::debug "Creating new enviroment with: #{@data.inspect} as child of #{@prev}"
         
       end
@@ -86,7 +87,7 @@ module RVM
       # the given name it tries the privious enviroments.
       def [] k
         r = @data[:locals][k] || @prev[k]
-        RVM::debug "Getting ariable #{k} (#{r})"
+        RVM::debug "Getting variable #{k} (#{r})"
         r
       end
       
@@ -97,6 +98,38 @@ module RVM
         @data[:locals][k] = v
       end
       
+      #Returns a function for the current enviroment
+      def function k
+        r = @data[:functions][k]
+        if not r and @prev.is_a? Enviroment
+         r = @prev.function(k)
+        end
+        RVM::debug "Getting functon #{k} (#{r})"
+        r
+      end
+      
+      #Returns a function for the current enviroment
+      def def_function k, b
+        @data[:functions][k] = b
+        RVM::debug "Setting functon #{k} (#{b})"
+        nil
+      end
+    end
+    
+    class FunctionDefinition
+      def initialize name, body, override = true
+        @name = name
+        @body = body
+        @override = override
+      end
+      
+      def execute env
+        if (not @override) and env.function(@name)
+          raise "Function #{@name} already defined!"
+        end
+        env.def_function(@name.execute(env),@body.execute(env))
+        nil
+      end
     end
     
     class Loop 
@@ -284,7 +317,7 @@ module RVM
       def execute env
         RVM::debug "Executing Parameter..."
         r = env.param(@num.execute(env).to_i)
-        @type = r.data_type
+        @type = r.data_type if r
         r
       end
     end
@@ -303,6 +336,10 @@ module RVM
         r
       end
       
+      def + v
+        Sequence.new(super)
+      end
+      
       def data_type
         :any
       end
@@ -322,11 +359,7 @@ module RVM
       #
       # Arguments is a list of the arguments to the function.
       def initialize function,  arguments
-        if function.is_a? RVM::Classes[:block]
-          @function = function
-        else
-          @function = RVM::Functions[function]
-        end
+        @function = function
         @arguments = arguments
       end
       
@@ -345,12 +378,25 @@ module RVM
       def execute env
         RVM::debug "Executing FunctionCall..."
         args = @arguments
-        if @function.execargs
+        if @function.is_a? RVM::Classes[:block]
+          args = @arguments.map do |arg|
+            arg.execute env
+          end
+          @function.call(args, env)
+        elsif (fun = env.function(@function))
           args = @arguments.map do |arg|
             arg.execute env
           end
+          fun.call(args, env)
+        else
+          fun = RVM::Functions[@function]
+          if fun.execargs
+            args = @arguments.map do |arg|
+              arg.execute env
+            end
+          end
+          fun.call(args, env)
         end
-        @function.call(args, env)
       end
     end
   end

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

@@ -1,36 +1,70 @@
 module RVM
-	module Languages
-		module Math
-			class Compiler
-				include RVM::Interpreter
-				FUNCTION_MAP = {
+  module Languages
+    module Math
+      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 :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 :op
-							FunctionCall.new(FUNCTION_MAP[tree[:op]], [compile(tree[:left]),compile(tree[:right])])
-						end
-					end
-				end
-			end
-		end
-	end
+        }
+        def Compiler.compile tree
+          if tree.is_a? Array
+            compile(tree.first)
+          elsif tree.is_a? Hash
+            case tree[:type]
+              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)))
+                  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/math/tokenizer.rb

@@ -1,47 +1,65 @@
 require 'strscan'
 module RVM
-	module Languages
-		module Math
-			class Tokenizer
-				def Tokenizer.tokenize str
-					s = StringScanner.new str
-					tokens = []
-					state = :number
-					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)
-								tokens << [s.matched, :function]
-							elsif s.scan(/[\d]+(\.\d+)?/i)
-								tokens << [s.matched, :number]
-								state = :opperator
-							elsif s.scan(/\(/)
-								tokens << [s.matched, :paren_open]
-							else
-								return []
-							end
-						else
-							if s.scan(/\)/)
-								tokens << [s.matched, :paren_close]
-							elsif s.scan(/,/)
-								tokens << [s.matched, :function_sep]
-								state = :number
-							elsif s.scan(/[*+\/^-]/)
-								tokens << [s.matched, :opperator]
-								state = :number
-							else
-								return []
-							end
-						end
-					end
-					tokens
-				end
-			end
-		end
-	end
+  module Languages
+    module Math
+      class Tokenizer
+        def Tokenizer.tokenize str
+          s = StringScanner.new str
+          tokens = []
+          state = :number
+          paren_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]
+              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(/,/)
+                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/math/tree.rb

@@ -1,100 +1,109 @@
 module RVM
-	module Languages
-		module Math
-				class Tree
-				PRIORITIES = {
+  module Languages
+    module Math
+      class Tree
+        PRIORITIES = {
+          ';' => -1,
+          '=' => 0,
 					'(' => 0,
 					'+' => 1,
 					'-' => 1,
 					'*' => 2,
 					'/' => 2,
 					'^' => 3,
-					}
-				ASSOSICATIONS = {
+        }
+        ASSOSICATIONS = {
+          ';' => :right,
 					'+' => :left,
 					'-' => :left,
 					'*' => :left,
 					'/' => :left,
-					'^' => :right
-					}
-				def Tree.generate tokens
-					output = []
-					dbgoutput = []
-						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[:op] != '(')
-								output << stack.pop
-								dbgoutput << dbgstack.pop
-							end
-						when :paren_open
-							op = token[0]
-							stack << {:type => :op, :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
-						when :number
-							output << {:type => :number, :number => token[0]}
-							dbgoutput << token[0]
-						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
-					end
-					while not stack.empty?
-						output <<  stack.pop
-					end
-					gen_tree output
-				end
-	
-				private
-				def Tree.gen_tree data
-					item = data.pop
-					case item[:type]
-					when :number
-						item
-					when :op
-						item[:right] = gen_tree(data)
-						item[:left] = 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
+					'^' => :right,
+          '=' => :right
+        }
+        def Tree.generate tokens
+          output = []
+          dbgoutput = []
+          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[:op] != '(')
+                output << stack.pop
+                dbgoutput << dbgstack.pop
+              end
+              when :paren_open
+              op = token[0]
+              stack << {:type => :op, :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
+              when :number
+              output << {:type => :number, :number => token[0]}
+              dbgoutput << token[0]
+              when :ident
+              output << {:type => :ident, :ident => token[0]}
+              dbgoutput << token[0]
+              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
+          end
+          while not stack.empty?
+            output <<  stack.pop
+          end
+          p output
+          gen_tree output
+        end
+        
+        private
+        def Tree.gen_tree data
+          p data
+          item = data.pop
+          case item[:type]
+            when :number, :ident
+            item
+            when :op
+            item[:right] = gen_tree(data)
+            item[:left] = 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rVM
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Heinz N. Gies
@@ -9,7 +9,7 @@ autorequire: ""
 bindir: bin
 cert_chain: []
 
-date: 2008-03-04 00:00:00 +01:00
+date: 2008-03-05 00:00:00 +01:00
 default_executable: 
 dependencies: []