type regexp/syntax.Regexp

75 uses

	regexp/syntax (current package)
		compile.go#L71: func Compile(re *Regexp) (*Prog, error) {
		compile.go#L89: func (c *compiler) compile(re *Regexp) frag {
		parse.go#L128: 	stack       []*Regexp // stack of parsed expressions
		parse.go#L129: 	free        *Regexp
		parse.go#L136: 	height      map[*Regexp]int   // regexp height, for height limit check
		parse.go#L137: 	size        map[*Regexp]int64 // regexp compiled size, for size limit check
		parse.go#L140: func (p *parser) newRegexp(op Op) *Regexp {
		parse.go#L144: 		*re = Regexp{}
		parse.go#L146: 		re = new(Regexp)
		parse.go#L153: func (p *parser) reuse(re *Regexp) {
		parse.go#L161: func (p *parser) checkLimits(re *Regexp) {
		parse.go#L169: func (p *parser) checkSize(re *Regexp) {
		parse.go#L200: 		p.size = make(map[*Regexp]int64)
		parse.go#L211: func (p *parser) calcSize(re *Regexp, force bool) int64 {
		parse.go#L257: func (p *parser) checkHeight(re *Regexp) {
		parse.go#L262: 		p.height = make(map[*Regexp]int)
		parse.go#L272: func (p *parser) calcHeight(re *Regexp, force bool) int {
		parse.go#L292: func (p *parser) push(re *Regexp) *Regexp {
		parse.go#L393: func (p *parser) op(op Op) *Regexp {
		parse.go#L451: func repeatIsValid(re *Regexp, n int) bool {
		parse.go#L476: func (p *parser) concat() *Regexp {
		parse.go#L496: func (p *parser) alternate() *Regexp {
		parse.go#L522: func cleanAlt(re *Regexp) {
		parse.go#L548: func (p *parser) collapse(subs []*Regexp, op Op) *Regexp {
		parse.go#L588: func (p *parser) factor(sub []*Regexp) []*Regexp {
		parse.go#L667: 	var first *Regexp
		parse.go#L674: 		var ifirst *Regexp
		parse.go#L777: func (p *parser) leadingString(re *Regexp) ([]rune, Flags) {
		parse.go#L789: func (p *parser) removeLeadingString(re *Regexp, n int) *Regexp {
		parse.go#L826: func (p *parser) leadingRegexp(re *Regexp) *Regexp {
		parse.go#L843: func (p *parser) removeLeadingRegexp(re *Regexp, reuse bool) *Regexp {
		parse.go#L866: func literalRegexp(s string, flags Flags) *Regexp {
		parse.go#L867: 	re := &Regexp{Op: OpLiteral}
		parse.go#L886: func Parse(s string, flags Flags) (*Regexp, error) {
		parse.go#L890: func parse(s string, flags Flags) (_ *Regexp, err error) {
		parse.go#L1301: func isCharClass(re *Regexp) bool {
		parse.go#L1309: func matchRune(re *Regexp, r rune) bool {
		parse.go#L1344: func mergeCharClass(dst, src *Regexp) {
		regexp.go#L18: type Regexp struct {
		regexp.go#L21: 	Sub      []*Regexp  // subexpressions, if any
		regexp.go#L22: 	Sub0     [1]*Regexp // storage for short Sub
		regexp.go#L64: func (x *Regexp) Equal(y *Regexp) bool {
		regexp.go#L82: 		return slices.EqualFunc(x.Sub, y.Sub, (*Regexp).Equal)
		regexp.go#L116: func addSpan(start, last *Regexp, f printFlags, flags *map[*Regexp]printFlags) {
		regexp.go#L118: 		*flags = make(map[*Regexp]printFlags)
		regexp.go#L129: func calcFlags(re *Regexp, flags *map[*Regexp]printFlags) (must, cant printFlags) {
		regexp.go#L225: func writeRegexp(b *strings.Builder, re *Regexp, f printFlags, flags map[*Regexp]printFlags) {
		regexp.go#L384: func (re *Regexp) String() string {
		regexp.go#L386: 	var flags map[*Regexp]printFlags
		regexp.go#L437: func (re *Regexp) MaxCap() int {
		regexp.go#L451: func (re *Regexp) CapNames() []string {
		regexp.go#L457: func (re *Regexp) capNames(names []string) {
		simplify.go#L14: func (re *Regexp) Simplify() *Regexp {
		simplify.go#L26: 				nre = new(Regexp)
		simplify.go#L45: 			return &Regexp{Op: OpEmptyMatch}
		simplify.go#L64: 			nre := &Regexp{Op: OpConcat}
		simplify.go#L85: 		var prefix *Regexp
		simplify.go#L87: 			prefix = &Regexp{Op: OpConcat}
		simplify.go#L98: 				nre2 := &Regexp{Op: OpConcat}
		simplify.go#L113: 		return &Regexp{Op: OpNoMatch}
		simplify.go#L134: func simplify1(op Op, flags Flags, sub, re *Regexp) *Regexp {
		simplify.go#L148: 	re = &Regexp{Op: op, Flags: flags}

	regexp
		regexp.go#L268: func minInputLen(re *syntax.Regexp) int {