Parser fixes; Lib updates

lib/utils/README.md

@@ -13,5 +13,5 @@ var myModule = ...;
 
 var helpers = utils(myModule);
 
-var str = helpers.getString(myModule.exportReturningAString());
+var str = helpers.string(myModule.exportReturningAString());
 ```

lib/utils/index.js

@@ -1,21 +1,103 @@
-module.exports = function(module) {
-  return {
-    getI32: function(ptr) {
-      return new Int32Array(module.memory.buffer, ptr, 4)[0];
-    },
-    getU32: function(ptr) {
-      return new Uint32Array(module.memory.buffer, ptr, 4)[0];
-    },
-    getF32: function(ptr) {
-      return new Float32Array(module.memory.buffer, ptr, 4)[0];
-    },
-    getF64: function(ptr) {
-      return new Float64Array(module.memory.buffer, ptr, 8)[0];
-    },
-    getString: function(ptr) {
-      var len = new Uint32Array(module.memory.buffer, ptr, 4)[0];
-      var str = new Uint16Array(module.memory.buffer, ptr + 4, len << 1);
-      return String.fromCharCode.apply(String, str);
-    }
+function utils(module) {
+
+  var i8,
+      u8 = new Uint8Array(0),
+      i16,
+      u16,
+      i32,
+      u32,
+      f32,
+      f64;
+
+  function maybeUpdate() {
+    var mem = module.memory.buffer;
+    if (mem.byteLength === u8.length)
+      return;
+    i8 = Int8Array(mem);
+    u8 = Uint8Array(mem);
+    i16 = Int16Array(mem);
+    u16 = Uint16Array(mem);
+    i32 = Int32Array(mem);
+    u32 = Uint32Array(mem);
+    f32 = Float32Array(mem);
+    f64 = Float64Array(mem);
   }
+
+  var helpers = {
+
+    i8: function(ptr) {
+      maybeUpdate();
+      return i8[ptr];
+    },
+
+    u8: function(ptr) {
+      maybeUpdate();
+      return u8[ptr];
+    },
+
+    i16: function(ptr) {
+      maybeUpdate();
+      return i16[ptr >>> 1];
+    },
+
+    u16: function(ptr) {
+      maybeUpdate();
+      return u16[ptr >>> 1];
+    },
+
+    i32: function(ptr) {
+      maybeUpdate();
+      return i32[ptr >>> 2];
+    },
+
+    u32: function(ptr) {
+      maybeUpdate();
+      return u32[ptr >>> 2];
+    },
+
+    i64: function(ptr) {
+      maybeUpdate();
+      return {
+        low: i32[ptr >>> 2],
+        high: i32[(ptr >>> 2) + 1]
+      };
+    },
+
+    u64: function(ptr) {
+      maybeUpdate();
+      return {
+        low: u32[ptr >>> 2],
+        high: u32[(ptr >>> 2) + 1]
+      };
+    },
+
+    bool: function(ptr) {
+      maybeUpdate();
+      return u8[ptr] === 1;
+    },
+
+    f32: function(ptr) {
+      maybeUpdate();
+      return f32[ptr >>> 2];
+    },
+
+    f64: function(ptr) {
+      maybeUpdate();
+      return f64[ptr >>> 3];
+    },
+
+    string: function(ptr) {
+      maybeUpdate();
+      var len = u32[ptr >>> 2];
+      var off = (ptr >>> 1) + 2;
+      return String.fromCharCode.apply(String, u16.subarray(off, off + len));
+    }
+  };
+
+  return helpers;
 };
+
+Object.defineProperties(module.exports = utils, {
+  __esModule: { value: true },
+  default: { value: utils }
+});

lib/webpack/README.md

@@ -11,3 +11,5 @@ import Module from "@assemblyscript/webpack!module.wasm";
 
 var myModule = Module({ imports: { ... }});
 ```
+
+TODO: Wire .ts files to the compiler API, accepting options, but also keep raw .wasm support.

lib/webpack/decode.js

@@ -7,23 +7,23 @@ module.exports = function(string) {
   // determine buffer length
   var length = string.length;
   if (length) {
-    var n = 0;
-    while (--length % 4 > 1 && string.charCodeAt(p) === 61) ++n;
-    length = Math.ceil(string.length * 3) / 4 - n;
+    var n = 0, p = length;
+    while (--p % 4 > 1 && string.charCodeAt(p) === 61) ++n;
+    length = Math.ceil(length * 3) / 4 - n;
   }
 
   // decode to buffer
   var buffer = new Uint8Array(length);
-  var j = 0, t;
+  var j = 0, o = 0, t;
   for (var i = 0, k = string.length; i < k;) {
     var c = string.charCodeAt(i++);
     if (c === 61 && j > 1) break;
     if ((c = s64[c]) === undefined) throw Error();
     switch (j) {
       case 0: t = c; j = 1; break;
-      case 1: buffer[offset++] = t << 2 | (c & 48) >> 4; t = c; j = 2; break;
-      case 2: buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2; t = c; j = 3; break;
-      case 3: buffer[offset++] = (t & 3) << 6 | c; j = 0; break;
+      case 1: buffer[o++] = t << 2 | (c & 48) >> 4; t = c; j = 2; break;
+      case 2: buffer[o++] = (t & 15) << 4 | (c & 60) >> 2; t = c; j = 3; break;
+      case 3: buffer[o++] = (t & 3) << 6 | c; j = 0; break;
     }
   }
   if (j === 1) throw Error();

lib/webpack/index.js

@@ -1,6 +1,6 @@
 var base64 = require("@protobufjs/base64");
 
-(module.exports = function(buffer) {
+function loader(buffer) {
   var data = base64.encode(buffer, 0, buffer.length);
   var code = [
     'var data = "' + data + '", wasm;',
@@ -9,5 +9,12 @@ var base64 = require("@protobufjs/base64");
     '  return new WebAssembly.Instance(new WebAssembly.Module(wasm), options && options.imports || {}).exports;',
     '};'
   ];
-  return code.join("\n");
-}).raw = true;
+  return code.join("\n") + "\n";
+}
+
+loader.raw = true;
+
+Object.defineProperties(module.exports = loader, {
+  __esModule: { value: true },
+  default: { value: loader }
+});