compile

const (
	// OpChar matches the single byte B and advances.
	OpChar Op = iota
	// OpFoldChar matches one UTF-8 code point case-insensitively (/i): it decodes
	// the code point at the cursor and accepts it when it is in the same simple
	// -case-folding orbit as Rune, advancing by that code point's byte length. It
	// is rune-aware, like OpUniProp.
	OpFoldChar
	// OpAny matches any byte and advances; unless DotAll is set it excludes
	// '\n' (Ruby's /m option makes the dot match a newline too).
	OpAny
	// OpClass matches a byte in (or, if Negate, not in) Ranges and advances. When
	// Props or RuneRanges is non-empty, or Fold is set, the class is rune-aware: it
	// decodes one UTF-8 code point and tests it against Ranges, RuneRanges and Props
	// before Negate is applied, advancing by the code point's byte length.
	OpClass
	// OpUniProp matches one UTF-8 code point that is a member of (or, if Negate,
	// not a member of) the Unicode property Prop, advancing by its byte length.
	OpUniProp
	// OpSplit forks: try X first, then Y on backtrack (greedy ordering).
	OpSplit
	// OpJmp jumps to X.
	OpJmp
	// OpSave records the current position into capture slot Slot.
	OpSave
	// OpAssertBeginText asserts the start of the input (\A).
	OpAssertBeginText
	// OpAssertEndText asserts the end of the input (\z).
	OpAssertEndText
	// OpAssertEndTextOptNL asserts end of input, allowing one trailing '\n' (\Z).
	OpAssertEndTextOptNL
	// OpAssertBeginLine asserts the start of a line (^).
	OpAssertBeginLine
	// OpAssertEndLine asserts the end of a line ($).
	OpAssertEndLine
	// OpBackref matches the text previously captured by group Slot.
	OpBackref
	// OpCall invokes a subexpression call (\g<…>): it pushes the return address
	// (the pc just past this instruction) onto the VM's call stack and jumps to X,
	// the entry pc of the referenced group's sub-program (group 0's entry is the
	// whole pattern). The called sub-program re-runs and re-captures, and on
	// reaching its closing OpReturn control returns to the saved address.
	OpCall
	// OpReturn ends the callable sub-program of the group whose index it carries in
	// Slot. It completes a \g<…> call only when the active call frame is a call to
	// *this* group (frame.group == Slot): it then pops that frame and jumps to the
	// saved return address. Otherwise — there is no active call, or the active call
	// targets an enclosing group and execution is merely passing linearly through a
	// nested group's terminator — it falls through to the next instruction. Tagging
	// the return with its group index is what lets a nested group's OpReturn be
	// skipped during an outer group's recursive call instead of stealing its frame.
	OpReturn
	// OpAssertPrevMatch asserts the position equals the scan/previous-match start
	// (\G).
	OpAssertPrevMatch
	// OpAssertWordBoundary asserts a word boundary (\b): the position lies between
	// a word character and a non-word character or a string edge. The word-char
	// notion is encoding-dependent and mirrors Onigmo/MRI's \b — a Unicode word
	// code point (\p{Word}) in UTF8 mode, an ASCII word byte ([0-9A-Za-z_]) in
	// ASCII8BIT mode — which the VM evaluates from the bytes surrounding the cursor.
	OpAssertWordBoundary
	// OpAssertNonWordBoundary asserts the complement of OpAssertWordBoundary (\B):
	// the position is NOT a word boundary.
	OpAssertNonWordBoundary
	// OpLook begins a lookaround assertion. Its sub-program is emitted inline
	// immediately after it and is terminated by OpLookEnd; X is the continuation
	// pc just past that OpLookEnd. Negate selects the negative form, Behind the
	// lookbehind form, and Min/Max bound the lookbehind width.
	OpLook
	// OpLookEnd marks a successful run of a lookaround sub-program.
	OpLookEnd
	// OpAtomicBegin opens an atomic (possessive) group (?>…): it records the
	// current backtrack-stack depth so the matching OpAtomicEnd can discard every
	// alternative created while the group's body matched. It is a no-op on input
	// position; only the backtrack stack is touched.
	OpAtomicBegin
	// OpAtomicEnd closes an atomic group: it truncates the backtrack stack back to
	// the depth its OpAtomicBegin recorded, dropping every backtrack point created
	// inside the group. After this the group's sub-match is committed — the engine
	// can never re-enter the body to try a shorter repetition or an alternate
	// sub-match — which is exactly the possessive/atomic barrier.
	OpAtomicEnd
	// OpMatch reports a successful match.
	OpMatch
	// OpLoop is a fused quantifier over a single input-consuming atom (OpChar,
	// OpClass, OpAny, OpUniProp, or OpFoldChar) with no captures or nested
	// branching inside it. It replaces the generic split/atom/jmp loop the compiler
	// would otherwise emit for X{Min,Max} when X is exactly one such atom, so a run
	// like [a-z]+ or .x's dot or \p{L}+ advances in one tight inner loop instead of
	// re-dispatching the outer switch (and touching the memo) per character. The
	// repeated atom is carried inline: Sub names which atom opcode the loop runs,
	// and the atom's own fields (B, Ranges, RuneRanges, Props, Prop, Negate, Fold,
	// DotAll, Rune) are reused on this same Inst to describe it. Min/Max bound the
	// repetition count (Max == -1 is unbounded) and Quant-style Greedy selects the
	// matching preference. X is the continuation pc just past the loop. It produces
	// exactly the same set of matches, in the same leftmost-first order, as the
	// unfused form: greedy consumes the maximal run then gives back one atom at a
	// time on backtrack; lazy consumes the minimum then takes one more atom at a
	// time when forced.
	OpLoop
)