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 // 745