porffor 0.17.0-94400a2b8 → 0.17.0-99a1a1851

package/README.md

@@ -148,27 +148,29 @@ These include some early (stage 1/0) and/or dead (last commit years ago) proposa
 - Array constructor (`Array(5)`, `new Array(1, 2, 3)`)
 - Labelled statements (`foo: while (...)`)
 - `do...while` loops
+- Optional parameters (`(foo = 'bar') => { ... }`)
 
 ### Built-ins
 
 - `NaN` and `Infinity`
 - `isNaN()` and `isFinite()`
 - Most of `Number` (`MAX_VALUE`, `MIN_VALUE`, `MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `POSITIVE_INFINITY`, `NEGATIVE_INFINITY`, `EPSILON`, `NaN`, `isNaN`, `isFinite`, `isInteger`, `isSafeInteger`)
-- Some `Math` funcs (`sqrt`, `abs`, `floor`, `sign`, `round`, `trunc`, `clz32`, `fround`, `random`)
+- Most `Math` funcs (`sqrt`, `abs`, `floor`, `sign`, `round`, `trunc`, `clz32`, `fround`, `random`, `exp`, `log`, `log2`, `log10`, `pow`, `expm1`, `log1p`, `sqrt`, `cbrt`, `hypot`, `sin`, `cos`, `tan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `asin`, `acos`, `atan`, `atan2`)
 - Basic `globalThis` support
 - Basic `Boolean` and `Number`
 - Basic `eval` for literals
 - `Math.random()` using self-made xorshift128+ PRNG
 - Some of `performance` (`now()`, `timeOrigin`)
-- Some of `Array.prototype` (`at`, `push`, `pop`, `shift`, `fill`, `slice`, `indexOf`, `lastIndexOf`, `includes`, `with`, `reverse`, `toReversed`)
-- Some of `Array` (`of`, `isArray`)
-- Most of `String.prototype` (`at`, `charAt`, `charCodeAt`, `toUpperCase`, `toLowerCase`, `startsWith`, `endsWith`, `indexOf`, `lastIndexOf`, `includes`, `padStart`, `padEnd`, `substring`, `substr`, `slice`, `trimStart`, `trimEnd`, `trim`, `toString`, `big`, `blink`, `bold`, `fixed`, `italics`, `small`, `strike`, `sub`, `sup`,  `trimLeft`, `trimRight`, )
+- Most of `Array.prototype` (`at`, `push`, `pop`, `shift`, `fill`, `slice`, `indexOf`, `lastIndexOf`, `includes`, `with`, `reverse`, `toReversed`, `forEach`, `filter`, `map`, `find`, `findLast`, `findIndex`, `findLastIndex`, `every`, `some`, `reduce`, `reduceRight`, `join`, `toString`)
+- Most of `Array` (`of`, `isArray`)
+- Most of `String.prototype` (`at`, `charAt`, `charCodeAt`, `toUpperCase`, `toLowerCase`, `startsWith`, `endsWith`, `indexOf`, `lastIndexOf`, `includes`, `padStart`, `padEnd`, `substring`, `substr`, `slice`, `trimStart`, `trimEnd`, `trim`, `toString`, `big`, `blink`, `bold`, `fixed`, `italics`, `small`, `strike`, `sub`, `sup`,  `trimLeft`, `trimRight`, `trim`)
 - Some of `crypto` (`randomUUID`)
 - `escape`
 - `btoa`
 - Most of `Number.prototype` (`toString`, `toFixed`, `toExponential`)
 - `parseInt`
 - Spec-compliant `Date`
+- WIP typed arrays (`Uint8Array`, `Int32Array`, etc)
 
 ### Custom
 

package/compiler/2c.js

@@ -182,7 +182,15 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
   }, {});
   const invGlobals = inv(globals, x => x.idx);
 
-  const sanitize = str => str.replace(/[^0-9a-zA-Z_]/g, _ => String.fromCharCode(97 + _.charCodeAt(0) % 32));
+  const codeToSanitizedStr = code => {
+    let out = '';
+    while (code > 0) {
+      out += String.fromCharCode(97 + code % 26);
+      code -= 26;
+    }
+    return out;
+  };
+  const sanitize = str => str.replace(/[^0-9a-zA-Z_]/g, _ => codeToSanitizedStr(_.charCodeAt(0)));
 
   for (const x in invGlobals) {
     invGlobals[x] = sanitize(invGlobals[x]);
@@ -273,10 +281,11 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
     }
 
     const returns = f.returns.length > 0;
+    const typedReturns = f.returnType == null;
 
     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 ? 'f64' : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+      else out += `${!typedReturns ? (returns ? CValtype[f.returns[0]] : '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  ');
@@ -418,11 +427,14 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
           continue;
 
         case Opcodes.return:
-          // line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
-          const b = vals.pop();
-          const a = vals.pop();
+          if (!typedReturns) {
+            line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
+            break;
+          }
+
+          const b = returns ? vals.pop() : -1;
+          const a = returns ? vals.pop() : -1;
           line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(a)}, ${removeBrackets(b)} }` : ''}`);
-          // line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
           break;
 
         case Opcodes.if: {
@@ -549,10 +561,15 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
                 prepend.set('__Porffor_readFile',
 `i32 __Porffor_readFile(u32 pathPtr, u32 outPtr) {
-  char* path = _memory + pathPtr + 4;
-  FILE* fp = fopen(path, "r");
-  if (fp == NULL) {
-    return -1;
+  FILE* fp;
+  if (pathPtr == 0) {
+    fp = stdin;
+  } else {
+    char* path = _memory + pathPtr + 4;
+    fp = fopen(path, "r");
+    if (fp == NULL) {
+      return -1;
+    }
   }
 
   u32 read = 0;
@@ -585,7 +602,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
           for (let j = 0; j < func.params.length; j++) args.unshift(removeBrackets(vals.pop()));
 
           if (func.returns.length > 0) {
-            if (func.internal) {
+            if (func.returnType != null) {
               vals.push(`${sanitize(func.name)}(${args.join(', ')})`);
             } else {
               const id = retTmpId++;

package/compiler/builtins/array.ts

@@ -4,6 +4,7 @@ export const __Array_isArray = (x: unknown): boolean =>
   // Porffor.wasm`local.get ${x+1}` == Porffor.TYPES.array;
   Porffor.rawType(x) == Porffor.TYPES.array;
 
+
 export const __Array_prototype_slice = (_this: any[], start: number, end: number) => {
   const len: i32 = _this.length;
   if (Porffor.rawType(end) == Porffor.TYPES.undefined) end = len;
@@ -22,7 +23,7 @@ export const __Array_prototype_slice = (_this: any[], start: number, end: number
   }
   if (end > len) end = len;
 
-  let out: any[] = [];
+  let out: any[] = Porffor.allocate();
 
   if (start > end) return out;
 
@@ -42,10 +43,10 @@ export const __Array_prototype_slice = (_this: any[], start: number, end: number
   }
 
   out.length = end - start;
-
   return out;
 };
 
+// @porf-typed-array
 export const __Array_prototype_indexOf = (_this: any[], searchElement: any, position: number) => {
   const len: i32 = _this.length;
   if (position > 0) {
@@ -60,6 +61,7 @@ export const __Array_prototype_indexOf = (_this: any[], searchElement: any, posi
   return -1;
 };
 
+// @porf-typed-array
 export const __Array_prototype_lastIndexOf = (_this: any[], searchElement: any, position: number) => {
   const len: i32 = _this.length;
   if (position > 0) {
@@ -74,6 +76,7 @@ export const __Array_prototype_lastIndexOf = (_this: any[], searchElement: any,
   return -1;
 };
 
+// @porf-typed-array
 export const __Array_prototype_includes = (_this: any[], searchElement: any, position: number) => {
   const len: i32 = _this.length;
   if (position > 0) {
@@ -88,6 +91,7 @@ export const __Array_prototype_includes = (_this: any[], searchElement: any, pos
   return false;
 };
 
+// @porf-typed-array
 export const __Array_prototype_with = (_this: any[], index: number, value: any) => {
   const len: i32 = _this.length;
   if (index < 0) {
@@ -101,8 +105,7 @@ export const __Array_prototype_with = (_this: any[], index: number, value: any)
     throw new RangeError('Invalid index');
   }
 
-  // todo: allocator is bad here?
-  let out: any[] = [];
+  let out: any[] = Porffor.allocate();
 
   Porffor.clone(_this, out);
 
@@ -111,6 +114,7 @@ export const __Array_prototype_with = (_this: any[], index: number, value: any)
   return out;
 };
 
+// @porf-typed-array
 export const __Array_prototype_reverse = (_this: any[]) => {
   const len: i32 = _this.length;
 
@@ -126,14 +130,14 @@ export const __Array_prototype_reverse = (_this: any[]) => {
   return _this;
 };
 
-// todo: this has memory/allocation bugs so sometimes crashes :(
+// @porf-typed-array
 export const __Array_prototype_toReversed = (_this: any[]) => {
   const len: i32 = _this.length;
 
   let start: i32 = 0;
   let end: i32 = len - 1;
 
-  let out: any[] = [];
+  let out: any[] = Porffor.allocate();
   out.length = len;
 
   while (start < end) {
@@ -144,11 +148,13 @@ export const __Array_prototype_toReversed = (_this: any[]) => {
   return out;
 };
 
+// @porf-typed-array
 export const __Array_prototype_valueOf = (_this: any[]) => {
   return _this;
 };
 
 
+// @porf-typed-array
 export const __Array_prototype_forEach = (_this: any[], callbackFn: any) => {
   const len: i32 = _this.length;
   let i: i32 = 0;
@@ -157,22 +163,26 @@ export const __Array_prototype_forEach = (_this: any[], callbackFn: any) => {
   }
 };
 
+// @porf-typed-array
 export const __Array_prototype_filter = (_this: any[], callbackFn: any) => {
-  const out: any[] = [];
+  const out: any[] = Porffor.allocate();
 
   const len: i32 = _this.length;
   let i: i32 = 0;
+  let j: i32 = 0;
   while (i < len) {
     const el: any = _this[i];
-    if (Boolean(callbackFn(el, i++, _this))) out.push(el);
+    if (Boolean(callbackFn(el, i++, _this))) out[j++] = el;
   }
 
+  out.length = j;
   return out;
 };
 
+// @porf-typed-array
 export const __Array_prototype_map = (_this: any[], callbackFn: any) => {
   const len: i32 = _this.length;
-  const out: any[] = [];
+  const out: any[] = Porffor.allocate();
   out.length = len;
 
   let i: i32 = 0;
@@ -183,6 +193,7 @@ export const __Array_prototype_map = (_this: any[], callbackFn: any) => {
   return out;
 };
 
+// @porf-typed-array
 export const __Array_prototype_find = (_this: any[], callbackFn: any) => {
   const len: i32 = _this.length;
   let i: i32 = 0;
@@ -192,6 +203,7 @@ export const __Array_prototype_find = (_this: any[], callbackFn: any) => {
   }
 };
 
+// @porf-typed-array
 export const __Array_prototype_findLast = (_this: any[], callbackFn: any) => {
   let i: i32 = _this.length;
   while (i > 0) {
@@ -200,6 +212,7 @@ export const __Array_prototype_findLast = (_this: any[], callbackFn: any) => {
   }
 };
 
+// @porf-typed-array
 export const __Array_prototype_findIndex = (_this: any[], callbackFn: any) => {
   const len: i32 = _this.length;
   let i: i32 = 0;
@@ -208,6 +221,7 @@ export const __Array_prototype_findIndex = (_this: any[], callbackFn: any) => {
   }
 };
 
+// @porf-typed-array
 export const __Array_prototype_findLastIndex = (_this: any[], callbackFn: any) => {
   let i: i32 = _this.length;
   while (i > 0) {
@@ -215,6 +229,7 @@ export const __Array_prototype_findLastIndex = (_this: any[], callbackFn: any) =
   }
 };
 
+// @porf-typed-array
 export const __Array_prototype_every = (_this: any[], callbackFn: any) => {
   const len: i32 = _this.length;
   let i: i32 = 0;
@@ -225,6 +240,18 @@ export const __Array_prototype_every = (_this: any[], callbackFn: any) => {
   return true;
 };
 
+// @porf-typed-array
+export const __Array_prototype_some = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    if (Boolean(callbackFn(_this[i], i++, _this))) return true;
+  }
+
+  return false;
+};
+
+// @porf-typed-array
 export const __Array_prototype_reduce = (_this: any[], callbackFn: any, initialValue: any) => {
   let acc: any = initialValue ?? _this[0];
 
@@ -237,6 +264,20 @@ export const __Array_prototype_reduce = (_this: any[], callbackFn: any, initialV
   return acc;
 };
 
+// @porf-typed-array
+export const __Array_prototype_reduceRight = (_this: any[], callbackFn: any, initialValue: any) => {
+  const len: i32 = _this.length;
+  let acc: any = initialValue ?? _this[len - 1];
+
+  let i: i32 = len;
+  while (i > 0) {
+    acc = callbackFn(acc, _this[--i], i, _this);
+  }
+
+  return acc;
+};
+
+// @porf-typed-array
 export const __Array_prototype_toString = (_this: any[]) => {
   // todo: this is bytestring only!
 
@@ -261,6 +302,7 @@ export const __Array_prototype_toString = (_this: any[]) => {
   return out;
 };
 
+// @porf-typed-array
 export const __Array_prototype_join = (_this: any[], _separator: any) => {
   // todo: this is bytestring only!
   // todo/perf: optimize single char separators

package/compiler/builtins/math.ts

@@ -16,7 +16,7 @@ export const __Math_exp = (x: number): number => {
     return 1 / Math.exp(-x);
   }
 
-  const k: number = Math.floor(x / Math.LN2);
+  let k: number = Math.floor(x / Math.LN2);
   const r: number = x - k * Math.LN2;
 
   // Taylor series via Horner's method
@@ -30,7 +30,11 @@ export const __Math_exp = (x: number): number => {
     i++;
   }
 
-  return sum * (1 << k);
+  while (k-- > 0) {
+    sum *= 2;
+  }
+
+  return sum;
 };
 
 export const __Math_log2 = (y: number): number => {

package/compiler/builtins/set.ts

@@ -170,15 +170,8 @@ export const Set = () => {
 export const Set$constructor = (iterable: any): Set => {
   const out: Set = __Porffor_allocate();
 
-  const type: number = Porffor.rawType(iterable);
-  if (Porffor.fastOr(
-    type == Porffor.TYPES.array,
-    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
-    type == Porffor.TYPES.set
-  )) {
-    for (const x of iterable) {
-      __Set_prototype_add(out, x);
-    }
+  if (Porffor.rawType(iterable) != Porffor.TYPES.undefined) for (const x of iterable) {
+    __Set_prototype_add(out, x);
   }
 
   return out;

package/compiler/builtins/typedarray.js

@@ -0,0 +1,96 @@
+export default async () => {
+  let out = '';
+
+  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} = () => {
+  throw new TypeError("Constructor ${name} requires 'new'");
+};
+
+export const ${name}$constructor = (arg: any): ${name} => {
+  const out: ${name} = Porffor.allocate();
+  let len: i32 = 0;
+
+  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;
+    }
+    len = i;
+  } else if (type == Porffor.TYPES.number) {
+    len = arg;
+  }
+
+  out.length = len;
+  return out;
+};
+
+export const __${name}_prototype_byteLength$get = (_this: ${name}) => {
+  return _this.length * ${name}.BYTES_PER_ELEMENT;
+};
+
+export const __${name}_prototype_at = (_this: ${name}, index: number) => {
+  const len: i32 = _this.length;
+  index |= 0;
+  if (index < 0) {
+    index = len + index;
+    if (index < 0) return undefined;
+  }
+  if (index >= len) return undefined;
+
+  return _this[index];
+};
+
+export const __${name}_prototype_slice = (_this: ${name}, start: number, end: number) => {
+  const len: i32 = _this.length;
+  if (Porffor.rawType(end) == Porffor.TYPES.undefined) end = len;
+
+  start |= 0;
+  end |= 0;
+
+  if (start < 0) {
+    start = len + start;
+    if (start < 0) start = 0;
+  }
+  if (start > len) start = len;
+  if (end < 0) {
+    end = len + end;
+    if (end < 0) end = 0;
+  }
+  if (end > len) end = len;
+
+  let out: ${name} = Porffor.allocate();
+
+  if (start > end) return out;
+
+  let i: i32 = start;
+  let j: i32 = 0;
+  while (i < end) {
+    out[j++] = _this[i++];
+  }
+
+  out.length = end - start;
+  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');
+
+  return out;
+};

package/compiler/builtins.js

@@ -160,6 +160,17 @@ export const BuiltinVars = function() {
   this.__performance_timeOrigin = [
     [ Opcodes.call, importedFuncs.timeOrigin ]
   ];
+
+
+  this.__Uint8Array_BYTES_PER_ELEMENT = number(1);
+  this.__Int8Array_BYTES_PER_ELEMENT = number(1);
+  this.__Uint8ClampedArray_BYTES_PER_ELEMENT = number(1);
+  this.__Uint16Array_BYTES_PER_ELEMENT = number(2);
+  this.__Int16Array_BYTES_PER_ELEMENT = number(2);
+  this.__Uint32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Int32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Float32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Float64Array_BYTES_PER_ELEMENT = number(8);
 };
 
 export const BuiltinFuncs = function() {
@@ -184,6 +195,20 @@ export const BuiltinFuncs = function() {
     ]
   };
 
+  this['f64_**'] = this['i32_**'] = {
+    params: [ valtypeBinary, valtypeBinary ],
+    locals: [],
+    returns: [ valtypeBinary ],
+    returnType: TYPES.number,
+    wasm: (scope, { builtin }) => [
+      [ Opcodes.local_get, 0 ],
+      ...number(TYPES.number, Valtype.i32),
+      [ Opcodes.local_get, 1 ],
+      ...number(TYPES.number, Valtype.i32),
+      [ Opcodes.call, builtin('__Math_pow') ]
+    ]
+  };
+
   // add bitwise ops by converting operands to i32 first
   for (const [ char, op ] of [ ['&', Opcodes.i32_and], ['|', Opcodes.i32_or], ['^', Opcodes.i32_xor], ['<<', Opcodes.i32_shl], ['>>', Opcodes.i32_shr_s], ['>>>', Opcodes.i32_shr_u] ]) {
     this[`f64_${char}`] = {