opal 0.3.21 → 0.3.22

data/core/object.rb

@@ -14,4 +14,8 @@ class Object
   def singleton_methods
     []
   end
+
+  # hack to make bridged classes get basicobject methods
+  alias __send__ __send__
+  alias send send
 end

data/core/proc.rb

@@ -1,11 +1,12 @@
 class Proc < `Function`
   %x{
     Proc_prototype._isProc = true;
+    Proc_prototype.is_lambda = true;
   }
 
   def self.new(&block)
     `if (block === nil) no_block_given();`
-
+    `block.is_lambda = false`
     block
   end
 
@@ -14,7 +15,7 @@ class Proc < `Function`
   end
 
   def call(*args)
-    `#{self}.apply(null, [#{self}._s].concat(#{args}))`
+    `#{self}.apply(#{self}._s, #{args})`
   end
 
   def to_proc
@@ -22,7 +23,9 @@ class Proc < `Function`
   end
 
   def lambda?
-    `!!this.$lambda`
+    # This method should tell the user if the proc tricks are unavailable,
+    # (see Proc#lambda? on ruby docs to find out more).
+    `!!#{self}.is_lambda`
   end
 
   def arity

data/core/racc.rb

@@ -0,0 +1,215 @@
+# Opal port of racc/parser.rb.
+#
+# Original license:
+#
+# $originalId: parser.rb,v 1.8 2006/07/06 11:42:07 aamine Exp $
+#
+# Copyright (c) 1999-2006 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the same terms of ruby.
+#
+# As a special exception, when this code is copied by Racc
+# into a Racc output file, you may use that output file
+# without restriction.
+module Racc
+
+  class Parser
+
+    def _racc_setup
+      self.class::Racc_arg
+    end
+
+    def do_parse
+      _racc_do_parse_rb _racc_setup, false
+    end
+
+    def _racc_do_parse_rb(arg, in_debug)
+      action_table   = arg[0]
+      action_check   = arg[1]
+      action_default = arg[2]
+      action_pointer = arg[3]
+
+      goto_table     = arg[4]
+      goto_check     = arg[5]
+      goto_default   = arg[6]
+      goto_pointer   = arg[7]
+
+      nt_base        = arg[8]
+      reduce_table   = arg[9]
+      token_table    = arg[10]
+      shift_n        = arg[11]
+      reduce_n       = arg[12]
+
+      use_result     = arg[13]
+
+      # racc sys vars
+      racc_state     = [0]
+      racc_tstack    = []
+      racc_vstack    = []
+
+      racc_t         = nil
+      racc_tok       = nil
+      racc_val       = nil
+      racc_read_next = true
+
+      racc_user_yyerror = false
+      racc_error_status = 0
+
+      token = nil; act = nil; i = nil; nerr = nil; custate = nil
+
+      while true
+        i = action_pointer[racc_state[-1]]
+
+        if i
+          if racc_read_next
+            if racc_t != 0 # not EOF
+              token = next_token
+
+              racc_tok = token[0]
+              racc_val = token[1]
+
+              if racc_tok == false # EOF
+                racc_t = 0
+              else
+                racc_t = token_table[racc_tok]
+                racc_t = 1 unless racc_t
+                # racc_t ||= 1
+              end
+
+              racc_read_token(racc_t, racc_tok, racc_val) if @yydebug
+              racc_read_next = false
+            end
+          end
+
+          i += racc_t
+
+          if (i < 0) || (act = action_table[i]).nil? || (action_check[i] != racc_state[-1])
+            act = action_default[racc_state[-1]]
+          end
+
+        else
+          act = action_default[racc_state[-1]]
+        end
+
+        puts "(act: #{act}, shift_n: #{shift_n}, reduce_n: #{reduce_n})" if @yydebug
+        if act > 0 && act < shift_n
+          if racc_error_status > 0
+            if racc_t != 1
+              racc_error_status -= 1
+            end
+          end
+
+          racc_vstack.push racc_val
+          curstate = act
+          racc_state << act
+          racc_read_next = true
+
+          if @yydebug
+            racc_tstack.push racc_t
+            racc_shift racc_t, racc_tstack, racc_vstack
+          end
+
+        elsif act < 0 && act > -reduce_n
+          reduce_i   = act * -3
+          reduce_len = reduce_table[reduce_i]
+          reduce_to  = reduce_table[reduce_i + 1]
+          method_id  = reduce_table[reduce_i + 2]
+
+          tmp_t = racc_tstack.last reduce_len
+          tmp_v = racc_vstack.last reduce_len
+
+          racc_state.pop reduce_len
+          racc_vstack.pop reduce_len
+          racc_tstack.pop reduce_len
+
+          if use_result
+            reduce_call_result = self.__send__ method_id, tmp_v, nil, tmp_v[0]
+            racc_vstack.push reduce_call_result
+          else
+            raise "not using result??"
+          end
+
+          racc_tstack.push reduce_to
+
+          if @yydebug
+            racc_reduce tmp_t, reduce_to, racc_tstack, racc_vstack
+          end
+
+          k1 = reduce_to - nt_base
+
+          if (reduce_i = goto_pointer[k1]) != nil
+            reduce_i += racc_state[-1]
+
+            if (reduce_i >= 0) && ((curstate = goto_table[reduce_i]) != nil) && (goto_check[reduce_i] == k1)
+              racc_state.push curstate
+            else
+              racc_state.push goto_default[k1]
+            end
+
+          else
+            racc_state.push goto_default[k1]
+          end
+
+        elsif act == shift_n
+          # action
+          return racc_vstack[0]
+
+        elsif act == -reduce_n
+          # reduce
+          raise "Opal Syntax Error: unexpected '#{racc_tok.inspect}'"
+
+        else
+          raise "Rac: unknown action: #{act}"
+        end
+
+        if @yydebug
+          racc_next_state racc_state[-1], racc_state
+        end
+        # raise "and finished loop"
+      end
+
+    end # _racc_do_parse_rb
+
+    def racc_read_token(t, tok, val)
+      puts "read    #{tok}(#{racc_token2str(t)}) #{val.inspect}"
+      puts "\n"
+    end
+
+    def racc_shift(tok, tstack, vstack)
+      puts "shift  #{racc_token2str tok}"
+      racc_print_stacks tstack, vstack
+      puts "\n"
+    end
+
+    def racc_reduce(toks, sim, tstack, vstack)
+      puts "reduce #{toks.empty? ? '<none>' : toks.map { |t| racc_token2str(t) }}"
+      puts "  --> #{racc_token2str(sim)}"
+      racc_print_stacks tstack, vstack
+    end
+
+    def racc_next_state(curstate, state)
+      puts "goto  #{curstate}"
+      racc_print_states state
+      puts "\n"
+    end
+
+    def racc_token2str(tok)
+      self.class::Racc_token_to_s_table[tok]
+    end
+
+    def racc_print_stacks(t, v)
+      puts '  ['
+      t.each_index do |i|
+        puts "    (#{racc_token2str(t[i])} #{v[i].inspect})"
+      end
+      puts '  ]'
+    end
+
+    def racc_print_states(s)
+      puts '  ['
+      s.each { |st| puts "   #{st}" }
+      puts '  ]'
+    end
+  end
+end

data/core/regexp.rb

@@ -20,9 +20,9 @@ class Regexp < `RegExp`
       var result = #{self}.exec(string);
 
       if (result) {
-        var matchdata = #{MatchData};
-        result.$k = matchdata;
-        result.$m = matchdata.$m_tbl;
+        result.$to_s    = match_to_s;
+        result.$inspect = match_inspect;
+        result._klass = #{MatchData};
 
         #{$~ = `result`};
       }
@@ -45,9 +45,9 @@ class Regexp < `RegExp`
       var result  = #{self}.exec(pattern);
 
       if (result) {
-        var matchdata = #{MatchData};
-        result.$k = matchdata;
-        result.$m = matchdata.$m_tbl;
+        result.$to_s    = match_to_s;
+        result.$inspect = match_inspect;
+        result._klass = #{MatchData};
 
         return #{$~ = `result`};
       }
@@ -60,22 +60,17 @@ class Regexp < `RegExp`
   def to_s
     `#{self}.source`
   end
-end
-
-class MatchData
-  def [](idx)
-    `#{self}[idx]`
-  end
 
-  def inspect
-    "#<MatchData #{self[0].inspect}>"
-  end
+  %x{
+    function match_to_s() {
+      return this[0];
+    }
 
-  def to_a
-    `#{self}.slice()`
-  end
+    function match_inspect() {
+      return "<#MatchData " + this[0].$inspect() + ">";
+    }
+  }
+end
 
-  def to_s
-    self[0]
-  end
+class MatchData
 end

data/core/runtime.js

@@ -28,12 +28,6 @@ Opal.alloc  = TopScope;
 // This is a useful reference to global object inside ruby files
 Opal.global = this;
 
-// Root method table (BasicObject inherits from this)
-function RootMethodTableConstructor() {}
-
-// The prototype (actual table) for root
-var RootMethodTable = RootMethodTableConstructor.prototype;
-
 // Minify common function calls
 var __hasOwn = Opal.hasOwnProperty;
 var __slice  = Opal.slice = Array.prototype.slice;
@@ -47,34 +41,6 @@ Opal.cvars = {};
 // Globals table
 Opal.gvars = {};
 
-var method_missing_mid = '';
-
-function method_missing_handler(self) {
-  var args = __slice.call(arguments, 1);
-  return self.$m.method_missing.apply(null, [self, method_missing_mid].concat(args));
-}
-
-Opal.mm = function(mid) {
-  method_missing_mid = mid;
-  return method_missing_handler;
-};
-
-Opal.send = function(recv, mid) {
-  var args = __slice.call(arguments, 2);
-  return (recv.$m[mid] || Opal.mm(mid)).apply(null, [recv].concat(args));
-};
-
-// define singleton method
-Opal.defs = function(obj, name, method) {
-  var singleton;
-
-  if (!(singleton = obj._singleton)) {
-    singleton = Opal.send(obj, 'singleton_class');
-  }
-
-  singleton.$m_tbl[name] = method;
-};
-
 // Runtime method used to either define a new class, or re-open an old
 // class. The base may be an object (rather than a class), which is
 // always the case when defining classes in the top level as the top
@@ -110,7 +76,7 @@ Opal.defs = function(obj, name, method) {
 Opal.klass = function(base, superklass, id, constructor) {
   var klass;
   if (base._isObject) {
-    base = base.$k;
+    base = base._klass;
   }
 
   if (superklass === null) {
@@ -121,13 +87,14 @@ Opal.klass = function(base, superklass, id, constructor) {
     klass = base._scope[id];
   }
   else {
-    if (!superklass.$m_tbl) {
+    if (!superklass._methods) {
       var bridged = superklass;
       superklass  = Object;
-      constructor = bridged;
+      klass       = bridge_class(bridged);
+    }
+    else {
+      klass = boot_class(superklass, constructor);
     }
-
-    klass = boot_class(superklass, constructor, bridged);
 
     klass._name = (base === Object ? id : base._name + '::' + id);
 
@@ -138,8 +105,8 @@ Opal.klass = function(base, superklass, id, constructor) {
 
     base[id] = base._scope[id] = klass;
 
-    if (superklass.$m.inherited) {
-      superklass.$m.inherited(superklass, klass);
+    if (superklass.$inherited) {
+      superklass.$inherited(klass);
     }
   }
 
@@ -150,14 +117,14 @@ Opal.klass = function(base, superklass, id, constructor) {
 Opal.module = function(base, id, constructor) {
   var klass;
   if (base._isObject) {
-    base = base.$k;
+    base = base._klass;
   }
 
   if (__hasOwn.call(base._scope, id)) {
     klass = base._scope[id];
   }
   else {
-    klass = boot_module(constructor);
+    klass = boot_class(Module, constructor);
     klass._name = (base === Object ? id : base._name + '::' + id);
 
     klass._isModule = true;
@@ -188,139 +155,124 @@ var boot_defclass = function(id, constructor, superklass) {
     constructor.prototype = new ctor();
   }
 
-  // method table constructor;
-  var m_ctr = function() {};
-
-  if (superklass) {
-    // not BasicObject
-    m_ctr.prototype = new superklass.$m_ctr;
-  }
-  else {
-    // BasicObject
-    m_ctr.prototype = RootMethodTable;
-  }
-
-  var    m_tbl = m_ctr.prototype;
-  m_tbl.constructor = m_ctr;
-
   var prototype = constructor.prototype;
 
   prototype.constructor = constructor;
   prototype._isObject   = true;
-  prototype.$k      = constructor;
-
-  // method table of instances
-  prototype.$m          = m_tbl;
-
-  // constructor._included_in  = [];
-  // constructor._isClass      = true;
-  // constructor._name         = id;
-  // constructor._super        = superklass;
-  // constructor._methods      = [];
-  // constructor._smethods     = [];
-  constructor._isObject     = false;
-
-  // method table for class methods
-  // constructor.$m            = c_tbl;
-  // method table of instances
-  constructor.$m_tbl        = m_tbl;
-  // method table constructor of instances
-  constructor.$m_ctr        = m_ctr;
-
-  constructor.$s = superklass;
+  prototype._klass      = constructor;
 
+  constructor._included_in  = [];
+  constructor._isClass      = true;
   constructor._name         = id;
+  constructor._super        = superklass;
+  constructor._methods      = [];
+  constructor._smethods     = [];
+  constructor._isObject     = false;
 
   constructor._donate = __donate;
+  constructor._sdonate = __sdonate;
 
   Opal[id] = constructor;
 
   return constructor;
 };
 
-var boot_defmeta = function(constructor, parent_m_tbl) {
-  var m_ctr = function(){};
-  m_ctr.prototype = new parent_m_tbl;
+// Create generic class with given superclass.
+var boot_class = function(superklass, constructor) {
+  var ctor = function() {};
+      ctor.prototype = superklass.prototype;
+
+  constructor.prototype = new ctor();
+  var prototype = constructor.prototype;
+
+  prototype._klass      = constructor;
+  prototype.constructor = constructor;
+
+  constructor._included_in  = [];
+  constructor._isClass      = true;
+  constructor._super        = superklass;
+  constructor._methods      = [];
+  constructor._isObject     = false;
+  constructor._klass        = Class;
+  constructor._donate       = __donate
+  constructor._sdonate      = __sdonate;
 
-  var m_tbl = m_ctr.prototype;
-  m_tbl.constructor = m_ctr;
+  constructor['$==='] = module_eqq;
+  constructor.$to_s = module_to_s;
 
-  constructor.$m = m_tbl;
+  var smethods;
+
+  smethods = superklass._smethods.slice();
+
+  constructor._smethods = smethods;
+  for (var i = 0, length = smethods.length; i < length; i++) {
+    var m = smethods[i];
+    constructor[m] = superklass[m];
+  }
 
   return constructor;
 };
 
-// Create generic class with given superclass.
-var boot_class = function(superklass, constructor, bridged) {
-  // method table constructor
-  function m_ctr(){};
-  m_ctr.prototype = new superklass.$m_tbl.constructor;
-  
-  // method table itself
-  var m_tbl = m_ctr.prototype;
-  m_tbl.constructor = m_ctr;
+var bridge_class = function(constructor) {
+  constructor.prototype._klass = constructor;
 
-  var prototype = constructor.prototype;
+  constructor._included_in  = [];
+  constructor._isClass      = true;
+  constructor._super        = Object;
+  constructor._klass        = Class;
+  constructor._methods      = [];
+  constructor._smethods     = [];
+  constructor._isObject     = false;
 
-  if (!bridged) {
-    constructor.prototype = new superklass;
-    prototype = constructor.prototype;
-    prototype.constructor = constructor;
-  }
+  constructor._donate = function(){};
+  constructor._sdonate = __sdonate;
 
-  prototype.$k = constructor; // instances need to know their class
-  prototype.$m = m_tbl;       // all instances get method table
+  constructor['$==='] = module_eqq;
+  constructor.$to_s = module_to_s;
 
-  prototype._isObject = true;
+  var smethods = constructor._smethods = Module._methods.slice();
+  for (var i = 0, length = smethods.length; i < length; i++) {
+    var m = smethods[i];
+    constructor[m] = Object[m];
+  }
 
-  constructor.$m_ctr  = m_ctr;
-  constructor.$m_tbl  = m_tbl;
+  bridged_classes.push(constructor);
 
-  // FIXME: need c_ctr
-  var c_ctr = function(){};
-  c_ctr.prototype = new superklass.$m.constructor;
+  var allocator = function(initializer) {
+    var result, kls = this, methods = kls._methods, proto = kls.prototype;
 
-  var c_tbl = c_ctr.prototype;
-  c_tbl.constructor = c_ctr;
-  constructor.$m = c_tbl;
+    if (initializer == null) {
+      result = new constructor
+    }
+    else {
+      result = new constructor(initializer);
+    }
 
+    if (kls === constructor) {
+      return result;
+    }
 
-  constructor.$k      = Class;
-  constructor.$s      = superklass;
+    result._klass = kls;
 
-  constructor._donate       = __donate
-  // constructor._included_in  = [];
-  // constructor._isClass      = true;
-  // constructor._super        = superklass;
-  // constructor._methods      = [];
-  constructor._isObject     = false;
-  // constructor._klass        = Class;
-  
-  return constructor;
-};
+    for (var i = 0, length = methods.length; i < length; i++) {
+      var method = methods[i];
+      result[method] = proto[method];
+    }
 
-var boot_module = function(constructor) {
-  // constructor.$m_ctr  = m_ctr;
-  constructor.$m_tbl  = {};     // simple method table for modules
+    return result;
+  };
 
-  // FIXME: need c_ctr
-  var c_ctr = function(){};
-  c_ctr.prototype = new Module.$m.constructor;
-  
-  var c_tbl = c_ctr.prototype;
-  constructor.$m = c_tbl;
+  var table = Object.prototype, methods = Object._methods;
 
+  for (var i = 0, length = methods.length; i < length; i++) {
+    var m = methods[i];
+    constructor.prototype[m] = table[m];
+  }
 
-  constructor.$k      = Class;
+  constructor.$allocate = allocator;
+
+  constructor._smethods.push('$allocate');
 
-  constructor._donate       = __donate
-  // constructor._included_in  = [];
-  // constructor._isClass      = true;
-  // constructor._super        = superklass;
-  // constructor._methods      = [];
-  constructor._isObject     = false;
-  // constructor._klass        = Class;
-  
   return constructor;
 };
 
@@ -331,39 +283,75 @@ boot_defclass('BasicObject', BasicObject);
 boot_defclass('Object', Object, BasicObject);
 boot_defclass('Class', Class, Object);
 
-boot_defmeta(BasicObject, Class.$m_tbl.constructor);
-boot_defmeta(Object, BasicObject.$m.constructor);
-boot_defmeta(Class, Object.$m.constructor);
+Class.prototype = Function.prototype;
+
+BasicObject._klass = Object._klass = Class._klass = Class;
+
+Module._donate = function(defined) {
+  // ...
+};
+
+// Implementation of Module#===
+function module_eqq(object) {
+  if (object == null) {
+    return false;
+  }
+
+  var search = object._klass;
+
+  while (search) {
+    if (search === this) {
+      return true;
+    }
 
-BasicObject.$k = Object.$k = Class.$k = Class;
+    search = search._super;
+  }
+
+  return false;
+}
+
+// Implementation of Module#to_s
+function module_to_s() {
+  return this._name;
+}
 
 // Donator for all 'normal' classes and modules
-function __donate(defined) {
-  var included_in = this.$included_in, m_tbl = this.$m_tbl;
+function __donate(defined, indirect) {
+  var methods = this._methods, included_in = this.$included_in;
+
+  // if (!indirect) {
+    this._methods = methods.concat(defined);
+  // }
 
   if (included_in) {
     for (var i = 0, length = included_in.length; i < length; i++) {
       var includee = included_in[i];
-      var dest = includee.$m_tbl;
+      var dest = includee.prototype;
 
-      for (var idx = 0, jj = defined.length; idx < jj; idx++) {
-        var method = defined[idx];
-        dest[method] = m_tbl[method];
+      for (var j = 0, jj = defined.length; j < jj; j++) {
+        var method = defined[j];
+        dest[method] = this.prototype[method];
       }
 
       if (includee.$included_in) {
-        // includee._donate(defined, true);
+        includee._donate(defined, true);
       }
     }
 
   }
 }
 
+// Donator for singleton (class) methods
+function __sdonate(defined) {
+  this._smethods = this._smethods.concat(defined);
+}
+
 var bridged_classes = Object.$included_in = [];
 BasicObject.$included_in = bridged_classes;
 
 BasicObject._scope = Object._scope = Opal;
 Opal.Module = Opal.Class;
+Opal.Kernel = Object;
 
 var class_const_alloc = function(){};
 var class_const_scope = new TopScope();
@@ -371,7 +359,7 @@ class_const_scope.alloc = class_const_alloc;
 Class._scope = class_const_scope;
 
 Object.prototype.toString = function() {
-  return this.$m.to_s(this, 'to_s');
+  return this.$to_s();
 };
 
 Opal.top = new Object;