third_party/gofrontend/libgo/go/text/template/parse/node.go - llvm-project/llgo - Git at Google

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Parse nodes.

 package parse

 import (
 	"bytes"
 	"fmt"
 	"strconv"
 	"strings"
 )

 var textFormat = "%s" // Changed to "%q" in tests for better error messages.

 // A Node is an element in the parse tree. The interface is trivial.
 // The interface contains an unexported method so that only
 // types local to this package can satisfy it.
 type Node interface {
 	Type() NodeType
 	String() string
 	// Copy does a deep copy of the Node and all its components.
 	// To avoid type assertions, some XxxNodes also have specialized
 	// CopyXxx methods that return *XxxNode.
 	Copy() Node
 	Position() Pos // byte position of start of node in full original input string
 	// Make sure only functions in this package can create Nodes.
 	unexported()
 }

 // NodeType identifies the type of a parse tree node.
 type NodeType int

 // Pos represents a byte position in the original input text from which
 // this template was parsed.
 type Pos int

 func (p Pos) Position() Pos {
 	return p
 }

 // unexported keeps Node implementations local to the package.
 // All implementations embed Pos, so this takes care of it.
 func (Pos) unexported() {
 }

 // Type returns itself and provides an easy default implementation
 // for embedding in a Node. Embedded in all non-trivial Nodes.
 func (t NodeType) Type() NodeType {
 	return t
 }

 const (
 	NodeText       NodeType = iota // Plain text.
 	NodeAction                     // A non-control action such as a field evaluation.
 	NodeBool                       // A boolean constant.
 	NodeChain                      // A sequence of field accesses.
 	NodeCommand                    // An element of a pipeline.
 	NodeDot                        // The cursor, dot.
 	nodeElse                       // An else action. Not added to tree.
 	nodeEnd                        // An end action. Not added to tree.
 	NodeField                      // A field or method name.
 	NodeIdentifier                 // An identifier; always a function name.
 	NodeIf                         // An if action.
 	NodeList                       // A list of Nodes.
 	NodeNil                        // An untyped nil constant.
 	NodeNumber                     // A numerical constant.
 	NodePipe                       // A pipeline of commands.
 	NodeRange                      // A range action.
 	NodeString                     // A string constant.
 	NodeTemplate                   // A template invocation action.
 	NodeVariable                   // A $ variable.
 	NodeWith                       // A with action.
 )

 // Nodes.

 // ListNode holds a sequence of nodes.
 type ListNode struct {
 	NodeType
 	Pos
 	Nodes []Node // The element nodes in lexical order.
 }

 func newList(pos Pos) *ListNode {
 	return &ListNode{NodeType: NodeList, Pos: pos}
 }

 func (l *ListNode) append(n Node) {
 	l.Nodes = append(l.Nodes, n)
 }

 func (l *ListNode) String() string {
 	b := new(bytes.Buffer)
 	for _, n := range l.Nodes {
 		fmt.Fprint(b, n)
 	}
 	return b.String()
 }

 func (l *ListNode) CopyList() *ListNode {
 	if l == nil {
 		return l
 	}
 	n := newList(l.Pos)
 	for _, elem := range l.Nodes {
 		n.append(elem.Copy())
 	}
 	return n
 }

 func (l *ListNode) Copy() Node {
 	return l.CopyList()
 }

 // TextNode holds plain text.
 type TextNode struct {
 	NodeType
 	Pos
 	Text []byte // The text; may span newlines.
 }

 func newText(pos Pos, text string) *TextNode {
 	return &TextNode{NodeType: NodeText, Pos: pos, Text: []byte(text)}
 }

 func (t *TextNode) String() string {
 	return fmt.Sprintf(textFormat, t.Text)
 }

 func (t *TextNode) Copy() Node {
 	return &TextNode{NodeType: NodeText, Text: append([]byte{}, t.Text...)}
 }

 // PipeNode holds a pipeline with optional declaration
 type PipeNode struct {
 	NodeType
 	Pos
 	Line int             // The line number in the input (deprecated; kept for compatibility)
 	Decl []*VariableNode // Variable declarations in lexical order.
 	Cmds []*CommandNode  // The commands in lexical order.
 }

 func newPipeline(pos Pos, line int, decl []*VariableNode) *PipeNode {
 	return &PipeNode{NodeType: NodePipe, Pos: pos, Line: line, Decl: decl}
 }

 func (p *PipeNode) append(command *CommandNode) {
 	p.Cmds = append(p.Cmds, command)
 }

 func (p *PipeNode) String() string {
 	s := ""
 	if len(p.Decl) > 0 {
 		for i, v := range p.Decl {
 			if i > 0 {
 				s += ", "
 			}
 			s += v.String()
 		}
 		s += " := "
 	}
 	for i, c := range p.Cmds {
 		if i > 0 {
 			s += " | "
 		}
 		s += c.String()
 	}
 	return s
 }

 func (p *PipeNode) CopyPipe() *PipeNode {
 	if p == nil {
 		return p
 	}
 	var decl []*VariableNode
 	for _, d := range p.Decl {
 		decl = append(decl, d.Copy().(*VariableNode))
 	}
 	n := newPipeline(p.Pos, p.Line, decl)
 	for _, c := range p.Cmds {
 		n.append(c.Copy().(*CommandNode))
 	}
 	return n
 }

 func (p *PipeNode) Copy() Node {
 	return p.CopyPipe()
 }

 // ActionNode holds an action (something bounded by delimiters).
 // Control actions have their own nodes; ActionNode represents simple
 // ones such as field evaluations and parenthesized pipelines.
 type ActionNode struct {
 	NodeType
 	Pos
 	Line int       // The line number in the input (deprecated; kept for compatibility)
 	Pipe *PipeNode // The pipeline in the action.
 }

 func newAction(pos Pos, line int, pipe *PipeNode) *ActionNode {
 	return &ActionNode{NodeType: NodeAction, Pos: pos, Line: line, Pipe: pipe}
 }

 func (a *ActionNode) String() string {
 	return fmt.Sprintf("{{%s}}", a.Pipe)

 }

 func (a *ActionNode) Copy() Node {
 	return newAction(a.Pos, a.Line, a.Pipe.CopyPipe())

 }

 // CommandNode holds a command (a pipeline inside an evaluating action).
 type CommandNode struct {
 	NodeType
 	Pos
 	Args []Node // Arguments in lexical order: Identifier, field, or constant.
 }

 func newCommand(pos Pos) *CommandNode {
 	return &CommandNode{NodeType: NodeCommand, Pos: pos}
 }

 func (c *CommandNode) append(arg Node) {
 	c.Args = append(c.Args, arg)
 }

 func (c *CommandNode) String() string {
 	s := ""
 	for i, arg := range c.Args {
 		if i > 0 {
 			s += " "
 		}
 		if arg, ok := arg.(*PipeNode); ok {
 			s += "(" + arg.String() + ")"
 			continue
 		}
 		s += arg.String()
 	}
 	return s
 }

 func (c *CommandNode) Copy() Node {
 	if c == nil {
 		return c
 	}
 	n := newCommand(c.Pos)
 	for _, c := range c.Args {
 		n.append(c.Copy())
 	}
 	return n
 }

 // IdentifierNode holds an identifier.
 type IdentifierNode struct {
 	NodeType
 	Pos
 	Ident string // The identifier's name.
 }

 // NewIdentifier returns a new IdentifierNode with the given identifier name.
 func NewIdentifier(ident string) *IdentifierNode {
 	return &IdentifierNode{NodeType: NodeIdentifier, Ident: ident}
 }

 // SetPos sets the position. NewIdentifier is a public method so we can't modify its signature.
 // Chained for convenience.
 // TODO: fix one day?
 func (i *IdentifierNode) SetPos(pos Pos) *IdentifierNode {
 	i.Pos = pos
 	return i
 }

 func (i *IdentifierNode) String() string {
 	return i.Ident
 }

 func (i *IdentifierNode) Copy() Node {
 	return NewIdentifier(i.Ident).SetPos(i.Pos)
 }

 // VariableNode holds a list of variable names, possibly with chained field
 // accesses. The dollar sign is part of the (first) name.
 type VariableNode struct {
 	NodeType
 	Pos
 	Ident []string // Variable name and fields in lexical order.
 }

 func newVariable(pos Pos, ident string) *VariableNode {
 	return &VariableNode{NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
 }

 func (v *VariableNode) String() string {
 	s := ""
 	for i, id := range v.Ident {
 		if i > 0 {
 			s += "."
 		}
 		s += id
 	}
 	return s
 }

 func (v *VariableNode) Copy() Node {
 	return &VariableNode{NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
 }

 // DotNode holds the special identifier '.'.
 type DotNode struct {
 	Pos
 }

 func newDot(pos Pos) *DotNode {
 	return &DotNode{Pos: pos}
 }

 func (d *DotNode) Type() NodeType {
 	return NodeDot
 }

 func (d *DotNode) String() string {
 	return "."
 }

 func (d *DotNode) Copy() Node {
 	return newDot(d.Pos)
 }

 // NilNode holds the special identifier 'nil' representing an untyped nil constant.
 type NilNode struct {
 	Pos
 }

 func newNil(pos Pos) *NilNode {
 	return &NilNode{Pos: pos}
 }

 func (n *NilNode) Type() NodeType {
 	return NodeNil
 }

 func (n *NilNode) String() string {
 	return "nil"
 }

 func (n *NilNode) Copy() Node {
 	return newNil(n.Pos)
 }

 // FieldNode holds a field (identifier starting with '.').
 // The names may be chained ('.x.y').
 // The period is dropped from each ident.
 type FieldNode struct {
 	NodeType
 	Pos
 	Ident []string // The identifiers in lexical order.
 }

 func newField(pos Pos, ident string) *FieldNode {
 	return &FieldNode{NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period
 }

 func (f *FieldNode) String() string {
 	s := ""
 	for _, id := range f.Ident {
 		s += "." + id
 	}
 	return s
 }

 func (f *FieldNode) Copy() Node {
 	return &FieldNode{NodeType: NodeField, Pos: f.Pos, Ident: append([]string{}, f.Ident...)}
 }

 // ChainNode holds a term followed by a chain of field accesses (identifier starting with '.').
 // The names may be chained ('.x.y').
 // The periods are dropped from each ident.
 type ChainNode struct {
 	NodeType
 	Pos
 	Node  Node
 	Field []string // The identifiers in lexical order.
 }

 func newChain(pos Pos, node Node) *ChainNode {
 	return &ChainNode{NodeType: NodeChain, Pos: pos, Node: node}
 }

 // Add adds the named field (which should start with a period) to the end of the chain.
 func (c *ChainNode) Add(field string) {
 	if len(field) == 0 || field[0] != '.' {
 		panic("no dot in field")
 	}
 	field = field[1:] // Remove leading dot.
 	if field == "" {
 		panic("empty field")
 	}
 	c.Field = append(c.Field, field)
 }

 func (c *ChainNode) String() string {
 	s := c.Node.String()
 	if _, ok := c.Node.(*PipeNode); ok {
 		s = "(" + s + ")"
 	}
 	for _, field := range c.Field {
 		s += "." + field
 	}
 	return s
 }

 func (c *ChainNode) Copy() Node {
 	return &ChainNode{NodeType: NodeChain, Pos: c.Pos, Node: c.Node, Field: append([]string{}, c.Field...)}
 }

 // BoolNode holds a boolean constant.
 type BoolNode struct {
 	NodeType
 	Pos
 	True bool // The value of the boolean constant.
 }

 func newBool(pos Pos, true bool) *BoolNode {
 	return &BoolNode{NodeType: NodeBool, Pos: pos, True: true}
 }

 func (b *BoolNode) String() string {
 	if b.True {
 		return "true"
 	}
 	return "false"
 }

 func (b *BoolNode) Copy() Node {
 	return newBool(b.Pos, b.True)
 }

 // NumberNode holds a number: signed or unsigned integer, float, or complex.
 // The value is parsed and stored under all the types that can represent the value.
 // This simulates in a small amount of code the behavior of Go's ideal constants.
 type NumberNode struct {
 	NodeType
 	Pos
 	IsInt      bool       // Number has an integral value.
 	IsUint     bool       // Number has an unsigned integral value.
 	IsFloat    bool       // Number has a floating-point value.
 	IsComplex  bool       // Number is complex.
 	Int64      int64      // The signed integer value.
 	Uint64     uint64     // The unsigned integer value.
 	Float64    float64    // The floating-point value.
 	Complex128 complex128 // The complex value.
 	Text       string     // The original textual representation from the input.
 }

 func newNumber(pos Pos, text string, typ itemType) (*NumberNode, error) {
 	n := &NumberNode{NodeType: NodeNumber, Pos: pos, Text: text}
 	switch typ {
 	case itemCharConstant:
 		rune, _, tail, err := strconv.UnquoteChar(text[1:], text[0])
 		if err != nil {
 			return nil, err
 		}
 		if tail != "'" {
 			return nil, fmt.Errorf("malformed character constant: %s", text)
 		}
 		n.Int64 = int64(rune)
 		n.IsInt = true
 		n.Uint64 = uint64(rune)
 		n.IsUint = true
 		n.Float64 = float64(rune) // odd but those are the rules.
 		n.IsFloat = true
 		return n, nil
 	case itemComplex:
 		// fmt.Sscan can parse the pair, so let it do the work.
 		if _, err := fmt.Sscan(text, &n.Complex128); err != nil {
 			return nil, err
 		}
 		n.IsComplex = true
 		n.simplifyComplex()
 		return n, nil
 	}
 	// Imaginary constants can only be complex unless they are zero.
 	if len(text) > 0 && text[len(text)-1] == 'i' {
 		f, err := strconv.ParseFloat(text[:len(text)-1], 64)
 		if err == nil {
 			n.IsComplex = true
 			n.Complex128 = complex(0, f)
 			n.simplifyComplex()
 			return n, nil
 		}
 	}
 	// Do integer test first so we get 0x123 etc.
 	u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below.
 	if err == nil {
 		n.IsUint = true
 		n.Uint64 = u
 	}
 	i, err := strconv.ParseInt(text, 0, 64)
 	if err == nil {
 		n.IsInt = true
 		n.Int64 = i
 		if i == 0 {
 			n.IsUint = true // in case of -0.
 			n.Uint64 = u
 		}
 	}
 	// If an integer extraction succeeded, promote the float.
 	if n.IsInt {
 		n.IsFloat = true
 		n.Float64 = float64(n.Int64)
 	} else if n.IsUint {
 		n.IsFloat = true
 		n.Float64 = float64(n.Uint64)
 	} else {
 		f, err := strconv.ParseFloat(text, 64)
 		if err == nil {
 			n.IsFloat = true
 			n.Float64 = f
 			// If a floating-point extraction succeeded, extract the int if needed.
 			if !n.IsInt && float64(int64(f)) == f {
 				n.IsInt = true
 				n.Int64 = int64(f)
 			}
 			if !n.IsUint && float64(uint64(f)) == f {
 				n.IsUint = true
 				n.Uint64 = uint64(f)
 			}
 		}
 	}
 	if !n.IsInt && !n.IsUint && !n.IsFloat {
 		return nil, fmt.Errorf("illegal number syntax: %q", text)
 	}
 	return n, nil
 }

 // simplifyComplex pulls out any other types that are represented by the complex number.
 // These all require that the imaginary part be zero.
 func (n *NumberNode) simplifyComplex() {
 	n.IsFloat = imag(n.Complex128) == 0
 	if n.IsFloat {
 		n.Float64 = real(n.Complex128)
 		n.IsInt = float64(int64(n.Float64)) == n.Float64
 		if n.IsInt {
 			n.Int64 = int64(n.Float64)
 		}
 		n.IsUint = float64(uint64(n.Float64)) == n.Float64
 		if n.IsUint {
 			n.Uint64 = uint64(n.Float64)
 		}
 	}
 }

 func (n *NumberNode) String() string {
 	return n.Text
 }

 func (n *NumberNode) Copy() Node {
 	nn := new(NumberNode)
 	*nn = *n // Easy, fast, correct.
 	return nn
 }

 // StringNode holds a string constant. The value has been "unquoted".
 type StringNode struct {
 	NodeType
 	Pos
 	Quoted string // The original text of the string, with quotes.
 	Text   string // The string, after quote processing.
 }

 func newString(pos Pos, orig, text string) *StringNode {
 	return &StringNode{NodeType: NodeString, Pos: pos, Quoted: orig, Text: text}
 }

 func (s *StringNode) String() string {
 	return s.Quoted
 }

 func (s *StringNode) Copy() Node {
 	return newString(s.Pos, s.Quoted, s.Text)
 }

 // endNode represents an {{end}} action.
 // It does not appear in the final parse tree.
 type endNode struct {
 	Pos
 }

 func newEnd(pos Pos) *endNode {
 	return &endNode{Pos: pos}
 }

 func (e *endNode) Type() NodeType {
 	return nodeEnd
 }

 func (e *endNode) String() string {
 	return "{{end}}"
 }

 func (e *endNode) Copy() Node {
 	return newEnd(e.Pos)
 }

 // elseNode represents an {{else}} action. Does not appear in the final tree.
 type elseNode struct {
 	NodeType
 	Pos
 	Line int // The line number in the input (deprecated; kept for compatibility)
 }

 func newElse(pos Pos, line int) *elseNode {
 	return &elseNode{NodeType: nodeElse, Pos: pos, Line: line}
 }

 func (e *elseNode) Type() NodeType {
 	return nodeElse
 }

 func (e *elseNode) String() string {
 	return "{{else}}"
 }

 func (e *elseNode) Copy() Node {
 	return newElse(e.Pos, e.Line)
 }

 // BranchNode is the common representation of if, range, and with.
 type BranchNode struct {
 	NodeType
 	Pos
 	Line     int       // The line number in the input (deprecated; kept for compatibility)
 	Pipe     *PipeNode // The pipeline to be evaluated.
 	List     *ListNode // What to execute if the value is non-empty.
 	ElseList *ListNode // What to execute if the value is empty (nil if absent).
 }

 func (b *BranchNode) String() string {
 	name := ""
 	switch b.NodeType {
 	case NodeIf:
 		name = "if"
 	case NodeRange:
 		name = "range"
 	case NodeWith:
 		name = "with"
 	default:
 		panic("unknown branch type")
 	}
 	if b.ElseList != nil {
 		return fmt.Sprintf("{{%s %s}}%s{{else}}%s{{end}}", name, b.Pipe, b.List, b.ElseList)
 	}
 	return fmt.Sprintf("{{%s %s}}%s{{end}}", name, b.Pipe, b.List)
 }

 // IfNode represents an {{if}} action and its commands.
 type IfNode struct {
 	BranchNode
 }

 func newIf(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *IfNode {
 	return &IfNode{BranchNode{NodeType: NodeIf, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
 }

 func (i *IfNode) Copy() Node {
 	return newIf(i.Pos, i.Line, i.Pipe.CopyPipe(), i.List.CopyList(), i.ElseList.CopyList())
 }

 // RangeNode represents a {{range}} action and its commands.
 type RangeNode struct {
 	BranchNode
 }

 func newRange(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *RangeNode {
 	return &RangeNode{BranchNode{NodeType: NodeRange, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
 }

 func (r *RangeNode) Copy() Node {
 	return newRange(r.Pos, r.Line, r.Pipe.CopyPipe(), r.List.CopyList(), r.ElseList.CopyList())
 }

 // WithNode represents a {{with}} action and its commands.
 type WithNode struct {
 	BranchNode
 }

 func newWith(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *WithNode {
 	return &WithNode{BranchNode{NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
 }

 func (w *WithNode) Copy() Node {
 	return newWith(w.Pos, w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList())
 }

 // TemplateNode represents a {{template}} action.
 type TemplateNode struct {
 	NodeType
 	Pos
 	Line int       // The line number in the input (deprecated; kept for compatibility)
 	Name string    // The name of the template (unquoted).
 	Pipe *PipeNode // The command to evaluate as dot for the template.
 }

 func newTemplate(pos Pos, line int, name string, pipe *PipeNode) *TemplateNode {
 	return &TemplateNode{NodeType: NodeTemplate, Line: line, Pos: pos, Name: name, Pipe: pipe}
 }

 func (t *TemplateNode) String() string {
 	if t.Pipe == nil {
 		return fmt.Sprintf("{{template %q}}", t.Name)
 	}
 	return fmt.Sprintf("{{template %q %s}}", t.Name, t.Pipe)
 }

 func (t *TemplateNode) Copy() Node {
 	return newTemplate(t.Pos, t.Line, t.Name, t.Pipe.CopyPipe())
 }
	// Copyright 2011 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Parse nodes.

	package parse

	import (
	"bytes"
	"fmt"
	"strconv"
	"strings"
	)

	var textFormat = "%s" // Changed to "%q" in tests for better error messages.

	// A Node is an element in the parse tree. The interface is trivial.
	// The interface contains an unexported method so that only
	// types local to this package can satisfy it.
	type Node interface {
	Type() NodeType
	String() string
	// Copy does a deep copy of the Node and all its components.
	// To avoid type assertions, some XxxNodes also have specialized
	// CopyXxx methods that return *XxxNode.
	Copy() Node
	Position() Pos // byte position of start of node in full original input string
	// Make sure only functions in this package can create Nodes.
	unexported()
	}

	// NodeType identifies the type of a parse tree node.
	type NodeType int

	// Pos represents a byte position in the original input text from which
	// this template was parsed.
	type Pos int

	func (p Pos) Position() Pos {
	return p
	}

	// unexported keeps Node implementations local to the package.
	// All implementations embed Pos, so this takes care of it.
	func (Pos) unexported() {
	}

	// Type returns itself and provides an easy default implementation
	// for embedding in a Node. Embedded in all non-trivial Nodes.
	func (t NodeType) Type() NodeType {
	return t
	}

	const (
	NodeText NodeType = iota // Plain text.
	NodeAction // A non-control action such as a field evaluation.
	NodeBool // A boolean constant.
	NodeChain // A sequence of field accesses.
	NodeCommand // An element of a pipeline.
	NodeDot // The cursor, dot.
	nodeElse // An else action. Not added to tree.
	nodeEnd // An end action. Not added to tree.
	NodeField // A field or method name.
	NodeIdentifier // An identifier; always a function name.
	NodeIf // An if action.
	NodeList // A list of Nodes.
	NodeNil // An untyped nil constant.
	NodeNumber // A numerical constant.
	NodePipe // A pipeline of commands.
	NodeRange // A range action.
	NodeString // A string constant.
	NodeTemplate // A template invocation action.
	NodeVariable // A $ variable.
	NodeWith // A with action.
	)

	// Nodes.

	// ListNode holds a sequence of nodes.
	type ListNode struct {
	NodeType
	Pos
	Nodes []Node // The element nodes in lexical order.
	}

	func newList(pos Pos) *ListNode {
	return &ListNode{NodeType: NodeList, Pos: pos}
	}

	func (l *ListNode) append(n Node) {
	l.Nodes = append(l.Nodes, n)
	}

	func (l *ListNode) String() string {
	b := new(bytes.Buffer)
	for _, n := range l.Nodes {
	fmt.Fprint(b, n)
	}
	return b.String()
	}

	func (l ListNode) CopyList() ListNode {
	if l == nil {
	return l
	}
	n := newList(l.Pos)
	for _, elem := range l.Nodes {
	n.append(elem.Copy())
	}
	return n
	}

	func (l *ListNode) Copy() Node {
	return l.CopyList()
	}

	// TextNode holds plain text.
	type TextNode struct {
	NodeType
	Pos
	Text []byte // The text; may span newlines.
	}

	func newText(pos Pos, text string) *TextNode {
	return &TextNode{NodeType: NodeText, Pos: pos, Text: []byte(text)}
	}

	func (t *TextNode) String() string {
	return fmt.Sprintf(textFormat, t.Text)
	}

	func (t *TextNode) Copy() Node {
	return &TextNode{NodeType: NodeText, Text: append([]byte{}, t.Text...)}
	}

	// PipeNode holds a pipeline with optional declaration
	type PipeNode struct {
	NodeType
	Pos
	Line int // The line number in the input (deprecated; kept for compatibility)
	Decl []*VariableNode // Variable declarations in lexical order.
	Cmds []*CommandNode // The commands in lexical order.
	}

	func newPipeline(pos Pos, line int, decl []VariableNode) PipeNode {
	return &PipeNode{NodeType: NodePipe, Pos: pos, Line: line, Decl: decl}
	}

	func (p PipeNode) append(command CommandNode) {
	p.Cmds = append(p.Cmds, command)
	}

	func (p *PipeNode) String() string {
	s := ""
	if len(p.Decl) > 0 {
	for i, v := range p.Decl {
	if i > 0 {
	s += ", "
	}
	s += v.String()
	}
	s += " := "
	}
	for i, c := range p.Cmds {
	if i > 0 {
	s += " \| "
	}
	s += c.String()
	}
	return s
	}

	func (p PipeNode) CopyPipe() PipeNode {
	if p == nil {
	return p
	}
	var decl []*VariableNode
	for _, d := range p.Decl {
	decl = append(decl, d.Copy().(*VariableNode))
	}
	n := newPipeline(p.Pos, p.Line, decl)
	for _, c := range p.Cmds {
	n.append(c.Copy().(*CommandNode))
	}
	return n
	}

	func (p *PipeNode) Copy() Node {
	return p.CopyPipe()
	}

	// ActionNode holds an action (something bounded by delimiters).
	// Control actions have their own nodes; ActionNode represents simple
	// ones such as field evaluations and parenthesized pipelines.
	type ActionNode struct {
	NodeType
	Pos
	Line int // The line number in the input (deprecated; kept for compatibility)
	Pipe *PipeNode // The pipeline in the action.
	}

	func newAction(pos Pos, line int, pipe PipeNode) ActionNode {
	return &ActionNode{NodeType: NodeAction, Pos: pos, Line: line, Pipe: pipe}
	}

	func (a *ActionNode) String() string {
	return fmt.Sprintf("{{%s}}", a.Pipe)

	}

	func (a *ActionNode) Copy() Node {
	return newAction(a.Pos, a.Line, a.Pipe.CopyPipe())

	}

	// CommandNode holds a command (a pipeline inside an evaluating action).
	type CommandNode struct {
	NodeType
	Pos
	Args []Node // Arguments in lexical order: Identifier, field, or constant.
	}

	func newCommand(pos Pos) *CommandNode {
	return &CommandNode{NodeType: NodeCommand, Pos: pos}
	}

	func (c *CommandNode) append(arg Node) {
	c.Args = append(c.Args, arg)
	}

	func (c *CommandNode) String() string {
	s := ""
	for i, arg := range c.Args {
	if i > 0 {
	s += " "
	}
	if arg, ok := arg.(*PipeNode); ok {
	s += "(" + arg.String() + ")"
	continue
	}
	s += arg.String()
	}
	return s
	}

	func (c *CommandNode) Copy() Node {
	if c == nil {
	return c
	}
	n := newCommand(c.Pos)
	for _, c := range c.Args {
	n.append(c.Copy())
	}
	return n
	}

	// IdentifierNode holds an identifier.
	type IdentifierNode struct {
	NodeType
	Pos
	Ident string // The identifier's name.
	}

	// NewIdentifier returns a new IdentifierNode with the given identifier name.
	func NewIdentifier(ident string) *IdentifierNode {
	return &IdentifierNode{NodeType: NodeIdentifier, Ident: ident}
	}

	// SetPos sets the position. NewIdentifier is a public method so we can't modify its signature.
	// Chained for convenience.
	// TODO: fix one day?
	func (i IdentifierNode) SetPos(pos Pos) IdentifierNode {
	i.Pos = pos
	return i
	}

	func (i *IdentifierNode) String() string {
	return i.Ident
	}

	func (i *IdentifierNode) Copy() Node {
	return NewIdentifier(i.Ident).SetPos(i.Pos)
	}

	// VariableNode holds a list of variable names, possibly with chained field
	// accesses. The dollar sign is part of the (first) name.
	type VariableNode struct {
	NodeType
	Pos
	Ident []string // Variable name and fields in lexical order.
	}

	func newVariable(pos Pos, ident string) *VariableNode {
	return &VariableNode{NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
	}

	func (v *VariableNode) String() string {
	s := ""
	for i, id := range v.Ident {
	if i > 0 {
	s += "."
	}
	s += id
	}
	return s
	}

	func (v *VariableNode) Copy() Node {
	return &VariableNode{NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
	}

	// DotNode holds the special identifier '.'.
	type DotNode struct {
	Pos
	}

	func newDot(pos Pos) *DotNode {
	return &DotNode{Pos: pos}
	}

	func (d *DotNode) Type() NodeType {
	return NodeDot
	}

	func (d *DotNode) String() string {
	return "."
	}

	func (d *DotNode) Copy() Node {
	return newDot(d.Pos)
	}

	// NilNode holds the special identifier 'nil' representing an untyped nil constant.
	type NilNode struct {
	Pos
	}

	func newNil(pos Pos) *NilNode {
	return &NilNode{Pos: pos}
	}

	func (n *NilNode) Type() NodeType {
	return NodeNil
	}

	func (n *NilNode) String() string {
	return "nil"
	}

	func (n *NilNode) Copy() Node {
	return newNil(n.Pos)
	}

	// FieldNode holds a field (identifier starting with '.').
	// The names may be chained ('.x.y').
	// The period is dropped from each ident.
	type FieldNode struct {
	NodeType
	Pos
	Ident []string // The identifiers in lexical order.
	}

	func newField(pos Pos, ident string) *FieldNode {
	return &FieldNode{NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period
	}

	func (f *FieldNode) String() string {
	s := ""
	for _, id := range f.Ident {
	s += "." + id
	}
	return s
	}

	func (f *FieldNode) Copy() Node {
	return &FieldNode{NodeType: NodeField, Pos: f.Pos, Ident: append([]string{}, f.Ident...)}
	}

	// ChainNode holds a term followed by a chain of field accesses (identifier starting with '.').
	// The names may be chained ('.x.y').
	// The periods are dropped from each ident.
	type ChainNode struct {
	NodeType
	Pos
	Node Node
	Field []string // The identifiers in lexical order.
	}

	func newChain(pos Pos, node Node) *ChainNode {
	return &ChainNode{NodeType: NodeChain, Pos: pos, Node: node}
	}

	// Add adds the named field (which should start with a period) to the end of the chain.
	func (c *ChainNode) Add(field string) {
	if len(field) == 0 \|\| field[0] != '.' {
	panic("no dot in field")
	}
	field = field[1:] // Remove leading dot.
	if field == "" {
	panic("empty field")
	}
	c.Field = append(c.Field, field)
	}

	func (c *ChainNode) String() string {
	s := c.Node.String()
	if _, ok := c.Node.(*PipeNode); ok {
	s = "(" + s + ")"
	}
	for _, field := range c.Field {
	s += "." + field
	}
	return s
	}

	func (c *ChainNode) Copy() Node {
	return &ChainNode{NodeType: NodeChain, Pos: c.Pos, Node: c.Node, Field: append([]string{}, c.Field...)}
	}

	// BoolNode holds a boolean constant.
	type BoolNode struct {
	NodeType
	Pos
	True bool // The value of the boolean constant.
	}

	func newBool(pos Pos, true bool) *BoolNode {
	return &BoolNode{NodeType: NodeBool, Pos: pos, True: true}
	}

	func (b *BoolNode) String() string {
	if b.True {
	return "true"
	}
	return "false"
	}

	func (b *BoolNode) Copy() Node {
	return newBool(b.Pos, b.True)
	}

	// NumberNode holds a number: signed or unsigned integer, float, or complex.
	// The value is parsed and stored under all the types that can represent the value.
	// This simulates in a small amount of code the behavior of Go's ideal constants.
	type NumberNode struct {
	NodeType
	Pos
	IsInt bool // Number has an integral value.
	IsUint bool // Number has an unsigned integral value.
	IsFloat bool // Number has a floating-point value.
	IsComplex bool // Number is complex.
	Int64 int64 // The signed integer value.
	Uint64 uint64 // The unsigned integer value.
	Float64 float64 // The floating-point value.
	Complex128 complex128 // The complex value.
	Text string // The original textual representation from the input.
	}

	func newNumber(pos Pos, text string, typ itemType) (*NumberNode, error) {
	n := &NumberNode{NodeType: NodeNumber, Pos: pos, Text: text}
	switch typ {
	case itemCharConstant:
	rune, _, tail, err := strconv.UnquoteChar(text[1:], text[0])
	if err != nil {
	return nil, err
	}
	if tail != "'" {
	return nil, fmt.Errorf("malformed character constant: %s", text)
	}
	n.Int64 = int64(rune)
	n.IsInt = true
	n.Uint64 = uint64(rune)
	n.IsUint = true
	n.Float64 = float64(rune) // odd but those are the rules.
	n.IsFloat = true
	return n, nil
	case itemComplex:
	// fmt.Sscan can parse the pair, so let it do the work.
	if _, err := fmt.Sscan(text, &n.Complex128); err != nil {
	return nil, err
	}
	n.IsComplex = true
	n.simplifyComplex()
	return n, nil
	}
	// Imaginary constants can only be complex unless they are zero.
	if len(text) > 0 && text[len(text)-1] == 'i' {
	f, err := strconv.ParseFloat(text[:len(text)-1], 64)
	if err == nil {
	n.IsComplex = true
	n.Complex128 = complex(0, f)
	n.simplifyComplex()
	return n, nil
	}
	}
	// Do integer test first so we get 0x123 etc.
	u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below.
	if err == nil {
	n.IsUint = true
	n.Uint64 = u
	}
	i, err := strconv.ParseInt(text, 0, 64)
	if err == nil {
	n.IsInt = true
	n.Int64 = i
	if i == 0 {
	n.IsUint = true // in case of -0.
	n.Uint64 = u
	}
	}
	// If an integer extraction succeeded, promote the float.
	if n.IsInt {
	n.IsFloat = true
	n.Float64 = float64(n.Int64)
	} else if n.IsUint {
	n.IsFloat = true
	n.Float64 = float64(n.Uint64)
	} else {
	f, err := strconv.ParseFloat(text, 64)
	if err == nil {
	n.IsFloat = true
	n.Float64 = f
	// If a floating-point extraction succeeded, extract the int if needed.
	if !n.IsInt && float64(int64(f)) == f {
	n.IsInt = true
	n.Int64 = int64(f)
	}
	if !n.IsUint && float64(uint64(f)) == f {
	n.IsUint = true
	n.Uint64 = uint64(f)
	}
	}
	}
	if !n.IsInt && !n.IsUint && !n.IsFloat {
	return nil, fmt.Errorf("illegal number syntax: %q", text)
	}
	return n, nil
	}

	// simplifyComplex pulls out any other types that are represented by the complex number.
	// These all require that the imaginary part be zero.
	func (n *NumberNode) simplifyComplex() {
	n.IsFloat = imag(n.Complex128) == 0
	if n.IsFloat {
	n.Float64 = real(n.Complex128)
	n.IsInt = float64(int64(n.Float64)) == n.Float64
	if n.IsInt {
	n.Int64 = int64(n.Float64)
	}
	n.IsUint = float64(uint64(n.Float64)) == n.Float64
	if n.IsUint {
	n.Uint64 = uint64(n.Float64)
	}
	}
	}

	func (n *NumberNode) String() string {
	return n.Text
	}

	func (n *NumberNode) Copy() Node {
	nn := new(NumberNode)
	nn = n // Easy, fast, correct.
	return nn
	}

	// StringNode holds a string constant. The value has been "unquoted".
	type StringNode struct {
	NodeType
	Pos
	Quoted string // The original text of the string, with quotes.
	Text string // The string, after quote processing.
	}

	func newString(pos Pos, orig, text string) *StringNode {
	return &StringNode{NodeType: NodeString, Pos: pos, Quoted: orig, Text: text}
	}

	func (s *StringNode) String() string {
	return s.Quoted
	}

	func (s *StringNode) Copy() Node {
	return newString(s.Pos, s.Quoted, s.Text)
	}

	// endNode represents an {{end}} action.
	// It does not appear in the final parse tree.
	type endNode struct {
	Pos
	}

	func newEnd(pos Pos) *endNode {
	return &endNode{Pos: pos}
	}

	func (e *endNode) Type() NodeType {
	return nodeEnd
	}

	func (e *endNode) String() string {
	return "{{end}}"
	}

	func (e *endNode) Copy() Node {
	return newEnd(e.Pos)
	}

	// elseNode represents an {{else}} action. Does not appear in the final tree.
	type elseNode struct {
	NodeType
	Pos
	Line int // The line number in the input (deprecated; kept for compatibility)
	}

	func newElse(pos Pos, line int) *elseNode {
	return &elseNode{NodeType: nodeElse, Pos: pos, Line: line}
	}

	func (e *elseNode) Type() NodeType {
	return nodeElse
	}

	func (e *elseNode) String() string {
	return "{{else}}"
	}

	func (e *elseNode) Copy() Node {
	return newElse(e.Pos, e.Line)
	}

	// BranchNode is the common representation of if, range, and with.
	type BranchNode struct {
	NodeType
	Pos
	Line int // The line number in the input (deprecated; kept for compatibility)
	Pipe *PipeNode // The pipeline to be evaluated.
	List *ListNode // What to execute if the value is non-empty.
	ElseList *ListNode // What to execute if the value is empty (nil if absent).
	}

	func (b *BranchNode) String() string {
	name := ""
	switch b.NodeType {
	case NodeIf:
	name = "if"
	case NodeRange:
	name = "range"
	case NodeWith:
	name = "with"
	default:
	panic("unknown branch type")
	}
	if b.ElseList != nil {
	return fmt.Sprintf("{{%s %s}}%s{{else}}%s{{end}}", name, b.Pipe, b.List, b.ElseList)
	}
	return fmt.Sprintf("{{%s %s}}%s{{end}}", name, b.Pipe, b.List)
	}

	// IfNode represents an {{if}} action and its commands.
	type IfNode struct {
	BranchNode
	}

	func newIf(pos Pos, line int, pipe PipeNode, list, elseList ListNode) *IfNode {
	return &IfNode{BranchNode{NodeType: NodeIf, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
	}

	func (i *IfNode) Copy() Node {
	return newIf(i.Pos, i.Line, i.Pipe.CopyPipe(), i.List.CopyList(), i.ElseList.CopyList())
	}

	// RangeNode represents a {{range}} action and its commands.
	type RangeNode struct {
	BranchNode
	}

	func newRange(pos Pos, line int, pipe PipeNode, list, elseList ListNode) *RangeNode {
	return &RangeNode{BranchNode{NodeType: NodeRange, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
	}

	func (r *RangeNode) Copy() Node {
	return newRange(r.Pos, r.Line, r.Pipe.CopyPipe(), r.List.CopyList(), r.ElseList.CopyList())
	}

	// WithNode represents a {{with}} action and its commands.
	type WithNode struct {
	BranchNode
	}

	func newWith(pos Pos, line int, pipe PipeNode, list, elseList ListNode) *WithNode {
	return &WithNode{BranchNode{NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
	}

	func (w *WithNode) Copy() Node {
	return newWith(w.Pos, w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList())
	}

	// TemplateNode represents a {{template}} action.
	type TemplateNode struct {
	NodeType
	Pos
	Line int // The line number in the input (deprecated; kept for compatibility)
	Name string // The name of the template (unquoted).
	Pipe *PipeNode // The command to evaluate as dot for the template.
	}

	func newTemplate(pos Pos, line int, name string, pipe PipeNode) TemplateNode {
	return &TemplateNode{NodeType: NodeTemplate, Line: line, Pos: pos, Name: name, Pipe: pipe}
	}

	func (t *TemplateNode) String() string {
	if t.Pipe == nil {
	return fmt.Sprintf("{{template %q}}", t.Name)
	}
	return fmt.Sprintf("{{template %q %s}}", t.Name, t.Pipe)
	}

	func (t *TemplateNode) Copy() Node {
	return newTemplate(t.Pos, t.Line, t.Name, t.Pipe.CopyPipe())
	}