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

     1	// Copyright 2011 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Package parse builds parse trees for templates as defined by text/template
     6	// and html/template. Clients should use those packages to construct templates
     7	// rather than this one, which provides shared internal data structures not
     8	// intended for general use.
     9	package parse
    10	
    11	import (
    12		"bytes"
    13		"fmt"
    14		"runtime"
    15		"strconv"
    16		"strings"
    17	)
    18	
    19	// Tree is the representation of a single parsed template.
    20	type Tree struct {
    21		Name      string    // name of the template represented by the tree.
    22		ParseName string    // name of the top-level template during parsing, for error messages.
    23		Root      *ListNode // top-level root of the tree.
    24		text      string    // text parsed to create the template (or its parent)
    25		// Parsing only; cleared after parse.
    26		funcs     []map[string]interface{}
    27		lex       *lexer
    28		token     [3]item // three-token lookahead for parser.
    29		peekCount int
    30		vars      []string // variables defined at the moment.
    31		treeSet   map[string]*Tree
    32	}
    33	
    34	// Copy returns a copy of the Tree. Any parsing state is discarded.
    35	func (t *Tree) Copy() *Tree {
    36		if t == nil {
    37			return nil
    38		}
    39		return &Tree{
    40			Name:      t.Name,
    41			ParseName: t.ParseName,
    42			Root:      t.Root.CopyList(),
    43			text:      t.text,
    44		}
    45	}
    46	
    47	// Parse returns a map from template name to parse.Tree, created by parsing the
    48	// templates described in the argument string. The top-level template will be
    49	// given the specified name. If an error is encountered, parsing stops and an
    50	// empty map is returned with the error.
    51	func Parse(name, text, leftDelim, rightDelim string, funcs ...map[string]interface{}) (map[string]*Tree, error) {
    52		treeSet := make(map[string]*Tree)
    53		t := New(name)
    54		t.text = text
    55		_, err := t.Parse(text, leftDelim, rightDelim, treeSet, funcs...)
    56		return treeSet, err
    57	}
    58	
    59	// next returns the next token.
    60	func (t *Tree) next() item {
    61		if t.peekCount > 0 {
    62			t.peekCount--
    63		} else {
    64			t.token[0] = t.lex.nextItem()
    65		}
    66		return t.token[t.peekCount]
    67	}
    68	
    69	// backup backs the input stream up one token.
    70	func (t *Tree) backup() {
    71		t.peekCount++
    72	}
    73	
    74	// backup2 backs the input stream up two tokens.
    75	// The zeroth token is already there.
    76	func (t *Tree) backup2(t1 item) {
    77		t.token[1] = t1
    78		t.peekCount = 2
    79	}
    80	
    81	// backup3 backs the input stream up three tokens
    82	// The zeroth token is already there.
    83	func (t *Tree) backup3(t2, t1 item) { // Reverse order: we're pushing back.
    84		t.token[1] = t1
    85		t.token[2] = t2
    86		t.peekCount = 3
    87	}
    88	
    89	// peek returns but does not consume the next token.
    90	func (t *Tree) peek() item {
    91		if t.peekCount > 0 {
    92			return t.token[t.peekCount-1]
    93		}
    94		t.peekCount = 1
    95		t.token[0] = t.lex.nextItem()
    96		return t.token[0]
    97	}
    98	
    99	// nextNonSpace returns the next non-space token.
   100	func (t *Tree) nextNonSpace() (token item) {
   101		for {
   102			token = t.next()
   103			if token.typ != itemSpace {
   104				break
   105			}
   106		}
   107		return token
   108	}
   109	
   110	// peekNonSpace returns but does not consume the next non-space token.
   111	func (t *Tree) peekNonSpace() (token item) {
   112		for {
   113			token = t.next()
   114			if token.typ != itemSpace {
   115				break
   116			}
   117		}
   118		t.backup()
   119		return token
   120	}
   121	
   122	// Parsing.
   123	
   124	// New allocates a new parse tree with the given name.
   125	func New(name string, funcs ...map[string]interface{}) *Tree {
   126		return &Tree{
   127			Name:  name,
   128			funcs: funcs,
   129		}
   130	}
   131	
   132	// ErrorContext returns a textual representation of the location of the node in the input text.
   133	// The receiver is only used when the node does not have a pointer to the tree inside,
   134	// which can occur in old code.
   135	func (t *Tree) ErrorContext(n Node) (location, context string) {
   136		pos := int(n.Position())
   137		tree := n.tree()
   138		if tree == nil {
   139			tree = t
   140		}
   141		text := tree.text[:pos]
   142		byteNum := strings.LastIndex(text, "\n")
   143		if byteNum == -1 {
   144			byteNum = pos // On first line.
   145		} else {
   146			byteNum++ // After the newline.
   147			byteNum = pos - byteNum
   148		}
   149		lineNum := 1 + strings.Count(text, "\n")
   150		context = n.String()
   151		return fmt.Sprintf("%s:%d:%d", tree.ParseName, lineNum, byteNum), context
   152	}
   153	
   154	// errorf formats the error and terminates processing.
   155	func (t *Tree) errorf(format string, args ...interface{}) {
   156		t.Root = nil
   157		format = fmt.Sprintf("template: %s:%d: %s", t.ParseName, t.token[0].line, format)
   158		panic(fmt.Errorf(format, args...))
   159	}
   160	
   161	// error terminates processing.
   162	func (t *Tree) error(err error) {
   163		t.errorf("%s", err)
   164	}
   165	
   166	// expect consumes the next token and guarantees it has the required type.
   167	func (t *Tree) expect(expected itemType, context string) item {
   168		token := t.nextNonSpace()
   169		if token.typ != expected {
   170			t.unexpected(token, context)
   171		}
   172		return token
   173	}
   174	
   175	// expectOneOf consumes the next token and guarantees it has one of the required types.
   176	func (t *Tree) expectOneOf(expected1, expected2 itemType, context string) item {
   177		token := t.nextNonSpace()
   178		if token.typ != expected1 && token.typ != expected2 {
   179			t.unexpected(token, context)
   180		}
   181		return token
   182	}
   183	
   184	// unexpected complains about the token and terminates processing.
   185	func (t *Tree) unexpected(token item, context string) {
   186		t.errorf("unexpected %s in %s", token, context)
   187	}
   188	
   189	// recover is the handler that turns panics into returns from the top level of Parse.
   190	func (t *Tree) recover(errp *error) {
   191		e := recover()
   192		if e != nil {
   193			if _, ok := e.(runtime.Error); ok {
   194				panic(e)
   195			}
   196			if t != nil {
   197				t.lex.drain()
   198				t.stopParse()
   199			}
   200			*errp = e.(error)
   201		}
   202	}
   203	
   204	// startParse initializes the parser, using the lexer.
   205	func (t *Tree) startParse(funcs []map[string]interface{}, lex *lexer, treeSet map[string]*Tree) {
   206		t.Root = nil
   207		t.lex = lex
   208		t.vars = []string{"$"}
   209		t.funcs = funcs
   210		t.treeSet = treeSet
   211	}
   212	
   213	// stopParse terminates parsing.
   214	func (t *Tree) stopParse() {
   215		t.lex = nil
   216		t.vars = nil
   217		t.funcs = nil
   218		t.treeSet = nil
   219	}
   220	
   221	// Parse parses the template definition string to construct a representation of
   222	// the template for execution. If either action delimiter string is empty, the
   223	// default ("{{" or "}}") is used. Embedded template definitions are added to
   224	// the treeSet map.
   225	func (t *Tree) Parse(text, leftDelim, rightDelim string, treeSet map[string]*Tree, funcs ...map[string]interface{}) (tree *Tree, err error) {
   226		defer t.recover(&err)
   227		t.ParseName = t.Name
   228		t.startParse(funcs, lex(t.Name, text, leftDelim, rightDelim), treeSet)
   229		t.text = text
   230		t.parse()
   231		t.add()
   232		t.stopParse()
   233		return t, nil
   234	}
   235	
   236	// add adds tree to t.treeSet.
   237	func (t *Tree) add() {
   238		tree := t.treeSet[t.Name]
   239		if tree == nil || IsEmptyTree(tree.Root) {
   240			t.treeSet[t.Name] = t
   241			return
   242		}
   243		if !IsEmptyTree(t.Root) {
   244			t.errorf("template: multiple definition of template %q", t.Name)
   245		}
   246	}
   247	
   248	// IsEmptyTree reports whether this tree (node) is empty of everything but space.
   249	func IsEmptyTree(n Node) bool {
   250		switch n := n.(type) {
   251		case nil:
   252			return true
   253		case *ActionNode:
   254		case *IfNode:
   255		case *ListNode:
   256			for _, node := range n.Nodes {
   257				if !IsEmptyTree(node) {
   258					return false
   259				}
   260			}
   261			return true
   262		case *RangeNode:
   263		case *TemplateNode:
   264		case *TextNode:
   265			return len(bytes.TrimSpace(n.Text)) == 0
   266		case *WithNode:
   267		default:
   268			panic("unknown node: " + n.String())
   269		}
   270		return false
   271	}
   272	
   273	// parse is the top-level parser for a template, essentially the same
   274	// as itemList except it also parses {{define}} actions.
   275	// It runs to EOF.
   276	func (t *Tree) parse() {
   277		t.Root = t.newList(t.peek().pos)
   278		for t.peek().typ != itemEOF {
   279			if t.peek().typ == itemLeftDelim {
   280				delim := t.next()
   281				if t.nextNonSpace().typ == itemDefine {
   282					newT := New("definition") // name will be updated once we know it.
   283					newT.text = t.text
   284					newT.ParseName = t.ParseName
   285					newT.startParse(t.funcs, t.lex, t.treeSet)
   286					newT.parseDefinition()
   287					continue
   288				}
   289				t.backup2(delim)
   290			}
   291			switch n := t.textOrAction(); n.Type() {
   292			case nodeEnd, nodeElse:
   293				t.errorf("unexpected %s", n)
   294			default:
   295				t.Root.append(n)
   296			}
   297		}
   298	}
   299	
   300	// parseDefinition parses a {{define}} ...  {{end}} template definition and
   301	// installs the definition in t.treeSet. The "define" keyword has already
   302	// been scanned.
   303	func (t *Tree) parseDefinition() {
   304		const context = "define clause"
   305		name := t.expectOneOf(itemString, itemRawString, context)
   306		var err error
   307		t.Name, err = strconv.Unquote(name.val)
   308		if err != nil {
   309			t.error(err)
   310		}
   311		t.expect(itemRightDelim, context)
   312		var end Node
   313		t.Root, end = t.itemList()
   314		if end.Type() != nodeEnd {
   315			t.errorf("unexpected %s in %s", end, context)
   316		}
   317		t.add()
   318		t.stopParse()
   319	}
   320	
   321	// itemList:
   322	//	textOrAction*
   323	// Terminates at {{end}} or {{else}}, returned separately.
   324	func (t *Tree) itemList() (list *ListNode, next Node) {
   325		list = t.newList(t.peekNonSpace().pos)
   326		for t.peekNonSpace().typ != itemEOF {
   327			n := t.textOrAction()
   328			switch n.Type() {
   329			case nodeEnd, nodeElse:
   330				return list, n
   331			}
   332			list.append(n)
   333		}
   334		t.errorf("unexpected EOF")
   335		return
   336	}
   337	
   338	// textOrAction:
   339	//	text | action
   340	func (t *Tree) textOrAction() Node {
   341		switch token := t.nextNonSpace(); token.typ {
   342		case itemText:
   343			return t.newText(token.pos, token.val)
   344		case itemLeftDelim:
   345			return t.action()
   346		default:
   347			t.unexpected(token, "input")
   348		}
   349		return nil
   350	}
   351	
   352	// Action:
   353	//	control
   354	//	command ("|" command)*
   355	// Left delim is past. Now get actions.
   356	// First word could be a keyword such as range.
   357	func (t *Tree) action() (n Node) {
   358		switch token := t.nextNonSpace(); token.typ {
   359		case itemBlock:
   360			return t.blockControl()
   361		case itemElse:
   362			return t.elseControl()
   363		case itemEnd:
   364			return t.endControl()
   365		case itemIf:
   366			return t.ifControl()
   367		case itemRange:
   368			return t.rangeControl()
   369		case itemTemplate:
   370			return t.templateControl()
   371		case itemWith:
   372			return t.withControl()
   373		}
   374		t.backup()
   375		token := t.peek()
   376		// Do not pop variables; they persist until "end".
   377		return t.newAction(token.pos, token.line, t.pipeline("command"))
   378	}
   379	
   380	// Pipeline:
   381	//	declarations? command ('|' command)*
   382	func (t *Tree) pipeline(context string) (pipe *PipeNode) {
   383		token := t.peekNonSpace()
   384		pipe = t.newPipeline(token.pos, token.line, nil)
   385		// Are there declarations or assignments?
   386	decls:
   387		if v := t.peekNonSpace(); v.typ == itemVariable {
   388			t.next()
   389			// Since space is a token, we need 3-token look-ahead here in the worst case:
   390			// in "$x foo" we need to read "foo" (as opposed to ":=") to know that $x is an
   391			// argument variable rather than a declaration. So remember the token
   392			// adjacent to the variable so we can push it back if necessary.
   393			tokenAfterVariable := t.peek()
   394			next := t.peekNonSpace()
   395			switch {
   396			case next.typ == itemAssign, next.typ == itemDeclare:
   397				pipe.IsAssign = next.typ == itemAssign
   398				t.nextNonSpace()
   399				pipe.Decl = append(pipe.Decl, t.newVariable(v.pos, v.val))
   400				t.vars = append(t.vars, v.val)
   401			case next.typ == itemChar && next.val == ",":
   402				t.nextNonSpace()
   403				pipe.Decl = append(pipe.Decl, t.newVariable(v.pos, v.val))
   404				t.vars = append(t.vars, v.val)
   405				if context == "range" && len(pipe.Decl) < 2 {
   406					switch t.peekNonSpace().typ {
   407					case itemVariable, itemRightDelim, itemRightParen:
   408						// second initialized variable in a range pipeline
   409						goto decls
   410					default:
   411						t.errorf("range can only initialize variables")
   412					}
   413				}
   414				t.errorf("too many declarations in %s", context)
   415			case tokenAfterVariable.typ == itemSpace:
   416				t.backup3(v, tokenAfterVariable)
   417			default:
   418				t.backup2(v)
   419			}
   420		}
   421		for {
   422			switch token := t.nextNonSpace(); token.typ {
   423			case itemRightDelim, itemRightParen:
   424				// At this point, the pipeline is complete
   425				t.checkPipeline(pipe, context)
   426				if token.typ == itemRightParen {
   427					t.backup()
   428				}
   429				return
   430			case itemBool, itemCharConstant, itemComplex, itemDot, itemField, itemIdentifier,
   431				itemNumber, itemNil, itemRawString, itemString, itemVariable, itemLeftParen:
   432				t.backup()
   433				pipe.append(t.command())
   434			default:
   435				t.unexpected(token, context)
   436			}
   437		}
   438	}
   439	
   440	func (t *Tree) checkPipeline(pipe *PipeNode, context string) {
   441		// Reject empty pipelines
   442		if len(pipe.Cmds) == 0 {
   443			t.errorf("missing value for %s", context)
   444		}
   445		// Only the first command of a pipeline can start with a non executable operand
   446		for i, c := range pipe.Cmds[1:] {
   447			switch c.Args[0].Type() {
   448			case NodeBool, NodeDot, NodeNil, NodeNumber, NodeString:
   449				// With A|B|C, pipeline stage 2 is B
   450				t.errorf("non executable command in pipeline stage %d", i+2)
   451			}
   452		}
   453	}
   454	
   455	func (t *Tree) parseControl(allowElseIf bool, context string) (pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) {
   456		defer t.popVars(len(t.vars))
   457		pipe = t.pipeline(context)
   458		var next Node
   459		list, next = t.itemList()
   460		switch next.Type() {
   461		case nodeEnd: //done
   462		case nodeElse:
   463			if allowElseIf {
   464				// Special case for "else if". If the "else" is followed immediately by an "if",
   465				// the elseControl will have left the "if" token pending. Treat
   466				//	{{if a}}_{{else if b}}_{{end}}
   467				// as
   468				//	{{if a}}_{{else}}{{if b}}_{{end}}{{end}}.
   469				// To do this, parse the if as usual and stop at it {{end}}; the subsequent{{end}}
   470				// is assumed. This technique works even for long if-else-if chains.
   471				// TODO: Should we allow else-if in with and range?
   472				if t.peek().typ == itemIf {
   473					t.next() // Consume the "if" token.
   474					elseList = t.newList(next.Position())
   475					elseList.append(t.ifControl())
   476					// Do not consume the next item - only one {{end}} required.
   477					break
   478				}
   479			}
   480			elseList, next = t.itemList()
   481			if next.Type() != nodeEnd {
   482				t.errorf("expected end; found %s", next)
   483			}
   484		}
   485		return pipe.Position(), pipe.Line, pipe, list, elseList
   486	}
   487	
   488	// If:
   489	//	{{if pipeline}} itemList {{end}}
   490	//	{{if pipeline}} itemList {{else}} itemList {{end}}
   491	// If keyword is past.
   492	func (t *Tree) ifControl() Node {
   493		return t.newIf(t.parseControl(true, "if"))
   494	}
   495	
   496	// Range:
   497	//	{{range pipeline}} itemList {{end}}
   498	//	{{range pipeline}} itemList {{else}} itemList {{end}}
   499	// Range keyword is past.
   500	func (t *Tree) rangeControl() Node {
   501		return t.newRange(t.parseControl(false, "range"))
   502	}
   503	
   504	// With:
   505	//	{{with pipeline}} itemList {{end}}
   506	//	{{with pipeline}} itemList {{else}} itemList {{end}}
   507	// If keyword is past.
   508	func (t *Tree) withControl() Node {
   509		return t.newWith(t.parseControl(false, "with"))
   510	}
   511	
   512	// End:
   513	//	{{end}}
   514	// End keyword is past.
   515	func (t *Tree) endControl() Node {
   516		return t.newEnd(t.expect(itemRightDelim, "end").pos)
   517	}
   518	
   519	// Else:
   520	//	{{else}}
   521	// Else keyword is past.
   522	func (t *Tree) elseControl() Node {
   523		// Special case for "else if".
   524		peek := t.peekNonSpace()
   525		if peek.typ == itemIf {
   526			// We see "{{else if ... " but in effect rewrite it to {{else}}{{if ... ".
   527			return t.newElse(peek.pos, peek.line)
   528		}
   529		token := t.expect(itemRightDelim, "else")
   530		return t.newElse(token.pos, token.line)
   531	}
   532	
   533	// Block:
   534	//	{{block stringValue pipeline}}
   535	// Block keyword is past.
   536	// The name must be something that can evaluate to a string.
   537	// The pipeline is mandatory.
   538	func (t *Tree) blockControl() Node {
   539		const context = "block clause"
   540	
   541		token := t.nextNonSpace()
   542		name := t.parseTemplateName(token, context)
   543		pipe := t.pipeline(context)
   544	
   545		block := New(name) // name will be updated once we know it.
   546		block.text = t.text
   547		block.ParseName = t.ParseName
   548		block.startParse(t.funcs, t.lex, t.treeSet)
   549		var end Node
   550		block.Root, end = block.itemList()
   551		if end.Type() != nodeEnd {
   552			t.errorf("unexpected %s in %s", end, context)
   553		}
   554		block.add()
   555		block.stopParse()
   556	
   557		return t.newTemplate(token.pos, token.line, name, pipe)
   558	}
   559	
   560	// Template:
   561	//	{{template stringValue pipeline}}
   562	// Template keyword is past. The name must be something that can evaluate
   563	// to a string.
   564	func (t *Tree) templateControl() Node {
   565		const context = "template clause"
   566		token := t.nextNonSpace()
   567		name := t.parseTemplateName(token, context)
   568		var pipe *PipeNode
   569		if t.nextNonSpace().typ != itemRightDelim {
   570			t.backup()
   571			// Do not pop variables; they persist until "end".
   572			pipe = t.pipeline(context)
   573		}
   574		return t.newTemplate(token.pos, token.line, name, pipe)
   575	}
   576	
   577	func (t *Tree) parseTemplateName(token item, context string) (name string) {
   578		switch token.typ {
   579		case itemString, itemRawString:
   580			s, err := strconv.Unquote(token.val)
   581			if err != nil {
   582				t.error(err)
   583			}
   584			name = s
   585		default:
   586			t.unexpected(token, context)
   587		}
   588		return
   589	}
   590	
   591	// command:
   592	//	operand (space operand)*
   593	// space-separated arguments up to a pipeline character or right delimiter.
   594	// we consume the pipe character but leave the right delim to terminate the action.
   595	func (t *Tree) command() *CommandNode {
   596		cmd := t.newCommand(t.peekNonSpace().pos)
   597		for {
   598			t.peekNonSpace() // skip leading spaces.
   599			operand := t.operand()
   600			if operand != nil {
   601				cmd.append(operand)
   602			}
   603			switch token := t.next(); token.typ {
   604			case itemSpace:
   605				continue
   606			case itemError:
   607				t.errorf("%s", token.val)
   608			case itemRightDelim, itemRightParen:
   609				t.backup()
   610			case itemPipe:
   611			default:
   612				t.errorf("unexpected %s in operand", token)
   613			}
   614			break
   615		}
   616		if len(cmd.Args) == 0 {
   617			t.errorf("empty command")
   618		}
   619		return cmd
   620	}
   621	
   622	// operand:
   623	//	term .Field*
   624	// An operand is a space-separated component of a command,
   625	// a term possibly followed by field accesses.
   626	// A nil return means the next item is not an operand.
   627	func (t *Tree) operand() Node {
   628		node := t.term()
   629		if node == nil {
   630			return nil
   631		}
   632		if t.peek().typ == itemField {
   633			chain := t.newChain(t.peek().pos, node)
   634			for t.peek().typ == itemField {
   635				chain.Add(t.next().val)
   636			}
   637			// Compatibility with original API: If the term is of type NodeField
   638			// or NodeVariable, just put more fields on the original.
   639			// Otherwise, keep the Chain node.
   640			// Obvious parsing errors involving literal values are detected here.
   641			// More complex error cases will have to be handled at execution time.
   642			switch node.Type() {
   643			case NodeField:
   644				node = t.newField(chain.Position(), chain.String())
   645			case NodeVariable:
   646				node = t.newVariable(chain.Position(), chain.String())
   647			case NodeBool, NodeString, NodeNumber, NodeNil, NodeDot:
   648				t.errorf("unexpected . after term %q", node.String())
   649			default:
   650				node = chain
   651			}
   652		}
   653		return node
   654	}
   655	
   656	// term:
   657	//	literal (number, string, nil, boolean)
   658	//	function (identifier)
   659	//	.
   660	//	.Field
   661	//	$
   662	//	'(' pipeline ')'
   663	// A term is a simple "expression".
   664	// A nil return means the next item is not a term.
   665	func (t *Tree) term() Node {
   666		switch token := t.nextNonSpace(); token.typ {
   667		case itemError:
   668			t.errorf("%s", token.val)
   669		case itemIdentifier:
   670			if !t.hasFunction(token.val) {
   671				t.errorf("function %q not defined", token.val)
   672			}
   673			return NewIdentifier(token.val).SetTree(t).SetPos(token.pos)
   674		case itemDot:
   675			return t.newDot(token.pos)
   676		case itemNil:
   677			return t.newNil(token.pos)
   678		case itemVariable:
   679			return t.useVar(token.pos, token.val)
   680		case itemField:
   681			return t.newField(token.pos, token.val)
   682		case itemBool:
   683			return t.newBool(token.pos, token.val == "true")
   684		case itemCharConstant, itemComplex, itemNumber:
   685			number, err := t.newNumber(token.pos, token.val, token.typ)
   686			if err != nil {
   687				t.error(err)
   688			}
   689			return number
   690		case itemLeftParen:
   691			pipe := t.pipeline("parenthesized pipeline")
   692			if token := t.next(); token.typ != itemRightParen {
   693				t.errorf("unclosed right paren: unexpected %s", token)
   694			}
   695			return pipe
   696		case itemString, itemRawString:
   697			s, err := strconv.Unquote(token.val)
   698			if err != nil {
   699				t.error(err)
   700			}
   701			return t.newString(token.pos, token.val, s)
   702		}
   703		t.backup()
   704		return nil
   705	}
   706	
   707	// hasFunction reports if a function name exists in the Tree's maps.
   708	func (t *Tree) hasFunction(name string) bool {
   709		for _, funcMap := range t.funcs {
   710			if funcMap == nil {
   711				continue
   712			}
   713			if funcMap[name] != nil {
   714				return true
   715			}
   716		}
   717		return false
   718	}
   719	
   720	// popVars trims the variable list to the specified length
   721	func (t *Tree) popVars(n int) {
   722		t.vars = t.vars[:n]
   723	}
   724	
   725	// useVar returns a node for a variable reference. It errors if the
   726	// variable is not defined.
   727	func (t *Tree) useVar(pos Pos, name string) Node {
   728		v := t.newVariable(pos, name)
   729		for _, varName := range t.vars {
   730			if varName == v.Ident[0] {
   731				return v
   732			}
   733		}
   734		t.errorf("undefined variable %q", v.Ident[0])
   735		return nil
   736	}
   737	

View as plain text