bend-kit-regex

Releases (10)

• 0.8.0.0 indexed
• 0.7.0.0 unindexed
• 0.6.0.4 unindexed
• 0.6.0.3 unindexed
• 0.6.0.2 unindexed
• 0.6.0.0 unindexed
• 0.5.0.0 unindexed
• 0.4.0.0 unindexed
• 0.3.0.0 unindexed
• 0.2.1.0 unindexed

Definitions (316)

regex.bend

• type ItemA set member: a code point range, or a Unicode general category ("L", "Lu", ...).
• type NodeAssertion kinds: 0 start of text, 1 end of text, 2 word boundary, 3 not a word boundary.
• type Tok
• def lit
• def is_digit
• def is_word
• def is_alnum
• def perl.d\d \w \s are ASCII, as in RE2.
• def perl.D
• def perl.w
• def perl.W
• def perl.s
• def perl.S
• def cats
• type Esc
• def prop.if
• def prop.ok
• def prop.name
• def prop\pL or \p{Lu}; \P negates.
• def esc.otherAn escaped letter or digit with no meaning is an error, as in RE2.
• def escThe text after a backslash.
• type Cs
• def class.range
• def class.hi
• def class.loc is one member; a "-" and a code point after it make a range.
• def class.esc
• def class.stepA "]" right after "[" or "[^" is a member.
• def class.runfuel: every step eats at least one char.
• def class
• type Lx
• type NumA run of decimal digits: its value (capped at 100000), its length, and the rest.
• def num.add
• def num.go
• def num
• def lex.repA trailing "?" makes a repetition lazy.
• def Num.n
• def lex.brace.maxA "{" that does not start {n}, {n,} or {n,m} is a literal, as in RE2.
• def lex.brace.min
• def lex.class
• def lex.esc
• def lex.step
• def lexfuel: every step but the last eats at least one char.
• type FrameAn open group: its capture index (None for (?:...)), and the enclosing alternatives and sequence.
• type Psn: the next capture index.
• def cat
• def seq.go
• def seq
• def alt.go
• def group
• def rep.copies
• def rep.opt
• def rep.infx* is (x+)?, so an empty x cannot loop; x{n,} is n-1 copies then x+; x{n,m} is n copies then (x(x...)?)?, as RE2 builds them.
• def rep.fin
• def rep
• def rep.okCounts go up to 1000, and a repetition cannot repeat, as in RE2.
• def parse.rep
• def parse.open
• def parse.close
• def parse.tok
• def parse.step
• def parse
• type Inst
• def required.rightA byte that every match must contain.
• def required
• def required.join
• def required.prefixThe first iteration contains the selected literal; every occurrence is inspected.
• def reverse.ok
• def reverse.node
• def size
• def emitThe instructions of n, placed at pc, in front of rest.
• type TrieA binary trie keyed by n >= 1: the path is the bits of n below its top bit, low bit first, so key n costs log2(n) steps and small keys stay near the root.
• def trie.gethere: n is 1.
• def trie.putfuel: a U32 key has at most 32 bits.
• def trie.atThe value at key k, stored as n = k + 1.
• def trie.set
• def trie.from
• type FsThe walk from pc 0 over the instructions that consume no char: the sets it reaches, or FsAny when it reaches an assertion or a match, so that any char may start a match.
• def first.inst
• def first.seen
• def firstfuel: each pc expands once and pushes at most two pcs.
• type EwBit-parallel NFA for is_match: bit pc stands for the set at pc, waiting on the next char.
• def eps.ctx
• def eps.assert
• def eps.inst
• def eps.seen
• def eps.gofuel: each pc expands once and pushes at most two pcs.
• def eps
• def Ew.mask
• def Ew.hit
• type BitThe set at bit mask; follow: the sets live after it takes a char; fin, end: whether the match is then reached inside the text, or at its end.
• type Bitsat0: the sets live at the start of the text, and hit0 whether the empty match is there; hit01 the same for the empty text; atn and hitn the same inside the text, hit1 at its end.
• def bits.set
• def bits.sets
• def bits.plainWord boundaries depend on the chars on both sides, which one mask per set cannot track.
• def bits.if
• def bits
• def item.has
• def items.has
• def starts
• type AscThe ASCII bytes that may start a match, one bit per byte, 32 to a word.