Nim/lib/impure/re.nim

#
#
#            Nim's Runtime Library
#        (c) Copyright 2012 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

when defined(js):
  {.error: "This library needs to be compiled with a c-like backend, and depends on PCRE2; See jsre for JS backend.".}

## .. warning:: This module is deprecated.
##   Use [Regex](https://github.com/nitely/nim-regex).
##   This compatibility module uses PCRE2.
##
## Regular expression support for Nim.
##
## This module is implemented by providing a wrapper around the
## `PCRE2 (Perl-Compatible Regular Expressions) <https://www.pcre.org>`_
## C library. This means that your application will depend on the PCRE2
## library's licence when using this module, which should not be a problem
## though.
##
## .. note:: There are also alternative nimble packages such as [tinyre](https://github.com/khchen/tinyre)
##   and [regex](https://github.com/nitely/nim-regex).
##
## PCRE2 is distributed under a BSD-style licence.


runnableExamples:
  ## Unless specified otherwise, `start` parameter in each proc indicates
  ## where the scan starts, but outputs are relative to the start of the input
  ## string, not to `start`:
  doAssert find("uxabc", re"(?<=x|y)ab", start = 1) == 2 # lookbehind assertion
  doAssert find("uxabc", re"ab", start = 3) == -1 # we're past `start` => not found
  doAssert not match("xabc", re"^abc$", start = 1)
    # can't match start of string since we're starting at 1

import
  std/[pcre2, strutils]

when defined(nimPreviewSlimSystem):
  import std/syncio

const
  MaxSubpatterns* = 20
    ## defines the maximum number of subpatterns that can be captured.
    ## This limit still exists for `replacef` and `parallelReplace`.

type
  RegexFlag* = enum     ## options for regular expressions
    reIgnoreCase = 0,   ## do caseless matching
    reMultiLine = 1,    ## `^` and `$` match newlines within data
    reDotAll = 2,       ## `.` matches anything including NL
    reExtended = 3,     ## ignore whitespace and `#` comments
    reStudy = 4         ## study the expression (may be omitted if the
                        ## expression will be used only once)

  RegexDesc = object
    h: ptr pcre2.Pcre

  Regex* = ref RegexDesc ## a compiled regular expression

  RegexError* = object of ValueError
    ## is raised if the pattern is no valid regular expression.

when defined(gcDestructors):
  when defined(nimAllowNonVarDestructor):
    proc `=destroy`(x: RegexDesc) =
      pcre2.code_free(x.h)
  else:
    proc `=destroy`(x: var RegexDesc) =
      pcre2.code_free(x.h)

proc raiseInvalidRegex(msg: string) {.noinline, noreturn.} =
  var e: ref RegexError
  new(e)
  e.msg = msg
  raise e

proc pcre2ErrorMessage(errorCode: cint): string =
  var buffer: array[256, uint8]
  let length = pcre2.get_error_message(errorCode, addr buffer[0], buffer.len.csize_t)
  if length >= 0:
    result = newString(length)
    if length > 0:
      copyMem(addr result[0], addr buffer[0], length)
  else:
    result = $errorCode

proc rawCompile(pattern: string, options: uint32): ptr pcre2.Pcre =
  var
    errorCode: cint = 0
    offset: csize_t = 0
  result = pcre2.compile(cast[ptr uint8](pattern.cstring), pattern.len.csize_t,
                         options, addr errorCode, addr offset, nil)
  if result == nil:
    raiseInvalidRegex(pcre2ErrorMessage(errorCode) & "\n" & pattern & "\n" &
                      spaces(offset.int) & "^\n")

proc finalizeRegEx(x: Regex) =
  pcre2.code_free(x.h)

func toPcre2Options(flags: set[RegexFlag]): uint32 =
  if reIgnoreCase in flags:
    result = result or pcre2.CASELESS.uint32
  if reMultiLine in flags:
    result = result or pcre2.MULTILINE.uint32
  if reDotAll in flags:
    result = result or pcre2.DOTALL.uint32
  if reExtended in flags:
    result = result or pcre2.EXTENDED.uint32

proc jitCompile(pattern: ptr pcre2.Pcre) =
  var hasJit: cint = 0
  if pcre2.config(pcre2.CONFIG_JIT, addr hasJit) == 0 and hasJit == 1:
    discard pcre2.jit_compile(pattern, pcre2.JIT_COMPLETE.uint32)

proc re*(s: string, flags = {reStudy}): Regex =
  ## Constructor of regular expressions.
  ##
  ## Note that Nim's
  ## extended raw string literals support the syntax `re"[abc]"` as
  ## a short form for `re(r"[abc]")`. Also note that since this
  ## compiles the regular expression, which is expensive, you should
  ## avoid putting it directly in the arguments of the functions like
  ## the examples show below if you plan to use it a lot of times, as
  ## this will hurt performance immensely. (e.g. outside a loop, ...)
  when defined(gcDestructors):
    result = Regex()
  else:
    new(result, finalizeRegEx)
  result.h = rawCompile(s, toPcre2Options(flags))
  if reStudy in flags:
    jitCompile(result.h)

proc rex*(s: string, flags = {reStudy, reExtended}): Regex =
  ## Constructor for extended regular expressions.
  ##
  ## The extended means that comments starting with `#` and
  ## whitespace are ignored.
  result = re(s, flags)

proc bufSubstr(b: cstring, sPos, ePos: int): string {.inline.} =
  ## Return a Nim string built from a slice of a cstring buffer.
  ## Don't assume cstring is '\0' terminated
  let sz = ePos - sPos
  result = newString(sz+1)
  copyMem(addr(result[0]), unsafeAddr(b[sPos]), sz)
  result.setLen(sz)

proc newMatchData(slots: int): ptr pcre2.MatchData =
  result = pcre2.match_data_create(max(slots, 1).uint32, nil)
  if result == nil:
    raiseInvalidRegex("could not allocate PCRE2 match data")

template ovector(matchData: ptr pcre2.MatchData): ptr UncheckedArray[csize_t] =
  cast[ptr UncheckedArray[csize_t]](pcre2.get_ovector_pointer(matchData))

proc rawMatch(buf: cstring, pattern: Regex, start, bufSize: int,
              options: uint32, matchData: ptr pcre2.MatchData): cint =
  if start < 0 or bufSize < 0:
    return pcre2.ERROR_BADOFFSET
  pcre2.match(pattern.h, cast[ptr uint8](buf), bufSize.csize_t,
              start.csize_t, options, matchData, nil)

proc copyStringMatches(buf: cstring, rawMatches: ptr UncheckedArray[csize_t],
                       captureCount: int, matches: var openArray[string]) =
  let upper = min(captureCount - 1, matches.len)
  if upper > 0:
    for i in 1 .. upper:
      let matchStart = rawMatches[i * 2]
      let matchEnd = rawMatches[i * 2 + 1]
      if matchStart != pcre2.UNSET:
        matches[i-1] = bufSubstr(buf, int(matchStart), int(matchEnd))
      else:
        matches[i-1] = ""

proc copyBoundsMatches(rawMatches: ptr UncheckedArray[csize_t],
                       captureCount: int,
                       matches: var openArray[tuple[first, last: int]]) =
  let upper = min(captureCount - 1, matches.len)
  if upper > 0:
    for i in 1 .. upper:
      let matchStart = rawMatches[i * 2]
      let matchEnd = rawMatches[i * 2 + 1]
      if matchStart != pcre2.UNSET:
        matches[i-1] = (int(matchStart), int(matchEnd) - 1)
      else:
        matches[i-1] = (-1, 0)

proc matchOrFind(buf: cstring, pattern: Regex, matches: var openArray[string],
                 start, bufSize: int, options: uint32): int =
  let matchData = newMatchData(matches.len + 1)
  defer: pcre2.match_data_free(matchData)
  let res = rawMatch(buf, pattern, start, bufSize, options, matchData)
  let rawMatches = ovector(matchData)
  if res < 0: return int(res)
  copyStringMatches(buf, rawMatches, int(res), matches)
  return int(rawMatches[1]) - int(rawMatches[0])

const MaxReBufSize* = high(int)
  ## Maximum PCRE2 buffer start/size accepted by this Nim API.

proc findBounds*(buf: cstring, pattern: Regex, matches: var openArray[string],
                 start = 0, bufSize: int): tuple[first, last: int] =
  ## returns the starting position and end position of `pattern` in `buf`
  ## (where `buf` has length `bufSize` and is not necessarily `'\0'` terminated),
  ## and the captured
  ## substrings in the array `matches`. If it does not match, nothing
  ## is written into `matches` and `(-1,0)` is returned.
  ##
  ## Note: The memory for `matches` needs to be allocated before this function is
  ## called, otherwise it will just remain empty.
  let matchData = newMatchData(matches.len + 1)
  defer: pcre2.match_data_free(matchData)
  let res = rawMatch(buf, pattern, start, bufSize, 0'u32, matchData)
  let rawMatches = ovector(matchData)
  if res < 0: return (-1, 0)
  copyStringMatches(buf, rawMatches, int(res), matches)
  return (rawMatches[0].int, rawMatches[1].int - 1)

proc findBounds*(s: string, pattern: Regex, matches: var openArray[string],
                 start = 0): tuple[first, last: int] {.inline.} =
  ## returns the starting position and end position of `pattern` in `s`
  ## and the captured substrings in the array `matches`.
  ## If it does not match, nothing
  ## is written into `matches` and `(-1,0)` is returned.
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  runnableExamples:
    var matches = newSeq[string](1)
    let (first, last) = findBounds("Hello World", re"(W\w+)", matches)
    doAssert first == 6
    doAssert last == 10
    doAssert matches[0] == "World"
  result = findBounds(cstring(s), pattern, matches,
      min(start, MaxReBufSize), min(s.len, MaxReBufSize))

proc findBounds*(buf: cstring, pattern: Regex,
                 matches: var openArray[tuple[first, last: int]],
                 start = 0, bufSize: int): tuple[first, last: int] =
  ## returns the starting position and end position of `pattern` in `buf`
  ## (where `buf` has length `bufSize` and is not necessarily `'\0'` terminated),
  ## and the captured substrings in the array `matches`.
  ## If it does not match, nothing is written into `matches` and
  ## `(-1,0)` is returned.
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  let matchData = newMatchData(matches.len + 1)
  defer: pcre2.match_data_free(matchData)
  let res = rawMatch(buf, pattern, start, bufSize, 0'u32, matchData)
  let rawMatches = ovector(matchData)
  if res < 0: return (-1, 0)
  copyBoundsMatches(rawMatches, int(res), matches)
  return (rawMatches[0].int, rawMatches[1].int - 1)

proc findBounds*(s: string, pattern: Regex,
                 matches: var openArray[tuple[first, last: int]],
                 start = 0): tuple[first, last: int] {.inline.} =
  ## returns the starting position and end position of `pattern` in `s`
  ## and the captured substrings in the array `matches`.
  ## If it does not match, nothing is written into `matches` and
  ## `(-1,0)` is returned.
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  runnableExamples:
    var matches = newSeq[tuple[first, last: int]](1)
    let (first, last) = findBounds("Hello World", re"(\w+)", matches)
    doAssert first == 0
    doAssert last == 4
    doAssert matches[0] == (0, 4)
  result = findBounds(cstring(s), pattern, matches,
      min(start, MaxReBufSize), min(s.len, MaxReBufSize))

proc findBoundsImpl(buf: cstring, pattern: Regex,
                    start = 0, bufSize = 0,
                    options = 0'u32): tuple[first, last: int] =
  let matchData = newMatchData(1)
  defer: pcre2.match_data_free(matchData)
  let res = rawMatch(buf, pattern, start, bufSize, options, matchData)
  let rawMatches = ovector(matchData)
  if res < 0:
    result = (-1, 0)
  else:
    result = (int(rawMatches[0]), int(rawMatches[1]) - 1)

proc findBounds*(buf: cstring, pattern: Regex,
                 start = 0, bufSize: int): tuple[first, last: int] =
  ## returns the `first` and `last` position of `pattern` in `buf`,
  ## where `buf` has length `bufSize` (not necessarily `'\0'` terminated).
  ## If it does not match, `(-1,0)` is returned.
  let matchData = newMatchData(1)
  defer: pcre2.match_data_free(matchData)
  let res = rawMatch(buf, pattern, start, bufSize, 0'u32, matchData)
  let rawMatches = ovector(matchData)
  if res < 0: return (int(res), 0)
  return (int(rawMatches[0]), int(rawMatches[1]) - 1)

proc findBounds*(s: string, pattern: Regex,
                 start = 0): tuple[first, last: int] {.inline.} =
  ## returns the `first` and `last` position of `pattern` in `s`.
  ## If it does not match, `(-1,0)` is returned.
  ##
  ## Note: there is a speed improvement if the matches do not need to be captured.
  runnableExamples:
    assert findBounds("01234abc89", re"abc") == (5,7)
  result = findBounds(cstring(s), pattern,
      min(start, MaxReBufSize), min(s.len, MaxReBufSize))

proc matchOrFind(buf: cstring, pattern: Regex, start, bufSize: int,
                 options: uint32): int =
  let matchData = newMatchData(1)
  defer: pcre2.match_data_free(matchData)
  let res = rawMatch(buf, pattern, start, bufSize, options, matchData)
  if res >= 0:
    let rawMatches = ovector(matchData)
    result = int(rawMatches[1]) - int(rawMatches[0])
  else:
    result = int(res)

proc matchLen*(s: string, pattern: Regex, matches: var openArray[string],
              start = 0): int {.inline.} =
  ## the same as `match`, but it returns the length of the match,
  ## if there is no match, `-1` is returned. Note that a match length
  ## of zero can happen.
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  result = matchOrFind(cstring(s), pattern, matches, start, s.len, cast[uint32](pcre2.ANCHORED))

proc matchLen*(buf: cstring, pattern: Regex, matches: var openArray[string],
              start = 0, bufSize: int): int {.inline.} =
  ## the same as `match`, but it returns the length of the match,
  ## if there is no match, `-1` is returned. Note that a match length
  ## of zero can happen.
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  return matchOrFind(buf, pattern, matches, start, bufSize, cast[uint32](pcre2.ANCHORED))

proc matchLen*(s: string, pattern: Regex, start = 0): int {.inline.} =
  ## the same as `match`, but it returns the length of the match,
  ## if there is no match, `-1` is returned. Note that a match length
  ## of zero can happen.
  ##
  runnableExamples:
    doAssert matchLen("abcdefg", re"cde", 2) == 3
    doAssert matchLen("abcdefg", re"abcde") == 5
    doAssert matchLen("abcdefg", re"cde") == -1
  result = matchOrFind(cstring(s), pattern, start, s.len, cast[uint32](pcre2.ANCHORED))

proc matchLen*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int {.inline.} =
  ## the same as `match`, but it returns the length of the match,
  ## if there is no match, `-1` is returned. Note that a match length
  ## of zero can happen.
  result = matchOrFind(buf, pattern, start, bufSize, cast[uint32](pcre2.ANCHORED))

proc match*(s: string, pattern: Regex, start = 0): bool {.inline.} =
  ## returns `true` if `s[start..]` matches the `pattern`.
  result = matchLen(cstring(s), pattern, start, s.len) != -1

proc match*(s: string, pattern: Regex, matches: var openArray[string],
           start = 0): bool {.inline.} =
  ## returns `true` if `s[start..]` matches the `pattern` and
  ## the captured substrings in the array `matches`. If it does not
  ## match, nothing is written into `matches` and `false` is
  ## returned.
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  runnableExamples:
    import std/sequtils
    var matches: array[2, string]
    if match("abcdefg", re"c(d)ef(g)", matches, 2):
      doAssert toSeq(matches) == @["d", "g"]
  result = matchLen(cstring(s), pattern, matches, start, s.len) != -1

proc match*(buf: cstring, pattern: Regex, matches: var openArray[string],
           start = 0, bufSize: int): bool {.inline.} =
  ## returns `true` if `buf[start..<bufSize]` matches the `pattern` and
  ## the captured substrings in the array `matches`. If it does not
  ## match, nothing is written into `matches` and `false` is
  ## returned.
  ## `buf` has length `bufSize` (not necessarily `'\0'` terminated).
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  result = matchLen(buf, pattern, matches, start, bufSize) != -1

proc find*(buf: cstring, pattern: Regex, matches: var openArray[string],
           start = 0, bufSize: int): int =
  ## returns the starting position of `pattern` in `buf` and the captured
  ## substrings in the array `matches`. If it does not match, nothing
  ## is written into `matches` and `-1` is returned.
  ## `buf` has length `bufSize` (not necessarily `'\0'` terminated).
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  let matchData = newMatchData(matches.len + 1)
  defer: pcre2.match_data_free(matchData)
  let res = rawMatch(buf, pattern, start, bufSize, 0'u32, matchData)
  let rawMatches = ovector(matchData)
  if res < 0: return int(res)
  copyStringMatches(buf, rawMatches, int(res), matches)
  return int(rawMatches[0])

proc find*(s: string, pattern: Regex, matches: var openArray[string],
           start = 0): int {.inline.} =
  ## returns the starting position of `pattern` in `s` and the captured
  ## substrings in the array `matches`. If it does not match, nothing
  ## is written into `matches` and `-1` is returned.
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  result = find(cstring(s), pattern, matches, start, s.len)

proc find*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int =
  ## returns the starting position of `pattern` in `buf`,
  ## where `buf` has length `bufSize` (not necessarily `'\0'` terminated).
  ## If it does not match, `-1` is returned.
  let matchData = newMatchData(1)
  defer: pcre2.match_data_free(matchData)
  let res = rawMatch(buf, pattern, start, bufSize, 0'u32, matchData)
  let rawMatches = ovector(matchData)
  if res < 0: return int(res)
  return int(rawMatches[0])

proc find*(s: string, pattern: Regex, start = 0): int {.inline.} =
  ## returns the starting position of `pattern` in `s`. If it does not
  ## match, `-1` is returned. We start the scan at `start`.
  runnableExamples:
    doAssert find("abcdefg", re"cde") == 2
    doAssert find("abcdefg", re"abc") == 0
    doAssert find("abcdefg", re"zz") == -1 # not found
    doAssert find("abcdefg", re"cde", start = 2) == 2 # still 2
    doAssert find("abcdefg", re"cde", start = 3) == -1 # we're past the start position
    doAssert find("xabc", re"(?<=x|y)abc", start = 1) == 1
      # lookbehind assertion `(?<=x|y)` can look behind `start`
  result = find(cstring(s), pattern, start, s.len)

iterator findAll*(s: string, pattern: Regex, start = 0): string =
  ## Yields all matching *substrings* of `s` that match `pattern`.
  ##
  ## Note that since this is an iterator you should not modify the string you
  ## are iterating over: bad things could happen.
  var i = start
  let matchData = newMatchData(1)
  defer: pcre2.match_data_free(matchData)
  while true:
    let res = rawMatch(s.cstring, pattern, i, len(s), 0'u32, matchData)
    if res < 0: break
    let rawMatches = ovector(matchData)
    let matchStart = rawMatches[0]
    let matchEnd = rawMatches[1]
    if matchStart == matchEnd and matchStart.int == i: break
    yield substr(s, int(matchStart), int(matchEnd) - 1)
    i = matchEnd.int

iterator findAll*(buf: cstring, pattern: Regex, start = 0, bufSize: int): string =
  ## Yields all matching `substrings` of `s` that match `pattern`.
  ##
  ## Note that since this is an iterator you should not modify the string you
  ## are iterating over: bad things could happen.
  var i = start
  let matchData = newMatchData(1)
  defer: pcre2.match_data_free(matchData)
  while true:
    let res = rawMatch(buf, pattern, i, bufSize, 0'u32, matchData)
    if res < 0: break
    let rawMatches = ovector(matchData)
    let matchStart = rawMatches[0]
    let matchEnd = rawMatches[1]
    if matchStart == matchEnd and matchStart.int == i: break
    var str = newString(int(matchEnd - matchStart))
    copyMem(str[0].addr, unsafeAddr(buf[int(matchStart)]), int(matchEnd - matchStart))
    yield str
    i = matchEnd.int

proc findAll*(s: string, pattern: Regex, start = 0): seq[string] {.inline.} =
  ## returns all matching `substrings` of `s` that match `pattern`.
  ## If it does not match, `@[]` is returned.
  result = @[]
  for x in findAll(s, pattern, start): result.add x

template `=~` *(s: string, pattern: Regex): untyped =
  ## This calls `match` with an implicit declared `matches` array that
  ## can be used in the scope of the `=~` call:
  runnableExamples:
    proc parse(line: string): string =
      if line =~ re"\s*(\w+)\s*\=\s*(\w+)": # matches a key=value pair:
        result = $(matches[0], matches[1])
      elif line =~ re"\s*(\#.*)": # matches a comment
        # note that the implicit `matches` array is different from 1st branch
        result = $(matches[0],)
      else: raiseAssert "unreachable"
      doAssert not declared(matches)
    doAssert parse("NAME = LENA") == """("NAME", "LENA")"""
    doAssert parse("   # comment ... ") == """("# comment ... ",)"""
  bind MaxSubpatterns
  when not declaredInScope(matches):
    var matches {.inject.}: array[MaxSubpatterns, string] = default(array[MaxSubpatterns, string])
  match(s, pattern, matches)

# ------------------------- more string handling ------------------------------

proc contains*(s: string, pattern: Regex, start = 0): bool {.inline.} =
  ## same as `find(s, pattern, start) >= 0`
  return find(s, pattern, start) >= 0

proc contains*(s: string, pattern: Regex, matches: var openArray[string],
              start = 0): bool {.inline.} =
  ## same as `find(s, pattern, matches, start) >= 0`
  ##
  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
  return find(s, pattern, matches, start) >= 0

proc startsWith*(s: string, prefix: Regex): bool {.inline.} =
  ## returns true if `s` starts with the pattern `prefix`
  result = matchLen(s, prefix) >= 0

proc endsWith*(s: string, suffix: Regex): bool {.inline.} =
  ## returns true if `s` ends with the pattern `suffix`
  for i in 0 .. s.len-1:
    if matchLen(s, suffix, i) == s.len - i: return true

proc replace*(s: string, sub: Regex, by = ""): string =
  ## Replaces `sub` in `s` by the string `by`. Captures cannot be
  ## accessed in `by`.
  runnableExamples:
    doAssert "var1=key; var2=key2".replace(re"(\w+)=(\w+)") == "; "
    doAssert "var1=key; var2=key2".replace(re"(\w+)=(\w+)", "?") == "?; ?"
  result = ""
  var prev = 0
  var flags = 0'u32
  while prev < s.len:
    var match = findBoundsImpl(s.cstring, sub, prev, s.len, flags)
    flags = 0
    if match.first < 0: break
    add(result, substr(s, prev, match.first-1))
    add(result, by)
    if match.first > match.last:
      # 0-len match
      flags = pcre2.NOTEMPTY_ATSTART.uint32
    prev = match.last + 1
  add(result, substr(s, prev))

proc replacef*(s: string, sub: Regex, by: string): string =
  ## Replaces `sub` in `s` by the string `by`. Captures can be accessed in `by`
  ## with the notation `$i` and `$#` (see strutils.\`%\`).
  runnableExamples:
    doAssert "var1=key; var2=key2".replacef(re"(\w+)=(\w+)", "$1<-$2$2") ==
      "var1<-keykey; var2<-key2key2"
  result = ""
  var caps: array[MaxSubpatterns, string]
  var prev = 0
  while prev < s.len:
    var match = findBounds(s, sub, caps, prev)
    if match.first < 0: break
    add(result, substr(s, prev, match.first-1))
    addf(result, by, caps)
    if match.last + 1 == prev: break
    prev = match.last + 1
  add(result, substr(s, prev))

proc multiReplace*(s: string, subs: openArray[
                   tuple[pattern: Regex, repl: string]]): string =
  ## Returns a modified copy of `s` with the substitutions in `subs`
  ## applied in parallel.
  result = ""
  var i = 0
  var caps: array[MaxSubpatterns, string]
  while i < s.len:
    block searchSubs:
      for j in 0..high(subs):
        var x = matchLen(s, subs[j][0], caps, i)
        if x > 0:
          addf(result, subs[j][1], caps)
          inc(i, x)
          break searchSubs
      add(result, s[i])
      inc(i)
  # copy the rest:
  add(result, substr(s, i))

proc transformFile*(infile, outfile: string,
                    subs: openArray[tuple[pattern: Regex, repl: string]]) =
  ## reads in the file `infile`, performs a parallel replacement (calls
  ## `parallelReplace`) and writes back to `outfile`. Raises `IOError` if an
  ## error occurs. This is supposed to be used for quick scripting.
  var x = readFile(infile)
  writeFile(outfile, x.multiReplace(subs))

iterator split*(s: string, sep: Regex; maxsplit = -1): string =
  ## Splits the string `s` into substrings.
  ##
  ## Substrings are separated by the regular expression `sep`
  ## (and the portion matched by `sep` is not returned).
  runnableExamples:
    import std/sequtils
    doAssert toSeq(split("00232this02939is39an22example111", re"\d+")) ==
      @["", "this", "is", "an", "example", ""]
  var last = 0
  var splits = maxsplit
  var x = -1
  if len(s) == 0:
    last = 1
  if matchLen(s, sep, 0) == 0:
    x = 0
  while last <= len(s):
    var first = last
    var sepLen = 1
    if x == 0:
      inc(last)
    while last < len(s):
      x = matchLen(s, sep, last)
      if x >= 0:
        sepLen = x
        break
      inc(last)
    if splits == 0: last = len(s)
    yield substr(s, first, last-1)
    if splits == 0: break
    dec(splits)
    inc(last, sepLen)

proc split*(s: string, sep: Regex, maxsplit = -1): seq[string] {.inline.} =
  ## Splits the string `s` into a seq of substrings.
  ##
  ## The portion matched by `sep` is not returned.
  result = @[]
  for x in split(s, sep, maxsplit): result.add x

proc escapeRe*(s: string): string =
  ## escapes `s` so that it is matched verbatim when used as a regular
  ## expression.
  result = ""
  for c in items(s):
    case c
    of 'a'..'z', 'A'..'Z', '0'..'9', '_':
      result.add(c)
    else:
      result.add("\\x")
      result.add(toHex(ord(c), 2))