regexp/syntax.Regexp.Op (field)

80 uses

	regexp/syntax (current package)
		compile.go#L90: 	switch re.Op {
		parse.go#L150: 	re.Op = op
		parse.go#L180: 		if re.Op == OpRepeat {
		parse.go#L220: 	switch re.Op {
		parse.go#L295: 	if re.Op == OpCharClass && len(re.Rune) == 2 && re.Rune[0] == re.Rune[1] {
		parse.go#L300: 		re.Op = OpLiteral
		parse.go#L303: 	} else if re.Op == OpCharClass && len(re.Rune) == 4 &&
		parse.go#L307: 		re.Op == OpCharClass && len(re.Rune) == 2 &&
		parse.go#L317: 		re.Op = OpLiteral
		parse.go#L347: 	if re1.Op != OpLiteral || re2.Op != OpLiteral || re1.Flags&FoldCase != re2.Flags&FoldCase {
		parse.go#L423: 	if sub.Op >= opPseudo {
		parse.go#L453: 	if re.Op == OpRepeat {
		parse.go#L482: 	for i > 0 && p.stack[i-1].Op < opPseudo {
		parse.go#L501: 	for i > 0 && p.stack[i-1].Op < opPseudo {
		parse.go#L524: 	switch re.Op {
		parse.go#L529: 			re.Op = OpAnyChar
		parse.go#L534: 			re.Op = OpAnyCharNotNL
		parse.go#L556: 		if sub.Op == op {
		parse.go#L680: 				(isCharClass(first) || (first.Op == OpRepeat && first.Min == first.Max && isCharClass(first.Sub[0]))) {
		parse.go#L740: 				if sub[max].Op < sub[j].Op || sub[max].Op == sub[j].Op && len(sub[max].Rune) < len(sub[j].Rune) {
		parse.go#L766: 		if i+1 < len(sub) && sub[i].Op == OpEmptyMatch && sub[i+1].Op == OpEmptyMatch {
		parse.go#L779: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L782: 	if re.Op != OpLiteral {
		parse.go#L791: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L797: 		if sub.Op == OpEmptyMatch {
		parse.go#L802: 				re.Op = OpEmptyMatch
		parse.go#L816: 	if re.Op == OpLiteral {
		parse.go#L819: 			re.Op = OpEmptyMatch
		parse.go#L828: 	if re.Op == OpEmptyMatch {
		parse.go#L831: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L833: 		if sub.Op == OpEmptyMatch {
		parse.go#L845: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L852: 			re.Op = OpEmptyMatch
		parse.go#L868: 	re := &Regexp{Op: OpLiteral}
		parse.go#L1303: 	return re.Op == OpLiteral && len(re.Rune) == 1 ||
		parse.go#L1304: 		re.Op == OpCharClass ||
		parse.go#L1305: 		re.Op == OpAnyCharNotNL ||
		parse.go#L1306: 		re.Op == OpAnyChar
		parse.go#L1311: 	switch re.Op {
		parse.go#L1346: 	switch dst.Op {
		parse.go#L1352: 			dst.Op = OpAnyChar
		parse.go#L1356: 		if src.Op == OpLiteral {
		parse.go#L1366: 		dst.Op = OpCharClass
		parse.go#L1379: 	if n >= 3 && p.stack[n-2].Op == opVerticalBar && isCharClass(p.stack[n-1]) && isCharClass(p.stack[n-3]) {
		parse.go#L1383: 		if re1.Op > re3.Op {
		parse.go#L1396: 		if re2.Op == opVerticalBar {
		parse.go#L1426: 	if re2.Op != opLeftParen {
		parse.go#L1435: 		re2.Op = OpCapture
		regexp.go#L19: 	Op       Op // operator
		regexp.go#L68: 	if x.Op != y.Op {
		regexp.go#L71: 	switch x.Op {
		regexp.go#L130: 	switch re.Op {
		regexp.go#L261: 	switch re.Op {
		regexp.go#L263: 		b.WriteString("<invalid op" + strconv.Itoa(int(re.Op)) + ">")
		regexp.go#L333: 		if re.Sub[0].Op != OpEmptyMatch {
		regexp.go#L340: 		if sub.Op > OpCapture || sub.Op == OpLiteral && len(sub.Rune) > 1 {
		regexp.go#L345: 		switch re.Op {
		regexp.go#L369: 			if sub.Op == OpAlternate {
		regexp.go#L439: 	if re.Op == OpCapture {
		regexp.go#L458: 	if re.Op == OpCapture {
		simplify.go#L18: 	switch re.Op {
		simplify.go#L39: 		return simplify1(re.Op, re.Flags, sub, re)
		simplify.go#L45: 			return &Regexp{Op: OpEmptyMatch}
		simplify.go#L64: 			nre := &Regexp{Op: OpConcat}
		simplify.go#L87: 			prefix = &Regexp{Op: OpConcat}
		simplify.go#L98: 				nre2 := &Regexp{Op: OpConcat}
		simplify.go#L113: 		return &Regexp{Op: OpNoMatch}
		simplify.go#L137: 	if sub.Op == OpEmptyMatch {
		simplify.go#L141: 	if op == sub.Op && flags&NonGreedy == sub.Flags&NonGreedy {
		simplify.go#L144: 	if re != nil && re.Op == op && re.Flags&NonGreedy == flags&NonGreedy && sub == re.Sub[0] {
		simplify.go#L148: 	re = &Regexp{Op: op, Flags: flags}

	regexp
		regexp.go#L269: 	switch re.Op {