347 lines
8.8 KiB
Go
347 lines
8.8 KiB
Go
// Copyright 2009 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.
|
|
|
|
// Code to execute a parsed template.
|
|
|
|
package template
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"reflect"
|
|
"strings"
|
|
)
|
|
|
|
// Internal state for executing a Template. As we evaluate the struct,
|
|
// the data item descends into the fields associated with sections, etc.
|
|
// Parent is used to walk upwards to find variables higher in the tree.
|
|
type state struct {
|
|
parent *state // parent in hierarchy
|
|
data reflect.Value // the driver data for this section etc.
|
|
wr io.Writer // where to send output
|
|
buf [2]bytes.Buffer // alternating buffers used when chaining formatters
|
|
}
|
|
|
|
func (parent *state) clone(data reflect.Value) *state {
|
|
return &state{parent: parent, data: data, wr: parent.wr}
|
|
}
|
|
|
|
// Evaluate interfaces and pointers looking for a value that can look up the name, via a
|
|
// struct field, method, or map key, and return the result of the lookup.
|
|
func (t *Template) lookup(st *state, v reflect.Value, name string) reflect.Value {
|
|
for v.IsValid() {
|
|
typ := v.Type()
|
|
if n := v.Type().NumMethod(); n > 0 {
|
|
for i := 0; i < n; i++ {
|
|
m := typ.Method(i)
|
|
mtyp := m.Type
|
|
if m.Name == name && mtyp.NumIn() == 1 && mtyp.NumOut() == 1 {
|
|
if !isExported(name) {
|
|
t.execError(st, t.linenum, "name not exported: %s in type %s", name, st.data.Type())
|
|
}
|
|
return v.Method(i).Call(nil)[0]
|
|
}
|
|
}
|
|
}
|
|
switch av := v; av.Kind() {
|
|
case reflect.Ptr:
|
|
v = av.Elem()
|
|
case reflect.Interface:
|
|
v = av.Elem()
|
|
case reflect.Struct:
|
|
if !isExported(name) {
|
|
t.execError(st, t.linenum, "name not exported: %s in type %s", name, st.data.Type())
|
|
}
|
|
return av.FieldByName(name)
|
|
case reflect.Map:
|
|
if v := av.MapIndex(reflect.ValueOf(name)); v.IsValid() {
|
|
return v
|
|
}
|
|
return reflect.Zero(typ.Elem())
|
|
default:
|
|
return reflect.Value{}
|
|
}
|
|
}
|
|
return v
|
|
}
|
|
|
|
// indirectPtr returns the item numLevels levels of indirection below the value.
|
|
// It is forgiving: if the value is not a pointer, it returns it rather than giving
|
|
// an error. If the pointer is nil, it is returned as is.
|
|
func indirectPtr(v reflect.Value, numLevels int) reflect.Value {
|
|
for i := numLevels; v.IsValid() && i > 0; i++ {
|
|
if p := v; p.Kind() == reflect.Ptr {
|
|
if p.IsNil() {
|
|
return v
|
|
}
|
|
v = p.Elem()
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
return v
|
|
}
|
|
|
|
// Walk v through pointers and interfaces, extracting the elements within.
|
|
func indirect(v reflect.Value) reflect.Value {
|
|
loop:
|
|
for v.IsValid() {
|
|
switch av := v; av.Kind() {
|
|
case reflect.Ptr:
|
|
v = av.Elem()
|
|
case reflect.Interface:
|
|
v = av.Elem()
|
|
default:
|
|
break loop
|
|
}
|
|
}
|
|
return v
|
|
}
|
|
|
|
// If the data for this template is a struct, find the named variable.
|
|
// Names of the form a.b.c are walked down the data tree.
|
|
// The special name "@" (the "cursor") denotes the current data.
|
|
// The value coming in (st.data) might need indirecting to reach
|
|
// a struct while the return value is not indirected - that is,
|
|
// it represents the actual named field. Leading stars indicate
|
|
// levels of indirection to be applied to the value.
|
|
func (t *Template) findVar(st *state, s string) reflect.Value {
|
|
data := st.data
|
|
flattenedName := strings.TrimLeft(s, "*")
|
|
numStars := len(s) - len(flattenedName)
|
|
s = flattenedName
|
|
if s == "@" {
|
|
return indirectPtr(data, numStars)
|
|
}
|
|
for _, elem := range strings.Split(s, ".") {
|
|
// Look up field; data must be a struct or map.
|
|
data = t.lookup(st, data, elem)
|
|
if !data.IsValid() {
|
|
return reflect.Value{}
|
|
}
|
|
}
|
|
return indirectPtr(data, numStars)
|
|
}
|
|
|
|
// Is there no data to look at?
|
|
func empty(v reflect.Value) bool {
|
|
v = indirect(v)
|
|
if !v.IsValid() {
|
|
return true
|
|
}
|
|
switch v.Kind() {
|
|
case reflect.Bool:
|
|
return v.Bool() == false
|
|
case reflect.String:
|
|
return v.String() == ""
|
|
case reflect.Struct:
|
|
return false
|
|
case reflect.Map:
|
|
return false
|
|
case reflect.Array:
|
|
return v.Len() == 0
|
|
case reflect.Slice:
|
|
return v.Len() == 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Look up a variable or method, up through the parent if necessary.
|
|
func (t *Template) varValue(name string, st *state) reflect.Value {
|
|
field := t.findVar(st, name)
|
|
if !field.IsValid() {
|
|
if st.parent == nil {
|
|
t.execError(st, t.linenum, "name not found: %s in type %s", name, st.data.Type())
|
|
}
|
|
return t.varValue(name, st.parent)
|
|
}
|
|
return field
|
|
}
|
|
|
|
func (t *Template) format(wr io.Writer, fmt string, val []interface{}, v *variableElement, st *state) {
|
|
fn := t.formatter(fmt)
|
|
if fn == nil {
|
|
t.execError(st, v.linenum, "missing formatter %s for variable", fmt)
|
|
}
|
|
fn(wr, fmt, val...)
|
|
}
|
|
|
|
// Evaluate a variable, looking up through the parent if necessary.
|
|
// If it has a formatter attached ({var|formatter}) run that too.
|
|
func (t *Template) writeVariable(v *variableElement, st *state) {
|
|
// Resolve field names
|
|
val := make([]interface{}, len(v.args))
|
|
for i, arg := range v.args {
|
|
if name, ok := arg.(fieldName); ok {
|
|
val[i] = t.varValue(string(name), st).Interface()
|
|
} else {
|
|
val[i] = arg
|
|
}
|
|
}
|
|
for i, fmt := range v.fmts[:len(v.fmts)-1] {
|
|
b := &st.buf[i&1]
|
|
b.Reset()
|
|
t.format(b, fmt, val, v, st)
|
|
val = val[0:1]
|
|
val[0] = b.Bytes()
|
|
}
|
|
t.format(st.wr, v.fmts[len(v.fmts)-1], val, v, st)
|
|
}
|
|
|
|
// Execute element i. Return next index to execute.
|
|
func (t *Template) executeElement(i int, st *state) int {
|
|
switch elem := t.elems[i].(type) {
|
|
case *textElement:
|
|
st.wr.Write(elem.text)
|
|
return i + 1
|
|
case *literalElement:
|
|
st.wr.Write(elem.text)
|
|
return i + 1
|
|
case *variableElement:
|
|
t.writeVariable(elem, st)
|
|
return i + 1
|
|
case *sectionElement:
|
|
t.executeSection(elem, st)
|
|
return elem.end
|
|
case *repeatedElement:
|
|
t.executeRepeated(elem, st)
|
|
return elem.end
|
|
}
|
|
e := t.elems[i]
|
|
t.execError(st, 0, "internal error: bad directive in execute: %v %T\n", reflect.ValueOf(e).Interface(), e)
|
|
return 0
|
|
}
|
|
|
|
// Execute the template.
|
|
func (t *Template) execute(start, end int, st *state) {
|
|
for i := start; i < end; {
|
|
i = t.executeElement(i, st)
|
|
}
|
|
}
|
|
|
|
// Execute a .section
|
|
func (t *Template) executeSection(s *sectionElement, st *state) {
|
|
// Find driver data for this section. It must be in the current struct.
|
|
field := t.varValue(s.field, st)
|
|
if !field.IsValid() {
|
|
t.execError(st, s.linenum, ".section: cannot find field %s in %s", s.field, st.data.Type())
|
|
}
|
|
st = st.clone(field)
|
|
start, end := s.start, s.or
|
|
if !empty(field) {
|
|
// Execute the normal block.
|
|
if end < 0 {
|
|
end = s.end
|
|
}
|
|
} else {
|
|
// Execute the .or block. If it's missing, do nothing.
|
|
start, end = s.or, s.end
|
|
if start < 0 {
|
|
return
|
|
}
|
|
}
|
|
for i := start; i < end; {
|
|
i = t.executeElement(i, st)
|
|
}
|
|
}
|
|
|
|
// Return the result of calling the Iter method on v, or nil.
|
|
func iter(v reflect.Value) reflect.Value {
|
|
for j := 0; j < v.Type().NumMethod(); j++ {
|
|
mth := v.Type().Method(j)
|
|
fv := v.Method(j)
|
|
ft := fv.Type()
|
|
// TODO(rsc): NumIn() should return 0 here, because ft is from a curried FuncValue.
|
|
if mth.Name != "Iter" || ft.NumIn() != 1 || ft.NumOut() != 1 {
|
|
continue
|
|
}
|
|
ct := ft.Out(0)
|
|
if ct.Kind() != reflect.Chan ||
|
|
ct.ChanDir()&reflect.RecvDir == 0 {
|
|
continue
|
|
}
|
|
return fv.Call(nil)[0]
|
|
}
|
|
return reflect.Value{}
|
|
}
|
|
|
|
// Execute a .repeated section
|
|
func (t *Template) executeRepeated(r *repeatedElement, st *state) {
|
|
// Find driver data for this section. It must be in the current struct.
|
|
field := t.varValue(r.field, st)
|
|
if !field.IsValid() {
|
|
t.execError(st, r.linenum, ".repeated: cannot find field %s in %s", r.field, st.data.Type())
|
|
}
|
|
field = indirect(field)
|
|
|
|
start, end := r.start, r.or
|
|
if end < 0 {
|
|
end = r.end
|
|
}
|
|
if r.altstart >= 0 {
|
|
end = r.altstart
|
|
}
|
|
first := true
|
|
|
|
// Code common to all the loops.
|
|
loopBody := func(newst *state) {
|
|
// .alternates between elements
|
|
if !first && r.altstart >= 0 {
|
|
for i := r.altstart; i < r.altend; {
|
|
i = t.executeElement(i, newst)
|
|
}
|
|
}
|
|
first = false
|
|
for i := start; i < end; {
|
|
i = t.executeElement(i, newst)
|
|
}
|
|
}
|
|
|
|
if array := field; array.Kind() == reflect.Array || array.Kind() == reflect.Slice {
|
|
for j := 0; j < array.Len(); j++ {
|
|
loopBody(st.clone(array.Index(j)))
|
|
}
|
|
} else if m := field; m.Kind() == reflect.Map {
|
|
for _, key := range m.MapKeys() {
|
|
loopBody(st.clone(m.MapIndex(key)))
|
|
}
|
|
} else if ch := iter(field); ch.IsValid() {
|
|
for {
|
|
e, ok := ch.Recv()
|
|
if !ok {
|
|
break
|
|
}
|
|
loopBody(st.clone(e))
|
|
}
|
|
} else {
|
|
t.execError(st, r.linenum, ".repeated: cannot repeat %s (type %s)",
|
|
r.field, field.Type())
|
|
}
|
|
|
|
if first {
|
|
// Empty. Execute the .or block, once. If it's missing, do nothing.
|
|
start, end := r.or, r.end
|
|
if start >= 0 {
|
|
newst := st.clone(field)
|
|
for i := start; i < end; {
|
|
i = t.executeElement(i, newst)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
// A valid delimiter must contain no space and be non-empty.
|
|
func validDelim(d []byte) bool {
|
|
if len(d) == 0 {
|
|
return false
|
|
}
|
|
for _, c := range d {
|
|
if isSpace(c) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|