rVM 0.0.14 → 0.0.17

data/README

@@ -21,18 +21,18 @@ The following example implements a pretty easy calculator using the the math lan
   compiler = RVM::Languages[:math].new #Lets get us the compiler
   while s!= 'QUIT'
     s=gets.chomp
-    puts compiler.compile(s).execute(RVM::Interpreter.env) # We pass an fresh enviroment as we don't need an environment.
+    puts compiler.compile(s).execute(compiler.env) # We pass an fresh environment as we don't need an environment.
   end
   
-Here one example that keeps set variables due to using one enviroment for all the calls.
+Here one example that keeps set variables due to using one environment for all the calls.
 
   require 'rubygems'
   require 'rvm' # This loads the rVM gem
   require 'rvm/languages/math'  #This loads the math plugin as well as the math function library
   s =''
   compiler = RVM::Languages[:math].new #Lets get us the compiler
-  env = RVM::Interpreter.env
+  env = compiler.env
   while s!= 'QUIT'
     s=gets.chomp
-    puts compiler.compile(s).execute(env) # We pass an fresh enviroment as we don't need an environment.
+    puts compiler.compile(s).execute(env) # We pass an fresh environment as we don't need an environment.
   end

data/bin/rvm

@@ -0,0 +1,229 @@
+#!/usr/bin/env ruby
+
+$: << "lib"
+require 'optparse'
+require 'ostruct'
+require 'pp'
+require 'rubygems'
+require 'rvm'
+
+rcfile = File.expand_path('~/.rvmrc')
+if File.exist?(rcfile)
+  File.new(rcfile).each do |line|
+    line.chomp!
+    ARGV << line.gsub(/\s.*$/,'')
+    ARGV << line.gsub(/^.*?\s/,'')
+  end
+end
+
+class RVMOptParser
+  #
+  # Return a structure describing the options.
+  #
+  LANGUAGES = %w[ecma bf math]
+  LANGUAGES_ALIASES = { "js" => "ecma", "javascript" => "ecma" }
+  def self.parse(args)
+    # The options specified on the command line will be collected in *options*.
+    # We set default values here.
+    options = OpenStruct.new
+    options.library = []
+    options.rvm_library = []
+    options.core_library = []
+    options.verbose = false
+    options.language = :ecma
+    options.code = nil
+    options.use_default_core_libs = true
+    
+    o = OptionParser.new do |opts|
+      opts.banner = "Usage: rvm [options]"
+      
+      opts.separator ""
+      opts.separator "Specific options:"
+      
+      # Mandatory argument.
+      opts.on("-r", "--require LIBRARY", "Require the LIBRARY before executing your script. This is for own libraries.") do |lib|
+        options.library << lib;
+      end
+      
+      opts.on("-i", "--rvm-require RVM_LIBRARY", "Require the RVM_LIBRARY before executing your script. This is for rvm internal libraries.") do |lib|
+        options.rvm_library << "rvm/#{lib}"
+      end
+      
+      opts.on("-b", "--no-corelibs", "Used to disable standard core libraries to be imported automatically") do |b|
+        options.use_default_core_libs = !b
+      end
+      opts.on("-c", "--core-require CORE_LIBRARY", "Require an additional CORE_LIBRARY before executing your script. This is for libraries that allow access to RVM library functions.") do |lib|
+        options.core_library << "#{lib}"
+      end
+      
+      opts.on("-f", "--function NAMESPACE/FUNCTION", "Require the function before executing your script. This is for rvm internal functions.") do |lib|
+        options.rvm_library << "rvm/functions/#{lib}"
+      end
+      
+      language_list = (LANGUAGES_ALIASES.keys + LANGUAGES).join(',')
+      opts.on("-l", "--language LANGUAGE", LANGUAGES, LANGUAGES_ALIASES, "Select interpreter language", "  (#{language_list})") do |language|
+        options.language = language
+      end
+      
+      # Boolean switch.
+      opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+        options.verbose = v
+      end
+
+      opts.on("-d", "--[no-]debug", "Run in debug mode (attention spammy! Implies -v") do |d|
+        options.verbose = true if $DEBUG = options.debug = d
+      end
+      
+      opts.on("-e", "--execute CODE", "Executes CODE directly.") do |code|
+        options.code = code
+      end
+      
+      opts.on("-o", "--optimize", "Optimizes the code prior to execution") do
+        options.optimize
+      end
+      
+      opts.separator ""
+      opts.separator "Common options:"
+      
+      # No argument, shows at tail.  This will print an options summary.
+      # Try it and see!
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+      
+      # Another typical switch to print the version.
+      opts.on_tail("--version", "Show version") do
+        puts OptionParser::Version.join('.')
+        exit
+      end
+    end
+    o.parse!(args)
+    options
+  end  # parse()
+
+end  # class OptparseExample
+
+@options = RVMOptParser.parse(ARGV)
+@compiler = nil
+
+def v text
+  puts text if @options.verbose
+end
+
+
+v "Initializing environment."
+
+@options.rvm_library.each do |lib|
+  v "Loading RVM Library: #{lib}."
+  unless require(lib)
+    puts "ERROR: could not require internal library: #{lib}"
+    exit 1
+  end
+end
+
+begin
+  if require("rvm/languages/#{@options.language}")
+    v "Loading Compiler: #{@options.language}"
+    @compiler = RVM::Languages[@options.language].new
+  else
+    puts "ERROR: could not find compiler: #{@options.language}"
+    exit 2
+  end
+rescue Exception => e
+  puts "ERROR: could not load compiler for: #{@options.language} #=> #{e}"
+  exit 3
+end
+
+if @options.use_default_core_libs
+  @env = @compiler.env
+else
+  @env = RVM::Initerpreter.env
+end
+
+@options.core_library.each do |lib|
+  v "Loading core library #{lib}."
+  if File.exist?(lib)
+    begin
+      v "Compiling core library #{lib}."
+      code = @compiler.compile(File.read(lib), true)
+      v "Optimizing library #{lib}" if @options.optimize
+      code = code.optimize if @options.optimize
+      begin
+        v "Executing library #{lib}."
+        code.execute(@env)
+      rescue Exception => e
+        puts "ERROR: could not execute core library: #{lib} #=> #{e}"
+        exit 4
+      end
+    rescue Exception => e
+      puts "ERROR: could not compile core library: #{lib} #=> #{e}"
+      exit 5
+    end
+  else
+    puts "ERROR: Could not load core library: #{lib}"
+    exit 6
+  end
+end
+
+@options.library.each do |lib|
+  v "Loading library #{lib}."
+  if File.exist?(lib)
+    begin
+      v "Compiling library #{lib}."
+      code = @compiler.compile(File.read(lib))
+      v "Optimizing library #{lib}" if @options.optimize
+      code = code.optimize if @options.optimize
+      begin
+        v "Executing library #{lib}."
+        code.execute(@env)
+      rescue Exception => e
+        puts "ERROR: could not execute library: #{lib} #=> #{e}"
+        exit 4
+      end
+    rescue Exception => e
+      puts "ERROR: could not compile library: #{lib} #=> #{e}"
+      exit 5
+    end
+  else
+    puts "ERROR: Could not load library: #{lib}"
+    exit 6
+  end
+end
+
+if @options.code
+  v "Executing: #{@options.code}."
+  @source = @options.code
+else
+  if file = ARGV.first
+    if File.exist?(file)
+	  @source = File.read(file)
+	else
+	  puts "ERROR: Could not load source file: #{file}"
+	  exit 7
+	end
+  else
+    puts "No files passed."
+    puts `#{$0} -h`
+    exit 8
+  end
+end
+  
+  
+begin
+  v "Compiling program code."
+  code = @compiler.compile(@source)
+  # p code
+  v "Optimizing library #{lib}" if @options.optimize
+  code = code.optimize if @options.optimize
+  begin
+    v "Executing program code."
+    code.execute(@env)
+  rescue Exception => e
+    puts "ERROR: could not execute program code #=> #{e}"
+    raise e
+  end
+rescue Exception => e
+  puts "ERROR: could not compile program code #=> #{e}"
+  raise e
+end

data/lib/rvm.rb

@@ -1,7 +1,7 @@
-require File.dirname(__FILE__) +'/rvm/interpreter'
-require File.dirname(__FILE__) +'/rvm/classes'
-require File.dirname(__FILE__) +'/rvm/functions'
-require File.dirname(__FILE__) +'/rvm/languages'
+require 'rvm/interpreter'
+require 'rvm/classes'
+require 'rvm/functions'
+require 'rvm/languages'
 require 'timeout'
 
 # This is the rVM library. Including it loads the very basic functionalites rVM offers.
@@ -15,7 +15,7 @@ require 'timeout'
 #
 # It also contains some usefull functions that wil allow to make the usuage easyer.
 module RVM
-  
+  VERSION = "0.0.16" unless defined?(VERSION)
   # 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.
@@ -88,7 +88,7 @@ module RVM
     
     # A utility function to give debug output based on weather $DEBUG is set or not
     def debug text
-      puts text if $DEBUG
+      puts ">>> #{text}" if $DEBUG
     end
   end
 end

data/lib/rvm/acts_as_rvm_type.rb

@@ -1,3 +1,27 @@
+=begin
+The MIT License
+
+Copyright (c) 2007 Heinz N. 'Licenser' Gies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Ruby Mush"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+=end
+
 
 # RVM::ActsAsRVMType is a mixin that allows to quickly publish classes and types
 # to the rVM interpreter without going through the hassle of defining each 
@@ -14,7 +38,6 @@
 #     register_variable :var
 #     register_function :to_s
 #   end
-
 module RVM::ActsAsRVMType
   
   # Called when included, loads the class methods and the instance methods needed.
@@ -52,8 +75,8 @@ module RVM::ActsAsRVMType
       puts self.class
       @variables = {}
       #gets the variables hash from the Test class and maps it to a getter/setter Class
-      self.class.object_variables.each do |name, data|
-        published_as, writable = data
+      self.class.object_variables.each do |published_as, data|
+        name, writable = data
         @variables[published_as.to_s] = RVM::Interpreter::VariableStorageCallback.new(self, name, writable)
       end
       #redefinces the variables method to remove overhead from mapping

data/lib/rvm/classes.rb

@@ -5,8 +5,8 @@
 # This file is published under the MIT Licenser, see LICENSE for details.
 #
 
-require File.dirname(__FILE__) + '/plugin'
-require File.dirname(__FILE__) + '/functions'
+require 'rvm/plugin'
+require 'rvm/functions'
 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,
@@ -16,11 +16,12 @@ module RVM
   #
   # === Creating a string calss
   #
-  #   require 'lib/base/classes'
+  #   require 'rvm/classes'
   #   string = RVM::Classes[:string].new
   module Classes
     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,
     # as well of basic functionality.
@@ -30,10 +31,10 @@ module RVM
     #
     # == Examples
     #
-    # === COMPLES NUMBERS
+    # === COMPLEX NUMBERS
     # 
-    #   # file: lib/classes/math/complex.rb
-    #   require 'lib/base/classes'
+    #   # file: rvm/classes/math/complex.rb
+    #   require 'rvm/classes'
     #   module RVM
     #     module Classes
     #       class Complex < RVM::Classes::Class
@@ -81,19 +82,12 @@ module RVM
         :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
-
       # Redefinding the method to allow using self defined functions
       # within classes - while this is discuraged it still is possible.      
       def method_missing(m, *args, &block)
         # Check if the functions PluginHost knwos about the called function
         if (RVM::Functions::has? m)
-          # Calls the function with given args and enviroment that is,
+          # Calls the function with given args and environment that is,
           # hopefully defiend in the calling class.
           RVM::Functions[m].execute args, @env
         else
@@ -107,5 +101,5 @@ module RVM
 end
 
 Dir[File.dirname(__FILE__) + '/classes/*.rb'].each do |c|
-  require c
+  require 'rvm/classes/' + File.basename(c)
 end

data/lib/rvm/classes/block.rb

@@ -16,13 +16,18 @@ module RVM
         true
       end
       
+      def optimize
+        @code = @code.optimize
+        self
+      end
+      
       def call params, env, pos = nil
-        RVM::debug "Calling Block at #{pos}...(#{env},#{params})" if $DEBUG
-        env = RVM::Interpreter::Enviroment.new({:params => params||[]}, env)
+        RVM::debug "Calling Block at #{pos}...(evn: #{env}, params: #{params})" if $DEBUG
+        env = RVM::Interpreter::Environment .new({:params => params||[]}, env)
         begin
           @code.execute(env)
         rescue RVM::Interpreter::ReturnException => e
-          RVM::debug "yuck, cought a result!" if $DEBUG
+          RVM::debug "yuck, caught a result!" if $DEBUG
           pp e if $DEBUG
           return e.val
         end

data/lib/rvm/classes/class.rb

@@ -31,14 +31,14 @@ module RVM
           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)
+          env = RVM::Interpreter::Environment.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)
+        env = RVM::Interpreter::Environment.new({:params => params||[], :locals => @variables, :functions => @functions}, env)
         o.obj_send(@initializer, [], env) if @object_functions[@initializer]
         o
       end

data/lib/rvm/classes/list.rb

@@ -1,6 +1,6 @@
 module RVM
   module Classes
-    class List < Array
+    class List < ::Array
       extend Plugin
       plugin_host Classes
       register_for :list

data/lib/rvm/classes/null.rb

@@ -0,0 +1,31 @@
+module RVM
+  module Classes
+    class Null < RVM::Classes::Class
+      register_for :null
+      
+      def data_type
+        :null
+      end
+      
+      def hash
+        nil.hash
+      end
+      
+      def eql?(o)
+        if o.nil? and o.is_a?(RVM::Classes::Null)
+          true
+        else
+          false
+        end
+      end
+      
+      def initialize value
+        super()
+      end
+      
+      def is_true?
+        false
+      end
+    end
+  end
+end