porffor 0.14.0-f67c123a1 → 0.16.0-594397507

package/compiler/builtins/math.ts

@@ -0,0 +1,410 @@
+import type {} from './porffor.d.ts';
+
+// todo: use any and Number(x) in all these later
+// todo: specify the rest of this file later
+// todo/perf: make i32 variants later
+// todo/perf: add a compiler pref for accuracy vs perf (epsilion?)
+
+export const __Math_exp = (x: number): number => {
+  if (!Number.isFinite(x)) {
+    if (x == -Infinity) return 0;
+    return x;
+  }
+
+  if (x < 0) {
+    // exp(-x) = 1 / exp(+x)
+    return 1 / Math.exp(-x);
+  }
+
+  const k: number = Math.floor(x / Math.LN2);
+  const r: number = x - k * Math.LN2;
+
+  // Taylor series via Horner's method
+  let term: number = r;
+  let sum: number = 1 + r;
+  let i: number = 2;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= r / i;
+    sum += term;
+    i++;
+  }
+
+  return sum * (1 << k);
+};
+
+export const __Math_log2 = (y: number): number => {
+  if (y <= 0) return NaN;
+  if (!Number.isFinite(y)) return y;
+
+  // approx using log knowledge
+  let x: number = y;
+  let exponent: number = 0;
+
+  while (x >= 2) {
+    x /= 2;
+    exponent++;
+  }
+
+  while (x < 1) {
+    x *= 2;
+    exponent--;
+  }
+
+  // 1 <= x < 2 -> 0 <= x < 1
+  x -= 1;
+
+  // refine with Newton-Raphson method
+  let delta: number;
+  do {
+    const e_x: number = Math.exp(x * Math.LN2);
+    delta = (e_x - y) / (e_x * Math.LN2);
+    x -= delta;
+  } while (Math.abs(delta) > 1e-15);
+
+  return x + exponent;
+};
+
+export const __Math_log = (y: number): number => {
+  if (y <= 0) {
+    if (y == 0) return -Infinity;
+    return NaN;
+  }
+  if (!Number.isFinite(y)) return y;
+
+  // guess using log knowledge
+  let x: number = y > 1 ? Math.log2(y) : 0;
+
+  // refine with Newton-Raphson method
+  let delta: number;
+  do {
+    const e_x: number = Math.exp(x);
+    delta = (e_x - y) / e_x;
+    x -= delta;
+  } while (Math.abs(delta) > 1e-15);
+
+  return x;
+};
+
+export const __Math_log10 = (x: number): number => {
+  if (x <= 0) {
+    if (x == 0) return -Infinity;
+    return NaN;
+  }
+  if (!Number.isFinite(x)) return x;
+
+  return Math.log(x) / Math.LN10;
+};
+
+// 21.3.2.26 Math.pow (base, exponent)
+// https://tc39.es/ecma262/#sec-math.pow
+export const __Math_pow = (base: number, exponent: number): number => {
+  // 1. Set base to ? ToNumber(base).
+  // 2. Set exponent to ? ToNumber(exponent).
+  // todo
+
+  // 3. Return Number::exponentiate(base, exponent).
+
+  // Number::exponentiate (base, exponent)
+  // https://tc39.es/ecma262/#sec-numeric-types-number-exponentiate
+  // 1. If exponent is NaN, return NaN.
+  if (Number.isNaN(exponent)) return NaN;
+
+  // 2. If exponent is either +0𝔽 or -0𝔽, return 1𝔽.
+  if (exponent == 0) return 1;
+
+  if (!Number.isFinite(base)) {
+    // 3. If base is NaN, return NaN.
+    if (Number.isNaN(base)) return base;
+
+    // 4. If base is +∞𝔽, then
+    if (base == Infinity) {
+      // a. If exponent > +0𝔽, return +∞𝔽. Otherwise, return +0𝔽.
+      if (exponent > 0) return base;
+      return 0;
+    }
+
+    // 5. If base is -∞𝔽, then
+    const isOdd = exponent % 2 == 1;
+
+    // a. If exponent > +0𝔽, then
+    if (exponent > 0) {
+      // i. If exponent is an odd integral Number, return -∞𝔽. Otherwise, return +∞𝔽.
+      if (isOdd) return -Infinity;
+      return Infinity;
+    }
+
+    // b. Else,
+    // i. If exponent is an odd integral Number, return -0𝔽. Otherwise, return +0𝔽.
+    if (isOdd) return -0;
+    return 0;
+  }
+
+  if (base == 0) {
+    // 6. If base is +0𝔽, then
+    if (1 / base == Infinity) {
+      // a. If exponent > +0𝔽, return +0𝔽. Otherwise, return +∞𝔽.
+      if (exponent > 0) return 0;
+      return Infinity;
+    }
+
+    // 7. If base is -0𝔽, then
+    const isOdd = exponent % 2 == 1;
+
+    // a. If exponent > +0𝔽, then
+    if (exponent > 0) {
+      // i. If exponent is an odd integral Number, return -0𝔽. Otherwise, return +0𝔽.
+      if (isOdd) return -0;
+      return 0;
+    }
+
+    // b. Else,
+    // i. If exponent is an odd integral Number, return -∞𝔽. Otherwise, return +∞𝔽.
+    if (isOdd) return -Infinity;
+    return Infinity;
+  }
+
+  // 8. Assert: base is finite and is neither +0𝔽 nor -0𝔽.
+  // todo
+
+  // 9. If exponent is +∞𝔽, then
+  if (exponent == Infinity) {
+    const abs = Math.abs(base);
+
+    // a. If abs(ℝ(base)) > 1, return +∞𝔽.
+    if (abs > 1) return Infinity;
+
+    // b. If abs(ℝ(base)) = 1, return NaN.
+    if (abs == 1) return NaN;
+
+    // c. If abs(ℝ(base)) < 1, return +0𝔽.
+    return 0;
+  }
+
+  // 10. If exponent is -∞𝔽, then
+  if (exponent == -Infinity) {
+    const abs = Math.abs(base);
+
+    // a. If abs(ℝ(base)) > 1, return +0𝔽.
+    if (abs > 1) return 0;
+
+    // b. If abs(ℝ(base)) = 1, return NaN.
+    if (abs == 1) return NaN;
+
+    // c. If abs(ℝ(base)) < 1, return +∞𝔽.
+    return Infinity;
+  }
+
+  // 11. Assert: exponent is finite and is neither +0𝔽 nor -0𝔽.
+  // todo
+
+  // 12. If base < -0𝔽 and exponent is not an integral Number, return NaN.
+  if (base < 0) if (!Number.isInteger(exponent)) return NaN;
+
+  // 13. Return an implementation-approximated Number value representing the result of raising ℝ(base) to the ℝ(exponent) power.
+  return Math.exp(exponent * Math.log(base));
+};
+
+
+export const __Math_expm1 = (x: number): number => {
+  if (!Number.isFinite(x)) {
+    if (x == -Infinity) return -1;
+    return x;
+  }
+
+  // use exp(x) - 1 for large x (perf)
+  if (Math.abs(x) > 1e-5) return Math.exp(x) - 1;
+
+  // Taylor series
+  let sum: number = x;
+  let term: number = x;
+  let i: number = 2;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= x / i;
+    sum += term;
+    i++;
+  }
+
+  return sum;
+};
+
+export const __Math_log1p = (x: number): number => {
+  if (x == -1) return -Infinity; // log(0) = -inf
+  if (!Number.isFinite(x)) return x;
+
+  // use exp(x) - 1 for large x (perf)
+  if (Math.abs(x) > 1e-5) return Math.log(1 + x);
+
+  // Taylor series
+  let sum: number = 0;
+  let term: number = x;
+  let i: number = 2;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= -x / i;
+    sum += term;
+    i++;
+  }
+
+  return sum;
+};
+
+
+export const __Math_sqrt = (y: number): number => {
+  if (y <= 0) {
+    if (y == 0) return 0;
+    return NaN;
+  }
+  if (!Number.isFinite(y)) return y;
+
+  // Babylonian method
+  let x: number = y;
+  let prev: number;
+
+  do {
+    prev = x;
+    x = 0.5 * (x + y / x);
+  } while (Math.abs(prev - x) > 1e-15);
+
+  return x;
+};
+
+export const __Math_cbrt = (y: number): number => {
+  if (y == 0) return 0; // cbrt(0) = 0
+  if (!Number.isFinite(y)) return y;
+
+  // Babylonian method
+  let x = Math.abs(y);
+
+  let prev: number;
+
+  do {
+    prev = x;
+    x = (2 * x + y / (x * x)) / 3;
+  } while (Math.abs(prev - x) > 1e-15);
+
+  return y < 0 ? -x : x;
+};
+
+
+// todo: varargs
+export const __Math_hypot = (x: number, y: number): number => Math.sqrt(x * x + y * y);
+
+export const __Math_sin = (x: number): number => {
+  // -inf <= x <= inf -> 0 <= x <= 2pi
+  const piX2: number = Math.PI * 2;
+  x %= piX2;
+  if (x < 0) x += piX2;
+
+  const x2: number = x * x;
+
+  return x * (
+    1 + x2 * (
+      -1.66666666666666307295e-1 + x2 * (
+        8.33333333332211858878e-3 + x2 * (
+          -1.98412698295895385996e-4 + x2 * (
+            2.75573136213857245213e-6 + x2 * (
+              -2.50507477628578072866e-8 + x2 * (
+                1.58962301576546568060e-10
+              )
+            )
+          )
+        )
+      )
+    )
+  );
+
+  // todo: investigate which is better (consider perf and accuracy)
+  // const x2 = x * x;
+  // const x4 = x2 * x2;
+  // const x6 = x4 * x2;
+  // const x8 = x4 * x4;
+  // const x10 = x6 * x4;
+  // const x12 = x6 * x6;
+  // const x14 = x12 * x2;
+
+  // return x * (
+  //   1 - x2 / 6 + x4 / 120 - x6 / 5040 + x8 / 362880 - x10 / 39916800 + x12 / 6227020800 - x14 / 1307674368000
+  // );
+};
+
+export const __Math_cos = (x: number): number => Math.sin(x - Math.PI / 2);
+export const __Math_tan = (x: number): number => Math.sin(x) / Math.cos(x);
+
+export const __Math_sinh = (x: number): number => (Math.exp(x) - Math.exp(-x)) / 2;
+export const __Math_cosh = (x: number): number => (Math.exp(x) + Math.exp(-x)) / 2;
+export const __Math_tanh = (x: number): number => Math.sinh(x) / Math.cosh(x);
+
+
+export const __Math_asinh = (x: number): number => Math.log(x + Math.sqrt(x * x + 1));
+export const __Math_acosh = (x: number): number => {
+  if (x < 1) return NaN;
+  return Math.log(x + Math.sqrt(x * x - 1));
+};
+export const __Math_atanh = (x: number): number => {
+  if (Math.abs(x) >= 1) return NaN;
+  return 0.5 * Math.log((1 + x) / (1 - x));
+};
+
+
+export const __Math_asin = (x: number): number => {
+  if (x <= -1) {
+    if (x == -1) return -Math.PI / 2;
+    return NaN;
+  }
+  if (x >= 1) {
+    if (x == 1) return Math.PI / 2;
+    return NaN;
+  }
+
+  // Taylor series
+  let sum: number = x;
+  let term: number = x;
+  let n: number = 1;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= x * x * (2 * n - 1) * (2 * n - 1) / ((2 * n) * (2 * n + 1));
+    sum += term / (2 * n + 1);
+    n++;
+  }
+
+  return sum;
+};
+
+export const __Math_acos = (x: number): number => Math.asin(x) - Math.PI / 2;
+
+export const __Math_atan = (x: number): number => {
+  if (x == Infinity) return Math.PI / 2
+  if (x == -Infinity) return -Math.PI / 2;
+
+  // Taylor series
+  let sum: number = x;
+  let term: number = x;
+  let n: number = 1;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= -x * x * (2 * n - 1) / ((2 * n) * (2 * n + 1));
+    sum += term;
+    n++;
+  }
+
+  return sum;
+};
+
+export const __Math_atan2 = (y: number, x: number): number => {
+  if (x == 0) {
+    if (y > 0) return Math.PI / 2;
+    if (y < 0) return -Math.PI / 2;
+
+    return NaN;
+  }
+
+  const ratio = y / x;
+  if (x > 0) {
+    return Math.atan(ratio);
+  }
+
+  if (y >= 0) return Math.atan(ratio) + Math.PI;
+  return Math.atan(ratio) - Math.PI;
+};

package/compiler/builtins/number.ts

@@ -1,3 +1,5 @@
+import type {} from './porffor.d.ts';
+
 // radix: number|any for rawType check
 export const __Number_prototype_toString = (_this: number, radix: number|any) => {
   let out: bytestring = '';

package/compiler/builtins/object.ts

@@ -1,3 +1,5 @@
+import type {} from './porffor.d.ts';
+
 export const __Object_prototype_toString = (_this: object) => {
   let out: bytestring = '[object Object]';
   return out;

package/compiler/builtins/porffor.d.ts

@@ -22,6 +22,14 @@ type PorfforGlobal = {
     }
   }
 
+  allocate(): any;
+  set: {
+    read(_this: any, index: number): i32;
+    write(_this: any, index: number, value: any): boolean;
+  }
+
+  print(x: any): i32;
+
   randomByte(): i32;
 
   type(x: any): bytestring;

package/compiler/builtins/set.ts

@@ -1,3 +1,5 @@
+import type {} from './porffor.d.ts';
+
 // dark wasm magic for dealing with memory, sorry.
 export const __Porffor_allocate = (): number => {
   Porffor.wasm`i32.const 1
@@ -56,14 +58,13 @@ i32.store8 0 12`;
 };
 
 
-// todo: this should be a getter somehow not a method
-export const __Set_prototype_size = (_this: Set) => {
+export const __Set_prototype_size$get = (_this: Set) => {
   return Porffor.wasm.i32.load(_this, 0, 0);
 };
 
 export const __Set_prototype_values = (_this: Set) => {
   // todo: this should return an iterator not array
-  const size: number = __Set_prototype_size(_this);
+  const size: number = Porffor.wasm.i32.load(_this, 0, 0);
 
   const out: any[] = __Porffor_allocate();
   for (let i: number = 0; i < size; i++) {
@@ -79,7 +80,7 @@ export const __Set_prototype_keys = (_this: Set) => {
 };
 
 export const __Set_prototype_has = (_this: Set, value: any) => {
-  const size: number = __Set_prototype_size(_this);
+  const size: number = Porffor.wasm.i32.load(_this, 0, 0);
 
   for (let i: number = 0; i < size; i++) {
     if (__Porffor_set_read(_this, i) === value) return true;
@@ -89,7 +90,7 @@ export const __Set_prototype_has = (_this: Set, value: any) => {
 };
 
 export const __Set_prototype_add = (_this: Set, value: any) => {
-  const size: number = __Set_prototype_size(_this);
+  const size: number = Porffor.wasm.i32.load(_this, 0, 0);
 
   // check if already in set
   for (let i: number = 0; i < size; i++) {
@@ -107,7 +108,7 @@ export const __Set_prototype_add = (_this: Set, value: any) => {
 };
 
 export const __Set_prototype_delete = (_this: Set, value: any) => {
-  const size: number = __Set_prototype_size(_this);
+  const size: number = Porffor.wasm.i32.load(_this, 0, 0);
 
   // check if already in set
   for (let i: number = 0; i < size; i++) {
@@ -184,4 +185,16 @@ export const Set$constructor = (iterable: any): Set => {
   }
 
   return out;
-};
+};
+
+export const __Set_prototype_union = (_this: Set, other: any) => {
+  if (Porffor.rawType(other) != Porffor.TYPES.set) {
+    throw new TypeError("Set.prototype.union\'s \'other\' argument must be a Set");
+  }
+
+  const out: Set = Set$constructor(_this);
+  for (const x of other) {
+    out.add(x);
+  }
+  return out;
+};

package/compiler/builtins/string.ts

@@ -1,4 +1,5 @@
 // @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const __String_fromCharCode = (code: i32) => {
   // todo: support >1 arg

package/compiler/builtins/symbol.ts

@@ -0,0 +1,62 @@
+import type {} from './porffor.d.ts';
+
+export const __Porffor_symbol_descStore = (op: boolean, value: any): any => {
+  const ptr: bytestring = '';
+
+  if (op) { // write
+    const size: number = Porffor.wasm.i32.load(ptr, 0, 0);
+    Porffor.wasm.i32.store(ptr, size + 1, 0, 0)
+
+    // reuse set internals to store description
+    Porffor.set.write(ptr, size, value);
+    return size;
+  } else { // read
+    return Porffor.set.read(ptr, value);
+  }
+};
+
+export const Symbol = (description: any): Symbol => {
+  // 1-based so always truthy as numeric value
+  return __Porffor_symbol_descStore(true, description) + 1;
+};
+
+export const __Symbol_prototype_description$get = (_this: Symbol) => {
+  const description: bytestring =
+    __Porffor_symbol_descStore(false, Porffor.wasm`local.get ${_this}` - 1);
+  return description;
+};
+
+export const __Symbol_prototype_toString = (_this: Symbol) => {
+  let out: bytestring = '';
+
+  // Symbol(
+  Porffor.wasm.i32.store8(out, 83, 0, 4);
+  Porffor.wasm.i32.store8(out, 121, 0, 5);
+  Porffor.wasm.i32.store8(out, 109, 0, 6);
+  Porffor.wasm.i32.store8(out, 98, 0, 7);
+  Porffor.wasm.i32.store8(out, 111, 0, 8);
+  Porffor.wasm.i32.store8(out, 108, 0, 9);
+  Porffor.wasm.i32.store8(out, 40, 0, 10);
+
+  const description: bytestring =
+    __Porffor_symbol_descStore(false, Porffor.wasm`local.get ${_this}` - 1);
+
+  const descLen: i32 = description.length;
+  let outPtr: i32 = Porffor.wasm`local.get ${out}` + 7;
+  let descPtr: i32 = Porffor.wasm`local.get ${description}`;
+  const descPtrEnd: i32 = descPtr + descLen;
+  while (descPtr < descPtrEnd) {
+    Porffor.wasm.i32.store8(outPtr++, Porffor.wasm.i32.load8_u(descPtr++, 0, 4), 0, 4);
+  }
+
+  // )
+  Porffor.wasm.i32.store8(Porffor.wasm`local.get ${out}` + descLen, 41, 0, 11);
+
+  out.length = 8 + descLen;
+
+  return out;
+};
+
+export const __Symbol_prototype_valueOf = (_this: Symbol) => {
+  return _this;
+};

package/compiler/builtins.js

@@ -40,6 +40,18 @@ export const importedFuncs = [
     import: 'z',
     params: 1,
     returns: 0
+  },
+  {
+    name: '__Porffor_readArgv',
+    import: 'w',
+    params: 2,
+    returns: 0
+  },
+  {
+    name: '__Porffor_readFile',
+    import: 'q',
+    params: 2,
+    returns: 0
   }
 ];
 
@@ -138,7 +150,7 @@ export const BuiltinVars = function() {
   this.Math = number(1);
 
   // wintercg(tm)
-  this.__navigator_userAgent = (scope, { makeString }) => makeString(scope, `Porffor/0.14.0`, false, '__navigator_userAgent');
+  this.__navigator_userAgent = (scope, { makeString }) => makeString(scope, `Porffor/0.16.0`, false, '__navigator_userAgent');
   this.__navigator_userAgent.type = Prefs.bytestring ? TYPES.bytestring : TYPES.string;
 
   for (const x in TYPES) {
@@ -198,7 +210,8 @@ export const BuiltinFuncs = function() {
     returns: [ valtypeBinary ],
     wasm: [
       [ Opcodes.local_get, 0 ]
-    ]
+    ],
+    constr: true
   };
 
   // just return given (default 0) for (new) Object() as we somewhat supports object just not constructor
@@ -210,7 +223,8 @@ export const BuiltinFuncs = function() {
     wasm: [
       // [ Opcodes.local_get, 0 ]
       ...number(1)
-    ]
+    ],
+    constr: true
   };
 
 
@@ -219,7 +233,7 @@ export const BuiltinFuncs = function() {
     typedParams: true,
     locals: [ Valtype.i32, Valtype.i32 ],
     returns: [],
-    wasm: (scope, { typeSwitch }) => [
+    wasm: (scope, { typeSwitch, builtin }) => [
       ...typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], {
         [TYPES.number]: [
           [ Opcodes.local_get, 0 ],
@@ -315,7 +329,7 @@ export const BuiltinFuncs = function() {
 
           // make end pointer
           [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-          ...number(ValtypeSize[valtype], Valtype.i32),
+          ...number(ValtypeSize[valtype] + 1, Valtype.i32),
           [ Opcodes.i32_mul ],
 
           [ Opcodes.local_get, 2 ],
@@ -324,14 +338,18 @@ export const BuiltinFuncs = function() {
 
           [ Opcodes.loop, Blocktype.void ],
 
-          // print current char
+          // print current array element
           [ Opcodes.local_get, 2 ],
-          [ Opcodes.load, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
-          [ Opcodes.call, importedFuncs.print ],
+          [ Opcodes.load, 0, ValtypeSize.i32 ],
+
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
+
+          [ Opcodes.call, builtin('__Porffor_print') ],
 
           // increment pointer by sizeof valtype
           [ Opcodes.local_get, 2 ],
-          ...number(ValtypeSize[valtype], Valtype.i32),
+          ...number(ValtypeSize[valtype] + 1, Valtype.i32),
           [ Opcodes.i32_add ],
           [ Opcodes.local_tee, 2 ],