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
	"io"
27
)
28

29
func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
30
	//fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
31

32
	// Check if we can move the queue at the beginning of the buffer.
33
	if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
34
		if parser.tokens_head != len(parser.tokens) {
35
			copy(parser.tokens, parser.tokens[parser.tokens_head:])
36
		}
37
		parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
38
		parser.tokens_head = 0
39
	}
40
	parser.tokens = append(parser.tokens, *token)
41
	if pos < 0 {
42
		return
43
	}
44
	copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
45
	parser.tokens[parser.tokens_head+pos] = *token
46
}
47

48
// Create a new parser object.
49
func yaml_parser_initialize(parser *yaml_parser_t) bool {
50
	*parser = yaml_parser_t{
51
		raw_buffer: make([]byte, 0, input_raw_buffer_size),
52
		buffer:     make([]byte, 0, input_buffer_size),
53
	}
54
	return true
55
}
56

57
// Destroy a parser object.
58
func yaml_parser_delete(parser *yaml_parser_t) {
59
	*parser = yaml_parser_t{}
60
}
61

62
// String read handler.
63
func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
64
	if parser.input_pos == len(parser.input) {
65
		return 0, io.EOF
66
	}
67
	n = copy(buffer, parser.input[parser.input_pos:])
68
	parser.input_pos += n
69
	return n, nil
70
}
71

72
// Reader read handler.
73
func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
74
	return parser.input_reader.Read(buffer)
75
}
76

77
// Set a string input.
78
func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
79
	if parser.read_handler != nil {
80
		panic("must set the input source only once")
81
	}
82
	parser.read_handler = yaml_string_read_handler
83
	parser.input = input
84
	parser.input_pos = 0
85
}
86

87
// Set a file input.
88
func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {
89
	if parser.read_handler != nil {
90
		panic("must set the input source only once")
91
	}
92
	parser.read_handler = yaml_reader_read_handler
93
	parser.input_reader = r
94
}
95

96
// Set the source encoding.
97
func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
98
	if parser.encoding != yaml_ANY_ENCODING {
99
		panic("must set the encoding only once")
100
	}
101
	parser.encoding = encoding
102
}
103

104
// Create a new emitter object.
105
func yaml_emitter_initialize(emitter *yaml_emitter_t) {
106
	*emitter = yaml_emitter_t{
107
		buffer:     make([]byte, output_buffer_size),
108
		raw_buffer: make([]byte, 0, output_raw_buffer_size),
109
		states:     make([]yaml_emitter_state_t, 0, initial_stack_size),
110
		events:     make([]yaml_event_t, 0, initial_queue_size),
111
		best_width: -1,
112
	}
113
}
114

115
// Destroy an emitter object.
116
func yaml_emitter_delete(emitter *yaml_emitter_t) {
117
	*emitter = yaml_emitter_t{}
118
}
119

120
// String write handler.
121
func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
122
	*emitter.output_buffer = append(*emitter.output_buffer, buffer...)
123
	return nil
124
}
125

126
// yaml_writer_write_handler uses emitter.output_writer to write the
127
// emitted text.
128
func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
129
	_, err := emitter.output_writer.Write(buffer)
130
	return err
131
}
132

133
// Set a string output.
134
func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
135
	if emitter.write_handler != nil {
136
		panic("must set the output target only once")
137
	}
138
	emitter.write_handler = yaml_string_write_handler
139
	emitter.output_buffer = output_buffer
140
}
141

142
// Set a file output.
143
func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) {
144
	if emitter.write_handler != nil {
145
		panic("must set the output target only once")
146
	}
147
	emitter.write_handler = yaml_writer_write_handler
148
	emitter.output_writer = w
149
}
150

151
// Set the output encoding.
152
func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
153
	if emitter.encoding != yaml_ANY_ENCODING {
154
		panic("must set the output encoding only once")
155
	}
156
	emitter.encoding = encoding
157
}
158

159
// Set the canonical output style.
160
func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
161
	emitter.canonical = canonical
162
}
163

164
// Set the indentation increment.
165
func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
166
	if indent < 2 || indent > 9 {
167
		indent = 2
168
	}
169
	emitter.best_indent = indent
170
}
171

172
// Set the preferred line width.
173
func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
174
	if width < 0 {
175
		width = -1
176
	}
177
	emitter.best_width = width
178
}
179

180
// Set if unescaped non-ASCII characters are allowed.
181
func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
182
	emitter.unicode = unicode
183
}
184

185
// Set the preferred line break character.
186
func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
187
	emitter.line_break = line_break
188
}
189

190
///*
191
// * Destroy a token object.
192
// */
193
//
194
//YAML_DECLARE(void)
195
//yaml_token_delete(yaml_token_t *token)
196
//{
197
//    assert(token);  // Non-NULL token object expected.
198
//
199
//    switch (token.type)
200
//    {
201
//        case YAML_TAG_DIRECTIVE_TOKEN:
202
//            yaml_free(token.data.tag_directive.handle);
203
//            yaml_free(token.data.tag_directive.prefix);
204
//            break;
205
//
206
//        case YAML_ALIAS_TOKEN:
207
//            yaml_free(token.data.alias.value);
208
//            break;
209
//
210
//        case YAML_ANCHOR_TOKEN:
211
//            yaml_free(token.data.anchor.value);
212
//            break;
213
//
214
//        case YAML_TAG_TOKEN:
215
//            yaml_free(token.data.tag.handle);
216
//            yaml_free(token.data.tag.suffix);
217
//            break;
218
//
219
//        case YAML_SCALAR_TOKEN:
220
//            yaml_free(token.data.scalar.value);
221
//            break;
222
//
223
//        default:
224
//            break;
225
//    }
226
//
227
//    memset(token, 0, sizeof(yaml_token_t));
228
//}
229
//
230
///*
231
// * Check if a string is a valid UTF-8 sequence.
232
// *
233
// * Check 'reader.c' for more details on UTF-8 encoding.
234
// */
235
//
236
//static int
237
//yaml_check_utf8(yaml_char_t *start, size_t length)
238
//{
239
//    yaml_char_t *end = start+length;
240
//    yaml_char_t *pointer = start;
241
//
242
//    while (pointer < end) {
243
//        unsigned char octet;
244
//        unsigned int width;
245
//        unsigned int value;
246
//        size_t k;
247
//
248
//        octet = pointer[0];
249
//        width = (octet & 0x80) == 0x00 ? 1 :
250
//                (octet & 0xE0) == 0xC0 ? 2 :
251
//                (octet & 0xF0) == 0xE0 ? 3 :
252
//                (octet & 0xF8) == 0xF0 ? 4 : 0;
253
//        value = (octet & 0x80) == 0x00 ? octet & 0x7F :
254
//                (octet & 0xE0) == 0xC0 ? octet & 0x1F :
255
//                (octet & 0xF0) == 0xE0 ? octet & 0x0F :
256
//                (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
257
//        if (!width) return 0;
258
//        if (pointer+width > end) return 0;
259
//        for (k = 1; k < width; k ++) {
260
//            octet = pointer[k];
261
//            if ((octet & 0xC0) != 0x80) return 0;
262
//            value = (value << 6) + (octet & 0x3F);
263
//        }
264
//        if (!((width == 1) ||
265
//            (width == 2 && value >= 0x80) ||
266
//            (width == 3 && value >= 0x800) ||
267
//            (width == 4 && value >= 0x10000))) return 0;
268
//
269
//        pointer += width;
270
//    }
271
//
272
//    return 1;
273
//}
274
//
275

276
// Create STREAM-START.
277
func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) {
278
	*event = yaml_event_t{
279
		typ:      yaml_STREAM_START_EVENT,
280
		encoding: encoding,
281
	}
282
}
283

284
// Create STREAM-END.
285
func yaml_stream_end_event_initialize(event *yaml_event_t) {
286
	*event = yaml_event_t{
287
		typ: yaml_STREAM_END_EVENT,
288
	}
289
}
290

291
// Create DOCUMENT-START.
292
func yaml_document_start_event_initialize(
293
	event *yaml_event_t,
294
	version_directive *yaml_version_directive_t,
295
	tag_directives []yaml_tag_directive_t,
296
	implicit bool,
297
) {
298
	*event = yaml_event_t{
299
		typ:               yaml_DOCUMENT_START_EVENT,
300
		version_directive: version_directive,
301
		tag_directives:    tag_directives,
302
		implicit:          implicit,
303
	}
304
}
305

306
// Create DOCUMENT-END.
307
func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {
308
	*event = yaml_event_t{
309
		typ:      yaml_DOCUMENT_END_EVENT,
310
		implicit: implicit,
311
	}
312
}
313

314
// Create ALIAS.
315
func yaml_alias_event_initialize(event *yaml_event_t, anchor []byte) bool {
316
	*event = yaml_event_t{
317
		typ:    yaml_ALIAS_EVENT,
318
		anchor: anchor,
319
	}
320
	return true
321
}
322

323
// Create SCALAR.
324
func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
325
	*event = yaml_event_t{
326
		typ:             yaml_SCALAR_EVENT,
327
		anchor:          anchor,
328
		tag:             tag,
329
		value:           value,
330
		implicit:        plain_implicit,
331
		quoted_implicit: quoted_implicit,
332
		style:           yaml_style_t(style),
333
	}
334
	return true
335
}
336

337
// Create SEQUENCE-START.
338
func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
339
	*event = yaml_event_t{
340
		typ:      yaml_SEQUENCE_START_EVENT,
341
		anchor:   anchor,
342
		tag:      tag,
343
		implicit: implicit,
344
		style:    yaml_style_t(style),
345
	}
346
	return true
347
}
348

349
// Create SEQUENCE-END.
350
func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
351
	*event = yaml_event_t{
352
		typ: yaml_SEQUENCE_END_EVENT,
353
	}
354
	return true
355
}
356

357
// Create MAPPING-START.
358
func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) {
359
	*event = yaml_event_t{
360
		typ:      yaml_MAPPING_START_EVENT,
361
		anchor:   anchor,
362
		tag:      tag,
363
		implicit: implicit,
364
		style:    yaml_style_t(style),
365
	}
366
}
367

368
// Create MAPPING-END.
369
func yaml_mapping_end_event_initialize(event *yaml_event_t) {
370
	*event = yaml_event_t{
371
		typ: yaml_MAPPING_END_EVENT,
372
	}
373
}
374

375
// Destroy an event object.
376
func yaml_event_delete(event *yaml_event_t) {
377
	*event = yaml_event_t{}
378
}
379

380
///*
381
// * Create a document object.
382
// */
383
//
384
//YAML_DECLARE(int)
385
//yaml_document_initialize(document *yaml_document_t,
386
//        version_directive *yaml_version_directive_t,
387
//        tag_directives_start *yaml_tag_directive_t,
388
//        tag_directives_end *yaml_tag_directive_t,
389
//        start_implicit int, end_implicit int)
390
//{
391
//    struct {
392
//        error yaml_error_type_t
393
//    } context
394
//    struct {
395
//        start *yaml_node_t
396
//        end *yaml_node_t
397
//        top *yaml_node_t
398
//    } nodes = { NULL, NULL, NULL }
399
//    version_directive_copy *yaml_version_directive_t = NULL
400
//    struct {
401
//        start *yaml_tag_directive_t
402
//        end *yaml_tag_directive_t
403
//        top *yaml_tag_directive_t
404
//    } tag_directives_copy = { NULL, NULL, NULL }
405
//    value yaml_tag_directive_t = { NULL, NULL }
406
//    mark yaml_mark_t = { 0, 0, 0 }
407
//
408
//    assert(document) // Non-NULL document object is expected.
409
//    assert((tag_directives_start && tag_directives_end) ||
410
//            (tag_directives_start == tag_directives_end))
411
//                            // Valid tag directives are expected.
412
//
413
//    if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
414
//
415
//    if (version_directive) {
416
//        version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
417
//        if (!version_directive_copy) goto error
418
//        version_directive_copy.major = version_directive.major
419
//        version_directive_copy.minor = version_directive.minor
420
//    }
421
//
422
//    if (tag_directives_start != tag_directives_end) {
423
//        tag_directive *yaml_tag_directive_t
424
//        if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
425
//            goto error
426
//        for (tag_directive = tag_directives_start
427
//                tag_directive != tag_directives_end; tag_directive ++) {
428
//            assert(tag_directive.handle)
429
//            assert(tag_directive.prefix)
430
//            if (!yaml_check_utf8(tag_directive.handle,
431
//                        strlen((char *)tag_directive.handle)))
432
//                goto error
433
//            if (!yaml_check_utf8(tag_directive.prefix,
434
//                        strlen((char *)tag_directive.prefix)))
435
//                goto error
436
//            value.handle = yaml_strdup(tag_directive.handle)
437
//            value.prefix = yaml_strdup(tag_directive.prefix)
438
//            if (!value.handle || !value.prefix) goto error
439
//            if (!PUSH(&context, tag_directives_copy, value))
440
//                goto error
441
//            value.handle = NULL
442
//            value.prefix = NULL
443
//        }
444
//    }
445
//
446
//    DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
447
//            tag_directives_copy.start, tag_directives_copy.top,
448
//            start_implicit, end_implicit, mark, mark)
449
//
450
//    return 1
451
//
452
//error:
453
//    STACK_DEL(&context, nodes)
454
//    yaml_free(version_directive_copy)
455
//    while (!STACK_EMPTY(&context, tag_directives_copy)) {
456
//        value yaml_tag_directive_t = POP(&context, tag_directives_copy)
457
//        yaml_free(value.handle)
458
//        yaml_free(value.prefix)
459
//    }
460
//    STACK_DEL(&context, tag_directives_copy)
461
//    yaml_free(value.handle)
462
//    yaml_free(value.prefix)
463
//
464
//    return 0
465
//}
466
//
467
///*
468
// * Destroy a document object.
469
// */
470
//
471
//YAML_DECLARE(void)
472
//yaml_document_delete(document *yaml_document_t)
473
//{
474
//    struct {
475
//        error yaml_error_type_t
476
//    } context
477
//    tag_directive *yaml_tag_directive_t
478
//
479
//    context.error = YAML_NO_ERROR // Eliminate a compiler warning.
480
//
481
//    assert(document) // Non-NULL document object is expected.
482
//
483
//    while (!STACK_EMPTY(&context, document.nodes)) {
484
//        node yaml_node_t = POP(&context, document.nodes)
485
//        yaml_free(node.tag)
486
//        switch (node.type) {
487
//            case YAML_SCALAR_NODE:
488
//                yaml_free(node.data.scalar.value)
489
//                break
490
//            case YAML_SEQUENCE_NODE:
491
//                STACK_DEL(&context, node.data.sequence.items)
492
//                break
493
//            case YAML_MAPPING_NODE:
494
//                STACK_DEL(&context, node.data.mapping.pairs)
495
//                break
496
//            default:
497
//                assert(0) // Should not happen.
498
//        }
499
//    }
500
//    STACK_DEL(&context, document.nodes)
501
//
502
//    yaml_free(document.version_directive)
503
//    for (tag_directive = document.tag_directives.start
504
//            tag_directive != document.tag_directives.end
505
//            tag_directive++) {
506
//        yaml_free(tag_directive.handle)
507
//        yaml_free(tag_directive.prefix)
508
//    }
509
//    yaml_free(document.tag_directives.start)
510
//
511
//    memset(document, 0, sizeof(yaml_document_t))
512
//}
513
//
514
///**
515
// * Get a document node.
516
// */
517
//
518
//YAML_DECLARE(yaml_node_t *)
519
//yaml_document_get_node(document *yaml_document_t, index int)
520
//{
521
//    assert(document) // Non-NULL document object is expected.
522
//
523
//    if (index > 0 && document.nodes.start + index <= document.nodes.top) {
524
//        return document.nodes.start + index - 1
525
//    }
526
//    return NULL
527
//}
528
//
529
///**
530
// * Get the root object.
531
// */
532
//
533
//YAML_DECLARE(yaml_node_t *)
534
//yaml_document_get_root_node(document *yaml_document_t)
535
//{
536
//    assert(document) // Non-NULL document object is expected.
537
//
538
//    if (document.nodes.top != document.nodes.start) {
539
//        return document.nodes.start
540
//    }
541
//    return NULL
542
//}
543
//
544
///*
545
// * Add a scalar node to a document.
546
// */
547
//
548
//YAML_DECLARE(int)
549
//yaml_document_add_scalar(document *yaml_document_t,
550
//        tag *yaml_char_t, value *yaml_char_t, length int,
551
//        style yaml_scalar_style_t)
552
//{
553
//    struct {
554
//        error yaml_error_type_t
555
//    } context
556
//    mark yaml_mark_t = { 0, 0, 0 }
557
//    tag_copy *yaml_char_t = NULL
558
//    value_copy *yaml_char_t = NULL
559
//    node yaml_node_t
560
//
561
//    assert(document) // Non-NULL document object is expected.
562
//    assert(value) // Non-NULL value is expected.
563
//
564
//    if (!tag) {
565
//        tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
566
//    }
567
//
568
//    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
569
//    tag_copy = yaml_strdup(tag)
570
//    if (!tag_copy) goto error
571
//
572
//    if (length < 0) {
573
//        length = strlen((char *)value)
574
//    }
575
//
576
//    if (!yaml_check_utf8(value, length)) goto error
577
//    value_copy = yaml_malloc(length+1)
578
//    if (!value_copy) goto error
579
//    memcpy(value_copy, value, length)
580
//    value_copy[length] = '\0'
581
//
582
//    SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
583
//    if (!PUSH(&context, document.nodes, node)) goto error
584
//
585
//    return document.nodes.top - document.nodes.start
586
//
587
//error:
588
//    yaml_free(tag_copy)
589
//    yaml_free(value_copy)
590
//
591
//    return 0
592
//}
593
//
594
///*
595
// * Add a sequence node to a document.
596
// */
597
//
598
//YAML_DECLARE(int)
599
//yaml_document_add_sequence(document *yaml_document_t,
600
//        tag *yaml_char_t, style yaml_sequence_style_t)
601
//{
602
//    struct {
603
//        error yaml_error_type_t
604
//    } context
605
//    mark yaml_mark_t = { 0, 0, 0 }
606
//    tag_copy *yaml_char_t = NULL
607
//    struct {
608
//        start *yaml_node_item_t
609
//        end *yaml_node_item_t
610
//        top *yaml_node_item_t
611
//    } items = { NULL, NULL, NULL }
612
//    node yaml_node_t
613
//
614
//    assert(document) // Non-NULL document object is expected.
615
//
616
//    if (!tag) {
617
//        tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
618
//    }
619
//
620
//    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
621
//    tag_copy = yaml_strdup(tag)
622
//    if (!tag_copy) goto error
623
//
624
//    if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
625
//
626
//    SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
627
//            style, mark, mark)
628
//    if (!PUSH(&context, document.nodes, node)) goto error
629
//
630
//    return document.nodes.top - document.nodes.start
631
//
632
//error:
633
//    STACK_DEL(&context, items)
634
//    yaml_free(tag_copy)
635
//
636
//    return 0
637
//}
638
//
639
///*
640
// * Add a mapping node to a document.
641
// */
642
//
643
//YAML_DECLARE(int)
644
//yaml_document_add_mapping(document *yaml_document_t,
645
//        tag *yaml_char_t, style yaml_mapping_style_t)
646
//{
647
//    struct {
648
//        error yaml_error_type_t
649
//    } context
650
//    mark yaml_mark_t = { 0, 0, 0 }
651
//    tag_copy *yaml_char_t = NULL
652
//    struct {
653
//        start *yaml_node_pair_t
654
//        end *yaml_node_pair_t
655
//        top *yaml_node_pair_t
656
//    } pairs = { NULL, NULL, NULL }
657
//    node yaml_node_t
658
//
659
//    assert(document) // Non-NULL document object is expected.
660
//
661
//    if (!tag) {
662
//        tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
663
//    }
664
//
665
//    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
666
//    tag_copy = yaml_strdup(tag)
667
//    if (!tag_copy) goto error
668
//
669
//    if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
670
//
671
//    MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
672
//            style, mark, mark)
673
//    if (!PUSH(&context, document.nodes, node)) goto error
674
//
675
//    return document.nodes.top - document.nodes.start
676
//
677
//error:
678
//    STACK_DEL(&context, pairs)
679
//    yaml_free(tag_copy)
680
//
681
//    return 0
682
//}
683
//
684
///*
685
// * Append an item to a sequence node.
686
// */
687
//
688
//YAML_DECLARE(int)
689
//yaml_document_append_sequence_item(document *yaml_document_t,
690
//        sequence int, item int)
691
//{
692
//    struct {
693
//        error yaml_error_type_t
694
//    } context
695
//
696
//    assert(document) // Non-NULL document is required.
697
//    assert(sequence > 0
698
//            && document.nodes.start + sequence <= document.nodes.top)
699
//                            // Valid sequence id is required.
700
//    assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
701
//                            // A sequence node is required.
702
//    assert(item > 0 && document.nodes.start + item <= document.nodes.top)
703
//                            // Valid item id is required.
704
//
705
//    if (!PUSH(&context,
706
//                document.nodes.start[sequence-1].data.sequence.items, item))
707
//        return 0
708
//
709
//    return 1
710
//}
711
//
712
///*
713
// * Append a pair of a key and a value to a mapping node.
714
// */
715
//
716
//YAML_DECLARE(int)
717
//yaml_document_append_mapping_pair(document *yaml_document_t,
718
//        mapping int, key int, value int)
719
//{
720
//    struct {
721
//        error yaml_error_type_t
722
//    } context
723
//
724
//    pair yaml_node_pair_t
725
//
726
//    assert(document) // Non-NULL document is required.
727
//    assert(mapping > 0
728
//            && document.nodes.start + mapping <= document.nodes.top)
729
//                            // Valid mapping id is required.
730
//    assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
731
//                            // A mapping node is required.
732
//    assert(key > 0 && document.nodes.start + key <= document.nodes.top)
733
//                            // Valid key id is required.
734
//    assert(value > 0 && document.nodes.start + value <= document.nodes.top)
735
//                            // Valid value id is required.
736
//
737
//    pair.key = key
738
//    pair.value = value
739
//
740
//    if (!PUSH(&context,
741
//                document.nodes.start[mapping-1].data.mapping.pairs, pair))
742
//        return 0
743
//
744
//    return 1
745
//}
746
//
747
//
748

749