porffor 0.56.5 → 0.56.6

package/compiler/builtins/array.ts

@@ -44,7 +44,7 @@ export const __Array_from = (arg: any, mapFn: any): any[] => {
     Porffor.type(arg) == Porffor.TYPES.array,
     Porffor.type(arg) == Porffor.TYPES.string, Porffor.type(arg) == Porffor.TYPES.bytestring,
     Porffor.type(arg) == Porffor.TYPES.set,
-    Porffor.fastAnd(Porffor.type(arg) >= Porffor.TYPES.uint8array, Porffor.type(arg) <= Porffor.TYPES.float64array)
+    Porffor.fastAnd(Porffor.type(arg) >= Porffor.TYPES.uint8array, Porffor.type(arg) <= Porffor.TYPES.biguint64array)
   )) {
     let i: i32 = 0;
     if (Porffor.type(mapFn) != Porffor.TYPES.undefined) {

package/compiler/builtins/arraybuffer.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const __ArrayBuffer_isView = (value: any): boolean => {
   return Porffor.fastOr(
     Porffor.type(value) == Porffor.TYPES.dataview,
-    Porffor.fastAnd(Porffor.type(value) >= Porffor.TYPES.uint8array, Porffor.type(value) <= Porffor.TYPES.float64array)
+    Porffor.fastAnd(Porffor.type(value) >= Porffor.TYPES.uint8array, Porffor.type(value) <= Porffor.TYPES.biguint64array)
   );
 };
 

package/compiler/builtins/bigint.ts

@@ -21,7 +21,7 @@ export const __Porffor_bigint_fromDigits = (negative: boolean, digits: i32[]): b
 
   if (allZero) {
     // todo: free ptr
-    ptr = 0;
+    return 0 as bigint;
   }
 
   return (ptr + 0x8000000000000) as bigint;

package/compiler/builtins/typedarray.js

@@ -9,7 +9,9 @@ export default async () => {
   // 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} {
+  for (const x of [ 'Uint8', 'Int8', 'Uint8Clamped', 'Uint16', 'Int16', 'Uint32', 'Int32', 'Float32', 'Float64', 'BigInt64', 'BigUint64' ]) {
+    const name = x + 'Array';
+    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(12);
@@ -47,7 +49,7 @@ export default async () => {
       Porffor.type(arg) == Porffor.TYPES.array,
       Porffor.type(arg) == Porffor.TYPES.string, Porffor.type(arg) == Porffor.TYPES.bytestring,
       Porffor.type(arg) == Porffor.TYPES.set,
-      Porffor.fastAnd(Porffor.type(arg) >= Porffor.TYPES.uint8array, Porffor.type(arg) <= Porffor.TYPES.float64array)
+      Porffor.fastAnd(Porffor.type(arg) >= Porffor.TYPES.uint8array, Porffor.type(arg) <= Porffor.TYPES.biguint64array)
     )) {
       let i: i32 = 0;
       for (const x of arg) {
@@ -78,7 +80,7 @@ export const __${name}_from = (arg: any, mapFn: any): ${name} => {
     Porffor.type(arg) == Porffor.TYPES.array,
     Porffor.type(arg) == Porffor.TYPES.string, Porffor.type(arg) == Porffor.TYPES.bytestring,
     Porffor.type(arg) == Porffor.TYPES.set,
-    Porffor.fastAnd(Porffor.type(arg) >= Porffor.TYPES.uint8array, Porffor.type(arg) <= Porffor.TYPES.float64array)
+    Porffor.fastAnd(Porffor.type(arg) >= Porffor.TYPES.uint8array, Porffor.type(arg) <= Porffor.TYPES.biguint64array)
   )) {
     let i: i32 = 0;
     if (Porffor.type(mapFn) != Porffor.TYPES.undefined) {
@@ -166,7 +168,7 @@ export const __${name}_prototype_set = (_this: ${name}, array: any, offset: numb
     Porffor.type(array) == Porffor.TYPES.array,
     Porffor.type(array) == Porffor.TYPES.string, Porffor.type(array) == Porffor.TYPES.bytestring,
     Porffor.type(array) == Porffor.TYPES.set,
-    Porffor.fastAnd(Porffor.type(array) >= Porffor.TYPES.uint8array, Porffor.type(array) <= Porffor.TYPES.float64array)
+    Porffor.fastAnd(Porffor.type(array) >= Porffor.TYPES.uint8array, Porffor.type(array) <= Porffor.TYPES.biguint64array)
   )) {
     let i: i32 = offset;
     for (const x of array) {
@@ -202,18 +204,8 @@ export const __${name}_prototype_subarray = (_this: ${name}, start: number, end:
   return out;
 };
 
-${typedArrayFuncs.reduce((acc, x) => acc + x.replace('// @porf-typed-array\n', '').replaceAll('Array', name).replaceAll('any[]', name) + '\n\n', '')}
-`;
-
-  constr('Uint8Array');
-  constr('Int8Array');
-  constr('Uint8ClampedArray');
-  constr('Uint16Array');
-  constr('Int16Array');
-  constr('Uint32Array');
-  constr('Int32Array');
-  constr('Float32Array');
-  constr('Float64Array');
+${typedArrayFuncs.reduce((acc, x) => acc + x.replace('// @porf-typed-array\n', '').replaceAll('Array', name).replaceAll('any[]', name) + '\n\n', '')}`;
+  };
 
   return out;
 };

package/compiler/builtins.js

@@ -92,6 +92,8 @@ export const BuiltinVars = function(ctx) {
   this.__Int32Array_BYTES_PER_ELEMENT = [ number(4) ];
   this.__Float32Array_BYTES_PER_ELEMENT = [ number(4) ];
   this.__Float64Array_BYTES_PER_ELEMENT = [ number(8) ];
+  this.__BigInt64Array_BYTES_PER_ELEMENT = [ number(8) ];
+  this.__BigUint64Array_BYTES_PER_ELEMENT = [ number(8) ];
 
   ObjectBuiltins.call(this, ctx, Prefs);
 };
@@ -881,6 +883,187 @@ export const BuiltinFuncs = function() {
     ]
   };
 
+  this.__Porffor_bigint_fromU64 = {
+    params: [ Valtype.i64 ],
+    locals: [ Valtype.i32, Valtype.i32, Valtype.i32 ],
+    localNames: [ 'x', 'hi', 'lo', 'ptr' ],
+    returns: [ Valtype.f64 ],
+    returnType: TYPES.bigint,
+    wasm: (scope, { builtin }) => [
+      // x is u64 so abs(x) = x
+      [ Opcodes.local_get, 0 ],
+      number(32, Valtype.i64),
+      [ Opcodes.i64_shr_u ],
+      [ Opcodes.i32_wrap_i64 ],
+      [ Opcodes.local_tee, 1 ],
+
+      [ Opcodes.local_get, 0 ],
+      [ Opcodes.i32_wrap_i64 ],
+      [ Opcodes.local_set, 2 ],
+
+      // if abs(x) < 0x8000000000000, return x as bigint
+      number(0x8000000000000 / (2 ** 32), Valtype.i32),
+      [ Opcodes.i32_lt_u ],
+      [ Opcodes.if, Blocktype.void ],
+        [ Opcodes.local_get, 0 ],
+        [ Opcodes.f64_convert_i64_u ],
+        [ Opcodes.return ],
+      [ Opcodes.end ],
+
+      number(16, Valtype.i32),
+      [ Opcodes.call, builtin('__Porffor_allocateBytes') ],
+      [ Opcodes.local_tee, 3 ],
+
+      // sign is already 0
+      // digit count = 2
+      number(2, Valtype.i32),
+      [ Opcodes.i32_store16, 0, 2 ],
+
+      // hi and lo as digits
+      [ Opcodes.local_get, 3 ],
+      [ Opcodes.local_get, 1 ],
+      [ Opcodes.i32_store, 0, 4 ],
+
+      [ Opcodes.local_get, 3 ],
+      [ Opcodes.local_get, 2 ],
+      [ Opcodes.i32_store, 0, 8 ],
+
+      [ Opcodes.local_get, 3 ],
+      Opcodes.i32_from_u,
+      number(0x8000000000000, Valtype.f64),
+      [ Opcodes.f64_add ]
+    ]
+  };
+
+  this.__Porffor_bigint_fromS64 = {
+    params: [ Valtype.i64 ],
+    locals: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i64 ],
+    localNames: [ 'x', 'hi', 'lo', 'ptr', 'abs' ],
+    returns: [ Valtype.f64 ],
+    returnType: TYPES.bigint,
+    wasm: (scope, { builtin }) => [
+      // abs = abs(x) = ((x >> 63) ^ x) - (x >> 63)
+      [ Opcodes.local_get, 0 ],
+      [ Opcodes.i64_const, 63 ],
+      [ Opcodes.i64_shr_s ],
+      [ Opcodes.local_get, 0 ],
+      [ Opcodes.i64_xor ],
+      [ Opcodes.local_get, 0 ],
+      [ Opcodes.i64_const, 63 ],
+      [ Opcodes.i64_shr_s ],
+      [ Opcodes.i64_sub ],
+      [ Opcodes.local_tee, 4 ],
+
+      number(32, Valtype.i64),
+      [ Opcodes.i64_shr_u ],
+      [ Opcodes.i32_wrap_i64 ],
+      [ Opcodes.local_tee, 1 ],
+
+      [ Opcodes.local_get, 4 ],
+      [ Opcodes.i32_wrap_i64 ],
+      [ Opcodes.local_set, 2 ],
+
+      // if hi < (0x8000000000000 / 2**32), return (hi * 2**32) + lo as bigint
+      number(0x8000000000000 / (2 ** 32), Valtype.i32),
+      [ Opcodes.i32_lt_u ],
+      [ Opcodes.if, Blocktype.void ],
+        [ Opcodes.local_get, 0 ],
+        [ Opcodes.f64_convert_i64_s ],
+        [ Opcodes.return ],
+      [ Opcodes.end ],
+
+      number(16, Valtype.i32),
+      [ Opcodes.call, builtin('__Porffor_allocateBytes') ],
+      [ Opcodes.local_tee, 3 ],
+
+      // sign = x != abs
+      [ Opcodes.local_get, 0 ],
+      [ Opcodes.local_get, 4 ],
+      [ Opcodes.i64_ne ],
+      [ Opcodes.i32_store8, 0, 0 ],
+
+      // digit count = 2
+      [ Opcodes.local_get, 3 ],
+      number(2, Valtype.i32),
+      [ Opcodes.i32_store16, 0, 2 ],
+
+      // hi and lo as digits
+      [ Opcodes.local_get, 3 ],
+      [ Opcodes.local_get, 1 ],
+      [ Opcodes.i32_store, 0, 4 ],
+
+      [ Opcodes.local_get, 3 ],
+      [ Opcodes.local_get, 2 ],
+      [ Opcodes.i32_store, 0, 8 ],
+
+      [ Opcodes.local_get, 3 ],
+      Opcodes.i32_from_u,
+      number(0x8000000000000, Valtype.f64),
+      [ Opcodes.f64_add ]
+    ]
+  };
+
+  this.__Porffor_bigint_toI64 = {
+    params: [ Valtype.f64 ],
+    locals: [ Valtype.i32, Valtype.i32 ],
+    localNames: [ 'x', 'ptr', 'digits' ],
+    returns: [ Valtype.i64 ],
+    returnType: TYPES.bigint,
+    wasm: () => [
+      // if abs(x) < 0x8000000000000, return x as u64
+      [ Opcodes.local_get, 0 ],
+      [ Opcodes.f64_abs ],
+      number(0x8000000000000, Valtype.f64),
+      [ Opcodes.f64_lt ],
+      [ Opcodes.if, Blocktype.void ],
+        [ Opcodes.local_get, 0 ],
+        Opcodes.i64_trunc_sat_f64_s,
+        [ Opcodes.return ],
+      [ Opcodes.end ],
+
+      [ Opcodes.local_get, 0 ],
+      number(0x8000000000000, Valtype.f64),
+      [ Opcodes.f64_sub ],
+      Opcodes.i32_to_u,
+      [ Opcodes.local_tee, 1 ],
+
+      // if sign == 1, * -1, else * 1
+      [ Opcodes.i32_load8_u, 0, 0 ],
+      [ Opcodes.if, Valtype.i64 ],
+        number(-1, Valtype.i64),
+      [ Opcodes.else ],
+        number(1, Valtype.i64),
+      [ Opcodes.end ],
+
+      // move ptr to final 2 digits
+      [ Opcodes.local_get, 1 ],
+      [ Opcodes.i32_load16_u, 0, 2 ],
+      [ Opcodes.local_tee, 2 ],
+      [ Opcodes.i32_const, 2 ],
+      [ Opcodes.i32_gt_u ],
+      [ Opcodes.if, Blocktype.void ],
+        [ Opcodes.local_get, 2 ],
+        [ Opcodes.i32_const, 2 ],
+        [ Opcodes.i32_sub ],
+        [ Opcodes.i32_const, 4 ],
+        [ Opcodes.i32_mul ],
+        [ Opcodes.local_get, 1 ],
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, 1 ],
+      [ Opcodes.end ],
+
+      [ Opcodes.local_get, 1 ],
+      [ Opcodes.i32_load, 0, 4 ],
+      [ Opcodes.i64_extend_i32_u ],
+      [ Opcodes.i64_const, 128, 128, 128, 128, 16 ], // todo: fix >2**32 for regular seb 128 encoding
+      [ Opcodes.i64_mul ],
+      [ Opcodes.local_get, 1 ],
+      [ Opcodes.i32_load, 0, 8 ],
+      [ Opcodes.i64_extend_i32_u ],
+      [ Opcodes.i64_add ],
+      [ Opcodes.i64_mul ] // * sign earlier
+    ]
+  };
 
   PrecompiledBuiltins.BuiltinFuncs.call(this);
 };