opal 0.3.6 → 0.3.9

data/runtime/fs.js

@@ -102,7 +102,7 @@ Fs.extname = function(file_name) {
 };
 
 Fs.exist_p = function(path) {
-  return opal.loader.factories[file_expand_path(path)] ? true : false;
+  return Op.loader.factories[fs_expand_path(path)] ? true : false;
 };
 
 /**
@@ -135,7 +135,7 @@ Fs.glob = function() {
 */
 function fs_glob_to_regexp(glob) {
   if (typeof glob !== 'string') {
-    throw new Error("file_glob_to_regexp: glob must be a string");
+    raise(eException, "file_glob_to_regexp: glob must be a string");
   }
 
   // make sure absolute

data/runtime/init.js

@@ -7,9 +7,8 @@
   @param {Object} val
   @return {Object} returns the set value
 */
-function const_set(klass, id, val) {
-  klass.$c_prototype[id] = val;
-  klass.$const_table[id] = val;
+function rb_const_set(klass, id, val) {
+  klass.$c[id] = val;
   return val;
 }
 
@@ -20,15 +19,14 @@ function const_set(klass, id, val) {
   @param {RClass} klass
   @param {String} id
 */
-function const_get(klass, id) {
+function rb_const_get(klass, id) {
   if (klass.$c[id]) {
     return (klass.$c[id]);
   }
 
   var parent = klass.$parent;
 
-  while (parent && parent != cObject) {
-  // while (parent) {
+  while (parent) {
     if (parent.$c[id] !== undefined) {
       return parent.$c[id];
     }
@@ -36,10 +34,10 @@ function const_get(klass, id) {
     parent = parent.$parent;
   }
 
-  raise(eNameError, 'uninitialized constant ' + id);
+  rb_raise(rb_eNameError, 'uninitialized constant ' + id);
 };
 
-Rt.const_get = const_get;
+Rt.const_get = rb_const_get;
 
 /**
   Returns true or false depending whether a constant named `id` is defined
@@ -49,7 +47,7 @@ Rt.const_get = const_get;
   @param {String} id
   @return {true, false}
 */
-function const_defined(klass, id) {
+function rb_const_defined(klass, id) {
   if (klass.$c[id]) {
     return true;
   }
@@ -68,7 +66,7 @@ function const_defined(klass, id) {
     - getter
     - setter
 */
-var global_tbl = {};
+var rb_global_tbl = {};
 
 /**
   Defines a hooked/global variable.
@@ -78,7 +76,7 @@ var global_tbl = {};
   @param {Function} setter The setter function used for setting the var
   @return {null}
 */
-function define_hooked_variable(name, getter, setter) {
+function rb_define_hooked_variable(name, getter, setter) {
   var entry = {
     "name": name,
     "value": Qnil,
@@ -86,7 +84,7 @@ function define_hooked_variable(name, getter, setter) {
     "setter": setter
   };
 
-  global_tbl[name] = entry;
+  rb_global_tbl[name] = entry;
 };
 
 /**
@@ -94,15 +92,15 @@ function define_hooked_variable(name, getter, setter) {
   name error with the given id. This can be used for variables that should
   not be altered.
 */
-function gvar_readonly_setter(id, value) {
-  raise(eNameError, id + " is a read-only variable");
+function rb_gvar_readonly_setter(id, value) {
+  rb_raise(rb_eNameError, id + " is a read-only variable");
 };
 
 /**
   Retrieve a global variable. This will use the assigned getter.
 */
-function gvar_get(id) {
-  var entry = global_tbl[id];
+function rb_gvar_get(id) {
+  var entry = rb_global_tbl[id];
   if (!entry) { return Qnil; }
   return entry.getter(id);
 };
@@ -110,67 +108,67 @@ function gvar_get(id) {
 /**
   Set a global. If not already set, then we assign basic getters and setters.
 */
-function gvar_set(id, value) {
-  var entry = global_tbl[id];
+function rb_gvar_set(id, value) {
+  var entry = rb_global_tbl[id];
   if (entry)  { return entry.setter(id, value); }
 
-  define_hooked_variable(id,
+  rb_define_hooked_variable(id,
 
     function(id) {
-      return global_tbl[id].value;
+      return rb_global_tbl[id].value;
     },
 
     function(id, value) {
-      return (global_tbl[id].value = value);
+      return (rb_global_tbl[id].value = value);
     }
   );
 
-  return gvar_set(id, value);
+  return rb_gvar_set(id, value);
 };
 
 /**
   Every object has a unique id. This count is used as the next id for the
   next created object. Therefore, first ruby object has id 0, next has 1 etc.
 */
-var hash_yield = 0;
+var rb_hash_yield = 0;
 
 /**
   Yield the next object id, updating the count, and returning it.
 */
-function yield_hash() {
-  return hash_yield++;
+function rb_yield_hash() {
+  return rb_hash_yield++;
 };
 
-var cHash;
+var rb_cHash;
 
 /**
   Returns a new hash with values passed from the runtime.
 */
 Rt.H = function() {
-  var hash = new RObject(cHash), k, v, args = [].slice.call(arguments);
-  hash.$keys = [];
-  hash.$assocs = {};
-  hash.$default = Qnil;
+  var hash = new rb_cHash.$a(), k, v, args = Array.prototype.slice.call(arguments);
+  var keys = hash.k = [];
+  var assocs = hash.a = {};
+  hash.d = Qnil;
 
   for (var i = 0, ii = args.length; i < ii; i++) {
     k = args[i];
     v = args[i + 1];
     i++;
-    hash.$keys.push(k);
-    hash.$assocs[k.$hash()] = v;
+    keys.push(k);
+    assocs[k.$h()] = v;
   }
 
   return hash;
 };
 
-var alias_method = Rt.alias_method = function(klass, new_name, old_name) {
-  var body = klass.$m_tbl[old_name];
+var rb_alias_method = Rt.alias_method = function(klass, new_name, old_name) {
+  var body = klass.$a.prototype['m$' + old_name];
 
   if (!body) {
-    throw new Error("NameError: undefined method `" + old_name + "' for class `" + klass.__classid__ + "'");
+    rb_raise(rb_eNameError, "undefined method `" + old_name + "' for class `" + klass.__classid__ + "'");
   }
 
-  define_raw_method(klass, new_name, body, body);
+  rb_define_raw_method(klass, 'm$' + new_name, body);
   return Qnil;
 };
 
@@ -179,13 +177,10 @@ var alias_method = Rt.alias_method = function(klass, new_name, old_name) {
   singleton_method_added etc. define_method does that.
 
 */
-function define_raw_method(klass, private_name, private_body, public_body) {
-  var public_name = '$' + private_name;
+function rb_define_raw_method(klass, name, body) {
 
-  klass.$m_tbl[private_name] = private_body;
-  klass.$m_tbl[public_name] = public_body;
-
-  klass.$method_table[private_name] = private_body;
+  klass.$a.prototype[name] = body;
+  klass.$m[name] = body;
 
   var included_in = klass.$included_in, includee;
 
@@ -193,144 +188,162 @@ function define_raw_method(klass, private_name, private_body, public_body) {
     for (var i = 0, ii = included_in.length; i < ii; i++) {
       includee = included_in[i];
 
-      define_raw_method(includee, private_name, private_body, public_body);
+      rb_define_raw_method(includee, name, body);
     }
   }
-};
-
-Rt.private_methods = function(klass, args) {
-  return;
-
-  if (args.length) {
-    var proto = klass.allocator.prototype;
 
-    for (var i = 0, ii = args.length; i < ii; i++) {
-      var arg = args[i].$m$to_s(), mid = 'm$' + arg;
-
-      // If method doesn't exist throw an error. Also check that if it
-      // does exist that it isnt just a method missing implementation.
-      if (!proto[mid] || proto[mid].$rbMM) {
-        raise(eNameError, "undefined method `" + arg +
-              "' for class `" + klass.__classid__ + "'");
-      }
+  // This class is toll free bridged, so add method to native
+  // prototype as well
+  if (klass.$bridge_prototype) {
+    klass.$bridge_prototype[name] = body;
+  }
 
-      // Set the public implementation to a function that just throws
-      // and error when called
-      klass.allocator.prototype[mid] = function() {
-        raise(eNoMethodError, "private method `" + arg + "' called for " +
-              this.$m$inspect());
-      }
+  // If we are dealing with Object, then we need to donate to
+  // all of our bridged prototypes as well.
+  if (klass === rb_cObject) {
+    var bridged = rb_bridged_classes;
 
-      // If this method is in the method_table then we must also set that.
-      // If not then we inherited this method from further up the chain,
-      // so we do not set it in our method table.
-      if (klass.$method_table[mid]) {
-        // set
+    for (var i = 0, ii = bridged.length; i < ii; i++) {
+      // do not overwrite bridged methods' implementation
+      if (!bridged[i][name]) {
+        bridged[i][name] = body;
       }
     }
   }
-  else {
-    // no args - set klass mode to private
-    klass.$mode = FL_PRIVATE;
-  }
 };
 
-function define_alias(base, new_name, old_name) {
-  define_method(base, new_name, base.$m_tbl[old_name]);
+function rb_define_alias(base, new_name, old_name) {
+  rb_define_method(base, new_name, base.$m_tbl[old_name]);
   return Qnil;
 };
 
-function obj_alloc(klass) {
-  var result = new RObject(klass);
-  return result;
-};
-
 /**
   Raise the exception class with the given string message.
 */
-function raise(exc, str) {
+function rb_raise(exc, str) {
   if (str === undefined) {
     str = exc;
-    exc = eException;
+    exc = rb_eException;
   }
 
-  var exception = exc.$m['new'](exc, str);
-  raise_exc(exception);
+  var exception = exc.m$new(str);
+  rb_raise_exc(exception);
 };
 
-Rt.raise = raise;
+Rt.raise = rb_raise;
 
 /**
   Raise an exception instance (DO NOT pass strings to this)
 */
-function raise_exc(exc) {
+function rb_raise_exc(exc) {
   throw exc;
 };
 
-Rt.raise_exc = raise_exc;
+var rb_cString;
 
-var cString, cSymbol;
 
 /**
-  Returns a new ruby symbol with the given intern value. Symbols are made
-  using the new String() constructor, and just have its klass and method
-  table reassigned. This makes dealing with strings/symbols internally
-  easier as both can be used as a string within opal.
+  Exception classes. Some of these are used by runtime so they are here for
+  convenience.
+*/
+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 rb_eExceptionInstance;
 
-  @param {String} intern Symbol value
-  @return {RSymbol} symbol
+/**
+  Standard jump exceptions to save re-creating them everytime they are needed
 */
-var intern = Rt.Y = function(intern) {
-  if (symbol_table.hasOwnProperty(intern)) {
-    return symbol_table[intern];
-  }
+var rb_eReturnInstance,
+    rb_eBreakInstance,
+    rb_eNextInstance;
+
+/**
+  Ruby break statement with the given value. When no break value is needed, nil
+  should be passed here. An undefined/null value is not valid and will cause an
+  internal error.
 
-  var res = new String(intern);
-  res.$klass = cSymbol;
-  res.$m = cSymbol.$m_tbl;
-  res.$flags = T_OBJECT | T_SYMBOL;
-  symbol_table[intern] = res;
-  return res;
+  @param {RubyObject} value The break value.
+*/
+Rt.B = function(value) {
+  rb_eBreakInstance.$value = value;
+  rb_raise_exc(eBreakInstance);
 };
 
+/**
+  Ruby return, with the given value. The func is the reference function which
+  represents the method that this statement must return from.
+*/
+Rt.R = function(value, func) {
+  rb_eReturnInstance.$value = value;
+  rb_eReturnInstance.$func = func;
+  throw rb_eReturnInstance;
+};
 
-var cIO, stdin, stdout, stderr;
+/**
+  Get global by id
+*/
+Rt.gg = function(id) {
+  return rb_gvar_get(id);
+};
 
-function stdio_getter(id) {
+/**
+  Set global by id
+*/
+Rt.gs = function(id, value) {
+  return rb_gvar_set(id, value);
+};
+
+function rb_regexp_match_getter(id) {
+  var matched = Rt.X;
+
+  if (matched) {
+    if (matched.$md) {
+      return matched.$md;
+    } else {
+      var res = new rb_cMatch.o$a();
+      res.$data = matched;
+      matched.$md = res;
+      return res;
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+var rb_cIO, rb_stdin, rb_stdout, rb_stderr;
+
+function rb_stdio_getter(id) {
   switch (id) {
     case "$stdout":
-      return stdout;
+      return rb_stdout;
     case "$stdin":
-      return stdin;
+      return rb_stdin;
     case "$stderr":
-      return stderr;
+      return rb_stderr;
     default:
-      raise(eRuntimeError, "stdout_setter being used for bad variable");
+      rb_raise(rb_eRuntimeError, "stdout_setter being used for bad variable");
   }
 };
 
-function stdio_setter(id, value) {
-  raise(eException, "stdio_setter cannot currently set stdio variables");
+function rb_stdio_setter(id, value) {
+  rb_raise(rb_eException, "stdio_setter cannot currently set stdio variables");
 
   switch (id) {
     case "$stdout":
-      return stdout = value;
+      return rb_stdout = value;
     case "$stdin":
-      return stdin = value;
+      return rb_stdin = value;
     case "$stderr":
-      return stderr = value;
+      return rb_stderr = value;
     default:
-      raise(eRuntimeError, "stdout_setter being used for bad variable: " + id);
+      rb_raise(rb_eRuntimeError, "stdout_setter being used for bad variable: " + id);
   }
 };
 
-Rt.re = function(re) {
-  var regexp = new cRegexp.allocator();
-  regexp.$re = re;
-  return regexp;
-};
-
-var cProc;
+var rb_cProc;
 
 /**
   Block passing - holds current block for runtime
@@ -339,15 +352,15 @@ var cProc;
   p: proc
   y: yield error
 */
-var block = Rt.P = {
+var rb_block = Rt.P = {
   f: null,
   p: null,
   y: function() {
-    throw new Error("LocalJumpError - no block given");
+    rb_raise(rb_eLocalJumpError, "no block given");
   }
 };
 
-block.y.$proc = [block.y];
+rb_block.y.$self = rb_block.y;
 
 /**
   Turns the given proc/function into a lambda. This is useful for the
@@ -371,7 +384,7 @@ block.y.$proc = [block.y];
   @param {Function} proc The proc/function to lambdafy.
   @return {Function} Wrapped lambda function.
 */
-Rt.lambda = function(proc) {
+function rb_make_lambda(proc) {
   if (proc.$lambda) return proc;
 
   var wrap = function() {
@@ -380,30 +393,28 @@ Rt.lambda = function(proc) {
   };
 
   wrap.$lambda = true;
-  wrap.$proc = proc.$proc;
+  wrap.o$s = proc.o$s;
 
-  return Rt.proc(wrap);
+  return proc;
 };
 
-var cRange;
+var rb_cRange;
 
 /**
   Returns a new ruby range. G for ranGe.
 */
 Rt.G = function(beg, end, exc) {
-  var range = new RObject(cRange, T_OBJECT);
-  range.$beg = beg;
-  range.$end = end;
-  range.$exc = exc;
+  var range = rb_obj_alloc(cRange);
+  range.beg = beg;
+  range.end = end;
+  range.exc = exc;
   return range;
 };
 
-Rt.A = function(objs) {
-  var arr = new cArray.allocator();
-  arr.splice.apply(arr, [0, 0].concat(objs));
-  return arr;
-};
-
+/**
+  Print to console - this is overriden upon init so that it will print to
+  stdout
+*/
 var puts = function(str) {
   console.log(str);
 };
@@ -413,146 +424,133 @@ var puts = function(str) {
   all the core objects and classes and required runtime features.
 */
 function init() {
-  if (typeof OPAL_DEBUG != "undefined" && OPAL_DEBUG) {
-    init_debug();
-  }
-
   var metaclass;
 
-  Rt.BasicObject = cBasicObject = boot_defrootclass('BasicObject');
-  Rt.Object = cObject = boot_defclass('Object', cBasicObject);
-  Rt.Module = cModule = boot_defclass('Module', cObject);
-  Rt.Class = cClass = boot_defclass('Class', cModule);
-
-  const_set(cObject, 'BasicObject', cBasicObject);
-
-  metaclass = make_metaclass(cBasicObject, cClass);
-  metaclass = make_metaclass(cObject, metaclass);
-  metaclass = make_metaclass(cModule, metaclass);
-  metaclass = make_metaclass(cClass, metaclass);
-
-  boot_defmetametaclass(cModule, metaclass);
-  boot_defmetametaclass(cObject, metaclass);
-  boot_defmetametaclass(cBasicObject, metaclass);
+  // The *instances* of core objects..
+  rb_boot_Object = rb_boot_defclass('Object');
+  rb_boot_Module = rb_boot_defclass('Module', rb_boot_Object);
+  rb_boot_Class  = rb_boot_defclass('Class', rb_boot_Module);
 
-  mKernel = Rt.Kernel = define_module('Kernel');
+  // The *classes* of core objects..
+  rb_cObject = rb_boot_makemeta('Object', rb_boot_Object, rb_boot_Class);
+  rb_cModule = rb_boot_makemeta('Module', rb_boot_Module, rb_cObject.constructor);
+  rb_cClass  = rb_boot_makemeta('Class', rb_boot_Class, rb_cModule.constructor);
 
-  top_self = obj_alloc(cObject);
-  Rt.top = top_self;
+  rb_boot_defmetameta(rb_cObject, rb_cClass);
+  rb_boot_defmetameta(rb_cModule, rb_cClass);
+  rb_boot_defmetameta(rb_cClass, rb_cClass);
 
-  cNilClass = define_class('NilClass', cObject);
-  Rt.Qnil = Qnil = obj_alloc(cNilClass);
-  Qnil.$r = false;
+  // fix superclasses..
+  rb_cObject.$s = null;
+  rb_cModule.$s = rb_cObject;
+  rb_cClass.$s  = rb_cModule;
 
-  cTrueClass = define_class('TrueClass', cObject);
-  Rt.Qtrue = Qtrue = obj_alloc(cTrueClass);
+  rb_const_set(rb_cObject, 'Object', rb_cObject);
+  rb_const_set(rb_cObject, 'Module', rb_cModule);
+  rb_const_set(rb_cObject, 'Class', rb_cClass);
 
-  cFalseClass = define_class('FalseClass', cObject);
-  Rt.Qfalse = Qfalse = obj_alloc(cFalseClass);
-  Qfalse.$r = false;
+  rb_mKernel      = rb_define_module('Kernel');
 
-  cArray = bridge_class(Array.prototype,
-    T_OBJECT | T_ARRAY, 'Array', cObject);
+  rb_top_self     = new rb_cObject.$a();
+  Rt.top          = rb_top_self;
 
-  Function.prototype.$hash = function() {
-    return this.$id || (this.$id = yield_hash());
+  rb_cNilClass = rb_define_class('NilClass', rb_cObject);
+  Rt.Qnil = Qnil = new rb_cNilClass.$a();
+  Qnil.toString = function() {
+    return "nil";
   };
 
-  cHash = define_class('Hash', cObject);
+  rb_cBoolean = rb_bridge_class(Boolean.prototype, T_OBJECT, 'Boolean', rb_cObject);
 
-  cNumeric = bridge_class(Number.prototype,
-    T_OBJECT | T_NUMBER, 'Numeric', cObject);
+  rb_cArray = rb_bridge_class(Array.prototype, T_OBJECT | T_ARRAY, 'Array', rb_cObject);
+  // array instances all get standard properties for subclasses to work
+  var ary_proto = Array.prototype, ary_inst = rb_cArray.$a.prototype;
+  ary_inst.$f      = T_ARRAY | T_OBJECT;
+  ary_inst.push    = ary_proto.push;
+  ary_inst.pop     = ary_proto.pop;
+  ary_inst.slice   = ary_proto.slice;
+  ary_inst.splice  = ary_proto.splice;
+  ary_inst.concat  = ary_proto.concat;
+  ary_inst.shift   = ary_proto.shift;
+  ary_inst.unshift = ary_proto.unshift;
+  ary_inst.length  = 0;
 
-  cString = bridge_class(String.prototype,
-    T_OBJECT | T_STRING, 'String', cObject);
+  rb_cHash = rb_define_class('Hash', rb_cObject);
 
-  cSymbol = define_class('Symbol', cObject);
+  rb_cNumeric = rb_bridge_class(Number.prototype,
+    T_OBJECT | T_NUMBER, 'Numeric', rb_cObject);
 
-  cProc = bridge_class(Function.prototype,
-    T_OBJECT | T_PROC, 'Proc', cObject);
+  rb_cString = rb_bridge_class(String.prototype,
+    T_OBJECT | T_STRING, 'String', rb_cObject);
 
-  Function.prototype.$hash = function() {
-    return this.$id || (this.$id = yield_hash());
-  };
-
-  cRange = define_class('Range', cObject);
+  rb_cProc = rb_bridge_class(Function.prototype,
+    T_OBJECT | T_PROC, 'Proc', rb_cObject);
 
-  cRegexp = bridge_class(RegExp.prototype,
-    T_OBJECT, 'Regexp', cObject);
+  rb_cRange = rb_define_class('Range', rb_cObject);
 
-  cMatch = define_class('MatchData', cObject);
-  define_hooked_variable('$~', regexp_match_getter, gvar_readonly_setter);
+  rb_cRegexp = rb_bridge_class(RegExp.prototype,
+    T_OBJECT, 'Regexp', rb_cObject);
 
-  eException = bridge_class(Error.prototype, T_OBJECT, 'Exception', cObject);
+  rb_cMatch = rb_define_class('MatchData', rb_cObject);
+  rb_define_hooked_variable('$~', rb_regexp_match_getter, rb_gvar_readonly_setter);
 
-  eStandardError = define_class("StandardError", eException);
-  eRuntimeError = define_class("RuntimeError", eException);
-  eLocalJumpError = define_class("LocalJumpError", eStandardError);
-  Rt.TypeError = eTypeError = define_class("TypeError", eStandardError);
+  rb_eException = rb_bridge_class(Error.prototype,
+    T_OBJECT, 'Exception', rb_cObject);
 
-  eNameError = define_class("NameError", eStandardError);
-  eNoMethodError = define_class('NoMethodError', eNameError);
-  eArgError = define_class('ArgumentError', eStandardError);
+  rb_eStandardError = rb_define_class("StandardError", rb_eException);
+  rb_eRuntimeError = rb_define_class("RuntimeError", rb_eException);
+  rb_eLocalJumpError = rb_define_class("LocalJumpError", rb_eStandardError);
+  rb_eTypeError = rb_define_class("TypeError", rb_eStandardError);
 
-  eScriptError = define_class('ScriptError', eException);
-  eLoadError = define_class('LoadError', eScriptError);
+  rb_eNameError = rb_define_class("NameError", rb_eStandardError);
+  rb_eNoMethodError = rb_define_class('NoMethodError', rb_eNameError);
+  rb_eArgError = rb_define_class('ArgumentError', rb_eStandardError);
 
-  eIndexError = define_class("IndexError", eStandardError);
-  eKeyError = define_class("KeyError", eIndexError);
-  eRangeError = define_class("RangeError", eStandardError);
+  rb_eScriptError = rb_define_class('ScriptError', rb_eException);
+  rb_eLoadError = rb_define_class('LoadError', rb_eScriptError);
 
-  eBreakInstance = new Error();
-  eBreakInstance['@message'] = "unexpected break";
-  block.b = eBreakInstance;
-  // dont need this anymore???
-  eBreakInstance.$keyword = 2;
+  rb_eIndexError = rb_define_class("IndexError", rb_eStandardError);
+  rb_eKeyError = rb_define_class("KeyError", rb_eIndexError);
+  rb_eRangeError = rb_define_class("RangeError", rb_eStandardError);
 
-  eReturnInstance = new Error();
-  eReturnInstance.$klass = eLocalJumpError;
-  eReturnInstance.$keyword = 1;
+  rb_eBreakInstance = new Error('unexpected break');
+  rb_eBreakInstance.$k = rb_eLocalJumpError;
+  rb_block.b = rb_eBreakInstance;
 
-  eNextInstance = new Error();
-  eNextInstance.$klass = eLocalJumpError;
-  eNextInstance.$keyword = 3;
+  rb_eReturnInstance = new Error('unexpected return');
+  rb_eReturnInstance.$k = rb_eLocalJumpError;
 
-  // need to do this after we make symbol
-  Rt.ds(cClass, 'new', class_s_new);
+  rb_eNextInstance = new Error('unexpected next');
+  rb_eNextInstance.$k = rb_eLocalJumpError;
 
-  cIO = define_class('IO', cObject);
-  stdin = obj_alloc(cIO);
-  stdout = obj_alloc(cIO);
-  stderr = obj_alloc(cIO);
+  rb_cIO = rb_define_class('IO', rb_cObject);
+  rb_stdin = new rb_cIO.$a();
+  rb_stdout = new rb_cIO.$a();
+  rb_stderr = new rb_cIO.$a();
 
-  const_set(cObject, 'STDIN', stdin);
-  const_set(cObject, 'STDOUT', stdout);
-  const_set(cObject, 'STDERR', stderr);
+  rb_const_set(rb_cObject, 'STDIN', rb_stdin);
+  rb_const_set(rb_cObject, 'STDOUT', rb_stdout);
+  rb_const_set(rb_cObject, 'STDERR', rb_stderr);
 
-  define_hooked_variable('$stdin', stdio_getter, stdio_setter);
-  define_hooked_variable('$stdout', stdio_getter, stdio_setter);
-  define_hooked_variable('$stderr', stdio_getter, stdio_setter);
+  rb_define_hooked_variable('$stdin', rb_stdio_getter, rb_stdio_setter);
+  rb_define_hooked_variable('$stdout', rb_stdio_getter, rb_stdio_setter);
+  rb_define_hooked_variable('$stderr', rb_stdio_getter, rb_stdio_setter);
 
-  define_hooked_variable('$:', load_path_getter, gvar_readonly_setter);
-  define_hooked_variable('$LOAD_PATH', load_path_getter, gvar_readonly_setter);
+  rb_define_hooked_variable('$:', rb_load_path_getter, rb_gvar_readonly_setter);
+  rb_define_hooked_variable('$LOAD_PATH', rb_load_path_getter, rb_gvar_readonly_setter);
 
   Op.loader = new Loader(Op);
   Op.cache = {};
 
-  // const_set(cObject, 'RUBY_ENGINE', Op.platform.engine);
-  const_set(cObject, 'RUBY_ENGINE', 'opal-gem');
+  rb_const_set(rb_cObject, 'RUBY_ENGINE', PLATFORM_ENGINE);
+  rb_const_set(rb_cObject, 'RUBY_PLATFORM', PLATFORM_PLATFORM);
+  rb_const_set(rb_cObject, 'RUBY_VERSION', PLATFORM_VERSION);
+  rb_const_set(rb_cObject, 'ARGV', PLATFORM_ARGV);
+
+  Op.run(core_lib);
 
   puts = function(str) {
-    top_self.$m.puts(top_self, str);
+    rb_stdout.m$puts(str);
   };
-
-};
-
-/**
-  Symbol table. All symbols are stored here.
-*/
-var symbol_table = { };
-
-function class_s_new(cls, sup) {
-  var klass = define_class_id("AnonClass", sup || cObject);
-  return klass;
 };