regexp/syntax.Regexp.Op (field)

79 uses

	regexp/syntax (current package)
		compile.go#L90: 	switch re.Op {
		parse.go#L149: 	re.Op = op
		parse.go#L179: 		if re.Op == OpRepeat {
		parse.go#L219: 	switch re.Op {
		parse.go#L296: 	if re.Op == OpCharClass && len(re.Rune) == 2 && re.Rune[0] == re.Rune[1] {
		parse.go#L301: 		re.Op = OpLiteral
		parse.go#L304: 	} else if re.Op == OpCharClass && len(re.Rune) == 4 &&
		parse.go#L308: 		re.Op == OpCharClass && len(re.Rune) == 2 &&
		parse.go#L318: 		re.Op = OpLiteral
		parse.go#L348: 	if re1.Op != OpLiteral || re2.Op != OpLiteral || re1.Flags&FoldCase != re2.Flags&FoldCase {
		parse.go#L426: 	if sub.Op >= opPseudo {
		parse.go#L456: 	if re.Op == OpRepeat {
		parse.go#L485: 	for i > 0 && p.stack[i-1].Op < opPseudo {
		parse.go#L504: 	for i > 0 && p.stack[i-1].Op < opPseudo {
		parse.go#L527: 	switch re.Op {
		parse.go#L532: 			re.Op = OpAnyChar
		parse.go#L537: 			re.Op = OpAnyCharNotNL
		parse.go#L559: 		if sub.Op == op {
		parse.go#L683: 				(isCharClass(first) || (first.Op == OpRepeat && first.Min == first.Max && isCharClass(first.Sub[0]))) {
		parse.go#L743: 				if sub[max].Op < sub[j].Op || sub[max].Op == sub[j].Op && len(sub[max].Rune) < len(sub[j].Rune) {
		parse.go#L769: 		if i+1 < len(sub) && sub[i].Op == OpEmptyMatch && sub[i+1].Op == OpEmptyMatch {
		parse.go#L782: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L785: 	if re.Op != OpLiteral {
		parse.go#L794: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L800: 		if sub.Op == OpEmptyMatch {
		parse.go#L805: 				re.Op = OpEmptyMatch
		parse.go#L819: 	if re.Op == OpLiteral {
		parse.go#L822: 			re.Op = OpEmptyMatch
		parse.go#L831: 	if re.Op == OpEmptyMatch {
		parse.go#L834: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L836: 		if sub.Op == OpEmptyMatch {
		parse.go#L848: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L855: 			re.Op = OpEmptyMatch
		parse.go#L871: 	re := &Regexp{Op: OpLiteral}
		parse.go#L1299: 	return re.Op == OpLiteral && len(re.Rune) == 1 ||
		parse.go#L1300: 		re.Op == OpCharClass ||
		parse.go#L1301: 		re.Op == OpAnyCharNotNL ||
		parse.go#L1302: 		re.Op == OpAnyChar
		parse.go#L1307: 	switch re.Op {
		parse.go#L1344: 	switch dst.Op {
		parse.go#L1350: 			dst.Op = OpAnyChar
		parse.go#L1354: 		if src.Op == OpLiteral {
		parse.go#L1364: 		dst.Op = OpCharClass
		parse.go#L1377: 	if n >= 3 && p.stack[n-2].Op == opVerticalBar && isCharClass(p.stack[n-1]) && isCharClass(p.stack[n-3]) {
		parse.go#L1381: 		if re1.Op > re3.Op {
		parse.go#L1394: 		if re2.Op == opVerticalBar {
		parse.go#L1424: 	if re2.Op != opLeftParen {
		parse.go#L1433: 		re2.Op = OpCapture
		regexp.go#L18: 	Op       Op // operator
		regexp.go#L67: 	if x.Op != y.Op {
		regexp.go#L70: 	switch x.Op {
		regexp.go#L117: 	switch re.Op {
		regexp.go#L119: 		b.WriteString("<invalid op" + strconv.Itoa(int(re.Op)) + ">")
		regexp.go#L193: 		if re.Sub[0].Op != OpEmptyMatch {
		regexp.go#L198: 		if sub := re.Sub[0]; sub.Op > OpCapture || sub.Op == OpLiteral && len(sub.Rune) > 1 {
		regexp.go#L205: 		switch re.Op {
		regexp.go#L228: 			if sub.Op == OpAlternate {
		regexp.go#L295: 	if re.Op == OpCapture {
		regexp.go#L314: 	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#L275: 	switch re.Op {