diff options
Diffstat (limited to 'vendor/github.com/hashicorp/hcl/json/parser/parser.go')
-rw-r--r-- | vendor/github.com/hashicorp/hcl/json/parser/parser.go | 313 |
1 files changed, 313 insertions, 0 deletions
diff --git a/vendor/github.com/hashicorp/hcl/json/parser/parser.go b/vendor/github.com/hashicorp/hcl/json/parser/parser.go new file mode 100644 index 0000000..125a5f0 --- /dev/null +++ b/vendor/github.com/hashicorp/hcl/json/parser/parser.go | |||
@@ -0,0 +1,313 @@ | |||
1 | package parser | ||
2 | |||
3 | import ( | ||
4 | "errors" | ||
5 | "fmt" | ||
6 | |||
7 | "github.com/hashicorp/hcl/hcl/ast" | ||
8 | hcltoken "github.com/hashicorp/hcl/hcl/token" | ||
9 | "github.com/hashicorp/hcl/json/scanner" | ||
10 | "github.com/hashicorp/hcl/json/token" | ||
11 | ) | ||
12 | |||
13 | type Parser struct { | ||
14 | sc *scanner.Scanner | ||
15 | |||
16 | // Last read token | ||
17 | tok token.Token | ||
18 | commaPrev token.Token | ||
19 | |||
20 | enableTrace bool | ||
21 | indent int | ||
22 | n int // buffer size (max = 1) | ||
23 | } | ||
24 | |||
25 | func newParser(src []byte) *Parser { | ||
26 | return &Parser{ | ||
27 | sc: scanner.New(src), | ||
28 | } | ||
29 | } | ||
30 | |||
31 | // Parse returns the fully parsed source and returns the abstract syntax tree. | ||
32 | func Parse(src []byte) (*ast.File, error) { | ||
33 | p := newParser(src) | ||
34 | return p.Parse() | ||
35 | } | ||
36 | |||
37 | var errEofToken = errors.New("EOF token found") | ||
38 | |||
39 | // Parse returns the fully parsed source and returns the abstract syntax tree. | ||
40 | func (p *Parser) Parse() (*ast.File, error) { | ||
41 | f := &ast.File{} | ||
42 | var err, scerr error | ||
43 | p.sc.Error = func(pos token.Pos, msg string) { | ||
44 | scerr = fmt.Errorf("%s: %s", pos, msg) | ||
45 | } | ||
46 | |||
47 | // The root must be an object in JSON | ||
48 | object, err := p.object() | ||
49 | if scerr != nil { | ||
50 | return nil, scerr | ||
51 | } | ||
52 | if err != nil { | ||
53 | return nil, err | ||
54 | } | ||
55 | |||
56 | // We make our final node an object list so it is more HCL compatible | ||
57 | f.Node = object.List | ||
58 | |||
59 | // Flatten it, which finds patterns and turns them into more HCL-like | ||
60 | // AST trees. | ||
61 | flattenObjects(f.Node) | ||
62 | |||
63 | return f, nil | ||
64 | } | ||
65 | |||
66 | func (p *Parser) objectList() (*ast.ObjectList, error) { | ||
67 | defer un(trace(p, "ParseObjectList")) | ||
68 | node := &ast.ObjectList{} | ||
69 | |||
70 | for { | ||
71 | n, err := p.objectItem() | ||
72 | if err == errEofToken { | ||
73 | break // we are finished | ||
74 | } | ||
75 | |||
76 | // we don't return a nil node, because might want to use already | ||
77 | // collected items. | ||
78 | if err != nil { | ||
79 | return node, err | ||
80 | } | ||
81 | |||
82 | node.Add(n) | ||
83 | |||
84 | // Check for a followup comma. If it isn't a comma, then we're done | ||
85 | if tok := p.scan(); tok.Type != token.COMMA { | ||
86 | break | ||
87 | } | ||
88 | } | ||
89 | |||
90 | return node, nil | ||
91 | } | ||
92 | |||
93 | // objectItem parses a single object item | ||
94 | func (p *Parser) objectItem() (*ast.ObjectItem, error) { | ||
95 | defer un(trace(p, "ParseObjectItem")) | ||
96 | |||
97 | keys, err := p.objectKey() | ||
98 | if err != nil { | ||
99 | return nil, err | ||
100 | } | ||
101 | |||
102 | o := &ast.ObjectItem{ | ||
103 | Keys: keys, | ||
104 | } | ||
105 | |||
106 | switch p.tok.Type { | ||
107 | case token.COLON: | ||
108 | pos := p.tok.Pos | ||
109 | o.Assign = hcltoken.Pos{ | ||
110 | Filename: pos.Filename, | ||
111 | Offset: pos.Offset, | ||
112 | Line: pos.Line, | ||
113 | Column: pos.Column, | ||
114 | } | ||
115 | |||
116 | o.Val, err = p.objectValue() | ||
117 | if err != nil { | ||
118 | return nil, err | ||
119 | } | ||
120 | } | ||
121 | |||
122 | return o, nil | ||
123 | } | ||
124 | |||
125 | // objectKey parses an object key and returns a ObjectKey AST | ||
126 | func (p *Parser) objectKey() ([]*ast.ObjectKey, error) { | ||
127 | keyCount := 0 | ||
128 | keys := make([]*ast.ObjectKey, 0) | ||
129 | |||
130 | for { | ||
131 | tok := p.scan() | ||
132 | switch tok.Type { | ||
133 | case token.EOF: | ||
134 | return nil, errEofToken | ||
135 | case token.STRING: | ||
136 | keyCount++ | ||
137 | keys = append(keys, &ast.ObjectKey{ | ||
138 | Token: p.tok.HCLToken(), | ||
139 | }) | ||
140 | case token.COLON: | ||
141 | // If we have a zero keycount it means that we never got | ||
142 | // an object key, i.e. `{ :`. This is a syntax error. | ||
143 | if keyCount == 0 { | ||
144 | return nil, fmt.Errorf("expected: STRING got: %s", p.tok.Type) | ||
145 | } | ||
146 | |||
147 | // Done | ||
148 | return keys, nil | ||
149 | case token.ILLEGAL: | ||
150 | return nil, errors.New("illegal") | ||
151 | default: | ||
152 | return nil, fmt.Errorf("expected: STRING got: %s", p.tok.Type) | ||
153 | } | ||
154 | } | ||
155 | } | ||
156 | |||
157 | // object parses any type of object, such as number, bool, string, object or | ||
158 | // list. | ||
159 | func (p *Parser) objectValue() (ast.Node, error) { | ||
160 | defer un(trace(p, "ParseObjectValue")) | ||
161 | tok := p.scan() | ||
162 | |||
163 | switch tok.Type { | ||
164 | case token.NUMBER, token.FLOAT, token.BOOL, token.NULL, token.STRING: | ||
165 | return p.literalType() | ||
166 | case token.LBRACE: | ||
167 | return p.objectType() | ||
168 | case token.LBRACK: | ||
169 | return p.listType() | ||
170 | case token.EOF: | ||
171 | return nil, errEofToken | ||
172 | } | ||
173 | |||
174 | return nil, fmt.Errorf("Expected object value, got unknown token: %+v", tok) | ||
175 | } | ||
176 | |||
177 | // object parses any type of object, such as number, bool, string, object or | ||
178 | // list. | ||
179 | func (p *Parser) object() (*ast.ObjectType, error) { | ||
180 | defer un(trace(p, "ParseType")) | ||
181 | tok := p.scan() | ||
182 | |||
183 | switch tok.Type { | ||
184 | case token.LBRACE: | ||
185 | return p.objectType() | ||
186 | case token.EOF: | ||
187 | return nil, errEofToken | ||
188 | } | ||
189 | |||
190 | return nil, fmt.Errorf("Expected object, got unknown token: %+v", tok) | ||
191 | } | ||
192 | |||
193 | // objectType parses an object type and returns a ObjectType AST | ||
194 | func (p *Parser) objectType() (*ast.ObjectType, error) { | ||
195 | defer un(trace(p, "ParseObjectType")) | ||
196 | |||
197 | // we assume that the currently scanned token is a LBRACE | ||
198 | o := &ast.ObjectType{} | ||
199 | |||
200 | l, err := p.objectList() | ||
201 | |||
202 | // if we hit RBRACE, we are good to go (means we parsed all Items), if it's | ||
203 | // not a RBRACE, it's an syntax error and we just return it. | ||
204 | if err != nil && p.tok.Type != token.RBRACE { | ||
205 | return nil, err | ||
206 | } | ||
207 | |||
208 | o.List = l | ||
209 | return o, nil | ||
210 | } | ||
211 | |||
212 | // listType parses a list type and returns a ListType AST | ||
213 | func (p *Parser) listType() (*ast.ListType, error) { | ||
214 | defer un(trace(p, "ParseListType")) | ||
215 | |||
216 | // we assume that the currently scanned token is a LBRACK | ||
217 | l := &ast.ListType{} | ||
218 | |||
219 | for { | ||
220 | tok := p.scan() | ||
221 | switch tok.Type { | ||
222 | case token.NUMBER, token.FLOAT, token.STRING: | ||
223 | node, err := p.literalType() | ||
224 | if err != nil { | ||
225 | return nil, err | ||
226 | } | ||
227 | |||
228 | l.Add(node) | ||
229 | case token.COMMA: | ||
230 | continue | ||
231 | case token.LBRACE: | ||
232 | node, err := p.objectType() | ||
233 | if err != nil { | ||
234 | return nil, err | ||
235 | } | ||
236 | |||
237 | l.Add(node) | ||
238 | case token.BOOL: | ||
239 | // TODO(arslan) should we support? not supported by HCL yet | ||
240 | case token.LBRACK: | ||
241 | // TODO(arslan) should we support nested lists? Even though it's | ||
242 | // written in README of HCL, it's not a part of the grammar | ||
243 | // (not defined in parse.y) | ||
244 | case token.RBRACK: | ||
245 | // finished | ||
246 | return l, nil | ||
247 | default: | ||
248 | return nil, fmt.Errorf("unexpected token while parsing list: %s", tok.Type) | ||
249 | } | ||
250 | |||
251 | } | ||
252 | } | ||
253 | |||
254 | // literalType parses a literal type and returns a LiteralType AST | ||
255 | func (p *Parser) literalType() (*ast.LiteralType, error) { | ||
256 | defer un(trace(p, "ParseLiteral")) | ||
257 | |||
258 | return &ast.LiteralType{ | ||
259 | Token: p.tok.HCLToken(), | ||
260 | }, nil | ||
261 | } | ||
262 | |||
263 | // scan returns the next token from the underlying scanner. If a token has | ||
264 | // been unscanned then read that instead. | ||
265 | func (p *Parser) scan() token.Token { | ||
266 | // If we have a token on the buffer, then return it. | ||
267 | if p.n != 0 { | ||
268 | p.n = 0 | ||
269 | return p.tok | ||
270 | } | ||
271 | |||
272 | p.tok = p.sc.Scan() | ||
273 | return p.tok | ||
274 | } | ||
275 | |||
276 | // unscan pushes the previously read token back onto the buffer. | ||
277 | func (p *Parser) unscan() { | ||
278 | p.n = 1 | ||
279 | } | ||
280 | |||
281 | // ---------------------------------------------------------------------------- | ||
282 | // Parsing support | ||
283 | |||
284 | func (p *Parser) printTrace(a ...interface{}) { | ||
285 | if !p.enableTrace { | ||
286 | return | ||
287 | } | ||
288 | |||
289 | const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " | ||
290 | const n = len(dots) | ||
291 | fmt.Printf("%5d:%3d: ", p.tok.Pos.Line, p.tok.Pos.Column) | ||
292 | |||
293 | i := 2 * p.indent | ||
294 | for i > n { | ||
295 | fmt.Print(dots) | ||
296 | i -= n | ||
297 | } | ||
298 | // i <= n | ||
299 | fmt.Print(dots[0:i]) | ||
300 | fmt.Println(a...) | ||
301 | } | ||
302 | |||
303 | func trace(p *Parser, msg string) *Parser { | ||
304 | p.printTrace(msg, "(") | ||
305 | p.indent++ | ||
306 | return p | ||
307 | } | ||
308 | |||
309 | // Usage pattern: defer un(trace(p, "...")) | ||
310 | func un(p *Parser) { | ||
311 | p.indent-- | ||
312 | p.printTrace(")") | ||
313 | } | ||