porffor 0.18.22 → 0.18.24

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

@@ -9,7 +9,7 @@ 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 > 34359738368) throw new RangeError('Invalid ArrayBuffer length (>32GiB)');
+  if (length > 4294967295) throw new RangeError('Invalid ArrayBuffer length (over 32 bit address space)');
 
   length |= 0;
 
@@ -20,5 +20,230 @@ export const ArrayBuffer = function (length: number): ArrayBuffer {
 };
 
 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/dataview.ts

@@ -0,0 +1,261 @@
+import type {} from './porffor.d.ts';
+
+export const DataView = function (arg: any, byteOffset: any, length: any): DataView {
+  if (!new.target) throw new TypeError("Constructor DataView requires 'new'");
+
+  const out: DataView = Porffor.allocateBytes(12);
+  const outPtr: i32 = Porffor.wasm`local.get ${out}`;
+
+  let len: i32 = 0;
+  let bufferPtr: i32;
+
+  const type: i32 = Porffor.rawType(arg);
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.arraybuffer,
+    type == Porffor.TYPES.sharedarraybuffer
+  )) {
+    bufferPtr = Porffor.wasm`local.get ${arg}`;
+
+    if (arg.detached) throw new TypeError('Constructed DataView with a detached ArrayBuffer');
+
+    let offset: i32 = 0;
+    if (Porffor.rawType(byteOffset) != Porffor.TYPES.undefined) offset = Math.trunc(byteOffset);
+    if (offset < 0) throw new RangeError('Invalid DataView byte offset (negative)');
+
+    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;
+    } else len = Math.trunc(length);
+  } else {
+    throw new TypeError('First argument to DataView constructor must be an ArrayBuffer');
+  }
+
+  if (len < 0) throw new RangeError('Invalid DataView length (negative)');
+  if (len > 4294967295) throw new RangeError('Invalid DataView length (over 32 bit address space)');
+
+  Porffor.wasm.i32.store(outPtr, len, 0, 0);
+  return out;
+};
+
+export const __DataView_prototype_buffer$get = (_this: DataView) => {
+  const out: ArrayBuffer = Porffor.wasm.i32.load(_this, 0, 4) - Porffor.wasm.i32.load(_this, 0, 8);
+  return out;
+};
+
+export const __DataView_prototype_byteLength$get = (_this: DataView) => {
+  return Porffor.wasm.i32.load(_this, 0, 0);
+};
+
+export const __DataView_prototype_byteOffset$get = (_this: DataView) => {
+  return Porffor.wasm.i32.load(_this, 0, 8);
+};
+
+
+export const __DataView_prototype_getUint8 = (_this: DataView, byteOffset: number) => {
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.fastOr(byteOffset < 0, byteOffset >= len)) throw new RangeError('Byte offset is out of bounds of the DataView');
+
+  Porffor.wasm`
+local.get ${_this}
+i32.to_u
+i32.load 0 4
+local.get ${byteOffset}
+i32.to_u
+i32.add
+i32.load8_u 0 4
+i32.from_u
+i32.const 0
+return`;
+};
+
+export const __DataView_prototype_setUint8 = (_this: DataView, byteOffset: number, value: number) => {
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.fastOr(byteOffset < 0, byteOffset >= len)) throw new RangeError('Byte offset is out of bounds of the DataView');
+
+  Porffor.wasm`
+local.get ${_this}
+i32.to_u
+i32.load 0 4
+local.get ${byteOffset}
+i32.to_u
+i32.add
+local.get ${value}
+i32.to_u
+i32.store8 0 4`;
+
+  return undefined;
+};
+
+export const __DataView_prototype_getInt8 = (_this: DataView, byteOffset: number) => {
+  const n: i32 = __DataView_prototype_getUint8(_this, byteOffset);
+  return n & 0x80 ? n ^ -0x100 : n;
+};
+
+export const __DataView_prototype_setInt8 = (_this: DataView, byteOffset: number, value: number) => {
+  return __DataView_prototype_setUint8(_this, byteOffset, value < 0 ? value | 0x100 : value);
+};
+
+
+export const __DataView_prototype_getUint16 = (_this: DataView, byteOffset: number, littleEndian: any) => {
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.fastOr(byteOffset < 0, byteOffset + 1 >= len)) throw new RangeError('Byte offset is out of bounds of the DataView');
+
+  let byte1: i32 = 0, byte2: i32 = 0;
+  Porffor.wasm`local ptr i32
+local.get ${_this}
+i32.to_u
+i32.load 0 4
+local.get ${byteOffset}
+i32.to_u
+i32.add
+local.set ptr
+
+local.get ptr
+i32.load8_u 0 4
+i32.from_u
+local.set ${byte1}
+local.get ptr
+i32.load8_u 0 5
+i32.from_u
+local.set ${byte2}`;
+
+  if (Boolean(littleEndian)) return byte1 | (byte2 << 8);
+  return (byte1 << 8) | byte2;
+};
+
+export const __DataView_prototype_setUint16 = (_this: DataView, byteOffset: number, value: number, littleEndian: any) => {
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.fastOr(byteOffset < 0, byteOffset + 1 >= len)) throw new RangeError('Byte offset is out of bounds of the DataView');
+
+  let byte1: i32 = 0, byte2: i32 = 0;
+  if (littleEndian) {
+    byte1 = value & 0xff;
+    byte2 = (value >>> 8) & 0xff;
+  } else {
+    byte1 = (value >>> 8) & 0xff;
+    byte2 = value & 0xff;
+  }
+
+  Porffor.wasm`local ptr i32
+local.get ${_this}
+i32.to_u
+i32.load 0 4
+local.get ${byteOffset}
+i32.to_u
+i32.add
+local.set ptr
+
+local.get ptr
+local.get ${byte1}
+i32.to_u
+i32.store8 0 4
+local.get ptr
+local.get ${byte2}
+i32.to_u
+i32.store8 0 5`;
+
+  return undefined;
+};
+
+export const __DataView_prototype_getInt16 = (_this: DataView, byteOffset: number, littleEndian: any) => {
+  const n: i32 = __DataView_prototype_getUint16(_this, byteOffset, littleEndian);
+  return n & 0x8000 ? n ^ -0x10000 : n;
+};
+
+export const __DataView_prototype_setInt16 = (_this: DataView, byteOffset: number, value: number, littleEndian: any) => {
+  return __DataView_prototype_setUint16(_this, byteOffset, value < 0 ? value | 0x10000 : value, littleEndian);
+};
+
+
+export const __DataView_prototype_getUint32 = (_this: DataView, byteOffset: number, littleEndian: any) => {
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.fastOr(byteOffset < 0, byteOffset + 3 >= len)) throw new RangeError('Byte offset is out of bounds of the DataView');
+
+  let byte1: i32 = 0, byte2: i32 = 0, byte3: i32 = 0, byte4: i32 = 0;
+  Porffor.wasm`local ptr i32
+local.get ${_this}
+i32.to_u
+i32.load 0 4
+local.get ${byteOffset}
+i32.to_u
+i32.add
+local.set ptr
+
+local.get ptr
+i32.load8_u 0 4
+i32.from_u
+local.set ${byte1}
+local.get ptr
+i32.load8_u 0 5
+i32.from_u
+local.set ${byte2}
+local.get ptr
+i32.load8_u 0 6
+i32.from_u
+local.set ${byte3}
+local.get ptr
+i32.load8_u 0 7
+i32.from_u
+local.set ${byte4}`;
+
+  if (Boolean(littleEndian)) return byte1 | (byte2 << 8) | (byte3 << 16) | (byte4 << 24);
+  return (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
+};
+
+export const __DataView_prototype_setUint32 = (_this: DataView, byteOffset: number, value: number, littleEndian: any) => {
+  const len: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  if (Porffor.fastOr(byteOffset < 0, byteOffset + 3 >= len)) throw new RangeError('Byte offset is out of bounds of the DataView');
+
+  let byte1: i32 = 0, byte2: i32 = 0, byte3: i32 = 0, byte4: i32 = 0;
+  if (littleEndian) {
+    byte1 = value & 0xff;
+    byte2 = (value >>> 8) & 0xff;
+    byte3 = (value >>> 16) & 0xff;
+    byte4 = (value >>> 24) & 0xff;
+  } else {
+    byte1 = (value >>> 24) & 0xff;
+    byte2 = (value >>> 16) & 0xff;
+    byte3 = (value >>> 8) & 0xff;
+    byte4 = value & 0xff;
+  }
+
+  Porffor.wasm`local ptr i32
+local.get ${_this}
+i32.to_u
+i32.load 0 4
+local.get ${byteOffset}
+i32.to_u
+i32.add
+local.set ptr
+
+local.get ptr
+local.get ${byte1}
+i32.to_u
+i32.store8 0 4
+local.get ptr
+local.get ${byte2}
+i32.to_u
+i32.store8 0 5
+local.get ptr
+local.get ${byte3}
+i32.to_u
+i32.store8 0 6
+local.get ptr
+local.get ${byte4}
+i32.to_u
+i32.store8 0 7`;
+
+  return undefined;
+};
+
+export const __DataView_prototype_getInt32 = (_this: DataView, byteOffset: number, littleEndian: any) => {
+  const n: i32 = __DataView_prototype_getUint32(_this, byteOffset, littleEndian);
+  return n & 0x80000000 ? n ^ -0x100000000 : n;
+};
+
+export const __DataView_prototype_setInt32 = (_this: DataView, byteOffset: number, value: number, littleEndian: any) => {
+  return __DataView_prototype_setUint32(_this, byteOffset, value < 0 ? value | 0x100000000 : value, littleEndian);
+};

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;