jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

use single backtick (#17115)

Browse source
This commit is contained in:
flywind 2021-02-20 05:20:29 -06:00 • committed by GitHub
commit a1a18cfe66
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 174 additions and 174 deletions
Download patch file Download diff file Expand all files Collapse all files

154
lib/impure/nre.nim
View file

@ -20,7 +20,7 @@ when defined(js):
## search the internet for a wide variety of third-party documentation and ## search the internet for a wide variety of third-party documentation and
## tools. ## 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 ## library doesn't work with it due to documented compiler limitations. As
## a workaround, use this: ## a workaround, use this:
## ##
@ -76,19 +76,19 @@ export options
type type
Regex* = ref object Regex* = ref object
## Represents the pattern that things are matched against, constructed with ## Represents the pattern that things are matched against, constructed with
## ``re(string)``. Examples: ``re"foo"``, ``re(r"(*ANYCRLF)(?x)foo # ## `re(string)`. Examples: `re"foo"`, `re(r"(*ANYCRLF)(?x)foo #
## comment".`` ## comment".`
## ##
## ``pattern: string`` ## `pattern: string`
## the string that was used to create the pattern. For details on how ## the string that was used to create the pattern. For details on how
## to write a pattern, please see `the official PCRE pattern ## to write a pattern, please see `the official PCRE pattern
## documentation. ## documentation.
## <https://www.pcre.org/original/doc/html/pcrepattern.html>`_ ## <https://www.pcre.org/original/doc/html/pcrepattern.html>`_
## ##
## ``captureCount: int`` ## `captureCount: int`
## the number of captures that the pattern has. ## 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. ## 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 following options may appear anywhere in the pattern, and they affect
## the rest of it. ## the rest of it.
## ##
## - ``(?i)`` - case insensitive ## - `(?i)` - case insensitive
## - ``(?m)`` - multi-line: ``^`` and ``$`` match the beginning and end of ## - `(?m)` - multi-line: `^` and `$` match the beginning and end of
## lines, not of the subject string ## lines, not of the subject string
## - ``(?s)`` - ``.`` also matches newline (*dotall*) ## - `(?s)` - `.` also matches newline (*dotall*)
## - ``(?U)`` - expressions are not greedy by default. ``?`` can be added ## - `(?U)` - expressions are not greedy by default. `?` can be added
## to a qualifier to make it greedy ## to a qualifier to make it greedy
## - ``(?x)`` - whitespace and comments (``#``) are ignored (*extended*) ## - `(?x)` - whitespace and comments (`#`) are ignored (*extended*)
## - ``(?X)`` - character escapes without special meaning (``\w`` vs. ## - `(?X)` - character escapes without special meaning (`\w` vs.
## ``\a``) are errors (*extra*) ## `\a`) are errors (*extra*)
## ##
## One or a combination of these options may appear only at the beginning ## One or a combination of these options may appear only at the beginning
## of the pattern: ## of the pattern:
## ##
## - ``(*UTF8)`` - treat both the pattern and subject as UTF-8 ## - `(*UTF8)` - treat both the pattern and subject as UTF-8
## - ``(*UCP)`` - Unicode character properties; ``\w`` matches ``я`` ## - `(*UCP)` - Unicode character properties; `\w` matches `я`
## - ``(*U)`` - a combination of the two options above ## - `(*U)` - a combination of the two options above
## - ``(*FIRSTLINE*)`` - fails if there is not a match on the first line ## - `(*FIRSTLINE*)` - fails if there is not a match on the first line
## - ``(*NO_AUTO_CAPTURE)`` - turn off auto-capture for groups; ## - `(*NO_AUTO_CAPTURE)` - turn off auto-capture for groups;
## ``(?<name>...)`` can be used to capture ## `(?<name>...)` can be used to capture
## - ``(*CR)`` - newlines are separated by ``\r`` ## - `(*CR)` - newlines are separated by `\r`
## - ``(*LF)`` - newlines are separated by ``\n`` (UNIX default) ## - `(*LF)` - newlines are separated by `\n` (UNIX default)
## - ``(*CRLF)`` - newlines are separated by ``\r\n`` (Windows default) ## - `(*CRLF)` - newlines are separated by `\r\n` (Windows default)
## - ``(*ANYCRLF)`` - newlines are separated by any of the above ## - `(*ANYCRLF)` - newlines are separated by any of the above
## - ``(*ANY)`` - newlines are separated by any of the above and Unicode ## - `(*ANY)` - newlines are separated by any of the above and Unicode
## newlines: ## newlines:
## ##
## single characters VT (vertical tab, U+000B), FF (form feed, U+000C), ## single characters VT (vertical tab, U+000B), FF (form feed, U+000C),
@ -130,8 +130,8 @@ type
## are recognized only in UTF-8 mode. ## are recognized only in UTF-8 mode.
## — man pcre ## — man pcre
## ##
## - ``(*JAVASCRIPT_COMPAT)`` - JavaScript compatibility ## - `(*JAVASCRIPT_COMPAT)` - JavaScript compatibility
## - ``(*NO_STUDY)`` - turn off studying; study is enabled by default ## - `(*NO_STUDY)` - turn off studying; study is enabled by default
## ##
## For more details on the leading option groups, see the `Option ## For more details on the leading option groups, see the `Option
## Setting <http://man7.org/linux/man-pages/man3/pcresyntax.3.html#OPTION_SETTING>`_ ## 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>`_. ## 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 ## Some of these options are not part of PCRE and are converted by nre
## into PCRE flags. These include ``NEVER_UTF``, ``ANCHORED``, ## into PCRE flags. These include `NEVER_UTF`, `ANCHORED`,
## ``DOLLAR_ENDONLY``, ``FIRSTLINE``, ``NO_AUTO_CAPTURE``, ## `DOLLAR_ENDONLY`, `FIRSTLINE`, `NO_AUTO_CAPTURE`,
## ``JAVASCRIPT_COMPAT``, ``U``, ``NO_STUDY``. In other PCRE wrappers, you ## `JAVASCRIPT_COMPAT`, `U`, `NO_STUDY`. In other PCRE wrappers, you
## will need to pass these as separate flags to PCRE. ## will need to pass these as separate flags to PCRE.
pattern*: string ## not nil pattern*: string ## not nil
pcreObj: ptr pcre.Pcre ## not nil pcreObj: ptr pcre.Pcre ## not nil
@ -155,46 +155,46 @@ type
## Usually seen as Option[RegexMatch], it represents the result of an ## Usually seen as Option[RegexMatch], it represents the result of an
## execution. On failure, it is none, on success, it is some. ## execution. On failure, it is none, on success, it is some.
## ##
## ``pattern: Regex`` ## `pattern: Regex`
## the pattern that is being matched ## the pattern that is being matched
## ##
## ``str: string`` ## `str: string`
## the string that was matched against ## the string that was matched against
## ##
## ``captures[]: string`` ## `captures[]: string`
## the string value of whatever was captured at that id. If the value ## 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, ## 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"(\w)").get.captures[0] == "a"`
## - ``"abc".match(re"(?<letter>\w)").get.captures["letter"] == "a"`` ## - `"abc".match(re"(?<letter>\w)").get.captures["letter"] == "a"`
## - ``"abc".match(re"(\w)\w").get.captures[-1] == "ab"`` ## - `"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 ## 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. ## The bounds are both inclusive.
## ##
## - ``"abc".match(re"(\w)").get.captureBounds[0] == 0 .. 0`` ## - `"abc".match(re"(\w)").get.captureBounds[0] == 0 .. 0`
## - ``0 in "abc".match(re"(\w)").get.captureBounds == true`` ## - `0 in "abc".match(re"(\w)").get.captureBounds == true`
## - ``"abc".match(re"").get.captureBounds[-1] == 0 .. -1`` ## - `"abc".match(re"").get.captureBounds[-1] == 0 .. -1`
## - ``"abc".match(re"abc").get.captureBounds[-1] == 0 .. 2`` ## - `"abc".match(re"abc").get.captureBounds[-1] == 0 .. 2`
## ##
## ``match: string`` ## `match: string`
## the full text of the match. ## the full text of the match.
## ##
## ``matchBounds: HSlice[int, int]`` ## `matchBounds: HSlice[int, int]`
## the bounds of the match, as in ``captureBounds[]`` ## the bounds of the match, as in `captureBounds[]`
## ##
## ``(captureBounds|captures).toTable`` ## `(captureBounds|captures).toTable`
## returns a table with each named capture as a key. ## returns a table with each named capture as a key.
## ##
## ``(captureBounds|captures).toSeq`` ## `(captureBounds|captures).toSeq`
## returns all the captures by their number. ## returns all the captures by their number.
## ##
## ``$: string`` ## `$: string`
## same as ``match`` ## same as `match`
pattern*: Regex ## The regex doing the matching. pattern*: Regex ## The regex doing the matching.
## Not nil. ## Not nil.
str*: string ## The string that was matched against. 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 = iterator findIter*(str: string, pattern: Regex, start = 0, endpos = int.high): RegexMatch =
## Works the same as `find(...)<#find,string,Regex,int>`_, but finds every ## Works the same as `find(...)<#find,string,Regex,int>`_, but finds every
## non-overlapping match. ``"2222".find(re"22")`` is ``"22", "22"``, not ## non-overlapping match. `"2222".find(re"22")` is `"22", "22"`, not
## ``"22", "22", "22"``. ## `"22", "22", "22"`.
## ##
## Arguments are the same as `find(...)<#find,string,Regex,int>`_ ## Arguments are the same as `find(...)<#find,string,Regex,int>`_
## ##
## Variants: ## Variants:
## ##
## - ``proc findAll(...)`` returns a ``seq[string]`` ## - `proc findAll(...)` returns a `seq[string]`
# see pcredemo for explanation # see pcredemo for explanation
let matchesCrLf = pattern.matchesCrLf() let matchesCrLf = pattern.matchesCrLf()
let unicode = uint32(getinfo[culong](pattern, pcre.INFO_OPTIONS) and 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 ## Finds the given pattern in the string between the end and start
## positions. ## positions.
## ##
## ``start`` ## `start`
## The start point at which to start matching. ``|abc`` is ``0``; ## The start point at which to start matching. `|abc` is `0`;
## ``a|bc`` is ``1`` ## `a|bc` is `1`
## ##
## ``endpos`` ## `endpos`
## The maximum index for a match; ``int.high`` means the end of the ## The maximum index for a match; `int.high` means the end of the
## string, otherwise it’s an inclusive upper bound. ## string, otherwise it’s an inclusive upper bound.
return str.matchImpl(pattern, start, endpos, 0) 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 = proc contains*(str: string, pattern: Regex, start = 0, endpos = int.high): bool =
## Determine if the string contains the given pattern between the end and ## Determine if the string contains the given pattern between the end and
## start positions: ## 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: runnableExamples:
doAssert "abc".contains(re"bc") 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 ## Splits the string with the given regex. This works according to the
## rules that Perl and Javascript use. ## 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: runnableExamples:
# - If the match is zero-width, then the string is still split: # - 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: # split:
doAssert "12".split(re"(\d)") == @["", "1", "", "2", ""] doAssert "12".split(re"(\d)") == @["", "1", "", "2", ""]
# - If ``maxsplit != -1``, then the string will only be split # - If `maxsplit != -1`, then the string will only be split
# ``maxsplit - 1`` times. This means that there will be ``maxsplit`` # `maxsplit - 1` times. This means that there will be `maxsplit`
# strings in the output seq. # strings in the output seq.
doAssert "1.2.3".split(re"\.", maxsplit = 2) == @["1", "2.3"] 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, proc replace*(str: string, pattern: Regex,
subproc: proc (match: RegexMatch): string): string = subproc: proc (match: RegexMatch): string): string =
## Replaces each match of Regex in the string with ``subproc``, which should ## Replaces each match of Regex in the string with `subproc`, which should
## never be or return ``nil``. ## 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. ## 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 ## full text of the match and and the return value is the replacement
## value. ## value.
## ##
## If ``subproc`` is a string, the syntax is as follows: ## If `subproc` is a string, the syntax is as follows:
## ##
## - ``$$`` - literal ``$`` ## - `$$` - literal `$`
## - ``$123`` - capture number ``123`` ## - `$123` - capture number `123`
## - ``$foo`` - named capture ``foo`` ## - `$foo` - named capture `foo`
## - ``${foo}`` - same as above ## - `${foo}` - same as above
## - ``$1$#`` - first and second captures ## - `$1$#` - first and second captures
## - ``$#`` - first capture ## - `$#` - first capture
## - ``$0`` - full match ## - `$0` - full match
## ##
## If a given capture is missing, ``IndexDefect`` thrown for un-named captures ## If a given capture is missing, `IndexDefect` thrown for un-named captures
## and ``KeyError`` for named captures. ## and `KeyError` for named captures.
replaceImpl(str, pattern, subproc(match)) replaceImpl(str, pattern, subproc(match))
proc replace*(str: string, pattern: Regex, 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.} = proc escapeRe*(str: string): string {.gcsafe.} =
## Escapes the string so it doesn't match any special characters. ## 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: `\ + * ? [ ^ ] $ ( ) { } = ! < > | : -` ## Escaped char: `\ + * ? [ ^ ] $ ( ) { } = ! < > | : -`
runnableExamples: runnableExamples:

152
lib/impure/re.nim
View file

@ -37,14 +37,14 @@ import
const const
MaxSubpatterns* = 20 MaxSubpatterns* = 20
## defines the maximum number of subpatterns that can be captured. ## 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 type
RegexFlag* = enum ## options for regular expressions RegexFlag* = enum ## options for regular expressions
reIgnoreCase = 0, ## do caseless matching reIgnoreCase = 0, ## do caseless matching
reMultiLine = 1, ## ``^`` and ``$`` match newlines within data reMultiLine = 1, ## `^` and `$` match newlines within data
reDotAll = 2, ## ``.`` matches anything including NL reDotAll = 2, ## `.` matches anything including NL
reExtended = 3, ## ignore whitespace and ``#`` comments reExtended = 3, ## ignore whitespace and `#` comments
reStudy = 4 ## study the expression (may be omitted if the reStudy = 4 ## study the expression (may be omitted if the
## expression will be used only once) ## expression will be used only once)
@ -79,7 +79,7 @@ proc rawCompile(pattern: string, flags: cint): ptr Pcre =
proc finalizeRegEx(x: Regex) = proc finalizeRegEx(x: Regex) =
# XXX This is a hack, but PCRE does not export its "free" function properly. # 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. # Fortunately the implementation is unlikely to change.
pcre.free_substring(cast[cstring](x.h)) pcre.free_substring(cast[cstring](x.h))
if not isNil(x.e): if not isNil(x.e):
@ -89,8 +89,8 @@ proc re*(s: string, flags = {reStudy}): Regex =
## Constructor of regular expressions. ## Constructor of regular expressions.
## ##
## Note that Nim's ## Note that Nim's
## extended raw string literals support the syntax ``re"[abc]"`` as ## extended raw string literals support the syntax `re"[abc]"` as
## a short form for ``re(r"[abc]")``. Also note that since this ## a short form for `re(r"[abc]")`. Also note that since this
## compiles the regular expression, which is expensive, you should ## compiles the regular expression, which is expensive, you should
## avoid putting it directly in the arguments of the functions like ## 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 ## 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], proc findBounds*(buf: cstring, pattern: Regex, matches: var openArray[string],
start = 0, bufSize: int): tuple[first, last: int] = start = 0, bufSize: int): tuple[first, last: int] =
## returns the starting position and end position of ``pattern`` in ``buf`` ## returns the starting position and end position of `pattern` in `buf`
## (where ``buf`` has length ``bufSize`` and is not necessarily ``'\0'`` terminated), ## (where `buf` has length `bufSize` and is not necessarily `'\0'` terminated),
## and the captured ## and the captured
## substrings in the array ``matches``. If it does not match, nothing ## 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.
var var
rtarray = initRtArray[cint]((matches.len+1)*3) rtarray = initRtArray[cint]((matches.len+1)*3)
rawMatches = rtarray.getRawData 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], proc findBounds*(s: string, pattern: Regex, matches: var openArray[string],
start = 0): tuple[first, last: int] {.inline.} = start = 0): tuple[first, last: int] {.inline.} =
## returns the starting position and end position of ``pattern`` in ``s`` ## returns the starting position and end position of `pattern` in `s`
## and the captured substrings in the array ``matches``. ## and the captured substrings in the array `matches`.
## If it does not match, nothing ## 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) result = findBounds(cstring(s), pattern, matches, start, s.len)
proc findBounds*(buf: cstring, pattern: Regex, proc findBounds*(buf: cstring, pattern: Regex,
matches: var openArray[tuple[first, last: int]], matches: var openArray[tuple[first, last: int]],
start = 0, bufSize = 0): tuple[first, last: int] = start = 0, bufSize = 0): tuple[first, last: int] =
## returns the starting position and end position of ``pattern`` in ``buf`` ## returns the starting position and end position of `pattern` in `buf`
## (where ``buf`` has length ``bufSize`` and is not necessarily ``'\0'`` terminated), ## (where `buf` has length `bufSize` and is not necessarily `'\0'` terminated),
## and the captured substrings in the array ``matches``. ## and the captured substrings in the array `matches`.
## If it does not match, nothing is written into ``matches`` and ## If it does not match, nothing is written into `matches` and
## ``(-1,0)`` is returned. ## `(-1,0)` is returned.
var var
rtarray = initRtArray[cint]((matches.len+1)*3) rtarray = initRtArray[cint]((matches.len+1)*3)
rawMatches = rtarray.getRawData rawMatches = rtarray.getRawData
@ -193,17 +193,17 @@ proc findBounds*(buf: cstring, pattern: Regex,
proc findBounds*(s: string, pattern: Regex, proc findBounds*(s: string, pattern: Regex,
matches: var openArray[tuple[first, last: int]], matches: var openArray[tuple[first, last: int]],
start = 0): tuple[first, last: int] {.inline.} = start = 0): tuple[first, last: int] {.inline.} =
## returns the starting position and end position of ``pattern`` in ``s`` ## returns the starting position and end position of `pattern` in `s`
## and the captured substrings in the array ``matches``. ## and the captured substrings in the array `matches`.
## If it does not match, nothing is written into ``matches`` and ## If it does not match, nothing is written into `matches` and
## ``(-1,0)`` is returned. ## `(-1,0)` is returned.
result = findBounds(cstring(s), pattern, matches, start, s.len) result = findBounds(cstring(s), pattern, matches, start, s.len)
proc findBounds*(buf: cstring, pattern: Regex, proc findBounds*(buf: cstring, pattern: Regex,
start = 0, bufSize: int): tuple[first, last: int] = start = 0, bufSize: int): tuple[first, last: int] =
## returns the ``first`` and ``last`` position of ``pattern`` in ``buf``, ## returns the `first` and `last` position of `pattern` in `buf`,
## where ``buf`` has length ``bufSize`` (not necessarily ``'\0'`` terminated). ## where `buf` has length `bufSize` (not necessarily `'\0'` terminated).
## If it does not match, ``(-1,0)`` is returned. ## If it does not match, `(-1,0)` is returned.
var var
rtarray = initRtArray[cint](3) rtarray = initRtArray[cint](3)
rawMatches = rtarray.getRawData rawMatches = rtarray.getRawData
@ -214,8 +214,8 @@ proc findBounds*(buf: cstring, pattern: Regex,
proc findBounds*(s: string, pattern: Regex, proc findBounds*(s: string, pattern: Regex,
start = 0): tuple[first, last: int] {.inline.} = start = 0): tuple[first, last: int] {.inline.} =
## returns the ``first`` and ``last`` position of ``pattern`` in ``s``. ## returns the `first` and `last` position of `pattern` in `s`.
## If it does not match, ``(-1,0)`` is returned. ## If it does not match, `(-1,0)` is returned.
## ##
## Note: there is a speed improvement if the matches do not need to be captured. ## Note: there is a speed improvement if the matches do not need to be captured.
runnableExamples: 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], proc matchLen*(s: string, pattern: Regex, matches: var openArray[string],
start = 0): int {.inline.} = start = 0): int {.inline.} =
## the same as ``match``, but it returns the length of the match, ## 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 ## if there is no match, `-1` is returned. Note that a match length
## of zero can happen. ## of zero can happen.
result = matchOrFind(cstring(s), pattern, matches, start.cint, s.len.cint, pcre.ANCHORED) result = matchOrFind(cstring(s), pattern, matches, start.cint, s.len.cint, pcre.ANCHORED)
proc matchLen*(buf: cstring, pattern: Regex, matches: var openArray[string], proc matchLen*(buf: cstring, pattern: Regex, matches: var openArray[string],
start = 0, bufSize: int): int {.inline.} = start = 0, bufSize: int): int {.inline.} =
## the same as ``match``, but it returns the length of the match, ## 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 ## if there is no match, `-1` is returned. Note that a match length
## of zero can happen. ## of zero can happen.
return matchOrFind(buf, pattern, matches, start.cint, bufSize.cint, pcre.ANCHORED) return matchOrFind(buf, pattern, matches, start.cint, bufSize.cint, pcre.ANCHORED)
proc matchLen*(s: string, pattern: Regex, start = 0): int {.inline.} = proc matchLen*(s: string, pattern: Regex, start = 0): int {.inline.} =
## the same as ``match``, but it returns the length of the match, ## 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 ## if there is no match, `-1` is returned. Note that a match length
## of zero can happen. ## of zero can happen.
## ##
runnableExamples: 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) result = matchOrFind(cstring(s), pattern, start.cint, s.len.cint, pcre.ANCHORED)
proc matchLen*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int {.inline.} = proc matchLen*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int {.inline.} =
## the same as ``match``, but it returns the length of the match, ## 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 ## if there is no match, `-1` is returned. Note that a match length
## of zero can happen. ## of zero can happen.
result = matchOrFind(buf, pattern, start.cint, bufSize, pcre.ANCHORED) result = matchOrFind(buf, pattern, start.cint, bufSize, pcre.ANCHORED)
proc match*(s: string, pattern: Regex, start = 0): bool {.inline.} = 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 result = matchLen(cstring(s), pattern, start, s.len) != -1
proc match*(s: string, pattern: Regex, matches: var openArray[string], proc match*(s: string, pattern: Regex, matches: var openArray[string],
start = 0): bool {.inline.} = start = 0): bool {.inline.} =
## returns ``true`` if ``s[start..]`` matches the ``pattern`` and ## returns `true` if `s[start..]` matches the `pattern` and
## the captured substrings in the array ``matches``. If it does not ## the captured substrings in the array `matches`. If it does not
## match, nothing is written into ``matches`` and ``false`` is ## match, nothing is written into `matches` and `false` is
## returned. ## returned.
## ##
runnableExamples: 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], proc match*(buf: cstring, pattern: Regex, matches: var openArray[string],
start = 0, bufSize: int): bool {.inline.} = start = 0, bufSize: int): bool {.inline.} =
## returns ``true`` if ``buf[start..<bufSize]`` matches the ``pattern`` and ## returns `true` if `buf[start..<bufSize]` matches the `pattern` and
## the captured substrings in the array ``matches``. If it does not ## the captured substrings in the array `matches`. If it does not
## match, nothing is written into ``matches`` and ``false`` is ## match, nothing is written into `matches` and `false` is
## returned. ## 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 result = matchLen(buf, pattern, matches, start, bufSize) != -1
proc find*(buf: cstring, pattern: Regex, matches: var openArray[string], proc find*(buf: cstring, pattern: Regex, matches: var openArray[string],
start = 0, bufSize = 0): int = start = 0, bufSize = 0): int =
## returns the starting position of ``pattern`` in ``buf`` and the captured ## returns the starting position of `pattern` in `buf` and the captured
## substrings in the array ``matches``. If it does not match, nothing ## substrings in the array `matches`. If it does not match, nothing
## is written into ``matches`` and ``-1`` is returned. ## is written into `matches` and `-1` is returned.
## ``buf`` has length ``bufSize`` (not necessarily ``'\0'`` terminated). ## `buf` has length `bufSize` (not necessarily `'\0'` terminated).
var var
rtarray = initRtArray[cint]((matches.len+1)*3) rtarray = initRtArray[cint]((matches.len+1)*3)
rawMatches = rtarray.getRawData 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], proc find*(s: string, pattern: Regex, matches: var openArray[string],
start = 0): int {.inline.} = start = 0): int {.inline.} =
## returns the starting position of ``pattern`` in ``s`` and the captured ## returns the starting position of `pattern` in `s` and the captured
## substrings in the array ``matches``. If it does not match, nothing ## substrings in the array `matches`. If it does not match, nothing
## is written into ``matches`` and ``-1`` is returned. ## is written into `matches` and `-1` is returned.
result = find(cstring(s), pattern, matches, start, s.len) result = find(cstring(s), pattern, matches, start, s.len)
proc find*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int = proc find*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int =
## returns the starting position of ``pattern`` in ``buf``, ## returns the starting position of `pattern` in `buf`,
## where ``buf`` has length ``bufSize`` (not necessarily ``'\0'`` terminated). ## where `buf` has length `bufSize` (not necessarily `'\0'` terminated).
## If it does not match, ``-1`` is returned. ## If it does not match, `-1` is returned.
var var
rtarray = initRtArray[cint](3) rtarray = initRtArray[cint](3)
rawMatches = rtarray.getRawData rawMatches = rtarray.getRawData
@ -328,8 +328,8 @@ proc find*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int =
return rawMatches[0] return rawMatches[0]
proc find*(s: string, pattern: Regex, start = 0): int {.inline.} = proc find*(s: string, pattern: Regex, start = 0): int {.inline.} =
## returns the starting position of ``pattern`` in ``s``. If it does not ## returns the starting position of `pattern` in `s`. If it does not
## match, ``-1`` is returned. We start the scan at `start`. ## match, `-1` is returned. We start the scan at `start`.
runnableExamples: runnableExamples:
doAssert find("abcdefg", re"cde") == 2 doAssert find("abcdefg", re"cde") == 2
doAssert find("abcdefg", re"abc") == 0 doAssert find("abcdefg", re"abc") == 0
@ -360,7 +360,7 @@ iterator findAll*(s: string, pattern: Regex, start = 0): string =
i = b i = b
iterator findAll*(buf: cstring, pattern: Regex, start = 0, bufSize: int): string = 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 ## Note that since this is an iterator you should not modify the string you
## are iterating over: bad things could happen. ## are iterating over: bad things could happen.
@ -381,20 +381,20 @@ iterator findAll*(buf: cstring, pattern: Regex, start = 0, bufSize: int): string
i = b i = b
proc findAll*(s: string, pattern: Regex, start = 0): seq[string] {.inline.} = 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. ## If it does not match, @[] is returned.
result = @[] result = @[]
for x in findAll(s, pattern, start): result.add x for x in findAll(s, pattern, start): result.add x
template `=~` *(s: string, pattern: Regex): untyped = template `=~` *(s: string, pattern: Regex): untyped =
## This calls ``match`` with an implicit declared ``matches`` array that ## This calls `match` with an implicit declared `matches` array that
## can be used in the scope of the ``=~`` call: ## can be used in the scope of the `=~` call:
runnableExamples: runnableExamples:
proc parse(line: string): string = proc parse(line: string): string =
if line =~ re"\s*(\w+)\s*\=\s*(\w+)": # matches a key=value pair: if line =~ re"\s*(\w+)\s*\=\s*(\w+)": # matches a key=value pair:
result = $(matches[0], matches[1]) result = $(matches[0], matches[1])
elif line =~ re"\s*(\#.*)": # matches a comment 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],) result = $(matches[0],)
else: doAssert false else: doAssert false
doAssert not declared(matches) doAssert not declared(matches)
@ -408,12 +408,12 @@ template `=~` *(s: string, pattern: Regex): untyped =
# ------------------------- more string handling ------------------------------ # ------------------------- more string handling ------------------------------
proc contains*(s: string, pattern: Regex, start = 0): bool {.inline.} = 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 return find(s, pattern, start) >= 0
proc contains*(s: string, pattern: Regex, matches: var openArray[string], proc contains*(s: string, pattern: Regex, matches: var openArray[string],
start = 0): bool {.inline.} = 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 return find(s, pattern, matches, start) >= 0
proc startsWith*(s: string, prefix: Regex): bool {.inline.} = 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 if matchLen(s, suffix, i) == s.len - i: return true
proc replace*(s: string, sub: Regex, by = ""): string = proc replace*(s: string, sub: Regex, by = ""): string =
## Replaces ``sub`` in ``s`` by the string ``by``. Captures cannot be ## Replaces `sub` in `s` by the string `by`. Captures cannot be
## accessed in ``by``. ## accessed in `by`.
runnableExamples: runnableExamples:
doAssert "var1=key; var2=key2".replace(re"(\w+)=(\w+)") == "; " doAssert "var1=key; var2=key2".replace(re"(\w+)=(\w+)") == "; "
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)) add(result, substr(s, prev))
proc replacef*(s: string, sub: Regex, by: string): string = proc replacef*(s: string, sub: Regex, by: string): string =
## Replaces ``sub`` in ``s`` by the string ``by``. Captures can be accessed in ``by`` ## Replaces `sub` in `s` by the string `by`. Captures can be accessed in `by`
## with the notation ``$i`` and ``$#`` (see strutils.\`%\`). ## with the notation `$i` and `$#` (see strutils.\`%\`).
runnableExamples: runnableExamples:
doAssert "var1=key; var2=key2".replacef(re"(\w+)=(\w+)", "$1<-$2$2") == doAssert "var1=key; var2=key2".replacef(re"(\w+)=(\w+)", "$1<-$2$2") ==
"var1<-keykey; var2<-key2key2" "var1<-keykey; var2<-key2key2"
@ -462,7 +462,7 @@ proc replacef*(s: string, sub: Regex, by: string): string =
proc multiReplace*(s: string, subs: openArray[ proc multiReplace*(s: string, subs: openArray[
tuple[pattern: Regex, repl: string]]): string = 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. ## applied in parallel.
result = "" result = ""
var i = 0 var i = 0
@ -482,17 +482,17 @@ proc multiReplace*(s: string, subs: openArray[
proc transformFile*(infile, outfile: string, proc transformFile*(infile, outfile: string,
subs: openArray[tuple[pattern: Regex, repl: string]]) = subs: openArray[tuple[pattern: Regex, repl: string]]) =
## reads in the file ``infile``, performs a parallel replacement (calls ## reads in the file `infile`, performs a parallel replacement (calls
## ``parallelReplace``) and writes back to ``outfile``. Raises ``IOError`` if an ## `parallelReplace`) and writes back to `outfile`. Raises `IOError` if an
## error occurs. This is supposed to be used for quick scripting. ## error occurs. This is supposed to be used for quick scripting.
var x = readFile(infile) var x = readFile(infile)
writeFile(outfile, x.multiReplace(subs)) writeFile(outfile, x.multiReplace(subs))
iterator split*(s: string, sep: Regex; maxsplit = -1): string = 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`` ## Substrings are separated by the regular expression `sep`
## (and the portion matched by ``sep`` is not returned). ## (and the portion matched by `sep` is not returned).
runnableExamples: runnableExamples:
import sequtils import sequtils
doAssert toSeq(split("00232this02939is39an22example111", re"\d+")) == doAssert toSeq(split("00232this02939is39an22example111", re"\d+")) ==
@ -519,14 +519,14 @@ iterator split*(s: string, sep: Regex; maxsplit = -1): string =
inc(last, sepLen) inc(last, sepLen)
proc split*(s: string, sep: Regex, maxsplit = -1): seq[string] {.inline.} = 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 = @[] result = @[]
for x in split(s, sep, maxsplit): result.add x for x in split(s, sep, maxsplit): result.add x
proc escapeRe*(s: string): string = 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. ## expression.
result = "" result = ""
for c in items(s): for c in items(s):

6
lib/posix/epoll.nim
View file

@ -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 {. proc epoll_ctl*(epfd: cint; op: cint; fd: cint | SocketHandle; event: ptr EpollEvent): cint {.
importc: "epoll_ctl", header: "<sys/epoll.h>".} importc: "epoll_ctl", header: "<sys/epoll.h>".}
## Manipulate an epoll instance "epfd". Returns ``0`` in case of success, ## 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). ## `-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 ## constants defined above. The "fd" parameter is the target of the
## operation. The "event" parameter describes which events the caller ## operation. The "event" parameter describes which events the caller
## is interested in and any associated user data. ## is interested in and any associated user data.

2
lib/posix/kqueue.nim
View file

@ -153,7 +153,7 @@ proc kevent*(kqFD: cint,
changelist: ptr KEvent, nchanges: cint, changelist: ptr KEvent, nchanges: cint,
eventlist: ptr KEvent, nevents: cint, timeout: ptr Timespec): cint eventlist: ptr KEvent, nevents: cint, timeout: ptr Timespec): cint
{.importc: "kevent", header: "<sys/event.h>".} {.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, proc EV_SET*(event: ptr KEvent, ident: uint, filter: cshort, flags: cushort,
fflags: cuint, data: int, udata: pointer) fflags: cuint, data: int, udata: pointer)

10
lib/posix/posix.nim
View file

@ -27,7 +27,7 @@
## the \`identifier\` notation is used. ## the \`identifier\` notation is used.
## ##
## This library relies on the header files of your C compiler. The ## 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. ## symbols declared here.
# Dead code elimination ensures that we don't accidentally generate #includes # 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 const StatHasNanoseconds* = defined(linux) or defined(freebsd) or
defined(osx) or defined(openbsd) or defined(dragonfly) or defined(haiku) ## \ defined(osx) or defined(openbsd) or defined(dragonfly) or defined(haiku) ## \
## Boolean flag that indicates if the system supports nanosecond time ## Boolean flag that indicates if the system supports nanosecond time
## resolution in the fields of ``Stat``. Note that the nanosecond based fields ## 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 ## (`Stat.st_atim`, `Stat.st_mtim` and `Stat.st_ctim`) can be accessed
## without checking this flag, because this module defines fallback procs ## without checking this flag, because this module defines fallback procs
## when they are not available. ## 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 {. proc bindSocket*(a1: SocketHandle, a2: ptr SockAddr, a3: SockLen): cint {.
importc: "bind", header: "<sys/socket.h>".} 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 {. proc connect*(a1: SocketHandle, a2: ptr SockAddr, a3: SockLen): cint {.
importc, header: "<sys/socket.h>".} 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) = template onSignal*(signals: varargs[cint], body: untyped) =
## Setup code to be executed when Unix signals are received. The ## 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. ## scope.
## ##
## Example: ## Example:

4
lib/posix/posix_haiku.nim
View file

@ -58,7 +58,7 @@ type
d_type*: int8 ## Type of file; not supported by all filesystem types. d_type*: int8 ## Type of file; not supported by all filesystem types.
## (not POSIX) ## (not POSIX)
when defined(linux) or defined(openbsd): 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): elif defined(haiku):
d_pino*: Ino ## Parent inode (only for queries) (not POSIX) d_pino*: Ino ## Parent inode (only for queries) (not POSIX)
d_reclen*: cushort ## Length of this record. (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 var SO_REUSEPORT* {.importc, header: "<sys/socket.h>".}: cint
when defined(macosx): 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 # Instead we should use SO_NOSIGPIPE in setsockopt
const const
MSG_NOSIGNAL* = 0'i32 MSG_NOSIGNAL* = 0'i32

4
lib/posix/posix_macos_amd64.nim
View file

@ -45,7 +45,7 @@ type
d_type*: int8 ## Type of file; not supported by all filesystem types. d_type*: int8 ## Type of file; not supported by all filesystem types.
## (not POSIX) ## (not POSIX)
when defined(linux) or defined(openbsd): 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): elif defined(haiku):
d_pino*: Ino ## Parent inode (only for queries) (not POSIX) d_pino*: Ino ## Parent inode (only for queries) (not POSIX)
d_reclen*: cushort ## Length of this record. (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 var SOCK_CLOEXEC* {.importc, header: "<sys/socket.h>".}: cint
when defined(macosx): 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 # Instead we should use SO_NOSIGPIPE in setsockopt
const const
MSG_NOSIGNAL* = 0'i32 MSG_NOSIGNAL* = 0'i32

2
lib/posix/posix_openbsd_amd64.nim
View file

@ -45,7 +45,7 @@ type
d_type*: int8 ## Type of file; not supported by all filesystem types. d_type*: int8 ## Type of file; not supported by all filesystem types.
## (not POSIX) ## (not POSIX)
when defined(linux) or defined(openbsd): 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): elif defined(haiku):
d_pino*: Ino ## Parent inode (only for queries) (not POSIX) d_pino*: Ino ## Parent inode (only for queries) (not POSIX)
d_reclen*: cushort ## Length of this record. (not POSIX) d_reclen*: cushort ## Length of this record. (not POSIX)

4
lib/posix/posix_other.nim
View file

@ -64,7 +64,7 @@ type
d_type*: int8 ## Type of file; not supported by all filesystem types. d_type*: int8 ## Type of file; not supported by all filesystem types.
## (not POSIX) ## (not POSIX)
when defined(linux) or defined(openbsd): 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): elif defined(haiku):
d_pino*: Ino ## Parent inode (only for queries) (not POSIX) d_pino*: Ino ## Parent inode (only for queries) (not POSIX)
d_reclen*: cushort ## Length of this record. (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 var SOCK_CLOEXEC* {.importc, header: "<sys/socket.h>".}: cint
when defined(macosx): 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 # Instead we should use SO_NOSIGPIPE in setsockopt
const const
MSG_NOSIGNAL* = 0'i32 MSG_NOSIGNAL* = 0'i32

10
lib/pure/asyncmacro.nim
View file

@ -146,7 +146,7 @@ template await*[T](f: Future[T]): auto {.used.} =
proc asyncSingleProc(prc: NimNode): NimNode {.compileTime.} = proc asyncSingleProc(prc: NimNode): NimNode {.compileTime.} =
## This macro transforms a single procedure into a closure iterator. ## 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: if prc.kind == nnkProcTy:
result = prc result = prc
if prc[0][0].kind == nnkEmpty: if prc[0][0].kind == nnkEmpty:
@ -320,8 +320,8 @@ proc stripReturnType(returnType: NimNode): NimNode =
proc splitProc(prc: NimNode): (NimNode, NimNode) = proc splitProc(prc: NimNode): (NimNode, NimNode) =
## Takes a procedure definition which takes a generic union of arguments, ## Takes a procedure definition which takes a generic union of arguments,
## for example: proc (socket: Socket | AsyncSocket). ## for example: proc (socket: Socket | AsyncSocket).
## It transforms them so that ``proc (socket: Socket)`` and ## It transforms them so that `proc (socket: Socket)` and
## ``proc (socket: AsyncSocket)`` are returned. ## `proc (socket: AsyncSocket)` are returned.
result[0] = prc.copyNimTree() result[0] = prc.copyNimTree()
# Retrieve the `T` inside `Future[T]`. # Retrieve the `T` inside `Future[T]`.
@ -349,8 +349,8 @@ macro multisync*(prc: untyped): untyped =
## Macro which processes async procedures into both asynchronous and ## Macro which processes async procedures into both asynchronous and
## synchronous procedures. ## synchronous procedures.
## ##
## The generated async procedures use the ``async`` macro, whereas the ## The generated async procedures use the `async` macro, whereas the
## generated synchronous procedures simply strip off the ``await`` calls. ## generated synchronous procedures simply strip off the `await` calls.
let (sync, asyncPrc) = splitProc(prc) let (sync, asyncPrc) = splitProc(prc)
result = newStmtList() result = newStmtList()
result.add(asyncSingleProc(asyncPrc)) result.add(asyncSingleProc(asyncPrc))