Source file src/path/match.go

     1	// Copyright 2010 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 path
     6	
     7	import (
     8		"errors"
     9		"strings"
    10		"unicode/utf8"
    11	)
    12	
    13	// ErrBadPattern indicates a pattern was malformed.
    14	var ErrBadPattern = errors.New("syntax error in pattern")
    15	
    16	// Match reports whether name matches the shell pattern.
    17	// The pattern syntax is:
    18	//
    19	//	pattern:
    20	//		{ term }
    21	//	term:
    22	//		'*'         matches any sequence of non-/ characters
    23	//		'?'         matches any single non-/ character
    24	//		'[' [ '^' ] { character-range } ']'
    25	//		            character class (must be non-empty)
    26	//		c           matches character c (c != '*', '?', '\\', '[')
    27	//		'\\' c      matches character c
    28	//
    29	//	character-range:
    30	//		c           matches character c (c != '\\', '-', ']')
    31	//		'\\' c      matches character c
    32	//		lo '-' hi   matches character c for lo <= c <= hi
    33	//
    34	// Match requires pattern to match all of name, not just a substring.
    35	// The only possible returned error is ErrBadPattern, when pattern
    36	// is malformed.
    37	//
    38	func Match(pattern, name string) (matched bool, err error) {
    39	Pattern:
    40		for len(pattern) > 0 {
    41			var star bool
    42			var chunk string
    43			star, chunk, pattern = scanChunk(pattern)
    44			if star && chunk == "" {
    45				// Trailing * matches rest of string unless it has a /.
    46				return !strings.Contains(name, "/"), nil
    47			}
    48			// Look for match at current position.
    49			t, ok, err := matchChunk(chunk, name)
    50			// if we're the last chunk, make sure we've exhausted the name
    51			// otherwise we'll give a false result even if we could still match
    52			// using the star
    53			if ok && (len(t) == 0 || len(pattern) > 0) {
    54				name = t
    55				continue
    56			}
    57			if err != nil {
    58				return false, err
    59			}
    60			if star {
    61				// Look for match skipping i+1 bytes.
    62				// Cannot skip /.
    63				for i := 0; i < len(name) && name[i] != '/'; i++ {
    64					t, ok, err := matchChunk(chunk, name[i+1:])
    65					if ok {
    66						// if we're the last chunk, make sure we exhausted the name
    67						if len(pattern) == 0 && len(t) > 0 {
    68							continue
    69						}
    70						name = t
    71						continue Pattern
    72					}
    73					if err != nil {
    74						return false, err
    75					}
    76				}
    77			}
    78			return false, nil
    79		}
    80		return len(name) == 0, nil
    81	}
    82	
    83	// scanChunk gets the next segment of pattern, which is a non-star string
    84	// possibly preceded by a star.
    85	func scanChunk(pattern string) (star bool, chunk, rest string) {
    86		for len(pattern) > 0 && pattern[0] == '*' {
    87			pattern = pattern[1:]
    88			star = true
    89		}
    90		inrange := false
    91		var i int
    92	Scan:
    93		for i = 0; i < len(pattern); i++ {
    94			switch pattern[i] {
    95			case '\\':
    96				// error check handled in matchChunk: bad pattern.
    97				if i+1 < len(pattern) {
    98					i++
    99				}
   100			case '[':
   101				inrange = true
   102			case ']':
   103				inrange = false
   104			case '*':
   105				if !inrange {
   106					break Scan
   107				}
   108			}
   109		}
   110		return star, pattern[0:i], pattern[i:]
   111	}
   112	
   113	// matchChunk checks whether chunk matches the beginning of s.
   114	// If so, it returns the remainder of s (after the match).
   115	// Chunk is all single-character operators: literals, char classes, and ?.
   116	func matchChunk(chunk, s string) (rest string, ok bool, err error) {
   117		for len(chunk) > 0 {
   118			if len(s) == 0 {
   119				return
   120			}
   121			switch chunk[0] {
   122			case '[':
   123				// character class
   124				r, n := utf8.DecodeRuneInString(s)
   125				s = s[n:]
   126				chunk = chunk[1:]
   127				// possibly negated
   128				notNegated := true
   129				if len(chunk) > 0 && chunk[0] == '^' {
   130					notNegated = false
   131					chunk = chunk[1:]
   132				}
   133				// parse all ranges
   134				match := false
   135				nrange := 0
   136				for {
   137					if len(chunk) > 0 && chunk[0] == ']' && nrange > 0 {
   138						chunk = chunk[1:]
   139						break
   140					}
   141					var lo, hi rune
   142					if lo, chunk, err = getEsc(chunk); err != nil {
   143						return
   144					}
   145					hi = lo
   146					if chunk[0] == '-' {
   147						if hi, chunk, err = getEsc(chunk[1:]); err != nil {
   148							return
   149						}
   150					}
   151					if lo <= r && r <= hi {
   152						match = true
   153					}
   154					nrange++
   155				}
   156				if match != notNegated {
   157					return
   158				}
   159	
   160			case '?':
   161				if s[0] == '/' {
   162					return
   163				}
   164				_, n := utf8.DecodeRuneInString(s)
   165				s = s[n:]
   166				chunk = chunk[1:]
   167	
   168			case '\\':
   169				chunk = chunk[1:]
   170				if len(chunk) == 0 {
   171					err = ErrBadPattern
   172					return
   173				}
   174				fallthrough
   175	
   176			default:
   177				if chunk[0] != s[0] {
   178					return
   179				}
   180				s = s[1:]
   181				chunk = chunk[1:]
   182			}
   183		}
   184		return s, true, nil
   185	}
   186	
   187	// getEsc gets a possibly-escaped character from chunk, for a character class.
   188	func getEsc(chunk string) (r rune, nchunk string, err error) {
   189		if len(chunk) == 0 || chunk[0] == '-' || chunk[0] == ']' {
   190			err = ErrBadPattern
   191			return
   192		}
   193		if chunk[0] == '\\' {
   194			chunk = chunk[1:]
   195			if len(chunk) == 0 {
   196				err = ErrBadPattern
   197				return
   198			}
   199		}
   200		r, n := utf8.DecodeRuneInString(chunk)
   201		if r == utf8.RuneError && n == 1 {
   202			err = ErrBadPattern
   203		}
   204		nchunk = chunk[n:]
   205		if len(nchunk) == 0 {
   206			err = ErrBadPattern
   207		}
   208		return
   209	}
   210	

View as plain text