contrib/libyaml/tests/example-deconstructor-alt.c

   1
   2 #include <yaml.h>
   3
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6
   7 int
   8 main(int argc, char *argv[])
   9 {
  10     int help = 0;
  11     int canonical = 0;
  12     int unicode = 0;
  13     int k;
  14     int done = 0;
  15
  16     yaml_parser_t parser;
  17     yaml_emitter_t emitter;
  18     yaml_event_t input_event;
  19     yaml_document_t output_document;
  20
  21     int root;
  22
  23     /* Clear the objects. */
  24
  25     memset(&parser, 0, sizeof(parser));
  26     memset(&emitter, 0, sizeof(emitter));
  27     memset(&input_event, 0, sizeof(input_event));
  28     memset(&output_document, 0, sizeof(output_document));
  29
  30     /* Analyze command line options. */
  31
  32     for (k = 1; k < argc; k ++)
  33     {
  34         if (strcmp(argv[k], "-h") == 0
  35                 || strcmp(argv[k], "--help") == 0) {
  36             help = 1;
  37         }
  38
  39         else if (strcmp(argv[k], "-c") == 0
  40                 || strcmp(argv[k], "--canonical") == 0) {
  41             canonical = 1;
  42         }
  43
  44         else if (strcmp(argv[k], "-u") == 0
  45                 || strcmp(argv[k], "--unicode") == 0) {
  46             unicode = 1;
  47         }
  48
  49         else {
  50             fprintf(stderr, "Unrecognized option: %s\n"
  51                     "Try `%s --help` for more information.\n",
  52                     argv[k], argv[0]);
  53             return 1;
  54         }
  55     }
  56
  57     /* Display the help string. */
  58
  59     if (help)
  60     {
  61         printf("%s <input\n"
  62                 "or\n%s -h | --help\nDeconstruct a YAML stream\n\nOptions:\n"
  63                 "-h, --help\t\tdisplay this help and exit\n"
  64                 "-c, --canonical\t\toutput in the canonical YAML format\n"
  65                 "-u, --unicode\t\toutput unescaped non-ASCII characters\n",
  66                 argv[0], argv[0]);
  67         return 0;
  68     }
  69
  70     /* Initialize the parser and emitter objects. */
  71
  72     if (!yaml_parser_initialize(&parser)) {
  73         fprintf(stderr, "Could not initialize the parser object\n");
  74         return 1;
  75     }
  76
  77     if (!yaml_emitter_initialize(&emitter)) {
  78         yaml_parser_delete(&parser);
  79         fprintf(stderr, "Could not inialize the emitter object\n");
  80         return 1;
  81     }
  82
  83     /* Set the parser parameters. */
  84
  85     yaml_parser_set_input_file(&parser, stdin);
  86
  87     /* Set the emitter parameters. */
  88
  89     yaml_emitter_set_output_file(&emitter, stdout);
  90
  91     yaml_emitter_set_canonical(&emitter, canonical);
  92     yaml_emitter_set_unicode(&emitter, unicode);
  93
  94     /* Create and emit the STREAM-START event. */
  95
  96     if (!yaml_emitter_open(&emitter))
  97         goto emitter_error;
  98
  99     /* Create a output_document object. */
 100
 101     if (!yaml_document_initialize(&output_document, NULL, NULL, NULL, 0, 0))
 102         goto document_error;
 103
 104     /* Create the root sequence. */
 105
 106     root = yaml_document_add_sequence(&output_document, NULL,
 107             YAML_BLOCK_SEQUENCE_STYLE);
 108     if (!root) goto document_error;
 109
 110     /* Loop through the input events. */
 111
 112     while (!done)
 113     {
 114         int properties, key, value, map, seq;
 115
 116         /* Get the next event. */
 117
 118         if (!yaml_parser_parse(&parser, &input_event))
 119             goto parser_error;
 120
 121         /* Check if this is the stream end. */
 122
 123         if (input_event.type == YAML_STREAM_END_EVENT) {
 124             done = 1;
 125         }
 126
 127         /* Create a mapping node and attach it to the root sequence. */
 128
 129         properties = yaml_document_add_mapping(&output_document, NULL,
 130                 YAML_BLOCK_MAPPING_STYLE);
 131         if (!properties) goto document_error;
 132         if (!yaml_document_append_sequence_item(&output_document,
 133                     root, properties)) goto document_error;
 134
 135         /* Analyze the event. */
 136
 137         switch (input_event.type)
 138         {
 139             case YAML_STREAM_START_EVENT:
 140
 141                 /* Add 'type': 'STREAM-START'. */
 142
 143                 key = yaml_document_add_scalar(&output_document, NULL,
 144                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 145                 if (!key) goto document_error;
 146                 value = yaml_document_add_scalar(&output_document, NULL,
 147                     "STREAM-START", -1, YAML_PLAIN_SCALAR_STYLE);
 148                 if (!value) goto document_error;
 149                 if (!yaml_document_append_mapping_pair(&output_document,
 150                             properties, key, value)) goto document_error;
 151
 152                 /* Add 'encoding': <encoding>. */
 153
 154                 if (input_event.data.stream_start.encoding)
 155                 {
 156                     yaml_encoding_t encoding
 157                         = input_event.data.stream_start.encoding;
 158
 159                     key = yaml_document_add_scalar(&output_document, NULL,
 160                         "encoding", -1, YAML_PLAIN_SCALAR_STYLE);
 161                     if (!key) goto document_error;
 162                     value = yaml_document_add_scalar(&output_document, NULL,
 163                             (encoding == YAML_UTF8_ENCODING ? "utf-8" :
 164                              encoding == YAML_UTF16LE_ENCODING ? "utf-16-le" :
 165                              encoding == YAML_UTF16BE_ENCODING ? "utf-16-be" :
 166                              "unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
 167                     if (!value) goto document_error;
 168                     if (!yaml_document_append_mapping_pair(&output_document,
 169                                 properties, key, value)) goto document_error;
 170                 }
 171
 172                 break;
 173
 174             case YAML_STREAM_END_EVENT:
 175
 176                 /* Add 'type': 'STREAM-END'. */
 177
 178                 key = yaml_document_add_scalar(&output_document, NULL,
 179                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 180                 if (!key) goto document_error;
 181                 value = yaml_document_add_scalar(&output_document, NULL,
 182                     "STREAM-END", -1, YAML_PLAIN_SCALAR_STYLE);
 183                 if (!value) goto document_error;
 184                 if (!yaml_document_append_mapping_pair(&output_document,
 185                             properties, key, value)) goto document_error;
 186
 187                 break;
 188
 189             case YAML_DOCUMENT_START_EVENT:
 190
 191                 /* Add 'type': 'DOCUMENT-START'. */
 192
 193                 key = yaml_document_add_scalar(&output_document, NULL,
 194                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 195                 if (!key) goto document_error;
 196                 value = yaml_document_add_scalar(&output_document, NULL,
 197                     "DOCUMENT-START", -1, YAML_PLAIN_SCALAR_STYLE);
 198                 if (!value) goto document_error;
 199                 if (!yaml_document_append_mapping_pair(&output_document,
 200                             properties, key, value)) goto document_error;
 201
 202                 /* Display the output_document version numbers. */
 203
 204                 if (input_event.data.document_start.version_directive)
 205                 {
 206                     yaml_version_directive_t *version
 207                         = input_event.data.document_start.version_directive;
 208                     char number[64];
 209
 210                     /* Add 'version': {}. */
 211
 212                     key = yaml_document_add_scalar(&output_document, NULL,
 213                         "version", -1, YAML_PLAIN_SCALAR_STYLE);
 214                     if (!key) goto document_error;
 215                     map = yaml_document_add_mapping(&output_document, NULL,
 216                             YAML_FLOW_MAPPING_STYLE);
 217                     if (!map) goto document_error;
 218                     if (!yaml_document_append_mapping_pair(&output_document,
 219                                 properties, key, map)) goto document_error;
 220
 221                     /* Add 'major': <number>. */
 222
 223                     key = yaml_document_add_scalar(&output_document, NULL,
 224                         "major", -1, YAML_PLAIN_SCALAR_STYLE);
 225                     if (!key) goto document_error;
 226                     sprintf(number, "%d", version->major);
 227                     value = yaml_document_add_scalar(&output_document, YAML_INT_TAG,
 228                         number, -1, YAML_PLAIN_SCALAR_STYLE);
 229                     if (!value) goto document_error;
 230                     if (!yaml_document_append_mapping_pair(&output_document,
 231                                 map, key, value)) goto document_error;
 232
 233                     /* Add 'minor': <number>. */
 234
 235                     key = yaml_document_add_scalar(&output_document, NULL,
 236                         "minor", -1, YAML_PLAIN_SCALAR_STYLE);
 237                     if (!key) goto document_error;
 238                     sprintf(number, "%d", version->minor);
 239                     value = yaml_document_add_scalar(&output_document, YAML_INT_TAG,
 240                         number, -1, YAML_PLAIN_SCALAR_STYLE);
 241                     if (!value) goto document_error;
 242                     if (!yaml_document_append_mapping_pair(&output_document,
 243                                 map, key, value)) goto document_error;
 244                 }
 245
 246                 /* Display the output_document tag directives. */
 247
 248                 if (input_event.data.document_start.tag_directives.start
 249                         != input_event.data.document_start.tag_directives.end)
 250                 {
 251                     yaml_tag_directive_t *tag;
 252
 253                     /* Add 'tags': []. */
 254
 255                     key = yaml_document_add_scalar(&output_document, NULL,
 256                         "tags", -1, YAML_PLAIN_SCALAR_STYLE);
 257                     if (!key) goto document_error;
 258                     seq = yaml_document_add_sequence(&output_document, NULL,
 259                             YAML_BLOCK_SEQUENCE_STYLE);
 260                     if (!seq) goto document_error;
 261                     if (!yaml_document_append_mapping_pair(&output_document,
 262                                 properties, key, seq)) goto document_error;
 263
 264                     for (tag = input_event.data.document_start.tag_directives.start;
 265                             tag != input_event.data.document_start.tag_directives.end;
 266                             tag ++)
 267                     {
 268                         /* Add {}. */
 269
 270                         map = yaml_document_add_mapping(&output_document, NULL,
 271                                 YAML_FLOW_MAPPING_STYLE);
 272                         if (!map) goto document_error;
 273                         if (!yaml_document_append_sequence_item(&output_document,
 274                                     seq, map)) goto document_error;
 275
 276                         /* Add 'handle': <handle>. */
 277
 278                         key = yaml_document_add_scalar(&output_document, NULL,
 279                             "handle", -1, YAML_PLAIN_SCALAR_STYLE);
 280                         if (!key) goto document_error;
 281                         value = yaml_document_add_scalar(&output_document, NULL,
 282                             tag->handle, -1, YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 283                         if (!value) goto document_error;
 284                         if (!yaml_document_append_mapping_pair(&output_document,
 285                                     map, key, value)) goto document_error;
 286
 287                         /* Add 'prefix': <prefix>. */
 288
 289                         key = yaml_document_add_scalar(&output_document, NULL,
 290                             "prefix", -1, YAML_PLAIN_SCALAR_STYLE);
 291                         if (!key) goto document_error;
 292                         value = yaml_document_add_scalar(&output_document, NULL,
 293                             tag->prefix, -1, YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 294                         if (!value) goto document_error;
 295                         if (!yaml_document_append_mapping_pair(&output_document,
 296                                     map, key, value)) goto document_error;
 297                     }
 298                 }
 299
 300                 /* Add 'implicit': <flag>. */
 301
 302                 key = yaml_document_add_scalar(&output_document, NULL,
 303                     "implicit", -1, YAML_PLAIN_SCALAR_STYLE);
 304                 if (!key) goto document_error;
 305                 value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
 306                         (input_event.data.document_start.implicit ?
 307                          "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
 308                 if (!value) goto document_error;
 309                 if (!yaml_document_append_mapping_pair(&output_document,
 310                             properties, key, value)) goto document_error;
 311
 312                 break;
 313
 314             case YAML_DOCUMENT_END_EVENT:
 315
 316                 /* Add 'type': 'DOCUMENT-END'. */
 317
 318                 key = yaml_document_add_scalar(&output_document, NULL,
 319                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 320                 if (!key) goto document_error;
 321                 value = yaml_document_add_scalar(&output_document, NULL,
 322                     "DOCUMENT-END", -1, YAML_PLAIN_SCALAR_STYLE);
 323                 if (!value) goto document_error;
 324                 if (!yaml_document_append_mapping_pair(&output_document,
 325                             properties, key, value)) goto document_error;
 326
 327                 /* Add 'implicit': <flag>. */
 328
 329                 key = yaml_document_add_scalar(&output_document, NULL,
 330                     "implicit", -1, YAML_PLAIN_SCALAR_STYLE);
 331                 if (!key) goto document_error;
 332                 value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
 333                         (input_event.data.document_end.implicit ?
 334                          "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
 335                 if (!value) goto document_error;
 336                 if (!yaml_document_append_mapping_pair(&output_document,
 337                             properties, key, value)) goto document_error;
 338
 339                 break;
 340
 341             case YAML_ALIAS_EVENT:
 342
 343                 /* Add 'type': 'ALIAS'. */
 344
 345                 key = yaml_document_add_scalar(&output_document, NULL,
 346                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 347                 if (!key) goto document_error;
 348                 value = yaml_document_add_scalar(&output_document, NULL,
 349                     "ALIAS", -1, YAML_PLAIN_SCALAR_STYLE);
 350                 if (!value) goto document_error;
 351                 if (!yaml_document_append_mapping_pair(&output_document,
 352                             properties, key, value)) goto document_error;
 353
 354                 /* Add 'anchor': <anchor>. */
 355
 356                 key = yaml_document_add_scalar(&output_document, NULL,
 357                     "anchor", -1, YAML_PLAIN_SCALAR_STYLE);
 358                 if (!key) goto document_error;
 359                 value = yaml_document_add_scalar(&output_document, NULL,
 360                         input_event.data.alias.anchor, -1,
 361                         YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 362                 if (!value) goto document_error;
 363                 if (!yaml_document_append_mapping_pair(&output_document,
 364                             properties, key, value)) goto document_error;
 365
 366                 break;
 367
 368             case YAML_SCALAR_EVENT:
 369
 370                 /* Add 'type': 'SCALAR'. */
 371
 372                 key = yaml_document_add_scalar(&output_document, NULL,
 373                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 374                 if (!key) goto document_error;
 375                 value = yaml_document_add_scalar(&output_document, NULL,
 376                     "SCALAR", -1, YAML_PLAIN_SCALAR_STYLE);
 377                 if (!value) goto document_error;
 378                 if (!yaml_document_append_mapping_pair(&output_document,
 379                             properties, key, value)) goto document_error;
 380
 381                 /* Add 'anchor': <anchor>. */
 382
 383                 if (input_event.data.scalar.anchor)
 384                 {
 385                     key = yaml_document_add_scalar(&output_document, NULL,
 386                         "anchor", -1, YAML_PLAIN_SCALAR_STYLE);
 387                     if (!key) goto document_error;
 388                     value = yaml_document_add_scalar(&output_document, NULL,
 389                             input_event.data.scalar.anchor, -1,
 390                             YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 391                     if (!value) goto document_error;
 392                     if (!yaml_document_append_mapping_pair(&output_document,
 393                                 properties, key, value)) goto document_error;
 394                 }
 395
 396                 /* Add 'tag': <tag>. */
 397
 398                 if (input_event.data.scalar.tag)
 399                 {
 400                     key = yaml_document_add_scalar(&output_document, NULL,
 401                         "tag", -1, YAML_PLAIN_SCALAR_STYLE);
 402                     if (!key) goto document_error;
 403                     value = yaml_document_add_scalar(&output_document, NULL,
 404                             input_event.data.scalar.tag, -1,
 405                             YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 406                     if (!value) goto document_error;
 407                     if (!yaml_document_append_mapping_pair(&output_document,
 408                                 properties, key, value)) goto document_error;
 409                 }
 410
 411                 /* Add 'value': <value>. */
 412
 413                 key = yaml_document_add_scalar(&output_document, NULL,
 414                     "value", -1, YAML_PLAIN_SCALAR_STYLE);
 415                 if (!key) goto document_error;
 416                 value = yaml_document_add_scalar(&output_document, NULL,
 417                         input_event.data.scalar.value,
 418                         input_event.data.scalar.length,
 419                         YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 420                 if (!value) goto document_error;
 421                 if (!yaml_document_append_mapping_pair(&output_document,
 422                             properties, key, value)) goto document_error;
 423
 424                 /* Display if the scalar tag is implicit. */
 425
 426                 /* Add 'implicit': {} */
 427
 428                 key = yaml_document_add_scalar(&output_document, NULL,
 429                     "version", -1, YAML_PLAIN_SCALAR_STYLE);
 430                 if (!key) goto document_error;
 431                 map = yaml_document_add_mapping(&output_document, NULL,
 432                         YAML_FLOW_MAPPING_STYLE);
 433                 if (!map) goto document_error;
 434                 if (!yaml_document_append_mapping_pair(&output_document,
 435                             properties, key, map)) goto document_error;
 436
 437                 /* Add 'plain': <flag>. */
 438
 439                 key = yaml_document_add_scalar(&output_document, NULL,
 440                     "plain", -1, YAML_PLAIN_SCALAR_STYLE);
 441                 if (!key) goto document_error;
 442                 value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
 443                         (input_event.data.scalar.plain_implicit ?
 444                          "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
 445                 if (!value) goto document_error;
 446                 if (!yaml_document_append_mapping_pair(&output_document,
 447                             map, key, value)) goto document_error;
 448
 449                 /* Add 'quoted': <flag>. */
 450
 451                 key = yaml_document_add_scalar(&output_document, NULL,
 452                     "quoted", -1, YAML_PLAIN_SCALAR_STYLE);
 453                 if (!key) goto document_error;
 454                 value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
 455                         (input_event.data.scalar.quoted_implicit ?
 456                          "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
 457                 if (!value) goto document_error;
 458                 if (!yaml_document_append_mapping_pair(&output_document,
 459                             map, key, value)) goto document_error;
 460
 461                 /* Display the style information. */
 462
 463                 if (input_event.data.scalar.style)
 464                 {
 465                     yaml_scalar_style_t style = input_event.data.scalar.style;
 466
 467                     /* Add 'style': <style>. */
 468
 469                     key = yaml_document_add_scalar(&output_document, NULL,
 470                         "style", -1, YAML_PLAIN_SCALAR_STYLE);
 471                     if (!key) goto document_error;
 472                     value = yaml_document_add_scalar(&output_document, NULL,
 473                             (style == YAML_PLAIN_SCALAR_STYLE ? "plain" :
 474                              style == YAML_SINGLE_QUOTED_SCALAR_STYLE ?
 475                                     "single-quoted" :
 476                              style == YAML_DOUBLE_QUOTED_SCALAR_STYLE ?
 477                                     "double-quoted" :
 478                              style == YAML_LITERAL_SCALAR_STYLE ? "literal" :
 479                              style == YAML_FOLDED_SCALAR_STYLE ? "folded" :
 480                              "unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
 481                     if (!value) goto document_error;
 482                     if (!yaml_document_append_mapping_pair(&output_document,
 483                                 properties, key, value)) goto document_error;
 484                 }
 485
 486                 break;
 487
 488             case YAML_SEQUENCE_START_EVENT:
 489
 490                 /* Add 'type': 'SEQUENCE-START'. */
 491
 492                 key = yaml_document_add_scalar(&output_document, NULL,
 493                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 494                 if (!key) goto document_error;
 495                 value = yaml_document_add_scalar(&output_document, NULL,
 496                     "SEQUENCE-START", -1, YAML_PLAIN_SCALAR_STYLE);
 497                 if (!value) goto document_error;
 498                 if (!yaml_document_append_mapping_pair(&output_document,
 499                             properties, key, value)) goto document_error;
 500
 501                 /* Add 'anchor': <anchor>. */
 502
 503                 if (input_event.data.sequence_start.anchor)
 504                 {
 505                     key = yaml_document_add_scalar(&output_document, NULL,
 506                         "anchor", -1, YAML_PLAIN_SCALAR_STYLE);
 507                     if (!key) goto document_error;
 508                     value = yaml_document_add_scalar(&output_document, NULL,
 509                             input_event.data.sequence_start.anchor, -1,
 510                             YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 511                     if (!value) goto document_error;
 512                     if (!yaml_document_append_mapping_pair(&output_document,
 513                                 properties, key, value)) goto document_error;
 514                 }
 515
 516                 /* Add 'tag': <tag>. */
 517
 518                 if (input_event.data.sequence_start.tag)
 519                 {
 520                     key = yaml_document_add_scalar(&output_document, NULL,
 521                         "tag", -1, YAML_PLAIN_SCALAR_STYLE);
 522                     if (!key) goto document_error;
 523                     value = yaml_document_add_scalar(&output_document, NULL,
 524                             input_event.data.sequence_start.tag, -1,
 525                             YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 526                     if (!value) goto document_error;
 527                     if (!yaml_document_append_mapping_pair(&output_document,
 528                                 properties, key, value)) goto document_error;
 529                 }
 530
 531                 /* Add 'implicit': <flag>. */
 532
 533                 key = yaml_document_add_scalar(&output_document, NULL,
 534                     "implicit", -1, YAML_PLAIN_SCALAR_STYLE);
 535                 if (!key) goto document_error;
 536                 value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
 537                         (input_event.data.sequence_start.implicit ?
 538                          "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
 539                 if (!value) goto document_error;
 540                 if (!yaml_document_append_mapping_pair(&output_document,
 541                             properties, key, value)) goto document_error;
 542
 543                 /* Display the style information. */
 544
 545                 if (input_event.data.sequence_start.style)
 546                 {
 547                     yaml_sequence_style_t style
 548                         = input_event.data.sequence_start.style;
 549
 550                     /* Add 'style': <style>. */
 551
 552                     key = yaml_document_add_scalar(&output_document, NULL,
 553                         "style", -1, YAML_PLAIN_SCALAR_STYLE);
 554                     if (!key) goto document_error;
 555                     value = yaml_document_add_scalar(&output_document, NULL,
 556                             (style == YAML_BLOCK_SEQUENCE_STYLE ? "block" :
 557                              style == YAML_FLOW_SEQUENCE_STYLE ? "flow" :
 558                              "unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
 559                     if (!value) goto document_error;
 560                     if (!yaml_document_append_mapping_pair(&output_document,
 561                                 properties, key, value)) goto document_error;
 562                 }
 563
 564                 break;
 565
 566             case YAML_SEQUENCE_END_EVENT:
 567
 568                 /* Add 'type': 'SEQUENCE-END'. */
 569
 570                 key = yaml_document_add_scalar(&output_document, NULL,
 571                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 572                 if (!key) goto document_error;
 573                 value = yaml_document_add_scalar(&output_document, NULL,
 574                     "SEQUENCE-END", -1, YAML_PLAIN_SCALAR_STYLE);
 575                 if (!value) goto document_error;
 576                 if (!yaml_document_append_mapping_pair(&output_document,
 577                             properties, key, value)) goto document_error;
 578
 579                 break;
 580
 581             case YAML_MAPPING_START_EVENT:
 582
 583                 /* Add 'type': 'MAPPING-START'. */
 584
 585                 key = yaml_document_add_scalar(&output_document, NULL,
 586                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 587                 if (!key) goto document_error;
 588                 value = yaml_document_add_scalar(&output_document, NULL,
 589                     "MAPPING-START", -1, YAML_PLAIN_SCALAR_STYLE);
 590                 if (!value) goto document_error;
 591                 if (!yaml_document_append_mapping_pair(&output_document,
 592                             properties, key, value)) goto document_error;
 593
 594                 /* Add 'anchor': <anchor>. */
 595
 596                 if (input_event.data.mapping_start.anchor)
 597                 {
 598                     key = yaml_document_add_scalar(&output_document, NULL,
 599                         "anchor", -1, YAML_PLAIN_SCALAR_STYLE);
 600                     if (!key) goto document_error;
 601                     value = yaml_document_add_scalar(&output_document, NULL,
 602                             input_event.data.mapping_start.anchor, -1,
 603                             YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 604                     if (!value) goto document_error;
 605                     if (!yaml_document_append_mapping_pair(&output_document,
 606                                 properties, key, value)) goto document_error;
 607                 }
 608
 609                 /* Add 'tag': <tag>. */
 610
 611                 if (input_event.data.mapping_start.tag)
 612                 {
 613                     key = yaml_document_add_scalar(&output_document, NULL,
 614                         "tag", -1, YAML_PLAIN_SCALAR_STYLE);
 615                     if (!key) goto document_error;
 616                     value = yaml_document_add_scalar(&output_document, NULL,
 617                             input_event.data.mapping_start.tag, -1,
 618                             YAML_DOUBLE_QUOTED_SCALAR_STYLE);
 619                     if (!value) goto document_error;
 620                     if (!yaml_document_append_mapping_pair(&output_document,
 621                                 properties, key, value)) goto document_error;
 622                 }
 623
 624                 /* Add 'implicit': <flag>. */
 625
 626                 key = yaml_document_add_scalar(&output_document, NULL,
 627                     "implicit", -1, YAML_PLAIN_SCALAR_STYLE);
 628                 if (!key) goto document_error;
 629                 value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
 630                         (input_event.data.mapping_start.implicit ?
 631                          "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
 632                 if (!value) goto document_error;
 633                 if (!yaml_document_append_mapping_pair(&output_document,
 634                             properties, key, value)) goto document_error;
 635
 636                 /* Display the style information. */
 637
 638                 if (input_event.data.sequence_start.style)
 639                 {
 640                     yaml_sequence_style_t style
 641                         = input_event.data.mapping_start.style;
 642
 643                     /* Add 'style': <style>. */
 644
 645                     key = yaml_document_add_scalar(&output_document, NULL,
 646                         "style", -1, YAML_PLAIN_SCALAR_STYLE);
 647                     if (!key) goto document_error;
 648                     value = yaml_document_add_scalar(&output_document, NULL,
 649                             (style == YAML_BLOCK_MAPPING_STYLE ? "block" :
 650                              style == YAML_FLOW_MAPPING_STYLE ? "flow" :
 651                              "unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
 652                     if (!value) goto document_error;
 653                     if (!yaml_document_append_mapping_pair(&output_document,
 654                                 properties, key, value)) goto document_error;
 655                 }
 656
 657                 break;
 658
 659             case YAML_MAPPING_END_EVENT:
 660
 661                 /* Add 'type': 'MAPPING-END'. */
 662
 663                 key = yaml_document_add_scalar(&output_document, NULL,
 664                     "type", -1, YAML_PLAIN_SCALAR_STYLE);
 665                 if (!key) goto document_error;
 666                 value = yaml_document_add_scalar(&output_document, NULL,
 667                     "MAPPING-END", -1, YAML_PLAIN_SCALAR_STYLE);
 668                 if (!value) goto document_error;
 669                 if (!yaml_document_append_mapping_pair(&output_document,
 670                             properties, key, value)) goto document_error;
 671
 672                 break;
 673
 674             default:
 675                 /* It couldn't really happen. */
 676                 break;
 677         }
 678
 679         /* Delete the event object. */
 680
 681         yaml_event_delete(&input_event);
 682     }
 683
 684     if (!yaml_emitter_dump(&emitter, &output_document))
 685         goto emitter_error;
 686     if (!yaml_emitter_close(&emitter))
 687         goto emitter_error;
 688
 689     yaml_parser_delete(&parser);
 690     yaml_emitter_delete(&emitter);
 691
 692     return 0;
 693
 694 parser_error:
 695
 696     /* Display a parser error message. */
 697
 698     switch (parser.error)
 699     {
 700         case YAML_MEMORY_ERROR:
 701             fprintf(stderr, "Memory error: Not enough memory for parsing\n");
 702             break;
 703
 704         case YAML_READER_ERROR:
 705             if (parser.problem_value != -1) {
 706                 fprintf(stderr, "Reader error: %s: #%X at %d\n", parser.problem,
 707                         parser.problem_value, parser.problem_offset);
 708             }
 709             else {
 710                 fprintf(stderr, "Reader error: %s at %d\n", parser.problem,
 711                         parser.problem_offset);
 712             }
 713             break;
 714
 715         case YAML_SCANNER_ERROR:
 716             if (parser.context) {
 717                 fprintf(stderr, "Scanner error: %s at line %d, column %d\n"
 718                         "%s at line %d, column %d\n", parser.context,
 719                         parser.context_mark.line+1, parser.context_mark.column+1,
 720                         parser.problem, parser.problem_mark.line+1,
 721                         parser.problem_mark.column+1);
 722             }
 723             else {
 724                 fprintf(stderr, "Scanner error: %s at line %d, column %d\n",
 725                         parser.problem, parser.problem_mark.line+1,
 726                         parser.problem_mark.column+1);
 727             }
 728             break;
 729
 730         case YAML_PARSER_ERROR:
 731             if (parser.context) {
 732                 fprintf(stderr, "Parser error: %s at line %d, column %d\n"
 733                         "%s at line %d, column %d\n", parser.context,
 734                         parser.context_mark.line+1, parser.context_mark.column+1,
 735                         parser.problem, parser.problem_mark.line+1,
 736                         parser.problem_mark.column+1);
 737             }
 738             else {
 739                 fprintf(stderr, "Parser error: %s at line %d, column %d\n",
 740                         parser.problem, parser.problem_mark.line+1,
 741                         parser.problem_mark.column+1);
 742             }
 743             break;
 744
 745         default:
 746             /* Couldn't happen. */
 747             fprintf(stderr, "Internal error\n");
 748             break;
 749     }
 750
 751     yaml_event_delete(&input_event);
 752     yaml_document_delete(&output_document);
 753     yaml_parser_delete(&parser);
 754     yaml_emitter_delete(&emitter);
 755
 756     return 1;
 757
 758 emitter_error:
 759
 760     /* Display an emitter error message. */
 761
 762     switch (emitter.error)
 763     {
 764         case YAML_MEMORY_ERROR:
 765             fprintf(stderr, "Memory error: Not enough memory for emitting\n");
 766             break;
 767
 768         case YAML_WRITER_ERROR:
 769             fprintf(stderr, "Writer error: %s\n", emitter.problem);
 770             break;
 771
 772         case YAML_EMITTER_ERROR:
 773             fprintf(stderr, "Emitter error: %s\n", emitter.problem);
 774             break;
 775
 776         default:
 777             /* Couldn't happen. */
 778             fprintf(stderr, "Internal error\n");
 779             break;
 780     }
 781
 782     yaml_event_delete(&input_event);
 783     yaml_document_delete(&output_document);
 784     yaml_parser_delete(&parser);
 785     yaml_emitter_delete(&emitter);
 786
 787     return 1;
 788
 789 document_error:
 790
 791     fprintf(stderr, "Memory error: Not enough memory for creating a document\n");
 792
 793     yaml_event_delete(&input_event);
 794     yaml_document_delete(&output_document);
 795     yaml_parser_delete(&parser);
 796     yaml_emitter_delete(&emitter);
 797
 798     return 1;
 799 }
 800