diff options
author | Alexandre Garand <alexandre.garand@fretlink.com> | 2019-08-09 15:59:15 +0200 |
---|---|---|
committer | Alexandre Garand <alexandre.garand@fretlink.com> | 2019-08-09 16:39:21 +0200 |
commit | 863486a6b71ed0e562a3965bed56465d007b1418 (patch) | |
tree | e93f6a687695af86d54237ec9f575d4ef104222d /vendor/github.com/zclconf/go-cty-yaml/parserc.go | |
parent | 49c1c7b4dc69ffb9ab52330e6dc52ccdd6351087 (diff) | |
download | terraform-provider-statuscake-863486a6b71ed0e562a3965bed56465d007b1418.tar.gz terraform-provider-statuscake-863486a6b71ed0e562a3965bed56465d007b1418.tar.zst terraform-provider-statuscake-863486a6b71ed0e562a3965bed56465d007b1418.zip |
update vendor and go.modadd_contact_groups
Diffstat (limited to 'vendor/github.com/zclconf/go-cty-yaml/parserc.go')
-rw-r--r-- | vendor/github.com/zclconf/go-cty-yaml/parserc.go | 1095 |
1 files changed, 1095 insertions, 0 deletions
diff --git a/vendor/github.com/zclconf/go-cty-yaml/parserc.go b/vendor/github.com/zclconf/go-cty-yaml/parserc.go new file mode 100644 index 0000000..81d05df --- /dev/null +++ b/vendor/github.com/zclconf/go-cty-yaml/parserc.go | |||
@@ -0,0 +1,1095 @@ | |||
1 | package yaml | ||
2 | |||
3 | import ( | ||
4 | "bytes" | ||
5 | ) | ||
6 | |||
7 | // The parser implements the following grammar: | ||
8 | // | ||
9 | // stream ::= STREAM-START implicit_document? explicit_document* STREAM-END | ||
10 | // implicit_document ::= block_node DOCUMENT-END* | ||
11 | // explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* | ||
12 | // block_node_or_indentless_sequence ::= | ||
13 | // ALIAS | ||
14 | // | properties (block_content | indentless_block_sequence)? | ||
15 | // | block_content | ||
16 | // | indentless_block_sequence | ||
17 | // block_node ::= ALIAS | ||
18 | // | properties block_content? | ||
19 | // | block_content | ||
20 | // flow_node ::= ALIAS | ||
21 | // | properties flow_content? | ||
22 | // | flow_content | ||
23 | // properties ::= TAG ANCHOR? | ANCHOR TAG? | ||
24 | // block_content ::= block_collection | flow_collection | SCALAR | ||
25 | // flow_content ::= flow_collection | SCALAR | ||
26 | // block_collection ::= block_sequence | block_mapping | ||
27 | // flow_collection ::= flow_sequence | flow_mapping | ||
28 | // block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END | ||
29 | // indentless_sequence ::= (BLOCK-ENTRY block_node?)+ | ||
30 | // block_mapping ::= BLOCK-MAPPING_START | ||
31 | // ((KEY block_node_or_indentless_sequence?)? | ||
32 | // (VALUE block_node_or_indentless_sequence?)?)* | ||
33 | // BLOCK-END | ||
34 | // flow_sequence ::= FLOW-SEQUENCE-START | ||
35 | // (flow_sequence_entry FLOW-ENTRY)* | ||
36 | // flow_sequence_entry? | ||
37 | // FLOW-SEQUENCE-END | ||
38 | // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? | ||
39 | // flow_mapping ::= FLOW-MAPPING-START | ||
40 | // (flow_mapping_entry FLOW-ENTRY)* | ||
41 | // flow_mapping_entry? | ||
42 | // FLOW-MAPPING-END | ||
43 | // flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? | ||
44 | |||
45 | // Peek the next token in the token queue. | ||
46 | func peek_token(parser *yaml_parser_t) *yaml_token_t { | ||
47 | if parser.token_available || yaml_parser_fetch_more_tokens(parser) { | ||
48 | return &parser.tokens[parser.tokens_head] | ||
49 | } | ||
50 | return nil | ||
51 | } | ||
52 | |||
53 | // Remove the next token from the queue (must be called after peek_token). | ||
54 | func skip_token(parser *yaml_parser_t) { | ||
55 | parser.token_available = false | ||
56 | parser.tokens_parsed++ | ||
57 | parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN | ||
58 | parser.tokens_head++ | ||
59 | } | ||
60 | |||
61 | // Get the next event. | ||
62 | func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
63 | // Erase the event object. | ||
64 | *event = yaml_event_t{} | ||
65 | |||
66 | // No events after the end of the stream or error. | ||
67 | if parser.stream_end_produced || parser.error != yaml_NO_ERROR || parser.state == yaml_PARSE_END_STATE { | ||
68 | return true | ||
69 | } | ||
70 | |||
71 | // Generate the next event. | ||
72 | return yaml_parser_state_machine(parser, event) | ||
73 | } | ||
74 | |||
75 | // Set parser error. | ||
76 | func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool { | ||
77 | parser.error = yaml_PARSER_ERROR | ||
78 | parser.problem = problem | ||
79 | parser.problem_mark = problem_mark | ||
80 | return false | ||
81 | } | ||
82 | |||
83 | func yaml_parser_set_parser_error_context(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string, problem_mark yaml_mark_t) bool { | ||
84 | parser.error = yaml_PARSER_ERROR | ||
85 | parser.context = context | ||
86 | parser.context_mark = context_mark | ||
87 | parser.problem = problem | ||
88 | parser.problem_mark = problem_mark | ||
89 | return false | ||
90 | } | ||
91 | |||
92 | // State dispatcher. | ||
93 | func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
94 | //trace("yaml_parser_state_machine", "state:", parser.state.String()) | ||
95 | |||
96 | switch parser.state { | ||
97 | case yaml_PARSE_STREAM_START_STATE: | ||
98 | return yaml_parser_parse_stream_start(parser, event) | ||
99 | |||
100 | case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE: | ||
101 | return yaml_parser_parse_document_start(parser, event, true) | ||
102 | |||
103 | case yaml_PARSE_DOCUMENT_START_STATE: | ||
104 | return yaml_parser_parse_document_start(parser, event, false) | ||
105 | |||
106 | case yaml_PARSE_DOCUMENT_CONTENT_STATE: | ||
107 | return yaml_parser_parse_document_content(parser, event) | ||
108 | |||
109 | case yaml_PARSE_DOCUMENT_END_STATE: | ||
110 | return yaml_parser_parse_document_end(parser, event) | ||
111 | |||
112 | case yaml_PARSE_BLOCK_NODE_STATE: | ||
113 | return yaml_parser_parse_node(parser, event, true, false) | ||
114 | |||
115 | case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: | ||
116 | return yaml_parser_parse_node(parser, event, true, true) | ||
117 | |||
118 | case yaml_PARSE_FLOW_NODE_STATE: | ||
119 | return yaml_parser_parse_node(parser, event, false, false) | ||
120 | |||
121 | case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: | ||
122 | return yaml_parser_parse_block_sequence_entry(parser, event, true) | ||
123 | |||
124 | case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: | ||
125 | return yaml_parser_parse_block_sequence_entry(parser, event, false) | ||
126 | |||
127 | case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: | ||
128 | return yaml_parser_parse_indentless_sequence_entry(parser, event) | ||
129 | |||
130 | case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: | ||
131 | return yaml_parser_parse_block_mapping_key(parser, event, true) | ||
132 | |||
133 | case yaml_PARSE_BLOCK_MAPPING_KEY_STATE: | ||
134 | return yaml_parser_parse_block_mapping_key(parser, event, false) | ||
135 | |||
136 | case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE: | ||
137 | return yaml_parser_parse_block_mapping_value(parser, event) | ||
138 | |||
139 | case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: | ||
140 | return yaml_parser_parse_flow_sequence_entry(parser, event, true) | ||
141 | |||
142 | case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE: | ||
143 | return yaml_parser_parse_flow_sequence_entry(parser, event, false) | ||
144 | |||
145 | case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: | ||
146 | return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event) | ||
147 | |||
148 | case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: | ||
149 | return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event) | ||
150 | |||
151 | case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: | ||
152 | return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event) | ||
153 | |||
154 | case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: | ||
155 | return yaml_parser_parse_flow_mapping_key(parser, event, true) | ||
156 | |||
157 | case yaml_PARSE_FLOW_MAPPING_KEY_STATE: | ||
158 | return yaml_parser_parse_flow_mapping_key(parser, event, false) | ||
159 | |||
160 | case yaml_PARSE_FLOW_MAPPING_VALUE_STATE: | ||
161 | return yaml_parser_parse_flow_mapping_value(parser, event, false) | ||
162 | |||
163 | case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: | ||
164 | return yaml_parser_parse_flow_mapping_value(parser, event, true) | ||
165 | |||
166 | default: | ||
167 | panic("invalid parser state") | ||
168 | } | ||
169 | } | ||
170 | |||
171 | // Parse the production: | ||
172 | // stream ::= STREAM-START implicit_document? explicit_document* STREAM-END | ||
173 | // ************ | ||
174 | func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
175 | token := peek_token(parser) | ||
176 | if token == nil { | ||
177 | return false | ||
178 | } | ||
179 | if token.typ != yaml_STREAM_START_TOKEN { | ||
180 | return yaml_parser_set_parser_error(parser, "did not find expected <stream-start>", token.start_mark) | ||
181 | } | ||
182 | parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE | ||
183 | *event = yaml_event_t{ | ||
184 | typ: yaml_STREAM_START_EVENT, | ||
185 | start_mark: token.start_mark, | ||
186 | end_mark: token.end_mark, | ||
187 | encoding: token.encoding, | ||
188 | } | ||
189 | skip_token(parser) | ||
190 | return true | ||
191 | } | ||
192 | |||
193 | // Parse the productions: | ||
194 | // implicit_document ::= block_node DOCUMENT-END* | ||
195 | // * | ||
196 | // explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* | ||
197 | // ************************* | ||
198 | func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool { | ||
199 | |||
200 | token := peek_token(parser) | ||
201 | if token == nil { | ||
202 | return false | ||
203 | } | ||
204 | |||
205 | // Parse extra document end indicators. | ||
206 | if !implicit { | ||
207 | for token.typ == yaml_DOCUMENT_END_TOKEN { | ||
208 | skip_token(parser) | ||
209 | token = peek_token(parser) | ||
210 | if token == nil { | ||
211 | return false | ||
212 | } | ||
213 | } | ||
214 | } | ||
215 | |||
216 | if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN && | ||
217 | token.typ != yaml_TAG_DIRECTIVE_TOKEN && | ||
218 | token.typ != yaml_DOCUMENT_START_TOKEN && | ||
219 | token.typ != yaml_STREAM_END_TOKEN { | ||
220 | // Parse an implicit document. | ||
221 | if !yaml_parser_process_directives(parser, nil, nil) { | ||
222 | return false | ||
223 | } | ||
224 | parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE) | ||
225 | parser.state = yaml_PARSE_BLOCK_NODE_STATE | ||
226 | |||
227 | *event = yaml_event_t{ | ||
228 | typ: yaml_DOCUMENT_START_EVENT, | ||
229 | start_mark: token.start_mark, | ||
230 | end_mark: token.end_mark, | ||
231 | } | ||
232 | |||
233 | } else if token.typ != yaml_STREAM_END_TOKEN { | ||
234 | // Parse an explicit document. | ||
235 | var version_directive *yaml_version_directive_t | ||
236 | var tag_directives []yaml_tag_directive_t | ||
237 | start_mark := token.start_mark | ||
238 | if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) { | ||
239 | return false | ||
240 | } | ||
241 | token = peek_token(parser) | ||
242 | if token == nil { | ||
243 | return false | ||
244 | } | ||
245 | if token.typ != yaml_DOCUMENT_START_TOKEN { | ||
246 | yaml_parser_set_parser_error(parser, | ||
247 | "did not find expected <document start>", token.start_mark) | ||
248 | return false | ||
249 | } | ||
250 | parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE) | ||
251 | parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE | ||
252 | end_mark := token.end_mark | ||
253 | |||
254 | *event = yaml_event_t{ | ||
255 | typ: yaml_DOCUMENT_START_EVENT, | ||
256 | start_mark: start_mark, | ||
257 | end_mark: end_mark, | ||
258 | version_directive: version_directive, | ||
259 | tag_directives: tag_directives, | ||
260 | implicit: false, | ||
261 | } | ||
262 | skip_token(parser) | ||
263 | |||
264 | } else { | ||
265 | // Parse the stream end. | ||
266 | parser.state = yaml_PARSE_END_STATE | ||
267 | *event = yaml_event_t{ | ||
268 | typ: yaml_STREAM_END_EVENT, | ||
269 | start_mark: token.start_mark, | ||
270 | end_mark: token.end_mark, | ||
271 | } | ||
272 | skip_token(parser) | ||
273 | } | ||
274 | |||
275 | return true | ||
276 | } | ||
277 | |||
278 | // Parse the productions: | ||
279 | // explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* | ||
280 | // *********** | ||
281 | // | ||
282 | func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
283 | token := peek_token(parser) | ||
284 | if token == nil { | ||
285 | return false | ||
286 | } | ||
287 | if token.typ == yaml_VERSION_DIRECTIVE_TOKEN || | ||
288 | token.typ == yaml_TAG_DIRECTIVE_TOKEN || | ||
289 | token.typ == yaml_DOCUMENT_START_TOKEN || | ||
290 | token.typ == yaml_DOCUMENT_END_TOKEN || | ||
291 | token.typ == yaml_STREAM_END_TOKEN { | ||
292 | parser.state = parser.states[len(parser.states)-1] | ||
293 | parser.states = parser.states[:len(parser.states)-1] | ||
294 | return yaml_parser_process_empty_scalar(parser, event, | ||
295 | token.start_mark) | ||
296 | } | ||
297 | return yaml_parser_parse_node(parser, event, true, false) | ||
298 | } | ||
299 | |||
300 | // Parse the productions: | ||
301 | // implicit_document ::= block_node DOCUMENT-END* | ||
302 | // ************* | ||
303 | // explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* | ||
304 | // | ||
305 | func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
306 | token := peek_token(parser) | ||
307 | if token == nil { | ||
308 | return false | ||
309 | } | ||
310 | |||
311 | start_mark := token.start_mark | ||
312 | end_mark := token.start_mark | ||
313 | |||
314 | implicit := true | ||
315 | if token.typ == yaml_DOCUMENT_END_TOKEN { | ||
316 | end_mark = token.end_mark | ||
317 | skip_token(parser) | ||
318 | implicit = false | ||
319 | } | ||
320 | |||
321 | parser.tag_directives = parser.tag_directives[:0] | ||
322 | |||
323 | parser.state = yaml_PARSE_DOCUMENT_START_STATE | ||
324 | *event = yaml_event_t{ | ||
325 | typ: yaml_DOCUMENT_END_EVENT, | ||
326 | start_mark: start_mark, | ||
327 | end_mark: end_mark, | ||
328 | implicit: implicit, | ||
329 | } | ||
330 | return true | ||
331 | } | ||
332 | |||
333 | // Parse the productions: | ||
334 | // block_node_or_indentless_sequence ::= | ||
335 | // ALIAS | ||
336 | // ***** | ||
337 | // | properties (block_content | indentless_block_sequence)? | ||
338 | // ********** * | ||
339 | // | block_content | indentless_block_sequence | ||
340 | // * | ||
341 | // block_node ::= ALIAS | ||
342 | // ***** | ||
343 | // | properties block_content? | ||
344 | // ********** * | ||
345 | // | block_content | ||
346 | // * | ||
347 | // flow_node ::= ALIAS | ||
348 | // ***** | ||
349 | // | properties flow_content? | ||
350 | // ********** * | ||
351 | // | flow_content | ||
352 | // * | ||
353 | // properties ::= TAG ANCHOR? | ANCHOR TAG? | ||
354 | // ************************* | ||
355 | // block_content ::= block_collection | flow_collection | SCALAR | ||
356 | // ****** | ||
357 | // flow_content ::= flow_collection | SCALAR | ||
358 | // ****** | ||
359 | func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool { | ||
360 | //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)() | ||
361 | |||
362 | token := peek_token(parser) | ||
363 | if token == nil { | ||
364 | return false | ||
365 | } | ||
366 | |||
367 | if token.typ == yaml_ALIAS_TOKEN { | ||
368 | parser.state = parser.states[len(parser.states)-1] | ||
369 | parser.states = parser.states[:len(parser.states)-1] | ||
370 | *event = yaml_event_t{ | ||
371 | typ: yaml_ALIAS_EVENT, | ||
372 | start_mark: token.start_mark, | ||
373 | end_mark: token.end_mark, | ||
374 | anchor: token.value, | ||
375 | } | ||
376 | skip_token(parser) | ||
377 | return true | ||
378 | } | ||
379 | |||
380 | start_mark := token.start_mark | ||
381 | end_mark := token.start_mark | ||
382 | |||
383 | var tag_token bool | ||
384 | var tag_handle, tag_suffix, anchor []byte | ||
385 | var tag_mark yaml_mark_t | ||
386 | if token.typ == yaml_ANCHOR_TOKEN { | ||
387 | anchor = token.value | ||
388 | start_mark = token.start_mark | ||
389 | end_mark = token.end_mark | ||
390 | skip_token(parser) | ||
391 | token = peek_token(parser) | ||
392 | if token == nil { | ||
393 | return false | ||
394 | } | ||
395 | if token.typ == yaml_TAG_TOKEN { | ||
396 | tag_token = true | ||
397 | tag_handle = token.value | ||
398 | tag_suffix = token.suffix | ||
399 | tag_mark = token.start_mark | ||
400 | end_mark = token.end_mark | ||
401 | skip_token(parser) | ||
402 | token = peek_token(parser) | ||
403 | if token == nil { | ||
404 | return false | ||
405 | } | ||
406 | } | ||
407 | } else if token.typ == yaml_TAG_TOKEN { | ||
408 | tag_token = true | ||
409 | tag_handle = token.value | ||
410 | tag_suffix = token.suffix | ||
411 | start_mark = token.start_mark | ||
412 | tag_mark = token.start_mark | ||
413 | end_mark = token.end_mark | ||
414 | skip_token(parser) | ||
415 | token = peek_token(parser) | ||
416 | if token == nil { | ||
417 | return false | ||
418 | } | ||
419 | if token.typ == yaml_ANCHOR_TOKEN { | ||
420 | anchor = token.value | ||
421 | end_mark = token.end_mark | ||
422 | skip_token(parser) | ||
423 | token = peek_token(parser) | ||
424 | if token == nil { | ||
425 | return false | ||
426 | } | ||
427 | } | ||
428 | } | ||
429 | |||
430 | var tag []byte | ||
431 | if tag_token { | ||
432 | if len(tag_handle) == 0 { | ||
433 | tag = tag_suffix | ||
434 | tag_suffix = nil | ||
435 | } else { | ||
436 | for i := range parser.tag_directives { | ||
437 | if bytes.Equal(parser.tag_directives[i].handle, tag_handle) { | ||
438 | tag = append([]byte(nil), parser.tag_directives[i].prefix...) | ||
439 | tag = append(tag, tag_suffix...) | ||
440 | break | ||
441 | } | ||
442 | } | ||
443 | if len(tag) == 0 { | ||
444 | yaml_parser_set_parser_error_context(parser, | ||
445 | "while parsing a node", start_mark, | ||
446 | "found undefined tag handle", tag_mark) | ||
447 | return false | ||
448 | } | ||
449 | } | ||
450 | } | ||
451 | |||
452 | implicit := len(tag) == 0 | ||
453 | if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN { | ||
454 | end_mark = token.end_mark | ||
455 | parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE | ||
456 | *event = yaml_event_t{ | ||
457 | typ: yaml_SEQUENCE_START_EVENT, | ||
458 | start_mark: start_mark, | ||
459 | end_mark: end_mark, | ||
460 | anchor: anchor, | ||
461 | tag: tag, | ||
462 | implicit: implicit, | ||
463 | style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE), | ||
464 | } | ||
465 | return true | ||
466 | } | ||
467 | if token.typ == yaml_SCALAR_TOKEN { | ||
468 | var plain_implicit, quoted_implicit bool | ||
469 | end_mark = token.end_mark | ||
470 | if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) || (len(tag) == 1 && tag[0] == '!') { | ||
471 | plain_implicit = true | ||
472 | } else if len(tag) == 0 { | ||
473 | quoted_implicit = true | ||
474 | } | ||
475 | parser.state = parser.states[len(parser.states)-1] | ||
476 | parser.states = parser.states[:len(parser.states)-1] | ||
477 | |||
478 | *event = yaml_event_t{ | ||
479 | typ: yaml_SCALAR_EVENT, | ||
480 | start_mark: start_mark, | ||
481 | end_mark: end_mark, | ||
482 | anchor: anchor, | ||
483 | tag: tag, | ||
484 | value: token.value, | ||
485 | implicit: plain_implicit, | ||
486 | quoted_implicit: quoted_implicit, | ||
487 | style: yaml_style_t(token.style), | ||
488 | } | ||
489 | skip_token(parser) | ||
490 | return true | ||
491 | } | ||
492 | if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN { | ||
493 | // [Go] Some of the events below can be merged as they differ only on style. | ||
494 | end_mark = token.end_mark | ||
495 | parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE | ||
496 | *event = yaml_event_t{ | ||
497 | typ: yaml_SEQUENCE_START_EVENT, | ||
498 | start_mark: start_mark, | ||
499 | end_mark: end_mark, | ||
500 | anchor: anchor, | ||
501 | tag: tag, | ||
502 | implicit: implicit, | ||
503 | style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE), | ||
504 | } | ||
505 | return true | ||
506 | } | ||
507 | if token.typ == yaml_FLOW_MAPPING_START_TOKEN { | ||
508 | end_mark = token.end_mark | ||
509 | parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE | ||
510 | *event = yaml_event_t{ | ||
511 | typ: yaml_MAPPING_START_EVENT, | ||
512 | start_mark: start_mark, | ||
513 | end_mark: end_mark, | ||
514 | anchor: anchor, | ||
515 | tag: tag, | ||
516 | implicit: implicit, | ||
517 | style: yaml_style_t(yaml_FLOW_MAPPING_STYLE), | ||
518 | } | ||
519 | return true | ||
520 | } | ||
521 | if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN { | ||
522 | end_mark = token.end_mark | ||
523 | parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE | ||
524 | *event = yaml_event_t{ | ||
525 | typ: yaml_SEQUENCE_START_EVENT, | ||
526 | start_mark: start_mark, | ||
527 | end_mark: end_mark, | ||
528 | anchor: anchor, | ||
529 | tag: tag, | ||
530 | implicit: implicit, | ||
531 | style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE), | ||
532 | } | ||
533 | return true | ||
534 | } | ||
535 | if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN { | ||
536 | end_mark = token.end_mark | ||
537 | parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE | ||
538 | *event = yaml_event_t{ | ||
539 | typ: yaml_MAPPING_START_EVENT, | ||
540 | start_mark: start_mark, | ||
541 | end_mark: end_mark, | ||
542 | anchor: anchor, | ||
543 | tag: tag, | ||
544 | implicit: implicit, | ||
545 | style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE), | ||
546 | } | ||
547 | return true | ||
548 | } | ||
549 | if len(anchor) > 0 || len(tag) > 0 { | ||
550 | parser.state = parser.states[len(parser.states)-1] | ||
551 | parser.states = parser.states[:len(parser.states)-1] | ||
552 | |||
553 | *event = yaml_event_t{ | ||
554 | typ: yaml_SCALAR_EVENT, | ||
555 | start_mark: start_mark, | ||
556 | end_mark: end_mark, | ||
557 | anchor: anchor, | ||
558 | tag: tag, | ||
559 | implicit: implicit, | ||
560 | quoted_implicit: false, | ||
561 | style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE), | ||
562 | } | ||
563 | return true | ||
564 | } | ||
565 | |||
566 | context := "while parsing a flow node" | ||
567 | if block { | ||
568 | context = "while parsing a block node" | ||
569 | } | ||
570 | yaml_parser_set_parser_error_context(parser, context, start_mark, | ||
571 | "did not find expected node content", token.start_mark) | ||
572 | return false | ||
573 | } | ||
574 | |||
575 | // Parse the productions: | ||
576 | // block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END | ||
577 | // ******************** *********** * ********* | ||
578 | // | ||
579 | func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { | ||
580 | if first { | ||
581 | token := peek_token(parser) | ||
582 | parser.marks = append(parser.marks, token.start_mark) | ||
583 | skip_token(parser) | ||
584 | } | ||
585 | |||
586 | token := peek_token(parser) | ||
587 | if token == nil { | ||
588 | return false | ||
589 | } | ||
590 | |||
591 | if token.typ == yaml_BLOCK_ENTRY_TOKEN { | ||
592 | mark := token.end_mark | ||
593 | skip_token(parser) | ||
594 | token = peek_token(parser) | ||
595 | if token == nil { | ||
596 | return false | ||
597 | } | ||
598 | if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN { | ||
599 | parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE) | ||
600 | return yaml_parser_parse_node(parser, event, true, false) | ||
601 | } else { | ||
602 | parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE | ||
603 | return yaml_parser_process_empty_scalar(parser, event, mark) | ||
604 | } | ||
605 | } | ||
606 | if token.typ == yaml_BLOCK_END_TOKEN { | ||
607 | parser.state = parser.states[len(parser.states)-1] | ||
608 | parser.states = parser.states[:len(parser.states)-1] | ||
609 | parser.marks = parser.marks[:len(parser.marks)-1] | ||
610 | |||
611 | *event = yaml_event_t{ | ||
612 | typ: yaml_SEQUENCE_END_EVENT, | ||
613 | start_mark: token.start_mark, | ||
614 | end_mark: token.end_mark, | ||
615 | } | ||
616 | |||
617 | skip_token(parser) | ||
618 | return true | ||
619 | } | ||
620 | |||
621 | context_mark := parser.marks[len(parser.marks)-1] | ||
622 | parser.marks = parser.marks[:len(parser.marks)-1] | ||
623 | return yaml_parser_set_parser_error_context(parser, | ||
624 | "while parsing a block collection", context_mark, | ||
625 | "did not find expected '-' indicator", token.start_mark) | ||
626 | } | ||
627 | |||
628 | // Parse the productions: | ||
629 | // indentless_sequence ::= (BLOCK-ENTRY block_node?)+ | ||
630 | // *********** * | ||
631 | func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
632 | token := peek_token(parser) | ||
633 | if token == nil { | ||
634 | return false | ||
635 | } | ||
636 | |||
637 | if token.typ == yaml_BLOCK_ENTRY_TOKEN { | ||
638 | mark := token.end_mark | ||
639 | skip_token(parser) | ||
640 | token = peek_token(parser) | ||
641 | if token == nil { | ||
642 | return false | ||
643 | } | ||
644 | if token.typ != yaml_BLOCK_ENTRY_TOKEN && | ||
645 | token.typ != yaml_KEY_TOKEN && | ||
646 | token.typ != yaml_VALUE_TOKEN && | ||
647 | token.typ != yaml_BLOCK_END_TOKEN { | ||
648 | parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE) | ||
649 | return yaml_parser_parse_node(parser, event, true, false) | ||
650 | } | ||
651 | parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE | ||
652 | return yaml_parser_process_empty_scalar(parser, event, mark) | ||
653 | } | ||
654 | parser.state = parser.states[len(parser.states)-1] | ||
655 | parser.states = parser.states[:len(parser.states)-1] | ||
656 | |||
657 | *event = yaml_event_t{ | ||
658 | typ: yaml_SEQUENCE_END_EVENT, | ||
659 | start_mark: token.start_mark, | ||
660 | end_mark: token.start_mark, // [Go] Shouldn't this be token.end_mark? | ||
661 | } | ||
662 | return true | ||
663 | } | ||
664 | |||
665 | // Parse the productions: | ||
666 | // block_mapping ::= BLOCK-MAPPING_START | ||
667 | // ******************* | ||
668 | // ((KEY block_node_or_indentless_sequence?)? | ||
669 | // *** * | ||
670 | // (VALUE block_node_or_indentless_sequence?)?)* | ||
671 | // | ||
672 | // BLOCK-END | ||
673 | // ********* | ||
674 | // | ||
675 | func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { | ||
676 | if first { | ||
677 | token := peek_token(parser) | ||
678 | parser.marks = append(parser.marks, token.start_mark) | ||
679 | skip_token(parser) | ||
680 | } | ||
681 | |||
682 | token := peek_token(parser) | ||
683 | if token == nil { | ||
684 | return false | ||
685 | } | ||
686 | |||
687 | if token.typ == yaml_KEY_TOKEN { | ||
688 | mark := token.end_mark | ||
689 | skip_token(parser) | ||
690 | token = peek_token(parser) | ||
691 | if token == nil { | ||
692 | return false | ||
693 | } | ||
694 | if token.typ != yaml_KEY_TOKEN && | ||
695 | token.typ != yaml_VALUE_TOKEN && | ||
696 | token.typ != yaml_BLOCK_END_TOKEN { | ||
697 | parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE) | ||
698 | return yaml_parser_parse_node(parser, event, true, true) | ||
699 | } else { | ||
700 | parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE | ||
701 | return yaml_parser_process_empty_scalar(parser, event, mark) | ||
702 | } | ||
703 | } else if token.typ == yaml_BLOCK_END_TOKEN { | ||
704 | parser.state = parser.states[len(parser.states)-1] | ||
705 | parser.states = parser.states[:len(parser.states)-1] | ||
706 | parser.marks = parser.marks[:len(parser.marks)-1] | ||
707 | *event = yaml_event_t{ | ||
708 | typ: yaml_MAPPING_END_EVENT, | ||
709 | start_mark: token.start_mark, | ||
710 | end_mark: token.end_mark, | ||
711 | } | ||
712 | skip_token(parser) | ||
713 | return true | ||
714 | } | ||
715 | |||
716 | context_mark := parser.marks[len(parser.marks)-1] | ||
717 | parser.marks = parser.marks[:len(parser.marks)-1] | ||
718 | return yaml_parser_set_parser_error_context(parser, | ||
719 | "while parsing a block mapping", context_mark, | ||
720 | "did not find expected key", token.start_mark) | ||
721 | } | ||
722 | |||
723 | // Parse the productions: | ||
724 | // block_mapping ::= BLOCK-MAPPING_START | ||
725 | // | ||
726 | // ((KEY block_node_or_indentless_sequence?)? | ||
727 | // | ||
728 | // (VALUE block_node_or_indentless_sequence?)?)* | ||
729 | // ***** * | ||
730 | // BLOCK-END | ||
731 | // | ||
732 | // | ||
733 | func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
734 | token := peek_token(parser) | ||
735 | if token == nil { | ||
736 | return false | ||
737 | } | ||
738 | if token.typ == yaml_VALUE_TOKEN { | ||
739 | mark := token.end_mark | ||
740 | skip_token(parser) | ||
741 | token = peek_token(parser) | ||
742 | if token == nil { | ||
743 | return false | ||
744 | } | ||
745 | if token.typ != yaml_KEY_TOKEN && | ||
746 | token.typ != yaml_VALUE_TOKEN && | ||
747 | token.typ != yaml_BLOCK_END_TOKEN { | ||
748 | parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE) | ||
749 | return yaml_parser_parse_node(parser, event, true, true) | ||
750 | } | ||
751 | parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE | ||
752 | return yaml_parser_process_empty_scalar(parser, event, mark) | ||
753 | } | ||
754 | parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE | ||
755 | return yaml_parser_process_empty_scalar(parser, event, token.start_mark) | ||
756 | } | ||
757 | |||
758 | // Parse the productions: | ||
759 | // flow_sequence ::= FLOW-SEQUENCE-START | ||
760 | // ******************* | ||
761 | // (flow_sequence_entry FLOW-ENTRY)* | ||
762 | // * ********** | ||
763 | // flow_sequence_entry? | ||
764 | // * | ||
765 | // FLOW-SEQUENCE-END | ||
766 | // ***************** | ||
767 | // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? | ||
768 | // * | ||
769 | // | ||
770 | func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { | ||
771 | if first { | ||
772 | token := peek_token(parser) | ||
773 | parser.marks = append(parser.marks, token.start_mark) | ||
774 | skip_token(parser) | ||
775 | } | ||
776 | token := peek_token(parser) | ||
777 | if token == nil { | ||
778 | return false | ||
779 | } | ||
780 | if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { | ||
781 | if !first { | ||
782 | if token.typ == yaml_FLOW_ENTRY_TOKEN { | ||
783 | skip_token(parser) | ||
784 | token = peek_token(parser) | ||
785 | if token == nil { | ||
786 | return false | ||
787 | } | ||
788 | } else { | ||
789 | context_mark := parser.marks[len(parser.marks)-1] | ||
790 | parser.marks = parser.marks[:len(parser.marks)-1] | ||
791 | return yaml_parser_set_parser_error_context(parser, | ||
792 | "while parsing a flow sequence", context_mark, | ||
793 | "did not find expected ',' or ']'", token.start_mark) | ||
794 | } | ||
795 | } | ||
796 | |||
797 | if token.typ == yaml_KEY_TOKEN { | ||
798 | parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE | ||
799 | *event = yaml_event_t{ | ||
800 | typ: yaml_MAPPING_START_EVENT, | ||
801 | start_mark: token.start_mark, | ||
802 | end_mark: token.end_mark, | ||
803 | implicit: true, | ||
804 | style: yaml_style_t(yaml_FLOW_MAPPING_STYLE), | ||
805 | } | ||
806 | skip_token(parser) | ||
807 | return true | ||
808 | } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { | ||
809 | parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE) | ||
810 | return yaml_parser_parse_node(parser, event, false, false) | ||
811 | } | ||
812 | } | ||
813 | |||
814 | parser.state = parser.states[len(parser.states)-1] | ||
815 | parser.states = parser.states[:len(parser.states)-1] | ||
816 | parser.marks = parser.marks[:len(parser.marks)-1] | ||
817 | |||
818 | *event = yaml_event_t{ | ||
819 | typ: yaml_SEQUENCE_END_EVENT, | ||
820 | start_mark: token.start_mark, | ||
821 | end_mark: token.end_mark, | ||
822 | } | ||
823 | |||
824 | skip_token(parser) | ||
825 | return true | ||
826 | } | ||
827 | |||
828 | // | ||
829 | // Parse the productions: | ||
830 | // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? | ||
831 | // *** * | ||
832 | // | ||
833 | func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
834 | token := peek_token(parser) | ||
835 | if token == nil { | ||
836 | return false | ||
837 | } | ||
838 | if token.typ != yaml_VALUE_TOKEN && | ||
839 | token.typ != yaml_FLOW_ENTRY_TOKEN && | ||
840 | token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { | ||
841 | parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE) | ||
842 | return yaml_parser_parse_node(parser, event, false, false) | ||
843 | } | ||
844 | mark := token.end_mark | ||
845 | skip_token(parser) | ||
846 | parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE | ||
847 | return yaml_parser_process_empty_scalar(parser, event, mark) | ||
848 | } | ||
849 | |||
850 | // Parse the productions: | ||
851 | // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? | ||
852 | // ***** * | ||
853 | // | ||
854 | func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
855 | token := peek_token(parser) | ||
856 | if token == nil { | ||
857 | return false | ||
858 | } | ||
859 | if token.typ == yaml_VALUE_TOKEN { | ||
860 | skip_token(parser) | ||
861 | token := peek_token(parser) | ||
862 | if token == nil { | ||
863 | return false | ||
864 | } | ||
865 | if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { | ||
866 | parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE) | ||
867 | return yaml_parser_parse_node(parser, event, false, false) | ||
868 | } | ||
869 | } | ||
870 | parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE | ||
871 | return yaml_parser_process_empty_scalar(parser, event, token.start_mark) | ||
872 | } | ||
873 | |||
874 | // Parse the productions: | ||
875 | // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? | ||
876 | // * | ||
877 | // | ||
878 | func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool { | ||
879 | token := peek_token(parser) | ||
880 | if token == nil { | ||
881 | return false | ||
882 | } | ||
883 | parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE | ||
884 | *event = yaml_event_t{ | ||
885 | typ: yaml_MAPPING_END_EVENT, | ||
886 | start_mark: token.start_mark, | ||
887 | end_mark: token.start_mark, // [Go] Shouldn't this be end_mark? | ||
888 | } | ||
889 | return true | ||
890 | } | ||
891 | |||
892 | // Parse the productions: | ||
893 | // flow_mapping ::= FLOW-MAPPING-START | ||
894 | // ****************** | ||
895 | // (flow_mapping_entry FLOW-ENTRY)* | ||
896 | // * ********** | ||
897 | // flow_mapping_entry? | ||
898 | // ****************** | ||
899 | // FLOW-MAPPING-END | ||
900 | // **************** | ||
901 | // flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? | ||
902 | // * *** * | ||
903 | // | ||
904 | func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { | ||
905 | if first { | ||
906 | token := peek_token(parser) | ||
907 | parser.marks = append(parser.marks, token.start_mark) | ||
908 | skip_token(parser) | ||
909 | } | ||
910 | |||
911 | token := peek_token(parser) | ||
912 | if token == nil { | ||
913 | return false | ||
914 | } | ||
915 | |||
916 | if token.typ != yaml_FLOW_MAPPING_END_TOKEN { | ||
917 | if !first { | ||
918 | if token.typ == yaml_FLOW_ENTRY_TOKEN { | ||
919 | skip_token(parser) | ||
920 | token = peek_token(parser) | ||
921 | if token == nil { | ||
922 | return false | ||
923 | } | ||
924 | } else { | ||
925 | context_mark := parser.marks[len(parser.marks)-1] | ||
926 | parser.marks = parser.marks[:len(parser.marks)-1] | ||
927 | return yaml_parser_set_parser_error_context(parser, | ||
928 | "while parsing a flow mapping", context_mark, | ||
929 | "did not find expected ',' or '}'", token.start_mark) | ||
930 | } | ||
931 | } | ||
932 | |||
933 | if token.typ == yaml_KEY_TOKEN { | ||
934 | skip_token(parser) | ||
935 | token = peek_token(parser) | ||
936 | if token == nil { | ||
937 | return false | ||
938 | } | ||
939 | if token.typ != yaml_VALUE_TOKEN && | ||
940 | token.typ != yaml_FLOW_ENTRY_TOKEN && | ||
941 | token.typ != yaml_FLOW_MAPPING_END_TOKEN { | ||
942 | parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE) | ||
943 | return yaml_parser_parse_node(parser, event, false, false) | ||
944 | } else { | ||
945 | parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE | ||
946 | return yaml_parser_process_empty_scalar(parser, event, token.start_mark) | ||
947 | } | ||
948 | } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN { | ||
949 | parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE) | ||
950 | return yaml_parser_parse_node(parser, event, false, false) | ||
951 | } | ||
952 | } | ||
953 | |||
954 | parser.state = parser.states[len(parser.states)-1] | ||
955 | parser.states = parser.states[:len(parser.states)-1] | ||
956 | parser.marks = parser.marks[:len(parser.marks)-1] | ||
957 | *event = yaml_event_t{ | ||
958 | typ: yaml_MAPPING_END_EVENT, | ||
959 | start_mark: token.start_mark, | ||
960 | end_mark: token.end_mark, | ||
961 | } | ||
962 | skip_token(parser) | ||
963 | return true | ||
964 | } | ||
965 | |||
966 | // Parse the productions: | ||
967 | // flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? | ||
968 | // * ***** * | ||
969 | // | ||
970 | func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool { | ||
971 | token := peek_token(parser) | ||
972 | if token == nil { | ||
973 | return false | ||
974 | } | ||
975 | if empty { | ||
976 | parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE | ||
977 | return yaml_parser_process_empty_scalar(parser, event, token.start_mark) | ||
978 | } | ||
979 | if token.typ == yaml_VALUE_TOKEN { | ||
980 | skip_token(parser) | ||
981 | token = peek_token(parser) | ||
982 | if token == nil { | ||
983 | return false | ||
984 | } | ||
985 | if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN { | ||
986 | parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE) | ||
987 | return yaml_parser_parse_node(parser, event, false, false) | ||
988 | } | ||
989 | } | ||
990 | parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE | ||
991 | return yaml_parser_process_empty_scalar(parser, event, token.start_mark) | ||
992 | } | ||
993 | |||
994 | // Generate an empty scalar event. | ||
995 | func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, mark yaml_mark_t) bool { | ||
996 | *event = yaml_event_t{ | ||
997 | typ: yaml_SCALAR_EVENT, | ||
998 | start_mark: mark, | ||
999 | end_mark: mark, | ||
1000 | value: nil, // Empty | ||
1001 | implicit: true, | ||
1002 | style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE), | ||
1003 | } | ||
1004 | return true | ||
1005 | } | ||
1006 | |||
1007 | var default_tag_directives = []yaml_tag_directive_t{ | ||
1008 | {[]byte("!"), []byte("!")}, | ||
1009 | {[]byte("!!"), []byte("tag:yaml.org,2002:")}, | ||
1010 | } | ||
1011 | |||
1012 | // Parse directives. | ||
1013 | func yaml_parser_process_directives(parser *yaml_parser_t, | ||
1014 | version_directive_ref **yaml_version_directive_t, | ||
1015 | tag_directives_ref *[]yaml_tag_directive_t) bool { | ||
1016 | |||
1017 | var version_directive *yaml_version_directive_t | ||
1018 | var tag_directives []yaml_tag_directive_t | ||
1019 | |||
1020 | token := peek_token(parser) | ||
1021 | if token == nil { | ||
1022 | return false | ||
1023 | } | ||
1024 | |||
1025 | for token.typ == yaml_VERSION_DIRECTIVE_TOKEN || token.typ == yaml_TAG_DIRECTIVE_TOKEN { | ||
1026 | if token.typ == yaml_VERSION_DIRECTIVE_TOKEN { | ||
1027 | if version_directive != nil { | ||
1028 | yaml_parser_set_parser_error(parser, | ||
1029 | "found duplicate %YAML directive", token.start_mark) | ||
1030 | return false | ||
1031 | } | ||
1032 | if token.major != 1 || token.minor != 1 { | ||
1033 | yaml_parser_set_parser_error(parser, | ||
1034 | "found incompatible YAML document", token.start_mark) | ||
1035 | return false | ||
1036 | } | ||
1037 | version_directive = &yaml_version_directive_t{ | ||
1038 | major: token.major, | ||
1039 | minor: token.minor, | ||
1040 | } | ||
1041 | } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN { | ||
1042 | value := yaml_tag_directive_t{ | ||
1043 | handle: token.value, | ||
1044 | prefix: token.prefix, | ||
1045 | } | ||
1046 | if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) { | ||
1047 | return false | ||
1048 | } | ||
1049 | tag_directives = append(tag_directives, value) | ||
1050 | } | ||
1051 | |||
1052 | skip_token(parser) | ||
1053 | token = peek_token(parser) | ||
1054 | if token == nil { | ||
1055 | return false | ||
1056 | } | ||
1057 | } | ||
1058 | |||
1059 | for i := range default_tag_directives { | ||
1060 | if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) { | ||
1061 | return false | ||
1062 | } | ||
1063 | } | ||
1064 | |||
1065 | if version_directive_ref != nil { | ||
1066 | *version_directive_ref = version_directive | ||
1067 | } | ||
1068 | if tag_directives_ref != nil { | ||
1069 | *tag_directives_ref = tag_directives | ||
1070 | } | ||
1071 | return true | ||
1072 | } | ||
1073 | |||
1074 | // Append a tag directive to the directives stack. | ||
1075 | func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool { | ||
1076 | for i := range parser.tag_directives { | ||
1077 | if bytes.Equal(value.handle, parser.tag_directives[i].handle) { | ||
1078 | if allow_duplicates { | ||
1079 | return true | ||
1080 | } | ||
1081 | return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark) | ||
1082 | } | ||
1083 | } | ||
1084 | |||
1085 | // [Go] I suspect the copy is unnecessary. This was likely done | ||
1086 | // because there was no way to track ownership of the data. | ||
1087 | value_copy := yaml_tag_directive_t{ | ||
1088 | handle: make([]byte, len(value.handle)), | ||
1089 | prefix: make([]byte, len(value.prefix)), | ||
1090 | } | ||
1091 | copy(value_copy.handle, value.handle) | ||
1092 | copy(value_copy.prefix, value.prefix) | ||
1093 | parser.tag_directives = append(parser.tag_directives, value_copy) | ||
1094 | return true | ||
1095 | } | ||