rVM 0.0.5 → 0.0.6

data/lib/rvm.rb

@@ -2,33 +2,92 @@ require 'rvm/interpreter'
 require 'rvm/classes'
 require 'rvm/functions'
 require 'rvm/languages'
-#This is the rVM Library
-module RVM
-  class << self
-  @@strict = false
-
-  def strict
-    @@strict
-  end
-
-  def compile language, code
-    compiler_for(language).compile(code)
-  end
+require 'timeout'
 
-  def compiler_for language
-   if l = RVM::Languages[language]
-      l
-    else
-      raise "RVM Error: Unknown Language #{language}"
+# This is the rVM library. Including it loads the very basic functionalites rVM offers.
+# 
+# It however does not yet load any functions or languages for security propose.
+# This will have to be done by hand for the reason that it will force the user to concider
+# which functions he wants to offer and which not.
+#
+# You may very well load your own functions and languages with rVM in the same way you can
+# load shipped languages.
+#
+# It also contains some usefull functions that wil allow to make the usuage easyer.
+module RVM
+  
+  # This class is designed to allow execting code more safely
+  #
+  # It allows to limit executin in multiple ways to prevent all sorty of runaway code.
+  class Safety
+    
+    attr_reader :timeout
+    def initialize
+      @timeout = nil
+    end
+    
+    # Sets the timeout for the executin, in seconds (you may use 0.5 and such)
+    # 
+    # The execution is aboarded and a exeption thrown if the 
+    def timeout=t 
+      raise ArgumentError, "The timeout must be a number!" if not t.is_a? Numeric
+      @timeout = t
+    end
+    
+    # Executes the code with the former set security measures.
+    #
+    # Exceptions are thrown according to the problem
+    def execute code, env
+      res = nil
+      if @timeout
+        Timeout::timeout(@timeout) do
+          res = code.execute(env)
+        end
+      else
+        res = code.execute(env)
+      end
+      res
     end
   end
-
-  def strict= v
-    @@strict = v
-  end
-
-  def debug text
-    puts text if $DEBUG
-  end
+  class << self
+    @@strict = false
+    
+    # This getter returns if rVM handles types strict.
+    #
+    # Calling a method with wrong types will raise a error if this is true.
+    # If false rVM will try to typecast accordingly.
+    def strict
+      @@strict
+    end
+    
+    # Sets if variables are strictly typed or casted for function calls.
+    # This allows to make a language either more secure or more flexible.
+    def strict= v
+      @@strict = v
+    end
+    
+    # Compils a code the given language.
+    # A new compiler is created for that and discarded afterwards.
+    #
+    # Using +compiler_for+ and calling compile for it yourself
+    # is more performant if you plan on doing thise more then once.
+    def compile language, code
+      compiler_for(language).compile(code)
+    end
+    
+    # Creates you a compiler object for the given language.
+    # If no language is given a error is raised.
+    def compiler_for language
+      if (l = RVM::Languages[language])
+        l.new
+      else
+        raise "RVM Error: Unknown Language #{language}"
+      end
+    end
+    
+    # A utility function to give debug output based on weather $DEBUG is set or not
+    def debug text
+      puts text if $DEBUG
+    end
   end
 end

data/lib/rvm/classes.rb

@@ -18,7 +18,7 @@ module RVM
   #   string = RVM::Classes[:string].new
   module Classes
     
-    extend PluginHost
+    extend RVM::PluginHost
     default :string
     # The Parent for new classes, meant never to be used alone.
     # It takes care of registering the calss to the PluginHost,
@@ -46,9 +46,18 @@ module RVM
     #   end
     class Class
       
-      extend Plugin
+      extend RVM::Plugin
       plugin_host Classes
       
+      
+      def functions
+        @functions ||= {}
+      end
+      
+      def variables
+        @variables ||= {:self => self, }
+      end
+      
       # This defines the type of the class, it defaults to :any
       # it is important for tying and type conversion, as long as it
       # behaves like a string, it can look like a sting ;)

data/lib/rvm/classes/block.rb

@@ -19,7 +19,13 @@ module RVM
       def call params, env
         #Logger.debug "Calling Block...(#{env},#{params})" if $DEBUG
         env = RVM::Interpreter::Enviroment.new({:params => params||[]}, env)
-        @code.execute env
+        begin
+          @code.execute(env)
+        rescue RVM::Interpreter::ReturnException => e
+          RVM::debug "yuck, cought a result!" if $DEBUG
+          pp e if $DEBUG
+          return e.val
+        end
       end
     end
   end

data/lib/rvm/classes/class.rb

@@ -0,0 +1,48 @@
+module RVM
+  module Classes
+    class VMClass < RVM::Classes::Class
+      register_for :class
+      
+      attr_reader :object_functions
+      attr_reader :functions
+      
+      attr_reader :variables
+      attr_accessor :initializer
+      attr_accessor :parent 
+      
+      def data_type
+        :class
+      end
+      
+      def initialize(parent = nil, initialize_name = "create");
+        super()
+        @initializer = initialize_name
+        @functions = {}
+        @variables = {}
+        @object_functions = {}
+        @parent = nil
+      end
+      
+      def obj_send(method, params, env)
+        if method == @initializer
+          instance params, env
+        else
+          m = @functions[method] || 
+          m = @parent.functions(method) if not m and @parent
+          raise "Unknown method #{method} for object #{self}" if not m
+          params.unshift self
+          env = RVM::Interpreter::Enviroment.new({:params => params||[], :locals => @variables, :functions => @functions}, env)
+          m.call(params, env)
+        end
+      end
+      
+      def instance params, env
+        o = RVM::Classes::Object.new self
+        env = RVM::Interpreter::Enviroment.new({:params => params||[], :locals => @variables, :functions => @functions}, env)
+        o.obj_send(@initializer, [], env) if @object_functions[@initializer]
+        o
+      end
+      
+    end
+  end
+end

data/lib/rvm/classes/number.rb

@@ -48,6 +48,7 @@ module RVM
         super(symbol,include_private)
       end
       
+      
       alias method_missing_old_number method_missing
       def method_missing m, *args
         if @value.respond_to? m

data/lib/rvm/classes/object.rb

@@ -0,0 +1,33 @@
+#TODO: 4
+module RVM
+  module Classes
+    class Object < RVM::Classes::Class
+      register_for :object
+      attr_reader :functions
+      attr_reader :variables
+      attr_reader :object_class
+      
+      def initialize objectClass
+        super()
+        @object_class = objectClass
+        @functions = {}
+        @variables = {}
+        
+      end
+      
+      def obj_send(method, params, env)
+        m = @functions[method] || @object_class.object_functions(method)
+        raise "Unknown method #{method} for object #{self}" if not m
+        params.unshift self
+        env = RVM::Interpreter::Enviroment.new({:params => params||[], :locals => @variables}, env)
+        m.call(params, env)
+      end
+      
+      
+      def data_type
+        :object
+      end
+      
+    end
+  end
+end

data/lib/rvm/functions.rb

@@ -2,9 +2,9 @@ require File.dirname(__FILE__) + '/plugin'
 require File.dirname(__FILE__) + '/interpreter'
 module RVM
   module Functions
-    extend PluginHost
+    extend RVM::PluginHost
     class Function
-      extend Plugin
+      extend RVM::Plugin
       plugin_host Functions
       class << self
         

data/lib/rvm/functions/array.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/array/*.rb'].each do |c|
+  require c
+end

data/lib/rvm/functions/array/append.rb

@@ -0,0 +1,20 @@
+module RVM
+  module Functions
+    class Append < Function
+      def Append.execute params, env
+        if params.length == 2
+          array = params.shift
+          value = params.shift
+          array << value
+        else
+          RVM::Classes[:error].new(1,"#-1 FUNCTION (#{self.class.to_s}) EXPECTS 2 OR MORE ARGUMENTS BUT GOT #{params.length}")
+        end
+      end
+
+      def Append.signature
+        [:list, :any]
+      end
+      register_for :append
+    end
+  end
+end

data/lib/rvm/functions/array/set_at.rb

@@ -0,0 +1,25 @@
+module RVM
+  module Functions
+    class SetAt < Function
+      def SetAt.execute params, env
+        if params.length == 3
+          p params
+          array = params.shift
+          pos = params.shift
+          value = params.shift
+          p array
+          p pos
+          p value
+          array[pos.to_i] = value
+        else
+          RVM::Classes[:error].new(1,"FUNCTION (#{self.class}) EXPECTS 3 ARGUMENTS BUT GOT #{params.length}")
+        end
+      end
+
+      def SetAt.signature
+        [:list, :number, :any]
+      end
+      register_for :set_at
+    end
+  end
+end

data/lib/rvm/functions/general/eq.rb

@@ -0,0 +1,19 @@
+module RVM
+  module Functions
+    class Eq < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            return RVM::Classes[:boolean].new(params[0] == params[1])
+          else
+          end
+        end
+        
+        def signature
+          [:any] 
+        end
+      end
+      register_for :eq
+    end
+  end
+end

data/lib/rvm/functions/general/gt.rb

@@ -0,0 +1,19 @@
+module RVM
+  module Functions
+    class Gt < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            return RVM::Classes[:boolean].new(params[0] > params[1])
+          else
+          end
+        end
+        
+        def signature
+          [:any] 
+        end
+      end
+      register_for :gt
+    end
+  end
+end

data/lib/rvm/functions/general/gte.rb

@@ -0,0 +1,19 @@
+module RVM
+  module Functions
+    class Gte < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            return RVM::Classes[:boolean].new(params[0] >= params[1])
+          else
+          end
+        end
+        
+        def signature
+          [:any] 
+        end
+      end
+      register_for :gte
+    end
+  end
+end

data/lib/rvm/functions/general/lt.rb

@@ -0,0 +1,19 @@
+module RVM
+  module Functions
+    class Lt < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            return RVM::Classes[:boolean].new(params[0] < params[1])
+          else
+          end
+        end
+        
+        def signature
+          [:any] 
+        end
+      end
+      register_for :lt
+    end
+  end
+end

data/lib/rvm/functions/general/lte.rb

@@ -0,0 +1,19 @@
+module RVM
+  module Functions
+    class Lte < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            return RVM::Classes[:boolean].new(params[0] <= params[1])
+          else
+          end
+        end
+        
+        def signature
+          [:any] 
+        end
+      end
+      register_for :lte
+    end
+  end
+end

data/lib/rvm/functions/general/neq.rb

@@ -0,0 +1,19 @@
+module RVM
+  module Functions
+    class Neq < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            return RVM::Classes[:boolean].new(params[0] != params[1])
+          else
+          end
+        end
+        
+        def signature
+          [:any] 
+        end
+      end
+      register_for :neq
+    end
+  end
+end

data/lib/rvm/functions/logic.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/logic/*.rb'].each do |c|
+  require c
+end