Index

Modules: regex, regex/common, regex/compiler, regex/dotgraph, regex/exptransformation, regex/exptype, regex/litopt, regex/nfa, regex/nfafindall, regex/nfafindall2, regex/nfamacro, regex/nfamatch, regex/nfamatch2, regex/nfatype, regex/nodematch, 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: `[]`(capts: Capts3; i, j: Natural): Slice[int]
• nfatype: `[]`(capts: var Capts3; i, j: Natural): var Slice[int]
• nfatype: `[]`(sm: Submatches; i: int): PState

add:

• common: add[T](s: var SortedSeq[T]; x: openArray[T])
• nfatype: add(sm: var Submatches; item: PState)

assertionKind:

• types: assertionKind

AtomsExp:

• exptype: AtomsExp

bounds:

• nfafindall: bounds(ms: RegexMatches): Slice[int]
• nfafindall2: bounds(ms: RegexMatches2): 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

Capts3:

• nfatype: Capts3

CaptState:

• nfatype: CaptState

Captures:

• nfatype: Captures

clear:

• nfatype: clear(capts: var Capts3)
• nfatype: clear(m: var RegexMatch)
• nfatype: clear(m: var RegexMatch2)
• 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
• regex: contains(s: string; pattern: Regex2): bool
• common: contains[T](s: SortedSeq[T]; x: T): bool

curr:

• scanner: curr[T](sc: Scanner[T]): T

diverge:

• nfatype: diverge(capts: var Capts3; captIdx: CaptIdx): CaptIdx

dummyMatch:

• nfafindall: dummyMatch(ms: var RegexMatches; i: int)
• nfafindall2: dummyMatch(ms: var RegexMatches2; i: int)

endsWith:

• regex: endsWith(s: string; pattern: Regex): bool
• regex: endsWith(s: string; pattern: Regex2): bool

eNfa:

• nfa: eNfa(exp: RpnExp): Enfa

Enfa:

• types: Enfa

epsilonMatch:

• nfamatch2: epsilonMatch(matched: var bool; captx: var CaptIdx; capts: var Capts3; look: var Lookaround; ntn: Node; text: string; i: int; cPrev: int32; c: Rune; flags: MatchFlags; bwMatch = false)

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)
• nfafindall2: fillMatchImpl(m: var RegexMatch2; mi: MatchItemIdx; ms: RegexMatches2; regex: Regex)

find:

• regex: find(s: string; pattern: Regex; m: var RegexMatch; start = 0): bool
• regex: find(s: string; pattern: Regex2; m: var RegexMatch2; 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: Regex2; start = 0): seq[RegexMatch2]
• regex: findAll(s: string; pattern: Regex; start = 0): RegexMatch
• regex: findAll(s: string; pattern: Regex2; start = 0): RegexMatch2

findAllBounds:

• regex: findAllBounds(s: string; pattern: Regex; start = 0): seq[Slice[int]]
• regex: findAllBounds(s: string; pattern: Regex2; start = 0): seq[Slice[int]]
• regex: findAllBounds(s: string; pattern: Regex; start = 0): Slice[int]
• regex: findAllBounds(s: string; pattern: Regex2; 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
• nfafindall2: findSomeImpl(text: string; regex: Regex; ms: var RegexMatches2; start: Natural = 0; flags: MatchFlags = {}): int

findSomeOptImpl:

• nfafindall: findSomeOptImpl(text: string; regex: Regex; ms: var RegexMatches; start: Natural): int
• nfafindall2: findSomeOptImpl(text: string; regex: Regex; ms: var RegexMatches2; start: Natural; flags: MatchFlags = {}): int

finished:

• scanner: finished[T](sc: Scanner[T]): bool

Flag:

• types: Flag

flagAnyMatchNewLine:

• Flag.flagAnyMatchNewLine

flagCaseInsensitive:

• Flag.flagCaseInsensitive

flagMultiLine:

• Flag.flagMultiLine

flagNotAnyMatchNewLine:

• Flag.flagNotAnyMatchNewLine

flagNotCaseInsensitive:

• Flag.flagNotCaseInsensitive

flagNotMultiLine:

• Flag.flagNotMultiLine

flagNotUnGreedy:

• Flag.flagNotUnGreedy

flagNotUnicode:

• Flag.flagNotUnicode

flagNotVerbose:

• Flag.flagNotVerbose

flagUnGreedy:

• Flag.flagUnGreedy

flagUnicode:

• Flag.flagUnicode

flagVerbose:

• Flag.flagVerbose

freeze:

• nfatype: freeze(capts: var Capts3): CaptState

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: RegexMatch2; i: int): Slice[int]
• regex: group(m: RegexMatch2; s: string): Slice[int]
• 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:

• 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]
• regex: groupNames(m: RegexMatch2): seq[string]

GroupsCapture:

• exptransformation: GroupsCapture

groupsCount:

• regex: groupsCount(m: RegexMatch): int
• regex: groupsCount(m: RegexMatch2): int

groupStartKind:

• types: groupStartKind

grow:

• nfatype: grow(sm: var SmLookaround)

hasState:

• nfatype: hasState(sm: Submatches; n: int16): bool

initCapts3:

• nfatype: initCapts3(groupsLen: int): Capts3

initEoeNode:

• types: initEoeNode(): Node

initGroupStart:

• types: initGroupStart(name: string = ""; flags: seq[Flag] = @[]; isCapturing = true): Node

initJoinerNode:

• types: initJoinerNode(): Node

initLook:

• nfamatch: initLook(): Lookaround
• nfamatch2: initLook(): Lookaround

initNotSetNode:

• types: initNotSetNode(): Node

initSetNode:

• types: initSetNode(): Node

initSkipNode:

• types: initSkipNode(): Node
• types: initSkipNode(next: openArray[int16]): Node

initSortedSeq:

• common: initSortedSeq[T](): SortedSeq[T]

invalidRune:

• common: invalidRune

isEmpty:

• types: isEmpty(n: Node): bool

isEpsilonTransition:

• types: isEpsilonTransition(n: Node): bool

isInitialized:

• regex: isInitialized(re: Regex): bool
• regex: isInitialized(re: Regex2): bool

items:

• common: items[T](s: SortedSeq[T]): T
• nfafindall: items(ms: RegexMatches): MatchItemIdx
• nfafindall2: items(ms: RegexMatches2): MatchItemIdx
• nfatype: items(sm: Submatches): PState
• scanner: items[T](sc: Scanner[T]): T

keepAlive:

• nfatype: keepAlive(capts: var Capts3; captIdx: CaptIdx)

last:

• nfatype: last(sm: SmLookaround): untyped

lastA:

• nfatype: lastA(sm: SmLookaround): untyped

lastB:

• nfatype: lastB(sm: SmLookaround): untyped

len:

• common: len[T](s: SortedSeq[T]): int
• nfatype: len(sm: Submatches): int

lineBreakRune:

• common: lineBreakRune

LitOpt:

• litopt: LitOpt

litopt3:

• litopt: litopt3(exp: RpnExp; flags: RegexFlags = {}): LitOpt

lookaheadKind:

• types: lookaheadKind

Lookaround:

• nfamatch: Lookaround
• nfamatch2: 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(s: string; pattern: Regex2): bool
• regex: match(s: string; pattern: Regex2; m: var RegexMatch2; 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:

• 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
• nfamatch2: matchImpl(text: string; regex: Regex; m: var RegexMatch2; start = 0; flags: MatchFlags = {}): bool

mfAnchored:

• MatchFlag.mfAnchored

mfBwMatch:

• MatchFlag.mfBwMatch

mfBytesInput:

• MatchFlag.mfBytesInput

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:

• types: Node

NodeIdx:

• nfatype: NodeIdx

NodeKind:

• types: NodeKind

NodeUid:

• types: NodeUid

nonCapture:

• nfatype: nonCapture

notRecyclable:

• nfatype: notRecyclable(capts: var Capts3; captIdx: CaptIdx)

opKind:

• types: opKind

parse:

• parser: parse(expression: string; flags: RegexFlags = {}): 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

re2:

• regex: re2(s: static string; flags: static RegexFlags = {}): static[Regex2]
• regex: re2(s: string; flags: RegexFlags = {}): Regex2

reAny:

• NodeKind.reAny

reAnyNl:

• NodeKind.reAnyNl

reChar:

• NodeKind.reChar

reCharCi:

• NodeKind.reCharCi

reCt:

• compiler: reCt(s: string; flags: RegexFlags = {}): Regex

recyclable:

• nfatype: recyclable(capts: var Capts3; captIdx: CaptIdx)

recycle:

• nfatype: recycle(capts: var Capts3)

reDigit:

• NodeKind.reDigit

reDigitAscii:

• NodeKind.reDigitAscii

reEnd:

• NodeKind.reEnd

reEndSym:

• NodeKind.reEndSym

reEndSymML:

• NodeKind.reEndSymML

reEoe:

• NodeKind.reEoe

reFlags:

• NodeKind.reFlags

Regex:

• nfatype: Regex

Regex2:

• nfatype: Regex2

regexArbitraryBytes:

• RegexFlag.regexArbitraryBytes

regexAscii:

• RegexFlag.regexAscii

regexCaseless:

• RegexFlag.regexCaseless

regexDotAll:

• RegexFlag.regexDotAll

RegexError:

• common: RegexError

regexExtended:

• RegexFlag.regexExtended

RegexFlag:

• types: RegexFlag

RegexFlags:

• types: RegexFlags

RegexLit:

• nfatype: RegexLit

RegexMatch:

• nfatype: RegexMatch

RegexMatch2:

• nfatype: RegexMatch2

RegexMatches:

• nfafindall: RegexMatches

RegexMatches2:

• nfafindall2: RegexMatches2

regexMultiline:

• RegexFlag.regexMultiline

regexUngreedy:

• RegexFlag.regexUngreedy

reGroupEnd:

• NodeKind.reGroupEnd

reGroupStart:

• NodeKind.reGroupStart

reImpl:

• compiler: reImpl(s: string; flags: RegexFlags = {}): Regex

reInSet:

• NodeKind.reInSet

reJoiner:

• NodeKind.reJoiner

reLookahead:

• NodeKind.reLookahead

reLookbehind:

• NodeKind.reLookbehind

removeLast:

• nfatype: removeLast(sm: var SmLookaround)

reNonCapture:

• regex: reNonCapture

reNotAlphaNum:

• NodeKind.reNotAlphaNum

reNotAlphaNumAscii:

• NodeKind.reNotAlphaNumAscii

reNotDigit:

• NodeKind.reNotDigit

reNotDigitAscii:

• NodeKind.reNotDigitAscii

reNotLookahead:

• NodeKind.reNotLookahead

reNotLookbehind:

• NodeKind.reNotLookbehind

reNotSet:

• NodeKind.reNotSet

reNotUCC:

• NodeKind.reNotUCC

reNotWhiteSpace:

• NodeKind.reNotWhiteSpace

reNotWhiteSpaceAscii:

• NodeKind.reNotWhiteSpaceAscii

reNotWordBoundary:

• NodeKind.reNotWordBoundary

reNotWordBoundaryAscii:

• NodeKind.reNotWordBoundaryAscii

reOneOrMore:

• NodeKind.reOneOrMore

reOr:

• NodeKind.reOr

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
• regex: replace(s: string; pattern: Regex2; by: proc (m: RegexMatch2; s: string): string; limit = 0): string
• regex: replace(s: string; pattern: Regex2; by: string; limit = 0): string

reRepRange:

• NodeKind.reRepRange

reSkip:

• NodeKind.reSkip

reStart:

• NodeKind.reStart

reStartSym:

• NodeKind.reStartSym

reStartSymML:

• NodeKind.reStartSymML

reUCC:

• NodeKind.reUCC

reverse:

• nfatype: reverse(capts: var Capts; a, b: CaptIdx): CaptIdx

reversedMatchImpl:

• nfamatch: reversedMatchImpl(smA, smB: var Submatches; text: string; nfa: Nfa; look: var Lookaround; start, limit: int): int
• nfamatch2: reversedMatchImpl(smA, smB: var Submatches; text: string; nfa: Nfa; look: var Lookaround; groupsLen: int; start, limit: int; flags: MatchFlags = {}): int

reWhiteSpace:

• NodeKind.reWhiteSpace

reWhiteSpaceAscii:

• NodeKind.reWhiteSpaceAscii

reWord:

• NodeKind.reWord

reWordAscii:

• NodeKind.reWordAscii

reWordBoundary:

• NodeKind.reWordBoundary

reWordBoundaryAscii:

• NodeKind.reWordBoundaryAscii

rex:

• regex: rex(s: string): RegexLit

reZeroOrMore:

• NodeKind.reZeroOrMore

reZeroOrOne:

• NodeKind.reZeroOrOne

RpnExp:

• types: RpnExp

scan:

• scanner: scan[T](s: seq[T]): Scanner[T]
• scanner: scan(raw: string; bytesMode = false): Scanner[Rune]

Scanner:

• scanner: Scanner

setLen:

• nfatype: setLen(item: var SmLookaroundItem; size: int)
• nfatype: setLen(sm: var Submatches; size: int)

shorthandKind:

• types: shorthandKind

SmLookaround:

• nfatype: SmLookaround

SmLookaroundItem:

• nfatype: SmLookaroundItem

SortedSeq:

• common: SortedSeq

split:

• regex: split(s: string; sep: Regex): seq[string]
• regex: split(s: string; sep: Regex2): seq[string]
• regex: split(s: string; sep: Regex): string
• regex: split(s: string; sep: Regex2): string

splitIncl:

• regex: splitIncl(s: string; sep: Regex): seq[string]
• regex: splitIncl(s: string; sep: Regex2): seq[string]

startsWith:

• regex: startsWith(s: string; pattern: Regex; start = 0): bool
• regex: startsWith(s: string; pattern: Regex2; start = 0): bool

startsWithImpl:

• nfamatch: startsWithImpl(text: string; regex: Regex; start: int): bool

startsWithImpl2:

• nfamatch2: startsWithImpl2(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; flags: RegexFlags = {}): AtomsExp

toCharNode:

• types: toCharNode(r: Rune): Node

toFlag:

• types: toFlag(fl: RegexFlag): Flag

toFlags:

• types: toFlags(fls: RegexFlags): set[Flag]

toFlagsSeq:

• types: toFlagsSeq(fls: RegexFlags): seq[Flag]

toMatchFlags:

• nfatype: toMatchFlags(f: RegexFlags): MatchFlags

toPattern:

• regex: toPattern(s: string): Regex

toRegex:

• nfatype: toRegex(r): untyped

toRegex2:

• nfatype: toRegex2(r): untyped

toRune:

• common: toRune(c: char): Rune

toString:

• types: toString(n: seq[Node]): string

transformExp:

• exptransformation: transformExp(exp: Exp; groups: var GroupsCapture; flags: RegexFlags = {}): RpnExp

unfreeze:

• nfatype: unfreeze(capts: var Capts3; freezeId: CaptState)

verifyUtf8:

• common: verifyUtf8(s: string): int