Source file src/pkg/text/template/exec.go

     1	// Copyright 2011 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package template
     6	
     7	import (
     8		"fmt"
     9		"io"
    10		"reflect"
    11		"runtime"
    12		"sort"
    13		"strings"
    14		"text/template/parse"
    15	)
    16	
    17	// state represents the state of an execution. It's not part of the
    18	// template so that multiple executions of the same template
    19	// can execute in parallel.
    20	type state struct {
    21		tmpl *Template
    22		wr   io.Writer
    23		line int        // line number for errors
    24		vars []variable // push-down stack of variable values.
    25	}
    26	
    27	// variable holds the dynamic value of a variable such as $, $x etc.
    28	type variable struct {
    29		name  string
    30		value reflect.Value
    31	}
    32	
    33	// push pushes a new variable on the stack.
    34	func (s *state) push(name string, value reflect.Value) {
    35		s.vars = append(s.vars, variable{name, value})
    36	}
    37	
    38	// mark returns the length of the variable stack.
    39	func (s *state) mark() int {
    40		return len(s.vars)
    41	}
    42	
    43	// pop pops the variable stack up to the mark.
    44	func (s *state) pop(mark int) {
    45		s.vars = s.vars[0:mark]
    46	}
    47	
    48	// setVar overwrites the top-nth variable on the stack. Used by range iterations.
    49	func (s *state) setVar(n int, value reflect.Value) {
    50		s.vars[len(s.vars)-n].value = value
    51	}
    52	
    53	// varValue returns the value of the named variable.
    54	func (s *state) varValue(name string) reflect.Value {
    55		for i := s.mark() - 1; i >= 0; i-- {
    56			if s.vars[i].name == name {
    57				return s.vars[i].value
    58			}
    59		}
    60		s.errorf("undefined variable: %s", name)
    61		return zero
    62	}
    63	
    64	var zero reflect.Value
    65	
    66	// errorf formats the error and terminates processing.
    67	func (s *state) errorf(format string, args ...interface{}) {
    68		format = fmt.Sprintf("template: %s:%d: %s", s.tmpl.Name(), s.line, format)
    69		panic(fmt.Errorf(format, args...))
    70	}
    71	
    72	// error terminates processing.
    73	func (s *state) error(err error) {
    74		s.errorf("%s", err)
    75	}
    76	
    77	// errRecover is the handler that turns panics into returns from the top
    78	// level of Parse.
    79	func errRecover(errp *error) {
    80		e := recover()
    81		if e != nil {
    82			switch err := e.(type) {
    83			case runtime.Error:
    84				panic(e)
    85			case error:
    86				*errp = err
    87			default:
    88				panic(e)
    89			}
    90		}
    91	}
    92	
    93	// ExecuteTemplate applies the template associated with t that has the given name
    94	// to the specified data object and writes the output to wr.
    95	func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error {
    96		tmpl := t.tmpl[name]
    97		if tmpl == nil {
    98			return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
    99		}
   100		return tmpl.Execute(wr, data)
   101	}
   102	
   103	// Execute applies a parsed template to the specified data object,
   104	// and writes the output to wr.
   105	func (t *Template) Execute(wr io.Writer, data interface{}) (err error) {
   106		defer errRecover(&err)
   107		value := reflect.ValueOf(data)
   108		state := &state{
   109			tmpl: t,
   110			wr:   wr,
   111			line: 1,
   112			vars: []variable{{"$", value}},
   113		}
   114		if t.Tree == nil || t.Root == nil {
   115			state.errorf("%q is an incomplete or empty template", t.name)
   116		}
   117		state.walk(value, t.Root)
   118		return
   119	}
   120	
   121	// Walk functions step through the major pieces of the template structure,
   122	// generating output as they go.
   123	func (s *state) walk(dot reflect.Value, n parse.Node) {
   124		switch n := n.(type) {
   125		case *parse.ActionNode:
   126			s.line = n.Line
   127			// Do not pop variables so they persist until next end.
   128			// Also, if the action declares variables, don't print the result.
   129			val := s.evalPipeline(dot, n.Pipe)
   130			if len(n.Pipe.Decl) == 0 {
   131				s.printValue(n, val)
   132			}
   133		case *parse.IfNode:
   134			s.line = n.Line
   135			s.walkIfOrWith(parse.NodeIf, dot, n.Pipe, n.List, n.ElseList)
   136		case *parse.ListNode:
   137			for _, node := range n.Nodes {
   138				s.walk(dot, node)
   139			}
   140		case *parse.RangeNode:
   141			s.line = n.Line
   142			s.walkRange(dot, n)
   143		case *parse.TemplateNode:
   144			s.line = n.Line
   145			s.walkTemplate(dot, n)
   146		case *parse.TextNode:
   147			if _, err := s.wr.Write(n.Text); err != nil {
   148				s.error(err)
   149			}
   150		case *parse.WithNode:
   151			s.line = n.Line
   152			s.walkIfOrWith(parse.NodeWith, dot, n.Pipe, n.List, n.ElseList)
   153		default:
   154			s.errorf("unknown node: %s", n)
   155		}
   156	}
   157	
   158	// walkIfOrWith walks an 'if' or 'with' node. The two control structures
   159	// are identical in behavior except that 'with' sets dot.
   160	func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) {
   161		defer s.pop(s.mark())
   162		val := s.evalPipeline(dot, pipe)
   163		truth, ok := isTrue(val)
   164		if !ok {
   165			s.errorf("if/with can't use %v", val)
   166		}
   167		if truth {
   168			if typ == parse.NodeWith {
   169				s.walk(val, list)
   170			} else {
   171				s.walk(dot, list)
   172			}
   173		} else if elseList != nil {
   174			s.walk(dot, elseList)
   175		}
   176	}
   177	
   178	// isTrue returns whether the value is 'true', in the sense of not the zero of its type,
   179	// and whether the value has a meaningful truth value.
   180	func isTrue(val reflect.Value) (truth, ok bool) {
   181		if !val.IsValid() {
   182			// Something like var x interface{}, never set. It's a form of nil.
   183			return false, true
   184		}
   185		switch val.Kind() {
   186		case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
   187			truth = val.Len() > 0
   188		case reflect.Bool:
   189			truth = val.Bool()
   190		case reflect.Complex64, reflect.Complex128:
   191			truth = val.Complex() != 0
   192		case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface:
   193			truth = !val.IsNil()
   194		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   195			truth = val.Int() != 0
   196		case reflect.Float32, reflect.Float64:
   197			truth = val.Float() != 0
   198		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   199			truth = val.Uint() != 0
   200		case reflect.Struct:
   201			truth = true // Struct values are always true.
   202		default:
   203			return
   204		}
   205		return truth, true
   206	}
   207	
   208	func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
   209		defer s.pop(s.mark())
   210		val, _ := indirect(s.evalPipeline(dot, r.Pipe))
   211		// mark top of stack before any variables in the body are pushed.
   212		mark := s.mark()
   213		oneIteration := func(index, elem reflect.Value) {
   214			// Set top var (lexically the second if there are two) to the element.
   215			if len(r.Pipe.Decl) > 0 {
   216				s.setVar(1, elem)
   217			}
   218			// Set next var (lexically the first if there are two) to the index.
   219			if len(r.Pipe.Decl) > 1 {
   220				s.setVar(2, index)
   221			}
   222			s.walk(elem, r.List)
   223			s.pop(mark)
   224		}
   225		switch val.Kind() {
   226		case reflect.Array, reflect.Slice:
   227			if val.Len() == 0 {
   228				break
   229			}
   230			for i := 0; i < val.Len(); i++ {
   231				oneIteration(reflect.ValueOf(i), val.Index(i))
   232			}
   233			return
   234		case reflect.Map:
   235			if val.Len() == 0 {
   236				break
   237			}
   238			for _, key := range sortKeys(val.MapKeys()) {
   239				oneIteration(key, val.MapIndex(key))
   240			}
   241			return
   242		case reflect.Chan:
   243			if val.IsNil() {
   244				break
   245			}
   246			i := 0
   247			for ; ; i++ {
   248				elem, ok := val.Recv()
   249				if !ok {
   250					break
   251				}
   252				oneIteration(reflect.ValueOf(i), elem)
   253			}
   254			if i == 0 {
   255				break
   256			}
   257			return
   258		case reflect.Invalid:
   259			break // An invalid value is likely a nil map, etc. and acts like an empty map.
   260		default:
   261			s.errorf("range can't iterate over %v", val)
   262		}
   263		if r.ElseList != nil {
   264			s.walk(dot, r.ElseList)
   265		}
   266	}
   267	
   268	func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
   269		tmpl := s.tmpl.tmpl[t.Name]
   270		if tmpl == nil {
   271			s.errorf("template %q not defined", t.Name)
   272		}
   273		// Variables declared by the pipeline persist.
   274		dot = s.evalPipeline(dot, t.Pipe)
   275		newState := *s
   276		newState.tmpl = tmpl
   277		// No dynamic scoping: template invocations inherit no variables.
   278		newState.vars = []variable{{"$", dot}}
   279		newState.walk(dot, tmpl.Root)
   280	}
   281	
   282	// Eval functions evaluate pipelines, commands, and their elements and extract
   283	// values from the data structure by examining fields, calling methods, and so on.
   284	// The printing of those values happens only through walk functions.
   285	
   286	// evalPipeline returns the value acquired by evaluating a pipeline. If the
   287	// pipeline has a variable declaration, the variable will be pushed on the
   288	// stack. Callers should therefore pop the stack after they are finished
   289	// executing commands depending on the pipeline value.
   290	func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) {
   291		if pipe == nil {
   292			return
   293		}
   294		for _, cmd := range pipe.Cmds {
   295			value = s.evalCommand(dot, cmd, value) // previous value is this one's final arg.
   296			// If the object has type interface{}, dig down one level to the thing inside.
   297			if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
   298				value = reflect.ValueOf(value.Interface()) // lovely!
   299			}
   300		}
   301		for _, variable := range pipe.Decl {
   302			s.push(variable.Ident[0], value)
   303		}
   304		return value
   305	}
   306	
   307	func (s *state) notAFunction(args []parse.Node, final reflect.Value) {
   308		if len(args) > 1 || final.IsValid() {
   309			s.errorf("can't give argument to non-function %s", args[0])
   310		}
   311	}
   312	
   313	func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value {
   314		firstWord := cmd.Args[0]
   315		switch n := firstWord.(type) {
   316		case *parse.FieldNode:
   317			return s.evalFieldNode(dot, n, cmd.Args, final)
   318		case *parse.IdentifierNode:
   319			// Must be a function.
   320			return s.evalFunction(dot, n.Ident, cmd.Args, final)
   321		case *parse.VariableNode:
   322			return s.evalVariableNode(dot, n, cmd.Args, final)
   323		}
   324		s.notAFunction(cmd.Args, final)
   325		switch word := firstWord.(type) {
   326		case *parse.BoolNode:
   327			return reflect.ValueOf(word.True)
   328		case *parse.DotNode:
   329			return dot
   330		case *parse.NumberNode:
   331			return s.idealConstant(word)
   332		case *parse.StringNode:
   333			return reflect.ValueOf(word.Text)
   334		}
   335		s.errorf("can't evaluate command %q", firstWord)
   336		panic("not reached")
   337	}
   338	
   339	// idealConstant is called to return the value of a number in a context where
   340	// we don't know the type. In that case, the syntax of the number tells us
   341	// its type, and we use Go rules to resolve.  Note there is no such thing as
   342	// a uint ideal constant in this situation - the value must be of int type.
   343	func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
   344		// These are ideal constants but we don't know the type
   345		// and we have no context.  (If it was a method argument,
   346		// we'd know what we need.) The syntax guides us to some extent.
   347		switch {
   348		case constant.IsComplex:
   349			return reflect.ValueOf(constant.Complex128) // incontrovertible.
   350		case constant.IsFloat && strings.IndexAny(constant.Text, ".eE") >= 0:
   351			return reflect.ValueOf(constant.Float64)
   352		case constant.IsInt:
   353			n := int(constant.Int64)
   354			if int64(n) != constant.Int64 {
   355				s.errorf("%s overflows int", constant.Text)
   356			}
   357			return reflect.ValueOf(n)
   358		case constant.IsUint:
   359			s.errorf("%s overflows int", constant.Text)
   360		}
   361		return zero
   362	}
   363	
   364	func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
   365		return s.evalFieldChain(dot, dot, field.Ident, args, final)
   366	}
   367	
   368	func (s *state) evalVariableNode(dot reflect.Value, v *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
   369		// $x.Field has $x as the first ident, Field as the second. Eval the var, then the fields.
   370		value := s.varValue(v.Ident[0])
   371		if len(v.Ident) == 1 {
   372			s.notAFunction(args, final)
   373			return value
   374		}
   375		return s.evalFieldChain(dot, value, v.Ident[1:], args, final)
   376	}
   377	
   378	// evalFieldChain evaluates .X.Y.Z possibly followed by arguments.
   379	// dot is the environment in which to evaluate arguments, while
   380	// receiver is the value being walked along the chain.
   381	func (s *state) evalFieldChain(dot, receiver reflect.Value, ident []string, args []parse.Node, final reflect.Value) reflect.Value {
   382		n := len(ident)
   383		for i := 0; i < n-1; i++ {
   384			receiver = s.evalField(dot, ident[i], nil, zero, receiver)
   385		}
   386		// Now if it's a method, it gets the arguments.
   387		return s.evalField(dot, ident[n-1], args, final, receiver)
   388	}
   389	
   390	func (s *state) evalFunction(dot reflect.Value, name string, args []parse.Node, final reflect.Value) reflect.Value {
   391		function, ok := findFunction(name, s.tmpl)
   392		if !ok {
   393			s.errorf("%q is not a defined function", name)
   394		}
   395		return s.evalCall(dot, function, name, args, final)
   396	}
   397	
   398	// evalField evaluates an expression like (.Field) or (.Field arg1 arg2).
   399	// The 'final' argument represents the return value from the preceding
   400	// value of the pipeline, if any.
   401	func (s *state) evalField(dot reflect.Value, fieldName string, args []parse.Node, final, receiver reflect.Value) reflect.Value {
   402		if !receiver.IsValid() {
   403			return zero
   404		}
   405		typ := receiver.Type()
   406		receiver, _ = indirect(receiver)
   407		// Unless it's an interface, need to get to a value of type *T to guarantee
   408		// we see all methods of T and *T.
   409		ptr := receiver
   410		if ptr.Kind() != reflect.Interface && ptr.CanAddr() {
   411			ptr = ptr.Addr()
   412		}
   413		if method := ptr.MethodByName(fieldName); method.IsValid() {
   414			return s.evalCall(dot, method, fieldName, args, final)
   415		}
   416		hasArgs := len(args) > 1 || final.IsValid()
   417		// It's not a method; is it a field of a struct?
   418		receiver, isNil := indirect(receiver)
   419		if receiver.Kind() == reflect.Struct {
   420			tField, ok := receiver.Type().FieldByName(fieldName)
   421			if ok {
   422				field := receiver.FieldByIndex(tField.Index)
   423				if tField.PkgPath == "" { // field is exported
   424					// If it's a function, we must call it.
   425					if hasArgs {
   426						s.errorf("%s has arguments but cannot be invoked as function", fieldName)
   427					}
   428					return field
   429				}
   430			}
   431		}
   432		// If it's a map, attempt to use the field name as a key.
   433		if receiver.Kind() == reflect.Map {
   434			nameVal := reflect.ValueOf(fieldName)
   435			if nameVal.Type().AssignableTo(receiver.Type().Key()) {
   436				if hasArgs {
   437					s.errorf("%s is not a method but has arguments", fieldName)
   438				}
   439				return receiver.MapIndex(nameVal)
   440			}
   441		}
   442		if isNil {
   443			s.errorf("nil pointer evaluating %s.%s", typ, fieldName)
   444		}
   445		s.errorf("can't evaluate field %s in type %s", fieldName, typ)
   446		panic("not reached")
   447	}
   448	
   449	var (
   450		errorType       = reflect.TypeOf((*error)(nil)).Elem()
   451		fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
   452	)
   453	
   454	// evalCall executes a function or method call. If it's a method, fun already has the receiver bound, so
   455	// it looks just like a function call.  The arg list, if non-nil, includes (in the manner of the shell), arg[0]
   456	// as the function itself.
   457	func (s *state) evalCall(dot, fun reflect.Value, name string, args []parse.Node, final reflect.Value) reflect.Value {
   458		if args != nil {
   459			args = args[1:] // Zeroth arg is function name/node; not passed to function.
   460		}
   461		typ := fun.Type()
   462		numIn := len(args)
   463		if final.IsValid() {
   464			numIn++
   465		}
   466		numFixed := len(args)
   467		if typ.IsVariadic() {
   468			numFixed = typ.NumIn() - 1 // last arg is the variadic one.
   469			if numIn < numFixed {
   470				s.errorf("wrong number of args for %s: want at least %d got %d", name, typ.NumIn()-1, len(args))
   471			}
   472		} else if numIn < typ.NumIn()-1 || !typ.IsVariadic() && numIn != typ.NumIn() {
   473			s.errorf("wrong number of args for %s: want %d got %d", name, typ.NumIn(), len(args))
   474		}
   475		if !goodFunc(typ) {
   476			s.errorf("can't handle multiple results from method/function %q", name)
   477		}
   478		// Build the arg list.
   479		argv := make([]reflect.Value, numIn)
   480		// Args must be evaluated. Fixed args first.
   481		i := 0
   482		for ; i < numFixed; i++ {
   483			argv[i] = s.evalArg(dot, typ.In(i), args[i])
   484		}
   485		// Now the ... args.
   486		if typ.IsVariadic() {
   487			argType := typ.In(typ.NumIn() - 1).Elem() // Argument is a slice.
   488			for ; i < len(args); i++ {
   489				argv[i] = s.evalArg(dot, argType, args[i])
   490			}
   491		}
   492		// Add final value if necessary.
   493		if final.IsValid() {
   494			t := typ.In(typ.NumIn() - 1)
   495			if typ.IsVariadic() {
   496				t = t.Elem()
   497			}
   498			argv[i] = s.validateType(final, t)
   499		}
   500		result := fun.Call(argv)
   501		// If we have an error that is not nil, stop execution and return that error to the caller.
   502		if len(result) == 2 && !result[1].IsNil() {
   503			s.errorf("error calling %s: %s", name, result[1].Interface().(error))
   504		}
   505		return result[0]
   506	}
   507	
   508	// validateType guarantees that the value is valid and assignable to the type.
   509	func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
   510		if !value.IsValid() {
   511			switch typ.Kind() {
   512			case reflect.Interface, reflect.Ptr, reflect.Chan, reflect.Map, reflect.Slice, reflect.Func:
   513				// An untyped nil interface{}. Accept as a proper nil value.
   514				// TODO: Can we delete the other types in this list? Should we?
   515				value = reflect.Zero(typ)
   516			default:
   517				s.errorf("invalid value; expected %s", typ)
   518			}
   519		}
   520		if !value.Type().AssignableTo(typ) {
   521			// Does one dereference or indirection work? We could do more, as we
   522			// do with method receivers, but that gets messy and method receivers
   523			// are much more constrained, so it makes more sense there than here.
   524			// Besides, one is almost always all you need.
   525			switch {
   526			case value.Kind() == reflect.Ptr && value.Type().Elem().AssignableTo(typ):
   527				value = value.Elem()
   528			case reflect.PtrTo(value.Type()).AssignableTo(typ) && value.CanAddr():
   529				value = value.Addr()
   530			default:
   531				s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
   532			}
   533		}
   534		return value
   535	}
   536	
   537	func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
   538		switch arg := n.(type) {
   539		case *parse.DotNode:
   540			return s.validateType(dot, typ)
   541		case *parse.FieldNode:
   542			return s.validateType(s.evalFieldNode(dot, arg, []parse.Node{n}, zero), typ)
   543		case *parse.VariableNode:
   544			return s.validateType(s.evalVariableNode(dot, arg, nil, zero), typ)
   545		}
   546		switch typ.Kind() {
   547		case reflect.Bool:
   548			return s.evalBool(typ, n)
   549		case reflect.Complex64, reflect.Complex128:
   550			return s.evalComplex(typ, n)
   551		case reflect.Float32, reflect.Float64:
   552			return s.evalFloat(typ, n)
   553		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   554			return s.evalInteger(typ, n)
   555		case reflect.Interface:
   556			if typ.NumMethod() == 0 {
   557				return s.evalEmptyInterface(dot, n)
   558			}
   559		case reflect.String:
   560			return s.evalString(typ, n)
   561		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   562			return s.evalUnsignedInteger(typ, n)
   563		}
   564		s.errorf("can't handle %s for arg of type %s", n, typ)
   565		panic("not reached")
   566	}
   567	
   568	func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
   569		if n, ok := n.(*parse.BoolNode); ok {
   570			value := reflect.New(typ).Elem()
   571			value.SetBool(n.True)
   572			return value
   573		}
   574		s.errorf("expected bool; found %s", n)
   575		panic("not reached")
   576	}
   577	
   578	func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
   579		if n, ok := n.(*parse.StringNode); ok {
   580			value := reflect.New(typ).Elem()
   581			value.SetString(n.Text)
   582			return value
   583		}
   584		s.errorf("expected string; found %s", n)
   585		panic("not reached")
   586	}
   587	
   588	func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
   589		if n, ok := n.(*parse.NumberNode); ok && n.IsInt {
   590			value := reflect.New(typ).Elem()
   591			value.SetInt(n.Int64)
   592			return value
   593		}
   594		s.errorf("expected integer; found %s", n)
   595		panic("not reached")
   596	}
   597	
   598	func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
   599		if n, ok := n.(*parse.NumberNode); ok && n.IsUint {
   600			value := reflect.New(typ).Elem()
   601			value.SetUint(n.Uint64)
   602			return value
   603		}
   604		s.errorf("expected unsigned integer; found %s", n)
   605		panic("not reached")
   606	}
   607	
   608	func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
   609		if n, ok := n.(*parse.NumberNode); ok && n.IsFloat {
   610			value := reflect.New(typ).Elem()
   611			value.SetFloat(n.Float64)
   612			return value
   613		}
   614		s.errorf("expected float; found %s", n)
   615		panic("not reached")
   616	}
   617	
   618	func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
   619		if n, ok := n.(*parse.NumberNode); ok && n.IsComplex {
   620			value := reflect.New(typ).Elem()
   621			value.SetComplex(n.Complex128)
   622			return value
   623		}
   624		s.errorf("expected complex; found %s", n)
   625		panic("not reached")
   626	}
   627	
   628	func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value {
   629		switch n := n.(type) {
   630		case *parse.BoolNode:
   631			return reflect.ValueOf(n.True)
   632		case *parse.DotNode:
   633			return dot
   634		case *parse.FieldNode:
   635			return s.evalFieldNode(dot, n, nil, zero)
   636		case *parse.IdentifierNode:
   637			return s.evalFunction(dot, n.Ident, nil, zero)
   638		case *parse.NumberNode:
   639			return s.idealConstant(n)
   640		case *parse.StringNode:
   641			return reflect.ValueOf(n.Text)
   642		case *parse.VariableNode:
   643			return s.evalVariableNode(dot, n, nil, zero)
   644		}
   645		s.errorf("can't handle assignment of %s to empty interface argument", n)
   646		panic("not reached")
   647	}
   648	
   649	// indirect returns the item at the end of indirection, and a bool to indicate if it's nil.
   650	// We indirect through pointers and empty interfaces (only) because
   651	// non-empty interfaces have methods we might need.
   652	func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
   653		for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
   654			if v.IsNil() {
   655				return v, true
   656			}
   657			if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
   658				break
   659			}
   660		}
   661		return v, false
   662	}
   663	
   664	// printValue writes the textual representation of the value to the output of
   665	// the template.
   666	func (s *state) printValue(n parse.Node, v reflect.Value) {
   667		if v.Kind() == reflect.Ptr {
   668			v, _ = indirect(v) // fmt.Fprint handles nil.
   669		}
   670		if !v.IsValid() {
   671			fmt.Fprint(s.wr, "<no value>")
   672			return
   673		}
   674	
   675		if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
   676			if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) {
   677				v = v.Addr()
   678			} else {
   679				switch v.Kind() {
   680				case reflect.Chan, reflect.Func:
   681					s.errorf("can't print %s of type %s", n, v.Type())
   682				}
   683			}
   684		}
   685		fmt.Fprint(s.wr, v.Interface())
   686	}
   687	
   688	// Types to help sort the keys in a map for reproducible output.
   689	
   690	type rvs []reflect.Value
   691	
   692	func (x rvs) Len() int      { return len(x) }
   693	func (x rvs) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
   694	
   695	type rvInts struct{ rvs }
   696	
   697	func (x rvInts) Less(i, j int) bool { return x.rvs[i].Int() < x.rvs[j].Int() }
   698	
   699	type rvUints struct{ rvs }
   700	
   701	func (x rvUints) Less(i, j int) bool { return x.rvs[i].Uint() < x.rvs[j].Uint() }
   702	
   703	type rvFloats struct{ rvs }
   704	
   705	func (x rvFloats) Less(i, j int) bool { return x.rvs[i].Float() < x.rvs[j].Float() }
   706	
   707	type rvStrings struct{ rvs }
   708	
   709	func (x rvStrings) Less(i, j int) bool { return x.rvs[i].String() < x.rvs[j].String() }
   710	
   711	// sortKeys sorts (if it can) the slice of reflect.Values, which is a slice of map keys.
   712	func sortKeys(v []reflect.Value) []reflect.Value {
   713		if len(v) <= 1 {
   714			return v
   715		}
   716		switch v[0].Kind() {
   717		case reflect.Float32, reflect.Float64:
   718			sort.Sort(rvFloats{v})
   719		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   720			sort.Sort(rvInts{v})
   721		case reflect.String:
   722			sort.Sort(rvStrings{v})
   723		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   724			sort.Sort(rvUints{v})
   725		}
   726		return v
   727	}