porffor 0.17.0-418ce1445 → 0.17.0-55678f69e

package/compiler/types.js

@@ -20,10 +20,26 @@ export const TYPE_NAMES = {
   [TYPES.bigint]: 'BigInt'
 };
 
+// flags
+export const TYPE_FLAGS = {
+  // iterable:  0b10000000,
+  length:    0b01000000,
+};
+
+// TYPES.string |= TYPE_FLAGS.iterable;
+TYPES.string |= TYPE_FLAGS.length;
+
+export const typeHasFlag = (type, flag) => (type & flag) !== 0;
+
 export const INTERNAL_TYPE_BASE = 0x10;
 let internalTypeIndex = INTERNAL_TYPE_BASE;
-const registerInternalType = name => {
-  const n = internalTypeIndex++;
+const registerInternalType = (name, flags = []) => {
+  let n = internalTypeIndex++;
+
+  for (const x of flags) {
+    if (TYPE_FLAGS[x]) n |= TYPE_FLAGS[x];
+  }
+
   TYPES[name.toLowerCase()] = n;
   TYPE_NAMES[n] = name;
 };
@@ -31,8 +47,18 @@ const registerInternalType = name => {
 // note: when adding a new internal type, please also add a deserializer to wrap.js
 // (it is okay to add a throw todo deserializer for wips)
 
-registerInternalType('Array');
+registerInternalType('Array', ['iterable', 'length']);
 registerInternalType('RegExp');
-registerInternalType('ByteString');
+registerInternalType('ByteString', ['iterable', 'length']);
 registerInternalType('Date');
-registerInternalType('Set');
+registerInternalType('Set', ['iterable']);
+
+registerInternalType('Uint8Array', ['iterable', 'length']);
+registerInternalType('Int8Array', ['iterable', 'length']);
+registerInternalType('Uint8ClampedArray', ['iterable', 'length']);
+registerInternalType('Uint16Array', ['iterable', 'length']);
+registerInternalType('Int16Array', ['iterable', 'length']);
+registerInternalType('Uint32Array', ['iterable', 'length']);
+registerInternalType('Int32Array', ['iterable', 'length']);
+registerInternalType('Float32Array', ['iterable', 'length']);
+registerInternalType('Float64Array', ['iterable', 'length']);

package/compiler/wasmSpec.js

@@ -68,6 +68,7 @@ export const Opcodes = {
 
   i32_load: 0x28,
   i64_load: 0x29,
+  f32_load: 0x2a,
   f64_load: 0x2b,
 
   i32_load8_s: 0x2c,
@@ -82,6 +83,7 @@ export const Opcodes = {
 
   i32_store: 0x36,
   i64_store: 0x37,
+  f32_store: 0x38,
   f64_store: 0x39,
 
   i32_store8: 0x3a,

package/compiler/wrap.js

@@ -2,7 +2,7 @@ import { encodeVector, encodeLocal } from './encoding.js';
 import { importedFuncs } from './builtins.js';
 import compile from './index.js';
 import decompile from './decompile.js';
-import { TYPES } from './types.js';
+import { TYPES, TYPE_NAMES } from './types.js';
 import { log } from './log.js';
 import Prefs from './prefs.js';
 
@@ -115,6 +115,19 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
       return Symbol(desc);
     }
 
+    case TYPES.uint8array:
+    case TYPES.int8array:
+    case TYPES.uint8clampedarray:
+    case TYPES.uint16array:
+    case TYPES.int16array:
+    case TYPES.uint32array:
+    case TYPES.int32array:
+    case TYPES.float32array:
+    case TYPES.float64array: {
+      const length = (new Int32Array(memory.buffer, value, 1))[0];
+      return new globalThis[TYPE_NAMES[type]](memory.buffer, value + 4, length);
+    }
+
     default: return value;
   }
 };
@@ -127,7 +140,7 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
 
   globalThis.porfDebugInfo = { funcs, globals };
 
-  if (source.includes?.('export ')) flags.push('module');
+  // if (process.argv[1].includes('/runner') && source.includes?.('export ')) flags.push('module');
 
   // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
@@ -297,16 +310,58 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
         return porfToJSValue({ memory, funcs, pages }, ret[0], ret[1]);
       } catch (e) {
         if (e.is && e.is(exceptTag)) {
-          const exceptId = e.getArg(exceptTag, 0);
-          const exception = exceptions[exceptId];
+          const exceptionMode = Prefs.exceptionMode ?? 'lut';
+          if (exceptionMode === 'lut') {
+            const exceptId = e.getArg(exceptTag, 0);
+            const exception = exceptions[exceptId];
+
+            const constructorName = exception.constructor;
+
+            // no constructor, just throw message
+            if (!constructorName) throw exception.message;
+
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(exception.message);
+          }
+
+          if (exceptionMode === 'stack') {
+            const value = e.getArg(exceptTag, 0);
+            const type = e.getArg(exceptTag, 1);
+
+            throw porfToJSValue({ memory, funcs, pages }, value, type);
+          }
+
+          if (exceptionMode === 'stackest') {
+            const constructorIdx = e.getArg(exceptTag, 0);
+            const constructorName = constructorIdx == -1 ? null : funcs.find(x => ((x.originalIndex ?? x.index) - importedFuncs.length) === constructorIdx)?.name;
+
+            const value = e.getArg(exceptTag, 1);
+            const type = e.getArg(exceptTag, 2);
+            const message = porfToJSValue({ memory, funcs, pages }, value, type);
 
-          const constructorName = exception.constructor;
+            // no constructor, just throw message
+            if (!constructorName) throw message;
+
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(message);
+          }
 
-          // no constructor, just throw message
-          if (!constructorName) throw exception.message;
+          if (exceptionMode === 'partial') {
+            const exceptId = e.getArg(exceptTag, 0);
+            const exception = exceptions[exceptId];
 
-          const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
-          throw new constructor(exception.message);
+            const constructorName = exception.constructor;
+
+            const value = e.getArg(exceptTag, 1);
+            const type = e.getArg(exceptTag, 2);
+            const message = porfToJSValue({ memory, funcs, pages }, value, type);
+
+            // no constructor, just throw message
+            if (!constructorName) throw message;
+
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(message);
+          }
         }
 
         if (e instanceof WebAssembly.RuntimeError) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.17.0-418ce1445",
+  "version": "0.17.0-55678f69e",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

@@ -130,7 +130,7 @@ const print = str => {
 let runStart;
 try {
   if (process.argv.includes('-b')) {
-    const { wasm, exports } = await compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
+    const { wasm, exports } = compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
 
     runStart = performance.now();
     if (!process.argv.includes('--no-run')) exports.main();
@@ -145,7 +145,9 @@ try {
   // if (cache) process.stdout.write(cache);
 } catch (e) {
   // if (cache) process.stdout.write(cache);
-  console.error(process.argv.includes('-i') ? e : `${e.constructor.name}: ${e.message}`);
+  let out = e;
+  if (!process.argv.includes('-i') && Object.getPrototypeOf(e).message != null) out = `${e.constructor.name}${e.message != null ? `: ${e.message}` : ''}`;
+  console.error(out);
 }
 
 if (process.argv.includes('-t')) console.log(`${process.argv.includes('-b') ? '' : '\n\n'}total time: ${(performance.now() - start).toFixed(2)}ms\nexecution time: ${(performance.now() - runStart).toFixed(2)}ms`);

package/runner/repl.js

@@ -40,10 +40,9 @@ let lastMemory, lastPages;
 const PageSize = 65536;
 const memoryToString = mem => {
   let out = '';
-  const pages = lastPages.length;
   const wasmPages = mem.buffer.byteLength / PageSize;
 
-  out += `\x1B[1mallocated ${mem.buffer.byteLength / 1024}KB\x1B[0m for ${pages} thing${pages === 1 ? '' : 's'} using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}\n\n`;
+  out += `\x1B[1mallocated ${mem.buffer.byteLength / 1024}KiB\x1B[0m (using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'})\n\n`;
 
   const buf = new Uint8Array(mem.buffer);
 
@@ -55,10 +54,16 @@ const memoryToString = mem => {
   }
 
   out += `\x1B[0m\x1B[1m  name${' '.repeat(longestName - 4)} \x1B[0m\x1B[90m│\x1B[0m\x1B[1m type${' '.repeat(longestType - 4)} \x1B[0m\x1B[90m│\x1B[0m\x1B[1m memory\x1B[0m\n`; // ─
-  for (let i = 0; i < pages; i++) {
-    const [ type, name ] = lastPages[i].split(': ');
-    // out += `\x1B[36m${lastPages[i].replace(':', '\x1B[90m:\x1B[34m')}\x1B[90m${' '.repeat(longestName - lastPages[i].length)} | \x1B[0m`;
-    out += `  \x1B[34m${name}${' '.repeat(longestName - name.length)} \x1B[90m│\x1B[0m \x1B[36m${type}${' '.repeat(longestType - type.length)} \x1B[90m│\x1B[0m `;
+  for (let i = 0; i < wasmPages; i++) {
+    if (lastPages[i]) {
+      const [ type, name ] = lastPages[i].split(': ');
+      // out += `\x1B[36m${lastPages[i].replace(':', '\x1B[90m:\x1B[34m')}\x1B[90m${' '.repeat(longestName - lastPages[i].length)} | \x1B[0m`;
+      out += `  \x1B[34m${name}${' '.repeat(longestName - name.length)} \x1B[90m│\x1B[0m \x1B[36m${type}${' '.repeat(longestType - type.length)} \x1B[90m│\x1B[0m `;
+    } else {
+      const type = '???';
+      const name = '???';
+      out += `  \x1B[34m${name}${' '.repeat(longestName - name.length)} \x1B[90m│\x1B[0m \x1B[36m${type}${' '.repeat(longestType - type.length)} \x1B[90m│\x1B[0m `;
+    }
 
     for (let j = 0; j < 40; j++) {
       const val = buf[i * pageSize + j];