feat: implemented non-greedy matching

Author: ColinEberhardt

assembly/__spec_tests__/generated.spec.ts

@@ -7,7 +7,9 @@ it("matches empty strings", () => {
 
 it("zero or one", () => {
   expectMatch("a?", ["a"]);
-  // expectNotMatch("a?", ["bc"]);
+  let match = exec("a?", "bc");
+  expect(match).not.toBeNull();
+  expect(match.matches[0]).toStrictEqual("");
 });
 
 it("one or more", () => {
@@ -35,3 +37,24 @@ it("one or more is greedy", () => {
   expect(match).not.toBeNull();
   expect(match.matches[0]).toStrictEqual("aaaaa");
 });
+
+describe("non-greedy", () => {
+  it("one or more supports non-greedy mode", () => {
+    let match = exec("[a-c]+?b", "abb");
+    expect(match).not.toBeNull();
+    expect(match.matches[0]).toStrictEqual("ab");
+  });
+
+  it("zero or more supports non-greedy mode", () => {
+    let match = exec("[a-c]*?b", "abb");
+    expect(match).not.toBeNull();
+    expect(match.matches[0]).toStrictEqual("ab");
+  });
+
+  it("zero or one supports non-greedy mode", () => {
+    expectMatch("a?", ["a"]);
+    let match = exec("a?", "bc");
+    expect(match).not.toBeNull();
+    expect(match.matches[0]).toStrictEqual("");
+  });
+});

assembly/__tests__/quantifiers.spec.ts

@@ -117,15 +117,20 @@ function union(first: Automata, second: Automata): Automata {
   return new Automata(start, end);
 }
 
-function closure(nfa: Automata): Automata {
+function closure(nfa: Automata, greedy: bool): Automata {
   const start = new State();
   const end = new State();
-  // to ensure greedy matches, the epsilon transitions that loop-back
-  // need to be first in the list
-  start.transitions.push(nfa.start);
-  start.transitions.push(end);
-  nfa.end.transitions.push(nfa.start);
-  nfa.end.transitions.push(end);
+  if (greedy) {
+    nfa.end.transitions.push(nfa.start);
+    nfa.end.transitions.push(end);
+    start.transitions.push(nfa.start);
+    start.transitions.push(end);
+  } else {
+    nfa.end.transitions.push(end);
+    nfa.end.transitions.push(nfa.start);
+    start.transitions.push(end);
+    start.transitions.push(nfa.start);
+  }
   return new Automata(start, end);
 }
 
@@ -138,14 +143,17 @@ function zeroOrOne(nfa: Automata): Automata {
   return new Automata(start, end);
 }
 
-function oneOrMore(nfa: Automata): Automata {
+function oneOrMore(nfa: Automata, greedy: bool): Automata {
   const start = new State();
   const end = new State();
   start.transitions.push(nfa.start);
-  // to ensure greedy matches, the epsilon transitions that loop-back
-  // need to be first in the list
-  nfa.end.transitions.push(nfa.start);
-  nfa.end.transitions.push(end);
+  if (greedy) {
+    nfa.end.transitions.push(nfa.start);
+    nfa.end.transitions.push(end);
+  } else {
+    nfa.end.transitions.push(end);
+    nfa.end.transitions.push(nfa.start);
+  }
   return new Automata(start, end);
 }
 
@@ -176,9 +184,9 @@ class AutomataFactor {
         if (quantifier == Char.Question) {
           return zeroOrOne(automata);
         } else if (quantifier == Char.Plus) {
-          return oneOrMore(automata);
+          return oneOrMore(automata, node.greedy);
         } else if (quantifier == Char.Asterisk) {
-          return closure(automata);
+          return closure(automata, node.greedy);
         } else {
           throw new Error(
             "unsupported quantifier - " + String.fromCharCode(quantifier)

assembly/nfa/nfa.ts

@@ -137,7 +137,11 @@ export class CharacterClassNode extends Node {
 }
 
 export class RepetitionNode extends Node {
-  constructor(public expression: Node, public quantifier: Char) {
+  constructor(
+    public expression: Node,
+    public quantifier: Char,
+    public greedy: bool = true
+  ) {
     super(NodeType.Repetition);
   }
 

assembly/parser/node.ts

@@ -243,8 +243,13 @@ export class Parser {
         }
       } else if (isQuantifier(token)) {
         const expression = nodes.pop();
-        nodes.push(new RepetitionNode(expression, token));
-        this.eatToken();
+        const quantifier = this.eatToken();
+        let greedy = true;
+        if (this.iterator.current == Char.Question) {
+          greedy = false;
+          this.eatToken();
+        }
+        nodes.push(new RepetitionNode(expression, quantifier, greedy));
         // @ts-ignore
       } else if (token == Char.LeftSquareBracket) {
         nodes.push(this.parseCharacterSet());

assembly/parser/parser.ts

@@ -481,7 +481,7 @@ E$ckv	  (?: [\\040\\t] |  \\(\n\
 (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\n\
 \\)  )*  > #                  trailing >\n\
 # name and address\n\
-)  (?: [\\040\\t] |  \\(\n\
+)  (?: [\\040\\t] |  \\(\n\^[ab]{1,3}(ab*?|b)
 (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\n\
 \\)  )*                       # optional trailing comment\n\
 	Alan Other <[email protected]>	(0,25)

spec/pcre-1.dat

@@ -13,6 +13,8 @@ const knownIssues = {
     1103,
     ...range(1185, 1188),
     ...range(1095, 1098),
+    ...range(487, 494),
+    ...range(1077, 1082),
   ],
   "issues with repeated capture groups": [
     262,
@@ -21,6 +23,10 @@ const knownIssues = {
     1391,
     1392,
   ],
+  "lazy quantifiers should still yield the longest overall regex match": [
+    ...range(141, 143),
+    1288,
+  ],
   "test contains an octal escape sequence": [1102],
   "requires triage": [
     1087,
@@ -103,8 +109,8 @@ lines.forEach((line, index) => {
       return;
     }
 
-    if (["*?", "??", "+?", "}?"].some((f) => regex.includes(f))) {
-      testCase += `xit("line: ${index} - lazy quantifiers are not supported", () => { });`;
+    if (["}?"].some((f) => regex.includes(f))) {
+      testCase += `xit("line: ${index} - lazy range repitition quantifiers are not supported", () => { });`;
       return;
     }
 

spec/test-generator.js

@@ -5,7 +5,7 @@ globalAny.log = console.log;
 
 import { RegExp } from "../assembly/regexp";
 
-const regexObj = new RegExp("^\\s");
-const match = regexObj.exec("\040abc");
+const regexObj = new RegExp(".*?");
+const match = regexObj.exec("abc");
 
 console.log(match);