porffor 0.61.1 → 0.61.2

package/compiler/builtins/regexp.ts

@@ -68,8 +68,15 @@ export const __Porffor_array_fastPopI32 = (arr: any[]): i32 => {
   return ret;
 };
 
+export const __Porffor_regex_hexDigitToValue = (char: i32): i32 => {
+  if (char >= 48 && char <= 57) return char - 48; // '0'-'9'
+  if (char >= 97 && char <= 102) return char - 87; // 'a'-'f'
+  if (char >= 65 && char <= 70) return char - 55; // 'A'-'F'
+  throw new SyntaxError('Regex parse: invalid hex digit');
+};
+
 export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytestring): RegExp => {
-  const ptr: i32 = Porffor.allocate();
+  const ptr: i32 = Porffor.malloc();
   Porffor.wasm.i32.store(ptr, patternStr, 0, 0);
 
   // parse flags
@@ -131,9 +138,9 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
 
   let groupDepth: i32 = 0;
   // todo: free all at the end (or statically allocate but = [] causes memory corruption)
-  const groupStack: i32[] = Porffor.allocateBytes(6144);
-  const altDepth: i32[] = Porffor.allocateBytes(6144); // number of |s so far at each depth
-  const altStack: i32[] = Porffor.allocateBytes(6144);
+  const groupStack: i32[] = Porffor.malloc(6144);
+  const altDepth: i32[] = Porffor.malloc(6144); // number of |s so far at each depth
+  const altStack: i32[] = Porffor.malloc(6144);
 
   while (patternPtr < patternEndPtr) {
     let char: i32 = Porffor.wasm.i32.load8_u(patternPtr, 0, 4);
@@ -180,19 +187,7 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
           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;
+          v = __Porffor_regex_hexDigitToValue(c1) * 16 + __Porffor_regex_hexDigitToValue(c2);
         } else if (char == 117) { // \u
           if (patternPtr + 3 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\u escape');
           const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
@@ -200,28 +195,7 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
           const c3 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
           const c4 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
 
-          let d1: number, d2: number, d3: number, d4: 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 \\u escape');
-
-          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 \\u escape');
-
-          if (c3 >= 48 && c3 <= 57) d3 = c3 - 48;
-            else if (c3 >= 97 && c3 <= 102) d3 = c3 - 87;
-            else if (c3 >= 65 && c3 <= 70) d3 = c3 - 55;
-            else throw new SyntaxError('Regex parse: invalid \\u escape');
-
-          if (c4 >= 48 && c4 <= 57) d4 = c4 - 48;
-            else if (c4 >= 97 && c4 <= 102) d4 = c4 - 87;
-            else if (c4 >= 65 && c4 <= 70) d4 = c4 - 55;
-            else throw new SyntaxError('Regex parse: invalid \\u escape');
-
-          v = d1 * 4096 + d2 * 256 + d3 * 16 + d4;
+          v = __Porffor_regex_hexDigitToValue(c1) * 4096 + __Porffor_regex_hexDigitToValue(c2) * 256 + __Porffor_regex_hexDigitToValue(c3) * 16 + __Porffor_regex_hexDigitToValue(c4);
         } else if (char == 99) { // \c
           if (patternPtr >= patternEndPtr) {
             // No character after \c, treat as literal \c
@@ -272,48 +246,15 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
               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;
-            } else if (endChar == 117) { // \u
-              if (patternPtr + 3 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\u escape');
-              const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
-              const c2 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
-              const c3 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
-              const c4 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
-
-              let d1: number, d2: number, d3: number, d4: 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 \\u escape');
-
-              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 \\u escape');
-
-              if (c3 >= 48 && c3 <= 57) d3 = c3 - 48;
-                else if (c3 >= 97 && c3 <= 102) d3 = c3 - 87;
-                else if (c3 >= 65 && c3 <= 70) d3 = c3 - 55;
-                else throw new SyntaxError('Regex parse: invalid \\u escape');
-
-              if (c4 >= 48 && c4 <= 57) d4 = c4 - 48;
-                else if (c4 >= 97 && c4 <= 102) d4 = c4 - 87;
-                else if (c4 >= 65 && c4 <= 70) d4 = c4 - 55;
-                else throw new SyntaxError('Regex parse: invalid \\u escape');
-
-              endChar = d1 * 4096 + d2 * 256 + d3 * 16 + d4;
+              endChar = __Porffor_regex_hexDigitToValue(c1) * 16 + __Porffor_regex_hexDigitToValue(c2);
+              } else if (endChar == 117) { // \u
+               if (patternPtr + 3 >= patternEndPtr) throw new SyntaxError('Regex parse: invalid \\u escape');
+               const c1 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+               const c2 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+               const c3 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+               const c4 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
+
+               endChar = __Porffor_regex_hexDigitToValue(c1) * 4096 + __Porffor_regex_hexDigitToValue(c2) * 256 + __Porffor_regex_hexDigitToValue(c3) * 16 + __Porffor_regex_hexDigitToValue(c4);
             } else if (endChar == 99) { // \c
               if (patternPtr >= patternEndPtr) {
                 // No character after \c, treat as literal \c
@@ -875,21 +816,9 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
         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);
+        Porffor.wasm.i32.store8(bcPtr, __Porffor_regex_hexDigitToValue(c1) * 16 + __Porffor_regex_hexDigitToValue(c2), 0, 1);
         bcPtr += 2;
         lastWasAtom = true;
         continue;
@@ -901,29 +830,8 @@ export const __Porffor_regex_compile = (patternStr: bytestring, flagsStr: bytest
         const c3 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
         const c4 = Porffor.wasm.i32.load8_u(patternPtr++, 0, 4);
 
-        let d1: number, d2: number, d3: number, d4: 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 \\u escape');
-
-        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 \\u escape');
-
-        if (c3 >= 48 && c3 <= 57) d3 = c3 - 48;
-          else if (c3 >= 97 && c3 <= 102) d3 = c3 - 87;
-          else if (c3 >= 65 && c3 <= 70) d3 = c3 - 55;
-          else throw new SyntaxError('Regex parse: invalid \\u escape');
-
-        if (c4 >= 48 && c4 <= 57) d4 = c4 - 48;
-          else if (c4 >= 97 && c4 <= 102) d4 = c4 - 87;
-          else if (c4 >= 65 && c4 <= 70) d4 = c4 - 55;
-          else throw new SyntaxError('Regex parse: invalid \\u escape');
-
         Porffor.wasm.i32.store8(bcPtr, 0x01, 0, 0);
-        Porffor.wasm.i32.store8(bcPtr, d1 * 4096 + d2 * 256 + d3 * 16 + d4, 0, 1);
+        Porffor.wasm.i32.store8(bcPtr, __Porffor_regex_hexDigitToValue(c1) * 4096 + __Porffor_regex_hexDigitToValue(c2) * 256 + __Porffor_regex_hexDigitToValue(c3) * 16 + __Porffor_regex_hexDigitToValue(c4), 0, 1);
         bcPtr += 2;
 
         lastAtomStart = bcPtr;
@@ -997,7 +905,23 @@ export const __Porffor_regex_interpret = (regexp: RegExp, input: i32, isTest: bo
   const backtrackStack: i32[] = [];
   const captures: i32[] = [];
 
+  // check if first op is char for fast scan
+  let fastChar: i32 = -1;
+  if (!Porffor.fastOr(ignoreCase, sticky)) {
+    const firstOp = Porffor.wasm.i32.load8_u(bcBase, 0, 0);
+    if (firstOp == 0x01) {
+      fastChar = Porffor.wasm.i32.load8_u(bcBase, 0, 1);
+    }
+  }
+
   for (let i: i32 = lastIndex; i <= inputLen; i++) {
+    if (fastChar != -1) {
+      while (i < inputLen && Porffor.wasm.i32.load8_u(input + i, 0, 4) != fastChar) {
+        i++;
+      }
+      if (i > inputLen) break;
+    }
+
     backtrackStack.length = 0;
     captures.length = 0;
 
@@ -1007,314 +931,321 @@ export const __Porffor_regex_interpret = (regexp: RegExp, input: i32, isTest: bo
     let matched: boolean = false;
     let finalSp: i32 = -1;
 
-    while (true) {
+    interpreter: while (true) {
       const op: i32 = Porffor.wasm.i32.load8_u(pc, 0, 0);
+      let backtrack: boolean = false;
 
-      if (op == 0x10) { // accept
-        // Check if this is a lookahead accept
-        if (backtrackStack.length >= 4) {
-          const marker = backtrackStack[backtrackStack.length - 1];
-          if (marker == -2000 || marker == -3000) { // lookahead markers
-            // This is a lookahead accept
-            const isNegative = marker == -2000;
-
-            const savedMarker = Porffor.array.fastPopI32(backtrackStack);
-            const savedCapturesLen = Porffor.array.fastPopI32(backtrackStack);
-            const savedSp = Porffor.array.fastPopI32(backtrackStack);
-            const lookaheadEndPc = Porffor.array.fastPopI32(backtrackStack);
-
-            // Restore string position (lookaheads don't consume)
-            sp = savedSp;
-            captures.length = savedCapturesLen;
-
-            if (isNegative) {
-              // Negative lookahead: pattern matched, so fail completely
-              matched = false;
+      switch (op) {
+        case 0x10: { // accept
+          // Check if this is a lookahead accept
+          if (backtrackStack.length >= 4) {
+            const marker = backtrackStack[backtrackStack.length - 1];
+            if (marker == -2000 || marker == -3000) { // lookahead markers
+              // This is a lookahead accept
+              const isNegative = marker == -2000;
+
+              const savedMarker = Porffor.array.fastPopI32(backtrackStack);
+              const savedCapturesLen = Porffor.array.fastPopI32(backtrackStack);
+              const savedSp = Porffor.array.fastPopI32(backtrackStack);
+              const lookaheadEndPc = Porffor.array.fastPopI32(backtrackStack);
+
+              // Restore string position (lookaheads don't consume)
+              sp = savedSp;
+              captures.length = savedCapturesLen;
+
+              if (isNegative) {
+                // Negative lookahead: pattern matched, so fail completely
+                matched = false;
+                break interpreter;
+              } else {
+                // Positive lookahead: pattern matched, so continue after lookahead
+                pc = lookaheadEndPc;
+              }
               break;
-            } else {
-              // Positive lookahead: pattern matched, so continue after lookahead
-              pc = lookaheadEndPc;
-              continue;
             }
-          } else {
-            // Normal accept
-            matched = true;
-            finalSp = sp;
-            break;
           }
-        } else {
+
           // Normal accept
           matched = true;
           finalSp = sp;
-          break;
+          break interpreter;
         }
-      }
-
-      let backtrack: boolean = false;
 
-      if (op == 0x01) { // single
-        if (sp >= inputLen) {
-          backtrack = true;
-        } else {
-          let c1: i32 = Porffor.wasm.i32.load8_u(pc, 0, 1);
-          let c2: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
-          if (ignoreCase) {
-            if (c1 >= 97 && c1 <= 122) c1 -= 32;
-            if (c2 >= 97 && c2 <= 122) c2 -= 32;
-          }
-          if (c1 == c2) {
-            pc += 2;
-            sp += 1;
-          } else {
+        case 0x01: { // single
+          if (sp >= inputLen) {
             backtrack = true;
+          } else {
+            let c1: i32 = Porffor.wasm.i32.load8_u(pc, 0, 1);
+            let c2: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
+            if (ignoreCase) {
+              if (c1 >= 97 && c1 <= 122) c1 -= 32;
+              if (c2 >= 97 && c2 <= 122) c2 -= 32;
+            }
+            if (c1 == c2) {
+              pc += 2;
+              sp += 1;
+            } else {
+              backtrack = true;
+            }
           }
+          break;
         }
-      } else if (op == 0x02 || op == 0x03) { // class or negated class
-        if (sp >= inputLen) {
-          backtrack = true;
-        } else {
-          let char: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
-          let classPc: i32 = pc + 1;
-          let charInClass: boolean = false;
-          while (true) {
-            const marker: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 0);
-            if (marker == 0xFF) break; // end of class
-
-            if (marker == 0x00) { // range
-              let from: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 1);
-              let to: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 2);
-              let cCheck: i32 = char;
-              if (ignoreCase) {
-                if (from >= 97 && from <= 122) from -= 32;
-                if (to >= 97 && to <= 122) to -= 32;
-                if (cCheck >= 97 && cCheck <= 122) cCheck -= 32;
-              }
-              if (cCheck >= from && cCheck <= to) {
-                charInClass = true;
-                break;
-              }
-              classPc += 3;
-            } else if (marker == 0x01) { // char
-              let c1: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 1);
-              let c2: i32 = char;
-              if (ignoreCase) {
-                if (c1 >= 97 && c1 <= 122) c1 -= 32;
-                if (c2 >= 97 && c2 <= 122) c2 -= 32;
-              }
-              if (c1 == c2) {
-                charInClass = true;
-                break;
+
+        case 0x02: // class
+        case 0x03: { // negated class
+          if (sp >= inputLen) {
+            backtrack = true;
+          } else {
+            let char: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
+            let classPc: i32 = pc + 1;
+            let charInClass: boolean = false;
+            while (true) {
+              const marker: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 0);
+              if (marker == 0xFF) break; // end of class
+
+              if (marker == 0x00) { // range
+                let from: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 1);
+                let to: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 2);
+                let cCheck: i32 = char;
+                if (ignoreCase) {
+                  if (from >= 97 && from <= 122) from -= 32;
+                  if (to >= 97 && to <= 122) to -= 32;
+                  if (cCheck >= 97 && cCheck <= 122) cCheck -= 32;
+                }
+                if (cCheck >= from && cCheck <= to) {
+                  charInClass = true;
+                  break;
+                }
+                classPc += 3;
+              } else if (marker == 0x01) { // char
+                let c1: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 1);
+                let c2: i32 = char;
+                if (ignoreCase) {
+                  if (c1 >= 97 && c1 <= 122) c1 -= 32;
+                  if (c2 >= 97 && c2 <= 122) c2 -= 32;
+                }
+                if (c1 == c2) {
+                  charInClass = true;
+                  break;
+                }
+                classPc += 2;
+              } else if (marker == 0x02) { // predefined
+                const classId: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 1);
+                let isMatch: boolean = false;
+                if (classId == 1) isMatch = char >= 48 && char <= 57;
+                else if (classId == 2) isMatch = !(char >= 48 && char <= 57);
+                else if (classId == 3) isMatch = Porffor.fastOr(char == 32, char == 9, char == 10, char == 13, char == 11, char == 12);
+                else if (classId == 4) isMatch = !Porffor.fastOr(char == 32, char == 9, char == 10, char == 13, char == 11, char == 12);
+                else if (classId == 5) isMatch = (char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57) || char == 95;
+                else if (classId == 6) isMatch = !((char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57) || char == 95);
+
+                if (isMatch) {
+                  charInClass = true;
+                  break;
+                }
+                classPc += 2;
               }
-              classPc += 2;
-            } else if (marker == 0x02) { // predefined
-              const classId: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 1);
-              let isMatch: boolean = false;
-              if (classId == 1) isMatch = char >= 48 && char <= 57;
-              else if (classId == 2) isMatch = !(char >= 48 && char <= 57);
-              else if (classId == 3) isMatch = Porffor.fastOr(char == 32, char == 9, char == 10, char == 13, char == 11, char == 12);
-              else if (classId == 4) isMatch = !Porffor.fastOr(char == 32, char == 9, char == 10, char == 13, char == 11, char == 12);
-              else if (classId == 5) isMatch = (char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57) || char == 95;
-              else if (classId == 6) isMatch = !((char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57) || char == 95);
-
-              if (isMatch) {
-                charInClass = true;
-                break;
+            }
+
+            if (op == 0x03) charInClass = !charInClass;
+
+            if (charInClass) {
+              while (Porffor.wasm.i32.load8_u(classPc, 0, 0) != 0xFF) {
+                const marker: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 0);
+                if (marker == 0x00) classPc += 3;
+                else if (marker == 0x01) classPc += 2;
+                else if (marker == 0x02) classPc += 2;
               }
-              classPc += 2;
+              pc = classPc + 1;
+              sp += 1;
+            } else {
+              backtrack = true;
             }
           }
+          break;
+        }
 
-          if (op == 0x03) charInClass = !charInClass;
-
-          if (charInClass) {
-            while (Porffor.wasm.i32.load8_u(classPc, 0, 0) != 0xFF) {
-              const marker: i32 = Porffor.wasm.i32.load8_u(classPc, 0, 0);
-              if (marker == 0x00) classPc += 3;
-              else if (marker == 0x01) classPc += 2;
-              else if (marker == 0x02) classPc += 2;
+        case 0x04: { // predefined class
+          if (sp >= inputLen) {
+            backtrack = true;
+          } else {
+            const classId: i32 = Porffor.wasm.i32.load8_u(pc, 0, 1);
+            const char: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
+            let isMatch: boolean = false;
+            if (classId == 1) isMatch = char >= 48 && char <= 57;
+            else if (classId == 2) isMatch = !(char >= 48 && char <= 57);
+            else if (classId == 3) isMatch = Porffor.fastOr(char == 32, char == 9, char == 10, char == 13, char == 11, char == 12);
+            else if (classId == 4) isMatch = !Porffor.fastOr(char == 32, char == 9, char == 10, char == 13, char == 11, char == 12);
+            else if (classId == 5) isMatch = (char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57) || char == 95;
+            else if (classId == 6) isMatch = !((char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57) || char == 95);
+
+            if (isMatch) {
+              pc += 2;
+              sp += 1;
+            } else {
+              backtrack = true;
             }
-            pc = classPc + 1;
-            sp += 1;
+          }
+          break;
+        }
+
+        case 0x05: // start
+          if (sp == 0 || (multiline && sp > 0 && Porffor.wasm.i32.load8_u(input + sp, 0, 3) == 10)) {
+            pc += 1;
           } else {
             backtrack = true;
           }
-        }
-      } else if (op == 0x04) { // predefined class
-        if (sp >= inputLen) {
-          backtrack = true;
-        } else {
-          const classId: i32 = Porffor.wasm.i32.load8_u(pc, 0, 1);
-          const char: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
-          let isMatch: boolean = false;
-          if (classId == 1) isMatch = char >= 48 && char <= 57;
-          else if (classId == 2) isMatch = !(char >= 48 && char <= 57);
-          else if (classId == 3) isMatch = Porffor.fastOr(char == 32, char == 9, char == 10, char == 13, char == 11, char == 12);
-          else if (classId == 4) isMatch = !Porffor.fastOr(char == 32, char == 9, char == 10, char == 13, char == 11, char == 12);
-          else if (classId == 5) isMatch = (char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57) || char == 95;
-          else if (classId == 6) isMatch = !((char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57) || char == 95);
-
-          if (isMatch) {
-            pc += 2;
-            sp += 1;
+          break;
+
+        case 0x06: // end
+          if (sp == inputLen || (multiline && sp < inputLen && Porffor.wasm.i32.load8_u(input + sp, 0, 4) == 10)) {
+            pc += 1;
           } else {
             backtrack = true;
           }
-        }
-      } else if (op == 0x05) { // start
-        if (sp == 0 || (multiline && sp > 0 && Porffor.wasm.i32.load8_u(input + sp, 0, 3) == 10)) {
-          pc += 1;
-        } else {
-          backtrack = true;
-        }
-      } else if (op == 0x06) { // end
-        if (sp == inputLen || (multiline && sp < inputLen && Porffor.wasm.i32.load8_u(input + sp, 0, 4) == 10)) {
-          pc += 1;
-        } else {
-          backtrack = true;
-        }
-      } else if (op == 0x07) { // word boundary
-        let prevIsWord: boolean = false;
-        if (sp > 0) {
-          const prevChar: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 3);
-          prevIsWord = Porffor.fastOr(
-            prevChar >= 65 && prevChar <= 90, // A-Z
-            prevChar >= 97 && prevChar <= 122, // a-z
-            prevChar >= 48 && prevChar <= 57, // 0-9
-            prevChar == 95 // _
-          );
-        }
+          break;
 
-        let nextIsWord: boolean = false;
-        if (sp < inputLen) {
-          const nextChar: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
-          nextIsWord = Porffor.fastOr(
-            nextChar >= 65 && nextChar <= 90, // A-Z
-            nextChar >= 97 && nextChar <= 122, // a-z
-            nextChar >= 48 && nextChar <= 57, // 0-9
-            nextChar == 95 // _
-          );
-        }
+        case 0x07: // word boundary
+        case 0x08: { // non-word boundary
+          let prevIsWord: boolean = false;
+          if (sp > 0) {
+            const prevChar: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 3);
+            prevIsWord = Porffor.fastOr(
+              prevChar >= 65 && prevChar <= 90, // A-Z
+              prevChar >= 97 && prevChar <= 122, // a-z
+              prevChar >= 48 && prevChar <= 57, // 0-9
+              prevChar == 95 // _
+            );
+          }
 
-        if (prevIsWord != nextIsWord) {
-          pc += 1;
-        } else {
-          backtrack = true;
-        }
-      } else if (op == 0x08) { // non-word boundary
-        let prevIsWord: boolean = false;
-        if (sp > 0) {
-          const prevChar: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 3);
-          prevIsWord = Porffor.fastOr(
-            prevChar >= 65 && prevChar <= 90, // A-Z
-            prevChar >= 97 && prevChar <= 122, // a-z
-            prevChar >= 48 && prevChar <= 57, // 0-9
-            prevChar == 95 // _
-          );
-        }
+          let nextIsWord: boolean = false;
+          if (sp < inputLen) {
+            const nextChar: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
+            nextIsWord = Porffor.fastOr(
+              nextChar >= 65 && nextChar <= 90, // A-Z
+              nextChar >= 97 && nextChar <= 122, // a-z
+              nextChar >= 48 && nextChar <= 57, // 0-9
+              nextChar == 95 // _
+            );
+          }
 
-        let nextIsWord: boolean = false;
-        if (sp < inputLen) {
-          const nextChar: i32 = Porffor.wasm.i32.load8_u(input + sp, 0, 4);
-          nextIsWord = Porffor.fastOr(
-            nextChar >= 65 && nextChar <= 90, // A-Z
-            nextChar >= 97 && nextChar <= 122, // a-z
-            nextChar >= 48 && nextChar <= 57, // 0-9
-            nextChar == 95 // _
-          );
+          const isWordBoundary = prevIsWord != nextIsWord;
+          if ((op == 0x07 && isWordBoundary) || (op == 0x08 && !isWordBoundary)) {
+            pc += 1;
+          } else {
+            backtrack = true;
+          }
+          break;
         }
 
-        if (prevIsWord == nextIsWord) {
-          pc += 1;
-        } else {
-          backtrack = true;
-        }
-      } else if (op == 0x09) { // dot
-        if (sp >= inputLen || (!dotAll && Porffor.wasm.i32.load8_u(input + sp, 0, 4) == 10)) {
-          backtrack = true;
-        } else {
-          pc += 1;
-          sp += 1;
-        }
-      } else if (op == 0x0a) { // back reference
-        const capIndex = Porffor.wasm.i32.load8_u(pc, 0, 1);
-        const arrIndex = (capIndex - 1) * 2;
-        if (arrIndex + 1 >= captures.length) { // reference to group that hasn't been seen
-          pc += 2;
-        } else {
-          const capStart = captures[arrIndex];
-          const capEnd = captures[arrIndex + 1];
-          if (capStart == -1 || capEnd == -1) { // reference to unmatched group
+        case 0x09: // dot
+          if (sp >= inputLen || (!dotAll && Porffor.wasm.i32.load8_u(input + sp, 0, 4) == 10)) {
+            backtrack = true;
+          } else {
+            pc += 1;
+            sp += 1;
+          }
+          break;
+
+        case 0x0a: { // back reference
+          const capIndex = Porffor.wasm.i32.load8_u(pc, 0, 1);
+          const arrIndex = (capIndex - 1) * 2;
+          if (arrIndex + 1 >= captures.length) { // reference to group that hasn't been seen
             pc += 2;
           } else {
-            const capLen = capEnd - capStart;
-            if (sp + capLen > inputLen) {
-              backtrack = true;
+            const capStart = captures[arrIndex];
+            const capEnd = captures[arrIndex + 1];
+            if (capStart == -1 || capEnd == -1) { // reference to unmatched group
+              pc += 2;
             } else {
-              let matches = true;
-              for (let k = 0; k < capLen; k++) {
-                let c1 = Porffor.wasm.i32.load8_u(input + capStart + k, 0, 4);
-                let c2 = Porffor.wasm.i32.load8_u(input + sp + k, 0, 4);
-                if (ignoreCase) {
-                  if (c1 >= 97 && c1 <= 122) c1 -= 32;
-                  if (c2 >= 97 && c2 <= 122) c2 -= 32;
+              const capLen = capEnd - capStart;
+              if (sp + capLen > inputLen) {
+                backtrack = true;
+              } else {
+                let matches = true;
+                for (let k = 0; k < capLen; k++) {
+                  let c1 = Porffor.wasm.i32.load8_u(input + capStart + k, 0, 4);
+                  let c2 = Porffor.wasm.i32.load8_u(input + sp + k, 0, 4);
+                  if (ignoreCase) {
+                    if (c1 >= 97 && c1 <= 122) c1 -= 32;
+                    if (c2 >= 97 && c2 <= 122) c2 -= 32;
+                  }
+                  if (c1 != c2) {
+                    matches = false;
+                    break;
+                  }
                 }
-                if (c1 != c2) {
-                  matches = false;
-                  break;
+                if (matches) {
+                  sp += capLen;
+                  pc += 2;
+                } else {
+                  backtrack = true;
                 }
               }
-              if (matches) {
-                sp += capLen;
-                pc += 2;
-              } else {
-                backtrack = true;
-              }
             }
           }
+          break;
+        }
+
+        case 0x0b:
+        case 0x0c: { // positive or negative lookahead
+          const jumpOffset = Porffor.wasm.i32.load16_s(pc, 0, 1);
+          const lookaheadEndPc = pc + jumpOffset + 3;
+          const savedSp = sp; // Save current string position
+
+          // Use fork to test the lookahead pattern
+          Porffor.array.fastPushI32(backtrackStack, lookaheadEndPc); // Continue point after lookahead
+          Porffor.array.fastPushI32(backtrackStack, savedSp); // Restore original sp
+          Porffor.array.fastPushI32(backtrackStack, captures.length);
+
+          // Mark this as a lookahead with special values
+          if (op == 0x0c) { // negative lookahead
+            Porffor.array.fastPushI32(backtrackStack, -2000); // Special marker for negative
+          } else { // positive lookahead
+            Porffor.array.fastPushI32(backtrackStack, -3000); // Special marker for positive
+          }
+
+          pc = pc + 3; // Jump to lookahead content
+          break;
+        }
+
+        case 0x20: // jump
+          pc += Porffor.wasm.i32.load16_s(pc, 0, 1);
+          break;
+
+        case 0x21: { // fork
+          const branch1Offset = Porffor.wasm.i32.load16_s(pc, 0, 1);
+          const branch2Offset = Porffor.wasm.i32.load16_s(pc, 0, 3);
+
+          Porffor.array.fastPushI32(backtrackStack, pc + branch2Offset);
+          Porffor.array.fastPushI32(backtrackStack, sp);
+          Porffor.array.fastPushI32(backtrackStack, captures.length);
+
+          pc += branch1Offset;
+          break;
         }
-      } else if (op == 0x0b || op == 0x0c) { // positive or negative lookahead
-        const jumpOffset = Porffor.wasm.i32.load16_s(pc, 0, 1);
-        const lookaheadEndPc = pc + jumpOffset + 3;
-        const savedSp = sp; // Save current string position
-
-        // Use fork to test the lookahead pattern
-        Porffor.array.fastPushI32(backtrackStack, lookaheadEndPc); // Continue point after lookahead
-        Porffor.array.fastPushI32(backtrackStack, savedSp); // Restore original sp
-        Porffor.array.fastPushI32(backtrackStack, captures.length);
-
-        // Mark this as a lookahead with special values
-        if (op == 0x0c) { // negative lookahead
-          Porffor.array.fastPushI32(backtrackStack, -2000); // Special marker for negative
-        } else { // positive lookahead
-          Porffor.array.fastPushI32(backtrackStack, -3000); // Special marker for positive
+
+        case 0x30: { // start capture
+          const capIndex = Porffor.wasm.i32.load8_u(pc, 0, 1);
+          const arrIndex = capIndex + 255; // + 255 offset for temp start, as it could never end properly
+          captures[arrIndex] = sp;
+          pc += 2;
+          break;
         }
 
-        pc = pc + 3; // Jump to lookahead content
-      } else if (op == 0x20) { // jump
-        pc += Porffor.wasm.i32.load16_s(pc, 0, 1);
-      } else if (op == 0x21) { // fork
-        const branch1Offset = Porffor.wasm.i32.load16_s(pc, 0, 1);
-        const branch2Offset = Porffor.wasm.i32.load16_s(pc, 0, 3);
-
-        Porffor.array.fastPushI32(backtrackStack, pc + branch2Offset);
-        Porffor.array.fastPushI32(backtrackStack, sp);
-        Porffor.array.fastPushI32(backtrackStack, captures.length);
-
-        pc += branch1Offset;
-      } else if (op == 0x30) { // start capture
-        const capIndex = Porffor.wasm.i32.load8_u(pc, 0, 1);
-        const arrIndex = capIndex + 255; // + 255 offset for temp start, as it could never end properly
-        captures[arrIndex] = sp;
-        pc += 2;
-      } else if (op == 0x31) { // end capture
-        const capIndex = Porffor.wasm.i32.load8_u(pc, 0, 1);
-        const arrIndex = (capIndex - 1) * 2 + 1;
-        while (captures.length <= arrIndex) Porffor.array.fastPushI32(captures, -1);
-        captures[arrIndex - 1] = captures[capIndex + 255];
-        captures[arrIndex] = sp;
-        pc += 2;
-      } else { // unknown op
-        backtrack = true;
+        case 0x31: { // end capture
+          const capIndex = Porffor.wasm.i32.load8_u(pc, 0, 1);
+          const arrIndex = (capIndex - 1) * 2 + 1;
+          while (captures.length <= arrIndex) Porffor.array.fastPushI32(captures, -1);
+          captures[arrIndex - 1] = captures[capIndex + 255];
+          captures[arrIndex] = sp;
+          pc += 2;
+          break;
+        }
+
+        default:
+          backtrack = true;
+          break;
       }
 
       if (backtrack) {
@@ -1361,7 +1292,7 @@ export const __Porffor_regex_interpret = (regexp: RegExp, input: i32, isTest: bo
         Porffor.wasm.i32.store16(regexp, finalSp, 0, 8); // write last index
       }
 
-      const result: any[] = Porffor.allocateBytes(4096);
+      const result: any[] = Porffor.malloc(4096);
       Porffor.array.fastPush(result, __ByteString_prototype_substring(input, matchStart, finalSp));
 
       for (let k = 0; k < totalCaptures; k++) {
@@ -1418,7 +1349,7 @@ export const __RegExp_prototype_flags$get = (_this: RegExp) => {
 
   // 3. Let codeUnits be a new empty List.
   const flags: i32 = Porffor.wasm.i32.load16_u(_this, 0, 4);
-  const result: bytestring = Porffor.allocateBytes(16);
+  const result: bytestring = Porffor.malloc(16);
 
   // 4. Let hasIndices be ToBoolean(? Get(R, "hasIndices")).
   // 5. If hasIndices is true, append the code unit 0x0064 (LATIN SMALL LETTER D) to codeUnits.
@@ -1529,7 +1460,7 @@ export const __Porffor_regex_match = (regexp: any, input: any) => {
 
   if (__RegExp_prototype_global$get(regexp)) {
     // global should return all matches as just complete string result
-    const result: any[] = Porffor.allocateBytes(4096);
+    const result: any[] = Porffor.malloc(4096);
     let match: any;
     while (match = __Porffor_regex_interpret(regexp, input, false)) {
       // read ourselves as we are in i32 space
@@ -1567,7 +1498,7 @@ export const __Porffor_regex_matchAll = (regexp: any, input: any) => {
 
   if (!__RegExp_prototype_global$get(regexp)) throw new TypeError('matchAll used with non-global RegExp');
 
-  const result: any[] = Porffor.allocateBytes(4096);
+  const result: any[] = Porffor.malloc(4096);
   let match: any;
   while (match = __Porffor_regex_interpret(regexp, input, false)) {
     Porffor.array.fastPush(result, match);
@@ -1596,7 +1527,7 @@ export const __Porffor_regex_escapeX = (out: bytestring, char: i32) => {
 };
 
 export const __RegExp_escape = (str: any) => {
-  const out: bytestring = Porffor.allocate();
+  const out: bytestring = Porffor.malloc();
 
   let i: i32 = 0;
   const first: i32 = str.charCodeAt(0);