AmberVM 0.0.19

data/lib/amber/environment.rb

@@ -0,0 +1,251 @@
+module AmberVM
+  module Interpreter
+    
+    def Interpreter.makevs(value)
+      if value.is_a?(VariableStorage)
+        value
+      else
+        VariableStorage.new(value)
+      end
+    end
+    # This class represents the environment, the memory so to say for the VM.
+    # The environment holds environmental 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 environments, as
+    # for example function calls.
+    class Environment
+      attr_accessor :prev
+      # This creates a new environment environment, 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 => {}, #oldenv ? oldenv.data[:locals] : {},
+          :locals_swapped => true, # init_data.keys.include?(:locals),
+          :evaldeepth => 0,
+          :params => oldenv ? oldenv.data[:params] : [],
+          :params_swapped => init_data.keys.include?(:params)
+        }.merge(init_data)
+        @path = [] if oldenv.nil?
+        
+        # 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
+            # We put it in a storage to assure the environment is propper.
+            locals[k] = AmberVM::Interpreter::makevs(v)
+          end
+        end
+        
+        # We store the priviouse environment to look upwards through the scopes
+        # for priviouse defined variables, if no old environment was given we
+        # set the priviose scope to an empty hash.
+        @prev = oldenv || {}
+        AmberVM::debug "data: #{data}\noldenv:#{oldenv}" if $DEBUG
+        AmberVM::debug "Creating new environment 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
+      
+      def path
+        @path || @pre.path
+      end
+      
+      # returns a parameter that was passed to the call. For function calls
+      # this is especially important, it beginns with 0.
+      #
+      # If the current environment does not have the given paramenter it tries
+      # it's 'oldenv' attrib to see if that had a object.
+      def param i
+        AmberVM::debug "Getting param #{i} (#{@data[:params][i]})" if $DEBUG
+        if @data[:params_swapped]
+          @data[:params][i] || @prev.param(i)
+        else
+          @data[:params][i]
+        end
+      end
+      
+      # Returns a local variable with the given name.
+      #
+      # If the current environment does not have any local variables with
+      # the given name it tries the privious environments.
+      #
+      # 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] 
+        r = @prev[k] if not r and @data[:locals_swapped]
+        AmberVM::debug "Getting variable #{k} (#{r})" if $DEBUG
+        r
+      end
+      
+      # Sets a local variable witin the environment.
+      #
+      # If the variable exists in a 'higher' environment the value is changed.
+      # 
+      # If not it is newly created in the current environment and thus not
+      # visible in upper environments.
+      def []= name, value
+        AmberVM::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 storage = self[name]
+          # If we found the storage we'll change it's value and not define it
+          # again.
+          storage.val = value
+          storage
+        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.
+          storage = declare name, value
+        end
+        storage
+      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
+        #Now we need to make our own set of storage!
+        if not @data[:locals_swapped]
+          @data[:locals_swapped] = true
+          @data[:locals] = {}
+        end
+        value = AmberVM::Interpreter::makevs(value)
+        @data[:locals][name] = value
+      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 AmberVM::Classes::Error if the requested variable wasn't
+      # found.
+      def read_var_val name
+        
+        r = nil
+        if (v = self[name])
+          r = v.val
+        else
+          raise "Variable #{name} is not defined."
+        end
+        AmberVM::debug "Getting variable value #{name} (#{r})" if $DEBUG
+        r
+      end
+    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_accessor :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
+        @val = val
+      end
+      
+      def to_s
+        "#<#{self.class}:#{self.object_id} @val=#{@val}>"
+      end
+      
+      def pretty_print(q)
+        q.text "Variable(#{object_id}=(#{@val}))"
+      end
+    end
+    
+    class ROVariableStorage
+      
+      # 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
+        @val = val
+      end
+      
+      def pretty_print(q)
+        q.text "Variable(#{object_id})"
+      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
+      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)
+        @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
+  end
+end

data/lib/amber/fukubukuro/ecma_core.rb

@@ -0,0 +1,409 @@
+module Fukubukuro
+  module ECMA
+    
+    # TODO: recursion detection
+    def self.make_core_object_from value
+      case value
+      when Numeric
+        ECMA::Core::Number.new value
+      when String
+        ECMA::Core::String.new value
+      when Array
+        array = value.map { |item| make_core_object_from item }
+        ECMA::Core::Array.bind_to_original(array, value)
+      when nil
+        ECMA::Core::Null::Null
+      when true
+        ECMA::Core::Boolean::True
+      when false
+        ECMA::Core::Boolean::False
+      when Symbol
+        ECMA::Core::Symbol.new value
+      when Proc
+        ECMA::Core::Lambda.new value
+      when :undefined
+        ECMA::Core::Undefined::Undefined
+      when OpenStruct
+        core_object = OpenStruct.new
+        for key, val in value.instance_variable_get :@table
+          core_object.send :"#{key}=", make_core_object_from(val)
+        end
+        ECMA::Core::Object.new core_object
+      else
+        ECMA::Core::ObjectWrapper.new value
+      end
+    end
+    
+    module Core
+      
+      class Container < ::Object
+        attr_accessor :value
+        alias initialize value=
+        private :initialize
+        def method_missing(meth, *args, &blk)
+          raise "%s doesn't know about %p" % [self.class, meth]
+        end
+        alias to_ruby value
+        
+        attr_accessor :original
+        def self.bind_to_original value, original
+          container = new(value)
+          container.original = original
+          container
+        end
+        
+        def inspect
+          "%p(%s)" % [self.class, value_inspect]
+        end
+        def pretty_print q
+          q.text inspect
+        end
+        def self.inspect
+          name[/\w+$/]
+        end
+        def value_inspect
+          value.inspect
+        end
+        
+      end
+      
+      class Number < Container
+        
+        def value_inspect
+          case value
+          when ::Integer
+            value.to_s
+          when ::Float
+            ('%0.0f' % value).chomp('.0')
+          end
+        end
+        
+        def + other
+          case other
+          when Number
+            Number.new value + other.value
+          when String
+            String.new value.to_s + other.value
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [other]
+          end
+        end
+        
+        def - other
+          case other
+          when Number
+            Number.new value - other.value
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [other]
+          end
+        end
+        
+        def _increment_prefix
+          self.value += 1
+          self
+        end
+        
+        def _increment_suffix
+          self.value += 1
+          Number.new value - 1
+        end
+        
+        def _decrement_prefix
+          self.value -= 1
+          self
+        end
+        
+        def _decrement_suffix
+          self.value -= 1
+          Number.new value + 1
+        end
+        
+        def increment by
+          self.value += by.value
+          self
+        end
+        
+        def increment_const by
+          self.value += by
+          self
+        end
+        
+        def decrement by
+          self.value -= by.value
+          self
+        end
+        
+        def decrement_const by
+          self.value -= by
+          self
+        end
+        
+        def < other
+          case other
+          when Number
+            value < other.value
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [other]
+          end
+        end
+        
+        def <= other
+          case other
+          when Number
+            value <= other.value
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [other]
+          end
+        end
+        
+        def == other
+          case other
+          when Number
+            value == other.value
+          else
+            false
+          end
+        end
+        
+        module_eval %{
+          def != other
+            case other
+            when Number
+              value != other.value
+            else
+              false
+            end
+          end
+        } if ::RUBY_VERSION >= '1.9'
+        
+        def not_equal_const other
+          value != other
+        end
+        
+        def -@
+          Number.new(-value)
+        end
+        
+        def +@
+          # Number.new(+value)
+          self
+        end
+        
+        def * other
+          case other
+          when Number
+            Number.new value * other.value
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [other]
+          end
+        end
+        
+        def / other
+          case other
+          when Number
+            Number.new value.to_f / other.value
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [other]
+          end
+        end
+        
+        def << other
+          case other
+          when Number
+            Number.new value << other.value
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [other]
+          end
+        end
+        
+        def lsr other
+          case other
+          when Number
+            Number.new value.lsr(other.value)
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [other]
+          end
+        end
+        
+        def false?
+          value.zero?
+        end
+        def true?
+          value.nonzero?
+        end
+        
+      end
+      
+      class Array < Container
+        
+        def [] index
+          case index
+          when Number
+            value[index.value]
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [index]
+          end
+        end
+        
+        def []= index, object
+          case index
+          when Number
+            value[index.value] = object
+          else
+            raise ::ArgumentError, 'expected Number, got %p' % [index]
+          end
+        end
+        
+        def to_ruby
+          original.replace value.map { |item| item.is_a?(Container) ? item.to_ruby : item }
+        end
+        
+        def length
+          Number.new value.size
+        end
+        
+        def fuku_send meth, *args
+          return send(meth, *args) if respond_to? meth
+          method_missing meth, *args
+        end
+        
+      end
+      
+      class String < Container
+        
+        def + other
+          case other
+          when String
+            String.new value + other.value
+          when Number
+            String.new value + other.value.to_s
+          else
+            raise ::ArgumentError, 'expected String, got %p' % [other]
+          end
+        end
+        
+        def to_ruby
+          if original
+            original.replace value
+          else
+            value
+          end
+        end
+        
+        def to_number
+          value[/\D/] ? value.to_f : value.to_i
+        end
+        
+        def _increment_suffix
+          as_number = self.to_number
+          new_value = as_number + 1
+          raise ::Fukubukuro::CastException.new(Number.new(new_value), Number.new(as_number))
+        end
+        
+      end
+      
+      class Boolean < Container
+        True = new true
+        def True.true?; true; end
+        def True.false?; false; end
+        False = new false
+        def False.true?; false; end
+        def False.false?; true; end
+        def new value
+          value ? True : False
+        end
+        def inspect
+          value.inspect
+        end
+      end unless defined? Core::Boolean
+      
+      class Null < Container
+        Null = new nil
+        def Null.true?; false; end
+        def Null.false?; true; end
+        def new value
+          Null
+        end
+        def inspect
+          'null'
+        end
+      end unless defined? Core::Null
+      
+      class Undefined < Container
+        Undefined = new nil
+        def Undefined.true?; false; end
+        def Undefined.false?; true; end
+        def new value
+          Undefined
+        end
+        def inspect
+          'undefined'
+        end
+      end unless defined? Core::Undefined
+      
+      class Symbol < Container
+      end
+      
+      class Object < Container
+        
+        def fuku_send(meth, *args)
+          if meth.to_s[-1] == ?=
+            raise 'Expected 1 argument for member assignment; got %p' % [args.size] if args.size != 1
+            value.send(meth, args.first)
+          else
+            value.send(meth, *args)
+          end
+        end
+        
+        def fuku_method_call(meth, *args)
+          raise "Can't method-call a setter method." if meth.to_s[-1] == ?=
+          Fukubukuro::CurrentReceiver.set self
+          value.send(meth).fuku_call(*args)
+        end
+        
+        def to_ruby
+          raise unless value.is_a? OpenStruct
+          ruby = OpenStruct.new
+          for key, val in value.instance_variable_get :@table
+            ruby.send :"#{key}=", val.to_ruby
+          end
+          ruby
+        end
+        
+      end
+      
+      class ObjectWrapper < Container
+        
+        def fuku_send(meth, *args)
+          if meth.to_s[-1] == ?=
+            raise 'Expected 1 argument for member assignment; got %p' % [args.size] if args.size != 1
+            value.send(meth, args.first.to_ruby)
+          else
+            ECMA.make_core_object_from value.send(meth, *args.map { |arg| arg.to_ruby })
+          end
+        end
+        
+        def fuku_method_call(meth, *args)
+          raise "Can't method-call a setter method." if meth.to_s[-1] == ?=
+          Fukubukuro::CurrentReceiver.set self
+          ECMA.make_core_object_from value.send(meth).call(*args.map { |arg| arg.to_ruby })
+        end
+        
+        def fuku_call *args
+          ECMA.make_core_object_from value.send(:call, *args.map { |arg| arg.to_ruby })
+        end
+        
+      end
+      
+      class Lambda < Container
+        
+        def fuku_call *args
+          ECMA.make_core_object_from value.send(:call, *args)
+        end
+        
+      end
+      
+    end
+    
+  end
+end