func Parse(name, src string) (*Chunk, error) {
ps := &parser{src, 0, 0, nil}
bn := parseChunk(ps, nil)
if ps.error != nil {
return bn, errutil.NewContextualError(
name, "syntax error", src, ps.pos, ps.error.Error())
}
if ps.pos != len(src) {
return bn, errutil.NewContextualError(
name, "syntax error", src, ps.pos, "unexpected rune")
}
return bn, nil
}
func Parse(name, src string) (*Chunk, error) {
rd := &reader{src, 0, nil}
bn := parseChunk(rd)
if rd.error != nil {
return nil, errutil.NewContextualError(
name, "syntax error", src, rd.pos, rd.error.Error())
}
return bn, nil
}
// errorf stops the ec.eval immediately by panicking with a diagnostic message.
// The panic is supposed to be caught by ec.eval.
func (ec *EvalCtx) errorf(p int, format string, args ...interface{}) {
throw(errutil.NewContextualError(
fmt.Sprintf("%s (%s)", ec.name, ec.context), "error",
ec.text, p, format, args...))
}
// errorf stops the ec.eval immediately by panicking with a diagnostic message.
// The panic is supposed to be caught by ec.eval.
func (ec *evalCtx) errorf(p parse.Pos, format string, args ...interface{}) {
errutil.Throw(errutil.NewContextualError(
fmt.Sprintf("%s (%s)", ec.name, ec.context), "evalling error",
ec.text, int(p), format, args...))
}
func (cp *compiler) errorf(p int, format string, args ...interface{}) {
throw(errutil.NewContextualError(cp.name, "syntax error", cp.source, p, format, args...))
}
func (cc *compileCtx) errorf(p parse.Pos, format string, args ...interface{}) {
errutil.Throw(errutil.NewContextualError(cc.name, "static error", cc.text, int(p), format, args...))
}
// errorf formats the error and terminates processing.
func (p *Parser) errorf(pos int, format string, args ...interface{}) {
p.Root = nil
errutil.Throw(errutil.NewContextualError(p.Name, "parsing error", p.text, pos, format, args...))
}