porffor 0.18.20 → 0.18.21

package/compiler/builtins/array.ts

@@ -36,7 +36,7 @@ export const __Array_prototype_slice = (_this: any[], start: number, end: number
 
   while (thisPtr < thisPtrEnd) {
     Porffor.wasm.f64.store(outPtr, Porffor.wasm.f64.load(thisPtr, 0, 4), 0, 4);
-    Porffor.wasm.i32.store8(outPtr + 8, Porffor.wasm.i32.load8_u(thisPtr + 8, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(outPtr, Porffor.wasm.i32.load8_u(thisPtr, 0, 12), 0, 12);
 
     thisPtr += 9;
     outPtr += 9;
@@ -72,7 +72,7 @@ export const __Array_prototype_splice = (_this: any[], start: number, deleteCoun
 
   while (thisPtr < thisPtrEnd) {
     Porffor.wasm.f64.store(outPtr, Porffor.wasm.f64.load(thisPtr, 0, 4), 0, 4);
-    Porffor.wasm.i32.store8(outPtr + 8, Porffor.wasm.i32.load8_u(thisPtr + 8, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(outPtr, Porffor.wasm.i32.load8_u(thisPtr, 0, 12), 0, 12);
 
     thisPtr += 9;
     outPtr += 9;
@@ -133,7 +133,7 @@ memory.copy 0 0`;
 
     while (thisPtr < thisPtrEnd) {
       Porffor.wasm.f64.store(thisPtr, Porffor.wasm.f64.load(itemsPtr, 0, 4), 0, 4);
-      Porffor.wasm.i32.store8(thisPtr + 8, Porffor.wasm.i32.load8_u(itemsPtr + 8, 0, 4), 0, 4);
+      Porffor.wasm.i32.store8(thisPtr, Porffor.wasm.i32.load8_u(itemsPtr, 0, 12), 0, 12);
 
       thisPtr += 9;
       itemsPtr += 9;

package/compiler/builtins/typedarray.js

@@ -4,28 +4,64 @@ export default async () => {
   const arrayCode = (await import('node:fs')).readFileSync(globalThis.precompileCompilerPath + '/builtins/array.ts', 'utf8');
   const typedArrayFuncs = [...arrayCode.matchAll(/\/\/ @porf-typed-array[\s\S]+?^};$/gm)].map(x => x[0]);
 
-  const constr = name => out += `export const ${name} = function (arg: any): ${name} {
+  // TypedArrays are stored like this in memory:
+  // length (i32)
+  // bufferPtr (i32)
+
+  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.allocate();
+  const out: ${name} = Porffor.allocateBytes(8);
+  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.array,
-    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
-    type == Porffor.TYPES.set
-  )) {
-    let i: i32 = 0;
-    for (const x of arg) {
-      out[i++] = x;
+  if (type == Porffor.TYPES.arraybuffer) {
+    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, 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 {
+    bufferPtr = Porffor.allocate();
+    Porffor.wasm.i32.store(outPtr, bufferPtr, 0, 4);
+
+    if (Porffor.fastOr(
+      type == Porffor.TYPES.array,
+      type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
+      type == Porffor.TYPES.set
+    )) {
+      let i: i32 = 0;
+      for (const x of arg) {
+        out[i++] = x;
+      }
+      len = i;
+    } else if (type == Porffor.TYPES.number) {
+      len = Math.trunc(arg);
     }
-    len = i;
-  } else if (type == Porffor.TYPES.number) {
-    len = arg;
+
+    Porffor.wasm.i32.store(bufferPtr, len * ${name}.BYTES_PER_ELEMENT, 0, 0);
   }
 
-  out.length = len;
+  if (len < 0) throw new RangeError('Invalid TypedArray length (negative)');
+  if (len > 34359738368) throw new RangeError('Invalid TypedArray length (>32GiB)');
+
+  Porffor.wasm.i32.store(outPtr, len, 0, 0);
+  return out;
+};
+
+export const __${name}_prototype_buffer$get = (_this: ${name}) => {
+  const out: ArrayBuffer = Porffor.wasm.i32.load(_this, 0, 4);
   return out;
 };
 

package/compiler/builtins/typedarray.ts

@@ -0,0 +1,19 @@
+import type {} from './porffor.d.ts';
+
+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)');
+
+  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) => {
+  return Porffor.wasm.i32.load(_this, 0, 0);
+};

package/compiler/builtins.js

@@ -1159,7 +1159,7 @@ export const BuiltinFuncs = function() {
       [ Opcodes.global_get, 1 ],
       ...number(pageSize, Valtype.i32),
       [ Opcodes.i32_ge_s ],
-      [ Opcodes.if, Blocktype.void ],
+      [ Opcodes.if, Valtype.i32 ],
         // bytesWritten = bytesToAllocate
         [ Opcodes.local_get, 0 ],
         [ Opcodes.global_set, 1 ],
@@ -1168,20 +1168,27 @@ export const BuiltinFuncs = function() {
         ...number(1, Valtype.i32),
         [ Opcodes.memory_grow, 0x00 ],
 
-        // currentPtr = old page count * pageSize
+        // currentPtr = old page count * pageSize + bytesToAllocate
         ...number(pageSize, Valtype.i32),
         [ Opcodes.i32_mul ],
+        [ Opcodes.local_get, 0 ],
+        [ Opcodes.i32_add ],
         [ Opcodes.global_set, 0 ],
+
+        // return currentPtr - bytesToAllocate
+        [ Opcodes.global_get, 0 ],
+        [ Opcodes.local_get, 0 ],
+        [ Opcodes.i32_sub ],
       [ Opcodes.else ],
         // else, currentPtr += bytesToAllocate
         [ Opcodes.global_get, 0 ],
         [ Opcodes.local_get, 0 ],
         [ Opcodes.i32_add ],
         [ Opcodes.global_set, 0 ],
-      [ Opcodes.end ],
 
-      // return currentPtr
-      [ Opcodes.global_get, 0 ]
+        // return currentPtr
+        [ Opcodes.global_get, 0 ],
+      [ Opcodes.end ]
     ]
   };
 

package/compiler/codegen.js

@@ -2916,6 +2916,8 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
           prelude: [
             ...generate(scope, decl.left.object),
             Opcodes.i32_to_u,
+            [ Opcodes.i32_load, 0, 4 ],
+
             ...generate(scope, decl.left.property),
             Opcodes.i32_to_u,
           ],
@@ -3577,6 +3579,7 @@ const generateForOf = (scope, decl) => {
         [ Opcodes.loop, Blocktype.void ],
 
         [ Opcodes.local_get, pointer ],
+        [ Opcodes.i32_load, 0, 4 ],
         [ Opcodes.local_get, counter ]
       ],
       postlude: [
@@ -4230,7 +4233,7 @@ const generateMember = (scope, decl, _global, _name) => {
   }
 
   // todo: generate this array procedurally during builtinFuncs creation
-  if (['size', 'description', 'byteLength'].includes(decl.property.name)) {
+  if (['size', 'description', 'byteLength', 'buffer'].includes(decl.property.name)) {
     const bc = {};
     const cands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + decl.property.name + '$get'));
 
@@ -4408,6 +4411,8 @@ const generateMember = (scope, decl, _global, _name) => {
       prelude: [
         ...object,
         Opcodes.i32_to_u,
+        [ Opcodes.i32_load, 0, 4 ],
+
         ...property,
         Opcodes.i32_to_u
       ],
@@ -4436,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'].includes(node.property.name)) {
+      if (['name', 'length', 'size', 'description', 'byteLength', 'buffer'].includes(node.property.name)) {
         node.object = objectHack(node.object);
         return;
       }