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

1260