AmberVM 0.0.19

data/README

@@ -0,0 +1,38 @@
+= rVM
+
+rVM is the implementation of a VirtualMachine in pure Ruby. To clarify, no virtual machine as in VMWare that lets you virtualize a computer. But rather like ruby 1.9 or JRuby that both implement a virtual machine (written in C or Java) to execute Ruby code.
+Just that rVM takes it the other way around, it is written in ruby and lets you execute code within ruby.
+
+= So what is so cool about that?
+
+For once, the challenge to pull this off ;P. Then it has on huge advantage. It makes it pretty easy to give ruby programs a interface for scripting.
+
+Now you might think 'wow cool but I could just use ruby!' that is right, and wrong. Imagine just short code snippets to make a query, perhaps you want to implement a SQL based language to let a user query data in your program? Also consider you want your website to allow user side scripts. I would not want to have ruby code executed for random visitors. Then again I might be more tempted to let them execute code within a VM that has no access to anything outside it's VM neither variables nor hardware nor memory.
+
+= Example
+
+
+The following example implements a pretty easy calculator using the the math language shipped with rVM. Set variables and are not used outside one line
+
+  require 'rubygems'
+  require 'amber' # This loads the rVM gem
+  require 'amber/languages/math'  #This loads the math plugin as well as the math function library
+  s =''
+  compiler = AmberVM::Languages[:math].new #Lets get us the compiler
+  while s!= 'QUIT'
+    s=gets.chomp
+    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 environment for all the calls.
+
+  require 'rubygems'
+  require 'amber' # This loads the rVM gem
+  require 'amber/languages/math'  #This loads the math plugin as well as the math function library
+  s =''
+  compiler = AmberVM::Languages[:math].new #Lets get us the compiler
+  env = compiler.env
+  while s!= 'QUIT'
+    s=gets.chomp
+    puts compiler.compile(s).execute(env) # We pass an fresh environment as we don't need an environment.
+  end

data/bin/ambervm

@@ -0,0 +1,278 @@
+#!/usr/bin/env ruby
+
+$: << "lib"
+require 'optparse'
+require 'ostruct'
+require 'pp'
+require 'amber'
+require 'rubygems'
+
+
+rcfile = File.expand_path('~/.amberrc')
+if File.exist?(rcfile)
+  File.new(rcfile).each do |line|
+    line.chomp!
+    ARGV << line.gsub(/\s.*$/,'')
+    ARGV << line.gsub(/^.*?\s/,'')
+  end
+end
+
+def v text
+  puts text if @options.verbose
+end
+
+def load_compiler lang
+  begin
+    if require("amber/languages/#{lang}")
+      v "Loading Compiler: #{lang}" if @options
+      @compiler = AmberVM::Languages[lang].new
+    else
+      puts "ERROR: could not find compiler: #{lang}"
+      exit 2
+    end
+  rescue Exception => e
+    puts "ERROR: could not load compiler for: #{lang} #=> #{e}"
+    exit 3
+  end
+  @compiler
+end
+
+class AmberVMOptParser
+  #
+  # Return a structure describing the options.
+  #
+  LANGUAGES = %w[ecma ecma_fuku 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.amber_library = []
+    options.core_library = []
+    options.verbose = false
+    options.language = :ecma
+    options.code = nil
+    options.use_default_core_libs = true
+    options.run_as_core = false
+    options.only_compilation = false
+
+    
+    o = OptionParser.new do |opts|
+      opts.banner = "Usage: amber [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", "--amber-require AmberVM_LIBRARY", "Require the AmberVM_LIBRARY before executing your script. This is for amber internal libraries.") do |lib|
+        options.amber_library << "amber/#{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 AmberVM 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 amber internal functions.") do |lib|
+        options.amber_library << "amber/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 |optimize|
+        options.optimize = optimize
+      end
+
+      opts.on_tail("-x", "--run-as-core", "Runs the code in core library mode (direct access to the rVM libraries)") do |c|
+        options.run_as_core = c
+      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
+      
+      opts.on("-s", "--source", "Shows the source before executing.") do
+        options.show_source = true
+      end
+      
+      opts.on("-p", "--compilation", "Only show the result of the compiler without executing it.") do
+        options.compilation = true
+      end
+      
+      opts.on("-n", "--dont-execute", "The code is only compiled but not executed.") do
+        options.dont_execute = true
+      end
+      
+      
+      # Another typical switch to print the version.
+      opts.on_tail("--version", "Show version") do
+        print "AmberVM version: #{AmberVM::VERSION}"
+        if options.language
+          puts ", #{options.language} compiler version: #{load_compiler(options.language).version}"
+        else
+          puts "."
+        end
+        exit
+      end
+    end
+    o.parse!(args)
+    options
+  end
+
+end  
+
+@options = AmberVMOptParser.parse(ARGV)
+@compiler = nil
+@optvars = {}
+
+  v "Initializing environment."
+
+@options.amber_library.each do |lib|
+  v "Loading AmberVM Library: #{lib}."
+  unless require(lib)
+    puts "ERROR: could not require internal library: #{lib}"
+    exit 1
+  end
+end
+
+load_compiler @options.language
+
+if not @options.dont_execute 
+
+  if @options.use_default_core_libs
+    if @options.optimize
+      @env = @compiler.optimized_env(@optvars) 
+    else
+      @env = @compiler.env() 
+    end
+  else
+    @env = AmberVM::Interpreter.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(@optvars) 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(@optvars) 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
+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
+  if @options.show_source
+    puts "\n### SOURCE ###"
+    i = 0; puts @source.gsub(/^/) { "%3d: " % [i += 1] }
+  end
+  v "Compiling program code."
+  code = @compiler.compile(@source, @options.run_as_core)
+  v "Optimizing code" if @options.optimize
+  code = code.optimize(@optvars) if @options.optimize
+  if @options.compilation
+    puts "\n### COMPILAT ###"
+    i = 0; puts code.pretty_inspect.gsub(/^/) { "%3d: " % [i += 1] }
+  end
+  unless @options.dont_execute 
+    begin
+      v "Executing program code."
+      p code.execute(@env)
+    rescue Exception => e
+      puts "ERROR: could not execute program code #=> #{}"
+      raise e
+    end
+  end
+rescue Exception => e
+  puts "ERROR: could not compile program code #=> #{e}"
+  raise e
+end

data/lib/amber/acts_as_rvm_type.rb

@@ -0,0 +1,157 @@
+=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
+
+
+# AmberVM::ActsAsAmberVMType is a mixin that allows to quickly publish classes and types
+# to the rVM interpreter without going through the hassle of defining each 
+# function on it's own and publisheing every varialbe that is watned.
+#
+# The function to call is ActsAsAmberVMTypeMethods::acts_as_amber_type.
+#
+# == Example
+#   class Test
+#     # Add the readers and writers for
+#     attr_accessor :var
+#     include AmberVM::ActsAsAmberVMType
+#     acts_as_amber_type
+#     register_variable :var
+#     register_function :to_s
+#   end
+module AmberVM::ActsAsAmberVMType
+  
+  # Called when included, loads the class methods and the instance methods needed.
+  def self.included(mod)
+    mod.extend(AmberVM::ActsAsAmberVMType::ActsAsAmberVMTypeMethods)
+  end
+  
+  
+  module ActsAsAmberVMTypeMethods
+    # This function sets up the class to be a registerd class for rVM.
+    # It also sets it up to allow the use of +register_variable+ and 
+    # +register_function+.
+    def acts_as_amber_type
+      # registering as class
+      extend AmberVM::Plugin
+      plugin_host AmberVM::Classes
+      register_for self.class.to_s.gsub(/(\w)([A-Z])/,"\1_" + "\2".downcase).to_sym
+      
+      #initializing empty functions and variables hashes
+      @functions = {}
+      @variables = {}
+      
+      #including DSL functions     
+      extend AmberVM::ActsAsAmberVMType::ActsAsAmberVMTypeInstanceMethods
+      
+      #including methods in class
+      include AmberVM::ActsAsAmberVMType::ActsAsAmberVMTypeSingeltonMethods
+    end
+  end
+  
+  module ActsAsAmberVMTypeSingeltonMethods
+    # This function will set up the variables for a rVM and replaces
+    # the current function with a shorter and faster one.
+    def variables
+      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 |published_as, data|
+        name, writable = data
+        @variables[published_as.to_s] = AmberVM::Interpreter::VariableStorageCallback.new(self, name, writable)
+      end
+      #redefinces the variables method to remove overhead from mapping
+      instance_eval do
+        def variables
+          @variables
+        end
+      end
+      
+      # Return the variables hash for the firs call.
+      @variables
+    end
+    
+    # This function will set up the variables for a rVM and replaces
+    # the current function with a shorter and faster one.
+    def functions
+      # Copy the original functions hash so that changes to the instance
+      # wont't carry over to to other instances.
+      @functions = self.class.object_functions.dup
+      
+      # Redefine the function method to speed up further accesses.
+      instance_eval do
+        def functions
+          @functions
+        end
+      end
+      
+      # Return the functions hash for the first call.
+      @functions
+    end
+  end
+  
+  
+  # This module hods the instance methods for classes that are supposed to
+  # act as  a rVM type.
+  #
+  # It includes +register_variable+ and +register_function+ to help setting up
+  # the class quickly.
+  module ActsAsAmberVMTypeInstanceMethods
+    # This registers a variable for the rVM interface, it allows the scripts
+    # to read and write them. If +writable+ is set this will be a read only
+    # variable. It alls an be published to rVM under a different name,
+    # by passing +published_as+.
+    def register_variable name, writable = true, published_as = name
+      @variables[published_as.to_s] = [name.to_sym, writable]
+    end
+   
+    # This registers a variable for the rVM interface, it allows the scripts
+    # to read and write them. If +writable+ is set this will be a read only
+    # variable. It alls an be published to rVM under a different name,
+    # by passing +published_as+.    
+    def register_function name, published_as = name
+      @functions[published_as.to_s] = Class.new(AmberVM::Functions::Function) do @name = name; end
+      class << @functions[published_as.to_s]
+        def execute params, env
+          env.read_var_val(:self).send(@name, *params)
+        end
+        
+        def signature
+          [:any] 
+        end
+      end
+    end
+    
+    # Returns the hash of variables for to be used only internally by the
+    # ActsAsAmberVMTypeSingeltonMethods#variables function to set up the details.
+    def object_variables
+      @variables
+    end
+    
+    # Returns the hash of variables for to be used only internally by the
+    # ActsAsAmberVMTypeSingeltonMethods#variables function to set up the details.
+    def object_functions
+      @functions
+    end 
+  end
+  
+end

data/lib/amber/classes/association.rb

@@ -0,0 +1,36 @@
+module AmberVM
+  module Classes
+    class Association < Hash
+      extend Plugin
+      plugin_host Classes
+      register_for :association
+      @@type = :association
+      
+      def data_type
+        :list
+      end      
+      
+      def variables
+        @variables ||= {}
+      end
+      
+      
+      def functions
+        @functions ||= {
+          'size' => AmberVM::Functions[:size],
+          'length' => AmberVM::Functions[:size],
+          'get' => AmberVM::Functions[:assoc_get],
+          'set' => AmberVM::Functions[:assoc_set],          
+        }
+      end
+      
+      def initialize source= {}, sepperator = ' '
+        super()
+        if source.is_a?(::Hash) # Okay we've to hack here to get sure we get the /real/ String
+          self.merge! source
+        end
+      end
+      
+    end
+  end
+end

data/lib/amber/classes/block.rb

@@ -0,0 +1,52 @@
+module AmberVM
+  module Classes
+    class Block < AmberVM::Classes::Class
+      attr_accessor :code
+      register_for :block
+      def initialize code
+        super()
+        @type = :any
+        @code = code
+      end
+      
+      def execute env
+      end
+      
+      def execargs
+        true
+      end
+      
+      class Variable_container
+        def initialize parent
+          @parent = parent
+          @data = {}
+        end
+        
+        def [] k
+          @data[k] || @parent[k]
+        end
+        
+        def []= k, v
+          @data[k] = v
+        end
+      end
+      
+      def optimize variables = {}
+        #old_keys = Set.new(variables.keys)
+        code = @code.optimize variables
+        #(Set.new(variables.keys) - old_keys).each do |key|
+        #  variables.delete(key)
+        #end
+        Block.new(code)
+      end
+      
+      def call params, env, pos = nil
+        AmberVM::debug "Calling Block at #{pos}...(evn: #{env.pretty_inspect}, params: #{params})" if $DEBUG
+        env = AmberVM::Interpreter::Environment.new({:params => params||[]}, env)
+        return (catch :return do
+          @code.execute(env)
+        end).val
+      end
+    end
+  end
+end

data/lib/amber/classes/boolean.rb

@@ -0,0 +1,40 @@
+module AmberVM
+  module Classes
+    class Boolean < AmberVM::Classes::Class
+      register_for :boolean
+      
+      def data_type
+        :boolean
+      end
+      
+      def hash
+        @value.hash
+      end
+      
+      def eql?(o)
+        if o.is_a?(AmberVM::Classes::Boolean)
+          o.is_true? == is_true?
+        else
+          @value == o
+        end
+      end
+      
+      def initialize value
+        super()
+        if value
+          if value.respond_to? :is_true?
+            @value = value.is_true?
+          else
+            @value = true
+          end
+        else
+          @value = false
+        end
+      end
+      
+      def is_true?
+        @value
+      end
+    end
+  end
+end

data/lib/amber/classes/class.rb

@@ -0,0 +1,50 @@
+module AmberVM
+  module Classes
+    class VMClass < AmberVM::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
+          AmberVM::debug "Executing object method #{method}." if $DEBUG
+          params.unshift self
+          env = AmberVM::Interpreter::Environment.new({:params => params||[], :locals => @variables, :functions => @functions}, env)
+          m.call(params, env)
+        end
+      end
+      
+      def instance params, env
+        o = AmberVM::Classes::Object.new self
+        env = AmberVM::Interpreter::Environment.new({:params => params||[], :locals => @variables, :functions => @functions}, env)
+        o.obj_send(@initializer, params, env) #if @object_functions[@initializer]
+        AmberVM::debug "Creating instance of #{self}: #{o.inspect}." if $DEBUG
+        o
+      end
+      
+    end
+  end
+end

data/lib/amber/classes/error.rb

@@ -0,0 +1,22 @@
+module AmberVM
+  module Classes
+    class Error < AmberVM::Classes::Class
+      register_for :error
+      attr_accessor :value
+      @@type = :error
+      def initialize value, text = "This is an error!"
+        super()
+        @value = value.to_i
+        @text = text
+      end
+      
+      def is_true? 
+        false
+      end
+      
+      def to_s
+        "##{@value} #{@text}"
+      end
+    end
+  end
+end