porffor 0.17.0-9c7bd8098 → 0.17.0-a23029b3a

package/compiler/pgo.js

@@ -91,7 +91,9 @@ export const run = obj => {
       },
       w: (ind, outPtr) => { // readArgv
         const pgoInd = process.argv.indexOf('--pgo');
-        const args = process.argv.slice(pgoInd).filter(x => !x.startsWith('-'));
+        let args = process.argv.slice(pgoInd);
+        args = args.slice(args.findIndex(x => !x.startsWith('-')) + 1);
+
         const str = args[ind - 1];
         if (pgoInd === -1 || !str) {
           if (Prefs.pgoLog) console.log('\nPGO warning: script was expecting arguments, please specify args to use for PGO after --pgo arg');
@@ -100,6 +102,9 @@ export const run = obj => {
 
         writeByteStr(exports.$, outPtr, str);
         return str.length;
+      },
+      q: (pathPtr, outPtr) => {
+        return -1;
       }
     }, () => {});
 
@@ -179,6 +184,9 @@ export const run = obj => {
 
   log = '';
   for (const x of funcs) {
+    // skip pgo opt for main()
+    if (x.name === 'main') continue;
+
     const wasmFunc = wasmFuncs.find(y => y.name === x.name);
 
     let targets = [];

package/compiler/precompile.js

@@ -6,6 +6,8 @@ import { join } from 'node:path';
 
 import { fileURLToPath } from 'node:url';
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
+globalThis.precompileCompilerPath = __dirname;
+globalThis.precompile = true;
 
 const argv = process.argv.slice();
 
@@ -14,7 +16,7 @@ const compile = async (file, [ _funcs, _globals ]) => {
   let first = source.slice(0, source.indexOf('\n'));
 
   if (first.startsWith('export default')) {
-    source = (await import(file)).default();
+    source = await (await import(file)).default();
     first = source.slice(0, source.indexOf('\n'));
   }
 
@@ -117,7 +119,7 @@ ${funcs.map(x => {
     locals: ${JSON.stringify(Object.values(x.locals).slice(x.params.length).map(x => x.type))},
     localNames: ${JSON.stringify(Object.keys(x.locals))},
 ${x.data && x.data.length > 0 ? `    data: ${JSON.stringify(x.data)},` : ''}
-${x.table ? `    table: true` : ''}
+${x.table ? `    table: true,` : ''}${x.constr ? `    constr: true,` : ''}
   };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');
 }).join('\n')}
 };`;

package/compiler/prototype.js

@@ -208,72 +208,6 @@ export const PrototypeFuncs = function() {
       //   ...number(1, Valtype.i32),
       //   [ Opcodes.i32_sub ]
       // ]),
-    ],
-
-    fill: (pointer, length, wElement, wType, iTmp, iTmp2) => [
-      ...wElement,
-      [ Opcodes.local_set, iTmp ],
-
-      // use cached length i32 as pointer
-      ...length.getCachedI32(),
-
-      // length - 1 for indexes
-      ...number(1, Valtype.i32),
-      [ Opcodes.i32_sub ],
-
-      // * sizeof value
-      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
-      [ Opcodes.i32_mul ],
-
-      ...length.setCachedI32(),
-
-      ...(noUnlikelyChecks ? [] : [
-        ...length.getCachedI32(),
-        ...number(0, Valtype.i32),
-        [ Opcodes.i32_lt_s ],
-        [ Opcodes.if, Blocktype.void ],
-        ...pointer,
-        Opcodes.i32_from_u,
-        [ Opcodes.br, 1 ],
-        [ Opcodes.end ]
-      ]),
-
-      [ Opcodes.loop, Blocktype.void ],
-
-      // calculate offset
-      ...length.getCachedI32(),
-      ...pointer,
-      [ Opcodes.i32_add ],
-      [ Opcodes.local_set, iTmp2 ],
-
-      // store value
-      [ Opcodes.local_get, iTmp2 ],
-      [ Opcodes.local_get, iTmp ],
-      [ Opcodes.store, 0, ValtypeSize.i32 ],
-
-      // store type
-      [ Opcodes.local_get, iTmp2 ],
-      ...wType,
-      [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
-
-      // pointer - sizeof value
-      ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
-      [ Opcodes.i32_sub ],
-
-      ...length.setCachedI32(),
-
-      // if pointer >= 0, loop
-      ...length.getCachedI32(),
-      ...number(0, Valtype.i32),
-      [ Opcodes.i32_ge_s ],
-      [ Opcodes.br_if, 0 ],
-
-      [ Opcodes.end ],
-
-      // return this array
-      ...pointer,
-      Opcodes.i32_from_u,
     ]
   };
 
@@ -282,9 +216,6 @@ export const PrototypeFuncs = function() {
   this[TYPES.array].push.noArgRetLength = true;
   this[TYPES.array].push.local = Valtype.i32;
   this[TYPES.array].pop.local = Valtype.i32;
-  this[TYPES.array].fill.local = valtypeBinary;
-  this[TYPES.array].fill.local2 = Valtype.i32;
-  this[TYPES.array].fill.returnType = TYPES.array;
 
   this[TYPES.string] = {
     at: (pointer, length, wIndex, wType, iTmp, _, arrayShell) => {

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));
 
@@ -235,8 +248,10 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
         y: () => {},
         z: () => {},
         w: (ind, outPtr) => { // readArgv
-          const args = process.argv.slice(2).filter(x => !x.startsWith('-'));
-          const str = args[ind];
+          let args = process.argv.slice(2);
+          args = args.slice(args.findIndex(x => !x.startsWith('-')) + 1);
+
+          const str = args[ind - 1];
           if (!str) return -1;
 
           writeByteStr(memory, outPtr, str);
@@ -244,7 +259,7 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
         },
         q: (pathPtr, outPtr) => { // readFile
           try {
-            const path = readByteStr(memory, pathPtr);
+            const path = pathPtr === 0 ? 0 : readByteStr(memory, pathPtr);
             const contents = fs.readFileSync(path, 'utf8');
             writeByteStr(memory, outPtr, contents);
             return contents.length;
@@ -297,16 +312,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;
 
-          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);
+          }
 
-          // no constructor, just throw message
-          if (!constructorName) throw exception.message;
+          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 constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
-          throw new constructor(exception.message);
+            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 (exceptionMode === 'partial') {
+            const exceptId = e.getArg(exceptTag, 0);
+            const exception = exceptions[exceptId];
+
+            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-9c7bd8098",
+  "version": "0.17.0-a23029b3a",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/rhemyn/README.md

@@ -24,13 +24,16 @@ Made for use with Porffor but could possibly be adapted, implementation/library
   - 🟢 digit, not digit (eg `\d\D`)
   - 🟢 word, not word (eg `\w\W`)
   - 🟢 whitespace, not whitespace (eg `\s\S`)
-- 🟠 quantifiers
-  - 🟠 star (eg `a*`)
-  - 🟠 plus (eg `a+`)
-  - 🟠 optional (eg `a?`)
+- 🟡 quantifiers
+  - 🟡 star (eg `a*`)
+  - 🟡 plus (eg `a+`)
+  - 🟡 optional (eg `a?`)
   - 🟠 lazy modifier (eg `a*?`)
   - 🔴 n repetitions (eg `a{4}`)
   - 🔴 n-m repetitions (eg `a{2,4}`)
+- 🟠 groups
+  - 🟠 capturing groups (`(a)`)
+  - 🔴 non-capturing groups (`(?:a)`)
 - 🔴 assertions
   - 🔴 beginning (eg `^a`)
   - 🔴 end (eg `a$`)