// Character class operators are listed simplest to most complex
// (OpLiteral, OpCharClass, OpAnyCharNotNL, OpAnyChar).

const (
	OpNoMatch        Op = 1 + iota // matches no strings
	OpEmptyMatch                   // matches empty string
	OpLiteral                      // matches Runes sequence
	OpCharClass                    // matches Runes interpreted as range pair list

	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[OpNoMatch-1]
	_ = x[OpEmptyMatch-2]
	_ = x[OpLiteral-3]
	_ = x[OpCharClass-4]
	_ = x[OpAnyCharNotNL-5]
	_ = x[OpAnyChar-6]
	_ = x[OpBeginLine-7]
	_ = x[OpEndLine-8]
	_ = x[OpBeginText-9]
	_ = x[OpEndText-10]
	_ = x[OpWordBoundary-11]
	_ = x[OpNoWordBoundary-12]
	_ = x[OpCapture-13]

func dump(re *Regexp) string {
	var b strings.Builder
	dumpRegexp(&b, re)
	return b.String()
}

var opNames = []string{
	OpNoMatch:        "no",
	OpEmptyMatch:     "emp",
	OpLiteral:        "lit",
	OpCharClass:      "cc",
	OpAnyCharNotNL:   "dnl",
	OpAnyChar:        "dot",
	OpBeginLine:      "bol",
	OpEndLine:        "eol",
	OpBeginText:      "bot",
	OpEndText:        "eot",
	OpWordBoundary:   "wb",

func (p *parser) push(re *Regexp) *Regexp {
	p.numRunes += len(re.Rune)
	if re.Op == OpCharClass && len(re.Rune) == 2 && re.Rune[0] == re.Rune[1] {
		// Single rune.
		if p.maybeConcat(re.Rune[0], p.flags&^FoldCase) {
			return nil
		}
		re.Op = OpLiteral
		re.Rune = re.Rune[:1]
		re.Flags = p.flags &^ FoldCase
	} else if re.Op == OpCharClass && len(re.Rune) == 4 &&
		re.Rune[0] == re.Rune[1] && re.Rune[2] == re.Rune[3] &&

		}
		var f frag
		for j := range re.Rune {
			f1 := c.rune(re.Rune[j:j+1], re.Flags)
			if j == 0 {
				f = f1
			} else {
				f = c.cat(f, f1)
			}
		}
		return f
	case OpCharClass:
		return c.rune(re.Rune, re.Flags)
	case OpAnyCharNotNL:
		return c.rune(anyRuneNotNL, 0)
	case OpAnyChar:
		return c.rune(anyRune, 0)
	case OpBeginLine:
		return c.empty(EmptyBeginLine)

// minInputLen walks the regexp to find the minimum length of any matchable input.
func minInputLen(re *syntax.Regexp) int {
	switch re.Op {
	default:
		return 0
	case syntax.OpAnyChar, syntax.OpAnyCharNotNL, syntax.OpCharClass:
		return 1
	case syntax.OpLiteral:
		l := 0
		for _, r := range re.Rune {
			if r == utf8.RuneError {
				l++
			} else {
				l += utf8.RuneLen(r)
			}
		}
		return l

		{"Op", Type, 0},
		{"OpAlternate", Const, 0},
		{"OpAnyChar", Const, 0},
		{"OpAnyCharNotNL", Const, 0},
		{"OpBeginLine", Const, 0},
		{"OpBeginText", Const, 0},
		{"OpCapture", Const, 0},
		{"OpCharClass", Const, 0},
		{"OpConcat", Const, 0},
		{"OpEmptyMatch", Const, 0},
		{"OpEndLine", Const, 0},
		{"OpEndText", Const, 0},
		{"OpLiteral", Const, 0},
		{"OpNoMatch", Const, 0},

pkg regexp/syntax, const OpAnyCharNotNL Op
pkg regexp/syntax, const OpBeginLine Op
pkg regexp/syntax, const OpBeginText Op
pkg regexp/syntax, const OpCapture Op
pkg regexp/syntax, const OpCharClass Op
pkg regexp/syntax, const OpConcat Op
pkg regexp/syntax, const OpEmptyMatch Op
pkg regexp/syntax, const OpEndLine Op
pkg regexp/syntax, const OpEndText Op
pkg regexp/syntax, const OpLiteral Op

pkg regexp/syntax, const OpAnyCharNotNL = 5
pkg regexp/syntax, const OpBeginLine = 7
pkg regexp/syntax, const OpBeginText = 9
pkg regexp/syntax, const OpCapture = 13
pkg regexp/syntax, const OpCharClass = 4
pkg regexp/syntax, const OpConcat = 18
pkg regexp/syntax, const OpEmptyMatch = 2
pkg regexp/syntax, const OpEndLine = 8
pkg regexp/syntax, const OpEndText = 10
pkg regexp/syntax, const OpLiteral = 3