buf []byte; // input text to process
p int; // position in buf
linenum int; // position in input
- errors chan os.Error; // for error reporting during parsing (only)
+ error os.Error; // error during parsing (only)
// Parsed results:
elems *vector.Vector;
}
t.fmap = fmap;
t.ldelim = lbrace;
t.rdelim = rbrace;
- t.errors = make(chan os.Error);
t.elems = vector.New(0);
return t;
}
-// Generic error handler, called only from execError or parseError.
-func error(errors chan os.Error, line int, err string, args ...) {
- errors <- &Error{line, fmt.Sprintf(err, args)};
- runtime.Goexit();
-}
-
-// Report error and stop executing. The line number must be provided explicitly.
+// Report error and stop executing. The line number must be provided explicitly.
func (t *Template) execError(st *state, line int, err string, args ...) {
- error(st.errors, line, err, args);
+ st.errors <- &Error{line, fmt.Sprintf(err, args)};
+ runtime.Goexit();
}
-// Report error and stop parsing. The line number comes from the template state.
+// Report error, save in Template to terminate parsing.
+// The line number comes from the template state.
func (t *Template) parseError(err string, args ...) {
- error(t.errors, t.linenum, err, args)
+ t.error = &Error{t.linenum, fmt.Sprintf(err, args)};
}
// -- Lexical analysis
i = j - 1;
case equal(t.buf, i, t.rdelim):
if !sawLeft {
- t.parseError("unmatched closing delimiter")
+ t.parseError("unmatched closing delimiter");
+ return nil;
}
sawLeft = false;
i += len(t.rdelim);
}
}
if sawLeft {
- t.parseError("unmatched opening delimiter")
+ t.parseError("unmatched opening delimiter");
+ return nil;
}
item := t.buf[start:i];
if special && trim_white {
// item is known to be non-empty
if !equal(item, 0, t.ldelim) { // doesn't start with left delimiter
tok = tokText;
- return
+ return;
}
if !equal(item, len(item)-len(t.rdelim), t.rdelim) { // doesn't end with right delimiter
- t.parseError("internal error: unmatched opening delimiter") // lexing should prevent this
+ t.parseError("internal error: unmatched opening delimiter"); // lexing should prevent this
+ return;
}
if len(item) <= len(t.ldelim)+len(t.rdelim) { // no contents
- t.parseError("empty directive")
+ t.parseError("empty directive");
+ return;
}
// Comment
if item[len(t.ldelim)] == '#' {
// Split into words
w = words(item[len(t.ldelim): len(item)-len(t.rdelim)]); // drop final delimiter
if len(w) == 0 {
- t.parseError("empty directive")
+ t.parseError("empty directive");
+ return;
}
if len(w) == 1 && w[0][0] != '.' {
tok = tokVariable;
return;
case ".section":
if len(w) != 2 {
- t.parseError("incorrect fields for .section: %s", item)
+ t.parseError("incorrect fields for .section: %s", item);
+ return;
}
tok = tokSection;
return;
case ".repeated":
if len(w) != 3 || w[1] != "section" {
- t.parseError("incorrect fields for .repeated: %s", item)
+ t.parseError("incorrect fields for .repeated: %s", item);
+ return;
}
tok = tokRepeated;
return;
case ".alternates":
if len(w) != 2 || w[1] != "with" {
- t.parseError("incorrect fields for .alternates: %s", item)
+ t.parseError("incorrect fields for .alternates: %s", item);
+ return;
}
tok = tokAlternates;
return;
// Otherwise return its details.
func (t *Template) parseSimple(item []byte) (done bool, tok int, w []string) {
tok, w = t.analyze(item);
+ if t.error != nil {
+ return
+ }
done = true; // assume for simplicity
switch tok {
case tokComment:
t.elems.Push(&literalElement{tab});
default:
t.parseError("internal error: unknown literal: %s", w[0]);
+ return;
}
return;
case tokVariable:
r.altstart = -1;
r.altend = -1;
Loop:
- for {
+ for t.error == nil {
item := t.nextItem();
+ if t.error != nil {
+ break;
+ }
if len(item) == 0 {
- t.parseError("missing .end for .repeated section")
+ t.parseError("missing .end for .repeated section");
+ break;
}
done, tok, w := t.parseSimple(item);
+ if t.error != nil {
+ break;
+ }
if done {
continue
}
case tokOr:
if r.or >= 0 {
t.parseError("extra .or in .repeated section");
+ break Loop;
}
r.altend = t.elems.Len();
r.or = t.elems.Len();
case tokAlternates:
if r.altstart >= 0 {
t.parseError("extra .alternates in .repeated section");
+ break Loop;
}
if r.or >= 0 {
t.parseError(".alternates inside .or block in .repeated section");
+ break Loop;
}
r.altstart = t.elems.Len();
default:
t.parseError("internal error: unknown repeated section item: %s", item);
+ break Loop;
}
}
+ if t.error != nil {
+ return nil
+ }
if r.altend < 0 {
r.altend = t.elems.Len()
}
s.start = t.elems.Len();
s.or = -1;
Loop:
- for {
+ for t.error == nil {
item := t.nextItem();
+ if t.error != nil {
+ break;
+ }
if len(item) == 0 {
- t.parseError("missing .end for .section")
+ t.parseError("missing .end for .section");
+ break;
}
done, tok, w := t.parseSimple(item);
+ if t.error != nil {
+ break;
+ }
if done {
continue
}
case tokOr:
if s.or >= 0 {
t.parseError("extra .or in .section");
+ break Loop;
}
s.or = t.elems.Len();
case tokSection:
t.parseError("internal error: unknown section item: %s", item);
}
}
+ if t.error != nil {
+ return nil
+ }
s.end = t.elems.Len();
return s;
}
func (t *Template) parse() {
- for {
+ for t.error == nil {
item := t.nextItem();
+ if t.error != nil {
+ break
+ }
if len(item) == 0 {
break
}
t.buf = strings.Bytes(s);
t.p = 0;
t.linenum = 0;
- go func() {
- t.parse();
- t.errors <- nil; // clean return;
- }();
- return <-t.errors;
+ t.parse();
+ return t.error;
}
// Execute applies a parsed template to the specified data object,
func Parse(s string, fmap FormatterMap) (t *Template, err os.Error) {
t = New(fmap);
err = t.Parse(s);
+ if err != nil {
+ t = nil
+ }
return
}
+
+// MustParse is like Parse but panics if the template cannot be parsed.
+func MustParse(s string, fmap FormatterMap) *Template {
+ t , err := Parse(s, fmap);
+ if err != nil {
+ panic("template parse error: ", err);
+ }
+ return t
+}