// 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" ) // A node is an element in the parse tree. The interface is trivial. 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 } // NodeType identifies the type of a parse tree node. type NodeType int // 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 simple action such as field evaluation. NodeBool // A boolean constant. 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. 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 Nodes []Node // The element nodes in lexical order. } func newList() *ListNode { return &ListNode{NodeType: NodeList} } 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() 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 Text []byte // The text; may span newlines. } func newText(text string) *TextNode { return &TextNode{NodeType: NodeText, Text: []byte(text)} } func (t *TextNode) String() string { return fmt.Sprintf("%q", 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 Line int // The line number in the input. Decl []*VariableNode // Variable declarations in lexical order. Cmds []*CommandNode // The commands in lexical order. } func newPipeline(line int, decl []*VariableNode) *PipeNode { return &PipeNode{NodeType: NodePipe, 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.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. type ActionNode struct { NodeType Line int // The line number in the input. Pipe *PipeNode // The pipeline in the action. } func newAction(line int, pipe *PipeNode) *ActionNode { return &ActionNode{NodeType: NodeAction, Line: line, Pipe: pipe} } func (a *ActionNode) String() string { return fmt.Sprintf("{{%s}}", a.Pipe) } func (a *ActionNode) Copy() Node { return newAction(a.Line, a.Pipe.CopyPipe()) } // CommandNode holds a command (a pipeline inside an evaluating action). type CommandNode struct { NodeType Args []Node // Arguments in lexical order: Identifier, field, or constant. } func newCommand() *CommandNode { return &CommandNode{NodeType: NodeCommand} } 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 += " " } s += arg.String() } return s } func (c *CommandNode) Copy() Node { if c == nil { return c } n := newCommand() for _, c := range c.Args { n.append(c.Copy()) } return n } // IdentifierNode holds an identifier. type IdentifierNode struct { NodeType 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} } func (i *IdentifierNode) String() string { return i.Ident } func (i *IdentifierNode) Copy() Node { return NewIdentifier(i.Ident) } // VariableNode holds a list of variable names. The dollar sign is // part of the name. type VariableNode struct { NodeType Ident []string // Variable names in lexical order. } func newVariable(ident string) *VariableNode { return &VariableNode{NodeType: NodeVariable, 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, Ident: append([]string{}, v.Ident...)} } // DotNode holds the special identifier '.'. It is represented by a nil pointer. type DotNode bool func newDot() *DotNode { return nil } func (d *DotNode) Type() NodeType { return NodeDot } func (d *DotNode) String() string { return "." } func (d *DotNode) Copy() Node { return newDot() } // 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 Ident []string // The identifiers in lexical order. } func newField(ident string) *FieldNode { return &FieldNode{NodeType: NodeField, 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, Ident: append([]string{}, f.Ident...)} } // BoolNode holds a boolean constant. type BoolNode struct { NodeType True bool // The value of the boolean constant. } func newBool(true bool) *BoolNode { return &BoolNode{NodeType: NodeBool, True: true} } func (b *BoolNode) String() string { if b.True { return "true" } return "false" } func (b *BoolNode) Copy() Node { return newBool(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 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(text string, typ itemType) (*NumberNode, error) { n := &NumberNode{NodeType: NodeNumber, 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 Quoted string // The original text of the string, with quotes. Text string // The string, after quote processing. } func newString(orig, text string) *StringNode { return &StringNode{NodeType: NodeString, Quoted: orig, Text: text} } func (s *StringNode) String() string { return s.Quoted } func (s *StringNode) Copy() Node { return newString(s.Quoted, s.Text) } // endNode represents an {{end}} action. It is represented by a nil pointer. // It does not appear in the final parse tree. type endNode bool func newEnd() *endNode { return nil } func (e *endNode) Type() NodeType { return nodeEnd } func (e *endNode) String() string { return "{{end}}" } func (e *endNode) Copy() Node { return newEnd() } // elseNode represents an {{else}} action. Does not appear in the final tree. type elseNode struct { NodeType Line int // The line number in the input. } func newElse(line int) *elseNode { return &elseNode{NodeType: nodeElse, Line: line} } func (e *elseNode) Type() NodeType { return nodeElse } func (e *elseNode) String() string { return "{{else}}" } func (e *elseNode) Copy() Node { return newElse(e.Line) } // BranchNode is the common representation of if, range, and with. type BranchNode struct { NodeType Line int // The line number in the input. 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(line int, pipe *PipeNode, list, elseList *ListNode) *IfNode { return &IfNode{BranchNode{NodeType: NodeIf, Line: line, Pipe: pipe, List: list, ElseList: elseList}} } func (i *IfNode) Copy() Node { return newIf(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(line int, pipe *PipeNode, list, elseList *ListNode) *RangeNode { return &RangeNode{BranchNode{NodeType: NodeRange, Line: line, Pipe: pipe, List: list, ElseList: elseList}} } func (r *RangeNode) Copy() Node { return newRange(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(line int, pipe *PipeNode, list, elseList *ListNode) *WithNode { return &WithNode{BranchNode{NodeType: NodeWith, Line: line, Pipe: pipe, List: list, ElseList: elseList}} } func (w *WithNode) Copy() Node { return newWith(w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList()) } // TemplateNode represents a {{template}} action. type TemplateNode struct { NodeType Line int // The line number in the input. Name string // The name of the template (unquoted). Pipe *PipeNode // The command to evaluate as dot for the template. } func newTemplate(line int, name string, pipe *PipeNode) *TemplateNode { return &TemplateNode{NodeType: NodeTemplate, Line: line, 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.Line, t.Name, t.Pipe.CopyPipe()) }