source: package_tags/libyaml/0.1.1-1~andersk1/tests/example-deconstructor-alt.c @ 2451

Last change on this file since 2451 was 898, checked in by hartmans, 16 years ago

Add pyyaml and libyaml packages
backported from lenny.
There is discussion about how these should go in the repository; these are added in this form
in order to make forward progress.

File size: 32.4 KB
Line 
1
2#include <yaml.h>
3
4#include <stdlib.h>
5#include <stdio.h>
6
7int
8main(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
694parser_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
758emitter_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
789document_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
Note: See TracBrowser for help on using the repository browser.