|
66
|
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 }
|
