regexp/syntax.Regexp.Op (field)

80 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#L294: 	if re.Op == OpCharClass && len(re.Rune) == 2 && re.Rune[0] == re.Rune[1] {
		parse.go#L299: 		re.Op = OpLiteral
		parse.go#L302: 	} else if re.Op == OpCharClass && len(re.Rune) == 4 &&
		parse.go#L306: 		re.Op == OpCharClass && len(re.Rune) == 2 &&
		parse.go#L316: 		re.Op = OpLiteral
		parse.go#L346: 	if re1.Op != OpLiteral || re2.Op != OpLiteral || re1.Flags&FoldCase != re2.Flags&FoldCase {
		parse.go#L422: 	if sub.Op >= opPseudo {
		parse.go#L452: 	if re.Op == OpRepeat {
		parse.go#L481: 	for i > 0 && p.stack[i-1].Op < opPseudo {
		parse.go#L500: 	for i > 0 && p.stack[i-1].Op < opPseudo {
		parse.go#L523: 	switch re.Op {
		parse.go#L528: 			re.Op = OpAnyChar
		parse.go#L533: 			re.Op = OpAnyCharNotNL
		parse.go#L555: 		if sub.Op == op {
		parse.go#L679: 				(isCharClass(first) || (first.Op == OpRepeat && first.Min == first.Max && isCharClass(first.Sub[0]))) {
		parse.go#L739: 				if sub[max].Op < sub[j].Op || sub[max].Op == sub[j].Op && len(sub[max].Rune) < len(sub[j].Rune) {
		parse.go#L765: 		if i+1 < len(sub) && sub[i].Op == OpEmptyMatch && sub[i+1].Op == OpEmptyMatch {
		parse.go#L778: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L781: 	if re.Op != OpLiteral {
		parse.go#L790: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L796: 		if sub.Op == OpEmptyMatch {
		parse.go#L801: 				re.Op = OpEmptyMatch
		parse.go#L815: 	if re.Op == OpLiteral {
		parse.go#L818: 			re.Op = OpEmptyMatch
		parse.go#L827: 	if re.Op == OpEmptyMatch {
		parse.go#L830: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L832: 		if sub.Op == OpEmptyMatch {
		parse.go#L844: 	if re.Op == OpConcat && len(re.Sub) > 0 {
		parse.go#L851: 			re.Op = OpEmptyMatch
		parse.go#L867: 	re := &Regexp{Op: OpLiteral}
		parse.go#L1302: 	return re.Op == OpLiteral && len(re.Rune) == 1 ||
		parse.go#L1303: 		re.Op == OpCharClass ||
		parse.go#L1304: 		re.Op == OpAnyCharNotNL ||
		parse.go#L1305: 		re.Op == OpAnyChar
		parse.go#L1310: 	switch re.Op {
		parse.go#L1345: 	switch dst.Op {
		parse.go#L1351: 			dst.Op = OpAnyChar
		parse.go#L1355: 		if src.Op == OpLiteral {
		parse.go#L1365: 		dst.Op = OpCharClass
		parse.go#L1378: 	if n >= 3 && p.stack[n-2].Op == opVerticalBar && isCharClass(p.stack[n-1]) && isCharClass(p.stack[n-3]) {
		parse.go#L1382: 		if re1.Op > re3.Op {
		parse.go#L1395: 		if re2.Op == opVerticalBar {
		parse.go#L1425: 	if re2.Op != opLeftParen {
		parse.go#L1434: 		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 {