Lines Matching refs:p
62 func parse(p *parser) (file *File, errs []error) {
66 errs = p.errors
73 defs := p.parseDefinitions()
74 p.accept(scanner.EOF)
75 errs = p.errors
76 comments := p.comments
79 Name: p.scanner.Filename,
87 p := newParser(r, scope)
88 p.eval = true
89 p.scanner.Filename = filename
91 return parse(p)
95 p := newParser(r, scope)
96 p.scanner.Filename = filename
98 return parse(p)
102 p := newParser(r, NewScope(nil))
103 value = p.parseExpression()
104 p.accept(scanner.EOF)
105 errs = p.errors
119 p := &parser{}
120 p.scope = scope
121 p.scanner.Init(r)
122 p.scanner.Error = func(sc *scanner.Scanner, msg string) {
123 p.errorf(msg)
125 p.scanner.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanStrings |
127 p.next()
128 return p
131 func (p *parser) error(err error) {
132 pos := p.scanner.Position
134 pos = p.scanner.Pos()
140 p.errors = append(p.errors, err)
141 if len(p.errors) >= maxErrors {
146 func (p *parser) errorf(format string, args ...interface{}) {
147 p.error(fmt.Errorf(format, args...))
150 func (p *parser) accept(toks ...rune) bool {
152 if p.tok != tok {
153 p.errorf("expected %s, found %s", scanner.TokenString(tok),
154 scanner.TokenString(p.tok))
157 p.next()
162 func (p *parser) next() {
163 if p.tok != scanner.EOF {
164 p.tok = p.scanner.Scan()
165 if p.tok == scanner.Comment {
167 for p.tok == scanner.Comment {
168 lines := strings.Split(p.scanner.TokenText(), "\n")
169 if len(comments) > 0 && p.scanner.Position.Line > comments[len(comments)-1].End().Line+1 {
170 p.comments = append(p.comments, &CommentGroup{Comments: comments})
173 comments = append(comments, &Comment{lines, p.scanner.Position})
174 p.tok = p.scanner.Scan()
176 p.comments = append(p.comments, &CommentGroup{Comments: comments})
182 func (p *parser) parseDefinitions() (defs []Definition) {
184 switch p.tok {
186 ident := p.scanner.TokenText()
187 pos := p.scanner.Position
189 p.accept(scanner.Ident)
191 switch p.tok {
193 p.accept('+')
194 defs = append(defs, p.parseAssignment(ident, pos, "+="))
196 defs = append(defs, p.parseAssignment(ident, pos, "="))
198 defs = append(defs, p.parseModule(ident, pos))
200 p.errorf("expected \"=\" or \"+=\" or \"{\" or \"(\", found %s",
201 scanner.TokenString(p.tok))
206 p.errorf("expected assignment or module definition, found %s",
207 scanner.TokenString(p.tok))
213 func (p *parser) parseAssignment(name string, namePos scanner.Position,
218 pos := p.scanner.Position
219 if !p.accept('=') {
222 value := p.parseExpression()
231 if p.scope != nil {
233 if old, local := p.scope.Get(assignment.Name); old == nil {
234 p.errorf("modified non-existent variable %q with +=", assignment.Name)
236 p.errorf("modified non-local variable %q with +=", assignment.Name)
238 p.errorf("modified variable %q with += after referencing", assignment.Name)
240 val, err := p.evaluateOperator(old.Value, assignment.Value, '+', assignment.EqualsPos)
242 p.error(err)
248 err := p.scope.Add(assignment)
250 p.error(err)
258 func (p *parser) parseModule(typ string, typPos scanner.Position) *Module {
261 lbracePos := p.scanner.Position
262 if p.tok == '{' {
266 if !p.accept(p.tok) {
269 properties := p.parsePropertyList(true, compat)
270 rbracePos := p.scanner.Position
272 p.accept(')')
274 p.accept('}')
288 func (p *parser) parsePropertyList(isModule, compat bool) (properties []*Property) {
289 for p.tok == scanner.Ident {
290 property := p.parseProperty(isModule, compat)
293 if p.tok != ',' {
298 p.accept(',')
304 func (p *parser) parseMapItemList() []*MapItem {
307 for p.tok != '}' {
308 items = append(items, p.parseMapItem())
310 if p.tok != ',' {
314 p.accept(',')
319 func (p *parser) parseMapItem() *MapItem {
320 keyExpression := p.parseExpression()
322 …p.errorf("only strings are supported as map keys: %s (%s)", keyExpression.Type(), keyExpression.St…
325 p.accept(':')
326 pos := p.scanner.Position
327 value := p.parseExpression()
335 func (p *parser) parseProperty(isModule, compat bool) (property *Property) {
338 name := p.scanner.TokenText()
339 namePos := p.scanner.Position
340 p.accept(scanner.Ident)
341 pos := p.scanner.Position
345 if !p.accept(':') {
349 if !p.accept('=') {
354 if !p.accept(':') {
359 value := p.parseExpression()
369 func (p *parser) parseExpression() (value Expression) {
370 value = p.parseValue()
371 switch p.tok {
373 return p.parseOperator(value)
375 p.errorf("subtraction not supported: %s", p.scanner.String())
382 func (p *parser) evaluateOperator(value1, value2 Expression, operator rune,
387 if p.eval {
409 v.Properties, err = p.addMaps(v.Properties, e2.(*Map).Properties, pos)
429 func (p *parser) addMaps(map1, map2 []*Property, pos scanner.Position) ([]*Property, error) {
451 newProp.Value, err = p.evaluateOperator(prop1.Value, prop2.Value, '+', pos)
470 func (p *parser) parseOperator(value1 Expression) *Operator {
471 operator := p.tok
472 pos := p.scanner.Position
473 p.accept(operator)
475 value2 := p.parseExpression()
477 value, err := p.evaluateOperator(value1, value2, operator, pos)
479 p.error(err)
487 func (p *parser) parseValue() (value Expression) {
488 switch p.tok {
490 return p.parseVariable()
492 return p.parseIntValue()
494 return p.parseStringValue()
496 return p.parseListValue()
498 return p.parseMapValue()
500 p.errorf("expected bool, list, or string value; found %s",
501 scanner.TokenString(p.tok))
506 func (p *parser) parseVariable() Expression {
509 switch text := p.scanner.TokenText(); text {
512 LiteralPos: p.scanner.Position,
517 if p.eval {
518 if assignment, local := p.scope.Get(text); assignment == nil {
519 p.errorf("variable %q is not set", text)
531 NamePos: p.scanner.Position,
536 p.accept(scanner.Ident)
540 func (p *parser) parseStringValue() *String {
541 str, err := strconv.Unquote(p.scanner.TokenText())
543 p.errorf("couldn't parse string: %s", err)
548 LiteralPos: p.scanner.Position,
551 p.accept(p.tok)
555 func (p *parser) parseIntValue() *Int64 {
557 literalPos := p.scanner.Position
558 if p.tok == '-' {
559 str += string(p.tok)
560 p.accept(p.tok)
561 if p.tok != scanner.Int {
562 p.errorf("expected int; found %s", scanner.TokenString(p.tok))
566 str += p.scanner.TokenText()
569 p.errorf("couldn't parse int: %s", err)
578 p.accept(scanner.Int)
582 func (p *parser) parseListValue() *List {
583 lBracePos := p.scanner.Position
584 if !p.accept('[') {
589 for p.tok != ']' {
590 element := p.parseExpression()
593 if p.tok != ',' {
598 p.accept(',')
601 rBracePos := p.scanner.Position
602 p.accept(']')
611 func (p *parser) parseMapValue() *Map {
612 lBracePos := p.scanner.Position
613 if !p.accept('{') {
620 if p.tok == scanner.Ident {
621 properties = p.parsePropertyList(false, false)
624 mapItems = p.parseMapItemList()
627 rBracePos := p.scanner.Position
628 p.accept('}')