rVM 0.0.1

data/README

@@ -0,0 +1 @@
+

data/lib/rvm/base/classes.rb

@@ -0,0 +1,85 @@
+# = classes.rb - Class Plugin Library
+#
+# Copyright (C) 2008 Heinz N. Gies (heinz@licenser.net)
+#
+# This file is published under the MIT Licenser, see LICENSE for details.
+#
+require File.dirname(__FILE__) + '/plugin'
+module RVM
+  # This module is the basic class container, classes are supposed to be
+  # used by this as in: RVM::Classes[<class id>] this guarnatees that,
+  # in the case of overwriting a standard class the code still works.
+  #
+  # == Example
+  #
+  # === Creating a string calss
+  #
+  #   require 'lib/base/classes'
+  #   string = RVM::Classes[:string].new
+  module Classes
+    
+    extend PluginHost
+    plugin_path File.dirname(__FILE__), '../classes/'
+    default :string
+    # The Parent for new classes, meant never to be used alone.
+    # It takes care of registering the calss to the PluginHost,
+    # as well of basic functionality.
+    #
+    # Also it offers access to the function plugins to be used
+    # as functions within the commands.
+    #
+    # == Examples
+    #
+    # === COMPLES NUMBERS
+    # 
+    #   # file: lib/classes/math/complex.rb
+    #   require 'lib/base/classes'
+    #   module RVM
+    #     module Classes
+    #       class Complex < RVM::Classes::Class
+    #         def initialize i, n
+    #           @i = i
+    #           @j = j
+    #         end
+    #         #...
+    #       end
+    #     end
+    #   end
+    class Class
+      
+      extend Plugin
+      plugin_host Classes
+      
+      # 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 ;)
+      def data_type
+        :any
+      end
+      
+      # Returns if the objects is true or not,
+      # this is interesting for things like errors overwrite it if your
+      # class is not always true.
+      def is_true?
+        true
+      end
+
+      alias method_missing_old method_missing         
+      alias respond_to_old respond_to?
+      
+      # Implements a fallcback to allow use of function plugins within classes.
+      def respond_to?(symbol,include_private = false)
+        respond_to_old(symbol,include_private)
+      end
+      
+      def method_missing(m, *args)
+        if (RVM::Functions.has? m)
+          RVM::Functions[m].execute args, @env
+        else
+          method_missing_old m, *args
+        end
+      end
+      
+    end
+  end
+end

data/lib/rvm/base/functions.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/plugin'
+require File.dirname(__FILE__) + '/interpreter'
+module RVM
+  module Functions
+    extend PluginHost
+    plugin_path File.dirname(__FILE__), '../functions/*/'
+    class Function
+      extend Plugin
+      plugin_host Functions
+      class << self
+        
+        def data_type
+          :any
+        end
+
+        alias method_missing_old method_missing         
+        alias respond_to_old respond_to?
+        def respond_to?(symbol,include_private = false)
+          respond_to_old(symbol,include_private)
+        end
+        
+        def method_missing(m, *args)
+          if (RVM::Functions.has? m)
+            RVM::Functions[m].execute args, @env 
+          else
+            method_missing_old m, *args
+          end
+        end
+        
+        #This is for letting he itnerpreter know that it shall interprete the arguments
+        #and not let the function do it itself (this is needed for logical functions)
+        def execargs
+          true
+        end
+        
+        def call params, env
+          i = 0
+          sig = :any 
+          params.map! do |p| 
+            sig = signature[i] || sig
+            if sig != :any and p.class != RVM::Classes[sig]
+              raise "TYPE MISMATCH" if RVM::strict
+              p = RVM::Classes[sig].new(p)
+            end
+            i+=1
+            p 
+          end if not signature.empty?
+          r = execute(params, env)
+          RVM::debug "#{self.inspect}: #{signature.inspect} = '#{r}'"
+          r
+        end
+        
+        def execute params, env
+          
+        end
+      end
+    end
+  end
+end

data/lib/rvm/base/interpreter.rb

@@ -0,0 +1,342 @@
+require File.dirname(__FILE__) + '/functions'
+require File.dirname(__FILE__) + '/classes'
+module RVM
+  # This Module hold all the VM Classes, so it is quite important to read
+  # and understand if you feel like making a own compiler.
+  #
+  # The basic idea is to translate your own code into a tree of objects
+  # from this.
+  #
+  module Interpreter
+    
+    # This is a helper fuctio to quickly generate a empty enviorment.
+    def Interpreter.env aenv = {}
+      RVM::debug "Interpreter.env"
+      Enviroment.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
+      RVM::Interpreter::Constant.new(RVM::Classes[type].new(value))
+    end
+    
+    # This class represents the enviroment, the memory so to say for the VM.
+    # The enviroment holds enviromental 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 enviroments, as
+    # for example function calls.
+    class Enviroment
+      # This creates a new enviroment enviroment, 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 
+      def initialize data = {}, oldenv=nil
+        RVM::debug "data: #{data}\noldenv:#{oldenv}"
+        @data = {
+          :locals => {},
+          :caller => nil,
+          :self => nil,
+          :evaldeepth => 0,
+          :params => []
+        }.merge(data)
+        @prev = oldenv  || {}
+        RVM::debug "Creating new enviroment with: #{@data.inspect} as child of #{@prev}"
+        
+      end
+      
+      # returns the object that issued the VM call - so to say it's owner.
+      #
+      # If the current enviroment has no caller it tries it's 'oldenv' attrib
+      # to see if that had a owner.
+      def caller
+        r = @data[:caller] || (@prev.is_a?(Enviroment) ? @prev.caller : nil)
+        RVM::debug "Getting caller: #{r}"
+        r
+      end
+      
+      # returns the object that the code is run as, so it has the rights of
+      # this object.
+      #
+      # If the current enviroment has no object it tries it's 'oldenv' attrib
+      # to see if that had a object.
+      def object
+        r = @data[:self] || (@prev.is_a?(Enviroment) ? @prev.object : nil)
+        RVM::debug "Getting object: #{r}"
+        r
+      end
+      
+      # returns a parameter that was passed to the call. For function calls
+      # this is especially important, it beginns with 0.
+      #
+      # If the current enviroment does not have the given paramenter it tries
+      # it's 'oldenv' attrib to see if that had a object.
+      def param i
+        RVM::debug "Getting param #{i} (#{@data[:params][i]})"
+        @data[:params][i]
+      end
+      
+      # Returns a local variable with the given name.
+      #
+      # If the current enviroment does not have any local variables with
+      # the given name it tries the privious enviroments.
+      def [] k
+        r = @data[:locals][k] || @prev[k]
+        RVM::debug "Getting ariable #{k} (#{r})"
+        r
+      end
+      
+      #Sets a local variable witin the enviroment.
+      def []= k, v
+        #TODO: add capability to have the privious env variables changed
+        RVM::debug "Setting variable #{k} to #{v}"
+        @data[:locals][k] = v
+      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
+      attr_reader :value
+      def initialize value
+        @value = value
+      end
+      
+      def data_type
+        @value.data_type
+      end
+      def == v
+        if v.is_a? Constant
+          @value == v.value
+        else
+          false
+        end
+      end
+      
+      def execute env
+        RVM::debug "Executing Constant: #{@value}"
+        @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
+      # 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?)
+      def initialize value, true_case, false_case = nil
+        @value = value
+        @true_case = true_case
+        @false_case = false_case
+      end
+      
+      def data_type
+        if @true_case.data_type == @false_case.data_type
+          @false_case.data_type
+        else
+          :any
+        end
+      end
+      
+      def execute env
+        if @value.execute(env).is_true?
+          RVM::debug "Executing Condition... (true)"
+          @true_case.execute env
+        elsif @false_case
+          RVM::debug "Executing Condition... (false)"
+          @false_case.execute env
+        end
+      end
+    end
+    
+    # A variable assignment that sets a local variable, a declaration
+    # is not required before the assignment can be done.
+    #
+    # Both the *name* and the *value* are evaluated before the assignment
+    # is done.
+    class Assignment
+      def initialize name, value
+        @name = name
+        @value = value
+      end
+      
+      def data_type
+        @value.data_type
+      end
+      
+      def execute env
+        RVM::debug "Executing Assignment..."
+        env[@name.execute(env).to_s] = @value.execute env
+      end
+    end
+    
+    # Reads the value of a variable in the enviroment.
+    #
+    # The *name* is evaluated before the variable is retrieved.  
+    class Variable
+      def initialize name
+        @name = name
+        @type = :any
+      end
+      
+      # The type can only be tretrieved when the name is aconstant
+      # as it can be evaluated without sideffect.
+      def data_type
+        @type
+      end
+      
+      def execute env
+        RVM::debug "Executing Variable..."
+        r = env[@name.execute(env).to_s]
+        @type = r.data_type
+        r
+      end
+    end
+    
+    
+    # Returns a parameter of the enviroment. This is needed for things like
+    # *self* or *caller*.
+    class EnvGetter
+      
+      def initialize what
+        @envvar = what
+      end
+      
+      def data_type
+        if @envvar == :self or @envvar == :caller
+          :object
+        else
+          :any
+        end
+      end
+      
+      def execute env
+        case @envvar
+          when :self
+          env.object
+          when :caller
+          env.caller
+        else
+          RVM::Classes[:sting].new('')  
+        end
+      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
+      def initialize num
+        @num = num
+        @type = :any
+      end
+      
+      # The type can only be tretrieved when the num is aconstant
+      # as it can be evaluated without sideffect.
+      def data_type
+        @type
+      end
+      
+      def execute env
+        RVM::debug "Executing Parameter..."
+        r = env.param(@num.execute(env).to_i)
+        @type = r.data_type
+        r
+      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 < Array
+      def execute env
+        RVM::debug "Executing Sequence... #{inspect}"
+        r = nil
+        self.map { |seq|
+          RVM::debug "Executing Sequence step..."
+          r = seq.execute env
+        }
+        r
+      end
+      
+      def data_type
+        :any
+      end
+    end
+    
+    # A function call or a function or a block. The initialization of a new
+    # enviroment 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
+      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
+        if function.is_a? RVM::Classes[:block]
+          @function = function
+        else
+          @function = RVM::Functions[function]
+        end
+        @arguments = arguments
+      end
+      
+      def data_type
+        @function.data_type
+      end
+      
+      def == v
+        if v.is_a? FunctionCall
+         (@arguments == v.arguments) && (@function == v.function)
+        else
+          false
+        end
+      end
+      
+      def execute env
+        RVM::debug "Executing FunctionCall..."
+        args = @arguments
+        if @function.execargs
+          args = @arguments.map do |arg|
+            arg.execute env
+          end
+        end
+        @function.call(args, env)
+      end
+    end
+  end
+end

data/lib/rvm/base/languages.rb

@@ -0,0 +1,47 @@
+# = languages.rb - Class Plugin Library
+#
+# Copyright (C) 2008 Heinz N. Gies (heinz@licenser.net)
+#
+# This file is published under the MIT Licenser, see LICENSE for details.
+require File.dirname(__FILE__) + '/plugin'
+module RVM
+  # This module is the basic language container, classes are supposed to be
+  # used by this as in: RVM::Language[<class id>] this guarnatees that,
+  # in the case of overwriting a standard compilers the code still works.
+  #
+  # This are *COMPILERS* not *INTERPRETERS* they compile source code to a 
+  # VM bytecode to be executed later
+  #
+  # Have a look at RVM::Interpreter for details
+  #
+  # == Example
+  #
+  # === COMPILING A MATHEMATICAL EQUILATION
+  #
+  #   require 'lib/base/languages'
+  #   code = RVM::Classes[:math].compile '(1 + 1) * 3^2'
+  module Languages
+    extend PluginHost
+    plugin_path File.dirname(__FILE__), '../languages'
+    
+    # The Compiler class, it holds the compiler. As those grow big I suggest
+    # to split the actuall code into multiple fils. Have a look at the MUSHCode
+    # compile for an example.
+    class Language
+      extend Plugin
+      plugin_host Languages
+      class << self
+        
+        # Method placeholder, your compiler /needs/ to implement this
+        # or it won't work (of cause).
+        def compile code
+          nil
+        end
+
+        def register_for *ids
+          plugin_host.register self.new, *ids
+        end
+      end
+    end
+  end
+end