porffor 0.14.0-c6edfd328 → 0.14.0-d6c141d91

package/CONTRIBUTING.md

@@ -198,11 +198,13 @@ Store the character code into the `out` pointer variable, and increment it.
 
 ## Porffor-specific TS notes
 
-- For declaring variables, you must use explicit type annotations currently (eg `let a: number = 1`, not `let a = 1`)
+- For declaring variables, you must use explicit type annotations currently (eg `let a: number = 1`, not `let a = 1`).
 - You might spot `Porffor.fastOr`/`Porffor.fastAnd`, these are non-short circuiting versions of `||`/`&&`, taking any number of conditions as arguments. You shouldn't don't need to use or worry about these.
-- **There are ~no objects, you cannot use them/literals.**
+- **There are ~no objects, you cannot use them.**
 - Attempt to avoid string/array-heavy code and use more variables instead if possible, easier on memory and CPU/perf.
 - Do not set a return type for prototype methods, it can cause errors/unexpected results.
+- You cannot use other functions in the file not exported, or variables not inside the current function.
+- `if (...)` uses a fast truthy implementation which is not spec-compliant as most conditions should be strictly checked. To use spec-compliant behavior, use `if (Boolean(...))`.
 
 <br>
 

package/compiler/2c.js

@@ -119,6 +119,9 @@ const removeBrackets = str => {
 };
 
 export default ({ funcs, globals, tags, data, exceptions, pages }) => {
+  // fix declaring order for c
+  funcs.reverse();
+
   const invOperatorOpcode = Object.values(operatorOpcode).reduce((acc, x) => {
     for (const k in x) {
       acc[x[k]] = k;
@@ -156,6 +159,11 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
     prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
   }
 
+  if (importFuncs.find(x => x.name === '__Porffor_readArgv')) {
+    prepend.set('argv', `int _argc; char** _argv;`);
+    prependMain.set('argv', `_argc = argc; _argv = argv;`);
+  }
+
   if (out) out += '\n';
 
   let depth = 1;
@@ -207,8 +215,9 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
     const returns = f.returns.length > 0;
 
-    const shouldInline = f.internal;
-    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? CValtype.f64 : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    const shouldInline = false; // f.internal;
+    if (f.name === 'main') out += `int main(${prependMain.has('argv') ? 'int argc, char* argv[]' : ''}) {\n`;
+      else out += `${f.internal ? (returns ? CValtype.f64 : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
 
     if (f.name === 'main') {
       out += [...prependMain.values()].join('\n');
@@ -459,6 +468,60 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
                 winIncludes.set('windows.h', true);
                 break;
 
+              case '__Porffor_readArgv':
+                includes.set('stdlib.h', true);
+
+                prepend.set('__Porffor_readArgv',
+`void __Porffor_readArgv(u32 index, u32 outPtr) {
+  if (index >= _argc) {
+    printf("expected %d arguments\\n", index);
+    exit(1);
+  }
+
+  char* arg = _argv[index];
+
+  u32 read = 0;
+  char* out = _memory + outPtr + 4;
+  char ch;
+  while ((ch = *(arg++)) != 0) {
+    out[read++] = ch;
+  }
+
+  memcpy(_memory + outPtr, &read, sizeof(read));
+}`);
+
+                line(`__Porffor_readArgv((u32)(${vals.at(-2)}), (u32)(${vals.pop()}))`);
+                vals.pop();
+                break;
+
+              case '__Porffor_readFile':
+                includes.set('stdio.h', true);
+                includes.set('stdlib.h', true);
+
+                prepend.set('__Porffor_readFile',
+`void __Porffor_readFile(u32 pathPtr, u32 outPtr) {
+  char* path = _memory + pathPtr + 4;
+  FILE* fp = fopen(path, "r");
+  if (fp == NULL) {
+    printf("failed to open file: %s\\n", path);
+    exit(1);
+  }
+
+  u32 read = 0;
+  char* out = _memory + outPtr + 4;
+  char ch;
+  while ((ch = fgetc(fp)) != EOF) {
+    out[read++] = ch;
+  }
+
+  fclose(fp);
+
+  memcpy(_memory + outPtr, &read, sizeof(read));
+}`);
+                line(`__Porffor_readFile((u32)(${vals.at(-2)}), (u32)(${vals.pop()}))`);
+                vals.pop();
+                break;
+
               default:
                 log.warning('2c', `unimplemented import: ${importFunc.name}`);
                 break;

package/compiler/builtins/annexb_string.ts

@@ -1,4 +1,5 @@
 // @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const __String_prototype_trimLeft = (_this: string) => {
   return __String_prototype_trimStart(_this);

package/compiler/builtins/array.ts

@@ -1,3 +1,5 @@
+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;
@@ -146,10 +148,78 @@ export const __Array_prototype_valueOf = (_this: any[]) => {
   return _this;
 };
 
-export const __Array_prototype_forEach = (_this: any[], callbackFn: Function) => {
+
+export const __Array_prototype_forEach = (_this: any[], callbackFn: any) => {
   const len: i32 = _this.length;
   let i: i32 = 0;
   while (i < len) {
     callbackFn(_this[i], i++, _this);
   }
+};
+
+export const __Array_prototype_filter = (_this: any[], callbackFn: any) => {
+  const out: any[] = [];
+
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    const el: any = _this[i];
+    if (Boolean(callbackFn(el, i++, _this))) out.push(el);
+  }
+
+  return out;
+};
+
+export const __Array_prototype_map = (_this: any[], callbackFn: any) => {
+  const out: any[] = [];
+
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    out.push(callbackFn(_this[i], i++, _this));
+  }
+
+  return out;
+};
+
+export const __Array_prototype_find = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    const el: any = _this[i];
+    if (Boolean(callbackFn(el, i++, _this))) return el;
+  }
+};
+
+export const __Array_prototype_findLast = (_this: any[], callbackFn: any) => {
+  let i: i32 = _this.length;
+  while (i > 0) {
+    const el: any = _this[--i];
+    if (Boolean(callbackFn(el, i, _this))) return el;
+  }
+};
+
+export const __Array_prototype_findIndex = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    if (Boolean(callbackFn(_this[i], i++, _this))) return i;
+  }
+};
+
+export const __Array_prototype_findLastIndex = (_this: any[], callbackFn: any) => {
+  let i: i32 = _this.length;
+  while (i > 0) {
+    if (Boolean(callbackFn(_this[--i], i, _this))) return i;
+  }
+};
+
+export const __Array_prototype_every = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    if (!Boolean(callbackFn(_this[i], i++, _this))) return false;
+  }
+
+  return true;
 };

package/compiler/builtins/base64.ts

@@ -1,4 +1,5 @@
 // @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const btoa = (input: bytestring): bytestring => {
   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

package/compiler/builtins/boolean.ts

@@ -1,3 +1,5 @@
+import type {} from './porffor.d.ts';
+
 // 20.3.3.2 Boolean.prototype.toString ()
 // https://tc39.es/ecma262/#sec-boolean.prototype.tostring
 export const __Boolean_prototype_toString = (_this: boolean) => {

package/compiler/builtins/crypto.ts

@@ -1,4 +1,5 @@
 // @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const __crypto_randomUUID = (): bytestring => {
   let bytes: bytestring = '................';

package/compiler/builtins/date.ts

@@ -1,3 +1,5 @@
+import type {} from './porffor.d.ts';
+
 // 21.4.1.3 Day (t)
 // https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-day
 // 1. Return 𝔽(floor(ℝ(t / msPerDay))).

package/compiler/builtins/escape.ts

@@ -1,6 +1,5 @@
 // @porf --valtype=i32
-
-import type {} from './porffor';
+import type {} from './porffor.d.ts';
 
 export const escape = (input: string|bytestring): bytestring => {
   // we have no byte array yet so use bytestring with 0x00 and 0x01 via escape characters

package/compiler/builtins/function.ts

@@ -1,3 +1,5 @@
+import type {} from './porffor.d.ts';
+
 export const __Function_prototype_toString = (_this: Function) => {
   // todo: actually use source
   let out: bytestring = 'function () {}';

package/compiler/builtins/int.ts

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

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/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