mirror of
https://github.com/nim-lang/Nim.git
synced 2026-07-19 07:21:19 +00:00
use single backtick (#17115)
This commit is contained in:
flywind
@@ -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):
|
||||
|
||||
@@ -57,10 +57,10 @@ proc epoll_create1*(flags: cint): cint {.importc: "epoll_create1",
|
||||
|
||||
proc epoll_ctl*(epfd: cint; op: cint; fd: cint | SocketHandle; event: ptr EpollEvent): cint {.
|
||||
importc: "epoll_ctl", header: "<sys/epoll.h>".}
|
||||
## Manipulate an epoll instance "epfd". Returns ``0`` in case of success,
|
||||
## ``-1`` in case of error (the "errno" variable will contain the specific error code).
|
||||
## Manipulate an epoll instance "epfd". Returns `0` in case of success,
|
||||
## `-1` in case of error (the "errno" variable will contain the specific error code).
|
||||
##
|
||||
## The "op" parameter is one of the ``EPOLL_CTL_*``
|
||||
## The "op" parameter is one of the `EPOLL_CTL_*`
|
||||
## constants defined above. The "fd" parameter is the target of the
|
||||
## operation. The "event" parameter describes which events the caller
|
||||
## is interested in and any associated user data.
|
||||
|
||||
@@ -153,7 +153,7 @@ proc kevent*(kqFD: cint,
|
||||
changelist: ptr KEvent, nchanges: cint,
|
||||
eventlist: ptr KEvent, nevents: cint, timeout: ptr Timespec): cint
|
||||
{.importc: "kevent", header: "<sys/event.h>".}
|
||||
## Manipulates queue for given ``kqFD`` descriptor.
|
||||
## Manipulates queue for given `kqFD` descriptor.
|
||||
|
||||
proc EV_SET*(event: ptr KEvent, ident: uint, filter: cshort, flags: cushort,
|
||||
fflags: cuint, data: int, udata: pointer)
|
||||
|
||||
@@ -27,7 +27,7 @@
|
||||
## the \`identifier\` notation is used.
|
||||
##
|
||||
## This library relies on the header files of your C compiler. The
|
||||
## resulting C code will just ``#include <XYZ.h>`` and *not* define the
|
||||
## resulting C code will just `#include <XYZ.h>` and *not* define the
|
||||
## symbols declared here.
|
||||
|
||||
# Dead code elimination ensures that we don't accidentally generate #includes
|
||||
@@ -90,8 +90,8 @@ type Sighandler = proc (a: cint) {.noconv.}
|
||||
const StatHasNanoseconds* = defined(linux) or defined(freebsd) or
|
||||
defined(osx) or defined(openbsd) or defined(dragonfly) or defined(haiku) ## \
|
||||
## Boolean flag that indicates if the system supports nanosecond time
|
||||
## resolution in the fields of ``Stat``. Note that the nanosecond based fields
|
||||
## (``Stat.st_atim``, ``Stat.st_mtim`` and ``Stat.st_ctim``) can be accessed
|
||||
## resolution in the fields of `Stat`. Note that the nanosecond based fields
|
||||
## (`Stat.st_atim`, `Stat.st_mtim` and `Stat.st_ctim`) can be accessed
|
||||
## without checking this flag, because this module defines fallback procs
|
||||
## when they are not available.
|
||||
|
||||
@@ -908,7 +908,7 @@ when defined(linux) or defined(bsd):
|
||||
|
||||
proc bindSocket*(a1: SocketHandle, a2: ptr SockAddr, a3: SockLen): cint {.
|
||||
importc: "bind", header: "<sys/socket.h>".}
|
||||
## is Posix's ``bind``, because ``bind`` is a reserved word
|
||||
## is Posix's `bind`, because `bind` is a reserved word
|
||||
|
||||
proc connect*(a1: SocketHandle, a2: ptr SockAddr, a3: SockLen): cint {.
|
||||
importc, header: "<sys/socket.h>".}
|
||||
@@ -1083,7 +1083,7 @@ proc handle_signal(sig: cint, handler: proc (a: cint) {.noconv.}) {.importc: "si
|
||||
|
||||
template onSignal*(signals: varargs[cint], body: untyped) =
|
||||
## Setup code to be executed when Unix signals are received. The
|
||||
## currently handled signal is injected as ``sig`` into the calling
|
||||
## currently handled signal is injected as `sig` into the calling
|
||||
## scope.
|
||||
##
|
||||
## Example:
|
||||
|
||||
@@ -58,7 +58,7 @@ type
|
||||
d_type*: int8 ## Type of file; not supported by all filesystem types.
|
||||
## (not POSIX)
|
||||
when defined(linux) or defined(openbsd):
|
||||
d_off*: Off ## Not an offset. Value that ``telldir()`` would return.
|
||||
d_off*: Off ## Not an offset. Value that `telldir()` would return.
|
||||
elif defined(haiku):
|
||||
d_pino*: Ino ## Parent inode (only for queries) (not POSIX)
|
||||
d_reclen*: cushort ## Length of this record. (not POSIX)
|
||||
@@ -551,7 +551,7 @@ else:
|
||||
var SO_REUSEPORT* {.importc, header: "<sys/socket.h>".}: cint
|
||||
|
||||
when defined(macosx):
|
||||
# We can't use the NOSIGNAL flag in the ``send`` function, it has no effect
|
||||
# We can't use the NOSIGNAL flag in the `send` function, it has no effect
|
||||
# Instead we should use SO_NOSIGPIPE in setsockopt
|
||||
const
|
||||
MSG_NOSIGNAL* = 0'i32
|
||||
|
||||
@@ -45,7 +45,7 @@ type
|
||||
d_type*: int8 ## Type of file; not supported by all filesystem types.
|
||||
## (not POSIX)
|
||||
when defined(linux) or defined(openbsd):
|
||||
d_off*: Off ## Not an offset. Value that ``telldir()`` would return.
|
||||
d_off*: Off ## Not an offset. Value that `telldir()` would return.
|
||||
elif defined(haiku):
|
||||
d_pino*: Ino ## Parent inode (only for queries) (not POSIX)
|
||||
d_reclen*: cushort ## Length of this record. (not POSIX)
|
||||
@@ -561,7 +561,7 @@ when defined(linux) or defined(bsd):
|
||||
var SOCK_CLOEXEC* {.importc, header: "<sys/socket.h>".}: cint
|
||||
|
||||
when defined(macosx):
|
||||
# We can't use the NOSIGNAL flag in the ``send`` function, it has no effect
|
||||
# We can't use the NOSIGNAL flag in the `send` function, it has no effect
|
||||
# Instead we should use SO_NOSIGPIPE in setsockopt
|
||||
const
|
||||
MSG_NOSIGNAL* = 0'i32
|
||||
|
||||
@@ -45,7 +45,7 @@ type
|
||||
d_type*: int8 ## Type of file; not supported by all filesystem types.
|
||||
## (not POSIX)
|
||||
when defined(linux) or defined(openbsd):
|
||||
d_off*: Off ## Not an offset. Value that ``telldir()`` would return.
|
||||
d_off*: Off ## Not an offset. Value that `telldir()` would return.
|
||||
elif defined(haiku):
|
||||
d_pino*: Ino ## Parent inode (only for queries) (not POSIX)
|
||||
d_reclen*: cushort ## Length of this record. (not POSIX)
|
||||
|
||||
@@ -64,7 +64,7 @@ type
|
||||
d_type*: int8 ## Type of file; not supported by all filesystem types.
|
||||
## (not POSIX)
|
||||
when defined(linux) or defined(openbsd):
|
||||
d_off*: Off ## Not an offset. Value that ``telldir()`` would return.
|
||||
d_off*: Off ## Not an offset. Value that `telldir()` would return.
|
||||
elif defined(haiku):
|
||||
d_pino*: Ino ## Parent inode (only for queries) (not POSIX)
|
||||
d_reclen*: cushort ## Length of this record. (not POSIX)
|
||||
@@ -615,7 +615,7 @@ when defined(linux) or defined(bsd):
|
||||
var SOCK_CLOEXEC* {.importc, header: "<sys/socket.h>".}: cint
|
||||
|
||||
when defined(macosx):
|
||||
# We can't use the NOSIGNAL flag in the ``send`` function, it has no effect
|
||||
# We can't use the NOSIGNAL flag in the `send` function, it has no effect
|
||||
# Instead we should use SO_NOSIGPIPE in setsockopt
|
||||
const
|
||||
MSG_NOSIGNAL* = 0'i32
|
||||
|
||||
@@ -146,7 +146,7 @@ template await*[T](f: Future[T]): auto {.used.} =
|
||||
|
||||
proc asyncSingleProc(prc: NimNode): NimNode {.compileTime.} =
|
||||
## This macro transforms a single procedure into a closure iterator.
|
||||
## The ``async`` macro supports a stmtList holding multiple async procedures.
|
||||
## The `async` macro supports a stmtList holding multiple async procedures.
|
||||
if prc.kind == nnkProcTy:
|
||||
result = prc
|
||||
if prc[0][0].kind == nnkEmpty:
|
||||
@@ -320,8 +320,8 @@ proc stripReturnType(returnType: NimNode): NimNode =
|
||||
proc splitProc(prc: NimNode): (NimNode, NimNode) =
|
||||
## Takes a procedure definition which takes a generic union of arguments,
|
||||
## for example: proc (socket: Socket | AsyncSocket).
|
||||
## It transforms them so that ``proc (socket: Socket)`` and
|
||||
## ``proc (socket: AsyncSocket)`` are returned.
|
||||
## It transforms them so that `proc (socket: Socket)` and
|
||||
## `proc (socket: AsyncSocket)` are returned.
|
||||
|
||||
result[0] = prc.copyNimTree()
|
||||
# Retrieve the `T` inside `Future[T]`.
|
||||
@@ -349,8 +349,8 @@ macro multisync*(prc: untyped): untyped =
|
||||
## Macro which processes async procedures into both asynchronous and
|
||||
## synchronous procedures.
|
||||
##
|
||||
## The generated async procedures use the ``async`` macro, whereas the
|
||||
## generated synchronous procedures simply strip off the ``await`` calls.
|
||||
## The generated async procedures use the `async` macro, whereas the
|
||||
## generated synchronous procedures simply strip off the `await` calls.
|
||||
let (sync, asyncPrc) = splitProc(prc)
|
||||
result = newStmtList()
|
||||
result.add(asyncSingleProc(asyncPrc))
|
||||
|
||||
Reference in New Issue
Block a user