contrib/libyaml/src/parser.c

   1
   2 /*
   3  * The parser implements the following grammar:
   4  *
   5  * stream               ::= STREAM-START implicit_document? explicit_document* STREAM-END
   6  * implicit_document    ::= block_node DOCUMENT-END*
   7  * explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
   8  * block_node_or_indentless_sequence    ::=
   9  *                          ALIAS
  10  *                          | properties (block_content | indentless_block_sequence)?
  11  *                          | block_content
  12  *                          | indentless_block_sequence
  13  * block_node           ::= ALIAS
  14  *                          | properties block_content?
  15  *                          | block_content
  16  * flow_node            ::= ALIAS
  17  *                          | properties flow_content?
  18  *                          | flow_content
  19  * properties           ::= TAG ANCHOR? | ANCHOR TAG?
  20  * block_content        ::= block_collection | flow_collection | SCALAR
  21  * flow_content         ::= flow_collection | SCALAR
  22  * block_collection     ::= block_sequence | block_mapping
  23  * flow_collection      ::= flow_sequence | flow_mapping
  24  * block_sequence       ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
  25  * indentless_sequence  ::= (BLOCK-ENTRY block_node?)+
  26  * block_mapping        ::= BLOCK-MAPPING_START
  27  *                          ((KEY block_node_or_indentless_sequence?)?
  28  *                          (VALUE block_node_or_indentless_sequence?)?)*
  29  *                          BLOCK-END
  30  * flow_sequence        ::= FLOW-SEQUENCE-START
  31  *                          (flow_sequence_entry FLOW-ENTRY)*
  32  *                          flow_sequence_entry?
  33  *                          FLOW-SEQUENCE-END
  34  * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
  35  * flow_mapping         ::= FLOW-MAPPING-START
  36  *                          (flow_mapping_entry FLOW-ENTRY)*
  37  *                          flow_mapping_entry?
  38  *                          FLOW-MAPPING-END
  39  * flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
  40  */
  41
  42 #include "yaml_private.h"
  43
  44 /*
  45  * Peek the next token in the token queue.
  46  */
  47
  48 #define PEEK_TOKEN(parser)                                                      \
  49     ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ?       \
  50         parser->tokens.head : NULL)
  51
  52 /*
  53  * Remove the next token from the queue (must be called after PEEK_TOKEN).
  54  */
  55
  56 #define SKIP_TOKEN(parser)                                                      \
  57     (parser->token_available = 0,                                               \
  58      parser->tokens_parsed ++,                                                  \
  59      parser->stream_end_produced =                                              \
  60         (parser->tokens.head->type == YAML_STREAM_END_TOKEN),                   \
  61      parser->tokens.head ++)
  62
  63 /*
  64  * Public API declarations.
  65  */
  66
  67 YAML_DECLARE(int)
  68 yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
  69
  70 /*
  71  * Error handling.
  72  */
  73
  74 static int
  75 yaml_parser_set_parser_error(yaml_parser_t *parser,
  76         const char *problem, yaml_mark_t problem_mark);
  77
  78 static int
  79 yaml_parser_set_parser_error_context(yaml_parser_t *parser,
  80         const char *context, yaml_mark_t context_mark,
  81         const char *problem, yaml_mark_t problem_mark);
  82
  83 /*
  84  * State functions.
  85  */
  86
  87 static int
  88 yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event);
  89
  90 static int
  91 yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event);
  92
  93 static int
  94 yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
  95         int implicit);
  96
  97 static int
  98 yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event);
  99
 100 static int
 101 yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event);
 102
 103 static int
 104 yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
 105         int block, int indentless_sequence);
 106
 107 static int
 108 yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
 109         yaml_event_t *event, int first);
 110
 111 static int
 112 yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
 113         yaml_event_t *event);
 114
 115 static int
 116 yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
 117         yaml_event_t *event, int first);
 118
 119 static int
 120 yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
 121         yaml_event_t *event);
 122
 123 static int
 124 yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
 125         yaml_event_t *event, int first);
 126
 127 static int
 128 yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
 129         yaml_event_t *event);
 130
 131 static int
 132 yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
 133         yaml_event_t *event);
 134
 135 static int
 136 yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
 137         yaml_event_t *event);
 138
 139 static int
 140 yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
 141         yaml_event_t *event, int first);
 142
 143 static int
 144 yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
 145         yaml_event_t *event, int empty);
 146
 147 /*
 148  * Utility functions.
 149  */
 150
 151 static int
 152 yaml_parser_process_empty_scalar(yaml_parser_t *parser,
 153         yaml_event_t *event, yaml_mark_t mark);
 154
 155 static int
 156 yaml_parser_process_directives(yaml_parser_t *parser,
 157         yaml_version_directive_t **version_directive_ref,
 158         yaml_tag_directive_t **tag_directives_start_ref,
 159         yaml_tag_directive_t **tag_directives_end_ref);
 160
 161 static int
 162 yaml_parser_append_tag_directive(yaml_parser_t *parser,
 163         yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark);
 164
 165 /*
 166  * Get the next event.
 167  */
 168
 169 YAML_DECLARE(int)
 170 yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event)
 171 {
 172     assert(parser);     /* Non-NULL parser object is expected. */
 173     assert(event);      /* Non-NULL event object is expected. */
 174
 175     /* Erase the event object. */
 176
 177     memset(event, 0, sizeof(yaml_event_t));
 178
 179     /* No events after the end of the stream or error. */
 180
 181     if (parser->stream_end_produced || parser->error ||
 182             parser->state == YAML_PARSE_END_STATE) {
 183         return 1;
 184     }
 185
 186     /* Generate the next event. */
 187
 188     return yaml_parser_state_machine(parser, event);
 189 }
 190
 191 /*
 192  * Set parser error.
 193  */
 194
 195 static int
 196 yaml_parser_set_parser_error(yaml_parser_t *parser,
 197         const char *problem, yaml_mark_t problem_mark)
 198 {
 199     parser->error = YAML_PARSER_ERROR;
 200     parser->problem = problem;
 201     parser->problem_mark = problem_mark;
 202
 203     return 0;
 204 }
 205
 206 static int
 207 yaml_parser_set_parser_error_context(yaml_parser_t *parser,
 208         const char *context, yaml_mark_t context_mark,
 209         const char *problem, yaml_mark_t problem_mark)
 210 {
 211     parser->error = YAML_PARSER_ERROR;
 212     parser->context = context;
 213     parser->context_mark = context_mark;
 214     parser->problem = problem;
 215     parser->problem_mark = problem_mark;
 216
 217     return 0;
 218 }
 219
 220
 221 /*
 222  * State dispatcher.
 223  */
 224
 225 static int
 226 yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event)
 227 {
 228     switch (parser->state)
 229     {
 230         case YAML_PARSE_STREAM_START_STATE:
 231             return yaml_parser_parse_stream_start(parser, event);
 232
 233         case YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE:
 234             return yaml_parser_parse_document_start(parser, event, 1);
 235
 236         case YAML_PARSE_DOCUMENT_START_STATE:
 237             return yaml_parser_parse_document_start(parser, event, 0);
 238
 239         case YAML_PARSE_DOCUMENT_CONTENT_STATE:
 240             return yaml_parser_parse_document_content(parser, event);
 241
 242         case YAML_PARSE_DOCUMENT_END_STATE:
 243             return yaml_parser_parse_document_end(parser, event);
 244
 245         case YAML_PARSE_BLOCK_NODE_STATE:
 246             return yaml_parser_parse_node(parser, event, 1, 0);
 247
 248         case YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
 249             return yaml_parser_parse_node(parser, event, 1, 1);
 250
 251         case YAML_PARSE_FLOW_NODE_STATE:
 252             return yaml_parser_parse_node(parser, event, 0, 0);
 253
 254         case YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
 255             return yaml_parser_parse_block_sequence_entry(parser, event, 1);
 256
 257         case YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
 258             return yaml_parser_parse_block_sequence_entry(parser, event, 0);
 259
 260         case YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
 261             return yaml_parser_parse_indentless_sequence_entry(parser, event);
 262
 263         case YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
 264             return yaml_parser_parse_block_mapping_key(parser, event, 1);
 265
 266         case YAML_PARSE_BLOCK_MAPPING_KEY_STATE:
 267             return yaml_parser_parse_block_mapping_key(parser, event, 0);
 268
 269         case YAML_PARSE_BLOCK_MAPPING_VALUE_STATE:
 270             return yaml_parser_parse_block_mapping_value(parser, event);
 271
 272         case YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
 273             return yaml_parser_parse_flow_sequence_entry(parser, event, 1);
 274
 275         case YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
 276             return yaml_parser_parse_flow_sequence_entry(parser, event, 0);
 277
 278         case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
 279             return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event);
 280
 281         case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
 282             return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event);
 283
 284         case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
 285             return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event);
 286
 287         case YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
 288             return yaml_parser_parse_flow_mapping_key(parser, event, 1);
 289
 290         case YAML_PARSE_FLOW_MAPPING_KEY_STATE:
 291             return yaml_parser_parse_flow_mapping_key(parser, event, 0);
 292
 293         case YAML_PARSE_FLOW_MAPPING_VALUE_STATE:
 294             return yaml_parser_parse_flow_mapping_value(parser, event, 0);
 295
 296         case YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
 297             return yaml_parser_parse_flow_mapping_value(parser, event, 1);
 298
 299         default:
 300             assert(1);      /* Invalid state. */
 301     }
 302
 303     return 0;
 304 }
 305
 306 /*
 307  * Parse the production:
 308  * stream   ::= STREAM-START implicit_document? explicit_document* STREAM-END
 309  *              ************
 310  */
 311
 312 static int
 313 yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event)
 314 {
 315     yaml_token_t *token;
 316
 317     token = PEEK_TOKEN(parser);
 318     if (!token) return 0;
 319
 320     if (token->type != YAML_STREAM_START_TOKEN) {
 321         return yaml_parser_set_parser_error(parser,
 322                 "did not find expected <stream-start>", token->start_mark);
 323     }
 324
 325     parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
 326     STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding,
 327             token->start_mark, token->start_mark);
 328     SKIP_TOKEN(parser);
 329
 330     return 1;
 331 }
 332
 333 /*
 334  * Parse the productions:
 335  * implicit_document    ::= block_node DOCUMENT-END*
 336  *                          *
 337  * explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
 338  *                          *************************
 339  */
 340
 341 static int
 342 yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
 343         int implicit)
 344 {
 345     yaml_token_t *token;
 346     yaml_version_directive_t *version_directive = NULL;
 347     struct {
 348         yaml_tag_directive_t *start;
 349         yaml_tag_directive_t *end;
 350     } tag_directives = { NULL, NULL };
 351
 352     token = PEEK_TOKEN(parser);
 353     if (!token) return 0;
 354
 355     /* Parse extra document end indicators. */
 356
 357     if (!implicit)
 358     {
 359         while (token->type == YAML_DOCUMENT_END_TOKEN) {
 360             SKIP_TOKEN(parser);
 361             token = PEEK_TOKEN(parser);
 362             if (!token) return 0;
 363         }
 364     }
 365
 366     /* Parse an implicit document. */
 367
 368     if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&
 369             token->type != YAML_TAG_DIRECTIVE_TOKEN &&
 370             token->type != YAML_DOCUMENT_START_TOKEN &&
 371             token->type != YAML_STREAM_END_TOKEN)
 372     {
 373         if (!yaml_parser_process_directives(parser, NULL, NULL, NULL))
 374             return 0;
 375         if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
 376             return 0;
 377         parser->state = YAML_PARSE_BLOCK_NODE_STATE;
 378         DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1,
 379                 token->start_mark, token->start_mark);
 380         return 1;
 381     }
 382
 383     /* Parse an explicit document. */
 384
 385     else if (token->type != YAML_STREAM_END_TOKEN)
 386     {
 387         yaml_mark_t start_mark, end_mark;
 388         start_mark = token->start_mark;
 389         if (!yaml_parser_process_directives(parser, &version_directive,
 390                     &tag_directives.start, &tag_directives.end))
 391             return 0;
 392         token = PEEK_TOKEN(parser);
 393         if (!token) goto error;
 394         if (token->type != YAML_DOCUMENT_START_TOKEN) {
 395             yaml_parser_set_parser_error(parser,
 396                     "did not find expected <document start>", token->start_mark);
 397             goto error;
 398         }
 399         if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
 400             goto error;
 401         parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
 402         end_mark = token->end_mark;
 403         DOCUMENT_START_EVENT_INIT(*event, version_directive,
 404                 tag_directives.start, tag_directives.end, 0,
 405                 start_mark, end_mark);
 406         SKIP_TOKEN(parser);
 407         version_directive = NULL;
 408         tag_directives.start = tag_directives.end = NULL;
 409         return 1;
 410     }
 411
 412     /* Parse the stream end. */
 413
 414     else
 415     {
 416         parser->state = YAML_PARSE_END_STATE;
 417         STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
 418         SKIP_TOKEN(parser);
 419         return 1;
 420     }
 421
 422 error:
 423     yaml_free(version_directive);
 424     while (tag_directives.start != tag_directives.end) {
 425         yaml_free(tag_directives.end[-1].handle);
 426         yaml_free(tag_directives.end[-1].prefix);
 427         tag_directives.end --;
 428     }
 429     yaml_free(tag_directives.start);
 430     return 0;
 431 }
 432
 433 /*
 434  * Parse the productions:
 435  * explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
 436  *                                                    ***********
 437  */
 438
 439 static int
 440 yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event)
 441 {
 442     yaml_token_t *token;
 443
 444     token = PEEK_TOKEN(parser);
 445     if (!token) return 0;
 446
 447     if (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
 448             token->type == YAML_TAG_DIRECTIVE_TOKEN ||
 449             token->type == YAML_DOCUMENT_START_TOKEN ||
 450             token->type == YAML_DOCUMENT_END_TOKEN ||
 451             token->type == YAML_STREAM_END_TOKEN) {
 452         parser->state = POP(parser, parser->states);
 453         return yaml_parser_process_empty_scalar(parser, event,
 454                 token->start_mark);
 455     }
 456     else {
 457         return yaml_parser_parse_node(parser, event, 1, 0);
 458     }
 459 }
 460
 461 /*
 462  * Parse the productions:
 463  * implicit_document    ::= block_node DOCUMENT-END*
 464  *                                     *************
 465  * explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
 466  *                                                                *************
 467  */
 468
 469 static int
 470 yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event)
 471 {
 472     yaml_token_t *token;
 473     yaml_mark_t start_mark, end_mark;
 474     int implicit = 1;
 475
 476     token = PEEK_TOKEN(parser);
 477     if (!token) return 0;
 478
 479     start_mark = end_mark = token->start_mark;
 480
 481     if (token->type == YAML_DOCUMENT_END_TOKEN) {
 482         end_mark = token->end_mark;
 483         SKIP_TOKEN(parser);
 484         implicit = 0;
 485     }
 486
 487     while (!STACK_EMPTY(parser, parser->tag_directives)) {
 488         yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
 489         yaml_free(tag_directive.handle);
 490         yaml_free(tag_directive.prefix);
 491     }
 492
 493     parser->state = YAML_PARSE_DOCUMENT_START_STATE;
 494     DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark);
 495
 496     return 1;
 497 }
 498
 499 /*
 500  * Parse the productions:
 501  * block_node_or_indentless_sequence    ::=
 502  *                          ALIAS
 503  *                          *****
 504  *                          | properties (block_content | indentless_block_sequence)?
 505  *                            **********  *
 506  *                          | block_content | indentless_block_sequence
 507  *                            *
 508  * block_node           ::= ALIAS
 509  *                          *****
 510  *                          | properties block_content?
 511  *                            ********** *
 512  *                          | block_content
 513  *                            *
 514  * flow_node            ::= ALIAS
 515  *                          *****
 516  *                          | properties flow_content?
 517  *                            ********** *
 518  *                          | flow_content
 519  *                            *
 520  * properties           ::= TAG ANCHOR? | ANCHOR TAG?
 521  *                          *************************
 522  * block_content        ::= block_collection | flow_collection | SCALAR
 523  *                                                               ******
 524  * flow_content         ::= flow_collection | SCALAR
 525  *                                            ******
 526  */
 527
 528 static int
 529 yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
 530         int block, int indentless_sequence)
 531 {
 532     yaml_token_t *token;
 533     yaml_char_t *anchor = NULL;
 534     yaml_char_t *tag_handle = NULL;
 535     yaml_char_t *tag_suffix = NULL;
 536     yaml_char_t *tag = NULL;
 537     yaml_mark_t start_mark, end_mark, tag_mark;
 538     int implicit;
 539
 540     token = PEEK_TOKEN(parser);
 541     if (!token) return 0;
 542
 543     if (token->type == YAML_ALIAS_TOKEN)
 544     {
 545         parser->state = POP(parser, parser->states);
 546         ALIAS_EVENT_INIT(*event, token->data.alias.value,
 547                 token->start_mark, token->end_mark);
 548         SKIP_TOKEN(parser);
 549         return 1;
 550     }
 551
 552     else
 553     {
 554         start_mark = end_mark = token->start_mark;
 555
 556         if (token->type == YAML_ANCHOR_TOKEN)
 557         {
 558             anchor = token->data.anchor.value;
 559             start_mark = token->start_mark;
 560             end_mark = token->end_mark;
 561             SKIP_TOKEN(parser);
 562             token = PEEK_TOKEN(parser);
 563             if (!token) goto error;
 564             if (token->type == YAML_TAG_TOKEN)
 565             {
 566                 tag_handle = token->data.tag.handle;
 567                 tag_suffix = token->data.tag.suffix;
 568                 tag_mark = token->start_mark;
 569                 end_mark = token->end_mark;
 570                 SKIP_TOKEN(parser);
 571                 token = PEEK_TOKEN(parser);
 572                 if (!token) goto error;
 573             }
 574         }
 575         else if (token->type == YAML_TAG_TOKEN)
 576         {
 577             tag_handle = token->data.tag.handle;
 578             tag_suffix = token->data.tag.suffix;
 579             start_mark = tag_mark = token->start_mark;
 580             end_mark = token->end_mark;
 581             SKIP_TOKEN(parser);
 582             token = PEEK_TOKEN(parser);
 583             if (!token) goto error;
 584             if (token->type == YAML_ANCHOR_TOKEN)
 585             {
 586                 anchor = token->data.anchor.value;
 587                 end_mark = token->end_mark;
 588                 SKIP_TOKEN(parser);
 589                 token = PEEK_TOKEN(parser);
 590                 if (!token) goto error;
 591             }
 592         }
 593
 594         if (tag_handle) {
 595             if (!*tag_handle) {
 596                 tag = tag_suffix;
 597                 yaml_free(tag_handle);
 598                 tag_handle = tag_suffix = NULL;
 599             }
 600             else {
 601                 yaml_tag_directive_t *tag_directive;
 602                 for (tag_directive = parser->tag_directives.start;
 603                         tag_directive != parser->tag_directives.top;
 604                         tag_directive ++) {
 605                     if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
 606                         size_t prefix_len = strlen((char *)tag_directive->prefix);
 607                         size_t suffix_len = strlen((char *)tag_suffix);
 608                         tag = yaml_malloc(prefix_len+suffix_len+1);
 609                         if (!tag) {
 610                             parser->error = YAML_MEMORY_ERROR;
 611                             goto error;
 612                         }
 613                         memcpy(tag, tag_directive->prefix, prefix_len);
 614                         memcpy(tag+prefix_len, tag_suffix, suffix_len);
 615                         tag[prefix_len+suffix_len] = '\0';
 616                         yaml_free(tag_handle);
 617                         yaml_free(tag_suffix);
 618                         tag_handle = tag_suffix = NULL;
 619                         break;
 620                     }
 621                 }
 622                 if (!tag) {
 623                     yaml_parser_set_parser_error_context(parser,
 624                             "while parsing a node", start_mark,
 625                             "found undefined tag handle", tag_mark);
 626                     goto error;
 627                 }
 628             }
 629         }
 630
 631         implicit = (!tag || !*tag);
 632         if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) {
 633             end_mark = token->end_mark;
 634             parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
 635             SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
 636                     YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
 637             return 1;
 638         }
 639         else {
 640             if (token->type == YAML_SCALAR_TOKEN) {
 641                 int plain_implicit = 0;
 642                 int quoted_implicit = 0;
 643                 end_mark = token->end_mark;
 644                 if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag)
 645                         || (tag && strcmp((char *)tag, "!") == 0)) {
 646                     plain_implicit = 1;
 647                 }
 648                 else if (!tag) {
 649                     quoted_implicit = 1;
 650                 }
 651                 parser->state = POP(parser, parser->states);
 652                 SCALAR_EVENT_INIT(*event, anchor, tag,
 653                         token->data.scalar.value, token->data.scalar.length,
 654                         plain_implicit, quoted_implicit,
 655                         token->data.scalar.style, start_mark, end_mark);
 656                 SKIP_TOKEN(parser);
 657                 return 1;
 658             }
 659             else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) {
 660                 end_mark = token->end_mark;
 661                 parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
 662                 SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
 663                         YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark);
 664                 return 1;
 665             }
 666             else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) {
 667                 end_mark = token->end_mark;
 668                 parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
 669                 MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
 670                         YAML_FLOW_MAPPING_STYLE, start_mark, end_mark);
 671                 return 1;
 672             }
 673             else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) {
 674                 end_mark = token->end_mark;
 675                 parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
 676                 SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
 677                         YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
 678                 return 1;
 679             }
 680             else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) {
 681                 end_mark = token->end_mark;
 682                 parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
 683                 MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
 684                         YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark);
 685                 return 1;
 686             }
 687             else if (anchor || tag) {
 688                 yaml_char_t *value = yaml_malloc(1);
 689                 if (!value) {
 690                     parser->error = YAML_MEMORY_ERROR;
 691                     goto error;
 692                 }
 693                 value[0] = '\0';
 694                 parser->state = POP(parser, parser->states);
 695                 SCALAR_EVENT_INIT(*event, anchor, tag, value, 0,
 696                         implicit, 0, YAML_PLAIN_SCALAR_STYLE,
 697                         start_mark, end_mark);
 698                 return 1;
 699             }
 700             else {
 701                 yaml_parser_set_parser_error_context(parser,
 702                         (block ? "while parsing a block node"
 703                          : "while parsing a flow node"), start_mark,
 704                         "did not find expected node content", token->start_mark);
 705                 goto error;
 706             }
 707         }
 708     }
 709
 710 error:
 711     yaml_free(anchor);
 712     yaml_free(tag_handle);
 713     yaml_free(tag_suffix);
 714     yaml_free(tag);
 715
 716     return 0;
 717 }
 718
 719 /*
 720  * Parse the productions:
 721  * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
 722  *                    ********************  *********** *             *********
 723  */
 724
 725 static int
 726 yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
 727         yaml_event_t *event, int first)
 728 {
 729     yaml_token_t *token;
 730
 731     if (first) {
 732         token = PEEK_TOKEN(parser);
 733         if (!PUSH(parser, parser->marks, token->start_mark))
 734             return 0;
 735         SKIP_TOKEN(parser);
 736     }
 737
 738     token = PEEK_TOKEN(parser);
 739     if (!token) return 0;
 740
 741     if (token->type == YAML_BLOCK_ENTRY_TOKEN)
 742     {
 743         yaml_mark_t mark = token->end_mark;
 744         SKIP_TOKEN(parser);
 745         token = PEEK_TOKEN(parser);
 746         if (!token) return 0;
 747         if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
 748                 token->type != YAML_BLOCK_END_TOKEN) {
 749             if (!PUSH(parser, parser->states,
 750                         YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE))
 751                 return 0;
 752             return yaml_parser_parse_node(parser, event, 1, 0);
 753         }
 754         else {
 755             parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
 756             return yaml_parser_process_empty_scalar(parser, event, mark);
 757         }
 758     }
 759
 760     else if (token->type == YAML_BLOCK_END_TOKEN)
 761     {
 762         yaml_mark_t dummy_mark;     /* Used to eliminate a compiler warning. */
 763         parser->state = POP(parser, parser->states);
 764         dummy_mark = POP(parser, parser->marks);
 765         SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
 766         SKIP_TOKEN(parser);
 767         return 1;
 768     }
 769
 770     else
 771     {
 772         return yaml_parser_set_parser_error_context(parser,
 773                 "while parsing a block collection", POP(parser, parser->marks),
 774                 "did not find expected '-' indicator", token->start_mark);
 775     }
 776 }
 777
 778 /*
 779  * Parse the productions:
 780  * indentless_sequence  ::= (BLOCK-ENTRY block_node?)+
 781  *                           *********** *
 782  */
 783
 784 static int
 785 yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
 786         yaml_event_t *event)
 787 {
 788     yaml_token_t *token;
 789
 790     token = PEEK_TOKEN(parser);
 791     if (!token) return 0;
 792
 793     if (token->type == YAML_BLOCK_ENTRY_TOKEN)
 794     {
 795         yaml_mark_t mark = token->end_mark;
 796         SKIP_TOKEN(parser);
 797         token = PEEK_TOKEN(parser);
 798         if (!token) return 0;
 799         if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
 800                 token->type != YAML_KEY_TOKEN &&
 801                 token->type != YAML_VALUE_TOKEN &&
 802                 token->type != YAML_BLOCK_END_TOKEN) {
 803             if (!PUSH(parser, parser->states,
 804                         YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE))
 805                 return 0;
 806             return yaml_parser_parse_node(parser, event, 1, 0);
 807         }
 808         else {
 809             parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
 810             return yaml_parser_process_empty_scalar(parser, event, mark);
 811         }
 812     }
 813
 814     else
 815     {
 816         parser->state = POP(parser, parser->states);
 817         SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
 818         return 1;
 819     }
 820 }
 821
 822 /*
 823  * Parse the productions:
 824  * block_mapping        ::= BLOCK-MAPPING_START
 825  *                          *******************
 826  *                          ((KEY block_node_or_indentless_sequence?)?
 827  *                            *** *
 828  *                          (VALUE block_node_or_indentless_sequence?)?)*
 829  *
 830  *                          BLOCK-END
 831  *                          *********
 832  */
 833
 834 static int
 835 yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
 836         yaml_event_t *event, int first)
 837 {
 838     yaml_token_t *token;
 839
 840     if (first) {
 841         token = PEEK_TOKEN(parser);
 842         if (!PUSH(parser, parser->marks, token->start_mark))
 843             return 0;
 844         SKIP_TOKEN(parser);
 845     }
 846
 847     token = PEEK_TOKEN(parser);
 848     if (!token) return 0;
 849
 850     if (token->type == YAML_KEY_TOKEN)
 851     {
 852         yaml_mark_t mark = token->end_mark;
 853         SKIP_TOKEN(parser);
 854         token = PEEK_TOKEN(parser);
 855         if (!token) return 0;
 856         if (token->type != YAML_KEY_TOKEN &&
 857                 token->type != YAML_VALUE_TOKEN &&
 858                 token->type != YAML_BLOCK_END_TOKEN) {
 859             if (!PUSH(parser, parser->states,
 860                         YAML_PARSE_BLOCK_MAPPING_VALUE_STATE))
 861                 return 0;
 862             return yaml_parser_parse_node(parser, event, 1, 1);
 863         }
 864         else {
 865             parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
 866             return yaml_parser_process_empty_scalar(parser, event, mark);
 867         }
 868     }
 869
 870     else if (token->type == YAML_BLOCK_END_TOKEN)
 871     {
 872         yaml_mark_t dummy_mark;     /* Used to eliminate a compiler warning. */
 873         parser->state = POP(parser, parser->states);
 874         dummy_mark = POP(parser, parser->marks);
 875         MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
 876         SKIP_TOKEN(parser);
 877         return 1;
 878     }
 879
 880     else
 881     {
 882         return yaml_parser_set_parser_error_context(parser,
 883                 "while parsing a block mapping", POP(parser, parser->marks),
 884                 "did not find expected key", token->start_mark);
 885     }
 886 }
 887
 888 /*
 889  * Parse the productions:
 890  * block_mapping        ::= BLOCK-MAPPING_START
 891  *
 892  *                          ((KEY block_node_or_indentless_sequence?)?
 893  *
 894  *                          (VALUE block_node_or_indentless_sequence?)?)*
 895  *                           ***** *
 896  *                          BLOCK-END
 897  *
 898  */
 899
 900 static int
 901 yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
 902         yaml_event_t *event)
 903 {
 904     yaml_token_t *token;
 905
 906     token = PEEK_TOKEN(parser);
 907     if (!token) return 0;
 908
 909     if (token->type == YAML_VALUE_TOKEN)
 910     {
 911         yaml_mark_t mark = token->end_mark;
 912         SKIP_TOKEN(parser);
 913         token = PEEK_TOKEN(parser);
 914         if (!token) return 0;
 915         if (token->type != YAML_KEY_TOKEN &&
 916                 token->type != YAML_VALUE_TOKEN &&
 917                 token->type != YAML_BLOCK_END_TOKEN) {
 918             if (!PUSH(parser, parser->states,
 919                         YAML_PARSE_BLOCK_MAPPING_KEY_STATE))
 920                 return 0;
 921             return yaml_parser_parse_node(parser, event, 1, 1);
 922         }
 923         else {
 924             parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
 925             return yaml_parser_process_empty_scalar(parser, event, mark);
 926         }
 927     }
 928
 929     else
 930     {
 931         parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
 932         return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
 933     }
 934 }
 935
 936 /*
 937  * Parse the productions:
 938  * flow_sequence        ::= FLOW-SEQUENCE-START
 939  *                          *******************
 940  *                          (flow_sequence_entry FLOW-ENTRY)*
 941  *                           *                   **********
 942  *                          flow_sequence_entry?
 943  *                          *
 944  *                          FLOW-SEQUENCE-END
 945  *                          *****************
 946  * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 947  *                          *
 948  */
 949
 950 static int
 951 yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
 952         yaml_event_t *event, int first)
 953 {
 954     yaml_token_t *token;
 955     yaml_mark_t dummy_mark;     /* Used to eliminate a compiler warning. */
 956
 957     if (first) {
 958         token = PEEK_TOKEN(parser);
 959         if (!PUSH(parser, parser->marks, token->start_mark))
 960             return 0;
 961         SKIP_TOKEN(parser);
 962     }
 963
 964     token = PEEK_TOKEN(parser);
 965     if (!token) return 0;
 966
 967     if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN)
 968     {
 969         if (!first) {
 970             if (token->type == YAML_FLOW_ENTRY_TOKEN) {
 971                 SKIP_TOKEN(parser);
 972                 token = PEEK_TOKEN(parser);
 973                 if (!token) return 0;
 974             }
 975             else {
 976                 return yaml_parser_set_parser_error_context(parser,
 977                         "while parsing a flow sequence", POP(parser, parser->marks),
 978                         "did not find expected ',' or ']'", token->start_mark);
 979             }
 980         }
 981
 982         if (token->type == YAML_KEY_TOKEN) {
 983             parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE;
 984             MAPPING_START_EVENT_INIT(*event, NULL, NULL,
 985                     1, YAML_FLOW_MAPPING_STYLE,
 986                     token->start_mark, token->end_mark);
 987             SKIP_TOKEN(parser);
 988             return 1;
 989         }
 990
 991         else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
 992             if (!PUSH(parser, parser->states,
 993                         YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE))
 994                 return 0;
 995             return yaml_parser_parse_node(parser, event, 0, 0);
 996         }
 997     }
 998
 999     parser->state = POP(parser, parser->states);
1000     dummy_mark = POP(parser, parser->marks);
1001     SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
1002     SKIP_TOKEN(parser);
1003     return 1;
1004 }
1005
1006 /*
1007  * Parse the productions:
1008  * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1009  *                                      *** *
1010  */
1011
1012 static int
1013 yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
1014         yaml_event_t *event)
1015 {
1016     yaml_token_t *token;
1017
1018     token = PEEK_TOKEN(parser);
1019     if (!token) return 0;
1020
1021     if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN
1022             && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
1023         if (!PUSH(parser, parser->states,
1024                     YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE))
1025             return 0;
1026         return yaml_parser_parse_node(parser, event, 0, 0);
1027     }
1028     else {
1029         yaml_mark_t mark = token->end_mark;
1030         SKIP_TOKEN(parser);
1031         parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
1032         return yaml_parser_process_empty_scalar(parser, event, mark);
1033     }
1034 }
1035
1036 /*
1037  * Parse the productions:
1038  * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1039  *                                                      ***** *
1040  */
1041
1042 static int
1043 yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
1044         yaml_event_t *event)
1045 {
1046     yaml_token_t *token;
1047
1048     token = PEEK_TOKEN(parser);
1049     if (!token) return 0;
1050
1051     if (token->type == YAML_VALUE_TOKEN) {
1052         SKIP_TOKEN(parser);
1053         token = PEEK_TOKEN(parser);
1054         if (!token) return 0;
1055         if (token->type != YAML_FLOW_ENTRY_TOKEN
1056                 && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
1057             if (!PUSH(parser, parser->states,
1058                         YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE))
1059                 return 0;
1060             return yaml_parser_parse_node(parser, event, 0, 0);
1061         }
1062     }
1063     parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
1064     return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
1065 }
1066
1067 /*
1068  * Parse the productions:
1069  * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1070  *                                                                      *
1071  */
1072
1073 static int
1074 yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
1075         yaml_event_t *event)
1076 {
1077     yaml_token_t *token;
1078
1079     token = PEEK_TOKEN(parser);
1080     if (!token) return 0;
1081
1082     parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
1083
1084     MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
1085     return 1;
1086 }
1087
1088 /*
1089  * Parse the productions:
1090  * flow_mapping         ::= FLOW-MAPPING-START
1091  *                          ******************
1092  *                          (flow_mapping_entry FLOW-ENTRY)*
1093  *                           *                  **********
1094  *                          flow_mapping_entry?
1095  *                          ******************
1096  *                          FLOW-MAPPING-END
1097  *                          ****************
1098  * flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1099  *                          *           *** *
1100  */
1101
1102 static int
1103 yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
1104         yaml_event_t *event, int first)
1105 {
1106     yaml_token_t *token;
1107     yaml_mark_t dummy_mark;     /* Used to eliminate a compiler warning. */
1108
1109     if (first) {
1110         token = PEEK_TOKEN(parser);
1111         if (!PUSH(parser, parser->marks, token->start_mark))
1112             return 0;
1113         SKIP_TOKEN(parser);
1114     }
1115
1116     token = PEEK_TOKEN(parser);
1117     if (!token) return 0;
1118
1119     if (token->type != YAML_FLOW_MAPPING_END_TOKEN)
1120     {
1121         if (!first) {
1122             if (token->type == YAML_FLOW_ENTRY_TOKEN) {
1123                 SKIP_TOKEN(parser);
1124                 token = PEEK_TOKEN(parser);
1125                 if (!token) return 0;
1126             }
1127             else {
1128                 return yaml_parser_set_parser_error_context(parser,
1129                         "while parsing a flow mapping", POP(parser, parser->marks),
1130                         "did not find expected ',' or '}'", token->start_mark);
1131             }
1132         }
1133
1134         if (token->type == YAML_KEY_TOKEN) {
1135             SKIP_TOKEN(parser);
1136             token = PEEK_TOKEN(parser);
1137             if (!token) return 0;
1138             if (token->type != YAML_VALUE_TOKEN
1139                     && token->type != YAML_FLOW_ENTRY_TOKEN
1140                     && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1141                 if (!PUSH(parser, parser->states,
1142                             YAML_PARSE_FLOW_MAPPING_VALUE_STATE))
1143                     return 0;
1144                 return yaml_parser_parse_node(parser, event, 0, 0);
1145             }
1146             else {
1147                 parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
1148                 return yaml_parser_process_empty_scalar(parser, event,
1149                         token->start_mark);
1150             }
1151         }
1152         else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1153             if (!PUSH(parser, parser->states,
1154                         YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE))
1155                 return 0;
1156             return yaml_parser_parse_node(parser, event, 0, 0);
1157         }
1158     }
1159
1160     parser->state = POP(parser, parser->states);
1161     dummy_mark = POP(parser, parser->marks);
1162     MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
1163     SKIP_TOKEN(parser);
1164     return 1;
1165 }
1166
1167 /*
1168  * Parse the productions:
1169  * flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1170  *                                   *                  ***** *
1171  */
1172
1173 static int
1174 yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
1175         yaml_event_t *event, int empty)
1176 {
1177     yaml_token_t *token;
1178
1179     token = PEEK_TOKEN(parser);
1180     if (!token) return 0;
1181
1182     if (empty) {
1183         parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1184         return yaml_parser_process_empty_scalar(parser, event,
1185                 token->start_mark);
1186     }
1187
1188     if (token->type == YAML_VALUE_TOKEN) {
1189         SKIP_TOKEN(parser);
1190         token = PEEK_TOKEN(parser);
1191         if (!token) return 0;
1192         if (token->type != YAML_FLOW_ENTRY_TOKEN
1193                 && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1194             if (!PUSH(parser, parser->states,
1195                         YAML_PARSE_FLOW_MAPPING_KEY_STATE))
1196                 return 0;
1197             return yaml_parser_parse_node(parser, event, 0, 0);
1198         }
1199     }
1200
1201     parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1202     return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
1203 }
1204
1205 /*
1206  * Generate an empty scalar event.
1207  */
1208
1209 static int
1210 yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event,
1211         yaml_mark_t mark)
1212 {
1213     yaml_char_t *value;
1214
1215     value = yaml_malloc(1);
1216     if (!value) {
1217         parser->error = YAML_MEMORY_ERROR;
1218         return 0;
1219     }
1220     value[0] = '\0';
1221
1222     SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0,
1223             1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark);
1224
1225     return 1;
1226 }
1227
1228 /*
1229  * Parse directives.
1230  */
1231
1232 static int
1233 yaml_parser_process_directives(yaml_parser_t *parser,
1234         yaml_version_directive_t **version_directive_ref,
1235         yaml_tag_directive_t **tag_directives_start_ref,
1236         yaml_tag_directive_t **tag_directives_end_ref)
1237 {
1238     yaml_tag_directive_t default_tag_directives[] = {
1239         {(yaml_char_t *)"!", (yaml_char_t *)"!"},
1240         {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
1241         {NULL, NULL}
1242     };
1243     yaml_tag_directive_t *default_tag_directive;
1244     yaml_version_directive_t *version_directive = NULL;
1245     struct {
1246         yaml_tag_directive_t *start;
1247         yaml_tag_directive_t *end;
1248         yaml_tag_directive_t *top;
1249     } tag_directives = { NULL, NULL, NULL };
1250     yaml_token_t *token;
1251
1252     if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))
1253         goto error;
1254
1255     token = PEEK_TOKEN(parser);
1256     if (!token) goto error;
1257
1258     while (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
1259             token->type == YAML_TAG_DIRECTIVE_TOKEN)
1260     {
1261         if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) {
1262             if (version_directive) {
1263                 yaml_parser_set_parser_error(parser,
1264                         "found duplicate %YAML directive", token->start_mark);
1265                 goto error;
1266             }
1267             if (token->data.version_directive.major != 1
1268                     || token->data.version_directive.minor != 1) {
1269                 yaml_parser_set_parser_error(parser,
1270                         "found incompatible YAML document", token->start_mark);
1271                 goto error;
1272             }
1273             version_directive = yaml_malloc(sizeof(yaml_version_directive_t));
1274             if (!version_directive) {
1275                 parser->error = YAML_MEMORY_ERROR;
1276                 goto error;
1277             }
1278             version_directive->major = token->data.version_directive.major;
1279             version_directive->minor = token->data.version_directive.minor;
1280         }
1281
1282         else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
1283             yaml_tag_directive_t value;
1284             value.handle = token->data.tag_directive.handle;
1285             value.prefix = token->data.tag_directive.prefix;
1286
1287             if (!yaml_parser_append_tag_directive(parser, value, 0,
1288                         token->start_mark))
1289                 goto error;
1290             if (!PUSH(parser, tag_directives, value))
1291                 goto error;
1292         }
1293
1294         SKIP_TOKEN(parser);
1295         token = PEEK_TOKEN(parser);
1296         if (!token) goto error;
1297     }
1298
1299     for (default_tag_directive = default_tag_directives;
1300             default_tag_directive->handle; default_tag_directive++) {
1301         if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1,
1302                     token->start_mark))
1303             goto error;
1304     }
1305
1306     if (version_directive_ref) {
1307         *version_directive_ref = version_directive;
1308     }
1309     if (tag_directives_start_ref) {
1310         if (STACK_EMPTY(parser, tag_directives)) {
1311             *tag_directives_start_ref = *tag_directives_end_ref = NULL;
1312             STACK_DEL(parser, tag_directives);
1313         }
1314         else {
1315             *tag_directives_start_ref = tag_directives.start;
1316             *tag_directives_end_ref = tag_directives.top;
1317         }
1318     }
1319     else {
1320         STACK_DEL(parser, tag_directives);
1321     }
1322
1323     return 1;
1324
1325 error:
1326     yaml_free(version_directive);
1327     while (!STACK_EMPTY(parser, tag_directives)) {
1328         yaml_tag_directive_t tag_directive = POP(parser, tag_directives);
1329         yaml_free(tag_directive.handle);
1330         yaml_free(tag_directive.prefix);
1331     }
1332     STACK_DEL(parser, tag_directives);
1333     return 0;
1334 }
1335
1336 /*
1337  * Append a tag directive to the directives stack.
1338  */
1339
1340 static int
1341 yaml_parser_append_tag_directive(yaml_parser_t *parser,
1342         yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
1343 {
1344     yaml_tag_directive_t *tag_directive;
1345     yaml_tag_directive_t copy = { NULL, NULL };
1346
1347     for (tag_directive = parser->tag_directives.start;
1348             tag_directive != parser->tag_directives.top; tag_directive ++) {
1349         if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
1350             if (allow_duplicates)
1351                 return 1;
1352             return yaml_parser_set_parser_error(parser,
1353                     "found duplicate %TAG directive", mark);
1354         }
1355     }
1356
1357     copy.handle = yaml_strdup(value.handle);
1358     copy.prefix = yaml_strdup(value.prefix);
1359     if (!copy.handle || !copy.prefix) {
1360         parser->error = YAML_MEMORY_ERROR;
1361         goto error;
1362     }
1363
1364     if (!PUSH(parser, parser->tag_directives, copy))
1365         goto error;
1366
1367     return 1;
1368
1369 error:
1370     yaml_free(copy.handle);
1371     yaml_free(copy.prefix);
1372     return 0;
1373 }
1374