Utilities and an initial webpack loader

lib/utils/README.md

@@ -0,0 +1,17 @@
+![](https://s.gravatar.com/avatar/f105de3decfafc734b8eabe9a960b25d?size=64) utils
+=================
+
+Utilities for working with [AssemblyScript](http://assemblyscript.org) modules.
+
+Usage
+-----
+
+```js
+import utils from "@assemblyscript/utils";
+
+var myModule = ...;
+
+var helpers = utils(myModule);
+
+var str = helpers.getString(myModule.exportReturningAString());
+```

lib/utils/index.js

@@ -0,0 +1,21 @@
+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);
+    }
+  }
+};

lib/utils/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@assemblyscript/utils",
+  "version": "0.5.0",
+  "description": "Utilities for working with AssemblyScript modules.",
+  "license": "Apache-2.0"
+}

lib/webpack/README.md

@@ -0,0 +1,13 @@
+![](https://s.gravatar.com/avatar/f105de3decfafc734b8eabe9a960b25d?size=64) webpack
+=================
+
+[webpack](https://webpack.js.org/) loader for [AssemblyScript](http://assemblyscript.org) modules.
+
+Usage
+-----
+
+```js
+import Module from "@assemblyscript/webpack!module.wasm";
+
+var myModule = Module({ imports: { ... }});
+```

lib/webpack/decode.js

@@ -0,0 +1,32 @@
+// set up decoding table
+var s64 = new Array(123);
+for (var i = 0; i < 64;) s64[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+
+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;
+  }
+
+  // decode to buffer
+  var buffer = new Uint8Array(length);
+  var j = 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;
+    }
+  }
+  if (j === 1) throw Error();
+
+  return buffer;
+};

lib/webpack/index.js

@@ -0,0 +1,13 @@
+var base64 = require("@protobufjs/base64");
+
+(module.exports = function(buffer) {
+  var data = base64.encode(buffer, 0, buffer.length);
+  var code = [
+    'var data = "' + data + '", wasm;',
+    'module.exports = function(options) {',
+    '  if (!wasm) wasm = require("@assemblyscript/webpack/decode")(data);',
+    '  return new WebAssembly.Instance(new WebAssembly.Module(wasm), options && options.imports || {}).exports;',
+    '};'
+  ];
+  return code.join("\n");
+}).raw = true;

lib/webpack/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@assemblyscript/webpack",
+  "version": "0.5.0",
+  "description": "webpack loader for AssemblyScript modules.",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@protobufjs/base64": "^1.1.2"
+  }
+}

src/types.ts

@@ -99,12 +99,12 @@ export class Type {
   }
 
   /** Computes the sign-extending shift in the target type. */
-  computeSmallIntegerShift(targetType: Type) {
+  computeSmallIntegerShift(targetType: Type): u32 {
     return targetType.size - this.size;
   }
 
   /** Computes the truncating mask in the target type. */
-  computeSmallIntegerMask(targetType: Type) {
+  computeSmallIntegerMask(targetType: Type): u32 {
     return -1 >>> (targetType.size - this.size);
   }