replaces #21 (#22)

* opt

* remove 'unreachable code' hack

Co-authored-by: MaxGraey <[email protected]>

Author: ColinEberhardt

assembly/nfa/matcher.ts

@@ -6,11 +6,18 @@ import {
   CharacterClassNode,
   CharacterRangeNode,
   NodeType,
-  Node,
 } from "../parser/node";
-import { Match } from "../regexp";
+
+const enum MatcherType {
+  Character,
+  CharacterRange,
+  CharacterClass,
+  CharacterSet,
+}
 
 export class Matcher {
+  constructor(readonly type: MatcherType) {}
+
   matches(code: u32): bool {
     return false;
   }
@@ -50,7 +57,7 @@ export class Matcher {
 
 export class CharacterMatcher extends Matcher {
   constructor(public character: Char) {
-    super();
+    super(MatcherType.Character);
   }
 
   matches(code: u32): bool {
@@ -60,7 +67,7 @@ export class CharacterMatcher extends Matcher {
 
 export class CharacterRangeMatcher extends Matcher {
   constructor(public from: u32, public to: u32) {
-    super();
+    super(MatcherType.CharacterRange);
   }
 
   matches(code: u32): bool {
@@ -70,7 +77,7 @@ export class CharacterRangeMatcher extends Matcher {
 
 export class CharacterClassMatcher extends Matcher {
   constructor(public charClass: Char) {
-    super();
+    super(MatcherType.CharacterClass);
   }
 
   matches(code: u32): bool {
@@ -113,20 +120,34 @@ export class CharacterClassMatcher extends Matcher {
   }
 }
 
-// no closure support
-let _code: u32;
-
 export class CharacterSetMatcher extends Matcher {
   constructor(public matchers: Matcher[], public negated: bool) {
-    super();
+    super(MatcherType.CharacterSet);
   }
 
   matches(code: u32): bool {
-    _code = code;
-    if (!this.negated) {
-      return this.matchers.some((m) => m.matches(_code));
-    } else {
-      return !this.matchers.some((m) => m.matches(_code));
+    let match: bool = false;
+    for (let i = 0, len = this.matchers.length; i < len; i++) {
+      let matcher = this.matchers[i];
+      switch (matcher.type) {
+        case MatcherType.Character:
+          match = (matcher as CharacterMatcher).matches(code);
+          break;
+
+        case MatcherType.CharacterRange:
+          match = (matcher as CharacterRangeMatcher).matches(code);
+          break;
+
+        case MatcherType.CharacterClass:
+          match = (matcher as CharacterClassMatcher).matches(code);
+          break;
+
+        case MatcherType.CharacterSet:
+          match = (matcher as CharacterSetMatcher).matches(code);
+          break;
+      }
+      if (match) break;
     }
+    return this.negated ? !match : match;
   }
 }

assembly/regexp.ts

@@ -152,32 +152,6 @@ export class RegExp {
 // TODO: do we need this factory function, or can we invoke
 // the ctr via the loader?
 export function createRegExp(regex: string, flags: string): RegExp {
-  /* ---------------- */
-  /*
-    This block of code is needed to avoid the following runtime error ...
-
-    RuntimeError: unreachable
-        at assembly/nfa/matcher/Matcher#matches@virtual (wasm-function[240]:1)
-        at assembly/nfa/matcher/CharacterSetMatcher#matches~anonymous|0 (wasm-function[241]:19)
-        at ~lib/array/Array<assembly/nfa/matcher/Matcher>#some (wasm-function[242]:85)
-        at assembly/nfa/matcher/CharacterSetMatcher#matches (wasm-function[244]:21)
-        at assembly/nfa/nfa/MatcherState<assembly/nfa/matcher/CharacterSetMatcher>#matches (wasm-function[245]:8)
-        at assembly/nfa/nfa/State#matches@virtual (wasm-function[250]:58)
-        at assembly/regexp/recursiveBacktrackingSearch (wasm-function[184]:121)
-        at assembly/regexp/recursiveBacktrackingSearch@varargs (wasm-function[185]:56)
-        at assembly/regexp/RegExp#exec (wasm-function[192]:307)
-  */
-  const matchers = new Array<Matcher>();
-  matchers.push(new CharacterMatcher(Char.A));
-  const charMatcher = new CharacterSetMatcher(matchers, false);
-  const state = new MatcherState<CharacterSetMatcher>(
-    charMatcher,
-    new State(true)
-  );
-  const char = "a".charCodeAt(0);
-  const doesMatch = state.matches(char) != null;
-  /* ---------------- */
-
   return new RegExp(regex, flags);
 }