rVM 0.0.14 → 0.0.17

data/lib/rvm/languages/ecma/core-math.js

@@ -0,0 +1,84 @@
+Math = {
+	sin: function(x) {
+		__RVM__.sin(x);
+	},
+	cos: function(x) {
+		__RVM__.cos(x);
+	},
+	pow: function(x,y) {
+		__RVM__.power(x,y);
+	},
+	abs: function(x) {
+		__RVM__.abs(x);
+	},
+	acos: function(x) {
+		__RVM__.acos(x);
+	},
+	asin: function(x) {
+		__RVM__.asin(x);
+	},
+	atan: function(x) {
+		__RVM__.atan(x);
+	},
+	atan2: function(x, y) {
+		__RVM__.atan(x, y);
+	},
+	ceil: function(x) {
+		__RVM__.ceil(x);
+	},
+	exp: function(x) {
+		__RVM__.exp(x);
+	},
+	floor: function(x) {
+		__RVM__.floor(x);
+	},
+	log: function(x) {
+		__RVM__.log(x);
+	},
+	random: function() {
+		__RVM__.random();
+		//return 4;
+	},
+	round: function(x) {
+		__RVM__.round(x)
+	},
+	round: function(x) {
+		//__RVM__.sqrt(x); //Do we want that or do we just use power?
+		__RVM__.power(x,0.5);
+	},
+	tan: function(x) {
+		__RVM__.tan(x);
+	},
+	/*NOT IMPLEMENTED! TODO: Implement functions with a variable number of arguments, or rather how to handle them.
+	max: function(*x) {
+		__RVM__.max(x);
+	},
+	min: function(*x) {
+		__RVM__.min(x)
+	}*/
+	E: 2.7182818284590452354,
+	LN10: 2.302585092994046,
+	LN2: 0.6931471805599453,
+	LOG2E: 1.4426950408889634,
+	LOG10E: 0.4342944819032518,
+	PI: 3.1415926535897932,
+	SQRT1_2: 0.7071067811865476,
+	SQRT2: 1.4142135623730951
+};
+
+function Array(n) {
+	a = [];
+	if (n && (n >= 1)) {
+		a = a + [null];
+		while (n > 1) {
+			if ((n % 2) == 0) {
+				a = a + a;
+				n = n/2;
+			} else {
+				a = a + [null];
+				n--;
+			};
+		};
+	};
+	return a;
+};

data/lib/rvm/languages/math.rb

@@ -1,10 +1,7 @@
-require File.dirname(__FILE__) + '/math/tokenizer'
-require File.dirname(__FILE__) + '/math/tree'
-require File.dirname(__FILE__) + '/math/compiler'
 require 'rvm/functions/math'
 module RVM
-	module Languages
-		# This compiler handels mathematical expressions.
+  module Languages
+    # This compiler handels mathematical expressions.
     #
     # It is limited to smiple terms, as in for example integration of functions is not offered.
     # Yet it is hopefully enough to serve most mathematical needs.
@@ -17,17 +14,13 @@ module RVM
     #  * Support for variables (getting and setting)
     #  * Multiple concatinated statemetns sepperated by ';'
     #  * Custom functions (as in defining as well as calling)
-    module Math
+    class Math < RVM::Languages::Language
+      register_for :math
+      helper :tokenizer, :tree, :compiler
       
+      def compile text
+        Compiler.compile(Tree.generate(Tokenizer.tokenize(text)))
+      end
     end
-    
-    # See the Math module for a description of this compiler.
-    class MathLanguage < RVM::Languages::Language
-			include Math
-			def compile text
-			  Compiler.compile(Tree.generate(Tokenizer.tokenize(text)))
-			end
-			register_for :math
-		end
-	end
+  end
 end

data/lib/rvm/languages/math/compiler.rb

@@ -1,14 +1,14 @@
 module RVM
   module Languages
-    module Math
+    class Math
       class Compiler
         include RVM::Interpreter
         FUNCTION_MAP = {
-					'+' => :add,
-					'-' => :sub,
-					'/' => :div,
-					'*' => :mul,
-					'^' => :power
+          '+' => :add,
+          '-' => :sub,
+          '/' => :div,
+          '*' => :mul,
+          '^' => :power
         }
         def Compiler.compile tree
           if tree.is_a? Array
@@ -21,7 +21,7 @@ module RVM
               params = tree[:params].map {|p| compile(p)}
               case tree[:op]
                 when '-'
-                FunctionCall.new :neg, params
+                CoreCall.new :neg, params
               else
                 FunctionCall.new tree[:op], params
               end
@@ -54,12 +54,12 @@ module RVM
                     i += 1
                   end
                   body << compile(tree[:right])
-                  Interpreter::FunctionDefinition.new(Interpreter.const(:string, tree[:left][:op]), Interpreter.const(:block,body))
+                  Interpreter::FunctionDefinition.new(Interpreter.const(:string, tree[:left][:op]), RVM::Classes::Block.new(body))
                 else
                   raise ArgumentError, "Bad name for a variable!"
                 end
               else
-                FunctionCall.new(FUNCTION_MAP[tree[:op]], [compile(tree[:left]),compile(tree[:right])])
+                CoreCall.new(FUNCTION_MAP[tree[:op]], [compile(tree[:left]),compile(tree[:right])])
               end
             end
           end

data/lib/rvm/languages/math/tokenizer.rb

@@ -1,7 +1,7 @@
 require 'strscan'
 module RVM
   module Languages
-    module Math
+    class Math
       class Tokenizer
         def Tokenizer.tokenize str
           s = StringScanner.new str

data/lib/rvm/languages/math/tree.rb

@@ -1,24 +1,24 @@
 module RVM
   module Languages
-    module Math
+    class Math
       class Tree
         PRIORITIES = {
           ';' => -100,
           '=' => -50,
-					'(' => 0,
-					'+' => 10,
-					'-' => 10,
-					'*' => 20,
-					'/' => 20,
-					'^' => 30,
+          '(' => 0,
+          '+' => 10,
+          '-' => 10,
+          '*' => 20,
+          '/' => 20,
+          '^' => 30,
         }
         ASSOSICATIONS = {
           ';' => :right, 
-					'+' => :left,
-					'-' => :left,
-					'*' => :left,
-					'/' => :left,
-					'^' => :right,
+          '+' => :left,
+          '-' => :left,
+          '*' => :left,
+          '/' => :left,
+          '^' => :right,
           '=' => :right
         }
         def Tree.generate tokens
@@ -72,8 +72,8 @@ module RVM
             else
                raise "Unknown element in parser tree: #{token.inspect}"
             end
-						p(dbgstack) if $DEBUG
-						p(dbgoutput) if $DEBUG
+            p(dbgstack) if $DEBUG
+            p(dbgoutput) if $DEBUG
           end
           while not stack.empty?
             output <<  stack.pop

data/lib/rvm/library.rb

@@ -22,27 +22,19 @@ module RVM
     # Initializes library, if anguage and file are given, they are loaded
     # Optionally a saftey object can be passed to handle securing the 
     # interpreted code
-    def initialize(language = nil, file = nil, safety = RVM::Safety.new)
-      @env = RVM::Interpreter.env()
+    def initialize(language, file = nil, safety = RVM::Safety.new)
+      @lang = RVM::Languages[language].new
+      @env = RVM::Interpreter.env #@lang.env
       @safety = safety
-      load_library(language, file) if language and file
+      load_library(file) if file
     end
     
     #Loads a file into the Library, attention it is executed!
-    def load_library(language, file)
-      @safety.execute(RVM::Languages[language].new.compile(File.new(file).read),@env)
+    def load_library(file)
+      @safety.execute(@lang.compile(File.read(file)),@env)
     end 
     
-    # This is the most important part, so to say, the ruby magic in here
-    # If a unknown method is called this gets executed to try to resole it form the
-    # loaded libraires
-    #
-    # Priorities are:
-    #  1) check the functions
-    #  2) check if it was a variable
-    #  3) check if the call ended with a '=' then set it's as variable
-    #  4) call super
-    def method_missing(m, *args)
+    def call_function(name, *args)
       # First we convert the args
       vmargs = args.map do |arg|
         if c = CLASS_MAP[arg.class]
@@ -51,15 +43,31 @@ module RVM
           arg
         end
       end
-      n = m.to_s
+      n = name.to_s
       if fun = @env.function(n)
-        fun.call(@env, vmargs)
+        fun.call(vmargs, @env)
       elsif v = @env[n]
         v.val
       elsif n =~ /=$/
         @env[n.gsub(/=$/,'')] = vmargs.first
       else
-        super(m,args)
+        raise "oops!"
+      end
+    end
+    # This is the most important part, so to say, the ruby magic in here
+    # If a unknown method is called this gets executed to try to resole it form the
+    # loaded libraires
+    #
+    # Priorities are:
+    #  1) check the functions
+    #  2) check if it was a variable
+    #  3) check if the call ended with a '=' then set it's as variable
+    #  4) call super
+    def method_missing(m, *args)
+      begin
+        call_function(m, args)
+      rescue Exception => e
+        super(m, args)
       end
     end
   end

data/lib/rvm/optimisation.rb

@@ -0,0 +1,109 @@
+module RVM
+  module Interpreter
+# The Simple assignment is a version of the RVM::Interpreter::Assignment that
+# is added for optimisation purpose, it does not evaluate the name and expects
+# it to be a string from the beginning
+    class SimpleAssignment < RVM::Interpreter::Assignment
+      
+      # 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 name, value, pos = nil
+        @pos = pos
+        @name = name
+        @value = value
+      end
+    
+      
+      # The simple assignemnt only evaluates the value and sets the variable
+      # with the given name in the Environment.
+      def execute env
+        RVM::debug "Executing SimpleAssignment at #{@pos}..." if $DEBUG
+        env[@name] = @value.execute env
+      end
+      
+      def optimize
+        @value = @value.optimize
+        self
+      end
+    end
+    
+    # Version of the RVM::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 = nil
+        super(name.to_s,pos)
+      end
+      
+      # The name is a sting and we simple get what is written in the env
+      def execute env
+        RVM::debug "Executing SimpleVariable at #{@pos}..." if $DEBUG
+        begin
+          r = env.read_var_val(@name)
+          @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
+        self
+      end
+    end
+    
+    # For details see RVM::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 RVM::Interpreter::Declration 
+      def execute env
+        RVM::debug "Executing SimpleAssignment at #{@pos}..." if $DEBUG
+        env.declare(@name,@value.execute(env)).val
+      end
+      
+      def optimize
+        @value = @value.optimize
+        self
+      end
+    end
+  end
+end

data/lib/rvm/plugin.rb

@@ -1,30 +1,28 @@
 module RVM
-# = PluginHost
-#
-# $Id: plugin.rb 69 2006-07-11 06:00:20Z 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
-#    require_plugin 'Generators/fancy'
-#
-#    Thanks a lot to Murphy, this code is borrowed from coderay.
-#
+  
+  # = 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
+  #    RVM.require_plugin 'Generators/fancy'
   module PluginHost
     
     # Raised if Encoders::[] fails because:
@@ -36,8 +34,12 @@ module RVM
     PLUGIN_HOSTS = []
     PLUGIN_HOSTS_BY_ID = {}  # dummy hash
     
-    # Loads all plugins using all_plugin_names and load.
-    
+    # Loads all plugins using list and load.
+    def load_all
+      for plugin in list
+        load plugin
+      end
+    end
     
     # Returns the Plugin for +id+.
     #
@@ -54,6 +56,15 @@ module RVM
     # 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.
@@ -82,6 +93,15 @@ module RVM
       
     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' % [self]
+    end
+    
     # The host's ID.
     #
     # If PLUGIN_HOST_ID is not set, it is simply the class name.
@@ -119,9 +139,13 @@ module RVM
     #    map :navy => :dark_blue
     #    default :gray
     #  end
-    def default id
-      id = validate_id id
-      plugin_hash[nil] = id
+    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
@@ -132,7 +156,7 @@ module RVM
       for id in ids
         unless id.is_a? Symbol
           raise ArgumentError,
-          "id must be a Symbol, but it was a #{id.class}"
+            "id must be a Symbol, but it was a #{id.class}"
         end
         plugin_hash[validate_id(id)] = plugin
       end
@@ -143,8 +167,15 @@ module RVM
       @plugin_hash ||= create_plugin_hash
     end
     
-    def has? id
-      plugin_hash.has_key? id
+    # 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.
@@ -153,15 +184,44 @@ module RVM
       map.each do |id, plugin|
         map[id] = plugin.to_s[/(?>[\w_]+)$/]
       end
-    "#{name}[#{host_id}]#{map.inspect}"
+      "#{name}[#{host_id}]#{map.inspect}"
     end
     
-    protected
+  protected
     # Created a new plugin list and stores it to @plugin_hash.
     def create_plugin_hash
       @plugin_hash =
-      Hash.new do |h, plugin_id|
-        raise "Plugin #{plugin_id} not loaded."
+        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
     
@@ -174,6 +234,10 @@ module RVM
       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.
@@ -191,7 +255,7 @@ module RVM
         end
       else
         raise ArgumentError,
-        "String or Symbol expected, but #{id.class}(#{id}) given."
+          "String or Symbol expected, but #{id.class} given."
       end
     end
     
@@ -227,9 +291,9 @@ module RVM
     def plugin_host host = nil
       if host and not host.is_a? PluginHost
         raise ArgumentError,
-        "PluginHost expected, but #{host.class} given."
+          "PluginHost expected, but #{host.class} given."
       end
-      self.const_set :PLUGIN_HOST, host if host and not self.const_defined?(:PLUGIN_HOST)
+      self.const_set :PLUGIN_HOST, host if host
       self::PLUGIN_HOST
     end
     
@@ -256,18 +320,18 @@ module RVM
     
   end
   
-  
   # Convenience method for plugin loading.
   # The syntax used is:
   #
-  #  require_plugin '<Host ID>/<Plugin ID>'
+  #  RVM.require_plugin '<Host ID>/<Plugin ID>'
   #
   # Returns the loaded plugin.
-  def require_plugin path
+  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
+      "No host for #{host_id.inspect} found." unless host
     host.load plugin_id
   end
+  
 end