porffor 0.18.22 → 0.18.24

package/compiler/builtins/typedarray.js

@@ -6,31 +6,39 @@ 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;
   let bufferPtr: i32;
 
   const type: i32 = Porffor.rawType(arg);
-  if (type == Porffor.TYPES.arraybuffer) {
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.arraybuffer,
+    type == Porffor.TYPES.sharedarraybuffer
+  )) {
     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);
+    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) / ${name}.BYTES_PER_ELEMENT;
 
-      if (!Number.isInteger(len)) throw new RangeError('byte length of ${name} should be divisible by 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 {
     bufferPtr = Porffor.allocate();
@@ -39,7 +47,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,19 +63,59 @@ 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);
+  const out: ArrayBuffer = Porffor.wasm.i32.load(_this, 0, 4) - Porffor.wasm.i32.load(_this, 0, 8);
   return out;
 };
 
 export const __${name}_prototype_byteLength$get = (_this: ${name}) => {
-  return _this.length * ${name}.BYTES_PER_ELEMENT;
+  return Porffor.wasm.i32.load(_this, 0, 0) * ${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) => {
@@ -99,7 +148,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;
       }