code review 4643068: exp/template: functions

src/pkg/exp/template/parse.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package template
 
 import (
         "bytes"
         "fmt"
         "os"
+        "reflect"
         "runtime"
         "strconv"
         "strings"
         "unicode"
 )
 
 // Template is the representation of a parsed template.
 type Template struct {
-        name string
-        root *listNode
+        name  string
+        root  *listNode
+        funcs map[string]reflect.Value
         // Parsing.
         lex      *lexer
         tokens   <-chan item
         token    item // token lookahead for parser
         havePeek bool
 }
 
 // next returns the next token.
 func (t *Template) next() item {
         if t.havePeek {
@@ skipping 412 matching lines @@
         }
         return fmt.Sprintf("({{with %s}} %s)", w.pipeline, w.list)
 }
 
 
 // Parsing.
 
 // New allocates a new template with the given name.
 func New(name string) *Template {
         return &Template{
-                name: name,
+                name:  name,
+                funcs: make(map[string]reflect.Value),
         }
 }
 
+// Funcs adds to the template's function map the elements of the
+// argument map.   It panics if a value in the map is not a function.
+// The return value is the template, so calls can be chained; it will be

[dsymonds, 2011/07/05 04:17:04]

It won't be nil; the return value will always be t.

+// nil in the error case.
+func (t *Template) Funcs(funcMap FuncMap) *Template {
+        addFuncs(t.funcs, funcMap)
+        return t
+}
+
 // errorf formats the error and terminates processing.
 func (t *Template) errorf(format string, args ...interface{}) {
+        t.root = nil
         format = fmt.Sprintf("template: %s:%d: %s", t.name, t.lex.lineNumber(), format)
         panic(fmt.Errorf(format, args...))
 }
 
 // error terminates processing.
 func (t *Template) error(err os.Error) {
         t.errorf("%s", err)
 }
 
 // expect consumes the next token and guarantees it has the required type.
@@ skipping 12 matching lines @@
 
 // recover is the handler that turns panics into returns from the top
 // level of Parse or Execute.
 func (t *Template) recover(errp *os.Error) {
         e := recover()
         if e != nil {
                 if _, ok := e.(runtime.Error); ok {
                         panic(e)
                 }
                 t.stopParse()
-                t.root = nil
                 *errp = e.(os.Error)
         }
         return
 }
 
 // startParse starts the template parsing from the lexer.
 func (t *Template) startParse(lex *lexer, tokens <-chan item) {
         t.root = nil
         t.lex, t.tokens = lex, tokens
 }
@@ skipping 242 matching lines @@
                         cmd.append(newString(s))
                 default:
                         t.unexpected(token, "command")
                 }
         }
         if len(cmd.args) == 0 {
                 t.errorf("empty command")
         }
         return cmd
 }