cmd/bpa-operator/vendor/gopkg.in/yaml.v2/apic.go

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