regexp/syntax.Regexp.Op (field)

77 uses

	regexp/syntax (current package)
		compile.go#L90: 	switch re.Op {
		parse.go#L113: 	re.Op = op
		parse.go#L161: 	if re.Op == OpCharClass && len(re.Rune) == 2 && re.Rune[0] == re.Rune[1] {
		parse.go#L166: 		re.Op = OpLiteral
		parse.go#L169: 	} else if re.Op == OpCharClass && len(re.Rune) == 4 &&
		parse.go#L173: 		re.Op == OpCharClass && len(re.Rune) == 2 &&
		parse.go#L183: 		re.Op = OpLiteral
		parse.go#L213: 	if re1.Op != OpLiteral || re2.Op != OpLiteral || re1.Flags&FoldCase != re2.Flags&FoldCase {
		parse.go#L291: 	if sub.Op >= opPseudo {
		parse.go#L321: 	if re.Op == OpRepeat {
		parse.go#L350: 	for i > 0 && p.stack[i-1].Op < opPseudo {
		parse.go#L369: 	for i > 0 && p.stack[i-1].Op < opPseudo {
		parse.go#L392: 	switch re.Op {
		parse.go#L397: 			re.Op = OpAnyChar
		parse.go#L402: 			re.Op = OpAnyCharNotNL
		parse.go#L424: 		if sub.Op == op {
		parse.go#L543: 				(isCharClass(first) || (first.Op == OpRepeat && first.Min == first.Max && isCharClass(first.Sub[0]))) {
		parse.go#L602: 				if sub[max].Op < sub[j].Op || sub[max].Op == sub[j].Op && len(sub[max].Rune) < len(sub[j].Rune) {
		parse.go#L628: 		if i+1 < len(sub) && sub[i].Op == OpEmptyMatch && sub[i+1].Op == OpEmptyMatch {
		parse.go#L641: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L644: 	if re.Op != OpLiteral {
		parse.go#L653: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L659: 		if sub.Op == OpEmptyMatch {
		parse.go#L664: 				re.Op = OpEmptyMatch
		parse.go#L678: 	if re.Op == OpLiteral {
		parse.go#L681: 			re.Op = OpEmptyMatch
		parse.go#L690: 	if re.Op == OpEmptyMatch {
		parse.go#L693: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L695: 		if sub.Op == OpEmptyMatch {
		parse.go#L707: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L714: 			re.Op = OpEmptyMatch
		parse.go#L730: 	re := &Regexp{Op: OpLiteral}
		parse.go#L1156: 	return re.Op == OpLiteral && len(re.Rune) == 1 ||
		parse.go#L1157: 		re.Op == OpCharClass ||
		parse.go#L1158: 		re.Op == OpAnyCharNotNL ||
		parse.go#L1159: 		re.Op == OpAnyChar
		parse.go#L1164: 	switch re.Op {
		parse.go#L1201: 	switch dst.Op {
		parse.go#L1207: 			dst.Op = OpAnyChar
		parse.go#L1211: 		if src.Op == OpLiteral {
		parse.go#L1221: 		dst.Op = OpCharClass
		parse.go#L1234: 	if n >= 3 && p.stack[n-2].Op == opVerticalBar && isCharClass(p.stack[n-1]) && isCharClass(p.stack[n-3]) {
		parse.go#L1238: 		if re1.Op > re3.Op {
		parse.go#L1251: 		if re2.Op == opVerticalBar {
		parse.go#L1281: 	if re2.Op != opLeftParen {
		parse.go#L1290: 		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#L273: 	switch re.Op {