source: libyaml/trunk/src/yaml_private.h @ 267

Revision 267, 54.9 KB checked in by xi, 6 years ago (diff)

Minor API updates.

Line 
1/*****************************************************************************
2 * Private Definitions for LibYAML
3 *
4 * Copyright (c) 2006 Kirill Simonov
5 *
6 * LibYAML is free software; you can use, modify and/or redistribute it under
7 * the terms of the MIT license; see the file LICENCE for more details.
8 *****************************************************************************/
9
10#if HAVE_CONFIG_H
11#include <config.h>
12#endif
13
14#include <yaml.h>
15
16#include <assert.h>
17#include <limits.h>
18#include <errno.h>
19#include <ctype.h>
20#include <locale.h>
21
22/*****************************************************************************
23 * Memory Management
24 *****************************************************************************/
25
26YAML_DECLARE(void *)
27yaml_malloc(size_t size);
28
29YAML_DECLARE(void *)
30yaml_realloc(void *ptr, size_t size);
31
32YAML_DECLARE(void)
33yaml_free(void *ptr);
34
35YAML_DECLARE(yaml_char_t *)
36yaml_strdup(const yaml_char_t *);
37
38/*****************************************************************************
39 * Error Management
40 *****************************************************************************/
41
42/*
43 * Generic error initializers; not to be used directly.
44 */
45
46#define ERROR_INIT(error, _type)                                                \
47    (memset(&(error), 0, sizeof(yaml_error_t)),                                 \
48     (error).type = (_type),                                                    \
49     0)
50
51#define READING_ERROR_INIT(error, _type, _problem, _offset, _value)             \
52    (ERROR_INIT(error, _type),                                                  \
53     (error).data.reading.problem = (_problem),                                 \
54     (error).data.reading.offset = (_offset),                                   \
55     (error).data.reading.value = (_value),                                     \
56     0)
57
58#define LOADING_ERROR_INIT(error, _type, _problem, _problem_mark)               \
59    (ERROR_INIT(error, _type),                                                  \
60     (error).data.loading.context = NULL,                                       \
61     (error).data.loading.context_mark.index = 0,                               \
62     (error).data.loading.context_mark.line = 0,                                \
63     (error).data.loading.context_mark.column = 0,                              \
64     (error).data.loading.problem = (_problem),                                 \
65     (error).data.loading.problem_mark = (_problem_mark),                       \
66     0)
67
68#define LOADING_ERROR_WITH_CONTEXT_INIT(error, _type, _context, _context_mark,  \
69        _problem, _problem_mark)                                                \
70    (ERROR_INIT(error, _type),                                                  \
71     (error).data.loading.context = (_context),                                 \
72     (error).data.loading.context_mark = (_context_mark),                       \
73     (error).data.loading.problem = (_problem),                                 \
74     (error).data.loading.problem_mark = (_problem_mark),                       \
75     0)
76
77#define WRITING_ERROR_INIT(error, _type, _problem, _offset)                     \
78    (ERROR_INIT(error, _type),                                                  \
79     (error).data.writing.problem = (_problem),                                 \
80     (error).data.writing.offset = (_offset),                                   \
81     0)
82
83#define DUMPING_ERROR_INIT(error, _type, _problem)                              \
84    (ERROR_INIT(error, _type),                                                  \
85     (error).data.dumping.problem = (_problem),                                 \
86     0)
87
88#define RESOLVING_ERROR_INIT(error, _type, _problem)                            \
89    (ERROR_INIT(error, _type),                                                  \
90     (error).data.resolving.problem = (_problem),                               \
91     0)
92
93/*
94 * Specific error initializers.
95 */
96
97#define MEMORY_ERROR_INIT(self)                                                 \
98    ERROR_INIT((self)->error, YAML_MEMORY_ERROR)
99
100#define READER_ERROR_INIT(self, _problem, _offset)                              \
101    READING_ERROR_INIT((self)->error, YAML_READER_ERROR, _problem, _offset, -1)
102
103#define DECODER_ERROR_INIT(self, _problem, _offset, _value)                     \
104    READING_ERROR_INIT((self)->error, YAML_DECODER_ERROR, _problem, _offset, _value)
105
106#define SCANNER_ERROR_INIT(self, _problem, _problem_mark)                       \
107    LOADING_ERROR_INIT((self)->error, YAML_SCANNER_ERROR, _problem, _problem_mark)
108
109#define SCANNER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark,          \
110        _problem, _problem_mark)                                                \
111    LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_SCANNER_ERROR,          \
112            _context, _context_mark, _problem, _problem_mark)
113
114#define PARSER_ERROR_INIT(self, _problem, _problem_mark)                        \
115    LOADING_ERROR_INIT((self)->error, YAML_PARSER_ERROR, _problem, _problem_mark)
116
117#define PARSER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark,           \
118        _problem, _problem_mark)                                                \
119    LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_PARSER_ERROR,           \
120            _context, _context_mark, _problem, _problem_mark)
121
122#define COMPOSER_ERROR_INIT(self, _problem, _problem_mark)                      \
123    LOADING_ERROR_INIT((self)->error, YAML_COMPOSER_ERROR, _problem, _problem_mark)
124
125#define COMPOSER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark,         \
126        _problem, _problem_mark)                                                \
127    LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_COMPOSER_ERROR,         \
128            _context, _context_mark, _problem, _problem_mark)
129
130#define WRITER_ERROR_INIT(self, _problem, _offset)                              \
131    WRITING_ERROR_INIT((self)->error, YAML_WRITER_ERROR, _problem, _offset)
132
133#define EMITTER_ERROR_INIT(self, _problem)                                      \
134    DUMPING_ERROR_INIT((self)->error, YAML_EMITTER_ERROR, _problem)
135
136#define SERIALIZER_ERROR_INIT(self, _problem)                                   \
137    DUMPING_ERROR_INIT((self)->error, YAML_SERIALIZER_ERROR, _problem)
138
139#define RESOLVER_ERROR_INIT(self, _problem)                                     \
140    RESOLVER_ERROR_INIT((self)->error, YAML_RESOLVER_ERROR, _problem)
141
142/*****************************************************************************
143 * Buffer Sizes
144 *****************************************************************************/
145
146/*
147 * The size of the input raw buffer.
148 */
149
150#define RAW_INPUT_BUFFER_CAPACITY   16384
151
152/*
153 * The size of the input buffer.
154 *
155 * The input buffer should be large enough to hold the content of the raw
156 * buffer after it is decoded.  The raw input buffer could be encoded in UTF-8
157 * or UTF-16 while the input buffer is always encoded in UTF-8.  A UTF-16
158 * character may take 2 or 4 bytes, and a UTF-8 character takes up to 4 bytes.
159 * We use the *3 multiplier just to be safe.
160 */
161
162#define INPUT_BUFFER_CAPACITY   (RAW_INPUT_BUFFER_CAPACITY*3)
163
164/*
165 * The size of the output buffer.
166 */
167
168#define OUTPUT_BUFFER_CAPACITY  16384
169
170/*
171 * The size of the output raw buffer.
172 *
173 * The raw buffer should be able to hold the content of the output buffer
174 * after it is encoded.
175 */
176
177#define RAW_OUTPUT_BUFFER_CAPACITY  (OUTPUT_BUFFER_CAPACITY*2+2)
178
179/*
180 * The size of other stacks and queues.
181 */
182
183#define INITIAL_STACK_CAPACITY  16
184#define INITIAL_QUEUE_CAPACITY  16
185#define INITIAL_STRING_CAPACITY 16
186
187/*****************************************************************************
188 * String Management
189 *****************************************************************************/
190
191/*
192 * An immutable string used as an input buffer.
193 */
194
195typedef struct yaml_istring_s {
196    const yaml_char_t *buffer;
197    size_t pointer;
198    size_t length;
199} yaml_istring_t;
200
201/*
202 * A string that is used as an output buffer.
203 */
204
205typedef struct yaml_ostring_s {
206    yaml_char_t *buffer;
207    size_t pointer;
208    size_t capacity;
209} yaml_ostring_t;
210
211/*
212 * A string that could be used both as an input and an output buffer.
213 */
214
215typedef struct yaml_iostring_s {
216    yaml_char_t *buffer;
217    size_t pointer;
218    size_t length;
219    size_t capacity;
220} yaml_iostring_t;
221
222/*
223 * A separate type for non-UTF-8 i/o strings.
224 */
225
226typedef struct yaml_raw_iostring_s {
227    unsigned char *buffer;
228    size_t pointer;
229    size_t length;
230    size_t capacity;
231} yaml_raw_iostring_t;
232
233/*
234 * Double the string capacity.
235 */
236
237YAML_DECLARE(int)
238yaml_ostring_extend(yaml_char_t **buffer, size_t *capacity);
239
240/*
241 * Append a string to the end of the base string expanding it if needed.
242 */
243
244YAML_DECLARE(int)
245yaml_ostring_join(
246        yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity,
247        yaml_char_t *adj_buffer, size_t adj_pointer);
248
249/*
250 * Basic string operations.
251 */
252
253#define ISTRING(buffer, length) { (buffer), 0, (length) }
254
255#define NULL_OSTRING { NULL, 0, 0 }
256
257#define IOSTRING_INIT(self, string, _capacity)                                  \
258    (((string).buffer = yaml_malloc(_capacity)) ?                               \
259        ((string).pointer = (string).length = 0,                                \
260         (string).capacity = (_capacity),                                       \
261         memset((string).buffer, 0, (_capacity)),                               \
262         1) :                                                                   \
263        ((self)->error.type = YAML_MEMORY_ERROR,                                \
264         0))
265
266#define IOSTRING_DEL(self, string)                                              \
267    (yaml_free((string).buffer),                                                \
268     (string).buffer = NULL,                                                    \
269     ((string).pointer = (string).length = (string).capacity = 0))
270
271#define IOSTRING_SET(self, string, _buffer, _capacity)                          \
272    (memset((_buffer), 0, (_capacity)),                                         \
273     (string).buffer = (_buffer),                                               \
274     (string).pointer = (string).length = 0,                                    \
275     (string).capacity = (_capacity))
276
277#define OSTRING_INIT(self, string, _capacity)                                   \
278    (((string).buffer = yaml_malloc(_capacity)) ?                               \
279        ((string).pointer = 0,                                                  \
280         (string).capacity = (_capacity),                                       \
281         memset((string).buffer, 0, (_capacity)),                               \
282         1) :                                                                   \
283        ((self)->error.type = YAML_MEMORY_ERROR,                                \
284         0))
285
286#define OSTRING_DEL(self, string)                                               \
287    (yaml_free((string).buffer),                                                \
288     (string).buffer = NULL,                                                    \
289     ((string).pointer = (string).capacity = 0))
290
291#define OSTRING_EXTEND(self, string)                                            \
292    ((((string).pointer+5 < (string).capacity)                                  \
293        || yaml_ostring_extend(&(string).buffer, &(string).capacity)) ?         \
294     1 :                                                                        \
295     ((self)->error.type = YAML_MEMORY_ERROR,                                   \
296      0))
297
298#define CLEAR(self, string)                                                     \
299    ((string).pointer = 0,                                                      \
300     memset((string).buffer, 0, (string).capacity))
301
302#define JOIN(self, base_string, adj_string)                                     \
303    ((yaml_ostring_join(&(base_string).buffer, &(base_string).pointer,          \
304                       &(base_string).capacity,                                 \
305                       (adj_string).buffer, (adj_string).pointer)) ?            \
306        ((adj_string).pointer = 0,                                              \
307         1) :                                                                   \
308        ((self)->error.type = YAML_MEMORY_ERROR,                                \
309         0))
310
311/*****************************************************************************
312 * String Tests
313 *****************************************************************************/
314
315/*
316 * Get the octet at the specified position.
317 */
318
319#define OCTET_AT(string, offset)                                                \
320    ((string).buffer[(string).pointer+(offset)])
321
322/*
323 * Get the current offset.
324 */
325
326#define OCTET(string)   OCTET_AT((string), 0)
327
328/*
329 * Check the octet at the specified position.
330 */
331
332#define CHECK_AT(string, octet, offset)                                         \
333    (OCTET_AT((string), (offset)) == (yaml_char_t)(octet))
334
335/*
336 * Check the current octet in the buffer.
337 */
338
339#define CHECK(string, octet)    CHECK_AT((string), (octet), 0)
340
341/*
342 * Check if the character at the specified position is an alphabetical
343 * character, a digit, '_', or '-'.
344 */
345
346#define IS_ALPHA_AT(string, offset)                                             \
347     ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' &&                     \
348       OCTET_AT((string), (offset)) <= (yaml_char_t) '9') ||                    \
349      (OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' &&                     \
350       OCTET_AT((string), (offset)) <= (yaml_char_t) 'Z') ||                    \
351      (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' &&                     \
352       OCTET_AT((string), (offset)) <= (yaml_char_t) 'z') ||                    \
353      OCTET_AT((string), (offset)) == '_' ||                                    \
354      OCTET_AT((string), (offset)) == '-')
355
356#define IS_ALPHA(string)    IS_ALPHA_AT((string), 0)
357
358/*
359 * Check if the character at the specified position is a digit.
360 */
361
362#define IS_DIGIT_AT(string, offset)                                             \
363     ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' &&                     \
364       OCTET_AT((string), (offset)) <= (yaml_char_t) '9'))
365
366#define IS_DIGIT(string)    IS_DIGIT_AT((string), 0)
367
368/*
369 * Get the value of a digit.
370 */
371
372#define AS_DIGIT_AT(string, offset)                                             \
373     (OCTET_AT((string), (offset)) - (yaml_char_t) '0')
374
375#define AS_DIGIT(string)    AS_DIGIT_AT((string), 0)
376
377/*
378 * Check if the character at the specified position is a hex-digit.
379 */
380
381#define IS_HEX_AT(string, offset)                                               \
382     ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' &&                     \
383       OCTET_AT((string), (offset)) <= (yaml_char_t) '9') ||                    \
384      (OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' &&                     \
385       OCTET_AT((string), (offset)) <= (yaml_char_t) 'F') ||                    \
386      (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' &&                     \
387       OCTET_AT((string), (offset)) <= (yaml_char_t) 'f'))
388
389#define IS_HEX(string)    IS_HEX_AT((string), 0)
390
391/*
392 * Get the value of a hex-digit.
393 */
394
395#define AS_HEX_AT(string, offset)                                               \
396      ((OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' &&                    \
397        OCTET_AT((string), (offset)) <= (yaml_char_t) 'F') ?                    \
398       (OCTET_AT((string), (offset)) - (yaml_char_t) 'A' + 10) :                \
399       (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' &&                    \
400        OCTET_AT((string), (offset)) <= (yaml_char_t) 'f') ?                    \
401       (OCTET_AT((string), (offset)) - (yaml_char_t) 'a' + 10) :                \
402       (OCTET_AT((string), (offset)) - (yaml_char_t) '0'))
403 
404#define AS_HEX(string)  AS_HEX_AT((string), 0)
405 
406/*
407 * Check if the character is ASCII.
408 */
409
410#define IS_ASCII_AT(string, offset)                                             \
411    (OCTET_AT((string), (offset)) <= (yaml_char_t) '\x7F')
412
413#define IS_ASCII(string)    IS_ASCII_AT((string), 0)
414
415/*
416 * Check if the character can be printed unescaped.
417 */
418
419#define IS_PRINTABLE_AT(string, offset)                                         \
420    ((OCTET_AT((string), (offset)) == 0x0A)         /* . == #x0A */             \
421     || (OCTET_AT((string), (offset)) >= 0x20       /* #x20 <= . <= #x7E */     \
422         && OCTET_AT((string), (offset)) <= 0x7E)                               \
423     || (OCTET_AT((string), (offset)) == 0xC2       /* #0xA0 <= . <= #xD7FF */  \
424         && OCTET_AT((string), (offset)+1) >= 0xA0)                             \
425     || (OCTET_AT((string), (offset)) > 0xC2                                    \
426         && OCTET_AT((string), (offset)) < 0xED)                                \
427     || (OCTET_AT((string), (offset)) == 0xED                                   \
428         && OCTET_AT((string), (offset)+1) < 0xA0)                              \
429     || (OCTET_AT((string), (offset)) == 0xEE)                                  \
430     || (OCTET_AT((string), (offset)) == 0xEF       /* #xE000 <= . <= #xFFFD */ \
431         && !(OCTET_AT((string), (offset)+1) == 0xBB       /* && . != #xFEFF */ \
432             && OCTET_AT((string), (offset)+2) == 0xBF)                         \
433         && !(OCTET_AT((string), (offset)+1) == 0xBF                            \
434             && (OCTET_AT((string), (offset)+2) == 0xBE                         \
435                 || OCTET_AT((string), (offset)+2) == 0xBF))))
436
437#define IS_PRINTABLE(string)    IS_PRINTABLE_AT((string), 0)
438
439/*
440 * Check if the character at the specified position is NUL.
441 */
442
443#define IS_Z_AT(string, offset)   CHECK_AT((string), '\0', (offset))
444
445#define IS_Z(string)    IS_Z_AT((string), 0)
446
447/*
448 * Check if the character at the specified position is BOM.
449 */
450
451#define IS_BOM_AT(string, offset)                                               \
452     (CHECK_AT((string), '\xEF', (offset))                                      \
453      && CHECK_AT((string), '\xBB', (offset)+1)                                 \
454      && CHECK_AT((string), '\xBF', (offset)+2))    /* BOM (#xFEFF) */
455
456#define IS_BOM(string)  IS_BOM_AT(string, 0)
457
458/*
459 * Check if the character at the specified position is space.
460 */
461
462#define IS_SPACE_AT(string, offset) CHECK_AT((string), ' ', (offset))
463
464#define IS_SPACE(string)    IS_SPACE_AT((string), 0)
465
466/*
467 * Check if the character at the specified position is tab.
468 */
469
470#define IS_TAB_AT(string, offset)   CHECK_AT((string), '\t', (offset))
471
472#define IS_TAB(string)  IS_TAB_AT((string), 0)
473
474/*
475 * Check if the character at the specified position is blank (space or tab).
476 */
477
478#define IS_BLANK_AT(string, offset)                                             \
479    (IS_SPACE_AT((string), (offset)) || IS_TAB_AT((string), (offset)))
480
481#define IS_BLANK(string)    IS_BLANK_AT((string), 0)
482
483/*
484 * Check if the character at the specified position is a line break.
485 */
486
487#define IS_BREAK_AT(string, offset)                                             \
488    (CHECK_AT((string), '\r', (offset))                 /* CR (#xD)*/           \
489     || CHECK_AT((string), '\n', (offset))              /* LF (#xA) */          \
490     || (CHECK_AT((string), '\xC2', (offset))                                   \
491         && CHECK_AT((string), '\x85', (offset)+1))     /* NEL (#x85) */        \
492     || (CHECK_AT((string), '\xE2', (offset))                                   \
493         && CHECK_AT((string), '\x80', (offset)+1)                              \
494         && CHECK_AT((string), '\xA8', (offset)+2))     /* LS (#x2028) */       \
495     || (CHECK_AT((string), '\xE2', (offset))                                   \
496         && CHECK_AT((string), '\x80', (offset)+1)                              \
497         && CHECK_AT((string), '\xA9', (offset)+2)))    /* PS (#x2029) */
498
499#define IS_BREAK(string)    IS_BREAK_AT((string), 0)
500
501#define IS_CRLF_AT(string, offset)                                              \
502     (CHECK_AT((string), '\r', (offset)) && CHECK_AT((string), '\n', (offset)+1))
503
504#define IS_CRLF(string) IS_CRLF_AT((string), 0)
505
506/*
507 * Check if the character is a line break or NUL.
508 */
509
510#define IS_BREAKZ_AT(string, offset)                                            \
511    (IS_BREAK_AT((string), (offset)) || IS_Z_AT((string), (offset)))
512
513#define IS_BREAKZ(string)   IS_BREAKZ_AT((string), 0)
514
515/*
516 * Check if the character is a line break, space, or NUL.
517 */
518
519#define IS_SPACEZ_AT(string, offset)                                            \
520    (IS_SPACE_AT((string), (offset)) || IS_BREAKZ_AT((string), (offset)))
521
522#define IS_SPACEZ(string)   IS_SPACEZ_AT((string), 0)
523
524/*
525 * Check if the character is a line break, space, tab, or NUL.
526 */
527
528#define IS_BLANKZ_AT(string, offset)                                            \
529    (IS_BLANK_AT((string), (offset)) || IS_BREAKZ_AT((string), (offset)))
530
531#define IS_BLANKZ(string)   IS_BLANKZ_AT((string), 0)
532
533/*
534 * Determine the width of the character.
535 */
536
537#define WIDTH_AT(string, offset)                                                \
538     ((OCTET_AT((string), (offset)) & 0x80) == 0x00 ? 1 :                       \
539      (OCTET_AT((string), (offset)) & 0xE0) == 0xC0 ? 2 :                       \
540      (OCTET_AT((string), (offset)) & 0xF0) == 0xE0 ? 3 :                       \
541      (OCTET_AT((string), (offset)) & 0xF8) == 0xF0 ? 4 : 0)
542
543#define WIDTH(string)   WIDTH_AT((string), 0)
544
545/*
546 * Move the string pointer to the next character.
547 */
548
549#define MOVE(string)    ((string).pointer += WIDTH((string)))
550
551/*
552 * Write a single octet and bump the pointer.
553 */
554
555#define JOIN_OCTET(string, octet)                                               \
556    ((string).buffer[(string).pointer++] = (octet))
557
558/*
559 * Copy a single octet and bump the pointers.
560 */
561
562#define COPY_OCTET(target_string, source_string)                                \
563    ((target_string).buffer[(target_string).pointer++]                          \
564     = (source_string).buffer[(source_string).pointer++])
565
566/*
567 * Copy a character and move the pointers of both strings.
568 */
569
570#define COPY(target_string, source_string)                                      \
571    ((OCTET(source_string) & 0x80) == 0x00 ?                                    \
572     COPY_OCTET((target_string), (source_string)) :                             \
573     (OCTET(source_string) & 0xE0) == 0xC0 ?                                    \
574     (COPY_OCTET((target_string), (source_string)),                             \
575      COPY_OCTET((target_string), (source_string))) :                           \
576     (OCTET(source_string) & 0xF0) == 0xE0 ?                                    \
577     (COPY_OCTET((target_string), (source_string)),                             \
578      COPY_OCTET((target_string), (source_string)),                             \
579      COPY_OCTET((target_string), (source_string))) :                           \
580     (OCTET(source_string) & 0xF8) == 0xF0 ?                                    \
581     (COPY_OCTET((target_string), (source_string)),                             \
582      COPY_OCTET((target_string), (source_string)),                             \
583      COPY_OCTET((target_string), (source_string)),                             \
584      COPY_OCTET((target_string), (source_string))) : 0)
585
586/*****************************************************************************
587 * Stack and Queue Management
588 *****************************************************************************/
589
590/*
591 * Double the stack capacity.
592 */
593
594YAML_DECLARE(int)
595yaml_stack_extend(void **list, size_t size, size_t *length, size_t *capacity);
596
597/*
598 * Double the queue capacity.
599 */
600
601YAML_DECLARE(int)
602yaml_queue_extend(void **list, size_t size,
603        size_t *head, size_t *tail, size_t *capacity);
604
605/*
606 * Basic stack operations.
607 */
608
609#define STACK_INIT(self, stack, _capacity)                                      \
610    (((stack).list = yaml_malloc((_capacity)*sizeof(*(stack).list))) ?          \
611        ((stack).length = 0,                                                    \
612         (stack).capacity = (_capacity),                                        \
613         1) :                                                                   \
614        ((self)->error.type = YAML_MEMORY_ERROR,                                \
615         0))
616
617#define STACK_DEL(self, stack)                                                  \
618    (yaml_free((stack).list),                                                   \
619     (stack).list = NULL,                                                       \
620     (stack).length = (stack).capacity = 0)
621
622#define STACK_SET(self, stack, _list, _capacity)                                \
623    ((stack).list = (_list),                                                    \
624     (stack).length = 0,                                                        \
625     (stack).capacity = (_capacity))
626
627#define STACK_EMPTY(self, stack)                                                \
628    ((stack).length == 0)
629
630#define STACK_ITER(self, stack, index)                                          \
631    ((stack).list + index)
632
633#define PUSH(self, stack, value)                                                \
634    (((stack).length < (stack).capacity                                         \
635      || yaml_stack_extend((void **)&(stack).list, sizeof(*(stack).list),       \
636              &(stack).length, &(stack).capacity)) ?                            \
637        ((stack).list[(stack).length++] = (value),                              \
638         1) :                                                                   \
639        ((self)->error.type = YAML_MEMORY_ERROR,                                \
640         0))
641
642#define POP(self, stack)                                                        \
643    ((stack).list[--(stack).length])
644
645/*
646 * Basic queue operations.
647 */
648
649#define QUEUE_INIT(self, queue, _capacity)                                      \
650    (((queue).list = yaml_malloc((_capacity)*sizeof(*(queue).list))) ?          \
651        ((queue).head = (queue).tail = 0,                                       \
652         (queue).capacity = (_capacity),                                        \
653         1) :                                                                   \
654        ((self)->error.type = YAML_MEMORY_ERROR,                                \
655         0))
656
657#define QUEUE_DEL(self, queue)                                                  \
658    (yaml_free((queue).list),                                                   \
659     (queue).list = NULL,                                                       \
660     (queue).head = (queue).tail = (queue).capacity = 0)
661
662#define QUEUE_SET(self, queue, _list, _capacity)                                \
663    ((queue).list = (_list),                                                    \
664     (queue).head = (queue).tail = 0,                                           \
665     (queue).capacity = (_capacity))
666
667#define QUEUE_EMPTY(self, queue)                                                \
668    ((queue).head == (queue).tail)
669
670#define QUEUE_ITER(self, queue, index)                                          \
671    ((queue).list + (queue).head + index)
672
673#define ENQUEUE(self, queue, value)                                             \
674    (((queue).tail != (queue).capacity                                          \
675      || yaml_queue_extend((void **)&(queue).list, sizeof(*(queue).list),       \
676          &(queue).head, &(queue).tail, &(queue).capacity)) ?                   \
677        ((queue).list[(queue).tail++] = (value),                                \
678         1) :                                                                   \
679        ((self)->error.type = YAML_MEMORY_ERROR,                                \
680         0))
681
682#define DEQUEUE(self, queue)                                                    \
683    ((queue).list[(queue).head++])
684
685#define QUEUE_INSERT(self, queue, index, value)                                 \
686    (((queue).tail != (queue).capacity                                          \
687      || yaml_queue_extend((void **)&(queue).list, sizeof(*(queue).list),       \
688          &(queue).head, &(queue).tail, &(queue).capacity)) ?                   \
689        (memmove((queue).list+(queue).head+(index)+1,                           \
690                 (queue).list+(queue).head+(index),                             \
691            ((queue).tail-(queue).head-(index))*sizeof(*(queue).list)),         \
692         (queue).list[(queue).head+(index)] = (value),                          \
693         (queue).tail++,                                                        \
694         1) :                                                                   \
695        ((self)->error.type = YAML_MEMORY_ERROR,                                \
696         0))
697
698/*****************************************************************************
699 * Token Initializers
700 *****************************************************************************/
701
702#define TOKEN_INIT(token, _type, _start_mark, _end_mark)                        \
703    (memset(&(token), 0, sizeof(yaml_token_t)),                                 \
704     (token).type = (_type),                                                    \
705     (token).start_mark = (_start_mark),                                        \
706     (token).end_mark = (_end_mark))
707
708#define STREAM_START_TOKEN_INIT(token, _encoding, _start_mark, _end_mark)       \
709    (TOKEN_INIT((token), YAML_STREAM_START_TOKEN, (_start_mark), (_end_mark)),  \
710     (token).data.stream_start.encoding = (_encoding))
711
712#define STREAM_END_TOKEN_INIT(token, _start_mark, _end_mark)                    \
713    (TOKEN_INIT((token), YAML_STREAM_END_TOKEN, (_start_mark), (_end_mark)))
714
715#define ALIAS_TOKEN_INIT(token, _value, _start_mark, _end_mark)                 \
716    (TOKEN_INIT((token), YAML_ALIAS_TOKEN, (_start_mark), (_end_mark)),         \
717     (token).data.alias.value = (_value))
718
719#define ANCHOR_TOKEN_INIT(token, _value, _start_mark, _end_mark)                \
720    (TOKEN_INIT((token), YAML_ANCHOR_TOKEN, (_start_mark), (_end_mark)),        \
721     (token).data.anchor.value = (_value))
722
723#define TAG_TOKEN_INIT(token, _handle, _suffix, _start_mark, _end_mark)         \
724    (TOKEN_INIT((token), YAML_TAG_TOKEN, (_start_mark), (_end_mark)),           \
725     (token).data.tag.handle = (_handle),                                       \
726     (token).data.tag.suffix = (_suffix))
727
728#define SCALAR_TOKEN_INIT(token, _value, _length, _style, _start_mark, _end_mark)   \
729    (TOKEN_INIT((token), YAML_SCALAR_TOKEN, (_start_mark), (_end_mark)),        \
730     (token).data.scalar.value = (_value),                                      \
731     (token).data.scalar.length = (_length),                                    \
732     (token).data.scalar.style = (_style))
733
734#define VERSION_DIRECTIVE_TOKEN_INIT(token, _major, _minor, _start_mark, _end_mark) \
735    (TOKEN_INIT((token), YAML_VERSION_DIRECTIVE_TOKEN, (_start_mark), (_end_mark)), \
736     (token).data.version_directive.major = (_major),                           \
737     (token).data.version_directive.minor = (_minor))
738
739#define TAG_DIRECTIVE_TOKEN_INIT(token, _handle, _prefix, _start_mark, _end_mark)   \
740    (TOKEN_INIT((token), YAML_TAG_DIRECTIVE_TOKEN, (_start_mark), (_end_mark)), \
741     (token).data.tag_directive.handle = (_handle),                             \
742     (token).data.tag_directive.prefix = (_prefix))
743
744/*****************************************************************************
745 * Event Initializers
746 *****************************************************************************/
747
748#define EVENT_INIT(event, _type, _start_mark, _end_mark)                        \
749    (memset(&(event), 0, sizeof(yaml_event_t)),                                 \
750     (event).type = (_type),                                                    \
751     (event).start_mark = (_start_mark),                                        \
752     (event).end_mark = (_end_mark))
753
754#define STREAM_START_EVENT_INIT(event, _encoding, _start_mark, _end_mark)       \
755    (EVENT_INIT((event), YAML_STREAM_START_EVENT, (_start_mark), (_end_mark)),  \
756     (event).data.stream_start.encoding = (_encoding))
757
758#define STREAM_END_EVENT_INIT(event, _start_mark, _end_mark)                    \
759    (EVENT_INIT((event), YAML_STREAM_END_EVENT, (_start_mark), (_end_mark)))
760
761#define DOCUMENT_START_EVENT_INIT(event, _version_directive,                    \
762        _tag_directives_list, _tag_directives_length, _tag_directives_capacity, \
763        _is_implicit, _start_mark, _end_mark)                                   \
764    (EVENT_INIT((event), YAML_DOCUMENT_START_EVENT, (_start_mark),(_end_mark)), \
765     (event).data.document_start.version_directive = (_version_directive),      \
766     (event).data.document_start.tag_directives.list = (_tag_directives_list),  \
767     (event).data.document_start.tag_directives.length = (_tag_directives_length),  \
768     (event).data.document_start.tag_directives.capacity = (_tag_directives_capacity),  \
769     (event).data.document_start.is_implicit = (_is_implicit))
770
771#define DOCUMENT_END_EVENT_INIT(event, _is_implicit, _start_mark, _end_mark)    \
772    (EVENT_INIT((event), YAML_DOCUMENT_END_EVENT, (_start_mark), (_end_mark)),  \
773     (event).data.document_end.is_implicit = (_is_implicit))
774
775#define ALIAS_EVENT_INIT(event, _anchor, _start_mark, _end_mark)                \
776    (EVENT_INIT((event), YAML_ALIAS_EVENT, (_start_mark), (_end_mark)),         \
777     (event).data.alias.anchor = (_anchor))
778
779#define SCALAR_EVENT_INIT(event, _anchor, _tag, _value, _length,                \
780        _is_plain_nonspecific, _is_quoted_nonspecific, _style, _start_mark, _end_mark)  \
781    (EVENT_INIT((event), YAML_SCALAR_EVENT, (_start_mark), (_end_mark)),        \
782     (event).data.scalar.anchor = (_anchor),                                    \
783     (event).data.scalar.tag = (_tag),                                          \
784     (event).data.scalar.value = (_value),                                      \
785     (event).data.scalar.length = (_length),                                    \
786     (event).data.scalar.is_plain_nonspecific = (_is_plain_nonspecific),        \
787     (event).data.scalar.is_quoted_nonspecific = (_is_quoted_nonspecific),      \
788     (event).data.scalar.style = (_style))
789
790#define SEQUENCE_START_EVENT_INIT(event, _anchor, _tag, _is_nonspecific, _style,    \
791        _start_mark, _end_mark)                                                 \
792    (EVENT_INIT((event), YAML_SEQUENCE_START_EVENT, (_start_mark), (_end_mark)),    \
793     (event).data.sequence_start.anchor = (_anchor),                            \
794     (event).data.sequence_start.tag = (_tag),                                  \
795     (event).data.sequence_start.is_nonspecific = (_is_nonspecific),            \
796     (event).data.sequence_start.style = (_style))
797
798#define SEQUENCE_END_EVENT_INIT(event, _start_mark, _end_mark)                  \
799    (EVENT_INIT((event), YAML_SEQUENCE_END_EVENT, (_start_mark), (_end_mark)))
800
801#define MAPPING_START_EVENT_INIT(event, _anchor, _tag, _is_nonspecific, _style, \
802        _start_mark, _end_mark)                                                 \
803    (EVENT_INIT((event), YAML_MAPPING_START_EVENT, (_start_mark), (_end_mark)), \
804     (event).data.mapping_start.anchor = (_anchor),                             \
805     (event).data.mapping_start.tag = (_tag),                                   \
806     (event).data.mapping_start.is_nonspecific = (_is_nonspecific),             \
807     (event).data.mapping_start.style = (_style))
808
809#define MAPPING_END_EVENT_INIT(event, _start_mark, _end_mark)                   \
810    (EVENT_INIT((event), YAML_MAPPING_END_EVENT, (_start_mark), (_end_mark)))
811
812/*****************************************************************************
813 * Document, Node and Arc Initializers
814 *****************************************************************************/
815
816#define DOCUMENT_INIT(document, _nodes_list, _nodes_length, _nodes_capacity,    \
817        _version_directive, _tag_directives_list, _tag_directives_length,       \
818        _tag_directives_capacity, _is_start_implicit, _is_end_implicit,         \
819        _start_mark, _end_mark)                                                 \
820    (memset(&(document), 0, sizeof(yaml_document_t)),                           \
821     (document).type = YAML_DOCUMENT,                                           \
822     (document).nodes.list = (_nodes_list),                                     \
823     (document).nodes.length = (_nodes_length),                                 \
824     (document).nodes.capacity = (_nodes_capacity),                             \
825     (document).version_directive = (_version_directive),                       \
826     (document).tag_directives.list = (_tag_directives_list),                   \
827     (document).tag_directives.length = (_tag_directives_length),               \
828     (document).tag_directives.capacity = (_tag_directives_capacity),           \
829     (document).is_start_implicit = (_is_start_implicit),                       \
830     (document).is_end_implicit = (_is_end_implicit),                           \
831     (document).start_mark = (_start_mark),                                     \
832     (document).end_mark = (_end_mark))
833
834#define NODE_INIT(node, _type, _anchor, _tag, _start_mark, _end_mark)           \
835    (memset(&(node), 0, sizeof(yaml_node_t)),                                   \
836     (node).type = (_type),                                                     \
837     (node).anchor = (_anchor),                                                 \
838     (node).tag = (_tag),                                                       \
839     (node).start_mark = (_start_mark),                                         \
840     (node).end_mark = (_end_mark))
841
842#define SCALAR_NODE_INIT(node, _anchor, _tag, _value, _length, _style,          \
843        _start_mark, _end_mark)                                                 \
844    (NODE_INIT((node), YAML_SCALAR_NODE, (_anchor), (_tag),                     \
845               (_start_mark), (_end_mark)),                                     \
846     (node).data.scalar.value = (_value),                                       \
847     (node).data.scalar.length = (_length),                                     \
848     (node).data.scalar.style = (_style))
849
850#define SEQUENCE_NODE_INIT(node, _anchor, _tag, _items_list, _items_length,     \
851        _items_capacity, _style, _start_mark, _end_mark)                        \
852    (NODE_INIT((node), YAML_SEQUENCE_NODE, (_anchor), (_tag),                   \
853               (_start_mark), (_end_mark)),                                     \
854     (node).data.sequence.items.list = (_items_list),                           \
855     (node).data.sequence.items.length = (_items_length),                       \
856     (node).data.sequence.items.capacity = (_items_capacity),                   \
857     (node).data.sequence.style = (_style))
858
859#define MAPPING_NODE_INIT(node, _anchor, _tag, _pairs_list, _pairs_length,      \
860        _pairs_capacity, _style, _start_mark, _end_mark)                        \
861    (NODE_INIT((node), YAML_MAPPING_NODE, (_anchor), (_tag),                    \
862               (_start_mark), (_end_mark)),                                     \
863     (node).data.mapping.pairs.list = (_pairs_list),                            \
864     (node).data.mapping.pairs.length = (_pairs_length),                        \
865     (node).data.mapping.pairs.capacity = (_pairs_capacity),                    \
866     (node).data.mapping.style = (_style))
867
868#define ARC_INIT(arc, _type, _tag)                                              \
869    (memset(&(arc), 0, sizeof(yaml_arc_t)),                                     \
870     (arc).type = (_type),                                                      \
871     (arc).tag = (_tag))
872
873#define SEQUENCE_ITEM_ARC_INIT(arc, _tag, _index)                               \
874    (ARC_INIT((arc), YAML_SEQUENCE_ITEM_ARC, (_tag)),                           \
875     (arc).data.item.index = (_index))
876
877#define MAPPING_KEY_ARC_INIT(arc, _tag)                                         \
878    ARC_INIT((arc), YAML_MAPPING_KEY_ARC, (_tag))
879
880#define MAPPING_VALUE_ARC_INIT(arc, _tag, _key_type, _key_tag)                  \
881    (ARC_INIT((arc), YAML_MAPPING_VALUE_ARC, (_tag)),                           \
882     (arc).data.value.key.type = (_key_type),                                   \
883     (arc).data.value.key.tag = (_key_tag))
884
885#define MAPPING_VALUE_FOR_SCALAR_KEY_ARC_INIT(arc, _tag, _key_tag,              \
886        _key_value, _key_length)                                                \
887    (MAPPING_VALUE_ARC_INIT((arc), (_tag), YAML_SCALAR_NODE, (_key_tag)),       \
888     (arc).data.value.key.data.scalar.value = (_key_value),                     \
889     (arc).data.value.key.data.scalar.length = (_key_length))
890
891#define MAPPING_VALUE_FOR_SEQUENCE_KEY_ARC_INIT(arc, _tag, _key_tag)            \
892    MAPPING_VALUE_ARC_INIT((arc), (_tag), YAML_SEQUENCE_NODE, (_key_tag))
893
894#define MAPPING_VALUE_FOR_MAPPING_KEY_INIT(arc, _tag, _key_tag)                 \
895    MAPPING_VALUE_ARC_INIT((arc), (_tag), YAML_MAPPING_NODE, (_key_tag))
896
897#define INCOMPLETE_NODE_INIT(node, _type, _path_list, _path_length,             \
898        _path_capacity, _mark)                                                  \
899    (memset(&(node), 0, sizeof(yaml_incomplete_node_t)),                        \
900     (node).type = (_type),                                                     \
901     (node).path.list = (_path_list),                                           \
902     (node).path.length = (_path_length),                                       \
903     (node).path.capacity = (_path_capacity),                                   \
904     (node).mark = (_mark))
905
906#define INCOMPLETE_SCALAR_NODE_INIT(node, _path_list, _path_length,             \
907        _path_capacity, _value, _length, _is_plain, _mark)                      \
908    (INCOMPLETE_NODE_INIT((node), YAML_SCALAR_NODE, (_path_list),               \
909                          (_path_length), (_path_capacity), (_mark)).           \
910     (node).data.scalar.value = (_value),                                       \
911     (node).data.scalar.length = (_length),                                     \
912     (node).data.scalar.is_plain = (_is_plain))
913
914#define INCOMPLETE_SEQUENCE_NODE_INIT(node, _path_list, _path_length,           \
915        _path_capacity, _mark)                                                  \
916    INCOMPLETE_NODE_INIT((node), YAML_SEQUENCE_NODE, (_path_list),              \
917            (_path_length), (_path_capacity), (_mark))
918
919#define INCOMPLETE_MAPPING_NODE_INIT(node, _path_list, _path_length,            \
920        _path_capacity, _mark)                                                  \
921    INCOMPLETE_NODE_INIT((node), YAML_MAPPING_NODE, (_path_list),               \
922            (_path_length), (_path_capacity), (_mark))
923
924/*****************************************************************************
925 * Parser Structures
926 *****************************************************************************/
927
928/*
929 * This structure holds information about a potential simple key.
930 */
931
932typedef struct yaml_simple_key_s {
933    /* Is a simple key possible? */
934    int is_possible;
935    /* Is a simple key required? */
936    int is_required;
937    /* The number of the token. */
938    size_t token_number;
939    /* The position mark. */
940    yaml_mark_t mark;
941} yaml_simple_key_t;
942
943/*
944 * The states of the parser.
945 */
946
947typedef enum yaml_parser_state_e {
948    /* Expect STREAM-START. */
949    YAML_PARSE_STREAM_START_STATE,
950    /* Expect the beginning of an implicit document. */
951    YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
952    /* Expect DOCUMENT-START. */
953    YAML_PARSE_DOCUMENT_START_STATE,
954    /* Expect the content of a document. */
955    YAML_PARSE_DOCUMENT_CONTENT_STATE,
956    /* Expect DOCUMENT-END. */
957    YAML_PARSE_DOCUMENT_END_STATE,
958    /* Expect a block node. */
959    YAML_PARSE_BLOCK_NODE_STATE,
960    /* Expect a block node or indentless sequence. */
961    YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
962    /* Expect a flow node. */
963    YAML_PARSE_FLOW_NODE_STATE,
964    /* Expect the first entry of a block sequence. */
965    YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE,
966    /* Expect an entry of a block sequence. */
967    YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,
968    /* Expect an entry of an indentless sequence. */
969    YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE,
970    /* Expect the first key of a block mapping. */
971    YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
972    /* Expect a block mapping key. */
973    YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
974    /* Expect a block mapping value. */
975    YAML_PARSE_BLOCK_MAPPING_VALUE_STATE,
976    /* Expect the first entry of a flow sequence. */
977    YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE,
978    /* Expect an entry of a flow sequence. */
979    YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
980    /* Expect a key of an ordered mapping. */
981    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
982    /* Expect a value of an ordered mapping. */
983    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE,
984    /* Expect the and of an ordered mapping entry. */
985    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
986    /* Expect the first key of a flow mapping. */
987    YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
988    /* Expect a key of a flow mapping. */
989    YAML_PARSE_FLOW_MAPPING_KEY_STATE,
990    /* Expect a value of a flow mapping. */
991    YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
992    /* Expect an empty value of a flow mapping. */
993    YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE,
994    /* Expect nothing. */
995    YAML_PARSE_END_STATE
996} yaml_parser_state_t;
997
998/*
999 * This structure holds aliases data.
1000 */
1001
1002typedef struct yaml_alias_data_s {
1003    /* The anchor. */
1004    yaml_char_t *anchor;
1005    /* The node id. */
1006    int index;
1007    /* The anchor mark. */
1008    yaml_mark_t mark;
1009} yaml_alias_data_t;
1010
1011/*
1012 * The structure that holds data used by the file and string readers.
1013 */
1014
1015typedef struct yaml_standard_reader_data_t {
1016    /* String input data. */
1017    yaml_istring_t string;
1018    /* File input data. */
1019    FILE *file;
1020} yaml_standard_reader_data_t;
1021
1022/*
1023 * The internal parser structure.
1024 */
1025
1026struct yaml_parser_s {
1027
1028    /*
1029     * Error stuff.
1030     */
1031
1032    yaml_error_t error;
1033
1034    /*
1035     * Reader stuff.
1036     */
1037
1038    /* The read handler. */
1039    yaml_reader_t *reader;
1040
1041    /* The application data to be passed to the reader. */
1042    void *reader_data;
1043
1044    /* Standard (string or file) input data. */
1045    yaml_standard_reader_data_t standard_reader_data;
1046
1047    /* EOF flag. */
1048    int is_eof;
1049
1050    /* The working buffer. */
1051    yaml_iostring_t input;
1052
1053    /* The number of unread characters in the buffer. */
1054    size_t unread;
1055
1056    /* The raw buffer. */
1057    yaml_raw_iostring_t raw_input;
1058
1059    /* The input encoding. */
1060    yaml_encoding_t encoding;
1061
1062    /* The offset of the current position (in bytes). */
1063    size_t offset;
1064
1065    /* The mark of the current position. */
1066    yaml_mark_t mark;
1067
1068    /*
1069     * Scanner stuff.
1070     */
1071
1072    /* Have we started to scan the input stream? */
1073    int is_stream_start_produced;
1074
1075    /* Have we reached the end of the input stream? */
1076    int is_stream_end_produced;
1077
1078    /* The number of unclosed '[' and '{' indicators. */
1079    int flow_level;
1080
1081    /* The tokens queue. */
1082    struct {
1083        yaml_token_t *list;
1084        size_t head;
1085        size_t tail;
1086        size_t capacity;
1087    } tokens;
1088
1089    /* The number of tokens fetched from the queue. */
1090    size_t tokens_parsed;
1091
1092    /* Does the tokens queue contain a token ready for dequeueing. */
1093    int is_token_available;
1094
1095    /* The indentation levels stack. */
1096    struct {
1097        int *list;
1098        size_t length;
1099        size_t capacity;
1100    } indents;
1101
1102    /* The current indentation level. */
1103    int indent;
1104
1105    /* May a simple key occur at the current position? */
1106    int is_simple_key_allowed;
1107
1108    /* The stack of simple keys. */
1109    struct {
1110        yaml_simple_key_t *list;
1111        size_t length;
1112        size_t capacity;
1113    } simple_keys;
1114
1115    /*
1116     * Parser stuff.
1117     */
1118
1119    /* The parser states stack. */
1120    struct {
1121        yaml_parser_state_t *list;
1122        size_t length;
1123        size_t capacity;
1124    } states;
1125
1126    /* The current parser state. */
1127    yaml_parser_state_t state;
1128
1129    /* The stack of marks. */
1130    struct {
1131        yaml_mark_t *list;
1132        size_t length;
1133        size_t capacity;
1134    } marks;
1135
1136    /* The list of TAG directives. */
1137    struct {
1138        yaml_tag_directive_t *list;
1139        size_t length;
1140        size_t capacity;
1141    } tag_directives;
1142
1143    /*
1144     * Dumper stuff.
1145     */
1146
1147    /* The resolve handler. */
1148    yaml_resolver_t *resolver;
1149
1150    /* The application data to be passed to the resolver. */
1151    void *resolver_data;
1152
1153    /* The alias data. */
1154    struct {
1155        yaml_alias_data_t *list;
1156        size_t length;
1157        size_t capacity;
1158    } aliases;
1159
1160    /* The document being parsed. */
1161    yaml_document_t *document;
1162
1163};
1164
1165/*****************************************************************************
1166 * Internal Parser API
1167 *****************************************************************************/
1168
1169/*
1170 * Reader: Ensure that the buffer contains at least `length` characters.
1171 */
1172
1173YAML_DECLARE(int)
1174yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
1175
1176/*
1177 * Scanner: Ensure that the token stack contains at least one token ready.
1178 */
1179
1180YAML_DECLARE(int)
1181yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
1182
1183/*****************************************************************************
1184 * Emitter Structures
1185 *****************************************************************************/
1186
1187/*
1188 * The emitter states.
1189 */
1190
1191typedef enum yaml_emitter_state_e {
1192    /* Expect STREAM-START. */
1193    YAML_EMIT_STREAM_START_STATE,
1194    /* Expect the first DOCUMENT-START or STREAM-END. */
1195    YAML_EMIT_FIRST_DOCUMENT_START_STATE,
1196    /* Expect DOCUMENT-START or STREAM-END. */
1197    YAML_EMIT_DOCUMENT_START_STATE,
1198    /* Expect the content of a document. */
1199    YAML_EMIT_DOCUMENT_CONTENT_STATE,
1200    /* Expect DOCUMENT-END. */
1201    YAML_EMIT_DOCUMENT_END_STATE,
1202    /* Expect the first item of a flow sequence. */
1203    YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE,
1204    /* Expect an item of a flow sequence. */
1205    YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE,
1206    /* Expect the first key of a flow mapping. */
1207    YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE,
1208    /* Expect a key of a flow mapping. */
1209    YAML_EMIT_FLOW_MAPPING_KEY_STATE,
1210    /* Expect a value for a simple key of a flow mapping. */
1211    YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE,
1212    /* Expect a value of a flow mapping. */
1213    YAML_EMIT_FLOW_MAPPING_VALUE_STATE,
1214    /* Expect the first item of a block sequence. */
1215    YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE,
1216    /* Expect an item of a block sequence. */
1217    YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE,
1218    /* Expect the first key of a block mapping. */
1219    YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE,
1220    /* Expect the key of a block mapping. */
1221    YAML_EMIT_BLOCK_MAPPING_KEY_STATE,
1222    /* Expect a value for a simple key of a block mapping. */
1223    YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE,
1224    /* Expect a value of a block mapping. */
1225    YAML_EMIT_BLOCK_MAPPING_VALUE_STATE,
1226    /* Expect nothing. */
1227    YAML_EMIT_END_STATE
1228} yaml_emitter_state_t;
1229
1230/*
1231 * The structure that holds data used by the file and string readers.
1232 */
1233
1234typedef struct yaml_standard_writer_data_t {
1235    /* String output data. */
1236    yaml_ostring_t string;
1237    size_t *length;
1238    /* File output data. */
1239    FILE *file;
1240} yaml_standard_writer_data_t;
1241
1242/*
1243 * The internals emitter structure.
1244 */
1245
1246struct yaml_emitter_s {
1247
1248    /*
1249     * Error stuff.
1250     */
1251
1252    yaml_error_t error;
1253
1254    /*
1255     * Writer stuff.
1256     */
1257
1258    /* Write handler. */
1259    yaml_writer_t *writer;
1260
1261    /* A pointer for passing to the white handler. */
1262    void *writer_data;
1263
1264    /* Standard (string or file) output data. */
1265    yaml_standard_writer_data_t standard_writer_data;
1266
1267    /* The working buffer. */
1268    yaml_iostring_t output;
1269
1270    /* The raw buffer. */
1271    yaml_raw_iostring_t raw_output;
1272
1273    /* The offset of the current position (in bytes). */
1274    size_t offset;
1275
1276    /* The stream encoding. */
1277    yaml_encoding_t encoding;
1278
1279    /*
1280     * Emitter stuff.
1281     */
1282
1283    /* If the output is in the canonical style? */
1284    int is_canonical;
1285    /* The number of indentation spaces. */
1286    int best_indent;
1287    /* The preferred width of the output lines. */
1288    int best_width;
1289    /* Allow unescaped non-ASCII characters? */
1290    int is_unicode;
1291    /* The preferred line break. */
1292    yaml_break_t line_break;
1293
1294    /* The stack of states. */
1295    struct {
1296        yaml_emitter_state_t *list;
1297        size_t length;
1298        size_t capacity;
1299    } states;
1300
1301    /* The current emitter state. */
1302    yaml_emitter_state_t state;
1303
1304    /* The event queue. */
1305    struct {
1306        yaml_event_t *list;
1307        size_t head;
1308        size_t tail;
1309        size_t capacity;
1310    } events;
1311
1312    /* The stack of indentation levels. */
1313    struct {
1314        int *list;
1315        size_t length;
1316        size_t capacity;
1317    } indents;
1318
1319    /* The list of tag directives. */
1320    struct {
1321        yaml_tag_directive_t *list;
1322        size_t length;
1323        size_t capacity;
1324    } tag_directives;
1325
1326    /* The current indentation level. */
1327    int indent;
1328
1329    /* The current flow level. */
1330    int flow_level;
1331
1332    /* Is it the document root context? */
1333    int is_root_context;
1334    /* Is it a sequence context? */
1335    int is_sequence_context;
1336    /* Is it a mapping context? */
1337    int is_mapping_context;
1338    /* Is it a simple mapping key context? */
1339    int is_simple_key_context;
1340
1341    /* The current line. */
1342    int line;
1343    /* The current column. */
1344    int column;
1345    /* If the last character was a whitespace? */
1346    int is_whitespace;
1347    /* If the last character was an indentation character (' ', '-', '?', ':')? */
1348    int is_indention;
1349
1350    /* Anchor analysis. */
1351    struct {
1352        /* The anchor value. */
1353        const yaml_char_t *anchor;
1354        /* The anchor length. */
1355        size_t anchor_length;
1356        /* Is it an alias? */
1357        int is_alias;
1358    } anchor_data;
1359
1360    /* Tag analysis. */
1361    struct {
1362        /* The tag handle. */
1363        const yaml_char_t *handle;
1364        /* The tag handle length. */
1365        size_t handle_length;
1366        /* The tag suffix. */
1367        const yaml_char_t *suffix;
1368        /* The tag suffix length. */
1369        size_t suffix_length;
1370    } tag_data;
1371
1372    /* Scalar analysis. */
1373    struct {
1374        /* The scalar value. */
1375        const yaml_char_t *value;
1376        /* The scalar length. */
1377        size_t length;
1378        /* Does the scalar contain line breaks? */
1379        int is_multiline;
1380        /* Can the scalar be expessed in the flow plain style? */
1381        int is_flow_plain_allowed;
1382        /* Can the scalar be expressed in the block plain style? */
1383        int is_block_plain_allowed;
1384        /* Can the scalar be expressed in the single quoted style? */
1385        int is_single_quoted_allowed;
1386        /* Can the scalar be expressed in the literal or folded styles? */
1387        int is_block_allowed;
1388        /* The output style. */
1389        yaml_scalar_style_t style;
1390    } scalar_data;
1391
1392    /*
1393     * Dumper stuff.
1394     */
1395
1396    /* The resolve handler. */
1397    yaml_resolver_t *resolver;
1398
1399    /* The application data to be passed to the resolver. */
1400    void *resolver_data;
1401
1402    /* If the stream was already opened? */
1403    int is_opened;
1404    /* If the stream was already closed? */
1405    int is_closed;
1406
1407    /* The information associated with the document nodes. */
1408    struct {
1409        /* The number of references. */
1410        size_t references;
1411        /* The anchor id. */
1412        int anchor;
1413        /* If the node has been emitted? */
1414        int is_serialized;
1415    } *anchors;
1416
1417    /* The last assigned anchor id. */
1418    int last_anchor_id;
1419
1420    /* The document being emitted. */
1421    yaml_document_t *document;
1422
1423};
1424
Note: See TracBrowser for help on using the repository browser.