rVM 0.0.14 → 0.0.17

data/lib/rvm/interpreter.rb

@@ -1,5 +1,6 @@
-require File.dirname(__FILE__) + '/functions'
-require File.dirname(__FILE__) + '/classes'
+require 'rvm/functions'
+require 'rvm/classes'
+require 'rvm/environment'
 module RVM
   # This Module hold all the VM classes that are used to execute and evaluate
   # code for the VM, so it is quite important to read and understand if you 
@@ -17,6 +18,35 @@ module RVM
   module Interpreter
     
     
+    class RuntimeError < Exception
+      attr_accessor :total, :line, :char, :error_message
+      def initialize message, total = nil, line = nil, char = nil
+        super()
+        @line = line
+        @char = char
+        @total = total
+        @error_message = message
+      end
+      
+      def to_s
+        res = "Runtime error"
+        if @total or @line
+          res << " at"
+        end
+        if @total
+          res << " character #{@total}"
+        end
+        if @line
+          res << " line #{@line}"
+        end
+        if @char
+          res << ":#{@char}"
+        end
+        res << ": #{@error_message}"
+        res
+      end
+    end
+    
     # Helper class to be parented to other Interpreter calsses for checks and
     # including general behavior.
     class Element
@@ -28,6 +58,12 @@ module RVM
       def initialize pos
         @pos = pos
       end
+      
+      #Placeholder for optimization
+      def optimize
+        RVM::debug "Optimizung #{self}" if $DEBUG
+        self
+      end
     end
     
     # This is a helper fuctio to quickly generate a empty enviorment.
@@ -37,7 +73,7 @@ module RVM
     # :functions can be a hash to hold functions defined in the the scope
     def Interpreter.env aenv = {}
       RVM::debug "Interpreter.env" if $DEBUG
-      Enviroment.new aenv
+      Environment.new aenv
     end
     
     # This is a helper function that generates a constat of a simple constant,
@@ -47,234 +83,6 @@ module RVM
       RVM::Interpreter::Constant.new(RVM::Classes[type].new(value), pos)
     end
     
-    # This class is used to store the variable content to allow chross 
-    # refferencing and passing variables upwards through different scopes.
-    class VariableStorage
-      
-      # Lets the script read the value of the variable.
-      attr_reader :val
-      
-      # The storage is initialized with two optional parameters:
-      #
-      # +val+:: which is the value to be stores.
-      # +writable+:: which when set to false prevents the variable to be
-      #              written, which might be helpfull when trying to publish
-      #              some data to a script that is not supposed to be changed.
-      def initialize val = nil, writable = true
-        @writable = writable
-        @val = val
-      end
-      
-      # Used to write to the variable, if +writable+ was set to false this
-      # will have no effect.
-      # 
-      # It returns the new value set or, if +writable+ was false the old value.
-      def val=v
-        @val = v if @writable
-        @val
-      end
-    end  
-    
-    # The callback storang is used to help publishing variables from a ruby
-    # class to the rVM, it will get and set the variables during runtime.
-    #
-    # It will link getter and setter methods and not the instance variable
-    # itself, which means also computed attributes can be handled by this.
-    #
-    # This class is made if it is nessessary that a script always has access
-    # to constantly chaning data within a object and not only deal with static
-    # values set once.
-    class VariableStorageCallback < VariableStorage
-      # The construtor takes 3 parameters to specifie the object it shold
-      # be linked with, the attribute to handle and +writable+ that will define
-      # if the VariableStorage can be written too by the script.
-      #
-      # var is expected to by a Symbol equal the the function, the getter will
-      # call obj.var and the setter will call obj.var=.
-      #
-      def initialize obj, var, writable = true
-        super(nil, writable)
-        @obj = obj
-        @get = var.to_sym
-        @set = "#{var}=".to_sym
-      end
-      
-      # This methods sets the variable passed to the object by sending it to
-      # the setter method.
-      def val= v
-        @obj.send(@set,v) if @writable
-        @obj.send(@get)
-      end
-      
-      # The getter will call the getter of the object to handle to get the
-      # current value.
-      def val
-        @obj.send(@get)
-      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
-    # and as well, and perhaps most importantly the local variables.
-    #
-    # Some of the functions called will initialize new enviroments, as
-    # for example function calls.
-    class Enviroment
-      # This creates a new enviroment enviroment, it generates a new env
-      # default variables are set if not defined in +data+.
-      #
-      # If +oldenv+ is provided it will also fall back to see if not
-      # existing variables 
-      #
-      # +init_data+ is a hash that can be passed the following values:
-      # :locals:: A hash with local variables mapped name => value
-      # :functions:: A hash with functions for the scope.
-      # :evaldeepth:: A fixnum that indicates how deep the evaluation  is.
-      # :params:: A array that holds local parameters for example for functions
-      #           or blocks.
-      def initialize init_data = {}, oldenv=nil
-        
-        @data = {
-          :locals => {},
-          :functions => {},
-          :evaldeepth => 0,
-          :params => []
-        }.merge(init_data)
-        
-        
-        # Make sure that all locals that are passed, are actually in a variable
-        # storage.
-        if init_data[:locals]
-          # For easy access we get us a link to the locals
-          locals = @data[:locals]
-          # Now we itterate through them
-          init_data[:locals].each do |k,v|
-            #For every variable that isn't already in a storage
-            if not v.is_a?(VariableStorage)
-              # We put it in a storage to assure the enviroment is propper.
-              locals[k] = VariableStorage.new(v)
-            end
-          end
-        end
-        
-        # We store the priviouse enviroment to look upwards through the scopes
-        # for priviouse defined variables, if no old enviroment was given we
-        # set the priviose scope to an empty hash.
-        @prev = oldenv || {}
-        RVM::debug "data: #{data}\noldenv:#{oldenv}" if $DEBUG
-        RVM::debug "Creating new enviroment with: #{@data.inspect} as child" +
-                   " of #{@prev}" if $DEBUG
-      end
-      
-      # Allows raw access to the data, it should not be used unless
-      # somoene knows pretty exactly what they are doing.
-      def data
-        @data
-      end
-      
-      # returns a parameter that was passed to the call. For function calls
-      # this is especially important, it beginns with 0.
-      #
-      # If the current enviroment does not have the given paramenter it tries
-      # it's 'oldenv' attrib to see if that had a object.
-      def param i
-        RVM::debug "Getting param #{i} (#{@data[:params][i]})" if $DEBUG
-        @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})" if $DEBUG
-        r
-      end
-      
-      # 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 []= name, value
-        RVM::debug "Setting variable #{name} to #{value}" if $DEBUG
-        # First we try to get the variable storage of the variable requested.
-        # This will work if it was defined in this or a priviouse scope.
-        if (res = self[name])
-          # If we found the storage we'll change it's value and not define it
-          # again.
-          res.val = value
-        else
-          # If we didn't found a Variable storage, the variable wasn't defined
-          # before so we make a new VariableStorage and save the variable in
-          # it.
-          @data[:locals][name] = VariableStorage.new(value)
-        end
-        value
-      end
-      
-      # Defines a varialbe in the current scope, priviose variables are not
-      # changed.
-      # This is needed for local varialbe declarations that overwrite priviouse
-      # globals.
-      def declare name, value
-        @data[:locals][name] = VariableStorage.new(value)
-      end
-      
-      # Returns a function for the enviroment. If the current enviroment does
-      # not hold a function with the requested name it checks through the 
-      # entire tree if a function can be found in the outer scopes.
-      # 
-      # The result is to be execpted to be of the +RVM::Classes::Block+ class.
-      def function name
-        # Try to get the function in the local defintions.
-        fun = @data[:functions][name]
-        # if that fails and we have a previous enviroment check that
-        fun = @prev.function(name) if fun.nil? and @prev.is_a? Enviroment
-        RVM::debug "Getting functon #{name} (#{fun})" if $DEBUG
-        # return what was found
-        fun
-      end
-      
-      # This defines a function within the enviroment and lets you call it later
-      # on.
-      # 
-      # It expects the body to be a RVM::Classes::Block so it can be executed.
-      # The return value is the given block
-      def def_function name, body
-        if not body.is_a?(RVM::Classes::Block)
-          raise(ArgumentError, "Function definitions must be of block class.") 
-        end
-        @data[:functions][name] = body
-        RVM::debug "Setting functon #{name} (#{body})" if $DEBUG
-        body
-      end
-      
-      # This functin is closely related to +[]+ with the difference that it
-      # returns the value and not the VariableStorage object.
-      # It is equivalent to [].val just that it also deals with nil ojects and
-      # and returns a RVM::Classes::Error if the requested variable wasn't
-      # found.
-      def read_var_val name
-        
-        r = nil
-        if (v = self[name])
-          r = v.val
-        else
-          r = RVM::Classes[:error].new(0, "Variable #{name} is not defined.")
-        end
-        RVM::debug "Getting variable value #{name} (#{r})" if $DEBUG
-        r
-      end
-    end
-    
-    
     # Jumps into object context (anther way beside using send).
     #
     # The special variable :self (attention, not to be mixed wiht 'self')
@@ -290,7 +98,6 @@ module RVM
     # This will execute my_code in a way pretty much equal to instance_eval in
     # ruby would do.
     class ObjectContext < Element
-      
       # The constructor takes 3 arguments, the first beeing the object of which
       # the scope is taken, the second is the code to be executed in the objects
       # scope and the third is the position, to be set by the compiler.
@@ -303,17 +110,29 @@ module RVM
         @code = code
       end
       
-      # Execute for this Interpreter element by creating a new enviroment,
+      def pretty_print(q) 
+        q.group 1, "#{@object}.{", "}" do
+          q.pp @code
+        end
+      end
+      
+      # Execute for this Interpreter element by creating a new environment ,
       # setting it's variables and functions to those definded by the object's
       # +functions+ and +variables+ methods. It also sets the :self variable in
-      # the new enviroment to the object.
+      # the new environment  to the object.
       def execute env
         #The new 
         obj = @object.execute(env)
-        new_env = Interpreter::Enviroment.new({:functions => obj.functions, :locals => obj.variables}, env)
+        new_env = Interpreter::Environment.new({:functions => obj.functions, :locals => obj.variables}, env)
         new_env.declare(:self, obj)
         @code.execute(new_env)
       end
+      
+      def optimize
+        @object = @object.optimize
+        @code = @code.optimize
+        super
+      end
     end
     
     
@@ -337,6 +156,12 @@ module RVM
         @object.object_functions[@name.execute(env)] = @function
         @function
       end
+      
+      def optimize
+        @object = @object.optimize
+        @function = @function.optimize
+        super
+      end
     end
     
     # A block localizes variables, do not mix this up with the
@@ -351,13 +176,25 @@ module RVM
         @content = content
       end
       
-      # When executed a temporary enviroment is created with the passed
+      def pretty_print(q)
+        first = true 
+        q.group 1, "{", "}" do
+          q.pp @content
+        end
+      end
+      
+      # When executed a temporary environment  is created with the passed
       # Enviroement as a parent to it.
-      # This new enviroment is discaded after the execution.
+      # This new environment  is discaded after the execution.
       def execute env
-        tenv = Enviroment.new({}, env) 
+        tenv = Environment.new({}, env) 
         @content.execute tenv
       end
+      
+      def optimize
+        @content = @content.optimize
+        super
+      end
     end
     
     
@@ -388,6 +225,18 @@ module RVM
         @override = override
       end
       
+      def pretty_print(q)
+        first = true
+        q.text "function "
+        if @name.is_a? Constant
+          q.text @name.value
+        else
+          q.pp @name
+        end
+        q.text "()"
+        q.pp @body
+      end
+      
       # When executed the FunctionDefinition first checks if a function with the
       # same name is already defined. If it is and +override+ wasn't set to ture
       # it trows a Exception. Otherwise it defines the function, deleting the
@@ -396,11 +245,17 @@ module RVM
       # It returns the body of the newly defined function.
       def execute env
         if (not @override) and env.function(@name)
-          raise "Function #{@name} already defined at #{@pos}!"
+          raise RuntimeError.new("Function #{@name} already defined", @pos[0], @pos[1], @pos[2])
         end
         env.def_function(@name.execute(env),@body)
         @body
       end
+      
+      def optimize
+        @body = @body.optimize
+        @name = @name.optimize
+        super
+      end
     end
     
     
@@ -427,6 +282,14 @@ module RVM
         @body = body
       end
       
+      def pretty_print(q)
+        first = true
+        q.text "while ("
+        q.pp @condition
+        q.text ")"
+        q.pp @body
+      end
+      
       # The loop will execute as long as the code passed as condition evaluates
       # to is_true?.
       # Once the loop stops executing the return value is the result of the last
@@ -440,6 +303,13 @@ module RVM
       end
     end
     
+    # Optimization of the loop
+    def optimize
+      @condition = @condition.optimize
+      @body = @body.optimize
+      super
+    end
+    
     
     # A constant, it evaluates to thevalue given and end the evaluation.
     # Meaning that no further execution is done in this tree branch, so the
@@ -456,6 +326,10 @@ module RVM
         @value.data_type
       end
       
+      def pretty_print(q)
+        q.pp @value
+      end
+      
       # Comparing a constant with something has two ways to go, if the object
       # it is compared to is a Constant the two values are compared. If not the
       # Constant compares the value with the passed object.
@@ -464,7 +338,6 @@ module RVM
           @value == v.value
         else
           @value == v
-          false
         end
       end
       
@@ -517,6 +390,17 @@ module RVM
         @false_case = false_case
       end
       
+      def pretty_print(q)
+        first = true
+        q.text "if ("
+        q.pp @value
+        q.text ")"
+        q.pp @true_case
+        if (@false_case) 
+          q.text "else"
+          q.pp @false_case
+        end
+      end
       
       # The data type of a condition is tried to evaluate by checking if the
       # type is the same for both conditions, if so the common type is returned,
@@ -546,6 +430,25 @@ module RVM
           @false_case.execute env
         end
       end
+      
+      #Optimizes the condition (checks for trivial cases)
+      def optimize
+        @value = @value.optimize
+        @true_case = @true_case.optimize
+        @false_case = @false_case.optimize if @false_case
+        if @value.is_a? RVM::Interpreter::Constant
+          RVM::debug "Optimizing #{self}, with shortcuting a condition." if $DEBUG
+          if @value.value.is_true?
+            @true_case
+          elsif @false_case
+            @false_case
+          else
+            RVM::Interpreter::Sequence.new
+          end
+        else
+          super
+        end
+      end
     end
     
     
@@ -575,6 +478,16 @@ module RVM
         @value = value
       end
       
+      def pretty_print(q)
+        if @name.is_a? Constant
+          q.text @name.value
+        else
+          q.pp @name
+        end
+        q.text " = "
+        q.pp @value
+      end      
+      
       # The data type of a Assignment is the data type of it's value.
       def data_type
         @value.data_type
@@ -582,7 +495,7 @@ module RVM
       
       # When executed the assignment first evaluates the name of the assignment
       # then the value and stores the result of the executed value in the
-      # enviroment under the name of the executed name.
+      # environment  under the name of the executed name.
       #
       # The return value of the execution is the value that is assigned to the
       # variable.
@@ -590,13 +503,23 @@ module RVM
         RVM::debug "Executing Assignment at #{@pos}..." if $DEBUG
         env[@name.execute(env).to_s] = @value.execute env
       end
+      def optimize
+        @name = @name.optimize
+        @value = @value.optimize
+        if @name.is_a? RVM::Interpreter::Constant
+          RVM::debug "Optimizing #{self}, by making it simple" if $DEBUG
+          RVM::Interpreter::SimpleAssignment.new(@name.value, @value, @pos)
+        else
+          super
+        end
+      end
     end
     
     # A variable declarion that sets a local variable, it will redelcare 
     # the variable if declared in a privouse scope.
     #
     # It is very closely related to the Assignment as it acts exactly alike if
-    # the variable is not yet existing in the Enviroment.
+    # the variable is not yet existing in the Environment .
     #
     # Both the +name+ and the #value# are evaluated before the assignment
     # is done.
@@ -619,6 +542,16 @@ module RVM
         @value = value
       end
       
+      def pretty_print(q)
+        if @name.is_a? Constant
+          q.text @name.value
+        else
+          q.pp @name
+        end
+        q.text " !=! "
+        q.pp @value
+      end
+      
       # The data type of a Assignment is the data type of it's value.
       def data_type
         @value.data_type
@@ -626,9 +559,9 @@ module RVM
       
       # When executed the assignment first evaluates the name of the assignment
       # then the value and stores the result of the executed value in the
-      # enviroment under the name of the executed name.
+      # environment  under the name of the executed name.
       #
-      # If the variable was priviosely in a enviroment that lays above the
+      # If the variable was priviosely in a environment  that lays above the
       # current one in the hearachy the old value will not be altered in any
       # way but a new variable declared.
       #
@@ -638,9 +571,20 @@ module RVM
         RVM::debug "Executing Assignment at #{@pos}..." if $DEBUG
         env.declare(@name.execute(env).to_s,@value.execute(env)).val
       end
-    end    
+      
+      def optimize
+        @name = @name.optimize
+        @value = @value.optimize
+        if @name.is_a? RVM::Interpreter::Constant
+          RVM::debug "Optimizing #{self}, by making it simple" if $DEBUG
+          RVM::Interpreter::SimpleDeclaration.new(@name.value, @value, @pos)
+        else
+          super
+        end
+      end
+    end
     
-    # Reads the value of a variable in the enviroment.
+    # Reads the value of a variable in the environment .
     #
     # The +name+ is evaluated before the variable is retrieved.  
     class Variable < Element
@@ -657,6 +601,14 @@ module RVM
         @type = :any
       end
       
+      def pretty_print(q)
+        if @name.is_a? Constant
+          q.text @name.value
+        else
+          q.pp @name
+        end
+      end
+      
       # The type can only be tretrieved when the name is aconstant
       # as it can be evaluated without sideffect.
       def data_type
@@ -666,16 +618,33 @@ module RVM
       # When the name is a symbol, the name isn't executed and treated as a
       # special variable.
       # Otherwise the name is executed and converted into a string to be passed
-      # to the enviroment so it can go and collect the value.
+      # to the environment  so it can go and collect the value.
       def execute env
         RVM::debug "Executing Variable at #{@pos}..." if $DEBUG
-        n = @name
-        if not @name.is_a?(Symbol)
-          n = n.execute(env).to_s
+        begin
+          n = @name
+          if not @name.is_a?(Symbol)
+            n = n.execute(env).to_s
+          end
+          r = env.read_var_val(n)
+          @type = r.data_type if r.respond_to?(:data_type)
+          r
+        rescue Exception => e
+          raise RuntimeError.new("Failed to get Varialbe #{e}", @pos[0], @pos[1], @pos[2])
+        end
+      end
+      
+      def optimize
+        @name = @name.optimize if not @name.is_a?(Symbol)
+        if @name.is_a?(Symbol)
+          RVM::debug "Optimizing #{self}, by making it simple" if $DEBUG
+          RVM::Interpreter::SimpleVariable.new(@name, @pos)
+        elsif @name.is_a?(RVM::Interpreter::Constant)
+          RVM::debug "Optimizing #{self}, by making it simple" if $DEBUG
+          RVM::Interpreter::SimpleVariable.new(@name.value, @pos)
+        else
+          super
         end
-        r = env.read_var_val(n)
-        @type = r.data_type if r.respond_to?(:data_type)
-        r
       end
     end
     
@@ -696,6 +665,12 @@ module RVM
         @type = :any
       end
       
+      def pretty_print(q)
+        q.text "!!PARAMS["
+        q.pp @num
+        q.text "]"
+      end
+      
       # The type can only be tretrieved when the num is aconstant
       # as it can be evaluated without sideffect.
       def data_type
@@ -703,23 +678,29 @@ module RVM
       end
       
       # When executed the Parameter evaluates the number, of the parameter and
-      # then queries the enviroment to get the function parameter requested.
+      # then queries the environment  to get the function parameter requested.
       #
       # After the first execution the parameter remembers the type of the value
       # it returns.
       def execute env
         RVM::debug "Executing Parameter at #{@pos}..." if $DEBUG
         r = env.param(@num.execute(env).to_i)
-        @type = r.data_type if r
+        @type = r.data_type if r && r.respond_to?(:data_type)
         r
       end
+      
+      def optimize
+        @num = @num.optimize
+        super
+      end
     end
     
     # A sequence is a list of commands that are executed one after
     # another.
     # The type of the squence is equal to the last element of the sequence.
-    class Sequence < Array
+    class Sequence < Element
       attr_accessor :pos
+      attr_accessor :data
       
       # The Sequence is initialized wiht 1 to 2 parameters.
       #
@@ -729,27 +710,73 @@ module RVM
       # pos:: The position within the source code of the definition - for 
       #       deugging purpose.     
       def initialize src=[], pos = nil
-        super(src)
+        @data = src
         @pos = pos
       end
       
+      def pretty_print(q)
+        first = true 
+        q.group 1, "{", "}" do
+          @data.each do |c|
+            if first
+              first = false
+            else
+              q.text ";"
+            end
+            q.breakable
+            q.pp c
+          end
+          q.breakable
+        end
+      end
+      
       # When exeuted a sequence starts to execute every element in it starting
       # with the first element in the array.
       #
       # The result is the last element of the array executed.
       def execute env
         RVM::debug "Executing Sequence... #{inspect}" if $DEBUG
-        r = nil
-        self.map { |seq|
-          r = seq.execute env
-        }
+        for item in @data
+          r = item.execute env
+        end
         r
       end
       
       # When adding something to the Sequence a new Sequence will be created
       # with the result of the joined arrays.
       def + v
-        Sequence.new(super)
+        v = v.data if v.is_a? RVM::Interpreter::Sequence
+        Sequence.new(@data + v)
+      end
+      
+      def << v
+        @data << v
+        self
+      end
+      
+      def unshift v
+        @data.unshift v
+        self
+      end
+      
+      # Optimization for sequences
+      def optimize
+
+        if @data.size == 1
+          return @data.first.optimize
+        else
+          newdata = []
+          @data.each do |d|
+            d = d.optimize
+            if d.is_a? RVM::Interpreter::Sequence
+              newdata.concat(d.data)
+            else
+              newdata << d
+            end
+          end
+          @data = newdata
+        end
+        super
       end
       
       # The data type of the list is :any as it is unknown where the the
@@ -796,6 +823,11 @@ module RVM
         @val = val
       end
       
+      def pretty_print(q)
+        q.text "return "
+        q.pp @val
+      end
+      
       # The data type of a return statement is any, as it does not return
       # anything at all, after all it jumps out of a block.
       def data_type
@@ -807,10 +839,15 @@ module RVM
       def execute env
         raise ReturnException.new(@val.execute(env))
       end
+      
+      def optimize
+        @val = @val.optimize
+        super
+      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
+    # environment  is done by the function Class as it also sorts the arguments
     # into it. 
     #
     # Arguments are only executed when the function does return true for 
@@ -822,12 +859,27 @@ module RVM
       # class.
       #
       # Arguments is a list of the arguments to the function.
-      def initialize function,  arguments, pos = nil
+      def initialize function,  arguments, pos = [0,0,0]
         super(pos)
         @function = function
         @arguments = arguments
       end
       
+      def pretty_print(q)
+        first = true
+        q.pp @function
+        q.text "("
+        @arguments.each do |a|
+          if first
+            first = false
+          else
+            q.text ', '
+          end
+          q.pp a
+        end
+        q.text ")"
+      end
+      
       # The data type of the FunctionCall is the return value of the function
       # that it calls.
       def data_type
@@ -844,6 +896,12 @@ module RVM
         end
       end
       
+      def optimize
+        @arguments.map!{ |a| a.optimize}
+        @function.optimize if @function.respond_to?(:optimize)
+        super
+      end
+      
       # When executed the FunctionCall has four possible behaviours.
       #
       # 1) If the function is a block, so an anonymous function, the arguments
@@ -880,19 +938,94 @@ module RVM
           fun.call(args, env, @pos)
           # If nothing of the above the function must be a global function.
         else
-          # Get the function from he globals
-          fun = RVM::Functions[@function]
-          # Test if the arguments should be executed
-          if fun.execargs
-            # The arges get executed
-            args.map! do |arg|
-              arg.execute env
+          raise RuntimeError.new("Function '#{@function}' Not found!", @pos[0], @pos[1], @pos[2])
+        end
+      end
+    end
+    
+    
+    # A core call is a call to the direct core functions and libraries RVM proides.
+    # this is used to write core libraries for different languages.
+    class CoreCall < Element
+      attr_reader :arguments
+      attr_reader :function
+      # The constructor. +function+ can either be a block object or a function
+      # class.
+      #
+      # Arguments is a list of the arguments to the function.
+      def initialize function,  arguments, pos = nil
+        super(pos)
+        @function = function
+        @arguments = arguments
+      end
+      
+      def pretty_print(q)
+        binary = {:sub => '-', :add => '+', :mul => '*', :div => '/', :mod => '%', :shl => '<<', :shr => '>>',
+                  :cmp => '<=>', :eq => '==', :gt => '>', :gte => '>=', :lt => '<', :lte => '<=',
+                  :bitwise_and => '&', :bitwise_or => '|', :bitwise_xor => '^',
+                  :and => '&&', :or => '||', }
+        if binary.keys.include?(@function)
+          first = true
+          @arguments.each do |a|
+            if first
+              first = false
+            else
+              q.text " #{binary[@function]} "
             end
+            q.pp a
           end
-          # Call the function
+        else
+          first = true
+          q.pp @function
+          q.text "!("
+          @arguments.each do |a|
+            if first
+              first = false
+            else
+              q.text ', '
+            end
+            q.pp a
+          end
+          q.text ")"
+        end
+      end
+      
+      def optimize
+        @arguments.map!{ |a| a.optimize}
+        super
+      end
+      
+      def data_type
+        RVM::Functions[@function] ? RVM::Functions[@function].data_type : :any
+      end
+      
+      # When executed the CoreCall it will call one of the RVM's library functions
+      def execute env
+        RVM::debug "Executing FunctionCall..." if $DEBUG
+        args = @arguments.dup
+        # The function is a anonymous function
+       
+        # Get the function from he globals
+        
+        if not fun = RVM::Functions[@function]
+          raise RuntimeError.new("Function Not found!", @pos[0], @pos[1], @pos[2])
+        end
+        # Test if the arguments should be executed
+        if fun.execargs
+          # The arges get executed
+          args.map! do |arg|
+            arg.execute env
+          end
+        end
+        # Call the function
+        begin
           fun.call(args, env,  @pos)
+        rescue Exception => e
+          raise e
+          raise RuntimeError.new("Function failed to execute: #{e}", @pos[0], @pos[1], @pos[2])
         end
       end
     end
   end
 end
+require 'rvm/optimisation'