porffor 0.18.21 → 0.18.23

package/compiler/assemble.js

@@ -21,6 +21,36 @@ const chHint = (topTier, baselineTier, strategy) => {
   return (strategy | (baselineTier << 2) | (topTier << 4));
 };
 
+const encodeNames = (funcs) => {
+  const encodeSection = (id, section) => [
+    id,
+    ...unsignedLEB128(section.length),
+    ...section
+  ];
+
+  const moduleSection = encodeString('js'); // TODO: filename?
+  const functionsSection = encodeVector(
+    funcs.map((x) => unsignedLEB128(x.index).concat(encodeString(x.name))),
+  );
+  const localsSection = encodeVector(
+    funcs.map((x) =>
+      unsignedLEB128(x.index).concat(
+        encodeVector(
+          Object.entries(x.locals).map(([name, local]) =>
+            unsignedLEB128(local.idx).concat(encodeString(name)),
+          ),
+        ),
+      ),
+    ),
+  );
+
+  return [
+    ...encodeSection(0, moduleSection),
+    ...encodeSection(1, functionsSection),
+    ...encodeSection(2, localsSection),
+  ];
+}
+
 export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) => {
   const types = [], typeCache = {};
 
@@ -112,6 +142,8 @@ export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) =
     encodeVector(funcs.map(x => getType(x.params, x.returns))) // type indexes
   );
 
+  const nameSection = Prefs.d ? customSection('name', encodeNames(funcs)) : [];
+
   const tableSection = !funcs.table ? [] : createSection(
     Section.table,
     encodeVector([ [ Reftype.funcref, 0x00, funcs.length ] ])
@@ -302,6 +334,7 @@ export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) =
     ...elementSection,
     ...dataCountSection,
     ...codeSection,
-    ...dataSection
+    ...dataSection,
+    ...nameSection
   ]);
 };

package/compiler/builtins/array.ts

@@ -1,9 +1,40 @@
 import type {} from './porffor.d.ts';
 
 export const __Array_isArray = (x: unknown): boolean =>
-  // Porffor.wasm`local.get ${x+1}` == Porffor.TYPES.array;
   Porffor.rawType(x) == Porffor.TYPES.array;
 
+export const __Array_from = (arg: any, mapFn: any): any[] => {
+  let out: any[] = Porffor.allocate();
+  let len: i32 = 0;
+
+  const type = Porffor.rawType(arg);
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.array,
+    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
+    type == Porffor.TYPES.set,
+    Porffor.fastAnd(type >= Porffor.TYPES.uint8array, type <= Porffor.TYPES.float64array)
+  )) {
+    const hasMapFn = Porffor.rawType(mapFn) != Porffor.TYPES.undefined;
+
+    let i: i32 = 0;
+    if (hasMapFn) {
+      if (Porffor.rawType(mapFn) != Porffor.TYPES.function) throw new TypeError('Called Array.from with a non-function mapFn');
+
+      for (const x of arg) {
+        out[i] = mapFn(x, i);
+        i++;
+      }
+    } else {
+      for (const x of arg) {
+        out[i++] = x;
+      }
+    }
+    len = i;
+  }
+
+  out.length = len;
+  return out;
+};
 
 export const __Array_prototype_slice = (_this: any[], start: number, end: number) => {
   const len: i32 = _this.length;

package/compiler/builtins/arraybuffer.ts

@@ -0,0 +1,249 @@
+import type {} from './porffor.d.ts';
+
+export const __ArrayBuffer_isView = function (value: any): boolean {
+  if (value.buffer) return true;
+  return false;
+};
+
+export const ArrayBuffer = function (length: number): ArrayBuffer {
+  if (!new.target) throw new TypeError("Constructor ArrayBuffer requires 'new'");
+
+  if (length < 0) throw new RangeError('Invalid ArrayBuffer length (negative)');
+  if (length > 4294967295) throw new RangeError('Invalid ArrayBuffer length (over 32 bit address space)');
+
+  length |= 0;
+
+  const out: ArrayBuffer = Porffor.allocateBytes(length + 4);
+  Porffor.wasm.i32.store(out, length, 0, 0);
+
+  return out;
+};
+
+export const __ArrayBuffer_prototype_byteLength$get = (_this: ArrayBuffer) => {
+  Porffor.wasm`
+local read i32
+local.get ${_this}
+i32.to_u
+i32.load 0 0
+local.tee read
+i32.const 0
+local.get read
+i32.const 0
+i32.ge_s
+select
+i32.from_u
+i32.const 0
+return`;
+};
+
+export const __ArrayBuffer_prototype_maxByteLength$get = (_this: ArrayBuffer) => {
+  Porffor.wasm`
+local read i32
+local.get ${_this}
+i32.to_u
+i32.load 0 0
+local.tee read
+i32.const 0
+local.get read
+i32.const 0
+i32.ge_s
+select
+i32.from_u
+i32.const 0
+return`;
+};
+
+export const __ArrayBuffer_prototype_detached$get = (_this: ArrayBuffer) => {
+  Porffor.wasm`
+local.get ${_this}
+i32.to_u
+i32.load 0 0
+i32.const 4294967295
+i32.eq
+i32.from_u
+i32.const 1
+return`;
+};
+
+export const __ArrayBuffer_prototype_resizable$get = (_this: ArrayBuffer) => {
+  return false;
+};
+
+export const __ArrayBuffer_prototype_slice = (_this: ArrayBuffer, start: number, end: any) => {
+  if (_this.detached) throw new TypeError('Called ArrayBuffer.prototype.slice on a detached ArrayBuffer');
+
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.rawType(end) == Porffor.TYPES.undefined) end = len;
+
+  start |= 0;
+  end |= 0;
+
+  if (start < 0) {
+    start = len + start;
+    if (start < 0) start = 0;
+  }
+  if (start > len) start = len;
+  if (end < 0) {
+    end = len + end;
+    if (end < 0) end = 0;
+  }
+  if (end > len) end = len;
+
+  const out: ArrayBuffer = Porffor.allocateBytes(4 + (end - start));
+  Porffor.wasm.i32.store(out, end - start, 0, 0);
+
+  Porffor.wasm`
+;; dst = out + 4
+local.get ${out}
+i32.to_u
+i32.const 4
+i32.add
+
+;; src = this + 4 + start
+local.get ${_this}
+i32.to_u
+i32.const 4
+i32.add
+local.get ${start}
+i32.to_u
+i32.add
+
+;; size = end - start
+local.get ${end}
+i32.to_u
+local.get ${start}
+i32.to_u
+i32.sub
+
+memory.copy 0 0`;
+
+  return out;
+};
+
+
+export const __ArrayBuffer_prototype_transfer = (_this: ArrayBuffer, newLength: any) => {
+  if (_this.detached) throw new TypeError('Called ArrayBuffer.prototype.transfer on a detached ArrayBuffer');
+
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.rawType(newLength) == Porffor.TYPES.undefined) newLength = len;
+
+  // make new arraybuffer
+  const out: ArrayBuffer = new ArrayBuffer(newLength);
+  Porffor.wasm.i32.store(out, newLength, 0, 0);
+
+  // copy data to it
+  Porffor.wasm`
+;; dst = out + 4
+local.get ${out}
+i32.to_u
+i32.const 4
+i32.add
+
+;; src = this + 4
+local.get ${_this}
+i32.to_u
+i32.const 4
+i32.add
+
+;; size = min(newLength, len)
+local.get ${newLength}
+local.get ${len}
+f64.min
+i32.to_u
+
+memory.copy 0 0`;
+
+  // mark as detached by setting length = "-1"
+  Porffor.wasm.i32.store(_this, 4294967295, 0, 0);
+
+  return out;
+};
+
+export const __ArrayBuffer_prototype_transferToFixedLength = (_this: ArrayBuffer, newLength: any) => __ArrayBuffer_prototype_transfer(_this, newLength);
+
+export const __ArrayBuffer_prototype_resize = (_this: ArrayBuffer, newLength: any) => {
+  // todo: resizable not implemented yet so just always fail
+  throw new TypeError('Called ArrayBuffer.prototype.resize on a non-resizable ArrayBuffer');
+};
+
+
+export const SharedArrayBuffer = function (length: number): SharedArrayBuffer {
+  if (!new.target) throw new TypeError("Constructor SharedArrayBuffer requires 'new'");
+
+  if (length < 0) throw new RangeError('Invalid SharedArrayBuffer length (negative)');
+  if (length > 4294967295) throw new RangeError('Invalid SharedArrayBuffer length (over 32 bit address space)');
+
+  length |= 0;
+
+  const out: SharedArrayBuffer = Porffor.allocateBytes(length + 4);
+  Porffor.wasm.i32.store(out, length, 0, 0);
+
+  return out;
+};
+
+export const __SharedArrayBuffer_prototype_byteLength$get = (_this: SharedArrayBuffer) => {
+  return Porffor.wasm.i32.load(_this, 0, 0);
+};
+
+export const __SharedArrayBuffer_prototype_maxByteLength$get = (_this: SharedArrayBuffer) => {
+  return Porffor.wasm.i32.load(_this, 0, 0);
+};
+
+export const __SharedArrayBuffer_prototype_growable$get = (_this: SharedArrayBuffer) => {
+  return false;
+};
+
+
+export const __SharedArrayBuffer_prototype_slice = (_this: SharedArrayBuffer, start: number, end: any) => {
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.rawType(end) == Porffor.TYPES.undefined) end = len;
+
+  start |= 0;
+  end |= 0;
+
+  if (start < 0) {
+    start = len + start;
+    if (start < 0) start = 0;
+  }
+  if (start > len) start = len;
+  if (end < 0) {
+    end = len + end;
+    if (end < 0) end = 0;
+  }
+  if (end > len) end = len;
+
+  const out: SharedArrayBuffer = Porffor.allocateBytes(4 + (end - start));
+  Porffor.wasm.i32.store(out, end - start, 0, 0);
+
+  Porffor.wasm`
+;; dst = out + 4
+local.get ${out}
+i32.to_u
+i32.const 4
+i32.add
+
+;; src = this + 4 + start
+local.get ${_this}
+i32.to_u
+i32.const 4
+i32.add
+local.get ${start}
+i32.to_u
+i32.add
+
+;; size = end - start
+local.get ${end}
+i32.to_u
+local.get ${start}
+i32.to_u
+i32.sub
+
+memory.copy 0 0`;
+
+  return out;
+};
+
+export const __SharedArrayBuffer_prototype_grow = (_this: SharedArrayBuffer, newLength: any) => {
+  // todo: growable not implemented yet so just always fail
+  throw new TypeError('Called SharedArrayBuffer.prototype.grow on a non-growable SharedArrayBuffer');
+};

package/compiler/builtins/porffor.d.ts

@@ -58,6 +58,8 @@ type PorfforGlobal = {
     bytestring: i32;
     date: i32;
     set: i32;
+
+    [key: string]: i32;
   }
 
   clone(source: any, destination: any): void;

package/compiler/builtins/typedarray.js

@@ -6,12 +6,13 @@ export default async () => {
 
   // TypedArrays are stored like this in memory:
   // length (i32)
-  // bufferPtr (i32)
+  // bufferPtr (i32) - buffer + byteOffset
+  // byteOffset (i32) - only used for getter
 
   const constr = name => out += `export const ${name} = function (arg: any, byteOffset: any, length: any): ${name} {
   if (!new.target) throw new TypeError("Constructor ${name} requires 'new'");
 
-  const out: ${name} = Porffor.allocateBytes(8);
+  const out: ${name} = Porffor.allocateBytes(12);
   const outPtr: i32 = Porffor.wasm\`local.get \${out}\`;
 
   let len: i32 = 0;
@@ -21,8 +22,26 @@ export default async () => {
   if (type == Porffor.TYPES.arraybuffer) {
     bufferPtr = Porffor.wasm\`local.get \${arg}\`;
 
+    if (arg.detached) throw new TypeError('Constructed ${name} with a detached ArrayBuffer');
+
+    let offset: i32 = 0;
+    if (Porffor.rawType(byteOffset) != Porffor.TYPES.undefined) offset = Math.trunc(byteOffset);
+    Porffor.wasm.i32.store(outPtr, offset, 0, 8);
+
+    Porffor.wasm.i32.store(outPtr, bufferPtr + offset, 0, 4);
+
+    if (Porffor.rawType(length) == Porffor.TYPES.undefined) {
+      const bufferLen: i32 = Porffor.wasm.i32.load(bufferPtr, 0, 0);
+      len = (bufferLen - byteOffset) / ${name}.BYTES_PER_ELEMENT;
+
+      if (!Number.isInteger(len)) throw new RangeError('byte length of ${name} should be divisible by BYTES_PER_ELEMENT');
+    } else len = Math.trunc(length);
+  } else if (type == Porffor.TYPES.sharedarraybuffer) {
+    bufferPtr = Porffor.wasm\`local.get \${arg}\`;
+
     let offset: i32 = 0;
     if (Porffor.rawType(byteOffset) != Porffor.TYPES.undefined) offset = Math.trunc(byteOffset);
+    Porffor.wasm.i32.store(outPtr, offset, 0, 8);
 
     Porffor.wasm.i32.store(outPtr, bufferPtr + offset, 0, 4);
 
@@ -39,7 +58,8 @@ export default async () => {
     if (Porffor.fastOr(
       type == Porffor.TYPES.array,
       type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
-      type == Porffor.TYPES.set
+      type == Porffor.TYPES.set,
+      Porffor.fastAnd(type >= Porffor.TYPES.uint8array, type <= Porffor.TYPES.float64array)
     )) {
       let i: i32 = 0;
       for (const x of arg) {
@@ -54,12 +74,48 @@ export default async () => {
   }
 
   if (len < 0) throw new RangeError('Invalid TypedArray length (negative)');
-  if (len > 34359738368) throw new RangeError('Invalid TypedArray length (>32GiB)');
+  if (len > 4294967295) throw new RangeError('Invalid ArrayBuffer length (over 32 bit address space)');
 
   Porffor.wasm.i32.store(outPtr, len, 0, 0);
   return out;
 };
 
+export const __${name}_of = (...items: any[]): ${name} => new ${name}(items);
+
+export const __${name}_from = (arg: any, mapFn: any): ${name} => {
+  const arr: any[] = Porffor.allocate();
+  let len: i32 = 0;
+
+  const type = Porffor.rawType(arg);
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.array,
+    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
+    type == Porffor.TYPES.set,
+    Porffor.fastAnd(type >= Porffor.TYPES.uint8array, type <= Porffor.TYPES.float64array)
+  )) {
+    const hasMapFn = Porffor.rawType(mapFn) != Porffor.TYPES.undefined;
+
+    let i: i32 = 0;
+    if (hasMapFn) {
+      if (Porffor.rawType(mapFn) != Porffor.TYPES.function) throw new TypeError('Called Array.from with a non-function mapFn');
+
+      for (const x of arg) {
+        arr[i] = mapFn(x, i);
+        i++;
+      }
+    } else {
+      for (const x of arg) {
+        arr[i++] = x;
+      }
+    }
+    len = i;
+  }
+
+  arr.length = len;
+
+  return new ${name}(arr);
+};
+
 export const __${name}_prototype_buffer$get = (_this: ${name}) => {
   const out: ArrayBuffer = Porffor.wasm.i32.load(_this, 0, 4);
   return out;
@@ -69,6 +125,10 @@ export const __${name}_prototype_byteLength$get = (_this: ${name}) => {
   return _this.length * ${name}.BYTES_PER_ELEMENT;
 };
 
+export const __${name}_prototype_byteOffset$get = (_this: ${name}) => {
+  return Porffor.wasm.i32.load(_this, 0, 8);
+};
+
 export const __${name}_prototype_at = (_this: ${name}, index: number) => {
   const len: i32 = _this.length;
   index |= 0;
@@ -99,7 +159,7 @@ export const __${name}_prototype_slice = (_this: ${name}, start: number, end: nu
   }
   if (end > len) end = len;
 
-  let out: ${name} = Porffor.allocate();
+  const out: ${name} = Porffor.allocate();
 
   if (start > end) return out;
 

package/compiler/builtins.js

@@ -52,6 +52,12 @@ export const importedFuncs = [
     import: 'q',
     params: 2,
     returns: 1
+  },
+  {
+    name: 'debugger',
+    import: 'b',
+    params: 0,
+    returns: 0,
   }
 ];
 

package/compiler/codegen.js

@@ -137,7 +137,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
     case 'DebuggerStatement':
       // todo: hook into terminal debugger
-      return [];
+      return [[ Opcodes.call, importedFuncs.debugger ]];
 
     case 'ArrayExpression':
       return generateArray(scope, decl, global, name);
@@ -4233,7 +4233,7 @@ const generateMember = (scope, decl, _global, _name) => {
   }
 
   // todo: generate this array procedurally during builtinFuncs creation
-  if (['size', 'description', 'byteLength', 'buffer'].includes(decl.property.name)) {
+  if (['size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength'].includes(decl.property.name)) {
     const bc = {};
     const cands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + decl.property.name + '$get'));
 
@@ -4441,7 +4441,7 @@ const objectHack = node => {
       if (!objectName) objectName = objectHack(node.object)?.name?.slice?.(2);
 
       // if .name or .length, give up (hack within a hack!)
-      if (['name', 'length', 'size', 'description', 'byteLength', 'buffer'].includes(node.property.name)) {
+      if (['name', 'length', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength'].includes(node.property.name)) {
         node.object = objectHack(node.object);
         return;
       }