1
2
3
4
5 package template
6
7 import (
8 "fmt"
9 "internal/fmtsort"
10 "io"
11 "reflect"
12 "runtime"
13 "strings"
14 "text/template/parse"
15 )
16
17
18
19
20
21 var maxExecDepth = initMaxExecDepth()
22
23 func initMaxExecDepth() int {
24 if runtime.GOARCH == "wasm" {
25 return 1000
26 }
27 return 100000
28 }
29
30
31
32
33 type state struct {
34 tmpl *Template
35 wr io.Writer
36 node parse.Node
37 vars []variable
38 depth int
39 }
40
41
42 type variable struct {
43 name string
44 value reflect.Value
45 }
46
47
48 func (s *state) push(name string, value reflect.Value) {
49 s.vars = append(s.vars, variable{name, value})
50 }
51
52
53 func (s *state) mark() int {
54 return len(s.vars)
55 }
56
57
58 func (s *state) pop(mark int) {
59 s.vars = s.vars[0:mark]
60 }
61
62
63
64 func (s *state) setVar(name string, value reflect.Value) {
65 for i := s.mark() - 1; i >= 0; i-- {
66 if s.vars[i].name == name {
67 s.vars[i].value = value
68 return
69 }
70 }
71 s.errorf("undefined variable: %s", name)
72 }
73
74
75 func (s *state) setTopVar(n int, value reflect.Value) {
76 s.vars[len(s.vars)-n].value = value
77 }
78
79
80 func (s *state) varValue(name string) reflect.Value {
81 for i := s.mark() - 1; i >= 0; i-- {
82 if s.vars[i].name == name {
83 return s.vars[i].value
84 }
85 }
86 s.errorf("undefined variable: %s", name)
87 return zero
88 }
89
90 var zero reflect.Value
91
92 type missingValType struct{}
93
94 var missingVal = reflect.ValueOf(missingValType{})
95
96
97 func (s *state) at(node parse.Node) {
98 s.node = node
99 }
100
101
102
103 func doublePercent(str string) string {
104 return strings.ReplaceAll(str, "%", "%%")
105 }
106
107
108
109
110
111
112
113
114 type ExecError struct {
115 Name string
116 Err error
117 }
118
119 func (e ExecError) Error() string {
120 return e.Err.Error()
121 }
122
123 func (e ExecError) Unwrap() error {
124 return e.Err
125 }
126
127
128 func (s *state) errorf(format string, args ...interface{}) {
129 name := doublePercent(s.tmpl.Name())
130 if s.node == nil {
131 format = fmt.Sprintf("template: %s: %s", name, format)
132 } else {
133 location, context := s.tmpl.ErrorContext(s.node)
134 format = fmt.Sprintf("template: %s: executing %q at <%s>: %s", location, name, doublePercent(context), format)
135 }
136 panic(ExecError{
137 Name: s.tmpl.Name(),
138 Err: fmt.Errorf(format, args...),
139 })
140 }
141
142
143
144
145
146 type writeError struct {
147 Err error
148 }
149
150 func (s *state) writeError(err error) {
151 panic(writeError{
152 Err: err,
153 })
154 }
155
156
157
158 func errRecover(errp *error) {
159 e := recover()
160 if e != nil {
161 switch err := e.(type) {
162 case runtime.Error:
163 panic(e)
164 case writeError:
165 *errp = err.Err
166 case ExecError:
167 *errp = err
168 default:
169 panic(e)
170 }
171 }
172 }
173
174
175
176
177
178
179
180
181 func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error {
182 var tmpl *Template
183 if t.common != nil {
184 tmpl = t.tmpl[name]
185 }
186 if tmpl == nil {
187 return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
188 }
189 return tmpl.Execute(wr, data)
190 }
191
192
193
194
195
196
197
198
199
200
201
202 func (t *Template) Execute(wr io.Writer, data interface{}) error {
203 return t.execute(wr, data)
204 }
205
206 func (t *Template) execute(wr io.Writer, data interface{}) (err error) {
207 defer errRecover(&err)
208 value, ok := data.(reflect.Value)
209 if !ok {
210 value = reflect.ValueOf(data)
211 }
212 state := &state{
213 tmpl: t,
214 wr: wr,
215 vars: []variable{{"$", value}},
216 }
217 if t.Tree == nil || t.Root == nil {
218 state.errorf("%q is an incomplete or empty template", t.Name())
219 }
220 state.walk(value, t.Root)
221 return
222 }
223
224
225
226
227
228 func (t *Template) DefinedTemplates() string {
229 if t.common == nil {
230 return ""
231 }
232 var b strings.Builder
233 for name, tmpl := range t.tmpl {
234 if tmpl.Tree == nil || tmpl.Root == nil {
235 continue
236 }
237 if b.Len() == 0 {
238 b.WriteString("; defined templates are: ")
239 } else {
240 b.WriteString(", ")
241 }
242 fmt.Fprintf(&b, "%q", name)
243 }
244 return b.String()
245 }
246
247
248
249 func (s *state) walk(dot reflect.Value, node parse.Node) {
250 s.at(node)
251 switch node := node.(type) {
252 case *parse.ActionNode:
253
254
255 val := s.evalPipeline(dot, node.Pipe)
256 if len(node.Pipe.Decl) == 0 {
257 s.printValue(node, val)
258 }
259 case *parse.CommentNode:
260 case *parse.IfNode:
261 s.walkIfOrWith(parse.NodeIf, dot, node.Pipe, node.List, node.ElseList)
262 case *parse.ListNode:
263 for _, node := range node.Nodes {
264 s.walk(dot, node)
265 }
266 case *parse.RangeNode:
267 s.walkRange(dot, node)
268 case *parse.TemplateNode:
269 s.walkTemplate(dot, node)
270 case *parse.TextNode:
271 if _, err := s.wr.Write(node.Text); err != nil {
272 s.writeError(err)
273 }
274 case *parse.WithNode:
275 s.walkIfOrWith(parse.NodeWith, dot, node.Pipe, node.List, node.ElseList)
276 default:
277 s.errorf("unknown node: %s", node)
278 }
279 }
280
281
282
283 func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) {
284 defer s.pop(s.mark())
285 val := s.evalPipeline(dot, pipe)
286 truth, ok := isTrue(indirectInterface(val))
287 if !ok {
288 s.errorf("if/with can't use %v", val)
289 }
290 if truth {
291 if typ == parse.NodeWith {
292 s.walk(val, list)
293 } else {
294 s.walk(dot, list)
295 }
296 } else if elseList != nil {
297 s.walk(dot, elseList)
298 }
299 }
300
301
302
303
304 func IsTrue(val interface{}) (truth, ok bool) {
305 return isTrue(reflect.ValueOf(val))
306 }
307
308 func isTrue(val reflect.Value) (truth, ok bool) {
309 if !val.IsValid() {
310
311 return false, true
312 }
313 switch val.Kind() {
314 case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
315 truth = val.Len() > 0
316 case reflect.Bool:
317 truth = val.Bool()
318 case reflect.Complex64, reflect.Complex128:
319 truth = val.Complex() != 0
320 case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface:
321 truth = !val.IsNil()
322 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
323 truth = val.Int() != 0
324 case reflect.Float32, reflect.Float64:
325 truth = val.Float() != 0
326 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
327 truth = val.Uint() != 0
328 case reflect.Struct:
329 truth = true
330 default:
331 return
332 }
333 return truth, true
334 }
335
336 func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
337 s.at(r)
338 defer s.pop(s.mark())
339 val, _ := indirect(s.evalPipeline(dot, r.Pipe))
340
341 mark := s.mark()
342 oneIteration := func(index, elem reflect.Value) {
343
344 if len(r.Pipe.Decl) > 0 {
345 s.setTopVar(1, elem)
346 }
347
348 if len(r.Pipe.Decl) > 1 {
349 s.setTopVar(2, index)
350 }
351 s.walk(elem, r.List)
352 s.pop(mark)
353 }
354 switch val.Kind() {
355 case reflect.Array, reflect.Slice:
356 if val.Len() == 0 {
357 break
358 }
359 for i := 0; i < val.Len(); i++ {
360 oneIteration(reflect.ValueOf(i), val.Index(i))
361 }
362 return
363 case reflect.Map:
364 if val.Len() == 0 {
365 break
366 }
367 om := fmtsort.Sort(val)
368 for i, key := range om.Key {
369 oneIteration(key, om.Value[i])
370 }
371 return
372 case reflect.Chan:
373 if val.IsNil() {
374 break
375 }
376 if val.Type().ChanDir() == reflect.SendDir {
377 s.errorf("range over send-only channel %v", val)
378 break
379 }
380 i := 0
381 for ; ; i++ {
382 elem, ok := val.Recv()
383 if !ok {
384 break
385 }
386 oneIteration(reflect.ValueOf(i), elem)
387 }
388 if i == 0 {
389 break
390 }
391 return
392 case reflect.Invalid:
393 break
394 default:
395 s.errorf("range can't iterate over %v", val)
396 }
397 if r.ElseList != nil {
398 s.walk(dot, r.ElseList)
399 }
400 }
401
402 func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
403 s.at(t)
404 tmpl := s.tmpl.tmpl[t.Name]
405 if tmpl == nil {
406 s.errorf("template %q not defined", t.Name)
407 }
408 if s.depth == maxExecDepth {
409 s.errorf("exceeded maximum template depth (%v)", maxExecDepth)
410 }
411
412 dot = s.evalPipeline(dot, t.Pipe)
413 newState := *s
414 newState.depth++
415 newState.tmpl = tmpl
416
417 newState.vars = []variable{{"$", dot}}
418 newState.walk(dot, tmpl.Root)
419 }
420
421
422
423
424
425
426
427
428
429 func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) {
430 if pipe == nil {
431 return
432 }
433 s.at(pipe)
434 value = missingVal
435 for _, cmd := range pipe.Cmds {
436 value = s.evalCommand(dot, cmd, value)
437
438 if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
439 value = reflect.ValueOf(value.Interface())
440 }
441 }
442 for _, variable := range pipe.Decl {
443 if pipe.IsAssign {
444 s.setVar(variable.Ident[0], value)
445 } else {
446 s.push(variable.Ident[0], value)
447 }
448 }
449 return value
450 }
451
452 func (s *state) notAFunction(args []parse.Node, final reflect.Value) {
453 if len(args) > 1 || final != missingVal {
454 s.errorf("can't give argument to non-function %s", args[0])
455 }
456 }
457
458 func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value {
459 firstWord := cmd.Args[0]
460 switch n := firstWord.(type) {
461 case *parse.FieldNode:
462 return s.evalFieldNode(dot, n, cmd.Args, final)
463 case *parse.ChainNode:
464 return s.evalChainNode(dot, n, cmd.Args, final)
465 case *parse.IdentifierNode:
466
467 return s.evalFunction(dot, n, cmd, cmd.Args, final)
468 case *parse.PipeNode:
469
470 s.notAFunction(cmd.Args, final)
471 return s.evalPipeline(dot, n)
472 case *parse.VariableNode:
473 return s.evalVariableNode(dot, n, cmd.Args, final)
474 }
475 s.at(firstWord)
476 s.notAFunction(cmd.Args, final)
477 switch word := firstWord.(type) {
478 case *parse.BoolNode:
479 return reflect.ValueOf(word.True)
480 case *parse.DotNode:
481 return dot
482 case *parse.NilNode:
483 s.errorf("nil is not a command")
484 case *parse.NumberNode:
485 return s.idealConstant(word)
486 case *parse.StringNode:
487 return reflect.ValueOf(word.Text)
488 }
489 s.errorf("can't evaluate command %q", firstWord)
490 panic("not reached")
491 }
492
493
494
495
496
497 func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
498
499
500
501 s.at(constant)
502 switch {
503 case constant.IsComplex:
504 return reflect.ValueOf(constant.Complex128)
505
506 case constant.IsFloat &&
507 !isHexInt(constant.Text) && !isRuneInt(constant.Text) &&
508 strings.ContainsAny(constant.Text, ".eEpP"):
509 return reflect.ValueOf(constant.Float64)
510
511 case constant.IsInt:
512 n := int(constant.Int64)
513 if int64(n) != constant.Int64 {
514 s.errorf("%s overflows int", constant.Text)
515 }
516 return reflect.ValueOf(n)
517
518 case constant.IsUint:
519 s.errorf("%s overflows int", constant.Text)
520 }
521 return zero
522 }
523
524 func isRuneInt(s string) bool {
525 return len(s) > 0 && s[0] == '\''
526 }
527
528 func isHexInt(s string) bool {
529 return len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && !strings.ContainsAny(s, "pP")
530 }
531
532 func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
533 s.at(field)
534 return s.evalFieldChain(dot, dot, field, field.Ident, args, final)
535 }
536
537 func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value {
538 s.at(chain)
539 if len(chain.Field) == 0 {
540 s.errorf("internal error: no fields in evalChainNode")
541 }
542 if chain.Node.Type() == parse.NodeNil {
543 s.errorf("indirection through explicit nil in %s", chain)
544 }
545
546 pipe := s.evalArg(dot, nil, chain.Node)
547 return s.evalFieldChain(dot, pipe, chain, chain.Field, args, final)
548 }
549
550 func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
551
552 s.at(variable)
553 value := s.varValue(variable.Ident[0])
554 if len(variable.Ident) == 1 {
555 s.notAFunction(args, final)
556 return value
557 }
558 return s.evalFieldChain(dot, value, variable, variable.Ident[1:], args, final)
559 }
560
561
562
563
564 func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value {
565 n := len(ident)
566 for i := 0; i < n-1; i++ {
567 receiver = s.evalField(dot, ident[i], node, nil, missingVal, receiver)
568 }
569
570 return s.evalField(dot, ident[n-1], node, args, final, receiver)
571 }
572
573 func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value {
574 s.at(node)
575 name := node.Ident
576 function, ok := findFunction(name, s.tmpl)
577 if !ok {
578 s.errorf("%q is not a defined function", name)
579 }
580 return s.evalCall(dot, function, cmd, name, args, final)
581 }
582
583
584
585
586 func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value {
587 if !receiver.IsValid() {
588 if s.tmpl.option.missingKey == mapError {
589 s.errorf("nil data; no entry for key %q", fieldName)
590 }
591 return zero
592 }
593 typ := receiver.Type()
594 receiver, isNil := indirect(receiver)
595 if receiver.Kind() == reflect.Interface && isNil {
596
597
598 s.errorf("nil pointer evaluating %s.%s", typ, fieldName)
599 return zero
600 }
601
602
603
604 ptr := receiver
605 if ptr.Kind() != reflect.Interface && ptr.Kind() != reflect.Ptr && ptr.CanAddr() {
606 ptr = ptr.Addr()
607 }
608 if method := ptr.MethodByName(fieldName); method.IsValid() {
609 return s.evalCall(dot, method, node, fieldName, args, final)
610 }
611 hasArgs := len(args) > 1 || final != missingVal
612
613 switch receiver.Kind() {
614 case reflect.Struct:
615 tField, ok := receiver.Type().FieldByName(fieldName)
616 if ok {
617 field := receiver.FieldByIndex(tField.Index)
618 if tField.PkgPath != "" {
619 s.errorf("%s is an unexported field of struct type %s", fieldName, typ)
620 }
621
622 if hasArgs {
623 s.errorf("%s has arguments but cannot be invoked as function", fieldName)
624 }
625 return field
626 }
627 case reflect.Map:
628
629 nameVal := reflect.ValueOf(fieldName)
630 if nameVal.Type().AssignableTo(receiver.Type().Key()) {
631 if hasArgs {
632 s.errorf("%s is not a method but has arguments", fieldName)
633 }
634 result := receiver.MapIndex(nameVal)
635 if !result.IsValid() {
636 switch s.tmpl.option.missingKey {
637 case mapInvalid:
638
639 case mapZeroValue:
640 result = reflect.Zero(receiver.Type().Elem())
641 case mapError:
642 s.errorf("map has no entry for key %q", fieldName)
643 }
644 }
645 return result
646 }
647 case reflect.Ptr:
648 etyp := receiver.Type().Elem()
649 if etyp.Kind() == reflect.Struct {
650 if _, ok := etyp.FieldByName(fieldName); !ok {
651
652
653 break
654 }
655 }
656 if isNil {
657 s.errorf("nil pointer evaluating %s.%s", typ, fieldName)
658 }
659 }
660 s.errorf("can't evaluate field %s in type %s", fieldName, typ)
661 panic("not reached")
662 }
663
664 var (
665 errorType = reflect.TypeOf((*error)(nil)).Elem()
666 fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
667 reflectValueType = reflect.TypeOf((*reflect.Value)(nil)).Elem()
668 )
669
670
671
672
673 func (s *state) evalCall(dot, fun reflect.Value, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value {
674 if args != nil {
675 args = args[1:]
676 }
677 typ := fun.Type()
678 numIn := len(args)
679 if final != missingVal {
680 numIn++
681 }
682 numFixed := len(args)
683 if typ.IsVariadic() {
684 numFixed = typ.NumIn() - 1
685 if numIn < numFixed {
686 s.errorf("wrong number of args for %s: want at least %d got %d", name, typ.NumIn()-1, len(args))
687 }
688 } else if numIn != typ.NumIn() {
689 s.errorf("wrong number of args for %s: want %d got %d", name, typ.NumIn(), numIn)
690 }
691 if !goodFunc(typ) {
692
693 s.errorf("can't call method/function %q with %d results", name, typ.NumOut())
694 }
695
696 argv := make([]reflect.Value, numIn)
697
698 i := 0
699 for ; i < numFixed && i < len(args); i++ {
700 argv[i] = s.evalArg(dot, typ.In(i), args[i])
701 }
702
703 if typ.IsVariadic() {
704 argType := typ.In(typ.NumIn() - 1).Elem()
705 for ; i < len(args); i++ {
706 argv[i] = s.evalArg(dot, argType, args[i])
707 }
708 }
709
710 if final != missingVal {
711 t := typ.In(typ.NumIn() - 1)
712 if typ.IsVariadic() {
713 if numIn-1 < numFixed {
714
715
716 t = typ.In(numIn - 1)
717 } else {
718
719
720 t = t.Elem()
721 }
722 }
723 argv[i] = s.validateType(final, t)
724 }
725 v, err := safeCall(fun, argv)
726
727
728 if err != nil {
729 s.at(node)
730 s.errorf("error calling %s: %v", name, err)
731 }
732 if v.Type() == reflectValueType {
733 v = v.Interface().(reflect.Value)
734 }
735 return v
736 }
737
738
739 func canBeNil(typ reflect.Type) bool {
740 switch typ.Kind() {
741 case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
742 return true
743 case reflect.Struct:
744 return typ == reflectValueType
745 }
746 return false
747 }
748
749
750 func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
751 if !value.IsValid() {
752 if typ == nil {
753
754 return reflect.ValueOf(nil)
755 }
756 if canBeNil(typ) {
757
758 return reflect.Zero(typ)
759 }
760 s.errorf("invalid value; expected %s", typ)
761 }
762 if typ == reflectValueType && value.Type() != typ {
763 return reflect.ValueOf(value)
764 }
765 if typ != nil && !value.Type().AssignableTo(typ) {
766 if value.Kind() == reflect.Interface && !value.IsNil() {
767 value = value.Elem()
768 if value.Type().AssignableTo(typ) {
769 return value
770 }
771
772 }
773
774
775
776
777 switch {
778 case value.Kind() == reflect.Ptr && value.Type().Elem().AssignableTo(typ):
779 value = value.Elem()
780 if !value.IsValid() {
781 s.errorf("dereference of nil pointer of type %s", typ)
782 }
783 case reflect.PtrTo(value.Type()).AssignableTo(typ) && value.CanAddr():
784 value = value.Addr()
785 default:
786 s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
787 }
788 }
789 return value
790 }
791
792 func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
793 s.at(n)
794 switch arg := n.(type) {
795 case *parse.DotNode:
796 return s.validateType(dot, typ)
797 case *parse.NilNode:
798 if canBeNil(typ) {
799 return reflect.Zero(typ)
800 }
801 s.errorf("cannot assign nil to %s", typ)
802 case *parse.FieldNode:
803 return s.validateType(s.evalFieldNode(dot, arg, []parse.Node{n}, missingVal), typ)
804 case *parse.VariableNode:
805 return s.validateType(s.evalVariableNode(dot, arg, nil, missingVal), typ)
806 case *parse.PipeNode:
807 return s.validateType(s.evalPipeline(dot, arg), typ)
808 case *parse.IdentifierNode:
809 return s.validateType(s.evalFunction(dot, arg, arg, nil, missingVal), typ)
810 case *parse.ChainNode:
811 return s.validateType(s.evalChainNode(dot, arg, nil, missingVal), typ)
812 }
813 switch typ.Kind() {
814 case reflect.Bool:
815 return s.evalBool(typ, n)
816 case reflect.Complex64, reflect.Complex128:
817 return s.evalComplex(typ, n)
818 case reflect.Float32, reflect.Float64:
819 return s.evalFloat(typ, n)
820 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
821 return s.evalInteger(typ, n)
822 case reflect.Interface:
823 if typ.NumMethod() == 0 {
824 return s.evalEmptyInterface(dot, n)
825 }
826 case reflect.Struct:
827 if typ == reflectValueType {
828 return reflect.ValueOf(s.evalEmptyInterface(dot, n))
829 }
830 case reflect.String:
831 return s.evalString(typ, n)
832 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
833 return s.evalUnsignedInteger(typ, n)
834 }
835 s.errorf("can't handle %s for arg of type %s", n, typ)
836 panic("not reached")
837 }
838
839 func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
840 s.at(n)
841 if n, ok := n.(*parse.BoolNode); ok {
842 value := reflect.New(typ).Elem()
843 value.SetBool(n.True)
844 return value
845 }
846 s.errorf("expected bool; found %s", n)
847 panic("not reached")
848 }
849
850 func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
851 s.at(n)
852 if n, ok := n.(*parse.StringNode); ok {
853 value := reflect.New(typ).Elem()
854 value.SetString(n.Text)
855 return value
856 }
857 s.errorf("expected string; found %s", n)
858 panic("not reached")
859 }
860
861 func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
862 s.at(n)
863 if n, ok := n.(*parse.NumberNode); ok && n.IsInt {
864 value := reflect.New(typ).Elem()
865 value.SetInt(n.Int64)
866 return value
867 }
868 s.errorf("expected integer; found %s", n)
869 panic("not reached")
870 }
871
872 func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
873 s.at(n)
874 if n, ok := n.(*parse.NumberNode); ok && n.IsUint {
875 value := reflect.New(typ).Elem()
876 value.SetUint(n.Uint64)
877 return value
878 }
879 s.errorf("expected unsigned integer; found %s", n)
880 panic("not reached")
881 }
882
883 func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
884 s.at(n)
885 if n, ok := n.(*parse.NumberNode); ok && n.IsFloat {
886 value := reflect.New(typ).Elem()
887 value.SetFloat(n.Float64)
888 return value
889 }
890 s.errorf("expected float; found %s", n)
891 panic("not reached")
892 }
893
894 func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
895 if n, ok := n.(*parse.NumberNode); ok && n.IsComplex {
896 value := reflect.New(typ).Elem()
897 value.SetComplex(n.Complex128)
898 return value
899 }
900 s.errorf("expected complex; found %s", n)
901 panic("not reached")
902 }
903
904 func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value {
905 s.at(n)
906 switch n := n.(type) {
907 case *parse.BoolNode:
908 return reflect.ValueOf(n.True)
909 case *parse.DotNode:
910 return dot
911 case *parse.FieldNode:
912 return s.evalFieldNode(dot, n, nil, missingVal)
913 case *parse.IdentifierNode:
914 return s.evalFunction(dot, n, n, nil, missingVal)
915 case *parse.NilNode:
916
917 s.errorf("evalEmptyInterface: nil (can't happen)")
918 case *parse.NumberNode:
919 return s.idealConstant(n)
920 case *parse.StringNode:
921 return reflect.ValueOf(n.Text)
922 case *parse.VariableNode:
923 return s.evalVariableNode(dot, n, nil, missingVal)
924 case *parse.PipeNode:
925 return s.evalPipeline(dot, n)
926 }
927 s.errorf("can't handle assignment of %s to empty interface argument", n)
928 panic("not reached")
929 }
930
931
932
933
934 func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
935 for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
936 if v.IsNil() {
937 return v, true
938 }
939 }
940 return v, false
941 }
942
943
944
945
946
947 func indirectInterface(v reflect.Value) reflect.Value {
948 if v.Kind() != reflect.Interface {
949 return v
950 }
951 if v.IsNil() {
952 return reflect.Value{}
953 }
954 return v.Elem()
955 }
956
957
958
959 func (s *state) printValue(n parse.Node, v reflect.Value) {
960 s.at(n)
961 iface, ok := printableValue(v)
962 if !ok {
963 s.errorf("can't print %s of type %s", n, v.Type())
964 }
965 _, err := fmt.Fprint(s.wr, iface)
966 if err != nil {
967 s.writeError(err)
968 }
969 }
970
971
972
973 func printableValue(v reflect.Value) (interface{}, bool) {
974 if v.Kind() == reflect.Ptr {
975 v, _ = indirect(v)
976 }
977 if !v.IsValid() {
978 return "<no value>", true
979 }
980
981 if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
982 if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) {
983 v = v.Addr()
984 } else {
985 switch v.Kind() {
986 case reflect.Chan, reflect.Func:
987 return nil, false
988 }
989 }
990 }
991 return v.Interface(), true
992 }
993
View as plain text