[js] Partial implementation of multi-dim arrays.

pmurias · pmurias · commit aa0cd139e2a0 · 2016-01-14T17:42:31.000+01:00
Support throwing errors from internals by throw new NQPException("...") instead of always using a ctx.
diff --git a/src/vm/js/QAST/Compiler.nqp b/src/vm/js/QAST/Compiler.nqp
@@ -786,13 +786,18 @@ class QAST::OperationsJS {
         add_simple_op('pop' ~ $suffix, $type, [$T_OBJ], sub ($array) {"$array.pop()"}, :sideffects);
         add_simple_op('push' ~ $suffix, $type, [$T_OBJ, $type], sub ($array, $elem) {"$array.push($elem)"}, :sideffects);
 
-        add_simple_op('atposnd' ~ $suffix, $type, [$T_OBJ, $T_OBJ], :ctx);
-        add_simple_op('bindposnd' ~ $suffix, $type, [$T_OBJ, $T_OBJ, $type], :ctx, :sideffects);
+        add_simple_op('atposnd' ~ $suffix, $type, [$T_OBJ, $T_OBJ]);
+        add_simple_op('atpos2d' ~ $suffix, $type, [$T_OBJ, $T_INT, $T_INT, $type],  :sideffects);
+        add_simple_op('atpos3d' ~ $suffix, $type, [$T_OBJ, $T_INT, $T_INT, $T_INT, $type], :sideffects);
+
+        add_simple_op('bindposnd' ~ $suffix, $type, [$T_OBJ, $T_OBJ, $type], :sideffects);
+        add_simple_op('bindpos2d' ~ $suffix, $type, [$T_OBJ, $T_INT, $T_INT, $type], :sideffects);
+        add_simple_op('bindpos3d' ~ $suffix, $type, [$T_OBJ, $T_INT, $T_INT, $T_INT, $type], :sideffects);
     }
 
     add_simple_op('numdimensions', $T_INT, [$T_OBJ]);
     add_simple_op('dimensions', $T_OBJ, [$T_OBJ]);
-    add_simple_op('setdimensions', $T_OBJ, [$T_OBJ, $T_OBJ], :sideffects, :ctx);
+    add_simple_op('setdimensions', $T_OBJ, [$T_OBJ, $T_OBJ], :sideffects);
 
     add_op('hash', sub ($comp, $node, :$want, :$cps) {
         # TODO CPS
@@ -1004,10 +1009,11 @@ class QAST::OperationsJS {
                 "try \{",
                 $body,
                 # HACK we need to check $body.type if we handle something like return
-                "//want: $want, body_expr: <{$body.expr}>, body_type:<{$body.type}>\n",
                 (($want == $T_VOID || $body.type == $T_VOID) ?? '' !! "$try_ret = {$body.expr};\n"),
                 "\} catch (e) \{if (e === $unwind_marker) \{",
                 ($want == $T_VOID ?? '' !! "$try_ret = $unwind_marker.ret;\n"),
+                "\} else if (e instanceof nqp.NQPException) \{\n",
+                "$*CTX.catchException(e);\n",
                 "\} else \{\n",
                 "throw e;\n",
                 "\}\n",
@@ -1075,7 +1081,7 @@ class QAST::OperationsJS {
 
     add_simple_op('splice', $T_OBJ, [$T_OBJ, $T_OBJ, $T_INT, $T_INT], :sideffects);
 
-    add_simple_op('setelems', $T_OBJ, [$T_OBJ, $T_INT], :sideffects, sub ($array, $elems) {"($array.length = $elems, $array)"});
+    add_simple_op('setelems', $T_OBJ, [$T_OBJ, $T_INT], :sideffects);
 
 
     add_simple_op('iterator', $T_OBJ, [$T_OBJ], :sideffects);
diff --git a/src/vm/js/nqp-runtime/core.js b/src/vm/js/nqp-runtime/core.js
@@ -7,6 +7,8 @@ var CodeRef = require('./code-ref.js');
 var LexPadHack = require('./lexpad-hack.js');
 var NQPInt = require('./nqp-int.js');
 
+var NQPException = require('./nqp-exception.js');
+
 var reprs = require('./reprs.js');
 
 exports.CodeRef = CodeRef;
@@ -502,11 +504,21 @@ op.unbox_s = function(obj) {
 op.elems = function(obj) {
   if (obj instanceof Array) {
     return obj.length;
-  } else if (obj.$$elems) {
+  } else {
     return obj.$$elems();
   }
 };
 
+op.setelems = function(obj, elems) {
+  if (obj instanceof Array) {
+    obj.length = elems;
+    return obj;
+  } else {
+    obj.$$setelems(elems);
+    return obj;
+  }
+};
+
 op.markcodestatic = function(code) {
   code.isStatic = true;
   return code;
@@ -874,48 +886,77 @@ op.getcodecuid = function(codeRef) {
 op.numdimensions = function(array) {
   if (array instanceof Array) {
     return 1;
+  } else {
+    return array.$$numdimensions();
   }
 };
 
 op.dimensions = function(array) {
   if (array instanceof Array) {
     return [array.length];
+  } else {
+    return array.$$dimensions();
   }
 };
 
-op.setdimensions = function(ctx, array, dimensions) {
+op.setdimensions = function(array, dimensions) {
   if (array instanceof Array) {
     if (dimensions.length != 1) {
-      ctx.die("A dynamic array can only have a single dimension");
+      throw new NQPException("A dynamic array can only have a single dimension");
     } else {
-        //console.log("setting ", array, dimensions);
         array.length = dimensions[0];
     }
+  } else {
+    array.$$setdimensions(dimensions);
   }
+  return dimensions;
 };
 
-op.atposnd = function(ctx, array, idx) {
+op.atposnd = function(array, idx) {
   if (array instanceof Array) {
     if (idx.length != 1) {
-      ctx.die("A dynamic array can only be indexed with a single dimension");
+      throw new NQPException("A dynamic array can only be indexed with a single dimension");
     }
     return array[idx[0]];
+  } else {
+    return array.$$atposnd(idx);
   }
 };
 
-op.atposnd_n = op.atposnd;
-op.atposnd_s = op.atposnd;
-op.atposnd_i = op.atposnd;
 
-op.bindposnd = function(ctx, array, idx, value) {
+
+op.bindposnd = function(array, idx, value) {
   if (array instanceof Array) {
     if (idx.length != 1) {
-      ctx.die("A dynamic array can only be indexed with a single dimension");
+      throw new NQPException("A dynamic array can only be indexed with a single dimension");
     }
     return (array[idx[0]] = value);
+  } else {
+    return array.$$bindposnd(idx, value);
   }
 };
 
-op.bindposnd_n = op.bindposnd;
-op.bindposnd_s = op.bindposnd;
-op.bindposnd_i = op.bindposnd;
+// TODO optimize
+op.atpos2d = function(array, x, y) {
+  return op.atposnd(array, [x, y]);
+};
+
+op.atpos3d = function(array, x, y, z) {
+  return op.atposnd(array, [x, y, z]);
+};
+
+op.bindpos2d = function(array, x, y, value) {
+  return op.bindposnd(array, [x, y], value);
+};
+
+op.bindpos3d = function(array, x, y, z, value) {
+  return op.bindposnd(array, [x, y, z], value);
+};
+
+['bindpos', 'atpos'].forEach(function(prefix) {
+  ['_n', '_s', '_i'].forEach(function(type) {
+    ['2d', '3d', 'nd'].forEach(function(dim) {
+      op[prefix + dim + type] = op[prefix + dim];
+    });
+  });
+});
diff --git a/src/vm/js/nqp-runtime/nqp-exception.js b/src/vm/js/nqp-runtime/nqp-exception.js
@@ -0,0 +1,9 @@
+function NQPException(message) {
+  this.name = 'NQPException';
+  this.message = message;
+}
+
+NQPException.prototype = Object.create(Error.prototype);
+NQPException.prototype.constructor = NQPException;
+
+module.exports = NQPException;
diff --git a/src/vm/js/nqp-runtime/reprs.js b/src/vm/js/nqp-runtime/reprs.js
@@ -1,6 +1,7 @@
 var sixmodel = require('./sixmodel.js');
 var Hash = require('./hash.js');
 var NQPInt = require('./nqp-int.js');
+var NQPException = require('./nqp-exception.js');
 
 function basic_type_object_for(HOW) {
   var st = new sixmodel.STable(this, HOW);
@@ -738,3 +739,112 @@ function ConditionVariable() {}
 ConditionVariable.prototype.create_obj_constructor = basic_constructor;
 
 module.exports.ConditionVariable = ConditionVariable;
+
+function MultiDimArray() {
+
+}
+MultiDimArray.prototype.type_object_for = basic_type_object_for;
+MultiDimArray.prototype.compose = function(STable, repr_info_hash) {
+  var array = repr_info_hash.content.get('array');
+  var dimensions = array.content.get('dimensions');
+
+  if (dimensions instanceof NQPInt) {
+    dimensions = dimensions.value;
+    if (dimensions === 0) {
+      throw new NQPException("MultiDimArray REPR must be composed with at least 1 dimension");
+    }
+
+  } else {
+    throw "dimensions to MultiDimArray.compose must be a native int";
+  }
+
+//  console.log('dimensions', dimensions);
+  STable.dimensions = dimensions;
+};
+MultiDimArray.prototype.allocate = basic_allocate;
+
+MultiDimArray.prototype.basic_constructor = basic_constructor;
+MultiDimArray.prototype.create_obj_constructor = function(STable) {
+  var c = this.basic_constructor(STable);
+
+  STable.obj_constructor = c; // HACK it's set again later, we set it for addInternalMethod
+
+  STable.addInternalMethod('$$numdimensions', function(value) {
+    if (this.type_object_) {
+      throw new NQPException("Cannot get number of dimensions of a type object");
+    }
+    return STable.dimensions;
+  });
+
+  STable.addInternalMethod('$$clone', function() {
+    var clone = new this._STable.obj_constructor();
+    clone.storage = this.storage.slice();
+    clone.dimensions = this.dimensions;
+    return clone;
+  });
+
+  STable.addInternalMethod('$$dimensions', function() {
+    if (this.type_object_) {
+      throw new NQPException("Cannot get dimensions of a type object");
+    }
+    return this.dimensions;
+  });
+
+  STable.addInternalMethod('$$setdimensions', function(value) {
+    if (value.length != STable.dimensions) {
+      throw new NQPException("Array type of " + STable.dimensions + " dimensions cannot be intialized with " + value.length + " dimensions");
+    } else if (this.dimensions) {
+      throw new NQPException("Can only set dimensions once");
+    }
+    this.storage = [];
+    return (this.dimensions = value);
+  });
+
+
+  STable.addInternalMethod('$$calculateIndex', function(idx, value) {
+    if (idx.length != STable.dimensions) {
+      throw new NQPException("Cannot access " + STable.dimensions + " dimension array with " + idx.length + " indices");
+    }
+
+    for (var i=0; i < idx.length; i++) {
+      if (idx[i] < 0 || idx[i] >= this.dimensions[i]) {
+        throw new NQPException("Index " + idx[i] + " for dimension " + (i+1) + " out of range (must be 0.." + this.dimensions[i] + ")");
+      }
+    }
+    var calculatedIdx = 0;
+    for (var i=0; i < idx.length; i++) {
+      calculatedIdx = calculatedIdx * this.dimensions[i] + idx[i];
+    }
+    return calculatedIdx;
+  });
+
+  STable.addInternalMethod('$$atposnd', function(idx) {
+    return this.storage[this.$$calculateIndex(idx)];
+  });
+
+  STable.addInternalMethod('$$bindposnd', function(idx, value) {
+    return (this.storage[this.$$calculateIndex(idx)] = value);
+  });
+
+  // TODO optimize access
+  STable.addInternalMethod('$$bindpos', function(index, value) {
+    return this.$$bindposnd([index], value);
+  });
+
+  STable.addInternalMethod('$$setelems', function(elems) {
+    this.$$setdimensions([elems]);
+  });
+
+  STable.addInternalMethod('$$elems', function(elems) {
+    return this.dimensions[0];
+  });
+
+  STable.addInternalMethod('$$atpos', function(index) {
+    return this.$$atposnd([index]);
+  });
+
+
+  return c;
+};
+
+module.exports.MultiDimArray = MultiDimArray;
diff --git a/src/vm/js/nqp-runtime/runtime.js b/src/vm/js/nqp-runtime/runtime.js
@@ -2,6 +2,7 @@ var op = {};
 exports.op = op;
 
 var NQPInt = require("./nqp-int.js");
+var NQPException = require("./nqp-exception.js");
 exports.NQPInt = NQPInt;
 
 function load_ops(module) {
@@ -221,6 +222,11 @@ Ctx.prototype.propagateException = function(exception) {
   throw exception.msg;
 };
 
+Ctx.prototype.catchException = function(exception) {
+  this.exception = exception;
+  this.CATCH();
+};
+
 Ctx.prototype.rethrow = function(exception) {
   exception.caught.caller.propagateException(exception);
 };
@@ -439,3 +445,4 @@ function runCPS(thunk_) {
 }
 
 exports.runCPS = runCPS;
+exports.NQPException = NQPException;
diff --git a/src/vm/js/nqp-runtime/sixmodel.js b/src/vm/js/nqp-runtime/sixmodel.js
@@ -6,15 +6,17 @@ function STable(REPR, HOW) {
 
 
   /* HACK - it's a bit hackish - think how correct it is */
-  this.obj_constructor.prototype.$$clone = function() {
-    var clone = new this._STable.obj_constructor();
-    for (var i in this) {
-      if (this.hasOwnProperty(i) && i != '_SC') {
-        clone[i] = this[i];
+  if (!this.obj_constructor.prototype.hasOwnProperty('$$clone')) {
+    this.obj_constructor.prototype.$$clone = function() {
+      var clone = new this._STable.obj_constructor();
+      for (var i in this) {
+        if (this.hasOwnProperty(i) && i != '_SC') {
+          clone[i] = this[i];
+        }
       }
-    }
-    return clone;
-  };
+      return clone;
+    };
+  }
 
   /* Default boolification mode 5 */
   this.obj_constructor.prototype.$$to_bool = function(ctx) {
