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