rVM 0.0.5 → 0.0.6

data/lib/rvm/functions/logic/not.rb

@@ -0,0 +1,17 @@
+module RVM
+  module Functions
+    class Not < RVM::Functions::Function
+      class << self
+        def execute params, env
+          RVM::Classes::Boolean.new(! params[0].is_true?)
+        end
+        
+        def signature
+          [:any] # adjust the signature here
+        end
+        
+      end
+      register_for :not
+    end
+  end
+end

data/lib/rvm/functions/logic/or.rb

@@ -0,0 +1,24 @@
+module RVM
+  module Functions
+    class Or < RVM::Functions::Function
+      class << self
+        def execute params, env
+          while not result and not params.empty?
+            v =  params.shift.execute(env)
+            return v if v.is_true?
+          end
+          return RVM::Classes::Boolean.new(false)
+        end
+        
+        def signature
+          [:any] # adjust the signature here
+        end
+        
+        def execargs
+          false
+        end
+      end
+      register_for :or
+    end
+  end
+end

data/lib/rvm/functions/math/add.rb

@@ -2,15 +2,15 @@ module RVM
 	module Functions
 		class Add < Function
 			def Add.execute params, env
-				a = RVM::Classes[:number].new 0
-				params.each do |p|
+				a = params.shift
+        params.each do |p|
 					a += p
 				end
 				a
 			end
 
 			def Add.signature
-				[:number, :number]
+				[:any]
 			end
 			register_for :add
 		end

data/lib/rvm/functions/math/div.rb

@@ -2,18 +2,16 @@ module RVM
 	module Functions
 		class Div < Function
 			def Div.execute params, env
-				a = RVM::Classes[:number].new params.shift
-				params.each do |p|
-					if p == 0
-						return RVM::Classes[:error].new(1,"DIVISION BY ZERO")
-					end
+				a = params.shift
+				
+        params.each do |p|
 					a /= p
 				end
 				a
 			end
 
 			def Div.signature
-				[:number, :number]
+				[:any]
 			end
 			register_for :div
 		end

data/lib/rvm/functions/math/mul.rb

@@ -2,7 +2,7 @@ module RVM
 	module Functions
 		class Mul < Function
 			def Mul.execute params, env
-				a = RVM::Classes[:number].new params.shift
+				a = params.shift
 				params.each do |p|
 					a *= p
 				end

data/lib/rvm/functions/math/sub.rb

@@ -2,7 +2,7 @@ module RVM
 	module Functions
 		class Sub < Function
 			def Sub.execute params, env
-				a = RVM::Classes[:number].new params.shift
+				a = params.shift
 				params.each do |p|
 					a -= p
 				end

data/lib/rvm/functions/objects/send.rb

@@ -0,0 +1,22 @@
+module RVM
+  module Functions
+    class Send < RVM::Functions::Function
+      class << self
+        def execute params, env
+          obj = params.shift
+          method = params.shift
+          if obj and method
+            obj.obj_send(method, params, env)
+          else
+            
+          end
+        end
+        
+        def signature
+          [:any, :string, :any] 
+        end
+      end
+      register_for :send
+    end
+  end
+end

data/lib/rvm/interpreter.rb

@@ -22,6 +22,19 @@ module RVM
       RVM::Interpreter::Constant.new(RVM::Classes[type].new(value))
     end
     
+    class VariableStorage
+      attr_accessor :val
+      def initialize val, writable = true
+        @writable = writable
+        @val = val
+      end
+      
+      def val=v
+        @val = v if @writable
+        @val
+      end
+    end
+    
     # This class represents the enviroment, the memory so to say for the VM.
     # The enviroment holds enviromental variables like who executes the
     # code, on what object it runs, what parameters where passed to the call
@@ -35,17 +48,22 @@ module RVM
       #
       # If *oldenv* is provided it will also fall back to see if not
       # existing variables 
-      def initialize data = {}, oldenv=nil
-        RVM::debug "data: #{data}\noldenv:#{oldenv}"
+      def initialize init_data = {}, oldenv=nil
+        
         @data = {
           :locals => {},
           :functions => {},
           :evaldeepth => 0,
           :params => []
-        }.merge(data)
+        }.merge(init_data)
         @prev = oldenv || {}
+        RVM::debug "data: #{data}\noldenv:#{oldenv}"
         RVM::debug "Creating new enviroment with: #{@data.inspect} as child of #{@prev}"
-        
+      end
+      
+      #allows raw access to the data, be carefull!
+      def data
+        @data
       end
       
       # returns a parameter that was passed to the call. For function calls
@@ -55,45 +73,143 @@ module RVM
       # it's 'oldenv' attrib to see if that had a object.
       def param i
         RVM::debug "Getting param #{i} (#{@data[:params][i]})"
-        @data[:params][i]
+        @data[:params][i] || @prev.param(i)
       end
       
       # Returns a local variable with the given name.
       #
       # If the current enviroment does not have any local variables with
       # the given name it tries the privious enviroments.
+      #
+      # This returns the +VariableData+ object NOT the value of the variable.
+      # Use +read_var_val+ if you want to read the value of a variable.
       def [] k
         r = @data[:locals][k] || @prev[k]
         RVM::debug "Getting variable #{k} (#{r})"
         r
       end
       
-      #Sets a local variable witin the enviroment.
+      # Sets a local variable witin the enviroment.
+      #
+      # If the variable exists in a 'higher' enviroment the value is changed.
+      # 
+      # If not it is newly created in the current enviroment and thus not visible
+      # in upper enviroments.
       def []= k, v
         #TODO: add capability to have the privious env variables changed
         RVM::debug "Setting variable #{k} to #{v}"
-        @data[:locals][k] = v
+        if (self[:locals] and r = self[:locals][k])
+          r.val = v
+        else
+          @data[:locals][k] = VariableStorage.new(v)
+        end
+        v
       end
       
-      #Returns a function for the current enviroment
+      # Returns a function for the current enviroment.
+      # The result is to be execpted to be of the +RVM::Classes::Block+ class.
       def function k
         r = @data[:functions][k]
         if not r and @prev.is_a? Enviroment
-         r = @prev.function(k)
+          r = @prev.function(k)
         end
         RVM::debug "Getting functon #{k} (#{r})"
         r
       end
       
-      #Returns a function for the current enviroment
+      # This defines a function within the enviroment and lets you call it later on.
+      # 
+      # It also checks if the given block is truely a +RVM::Classes::Block+ object.       
       def def_function k, b
+        rise(ArgumentError, "Function definitions must be of block class.")if not b.is_a?(RVM::Classes::Block)
         @data[:functions][k] = b
         RVM::debug "Setting functon #{k} (#{b})"
         nil
       end
+      
+      # This functin is closely related to +[]+ with the difference that it returns the value
+      # And not the VariableData object.
+      def read_var_val name
+        if (v = self[name])
+          v.val
+        end
+      end
+    end
+    
+    
+    # Skipps into object context (anther way beside using send)
+    #
+    # the special variable :self (attention, not to be mixed wiht 'self')
+    # is set to the object in which context we are!
+    #
+    # The class is stred in :class
+    class ObjectContext
+      def initialize object, code
+        @object = object
+        @code = code
+      end
+      
+      def execute env
+        #The new 
+        obj = @object.execute(env)
+        env = Interpreter::Enviroment.new({:functions => obj.functions, :locals => obj.variables}, env)
+        @code.execute(env)
+      end
+    end
+    
+    
+    #This sets a funciton on a Class (to be included in its objects)
+    #
+    #To define class functions use ObjectContext and define the function normaly, nifty isn't it?
+    class SetClassFunction
+      def initialize obj, name, function
+        @object = obj
+        @name = name
+        @function = function
+      end
+      
+      def execute env
+        @object.object_functions[@name.execute(env)] = @function
+        @function
+      end
+    end
+    
+    # A block localizes variables, do not mix this up with the
+    # +RVM::Classes::Block+ class!
+    #
+    # Blocks are mostly used to handle tasks as not interfeeing
+    # With outer code.
+    class Block
+      attr_reader :content
+      def initialize content
+        @content = content
+      end
+      
+      # When executed a temporary enviroment is created with the passed
+      # Enviroement as a parent to it.
+      # This new enviroment is discaded after the execution.
+      def execute env
+        tenv = Enviroment.new({}, env) 
+        @content.execute tenv
+      end
     end
     
+    # This is a function definition used to write in the function libary
+    #
     class FunctionDefinition
+      
+      # Initializes a new function definition
+      #
+      # name:: is the name of the function to define, if it is not 
+      #        unique it will overwrite earlyer definitions 
+      #        (unless override is false)
+      # 
+      # body:: is the body of the cuntion. this will be executed
+      #        when the defined function is called.
+      #
+      # override:: when true (default) earlyer definitions are 
+      #            replaced when it is called a second time.
+      #            When false a exception is thrown
       def initialize name, body, override = true
         @name = name
         @body = body
@@ -104,12 +220,21 @@ module RVM
         if (not @override) and env.function(@name)
           raise "Function #{@name} already defined!"
         end
-        env.def_function(@name.execute(env),@body.execute(env))
+        env.def_function(@name.execute(env),@body)
         nil
       end
     end
     
+    
+    # This is a loop. It is executed over and over again as long as
+    # the passed condition evaluates to a value that matches is_true?.
     class Loop 
+      # Initializes a new loop.
+      #
+      # condition:: is executed before each run of the loop. If it evaluates
+      #             to true the loop is executed another time otherwise the
+      #             exection ends.
+      # body::      For each itteration of the loop this is executed once.
       def initialize(condition, body)
         @condition = condition
         @body = body
@@ -135,6 +260,7 @@ module RVM
       def data_type
         @value.data_type
       end
+      
       def == v
         if v.is_a? Constant
           @value == v.value
@@ -242,41 +368,12 @@ module RVM
       
       def execute env
         RVM::debug "Executing Variable..."
-        r = env[@name.execute(env).to_s]
+        r = env.read_var_val(@name.execute(env).to_s)
         @type = r.data_type if r
         r
       end
     end
     
-    
-    # Returns a parameter of the enviroment. This is needed for things like
-    # *self* or *caller*.
-    class EnvGetter
-      
-      def initialize what
-        @envvar = what
-      end
-      
-      def data_type
-        if @envvar == :self or @envvar == :caller
-          :object
-        else
-          :any
-        end
-      end
-      
-      def execute env
-        case @envvar
-          when :self
-          env.object
-          when :caller
-          env.caller
-        else
-          RVM::Classes[:sting].new('')  
-        end
-      end
-    end
-    
     # This evauates to the parameter passed to the function call.
     # The number of it is evaluated and typecasted to an interger.
     class Parameter
@@ -322,6 +419,35 @@ module RVM
       end
     end
     
+    # This is an exception designed to handle the return statement.
+    # It is thrown for for the return and the value can be evaluated.
+    # 
+    # The catching is handled bythe +RVM::Classes::Block+ class.
+    class ReturnException < Exception
+      attr_reader :val
+      def initialize val
+        super()
+        @val = val
+      end
+    end
+    
+    # Represents the return statement, it throws a 
+    # +ReturnException+ which can be caught to have the function
+    # or block return what they wish.
+    class Return
+      def initialize val
+        @val = val
+      end
+      
+      def data_type
+        :any
+      end
+      
+      def execute env
+        raise ReturnException.new(@val.execute(env))
+      end
+    end
+    
     # A function call or a function or a block. The initialization of a new
     # enviroment is done by the function Class as it also sorts the arguments
     # into it. 

data/lib/rvm/languages.rb

@@ -21,13 +21,13 @@ module RVM
   #   require 'lib/base/languages'
   #   code = RVM::Classes[:math].compile '(1 + 1) * 3^2'
   module Languages
-    extend PluginHost
+    extend RVM::PluginHost
     
     # The Compiler class, it holds the compiler. As those grow big I suggest
     # to split the actuall code into multiple fils. Have a look at the MUSHCode
     # compile for an example.
     class Language
-      extend Plugin
+      extend RVM::Plugin
       plugin_host Languages
       class << self
         
@@ -37,8 +37,9 @@ module RVM
           nil
         end
 
+        # Class method called from the plugin to register witht the plugin host.
         def register_for *ids
-          plugin_host.register self.new, *ids
+          plugin_host.register self, *ids
         end
       end
     end