Implement lookahead and negative lookahead assertions

Author: milseman

Sources/_StringProcessing/Compiler.swift

@@ -79,9 +79,17 @@ class Compiler {
  case .trivia, .empty:
  break
 
- // FIXME: This can't be right...
  case .group(let g):
- try emit(g.child)
+ switch g.kind.value {
+
+ case .lookahead, .negativeLookahead,
+ .lookbehind, .negativeLookbehind:
+ try compileLookaround(g.kind.value, g.child)
+
+ default:
+ // FIXME: This can't be right...
+ try emit(g.child)
+ }
 
  case .quantification(let quant):
  try emitQuantification(quant)
@@ -101,6 +109,60 @@ class Compiler {
  }
  }
 
+ func compileLookaround(
+ _ kind: AST.Group.Kind,
+ _ child: AST
+ ) throws {
+ switch kind {
+ case .lookbehind, .negativeLookbehind:
+ throw unsupported("\(kind) assertions")
+
+ case .lookahead, .negativeLookahead:
+ break
+
+ default: fatalError("unreachable")
+ }
+
+ let positive = kind == .lookahead
+ assert(positive || kind == .negativeLookahead)
+ _ = """
+ save(restoringAt: success)
+ save(restoringAt: intercept)
+ <sub-pattern> // failure restores at intercept
+ clearSavePoint // remove intercept
+ <if negative>:
+ clearSavePoint // remove success
+ fail // positive->success, negative propagates
+ intercept:
+ <if positive>:
+ clearSavePoint // remove result
+ fail // positive propagates, negative->success
+ success:
+ ...
+ """
+
+ let intercept = builder.makeAddress()
+ let success = builder.makeAddress()
+
+ builder.buildSave(success)
+ builder.buildSave(intercept)
+ try emit(child)
+ builder.buildClear()
+ if !positive {
+ builder.buildClear()
+ }
+ builder.buildFail()
+
+ builder.label(intercept)
+ if positive {
+ builder.buildClear()
+ }
+ builder.buildFail()
+
+ builder.label(success)
+ }
+
+
  func compileQuantification(
  low: Int,
  high: Int?,

Tests/RegexTests/CompileTests.swift

@@ -6,6 +6,28 @@ import XCTest
 
 extension RegexTests {
 
+ private func testCompilationEquivalence(
+ _ equivs: [String]
+ ) throws {
+ assert(!equivs.isEmpty)
+ let progs = try equivs.map {
+ try _compileRegex($0).engine.program
+ }
+ let ref = progs.first!
+ for prog in progs.dropFirst() {
+ guard ref.instructions.elementsEqual(
+ prog.instructions) else {
+ XCTFail("""
+ Reference:
+ \(ref)
+ Current:
+ \(prog)
+ """)
+ continue
+ }
+ }
+ }
+
  func testCompileQuantification() throws {
 
  // NOTE: While we might change how we compile
@@ -26,15 +48,22 @@ extension RegexTests {
  ]
 
  for row in equivalents {
- let progs = try row.map {
- try _compileRegex($0).engine.program
- }
- let ref = progs.first!
- for prog in progs.dropFirst() {
- XCTAssert(ref.instructions.elementsEqual(
- prog.instructions))
-
- }
+ try testCompilationEquivalence(row)
+ }
+ }
+
+ func testCompileGroups() throws {
+ let equivalents: Array<[String]> = [
+ ["(?= assert)",
+ "(*pla: assert)",
+ "(*positive_lookahead: assert)"],
+ ["(?! assert)",
+ "(*nla: assert)",
+ "(*negative_lookahead: assert)"]
+ ]
+
+ for row in equivalents {
+ try testCompilationEquivalence(row)
  }
  }
 }

Tests/RegexTests/MatchTests.swift

@@ -589,59 +589,40 @@ extension RegexTests {
  input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")
  }
 
- func testMatchGroups() {
- // MARK: Groups
-
- // Named captures
- matchTest(
- #"a(?<label>b)c"#, input: "123abcxyz", match: "abc")
- matchTest(
- #"a(?'label'b)c"#, input: "123abcxyz", match: "abc")
- matchTest(
- #"a(?P<label>b)c"#, input: "123abcxyz", match: "abc")
-
- // Other groups
- matchTest(
- #"a(?:b)c"#, input: "123abcxyz", match: "abc")
- matchTest(
- "(?|(a)|(b)|(c))", input: "123abcxyz", match: "a")
-
- matchTest(
- #"(?:a|.b)c"#, input: "123abcacxyz", match: "abc")
- matchTest(
- #"(?>a|.b)c"#, input: "123abcacxyz", match: "ac", xfail: true)
- matchTest(
- "(*atomic:a|.b)c", input: "123abcacxyz", match: "ac", xfail: true)
- matchTest(
- #"(?:a+)[a-z]c"#, input: "123aacacxyz", match: "aac")
- matchTest(
- #"(?>a+)[a-z]c"#, input: "123aacacxyz", match: "ac", xfail: true)
-
+ func testAssertions() {
  matchTest(
  #"\d+(?= dollars)"#,
- input: "Price: 100 dollars", match: "100", xfail: true)
+ input: "Price: 100 dollars", match: "100")
+ matchTest(
+ #"\d+(?= pesos)"#,
+ input: "Price: 100 dollars", match: nil)
  matchTest(
  #"(?=\d+ dollars)\d+"#,
- input: "Price: 100 dollars", match: "100", xfail: true)
+ input: "Price: 100 dollars", match: "100",
+ xfail: true) // TODO
+
  matchTest(
  #"\d+(*pla: dollars)"#,
- input: "Price: 100 dollars", match: "100", xfail: true)
+ input: "Price: 100 dollars", match: "100")
  matchTest(
  #"\d+(*positive_lookahead: dollars)"#,
- input: "Price: 100 dollars", match: "100", xfail: true)
+ input: "Price: 100 dollars", match: "100")
 
  matchTest(
  #"\d+(?! dollars)"#,
- input: "Price: 100 pesos", match: "100", xfail: true)
+ input: "Price: 100 pesos", match: "100")
+ matchTest(
+ #"\d+(?! dollars)"#,
+ input: "Price: 100 dollars", match: "10")
  matchTest(
  #"(?!\d+ dollars)\d+"#,
- input: "Price: 100 pesos", match: "100", xfail: true)
+ input: "Price: 100 pesos", match: "100")
  matchTest(
  #"\d+(*nla: dollars)"#,
- input: "Price: 100 pesos", match: "100", xfail: true)
+ input: "Price: 100 pesos", match: "100")
  matchTest(
  #"\d+(*negative_lookahead: dollars)"#,
- input: "Price: 100 pesos", match: "100", xfail: true)
+ input: "Price: 100 pesos", match: "100")
 
  matchTest(
  #"(?<=USD)\d+"#, input: "Price: USD100", match: "100", xfail: true)
@@ -664,6 +645,36 @@ extension RegexTests {
  // engines generally enforce that lookbehinds are fixed width
  matchTest(
  #"\d{3}(?<!USD\d{3})"#, input: "Price: JYP100", match: "100", xfail: true)
+ }
+
+ func testMatchGroups() {
+ // MARK: Groups
+
+ // Named captures
+ matchTest(
+ #"a(?<label>b)c"#, input: "123abcxyz", match: "abc")
+ matchTest(
+ #"a(?'label'b)c"#, input: "123abcxyz", match: "abc")
+ matchTest(
+ #"a(?P<label>b)c"#, input: "123abcxyz", match: "abc")
+
+ // Other groups
+ matchTest(
+ #"a(?:b)c"#, input: "123abcxyz", match: "abc")
+ matchTest(
+ "(?|(a)|(b)|(c))", input: "123abcxyz", match: "a")
+
+ matchTest(
+ #"(?:a|.b)c"#, input: "123abcacxyz", match: "abc")
+ matchTest(
+ #"(?>a|.b)c"#, input: "123abcacxyz", match: "ac", xfail: true)
+ matchTest(
+ "(*atomic:a|.b)c", input: "123abcacxyz", match: "ac", xfail: true)
+ matchTest(
+ #"(?:a+)[a-z]c"#, input: "123aacacxyz", match: "aac")
+ matchTest(
+ #"(?>a+)[a-z]c"#, input: "123aacacxyz", match: "ac", xfail: true)
+
 
  // TODO: Test example where non-atomic is significant
  matchTest(