porffor 0.58.14 → 0.58.15

package/AGENT.md

@@ -0,0 +1,13 @@
+you are an assistant coder for Porffor - a WIP js/ts -> wasm/native ahead-of-time compiler. the codebase is written in js and ts.
+
+IMPORTANT:
+- built-ins apis (Date, String.prototype, etc) are written in ts inside `compiler/builtins`
+- once you update a file inside that directory, you MUST run `./porf precompile` to compile to make your changes effective
+
+test your work using the test262 tools available, iterate independently but do not get stuck on one chain of thought or approach. paths for test262 tools should be relative to the 'test262/test' directory (e.g., 'built-ins/RegExp' instead of 'test262/test/built-ins/RegExp').
+
+- always use single quotes instead of double quotes (unless needed)
+- after finishing, check if your work/diff could be simplified
+- to just evaluate code in the engine, use the command: `./porf -p "..."`
+- to get an overview of the most failing directories, use the command: `node test262/fails.cjs`
+- when working in `compiler/builtins`, inline code instead of using utility/helper functions

package/compiler/builtins/array.ts

@@ -80,6 +80,29 @@ export const __Array_from = (arg: any, mapFn: any): any[] => {
   return out;
 };
 
+// 23.1.3.1 Array.prototype.at (index)
+// https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.at
+export const __Array_prototype_at = (_this: any[], index: any) => {
+  // 1. Let O be ? ToObject(this value).
+  // 2. Let len be ? LengthOfArrayLike(O).
+  const len: i32 = _this.length;
+
+  // 3. Let relativeIndex be ? ToIntegerOrInfinity(index).
+  index = ecma262.ToIntegerOrInfinity(index);
+
+  // 4. If relativeIndex ≥ 0, then
+  //        a. Let k be relativeIndex.
+  // 5. Else,
+  //        a. Let k be len + relativeIndex.
+  if (index < 0) index = len + index;
+
+  // 6. If k < 0 or k ≥ len, return undefined.
+  if (Porffor.fastOr(index < 0, index >= len)) return undefined;
+
+  // 7. Return ? Get(O, ! ToString(𝔽(k))).
+  return _this[index];
+};
+
 export const __Array_prototype_push = (_this: any[], ...items: any[]) => {
   let len: i32 = _this.length;
   const itemsLen: i32 = items.length;

package/compiler/builtins/regexp.ts

@@ -164,6 +164,25 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
         else if (char == 118) v = 11; // \v
         else if (char == 102) v = 12; // \f
         else if (char == 48) v = 0; // \0
+        else if (char == 120) { // \x
+          if (patternPtr + 1 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\x escape');
+          const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+          const c2 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+
+          let d1: number;
+          if (c1 >= 48 && c1 <= 57) d1 = c1 - 48;
+            else if (c1 >= 97 && c1 <= 102) d1 = c1 - 87;
+            else if (c1 >= 65 && c1 <= 70) d1 = c1 - 55;
+            else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+          let d2: number;
+          if (c2 >= 48 && c2 <= 57) d2 = c2 - 48;
+            else if (c2 >= 97 && c2 <= 102) d2 = c2 - 87;
+            else if (c2 >= 65 && c2 <= 70) d2 = c2 - 55;
+            else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+          v = d1 * 16 + d2;
+        }
       }
 
       if ((patternPtr + 1) < patternEndPtr && Porffor.wasm.i32.load8_u(patternPtr, 0, 4) == 45 && Porffor.wasm.i32.load8_u(patternPtr, 0, 5) != 93) {
@@ -194,6 +213,25 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
             else if (endChar == 118) endChar = 11;
             else if (endChar == 102) endChar = 12;
             else if (endChar == 48) endChar = 0;
+            else if (endChar == 120) { // \x
+              if (patternPtr + 1 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\x escape');
+              const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+              const c2 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+
+              let d1: number;
+              if (c1 >= 48 && c1 <= 57) d1 = c1 - 48;
+                else if (c1 >= 97 && c1 <= 102) d1 = c1 - 87;
+                else if (c1 >= 65 && c1 <= 70) d1 = c1 - 55;
+                else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+              let d2: number;
+              if (c2 >= 48 && c2 <= 57) d2 = c2 - 48;
+                else if (c2 >= 97 && c2 <= 102) d2 = c2 - 87;
+                else if (c2 >= 65 && c2 <= 70) d2 = c2 - 55;
+                else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+              endChar = d1 * 16 + d2;
+            }
         }
 
         // If either side is a predefined class, treat as literal chars
@@ -674,6 +712,30 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
         lastWasAtom = true;
         continue;
       }
+      if (char == 120) { // \x
+        if (patternPtr + 1 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\x escape');
+        const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+        const c2 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+
+        let d1: number;
+        if (c1 >= 48 && c1 <= 57) d1 = c1 - 48;
+          else if (c1 >= 97 && c1 <= 102) d1 = c1 - 87;
+          else if (c1 >= 65 && c1 <= 70) d1 = c1 - 55;
+          else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+        let d2: number;
+        if (c2 >= 48 && c2 <= 57) d2 = c2 - 48;
+          else if (c2 >= 97 && c2 <= 102) d2 = c2 - 87;
+          else if (c2 >= 65 && c2 <= 70) d2 = c2 - 55;
+          else throw new SyntaxError('Regex parse: invalid \\x escape');
+
+        lastAtomStart = bcPtr;
+        Porffor.wasm.i32.store8(bcPtr, 0x01, 0, 0);
+        Porffor.wasm.i32.store8(bcPtr, d1 * 16 + d2, 0, 1);
+        bcPtr += 2;
+        lastWasAtom = true;
+        continue;
+      }
     }
 
     // default: emit single char (either a literal, or an escape that resolves to a literal)