porffor 0.14.0-cdebd5442 → 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>
 
@@ -231,7 +233,11 @@ builtins/tostring_number: impl radix
 
 Make sure you have Test262 cloned already **inside of `test262/`** (`git clone https://github.com/tc39/test262.git test262/test262`) and run `npm install` inside `test262/` too.
 
-Run `node test262` to run all the tests and get an output of total overall test results. The main thing you want to pay attention to is the emoji summary (lol):
+Run `node test262` to run all the tests and get an output of total overall test results.
+
+Warning: this will consume 1-6GB of memory and ~90% of all CPU cores while running (depending on thread count), it should take 15-120s depending on machine. You can specify how many threads with `--threads=N`, it will use the number of CPU threads by default.
+
+The main thing you want to pay attention to is the emoji summary (lol):
 ```
 🧪 50005 | 🤠 7007 (-89) | ❌ 1914 (-32) | 💀 13904 (-61) | 📝 23477 (-120) | ⏰ 2 | 🏗 2073 (+302) | 💥 1628
 ```

package/asur/index.js

@@ -1155,7 +1155,7 @@ if (bc.porfFunc && paused && op) {
   switch (byg(
     paused,
     funcLines[currentFunc] + currentLine,
-    '\x1b[1masur\x1b[22m: ' + callStack.join(' -> ') + (parents.length > 1 ? \` | \${parents.slice(1).map(x => invOpcodes[x.opcode]).join(' -> ')}\` : ''),
+    '\x1b[1masur debugger\x1b[22m: ' + callStack.join(' -> ') + (parents.length > 1 ? \` | \${parents.slice(1).map(x => invOpcodes[x.opcode]).join(' -> ')}\` : ''),
     [
       {
         x: termWidth - 1 - width - 6,

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/assemble.js

@@ -116,6 +116,20 @@ export default (funcs, globals, tags, pages, data, flags) => {
     ] ])
   );
 
+  if (pages.has('func argc lut')) {
+    // generate func argc lut data
+    const bytes = [];
+    for (let i = 0; i < funcs.length; i++) {
+      const argc = Math.floor(funcs[i].params.length / 2);
+      bytes.push(argc % 256, (argc / 256 | 0) % 256);
+    }
+
+    data.push({
+      offset: pages.get('func argc lut').ind * pageSize,
+      bytes
+    });
+  }
+
   // const t0 = performance.now();
 
   // specially optimized assembly for globals as this version is much (>5x) faster than traditional createSection()

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;
@@ -27,14 +29,16 @@ export const __Array_prototype_slice = (_this: any[], start: number, end: number
   let outPtr: i32 = Porffor.wasm`local.get ${out}`;
   let thisPtr: i32 = Porffor.wasm`local.get ${_this}`;
 
-  const thisPtrEnd: i32 = thisPtr + end * 8;
+  const thisPtrEnd: i32 = thisPtr + end * 9;
 
-  thisPtr += start * 8;
+  thisPtr += start * 9;
 
   while (thisPtr < thisPtrEnd) {
     Porffor.wasm.f64.store(outPtr, Porffor.wasm.f64.load(thisPtr, 0, 4), 0, 4);
-    thisPtr += 8;
-    outPtr += 8;
+    Porffor.wasm.i32.store8(outPtr + 8, Porffor.wasm.i32.load8_u(thisPtr + 8, 0, 4), 0, 4);
+
+    thisPtr += 9;
+    outPtr += 9;
   }
 
   out.length = end - start;
@@ -142,4 +146,80 @@ export const __Array_prototype_toReversed = (_this: any[]) => {
 
 export const __Array_prototype_valueOf = (_this: any[]) => {
   return _this;
+};
+
+
+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/error.js

@@ -0,0 +1,22 @@
+export default () => {
+  let out = '';
+
+  const error = name => out += `export const ${name} = (message: bytestring) => {
+  return {};
+};
+
+export const ${name}$constructor = (message: bytestring) => {
+  return {};
+};`;
+
+  error('Error');
+  error('AggregateError');
+  error('TypeError');
+  error('ReferenceError');
+  error('SyntaxError');
+  error('RangeError');
+  error('EvalError');
+  error('URIError');
+
+  return out;
+};

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 => {