opal 0.3.6 → 0.3.9

data/runtime/loader.js

@@ -20,7 +20,7 @@ load_extensions['.rb'] = function(loader, path) {
   @param {String} id lib path/name
   @return {Boolean}
 */
-var load_require = Op.require = Rt.require = function(lib) {
+var rb_require = Op.require = function(lib) {
   var resolved = Op.loader.resolve_lib(lib);
   var cached = Op.cache[resolved];
 
@@ -61,91 +61,94 @@ Op.run = function(body) {
   var res = Qnil;
 
   if (typeof body != 'function') {
-    throw new Error("Expected body to be a function");
+    rb_raise(rb_eException, "Expected body to be a function");
   }
 
-  try {
-    res = body(Rt, Rt.top, "(opal)");
-  }
-  catch (exc) {
-    var exc, stack;
-
-    if (exc && exc['@message']) {
-      puts(exc.$klass.__classid__ + ': ' + exc['@message']);
-    }
-    else {
-      puts('NativeError: ' + exc.message);
-    }
-
-    // first try (if in debug mode...)
-    if (typeof OPAL_DEBUG != 'undefined') {
-      puts(stack);
-      Db.stack = [];
-    }
-    else if (stack = exc.stack) {
-      puts(stack);
-    }
-  }
+  // try {
+    res = body(Rt, rb_top_self, "(opal)");
+  // }
+  // catch (err) {
+    // var stack;
+
+    // if (err.$message) {
+      // puts(err.$k.__classid__ + ': ' + err.$message);
+    // }
+    // else if (err.message) {
+      // puts(err.$k.__classid__ + ': ' + err.message);
+    // }
+    // else {
+      // puts('NativeError: ' + err.message);
+      // console.log(err);
+    // }
+  // }
   return res;
 };
 
 /**
-  Register a lib or gem with the given info. If info is an object then
-  a gem will be registered with the object represented a JSON version
-  of the gemspec for the gem. If the info is simply a function (or
-  string?) then a singular lib will be registerd with the function as
-  its body.
+  Register a simple lib file. This file is simply just put into the lib
+  "directory" so it is ready to load"
 
   @param {String} name The lib/gem name
-  @param {Object, Function} info
+  @param {String, Function} info
 */
-Op.register = function(name, info) {
-  // make sure name is useful
+Op.lib = function(name, info) {
+  // make sure name if useful
   if (typeof name !== 'string') {
-    throw new Error("Cannot register a lib without a proper name");
+    rb_raise(rb_eException, "Cannot register a lib without a proper name");
   }
 
-  // registering a lib/file?
+  // make sure info is useful
   if (typeof info === 'string' || typeof info === 'function') {
-    load_register_lib(name, info);
+    return load_register_lib(name, info);
   }
-  // registering a gem?
-  else if (typeof info === 'object') {
-    load_register_gem(name, info);
+
+  // something went wrong..
+  rb_raise(rb_eException, "Invalid lib data for: " + name);
+};
+
+/**
+  External api for defining a package. This takes an object that defines
+  all the package info and files.
+
+  @param {Object} info Package info
+*/
+Op.package = function(info) {
+  if (typeof info === 'object') {
+    load_register_package(info);
   }
-  // something has gone wrong..
   else {
-    throw new Error("Invalid gem/lib data for '" + name + "'");
+    rb_raise(rb_eException, "Invalid package data");
   }
 };
 
 /**
-  Actually register a predefined gem. This is for the browser context
-  where gems can be serialized into JSON and defined before hand.
+  Actually register a predefined package. This is for the browser context
+  where package can be serialized into JSON and defined before hand.
 
-  @param {String} name Gem name
   @param {Object} info Serialized gemspec
 */
-function load_register_gem(name, info) {
+function load_register_package(info) {
   var factories = Op.loader.factories,
-      paths     = Op.loader.paths;
+      paths     = Op.loader.paths,
+      name      = info.name;
 
   // register all lib files
-  var files = info.files || {};
+  var libs = info.libs || {};
 
   // root dir for gem is '/gem_name'
   var root_dir = '/' + name;
 
   // for now assume './lib' as dir for all libs (should be dynamic..)
-  var lib_dir = './lib';
+  var lib_dir = '/' + name + '/lib/';
 
   // add lib dir to paths
   paths.unshift(fs_expand_path(fs_join(root_dir, lib_dir)));
 
-  for (var file in files) {
-    if (files.hasOwnProperty(file)) {
-      var file_path = fs_expand_path(fs_join(root_dir, file));
-      factories[file_path] = files[file];
+  for (var lib in libs) {
+    if (hasOwnProperty.call(libs, lib)) {
+      var file_path = lib_dir + lib;
+      Op.loader.factories[file_path] = libs[lib];
+      Op.loader.libs[lib] = file_path;
     }
   }
 
@@ -160,8 +163,9 @@ function load_register_gem(name, info) {
   @param {Function, String} factory
 */
 function load_register_lib(name, factory) {
-  var path = '/' + name;
+  var path = '/lib/' + name;
   Op.loader.factories[path] = factory;
+  Op.loader.libs[name] = path;
 }
 
 /**
@@ -179,6 +183,7 @@ function Loader(opal) {
   this.opal = opal;
   this.paths = ['', '/lib'];
   this.factories = {};
+  this.libs = {};
   return this;
 }
 
@@ -215,52 +220,31 @@ Lp.resolve_lib = function(lib) {
   var resolved = this.find_lib(lib, this.paths);
 
   if (!resolved) {
-    throw new Error("LoadError: no such file to load -- " + lib);
+    raise(eLoadError, "no such file to load -- " + lib);
   }
 
   return resolved;
 };
 
-/**
-  Locates the lib/file using the given paths.
-
-  @param {String} lib The lib path/file to look for
-  @param {Array} paths Load paths to use
-  @return {String} Located path
-*/
-Lp.find_lib = function(id, paths) {
-  var extensions = this.valid_extensions, factories = this.factories, candidate;
+Lp.find_lib = function(id) {
+  var libs = this.libs;
+  var id_with_ext = id + '.rb';
 
-  for (var i = 0, ii = extensions.length; i < ii; i++) {
-    for (var j = 0, jj = paths.length; j < jj; j++) {
-      candidate = fs_join(paths[j], id + extensions[i]);
-
-      if (factories[candidate]) {
-        return candidate;
-      }
-    }
+  // try to load a lib path first - i.e. something in our load path
+  if (libs[id_with_ext]) {
+    return libs[id_with_ext];
   }
 
-  // try full path (we try to load absolute path!)
-  if (factories[id]) {
-    return id;
-  }
+  // go through full paths..
 
-  // try full path with each extension
-  for (var i = 0; i < extensions.length; i++) {
-    candidate = id + extensions[i];
-    if (factories[candidate]) {
-      return candidate;
-    }
-  }
-
-  // try each path with no extension (if id already has extension)
-  for (var i = 0; i < paths.length; i++) {
-    candidate = fs_join(paths[j], id);
-
-    if (factories[candidate]) {
-      return candidate;
+  // next, incase our require() has a ruby extension..
+  if (id.lastIndexOf('.rb') == id.length - 3) {
+    // id = id.substr(0, id.length - 3);
+    if (libs[id]) {
+      return libs[id];
     }
+    // if not..
+    // return null;
   }
 
   return null;
@@ -292,7 +276,7 @@ function load_file(loader, path) {
   var ext = load_extensions[PATH_RE.exec(path)[3] || '.js'];
 
   if (!ext) {
-    throw new Error("load_run_file - Bad extension for resolved path");
+    rb_raise(rb_eException, "load_run_file - Bad extension for resolved path");
   }
 
   ext(loader, path);
@@ -310,7 +294,7 @@ function load_file(loader, path) {
   @param {String} path
 */
 function load_execute_file(loader, content, path) {
-  var args = [Rt, top_self, path];
+  var args = [Rt, rb_top_self, path];
 
   if (typeof content === 'function') {
     return content.apply(Op, args);
@@ -320,8 +304,7 @@ function load_execute_file(loader, content, path) {
     return func.apply(Op, args);
 
   } else {
-    throw new Error(
-      "Loader.execute - bad content sent for '" + path + "'");
+    rb_raise(rb_eException, "Loader.execute - bad content for: " + path);
   }
 }
 
@@ -331,8 +314,8 @@ function load_execute_file(loader, content, path) {
   @param {String} id The globals id being retrieved.
   @return {Array} Load paths
 */
-function load_path_getter(id) {
-  return Rt.A(opal.loader.paths);
+function rb_load_path_getter(id) {
+  return Op.loader.paths;
 }
 
 /**
@@ -341,11 +324,7 @@ function load_path_getter(id) {
   @param {String} id Feature global id
   @return {Array} Loaded features
 */
-function loaded_feature_getter(id) {
+function rb_loaded_feature_getter(id) {
   return loaded_features;
 }
 
-function obj_require(obj, path) {
-  return Rt.require(path) ? Qtrue : Qfalse;
-}
-

data/runtime/module.js

@@ -2,49 +2,49 @@
 /**
   Define a top level module with the given id
 */
-function define_module(id) {
-  return define_module_under(cObject, id);
+function rb_define_module(id) {
+  return rb_define_module_under(rb_cObject, id);
 };
 
-function define_module_under(base, id) {
+function rb_define_module_under(base, id) {
   var module;
 
-  if (const_defined(base, id)) {
-    module = const_get(base, id);
-    if (module.$flags & T_MODULE) {
+  if (rb_const_defined(base, id)) {
+    module = rb_const_get(base, id);
+    if (module.$f & T_MODULE) {
       return module;
     }
 
-    throw new Error(id + " is not a module.");
+    rb_raise(rb_eException, id + " is not a module");
   }
 
-  module = define_module_id(id);
+  module = rb_define_module_id(id);
 
-  if (base == cObject) {
-    name_class(module, id);
+  if (base == rb_cObject) {
+    rb_name_class(module, id);
   } else {
-    name_class(module, base.__classid__ + '::' + id);
+    rb_name_class(module, base.__classid__ + '::' + id);
   }
 
-  const_set(base, id, module);
+  rb_const_set(base, id, module);
   module.$parent = base;
   return module;
 };
 
-function define_module_id(id) {
-  var module = class_create(cModule);
-  make_metaclass(module, cModule);
+function rb_define_module_id(id) {
+  var module = rb_class_create(rb_cModule);
+  rb_make_metaclass(module, rb_cModule);
 
-  module.$flags = T_MODULE;
+  module.$f = T_MODULE;
   module.$included_in = [];
   return module;
 };
 
-function mod_create() {
-  return class_boot(cModule);
+function rb_mod_create() {
+  return rb_class_boot(rb_cModule);
 };
 
-function include_module(klass, module) {
+function rb_include_module(klass, module) {
 
   if (!klass.$included_modules) {
     klass.$included_modules = [];
@@ -61,24 +61,21 @@ function include_module(klass, module) {
 
   module.$included_in.push(klass);
 
-  for (var method in module.$method_table) {
-    if (module.$method_table.hasOwnProperty(method)) {
-      define_raw_method(klass, method,
-                        module.$m_tbl[method],
-                        module.$m_tbl['$' + method]);
+  for (var method in module.$m) {
+    if (hasOwnProperty.call(module.$m, method)) {
+      rb_define_raw_method(klass, method,
+                        module.$a.prototype[method]);
     }
   }
 
-  for (var constant in module.$c) {
-    if (module.$c.hasOwnProperty(constant)) {
-      const_set(klass, constant, module.$c[constant]);
-    }
-  }
+  // for (var constant in module.$c) {
+    // if (hasOwnProperty.call(module.$c, constant)) {
+      // const_set(klass, constant, module.$c[constant]);
+    // }
+  // }
 };
 
-Rt.include_module = include_module;
-
-function extend_module(klass, module) {
+function rb_extend_module(klass, module) {
   if (!klass.$extended_modules) {
     klass.$extended_modules = [];
   }
@@ -94,16 +91,13 @@ function extend_module(klass, module) {
 
   module.$extended_in.push(klass);
 
-  var meta = klass.$klass;
+  var meta = klass.$k;
 
-  for (var method in module.$method_table) {
-    if (module.$method_table.hasOwnProperty(method)) {
-      define_raw_method(meta, method,
-                        module.$m_tbl[method],
-                        module.$m_tbl['$' + method]);
+  for (var method in module.o$m) {
+    if (hasOwnProperty.call(module.o$m, method)) {
+      rb_define_raw_method(meta, method,
+                        module.o$a.prototype[method]);
     }
   }
 };
 
-Rt.extend_module = extend_module;
-

data/runtime/post.js

@@ -1,10 +1,10 @@
 
 init();
 
-})();
+})(undefined);
 
 // if in a commonjs system already (node etc), exports become our opal
 // object. Otherwise, in the browser, we just get a top level opal var
 if ((typeof require !== 'undefined') && (typeof module !== 'undefined')) {
-  module.exports = opal;
+  module.exports = opalscript;
 }

data/runtime/pre.js

@@ -1,6 +1,6 @@
 opal = {};
 
-(function() {
+(function(undefined) {
 
 // So we can minimize
 var Op = opal;

data/runtime/runtime.js

@@ -2,56 +2,53 @@
   All methods and properties available to ruby/js sources at runtime. These
   are kept in their own namespace to keep the opal namespace clean.
 */
-Op.runtime = {};
+var Rt = Op.runtime = {};
 
-// for minimizng
-var Rt = Op.runtime;
 Rt.opal = Op;
 
 /**
   Opal platform - this is overriden in gem context and nodejs context. These
   are the default values used in the browser, `opal-browser'.
 */
-Op.platform = {
-  platform: "opal",
-  engine: "opal-browser",
-  version: "1.9.2",
-  argv: []
-};
+var PLATFORM_PLATFORM = "opal";
+var PLATFORM_ENGINE   = "opal-browser";
+var PLATFORM_VERSION  = "1.9.2";
+var PLATFORM_ARGV     = [];
+
+// Minimize js types
+var ArrayProto     = Array.prototype,
+    ObjectProto    = Object.prototype,
+
+    ArraySlice     = ArrayProto.slice,
+
+    hasOwnProperty = ObjectProto.hasOwnProperty;
 
 /**
   Core runtime classes, objects and literals.
 */
-var cBasicObject,     cObject,          cModule,          cClass,
-    mKernel,          cNilClass,        cTrueClass,       cFalseClass,
-    cArray,
-    cRegexp,          cMatch,           top_self,            Qnil,
-    Qfalse,           Qtrue,
+var rb_cBasirb_cObject,     rb_cObject,          rb_cModule,          rb_cClass,
+    rb_mKernel,          rb_cNilClass,        rb_cBoolean,
+    rb_cArray,           rb_cNumeric,
+    rb_cRegexp,          rb_cMatch,           rb_top_self,            Qnil,
 
-    cDir;
+    rb_cDir;
 
 /**
   Core object type flags. Added as local variables, and onto runtime.
 */
-var T_CLASS       = Rt.T_CLASS       = 1,
-    T_MODULE      = Rt.T_MODULE      = 2,
-    T_OBJECT      = Rt.T_OBJECT      = 4,
-    T_BOOLEAN     = Rt.T_BOOLEAN     = 8,
-    T_STRING      = Rt.T_STRING      = 16,
-    T_ARRAY       = Rt.T_ARRAY       = 32,
-    T_NUMBER      = Rt.T_NUMBER      = 64,
-    T_PROC        = Rt.T_PROC        = 128,
-    T_SYMBOL      = Rt.T_SYMBOL      = 256,
-    T_HASH        = Rt.T_HASH        = 512,
-    T_RANGE       = Rt.T_RANGE       = 1024,
-    T_ICLASS      = Rt.T_ICLASS      = 2056,
-    FL_SINGLETON  = Rt.FL_SINGLETON  = 4112;
-
-/**
-  Method visibility modes
- */
-var FL_PUBLIC  = 0,
-    FL_PRIVATE = 1;
+var T_CLASS       = 1,
+    T_MODULE      = 2,
+    T_OBJECT      = 4,
+    T_BOOLEAN     = 8,
+    T_STRING      = 16,
+    T_ARRAY       = 32,
+    T_NUMBER      = 64,
+    T_PROC        = 128,
+    T_SYMBOL      = 256,
+    T_HASH        = 512,
+    T_RANGE       = 1024,
+    T_ICLASS      = 2056,
+    FL_SINGLETON  = 4112;
 
 /**
   Define classes. This is the public API for defining classes, shift classes
@@ -68,35 +65,32 @@ Rt.dc = function(base, super_class, id, body, flag) {
 
   switch (flag) {
     case 0:
-      if (base.$flags & T_OBJECT) {
-        base = class_real(base.$klass);
+      if (base.$f & T_OBJECT) {
+        base = rb_class_real(base.$k);
       }
 
       if (super_class == Qnil) {
-        super_class = cObject;
+        super_class = rb_cObject;
       }
 
-      klass = define_class_under(base, id, super_class);
+      klass = rb_define_class_under(base, id, super_class);
       break;
 
     case 1:
-      klass = singleton_class(base);
+      klass = rb_singleton_class(base);
       break;
 
     case 2:
-      if (base.$flags & T_OBJECT) {
-        base = class_real(base.$klass);
+      if (base.$f & T_OBJECT) {
+        base = rb_class_real(base.$k);
       }
-      klass = define_module_under(base, id);
+      klass = rb_define_module_under(base, id);
       break;
 
     default:
-      raise(eException, "define_class got a unknown flag " + flag);
+      rb_raise(rb_eException, "define_class got a unknown flag " + flag);
   }
 
-  // when reopening a class always set it back to public
-  klass.$mode = FL_PUBLIC;
-
   var res = body(klass);
 
   return res;
@@ -117,79 +111,38 @@ Rt.um = function(kls) {
   for (var i = 0, ii = args.length; i < ii; i++) {
     (function(mid) {
       var func = function() {
-        raise(eNoMethodError, "undefined method `" + mid + "' for " + this.m$inspect());
+        rb_raise(rb_eNoMethodError, "undefined method `" + mid + "' for " + this.m$inspect());
       };
 
-      kls.allocator.prototype['m$' + mid] = func;
+      kls.o$a.prototype['m$' + mid] = func;
 
-      if (kls.$bridge_prototype) {
-        kls.$bridge_prototype['m$' + mid] = func;
-      }
     })(args[i].m$to_s());
   }
 
   return Qnil;
 };
 
-/**
-  Method missing support - used in debug mode (opt in).
-*/
-Rt.mm = function(method_ids) {
-  var prototype = cBasicObject.$m_tbl;
-
-  for (var i = 0, ii = method_ids.length; i < ii; i++) {
-    var mid = method_ids[i];
-
-    if (!prototype[mid]) {
-      var imp = (function(mid, method_id) {
-        return function(self) {
-          var args = [].slice.call(arguments, 0);
-          args.unshift(intern(method_id));
-          args.unshift(self);
-          return self.$m.method_missing.apply(null, args);
-        };
-      })(mid, method_ids[i]);
-
-      imp.$rbMM = true;
-
-      prototype[mid] = prototype['$' + mid] = imp;
-    }
-  }
-};
-
 /**
   Define methods. Public method for defining a method on the given base.
 
   @param {Object} klass The base to define method on
   @param {String} name Ruby mid
-  @param {Function} public_body The method implementation
+  @param {Function} body The method implementation
   @param {Number} arity Method arity
   @return {Qnil}
 */
-Rt.dm = function(klass, name, public_body, arity) {
-  if (klass.$flags & T_OBJECT) {
-    klass = klass.$klass;
+Rt.dm = function(klass, name, body, arity) {
+  if (klass.$f & T_OBJECT) {
+    klass = klass.$k;
   }
 
-  var mode = klass.$mode;
-  var private_body = public_body;
-
-  if (mode == FL_PRIVATE) {
-    public_body = function() {
-      raise(eNoMethodError, "private method `" + name +
-        "' called for " + this.$m$inspect());
-    };
-    public_body.$arity = -1;
+  if (!body.$rbName) {
+    body.$rbName = name;
+    body.$arity = arity;
   }
 
-  if (!private_body.$rbName) {
-    private_body.$rbName = name;
-    private_body.$rbArity = arity;
-  }
-
-  // FIXME: add to private/public methods
-  // klass.$methods.push(intern(name));
-  define_raw_method(klass, name, private_body, public_body);
+  rb_define_raw_method(klass, 'm$' + name, body);
+  klass.$methods.push(name);
 
   return Qnil;
 };
@@ -204,7 +157,7 @@ Rt.dm = function(klass, name, public_body, arity) {
   @return {Qnil}
 */
 Rt.ds = function(base, method_id, body, arity) {
-  return Rt.dm(singleton_class(base), method_id, body);
+  return Rt.dm(rb_singleton_class(base), method_id, body);
 };
 
 /**
@@ -215,44 +168,45 @@ Rt.ds = function(base, method_id, body, arity) {
   This is actually done in super_find.
 */
 Rt.S = function(callee, self, args) {
-  var mid = callee.$rbName;
-  var func = super_find(self.$klass, callee, mid);
+  var mid = 'm$' + callee.$rbName;
+  var func = rb_super_find(self.$k, callee, mid);
 
   if (!func) {
-    raise(eNoMethodError, "super: no super class method `" + mid + "`" +
+    rb_raise(rb_eNoMethodError, "super: no super class method `" + mid + "`" +
       " for " + self.m$inspect());
   }
 
-  var args_to_send = [self].concat(args);
+  // var args_to_send = [self].concat(args);
+  var args_to_send = [].concat(args);
   return func.apply(self, args_to_send);
 };
 
 /**
   Actually find super impl to call.  Returns null if cannot find it.
 */
-function super_find(klass, callee, mid) {
+function rb_super_find(klass, callee, mid) {
   var cur_method;
 
   while (klass) {
-    if (klass.$m_tbl[mid]) {
-      if (klass.$m_tbl[mid] == callee) {
-        cur_method = klass.$m_tbl[mid];
+    if (klass.$m[mid]) {
+      if (klass.$m[mid] == callee) {
+        cur_method = klass.$m[mid];
         break;
       }
     }
-    klass = klass.$super;
+    klass = klass.$s;
   }
 
   if (!(klass && cur_method)) { return null; }
 
-  klass = klass.$super;
+  klass = klass.$s;
 
   while (klass) {
-    if (klass.$m_tbl[mid]) {
-      return klass.$m_tbl[mid];
+    if (klass.$m[mid]) {
+      return klass.$m[mid];
     }
 
-    klass = klass.$super;
+    klass = klass.$s;
   }
 
   return null;
@@ -262,19 +216,19 @@ function super_find(klass, callee, mid) {
   Exception classes. Some of these are used by runtime so they are here for
   convenience.
 */
-var eException,       eStandardError,   eLocalJumpError,  eNameError,
-    eNoMethodError,   eArgError,        eScriptError,     eLoadError,
-    eRuntimeError,    eTypeError,       eIndexError,      eKeyError,
-    eRangeError;
+var rb_eException,       rb_eStandardError,   rb_eLocalJumpError,  rb_eNameError,
+    rb_eNoMethodError,   rb_eArgError,        rb_eScriptError,     rb_eLoadError,
+    rb_eRuntimeError,    rb_eTypeError,       rb_eIndexError,      rb_eKeyError,
+    rb_eRangeError;
 
-var eExceptionInstance;
+var rb_eExceptionInstance;
 
 /**
   Standard jump exceptions to save re-creating them everytime they are needed
 */
-var eReturnInstance,
-    eBreakInstance,
-    eNextInstance;
+var rb_eReturnInstance,
+    rb_eBreakInstance,
+    rb_eNextInstance;
 
 /**
   Ruby break statement with the given value. When no break value is needed, nil
@@ -284,8 +238,8 @@ var eReturnInstance,
   @param {RubyObject} value The break value.
 */
 Rt.B = function(value) {
-  eBreakInstance.$value = value;
-  raise_exc(eBreakInstance);
+  rb_eBreakInstance.$value = value;
+  rb_raise_exc(rb_eBreakInstance);
 };
 
 /**
@@ -293,53 +247,70 @@ Rt.B = function(value) {
   represents the method that this statement must return from.
 */
 Rt.R = function(value, func) {
-  eReturnInstance.$value = value;
-  eReturnInstance.$func = func;
-  throw eReturnInstance;
+  rb_eReturnInstance.$value = value;
+  rb_eReturnInstance.$func = func;
+  throw rb_eReturnInstance;
 };
 
 /**
   Get the given constant name from the given base
 */
 Rt.cg = function(base, id) {
-  if (base.$flags & T_OBJECT) {
-    base = class_real(base.$klass);
+  if (base.$f & T_OBJECT) {
+    base = rb_class_real(base.$k);
   }
-  return const_get(base, id);
+  return rb_const_get(base, id);
 };
 
 /**
   Set constant from runtime
 */
 Rt.cs = function(base, id, val) {
-  if (base.$flags & T_OBJECT) {
-    base = class_real(base.$klass);
+  if (base.$f & T_OBJECT) {
+    base = rb_class_real(base.$k);
   }
-  return const_set(base, id, val);
+  return rb_const_set(base, id, val);
 };
 
 /**
   Get global by id
 */
 Rt.gg = function(id) {
-  return gvar_get(id);
+  return rb_gvar_get(id);
 };
 
 /**
   Set global by id
 */
 Rt.gs = function(id, value) {
-  return gvar_set(id, value);
+  return rb_gvar_set(id, value);
+};
+
+/**
+  Class variables table
+*/
+var rb_class_variables = {};
+
+Rt.cvg = function(id) {
+  var v = rb_class_variables[id];
+
+  if (v) return v;
+
+  return Qnil;
+};
+
+Rt.cvs = function(id, val) {
+  return rb_class_variables[id] = val;
 };
 
-function regexp_match_getter(id) {
+function rb_regexp_match_getter(id) {
   var matched = Rt.X;
 
   if (matched) {
     if (matched.$md) {
       return matched.$md;
     } else {
-      var res = new cMatch.allocator();
+      var res = new cMatch.o$a();
       res.$data = matched;
       matched.$md = res;
       return res;
@@ -349,3 +320,26 @@ function regexp_match_getter(id) {
   }
 }
 
+/**
+  An array of procs to call for at_exit()
+
+  @param {Function} proc implementation
+*/
+var rb_end_procs = [];
+
+/**
+  Called upon exit: we need to run all of our registered procs
+  in reverse order: i.e. call last ones first.
+
+  FIXME: do we need to try/catch this??
+*/
+Rt.do_at_exit = function() {
+  var proc;
+
+  while (proc = rb_end_procs.pop()) {
+    proc.call(proc.$self);
+  }
+
+  return null;
+};
+