Remember the pushed state (in response to a ')')

This is the pop.

Remove a number from the longjump unrolling stack

Remove the starting text from the one or multi node. This may end up changing the type of the node to be Empty if the starting text matches the node'

We also use a stack of RegexFC objects. This is the push.

Push the parser state (in response to an open paren)

To avoid recursion, we use a simple integer stack. This is the push.

Basic optimization. Single-letter alternations can be replaced by faster set specifications, and nested alternations with no intervening operators can

Remove unnecessary atomic nodes, and make appropriate descendents of the atomic node themselves atomic. e.g. (?>(?>(?>a*))) => (?>a*) e.g. (?>(abc*)*)

Optimizations for backreference conditionals.

Combine adjacent loops. e.g. a*a*a* => a* e.g. a+ab => a{2,}b

Basic optimization. Adjacent strings can be concatenated. (?:abc)(?:def) -> abcdef

<summary>Optimizations for expression conditionals.</summary>

<summary>Optimizations for positive and negative lookaheads/behinds.</summary>

Nested repeaters just get multiplied with each other if they're not too lumpy

Simple optimization. If a set is a singleton, an inverse singleton, or empty, it's transformed accordingly.

* * The main FC computation. It does a shortcutted depth-first walk * through the tree and calls CalculateFC to emits code before * and after each

Nonpublic builder: removes a group match by capnum

Removes unnecessary Empty and Nothing nodes from the alternation. A Nothing will never match, so it can be removed entirely, and an Empty can be remov

repeat the rune r, c times... up to the max of MaxPrefixSize

Given a Match, emits into the StringBuilder the evaluated substitution pattern.

Scans \-style backreferences and character escapes

Grabs and converts an ascii control character

* * Scans $ patterns recognized within replacement patterns */

scanGroupOpen scans chars following a '(' (not counting the '('), and returns a RegexNode for the type of group scanned, or nil if the group simply ch

Scans up to three octal digits (stops before exceeding 0377).

Scans up to three octal digits (stops before exceeding 0377).

* * Simple parsing for replacement patterns */

Returns an index in the set table for a charset uses a map to eliminate duplicates.

Called in Beforechild to prevent further processing of the current child

Technically we are actually peeking at items already popped. So if you want to get and pop the top item from the stack, you do r.stackPop(); r.stackP

get the ith element down on the grouping stack

pop framesize items from the grouping stack

Push onto the grouping stack

Start a new round for the parser state (in response to an open paren or string start)

stop the timeout clock in the background should only used for unit tests to abandon the background goroutine

Returns an index in the string table for a string. uses a map to eliminate duplicates.

This is the top.

Technically we are actually peeking at items already popped. So if you want to get and pop the top item from the stack, you do r.trackPop(); r.trackP

get the ith element down on the backtracking stack

pop framesize items from the backtracking stack