1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
package parser
import (
"strconv"
"github.com/vektah/gqlparser/ast"
"github.com/vektah/gqlparser/gqlerror"
"github.com/vektah/gqlparser/lexer"
)
type parser struct {
lexer lexer.Lexer
err *gqlerror.Error
peeked bool
peekToken lexer.Token
peekError *gqlerror.Error
prev lexer.Token
}
func (p *parser) peekPos() *ast.Position {
if p.err != nil {
return nil
}
peek := p.peek()
return &peek.Pos
}
func (p *parser) peek() lexer.Token {
if p.err != nil {
return p.prev
}
if !p.peeked {
p.peekToken, p.peekError = p.lexer.ReadToken()
p.peeked = true
}
return p.peekToken
}
func (p *parser) error(tok lexer.Token, format string, args ...interface{}) {
if p.err != nil {
return
}
p.err = gqlerror.ErrorLocf(tok.Pos.Src.Name, tok.Pos.Line, tok.Pos.Column, format, args...)
}
func (p *parser) next() lexer.Token {
if p.err != nil {
return p.prev
}
if p.peeked {
p.peeked = false
p.prev, p.err = p.peekToken, p.peekError
} else {
p.prev, p.err = p.lexer.ReadToken()
}
return p.prev
}
func (p *parser) expectKeyword(value string) lexer.Token {
tok := p.peek()
if tok.Kind == lexer.Name && tok.Value == value {
return p.next()
}
p.error(tok, "Expected %s, found %s", strconv.Quote(value), tok.String())
return tok
}
func (p *parser) expect(kind lexer.Type) lexer.Token {
tok := p.peek()
if tok.Kind == kind {
return p.next()
}
p.error(tok, "Expected %s, found %s", kind, tok.Kind.String())
return tok
}
func (p *parser) skip(kind lexer.Type) bool {
tok := p.peek()
if tok.Kind != kind {
return false
}
p.next()
return true
}
func (p *parser) unexpectedError() {
p.unexpectedToken(p.peek())
}
func (p *parser) unexpectedToken(tok lexer.Token) {
p.error(tok, "Unexpected %s", tok.String())
}
func (p *parser) many(start lexer.Type, end lexer.Type, cb func()) {
hasDef := p.skip(start)
if !hasDef {
return
}
for p.peek().Kind != end && p.err == nil {
cb()
}
p.next()
}
|
