Mercurial > yakumo_izuru > aya

comparison vendor/gopkg.in/yaml.v2/apic.go @ 66:787b5ee0289d draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Use vendored modules Signed-off-by: Izuru Yakumo <yakumo.izuru@chaotic.ninja>
author yakumo.izuru
date Sun, 23 Jul 2023 13:18:53 +0000
parents
children
comparison
equal deleted inserted replaced
65:6d985efa0f7a 66:787b5ee0289d
1 package yaml
2
3 import (
4 "io"
5 )
6
7 func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
8 //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
9
10 // Check if we can move the queue at the beginning of the buffer.
11 if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
12 if parser.tokens_head != len(parser.tokens) {
13 copy(parser.tokens, parser.tokens[parser.tokens_head:])
14 }
15 parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
16 parser.tokens_head = 0
17 }
18 parser.tokens = append(parser.tokens, *token)
19 if pos < 0 {
20 return
21 }
22 copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
23 parser.tokens[parser.tokens_head+pos] = *token
24 }
25
26 // Create a new parser object.
27 func yaml_parser_initialize(parser *yaml_parser_t) bool {
28 *parser = yaml_parser_t{
29 raw_buffer: make([]byte, 0, input_raw_buffer_size),
30 buffer: make([]byte, 0, input_buffer_size),
31 }
32 return true
33 }
34
35 // Destroy a parser object.
36 func yaml_parser_delete(parser *yaml_parser_t) {
37 *parser = yaml_parser_t{}
38 }
39
40 // String read handler.
41 func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
42 if parser.input_pos == len(parser.input) {
43 return 0, io.EOF
44 }
45 n = copy(buffer, parser.input[parser.input_pos:])
46 parser.input_pos += n
47 return n, nil
48 }
49
50 // Reader read handler.
51 func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
52 return parser.input_reader.Read(buffer)
53 }
54
55 // Set a string input.
56 func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
57 if parser.read_handler != nil {
58 panic("must set the input source only once")
59 }
60 parser.read_handler = yaml_string_read_handler
61 parser.input = input
62 parser.input_pos = 0
63 }
64
65 // Set a file input.
66 func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {
67 if parser.read_handler != nil {
68 panic("must set the input source only once")
69 }
70 parser.read_handler = yaml_reader_read_handler
71 parser.input_reader = r
72 }
73
74 // Set the source encoding.
75 func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
76 if parser.encoding != yaml_ANY_ENCODING {
77 panic("must set the encoding only once")
78 }
79 parser.encoding = encoding
80 }
81
82 var disableLineWrapping = false
83
84 // Create a new emitter object.
85 func yaml_emitter_initialize(emitter *yaml_emitter_t) {
86 *emitter = yaml_emitter_t{
87 buffer: make([]byte, output_buffer_size),
88 raw_buffer: make([]byte, 0, output_raw_buffer_size),
89 states: make([]yaml_emitter_state_t, 0, initial_stack_size),
90 events: make([]yaml_event_t, 0, initial_queue_size),
91 }
92 if disableLineWrapping {
93 emitter.best_width = -1
94 }
95 }
96
97 // Destroy an emitter object.
98 func yaml_emitter_delete(emitter *yaml_emitter_t) {
99 *emitter = yaml_emitter_t{}
100 }
101
102 // String write handler.
103 func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
104 *emitter.output_buffer = append(*emitter.output_buffer, buffer...)
105 return nil
106 }
107
108 // yaml_writer_write_handler uses emitter.output_writer to write the
109 // emitted text.
110 func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
111 _, err := emitter.output_writer.Write(buffer)
112 return err
113 }
114
115 // Set a string output.
116 func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
117 if emitter.write_handler != nil {
118 panic("must set the output target only once")
119 }
120 emitter.write_handler = yaml_string_write_handler
121 emitter.output_buffer = output_buffer
122 }
123
124 // Set a file output.
125 func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) {
126 if emitter.write_handler != nil {
127 panic("must set the output target only once")
128 }
129 emitter.write_handler = yaml_writer_write_handler
130 emitter.output_writer = w
131 }
132
133 // Set the output encoding.
134 func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
135 if emitter.encoding != yaml_ANY_ENCODING {
136 panic("must set the output encoding only once")
137 }
138 emitter.encoding = encoding
139 }
140
141 // Set the canonical output style.
142 func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
143 emitter.canonical = canonical
144 }
145
146 //// Set the indentation increment.
147 func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
148 if indent < 2 || indent > 9 {
149 indent = 2
150 }
151 emitter.best_indent = indent
152 }
153
154 // Set the preferred line width.
155 func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
156 if width < 0 {
157 width = -1
158 }
159 emitter.best_width = width
160 }
161
162 // Set if unescaped non-ASCII characters are allowed.
163 func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
164 emitter.unicode = unicode
165 }
166
167 // Set the preferred line break character.
168 func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
169 emitter.line_break = line_break
170 }
171
172 ///*
173 // * Destroy a token object.
174 // */
175 //
176 //YAML_DECLARE(void)
177 //yaml_token_delete(yaml_token_t *token)
178 //{
179 // assert(token); // Non-NULL token object expected.
180 //
181 // switch (token.type)
182 // {
183 // case YAML_TAG_DIRECTIVE_TOKEN:
184 // yaml_free(token.data.tag_directive.handle);
185 // yaml_free(token.data.tag_directive.prefix);
186 // break;
187 //
188 // case YAML_ALIAS_TOKEN:
189 // yaml_free(token.data.alias.value);
190 // break;
191 //
192 // case YAML_ANCHOR_TOKEN:
193 // yaml_free(token.data.anchor.value);
194 // break;
195 //
196 // case YAML_TAG_TOKEN:
197 // yaml_free(token.data.tag.handle);
198 // yaml_free(token.data.tag.suffix);
199 // break;
200 //
201 // case YAML_SCALAR_TOKEN:
202 // yaml_free(token.data.scalar.value);
203 // break;
204 //
205 // default:
206 // break;
207 // }
208 //
209 // memset(token, 0, sizeof(yaml_token_t));
210 //}
211 //
212 ///*
213 // * Check if a string is a valid UTF-8 sequence.
214 // *
215 // * Check 'reader.c' for more details on UTF-8 encoding.
216 // */
217 //
218 //static int
219 //yaml_check_utf8(yaml_char_t *start, size_t length)
220 //{
221 // yaml_char_t *end = start+length;
222 // yaml_char_t *pointer = start;
223 //
224 // while (pointer < end) {
225 // unsigned char octet;
226 // unsigned int width;
227 // unsigned int value;
228 // size_t k;
229 //
230 // octet = pointer[0];
231 // width = (octet & 0x80) == 0x00 ? 1 :
232 // (octet & 0xE0) == 0xC0 ? 2 :
233 // (octet & 0xF0) == 0xE0 ? 3 :
234 // (octet & 0xF8) == 0xF0 ? 4 : 0;
235 // value = (octet & 0x80) == 0x00 ? octet & 0x7F :
236 // (octet & 0xE0) == 0xC0 ? octet & 0x1F :
237 // (octet & 0xF0) == 0xE0 ? octet & 0x0F :
238 // (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
239 // if (!width) return 0;
240 // if (pointer+width > end) return 0;
241 // for (k = 1; k < width; k ++) {
242 // octet = pointer[k];
243 // if ((octet & 0xC0) != 0x80) return 0;
244 // value = (value << 6) + (octet & 0x3F);
245 // }
246 // if (!((width == 1) ||
247 // (width == 2 && value >= 0x80) ||
248 // (width == 3 && value >= 0x800) ||
249 // (width == 4 && value >= 0x10000))) return 0;
250 //
251 // pointer += width;
252 // }
253 //
254 // return 1;
255 //}
256 //
257
258 // Create STREAM-START.
259 func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) {
260 *event = yaml_event_t{
261 typ: yaml_STREAM_START_EVENT,
262 encoding: encoding,
263 }
264 }
265
266 // Create STREAM-END.
267 func yaml_stream_end_event_initialize(event *yaml_event_t) {
268 *event = yaml_event_t{
269 typ: yaml_STREAM_END_EVENT,
270 }
271 }
272
273 // Create DOCUMENT-START.
274 func yaml_document_start_event_initialize(
275 event *yaml_event_t,
276 version_directive *yaml_version_directive_t,
277 tag_directives []yaml_tag_directive_t,
278 implicit bool,
279 ) {
280 *event = yaml_event_t{
281 typ: yaml_DOCUMENT_START_EVENT,
282 version_directive: version_directive,
283 tag_directives: tag_directives,
284 implicit: implicit,
285 }
286 }
287
288 // Create DOCUMENT-END.
289 func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {
290 *event = yaml_event_t{
291 typ: yaml_DOCUMENT_END_EVENT,
292 implicit: implicit,
293 }
294 }
295
296 ///*
297 // * Create ALIAS.
298 // */
299 //
300 //YAML_DECLARE(int)
301 //yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)
302 //{
303 // mark yaml_mark_t = { 0, 0, 0 }
304 // anchor_copy *yaml_char_t = NULL
305 //
306 // assert(event) // Non-NULL event object is expected.
307 // assert(anchor) // Non-NULL anchor is expected.
308 //
309 // if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0
310 //
311 // anchor_copy = yaml_strdup(anchor)
312 // if (!anchor_copy)
313 // return 0
314 //
315 // ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)
316 //
317 // return 1
318 //}
319
320 // Create SCALAR.
321 func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
322 *event = yaml_event_t{
323 typ: yaml_SCALAR_EVENT,
324 anchor: anchor,
325 tag: tag,
326 value: value,
327 implicit: plain_implicit,
328 quoted_implicit: quoted_implicit,
329 style: yaml_style_t(style),
330 }
331 return true
332 }
333
334 // Create SEQUENCE-START.
335 func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
336 *event = yaml_event_t{
337 typ: yaml_SEQUENCE_START_EVENT,
338 anchor: anchor,
339 tag: tag,
340 implicit: implicit,
341 style: yaml_style_t(style),
342 }
343 return true
344 }
345
346 // Create SEQUENCE-END.
347 func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
348 *event = yaml_event_t{
349 typ: yaml_SEQUENCE_END_EVENT,
350 }
351 return true
352 }
353
354 // Create MAPPING-START.
355 func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) {
356 *event = yaml_event_t{
357 typ: yaml_MAPPING_START_EVENT,
358 anchor: anchor,
359 tag: tag,
360 implicit: implicit,
361 style: yaml_style_t(style),
362 }
363 }
364
365 // Create MAPPING-END.
366 func yaml_mapping_end_event_initialize(event *yaml_event_t) {
367 *event = yaml_event_t{
368 typ: yaml_MAPPING_END_EVENT,
369 }
370 }
371
372 // Destroy an event object.
373 func yaml_event_delete(event *yaml_event_t) {
374 *event = yaml_event_t{}
375 }
376
377 ///*
378 // * Create a document object.
379 // */
380 //
381 //YAML_DECLARE(int)
382 //yaml_document_initialize(document *yaml_document_t,
383 // version_directive *yaml_version_directive_t,
384 // tag_directives_start *yaml_tag_directive_t,
385 // tag_directives_end *yaml_tag_directive_t,
386 // start_implicit int, end_implicit int)
387 //{
388 // struct {
389 // error yaml_error_type_t
390 // } context
391 // struct {
392 // start *yaml_node_t
393 // end *yaml_node_t
394 // top *yaml_node_t
395 // } nodes = { NULL, NULL, NULL }
396 // version_directive_copy *yaml_version_directive_t = NULL
397 // struct {
398 // start *yaml_tag_directive_t
399 // end *yaml_tag_directive_t
400 // top *yaml_tag_directive_t
401 // } tag_directives_copy = { NULL, NULL, NULL }
402 // value yaml_tag_directive_t = { NULL, NULL }
403 // mark yaml_mark_t = { 0, 0, 0 }
404 //
405 // assert(document) // Non-NULL document object is expected.
406 // assert((tag_directives_start && tag_directives_end) ||
407 // (tag_directives_start == tag_directives_end))
408 // // Valid tag directives are expected.
409 //
410 // if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
411 //
412 // if (version_directive) {
413 // version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
414 // if (!version_directive_copy) goto error
415 // version_directive_copy.major = version_directive.major
416 // version_directive_copy.minor = version_directive.minor
417 // }
418 //
419 // if (tag_directives_start != tag_directives_end) {
420 // tag_directive *yaml_tag_directive_t
421 // if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
422 // goto error
423 // for (tag_directive = tag_directives_start
424 // tag_directive != tag_directives_end; tag_directive ++) {
425 // assert(tag_directive.handle)
426 // assert(tag_directive.prefix)
427 // if (!yaml_check_utf8(tag_directive.handle,
428 // strlen((char *)tag_directive.handle)))
429 // goto error
430 // if (!yaml_check_utf8(tag_directive.prefix,
431 // strlen((char *)tag_directive.prefix)))
432 // goto error
433 // value.handle = yaml_strdup(tag_directive.handle)
434 // value.prefix = yaml_strdup(tag_directive.prefix)
435 // if (!value.handle || !value.prefix) goto error
436 // if (!PUSH(&context, tag_directives_copy, value))
437 // goto error
438 // value.handle = NULL
439 // value.prefix = NULL
440 // }
441 // }
442 //
443 // DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
444 // tag_directives_copy.start, tag_directives_copy.top,
445 // start_implicit, end_implicit, mark, mark)
446 //
447 // return 1
448 //
449 //error:
450 // STACK_DEL(&context, nodes)
451 // yaml_free(version_directive_copy)
452 // while (!STACK_EMPTY(&context, tag_directives_copy)) {
453 // value yaml_tag_directive_t = POP(&context, tag_directives_copy)
454 // yaml_free(value.handle)
455 // yaml_free(value.prefix)
456 // }
457 // STACK_DEL(&context, tag_directives_copy)
458 // yaml_free(value.handle)
459 // yaml_free(value.prefix)
460 //
461 // return 0
462 //}
463 //
464 ///*
465 // * Destroy a document object.
466 // */
467 //
468 //YAML_DECLARE(void)
469 //yaml_document_delete(document *yaml_document_t)
470 //{
471 // struct {
472 // error yaml_error_type_t
473 // } context
474 // tag_directive *yaml_tag_directive_t
475 //
476 // context.error = YAML_NO_ERROR // Eliminate a compiler warning.
477 //
478 // assert(document) // Non-NULL document object is expected.
479 //
480 // while (!STACK_EMPTY(&context, document.nodes)) {
481 // node yaml_node_t = POP(&context, document.nodes)
482 // yaml_free(node.tag)
483 // switch (node.type) {
484 // case YAML_SCALAR_NODE:
485 // yaml_free(node.data.scalar.value)
486 // break
487 // case YAML_SEQUENCE_NODE:
488 // STACK_DEL(&context, node.data.sequence.items)
489 // break
490 // case YAML_MAPPING_NODE:
491 // STACK_DEL(&context, node.data.mapping.pairs)
492 // break
493 // default:
494 // assert(0) // Should not happen.
495 // }
496 // }
497 // STACK_DEL(&context, document.nodes)
498 //
499 // yaml_free(document.version_directive)
500 // for (tag_directive = document.tag_directives.start
501 // tag_directive != document.tag_directives.end
502 // tag_directive++) {
503 // yaml_free(tag_directive.handle)
504 // yaml_free(tag_directive.prefix)
505 // }
506 // yaml_free(document.tag_directives.start)
507 //
508 // memset(document, 0, sizeof(yaml_document_t))
509 //}
510 //
511 ///**
512 // * Get a document node.
513 // */
514 //
515 //YAML_DECLARE(yaml_node_t *)
516 //yaml_document_get_node(document *yaml_document_t, index int)
517 //{
518 // assert(document) // Non-NULL document object is expected.
519 //
520 // if (index > 0 && document.nodes.start + index <= document.nodes.top) {
521 // return document.nodes.start + index - 1
522 // }
523 // return NULL
524 //}
525 //
526 ///**
527 // * Get the root object.
528 // */
529 //
530 //YAML_DECLARE(yaml_node_t *)
531 //yaml_document_get_root_node(document *yaml_document_t)
532 //{
533 // assert(document) // Non-NULL document object is expected.
534 //
535 // if (document.nodes.top != document.nodes.start) {
536 // return document.nodes.start
537 // }
538 // return NULL
539 //}
540 //
541 ///*
542 // * Add a scalar node to a document.
543 // */
544 //
545 //YAML_DECLARE(int)
546 //yaml_document_add_scalar(document *yaml_document_t,
547 // tag *yaml_char_t, value *yaml_char_t, length int,
548 // style yaml_scalar_style_t)
549 //{
550 // struct {
551 // error yaml_error_type_t
552 // } context
553 // mark yaml_mark_t = { 0, 0, 0 }
554 // tag_copy *yaml_char_t = NULL
555 // value_copy *yaml_char_t = NULL
556 // node yaml_node_t
557 //
558 // assert(document) // Non-NULL document object is expected.
559 // assert(value) // Non-NULL value is expected.
560 //
561 // if (!tag) {
562 // tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
563 // }
564 //
565 // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
566 // tag_copy = yaml_strdup(tag)
567 // if (!tag_copy) goto error
568 //
569 // if (length < 0) {
570 // length = strlen((char *)value)
571 // }
572 //
573 // if (!yaml_check_utf8(value, length)) goto error
574 // value_copy = yaml_malloc(length+1)
575 // if (!value_copy) goto error
576 // memcpy(value_copy, value, length)
577 // value_copy[length] = '\0'
578 //
579 // SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
580 // if (!PUSH(&context, document.nodes, node)) goto error
581 //
582 // return document.nodes.top - document.nodes.start
583 //
584 //error:
585 // yaml_free(tag_copy)
586 // yaml_free(value_copy)
587 //
588 // return 0
589 //}
590 //
591 ///*
592 // * Add a sequence node to a document.
593 // */
594 //
595 //YAML_DECLARE(int)
596 //yaml_document_add_sequence(document *yaml_document_t,
597 // tag *yaml_char_t, style yaml_sequence_style_t)
598 //{
599 // struct {
600 // error yaml_error_type_t
601 // } context
602 // mark yaml_mark_t = { 0, 0, 0 }
603 // tag_copy *yaml_char_t = NULL
604 // struct {
605 // start *yaml_node_item_t
606 // end *yaml_node_item_t
607 // top *yaml_node_item_t
608 // } items = { NULL, NULL, NULL }
609 // node yaml_node_t
610 //
611 // assert(document) // Non-NULL document object is expected.
612 //
613 // if (!tag) {
614 // tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
615 // }
616 //
617 // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
618 // tag_copy = yaml_strdup(tag)
619 // if (!tag_copy) goto error
620 //
621 // if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
622 //
623 // SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
624 // style, mark, mark)
625 // if (!PUSH(&context, document.nodes, node)) goto error
626 //
627 // return document.nodes.top - document.nodes.start
628 //
629 //error:
630 // STACK_DEL(&context, items)
631 // yaml_free(tag_copy)
632 //
633 // return 0
634 //}
635 //
636 ///*
637 // * Add a mapping node to a document.
638 // */
639 //
640 //YAML_DECLARE(int)
641 //yaml_document_add_mapping(document *yaml_document_t,
642 // tag *yaml_char_t, style yaml_mapping_style_t)
643 //{
644 // struct {
645 // error yaml_error_type_t
646 // } context
647 // mark yaml_mark_t = { 0, 0, 0 }
648 // tag_copy *yaml_char_t = NULL
649 // struct {
650 // start *yaml_node_pair_t
651 // end *yaml_node_pair_t
652 // top *yaml_node_pair_t
653 // } pairs = { NULL, NULL, NULL }
654 // node yaml_node_t
655 //
656 // assert(document) // Non-NULL document object is expected.
657 //
658 // if (!tag) {
659 // tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
660 // }
661 //
662 // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
663 // tag_copy = yaml_strdup(tag)
664 // if (!tag_copy) goto error
665 //
666 // if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
667 //
668 // MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
669 // style, mark, mark)
670 // if (!PUSH(&context, document.nodes, node)) goto error
671 //
672 // return document.nodes.top - document.nodes.start
673 //
674 //error:
675 // STACK_DEL(&context, pairs)
676 // yaml_free(tag_copy)
677 //
678 // return 0
679 //}
680 //
681 ///*
682 // * Append an item to a sequence node.
683 // */
684 //
685 //YAML_DECLARE(int)
686 //yaml_document_append_sequence_item(document *yaml_document_t,
687 // sequence int, item int)
688 //{
689 // struct {
690 // error yaml_error_type_t
691 // } context
692 //
693 // assert(document) // Non-NULL document is required.
694 // assert(sequence > 0
695 // && document.nodes.start + sequence <= document.nodes.top)
696 // // Valid sequence id is required.
697 // assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
698 // // A sequence node is required.
699 // assert(item > 0 && document.nodes.start + item <= document.nodes.top)
700 // // Valid item id is required.
701 //
702 // if (!PUSH(&context,
703 // document.nodes.start[sequence-1].data.sequence.items, item))
704 // return 0
705 //
706 // return 1
707 //}
708 //
709 ///*
710 // * Append a pair of a key and a value to a mapping node.
711 // */
712 //
713 //YAML_DECLARE(int)
714 //yaml_document_append_mapping_pair(document *yaml_document_t,
715 // mapping int, key int, value int)
716 //{
717 // struct {
718 // error yaml_error_type_t
719 // } context
720 //
721 // pair yaml_node_pair_t
722 //
723 // assert(document) // Non-NULL document is required.
724 // assert(mapping > 0
725 // && document.nodes.start + mapping <= document.nodes.top)
726 // // Valid mapping id is required.
727 // assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
728 // // A mapping node is required.
729 // assert(key > 0 && document.nodes.start + key <= document.nodes.top)
730 // // Valid key id is required.
731 // assert(value > 0 && document.nodes.start + value <= document.nodes.top)
732 // // Valid value id is required.
733 //
734 // pair.key = key
735 // pair.value = value
736 //
737 // if (!PUSH(&context,
738 // document.nodes.start[mapping-1].data.mapping.pairs, pair))
739 // return 0
740 //
741 // return 1
742 //}
743 //
744 //