contrib/libyaml/src/dumper.c

   1
   2 #include "yaml_private.h"
   3
   4 /*
   5  * API functions.
   6  */
   7
   8 YAML_DECLARE(int)
   9 yaml_emitter_open(yaml_emitter_t *emitter);
  10
  11 YAML_DECLARE(int)
  12 yaml_emitter_close(yaml_emitter_t *emitter);
  13
  14 YAML_DECLARE(int)
  15 yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
  16
  17 /*
  18  * Clean up functions.
  19  */
  20
  21 static void
  22 yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter);
  23
  24 /*
  25  * Anchor functions.
  26  */
  27
  28 static void
  29 yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index);
  30
  31 static yaml_char_t *
  32 yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id);
  33
  34
  35 /*
  36  * Serialize functions.
  37  */
  38
  39 static int
  40 yaml_emitter_dump_node(yaml_emitter_t *emitter, int index);
  41
  42 static int
  43 yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor);
  44
  45 static int
  46 yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
  47         yaml_char_t *anchor);
  48
  49 static int
  50 yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
  51         yaml_char_t *anchor);
  52
  53 static int
  54 yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
  55         yaml_char_t *anchor);
  56
  57 /*
  58  * Issue a STREAM-START event.
  59  */
  60
  61 YAML_DECLARE(int)
  62 yaml_emitter_open(yaml_emitter_t *emitter)
  63 {
  64     yaml_event_t event;
  65     yaml_mark_t mark = { 0, 0, 0 };
  66
  67     assert(emitter);            /* Non-NULL emitter object is required. */
  68     assert(!emitter->opened);   /* Emitter should not be opened yet. */
  69
  70     STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark);
  71
  72     if (!yaml_emitter_emit(emitter, &event)) {
  73         return 0;
  74     }
  75
  76     emitter->opened = 1;
  77
  78     return 1;
  79 }
  80
  81 /*
  82  * Issue a STREAM-END event.
  83  */
  84
  85 YAML_DECLARE(int)
  86 yaml_emitter_close(yaml_emitter_t *emitter)
  87 {
  88     yaml_event_t event;
  89     yaml_mark_t mark = { 0, 0, 0 };
  90
  91     assert(emitter);            /* Non-NULL emitter object is required. */
  92     assert(emitter->opened);    /* Emitter should be opened. */
  93
  94     if (emitter->closed) return 1;
  95
  96     STREAM_END_EVENT_INIT(event, mark, mark);
  97
  98     if (!yaml_emitter_emit(emitter, &event)) {
  99         return 0;
 100     }
 101
 102     emitter->closed = 1;
 103
 104     return 1;
 105 }
 106
 107 /*
 108  * Dump a YAML document.
 109  */
 110
 111 YAML_DECLARE(int)
 112 yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
 113 {
 114     yaml_event_t event;
 115     yaml_mark_t mark = { 0, 0, 0 };
 116
 117     assert(emitter);            /* Non-NULL emitter object is required. */
 118     assert(document);           /* Non-NULL emitter object is expected. */
 119
 120     emitter->document = document;
 121
 122     if (!emitter->opened) {
 123         if (!yaml_emitter_open(emitter)) goto error;
 124     }
 125
 126     if (STACK_EMPTY(emitter, document->nodes)) {
 127         if (!yaml_emitter_close(emitter)) goto error;
 128         yaml_emitter_delete_document_and_anchors(emitter);
 129         return 1;
 130     }
 131
 132     assert(emitter->opened);    /* Emitter should be opened. */
 133
 134     emitter->anchors = yaml_malloc(sizeof(*(emitter->anchors))
 135             * (document->nodes.top - document->nodes.start));
 136     if (!emitter->anchors) goto error;
 137     memset(emitter->anchors, 0, sizeof(*(emitter->anchors))
 138             * (document->nodes.top - document->nodes.start));
 139
 140     DOCUMENT_START_EVENT_INIT(event, document->version_directive,
 141             document->tag_directives.start, document->tag_directives.end,
 142             document->start_implicit, mark, mark);
 143     if (!yaml_emitter_emit(emitter, &event)) goto error;
 144
 145     yaml_emitter_anchor_node(emitter, 1);
 146     if (!yaml_emitter_dump_node(emitter, 1)) goto error;
 147
 148     DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark);
 149     if (!yaml_emitter_emit(emitter, &event)) goto error;
 150
 151     yaml_emitter_delete_document_and_anchors(emitter);
 152
 153     return 1;
 154
 155 error:
 156
 157     yaml_emitter_delete_document_and_anchors(emitter);
 158
 159     return 0;
 160 }
 161
 162 /*
 163  * Clean up the emitter object after a document is dumped.
 164  */
 165
 166 static void
 167 yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
 168 {
 169     int index;
 170
 171     if (!emitter->anchors) {
 172         yaml_document_delete(emitter->document);
 173         emitter->document = NULL;
 174         return;
 175     }
 176
 177     for (index = 0; emitter->document->nodes.start + index
 178             < emitter->document->nodes.top; index ++) {
 179         yaml_node_t node = emitter->document->nodes.start[index];
 180         if (!emitter->anchors[index].serialized) {
 181             yaml_free(node.tag);
 182             if (node.type == YAML_SCALAR_NODE) {
 183                 yaml_free(node.data.scalar.value);
 184             }
 185         }
 186         if (node.type == YAML_SEQUENCE_NODE) {
 187             STACK_DEL(emitter, node.data.sequence.items);
 188         }
 189         if (node.type == YAML_MAPPING_NODE) {
 190             STACK_DEL(emitter, node.data.mapping.pairs);
 191         }
 192     }
 193
 194     STACK_DEL(emitter, emitter->document->nodes);
 195     yaml_free(emitter->anchors);
 196
 197     emitter->anchors = NULL;
 198     emitter->last_anchor_id = 0;
 199     emitter->document = NULL;
 200 }
 201
 202 /*
 203  * Check the references of a node and assign the anchor id if needed.
 204  */
 205
 206 static void
 207 yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index)
 208 {
 209     yaml_node_t *node = emitter->document->nodes.start + index - 1;
 210     yaml_node_item_t *item;
 211     yaml_node_pair_t *pair;
 212
 213     emitter->anchors[index-1].references ++;
 214
 215     if (emitter->anchors[index-1].references == 1) {
 216         switch (node->type) {
 217             case YAML_SEQUENCE_NODE:
 218                 for (item = node->data.sequence.items.start;
 219                         item < node->data.sequence.items.top; item ++) {
 220                     yaml_emitter_anchor_node(emitter, *item);
 221                 }
 222                 break;
 223             case YAML_MAPPING_NODE:
 224                 for (pair = node->data.mapping.pairs.start;
 225                         pair < node->data.mapping.pairs.top; pair ++) {
 226                     yaml_emitter_anchor_node(emitter, pair->key);
 227                     yaml_emitter_anchor_node(emitter, pair->value);
 228                 }
 229                 break;
 230             default:
 231                 break;
 232         }
 233     }
 234
 235     else if (emitter->anchors[index-1].references == 2) {
 236         emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id);
 237     }
 238 }
 239
 240 /*
 241  * Generate a textual representation for an anchor.
 242  */
 243
 244 #define ANCHOR_TEMPLATE         "id%03d"
 245 #define ANCHOR_TEMPLATE_LENGTH  16
 246
 247 static yaml_char_t *
 248 yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id)
 249 {
 250     yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);
 251
 252     if (!anchor) return NULL;
 253
 254     sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id);
 255
 256     return anchor;
 257 }
 258
 259 /*
 260  * Serialize a node.
 261  */
 262
 263 static int
 264 yaml_emitter_dump_node(yaml_emitter_t *emitter, int index)
 265 {
 266     yaml_node_t *node = emitter->document->nodes.start + index - 1;
 267     int anchor_id = emitter->anchors[index-1].anchor;
 268     yaml_char_t *anchor = NULL;
 269
 270     if (anchor_id) {
 271         anchor = yaml_emitter_generate_anchor(emitter, anchor_id);
 272         if (!anchor) return 0;
 273     }
 274
 275     if (emitter->anchors[index-1].serialized) {
 276         return yaml_emitter_dump_alias(emitter, anchor);
 277     }
 278
 279     emitter->anchors[index-1].serialized = 1;
 280
 281     switch (node->type) {
 282         case YAML_SCALAR_NODE:
 283             return yaml_emitter_dump_scalar(emitter, node, anchor);
 284         case YAML_SEQUENCE_NODE:
 285             return yaml_emitter_dump_sequence(emitter, node, anchor);
 286         case YAML_MAPPING_NODE:
 287             return yaml_emitter_dump_mapping(emitter, node, anchor);
 288         default:
 289             assert(0);      /* Could not happen. */
 290             break;
 291     }
 292
 293     return 0;       /* Could not happen. */
 294 }
 295
 296 /*
 297  * Serialize an alias.
 298  */
 299
 300 static int
 301 yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor)
 302 {
 303     yaml_event_t event;
 304     yaml_mark_t mark  = { 0, 0, 0 };
 305
 306     ALIAS_EVENT_INIT(event, anchor, mark, mark);
 307
 308     return yaml_emitter_emit(emitter, &event);
 309 }
 310
 311 /*
 312  * Serialize a scalar.
 313  */
 314
 315 static int
 316 yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
 317         yaml_char_t *anchor)
 318 {
 319     yaml_event_t event;
 320     yaml_mark_t mark  = { 0, 0, 0 };
 321
 322     int plain_implicit = (strcmp((char *)node->tag,
 323                 YAML_DEFAULT_SCALAR_TAG) == 0);
 324     int quoted_implicit = (strcmp((char *)node->tag,
 325                 YAML_DEFAULT_SCALAR_TAG) == 0);
 326
 327     SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value,
 328             node->data.scalar.length, plain_implicit, quoted_implicit,
 329             node->data.scalar.style, mark, mark);
 330
 331     return yaml_emitter_emit(emitter, &event);
 332 }
 333
 334 /*
 335  * Serialize a sequence.
 336  */
 337
 338 static int
 339 yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
 340         yaml_char_t *anchor)
 341 {
 342     yaml_event_t event;
 343     yaml_mark_t mark  = { 0, 0, 0 };
 344
 345     int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0);
 346
 347     yaml_node_item_t *item;
 348
 349     SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit,
 350             node->data.sequence.style, mark, mark);
 351     if (!yaml_emitter_emit(emitter, &event)) return 0;
 352
 353     for (item = node->data.sequence.items.start;
 354             item < node->data.sequence.items.top; item ++) {
 355         if (!yaml_emitter_dump_node(emitter, *item)) return 0;
 356     }
 357
 358     SEQUENCE_END_EVENT_INIT(event, mark, mark);
 359     if (!yaml_emitter_emit(emitter, &event)) return 0;
 360
 361     return 1;
 362 }
 363
 364 /*
 365  * Serialize a mapping.
 366  */
 367
 368 static int
 369 yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
 370         yaml_char_t *anchor)
 371 {
 372     yaml_event_t event;
 373     yaml_mark_t mark  = { 0, 0, 0 };
 374
 375     int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0);
 376
 377     yaml_node_pair_t *pair;
 378
 379     MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit,
 380             node->data.mapping.style, mark, mark);
 381     if (!yaml_emitter_emit(emitter, &event)) return 0;
 382
 383     for (pair = node->data.mapping.pairs.start;
 384             pair < node->data.mapping.pairs.top; pair ++) {
 385         if (!yaml_emitter_dump_node(emitter, pair->key)) return 0;
 386         if (!yaml_emitter_dump_node(emitter, pair->value)) return 0;
 387     }
 388
 389     MAPPING_END_EVENT_INIT(event, mark, mark);
 390     if (!yaml_emitter_emit(emitter, &event)) return 0;
 391
 392     return 1;
 393 }
 394