// Error codes returned by failures to parse an expression.
var (
ErrInternal = "internal error"
- ErrUnmatchedLpar = "unmatched ''"
- ErrUnmatchedRpar = "unmatched ''"
+ ErrUnmatchedLpar = "unmatched '('"
+ ErrUnmatchedRpar = "unmatched ')'"
ErrUnmatchedLbkt = "unmatched '['"
ErrUnmatchedRbkt = "unmatched ']'"
ErrBadRange = "bad range in character class"
ErrExtraneousBackslash = "extraneous backslash"
- ErrBadClosure = "repeated closure **, ++, etc."
+ ErrBadClosure = "repeated closure (**, ++, etc.)"
ErrBareClosure = "closure applies to nothing"
ErrBadBackslash = "illegal backslash escape"
)
type parser struct {
re *Regexp
- error string
nlpar int // number of unclosed lpars
pos int
ch int
}
+func (p *parser) error(err string) {
+ panic(err)
+}
+
const endOfFile = -1
func (p *parser) c() int { return p.ch }
switch c := p.c(); c {
case ']', endOfFile:
if left >= 0 {
- p.error = ErrBadRange
- return nil
+ p.error(ErrBadRange)
}
// Is it [^\n]?
if cc.negate && len(cc.ranges) == 2 &&
p.re.add(cc)
return cc
case '-': // do this before backslash processing
- p.error = ErrBadRange
- return nil
+ p.error(ErrBadRange)
case '\\':
c = p.nextc()
switch {
case c == endOfFile:
- p.error = ErrExtraneousBackslash
- return nil
+ p.error(ErrExtraneousBackslash)
case c == 'n':
c = '\n'
case specialcclass(c):
// c is as delivered
default:
- p.error = ErrBadBackslash
- return nil
+ p.error(ErrBadBackslash)
}
fallthrough
default:
cc.addRange(left, c)
left = -1
default:
- p.error = ErrBadRange
- return nil
+ p.error(ErrBadRange)
}
}
}
}
func (p *parser) term() (start, end instr) {
- // term() is the leaf of the recursion, so it's sufficient to pick off the
- // error state here for early exit.
- // The other functions (closure(), concatenation() etc.) assume
- // it's safe to recur to here.
- if p.error != "" {
- return
- }
switch c := p.c(); c {
case '|', endOfFile:
return nil, nil
case '*', '+':
- p.error = ErrBareClosure
+ p.error(ErrBareClosure)
return
case ')':
if p.nlpar == 0 {
- p.error = ErrUnmatchedRpar
- return
+ p.error(ErrUnmatchedRpar)
}
return nil, nil
case ']':
- p.error = ErrUnmatchedRbkt
- return
+ p.error(ErrUnmatchedRbkt)
case '^':
p.nextc()
start = p.re.add(new(_Bot))
case '[':
p.nextc()
start = p.charClass()
- if p.error != "" {
- return
- }
if p.c() != ']' {
- p.error = ErrUnmatchedLbkt
- return
+ p.error(ErrUnmatchedLbkt)
}
p.nextc()
return start, start
nbra := p.re.nbra
start, end = p.regexp()
if p.c() != ')' {
- p.error = ErrUnmatchedLpar
- return
+ p.error(ErrUnmatchedLpar)
}
p.nlpar--
p.nextc()
ebra.n = nbra
if start == nil {
if end == nil {
- p.error = ErrInternal
- return
+ p.error(ErrInternal)
}
start = ebra
} else {
c = p.nextc()
switch {
case c == endOfFile:
- p.error = ErrExtraneousBackslash
+ p.error(ErrExtraneousBackslash)
return
case c == 'n':
c = '\n'
case special(c):
// c is as delivered
default:
- p.error = ErrBadBackslash
- return
+ p.error(ErrBadBackslash)
}
fallthrough
default:
func (p *parser) closure() (start, end instr) {
start, end = p.term()
- if start == nil || p.error != "" {
+ if start == nil {
return
}
switch p.c() {
}
switch p.nextc() {
case '*', '+', '?':
- p.error = ErrBadClosure
+ p.error(ErrBadClosure)
}
return
}
func (p *parser) concatenation() (start, end instr) {
for {
nstart, nend := p.closure()
- if p.error != "" {
- return
- }
switch {
case nstart == nil: // end of this concatenation
if start == nil { // this is the empty string
func (p *parser) regexp() (start, end instr) {
start, end = p.concatenation()
- if p.error != "" {
- return
- }
for {
switch p.c() {
default:
case '|':
p.nextc()
nstart, nend := p.concatenation()
- if p.error != "" {
- return
- }
alt := new(_Alt)
p.re.add(alt)
alt.left = start
}
}
-func (re *Regexp) doParse() string {
+func (re *Regexp) doParse() {
p := newParser(re)
start := new(_Start)
re.add(start)
s, e := p.regexp()
- if p.error != "" {
- return p.error
- }
start.setNext(s)
re.start = start
e.setNext(re.add(new(_End)))
re.eliminateNops()
- return p.error
}
// CompileRegexp parses a regular expression and returns, if successful, a Regexp
// object that can be used to match against text.
func CompileRegexp(str string) (regexp *Regexp, error string) {
regexp = new(Regexp)
+ // doParse will panic if there is a parse error.
+ defer func() {
+ if e := recover(); e != nil {
+ regexp = nil
+ error = e.(string) // Will re-panic if error was not a string, e.g. nil-pointer exception
+ }
+ }()
regexp.expr = str
regexp.inst = make([]instr, 0, 20)
- error = regexp.doParse()
- if error != "" {
- regexp = nil
- }
+ regexp.doParse()
return
}