** And predicate ** optimization: fixedlen(p) = n ==> <&p> == <p>; behind n ** (valid only when 'p' has no captures) */

** <behind(p)> == behind n; <p> (where n = fixedlen(p)) */

** Captures: if pattern has fixed (and not too big) length, and it ** has no nested captures, use a single IFullCapture instruction ** after the match

** Code an IChar instruction, or IAny if there is an equivalent ** test dominating it */

** Code a char set, using IAny when instruction is dominated by an ** equivalent test. */

** Choice; optimizations: ** - when p1 is headfail or when first(p1) and first(p2) are disjoint, ** than a character not in first(p1) cannot go to p1

** Code for a grammar: ** call L1; jmp L2; L1: rule 1; ret; rule 2; ret; ...; L2: */

** Not predicate; optimizations: ** In any case, if first test fails, 'not' succeeds, so it can jump to ** the end. If pattern is headfail, that is al

** Repetion; optimizations: ** When pattern is a charset, use special code. ** When pattern is head fail, or if it starts with characters that ** are

** Try repetition of charsets: ** For an empty set, repetition of fail is a no-op; ** For any or char, code a tight loop; ** For generic charset, use

** Code first child of a sequence ** (second child is called in-place to allow tail call) ** Return 'tt' for second child */

** traverse grammar at index 'arg', pushing all its keys and patterns ** into the stack. Create a new table (before all pairs key-pattern) to ** colle

The commit and parents parameters represent the current row. The mParents member represents the next row after this one.

** Compile a pattern. 'size' is the size of the pattern's tree, ** which gives a hint for the size of the final code. */

agent availability hook

** Transform left associative constructions into right ** associative ones, for sequence and choice; that is: ** (t11 + t12) + t2 => t11 + (t12 + t2

** change open calls to calls, using list 'positions' to find ** correct offsets; also optimize tail calls */

** A few basic operations on Charsets */

** Check whether charset 'info' is dominated by instruction 'p' */

! * \brief DiffView::fetchMore * Fetch maxNewFiles more patches * use a while loop with canFetchMore() to get all */

** Try to find a named group capture with the name given at the top of ** the stack; goes backward from 'ref'. */

** Find the corresponding 'open' capture before 'cap', when that capture ** can become a full capture. If a full capture c1 is followed by an ** empty

** Fix a TOpenCall into a TCall node, using table 'postable' to ** translate a key to its rule address in the tree. Raises an ** error if key does not

** Fold capture */

Watch subdirs.

** Function capture */

** Prepare a CapState structure and traverse the entire list of ** captures in the stack pushing its results. 's' is the subject ** string, 'r' is the

** push on the stack the index and the pattern for the ** initial rule of grammar at index 'arg' in the stack; ** also add that index into position ta

** Collect values from current capture into array 'cps'. Current ** capture must be Cstring (first call) or Csimple (recursive calls). ** (In first ca