← Back to branch summary

~mwhudson/ubuntu/xenial/juju-core/mwhudson

« back to all changes in this revision

Viewing changes to src/launchpad.net/goyaml/emitter.c

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-04-24 22:34:47 UTC
  • Revision ID: package-import@ubuntu.com-20130424223447-f0qdji7ubnyo0s71
Tags: upstream-1.10.0.1
Import upstream version 1.10.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/goyaml/emitter.c
 
1
 
 
2
#include "yaml_private.h"
 
3
 
 
4
/*
 
5
 * Flush the buffer if needed.
 
6
 */
 
7
 
 
8
#define FLUSH(emitter)                                                          \
 
9
    ((emitter->buffer.pointer+5 < emitter->buffer.end)                          \
 
10
     || yaml_emitter_flush(emitter))
 
11
 
 
12
/*
 
13
 * Put a character to the output buffer.
 
14
 */
 
15
 
 
16
#define PUT(emitter,value)                                                      \
 
17
    (FLUSH(emitter)                                                             \
 
18
     && (*(emitter->buffer.pointer++) = (yaml_char_t)(value),                   \
 
19
         emitter->column ++,                                                    \
 
20
         1))
 
21
 
 
22
/*
 
23
 * Put a line break to the output buffer.
 
24
 */
 
25
 
 
26
#define PUT_BREAK(emitter)                                                      \
 
27
    (FLUSH(emitter)                                                             \
 
28
     && ((emitter->line_break == YAML_CR_BREAK ?                                \
 
29
             (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') :              \
 
30
          emitter->line_break == YAML_LN_BREAK ?                                \
 
31
             (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') :              \
 
32
          emitter->line_break == YAML_CRLN_BREAK ?                              \
 
33
             (*(emitter->buffer.pointer++) = (yaml_char_t) '\r',                \
 
34
              *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0),          \
 
35
         emitter->column = 0,                                                   \
 
36
         emitter->line ++,                                                      \
 
37
         1))
 
38
 
 
39
/*
 
40
 * Copy a character from a string into buffer.
 
41
 */
 
42
 
 
43
#define WRITE(emitter,string)                                                   \
 
44
    (FLUSH(emitter)                                                             \
 
45
     && (COPY(emitter->buffer,string),                                          \
 
46
         emitter->column ++,                                                    \
 
47
         1))
 
48
 
 
49
/*
 
50
 * Copy a line break character from a string into buffer.
 
51
 */
 
52
 
 
53
#define WRITE_BREAK(emitter,string)                                             \
 
54
    (FLUSH(emitter)                                                             \
 
55
     && (CHECK(string,'\n') ?                                                   \
 
56
         (PUT_BREAK(emitter),                                                   \
 
57
          string.pointer ++,                                                    \
 
58
          1) :                                                                  \
 
59
         (COPY(emitter->buffer,string),                                         \
 
60
          emitter->column = 0,                                                  \
 
61
          emitter->line ++,                                                     \
 
62
          1)))
 
63
 
 
64
/*
 
65
 * API functions.
 
66
 */
 
67
 
 
68
YAML_DECLARE(int)
 
69
yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
 
70
 
 
71
/*
 
72
 * Utility functions.
 
73
 */
 
74
 
 
75
static int
 
76
yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem);
 
77
 
 
78
static int
 
79
yaml_emitter_need_more_events(yaml_emitter_t *emitter);
 
80
 
 
81
static int
 
82
yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
 
83
        yaml_tag_directive_t value, int allow_duplicates);
 
84
 
 
85
static int
 
86
yaml_emitter_increase_indent(yaml_emitter_t *emitter,
 
87
        int flow, int indentless);
 
88
 
 
89
/*
 
90
 * State functions.
 
91
 */
 
92
 
 
93
static int
 
94
yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event);
 
95
 
 
96
static int
 
97
yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
 
98
        yaml_event_t *event);
 
99
 
 
100
static int
 
101
yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
 
102
        yaml_event_t *event, int first);
 
103
 
 
104
static int
 
105
yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
 
106
        yaml_event_t *event);
 
107
 
 
108
static int
 
109
yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
 
110
        yaml_event_t *event);
 
111
 
 
112
static int
 
113
yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
 
114
        yaml_event_t *event, int first);
 
115
 
 
116
static int
 
117
yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
 
118
        yaml_event_t *event, int first);
 
119
 
 
120
static int
 
121
yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
 
122
        yaml_event_t *event, int simple);
 
123
 
 
124
static int
 
125
yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
 
126
        yaml_event_t *event, int first);
 
127
 
 
128
static int
 
129
yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
 
130
        yaml_event_t *event, int first);
 
131
 
 
132
static int
 
133
yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
 
134
        yaml_event_t *event, int simple);
 
135
 
 
136
static int
 
137
yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
 
138
        int root, int sequence, int mapping, int simple_key);
 
139
 
 
140
static int
 
141
yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event);
 
142
 
 
143
static int
 
144
yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event);
 
145
 
 
146
static int
 
147
yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event);
 
148
 
 
149
static int
 
150
yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event);
 
151
 
 
152
/*
 
153
 * Checkers.
 
154
 */
 
155
 
 
156
static int
 
157
yaml_emitter_check_empty_document(yaml_emitter_t *emitter);
 
158
 
 
159
static int
 
160
yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
 
161
 
 
162
static int
 
163
yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
 
164
 
 
165
static int
 
166
yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
 
167
 
 
168
static int
 
169
yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event);
 
170
 
 
171
/*
 
172
 * Processors.
 
173
 */
 
174
 
 
175
static int
 
176
yaml_emitter_process_anchor(yaml_emitter_t *emitter);
 
177
 
 
178
static int
 
179
yaml_emitter_process_tag(yaml_emitter_t *emitter);
 
180
 
 
181
static int
 
182
yaml_emitter_process_scalar(yaml_emitter_t *emitter);
 
183
 
 
184
/*
 
185
 * Analyzers.
 
186
 */
 
187
 
 
188
static int
 
189
yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
 
190
        yaml_version_directive_t version_directive);
 
191
 
 
192
static int
 
193
yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
 
194
        yaml_tag_directive_t tag_directive);
 
195
 
 
196
static int
 
197
yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
 
198
        yaml_char_t *anchor, int alias);
 
199
 
 
200
static int
 
201
yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
 
202
        yaml_char_t *tag);
 
203
 
 
204
static int
 
205
yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
 
206
        yaml_char_t *value, size_t length);
 
207
 
 
208
static int
 
209
yaml_emitter_analyze_event(yaml_emitter_t *emitter,
 
210
        yaml_event_t *event);
 
211
 
 
212
/*
 
213
 * Writers.
 
214
 */
 
215
 
 
216
static int
 
217
yaml_emitter_write_bom(yaml_emitter_t *emitter);
 
218
 
 
219
static int
 
220
yaml_emitter_write_indent(yaml_emitter_t *emitter);
 
221
 
 
222
static int
 
223
yaml_emitter_write_indicator(yaml_emitter_t *emitter,
 
224
        char *indicator, int need_whitespace,
 
225
        int is_whitespace, int is_indention);
 
226
 
 
227
static int
 
228
yaml_emitter_write_anchor(yaml_emitter_t *emitter,
 
229
        yaml_char_t *value, size_t length);
 
230
 
 
231
static int
 
232
yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
 
233
        yaml_char_t *value, size_t length);
 
234
 
 
235
static int
 
236
yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
 
237
        yaml_char_t *value, size_t length, int need_whitespace);
 
238
 
 
239
static int
 
240
yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
 
241
        yaml_char_t *value, size_t length, int allow_breaks);
 
242
 
 
243
static int
 
244
yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
 
245
        yaml_char_t *value, size_t length, int allow_breaks);
 
246
 
 
247
static int
 
248
yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
 
249
        yaml_char_t *value, size_t length, int allow_breaks);
 
250
 
 
251
static int
 
252
yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
 
253
        yaml_string_t string);
 
254
 
 
255
static int
 
256
yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
 
257
        yaml_char_t *value, size_t length);
 
258
 
 
259
static int
 
260
yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
 
261
        yaml_char_t *value, size_t length);
 
262
 
 
263
/*
 
264
 * Set an emitter error and return 0.
 
265
 */
 
266
 
 
267
static int
 
268
yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem)
 
269
{
 
270
    emitter->error = YAML_EMITTER_ERROR;
 
271
    emitter->problem = problem;
 
272
 
 
273
    return 0;
 
274
}
 
275
 
 
276
/*
 
277
 * Emit an event.
 
278
 */
 
279
 
 
280
YAML_DECLARE(int)
 
281
yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
 
282
{
 
283
    if (!ENQUEUE(emitter, emitter->events, *event)) {
 
284
        yaml_event_delete(event);
 
285
        return 0;
 
286
    }
 
287
 
 
288
    while (!yaml_emitter_need_more_events(emitter)) {
 
289
        if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
 
290
            return 0;
 
291
        if (!yaml_emitter_state_machine(emitter, emitter->events.head))
 
292
            return 0;
 
293
        yaml_event_delete(&DEQUEUE(emitter, emitter->events));
 
294
    }
 
295
 
 
296
    return 1;
 
297
}
 
298
 
 
299
/*
 
300
 * Check if we need to accumulate more events before emitting.
 
301
 *
 
302
 * We accumulate extra
 
303
 *  - 1 event for DOCUMENT-START
 
304
 *  - 2 events for SEQUENCE-START
 
305
 *  - 3 events for MAPPING-START
 
306
 */
 
307
 
 
308
static int
 
309
yaml_emitter_need_more_events(yaml_emitter_t *emitter)
 
310
{
 
311
    int level = 0;
 
312
    int accumulate = 0;
 
313
    yaml_event_t *event;
 
314
 
 
315
    if (QUEUE_EMPTY(emitter, emitter->events))
 
316
        return 1;
 
317
 
 
318
    switch (emitter->events.head->type) {
 
319
        case YAML_DOCUMENT_START_EVENT:
 
320
            accumulate = 1;
 
321
            break;
 
322
        case YAML_SEQUENCE_START_EVENT:
 
323
            accumulate = 2;
 
324
            break;
 
325
        case YAML_MAPPING_START_EVENT:
 
326
            accumulate = 3;
 
327
            break;
 
328
        default:
 
329
            return 0;
 
330
    }
 
331
 
 
332
    if (emitter->events.tail - emitter->events.head > accumulate)
 
333
        return 0;
 
334
 
 
335
    for (event = emitter->events.head; event != emitter->events.tail; event ++) {
 
336
        switch (event->type) {
 
337
            case YAML_STREAM_START_EVENT:
 
338
            case YAML_DOCUMENT_START_EVENT:
 
339
            case YAML_SEQUENCE_START_EVENT:
 
340
            case YAML_MAPPING_START_EVENT:
 
341
                level += 1;
 
342
                break;
 
343
            case YAML_STREAM_END_EVENT:
 
344
            case YAML_DOCUMENT_END_EVENT:
 
345
            case YAML_SEQUENCE_END_EVENT:
 
346
            case YAML_MAPPING_END_EVENT:
 
347
                level -= 1;
 
348
                break;
 
349
            default:
 
350
                break;
 
351
        }
 
352
        if (!level)
 
353
            return 0;
 
354
    }
 
355
 
 
356
    return 1;
 
357
}
 
358
 
 
359
/*
 
360
 * Append a directive to the directives stack.
 
361
 */
 
362
 
 
363
static int
 
364
yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
 
365
        yaml_tag_directive_t value, int allow_duplicates)
 
366
{
 
367
    yaml_tag_directive_t *tag_directive;
 
368
    yaml_tag_directive_t copy = { NULL, NULL };
 
369
 
 
370
    for (tag_directive = emitter->tag_directives.start;
 
371
            tag_directive != emitter->tag_directives.top; tag_directive ++) {
 
372
        if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
 
373
            if (allow_duplicates)
 
374
                return 1;
 
375
            return yaml_emitter_set_emitter_error(emitter,
 
376
                    "duplicate %TAG directive");
 
377
        }
 
378
    }
 
379
 
 
380
    copy.handle = yaml_strdup(value.handle);
 
381
    copy.prefix = yaml_strdup(value.prefix);
 
382
    if (!copy.handle || !copy.prefix) {
 
383
        emitter->error = YAML_MEMORY_ERROR;
 
384
        goto error;
 
385
    }
 
386
 
 
387
    if (!PUSH(emitter, emitter->tag_directives, copy))
 
388
        goto error;
 
389
 
 
390
    return 1;
 
391
 
 
392
error:
 
393
    yaml_free(copy.handle);
 
394
    yaml_free(copy.prefix);
 
395
    return 0;
 
396
}
 
397
 
 
398
/*
 
399
 * Increase the indentation level.
 
400
 */
 
401
 
 
402
static int
 
403
yaml_emitter_increase_indent(yaml_emitter_t *emitter,
 
404
        int flow, int indentless)
 
405
{
 
406
    if (!PUSH(emitter, emitter->indents, emitter->indent))
 
407
        return 0;
 
408
 
 
409
    if (emitter->indent < 0) {
 
410
        emitter->indent = flow ? emitter->best_indent : 0;
 
411
    }
 
412
    else if (!indentless) {
 
413
        emitter->indent += emitter->best_indent;
 
414
    }
 
415
 
 
416
    return 1;
 
417
}
 
418
 
 
419
/*
 
420
 * State dispatcher.
 
421
 */
 
422
 
 
423
static int
 
424
yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event)
 
425
{
 
426
    switch (emitter->state)
 
427
    {
 
428
        case YAML_EMIT_STREAM_START_STATE:
 
429
            return yaml_emitter_emit_stream_start(emitter, event);
 
430
 
 
431
        case YAML_EMIT_FIRST_DOCUMENT_START_STATE:
 
432
            return yaml_emitter_emit_document_start(emitter, event, 1);
 
433
 
 
434
        case YAML_EMIT_DOCUMENT_START_STATE:
 
435
            return yaml_emitter_emit_document_start(emitter, event, 0);
 
436
 
 
437
        case YAML_EMIT_DOCUMENT_CONTENT_STATE:
 
438
            return yaml_emitter_emit_document_content(emitter, event);
 
439
 
 
440
        case YAML_EMIT_DOCUMENT_END_STATE:
 
441
            return yaml_emitter_emit_document_end(emitter, event);
 
442
 
 
443
        case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
 
444
            return yaml_emitter_emit_flow_sequence_item(emitter, event, 1);
 
445
 
 
446
        case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE:
 
447
            return yaml_emitter_emit_flow_sequence_item(emitter, event, 0);
 
448
 
 
449
        case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
 
450
            return yaml_emitter_emit_flow_mapping_key(emitter, event, 1);
 
451
 
 
452
        case YAML_EMIT_FLOW_MAPPING_KEY_STATE:
 
453
            return yaml_emitter_emit_flow_mapping_key(emitter, event, 0);
 
454
 
 
455
        case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
 
456
            return yaml_emitter_emit_flow_mapping_value(emitter, event, 1);
 
457
 
 
458
        case YAML_EMIT_FLOW_MAPPING_VALUE_STATE:
 
459
            return yaml_emitter_emit_flow_mapping_value(emitter, event, 0);
 
460
 
 
461
        case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
 
462
            return yaml_emitter_emit_block_sequence_item(emitter, event, 1);
 
463
 
 
464
        case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
 
465
            return yaml_emitter_emit_block_sequence_item(emitter, event, 0);
 
466
 
 
467
        case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
 
468
            return yaml_emitter_emit_block_mapping_key(emitter, event, 1);
 
469
 
 
470
        case YAML_EMIT_BLOCK_MAPPING_KEY_STATE:
 
471
            return yaml_emitter_emit_block_mapping_key(emitter, event, 0);
 
472
 
 
473
        case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
 
474
            return yaml_emitter_emit_block_mapping_value(emitter, event, 1);
 
475
 
 
476
        case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE:
 
477
            return yaml_emitter_emit_block_mapping_value(emitter, event, 0);
 
478
 
 
479
        case YAML_EMIT_END_STATE:
 
480
            return yaml_emitter_set_emitter_error(emitter,
 
481
                    "expected nothing after STREAM-END");
 
482
 
 
483
        default:
 
484
            assert(1);      /* Invalid state. */
 
485
    }
 
486
 
 
487
    return 0;
 
488
}
 
489
 
 
490
/*
 
491
 * Expect STREAM-START.
 
492
 */
 
493
 
 
494
static int
 
495
yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
 
496
        yaml_event_t *event)
 
497
{
 
498
    if (event->type == YAML_STREAM_START_EVENT)
 
499
    {
 
500
        if (!emitter->encoding) {
 
501
            emitter->encoding = event->data.stream_start.encoding;
 
502
        }
 
503
 
 
504
        if (!emitter->encoding) {
 
505
            emitter->encoding = YAML_UTF8_ENCODING;
 
506
        }
 
507
 
 
508
        if (emitter->best_indent < 2 || emitter->best_indent > 9) {
 
509
            emitter->best_indent  = 2;
 
510
        }
 
511
 
 
512
        if (emitter->best_width >= 0
 
513
                && emitter->best_width <= emitter->best_indent*2) {
 
514
            emitter->best_width = 80;
 
515
        }
 
516
 
 
517
        if (emitter->best_width < 0) {
 
518
            emitter->best_width = INT_MAX;
 
519
        }
 
520
        
 
521
        if (!emitter->line_break) {
 
522
            emitter->line_break = YAML_LN_BREAK;
 
523
        }
 
524
 
 
525
        emitter->indent = -1;
 
526
 
 
527
        emitter->line = 0;
 
528
        emitter->column = 0;
 
529
        emitter->whitespace = 1;
 
530
        emitter->indention = 1;
 
531
 
 
532
        if (emitter->encoding != YAML_UTF8_ENCODING) {
 
533
            if (!yaml_emitter_write_bom(emitter))
 
534
                return 0;
 
535
        }
 
536
 
 
537
        emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;
 
538
 
 
539
        return 1;
 
540
    }
 
541
 
 
542
    return yaml_emitter_set_emitter_error(emitter,
 
543
            "expected STREAM-START");
 
544
}
 
545
 
 
546
/*
 
547
 * Expect DOCUMENT-START or STREAM-END.
 
548
 */
 
549
 
 
550
static int
 
551
yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
 
552
        yaml_event_t *event, int first)
 
553
{
 
554
    if (event->type == YAML_DOCUMENT_START_EVENT)
 
555
    {
 
556
        yaml_tag_directive_t default_tag_directives[] = {
 
557
            {(yaml_char_t *)"!", (yaml_char_t *)"!"},
 
558
            {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
 
559
            {NULL, NULL}
 
560
        };
 
561
        yaml_tag_directive_t *tag_directive;
 
562
        int implicit;
 
563
 
 
564
        if (event->data.document_start.version_directive) {
 
565
            if (!yaml_emitter_analyze_version_directive(emitter,
 
566
                        *event->data.document_start.version_directive))
 
567
                return 0;
 
568
        }
 
569
 
 
570
        for (tag_directive = event->data.document_start.tag_directives.start;
 
571
                tag_directive != event->data.document_start.tag_directives.end;
 
572
                tag_directive ++) {
 
573
            if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive))
 
574
                return 0;
 
575
            if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0))
 
576
                return 0;
 
577
        }
 
578
 
 
579
        for (tag_directive = default_tag_directives;
 
580
                tag_directive->handle; tag_directive ++) {
 
581
            if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1))
 
582
                return 0;
 
583
        }
 
584
 
 
585
        implicit = event->data.document_start.implicit;
 
586
        if (!first || emitter->canonical) {
 
587
            implicit = 0;
 
588
        }
 
589
 
 
590
        if ((event->data.document_start.version_directive ||
 
591
                    (event->data.document_start.tag_directives.start
 
592
                     != event->data.document_start.tag_directives.end)) &&
 
593
                emitter->open_ended)
 
594
        {
 
595
            if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
 
596
                return 0;
 
597
            if (!yaml_emitter_write_indent(emitter))
 
598
                return 0;
 
599
        }
 
600
 
 
601
        if (event->data.document_start.version_directive) {
 
602
            implicit = 0;
 
603
            if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0))
 
604
                return 0;
 
605
            if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0))
 
606
                return 0;
 
607
            if (!yaml_emitter_write_indent(emitter))
 
608
                return 0;
 
609
        }
 
610
        
 
611
        if (event->data.document_start.tag_directives.start
 
612
                != event->data.document_start.tag_directives.end) {
 
613
            implicit = 0;
 
614
            for (tag_directive = event->data.document_start.tag_directives.start;
 
615
                    tag_directive != event->data.document_start.tag_directives.end;
 
616
                    tag_directive ++) {
 
617
                if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0))
 
618
                    return 0;
 
619
                if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle,
 
620
                            strlen((char *)tag_directive->handle)))
 
621
                    return 0;
 
622
                if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix,
 
623
                            strlen((char *)tag_directive->prefix), 1))
 
624
                    return 0;
 
625
                if (!yaml_emitter_write_indent(emitter))
 
626
                    return 0;
 
627
            }
 
628
        }
 
629
 
 
630
        if (yaml_emitter_check_empty_document(emitter)) {
 
631
            implicit = 0;
 
632
        }
 
633
 
 
634
        if (!implicit) {
 
635
            if (!yaml_emitter_write_indent(emitter))
 
636
                return 0;
 
637
            if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0))
 
638
                return 0;
 
639
            if (emitter->canonical) {
 
640
                if (!yaml_emitter_write_indent(emitter))
 
641
                    return 0;
 
642
            }
 
643
        }
 
644
 
 
645
        emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
 
646
 
 
647
        return 1;
 
648
    }
 
649
 
 
650
    else if (event->type == YAML_STREAM_END_EVENT)
 
651
    {
 
652
        if (emitter->open_ended)
 
653
        {
 
654
            if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
 
655
                return 0;
 
656
            if (!yaml_emitter_write_indent(emitter))
 
657
                return 0;
 
658
        }
 
659
 
 
660
        if (!yaml_emitter_flush(emitter))
 
661
            return 0;
 
662
 
 
663
        emitter->state = YAML_EMIT_END_STATE;
 
664
 
 
665
        return 1;
 
666
    }
 
667
 
 
668
    return yaml_emitter_set_emitter_error(emitter,
 
669
            "expected DOCUMENT-START or STREAM-END");
 
670
}
 
671
 
 
672
/*
 
673
 * Expect the root node.
 
674
 */
 
675
 
 
676
static int
 
677
yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
 
678
        yaml_event_t *event)
 
679
{
 
680
    if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE))
 
681
        return 0;
 
682
 
 
683
    return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0);
 
684
}
 
685
 
 
686
/*
 
687
 * Expect DOCUMENT-END.
 
688
 */
 
689
 
 
690
static int
 
691
yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
 
692
        yaml_event_t *event)
 
693
{
 
694
    if (event->type == YAML_DOCUMENT_END_EVENT)
 
695
    {
 
696
        if (!yaml_emitter_write_indent(emitter))
 
697
            return 0;
 
698
        if (!event->data.document_end.implicit) {
 
699
            if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
 
700
                return 0;
 
701
            if (!yaml_emitter_write_indent(emitter))
 
702
                return 0;
 
703
        }
 
704
        if (!yaml_emitter_flush(emitter))
 
705
            return 0;
 
706
 
 
707
        emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
 
708
 
 
709
        while (!STACK_EMPTY(emitter, emitter->tag_directives)) {
 
710
            yaml_tag_directive_t tag_directive = POP(emitter,
 
711
                    emitter->tag_directives);
 
712
            yaml_free(tag_directive.handle);
 
713
            yaml_free(tag_directive.prefix);
 
714
        }
 
715
 
 
716
        return 1;
 
717
    }
 
718
 
 
719
    return yaml_emitter_set_emitter_error(emitter,
 
720
            "expected DOCUMENT-END");
 
721
}
 
722
 
 
723
/*
 
724
 * 
 
725
 * Expect a flow item node.
 
726
 */
 
727
 
 
728
static int
 
729
yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
 
730
        yaml_event_t *event, int first)
 
731
{
 
732
    if (first)
 
733
    {
 
734
        if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0))
 
735
            return 0;
 
736
        if (!yaml_emitter_increase_indent(emitter, 1, 0))
 
737
            return 0;
 
738
        emitter->flow_level ++;
 
739
    }
 
740
 
 
741
    if (event->type == YAML_SEQUENCE_END_EVENT)
 
742
    {
 
743
        emitter->flow_level --;
 
744
        emitter->indent = POP(emitter, emitter->indents);
 
745
        if (emitter->canonical && !first) {
 
746
            if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
 
747
                return 0;
 
748
            if (!yaml_emitter_write_indent(emitter))
 
749
                return 0;
 
750
        }
 
751
        if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0))
 
752
            return 0;
 
753
        emitter->state = POP(emitter, emitter->states);
 
754
 
 
755
        return 1;
 
756
    }
 
757
 
 
758
    if (!first) {
 
759
        if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
 
760
            return 0;
 
761
    }
 
762
 
 
763
    if (emitter->canonical || emitter->column > emitter->best_width) {
 
764
        if (!yaml_emitter_write_indent(emitter))
 
765
            return 0;
 
766
    }
 
767
    if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE))
 
768
        return 0;
 
769
 
 
770
    return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
 
771
}
 
772
 
 
773
/*
 
774
 * Expect a flow key node.
 
775
 */
 
776
 
 
777
static int
 
778
yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
 
779
        yaml_event_t *event, int first)
 
780
{
 
781
    if (first)
 
782
    {
 
783
        if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0))
 
784
            return 0;
 
785
        if (!yaml_emitter_increase_indent(emitter, 1, 0))
 
786
            return 0;
 
787
        emitter->flow_level ++;
 
788
    }
 
789
 
 
790
    if (event->type == YAML_MAPPING_END_EVENT)
 
791
    {
 
792
        emitter->flow_level --;
 
793
        emitter->indent = POP(emitter, emitter->indents);
 
794
        if (emitter->canonical && !first) {
 
795
            if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
 
796
                return 0;
 
797
            if (!yaml_emitter_write_indent(emitter))
 
798
                return 0;
 
799
        }
 
800
        if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0))
 
801
            return 0;
 
802
        emitter->state = POP(emitter, emitter->states);
 
803
 
 
804
        return 1;
 
805
    }
 
806
 
 
807
    if (!first) {
 
808
        if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
 
809
            return 0;
 
810
    }
 
811
    if (emitter->canonical || emitter->column > emitter->best_width) {
 
812
        if (!yaml_emitter_write_indent(emitter))
 
813
            return 0;
 
814
    }
 
815
 
 
816
    if (!emitter->canonical && yaml_emitter_check_simple_key(emitter))
 
817
    {
 
818
        if (!PUSH(emitter, emitter->states,
 
819
                    YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE))
 
820
            return 0;
 
821
 
 
822
        return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
 
823
    }
 
824
    else
 
825
    {
 
826
        if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0))
 
827
            return 0;
 
828
        if (!PUSH(emitter, emitter->states,
 
829
                    YAML_EMIT_FLOW_MAPPING_VALUE_STATE))
 
830
            return 0;
 
831
 
 
832
        return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
 
833
    }
 
834
}
 
835
 
 
836
/*
 
837
 * Expect a flow value node.
 
838
 */
 
839
 
 
840
static int
 
841
yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
 
842
        yaml_event_t *event, int simple)
 
843
{
 
844
    if (simple) {
 
845
        if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
 
846
            return 0;
 
847
    }
 
848
    else {
 
849
        if (emitter->canonical || emitter->column > emitter->best_width) {
 
850
            if (!yaml_emitter_write_indent(emitter))
 
851
                return 0;
 
852
        }
 
853
        if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0))
 
854
            return 0;
 
855
    }
 
856
    if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE))
 
857
        return 0;
 
858
    return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
 
859
}
 
860
 
 
861
/*
 
862
 * Expect a block item node.
 
863
 */
 
864
 
 
865
static int
 
866
yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
 
867
        yaml_event_t *event, int first)
 
868
{
 
869
    if (first)
 
870
    {
 
871
        if (!yaml_emitter_increase_indent(emitter, 0,
 
872
                    (emitter->mapping_context && !emitter->indention)))
 
873
            return 0;
 
874
    }
 
875
 
 
876
    if (event->type == YAML_SEQUENCE_END_EVENT)
 
877
    {
 
878
        emitter->indent = POP(emitter, emitter->indents);
 
879
        emitter->state = POP(emitter, emitter->states);
 
880
 
 
881
        return 1;
 
882
    }
 
883
 
 
884
    if (!yaml_emitter_write_indent(emitter))
 
885
        return 0;
 
886
    if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1))
 
887
        return 0;
 
888
    if (!PUSH(emitter, emitter->states,
 
889
                YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE))
 
890
        return 0;
 
891
 
 
892
    return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
 
893
}
 
894
 
 
895
/*
 
896
 * Expect a block key node.
 
897
 */
 
898
 
 
899
static int
 
900
yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
 
901
        yaml_event_t *event, int first)
 
902
{
 
903
    if (first)
 
904
    {
 
905
        if (!yaml_emitter_increase_indent(emitter, 0, 0))
 
906
            return 0;
 
907
    }
 
908
 
 
909
    if (event->type == YAML_MAPPING_END_EVENT)
 
910
    {
 
911
        emitter->indent = POP(emitter, emitter->indents);
 
912
        emitter->state = POP(emitter, emitter->states);
 
913
 
 
914
        return 1;
 
915
    }
 
916
 
 
917
    if (!yaml_emitter_write_indent(emitter))
 
918
        return 0;
 
919
 
 
920
    if (yaml_emitter_check_simple_key(emitter))
 
921
    {
 
922
        if (!PUSH(emitter, emitter->states,
 
923
                    YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE))
 
924
            return 0;
 
925
 
 
926
        return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
 
927
    }
 
928
    else
 
929
    {
 
930
        if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1))
 
931
            return 0;
 
932
        if (!PUSH(emitter, emitter->states,
 
933
                    YAML_EMIT_BLOCK_MAPPING_VALUE_STATE))
 
934
            return 0;
 
935
 
 
936
        return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
 
937
    }
 
938
}
 
939
 
 
940
/*
 
941
 * Expect a block value node.
 
942
 */
 
943
 
 
944
static int
 
945
yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
 
946
        yaml_event_t *event, int simple)
 
947
{
 
948
    if (simple) {
 
949
        if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
 
950
            return 0;
 
951
    }
 
952
    else {
 
953
        if (!yaml_emitter_write_indent(emitter))
 
954
            return 0;
 
955
        if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1))
 
956
            return 0;
 
957
    }
 
958
    if (!PUSH(emitter, emitter->states,
 
959
                YAML_EMIT_BLOCK_MAPPING_KEY_STATE))
 
960
        return 0;
 
961
 
 
962
    return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
 
963
}
 
964
 
 
965
/*
 
966
 * Expect a node.
 
967
 */
 
968
 
 
969
static int
 
970
yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
 
971
        int root, int sequence, int mapping, int simple_key)
 
972
{
 
973
    emitter->root_context = root;
 
974
    emitter->sequence_context = sequence;
 
975
    emitter->mapping_context = mapping;
 
976
    emitter->simple_key_context = simple_key;
 
977
 
 
978
    switch (event->type)
 
979
    {
 
980
        case YAML_ALIAS_EVENT:
 
981
            return yaml_emitter_emit_alias(emitter, event);
 
982
 
 
983
        case YAML_SCALAR_EVENT:
 
984
            return yaml_emitter_emit_scalar(emitter, event);
 
985
 
 
986
        case YAML_SEQUENCE_START_EVENT:
 
987
            return yaml_emitter_emit_sequence_start(emitter, event);
 
988
 
 
989
        case YAML_MAPPING_START_EVENT:
 
990
            return yaml_emitter_emit_mapping_start(emitter, event);
 
991
 
 
992
        default:
 
993
            return yaml_emitter_set_emitter_error(emitter,
 
994
                    "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
 
995
    }
 
996
 
 
997
    return 0;
 
998
}
 
999
 
 
1000
/*
 
1001
 * Expect ALIAS.
 
1002
 */
 
1003
 
 
1004
static int
 
1005
yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event)
 
1006
{
 
1007
    if (!yaml_emitter_process_anchor(emitter))
 
1008
        return 0;
 
1009
    emitter->state = POP(emitter, emitter->states);
 
1010
 
 
1011
    return 1;
 
1012
}
 
1013
 
 
1014
/*
 
1015
 * Expect SCALAR.
 
1016
 */
 
1017
 
 
1018
static int
 
1019
yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event)
 
1020
{
 
1021
    if (!yaml_emitter_select_scalar_style(emitter, event))
 
1022
        return 0;
 
1023
    if (!yaml_emitter_process_anchor(emitter))
 
1024
        return 0;
 
1025
    if (!yaml_emitter_process_tag(emitter))
 
1026
        return 0;
 
1027
    if (!yaml_emitter_increase_indent(emitter, 1, 0))
 
1028
        return 0;
 
1029
    if (!yaml_emitter_process_scalar(emitter))
 
1030
        return 0;
 
1031
    emitter->indent = POP(emitter, emitter->indents);
 
1032
    emitter->state = POP(emitter, emitter->states);
 
1033
 
 
1034
    return 1;
 
1035
}
 
1036
 
 
1037
/*
 
1038
 * Expect SEQUENCE-START.
 
1039
 */
 
1040
 
 
1041
static int
 
1042
yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event)
 
1043
{
 
1044
    if (!yaml_emitter_process_anchor(emitter))
 
1045
        return 0;
 
1046
    if (!yaml_emitter_process_tag(emitter))
 
1047
        return 0;
 
1048
 
 
1049
    if (emitter->flow_level || emitter->canonical
 
1050
            || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE
 
1051
            || yaml_emitter_check_empty_sequence(emitter)) {
 
1052
        emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
 
1053
    }
 
1054
    else {
 
1055
        emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
 
1056
    }
 
1057
 
 
1058
    return 1;
 
1059
}
 
1060
 
 
1061
/*
 
1062
 * Expect MAPPING-START.
 
1063
 */
 
1064
 
 
1065
static int
 
1066
yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
 
1067
{
 
1068
    if (!yaml_emitter_process_anchor(emitter))
 
1069
        return 0;
 
1070
    if (!yaml_emitter_process_tag(emitter))
 
1071
        return 0;
 
1072
 
 
1073
    if (emitter->flow_level || emitter->canonical
 
1074
            || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE
 
1075
            || yaml_emitter_check_empty_mapping(emitter)) {
 
1076
        emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
 
1077
    }
 
1078
    else {
 
1079
        emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
 
1080
    }
 
1081
 
 
1082
    return 1;
 
1083
}
 
1084
 
 
1085
/*
 
1086
 * Check if the document content is an empty scalar.
 
1087
 */
 
1088
 
 
1089
static int
 
1090
yaml_emitter_check_empty_document(yaml_emitter_t *emitter)
 
1091
{
 
1092
    return 0;
 
1093
}
 
1094
 
 
1095
/*
 
1096
 * Check if the next events represent an empty sequence.
 
1097
 */
 
1098
 
 
1099
static int
 
1100
yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
 
1101
{
 
1102
    if (emitter->events.tail - emitter->events.head < 2)
 
1103
        return 0;
 
1104
 
 
1105
    return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT
 
1106
            && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT);
 
1107
}
 
1108
 
 
1109
/*
 
1110
 * Check if the next events represent an empty mapping.
 
1111
 */
 
1112
 
 
1113
static int
 
1114
yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
 
1115
{
 
1116
    if (emitter->events.tail - emitter->events.head < 2)
 
1117
        return 0;
 
1118
 
 
1119
    return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT
 
1120
            && emitter->events.head[1].type == YAML_MAPPING_END_EVENT);
 
1121
}
 
1122
 
 
1123
/*
 
1124
 * Check if the next node can be expressed as a simple key.
 
1125
 */
 
1126
 
 
1127
static int
 
1128
yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
 
1129
{
 
1130
    yaml_event_t *event = emitter->events.head;
 
1131
    size_t length = 0;
 
1132
 
 
1133
    switch (event->type)
 
1134
    {
 
1135
        case YAML_ALIAS_EVENT:
 
1136
            length += emitter->anchor_data.anchor_length;
 
1137
            break;
 
1138
 
 
1139
        case YAML_SCALAR_EVENT:
 
1140
            if (emitter->scalar_data.multiline)
 
1141
                return 0;
 
1142
            length += emitter->anchor_data.anchor_length
 
1143
                + emitter->tag_data.handle_length
 
1144
                + emitter->tag_data.suffix_length
 
1145
                + emitter->scalar_data.length;
 
1146
            break;
 
1147
 
 
1148
        case YAML_SEQUENCE_START_EVENT:
 
1149
            if (!yaml_emitter_check_empty_sequence(emitter))
 
1150
                return 0;
 
1151
            length += emitter->anchor_data.anchor_length
 
1152
                + emitter->tag_data.handle_length
 
1153
                + emitter->tag_data.suffix_length;
 
1154
            break;
 
1155
 
 
1156
        case YAML_MAPPING_START_EVENT:
 
1157
            if (!yaml_emitter_check_empty_mapping(emitter))
 
1158
                return 0;
 
1159
            length += emitter->anchor_data.anchor_length
 
1160
                + emitter->tag_data.handle_length
 
1161
                + emitter->tag_data.suffix_length;
 
1162
            break;
 
1163
 
 
1164
        default:
 
1165
            return 0;
 
1166
    }
 
1167
 
 
1168
    if (length > 128)
 
1169
        return 0;
 
1170
 
 
1171
    return 1;
 
1172
}
 
1173
 
 
1174
/*
 
1175
 * Determine an acceptable scalar style.
 
1176
 */
 
1177
 
 
1178
static int
 
1179
yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event)
 
1180
{
 
1181
    yaml_scalar_style_t style = event->data.scalar.style;
 
1182
    int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix);
 
1183
 
 
1184
    if (no_tag && !event->data.scalar.plain_implicit
 
1185
            && !event->data.scalar.quoted_implicit) {
 
1186
        return yaml_emitter_set_emitter_error(emitter,
 
1187
                "neither tag nor implicit flags are specified");
 
1188
    }
 
1189
 
 
1190
    if (style == YAML_ANY_SCALAR_STYLE)
 
1191
        style = YAML_PLAIN_SCALAR_STYLE;
 
1192
 
 
1193
    if (emitter->canonical)
 
1194
        style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
 
1195
 
 
1196
    if (emitter->simple_key_context && emitter->scalar_data.multiline)
 
1197
        style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
 
1198
 
 
1199
    if (style == YAML_PLAIN_SCALAR_STYLE)
 
1200
    {
 
1201
        if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed)
 
1202
                || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed))
 
1203
            style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
 
1204
        if (!emitter->scalar_data.length
 
1205
                && (emitter->flow_level || emitter->simple_key_context))
 
1206
            style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
 
1207
        if (no_tag && !event->data.scalar.plain_implicit)
 
1208
            style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
 
1209
    }
 
1210
 
 
1211
    if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE)
 
1212
    {
 
1213
        if (!emitter->scalar_data.single_quoted_allowed)
 
1214
            style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
 
1215
    }
 
1216
 
 
1217
    if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE)
 
1218
    {
 
1219
        if (!emitter->scalar_data.block_allowed
 
1220
                || emitter->flow_level || emitter->simple_key_context)
 
1221
            style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
 
1222
    }
 
1223
 
 
1224
    if (no_tag && !event->data.scalar.quoted_implicit
 
1225
            && style != YAML_PLAIN_SCALAR_STYLE)
 
1226
    {
 
1227
        emitter->tag_data.handle = (yaml_char_t *)"!";
 
1228
        emitter->tag_data.handle_length = 1;
 
1229
    }
 
1230
 
 
1231
    emitter->scalar_data.style = style;
 
1232
 
 
1233
    return 1;
 
1234
}
 
1235
 
 
1236
/*
 
1237
 * Write an achor.
 
1238
 */
 
1239
 
 
1240
static int
 
1241
yaml_emitter_process_anchor(yaml_emitter_t *emitter)
 
1242
{
 
1243
    if (!emitter->anchor_data.anchor)
 
1244
        return 1;
 
1245
 
 
1246
    if (!yaml_emitter_write_indicator(emitter,
 
1247
                (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0))
 
1248
        return 0;
 
1249
 
 
1250
    return yaml_emitter_write_anchor(emitter,
 
1251
            emitter->anchor_data.anchor, emitter->anchor_data.anchor_length);
 
1252
}
 
1253
 
 
1254
/*
 
1255
 * Write a tag.
 
1256
 */
 
1257
 
 
1258
static int
 
1259
yaml_emitter_process_tag(yaml_emitter_t *emitter)
 
1260
{
 
1261
    if (!emitter->tag_data.handle && !emitter->tag_data.suffix)
 
1262
        return 1;
 
1263
 
 
1264
    if (emitter->tag_data.handle)
 
1265
    {
 
1266
        if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle,
 
1267
                    emitter->tag_data.handle_length))
 
1268
            return 0;
 
1269
        if (emitter->tag_data.suffix) {
 
1270
            if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
 
1271
                        emitter->tag_data.suffix_length, 0))
 
1272
                return 0;
 
1273
        }
 
1274
    }
 
1275
    else
 
1276
    {
 
1277
        if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0))
 
1278
            return 0;
 
1279
        if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
 
1280
                    emitter->tag_data.suffix_length, 0))
 
1281
            return 0;
 
1282
        if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0))
 
1283
            return 0;
 
1284
    }
 
1285
 
 
1286
    return 1;
 
1287
}
 
1288
 
 
1289
/*
 
1290
 * Write a scalar.
 
1291
 */
 
1292
 
 
1293
static int
 
1294
yaml_emitter_process_scalar(yaml_emitter_t *emitter)
 
1295
{
 
1296
    switch (emitter->scalar_data.style)
 
1297
    {
 
1298
        case YAML_PLAIN_SCALAR_STYLE:
 
1299
            return yaml_emitter_write_plain_scalar(emitter,
 
1300
                    emitter->scalar_data.value, emitter->scalar_data.length,
 
1301
                    !emitter->simple_key_context);
 
1302
 
 
1303
        case YAML_SINGLE_QUOTED_SCALAR_STYLE:
 
1304
            return yaml_emitter_write_single_quoted_scalar(emitter,
 
1305
                    emitter->scalar_data.value, emitter->scalar_data.length,
 
1306
                    !emitter->simple_key_context);
 
1307
 
 
1308
        case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
 
1309
            return yaml_emitter_write_double_quoted_scalar(emitter,
 
1310
                    emitter->scalar_data.value, emitter->scalar_data.length,
 
1311
                    !emitter->simple_key_context);
 
1312
 
 
1313
        case YAML_LITERAL_SCALAR_STYLE:
 
1314
            return yaml_emitter_write_literal_scalar(emitter,
 
1315
                    emitter->scalar_data.value, emitter->scalar_data.length);
 
1316
 
 
1317
        case YAML_FOLDED_SCALAR_STYLE:
 
1318
            return yaml_emitter_write_folded_scalar(emitter,
 
1319
                    emitter->scalar_data.value, emitter->scalar_data.length);
 
1320
 
 
1321
        default:
 
1322
            assert(1);      /* Impossible. */
 
1323
    }
 
1324
 
 
1325
    return 0;
 
1326
}
 
1327
 
 
1328
/*
 
1329
 * Check if a %YAML directive is valid.
 
1330
 */
 
1331
 
 
1332
static int
 
1333
yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
 
1334
        yaml_version_directive_t version_directive)
 
1335
{
 
1336
    if (version_directive.major != 1 || version_directive.minor != 1) {
 
1337
        return yaml_emitter_set_emitter_error(emitter,
 
1338
                "incompatible %YAML directive");
 
1339
    }
 
1340
 
 
1341
    return 1;
 
1342
}
 
1343
 
 
1344
/*
 
1345
 * Check if a %TAG directive is valid.
 
1346
 */
 
1347
 
 
1348
static int
 
1349
yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
 
1350
        yaml_tag_directive_t tag_directive)
 
1351
{
 
1352
    yaml_string_t handle;
 
1353
    yaml_string_t prefix;
 
1354
    size_t handle_length;
 
1355
    size_t prefix_length;
 
1356
 
 
1357
    handle_length = strlen((char *)tag_directive.handle);
 
1358
    prefix_length = strlen((char *)tag_directive.prefix);
 
1359
    STRING_ASSIGN(handle, tag_directive.handle, handle_length);
 
1360
    STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length);
 
1361
 
 
1362
    if (handle.start == handle.end) {
 
1363
        return yaml_emitter_set_emitter_error(emitter,
 
1364
                "tag handle must not be empty");
 
1365
    }
 
1366
 
 
1367
    if (handle.start[0] != '!') {
 
1368
        return yaml_emitter_set_emitter_error(emitter,
 
1369
                "tag handle must start with '!'");
 
1370
    }
 
1371
 
 
1372
    if (handle.end[-1] != '!') {
 
1373
        return yaml_emitter_set_emitter_error(emitter,
 
1374
                "tag handle must end with '!'");
 
1375
    }
 
1376
 
 
1377
    handle.pointer ++;
 
1378
 
 
1379
    while (handle.pointer < handle.end-1) {
 
1380
        if (!IS_ALPHA(handle)) {
 
1381
            return yaml_emitter_set_emitter_error(emitter,
 
1382
                    "tag handle must contain alphanumerical characters only");
 
1383
        }
 
1384
        MOVE(handle);
 
1385
    }
 
1386
 
 
1387
    if (prefix.start == prefix.end) {
 
1388
        return yaml_emitter_set_emitter_error(emitter,
 
1389
                "tag prefix must not be empty");
 
1390
    }
 
1391
 
 
1392
    return 1;
 
1393
}
 
1394
 
 
1395
/*
 
1396
 * Check if an anchor is valid.
 
1397
 */
 
1398
 
 
1399
static int
 
1400
yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
 
1401
        yaml_char_t *anchor, int alias)
 
1402
{
 
1403
    size_t anchor_length;
 
1404
    yaml_string_t string;
 
1405
    
 
1406
    anchor_length = strlen((char *)anchor);
 
1407
    STRING_ASSIGN(string, anchor, anchor_length);
 
1408
 
 
1409
    if (string.start == string.end) {
 
1410
        return yaml_emitter_set_emitter_error(emitter, alias ?
 
1411
                "alias value must not be empty" :
 
1412
                "anchor value must not be empty");
 
1413
    }
 
1414
 
 
1415
    while (string.pointer != string.end) {
 
1416
        if (!IS_ALPHA(string)) {
 
1417
            return yaml_emitter_set_emitter_error(emitter, alias ?
 
1418
                    "alias value must contain alphanumerical characters only" :
 
1419
                    "anchor value must contain alphanumerical characters only");
 
1420
        }
 
1421
        MOVE(string);
 
1422
    }
 
1423
 
 
1424
    emitter->anchor_data.anchor = string.start;
 
1425
    emitter->anchor_data.anchor_length = string.end - string.start;
 
1426
    emitter->anchor_data.alias = alias;
 
1427
 
 
1428
    return 1;
 
1429
}
 
1430
 
 
1431
/*
 
1432
 * Check if a tag is valid.
 
1433
 */
 
1434
 
 
1435
static int
 
1436
yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
 
1437
        yaml_char_t *tag)
 
1438
{
 
1439
    size_t tag_length;
 
1440
    yaml_string_t string;
 
1441
    yaml_tag_directive_t *tag_directive;
 
1442
 
 
1443
    tag_length = strlen((char *)tag);
 
1444
    STRING_ASSIGN(string, tag, tag_length);
 
1445
 
 
1446
    if (string.start == string.end) {
 
1447
        return yaml_emitter_set_emitter_error(emitter,
 
1448
                "tag value must not be empty");
 
1449
    }
 
1450
 
 
1451
    for (tag_directive = emitter->tag_directives.start;
 
1452
            tag_directive != emitter->tag_directives.top; tag_directive ++) {
 
1453
        size_t prefix_length = strlen((char *)tag_directive->prefix);
 
1454
        if (prefix_length < (size_t)(string.end - string.start)
 
1455
                && strncmp((char *)tag_directive->prefix, (char *)string.start,
 
1456
                    prefix_length) == 0)
 
1457
        {
 
1458
            emitter->tag_data.handle = tag_directive->handle;
 
1459
            emitter->tag_data.handle_length =
 
1460
                strlen((char *)tag_directive->handle);
 
1461
            emitter->tag_data.suffix = string.start + prefix_length;
 
1462
            emitter->tag_data.suffix_length =
 
1463
                (string.end - string.start) - prefix_length;
 
1464
            return 1;
 
1465
        }
 
1466
    }
 
1467
 
 
1468
    emitter->tag_data.suffix = string.start;
 
1469
    emitter->tag_data.suffix_length = string.end - string.start;
 
1470
 
 
1471
    return 1;
 
1472
}
 
1473
 
 
1474
/*
 
1475
 * Check if a scalar is valid.
 
1476
 */
 
1477
 
 
1478
static int
 
1479
yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
 
1480
        yaml_char_t *value, size_t length)
 
1481
{
 
1482
    yaml_string_t string;
 
1483
 
 
1484
    int block_indicators = 0;
 
1485
    int flow_indicators = 0;
 
1486
    int line_breaks = 0;
 
1487
    int special_characters = 0;
 
1488
 
 
1489
    int leading_space = 0;
 
1490
    int leading_break = 0;
 
1491
    int trailing_space = 0;
 
1492
    int trailing_break = 0;
 
1493
    int break_space = 0;
 
1494
    int space_break = 0;
 
1495
 
 
1496
    int preceeded_by_whitespace = 0;
 
1497
    int followed_by_whitespace = 0;
 
1498
    int previous_space = 0;
 
1499
    int previous_break = 0;
 
1500
 
 
1501
    STRING_ASSIGN(string, value, length);
 
1502
 
 
1503
    emitter->scalar_data.value = value;
 
1504
    emitter->scalar_data.length = length;
 
1505
 
 
1506
    if (string.start == string.end)
 
1507
    {
 
1508
        emitter->scalar_data.multiline = 0;
 
1509
        emitter->scalar_data.flow_plain_allowed = 0;
 
1510
        emitter->scalar_data.block_plain_allowed = 1;
 
1511
        emitter->scalar_data.single_quoted_allowed = 1;
 
1512
        emitter->scalar_data.block_allowed = 0;
 
1513
 
 
1514
        return 1;
 
1515
    }
 
1516
 
 
1517
    if ((CHECK_AT(string, '-', 0)
 
1518
                && CHECK_AT(string, '-', 1)
 
1519
                && CHECK_AT(string, '-', 2))
 
1520
            || (CHECK_AT(string, '.', 0)
 
1521
                && CHECK_AT(string, '.', 1)
 
1522
                && CHECK_AT(string, '.', 2))) {
 
1523
        block_indicators = 1;
 
1524
        flow_indicators = 1;
 
1525
    }
 
1526
 
 
1527
    preceeded_by_whitespace = 1;
 
1528
    followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
 
1529
 
 
1530
    while (string.pointer != string.end)
 
1531
    {
 
1532
        if (string.start == string.pointer)
 
1533
        {
 
1534
            if (CHECK(string, '#') || CHECK(string, ',')
 
1535
                    || CHECK(string, '[') || CHECK(string, ']')
 
1536
                    || CHECK(string, '{') || CHECK(string, '}')
 
1537
                    || CHECK(string, '&') || CHECK(string, '*')
 
1538
                    || CHECK(string, '!') || CHECK(string, '|')
 
1539
                    || CHECK(string, '>') || CHECK(string, '\'')
 
1540
                    || CHECK(string, '"') || CHECK(string, '%')
 
1541
                    || CHECK(string, '@') || CHECK(string, '`')) {
 
1542
                flow_indicators = 1;
 
1543
                block_indicators = 1;
 
1544
            }
 
1545
 
 
1546
            if (CHECK(string, '?') || CHECK(string, ':')) {
 
1547
                flow_indicators = 1;
 
1548
                if (followed_by_whitespace) {
 
1549
                    block_indicators = 1;
 
1550
                }
 
1551
            }
 
1552
 
 
1553
            if (CHECK(string, '-') && followed_by_whitespace) {
 
1554
                flow_indicators = 1;
 
1555
                block_indicators = 1;
 
1556
            }
 
1557
        }
 
1558
        else
 
1559
        {
 
1560
            if (CHECK(string, ',') || CHECK(string, '?')
 
1561
                    || CHECK(string, '[') || CHECK(string, ']')
 
1562
                    || CHECK(string, '{') || CHECK(string, '}')) {
 
1563
                flow_indicators = 1;
 
1564
            }
 
1565
 
 
1566
            if (CHECK(string, ':')) {
 
1567
                flow_indicators = 1;
 
1568
                if (followed_by_whitespace) {
 
1569
                    block_indicators = 1;
 
1570
                }
 
1571
            }
 
1572
 
 
1573
            if (CHECK(string, '#') && preceeded_by_whitespace) {
 
1574
                flow_indicators = 1;
 
1575
                block_indicators = 1;
 
1576
            }
 
1577
        }
 
1578
 
 
1579
        if (!IS_PRINTABLE(string)
 
1580
                || (!IS_ASCII(string) && !emitter->unicode)) {
 
1581
            special_characters = 1;
 
1582
        }
 
1583
 
 
1584
        if (IS_BREAK(string)) {
 
1585
            line_breaks = 1;
 
1586
        }
 
1587
 
 
1588
        if (IS_SPACE(string))
 
1589
        {
 
1590
            if (string.start == string.pointer) {
 
1591
                leading_space = 1;
 
1592
            }
 
1593
            if (string.pointer+WIDTH(string) == string.end) {
 
1594
                trailing_space = 1;
 
1595
            }
 
1596
            if (previous_break) {
 
1597
                break_space = 1;
 
1598
            }
 
1599
            previous_space = 1;
 
1600
            previous_break = 0;
 
1601
        }
 
1602
        else if (IS_BREAK(string))
 
1603
        {
 
1604
            if (string.start == string.pointer) {
 
1605
                leading_break = 1;
 
1606
            }
 
1607
            if (string.pointer+WIDTH(string) == string.end) {
 
1608
                trailing_break = 1;
 
1609
            }
 
1610
            if (previous_space) {
 
1611
                space_break = 1;
 
1612
            }
 
1613
            previous_space = 0;
 
1614
            previous_break = 1;
 
1615
        }
 
1616
        else
 
1617
        {
 
1618
            previous_space = 0;
 
1619
            previous_break = 0;
 
1620
        }
 
1621
 
 
1622
        preceeded_by_whitespace = IS_BLANKZ(string);
 
1623
        MOVE(string);
 
1624
        if (string.pointer != string.end) {
 
1625
            followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
 
1626
        }
 
1627
    }
 
1628
 
 
1629
    emitter->scalar_data.multiline = line_breaks;
 
1630
 
 
1631
    emitter->scalar_data.flow_plain_allowed = 1;
 
1632
    emitter->scalar_data.block_plain_allowed = 1;
 
1633
    emitter->scalar_data.single_quoted_allowed = 1;
 
1634
    emitter->scalar_data.block_allowed = 1;
 
1635
 
 
1636
    if (leading_space || leading_break || trailing_space || trailing_break) {
 
1637
        emitter->scalar_data.flow_plain_allowed = 0;
 
1638
        emitter->scalar_data.block_plain_allowed = 0;
 
1639
    }
 
1640
 
 
1641
    if (trailing_space) {
 
1642
        emitter->scalar_data.block_allowed = 0;
 
1643
    }
 
1644
 
 
1645
    if (break_space) {
 
1646
        emitter->scalar_data.flow_plain_allowed = 0;
 
1647
        emitter->scalar_data.block_plain_allowed = 0;
 
1648
        emitter->scalar_data.single_quoted_allowed = 0;
 
1649
    }
 
1650
 
 
1651
    if (space_break || special_characters) {
 
1652
        emitter->scalar_data.flow_plain_allowed = 0;
 
1653
        emitter->scalar_data.block_plain_allowed = 0;
 
1654
        emitter->scalar_data.single_quoted_allowed = 0;
 
1655
        emitter->scalar_data.block_allowed = 0;
 
1656
    }
 
1657
 
 
1658
    if (line_breaks) {
 
1659
        emitter->scalar_data.flow_plain_allowed = 0;
 
1660
        emitter->scalar_data.block_plain_allowed = 0;
 
1661
    }
 
1662
 
 
1663
    if (flow_indicators) {
 
1664
        emitter->scalar_data.flow_plain_allowed = 0;
 
1665
    }
 
1666
 
 
1667
    if (block_indicators) {
 
1668
        emitter->scalar_data.block_plain_allowed = 0;
 
1669
    }
 
1670
 
 
1671
    return 1;
 
1672
}
 
1673
 
 
1674
/*
 
1675
 * Check if the event data is valid.
 
1676
 */
 
1677
 
 
1678
static int
 
1679
yaml_emitter_analyze_event(yaml_emitter_t *emitter,
 
1680
        yaml_event_t *event)
 
1681
{
 
1682
    emitter->anchor_data.anchor = NULL;
 
1683
    emitter->anchor_data.anchor_length = 0;
 
1684
    emitter->tag_data.handle = NULL;
 
1685
    emitter->tag_data.handle_length = 0;
 
1686
    emitter->tag_data.suffix = NULL;
 
1687
    emitter->tag_data.suffix_length = 0;
 
1688
    emitter->scalar_data.value = NULL;
 
1689
    emitter->scalar_data.length = 0;
 
1690
 
 
1691
    switch (event->type)
 
1692
    {
 
1693
        case YAML_ALIAS_EVENT:
 
1694
            if (!yaml_emitter_analyze_anchor(emitter,
 
1695
                        event->data.alias.anchor, 1))
 
1696
                return 0;
 
1697
            return 1;
 
1698
 
 
1699
        case YAML_SCALAR_EVENT:
 
1700
            if (event->data.scalar.anchor) {
 
1701
                if (!yaml_emitter_analyze_anchor(emitter,
 
1702
                            event->data.scalar.anchor, 0))
 
1703
                    return 0;
 
1704
            }
 
1705
            if (event->data.scalar.tag && (emitter->canonical ||
 
1706
                        (!event->data.scalar.plain_implicit
 
1707
                         && !event->data.scalar.quoted_implicit))) {
 
1708
                if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag))
 
1709
                    return 0;
 
1710
            }
 
1711
            if (!yaml_emitter_analyze_scalar(emitter,
 
1712
                        event->data.scalar.value, event->data.scalar.length))
 
1713
                return 0;
 
1714
            return 1;
 
1715
 
 
1716
        case YAML_SEQUENCE_START_EVENT:
 
1717
            if (event->data.sequence_start.anchor) {
 
1718
                if (!yaml_emitter_analyze_anchor(emitter,
 
1719
                            event->data.sequence_start.anchor, 0))
 
1720
                    return 0;
 
1721
            }
 
1722
            if (event->data.sequence_start.tag && (emitter->canonical ||
 
1723
                        !event->data.sequence_start.implicit)) {
 
1724
                if (!yaml_emitter_analyze_tag(emitter,
 
1725
                            event->data.sequence_start.tag))
 
1726
                    return 0;
 
1727
            }
 
1728
            return 1;
 
1729
 
 
1730
        case YAML_MAPPING_START_EVENT:
 
1731
            if (event->data.mapping_start.anchor) {
 
1732
                if (!yaml_emitter_analyze_anchor(emitter,
 
1733
                            event->data.mapping_start.anchor, 0))
 
1734
                    return 0;
 
1735
            }
 
1736
            if (event->data.mapping_start.tag && (emitter->canonical ||
 
1737
                        !event->data.mapping_start.implicit)) {
 
1738
                if (!yaml_emitter_analyze_tag(emitter,
 
1739
                            event->data.mapping_start.tag))
 
1740
                    return 0;
 
1741
            }
 
1742
            return 1;
 
1743
 
 
1744
        default:
 
1745
            return 1;
 
1746
    }
 
1747
}
 
1748
 
 
1749
/*
 
1750
 * Write the BOM character.
 
1751
 */
 
1752
 
 
1753
static int
 
1754
yaml_emitter_write_bom(yaml_emitter_t *emitter)
 
1755
{
 
1756
    if (!FLUSH(emitter)) return 0;
 
1757
 
 
1758
    *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
 
1759
    *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
 
1760
    *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';
 
1761
 
 
1762
    return 1;
 
1763
}
 
1764
 
 
1765
static int
 
1766
yaml_emitter_write_indent(yaml_emitter_t *emitter)
 
1767
{
 
1768
    int indent = (emitter->indent >= 0) ? emitter->indent : 0;
 
1769
 
 
1770
    if (!emitter->indention || emitter->column > indent
 
1771
            || (emitter->column == indent && !emitter->whitespace)) {
 
1772
        if (!PUT_BREAK(emitter)) return 0;
 
1773
    }
 
1774
 
 
1775
    while (emitter->column < indent) {
 
1776
        if (!PUT(emitter, ' ')) return 0;
 
1777
    }
 
1778
 
 
1779
    emitter->whitespace = 1;
 
1780
    emitter->indention = 1;
 
1781
 
 
1782
    return 1;
 
1783
}
 
1784
 
 
1785
static int
 
1786
yaml_emitter_write_indicator(yaml_emitter_t *emitter,
 
1787
        char *indicator, int need_whitespace,
 
1788
        int is_whitespace, int is_indention)
 
1789
{
 
1790
    size_t indicator_length;
 
1791
    yaml_string_t string;
 
1792
 
 
1793
    indicator_length = strlen(indicator);
 
1794
    STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length);
 
1795
 
 
1796
    if (need_whitespace && !emitter->whitespace) {
 
1797
        if (!PUT(emitter, ' ')) return 0;
 
1798
    }
 
1799
 
 
1800
    while (string.pointer != string.end) {
 
1801
        if (!WRITE(emitter, string)) return 0;
 
1802
    }
 
1803
 
 
1804
    emitter->whitespace = is_whitespace;
 
1805
    emitter->indention = (emitter->indention && is_indention);
 
1806
    emitter->open_ended = 0;
 
1807
 
 
1808
    return 1;
 
1809
}
 
1810
 
 
1811
static int
 
1812
yaml_emitter_write_anchor(yaml_emitter_t *emitter,
 
1813
        yaml_char_t *value, size_t length)
 
1814
{
 
1815
    yaml_string_t string;
 
1816
    STRING_ASSIGN(string, value, length);
 
1817
 
 
1818
    while (string.pointer != string.end) {
 
1819
        if (!WRITE(emitter, string)) return 0;
 
1820
    }
 
1821
 
 
1822
    emitter->whitespace = 0;
 
1823
    emitter->indention = 0;
 
1824
 
 
1825
    return 1;
 
1826
}
 
1827
 
 
1828
static int
 
1829
yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
 
1830
        yaml_char_t *value, size_t length)
 
1831
{
 
1832
    yaml_string_t string;
 
1833
    STRING_ASSIGN(string, value, length);
 
1834
 
 
1835
    if (!emitter->whitespace) {
 
1836
        if (!PUT(emitter, ' ')) return 0;
 
1837
    }
 
1838
 
 
1839
    while (string.pointer != string.end) {
 
1840
        if (!WRITE(emitter, string)) return 0;
 
1841
    }
 
1842
 
 
1843
    emitter->whitespace = 0;
 
1844
    emitter->indention = 0;
 
1845
 
 
1846
    return 1;
 
1847
}
 
1848
 
 
1849
static int
 
1850
yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
 
1851
        yaml_char_t *value, size_t length,
 
1852
        int need_whitespace)
 
1853
{
 
1854
    yaml_string_t string;
 
1855
    STRING_ASSIGN(string, value, length);
 
1856
 
 
1857
    if (need_whitespace && !emitter->whitespace) {
 
1858
        if (!PUT(emitter, ' ')) return 0;
 
1859
    }
 
1860
 
 
1861
    while (string.pointer != string.end) {
 
1862
        if (IS_ALPHA(string)
 
1863
                || CHECK(string, ';') || CHECK(string, '/')
 
1864
                || CHECK(string, '?') || CHECK(string, ':')
 
1865
                || CHECK(string, '@') || CHECK(string, '&')
 
1866
                || CHECK(string, '=') || CHECK(string, '+')
 
1867
                || CHECK(string, '$') || CHECK(string, ',')
 
1868
                || CHECK(string, '_') || CHECK(string, '.')
 
1869
                || CHECK(string, '~') || CHECK(string, '*')
 
1870
                || CHECK(string, '\'') || CHECK(string, '(')
 
1871
                || CHECK(string, ')') || CHECK(string, '[')
 
1872
                || CHECK(string, ']')) {
 
1873
            if (!WRITE(emitter, string)) return 0;
 
1874
        }
 
1875
        else {
 
1876
            int width = WIDTH(string);
 
1877
            unsigned int value;
 
1878
            while (width --) {
 
1879
                value = *(string.pointer++);
 
1880
                if (!PUT(emitter, '%')) return 0;
 
1881
                if (!PUT(emitter, (value >> 4)
 
1882
                            + ((value >> 4) < 10 ? '0' : 'A' - 10)))
 
1883
                    return 0;
 
1884
                if (!PUT(emitter, (value & 0x0F)
 
1885
                            + ((value & 0x0F) < 10 ? '0' : 'A' - 10)))
 
1886
                    return 0;
 
1887
            }
 
1888
        }
 
1889
    }
 
1890
 
 
1891
    emitter->whitespace = 0;
 
1892
    emitter->indention = 0;
 
1893
 
 
1894
    return 1;
 
1895
}
 
1896
 
 
1897
static int
 
1898
yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
 
1899
        yaml_char_t *value, size_t length, int allow_breaks)
 
1900
{
 
1901
    yaml_string_t string;
 
1902
    int spaces = 0;
 
1903
    int breaks = 0;
 
1904
 
 
1905
    STRING_ASSIGN(string, value, length);
 
1906
 
 
1907
    if (!emitter->whitespace) {
 
1908
        if (!PUT(emitter, ' ')) return 0;
 
1909
    }
 
1910
 
 
1911
    while (string.pointer != string.end)
 
1912
    {
 
1913
        if (IS_SPACE(string))
 
1914
        {
 
1915
            if (allow_breaks && !spaces
 
1916
                    && emitter->column > emitter->best_width
 
1917
                    && !IS_SPACE_AT(string, 1)) {
 
1918
                if (!yaml_emitter_write_indent(emitter)) return 0;
 
1919
                MOVE(string);
 
1920
            }
 
1921
            else {
 
1922
                if (!WRITE(emitter, string)) return 0;
 
1923
            }
 
1924
            spaces = 1;
 
1925
        }
 
1926
        else if (IS_BREAK(string))
 
1927
        {
 
1928
            if (!breaks && CHECK(string, '\n')) {
 
1929
                if (!PUT_BREAK(emitter)) return 0;
 
1930
            }
 
1931
            if (!WRITE_BREAK(emitter, string)) return 0;
 
1932
            emitter->indention = 1;
 
1933
            breaks = 1;
 
1934
        }
 
1935
        else
 
1936
        {
 
1937
            if (breaks) {
 
1938
                if (!yaml_emitter_write_indent(emitter)) return 0;
 
1939
            }
 
1940
            if (!WRITE(emitter, string)) return 0;
 
1941
            emitter->indention = 0;
 
1942
            spaces = 0;
 
1943
            breaks = 0;
 
1944
        }
 
1945
    }
 
1946
 
 
1947
    emitter->whitespace = 0;
 
1948
    emitter->indention = 0;
 
1949
    if (emitter->root_context)
 
1950
    {
 
1951
        emitter->open_ended = 1;
 
1952
    }
 
1953
 
 
1954
    return 1;
 
1955
}
 
1956
 
 
1957
static int
 
1958
yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
 
1959
        yaml_char_t *value, size_t length, int allow_breaks)
 
1960
{
 
1961
    yaml_string_t string;
 
1962
    int spaces = 0;
 
1963
    int breaks = 0;
 
1964
 
 
1965
    STRING_ASSIGN(string, value, length);
 
1966
 
 
1967
    if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0))
 
1968
        return 0;
 
1969
 
 
1970
    while (string.pointer != string.end)
 
1971
    {
 
1972
        if (IS_SPACE(string))
 
1973
        {
 
1974
            if (allow_breaks && !spaces
 
1975
                    && emitter->column > emitter->best_width
 
1976
                    && string.pointer != string.start
 
1977
                    && string.pointer != string.end - 1
 
1978
                    && !IS_SPACE_AT(string, 1)) {
 
1979
                if (!yaml_emitter_write_indent(emitter)) return 0;
 
1980
                MOVE(string);
 
1981
            }
 
1982
            else {
 
1983
                if (!WRITE(emitter, string)) return 0;
 
1984
            }
 
1985
            spaces = 1;
 
1986
        }
 
1987
        else if (IS_BREAK(string))
 
1988
        {
 
1989
            if (!breaks && CHECK(string, '\n')) {
 
1990
                if (!PUT_BREAK(emitter)) return 0;
 
1991
            }
 
1992
            if (!WRITE_BREAK(emitter, string)) return 0;
 
1993
            emitter->indention = 1;
 
1994
            breaks = 1;
 
1995
        }
 
1996
        else
 
1997
        {
 
1998
            if (breaks) {
 
1999
                if (!yaml_emitter_write_indent(emitter)) return 0;
 
2000
            }
 
2001
            if (CHECK(string, '\'')) {
 
2002
                if (!PUT(emitter, '\'')) return 0;
 
2003
            }
 
2004
            if (!WRITE(emitter, string)) return 0;
 
2005
            emitter->indention = 0;
 
2006
            spaces = 0;
 
2007
            breaks = 0;
 
2008
        }
 
2009
    }
 
2010
 
 
2011
    if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0))
 
2012
        return 0;
 
2013
 
 
2014
    emitter->whitespace = 0;
 
2015
    emitter->indention = 0;
 
2016
 
 
2017
    return 1;
 
2018
}
 
2019
 
 
2020
static int
 
2021
yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
 
2022
        yaml_char_t *value, size_t length, int allow_breaks)
 
2023
{
 
2024
    yaml_string_t string;
 
2025
    int spaces = 0;
 
2026
 
 
2027
    STRING_ASSIGN(string, value, length);
 
2028
 
 
2029
    if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0))
 
2030
        return 0;
 
2031
 
 
2032
    while (string.pointer != string.end)
 
2033
    {
 
2034
        if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string))
 
2035
                || IS_BOM(string) || IS_BREAK(string)
 
2036
                || CHECK(string, '"') || CHECK(string, '\\'))
 
2037
        {
 
2038
            unsigned char octet;
 
2039
            unsigned int width;
 
2040
            unsigned int value;
 
2041
            int k;
 
2042
 
 
2043
            octet = string.pointer[0];
 
2044
            width = (octet & 0x80) == 0x00 ? 1 :
 
2045
                    (octet & 0xE0) == 0xC0 ? 2 :
 
2046
                    (octet & 0xF0) == 0xE0 ? 3 :
 
2047
                    (octet & 0xF8) == 0xF0 ? 4 : 0;
 
2048
            value = (octet & 0x80) == 0x00 ? octet & 0x7F :
 
2049
                    (octet & 0xE0) == 0xC0 ? octet & 0x1F :
 
2050
                    (octet & 0xF0) == 0xE0 ? octet & 0x0F :
 
2051
                    (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
 
2052
            for (k = 1; k < (int)width; k ++) {
 
2053
                octet = string.pointer[k];
 
2054
                value = (value << 6) + (octet & 0x3F);
 
2055
            }
 
2056
            string.pointer += width;
 
2057
 
 
2058
            if (!PUT(emitter, '\\')) return 0;
 
2059
 
 
2060
            switch (value)
 
2061
            {
 
2062
                case 0x00:
 
2063
                    if (!PUT(emitter, '0')) return 0;
 
2064
                    break;
 
2065
 
 
2066
                case 0x07:
 
2067
                    if (!PUT(emitter, 'a')) return 0;
 
2068
                    break;
 
2069
 
 
2070
                case 0x08:
 
2071
                    if (!PUT(emitter, 'b')) return 0;
 
2072
                    break;
 
2073
 
 
2074
                case 0x09:
 
2075
                    if (!PUT(emitter, 't')) return 0;
 
2076
                    break;
 
2077
 
 
2078
                case 0x0A:
 
2079
                    if (!PUT(emitter, 'n')) return 0;
 
2080
                    break;
 
2081
 
 
2082
                case 0x0B:
 
2083
                    if (!PUT(emitter, 'v')) return 0;
 
2084
                    break;
 
2085
 
 
2086
                case 0x0C:
 
2087
                    if (!PUT(emitter, 'f')) return 0;
 
2088
                    break;
 
2089
 
 
2090
                case 0x0D:
 
2091
                    if (!PUT(emitter, 'r')) return 0;
 
2092
                    break;
 
2093
 
 
2094
                case 0x1B:
 
2095
                    if (!PUT(emitter, 'e')) return 0;
 
2096
                    break;
 
2097
 
 
2098
                case 0x22:
 
2099
                    if (!PUT(emitter, '\"')) return 0;
 
2100
                    break;
 
2101
 
 
2102
                case 0x5C:
 
2103
                    if (!PUT(emitter, '\\')) return 0;
 
2104
                    break;
 
2105
 
 
2106
                case 0x85:
 
2107
                    if (!PUT(emitter, 'N')) return 0;
 
2108
                    break;
 
2109
 
 
2110
                case 0xA0:
 
2111
                    if (!PUT(emitter, '_')) return 0;
 
2112
                    break;
 
2113
 
 
2114
                case 0x2028:
 
2115
                    if (!PUT(emitter, 'L')) return 0;
 
2116
                    break;
 
2117
 
 
2118
                case 0x2029:
 
2119
                    if (!PUT(emitter, 'P')) return 0;
 
2120
                    break;
 
2121
 
 
2122
                default:
 
2123
                    if (value <= 0xFF) {
 
2124
                        if (!PUT(emitter, 'x')) return 0;
 
2125
                        width = 2;
 
2126
                    }
 
2127
                    else if (value <= 0xFFFF) {
 
2128
                        if (!PUT(emitter, 'u')) return 0;
 
2129
                        width = 4;
 
2130
                    }
 
2131
                    else {
 
2132
                        if (!PUT(emitter, 'U')) return 0;
 
2133
                        width = 8;
 
2134
                    }
 
2135
                    for (k = (width-1)*4; k >= 0; k -= 4) {
 
2136
                        int digit = (value >> k) & 0x0F;
 
2137
                        if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10)))
 
2138
                            return 0;
 
2139
                    }
 
2140
            }
 
2141
            spaces = 0;
 
2142
        }
 
2143
        else if (IS_SPACE(string))
 
2144
        {
 
2145
            if (allow_breaks && !spaces
 
2146
                    && emitter->column > emitter->best_width
 
2147
                    && string.pointer != string.start
 
2148
                    && string.pointer != string.end - 1) {
 
2149
                if (!yaml_emitter_write_indent(emitter)) return 0;
 
2150
                if (IS_SPACE_AT(string, 1)) {
 
2151
                    if (!PUT(emitter, '\\')) return 0;
 
2152
                }
 
2153
                MOVE(string);
 
2154
            }
 
2155
            else {
 
2156
                if (!WRITE(emitter, string)) return 0;
 
2157
            }
 
2158
            spaces = 1;
 
2159
        }
 
2160
        else
 
2161
        {
 
2162
            if (!WRITE(emitter, string)) return 0;
 
2163
            spaces = 0;
 
2164
        }
 
2165
    }
 
2166
 
 
2167
    if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0))
 
2168
        return 0;
 
2169
 
 
2170
    emitter->whitespace = 0;
 
2171
    emitter->indention = 0;
 
2172
 
 
2173
    return 1;
 
2174
}
 
2175
 
 
2176
static int
 
2177
yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
 
2178
        yaml_string_t string)
 
2179
{
 
2180
    char indent_hint[2];
 
2181
    char *chomp_hint = NULL;
 
2182
 
 
2183
    if (IS_SPACE(string) || IS_BREAK(string))
 
2184
    {
 
2185
        indent_hint[0] = '0' + (char)emitter->best_indent;
 
2186
        indent_hint[1] = '\0';
 
2187
        if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0))
 
2188
            return 0;
 
2189
    }
 
2190
 
 
2191
    emitter->open_ended = 0;
 
2192
 
 
2193
    string.pointer = string.end;
 
2194
    if (string.start == string.pointer)
 
2195
    {
 
2196
        chomp_hint = "-";
 
2197
    }
 
2198
    else
 
2199
    {
 
2200
        do {
 
2201
            string.pointer --;
 
2202
        } while ((*string.pointer & 0xC0) == 0x80);
 
2203
        if (!IS_BREAK(string))
 
2204
        {
 
2205
            chomp_hint = "-";
 
2206
        }
 
2207
        else if (string.start == string.pointer)
 
2208
        {
 
2209
            chomp_hint = "+";
 
2210
            emitter->open_ended = 1;
 
2211
        }
 
2212
        else
 
2213
        {
 
2214
            do {
 
2215
                string.pointer --;
 
2216
            } while ((*string.pointer & 0xC0) == 0x80);
 
2217
            if (IS_BREAK(string))
 
2218
            {
 
2219
                chomp_hint = "+";
 
2220
                emitter->open_ended = 1;
 
2221
            }
 
2222
        }
 
2223
    }
 
2224
 
 
2225
    if (chomp_hint)
 
2226
    {
 
2227
        if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0))
 
2228
            return 0;
 
2229
    }
 
2230
 
 
2231
    return 1;
 
2232
}
 
2233
 
 
2234
static int
 
2235
yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
 
2236
        yaml_char_t *value, size_t length)
 
2237
{
 
2238
    yaml_string_t string;
 
2239
    int breaks = 1;
 
2240
 
 
2241
    STRING_ASSIGN(string, value, length);
 
2242
 
 
2243
    if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0))
 
2244
        return 0;
 
2245
    if (!yaml_emitter_write_block_scalar_hints(emitter, string))
 
2246
        return 0;
 
2247
    if (!PUT_BREAK(emitter)) return 0;
 
2248
    emitter->indention = 1;
 
2249
    emitter->whitespace = 1;
 
2250
 
 
2251
    while (string.pointer != string.end)
 
2252
    {
 
2253
        if (IS_BREAK(string))
 
2254
        {
 
2255
            if (!WRITE_BREAK(emitter, string)) return 0;
 
2256
            emitter->indention = 1;
 
2257
            breaks = 1;
 
2258
        }
 
2259
        else
 
2260
        {
 
2261
            if (breaks) {
 
2262
                if (!yaml_emitter_write_indent(emitter)) return 0;
 
2263
            }
 
2264
            if (!WRITE(emitter, string)) return 0;
 
2265
            emitter->indention = 0;
 
2266
            breaks = 0;
 
2267
        }
 
2268
    }
 
2269
 
 
2270
    return 1;
 
2271
}
 
2272
 
 
2273
static int
 
2274
yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
 
2275
        yaml_char_t *value, size_t length)
 
2276
{
 
2277
    yaml_string_t string;
 
2278
    int breaks = 1;
 
2279
    int leading_spaces = 1;
 
2280
 
 
2281
    STRING_ASSIGN(string, value, length);
 
2282
 
 
2283
    if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0))
 
2284
        return 0;
 
2285
    if (!yaml_emitter_write_block_scalar_hints(emitter, string))
 
2286
        return 0;
 
2287
    if (!PUT_BREAK(emitter)) return 0;
 
2288
    emitter->indention = 1;
 
2289
    emitter->whitespace = 1;
 
2290
 
 
2291
    while (string.pointer != string.end)
 
2292
    {
 
2293
        if (IS_BREAK(string))
 
2294
        {
 
2295
            if (!breaks && !leading_spaces && CHECK(string, '\n')) {
 
2296
                int k = 0;
 
2297
                while (IS_BREAK_AT(string, k)) {
 
2298
                    k += WIDTH_AT(string, k);
 
2299
                }
 
2300
                if (!IS_BLANKZ_AT(string, k)) {
 
2301
                    if (!PUT_BREAK(emitter)) return 0;
 
2302
                }
 
2303
            }
 
2304
            if (!WRITE_BREAK(emitter, string)) return 0;
 
2305
            emitter->indention = 1;
 
2306
            breaks = 1;
 
2307
        }
 
2308
        else
 
2309
        {
 
2310
            if (breaks) {
 
2311
                if (!yaml_emitter_write_indent(emitter)) return 0;
 
2312
                leading_spaces = IS_BLANK(string);
 
2313
            }
 
2314
            if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1)
 
2315
                    && emitter->column > emitter->best_width) {
 
2316
                if (!yaml_emitter_write_indent(emitter)) return 0;
 
2317
                MOVE(string);
 
2318
            }
 
2319
            else {
 
2320
                if (!WRITE(emitter, string)) return 0;
 
2321
            }
 
2322
            emitter->indention = 0;
 
2323
            breaks = 0;
 
2324
        }
 
2325
    }
 
2326
 
 
2327
    return 1;
 
2328
}
 
2329