porffor 0.0.0-758fed5 → 0.0.0-7d5ae9c

package/compiler/decompile.js

@@ -57,7 +57,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       out += ` ;; label @${depth}`;
     }
 
-    if (inst[0] === Opcodes.br) {
+    if (inst[0] === Opcodes.br || inst[0] === Opcodes.br_if) {
       out += ` ;; goto @${depth - inst[1]}`;
     }
 

package/compiler/embedding.js

@@ -9,11 +9,15 @@ export const number = (n, valtype = valtypeBinary) => {
   }
 };
 
-const enforceTwoBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0 ];
+export const enforceOneByte = arr => [ arr[0] ?? 0 ];
+export const enforceTwoBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0 ];
+export const enforceFourBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0 ];
+export const enforceEightBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0, arr[4] ?? 0, arr[5] ?? 0, arr[6] ?? 0, arr[7] ?? 0 ];
+
 export const i32x4 = (a, b, c, d) => [ [
   ...Opcodes.v128_const,
-  ...enforceTwoBytes(signedLEB128(a)),
-  ...enforceTwoBytes(signedLEB128(b)),
-  ...enforceTwoBytes(signedLEB128(c)),
-  ...enforceTwoBytes(signedLEB128(d))
+  ...enforceFourBytes(signedLEB128(a)),
+  ...enforceFourBytes(signedLEB128(b)),
+  ...enforceFourBytes(signedLEB128(c)),
+  ...enforceFourBytes(signedLEB128(d))
 ] ];

package/compiler/index.js

@@ -4,6 +4,8 @@ import opt from './opt.js';
 import produceSections from './sections.js';
 import decompile from './decompile.js';
 import { BuiltinPreludes } from './builtins.js';
+import toc from './2c.js';
+
 
 globalThis.decompile = decompile;
 
@@ -15,7 +17,8 @@ const areaColors = {
   codegen: [ 20, 80, 250 ],
   opt: [ 250, 20, 80 ],
   sections: [ 20, 250, 80 ],
-  alloc: [ 250, 250, 20 ]
+  alloc: [ 250, 250, 20 ],
+  '2c': [ 20, 250, 250 ]
 };
 
 globalThis.log = (area, ...args) => console.log(`\u001b[90m[\u001b[0m${rgb(...areaColors[area], area)}\u001b[90m]\u001b[0m`, ...args);
@@ -36,10 +39,16 @@ const logFuncs = (funcs, globals, exceptions) => {
   console.log();
 };
 
+const getArg = name => process.argv.find(x => x.startsWith(`-${name}=`))?.slice(name.length + 2);
+
+const writeFileSync = (typeof process !== 'undefined' ? (await import('node:fs')).writeFileSync : undefined);
+const execSync = (typeof process !== 'undefined' ? (await import('node:child_process')).execSync : undefined);
+
 export default (code, flags) => {
   globalThis.optLog = process.argv.includes('-opt-log');
   globalThis.codeLog = process.argv.includes('-code-log');
   globalThis.allocLog = process.argv.includes('-alloc-log');
+  globalThis.regexLog = process.argv.includes('-regex-log');
 
   for (const x in BuiltinPreludes) {
     if (code.indexOf(x + '(') !== -1) code = BuiltinPreludes[x] + code;
@@ -50,7 +59,7 @@ export default (code, flags) => {
   if (flags.includes('info')) console.log(`1. parsed in ${(performance.now() - t0).toFixed(2)}ms`);
 
   const t1 = performance.now();
-  const { funcs, globals, tags, exceptions, pages } = codeGen(program);
+  const { funcs, globals, tags, exceptions, pages, data } = codeGen(program);
   if (flags.includes('info')) console.log(`2. generated code in ${(performance.now() - t1).toFixed(2)}ms`);
 
   if (process.argv.includes('-funcs')) logFuncs(funcs, globals, exceptions);
@@ -62,15 +71,48 @@ export default (code, flags) => {
   if (process.argv.includes('-opt-funcs')) logFuncs(funcs, globals, exceptions);
 
   const t3 = performance.now();
-  const sections = produceSections(funcs, globals, tags, pages, flags);
+  const sections = produceSections(funcs, globals, tags, pages, data, flags);
   if (flags.includes('info')) console.log(`4. produced sections in ${(performance.now() - t3).toFixed(2)}ms`);
 
   if (allocLog) {
     const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
     const bytes = wasmPages * 65536;
     log('alloc', `\x1B[1mallocated ${bytes / 1024}KiB\x1B[0m for ${pages.size} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}`);
-    // console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n'));
+    console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n') + '\n');
+  }
+
+  const out = { wasm: sections, funcs, globals, tags, exceptions, pages };
+
+  const target = getArg('target') ?? getArg('t') ?? 'wasm';
+  const outFile = getArg('o');
+
+  if (target === 'c') {
+    const c = toc(out);
+
+    if (outFile) {
+      writeFileSync(outFile, c);
+    } else {
+      console.log(c);
+    }
+
+    process.exit();
+  }
+
+  if (target === 'native') {
+    const compiler = getArg('compiler') ?? 'clang';
+    const cO = getArg('cO') ?? 'Ofast';
+
+    const tmpfile = 'tmp.c';
+    const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native' ];
+
+    const c = toc(out);
+    writeFileSync(tmpfile, c);
+
+    // obvious command escape is obvious
+    execSync(args.join(' '), { stdio: 'inherit' });
+
+    process.exit();
   }
 
-  return { wasm: sections, funcs, globals, tags, exceptions, pages };
+  return out;
 };

package/compiler/opt.js

@@ -142,7 +142,7 @@ export default (funcs, globals) => {
             depth--;
             if (depth <= 0) break;
           }
-          if (op === Opcodes.br) {
+          if (op === Opcodes.br || op === Opcodes.br_if) {
             hasBranch = true;
             break;
           }
@@ -317,28 +317,24 @@ export default (funcs, globals) => {
         continue;
       }
 
-      if (i < 2) continue;
-      const lastLastInst = wasm[i - 2];
+      // remove unneeded before get with update exprs (n++, etc) when value is unused
+      if (i < wasm.length - 4 && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get && wasm[i + 1][0] === Opcodes.const && [Opcodes.add, Opcodes.sub].includes(wasm[i + 2][0]) && wasm[i + 3][0] === Opcodes.local_set && wasm[i + 3][1] === inst[1] && (wasm[i + 4][0] === Opcodes.drop || wasm[i + 4][0] === Opcodes.br)) {
+        // local.get 1
+        // local.get 1
+        // -->
+        // local.get 1
 
-      if (depth.length === 2) {
-        // hack to remove unneeded before get in for loops with (...; i++)
-        if (lastLastInst[0] === Opcodes.end && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get) {
-          // local.get 1
-          // local.get 1
-          // -->
-          // local.get 1
-
-          // remove drop at the end as well
-          if (wasm[i + 4][0] === Opcodes.drop) {
-            wasm.splice(i + 4, 1);
-          }
+        // remove drop at the end as well
+        if (wasm[i + 4][0] === Opcodes.drop) wasm.splice(i + 4, 1);
 
-          wasm.splice(i, 1); // remove this inst (second get)
-          i--;
-          continue;
-        }
+        wasm.splice(i, 1); // remove this inst (second get)
+        i--;
+        continue;
       }
 
+      if (i < 2) continue;
+      const lastLastInst = wasm[i - 2];
+
       if (lastLastInst[1] === inst[1] && inst[0] === Opcodes.local_get && lastInst[0] === Opcodes.local_tee && lastLastInst[0] === Opcodes.local_set) {
         // local.set x
         // local.tee y

package/compiler/parse.js

@@ -1,3 +1,4 @@
+// import { parse } from 'acorn';
 const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
 
 export default (input, flags) => {

package/compiler/prototype.js

@@ -15,13 +15,17 @@ const TYPES = {
   bigint: 0xffffffffffff7,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0xfffffffffff0f,
+  _regexp: 0xfffffffffff1f
 };
 
 // todo: turn these into built-ins once arrays and these become less hacky
 
 export const PrototypeFuncs = function() {
   const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
+  let zeroChecks = process.argv.find(x => x.startsWith('-funsafe-zero-proto-checks='));
+  if (zeroChecks) zeroChecks = zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
+    else zeroChecks = {};
 
   this[TYPES._array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
@@ -35,7 +39,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
       [ Opcodes.if, Blocktype.void ],
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_add ],
       [ Opcodes.local_set, iTmp ],
       [ Opcodes.end ],
@@ -46,7 +50,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
 
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_ge_s ],
       [ Opcodes.i32_or ],
 
@@ -66,7 +70,7 @@ export const PrototypeFuncs = function() {
     // todo: only for 1 argument
     push: (pointer, length, wNewMember) => [
       // get memory offset of array at last index (length)
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
@@ -78,17 +82,17 @@ export const PrototypeFuncs = function() {
 
       // bump array length by 1 and return it
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_add ]
       ]),
 
-      ...length.get
+      ...length.get()
     ],
 
     pop: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -99,13 +103,13 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ]
       ]),
 
       // load last element
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
@@ -114,7 +118,7 @@ export const PrototypeFuncs = function() {
 
     shift: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       Opcodes.i32_eqz,
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -125,7 +129,7 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ]
       ]),
@@ -139,14 +143,69 @@ export const PrototypeFuncs = function() {
       ...number(pointer + ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32), // src = base array index + length size + an index
       ...number(pageSize - ValtypeSize.i32 - ValtypeSize[valtype], Valtype.i32), // size = PageSize - length size - an index
       [ ...Opcodes.memory_copy, 0x00, 0x00 ]
+    ],
+
+    fill: (pointer, length, wElement, iTmp) => [
+      ...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], Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      ...length.setCachedI32(),
+
+      ...(noUnlikelyChecks ? [] : [
+        ...length.getCachedI32(),
+        ...number(0, Valtype.i32),
+        [ Opcodes.i32_lt_s ],
+        [ Opcodes.if, Blocktype.void ],
+        ...number(pointer),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ]
+      ]),
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // set element using pointer
+      ...length.getCachedI32(),
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+
+      // pointer - sizeof value
+      ...length.getCachedI32(),
+      ...number(ValtypeSize[valtype], 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
+      ...number(pointer)
     ]
   };
 
   this[TYPES._array].at.local = Valtype.i32;
   this[TYPES._array].push.noArgRetLength = true;
+  this[TYPES._array].fill.local = valtypeBinary;
+  this[TYPES._array].fill.returnType = TYPES._array;
 
   this[TYPES.string] = {
-    at: (pointer, length, wIndex, iTmp, arrayShell) => {
+    at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -165,7 +224,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
         [ Opcodes.if, Blocktype.void ],
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_add ],
         [ Opcodes.local_set, iTmp ],
         [ Opcodes.end ],
@@ -176,7 +235,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
 
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_ge_s ],
         [ Opcodes.i32_or ],
 
@@ -201,7 +260,7 @@ export const PrototypeFuncs = function() {
     },
 
     // todo: out of bounds properly
-    charAt: (pointer, length, wIndex, _, arrayShell) => {
+    charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -232,39 +291,120 @@ export const PrototypeFuncs = function() {
       return [
         ...wIndex,
         Opcodes.i32_to,
-        [ Opcodes.local_set, iTmp ],
 
-        // index < 0
-        ...(noUnlikelyChecks ? [] : [
+        ...(zeroChecks.charcodeat ? [] : [
+          [ Opcodes.local_set, iTmp ],
+
+          // index < 0
+          ...(noUnlikelyChecks ? [] : [
+            [ Opcodes.local_get, iTmp ],
+            ...number(0, Valtype.i32),
+            [ Opcodes.i32_lt_s ],
+          ]),
+
+          // index >= length
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
+
+          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+          [ Opcodes.if, Blocktype.void ],
+          ...number(NaN),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
+
           [ Opcodes.local_get, iTmp ],
-          ...number(0, Valtype.i32),
-          [ Opcodes.i32_lt_s ],
         ]),
 
-        // index >= length
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_mul ],
+
+        // load current string ind {arg}
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+        Opcodes.i32_from_u
+      ];
+    },
+
+    isWellFormed: (pointer, length, wIndex, iTmp, iTmp2, arrayShell, { wellFormed } = {}) => {
+      // aot approx metadata
+      if (wellFormed != null) return number(wellFormed ? 1 : 0);
+
+      return [
+        // note: we cannot presume it begins as 0 in case it was used previously
+        ...number(0, Valtype.i32),
+        [ Opcodes.local_set, iTmp ],
+
+        [ Opcodes.loop, Blocktype.void ],
+
+        [ Opcodes.block, Blocktype.void ],
+
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+        [ Opcodes.local_set, iTmp2 ],
+
+        // if not surrogate, continue
+        [ Opcodes.local_get, iTmp2 ],
+        ...number(0xF800, Valtype.i32),
+        [ Opcodes.i32_and ],
+        ...number(0xD800, Valtype.i32),
+        [ Opcodes.i32_ne ],
+        [ Opcodes.br_if, 0 ],
+
+        // if not leading surrogate, return false
+        [ Opcodes.local_get, iTmp2 ],
+        ...number(0xDC00, Valtype.i32),
         [ Opcodes.i32_ge_s ],
+        [ Opcodes.if, Blocktype.void ],
+        ...number(0),
+        [ Opcodes.br, 3 ],
+        [ Opcodes.end ],
 
-        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+        // if not followed by trailing surrogate, return false
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 + ValtypeSize.i16) ],
+        ...number(0xFC00, Valtype.i32),
+        [ Opcodes.i32_and ],
+        ...number(0xDC00, Valtype.i32),
+        [ Opcodes.i32_ne ],
         [ Opcodes.if, Blocktype.void ],
-        ...number(NaN),
-        [ Opcodes.br, 1 ],
+        ...number(0),
+        [ Opcodes.br, 3 ],
         [ Opcodes.end ],
 
+        // bump index again since gone through two valid chars
         [ Opcodes.local_get, iTmp ],
         ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, iTmp ],
+
+        [ Opcodes.end ],
+
+        // bump pointer and loop if not at the end
+        [ Opcodes.local_get, iTmp ],
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_tee, iTmp ],
+
+        ...length.getCachedI32(),
+        ...number(ValtypeSize.i16, Valtype.i32),
         [ Opcodes.i32_mul ],
+        [ Opcodes.i32_ne ],
+        [ Opcodes.br_if, 0 ],
 
-        // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
-        Opcodes.i32_from_u
-      ];
-    },
+        [ Opcodes.end ],
+
+        // return true
+        ...number(1)
+      ]
+    }
   };
 
   this[TYPES.string].at.local = Valtype.i32;
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
+
+  this[TYPES.string].isWellFormed.local = Valtype.i32;
+  this[TYPES.string].isWellFormed.local2 = Valtype.i32;
+  this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
 };

package/compiler/sections.js

@@ -1,5 +1,5 @@
 import { Valtype, FuncType, Empty, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize } from './wasmSpec.js';
-import { encodeVector, encodeString, encodeLocal } from './encoding.js';
+import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128 } from './encoding.js';
 import { number } from './embedding.js';
 import { importedFuncs } from './builtins.js';
 
@@ -20,7 +20,7 @@ const chHint = (topTier, baselineTier, strategy) => {
   return (strategy | (baselineTier << 2) | (topTier << 4));
 };
 
-export default (funcs, globals, tags, pages, flags) => {
+export default (funcs, globals, tags, pages, data, flags) => {
   const types = [], typeCache = {};
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
@@ -76,6 +76,7 @@ export default (funcs, globals, tags, pages, flags) => {
       }
     }
   }
+  globalThis.importFuncs = importFuncs;
 
   if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
@@ -104,6 +105,8 @@ export default (funcs, globals, tags, pages, flags) => {
 
   const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, x.index ]);
 
+  if (process.argv.includes('-always-memory') && pages.size === 0) pages.set('-always-memory', 0);
+
   const usesMemory = pages.size > 0;
   const memorySection = !usesMemory ? [] : createSection(
     Section.memory,
@@ -154,13 +157,24 @@ export default (funcs, globals, tags, pages, flags) => {
     encodeVector(types)
   );
 
+  const dataSection = data.length === 0 ? [] : createSection(
+    Section.data,
+    encodeVector(data.map(x => [ 0x00, Opcodes.i32_const, ...signedLEB128(x.offset), Opcodes.end, ...encodeVector(x.bytes) ]))
+  );
+
+  const dataCountSection = data.length === 0 ? [] : createSection(
+    Section.data_count,
+    unsignedLEB128(data.length)
+  );
+
   if (process.argv.includes('-sections')) console.log({
     typeSection: typeSection.map(x => x.toString(16)),
     importSection: importSection.map(x => x.toString(16)),
     funcSection: funcSection.map(x => x.toString(16)),
     globalSection: globalSection.map(x => x.toString(16)),
     exportSection: exportSection.map(x => x.toString(16)),
-    codeSection: codeSection.map(x => x.toString(16))
+    codeSection: codeSection.map(x => x.toString(16)),
+    dataSection: dataSection.map(x => x.toString(16)),
   });
 
   return Uint8Array.from([
@@ -174,6 +188,8 @@ export default (funcs, globals, tags, pages, flags) => {
     ...tagSection,
     ...globalSection,
     ...exportSection,
-    ...codeSection
+    ...dataCountSection,
+    ...codeSection,
+    ...dataSection
   ]);
 };

package/compiler/wrap.js

@@ -1,10 +1,11 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-import fs from 'node:fs';
+// import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
 const typeBase = 0xffffffffffff0;
+const internalTypeBase = 0xfffffffffff0f;
 const TYPES = {
   [typeBase]: 'number',
   [typeBase + 1]: 'boolean',
@@ -16,7 +17,8 @@ const TYPES = {
   [typeBase + 7]: 'bigint',
 
   // internal
-  [typeBase + 8]: '_array'
+  [internalTypeBase]: '_array',
+  [internalTypeBase + 1]: '_regexp'
 };
 
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
@@ -27,16 +29,23 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   if (source.includes('export function')) flags.push('module');
 
-  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
+  const getString = pointer => {
+    const length = new Int32Array(memory.buffer, pointer, 1);
+
+    return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+  };
+
   const t2 = performance.now();
   const { instance } = await WebAssembly.instantiate(wasm, {
     '': {
       p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
       c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
+      s: valtype === 'i64' ? i => print(getString(Number(i))) : i => print(getString(i)),
       a: c => { if (!Number(c)) throw new Error(`assert failed`); },
       t: _ => performance.now(),
       ...customImports

package/hi.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+
+double inline f64_f(double x, double y) {
+  return x - (int)(x / y) * y;
+}
+
+double isPrime(double number) {
+  double i;
+
+  if (number < 2e+0) {
+    return 0e+0;
+  }
+  i = 2e+0;
+  while (i < number) {
+    if (f64_f(number, i) == 0e+0) {
+      return 0e+0;
+    }
+    i = i + 1e+0;
+  }
+  return 1e+0;
+}
+
+int main() {
+  double sum;
+  double counter;
+
+  sum = 0e+0;
+  counter = 0e+0;
+  while (counter <= 1e+5) {
+    if (isPrime(counter) == 1e+0) {
+      sum = sum + counter;
+    }
+    counter = counter + 1e+0;
+  }
+  printf("%f\n", sum);
+}
+