Mercurial > yakumo_izuru > aya

comparison vendor/gopkg.in/yaml.v3/apic.go @ 74:d8727551f403 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
The Empress (III) * Change the way how versions are handled in version.go (to ease `go install`) * Upgrade yaml.v2 to yaml.v3 Signed-off-by: Izuru Yakumo <yakumo.izuru@chaotic.ninja>
author yakumo.izuru
date Mon, 04 Dec 2023 00:54:29 +0000
parents
children
comparison
equal deleted inserted replaced
73:8533d875a2bb 74:d8727551f403
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 //