Module parseutils

This module contains helpers for parsing tokens, numbers, identifiers, etc.

Types

TInterpolatedKind* = enum 
  ikStr,                      ## ``str`` part of the interpolated string
  ikDollar,                   ## escaped ``$`` part of the interpolated string
  ikVar,                      ## ``var`` part of the interpolated string
  ikExpr                      ## ``expr`` part of the interpolated string
describes for interpolatedFragments which part of the interpolated string is yielded; for example in "str$$$var${expr}"

Procs

proc parseHex*(s: string; number: var int; start = 0): int {.rtl, 
    extern: "npuParseHex", noSideEffect.}
parses a hexadecimal number and stores its value in number. Returns the number of the parsed characters or 0 in case of an error.
proc parseOct*(s: string; number: var int; start = 0): int {.rtl, 
    extern: "npuParseOct", noSideEffect.}
parses an octal number and stores its value in number. Returns the number of the parsed characters or 0 in case of an error.
proc parseIdent*(s: string; ident: var string; start = 0): int
parses an identifier and stores it in ident. Returns the number of the parsed characters or 0 in case of an error.
proc parseIdent*(s: string; start = 0): string
parses an identifier and stores it in ident. Returns the parsed identifier or an empty string in case of an error.
proc parseToken*(s: string; token: var string; validChars: set[char]; start = 0): int {.
    inline, deprecated.}

parses a token and stores it in token. Returns the number of the parsed characters or 0 in case of an error. A token consists of the characters in validChars.

Deprecated since version 0.8.12: Use parseWhile instead.

proc skipWhitespace*(s: string; start = 0): int {.inline.}
skips the whitespace starting at s[start]. Returns the number of skipped characters.
proc skip*(s, token: string; start = 0): int {.inline.}
skips the token starting at s[start]. Returns the length of token or 0 if there was no token at s[start].
proc skipIgnoreCase*(s, token: string; start = 0): int
same as skip but case is ignored for token matching.
proc skipUntil*(s: string; until: set[char]; start = 0): int {.inline.}
Skips all characters until one char from the set until is found or the end is reached. Returns number of characters skipped.
proc skipUntil*(s: string; until: char; start = 0): int {.inline.}
Skips all characters until the char until is found or the end is reached. Returns number of characters skipped.
proc skipWhile*(s: string; toSkip: set[char]; start = 0): int {.inline.}
Skips all characters while one char from the set token is found. Returns number of characters skipped.
proc parseUntil*(s: string; token: var string; until: set[char]; start = 0): int {.
    inline.}
parses a token and stores it in token. Returns the number of the parsed characters or 0 in case of an error. A token consists of the characters notin until.
proc parseUntil*(s: string; token: var string; until: char; start = 0): int {.
    inline.}
parses a token and stores it in token. Returns the number of the parsed characters or 0 in case of an error. A token consists of any character that is not the until character.
proc parseWhile*(s: string; token: var string; validChars: set[char]; start = 0): int {.
    inline.}
parses a token and stores it in token. Returns the number of the parsed characters or 0 in case of an error. A token consists of the characters in validChars.
proc captureBetween*(s: string; first: char; second = '\0'; start = 0): string
Finds the first occurence of first, then returns everything from there up to second``(if ``second is '0', then first is used).
proc parseBiggestInt*(s: string; number: var biggestInt; start = 0): int {.rtl, 
    extern: "npuParseBiggestInt", noSideEffect.}
parses an integer starting at start and stores the value into number. Result is the number of processed chars or 0 if there is no integer. EOverflow is raised if an overflow occurs.
proc parseInt*(s: string; number: var int; start = 0): int {.rtl, 
    extern: "npuParseInt", noSideEffect.}
parses an integer starting at start and stores the value into number. Result is the number of processed chars or 0 if there is no integer. EOverflow is raised if an overflow occurs.
proc parseBiggestFloat*(s: string; number: var biggestFloat; start = 0): int {.
    rtl, extern: "npuParseBiggestFloat", noSideEffect.}
parses a float starting at start and stores the value into number. Result is the number of processed chars or 0 if there occured a parsing error.
proc parseFloat*(s: string; number: var float; start = 0): int {.rtl, 
    extern: "npuParseFloat", noSideEffect.}
parses a float starting at start and stores the value into number. Result is the number of processed chars or 0 if there occured a parsing error.

Iterators

iterator interpolatedFragments*(s: string): tuple[kind: TInterpolatedKind, 
    value: string]

Tokenizes the string s into substrings for interpolation purposes.

Example:

for k, v in interpolatedFragments("  $this is ${an  example}  $$"):
  echo "(", k, ", \"", v, "\")"

Results in:

(ikString, "  ")
(ikExpr, "this")
(ikString, " is ")
(ikExpr, "an  example")
(ikString, "  ")
(ikDollar, "$")
Generated: 2012-09-23 21:47:54 UTC