package regexp

Import Path
	regexp (on golang.org and go.dev)

Dependency Relation
	imports 9 packages, and imported by 5 packages

Involved Source Files
	    backtrack.go
	    exec.go
	    onepass.go
	d-> regexp.go

Exported Type Names

type Regexp (struct) Regexp is the representation of a compiled regular expression. A Regexp is safe for concurrent use by multiple goroutines, except for configuration methods, such as Longest. (*T) Copy() *Regexp (*T) Expand(dst []byte, template []byte, src []byte, match []int) []byte (*T) ExpandString(dst []byte, template string, src string, match []int) []byte (*T) Find(b []byte) []byte (*T) FindAll(b []byte, n int) [][]byte (*T) FindAllIndex(b []byte, n int) [][]int (*T) FindAllString(s string, n int) []string (*T) FindAllStringIndex(s string, n int) [][]int (*T) FindAllStringSubmatch(s string, n int) [][]string (*T) FindAllStringSubmatchIndex(s string, n int) [][]int (*T) FindAllSubmatch(b []byte, n int) [][][]byte (*T) FindAllSubmatchIndex(b []byte, n int) [][]int (*T) FindIndex(b []byte) (loc []int) (*T) FindReaderIndex(r io.RuneReader) (loc []int) (*T) FindReaderSubmatchIndex(r io.RuneReader) []int (*T) FindString(s string) string (*T) FindStringIndex(s string) (loc []int) (*T) FindStringSubmatch(s string) []string (*T) FindStringSubmatchIndex(s string) []int (*T) FindSubmatch(b []byte) [][]byte (*T) FindSubmatchIndex(b []byte) []int (*T) LiteralPrefix() (prefix string, complete bool) (*T) Longest() (*T) Match(b []byte) bool (*T) MatchReader(r io.RuneReader) bool (*T) MatchString(s string) bool (*T) NumSubexp() int (*T) ReplaceAll(src, repl []byte) []byte (*T) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte (*T) ReplaceAllLiteral(src, repl []byte) []byte (*T) ReplaceAllLiteralString(src, repl string) string (*T) ReplaceAllString(src, repl string) string (*T) ReplaceAllStringFunc(src string, repl func(string) string) string (*T) Split(s string, n int) []string (*T) String() string (*T) SubexpIndex(name string) int (*T) SubexpNames() []string *T : expvar.Var *T : fmt.Stringer func Compile(expr string) (*Regexp, error) func CompilePOSIX(expr string) (*Regexp, error) func MustCompile(str string) *Regexp func MustCompilePOSIX(str string) *Regexp func (*Regexp).Copy() *Regexp func index/suffixarray.(*Index).FindAllIndex(r *Regexp, n int) (result [][]int) func internal/profile.(*Profile).FilterSamplesByName(focus, ignore, hide *Regexp) (fm, im, hm bool) func internal/profile.(*Profile).Prune(dropRx, keepRx *Regexp)
Exported Values
func Compile(expr string) (*Regexp, error) Compile parses a regular expression and returns, if successful, a Regexp object that can be used to match against text. When matching against text, the regexp returns a match that begins as early as possible in the input (leftmost), and among those it chooses the one that a backtracking search would have found first. This so-called leftmost-first matching is the same semantics that Perl, Python, and other implementations use, although this package implements it without the expense of backtracking. For POSIX leftmost-longest matching, see CompilePOSIX.
func CompilePOSIX(expr string) (*Regexp, error) CompilePOSIX is like Compile but restricts the regular expression to POSIX ERE (egrep) syntax and changes the match semantics to leftmost-longest. That is, when matching against text, the regexp returns a match that begins as early as possible in the input (leftmost), and among those it chooses a match that is as long as possible. This so-called leftmost-longest matching is the same semantics that early regular expression implementations used and that POSIX specifies. However, there can be multiple leftmost-longest matches, with different submatch choices, and here this package diverges from POSIX. Among the possible leftmost-longest matches, this package chooses the one that a backtracking search would have found first, while POSIX specifies that the match be chosen to maximize the length of the first subexpression, then the second, and so on from left to right. The POSIX rule is computationally prohibitive and not even well-defined. See https://swtch.com/~rsc/regexp/regexp2.html#posix for details.
func Match(pattern string, b []byte) (matched bool, err error) Match reports whether the byte slice b contains any match of the regular expression pattern. More complicated queries need to use Compile and the full Regexp interface.
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error) MatchReader reports whether the text returned by the RuneReader contains any match of the regular expression pattern. More complicated queries need to use Compile and the full Regexp interface.
func MatchString(pattern string, s string) (matched bool, err error) MatchString reports whether the string s contains any match of the regular expression pattern. More complicated queries need to use Compile and the full Regexp interface.
func MustCompile(str string) *Regexp MustCompile is like Compile but panics if the expression cannot be parsed. It simplifies safe initialization of global variables holding compiled regular expressions.
func MustCompilePOSIX(str string) *Regexp MustCompilePOSIX is like CompilePOSIX but panics if the expression cannot be parsed. It simplifies safe initialization of global variables holding compiled regular expressions.
func QuoteMeta(s string) string QuoteMeta returns a string that escapes all regular expression metacharacters inside the argument text; the returned string is a regular expression matching the literal text.