use single backtick (#17115)
This commit is contained in:
flywind
GitHub
parent
1efaef52a2
commit
a1a18cfe66
10 changed files with 174 additions and 174 deletions
|
|
@ -20,7 +20,7 @@ when defined(js):
|
|||
## search the internet for a wide variety of third-party documentation and
|
||||
## tools.
|
||||
##
|
||||
## **Note**: If you love ``sequtils.toSeq`` we have bad news for you. This
|
||||
## **Note**: If you love `sequtils.toSeq` we have bad news for you. This
|
||||
## library doesn't work with it due to documented compiler limitations. As
|
||||
## a workaround, use this:
|
||||
##
|
||||
|
|
@ -76,19 +76,19 @@ export options
|
|||
type
|
||||
Regex* = ref object
|
||||
## Represents the pattern that things are matched against, constructed with
|
||||
## ``re(string)``. Examples: ``re"foo"``, ``re(r"(*ANYCRLF)(?x)foo #
|
||||
## comment".``
|
||||
## `re(string)`. Examples: `re"foo"`, `re(r"(*ANYCRLF)(?x)foo #
|
||||
## comment".`
|
||||
##
|
||||
## ``pattern: string``
|
||||
## `pattern: string`
|
||||
## the string that was used to create the pattern. For details on how
|
||||
## to write a pattern, please see `the official PCRE pattern
|
||||
## documentation.
|
||||
## <https://www.pcre.org/original/doc/html/pcrepattern.html>`_
|
||||
##
|
||||
## ``captureCount: int``
|
||||
## `captureCount: int`
|
||||
## the number of captures that the pattern has.
|
||||
##
|
||||
## ``captureNameId: Table[string, int]``
|
||||
## `captureNameId: Table[string, int]`
|
||||
## a table from the capture names to their numeric id.
|
||||
##
|
||||
##
|
||||
|
|
@ -98,30 +98,30 @@ type
|
|||
## The following options may appear anywhere in the pattern, and they affect
|
||||
## the rest of it.
|
||||
##
|
||||
## - ``(?i)`` - case insensitive
|
||||
## - ``(?m)`` - multi-line: ``^`` and ``$`` match the beginning and end of
|
||||
## - `(?i)` - case insensitive
|
||||
## - `(?m)` - multi-line: `^` and `$` match the beginning and end of
|
||||
## lines, not of the subject string
|
||||
## - ``(?s)`` - ``.`` also matches newline (*dotall*)
|
||||
## - ``(?U)`` - expressions are not greedy by default. ``?`` can be added
|
||||
## - `(?s)` - `.` also matches newline (*dotall*)
|
||||
## - `(?U)` - expressions are not greedy by default. `?` can be added
|
||||
## to a qualifier to make it greedy
|
||||
## - ``(?x)`` - whitespace and comments (``#``) are ignored (*extended*)
|
||||
## - ``(?X)`` - character escapes without special meaning (``\w`` vs.
|
||||
## ``\a``) are errors (*extra*)
|
||||
## - `(?x)` - whitespace and comments (`#`) are ignored (*extended*)
|
||||
## - `(?X)` - character escapes without special meaning (`\w` vs.
|
||||
## `\a`) are errors (*extra*)
|
||||
##
|
||||
## One or a combination of these options may appear only at the beginning
|
||||
## of the pattern:
|
||||
##
|
||||
## - ``(*UTF8)`` - treat both the pattern and subject as UTF-8
|
||||
## - ``(*UCP)`` - Unicode character properties; ``\w`` matches ``я``
|
||||
## - ``(*U)`` - a combination of the two options above
|
||||
## - ``(*FIRSTLINE*)`` - fails if there is not a match on the first line
|
||||
## - ``(*NO_AUTO_CAPTURE)`` - turn off auto-capture for groups;
|
||||
## ``(?<name>...)`` can be used to capture
|
||||
## - ``(*CR)`` - newlines are separated by ``\r``
|
||||
## - ``(*LF)`` - newlines are separated by ``\n`` (UNIX default)
|
||||
## - ``(*CRLF)`` - newlines are separated by ``\r\n`` (Windows default)
|
||||
## - ``(*ANYCRLF)`` - newlines are separated by any of the above
|
||||
## - ``(*ANY)`` - newlines are separated by any of the above and Unicode
|
||||
## - `(*UTF8)` - treat both the pattern and subject as UTF-8
|
||||
## - `(*UCP)` - Unicode character properties; `\w` matches `я`
|
||||
## - `(*U)` - a combination of the two options above
|
||||
## - `(*FIRSTLINE*)` - fails if there is not a match on the first line
|
||||
## - `(*NO_AUTO_CAPTURE)` - turn off auto-capture for groups;
|
||||
## `(?<name>...)` can be used to capture
|
||||
## - `(*CR)` - newlines are separated by `\r`
|
||||
## - `(*LF)` - newlines are separated by `\n` (UNIX default)
|
||||
## - `(*CRLF)` - newlines are separated by `\r\n` (Windows default)
|
||||
## - `(*ANYCRLF)` - newlines are separated by any of the above
|
||||
## - `(*ANY)` - newlines are separated by any of the above and Unicode
|
||||
## newlines:
|
||||
##
|
||||
## single characters VT (vertical tab, U+000B), FF (form feed, U+000C),
|
||||
|
|
@ -130,8 +130,8 @@ type
|
|||
## are recognized only in UTF-8 mode.
|
||||
## — man pcre
|
||||
##
|
||||
## - ``(*JAVASCRIPT_COMPAT)`` - JavaScript compatibility
|
||||
## - ``(*NO_STUDY)`` - turn off studying; study is enabled by default
|
||||
## - `(*JAVASCRIPT_COMPAT)` - JavaScript compatibility
|
||||
## - `(*NO_STUDY)` - turn off studying; study is enabled by default
|
||||
##
|
||||
## For more details on the leading option groups, see the `Option
|
||||
## Setting <http://man7.org/linux/man-pages/man3/pcresyntax.3.html#OPTION_SETTING>`_
|
||||
|
|
@ -141,9 +141,9 @@ type
|
|||
## manual <http://man7.org/linux/man-pages/man3/pcresyntax.3.html>`_.
|
||||
##
|
||||
## Some of these options are not part of PCRE and are converted by nre
|
||||
## into PCRE flags. These include ``NEVER_UTF``, ``ANCHORED``,
|
||||
## ``DOLLAR_ENDONLY``, ``FIRSTLINE``, ``NO_AUTO_CAPTURE``,
|
||||
## ``JAVASCRIPT_COMPAT``, ``U``, ``NO_STUDY``. In other PCRE wrappers, you
|
||||
## into PCRE flags. These include `NEVER_UTF`, `ANCHORED`,
|
||||
## `DOLLAR_ENDONLY`, `FIRSTLINE`, `NO_AUTO_CAPTURE`,
|
||||
## `JAVASCRIPT_COMPAT`, `U`, `NO_STUDY`. In other PCRE wrappers, you
|
||||
## will need to pass these as separate flags to PCRE.
|
||||
pattern*: string ## not nil
|
||||
pcreObj: ptr pcre.Pcre ## not nil
|
||||
|
|
@ -155,46 +155,46 @@ type
|
|||
## Usually seen as Option[RegexMatch], it represents the result of an
|
||||
## execution. On failure, it is none, on success, it is some.
|
||||
##
|
||||
## ``pattern: Regex``
|
||||
## `pattern: Regex`
|
||||
## the pattern that is being matched
|
||||
##
|
||||
## ``str: string``
|
||||
## `str: string`
|
||||
## the string that was matched against
|
||||
##
|
||||
## ``captures[]: string``
|
||||
## `captures[]: string`
|
||||
## the string value of whatever was captured at that id. If the value
|
||||
## is invalid, then behavior is undefined. If the id is ``-1``, then
|
||||
## is invalid, then behavior is undefined. If the id is `-1`, then
|
||||
## the whole match is returned. If the given capture was not matched,
|
||||
## ``nil`` is returned.
|
||||
## `nil` is returned.
|
||||
##
|
||||
## - ``"abc".match(re"(\w)").get.captures[0] == "a"``
|
||||
## - ``"abc".match(re"(?<letter>\w)").get.captures["letter"] == "a"``
|
||||
## - ``"abc".match(re"(\w)\w").get.captures[-1] == "ab"``
|
||||
## - `"abc".match(re"(\w)").get.captures[0] == "a"`
|
||||
## - `"abc".match(re"(?<letter>\w)").get.captures["letter"] == "a"`
|
||||
## - `"abc".match(re"(\w)\w").get.captures[-1] == "ab"`
|
||||
##
|
||||
## ``captureBounds[]: HSlice[int, int]``
|
||||
## `captureBounds[]: HSlice[int, int]`
|
||||
## gets the bounds of the given capture according to the same rules as
|
||||
## the above. If the capture is not filled, then ``None`` is returned.
|
||||
## the above. If the capture is not filled, then `None` is returned.
|
||||
## The bounds are both inclusive.
|
||||
##
|
||||
## - ``"abc".match(re"(\w)").get.captureBounds[0] == 0 .. 0``
|
||||
## - ``0 in "abc".match(re"(\w)").get.captureBounds == true``
|
||||
## - ``"abc".match(re"").get.captureBounds[-1] == 0 .. -1``
|
||||
## - ``"abc".match(re"abc").get.captureBounds[-1] == 0 .. 2``
|
||||
## - `"abc".match(re"(\w)").get.captureBounds[0] == 0 .. 0`
|
||||
## - `0 in "abc".match(re"(\w)").get.captureBounds == true`
|
||||
## - `"abc".match(re"").get.captureBounds[-1] == 0 .. -1`
|
||||
## - `"abc".match(re"abc").get.captureBounds[-1] == 0 .. 2`
|
||||
##
|
||||
## ``match: string``
|
||||
## `match: string`
|
||||
## the full text of the match.
|
||||
##
|
||||
## ``matchBounds: HSlice[int, int]``
|
||||
## the bounds of the match, as in ``captureBounds[]``
|
||||
## `matchBounds: HSlice[int, int]`
|
||||
## the bounds of the match, as in `captureBounds[]`
|
||||
##
|
||||
## ``(captureBounds|captures).toTable``
|
||||
## `(captureBounds|captures).toTable`
|
||||
## returns a table with each named capture as a key.
|
||||
##
|
||||
## ``(captureBounds|captures).toSeq``
|
||||
## `(captureBounds|captures).toSeq`
|
||||
## returns all the captures by their number.
|
||||
##
|
||||
## ``$: string``
|
||||
## same as ``match``
|
||||
## `$: string`
|
||||
## same as `match`
|
||||
pattern*: Regex ## The regex doing the matching.
|
||||
## Not nil.
|
||||
str*: string ## The string that was matched against.
|
||||
|
|
@ -549,14 +549,14 @@ proc match*(str: string, pattern: Regex, start = 0, endpos = int.high): Option[R
|
|||
|
||||
iterator findIter*(str: string, pattern: Regex, start = 0, endpos = int.high): RegexMatch =
|
||||
## Works the same as `find(...)<#find,string,Regex,int>`_, but finds every
|
||||
## non-overlapping match. ``"2222".find(re"22")`` is ``"22", "22"``, not
|
||||
## ``"22", "22", "22"``.
|
||||
## non-overlapping match. `"2222".find(re"22")` is `"22", "22"`, not
|
||||
## `"22", "22", "22"`.
|
||||
##
|
||||
## Arguments are the same as `find(...)<#find,string,Regex,int>`_
|
||||
##
|
||||
## Variants:
|
||||
##
|
||||
## - ``proc findAll(...)`` returns a ``seq[string]``
|
||||
## - `proc findAll(...)` returns a `seq[string]`
|
||||
# see pcredemo for explanation
|
||||
let matchesCrLf = pattern.matchesCrLf()
|
||||
let unicode = uint32(getinfo[culong](pattern, pcre.INFO_OPTIONS) and
|
||||
|
|
@ -601,12 +601,12 @@ proc find*(str: string, pattern: Regex, start = 0, endpos = int.high): Option[Re
|
|||
## Finds the given pattern in the string between the end and start
|
||||
## positions.
|
||||
##
|
||||
## ``start``
|
||||
## The start point at which to start matching. ``|abc`` is ``0``;
|
||||
## ``a|bc`` is ``1``
|
||||
## `start`
|
||||
## The start point at which to start matching. `|abc` is `0`;
|
||||
## `a|bc` is `1`
|
||||
##
|
||||
## ``endpos``
|
||||
## The maximum index for a match; ``int.high`` means the end of the
|
||||
## `endpos`
|
||||
## The maximum index for a match; `int.high` means the end of the
|
||||
## string, otherwise it’s an inclusive upper bound.
|
||||
return str.matchImpl(pattern, start, endpos, 0)
|
||||
|
||||
|
|
@ -618,7 +618,7 @@ proc findAll*(str: string, pattern: Regex, start = 0, endpos = int.high): seq[st
|
|||
proc contains*(str: string, pattern: Regex, start = 0, endpos = int.high): bool =
|
||||
## Determine if the string contains the given pattern between the end and
|
||||
## start positions:
|
||||
## This function is equivalent to ``isSome(str.find(pattern, start, endpos))``.
|
||||
## This function is equivalent to `isSome(str.find(pattern, start, endpos))`.
|
||||
##
|
||||
runnableExamples:
|
||||
doAssert "abc".contains(re"bc")
|
||||
|
|
@ -631,7 +631,7 @@ proc split*(str: string, pattern: Regex, maxSplit = -1, start = 0): seq[string]
|
|||
## Splits the string with the given regex. This works according to the
|
||||
## rules that Perl and Javascript use.
|
||||
##
|
||||
## ``start`` behaves the same as in `find(...)<#find,string,Regex,int>`_.
|
||||
## `start` behaves the same as in `find(...)<#find,string,Regex,int>`_.
|
||||
##
|
||||
runnableExamples:
|
||||
# - If the match is zero-width, then the string is still split:
|
||||
|
|
@ -641,8 +641,8 @@ proc split*(str: string, pattern: Regex, maxSplit = -1, start = 0): seq[string]
|
|||
# split:
|
||||
doAssert "12".split(re"(\d)") == @["", "1", "", "2", ""]
|
||||
|
||||
# - If ``maxsplit != -1``, then the string will only be split
|
||||
# ``maxsplit - 1`` times. This means that there will be ``maxsplit``
|
||||
# - If `maxsplit != -1`, then the string will only be split
|
||||
# `maxsplit - 1` times. This means that there will be `maxsplit`
|
||||
# strings in the output seq.
|
||||
doAssert "1.2.3".split(re"\.", maxsplit = 2) == @["1", "2.3"]
|
||||
|
||||
|
|
@ -708,28 +708,28 @@ template replaceImpl(str: string, pattern: Regex,
|
|||
|
||||
proc replace*(str: string, pattern: Regex,
|
||||
subproc: proc (match: RegexMatch): string): string =
|
||||
## Replaces each match of Regex in the string with ``subproc``, which should
|
||||
## never be or return ``nil``.
|
||||
## Replaces each match of Regex in the string with `subproc`, which should
|
||||
## never be or return `nil`.
|
||||
##
|
||||
## If ``subproc`` is a ``proc (RegexMatch): string``, then it is executed with
|
||||
## If `subproc` is a `proc (RegexMatch): string`, then it is executed with
|
||||
## each match and the return value is the replacement value.
|
||||
##
|
||||
## If ``subproc`` is a ``proc (string): string``, then it is executed with the
|
||||
## If `subproc` is a `proc (string): string`, then it is executed with the
|
||||
## full text of the match and and the return value is the replacement
|
||||
## value.
|
||||
##
|
||||
## If ``subproc`` is a string, the syntax is as follows:
|
||||
## If `subproc` is a string, the syntax is as follows:
|
||||
##
|
||||
## - ``$$`` - literal ``$``
|
||||
## - ``$123`` - capture number ``123``
|
||||
## - ``$foo`` - named capture ``foo``
|
||||
## - ``${foo}`` - same as above
|
||||
## - ``$1$#`` - first and second captures
|
||||
## - ``$#`` - first capture
|
||||
## - ``$0`` - full match
|
||||
## - `$$` - literal `$`
|
||||
## - `$123` - capture number `123`
|
||||
## - `$foo` - named capture `foo`
|
||||
## - `${foo}` - same as above
|
||||
## - `$1$#` - first and second captures
|
||||
## - `$#` - first capture
|
||||
## - `$0` - full match
|
||||
##
|
||||
## If a given capture is missing, ``IndexDefect`` thrown for un-named captures
|
||||
## and ``KeyError`` for named captures.
|
||||
## If a given capture is missing, `IndexDefect` thrown for un-named captures
|
||||
## and `KeyError` for named captures.
|
||||
replaceImpl(str, pattern, subproc(match))
|
||||
|
||||
proc replace*(str: string, pattern: Regex,
|
||||
|
|
@ -743,7 +743,7 @@ proc replace*(str: string, pattern: Regex, sub: string): string =
|
|||
|
||||
proc escapeRe*(str: string): string {.gcsafe.} =
|
||||
## Escapes the string so it doesn't match any special characters.
|
||||
## Incompatible with the Extra flag (``X``).
|
||||
## Incompatible with the Extra flag (`X`).
|
||||
##
|
||||
## Escaped char: `\ + * ? [ ^ ] $ ( ) { } = ! < > | : -`
|
||||
runnableExamples:
|
||||
|
|
|
|||
|
|
@ -37,14 +37,14 @@ import
|
|||
const
|
||||
MaxSubpatterns* = 20
|
||||
## defines the maximum number of subpatterns that can be captured.
|
||||
## This limit still exists for ``replacef`` and ``parallelReplace``.
|
||||
## 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
|
||||
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)
|
||||
|
||||
|
|
@ -79,7 +79,7 @@ proc rawCompile(pattern: string, flags: cint): ptr Pcre =
|
|||
|
||||
proc finalizeRegEx(x: Regex) =
|
||||
# XXX This is a hack, but PCRE does not export its "free" function properly.
|
||||
# Sigh. The hack relies on PCRE's implementation (see ``pcre_get.c``).
|
||||
# Sigh. The hack relies on PCRE's implementation (see `pcre_get.c`).
|
||||
# Fortunately the implementation is unlikely to change.
|
||||
pcre.free_substring(cast[cstring](x.h))
|
||||
if not isNil(x.e):
|
||||
|
|
@ -89,8 +89,8 @@ 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
|
||||
## 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
|
||||
|
|
@ -143,11 +143,11 @@ proc matchOrFind(buf: cstring, pattern: Regex, matches: var openArray[string],
|
|||
|
||||
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),
|
||||
## 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.
|
||||
## substrings in the array `matches`. If it does not match, nothing
|
||||
## is written into `matches` and `(-1,0)` is returned.
|
||||
var
|
||||
rtarray = initRtArray[cint]((matches.len+1)*3)
|
||||
rawMatches = rtarray.getRawData
|
||||
|
|
@ -163,20 +163,20 @@ proc findBounds*(buf: cstring, pattern: Regex, matches: var openArray[string],
|
|||
|
||||
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``.
|
||||
## 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.
|
||||
## is written into `matches` and `(-1,0)` is returned.
|
||||
result = findBounds(cstring(s), pattern, matches, start, s.len)
|
||||
|
||||
proc findBounds*(buf: cstring, pattern: Regex,
|
||||
matches: var openArray[tuple[first, last: int]],
|
||||
start = 0, bufSize = 0): 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.
|
||||
## 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.
|
||||
var
|
||||
rtarray = initRtArray[cint]((matches.len+1)*3)
|
||||
rawMatches = rtarray.getRawData
|
||||
|
|
@ -193,17 +193,17 @@ proc findBounds*(buf: cstring, pattern: Regex,
|
|||
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.
|
||||
## 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.
|
||||
result = findBounds(cstring(s), pattern, matches, start, s.len)
|
||||
|
||||
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.
|
||||
## 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.
|
||||
var
|
||||
rtarray = initRtArray[cint](3)
|
||||
rawMatches = rtarray.getRawData
|
||||
|
|
@ -214,8 +214,8 @@ proc findBounds*(buf: cstring, pattern: Regex,
|
|||
|
||||
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.
|
||||
## 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:
|
||||
|
|
@ -233,21 +233,21 @@ proc matchOrFind(buf: cstring, pattern: Regex, start, bufSize: int, flags: cint)
|
|||
|
||||
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
|
||||
## 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(cstring(s), pattern, matches, start.cint, s.len.cint, pcre.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
|
||||
## 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.
|
||||
return matchOrFind(buf, pattern, matches, start.cint, bufSize.cint, pcre.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
|
||||
## 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:
|
||||
|
|
@ -257,20 +257,20 @@ proc matchLen*(s: string, pattern: Regex, start = 0): int {.inline.} =
|
|||
result = matchOrFind(cstring(s), pattern, start.cint, s.len.cint, pcre.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
|
||||
## 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.cint, bufSize, pcre.ANCHORED)
|
||||
|
||||
proc match*(s: string, pattern: Regex, start = 0): bool {.inline.} =
|
||||
## returns ``true`` if ``s[start..]`` matches the ``pattern``.
|
||||
## 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
|
||||
## 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.
|
||||
##
|
||||
runnableExamples:
|
||||
|
|
@ -282,19 +282,19 @@ proc match*(s: string, pattern: Regex, matches: var openArray[string],
|
|||
|
||||
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
|
||||
## 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).
|
||||
## `buf` has length `bufSize` (not necessarily `'\0'` terminated).
|
||||
result = matchLen(buf, pattern, matches, start, bufSize) != -1
|
||||
|
||||
proc find*(buf: cstring, pattern: Regex, matches: var openArray[string],
|
||||
start = 0, bufSize = 0): 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).
|
||||
## 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).
|
||||
var
|
||||
rtarray = initRtArray[cint]((matches.len+1)*3)
|
||||
rawMatches = rtarray.getRawData
|
||||
|
|
@ -310,15 +310,15 @@ proc find*(buf: cstring, pattern: Regex, matches: var openArray[string],
|
|||
|
||||
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.
|
||||
## 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.
|
||||
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.
|
||||
## 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.
|
||||
var
|
||||
rtarray = initRtArray[cint](3)
|
||||
rawMatches = rtarray.getRawData
|
||||
|
|
@ -328,8 +328,8 @@ proc find*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int =
|
|||
return 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`.
|
||||
## 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
|
||||
|
|
@ -360,7 +360,7 @@ iterator findAll*(s: string, pattern: Regex, start = 0): string =
|
|||
i = b
|
||||
|
||||
iterator findAll*(buf: cstring, pattern: Regex, start = 0, bufSize: int): string =
|
||||
## Yields all matching `substrings` of ``s`` that match ``pattern``.
|
||||
## 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.
|
||||
|
|
@ -381,20 +381,20 @@ iterator findAll*(buf: cstring, pattern: Regex, start = 0, bufSize: int): string
|
|||
i = b
|
||||
|
||||
proc findAll*(s: string, pattern: Regex, start = 0): seq[string] {.inline.} =
|
||||
## returns all matching `substrings` of ``s`` that match ``pattern``.
|
||||
## 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:
|
||||
## 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
|
||||
# note that the implicit `matches` array is different from 1st branch
|
||||
result = $(matches[0],)
|
||||
else: doAssert false
|
||||
doAssert not declared(matches)
|
||||
|
|
@ -408,12 +408,12 @@ template `=~` *(s: string, pattern: Regex): untyped =
|
|||
# ------------------------- more string handling ------------------------------
|
||||
|
||||
proc contains*(s: string, pattern: Regex, start = 0): bool {.inline.} =
|
||||
## same as ``find(s, pattern, start) >= 0``
|
||||
## 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``
|
||||
## same as `find(s, pattern, matches, start) >= 0`
|
||||
return find(s, pattern, matches, start) >= 0
|
||||
|
||||
proc startsWith*(s: string, prefix: Regex): bool {.inline.} =
|
||||
|
|
@ -426,8 +426,8 @@ proc endsWith*(s: string, suffix: Regex): bool {.inline.} =
|
|||
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``.
|
||||
## 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+)", "?") == "?; ?"
|
||||
|
|
@ -443,8 +443,8 @@ proc replace*(s: string, sub: Regex, by = ""): string =
|
|||
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.\`%\`).
|
||||
## 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"
|
||||
|
|
@ -462,7 +462,7 @@ proc replacef*(s: string, sub: Regex, by: string): string =
|
|||
|
||||
proc multiReplace*(s: string, subs: openArray[
|
||||
tuple[pattern: Regex, repl: string]]): string =
|
||||
## Returns a modified copy of ``s`` with the substitutions in ``subs``
|
||||
## Returns a modified copy of `s` with the substitutions in `subs`
|
||||
## applied in parallel.
|
||||
result = ""
|
||||
var i = 0
|
||||
|
|
@ -482,17 +482,17 @@ proc multiReplace*(s: string, subs: openArray[
|
|||
|
||||
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
|
||||
## 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.
|
||||
## Splits the string `s` into substrings.
|
||||
##
|
||||
## Substrings are separated by the regular expression ``sep``
|
||||
## (and the portion matched by ``sep`` is not returned).
|
||||
## Substrings are separated by the regular expression `sep`
|
||||
## (and the portion matched by `sep` is not returned).
|
||||
runnableExamples:
|
||||
import sequtils
|
||||
doAssert toSeq(split("00232this02939is39an22example111", re"\d+")) ==
|
||||
|
|
@ -519,14 +519,14 @@ iterator split*(s: string, sep: Regex; maxsplit = -1): string =
|
|||
inc(last, sepLen)
|
||||
|
||||
proc split*(s: string, sep: Regex, maxsplit = -1): seq[string] {.inline.} =
|
||||
## Splits the string ``s`` into a seq of substrings.
|
||||
## Splits the string `s` into a seq of substrings.
|
||||
##
|
||||
## The portion matched by ``sep`` is not returned.
|
||||
## 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
|
||||
## escapes `s` so that it is matched verbatim when used as a regular
|
||||
## expression.
|
||||
result = ""
|
||||
for c in items(s):
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue