type Error … func (e *Error) Error() string { … } type ErrorCode … const ErrInternalError … const ErrInvalidCharClass … const ErrInvalidCharRange … const ErrInvalidEscape … const ErrInvalidNamedCapture … const ErrInvalidPerlOp … const ErrInvalidRepeatOp … const ErrInvalidRepeatSize … const ErrInvalidUTF8 … const ErrMissingBracket … const ErrMissingParen … const ErrMissingRepeatArgument … const ErrTrailingBackslash … const ErrUnexpectedParen … const ErrNestingDepth … const ErrLarge … func (e ErrorCode) String() string { … } type Flags … const FoldCase … const Literal … const ClassNL … const DotNL … const OneLine … const NonGreedy … const PerlX … const UnicodeGroups … const WasDollar … const Simple … const MatchNL … const Perl … const POSIX … const opLeftParen … const opVerticalBar … const maxHeight … const maxSize … const instSize … const maxRunes … const runeSize … type parser … func (p *parser) newRegexp(op Op) *Regexp { … } func (p *parser) reuse(re *Regexp) { … } func (p *parser) checkLimits(re *Regexp) { … } func (p *parser) checkSize(re *Regexp) { … } func (p *parser) calcSize(re *Regexp, force bool) int64 { … } func (p *parser) checkHeight(re *Regexp) { … } func (p *parser) calcHeight(re *Regexp, force bool) int { … } // push pushes the regexp re onto the parse stack and returns the regexp. func (p *parser) push(re *Regexp) *Regexp { … } // maybeConcat implements incremental concatenation // of literal runes into string nodes. The parser calls this // before each push, so only the top fragment of the stack // might need processing. Since this is called before a push, // the topmost literal is no longer subject to operators like * // (Otherwise ab* would turn into (ab)*.) // If r >= 0 and there's a node left over, maybeConcat uses it // to push r with the given flags. // maybeConcat reports whether r was pushed. func (p *parser) maybeConcat(r rune, flags Flags) bool { … } // literal pushes a literal regexp for the rune r on the stack. func (p *parser) literal(r rune) { … } // minFoldRune returns the minimum rune fold-equivalent to r. func minFoldRune(r rune) rune { … } // op pushes a regexp with the given op onto the stack // and returns that regexp. func (p *parser) op(op Op) *Regexp { … } // repeat replaces the top stack element with itself repeated according to op, min, max. // before is the regexp suffix starting at the repetition operator. // after is the regexp suffix following after the repetition operator. // repeat returns an updated 'after' and an error, if any. func (p *parser) repeat(op Op, min, max int, before, after, lastRepeat string) (string, error) { … } // repeatIsValid reports whether the repetition re is valid. // Valid means that the combination of the top-level repetition // and any inner repetitions does not exceed n copies of the // innermost thing. // This function rewalks the regexp tree and is called for every repetition, // so we have to worry about inducing quadratic behavior in the parser. // We avoid this by only calling repeatIsValid when min or max >= 2. // In that case the depth of any >= 2 nesting can only get to 9 without // triggering a parse error, so each subtree can only be rewalked 9 times. func repeatIsValid(re *Regexp, n int) bool { … } // concat replaces the top of the stack (above the topmost '|' or '(') with its concatenation. func (p *parser) concat() *Regexp { … } // alternate replaces the top of the stack (above the topmost '(') with its alternation. func (p *parser) alternate() *Regexp { … } // cleanAlt cleans re for eventual inclusion in an alternation. func cleanAlt(re *Regexp) { … } // collapse returns the result of applying op to sub. // If sub contains op nodes, they all get hoisted up // so that there is never a concat of a concat or an // alternate of an alternate. func (p *parser) collapse(subs []*Regexp, op Op) *Regexp { … } // factor factors common prefixes from the alternation list sub. // It returns a replacement list that reuses the same storage and // frees (passes to p.reuse) any removed *Regexps. // // For example, // // ABC|ABD|AEF|BCX|BCY // // simplifies by literal prefix extraction to // // A(B(C|D)|EF)|BC(X|Y) // // which simplifies by character class introduction to // // A(B[CD]|EF)|BC[XY] func (p *parser) factor(sub []*Regexp) []*Regexp { … } // leadingString returns the leading literal string that re begins with. // The string refers to storage in re or its children. func (p *parser) leadingString(re *Regexp) ([]rune, Flags) { … } // removeLeadingString removes the first n leading runes // from the beginning of re. It returns the replacement for re. func (p *parser) removeLeadingString(re *Regexp, n int) *Regexp { … } // leadingRegexp returns the leading regexp that re begins with. // The regexp refers to storage in re or its children. func (p *parser) leadingRegexp(re *Regexp) *Regexp { … } // removeLeadingRegexp removes the leading regexp in re. // It returns the replacement for re. // If reuse is true, it passes the removed regexp (if no longer needed) to p.reuse. func (p *parser) removeLeadingRegexp(re *Regexp, reuse bool) *Regexp { … } func literalRegexp(s string, flags Flags) *Regexp { … } // Parse parses a regular expression string s, controlled by the specified // Flags, and returns a regular expression parse tree. The syntax is // described in the top-level comment. func Parse(s string, flags Flags) (*Regexp, error) { … } func parse(s string, flags Flags) (_ *Regexp, err error) { … } // parseRepeat parses {min} (max=min) or {min,} (max=-1) or {min,max}. // If s is not of that form, it returns ok == false. // If s has the right form but the values are too big, it returns min == -1, ok == true. func (p *parser) parseRepeat(s string) (min, max int, rest string, ok bool) { … } // parsePerlFlags parses a Perl flag setting or non-capturing group or both, // like (?i) or (?: or (?i:. It removes the prefix from s and updates the parse state. // The caller must have ensured that s begins with "(?". func (p *parser) parsePerlFlags(s string) (rest string, err error) { … } // isValidCaptureName reports whether name // is a valid capture name: [A-Za-z0-9_]+. // PCRE limits names to 32 bytes. // Python rejects names starting with digits. // We don't enforce either of those. func isValidCaptureName(name string) bool { … } // parseInt parses a decimal integer. func (p *parser) parseInt(s string) (n int, rest string, ok bool) { … } // can this be represented as a character class? // single-rune literal string, char class, ., and .|\n. func isCharClass(re *Regexp) bool { … } // does re match r? func matchRune(re *Regexp, r rune) bool { … } // parseVerticalBar handles a | in the input. func (p *parser) parseVerticalBar() { … } // mergeCharClass makes dst = dst|src. // The caller must ensure that dst.Op >= src.Op, // to reduce the amount of copying. func mergeCharClass(dst, src *Regexp) { … } // If the top of the stack is an element followed by an opVerticalBar // swapVerticalBar swaps the two and returns true. // Otherwise it returns false. func (p *parser) swapVerticalBar() bool { … } // parseRightParen handles a ) in the input. func (p *parser) parseRightParen() error { … } // parseEscape parses an escape sequence at the beginning of s // and returns the rune. func (p *parser) parseEscape(s string) (r rune, rest string, err error) { … } // parseClassChar parses a character class character at the beginning of s // and returns it. func (p *parser) parseClassChar(s, wholeClass string) (r rune, rest string, err error) { … } type charGroup … // parsePerlClassEscape parses a leading Perl character class escape like \d // from the beginning of s. If one is present, it appends the characters to r // and returns the new slice r and the remainder of the string. func (p *parser) parsePerlClassEscape(s string, r []rune) (out []rune, rest string) { … } // parseNamedClass parses a leading POSIX named character class like [:alnum:] // from the beginning of s. If one is present, it appends the characters to r // and returns the new slice r and the remainder of the string. func (p *parser) parseNamedClass(s string, r []rune) (out []rune, rest string, err error) { … } func (p *parser) appendGroup(r []rune, g charGroup) []rune { … } var anyTable … // unicodeTable returns the unicode.RangeTable identified by name // and the table of additional fold-equivalent code points. func unicodeTable(name string) (*unicode.RangeTable, *unicode.RangeTable) { … } // parseUnicodeClass parses a leading Unicode character class like \p{Han} // from the beginning of s. If one is present, it appends the characters to r // and returns the new slice r and the remainder of the string. func (p *parser) parseUnicodeClass(s string, r []rune) (out []rune, rest string, err error) { … } // parseClass parses a character class at the beginning of s // and pushes it onto the parse stack. func (p *parser) parseClass(s string) (rest string, err error) { … } // cleanClass sorts the ranges (pairs of elements of r), // merges them, and eliminates duplicates. func cleanClass(rp *[]rune) []rune { … } // inCharClass reports whether r is in the class. // It assumes the class has been cleaned by cleanClass. func inCharClass(r rune, class []rune) bool { … } // appendLiteral returns the result of appending the literal x to the class r. func appendLiteral(r []rune, x rune, flags Flags) []rune { … } // appendRange returns the result of appending the range lo-hi to the class r. func appendRange(r []rune, lo, hi rune) []rune { … } const minFold … const maxFold … // appendFoldedRange returns the result of appending the range lo-hi // and its case folding-equivalent runes to the class r. func appendFoldedRange(r []rune, lo, hi rune) []rune { … } // appendClass returns the result of appending the class x to the class r. // It assume x is clean. func appendClass(r []rune, x []rune) []rune { … } // appendFoldedClass returns the result of appending the case folding of the class x to the class r. func appendFoldedClass(r []rune, x []rune) []rune { … } // appendNegatedClass returns the result of appending the negation of the class x to the class r. // It assumes x is clean. func appendNegatedClass(r []rune, x []rune) []rune { … } // appendTable returns the result of appending x to the class r. func appendTable(r []rune, x *unicode.RangeTable) []rune { … } // appendNegatedTable returns the result of appending the negation of x to the class r. func appendNegatedTable(r []rune, x *unicode.RangeTable) []rune { … } // negateClass overwrites r and returns r's negation. // It assumes the class r is already clean. func negateClass(r []rune) []rune { … } type ranges … func (ra ranges) Less(i, j int) bool { … } func (ra ranges) Len() int { … } func (ra ranges) Swap(i, j int) { … } func checkUTF8(s string) error { … } func nextRune(s string) (c rune, t string, err error) { … } func isalnum(c rune) bool { … } func unhex(c rune) rune { … }
Codebase Browser
go