← Back to branch summary

~ubuntu-branches/ubuntu/saucy/juju-core/saucy-proposed

« 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-07-11 17:18:27 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20130711171827-vjqkg40r0dlf7ys2
Tags: 1.11.2-0ubuntu1
https://launchpad.net/bugs/1190634
https://launchpad.net/bugs/1172505
* New upstream release.
* Make juju-core the default juju (LP: #1190634):
  - d/control: Add virtual package juju -> juju-core.
  - d/juju-core.postinst.in: Bump priority of alternatives over that of
    python juju packages.
* Enable for all architectures (LP: #1172505):
  - d/control: Version BD on golang-go to >= 2:1.1.1 to ensure CGO
    support for non-x86 archs, make juju-core Arch: any.
  - d/README.source: Dropped - no longer required.
* d/watch: Updated for new upstream tarball naming.

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