Index
Modules:
regex
,
regex/common
,
regex/compiler
,
regex/dotgraph
,
regex/exptransformation
,
regex/exptype
,
regex/litopt
,
regex/nfa
,
regex/nfafindall
,
regex/nfamacro
,
regex/nfamatch
,
regex/nfatype
,
regex/nodematch
,
regex/nodetype
,
regex/parser
,
regex/scanner
,
regex/types
.
API symbols
`$`:
types: `$`(n: Node): string
`%%`:
common: `%%`(formatstr: string; a: openArray[string]): string
common: `%%`(formatstr: string; a: string): string
`<=`:
common: `<=`(x, y: Rune): bool
`[]`:
nfatype: `[]`(sm: Submatches; i: int): PState
add:
nfatype: add(sm: var Submatches; item: PState)
assertionKind:
nodetype: assertionKind
types: assertionKind
AtomsExp:
exptype: AtomsExp
bounds:
nfafindall: bounds(ms: RegexMatches): Slice[int]
Bounds:
nfatype: Bounds
bwFastRuneAt:
common: bwFastRuneAt(s: string; n: var int; result: var Rune): untyped
bwRuneAt:
common: bwRuneAt(s: string; n: int): Rune
canOpt:
litopt: canOpt(litOpt: LitOpt): bool
cap:
nfatype: cap(sm: Submatches): int
CaptIdx:
nfatype: CaptIdx
CaptNode:
nfatype: CaptNode
Capts:
nfatype: Capts
Captures:
nfatype: Captures
clear:
nfatype: clear(m: var RegexMatch)
nfatype: clear(sm: var Submatches)
cmp:
common: cmp(x, y: Rune): int
constructSubmatches:
nfatype: constructSubmatches(captures: var Captures; capts: Capts; capt, size: int)
contains:
regex: contains(s: string; pattern: Regex): bool
curr:
scanner: curr[T](sc: Scanner[T]): T
dummyMatch:
nfafindall: dummyMatch(ms: var RegexMatches; i: int)
endsWith:
regex: endsWith(s: string; pattern: Regex): bool
eNfa:
nfa: eNfa(exp: RpnExp): Enfa
Enfa:
types: Enfa
eRemoval:
nfa: eRemoval(eNfa: Enfa): Nfa
escapeRe:
regex: escapeRe(s: string): string
Exp:
exptype: Exp
fillMatchImpl:
nfafindall: fillMatchImpl(m: var RegexMatch; mi: MatchItemIdx; ms: RegexMatches; regex: Regex)
find:
regex: find(s: string; pattern: Regex; m: var RegexMatch; start = 0): bool
scanner: find(sc: Scanner[Rune]; r: Rune): int
findAll:
regex: findAll(s: string; pattern: Regex; start = 0): seq[RegexMatch]
regex: findAll(s: string; pattern: Regex; start = 0): RegexMatch
findAllBounds:
regex: findAllBounds(s: string; pattern: Regex; start = 0): seq[Slice[int]]
regex: findAllBounds(s: string; pattern: Regex; start = 0): Slice[int]
findAndCaptureAll:
regex: findAndCaptureAll(s: string; pattern: Regex): seq[string]
findSomeImpl:
nfafindall: findSomeImpl(text: string; regex: Regex; ms: var RegexMatches; start: Natural = 0; flags: set[MatchFlag] = {}): int
findSomeOptImpl:
nfafindall: findSomeOptImpl(text: string; regex: Regex; ms: var RegexMatches; start: Natural): int
finished:
scanner: finished[T](sc: Scanner[T]): bool
Flag:
nodetype: Flag
types: Flag
flagAnyMatchNewLine:
Flag.flagAnyMatchNewLine
Flag.flagAnyMatchNewLine
flagCaseInsensitive:
Flag.flagCaseInsensitive
Flag.flagCaseInsensitive
flagMultiLine:
Flag.flagMultiLine
Flag.flagMultiLine
flagNotAnyMatchNewLine:
Flag.flagNotAnyMatchNewLine
Flag.flagNotAnyMatchNewLine
flagNotCaseInsensitive:
Flag.flagNotCaseInsensitive
Flag.flagNotCaseInsensitive
flagNotMultiLine:
Flag.flagNotMultiLine
Flag.flagNotMultiLine
flagNotUnGreedy:
Flag.flagNotUnGreedy
Flag.flagNotUnGreedy
flagNotUnicode:
Flag.flagNotUnicode
Flag.flagNotUnicode
flagNotVerbose:
Flag.flagNotVerbose
Flag.flagNotVerbose
flagUnGreedy:
Flag.flagUnGreedy
Flag.flagUnGreedy
flagUnicode:
Flag.flagUnicode
Flag.flagUnicode
flagVerbose:
Flag.flagVerbose
Flag.flagVerbose
graph:
dotgraph: graph(nfa: Nfa): string
dotgraph: graph(regex: Regex): string
graphToFile:
dotgraph: graphToFile(regex: Regex; dir: string)
group:
regex: group(m: RegexMatch; i: int): seq[Slice[int]]
regex: group(m: RegexMatch; i: int; text: string): seq[string]
regex: group(m: RegexMatch; s: string): seq[Slice[int]]
regex: group(m: RegexMatch; groupName: string; text: string): seq[string]
regex: group(m: RegexMatch; i: int): Slice[int]
regex: group(m: RegexMatch; s: string): Slice[int]
groupFirstCapture:
regex: groupFirstCapture(m: RegexMatch; i: int; text: string): string
regex: groupFirstCapture(m: RegexMatch; groupName: string; text: string): string
groupKind:
nodetype: groupKind
types: groupKind
groupLastCapture:
regex: groupLastCapture(m: RegexMatch; i: int; text: string): string
regex: groupLastCapture(m: RegexMatch; groupName: string; text: string): string
groupNames:
regex: groupNames(m: RegexMatch): seq[string]
GroupsCapture:
exptransformation: GroupsCapture
groupsCount:
regex: groupsCount(m: RegexMatch): int
groupStartKind:
types: groupStartKind
grow:
nfatype: grow(sm: var SmLookaround)
hasState:
nfatype: hasState(sm: Submatches; n: int16): bool
initEoeNode:
nodetype: initEoeNode(): Node
types: initEoeNode(): Node
initGroupStart:
nodetype: initGroupStart(name: string = ""; flags: seq[Flag] = @[]; isCapturing = true): Node
types: initGroupStart(name: string = ""; flags: seq[Flag] = @[]; isCapturing = true): Node
initJoinerNode:
nodetype: initJoinerNode(): Node
types: initJoinerNode(): Node
initLook:
nfamatch: initLook(): Lookaround
initNotSetNode:
nodetype: initNotSetNode(): Node
types: initNotSetNode(): Node
initSetNode:
nodetype: initSetNode(): Node
types: initSetNode(): Node
initSkipNode:
nodetype: initSkipNode(next: openArray[int16]): Node
types: initSkipNode(next: openArray[int16]): Node
invalidRune:
common: invalidRune
isEmpty:
nodetype: isEmpty(n: Node): bool
types: isEmpty(n: Node): bool
isInitialized:
regex: isInitialized(re: Regex): bool
items:
nfafindall: items(ms: RegexMatches): MatchItemIdx
nfatype: items(sm: Submatches): PState
scanner: items[T](sc: Scanner[T]): T
last:
nfatype: last(sm: var SmLookaround): untyped
lastA:
nfatype: lastA(sm: var SmLookaround): untyped
lastB:
nfatype: lastB(sm: var SmLookaround): untyped
len:
nfatype: len(sm: Submatches): int
lineBreakRune:
common: lineBreakRune
LitOpt:
litopt: LitOpt
litopt2:
litopt: litopt2(exp: RpnExp): LitOpt
lookaheadKind:
types: lookaheadKind
Lookaround:
nfamatch: Lookaround
lookaroundKind:
types: lookaroundKind
lookAroundTpl:
nfamatch: lookAroundTpl(): untyped
lookbehindKind:
types: lookbehindKind
match:
regex: match(s: string; pattern: Regex): bool
regex: match(s: string; pattern: Regex; m: var RegexMatch; start = 0): bool
regex: match(text: string; regex: RegexLit; body: untyped): untyped
nodematch: match(n: Node; r: Rune): bool
nodematch: match(n: Node; r: Rune; nxt: Rune): bool
matchableKind:
nodetype: matchableKind
types: matchableKind
MatchFlag:
nfatype: MatchFlag
MatchFlags:
nfatype: MatchFlags
matchImpl:
nfamacro: matchImpl(text, expLit, body: NimNode): NimNode
nfamatch: matchImpl(text: string; regex: Regex; m: var RegexMatch; start = 0): bool
mfAnchored:
MatchFlag.mfAnchored
mfBwMatch:
MatchFlag.mfBwMatch
mfFindMatch:
MatchFlag.mfFindMatch
mfFindMatchOpt:
MatchFlag.mfFindMatchOpt
mfNoCaptures:
MatchFlag.mfNoCaptures
mfReverseCapts:
MatchFlag.mfReverseCapts
mfShortestMatch:
MatchFlag.mfShortestMatch
mitems:
scanner: mitems[T](sc: var Scanner[T]): var T
newScanner:
scanner: newScanner[T](s: seq[T]): Scanner[T]
newSubmatches:
nfatype: newSubmatches(size: int): Submatches
next:
scanner: next[T](sc: Scanner[T]): T
Nfa:
types: Nfa
nfa2:
nfa: nfa2(exp: RpnExp): Nfa
Node:
nodetype: Node
types: Node
NodeIdx:
nfatype: NodeIdx
NodeKind:
nodetype: NodeKind
types: NodeKind
NodeUid:
nodetype: NodeUid
types: NodeUid
opKind:
nodetype: opKind
types: opKind
parse:
parser: parse(expression: string): Exp
peek:
scanner: peek(sc: Scanner[Node]): Node
scanner: peek(sc: Scanner[Rune]): Rune
scanner: peek(sc: Scanner[Rune]; n: int): Rune
scanner: peek[T](sc: Scanner[T]): (T, T)
prev:
scanner: prev[T](sc: Scanner[T]): T
PState:
nfatype: PState
re:
regex: re(s: static string): static[Regex]
regex: re(s: string): Regex
reAny:
NodeKind.reAny
NodeKind.reAny
reAnyAscii:
NodeKind.reAnyAscii
NodeKind.reAnyAscii
reAnyNl:
NodeKind.reAnyNl
NodeKind.reAnyNl
reAnyNlAscii:
NodeKind.reAnyNlAscii
NodeKind.reAnyNlAscii
reChar:
NodeKind.reChar
NodeKind.reChar
reCharCi:
NodeKind.reCharCi
NodeKind.reCharCi
reCt:
compiler: reCt(s: string): Regex
reDigit:
NodeKind.reDigit
NodeKind.reDigit
reDigitAscii:
NodeKind.reDigitAscii
NodeKind.reDigitAscii
reEnd:
NodeKind.reEnd
NodeKind.reEnd
reEndSym:
NodeKind.reEndSym
NodeKind.reEndSym
reEndSymML:
NodeKind.reEndSymML
NodeKind.reEndSymML
reEoe:
NodeKind.reEoe
NodeKind.reEoe
Regex:
nfatype: Regex
RegexError:
common: RegexError
RegexLit:
nfatype: RegexLit
RegexMatch:
nfatype: RegexMatch
RegexMatches:
nfafindall: RegexMatches
reGroupEnd:
NodeKind.reGroupEnd
NodeKind.reGroupEnd
reGroupStart:
NodeKind.reGroupStart
NodeKind.reGroupStart
reImpl:
compiler: reImpl(s: string): Regex
reInSet:
NodeKind.reInSet
NodeKind.reInSet
reJoiner:
NodeKind.reJoiner
NodeKind.reJoiner
reLookahead:
NodeKind.reLookahead
NodeKind.reLookahead
reLookbehind:
NodeKind.reLookbehind
NodeKind.reLookbehind
removeLast:
nfatype: removeLast(sm: var SmLookaround)
reNotAlphaNum:
NodeKind.reNotAlphaNum
NodeKind.reNotAlphaNum
reNotAlphaNumAscii:
NodeKind.reNotAlphaNumAscii
NodeKind.reNotAlphaNumAscii
reNotDigit:
NodeKind.reNotDigit
NodeKind.reNotDigit
reNotDigitAscii:
NodeKind.reNotDigitAscii
NodeKind.reNotDigitAscii
reNotLookahead:
NodeKind.reNotLookahead
NodeKind.reNotLookahead
reNotLookbehind:
NodeKind.reNotLookbehind
NodeKind.reNotLookbehind
reNotSet:
NodeKind.reNotSet
NodeKind.reNotSet
reNotUCC:
NodeKind.reNotUCC
NodeKind.reNotUCC
reNotWhiteSpace:
NodeKind.reNotWhiteSpace
NodeKind.reNotWhiteSpace
reNotWhiteSpaceAscii:
NodeKind.reNotWhiteSpaceAscii
NodeKind.reNotWhiteSpaceAscii
reNotWordBoundary:
NodeKind.reNotWordBoundary
NodeKind.reNotWordBoundary
reNotWordBoundaryAscii:
NodeKind.reNotWordBoundaryAscii
NodeKind.reNotWordBoundaryAscii
reOneOrMore:
NodeKind.reOneOrMore
NodeKind.reOneOrMore
reOr:
NodeKind.reOr
NodeKind.reOr
repetitionKind:
nodetype: repetitionKind
types: repetitionKind
replace:
regex: replace(s: string; pattern: Regex; by: proc (m: RegexMatch; s: string): string; limit = 0): string
regex: replace(s: string; pattern: Regex; by: string; limit = 0): string
reRepRange:
NodeKind.reRepRange
NodeKind.reRepRange
reSkip:
NodeKind.reSkip
NodeKind.reSkip
reStart:
NodeKind.reStart
NodeKind.reStart
reStartSym:
NodeKind.reStartSym
NodeKind.reStartSym
reStartSymML:
NodeKind.reStartSymML
NodeKind.reStartSymML
reUCC:
NodeKind.reUCC
NodeKind.reUCC
reverse:
nfatype: reverse(capts: var Capts; a, b: int32): int32
reversedMatchImpl:
nfamatch: reversedMatchImpl(smA, smB: var Submatches; text: string; nfa: Nfa; look: var Lookaround; start, limit: int): int
reWhiteSpace:
NodeKind.reWhiteSpace
NodeKind.reWhiteSpace
reWhiteSpaceAscii:
NodeKind.reWhiteSpaceAscii
NodeKind.reWhiteSpaceAscii
reWord:
NodeKind.reWord
NodeKind.reWord
reWordAscii:
NodeKind.reWordAscii
NodeKind.reWordAscii
reWordBoundary:
NodeKind.reWordBoundary
NodeKind.reWordBoundary
reWordBoundaryAscii:
NodeKind.reWordBoundaryAscii
NodeKind.reWordBoundaryAscii
rex:
regex: rex(s: string): RegexLit
reZeroOrMore:
NodeKind.reZeroOrMore
NodeKind.reZeroOrMore
reZeroOrOne:
NodeKind.reZeroOrOne
NodeKind.reZeroOrOne
RpnExp:
types: RpnExp
scan:
scanner: scan[T](s: seq[T]): Scanner[T]
scanner: scan(raw: string): Scanner[Rune]
Scanner:
scanner: Scanner
setLen:
nfatype: setLen(item: var SmLookaroundItem; size: int)
nfatype: setLen(sm: var Submatches; size: int)
shorthandKind:
nodetype: shorthandKind
types: shorthandKind
SmLookaround:
nfatype: SmLookaround
SmLookaroundItem:
nfatype: SmLookaroundItem
split:
regex: split(s: string; sep: Regex): seq[string]
regex: split(s: string; sep: Regex): string
splitIncl:
regex: splitIncl(s: string; sep: Regex): seq[string]
startsWith:
regex: startsWith(s: string; pattern: Regex; start = 0): bool
startsWithImpl:
nfamatch: startsWithImpl(text: string; regex: Regex; start: int): bool
SubExp:
types: SubExp
subExps:
nfa: subExps(exp: RpnExp): RpnExp
Submatches:
nfatype: Submatches
swapCase:
nodematch: swapCase(r: Rune): Rune
toAtoms:
exptransformation: toAtoms(exp: Exp; groups: var GroupsCapture): AtomsExp
toCharNode:
nodetype: toCharNode(r: Rune): Node
types: toCharNode(r: Rune): Node
toPattern:
regex: toPattern(s: string): Regex
toRune:
common: toRune(s: string): Rune
toString:
nodetype: toString(n: Node): string
nodetype: toString(n: seq[Node]): string
types: toString(n: seq[Node]): string
transformExp:
exptransformation: transformExp(exp: Exp; groups: var GroupsCapture): RpnExp
Transitions:
types: Transitions
TransitionsAll:
types: TransitionsAll
ZclosureStates:
types: ZclosureStates