ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/aya/vendor/gopkg.in/yaml.v3/parserc.go
Revision: 1.1
Committed: Mon Sep 30 00:42:06 2024 UTC (6 weeks, 4 days ago) by yakumo_izuru
Branch: MAIN
CVS Tags: HEAD
Log Message: 
Mirrored from https://git.chaotic.ninja/git/yakumo_izuru/aya

File Contents

# User Rev Content
1 yakumo_izuru 1.1 //
2     // Copyright (c) 2011-2019 Canonical Ltd
3     // Copyright (c) 2006-2010 Kirill Simonov
4     //
5     // Permission is hereby granted, free of charge, to any person obtaining a copy of
6     // this software and associated documentation files (the "Software"), to deal in
7     // the Software without restriction, including without limitation the rights to
8     // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9     // of the Software, and to permit persons to whom the Software is furnished to do
10     // so, subject to the following conditions:
11     //
12     // The above copyright notice and this permission notice shall be included in all
13     // copies or substantial portions of the Software.
14     //
15     // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16     // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17     // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18     // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19     // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20     // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21     // SOFTWARE.
22    
23     package yaml
24    
25     import (
26     "bytes"
27     )
28    
29     // The parser implements the following grammar:
30     //
31     // stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
32     // implicit_document ::= block_node DOCUMENT-END*
33     // explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
34     // block_node_or_indentless_sequence ::=
35     // ALIAS
36     // | properties (block_content | indentless_block_sequence)?
37     // | block_content
38     // | indentless_block_sequence
39     // block_node ::= ALIAS
40     // | properties block_content?
41     // | block_content
42     // flow_node ::= ALIAS
43     // | properties flow_content?
44     // | flow_content
45     // properties ::= TAG ANCHOR? | ANCHOR TAG?
46     // block_content ::= block_collection | flow_collection | SCALAR
47     // flow_content ::= flow_collection | SCALAR
48     // block_collection ::= block_sequence | block_mapping
49     // flow_collection ::= flow_sequence | flow_mapping
50     // block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
51     // indentless_sequence ::= (BLOCK-ENTRY block_node?)+
52     // block_mapping ::= BLOCK-MAPPING_START
53     // ((KEY block_node_or_indentless_sequence?)?
54     // (VALUE block_node_or_indentless_sequence?)?)*
55     // BLOCK-END
56     // flow_sequence ::= FLOW-SEQUENCE-START
57     // (flow_sequence_entry FLOW-ENTRY)*
58     // flow_sequence_entry?
59     // FLOW-SEQUENCE-END
60     // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
61     // flow_mapping ::= FLOW-MAPPING-START
62     // (flow_mapping_entry FLOW-ENTRY)*
63     // flow_mapping_entry?
64     // FLOW-MAPPING-END
65     // flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
66    
67     // Peek the next token in the token queue.
68     func peek_token(parser *yaml_parser_t) *yaml_token_t {
69     if parser.token_available || yaml_parser_fetch_more_tokens(parser) {
70     token := &parser.tokens[parser.tokens_head]
71     yaml_parser_unfold_comments(parser, token)
72     return token
73     }
74     return nil
75     }
76    
77     // yaml_parser_unfold_comments walks through the comments queue and joins all
78     // comments behind the position of the provided token into the respective
79     // top-level comment slices in the parser.
80     func yaml_parser_unfold_comments(parser *yaml_parser_t, token *yaml_token_t) {
81     for parser.comments_head < len(parser.comments) && token.start_mark.index >= parser.comments[parser.comments_head].token_mark.index {
82     comment := &parser.comments[parser.comments_head]
83     if len(comment.head) > 0 {
84     if token.typ == yaml_BLOCK_END_TOKEN {
85     // No heads on ends, so keep comment.head for a follow up token.
86     break
87     }
88     if len(parser.head_comment) > 0 {
89     parser.head_comment = append(parser.head_comment, '\n')
90     }
91     parser.head_comment = append(parser.head_comment, comment.head...)
92     }
93     if len(comment.foot) > 0 {
94     if len(parser.foot_comment) > 0 {
95     parser.foot_comment = append(parser.foot_comment, '\n')
96     }
97     parser.foot_comment = append(parser.foot_comment, comment.foot...)
98     }
99     if len(comment.line) > 0 {
100     if len(parser.line_comment) > 0 {
101     parser.line_comment = append(parser.line_comment, '\n')
102     }
103     parser.line_comment = append(parser.line_comment, comment.line...)
104     }
105     *comment = yaml_comment_t{}
106     parser.comments_head++
107     }
108     }
109    
110     // Remove the next token from the queue (must be called after peek_token).
111     func skip_token(parser *yaml_parser_t) {
112     parser.token_available = false
113     parser.tokens_parsed++
114     parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN
115     parser.tokens_head++
116     }
117    
118     // Get the next event.
119     func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool {
120     // Erase the event object.
121     *event = yaml_event_t{}
122    
123     // No events after the end of the stream or error.
124     if parser.stream_end_produced || parser.error != yaml_NO_ERROR || parser.state == yaml_PARSE_END_STATE {
125     return true
126     }
127    
128     // Generate the next event.
129     return yaml_parser_state_machine(parser, event)
130     }
131    
132     // Set parser error.
133     func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool {
134     parser.error = yaml_PARSER_ERROR
135     parser.problem = problem
136     parser.problem_mark = problem_mark
137     return false
138     }
139    
140     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 {
141     parser.error = yaml_PARSER_ERROR
142     parser.context = context
143     parser.context_mark = context_mark
144     parser.problem = problem
145     parser.problem_mark = problem_mark
146     return false
147     }
148    
149     // State dispatcher.
150     func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool {
151     //trace("yaml_parser_state_machine", "state:", parser.state.String())
152    
153     switch parser.state {
154     case yaml_PARSE_STREAM_START_STATE:
155     return yaml_parser_parse_stream_start(parser, event)
156    
157     case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
158     return yaml_parser_parse_document_start(parser, event, true)
159    
160     case yaml_PARSE_DOCUMENT_START_STATE:
161     return yaml_parser_parse_document_start(parser, event, false)
162    
163     case yaml_PARSE_DOCUMENT_CONTENT_STATE:
164     return yaml_parser_parse_document_content(parser, event)
165    
166     case yaml_PARSE_DOCUMENT_END_STATE:
167     return yaml_parser_parse_document_end(parser, event)
168    
169     case yaml_PARSE_BLOCK_NODE_STATE:
170     return yaml_parser_parse_node(parser, event, true, false)
171    
172     case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
173     return yaml_parser_parse_node(parser, event, true, true)
174    
175     case yaml_PARSE_FLOW_NODE_STATE:
176     return yaml_parser_parse_node(parser, event, false, false)
177    
178     case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
179     return yaml_parser_parse_block_sequence_entry(parser, event, true)
180    
181     case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
182     return yaml_parser_parse_block_sequence_entry(parser, event, false)
183    
184     case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
185     return yaml_parser_parse_indentless_sequence_entry(parser, event)
186    
187     case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
188     return yaml_parser_parse_block_mapping_key(parser, event, true)
189    
190     case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
191     return yaml_parser_parse_block_mapping_key(parser, event, false)
192    
193     case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
194     return yaml_parser_parse_block_mapping_value(parser, event)
195    
196     case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
197     return yaml_parser_parse_flow_sequence_entry(parser, event, true)
198    
199     case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
200     return yaml_parser_parse_flow_sequence_entry(parser, event, false)
201    
202     case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
203     return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)
204    
205     case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
206     return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event)
207    
208     case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
209     return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event)
210    
211     case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
212     return yaml_parser_parse_flow_mapping_key(parser, event, true)
213    
214     case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
215     return yaml_parser_parse_flow_mapping_key(parser, event, false)
216    
217     case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
218     return yaml_parser_parse_flow_mapping_value(parser, event, false)
219    
220     case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
221     return yaml_parser_parse_flow_mapping_value(parser, event, true)
222    
223     default:
224     panic("invalid parser state")
225     }
226     }
227    
228     // Parse the production:
229     // stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
230     // ************
231     func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool {
232     token := peek_token(parser)
233     if token == nil {
234     return false
235     }
236     if token.typ != yaml_STREAM_START_TOKEN {
237     return yaml_parser_set_parser_error(parser, "did not find expected <stream-start>", token.start_mark)
238     }
239     parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE
240     *event = yaml_event_t{
241     typ: yaml_STREAM_START_EVENT,
242     start_mark: token.start_mark,
243     end_mark: token.end_mark,
244     encoding: token.encoding,
245     }
246     skip_token(parser)
247     return true
248     }
249    
250     // Parse the productions:
251     // implicit_document ::= block_node DOCUMENT-END*
252     // *
253     // explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
254     // *************************
255     func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool {
256    
257     token := peek_token(parser)
258     if token == nil {
259     return false
260     }
261    
262     // Parse extra document end indicators.
263     if !implicit {
264     for token.typ == yaml_DOCUMENT_END_TOKEN {
265     skip_token(parser)
266     token = peek_token(parser)
267     if token == nil {
268     return false
269     }
270     }
271     }
272    
273     if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN &&
274     token.typ != yaml_TAG_DIRECTIVE_TOKEN &&
275     token.typ != yaml_DOCUMENT_START_TOKEN &&
276     token.typ != yaml_STREAM_END_TOKEN {
277     // Parse an implicit document.
278     if !yaml_parser_process_directives(parser, nil, nil) {
279     return false
280     }
281     parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
282     parser.state = yaml_PARSE_BLOCK_NODE_STATE
283    
284     var head_comment []byte
285     if len(parser.head_comment) > 0 {
286     // [Go] Scan the header comment backwards, and if an empty line is found, break
287     // the header so the part before the last empty line goes into the
288     // document header, while the bottom of it goes into a follow up event.
289     for i := len(parser.head_comment) - 1; i > 0; i-- {
290     if parser.head_comment[i] == '\n' {
291     if i == len(parser.head_comment)-1 {
292     head_comment = parser.head_comment[:i]
293     parser.head_comment = parser.head_comment[i+1:]
294     break
295     } else if parser.head_comment[i-1] == '\n' {
296     head_comment = parser.head_comment[:i-1]
297     parser.head_comment = parser.head_comment[i+1:]
298     break
299     }
300     }
301     }
302     }
303    
304     *event = yaml_event_t{
305     typ: yaml_DOCUMENT_START_EVENT,
306     start_mark: token.start_mark,
307     end_mark: token.end_mark,
308    
309     head_comment: head_comment,
310     }
311    
312     } else if token.typ != yaml_STREAM_END_TOKEN {
313     // Parse an explicit document.
314     var version_directive *yaml_version_directive_t
315     var tag_directives []yaml_tag_directive_t
316     start_mark := token.start_mark
317     if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) {
318     return false
319     }
320     token = peek_token(parser)
321     if token == nil {
322     return false
323     }
324     if token.typ != yaml_DOCUMENT_START_TOKEN {
325     yaml_parser_set_parser_error(parser,
326     "did not find expected <document start>", token.start_mark)
327     return false
328     }
329     parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
330     parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE
331     end_mark := token.end_mark
332    
333     *event = yaml_event_t{
334     typ: yaml_DOCUMENT_START_EVENT,
335     start_mark: start_mark,
336     end_mark: end_mark,
337     version_directive: version_directive,
338     tag_directives: tag_directives,
339     implicit: false,
340     }
341     skip_token(parser)
342    
343     } else {
344     // Parse the stream end.
345     parser.state = yaml_PARSE_END_STATE
346     *event = yaml_event_t{
347     typ: yaml_STREAM_END_EVENT,
348     start_mark: token.start_mark,
349     end_mark: token.end_mark,
350     }
351     skip_token(parser)
352     }
353    
354     return true
355     }
356    
357     // Parse the productions:
358     // explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
359     // ***********
360     //
361     func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool {
362     token := peek_token(parser)
363     if token == nil {
364     return false
365     }
366    
367     if token.typ == yaml_VERSION_DIRECTIVE_TOKEN ||
368     token.typ == yaml_TAG_DIRECTIVE_TOKEN ||
369     token.typ == yaml_DOCUMENT_START_TOKEN ||
370     token.typ == yaml_DOCUMENT_END_TOKEN ||
371     token.typ == yaml_STREAM_END_TOKEN {
372     parser.state = parser.states[len(parser.states)-1]
373     parser.states = parser.states[:len(parser.states)-1]
374     return yaml_parser_process_empty_scalar(parser, event,
375     token.start_mark)
376     }
377     return yaml_parser_parse_node(parser, event, true, false)
378     }
379    
380     // Parse the productions:
381     // implicit_document ::= block_node DOCUMENT-END*
382     // *************
383     // explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
384     //
385     func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool {
386     token := peek_token(parser)
387     if token == nil {
388     return false
389     }
390    
391     start_mark := token.start_mark
392     end_mark := token.start_mark
393    
394     implicit := true
395     if token.typ == yaml_DOCUMENT_END_TOKEN {
396     end_mark = token.end_mark
397     skip_token(parser)
398     implicit = false
399     }
400    
401     parser.tag_directives = parser.tag_directives[:0]
402    
403     parser.state = yaml_PARSE_DOCUMENT_START_STATE
404     *event = yaml_event_t{
405     typ: yaml_DOCUMENT_END_EVENT,
406     start_mark: start_mark,
407     end_mark: end_mark,
408     implicit: implicit,
409     }
410     yaml_parser_set_event_comments(parser, event)
411     if len(event.head_comment) > 0 && len(event.foot_comment) == 0 {
412     event.foot_comment = event.head_comment
413     event.head_comment = nil
414     }
415     return true
416     }
417    
418     func yaml_parser_set_event_comments(parser *yaml_parser_t, event *yaml_event_t) {
419     event.head_comment = parser.head_comment
420     event.line_comment = parser.line_comment
421     event.foot_comment = parser.foot_comment
422     parser.head_comment = nil
423     parser.line_comment = nil
424     parser.foot_comment = nil
425     parser.tail_comment = nil
426     parser.stem_comment = nil
427     }
428    
429     // Parse the productions:
430     // block_node_or_indentless_sequence ::=
431     // ALIAS
432     // *****
433     // | properties (block_content | indentless_block_sequence)?
434     // ********** *
435     // | block_content | indentless_block_sequence
436     // *
437     // block_node ::= ALIAS
438     // *****
439     // | properties block_content?
440     // ********** *
441     // | block_content
442     // *
443     // flow_node ::= ALIAS
444     // *****
445     // | properties flow_content?
446     // ********** *
447     // | flow_content
448     // *
449     // properties ::= TAG ANCHOR? | ANCHOR TAG?
450     // *************************
451     // block_content ::= block_collection | flow_collection | SCALAR
452     // ******
453     // flow_content ::= flow_collection | SCALAR
454     // ******
455     func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool {
456     //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)()
457    
458     token := peek_token(parser)
459     if token == nil {
460     return false
461     }
462    
463     if token.typ == yaml_ALIAS_TOKEN {
464     parser.state = parser.states[len(parser.states)-1]
465     parser.states = parser.states[:len(parser.states)-1]
466     *event = yaml_event_t{
467     typ: yaml_ALIAS_EVENT,
468     start_mark: token.start_mark,
469     end_mark: token.end_mark,
470     anchor: token.value,
471     }
472     yaml_parser_set_event_comments(parser, event)
473     skip_token(parser)
474     return true
475     }
476    
477     start_mark := token.start_mark
478     end_mark := token.start_mark
479    
480     var tag_token bool
481     var tag_handle, tag_suffix, anchor []byte
482     var tag_mark yaml_mark_t
483     if token.typ == yaml_ANCHOR_TOKEN {
484     anchor = token.value
485     start_mark = token.start_mark
486     end_mark = token.end_mark
487     skip_token(parser)
488     token = peek_token(parser)
489     if token == nil {
490     return false
491     }
492     if token.typ == yaml_TAG_TOKEN {
493     tag_token = true
494     tag_handle = token.value
495     tag_suffix = token.suffix
496     tag_mark = token.start_mark
497     end_mark = token.end_mark
498     skip_token(parser)
499     token = peek_token(parser)
500     if token == nil {
501     return false
502     }
503     }
504     } else if token.typ == yaml_TAG_TOKEN {
505     tag_token = true
506     tag_handle = token.value
507     tag_suffix = token.suffix
508     start_mark = token.start_mark
509     tag_mark = token.start_mark
510     end_mark = token.end_mark
511     skip_token(parser)
512     token = peek_token(parser)
513     if token == nil {
514     return false
515     }
516     if token.typ == yaml_ANCHOR_TOKEN {
517     anchor = token.value
518     end_mark = token.end_mark
519     skip_token(parser)
520     token = peek_token(parser)
521     if token == nil {
522     return false
523     }
524     }
525     }
526    
527     var tag []byte
528     if tag_token {
529     if len(tag_handle) == 0 {
530     tag = tag_suffix
531     tag_suffix = nil
532     } else {
533     for i := range parser.tag_directives {
534     if bytes.Equal(parser.tag_directives[i].handle, tag_handle) {
535     tag = append([]byte(nil), parser.tag_directives[i].prefix...)
536     tag = append(tag, tag_suffix...)
537     break
538     }
539     }
540     if len(tag) == 0 {
541     yaml_parser_set_parser_error_context(parser,
542     "while parsing a node", start_mark,
543     "found undefined tag handle", tag_mark)
544     return false
545     }
546     }
547     }
548    
549     implicit := len(tag) == 0
550     if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN {
551     end_mark = token.end_mark
552     parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
553     *event = yaml_event_t{
554     typ: yaml_SEQUENCE_START_EVENT,
555     start_mark: start_mark,
556     end_mark: end_mark,
557     anchor: anchor,
558     tag: tag,
559     implicit: implicit,
560     style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
561     }
562     return true
563     }
564     if token.typ == yaml_SCALAR_TOKEN {
565     var plain_implicit, quoted_implicit bool
566     end_mark = token.end_mark
567     if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) || (len(tag) == 1 && tag[0] == '!') {
568     plain_implicit = true
569     } else if len(tag) == 0 {
570     quoted_implicit = true
571     }
572     parser.state = parser.states[len(parser.states)-1]
573     parser.states = parser.states[:len(parser.states)-1]
574    
575     *event = yaml_event_t{
576     typ: yaml_SCALAR_EVENT,
577     start_mark: start_mark,
578     end_mark: end_mark,
579     anchor: anchor,
580     tag: tag,
581     value: token.value,
582     implicit: plain_implicit,
583     quoted_implicit: quoted_implicit,
584     style: yaml_style_t(token.style),
585     }
586     yaml_parser_set_event_comments(parser, event)
587     skip_token(parser)
588     return true
589     }
590     if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN {
591     // [Go] Some of the events below can be merged as they differ only on style.
592     end_mark = token.end_mark
593     parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE
594     *event = yaml_event_t{
595     typ: yaml_SEQUENCE_START_EVENT,
596     start_mark: start_mark,
597     end_mark: end_mark,
598     anchor: anchor,
599     tag: tag,
600     implicit: implicit,
601     style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE),
602     }
603     yaml_parser_set_event_comments(parser, event)
604     return true
605     }
606     if token.typ == yaml_FLOW_MAPPING_START_TOKEN {
607     end_mark = token.end_mark
608     parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE
609     *event = yaml_event_t{
610     typ: yaml_MAPPING_START_EVENT,
611     start_mark: start_mark,
612     end_mark: end_mark,
613     anchor: anchor,
614     tag: tag,
615     implicit: implicit,
616     style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
617     }
618     yaml_parser_set_event_comments(parser, event)
619     return true
620     }
621     if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN {
622     end_mark = token.end_mark
623     parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE
624     *event = yaml_event_t{
625     typ: yaml_SEQUENCE_START_EVENT,
626     start_mark: start_mark,
627     end_mark: end_mark,
628     anchor: anchor,
629     tag: tag,
630     implicit: implicit,
631     style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
632     }
633     if parser.stem_comment != nil {
634     event.head_comment = parser.stem_comment
635     parser.stem_comment = nil
636     }
637     return true
638     }
639     if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN {
640     end_mark = token.end_mark
641     parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE
642     *event = yaml_event_t{
643     typ: yaml_MAPPING_START_EVENT,
644     start_mark: start_mark,
645     end_mark: end_mark,
646     anchor: anchor,
647     tag: tag,
648     implicit: implicit,
649     style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE),
650     }
651     if parser.stem_comment != nil {
652     event.head_comment = parser.stem_comment
653     parser.stem_comment = nil
654     }
655     return true
656     }
657     if len(anchor) > 0 || len(tag) > 0 {
658     parser.state = parser.states[len(parser.states)-1]
659     parser.states = parser.states[:len(parser.states)-1]
660    
661     *event = yaml_event_t{
662     typ: yaml_SCALAR_EVENT,
663     start_mark: start_mark,
664     end_mark: end_mark,
665     anchor: anchor,
666     tag: tag,
667     implicit: implicit,
668     quoted_implicit: false,
669     style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
670     }
671     return true
672     }
673    
674     context := "while parsing a flow node"
675     if block {
676     context = "while parsing a block node"
677     }
678     yaml_parser_set_parser_error_context(parser, context, start_mark,
679     "did not find expected node content", token.start_mark)
680     return false
681     }
682    
683     // Parse the productions:
684     // block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
685     // ******************** *********** * *********
686     //
687     func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
688     if first {
689     token := peek_token(parser)
690     if token == nil {
691     return false
692     }
693     parser.marks = append(parser.marks, token.start_mark)
694     skip_token(parser)
695     }
696    
697     token := peek_token(parser)
698     if token == nil {
699     return false
700     }
701    
702     if token.typ == yaml_BLOCK_ENTRY_TOKEN {
703     mark := token.end_mark
704     prior_head_len := len(parser.head_comment)
705     skip_token(parser)
706     yaml_parser_split_stem_comment(parser, prior_head_len)
707     token = peek_token(parser)
708     if token == nil {
709     return false
710     }
711     if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN {
712     parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)
713     return yaml_parser_parse_node(parser, event, true, false)
714     } else {
715     parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE
716     return yaml_parser_process_empty_scalar(parser, event, mark)
717     }
718     }
719     if token.typ == yaml_BLOCK_END_TOKEN {
720     parser.state = parser.states[len(parser.states)-1]
721     parser.states = parser.states[:len(parser.states)-1]
722     parser.marks = parser.marks[:len(parser.marks)-1]
723    
724     *event = yaml_event_t{
725     typ: yaml_SEQUENCE_END_EVENT,
726     start_mark: token.start_mark,
727     end_mark: token.end_mark,
728     }
729    
730     skip_token(parser)
731     return true
732     }
733    
734     context_mark := parser.marks[len(parser.marks)-1]
735     parser.marks = parser.marks[:len(parser.marks)-1]
736     return yaml_parser_set_parser_error_context(parser,
737     "while parsing a block collection", context_mark,
738     "did not find expected '-' indicator", token.start_mark)
739     }
740    
741     // Parse the productions:
742     // indentless_sequence ::= (BLOCK-ENTRY block_node?)+
743     // *********** *
744     func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool {
745     token := peek_token(parser)
746     if token == nil {
747     return false
748     }
749    
750     if token.typ == yaml_BLOCK_ENTRY_TOKEN {
751     mark := token.end_mark
752     prior_head_len := len(parser.head_comment)
753     skip_token(parser)
754     yaml_parser_split_stem_comment(parser, prior_head_len)
755     token = peek_token(parser)
756     if token == nil {
757     return false
758     }
759     if token.typ != yaml_BLOCK_ENTRY_TOKEN &&
760     token.typ != yaml_KEY_TOKEN &&
761     token.typ != yaml_VALUE_TOKEN &&
762     token.typ != yaml_BLOCK_END_TOKEN {
763     parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)
764     return yaml_parser_parse_node(parser, event, true, false)
765     }
766     parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
767     return yaml_parser_process_empty_scalar(parser, event, mark)
768     }
769     parser.state = parser.states[len(parser.states)-1]
770     parser.states = parser.states[:len(parser.states)-1]
771    
772     *event = yaml_event_t{
773     typ: yaml_SEQUENCE_END_EVENT,
774     start_mark: token.start_mark,
775     end_mark: token.start_mark, // [Go] Shouldn't this be token.end_mark?
776     }
777     return true
778     }
779    
780     // Split stem comment from head comment.
781     //
782     // When a sequence or map is found under a sequence entry, the former head comment
783     // is assigned to the underlying sequence or map as a whole, not the individual
784     // sequence or map entry as would be expected otherwise. To handle this case the
785     // previous head comment is moved aside as the stem comment.
786     func yaml_parser_split_stem_comment(parser *yaml_parser_t, stem_len int) {
787     if stem_len == 0 {
788     return
789     }
790    
791     token := peek_token(parser)
792     if token == nil || token.typ != yaml_BLOCK_SEQUENCE_START_TOKEN && token.typ != yaml_BLOCK_MAPPING_START_TOKEN {
793     return
794     }
795    
796     parser.stem_comment = parser.head_comment[:stem_len]
797     if len(parser.head_comment) == stem_len {
798     parser.head_comment = nil
799     } else {
800     // Copy suffix to prevent very strange bugs if someone ever appends
801     // further bytes to the prefix in the stem_comment slice above.
802     parser.head_comment = append([]byte(nil), parser.head_comment[stem_len+1:]...)
803     }
804     }
805    
806     // Parse the productions:
807     // block_mapping ::= BLOCK-MAPPING_START
808     // *******************
809     // ((KEY block_node_or_indentless_sequence?)?
810     // *** *
811     // (VALUE block_node_or_indentless_sequence?)?)*
812     //
813     // BLOCK-END
814     // *********
815     //
816     func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
817     if first {
818     token := peek_token(parser)
819     if token == nil {
820     return false
821     }
822     parser.marks = append(parser.marks, token.start_mark)
823     skip_token(parser)
824     }
825    
826     token := peek_token(parser)
827     if token == nil {
828     return false
829     }
830    
831     // [Go] A tail comment was left from the prior mapping value processed. Emit an event
832     // as it needs to be processed with that value and not the following key.
833     if len(parser.tail_comment) > 0 {
834     *event = yaml_event_t{
835     typ: yaml_TAIL_COMMENT_EVENT,
836     start_mark: token.start_mark,
837     end_mark: token.end_mark,
838     foot_comment: parser.tail_comment,
839     }
840     parser.tail_comment = nil
841     return true
842     }
843    
844     if token.typ == yaml_KEY_TOKEN {
845     mark := token.end_mark
846     skip_token(parser)
847     token = peek_token(parser)
848     if token == nil {
849     return false
850     }
851     if token.typ != yaml_KEY_TOKEN &&
852     token.typ != yaml_VALUE_TOKEN &&
853     token.typ != yaml_BLOCK_END_TOKEN {
854     parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE)
855     return yaml_parser_parse_node(parser, event, true, true)
856     } else {
857     parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE
858     return yaml_parser_process_empty_scalar(parser, event, mark)
859     }
860     } else if token.typ == yaml_BLOCK_END_TOKEN {
861     parser.state = parser.states[len(parser.states)-1]
862     parser.states = parser.states[:len(parser.states)-1]
863     parser.marks = parser.marks[:len(parser.marks)-1]
864     *event = yaml_event_t{
865     typ: yaml_MAPPING_END_EVENT,
866     start_mark: token.start_mark,
867     end_mark: token.end_mark,
868     }
869     yaml_parser_set_event_comments(parser, event)
870     skip_token(parser)
871     return true
872     }
873    
874     context_mark := parser.marks[len(parser.marks)-1]
875     parser.marks = parser.marks[:len(parser.marks)-1]
876     return yaml_parser_set_parser_error_context(parser,
877     "while parsing a block mapping", context_mark,
878     "did not find expected key", token.start_mark)
879     }
880    
881     // Parse the productions:
882     // block_mapping ::= BLOCK-MAPPING_START
883     //
884     // ((KEY block_node_or_indentless_sequence?)?
885     //
886     // (VALUE block_node_or_indentless_sequence?)?)*
887     // ***** *
888     // BLOCK-END
889     //
890     //
891     func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
892     token := peek_token(parser)
893     if token == nil {
894     return false
895     }
896     if token.typ == yaml_VALUE_TOKEN {
897     mark := token.end_mark
898     skip_token(parser)
899     token = peek_token(parser)
900     if token == nil {
901     return false
902     }
903     if token.typ != yaml_KEY_TOKEN &&
904     token.typ != yaml_VALUE_TOKEN &&
905     token.typ != yaml_BLOCK_END_TOKEN {
906     parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE)
907     return yaml_parser_parse_node(parser, event, true, true)
908     }
909     parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
910     return yaml_parser_process_empty_scalar(parser, event, mark)
911     }
912     parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
913     return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
914     }
915    
916     // Parse the productions:
917     // flow_sequence ::= FLOW-SEQUENCE-START
918     // *******************
919     // (flow_sequence_entry FLOW-ENTRY)*
920     // * **********
921     // flow_sequence_entry?
922     // *
923     // FLOW-SEQUENCE-END
924     // *****************
925     // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
926     // *
927     //
928     func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
929     if first {
930     token := peek_token(parser)
931     if token == nil {
932     return false
933     }
934     parser.marks = append(parser.marks, token.start_mark)
935     skip_token(parser)
936     }
937     token := peek_token(parser)
938     if token == nil {
939     return false
940     }
941     if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
942     if !first {
943     if token.typ == yaml_FLOW_ENTRY_TOKEN {
944     skip_token(parser)
945     token = peek_token(parser)
946     if token == nil {
947     return false
948     }
949     } else {
950     context_mark := parser.marks[len(parser.marks)-1]
951     parser.marks = parser.marks[:len(parser.marks)-1]
952     return yaml_parser_set_parser_error_context(parser,
953     "while parsing a flow sequence", context_mark,
954     "did not find expected ',' or ']'", token.start_mark)
955     }
956     }
957    
958     if token.typ == yaml_KEY_TOKEN {
959     parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE
960     *event = yaml_event_t{
961     typ: yaml_MAPPING_START_EVENT,
962     start_mark: token.start_mark,
963     end_mark: token.end_mark,
964     implicit: true,
965     style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
966     }
967     skip_token(parser)
968     return true
969     } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
970     parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE)
971     return yaml_parser_parse_node(parser, event, false, false)
972     }
973     }
974    
975     parser.state = parser.states[len(parser.states)-1]
976     parser.states = parser.states[:len(parser.states)-1]
977     parser.marks = parser.marks[:len(parser.marks)-1]
978    
979     *event = yaml_event_t{
980     typ: yaml_SEQUENCE_END_EVENT,
981     start_mark: token.start_mark,
982     end_mark: token.end_mark,
983     }
984     yaml_parser_set_event_comments(parser, event)
985    
986     skip_token(parser)
987     return true
988     }
989    
990     //
991     // Parse the productions:
992     // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
993     // *** *
994     //
995     func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool {
996     token := peek_token(parser)
997     if token == nil {
998     return false
999     }
1000     if token.typ != yaml_VALUE_TOKEN &&
1001     token.typ != yaml_FLOW_ENTRY_TOKEN &&
1002     token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
1003     parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)
1004     return yaml_parser_parse_node(parser, event, false, false)
1005     }
1006     mark := token.end_mark
1007     skip_token(parser)
1008     parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
1009     return yaml_parser_process_empty_scalar(parser, event, mark)
1010     }
1011    
1012     // Parse the productions:
1013     // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1014     // ***** *
1015     //
1016     func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
1017     token := peek_token(parser)
1018     if token == nil {
1019     return false
1020     }
1021     if token.typ == yaml_VALUE_TOKEN {
1022     skip_token(parser)
1023     token := peek_token(parser)
1024     if token == nil {
1025     return false
1026     }
1027     if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
1028     parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)
1029     return yaml_parser_parse_node(parser, event, false, false)
1030     }
1031     }
1032     parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
1033     return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
1034     }
1035    
1036     // Parse the productions:
1037     // flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1038     // *
1039     //
1040     func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool {
1041     token := peek_token(parser)
1042     if token == nil {
1043     return false
1044     }
1045     parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE
1046     *event = yaml_event_t{
1047     typ: yaml_MAPPING_END_EVENT,
1048     start_mark: token.start_mark,
1049     end_mark: token.start_mark, // [Go] Shouldn't this be end_mark?
1050     }
1051     return true
1052     }
1053    
1054     // Parse the productions:
1055     // flow_mapping ::= FLOW-MAPPING-START
1056     // ******************
1057     // (flow_mapping_entry FLOW-ENTRY)*
1058     // * **********
1059     // flow_mapping_entry?
1060     // ******************
1061     // FLOW-MAPPING-END
1062     // ****************
1063     // flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1064     // * *** *
1065     //
1066     func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
1067     if first {
1068     token := peek_token(parser)
1069     parser.marks = append(parser.marks, token.start_mark)
1070     skip_token(parser)
1071     }
1072    
1073     token := peek_token(parser)
1074     if token == nil {
1075     return false
1076     }
1077    
1078     if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
1079     if !first {
1080     if token.typ == yaml_FLOW_ENTRY_TOKEN {
1081     skip_token(parser)
1082     token = peek_token(parser)
1083     if token == nil {
1084     return false
1085     }
1086     } else {
1087     context_mark := parser.marks[len(parser.marks)-1]
1088     parser.marks = parser.marks[:len(parser.marks)-1]
1089     return yaml_parser_set_parser_error_context(parser,
1090     "while parsing a flow mapping", context_mark,
1091     "did not find expected ',' or '}'", token.start_mark)
1092     }
1093     }
1094    
1095     if token.typ == yaml_KEY_TOKEN {
1096     skip_token(parser)
1097     token = peek_token(parser)
1098     if token == nil {
1099     return false
1100     }
1101     if token.typ != yaml_VALUE_TOKEN &&
1102     token.typ != yaml_FLOW_ENTRY_TOKEN &&
1103     token.typ != yaml_FLOW_MAPPING_END_TOKEN {
1104     parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE)
1105     return yaml_parser_parse_node(parser, event, false, false)
1106     } else {
1107     parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE
1108     return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
1109     }
1110     } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
1111     parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)
1112     return yaml_parser_parse_node(parser, event, false, false)
1113     }
1114     }
1115    
1116     parser.state = parser.states[len(parser.states)-1]
1117     parser.states = parser.states[:len(parser.states)-1]
1118     parser.marks = parser.marks[:len(parser.marks)-1]
1119     *event = yaml_event_t{
1120     typ: yaml_MAPPING_END_EVENT,
1121     start_mark: token.start_mark,
1122     end_mark: token.end_mark,
1123     }
1124     yaml_parser_set_event_comments(parser, event)
1125     skip_token(parser)
1126     return true
1127     }
1128    
1129     // Parse the productions:
1130     // flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1131     // * ***** *
1132     //
1133     func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool {
1134     token := peek_token(parser)
1135     if token == nil {
1136     return false
1137     }
1138     if empty {
1139     parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
1140     return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
1141     }
1142     if token.typ == yaml_VALUE_TOKEN {
1143     skip_token(parser)
1144     token = peek_token(parser)
1145     if token == nil {
1146     return false
1147     }
1148     if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN {
1149     parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE)
1150     return yaml_parser_parse_node(parser, event, false, false)
1151     }
1152     }
1153     parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
1154     return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
1155     }
1156    
1157     // Generate an empty scalar event.
1158     func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, mark yaml_mark_t) bool {
1159     *event = yaml_event_t{
1160     typ: yaml_SCALAR_EVENT,
1161     start_mark: mark,
1162     end_mark: mark,
1163     value: nil, // Empty
1164     implicit: true,
1165     style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
1166     }
1167     return true
1168     }
1169    
1170     var default_tag_directives = []yaml_tag_directive_t{
1171     {[]byte("!"), []byte("!")},
1172     {[]byte("!!"), []byte("tag:yaml.org,2002:")},
1173     }
1174    
1175     // Parse directives.
1176     func yaml_parser_process_directives(parser *yaml_parser_t,
1177     version_directive_ref **yaml_version_directive_t,
1178     tag_directives_ref *[]yaml_tag_directive_t) bool {
1179    
1180     var version_directive *yaml_version_directive_t
1181     var tag_directives []yaml_tag_directive_t
1182    
1183     token := peek_token(parser)
1184     if token == nil {
1185     return false
1186     }
1187    
1188     for token.typ == yaml_VERSION_DIRECTIVE_TOKEN || token.typ == yaml_TAG_DIRECTIVE_TOKEN {
1189     if token.typ == yaml_VERSION_DIRECTIVE_TOKEN {
1190     if version_directive != nil {
1191     yaml_parser_set_parser_error(parser,
1192     "found duplicate %YAML directive", token.start_mark)
1193     return false
1194     }
1195     if token.major != 1 || token.minor != 1 {
1196     yaml_parser_set_parser_error(parser,
1197     "found incompatible YAML document", token.start_mark)
1198     return false
1199     }
1200     version_directive = &yaml_version_directive_t{
1201     major: token.major,
1202     minor: token.minor,
1203     }
1204     } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN {
1205     value := yaml_tag_directive_t{
1206     handle: token.value,
1207     prefix: token.prefix,
1208     }
1209     if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) {
1210     return false
1211     }
1212     tag_directives = append(tag_directives, value)
1213     }
1214    
1215     skip_token(parser)
1216     token = peek_token(parser)
1217     if token == nil {
1218     return false
1219     }
1220     }
1221    
1222     for i := range default_tag_directives {
1223     if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) {
1224     return false
1225     }
1226     }
1227    
1228     if version_directive_ref != nil {
1229     *version_directive_ref = version_directive
1230     }
1231     if tag_directives_ref != nil {
1232     *tag_directives_ref = tag_directives
1233     }
1234     return true
1235     }
1236    
1237     // Append a tag directive to the directives stack.
1238     func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool {
1239     for i := range parser.tag_directives {
1240     if bytes.Equal(value.handle, parser.tag_directives[i].handle) {
1241     if allow_duplicates {
1242     return true
1243     }
1244     return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark)
1245     }
1246     }
1247    
1248     // [Go] I suspect the copy is unnecessary. This was likely done
1249     // because there was no way to track ownership of the data.
1250     value_copy := yaml_tag_directive_t{
1251     handle: make([]byte, len(value.handle)),
1252     prefix: make([]byte, len(value.prefix)),
1253     }
1254     copy(value_copy.handle, value.handle)
1255     copy(value_copy.prefix, value.prefix)
1256     parser.tag_directives = append(parser.tag_directives, value_copy)
1257     return true
1258     }