rVM 0.0.4 → 0.0.5

data/lib/rvm/interpreter.rb

@@ -40,8 +40,6 @@ module RVM
         @data = {
           :locals => {},
           :functions => {},
-          :caller => nil,
-          :self => nil,
           :evaldeepth => 0,
           :params => []
         }.merge(data)
@@ -50,27 +48,6 @@ module RVM
         
       end
       
-      # returns the object that issued the VM call - so to say it's owner.
-      #
-      # If the current enviroment has no caller it tries it's 'oldenv' attrib
-      # to see if that had a owner.
-      def caller
-        r = @data[:caller] || (@prev.is_a?(Enviroment) ? @prev.caller : nil)
-        RVM::debug "Getting caller: #{r}"
-        r
-      end
-      
-      # returns the object that the code is run as, so it has the rights of
-      # this object.
-      #
-      # If the current enviroment has no object it tries it's 'oldenv' attrib
-      # to see if that had a object.
-      def object
-        r = @data[:self] || (@prev.is_a?(Enviroment) ? @prev.object : nil)
-        RVM::debug "Getting object: #{r}"
-        r
-      end
-      
       # returns a parameter that was passed to the call. For function calls
       # this is especially important, it beginns with 0.
       #

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

@@ -51,10 +51,10 @@ module RVM
                   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

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

@@ -16,16 +16,20 @@ module RVM
                 if t == '-'
                   tokens << [t, :function]
                 end
-              elsif s.scan(/[a-z][a-z0-9]*/i)
+              elsif s.scan(/[_a-z][_a-z0-9]*/i)
                 r = s.matched
                 if s.scan(/\(/)      
                   tokens << [r, :function] 
-                  paren_deepth += 1
+                  if s.scan(/\)/)
+                    tokens << [s.matched, :paren_close]
+                  else
+                     paren_deepth += 1
+                  end
                 else
                   tokens << [r, :ident]
                   state = :opperator
                 end
-              elsif s.scan(/[\d]+(\.\d+)?/i)
+              elsif s.scan(/((\d+(\.\d+)?)|(\.\d+))(e-?\d+)?/i)
                 tokens << [s.matched, :number]
                 state = :opperator
               elsif s.scan(/\(/)

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

@@ -3,17 +3,17 @@ module RVM
     module Math
       class Tree
         PRIORITIES = {
-          ';' => -1,
-          '=' => 0,
+          ';' => -100,
+          '=' => -50,
 					'(' => 0,
-					'+' => 1,
-					'-' => 1,
-					'*' => 2,
-					'/' => 2,
-					'^' => 3,
+					'+' => 10,
+					'-' => 10,
+					'*' => 20,
+					'/' => 20,
+					'^' => 30,
         }
         ASSOSICATIONS = {
-          ';' => :right,
+          ';' => :right, 
 					'+' => :left,
 					'-' => :left,
 					'*' => :left,
@@ -36,7 +36,7 @@ module RVM
               dbgoutput << ')'
               dbgstack << fun
               when :function_sep
-              while stack.last && (stack.last[:op] != '(')
+              while stack.last && (stack.last[:type] != :function)
                 output << stack.pop
                 dbgoutput << dbgstack.pop
               end
@@ -51,10 +51,6 @@ module RVM
               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]
@@ -65,7 +61,7 @@ module RVM
               op = token[0]
               ass = ASSOSICATIONS[op]
               o1p = PRIORITIES[op]
-              while stack.last && 
+              while stack.last && (stack.last[:type] != :function) &&
                (((ass == :left) && (o1p <= PRIORITIES[stack.last[:op]])) || 
                ((ass == :right) && (o1p < PRIORITIES[stack.last[:op]])))
                 output << stack.pop
@@ -74,25 +70,30 @@ module RVM
               stack << {:type => :op, :op => op}
               dbgstack << op
             else
+               raise "Unknown element in parser tree: #{token.inspect}"
             end
+						p(dbgstack) if $DEBUG
+						p(dbgoutput) if $DEBUG
           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
+          when :op
             item[:right] = gen_tree(data)
-            item[:left] = gen_tree(data)
+            if item[:op] == ';' and  data.empty?
+              item = item[:right]
+            else
+              item[:left] = gen_tree(data)
+            end
             item
             when :function
             item[:params] = []

data/lib/rvm/languages/simple.rb

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,144 @@
+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

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: rVM
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Heinz N. Gies
-autorequire: ""
+autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-03-05 00:00:00 +01:00
+date: 2008-03-06 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -73,6 +73,11 @@ files:
 - 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/plugin.rb
 - lib/rvm.rb