opal 0.3.2 → 0.3.6

data/runtime/init.js

@@ -0,0 +1,558 @@
+
+/**
+  Sets the constant value `val` on the given `klass` as `id`.
+
+  @param {RClass} klass
+  @param {String} id
+  @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;
+  return val;
+}
+
+/**
+  Lookup a constant named `id` on the `klass`. This will throw an error if
+  the constant cannot be found.
+
+  @param {RClass} klass
+  @param {String} id
+*/
+function const_get(klass, id) {
+  if (klass.$c[id]) {
+    return (klass.$c[id]);
+  }
+
+  var parent = klass.$parent;
+
+  while (parent && parent != cObject) {
+  // while (parent) {
+    if (parent.$c[id] !== undefined) {
+      return parent.$c[id];
+    }
+
+    parent = parent.$parent;
+  }
+
+  raise(eNameError, 'uninitialized constant ' + id);
+};
+
+Rt.const_get = const_get;
+
+/**
+  Returns true or false depending whether a constant named `id` is defined
+  on the receiver `klass`.
+
+  @param {RClass} klass
+  @param {String} id
+  @return {true, false}
+*/
+function const_defined(klass, id) {
+  if (klass.$c[id]) {
+    return true;
+  }
+
+  return false;
+};
+
+/**
+  This table holds all the global variables accessible from ruby.
+
+  Entries are mapped by their global id => an object that contains the
+  given keys:
+
+    - name
+    - value
+    - getter
+    - setter
+*/
+var global_tbl = {};
+
+/**
+  Defines a hooked/global variable.
+
+  @param {String} name The global name (e.g. '$:')
+  @param {Function} getter The getter function to return the variable
+  @param {Function} setter The setter function used for setting the var
+  @return {null}
+*/
+function define_hooked_variable(name, getter, setter) {
+  var entry = {
+    "name": name,
+    "value": Qnil,
+    "getter": getter,
+    "setter": setter
+  };
+
+  global_tbl[name] = entry;
+};
+
+/**
+  A default read only getter for a global variable. This will simply throw a
+  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");
+};
+
+/**
+  Retrieve a global variable. This will use the assigned getter.
+*/
+function gvar_get(id) {
+  var entry = global_tbl[id];
+  if (!entry) { return Qnil; }
+  return entry.getter(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];
+  if (entry)  { return entry.setter(id, value); }
+
+  define_hooked_variable(id,
+
+    function(id) {
+      return global_tbl[id].value;
+    },
+
+    function(id, value) {
+      return (global_tbl[id].value = value);
+    }
+  );
+
+  return 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;
+
+/**
+  Yield the next object id, updating the count, and returning it.
+*/
+function yield_hash() {
+  return hash_yield++;
+};
+
+var 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;
+
+  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;
+  }
+
+  return hash;
+};
+
+var alias_method = Rt.alias_method = function(klass, new_name, old_name) {
+  var body = klass.$m_tbl[old_name];
+
+  if (!body) {
+    throw new Error("NameError: undefined method `" + old_name + "' for class `" + klass.__classid__ + "'");
+  }
+
+  define_raw_method(klass, new_name, body, body);
+  return Qnil;
+};
+
+/**
+  This does the main work, but does not call runtime methods like
+  singleton_method_added etc. define_method does that.
+
+*/
+function define_raw_method(klass, private_name, private_body, public_body) {
+  var public_name = '$' + private_name;
+
+  klass.$m_tbl[private_name] = private_body;
+  klass.$m_tbl[public_name] = public_body;
+
+  klass.$method_table[private_name] = private_body;
+
+  var included_in = klass.$included_in, includee;
+
+  if (included_in) {
+    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);
+    }
+  }
+};
+
+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__ + "'");
+      }
+
+      // 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 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
+      }
+    }
+  }
+  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]);
+  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) {
+  if (str === undefined) {
+    str = exc;
+    exc = eException;
+  }
+
+  var exception = exc.$m['new'](exc, str);
+  raise_exc(exception);
+};
+
+Rt.raise = raise;
+
+/**
+  Raise an exception instance (DO NOT pass strings to this)
+*/
+function raise_exc(exc) {
+  throw exc;
+};
+
+Rt.raise_exc = raise_exc;
+
+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.
+
+  @param {String} intern Symbol value
+  @return {RSymbol} symbol
+*/
+var intern = Rt.Y = function(intern) {
+  if (symbol_table.hasOwnProperty(intern)) {
+    return symbol_table[intern];
+  }
+
+  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;
+};
+
+
+var cIO, stdin, stdout, stderr;
+
+function stdio_getter(id) {
+  switch (id) {
+    case "$stdout":
+      return stdout;
+    case "$stdin":
+      return stdin;
+    case "$stderr":
+      return stderr;
+    default:
+      raise(eRuntimeError, "stdout_setter being used for bad variable");
+  }
+};
+
+function stdio_setter(id, value) {
+  raise(eException, "stdio_setter cannot currently set stdio variables");
+
+  switch (id) {
+    case "$stdout":
+      return stdout = value;
+    case "$stdin":
+      return stdin = value;
+    case "$stderr":
+      return stderr = value;
+    default:
+      raise(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;
+
+/**
+  Block passing - holds current block for runtime
+
+  f: function
+  p: proc
+  y: yield error
+*/
+var block = Rt.P = {
+  f: null,
+  p: null,
+  y: function() {
+    throw new Error("LocalJumpError - no block given");
+  }
+};
+
+block.y.$proc = [block.y];
+
+/**
+  Turns the given proc/function into a lambda. This is useful for the
+  Proc#lambda method, but also for blocks that are turned into
+  methods, in Module#define_method, for example. Lambdas and methods
+  from blocks are the same thing. Lambdas basically wrap the passed
+  block function and perform stricter arg checking to make sure the
+  right number of args are passed. Procs are liberal in their arg
+  checking, and simply turned ommited args into nil. Lambdas and
+  methods MUST check args and throw an error if the wrong number are
+  given. Also, lambdas/methods must catch return statements as lambdas
+  capture returns.
+
+  FIXME: wrap must detect if we are the receiver of a block, and fix
+  the block to send it to the proc.
+
+  FIXME: need to be strict on checking proc arity
+
+  FIXME: need to catch return statements which may be thrown.
+
+  @param {Function} proc The proc/function to lambdafy.
+  @return {Function} Wrapped lambda function.
+*/
+Rt.lambda = function(proc) {
+  if (proc.$lambda) return proc;
+
+  var wrap = function() {
+    var args = Array.prototype.slice.call(arguments, 0);
+    return proc.apply(null, args);
+  };
+
+  wrap.$lambda = true;
+  wrap.$proc = proc.$proc;
+
+  return Rt.proc(wrap);
+};
+
+var 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;
+  return range;
+};
+
+Rt.A = function(objs) {
+  var arr = new cArray.allocator();
+  arr.splice.apply(arr, [0, 0].concat(objs));
+  return arr;
+};
+
+var puts = function(str) {
+  console.log(str);
+};
+
+/**
+  Main init method. This is called once this file has fully loaded. It setups
+  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);
+
+  mKernel = Rt.Kernel = define_module('Kernel');
+
+  top_self = obj_alloc(cObject);
+  Rt.top = top_self;
+
+  cNilClass = define_class('NilClass', cObject);
+  Rt.Qnil = Qnil = obj_alloc(cNilClass);
+  Qnil.$r = false;
+
+  cTrueClass = define_class('TrueClass', cObject);
+  Rt.Qtrue = Qtrue = obj_alloc(cTrueClass);
+
+  cFalseClass = define_class('FalseClass', cObject);
+  Rt.Qfalse = Qfalse = obj_alloc(cFalseClass);
+  Qfalse.$r = false;
+
+  cArray = bridge_class(Array.prototype,
+    T_OBJECT | T_ARRAY, 'Array', cObject);
+
+  Function.prototype.$hash = function() {
+    return this.$id || (this.$id = yield_hash());
+  };
+
+  cHash = define_class('Hash', cObject);
+
+  cNumeric = bridge_class(Number.prototype,
+    T_OBJECT | T_NUMBER, 'Numeric', cObject);
+
+  cString = bridge_class(String.prototype,
+    T_OBJECT | T_STRING, 'String', cObject);
+
+  cSymbol = define_class('Symbol', cObject);
+
+  cProc = bridge_class(Function.prototype,
+    T_OBJECT | T_PROC, 'Proc', cObject);
+
+  Function.prototype.$hash = function() {
+    return this.$id || (this.$id = yield_hash());
+  };
+
+  cRange = define_class('Range', cObject);
+
+  cRegexp = bridge_class(RegExp.prototype,
+    T_OBJECT, 'Regexp', cObject);
+
+  cMatch = define_class('MatchData', cObject);
+  define_hooked_variable('$~', regexp_match_getter, gvar_readonly_setter);
+
+  eException = bridge_class(Error.prototype, T_OBJECT, 'Exception', cObject);
+
+  eStandardError = define_class("StandardError", eException);
+  eRuntimeError = define_class("RuntimeError", eException);
+  eLocalJumpError = define_class("LocalJumpError", eStandardError);
+  Rt.TypeError = eTypeError = define_class("TypeError", eStandardError);
+
+  eNameError = define_class("NameError", eStandardError);
+  eNoMethodError = define_class('NoMethodError', eNameError);
+  eArgError = define_class('ArgumentError', eStandardError);
+
+  eScriptError = define_class('ScriptError', eException);
+  eLoadError = define_class('LoadError', eScriptError);
+
+  eIndexError = define_class("IndexError", eStandardError);
+  eKeyError = define_class("KeyError", eIndexError);
+  eRangeError = define_class("RangeError", eStandardError);
+
+  eBreakInstance = new Error();
+  eBreakInstance['@message'] = "unexpected break";
+  block.b = eBreakInstance;
+  // dont need this anymore???
+  eBreakInstance.$keyword = 2;
+
+  eReturnInstance = new Error();
+  eReturnInstance.$klass = eLocalJumpError;
+  eReturnInstance.$keyword = 1;
+
+  eNextInstance = new Error();
+  eNextInstance.$klass = eLocalJumpError;
+  eNextInstance.$keyword = 3;
+
+  // need to do this after we make symbol
+  Rt.ds(cClass, 'new', class_s_new);
+
+  cIO = define_class('IO', cObject);
+  stdin = obj_alloc(cIO);
+  stdout = obj_alloc(cIO);
+  stderr = obj_alloc(cIO);
+
+  const_set(cObject, 'STDIN', stdin);
+  const_set(cObject, 'STDOUT', stdout);
+  const_set(cObject, 'STDERR', 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);
+
+  define_hooked_variable('$:', load_path_getter, gvar_readonly_setter);
+  define_hooked_variable('$LOAD_PATH', load_path_getter, 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');
+
+  puts = function(str) {
+    top_self.$m.puts(top_self, 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;
+};
+