AmberVM 0.0.19

data/lib/amber/interpreter.rb

@@ -0,0 +1,1380 @@
+require 'amber/functions'
+require 'amber/classes'
+require 'amber/environment'
+require 'set'
+module AmberVM
+  # 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 
+  # feel like making a own compiler.
+  #
+  # For someone not interested in going as deep into building a own compiler
+  # it still is a good start for understanding how rVM works, yet it is not
+  # mandatory to read.
+  #
+  # The basic idea of this objects is that the compiler translates the source
+  # code into a tree of AmberVM::Interpreter objects to build the behavior that is
+  # expected. Once that is done the code can be executed by calling #execute
+  # for the root of the object tree.
+  #
+  module Interpreter
+    
+    # This is a helper fuctio to quickly generate a empty enviorment.
+    # A hash can be passed to store variables.
+    #
+    # :locals can be a hash holding local variables
+    # :functions can be a hash to hold functions defined in the the scope
+    def Interpreter.env aenv = {}
+      AmberVM::debug "Interpreter.env" if $DEBUG
+      Environment.new aenv
+    end
+    
+    # This is a helper function that generates a constat of a simple constant,
+    # for example if you've a lot of string constants it is way quickly to call
+    # this then writing it out the whole time.
+    def Interpreter.const type, value, pos = nil
+      AmberVM::Interpreter::Constant.new(AmberVM::Classes[type].new(value), pos)
+    end
+    
+    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
+      # The position in the soruce code, added to help debugging scripts with
+      # problems.
+      attr_accessor :pos
+      
+      # Initializes the interpreter element with a position.
+      def initialize pos
+        @pos = pos
+      end
+      
+      #Placeholder for execute
+      def execute env
+        raise "Execute not yet implemented for #{self.class}."
+      end
+      
+      #Placeholder for optimization
+      def optimize variables = {}
+        AmberVM::debug "Optimizung #{self}" if $DEBUG
+        slef.class.new(@pos)
+      end
+    end
+
+
+    class Program < Element
+      def initialize code
+        @code = code
+        @variables = {}
+      end
+      
+      def optimize variables = {}
+        @code = @code.optimize(variables)
+        @variables = variables
+        self
+      end
+      
+      def execute env
+        @variables.each do |name, var|
+          var.val = env[name].val if env[name]
+        end
+        res = @code.execute(env)
+        @variables.each do |name, var|
+          env[name] = var.val
+        end
+        res
+      end
+    end
+
+    # Version of the AmberVM::Interpreter::Variable that is made to use with objects    
+    # Jumps 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!
+    #
+    # This is one of the few AmberVM::Interpreter calsses that is likely to be used
+    # outside a compiler as it will allow to execute a set of code within the
+    # scope of a specific object:
+    #
+    # =Example
+    #   AmberVM::Interpreter::ObjectContext.new(my_object, my_code).execute(env)
+    #
+    # 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.
+      #
+      # The passed object is executed once when the code is ran so it can be
+      # passed something that evaluates like a variable, or constant.
+      def initialize object, code, pos = nil
+        super(pos)
+        @object = object
+        @code = code
+      end
+      
+      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 environment  to the object.
+      def execute env
+        #The new 
+        obj = @object.execute(env)
+       o bj.env.prev = env if obj.env.prev == {}
+        
+        @code.execute(obj.env)
+      end
+      
+      def optimize variables = {}
+        object = @object.optimize variables
+        code = @code.optimize variables
+        ObjectContext.new(object, code)
+      end
+    end
+    
+    class NewClassInstance < Element  
+      def initialize object_class, params
+        @class = object_class
+        @params = params
+      end
+
+      def execute env
+        AmberVM::debug "Creating class instance..." if $DEBUG
+        params = @params.map{|p| p.execute(env)}
+        @class.instance(@params, env)
+      end
+
+      def optimize variables = {}
+        p = params.map{|p| p.optimize variables}
+        NewClassInstance.new(@class, p)
+      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?
+    #
+    # This object may be subject to removal or change, don't use it yet.    
+    #---
+    # TODO: Work this over. 
+    class SetClassFunction < Element
+      def initialize obj, name, function, pos = nil
+        super(pos)
+        @object = obj
+        @name = name
+        @function = function
+      end
+      
+      def execute env
+        @object.object_functions[@name.execute(env)] = @function
+        @function
+      end
+      
+      def optimize variables = {}
+        object = @object.optimize variables
+        function = @function.optimize variables
+        SetClassFunction.new(object, function)
+      end
+    end
+    
+    # A block localizes variables, do not mix this up with the
+    # +AmberVM::Classes::Block+ class!
+    #
+    # Blocks are mostly used to handle tasks as not interfeeing
+    # With outer code.
+    class Block < Element
+      attr_reader :content
+      def initialize content, pos = nil
+        super(pos)
+        @content = content
+      end
+      
+      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 environment  is discaded after the execution.
+      def execute env
+        tenv = Environment.new({}, env) 
+        @content.execute tenv
+      end
+      
+      def optimize variables = {}
+        content = @content.optimize variables
+        Block.new(content, @pos)
+      end
+    end
+    
+    # The FunctionDefinition can be used to define functions in the current
+    # scope, it can either be methods belonging to a object when called within
+    # object scope or good old functions.
+    class FunctionDefinition < Element
+      
+      # 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
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose. 
+      def initialize name, body, override = true, pos = nil
+        super(pos)
+        @name = name
+        @body = body
+        @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
+      # old definition when still repsent.
+      #
+      # It returns the body of the newly defined function.
+      def execute env
+        if (not @override) and env.function(@name)
+          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 variables = {}
+        local_variables = {}
+        body = @body.optimize local_variables
+        name = @name.optimize variables
+        FunctionDefinition.new(body, name, @pos)
+      end
+    end
+    
+    class Closures < Element
+      
+      class Binding
+      
+        def initialize content, vars
+          @content = content
+          @vars = vars
+        end
+        
+        def call params, env, pos = nil
+          env = AmberVM::Interpreter::Environment.new({:locals => @vars}, env)
+          @content.call(params, env, pos)
+        end
+        
+        def inspect
+          "<#{self.class}:#{self.object_id}>"
+        end
+      end
+      
+      attr_accessor :content
+      def initialize content
+        @content = content
+      end
+      
+      def optimize variables = {}
+        OptimizedClosures.new(@content, variables)
+      end
+      
+      def execute env
+        Binding.new(@content, env.data[:locals].dup)
+      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?.
+    #
+    #---
+    #TODO: Add BreakException to stop execution of loops.
+    #TODO: Add NextExceeption to skip rest of a evaluation on loop code.
+    class Loop < Element
+      # 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.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose. 
+      def initialize(condition, body, pos = nil)
+        super(pos)
+        @condition = condition
+        @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
+      # body execution.
+      def execute env
+        r = nil
+        while @condition.execute(env).is_true?
+          r = @body.execute(env)
+        end
+        r
+      end
+      
+      # Optimization of the loop
+      def optimize variables = {}
+        condition = @condition.optimize variables
+        body = @body.optimize variables
+        Loop.new(condition, body, @pos)
+      end
+      
+    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
+    # value isn't evaluated.
+    class Constant < Element
+      attr_reader :value
+      def initialize value, pos = nil
+        super(pos)
+        @value = value
+      end
+      
+      # A constat returns the data type of the value that is stored in it.
+      def data_type
+        @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.
+      def == v
+        if v.is_a? Constant
+          @value == v.value
+        else
+          @value == v
+        end
+      end
+      
+      def optimize variables={}
+        value = @value
+        if @value.respond_to?(:optimize)
+          value = @value.optimize(variables)
+        end
+        Constant.new(value)
+      end
+      
+      # When executed the constant returns the value stored in it, without
+      # evaluating it.
+      def execute env
+        AmberVM::debug "Executing Constant at #{@pos}: #{@value}" if $DEBUG
+        @value
+      end
+    end
+    
+    # The condition is most widely known as 'if' statement, also the tertier
+    # opperator is a condition.
+    #
+    # Conditions are quite important, elseif can be implemented by chaining
+    # if statements.
+    #
+    # == Example
+    #
+    # === TRANSLATING IF
+    #
+    #   cond = Interpreter::Condition.new(
+    #      <... thing for the condition  ...>,
+    #      <... what to do if condition is true ...>
+    #      [<... what to do if condition is false ...>])
+    #
+    # if now cond.execute is called the following happens:
+    # * execute is called for the condition
+    # * if the result of it true and is_true? is also true:
+    #   * execute for the true case is called and it's result returned
+    # * if the result is false or is_true? is false:
+    #   * execute is called for the false case and it's result is returned    
+    class Condition < Element
+      # Creates a new condition with the given parameters. The false_case can
+      # be ommitted.
+      #
+      # value:: is executed, and depandant of the result either true_case or
+      #         false casae s executed.
+      #
+      # true_case:: is only executed if value evalutes to true (is_true?)
+      #
+      # false_case:: is only executed if value evalutes to false (!is_true?)
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.
+      def initialize value, true_case, false_case = nil, pos = nil
+        super(pos)
+        @value = value
+        @true_case = true_case
+        @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,
+      # if not :any is returend as it can not be determined what type the 
+      # Condition will have.
+      def data_type
+        if @true_case.data_type == @false_case.data_type
+          @false_case.data_type
+        else
+          :any
+        end
+      end
+      
+      # When executed the condition first executes the condition, if it
+      # evaluates to a value that .is_true? the true case is executed if not,
+      # and a false case is given it will be executed.
+      #
+      # The return value is the value of the executed condition, so either the
+      # ture_case or the false_case.
+      def execute env
+        v =  @value.execute(env)
+        if v and v.is_true?
+          AmberVM::debug "Executing Condition... (true)" if $DEBUG
+          @true_case.execute env
+        elsif @false_case
+          AmberVM::debug "Executing Condition... (false)" if $DEBUG
+          @false_case.execute env
+        end
+      end
+      
+      #Optimizes the condition (checks for trivial cases)
+      def optimize variables = {}
+        value = @value.optimize variables
+        true_case = @true_case.optimize variables
+        false_case = @false_case.optimize variables if @false_case
+        if value.is_a? AmberVM::Interpreter::Constant
+          AmberVM::debug "Optimizing #{self}, with shortcuting a condition." if $DEBUG
+          if value.value.is_true?
+            true_case
+          elsif false_case
+            false_case
+          else
+            AmberVM::Interpreter::Sequence.new
+          end
+        else
+          Condition.new(value, true_case, false_case, @pos)
+        end
+      end
+    end
+    
+    
+    # A variable assignment that sets a local variable. A declaration
+    # is not required before the assignment can be done, yet it can be used to
+    # force a laready declaed variale into the local scope.
+    #
+    # Both the +name+ and the +value+ are evaluated before the assignment
+    # is done.
+    class Assignment < Element
+      
+      # A Assignment is initialized wiht 2 to 3 parameters.
+      #
+      # name:: The name of the variable to store, it will be executed, usually
+      #        this will be a Constant, unless dynamic naming is needed by the
+      #        implemented language.
+      #
+      # value:: The value that will be assigned to the variable, for a = 1 + 1
+      #         '1+1' would be the value to assign, so as this already suggests
+      #         the value will be executed.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.   
+      def initialize variable, value, pos = nil
+        super(pos)
+        @variable = variable
+        @value = value
+      end
+      
+      def pretty_print(q)
+        q.pp @variable
+        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
+      end
+      
+      # When executed the assignment first evaluates the name of the assignment
+      # then the value and stores the result of the executed value in the
+      # environment  under the name of the executed name.
+      #
+      # The return value of the execution is the value that is assigned to the
+      # variable.
+      def execute env
+        new_val = @value.execute env
+        var = @variable.execute env
+        AmberVM::debug "Executing Assignment at #{@pos}... #{var} = #{new_val}" if $DEBUG
+        var.val = new_val
+      end
+      
+      def optimize variables = {}
+        variable = @variable.optimize(variables)
+        value = @value.optimize variables
+        Assignment.new(variable, value, @pos);
+      end
+    end
+
+    # # A variable assignment that sets a local variable. A declaration
+    # # is not required before the assignment can be done, yet it can be used to
+    # # force a laready declaed variale into the local scope.
+    # #
+    # # Both the +name+ and the +value+ are evaluated before the assignment
+    # # is done.
+    # class ObjectAssignment < Element
+    #   
+    #   # A Assignment is initialized wiht 2 to 3 parameters.
+    #   #
+    #   # name:: The name of the variable to store, it will be executed, usually
+    #   #        this will be a Constant, unless dynamic naming is needed by the
+    #   #        implemented language.
+    #   #
+    #   # value:: The value that will be assigned to the variable, for a = 1 + 1
+    #   #         '1+1' would be the value to assign, so as this already suggests
+    #   #         the value will be executed.
+    #   #
+    #   # pos:: The position within the source code of the definition - for 
+    #   #       deugging purpose.   
+    #   def initialize object, name, value, pos = nil
+    #     super(pos)
+    #     @object = object
+    #     @name = name
+    #     @value = value
+    #   end
+    #   
+    #   def pretty_print(q)
+    #     if @object.is_a? Constant
+    #       q.text @object.value
+    #     else
+    #       q.pp @object
+    #     end
+    #     q.text '.'
+    #     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
+    #   end
+    #   
+    #   # When executed the assignment first evaluates the name of the assignment
+    #   # then the value and stores the result of the executed value in the
+    #   # environment  under the name of the executed name.
+    #   #
+    #   # The return value of the execution is the value that is assigned to the
+    #   # variable.
+    #   def execute env
+    #     AmberVM::debug "Executing Assignment at #{@pos}..." if $DEBUG
+    #     @object.execute(env).variables[@name.execute(env).to_s] = @value.execute env
+    #   end
+    #   
+    #   def optimize variables = {}
+    #     @name = @name.optimize variables
+    #     @value = @value.optimize variables
+    #     if @name.is_a? AmberVM::Interpreter::Constant
+    #       AmberVM::debug "Optimizing #{self}, by making it simple" if $DEBUG
+    #       AmberVM::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 Environment .
+    #
+    # Both the +name+ and the #value# are evaluated before the assignment
+    # is done.
+    class Declaration < Element
+      # A Declaration is initialized wiht 2 to 3 parameters.
+      #
+      # name:: The name of the variable to store, it will be executed, usually
+      #        this will be a Constant, unless dynamic naming is needed by the
+      #        implemented language.
+      #
+      # value:: The value that will be assigned to the variable, for a = 1 + 1
+      #         '1+1' would be the value to assign, so as this already suggests
+      #         the value will be executed.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.
+      def initialize name, value, pos = nil
+        super(pos)
+        @name = name
+        @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
+      end
+      
+      # When executed the assignment first evaluates the name of the assignment
+      # then the value and stores the result of the executed value in the
+      # environment  under the name of the executed name.
+      #
+      # 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.
+      #
+      # The return value of the execution is the value that is assigned to the
+      # variable.     
+      def execute env
+        AmberVM::debug "Executing Assignment at #{@pos}..." if $DEBUG
+        env.declare(@name.execute(env).to_s,@value.execute(env)).val
+      end
+      
+      def optimize variables = {}
+        name = @name.optimize variables
+        value = @value.optimize variables
+        if name.is_a? AmberVM::Interpreter::Constant
+          AmberVM::debug "Optimizing #{self}, by making it simple" if $DEBUG
+          AmberVM::Interpreter::SimpleDeclaration.new(name.value, value, @pos)
+        else
+          Declaration.new(name, value, @pos)
+          super
+        end
+      end
+    end
+    
+    # Reads the value of a variable in the environment .
+    #
+    # The +name+ is evaluated before the variable is retrieved.  
+    class Variable < Element
+      # A Variable is initialized wiht 1 to 2 parameters.
+      #
+      # name:: The name of the variable to get, it will be executed as long as
+      #        it is no Sybol in which case it is treated as a special variable.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.
+      def initialize name, pos = ['-','-','-'], require_declaration = false
+        super(pos)
+        @name = name
+        @type = :any
+        @require_declaration = require_declaration
+      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
+        @type
+      end
+      
+      # 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 environment  so it can go and collect the value.
+      def execute env
+        AmberVM::debug "Executing Variable at #{@pos}..." if $DEBUG
+        begin
+          n = @name
+          if not @name.is_a?(Symbol)
+            n = n.execute(env).to_s
+          end
+          r = env[n]
+          if not r
+            if @require_declaration
+              raise RuntimeError.new("Variable #{n} was not declared.")
+            else
+              r = env.declare(n, AmberVM::Classes::Null.new(nil))
+            end
+          end
+          AmberVM::debug "Gor variable: #{r}" if $DEBUG
+          @type = r.val.data_type if r.val.respond_to?(:data_type)
+          r
+        rescue Exception => e
+          raise RuntimeError.new("Failed to get Variable #{e}", @pos[0], @pos[1], @pos[2])
+        end
+      end
+      
+      def optimize variables = {}
+        name = @name
+        name = name.optimize variables if not name.is_a?(Symbol)
+        if name.is_a?(Symbol)
+          AmberVM::debug "Optimizing #{self}, by making it simple" if $DEBUG
+          AmberVM::Interpreter::SimpleVariable.new(name, @pos)
+        elsif name.is_a?(AmberVM::Interpreter::Constant)
+          AmberVM::debug "Optimizing #{self}, by making it simple" if $DEBUG
+          AmberVM::Interpreter::SimpleVariable.new(name.value, @pos)
+        else
+          Variable.new(name, @pos, @require_declaration)
+        end
+      end
+    end
+    
+    class VariableValue < Element
+      attr_accessor :variable
+      def initialize variable, pos = ['-', '-', '-']
+        super(pos)
+        @variable = variable
+      end
+      
+      def execute env
+        @variable.execute(env).val
+      end
+      
+      def pretty_print(q)
+        q.pp @variable
+        q.text ".value"
+      end
+      
+      def optimize variables = {}
+        variable = @variable.optimize variables
+        VariableValue.new(variable)
+      end
+    end
+    
+    class ObjectVariable < AmberVM::Interpreter::Variable
+      # A SimpleVariable is initialized wiht 1 to 2 parameters.
+      #
+      # name:: The name of the variable to get, it will be executed as long as
+      #        it is no Sybol in which case it is treated as a special variable.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.
+      
+      attr_reader :object, :name
+      def initialize object, name, pos = ['-', '-', '-'], require_declaration = false 
+        super(name.to_s, pos, require_declaration)
+        @object = object
+      end
+      
+      def pretty_print q
+        q.pp @object
+        q.text '.'
+        q.pp @name
+      end
+      
+      # The name is a sting and we simple get what is written in the env
+      def execute env
+        AmberVM::debug "Executing SimpleVariable at #{@pos}..." if $DEBUG
+        begin
+          obj = @object.execute(env) #.val
+          r = obj.variables[@name]
+          if not r
+            if @require_declaration
+              raise RuntimeError.new("Variable #{@name} was not declared for thie Object.")
+            else
+              r = obj.variables[@name] = AmberVM::Interpreter::VariableStorage.new(AmberVM::Classes::Null.new(nil))
+            end
+          end
+          @type = r.val.data_type if r.val.respond_to?(:data_type)
+          r
+        rescue Exception => e
+          raise RuntimeError.new("Failed to get object variable Variable #{$!}", @pos[0], @pos[1], @pos[2])
+        end
+      end
+      
+      def optimize variables = {}
+        object = @object.optimize(variables)
+        ObjectVariable.new(object, @name, @pos)        
+      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 < Element
+      
+      # A Parameter is initialized wiht 1 to 2 parameters.
+      #
+      # num:: The number if the parameter to get, 0 is the first parameter
+      #       passed, 1 the second and so on.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.
+      def initialize num, pos = nil
+        super(pos)
+        @num = num
+        @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
+        @type
+      end
+      
+      # When executed the Parameter evaluates the number, of the parameter and
+      # 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
+        AmberVM::debug "Executing Parameter at #{@pos}..." if $DEBUG
+        r = env.param(@num.execute(env).to_i)
+        @type = r.data_type if r && r.respond_to?(:data_type)
+        r
+      end
+      
+      def optimize variables = {}
+        num = @num.optimize variables
+        Parameter.new(num, @pos)
+      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 < Element
+      attr_accessor :pos
+      attr_accessor :data
+      
+      # The Sequence is initialized wiht 1 to 2 parameters.
+      #
+      # src:: The source is an array that holds the inital list of commands that
+      #       are supposed to be executed.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.     
+      def initialize src=[], pos = nil
+        @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
+        AmberVM::debug "Executing Sequence... #{inspect}" if $DEBUG
+        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
+        v = v.data if v.is_a? AmberVM::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 variables = {}
+
+        if @data.size == 1
+          return @data.first.optimize(variables)
+        else
+          newdata = []
+          @data.each do |d|
+            d = d.optimize variables
+            if d.is_a? AmberVM::Interpreter::Sequence
+              newdata.concat(d.data)
+            else
+              newdata << d
+            end
+          end
+          Sequence.new(newdata, @pos)
+        end
+      end
+      
+      # The data type of the list is :any as it is unknown where the the
+      # sequence exits.
+      def data_type
+        :any
+      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 +AmberVM::Classes::Block+ class.
+    class ReturnData < Exception
+      attr_reader :val
+      attr_reader :pos
+      
+      # The ReturnException is initialized wiht 1 to 2 parameters.
+      #
+      # val:: The value that will be returned, aka the part after 'return'.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.     
+      def initialize val, pos = nil
+        super()
+        @val = val
+        @pos = pos
+      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  < Element
+      
+      # The Return is initialized wiht 1 to 2 parameters.
+      #
+      # val:: The value that will be returned, aka the part after 'return'.
+      #
+      # pos:: The position within the source code of the definition - for 
+      #       deugging purpose.
+      def initialize val, pos = nil
+        super(pos)
+        @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
+        :any
+      end
+      
+      # When executed the Return executed the value and then raises a 
+      # ReturnException.
+      def execute env
+        v = @val.execute(env)
+        AmberVM::debug "Return reached, returning: #{v}" if $DEBUG
+        throw :return, ReturnData.new(v)
+      end
+      
+      def optimize variables = {}
+        val = @val.optimize variables
+        Return.new(val, @pos)
+      end
+    end
+    
+    # A function call or a function or a block. The initialization of a new
+    # 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 
+    # execargs.
+    class FunctionCall < 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 = [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
+        @function.data_type
+      end
+      
+      # Comparing two function calls will result in a match when the passed
+      # arguments are the same and the function to call the same
+      def == v
+        if v.is_a? FunctionCall
+         (@arguments == v.arguments) && (@function == v.function)
+        else
+          false
+        end
+      end
+      
+      def optimize variables = {}
+        arguments =  @arguments.map{ |a| a.optimize variables}
+        function = @function
+        function = @function.optimize variables if function.respond_to?(:optimize)
+        FunctionCall.new(function, arguments, @pos)
+      end
+      
+      # When executed the FunctionCall has four possible behaviours.
+      #
+      # 1) If the function is a block, so an anonymous function, the arguments
+      #    will be executed and then the block is called.
+      #
+      # 2) The function is a locally defined function and then the arguments are
+      #    executed and passed to the locally defined function.
+      #
+      # 3) The function is a AmberVM::Functions::Function and execargs returns true,
+      #    the arguments are executed and the function called.
+      #
+      # 4) The function is a AmberVM::Functions::Function and execargs returns
+      #    false, the arguments are passed along unexecuted and the function has
+      #    to take care of that itself. This is important for logical functions
+      #    as and and or which execute only some of the arguments
+      def execute env
+        AmberVM::debug "Executing FunctionCall..." if $DEBUG
+        # The function is a anonymous function
+        if @function.is_a? AmberVM::Classes[:block] or @function.is_a? AmberVM::Interpreter::Closures::Binding
+          # The arguments are executed.
+          args = @arguments.map do |arg|
+            arg.execute env
+          end
+          # Call the function
+          @function.call(args, env,  @pos)
+          # The function is a selfdefined function (or object function)
+        elsif @function.is_a? AmberVM::Interpreter::Element
+            fun = @function.execute(env)
+            # The arguments are executed.
+            args = @arguments.map do |arg|
+              arg.execute env
+            end
+            # Call the function
+            begin
+              fun.call(args, env,  @pos)
+            rescue Exception => e
+              exit
+            end
+            # The function is a selfdefined function (or object function)
+          elsif fun = env.function(@function)
+          # The arguments are executed.
+          args = @arguments.map do |arg|
+            arg.execute env
+          end
+          # Call the function
+          
+          fun.call(args, env, @pos)
+          # If nothing of the above the function must be a global function.
+        else
+          raise RuntimeError.new("Function '#{@function}' Not found!", @pos[0], @pos[1], @pos[2])
+        end
+      end
+    end
+    
+    # # A function call or a function or a block. The initialization of a new
+    # # 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 
+    # # execargs.
+    # class ObjectFunctionCall < 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 object, function,  arguments, pos = [0,0,0]
+    #     super(pos)
+    #     @object = object
+    #     @function = function
+    #     @arguments = arguments
+    #   end
+    #   
+    #   def pretty_print(q)
+    #     first = true
+    #     q.pp @object
+    #     q.text '.'
+    #     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
+    #     @function.data_type
+    #   end
+    #   
+    #   # Comparing two function calls will result in a match when the passed
+    #   # arguments are the same and the function to call the same
+    #   def == v
+    #     if v.is_a? FunctionCall
+    #      (@arguments == v.arguments) && (@function == v.function)
+    #     else
+    #       false
+    #     end
+    #   end
+    #   
+    #   def optimize variables = {}
+    #     @arguments.map!{ |a| a.optimize variables}
+    #     @function.optimize variables 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
+    #   #    will be executed and then the block is called.
+    #   #
+    #   # 2) The function is a locally defined function and then the arguments are
+    #   #    executed and passed to the locally defined function.
+    #   #
+    #   # 3) The function is a AmberVM::Functions::Function and execargs returns true,
+    #   #    the arguments are executed and the function called.
+    #   #
+    #   # 4) The function is a AmberVM::Functions::Function and execargs returns
+    #   #    false, the arguments are passed along unexecuted and the function has
+    #   #    to take care of that itself. This is important for logical functions
+    #   #    as and and or which execute only some of the arguments
+    #   def execute env
+    #     AmberVM::debug "Executing Object FunctionCall..." if $DEBUG
+    #     obj = @object.execute(env).val
+    #     # The function is a anonymous function
+    #     if fun = obj.functions[@function]
+    #       # The arguments are executed.
+    #       args = @arguments.map do |arg|
+    #         arg.execute env
+    #       end
+    #       # Call the function
+    #       obj.obj_send(@function, args, env)
+    #       # If nothing of the above the function must be a global function.
+    #     else
+    #       raise RuntimeError.new("Function '#{@function}' for object #{obj} not found!", @pos[0], @pos[1], @pos[2])
+    #     end
+    #   end
+    # end
+    
+    # A core call is a call to the direct core functions and libraries AmberVM 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
+        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 variables = {}
+        arguments = @arguments.map!{ |a| a.optimize variables}
+        if fun = AmberVM::Functions[@function]
+          AmberVM::Interpreter::SimpleCoreCall.new(fun, arguments, @pos)
+        else 
+          CoreCall.new(@function, arguments, @pos)
+        end
+      end
+      
+      def data_type
+        AmberVM::Functions[@function] ? AmberVM::Functions[@function].data_type : :any
+      end
+      
+      # When executed the CoreCall it will call one of the AmberVM's library functions
+      def execute env
+        AmberVM::debug "Executing CoreCall... args: #{@arguments.inspect}" if $DEBUG
+        args = nil
+        # The function is a anonymous function
+       
+        # Get the function from he globals
+        if not fun = AmberVM::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 = @arguments.map do |arg|
+            a = arg.execute env
+          end
+        else
+          args = @arguments
+        end
+        args.map! do |a|
+          a = a.is_a?(AmberVM::Interpreter::VariableStorage) ? a.val : a
+          a
+        end
+        # Call the function
+        begin
+          f = fun.call(args, env,  @pos)
+          f
+        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 'amber/optimisation'