...
Run Format

Source file src/regexp/syntax/regexp.go

     1	// Copyright 2011 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package syntax
     6	
     7	// Note to implementers:
     8	// In this package, re is always a *Regexp and r is always a rune.
     9	
    10	import (
    11		"bytes"
    12		"strconv"
    13		"strings"
    14		"unicode"
    15	)
    16	
    17	// A Regexp is a node in a regular expression syntax tree.
    18	type Regexp struct {
    19		Op       Op // operator
    20		Flags    Flags
    21		Sub      []*Regexp  // subexpressions, if any
    22		Sub0     [1]*Regexp // storage for short Sub
    23		Rune     []rune     // matched runes, for OpLiteral, OpCharClass
    24		Rune0    [2]rune    // storage for short Rune
    25		Min, Max int        // min, max for OpRepeat
    26		Cap      int        // capturing index, for OpCapture
    27		Name     string     // capturing name, for OpCapture
    28	}
    29	
    30	// An Op is a single regular expression operator.
    31	type Op uint8
    32	
    33	// Operators are listed in precedence order, tightest binding to weakest.
    34	// Character class operators are listed simplest to most complex
    35	// (OpLiteral, OpCharClass, OpAnyCharNotNL, OpAnyChar).
    36	
    37	const (
    38		OpNoMatch        Op = 1 + iota // matches no strings
    39		OpEmptyMatch                   // matches empty string
    40		OpLiteral                      // matches Runes sequence
    41		OpCharClass                    // matches Runes interpreted as range pair list
    42		OpAnyCharNotNL                 // matches any character except newline
    43		OpAnyChar                      // matches any character
    44		OpBeginLine                    // matches empty string at beginning of line
    45		OpEndLine                      // matches empty string at end of line
    46		OpBeginText                    // matches empty string at beginning of text
    47		OpEndText                      // matches empty string at end of text
    48		OpWordBoundary                 // matches word boundary `\b`
    49		OpNoWordBoundary               // matches word non-boundary `\B`
    50		OpCapture                      // capturing subexpression with index Cap, optional name Name
    51		OpStar                         // matches Sub[0] zero or more times
    52		OpPlus                         // matches Sub[0] one or more times
    53		OpQuest                        // matches Sub[0] zero or one times
    54		OpRepeat                       // matches Sub[0] at least Min times, at most Max (Max == -1 is no limit)
    55		OpConcat                       // matches concatenation of Subs
    56		OpAlternate                    // matches alternation of Subs
    57	)
    58	
    59	const opPseudo Op = 128 // where pseudo-ops start
    60	
    61	// Equal returns true if x and y have identical structure.
    62	func (x *Regexp) Equal(y *Regexp) bool {
    63		if x == nil || y == nil {
    64			return x == y
    65		}
    66		if x.Op != y.Op {
    67			return false
    68		}
    69		switch x.Op {
    70		case OpEndText:
    71			// The parse flags remember whether this is \z or \Z.
    72			if x.Flags&WasDollar != y.Flags&WasDollar {
    73				return false
    74			}
    75	
    76		case OpLiteral, OpCharClass:
    77			if len(x.Rune) != len(y.Rune) {
    78				return false
    79			}
    80			for i, r := range x.Rune {
    81				if r != y.Rune[i] {
    82					return false
    83				}
    84			}
    85	
    86		case OpAlternate, OpConcat:
    87			if len(x.Sub) != len(y.Sub) {
    88				return false
    89			}
    90			for i, sub := range x.Sub {
    91				if !sub.Equal(y.Sub[i]) {
    92					return false
    93				}
    94			}
    95	
    96		case OpStar, OpPlus, OpQuest:
    97			if x.Flags&NonGreedy != y.Flags&NonGreedy || !x.Sub[0].Equal(y.Sub[0]) {
    98				return false
    99			}
   100	
   101		case OpRepeat:
   102			if x.Flags&NonGreedy != y.Flags&NonGreedy || x.Min != y.Min || x.Max != y.Max || !x.Sub[0].Equal(y.Sub[0]) {
   103				return false
   104			}
   105	
   106		case OpCapture:
   107			if x.Cap != y.Cap || x.Name != y.Name || !x.Sub[0].Equal(y.Sub[0]) {
   108				return false
   109			}
   110		}
   111		return true
   112	}
   113	
   114	// writeRegexp writes the Perl syntax for the regular expression re to b.
   115	func writeRegexp(b *bytes.Buffer, re *Regexp) {
   116		switch re.Op {
   117		default:
   118			b.WriteString("<invalid op" + strconv.Itoa(int(re.Op)) + ">")
   119		case OpNoMatch:
   120			b.WriteString(`[^\x00-\x{10FFFF}]`)
   121		case OpEmptyMatch:
   122			b.WriteString(`(?:)`)
   123		case OpLiteral:
   124			if re.Flags&FoldCase != 0 {
   125				b.WriteString(`(?i:`)
   126			}
   127			for _, r := range re.Rune {
   128				escape(b, r, false)
   129			}
   130			if re.Flags&FoldCase != 0 {
   131				b.WriteString(`)`)
   132			}
   133		case OpCharClass:
   134			if len(re.Rune)%2 != 0 {
   135				b.WriteString(`[invalid char class]`)
   136				break
   137			}
   138			b.WriteRune('[')
   139			if len(re.Rune) == 0 {
   140				b.WriteString(`^\x00-\x{10FFFF}`)
   141			} else if re.Rune[0] == 0 && re.Rune[len(re.Rune)-1] == unicode.MaxRune {
   142				// Contains 0 and MaxRune. Probably a negated class.
   143				// Print the gaps.
   144				b.WriteRune('^')
   145				for i := 1; i < len(re.Rune)-1; i += 2 {
   146					lo, hi := re.Rune[i]+1, re.Rune[i+1]-1
   147					escape(b, lo, lo == '-')
   148					if lo != hi {
   149						b.WriteRune('-')
   150						escape(b, hi, hi == '-')
   151					}
   152				}
   153			} else {
   154				for i := 0; i < len(re.Rune); i += 2 {
   155					lo, hi := re.Rune[i], re.Rune[i+1]
   156					escape(b, lo, lo == '-')
   157					if lo != hi {
   158						b.WriteRune('-')
   159						escape(b, hi, hi == '-')
   160					}
   161				}
   162			}
   163			b.WriteRune(']')
   164		case OpAnyCharNotNL:
   165			b.WriteString(`(?-s:.)`)
   166		case OpAnyChar:
   167			b.WriteString(`(?s:.)`)
   168		case OpBeginLine:
   169			b.WriteString(`(?m:^)`)
   170		case OpEndLine:
   171			b.WriteString(`(?m:$)`)
   172		case OpBeginText:
   173			b.WriteString(`\A`)
   174		case OpEndText:
   175			if re.Flags&WasDollar != 0 {
   176				b.WriteString(`(?-m:$)`)
   177			} else {
   178				b.WriteString(`\z`)
   179			}
   180		case OpWordBoundary:
   181			b.WriteString(`\b`)
   182		case OpNoWordBoundary:
   183			b.WriteString(`\B`)
   184		case OpCapture:
   185			if re.Name != "" {
   186				b.WriteString(`(?P<`)
   187				b.WriteString(re.Name)
   188				b.WriteRune('>')
   189			} else {
   190				b.WriteRune('(')
   191			}
   192			if re.Sub[0].Op != OpEmptyMatch {
   193				writeRegexp(b, re.Sub[0])
   194			}
   195			b.WriteRune(')')
   196		case OpStar, OpPlus, OpQuest, OpRepeat:
   197			if sub := re.Sub[0]; sub.Op > OpCapture || sub.Op == OpLiteral && len(sub.Rune) > 1 {
   198				b.WriteString(`(?:`)
   199				writeRegexp(b, sub)
   200				b.WriteString(`)`)
   201			} else {
   202				writeRegexp(b, sub)
   203			}
   204			switch re.Op {
   205			case OpStar:
   206				b.WriteRune('*')
   207			case OpPlus:
   208				b.WriteRune('+')
   209			case OpQuest:
   210				b.WriteRune('?')
   211			case OpRepeat:
   212				b.WriteRune('{')
   213				b.WriteString(strconv.Itoa(re.Min))
   214				if re.Max != re.Min {
   215					b.WriteRune(',')
   216					if re.Max >= 0 {
   217						b.WriteString(strconv.Itoa(re.Max))
   218					}
   219				}
   220				b.WriteRune('}')
   221			}
   222			if re.Flags&NonGreedy != 0 {
   223				b.WriteRune('?')
   224			}
   225		case OpConcat:
   226			for _, sub := range re.Sub {
   227				if sub.Op == OpAlternate {
   228					b.WriteString(`(?:`)
   229					writeRegexp(b, sub)
   230					b.WriteString(`)`)
   231				} else {
   232					writeRegexp(b, sub)
   233				}
   234			}
   235		case OpAlternate:
   236			for i, sub := range re.Sub {
   237				if i > 0 {
   238					b.WriteRune('|')
   239				}
   240				writeRegexp(b, sub)
   241			}
   242		}
   243	}
   244	
   245	func (re *Regexp) String() string {
   246		var b bytes.Buffer
   247		writeRegexp(&b, re)
   248		return b.String()
   249	}
   250	
   251	const meta = `\.+*?()|[]{}^$`
   252	
   253	func escape(b *bytes.Buffer, r rune, force bool) {
   254		if unicode.IsPrint(r) {
   255			if strings.ContainsRune(meta, r) || force {
   256				b.WriteRune('\\')
   257			}
   258			b.WriteRune(r)
   259			return
   260		}
   261	
   262		switch r {
   263		case '\a':
   264			b.WriteString(`\a`)
   265		case '\f':
   266			b.WriteString(`\f`)
   267		case '\n':
   268			b.WriteString(`\n`)
   269		case '\r':
   270			b.WriteString(`\r`)
   271		case '\t':
   272			b.WriteString(`\t`)
   273		case '\v':
   274			b.WriteString(`\v`)
   275		default:
   276			if r < 0x100 {
   277				b.WriteString(`\x`)
   278				s := strconv.FormatInt(int64(r), 16)
   279				if len(s) == 1 {
   280					b.WriteRune('0')
   281				}
   282				b.WriteString(s)
   283				break
   284			}
   285			b.WriteString(`\x{`)
   286			b.WriteString(strconv.FormatInt(int64(r), 16))
   287			b.WriteString(`}`)
   288		}
   289	}
   290	
   291	// MaxCap walks the regexp to find the maximum capture index.
   292	func (re *Regexp) MaxCap() int {
   293		m := 0
   294		if re.Op == OpCapture {
   295			m = re.Cap
   296		}
   297		for _, sub := range re.Sub {
   298			if n := sub.MaxCap(); m < n {
   299				m = n
   300			}
   301		}
   302		return m
   303	}
   304	
   305	// CapNames walks the regexp to find the names of capturing groups.
   306	func (re *Regexp) CapNames() []string {
   307		names := make([]string, re.MaxCap()+1)
   308		re.capNames(names)
   309		return names
   310	}
   311	
   312	func (re *Regexp) capNames(names []string) {
   313		if re.Op == OpCapture {
   314			names[re.Cap] = re.Name
   315		}
   316		for _, sub := range re.Sub {
   317			sub.capNames(names)
   318		}
   319	}
   320	

View as plain text