AmberVM 0.0.19

data/lib/amber/optimisation.rb

@@ -0,0 +1,299 @@
+module AmberVM
+  module Interpreter
+    
+    # Version of the AmberVM::Interpreter::Variable that handles static variable names
+    class SimpleVariable < 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.
+      def initialize name, pos = ['-', '-', '-'], require_declaration = false 
+        super(name.to_s,pos, require_declaration)
+      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
+          r = env[@name]
+          if not r
+            if @require_declaration
+              raise RuntimeError.new("Variable #{@name} was not declared.")
+            else
+              r = env.declare(@name, 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 Varialbe #{e}", @pos[0], @pos[1], @pos[2])
+        end
+      end
+      
+      def optimize variables = {}
+        variables[@name] ||= VariableStorage.new(AmberVM::Classes[:null].new(nil))
+        StaticVariable.new(variables[@name], pos, @require_declaration)
+      end
+    end
+    
+    # Version of the AmberVM::Interpreter::Variable that handles static variable names
+    class StaticVariable < 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.
+      def initialize var, pos = ['-', '-', '-'], require_declaration = false
+        var =  AmberVM::Interpreter::makevs(var)
+        super(var, pos, require_declaration)
+      end
+      
+      def value
+        @name
+      end
+      # The name is a sting and we simple get what is written in the env
+      def execute env
+        AmberVM::debug "Executing Static at #{@pos}..." if $DEBUG
+        @name
+      end
+      
+      def optimize variables = {}
+        StaticVariable.new(@name, @pos, @require_declaration)
+      end
+    end
+    
+    # class SimpleFunctionDefinition < FunctionDefinition
+    #     
+    #       # Initializes a new function definition
+    #       #
+    #       # name:: is the name of the function to define, if it is not 
+    #       #        unique it will overwrite earlyer definitions 
+    #       #        (unless override is false)
+    #       # 
+    #       # body:: is the body of the cuntion. this will be executed
+    #       #        when the defined function is called.
+    #       #
+    #       # override:: when true (default) earlyer definitions are 
+    #       #            replaced when it is called a second time.
+    #       #            When false a exception is thrown
+    #       #
+    #       # pos:: The position within the source code of the definition - for 
+    #       #       deugging purpose. 
+    #       def initialize name, body, override = true, pos = nil
+    #         super(name, body, override, pos)
+    #     
+    #       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
+    #         if not env
+    #           raise RuntimeError.new("No env in #{@name}", @pos[0], @pos[1], @pos[2])
+    #         end
+    #         env.def_function(@name,@body)
+    #         @body
+    #       end
+    #     
+    #       def optimize variables = {}
+    #         local_vars = {}
+    #         @body = @body.optimize local_vars
+    #         self
+    #       end
+    #     end
+    
+    class SimpleBlock < Block
+      
+      def execute env
+        @content.execute tenv
+      end
+      
+      def optimize variables = {}
+        SimpleBlock.new(@content.optimize(variables))
+      end
+    end
+    
+    class SimpleCoreCall < CoreCall
+      
+      def initialize function,  arguments, pos = nil
+        @pos = pos
+        @function = function
+        @arguments = arguments 
+      end
+      # When executed the CoreCall it will call one of the AmberVM's library functions
+      def execute env
+        AmberVM::debug "Executing SimpleCoreCall... args: #{@arguments.inspect}" if $DEBUG
+        args = nil
+        # The function is a anonymous function
+     
+        # Get the function from he globals
+        # Test if the arguments should be executed
+        if @function.execargs
+          # The arges get executed
+          args = @arguments.map do |arg|
+            a = arg.execute env
+          end
+        else
+          args = @arguments
+        end
+        args = args.map do |a|
+          a.is_a?(AmberVM::Interpreter::VariableStorage) ? a.val : a
+        end
+        # Call the function
+        begin
+          f = @function.call(args, env,  @pos)
+          f
+        rescue Exception => e
+          pp self
+          raise e
+          raise RuntimeError.new("Function failed to execute: #{e}", @pos[0], @pos[1], @pos[2])
+        end
+      end
+      
+      def optimize env
+        optimized = true
+        @arguments.each do |a|
+          if optimized
+            if a.is_a?(AmberVM::Interpreter::Constant)
+            elsif a.is_a?(AmberVM::Interpreter::VariableValue)
+              if a.variable.is_a?(AmberVM::Interpreter::StaticVariable)
+              else
+                optimized = false
+              end
+            else
+              optimized = false
+            end
+          end
+        end
+        if optimized and @function.execargs
+          newargs = arguments.map! do |a|
+            a = if a.is_a?(AmberVM::Interpreter::VariableValue)
+              a.variable.value
+            else
+              AmberVM::Interpreter::VariableStorage.new(a.execute(nil))
+            end
+          end
+          AmberVM::Interpreter::TrivialCoreCall.new(@function, @arguments, @pos)
+        else
+          self
+        end
+      end
+    end
+    
+    class TrivialCoreCall < SimpleCoreCall
+      def initialize function, arguments, pos = nil
+        super
+      end
+      
+      def execute env
+        AmberVM::debug "Executing TrivialCoreCall... args: #{@arguments.inspect}" if $DEBUG
+        args = nil
+        # The function is a anonymous function
+
+        args = @arguments.map do |a|
+          a.val
+        end
+        # Call the function
+        begin
+          f = @function.call(args, env,  @pos)
+          f
+        rescue Exception => e
+          pp self
+          raise e
+          raise RuntimeError.new("Function failed to execute: #{e}", @pos[0], @pos[1], @pos[2])
+        end
+      end
+      
+      def optimize variables
+        self
+      end
+    end
+    
+    
+    # For details see AmberVM::Interpreter::Declration, this is a
+    # optimized version vor simple cases.
+    #
+    # Only #value# is evaluated before the assignment is done.
+    
+    class SimpleDeclaration < Declaration
+      # 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
+        @pos = pos
+        @name = name.to_s
+        @value = value
+      end
+      
+      # Only the value is evaluated before assigning it, the name is taken
+      # to be a string.
+      #
+      # For details see AmberVM::Interpreter::Declration 
+      def execute env
+        AmberVM::debug "Executing SimpleAssignment at #{@pos}..." if $DEBUG
+        env.declare(@name,@value.execute(env)).val
+      end
+      
+      def optimize variables = {}
+        variables[@name] = VariableStorage.new(AmberVM::Classes[:null].new(nil))
+        value = @value.optimize variables
+        Assignment.new(StaticVariable.new(variables[@name]), value)
+      end
+    end
+    
+    class OptimizedClosures < Closures
+      
+      class OptimizedBinding < Binding
+      
+        def initialize content, vars
+          @content = content
+          @vars = vars
+        end
+        
+        def call params, env, pos = nil
+          @vars.each do |var,value|
+            var.val = value
+          end
+          @content.call(params, env, pos)
+        end
+      end
+      
+      def initialize content, variables
+        @content = content
+        @variables = variables
+      end
+      
+      def optimize variables = {}
+        OptimizedClosures.new(@content, @var)
+      end
+      
+      def execute env
+        local_variables = {}
+        new_content=@content.optimize(local_variables)
+        vars_to_copy=Set.new(@variables.keys).intersection(Set.new(local_variables.keys)).to_a.map{|k| [local_variables[k],@variables[k]]}
+        OptimizedBinding.new(new_content, vars_to_copy.map{|inner,outer| [inner,outer.val]})
+      end
+      
+    end
+  end
+end

data/lib/amber/plugin.rb

@@ -0,0 +1,337 @@
+module AmberVM
+  
+  # = PluginHost
+  #
+  # $Id: plugin.rb 255 2008-09-21 16:25:44Z murphy $
+  #
+  # A simple subclass plugin system.
+  #
+  #  Example:
+  #    class Generators < PluginHost
+  #      plugin_path 'app/generators'
+  #    end
+  #    
+  #    class Generator
+  #      extend Plugin
+  #      PLUGIN_HOST = Generators
+  #    end
+  #    
+  #    class FancyGenerator < Generator
+  #      register_for :fancy
+  #    end
+  #
+  #    Generators[:fancy]  #-> FancyGenerator
+  #    # or
+  #    AmberVM.require_plugin 'Generators/fancy'
+  module PluginHost
+    
+    # Raised if Encoders::[] fails because:
+    # * a file could not be found
+    # * the requested Encoder is not registered
+    PluginNotFound = Class.new Exception
+    HostNotFound = Class.new Exception
+    
+    PLUGIN_HOSTS = []
+    PLUGIN_HOSTS_BY_ID = {}  # dummy hash
+    
+    # Loads all plugins using list and load.
+    def load_all
+      for plugin in list
+        load plugin
+      end
+    end
+    
+    # Returns the Plugin for +id+.
+    #
+    # Example:
+    #  yaml_plugin = MyPluginHost[:yaml]
+    def [] id, *args, &blk
+      plugin = validate_id(id)
+      begin
+        plugin = plugin_hash.[] plugin, *args, &blk
+      end while plugin.is_a? Symbol
+      plugin
+    end
+    
+    # Alias for +[]+.
+    alias load []
+    
+    def require_helper plugin_id, helper_name
+      path = path_to File.join(plugin_id, helper_name)
+      require path
+    end
+    
+    def has? id
+      plugin_hash.has_key? validate_id(id)
+    end
+    
+    class << self
+      
+      # Adds the module/class to the PLUGIN_HOSTS list.
+      def extended mod
+        PLUGIN_HOSTS << mod
+      end
+      
+      # Warns you that you should not #include this module.
+      def included mod
+        warn "#{name} should not be included. Use extend."
+      end
+      
+      # Find the PluginHost for host_id.
+      def host_by_id host_id
+        unless PLUGIN_HOSTS_BY_ID.default_proc
+          ph = Hash.new do |h, a_host_id|
+            for host in PLUGIN_HOSTS
+              h[host.host_id] = host
+            end
+            h.fetch a_host_id, nil
+          end
+          PLUGIN_HOSTS_BY_ID.replace ph
+        end
+        PLUGIN_HOSTS_BY_ID[host_id]
+      end
+      
+    end
+    
+    # The path where the plugins can be found.
+    def plugin_path *args
+      unless args.empty?
+        @plugin_path = File.expand_path File.join(*args)
+        load_map
+      end
+      @plugin_path or raise 'No plugin_path given for %p %p' % [args, self]
+    end
+    
+    # The host's ID.
+    #
+    # If PLUGIN_HOST_ID is not set, it is simply the class name.
+    def host_id
+      if self.const_defined? :PLUGIN_HOST_ID
+        self::PLUGIN_HOST_ID
+      else
+        name
+      end
+    end
+    
+    # Map a plugin_id to another.
+    #
+    # Usage: Put this in a file plugin_path/_map.rb.
+    #
+    #  class MyColorHost < PluginHost
+    #    map :navy => :dark_blue,
+    #      :maroon => :brown,
+    #      :luna => :moon
+    #  end
+    def map hash
+      for from, to in hash
+        from = validate_id from
+        to = validate_id to
+        plugin_hash[from] = to unless plugin_hash.has_key? from
+      end
+    end
+    
+    # Define the default plugin to use when no plugin is found
+    # for a given id.
+    #
+    # See also map.
+    #
+    #  class MyColorHost < PluginHost
+    #    map :navy => :dark_blue
+    #    default :gray
+    #  end
+    def default id = nil
+      if id
+        id = validate_id id
+        plugin_hash[nil] = id
+      else
+        plugin_hash[nil]
+      end
+    end
+    
+    # Every plugin must register itself for one or more
+    # +ids+ by calling register_for, which calls this method.
+    #
+    # See Plugin#register_for.
+    def register plugin, *ids
+      for id in ids
+        unless id.is_a? Symbol
+          raise ArgumentError,
+            "id must be a Symbol, but it was a #{id.class}"
+        end
+        plugin_hash[validate_id(id)] = plugin
+      end
+    end
+    
+    # A Hash of plugion_id => Plugin pairs.
+    def plugin_hash
+      @plugin_hash ||= create_plugin_hash
+    end
+    
+    # Returns an array of all .rb files in the plugin path.
+    #
+    # The extension .rb is not included.
+    def list
+      Dir[path_to('*')].select do |file|
+        File.basename(file)[/^(?!_)\w+\.rb$/]
+      end.map do |file|
+        File.basename file, '.rb'
+      end
+    end
+    
+    # Makes a map of all loaded plugins.
+    def inspect
+      map = plugin_hash.dup
+      map.each do |id, plugin|
+        map[id] = plugin.to_s[/(?>\w+)$/]
+      end
+      "#{name}[#{host_id}]#{map.inspect}"
+    end
+    
+  protected
+    # Created a new plugin list and stores it to @plugin_hash.
+    def create_plugin_hash
+      @plugin_hash =
+        Hash.new do |h, plugin_id|
+          id = validate_id(plugin_id)
+          path = path_to id
+          begin
+            require path
+          rescue LoadError => boom
+            if h.has_key? nil  # default plugin
+              h[id] = h[nil]
+            else
+              raise PluginNotFound, 'Could not load plugin %p: %s' % [id, boom]
+            end
+          else
+            # Plugin should have registered by now
+            unless h.has_key? id
+              raise PluginNotFound,
+                "No #{self.name} plugin for #{id.inspect} found in #{path}."
+            end
+          end
+          h[id]
+        end
+    end
+    
+    # Loads the map file (see map).
+    #
+    # This is done automatically when plugin_path is called.
+    def load_map
+      mapfile = path_to '_map'
+      if File.exist? mapfile
+        require mapfile
+      elsif $DEBUG
+        warn 'no _map.rb found for %s' % name
+      end
+    end
+    
+    # Returns the Plugin for +id+.
+    # Use it like Hash#fetch.
+    #
+    # Example:
+    #  yaml_plugin = MyPluginHost[:yaml, :default]
+    def fetch id, *args, &blk
+      plugin_hash.fetch validate_id(id), *args, &blk
+    end
+    
+    # Returns the expected path to the plugin file for the given id.
+    def path_to plugin_id
+      File.join plugin_path, "#{plugin_id}.rb"
+    end
+    
+    # Converts +id+ to a Symbol if it is a String,
+    # or returns +id+ if it already is a Symbol.
+    #
+    # Raises +ArgumentError+ for all other objects, or if the
+    # given String includes non-alphanumeric characters (\W).
+    def validate_id id
+      if id.is_a? Symbol or id.nil?
+        id
+      elsif id.is_a? String
+        if id[/\w+/] == id
+          id.to_sym
+        else
+          raise ArgumentError, "Invalid id: '#{id}' given."
+        end
+      else
+        raise ArgumentError,
+          "String or Symbol expected, but #{id.class} given."
+      end
+    end
+    
+  end
+  
+  
+  # = Plugin
+  #
+  #  Plugins have to include this module.
+  #
+  #  IMPORTANT: use extend for this module.
+  #
+  #  Example: see PluginHost.
+  module Plugin
+    
+    def included mod
+      warn "#{name} should not be included. Use extend."
+    end
+    
+    # Register this class for the given langs.
+    # Example:
+    #   class MyPlugin < PluginHost::BaseClass
+    #     register_for :my_id
+    #     ...
+    #   end
+    #
+    # See PluginHost.register.
+    def register_for *ids
+      plugin_host.register self, *ids
+    end
+    
+    # The host for this Plugin class.
+    def plugin_host host = nil
+      if host and not host.is_a? PluginHost
+        raise ArgumentError,
+          "PluginHost expected, but #{host.class} given."
+      end
+      self.const_set :PLUGIN_HOST, host if host
+      self::PLUGIN_HOST
+    end
+    
+    # Require some helper files.
+    #
+    # Example:
+    #
+    #  class MyPlugin < PluginHost::BaseClass
+    #     register_for :my_id
+    #     helper :my_helper
+    #
+    # The above example loads the file myplugin/my_helper.rb relative to the
+    # file in which MyPlugin was defined.
+    def helper *helpers
+      for helper in helpers
+        self::PLUGIN_HOST.require_helper plugin_id, helper.to_s
+      end
+    end
+    
+    # Returns the pulgin id used by the engine.
+    def plugin_id
+      name[/\w+$/].downcase
+    end
+    
+  end
+  
+  # Convenience method for plugin loading.
+  # The syntax used is:
+  #
+  #  AmberVM.require_plugin '<Host ID>/<Plugin ID>'
+  #
+  # Returns the loaded plugin.
+  def self.require_plugin path
+    host_id, plugin_id = path.split '/', 2
+    host = PluginHost.host_by_id(host_id)
+    raise PluginHost::HostNotFound,
+      "No host for #{host_id.inspect} found." unless host
+    host.load plugin_id
+  end
+  
+end