1package yaml 2 3import ( 4 "io" 5) 6 7func 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. 27func 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. 36func yaml_parser_delete(parser *yaml_parser_t) { 37 *parser = yaml_parser_t{} 38} 39 40// String read handler. 41func 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. 51func 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. 56func 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. 66func 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. 75func 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 82var disableLineWrapping = false 83 84// Create a new emitter object. 85func 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. 98func yaml_emitter_delete(emitter *yaml_emitter_t) { 99 *emitter = yaml_emitter_t{} 100} 101 102// String write handler. 103func 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. 110func 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. 116func 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. 125func 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. 134func 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. 142func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) { 143 emitter.canonical = canonical 144} 145 146//// Set the indentation increment. 147func 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. 155func 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. 163func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) { 164 emitter.unicode = unicode 165} 166 167// Set the preferred line break character. 168func 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. 259func 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. 267func 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. 274func 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. 289func 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. 321func 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. 335func 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. 347func 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. 355func 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. 366func 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. 373func 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