Black Lives Matter. Support the Equal Justice Initiative.

Source file src/text/template/parse/node.go

Documentation: text/template/parse

     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  // Parse nodes.
     6  
     7  package parse
     8  
     9  import (
    10  	"fmt"
    11  	"strconv"
    12  	"strings"
    13  )
    14  
    15  var textFormat = "%s" // Changed to "%q" in tests for better error messages.
    16  
    17  // A Node is an element in the parse tree. The interface is trivial.
    18  // The interface contains an unexported method so that only
    19  // types local to this package can satisfy it.
    20  type Node interface {
    21  	Type() NodeType
    22  	String() string
    23  	// Copy does a deep copy of the Node and all its components.
    24  	// To avoid type assertions, some XxxNodes also have specialized
    25  	// CopyXxx methods that return *XxxNode.
    26  	Copy() Node
    27  	Position() Pos // byte position of start of node in full original input string
    28  	// tree returns the containing *Tree.
    29  	// It is unexported so all implementations of Node are in this package.
    30  	tree() *Tree
    31  	// writeTo writes the String output to the builder.
    32  	writeTo(*strings.Builder)
    33  }
    34  
    35  // NodeType identifies the type of a parse tree node.
    36  type NodeType int
    37  
    38  // Pos represents a byte position in the original input text from which
    39  // this template was parsed.
    40  type Pos int
    41  
    42  func (p Pos) Position() Pos {
    43  	return p
    44  }
    45  
    46  // Type returns itself and provides an easy default implementation
    47  // for embedding in a Node. Embedded in all non-trivial Nodes.
    48  func (t NodeType) Type() NodeType {
    49  	return t
    50  }
    51  
    52  const (
    53  	NodeText       NodeType = iota // Plain text.
    54  	NodeAction                     // A non-control action such as a field evaluation.
    55  	NodeBool                       // A boolean constant.
    56  	NodeChain                      // A sequence of field accesses.
    57  	NodeCommand                    // An element of a pipeline.
    58  	NodeDot                        // The cursor, dot.
    59  	nodeElse                       // An else action. Not added to tree.
    60  	nodeEnd                        // An end action. Not added to tree.
    61  	NodeField                      // A field or method name.
    62  	NodeIdentifier                 // An identifier; always a function name.
    63  	NodeIf                         // An if action.
    64  	NodeList                       // A list of Nodes.
    65  	NodeNil                        // An untyped nil constant.
    66  	NodeNumber                     // A numerical constant.
    67  	NodePipe                       // A pipeline of commands.
    68  	NodeRange                      // A range action.
    69  	NodeString                     // A string constant.
    70  	NodeTemplate                   // A template invocation action.
    71  	NodeVariable                   // A $ variable.
    72  	NodeWith                       // A with action.
    73  	NodeComment                    // A comment.
    74  )
    75  
    76  // Nodes.
    77  
    78  // ListNode holds a sequence of nodes.
    79  type ListNode struct {
    80  	NodeType
    81  	Pos
    82  	tr    *Tree
    83  	Nodes []Node // The element nodes in lexical order.
    84  }
    85  
    86  func (t *Tree) newList(pos Pos) *ListNode {
    87  	return &ListNode{tr: t, NodeType: NodeList, Pos: pos}
    88  }
    89  
    90  func (l *ListNode) append(n Node) {
    91  	l.Nodes = append(l.Nodes, n)
    92  }
    93  
    94  func (l *ListNode) tree() *Tree {
    95  	return l.tr
    96  }
    97  
    98  func (l *ListNode) String() string {
    99  	var sb strings.Builder
   100  	l.writeTo(&sb)
   101  	return sb.String()
   102  }
   103  
   104  func (l *ListNode) writeTo(sb *strings.Builder) {
   105  	for _, n := range l.Nodes {
   106  		n.writeTo(sb)
   107  	}
   108  }
   109  
   110  func (l *ListNode) CopyList() *ListNode {
   111  	if l == nil {
   112  		return l
   113  	}
   114  	n := l.tr.newList(l.Pos)
   115  	for _, elem := range l.Nodes {
   116  		n.append(elem.Copy())
   117  	}
   118  	return n
   119  }
   120  
   121  func (l *ListNode) Copy() Node {
   122  	return l.CopyList()
   123  }
   124  
   125  // TextNode holds plain text.
   126  type TextNode struct {
   127  	NodeType
   128  	Pos
   129  	tr   *Tree
   130  	Text []byte // The text; may span newlines.
   131  }
   132  
   133  func (t *Tree) newText(pos Pos, text string) *TextNode {
   134  	return &TextNode{tr: t, NodeType: NodeText, Pos: pos, Text: []byte(text)}
   135  }
   136  
   137  func (t *TextNode) String() string {
   138  	return fmt.Sprintf(textFormat, t.Text)
   139  }
   140  
   141  func (t *TextNode) writeTo(sb *strings.Builder) {
   142  	sb.WriteString(t.String())
   143  }
   144  
   145  func (t *TextNode) tree() *Tree {
   146  	return t.tr
   147  }
   148  
   149  func (t *TextNode) Copy() Node {
   150  	return &TextNode{tr: t.tr, NodeType: NodeText, Pos: t.Pos, Text: append([]byte{}, t.Text...)}
   151  }
   152  
   153  // CommentNode holds a comment.
   154  type CommentNode struct {
   155  	NodeType
   156  	Pos
   157  	tr   *Tree
   158  	Text string // Comment text.
   159  }
   160  
   161  func (t *Tree) newComment(pos Pos, text string) *CommentNode {
   162  	return &CommentNode{tr: t, NodeType: NodeComment, Pos: pos, Text: text}
   163  }
   164  
   165  func (c *CommentNode) String() string {
   166  	var sb strings.Builder
   167  	c.writeTo(&sb)
   168  	return sb.String()
   169  }
   170  
   171  func (c *CommentNode) writeTo(sb *strings.Builder) {
   172  	sb.WriteString("{{")
   173  	sb.WriteString(c.Text)
   174  	sb.WriteString("}}")
   175  }
   176  
   177  func (c *CommentNode) tree() *Tree {
   178  	return c.tr
   179  }
   180  
   181  func (c *CommentNode) Copy() Node {
   182  	return &CommentNode{tr: c.tr, NodeType: NodeComment, Pos: c.Pos, Text: c.Text}
   183  }
   184  
   185  // PipeNode holds a pipeline with optional declaration
   186  type PipeNode struct {
   187  	NodeType
   188  	Pos
   189  	tr       *Tree
   190  	Line     int             // The line number in the input. Deprecated: Kept for compatibility.
   191  	IsAssign bool            // The variables are being assigned, not declared.
   192  	Decl     []*VariableNode // Variables in lexical order.
   193  	Cmds     []*CommandNode  // The commands in lexical order.
   194  }
   195  
   196  func (t *Tree) newPipeline(pos Pos, line int, vars []*VariableNode) *PipeNode {
   197  	return &PipeNode{tr: t, NodeType: NodePipe, Pos: pos, Line: line, Decl: vars}
   198  }
   199  
   200  func (p *PipeNode) append(command *CommandNode) {
   201  	p.Cmds = append(p.Cmds, command)
   202  }
   203  
   204  func (p *PipeNode) String() string {
   205  	var sb strings.Builder
   206  	p.writeTo(&sb)
   207  	return sb.String()
   208  }
   209  
   210  func (p *PipeNode) writeTo(sb *strings.Builder) {
   211  	if len(p.Decl) > 0 {
   212  		for i, v := range p.Decl {
   213  			if i > 0 {
   214  				sb.WriteString(", ")
   215  			}
   216  			v.writeTo(sb)
   217  		}
   218  		sb.WriteString(" := ")
   219  	}
   220  	for i, c := range p.Cmds {
   221  		if i > 0 {
   222  			sb.WriteString(" | ")
   223  		}
   224  		c.writeTo(sb)
   225  	}
   226  }
   227  
   228  func (p *PipeNode) tree() *Tree {
   229  	return p.tr
   230  }
   231  
   232  func (p *PipeNode) CopyPipe() *PipeNode {
   233  	if p == nil {
   234  		return p
   235  	}
   236  	vars := make([]*VariableNode, len(p.Decl))
   237  	for i, d := range p.Decl {
   238  		vars[i] = d.Copy().(*VariableNode)
   239  	}
   240  	n := p.tr.newPipeline(p.Pos, p.Line, vars)
   241  	n.IsAssign = p.IsAssign
   242  	for _, c := range p.Cmds {
   243  		n.append(c.Copy().(*CommandNode))
   244  	}
   245  	return n
   246  }
   247  
   248  func (p *PipeNode) Copy() Node {
   249  	return p.CopyPipe()
   250  }
   251  
   252  // ActionNode holds an action (something bounded by delimiters).
   253  // Control actions have their own nodes; ActionNode represents simple
   254  // ones such as field evaluations and parenthesized pipelines.
   255  type ActionNode struct {
   256  	NodeType
   257  	Pos
   258  	tr   *Tree
   259  	Line int       // The line number in the input. Deprecated: Kept for compatibility.
   260  	Pipe *PipeNode // The pipeline in the action.
   261  }
   262  
   263  func (t *Tree) newAction(pos Pos, line int, pipe *PipeNode) *ActionNode {
   264  	return &ActionNode{tr: t, NodeType: NodeAction, Pos: pos, Line: line, Pipe: pipe}
   265  }
   266  
   267  func (a *ActionNode) String() string {
   268  	var sb strings.Builder
   269  	a.writeTo(&sb)
   270  	return sb.String()
   271  }
   272  
   273  func (a *ActionNode) writeTo(sb *strings.Builder) {
   274  	sb.WriteString("{{")
   275  	a.Pipe.writeTo(sb)
   276  	sb.WriteString("}}")
   277  }
   278  
   279  func (a *ActionNode) tree() *Tree {
   280  	return a.tr
   281  }
   282  
   283  func (a *ActionNode) Copy() Node {
   284  	return a.tr.newAction(a.Pos, a.Line, a.Pipe.CopyPipe())
   285  
   286  }
   287  
   288  // CommandNode holds a command (a pipeline inside an evaluating action).
   289  type CommandNode struct {
   290  	NodeType
   291  	Pos
   292  	tr   *Tree
   293  	Args []Node // Arguments in lexical order: Identifier, field, or constant.
   294  }
   295  
   296  func (t *Tree) newCommand(pos Pos) *CommandNode {
   297  	return &CommandNode{tr: t, NodeType: NodeCommand, Pos: pos}
   298  }
   299  
   300  func (c *CommandNode) append(arg Node) {
   301  	c.Args = append(c.Args, arg)
   302  }
   303  
   304  func (c *CommandNode) String() string {
   305  	var sb strings.Builder
   306  	c.writeTo(&sb)
   307  	return sb.String()
   308  }
   309  
   310  func (c *CommandNode) writeTo(sb *strings.Builder) {
   311  	for i, arg := range c.Args {
   312  		if i > 0 {
   313  			sb.WriteByte(' ')
   314  		}
   315  		if arg, ok := arg.(*PipeNode); ok {
   316  			sb.WriteByte('(')
   317  			arg.writeTo(sb)
   318  			sb.WriteByte(')')
   319  			continue
   320  		}
   321  		arg.writeTo(sb)
   322  	}
   323  }
   324  
   325  func (c *CommandNode) tree() *Tree {
   326  	return c.tr
   327  }
   328  
   329  func (c *CommandNode) Copy() Node {
   330  	if c == nil {
   331  		return c
   332  	}
   333  	n := c.tr.newCommand(c.Pos)
   334  	for _, c := range c.Args {
   335  		n.append(c.Copy())
   336  	}
   337  	return n
   338  }
   339  
   340  // IdentifierNode holds an identifier.
   341  type IdentifierNode struct {
   342  	NodeType
   343  	Pos
   344  	tr    *Tree
   345  	Ident string // The identifier's name.
   346  }
   347  
   348  // NewIdentifier returns a new IdentifierNode with the given identifier name.
   349  func NewIdentifier(ident string) *IdentifierNode {
   350  	return &IdentifierNode{NodeType: NodeIdentifier, Ident: ident}
   351  }
   352  
   353  // SetPos sets the position. NewIdentifier is a public method so we can't modify its signature.
   354  // Chained for convenience.
   355  // TODO: fix one day?
   356  func (i *IdentifierNode) SetPos(pos Pos) *IdentifierNode {
   357  	i.Pos = pos
   358  	return i
   359  }
   360  
   361  // SetTree sets the parent tree for the node. NewIdentifier is a public method so we can't modify its signature.
   362  // Chained for convenience.
   363  // TODO: fix one day?
   364  func (i *IdentifierNode) SetTree(t *Tree) *IdentifierNode {
   365  	i.tr = t
   366  	return i
   367  }
   368  
   369  func (i *IdentifierNode) String() string {
   370  	return i.Ident
   371  }
   372  
   373  func (i *IdentifierNode) writeTo(sb *strings.Builder) {
   374  	sb.WriteString(i.String())
   375  }
   376  
   377  func (i *IdentifierNode) tree() *Tree {
   378  	return i.tr
   379  }
   380  
   381  func (i *IdentifierNode) Copy() Node {
   382  	return NewIdentifier(i.Ident).SetTree(i.tr).SetPos(i.Pos)
   383  }
   384  
   385  // VariableNode holds a list of variable names, possibly with chained field
   386  // accesses. The dollar sign is part of the (first) name.
   387  type VariableNode struct {
   388  	NodeType
   389  	Pos
   390  	tr    *Tree
   391  	Ident []string // Variable name and fields in lexical order.
   392  }
   393  
   394  func (t *Tree) newVariable(pos Pos, ident string) *VariableNode {
   395  	return &VariableNode{tr: t, NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
   396  }
   397  
   398  func (v *VariableNode) String() string {
   399  	var sb strings.Builder
   400  	v.writeTo(&sb)
   401  	return sb.String()
   402  }
   403  
   404  func (v *VariableNode) writeTo(sb *strings.Builder) {
   405  	for i, id := range v.Ident {
   406  		if i > 0 {
   407  			sb.WriteByte('.')
   408  		}
   409  		sb.WriteString(id)
   410  	}
   411  }
   412  
   413  func (v *VariableNode) tree() *Tree {
   414  	return v.tr
   415  }
   416  
   417  func (v *VariableNode) Copy() Node {
   418  	return &VariableNode{tr: v.tr, NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
   419  }
   420  
   421  // DotNode holds the special identifier '.'.
   422  type DotNode struct {
   423  	NodeType
   424  	Pos
   425  	tr *Tree
   426  }
   427  
   428  func (t *Tree) newDot(pos Pos) *DotNode {
   429  	return &DotNode{tr: t, NodeType: NodeDot, Pos: pos}
   430  }
   431  
   432  func (d *DotNode) Type() NodeType {
   433  	// Override method on embedded NodeType for API compatibility.
   434  	// TODO: Not really a problem; could change API without effect but
   435  	// api tool complains.
   436  	return NodeDot
   437  }
   438  
   439  func (d *DotNode) String() string {
   440  	return "."
   441  }
   442  
   443  func (d *DotNode) writeTo(sb *strings.Builder) {
   444  	sb.WriteString(d.String())
   445  }
   446  
   447  func (d *DotNode) tree() *Tree {
   448  	return d.tr
   449  }
   450  
   451  func (d *DotNode) Copy() Node {
   452  	return d.tr.newDot(d.Pos)
   453  }
   454  
   455  // NilNode holds the special identifier 'nil' representing an untyped nil constant.
   456  type NilNode struct {
   457  	NodeType
   458  	Pos
   459  	tr *Tree
   460  }
   461  
   462  func (t *Tree) newNil(pos Pos) *NilNode {
   463  	return &NilNode{tr: t, NodeType: NodeNil, Pos: pos}
   464  }
   465  
   466  func (n *NilNode) Type() NodeType {
   467  	// Override method on embedded NodeType for API compatibility.
   468  	// TODO: Not really a problem; could change API without effect but
   469  	// api tool complains.
   470  	return NodeNil
   471  }
   472  
   473  func (n *NilNode) String() string {
   474  	return "nil"
   475  }
   476  
   477  func (n *NilNode) writeTo(sb *strings.Builder) {
   478  	sb.WriteString(n.String())
   479  }
   480  
   481  func (n *NilNode) tree() *Tree {
   482  	return n.tr
   483  }
   484  
   485  func (n *NilNode) Copy() Node {
   486  	return n.tr.newNil(n.Pos)
   487  }
   488  
   489  // FieldNode holds a field (identifier starting with '.').
   490  // The names may be chained ('.x.y').
   491  // The period is dropped from each ident.
   492  type FieldNode struct {
   493  	NodeType
   494  	Pos
   495  	tr    *Tree
   496  	Ident []string // The identifiers in lexical order.
   497  }
   498  
   499  func (t *Tree) newField(pos Pos, ident string) *FieldNode {
   500  	return &FieldNode{tr: t, NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period
   501  }
   502  
   503  func (f *FieldNode) String() string {
   504  	var sb strings.Builder
   505  	f.writeTo(&sb)
   506  	return sb.String()
   507  }
   508  
   509  func (f *FieldNode) writeTo(sb *strings.Builder) {
   510  	for _, id := range f.Ident {
   511  		sb.WriteByte('.')
   512  		sb.WriteString(id)
   513  	}
   514  }
   515  
   516  func (f *FieldNode) tree() *Tree {
   517  	return f.tr
   518  }
   519  
   520  func (f *FieldNode) Copy() Node {
   521  	return &FieldNode{tr: f.tr, NodeType: NodeField, Pos: f.Pos, Ident: append([]string{}, f.Ident...)}
   522  }
   523  
   524  // ChainNode holds a term followed by a chain of field accesses (identifier starting with '.').
   525  // The names may be chained ('.x.y').
   526  // The periods are dropped from each ident.
   527  type ChainNode struct {
   528  	NodeType
   529  	Pos
   530  	tr    *Tree
   531  	Node  Node
   532  	Field []string // The identifiers in lexical order.
   533  }
   534  
   535  func (t *Tree) newChain(pos Pos, node Node) *ChainNode {
   536  	return &ChainNode{tr: t, NodeType: NodeChain, Pos: pos, Node: node}
   537  }
   538  
   539  // Add adds the named field (which should start with a period) to the end of the chain.
   540  func (c *ChainNode) Add(field string) {
   541  	if len(field) == 0 || field[0] != '.' {
   542  		panic("no dot in field")
   543  	}
   544  	field = field[1:] // Remove leading dot.
   545  	if field == "" {
   546  		panic("empty field")
   547  	}
   548  	c.Field = append(c.Field, field)
   549  }
   550  
   551  func (c *ChainNode) String() string {
   552  	var sb strings.Builder
   553  	c.writeTo(&sb)
   554  	return sb.String()
   555  }
   556  
   557  func (c *ChainNode) writeTo(sb *strings.Builder) {
   558  	if _, ok := c.Node.(*PipeNode); ok {
   559  		sb.WriteByte('(')
   560  		c.Node.writeTo(sb)
   561  		sb.WriteByte(')')
   562  	} else {
   563  		c.Node.writeTo(sb)
   564  	}
   565  	for _, field := range c.Field {
   566  		sb.WriteByte('.')
   567  		sb.WriteString(field)
   568  	}
   569  }
   570  
   571  func (c *ChainNode) tree() *Tree {
   572  	return c.tr
   573  }
   574  
   575  func (c *ChainNode) Copy() Node {
   576  	return &ChainNode{tr: c.tr, NodeType: NodeChain, Pos: c.Pos, Node: c.Node, Field: append([]string{}, c.Field...)}
   577  }
   578  
   579  // BoolNode holds a boolean constant.
   580  type BoolNode struct {
   581  	NodeType
   582  	Pos
   583  	tr   *Tree
   584  	True bool // The value of the boolean constant.
   585  }
   586  
   587  func (t *Tree) newBool(pos Pos, true bool) *BoolNode {
   588  	return &BoolNode{tr: t, NodeType: NodeBool, Pos: pos, True: true}
   589  }
   590  
   591  func (b *BoolNode) String() string {
   592  	if b.True {
   593  		return "true"
   594  	}
   595  	return "false"
   596  }
   597  
   598  func (b *BoolNode) writeTo(sb *strings.Builder) {
   599  	sb.WriteString(b.String())
   600  }
   601  
   602  func (b *BoolNode) tree() *Tree {
   603  	return b.tr
   604  }
   605  
   606  func (b *BoolNode) Copy() Node {
   607  	return b.tr.newBool(b.Pos, b.True)
   608  }
   609  
   610  // NumberNode holds a number: signed or unsigned integer, float, or complex.
   611  // The value is parsed and stored under all the types that can represent the value.
   612  // This simulates in a small amount of code the behavior of Go's ideal constants.
   613  type NumberNode struct {
   614  	NodeType
   615  	Pos
   616  	tr         *Tree
   617  	IsInt      bool       // Number has an integral value.
   618  	IsUint     bool       // Number has an unsigned integral value.
   619  	IsFloat    bool       // Number has a floating-point value.
   620  	IsComplex  bool       // Number is complex.
   621  	Int64      int64      // The signed integer value.
   622  	Uint64     uint64     // The unsigned integer value.
   623  	Float64    float64    // The floating-point value.
   624  	Complex128 complex128 // The complex value.
   625  	Text       string     // The original textual representation from the input.
   626  }
   627  
   628  func (t *Tree) newNumber(pos Pos, text string, typ itemType) (*NumberNode, error) {
   629  	n := &NumberNode{tr: t, NodeType: NodeNumber, Pos: pos, Text: text}
   630  	switch typ {
   631  	case itemCharConstant:
   632  		rune, _, tail, err := strconv.UnquoteChar(text[1:], text[0])
   633  		if err != nil {
   634  			return nil, err
   635  		}
   636  		if tail != "'" {
   637  			return nil, fmt.Errorf("malformed character constant: %s", text)
   638  		}
   639  		n.Int64 = int64(rune)
   640  		n.IsInt = true
   641  		n.Uint64 = uint64(rune)
   642  		n.IsUint = true
   643  		n.Float64 = float64(rune) // odd but those are the rules.
   644  		n.IsFloat = true
   645  		return n, nil
   646  	case itemComplex:
   647  		// fmt.Sscan can parse the pair, so let it do the work.
   648  		if _, err := fmt.Sscan(text, &n.Complex128); err != nil {
   649  			return nil, err
   650  		}
   651  		n.IsComplex = true
   652  		n.simplifyComplex()
   653  		return n, nil
   654  	}
   655  	// Imaginary constants can only be complex unless they are zero.
   656  	if len(text) > 0 && text[len(text)-1] == 'i' {
   657  		f, err := strconv.ParseFloat(text[:len(text)-1], 64)
   658  		if err == nil {
   659  			n.IsComplex = true
   660  			n.Complex128 = complex(0, f)
   661  			n.simplifyComplex()
   662  			return n, nil
   663  		}
   664  	}
   665  	// Do integer test first so we get 0x123 etc.
   666  	u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below.
   667  	if err == nil {
   668  		n.IsUint = true
   669  		n.Uint64 = u
   670  	}
   671  	i, err := strconv.ParseInt(text, 0, 64)
   672  	if err == nil {
   673  		n.IsInt = true
   674  		n.Int64 = i
   675  		if i == 0 {
   676  			n.IsUint = true // in case of -0.
   677  			n.Uint64 = u
   678  		}
   679  	}
   680  	// If an integer extraction succeeded, promote the float.
   681  	if n.IsInt {
   682  		n.IsFloat = true
   683  		n.Float64 = float64(n.Int64)
   684  	} else if n.IsUint {
   685  		n.IsFloat = true
   686  		n.Float64 = float64(n.Uint64)
   687  	} else {
   688  		f, err := strconv.ParseFloat(text, 64)
   689  		if err == nil {
   690  			// If we parsed it as a float but it looks like an integer,
   691  			// it's a huge number too large to fit in an int. Reject it.
   692  			if !strings.ContainsAny(text, ".eEpP") {
   693  				return nil, fmt.Errorf("integer overflow: %q", text)
   694  			}
   695  			n.IsFloat = true
   696  			n.Float64 = f
   697  			// If a floating-point extraction succeeded, extract the int if needed.
   698  			if !n.IsInt && float64(int64(f)) == f {
   699  				n.IsInt = true
   700  				n.Int64 = int64(f)
   701  			}
   702  			if !n.IsUint && float64(uint64(f)) == f {
   703  				n.IsUint = true
   704  				n.Uint64 = uint64(f)
   705  			}
   706  		}
   707  	}
   708  	if !n.IsInt && !n.IsUint && !n.IsFloat {
   709  		return nil, fmt.Errorf("illegal number syntax: %q", text)
   710  	}
   711  	return n, nil
   712  }
   713  
   714  // simplifyComplex pulls out any other types that are represented by the complex number.
   715  // These all require that the imaginary part be zero.
   716  func (n *NumberNode) simplifyComplex() {
   717  	n.IsFloat = imag(n.Complex128) == 0
   718  	if n.IsFloat {
   719  		n.Float64 = real(n.Complex128)
   720  		n.IsInt = float64(int64(n.Float64)) == n.Float64
   721  		if n.IsInt {
   722  			n.Int64 = int64(n.Float64)
   723  		}
   724  		n.IsUint = float64(uint64(n.Float64)) == n.Float64
   725  		if n.IsUint {
   726  			n.Uint64 = uint64(n.Float64)
   727  		}
   728  	}
   729  }
   730  
   731  func (n *NumberNode) String() string {
   732  	return n.Text
   733  }
   734  
   735  func (n *NumberNode) writeTo(sb *strings.Builder) {
   736  	sb.WriteString(n.String())
   737  }
   738  
   739  func (n *NumberNode) tree() *Tree {
   740  	return n.tr
   741  }
   742  
   743  func (n *NumberNode) Copy() Node {
   744  	nn := new(NumberNode)
   745  	*nn = *n // Easy, fast, correct.
   746  	return nn
   747  }
   748  
   749  // StringNode holds a string constant. The value has been "unquoted".
   750  type StringNode struct {
   751  	NodeType
   752  	Pos
   753  	tr     *Tree
   754  	Quoted string // The original text of the string, with quotes.
   755  	Text   string // The string, after quote processing.
   756  }
   757  
   758  func (t *Tree) newString(pos Pos, orig, text string) *StringNode {
   759  	return &StringNode{tr: t, NodeType: NodeString, Pos: pos, Quoted: orig, Text: text}
   760  }
   761  
   762  func (s *StringNode) String() string {
   763  	return s.Quoted
   764  }
   765  
   766  func (s *StringNode) writeTo(sb *strings.Builder) {
   767  	sb.WriteString(s.String())
   768  }
   769  
   770  func (s *StringNode) tree() *Tree {
   771  	return s.tr
   772  }
   773  
   774  func (s *StringNode) Copy() Node {
   775  	return s.tr.newString(s.Pos, s.Quoted, s.Text)
   776  }
   777  
   778  // endNode represents an {{end}} action.
   779  // It does not appear in the final parse tree.
   780  type endNode struct {
   781  	NodeType
   782  	Pos
   783  	tr *Tree
   784  }
   785  
   786  func (t *Tree) newEnd(pos Pos) *endNode {
   787  	return &endNode{tr: t, NodeType: nodeEnd, Pos: pos}
   788  }
   789  
   790  func (e *endNode) String() string {
   791  	return "{{end}}"
   792  }
   793  
   794  func (e *endNode) writeTo(sb *strings.Builder) {
   795  	sb.WriteString(e.String())
   796  }
   797  
   798  func (e *endNode) tree() *Tree {
   799  	return e.tr
   800  }
   801  
   802  func (e *endNode) Copy() Node {
   803  	return e.tr.newEnd(e.Pos)
   804  }
   805  
   806  // elseNode represents an {{else}} action. Does not appear in the final tree.
   807  type elseNode struct {
   808  	NodeType
   809  	Pos
   810  	tr   *Tree
   811  	Line int // The line number in the input. Deprecated: Kept for compatibility.
   812  }
   813  
   814  func (t *Tree) newElse(pos Pos, line int) *elseNode {
   815  	return &elseNode{tr: t, NodeType: nodeElse, Pos: pos, Line: line}
   816  }
   817  
   818  func (e *elseNode) Type() NodeType {
   819  	return nodeElse
   820  }
   821  
   822  func (e *elseNode) String() string {
   823  	return "{{else}}"
   824  }
   825  
   826  func (e *elseNode) writeTo(sb *strings.Builder) {
   827  	sb.WriteString(e.String())
   828  }
   829  
   830  func (e *elseNode) tree() *Tree {
   831  	return e.tr
   832  }
   833  
   834  func (e *elseNode) Copy() Node {
   835  	return e.tr.newElse(e.Pos, e.Line)
   836  }
   837  
   838  // BranchNode is the common representation of if, range, and with.
   839  type BranchNode struct {
   840  	NodeType
   841  	Pos
   842  	tr       *Tree
   843  	Line     int       // The line number in the input. Deprecated: Kept for compatibility.
   844  	Pipe     *PipeNode // The pipeline to be evaluated.
   845  	List     *ListNode // What to execute if the value is non-empty.
   846  	ElseList *ListNode // What to execute if the value is empty (nil if absent).
   847  }
   848  
   849  func (b *BranchNode) String() string {
   850  	var sb strings.Builder
   851  	b.writeTo(&sb)
   852  	return sb.String()
   853  }
   854  
   855  func (b *BranchNode) writeTo(sb *strings.Builder) {
   856  	name := ""
   857  	switch b.NodeType {
   858  	case NodeIf:
   859  		name = "if"
   860  	case NodeRange:
   861  		name = "range"
   862  	case NodeWith:
   863  		name = "with"
   864  	default:
   865  		panic("unknown branch type")
   866  	}
   867  	sb.WriteString("{{")
   868  	sb.WriteString(name)
   869  	sb.WriteByte(' ')
   870  	b.Pipe.writeTo(sb)
   871  	sb.WriteString("}}")
   872  	b.List.writeTo(sb)
   873  	if b.ElseList != nil {
   874  		sb.WriteString("{{else}}")
   875  		b.ElseList.writeTo(sb)
   876  	}
   877  	sb.WriteString("{{end}}")
   878  }
   879  
   880  func (b *BranchNode) tree() *Tree {
   881  	return b.tr
   882  }
   883  
   884  func (b *BranchNode) Copy() Node {
   885  	switch b.NodeType {
   886  	case NodeIf:
   887  		return b.tr.newIf(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
   888  	case NodeRange:
   889  		return b.tr.newRange(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
   890  	case NodeWith:
   891  		return b.tr.newWith(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
   892  	default:
   893  		panic("unknown branch type")
   894  	}
   895  }
   896  
   897  // IfNode represents an {{if}} action and its commands.
   898  type IfNode struct {
   899  	BranchNode
   900  }
   901  
   902  func (t *Tree) newIf(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *IfNode {
   903  	return &IfNode{BranchNode{tr: t, NodeType: NodeIf, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
   904  }
   905  
   906  func (i *IfNode) Copy() Node {
   907  	return i.tr.newIf(i.Pos, i.Line, i.Pipe.CopyPipe(), i.List.CopyList(), i.ElseList.CopyList())
   908  }
   909  
   910  // RangeNode represents a {{range}} action and its commands.
   911  type RangeNode struct {
   912  	BranchNode
   913  }
   914  
   915  func (t *Tree) newRange(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *RangeNode {
   916  	return &RangeNode{BranchNode{tr: t, NodeType: NodeRange, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
   917  }
   918  
   919  func (r *RangeNode) Copy() Node {
   920  	return r.tr.newRange(r.Pos, r.Line, r.Pipe.CopyPipe(), r.List.CopyList(), r.ElseList.CopyList())
   921  }
   922  
   923  // WithNode represents a {{with}} action and its commands.
   924  type WithNode struct {
   925  	BranchNode
   926  }
   927  
   928  func (t *Tree) newWith(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *WithNode {
   929  	return &WithNode{BranchNode{tr: t, NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
   930  }
   931  
   932  func (w *WithNode) Copy() Node {
   933  	return w.tr.newWith(w.Pos, w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList())
   934  }
   935  
   936  // TemplateNode represents a {{template}} action.
   937  type TemplateNode struct {
   938  	NodeType
   939  	Pos
   940  	tr   *Tree
   941  	Line int       // The line number in the input. Deprecated: Kept for compatibility.
   942  	Name string    // The name of the template (unquoted).
   943  	Pipe *PipeNode // The command to evaluate as dot for the template.
   944  }
   945  
   946  func (t *Tree) newTemplate(pos Pos, line int, name string, pipe *PipeNode) *TemplateNode {
   947  	return &TemplateNode{tr: t, NodeType: NodeTemplate, Pos: pos, Line: line, Name: name, Pipe: pipe}
   948  }
   949  
   950  func (t *TemplateNode) String() string {
   951  	var sb strings.Builder
   952  	t.writeTo(&sb)
   953  	return sb.String()
   954  }
   955  
   956  func (t *TemplateNode) writeTo(sb *strings.Builder) {
   957  	sb.WriteString("{{template ")
   958  	sb.WriteString(strconv.Quote(t.Name))
   959  	if t.Pipe != nil {
   960  		sb.WriteByte(' ')
   961  		t.Pipe.writeTo(sb)
   962  	}
   963  	sb.WriteString("}}")
   964  }
   965  
   966  func (t *TemplateNode) tree() *Tree {
   967  	return t.tr
   968  }
   969  
   970  func (t *TemplateNode) Copy() Node {
   971  	return t.tr.newTemplate(t.Pos, t.Line, t.Name, t.Pipe.CopyPipe())
   972  }
   973  

View as plain text