AmberVM 0.0.19

data/lib/amber/languages/ecma_fuku/core-math.js

@@ -0,0 +1,67 @@
+Math = {
+  sin: function(x) {
+    return __AmberVM__.sin(x);
+  },
+  cos: function(x) {
+    return __AmberVM__.cos(x);
+  },
+  pow: function(x,y) {
+    return __AmberVM__.power(x, y);
+  },
+  abs: function(x) {
+    return __AmberVM__.abs(x);
+  },
+  acos: function(x) {
+    return __AmberVM__.acos(x);
+  },
+  asin: function(x) {
+    return __AmberVM__.asin(x);
+  },
+  atan: function(x) {
+    return __AmberVM__.atan(x);
+  },
+  atan2: function(x, y) {
+    return __AmberVM__.atan(x, y);
+  },
+  ceil: function(x) {
+    return __AmberVM__.ceil(x);
+  },
+  exp: function(x) {
+    return __AmberVM__.exp(x);
+  },
+  floor: function(x) {
+    return __AmberVM__.floor(x);
+  },
+  log: function(x) {
+    return __AmberVM__.log(x);
+  },
+  random: function() {
+    return __AmberVM__.rand();
+    //return 4;
+  },
+  round: function(x) {
+    return __AmberVM__.round(x);
+  },
+  sqrt: function(x) {
+    //return __AmberVM__.sqrt(x); //Do we want that or do we just use power?
+    return __AmberVM__.power(x, 0.5);
+  },
+  tan: function(x) {
+    return __AmberVM__.tan(x);
+  },
+  /*NOT IMPLEMENTED! TODO: Implement functions with a variable number of arguments, or rather how to handle them.
+  max: function(*x) {
+    return __AmberVM__.max(x);
+  },
+  min: function(*x) {
+    return __AmberVM__.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
+};

data/lib/amber/languages/ecma_fuku/core-objects.js

@@ -0,0 +1,56 @@
+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;
+};
+
+function print(x) {
+	__AmberVM__.print(x, "\n");
+}
+
+Core = {
+	inc: function(x) {
+		return __AmberVM__.add(1, x);
+	},
+	dec: function(x) {
+		return __AmberVM__.add(-1, x);
+	},
+	type: function(x) {
+		t = __AmberVM__.type(x);
+		if (t == "AmberVM::Classes::String")
+		  return "string";
+		else if (t == "AmberVM::Classes::Number")
+		  return "number";
+		else if (t == "AmberVM::Classes::Boolen")
+		  return "boolean";
+		else if (t == "AmberVM::Classes::List")
+		  return "array";
+		else if (t == "AmberVM::Classes::Object")
+		  return "object";
+		else
+		  return t;
+	},
+	plus: function(a,b) {
+		if (__AmberVM__.type(a) == "AmberVM::Classes::String" || __AmberVM__.type(b) == "AmberVM::Classes::String")
+			return __AmberVM__.add("", a,b);
+		else
+			return __AmberVM__.add(a,b);
+	}
+};
+
+Undefined = {
+  undefined: null
+};
+
+Null = null;

data/lib/amber/languages/ecma_fuku.rb

@@ -0,0 +1,13 @@
+module AmberVM
+  module Languages
+    # A compiler for JavaScript.
+    class ECMA_Fuku < AmberVM::Languages::Language
+      register_for :'ecma_fuku'
+      plugin_id
+      helper :compiler
+      def default_env
+        @compiler.env
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module AmberVM
+  module Languages
+    class Math
+      class Compiler
+        include AmberVM::Interpreter
+        FUNCTION_MAP = {
+          '+' => :add,
+          '-' => :sub,
+          '/' => :div,
+          '*' => :mul,
+          '^' => :power
+        }
+        def Compiler.compile tree
+          if tree.is_a? Array
+            compile(tree.first)
+          elsif tree.is_a? Hash
+            case tree[:type]
+              when :number
+              Interpreter.const(:number, tree[:number])
+              when :function
+              params = tree[:params].map {|p| compile(p)}
+              case tree[:op]
+                when '-'
+                CoreCall.new :neg, params
+              else
+                FunctionCall.new tree[:op], params
+              end
+              when :ident
+              Interpreter::Variable.new(Interpreter.const(:string, tree[:ident]))
+              when :op
+              case tree[:op]
+                when ';'
+                s = Interpreter::Sequence.new()
+                if (tree[:left][:type] == :op) and (tree[:left][:op] == ';')
+                  s += compile(tree[:left])
+                else
+                  s << compile(tree[:left])
+                end
+                if (tree[:right][:type] == :op) and (tree[:right][:op] == ';')
+                  s += compile(tree[:right])
+                else
+                  s << compile(tree[:right])
+                end
+                when '='
+                case tree[:left][:type]
+                  when :ident
+                  Interpreter::Assignment.new(Interpreter.const(:string, tree[:left][:ident]),compile(tree[:right]))
+                  when :function
+                  body = Interpreter::Sequence.new()
+                  i = 0
+                  tree[:left][:params].each do |p|
+                    raise ArgumentError, "Bad ype for a function parameter: #{p[:type]} " if p[:type] != :ident
+                    body << Interpreter::Assignment.new(Interpreter.const(:string, p[:ident]), Interpreter::Parameter.new(Interpreter.const(:number, i)))
+                    i += 1
+                  end
+                  body << compile(tree[:right])
+                  Interpreter::FunctionDefinition.new(Interpreter.const(:string, tree[:left][:op]), AmberVM::Classes::Block.new(body))
+                else
+                  raise ArgumentError, "Bad name for a variable!"
+                end
+              else
+                CoreCall.new(FUNCTION_MAP[tree[:op]], [compile(tree[:left]),compile(tree[:right])])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'strscan'
+module AmberVM
+  module Languages
+    class Math
+      class Tokenizer
+        def Tokenizer.tokenize str
+          s = StringScanner.new str
+          tokens = []
+          state = :number
+          paren_deepth = 0
+          while not s.eos?
+            s.skip(/\s*/)
+            if state == :number
+              if s.scan(/[+-]+/)
+                t = s.matched.gsub('+','').gsub('--','')
+                if t == '-'
+                  tokens << [t, :function]
+                end
+              elsif s.scan(/[_a-z][_a-z0-9]*/i)
+                r = s.matched
+                if s.scan(/\(/)      
+                  tokens << [r, :function] 
+                  if s.scan(/\)/)
+                    tokens << [s.matched, :paren_close]
+                  else
+                     paren_deepth += 1
+                  end
+                else
+                  tokens << [r, :ident]
+                  state = :opperator
+                end
+              elsif s.scan(/((\d+(\.\d+)?)|(\.\d+))(e-?\d+)?/i)
+                tokens << [s.matched, :number]
+                state = :opperator
+              elsif s.scan(/\(/)
+                paren_deepth += 1
+                tokens << [s.matched, :paren_open]
+              else
+                raise "Unknown literal in term at positin #{s.pos}."
+              end
+            else
+              if s.scan(/\)/)
+                paren_deepth -= 1
+                raise "Unmatched parenthes at #{s.pos}" if paren_deepth < 0
+                tokens << [s.matched, :paren_close]
+              elsif s.scan(/,/)
+                tokens << [s.matched, :function_sep]
+                state = :number
+              elsif s.scan(/[*+\/^=-]/)
+                tokens << [s.matched, :opperator]
+                state = :number
+              elsif s.scan(/;/)
+                if paren_deepth == 0
+                  tokens << [s.matched, :opperator]
+                  state = :number
+                else
+                   raise "Expression sepperator enclosed in parenthes at #{s.pos}"
+                end
+              else
+                raise "Unknown literal in term at positin #{s.pos}."
+              end
+            end
+          end
+          tokens
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+module AmberVM
+  module Languages
+    class Math
+      class Tree
+        PRIORITIES = {
+          ';' => -100,
+          '=' => -50,
+          '(' => 0,
+          '+' => 10,
+          '-' => 10,
+          '*' => 20,
+          '/' => 20,
+          '^' => 30,
+        }
+        ASSOSICATIONS = {
+          ';' => :right, 
+          '+' => :left,
+          '-' => :left,
+          '*' => :left,
+          '/' => :left,
+          '^' => :right,
+          '=' => :right
+        }
+        def Tree.generate tokens
+          output = []
+          dbgoutput = []
+          stack = []
+          dbgstack = []
+          while not tokens.empty?
+            token = tokens.shift
+            case token[1]
+              when :function 
+              fun = token[0]
+              stack << {:type => :function, :op => fun}
+              output << {:type => :function_end}
+              dbgoutput << ')'
+              dbgstack << fun
+              when :function_sep
+              while stack.last && (stack.last[:type] != :function)
+                output << stack.pop
+                dbgoutput << dbgstack.pop
+              end
+              when :paren_open
+              op = token[0]
+              stack << {:type => :op, :op => op}
+              dbgstack << op
+              when :paren_close
+              while stack.last && (stack.last[:op] != '(')
+                output << stack.pop
+                dbgoutput << dbgstack.pop
+              end
+              stack.pop
+              dbgstack.pop
+              when :number
+              output << {:type => :number, :number => token[0]}
+              dbgoutput << token[0]
+              when :ident
+              output << {:type => :ident, :ident => token[0]}
+              dbgoutput << token[0]
+              when :opperator
+              op = token[0]
+              ass = ASSOSICATIONS[op]
+              o1p = PRIORITIES[op]
+              while stack.last && (stack.last[:type] != :function) &&
+               (((ass == :left) && (o1p <= PRIORITIES[stack.last[:op]])) || 
+               ((ass == :right) && (o1p < PRIORITIES[stack.last[:op]])))
+                output << stack.pop
+                dbgoutput << dbgstack.pop
+              end
+              stack << {:type => :op, :op => op}
+              dbgstack << op
+            else
+               raise "Unknown element in parser tree: #{token.inspect}"
+            end
+            p(dbgstack) if $DEBUG
+            p(dbgoutput) if $DEBUG
+          end
+          while not stack.empty?
+            output <<  stack.pop
+          end
+          gen_tree output
+        end
+        
+        private
+        def Tree.gen_tree data
+          item = data.pop
+          case item[:type]
+            when :number, :ident
+            item
+          when :op
+            item[:right] = gen_tree(data)
+            if item[:op] == ';' and  data.empty?
+              item = item[:right]
+            else
+              item[:left] = gen_tree(data)
+            end
+            item
+            when :function
+            item[:params] = []
+            while data.last && data.last[:type] != :function_end
+              item[:params] << gen_tree(data)
+            end
+            data.pop
+            item
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amber/languages/math.rb

@@ -0,0 +1,26 @@
+require 'amber/functions/math'
+module AmberVM
+  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.
+    #
+    # Included are:
+    #  * Opperators: +, -, *, /, ^
+    #  * Parenthetes
+    #  * Functions (as in proveded by the 'amber/funcions/math' library or custom loaded)
+    #  * Currect prioriets in execution
+    #  * Support for variables (getting and setting)
+    #  * Multiple concatinated statemetns sepperated by ';'
+    #  * Custom functions (as in defining as well as calling)
+    class Math < AmberVM::Languages::Language
+      register_for :math
+      helper :tokenizer, :tree, :compiler
+      
+      def compile text
+        Compiler.compile(Tree.generate(Tokenizer.tokenize(text)))
+      end
+    end
+  end
+end

data/lib/amber/languages.rb

@@ -0,0 +1,99 @@
+# = 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 'amber/plugin'
+module AmberVM
+  # This module is the basic language container, classes are supposed to be
+  # used by this as in: AmberVM::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 AmberVM::Interpreter for details
+  #
+  # == Example
+  #
+  # === COMPILING A MATHEMATICAL EQUILATION
+  #
+  #   require 'lib/base/languages'
+  #   code = AmberVM::Classes[:math].compile '(1 + 1) * 3^2'
+  module Languages
+    extend AmberVM::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 AmberVM::Plugin
+      plugin_host Languages
+      
+      def initialize *args
+        @compiler = self.class::Compiler.new(*args)
+        @core_libs = nil
+        core_libs
+      end
+      
+      # Loads the core libaries for a language, they have to be in the directory
+      # amber/langauges/LANGUAGE_ID/ directory and have to be named core-* to be
+      # recongnized ase core libraries.
+      # For speed reasons the core libraries will be cahced, to force them to be
+      # recompiled use the force_reload parameter as true.
+      def core_libs force_reload=false, additional_core_libs=[]
+        if not @core_libs or force_reload
+          @core_libs = additional_core_libs
+          Dir[File.join(File.dirname(__FILE__), 'languages', self.class.plugin_id.to_s, 'core-*')].each do |f|
+            begin
+              @core_libs << compile(File.read(f),true)
+            rescue Exception => e
+              puts "Failed to compile core library: #{f}."
+              raise e
+            end
+          end
+        end
+        
+        def version
+          @compiler.version
+        end
+        
+        @core_libs
+      end
+      
+      # This method returns a environment that has the needed core libraries loaded.
+      #
+      # When your langauge uses core libraries to publish AmberVM functions to the program
+      # this should be used.
+      # The first parameter force_reload can be passed to forcefully reload the core
+      # libraries.
+      # The second parameter can be passed to add the core libraries to an existing
+      # environment.
+      def env force_reload=false, additional_core_libs=[], core_env=nil
+        core_env ||= default_env
+        core_libs(force_reload, additional_core_libs).each do |lib|
+          lib.execute(core_env)
+        end
+        core_env
+      end
+      
+      def optimized_env variables={}, force_reload=false, additional_core_libs=[], core_env=nil
+        core_env ||= default_env
+        core_libs(force_reload, additional_core_libs).each do |lib|
+          lib.optimize(variables).execute(core_env)
+        end
+        core_env
+      end
+      
+      def default_env
+        AmberVM::Interpreter.env
+      end
+        
+      # Compiles a code with the generated compiler.
+      def compile code, *args
+        @compiler.compile code, *args
+      end
+    end
+  end
+end

data/lib/amber/library.rb

@@ -0,0 +1,79 @@
+require 'amber'
+
+module AmberVM
+  
+  # The Library class is made to provide library loading capabilites
+  # using any rVM supporte langauges and build a frontend between
+  # the rVM code and the Ruby code
+  #
+  # A Library can hold the content of more then one, file and the loaded
+  # files are not required to have the same langauge
+  class Library
+    # This maps rVM classes to usual Ruby classes so you won't need to take care of it
+    CLASS_MAP={
+      String => AmberVM::Classes::String,
+      Fixnum => AmberVM::Classes::Number,
+      Bignum => AmberVM::Classes::Number,
+      Float => AmberVM::Classes::Number,
+      FalseClass => AmberVM::Classes::Boolean,
+      TrueClass => AmberVM::Classes::Boolean,
+      Array => AmberVM::Classes::List
+    }
+    # 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, file = nil, safety = AmberVM::Safety.new)
+      @lang = AmberVM::Languages[language].new
+      @env = AmberVM::Interpreter.env #@lang.env
+      @safety = safety
+      load_library(file) if file
+    end
+    
+    #Loads a file into the Library, attention it is executed!
+    def load_library(file)
+      @safety.execute(@lang.compile(File.read(file)),@env)
+    end 
+    
+    def call_function(name, *args)
+      # First we convert the args
+      vmargs = args.map do |arg|
+        if c = CLASS_MAP[arg.class]
+          c.new(arg)
+        else
+          arg
+        end
+      end
+      n = name.to_s
+      if fun = @env.function(n)
+        fun.call(vmargs, @env)
+      elsif v = @env[n]
+        v.val
+      elsif n =~ /=$/
+        @env[n.gsub(/=$/,'')] = vmargs.first
+      else
+        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
+end
+
+
+
+
+