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

Revision 213, 14.8 KB checked in by xi, 8 years ago (diff)

Implement Emitter state machine.

RevLine 
[208]1
2#if HAVE_CONFIG_H
3#include <config.h>
4#endif
5
6#include <yaml.h>
7
8#include <assert.h>
[213]9#include <limits.h>
[208]10
11/*
12 * Memory management.
13 */
14
15YAML_DECLARE(void *)
16yaml_malloc(size_t size);
17
18YAML_DECLARE(void *)
19yaml_realloc(void *ptr, size_t size);
20
21YAML_DECLARE(void)
22yaml_free(void *ptr);
23
[212]24YAML_DECLARE(yaml_char_t *)
25yaml_strdup(const yaml_char_t *);
[208]26
27/*
28 * Reader: Ensure that the buffer contains at least `length` characters.
29 */
30
31YAML_DECLARE(int)
32yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
33
34/*
35 * Scanner: Ensure that the token stack contains at least one token ready.
36 */
37
38YAML_DECLARE(int)
39yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
40
41/*
[211]42 * The size of the input raw buffer.
[208]43 */
44
[211]45#define INPUT_RAW_BUFFER_SIZE   16384
[208]46
47/*
[211]48 * The size of the input buffer.
[208]49 *
50 * It should be possible to decode the whole raw buffer.
51 */
52
[211]53#define INPUT_BUFFER_SIZE       (INPUT_RAW_BUFFER_SIZE*3)
[208]54
55/*
[211]56 * The size of the output buffer.
57 */
58
59#define OUTPUT_BUFFER_SIZE      16384
60
61/*
62 * The size of the output raw buffer.
63 *
64 * It should be possible to encode the whole output buffer.
65 */
66
67#define OUTPUT_RAW_BUFFER_SIZE  (OUTPUT_BUFFER_SIZE*2+2)
68
69/*
[208]70 * The size of other stacks and queues.
71 */
72
73#define INITIAL_STACK_SIZE  16
74#define INITIAL_QUEUE_SIZE  16
75#define INITIAL_STRING_SIZE 16
76
77/*
78 * Buffer management.
79 */
80
81#define BUFFER_INIT(context,buffer,size)                                        \
82    (((buffer).start = yaml_malloc(size)) ?                                     \
83        ((buffer).last = (buffer).pointer = (buffer).start,                     \
84         (buffer).end = (buffer).start+(size),                                  \
85         1) :                                                                   \
86        ((context)->error = YAML_MEMORY_ERROR,                                  \
87         0))
88
89#define BUFFER_DEL(context,buffer)                                              \
90    (yaml_free((buffer).start),                                                 \
91     (buffer).start = (buffer).pointer = (buffer).end = 0)
92
93/*
94 * String management.
95 */
96
97typedef struct {
98    yaml_char_t *start;
99    yaml_char_t *end;
100    yaml_char_t *pointer;
101} yaml_string_t;
102
103YAML_DECLARE(int)
104yaml_string_extend(yaml_char_t **start,
105        yaml_char_t **pointer, yaml_char_t **end);
106
107YAML_DECLARE(int)
108yaml_string_join(
109        yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
110        yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end);
111
112#define NULL_STRING { NULL, NULL, NULL }
113
114#define STRING_INIT(context,string,size)                                        \
115    (((string).start = yaml_malloc(size)) ?                                     \
116        ((string).pointer = (string).start,                                     \
117         (string).end = (string).start+(size),                                  \
118         memset((string).start, 0, (size)),                                     \
119         1) :                                                                   \
120        ((context)->error = YAML_MEMORY_ERROR,                                  \
121         0))
122
123#define STRING_DEL(context,string)                                              \
124    (yaml_free((string).start),                                                 \
125     (string).start = (string).pointer = (string).end = 0)
126
127#define STRING_EXTEND(context,string)                                           \
128    (((string).pointer+5 < (string).end)                                        \
129        || yaml_string_extend(&(string).start,                                  \
130            &(string).pointer, &(string).end))
131
132#define CLEAR(context,string)                                                   \
133    ((string).pointer = (string).start,                                         \
134     memset((string).start, 0, (string).end-(string).start))
135
136#define JOIN(context,string_a,string_b)                                         \
137    ((yaml_string_join(&(string_a).start, &(string_a).pointer,                  \
138                       &(string_a).end, &(string_b).start,                      \
139                       &(string_b).pointer, &(string_b).end)) ?                 \
140        ((string_b).pointer = (string_b).start,                                 \
141         1) :                                                                   \
142        ((context)->error = YAML_MEMORY_ERROR,                                  \
143         0))
144
145/*
146 * Stack and queue management.
147 */
148
149YAML_DECLARE(int)
150yaml_stack_extend(void **start, void **top, void **end);
151
152YAML_DECLARE(int)
153yaml_queue_extend(void **start, void **head, void **tail, void **end);
154
155#define STACK_INIT(context,stack,size)                                          \
156    (((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ?             \
157        ((stack).top = (stack).start,                                           \
158         (stack).end = (stack).start+(size),                                    \
159         1) :                                                                   \
160        ((context)->error = YAML_MEMORY_ERROR,                                  \
161         0))
162
163#define STACK_DEL(context,stack)                                                \
164    (yaml_free((stack).start),                                                  \
165     (stack).start = (stack).top = (stack).end = 0)
166
167#define STACK_EMPTY(context,stack)                                              \
168    ((stack).start == (stack).top)
169
170#define PUSH(context,stack,value)                                               \
171    (((stack).top != (stack).end                                                \
172      || yaml_stack_extend((void **)&(stack).start,                             \
173              (void **)&(stack).top, (void **)&(stack).end)) ?                  \
174        (*((stack).top++) = value,                                              \
175         1) :                                                                   \
176        ((context)->error = YAML_MEMORY_ERROR,                                  \
177         0))
178
179#define POP(context,stack)                                                      \
180    (*(--(stack).top))
181
182#define QUEUE_INIT(context,queue,size)                                          \
183    (((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ?             \
184        ((queue).head = (queue).tail = (queue).start,                           \
185         (queue).end = (queue).start+(size),                                    \
186         1) :                                                                   \
187        ((context)->error = YAML_MEMORY_ERROR,                                  \
188         0))
189
190#define QUEUE_DEL(context,queue)                                                \
191    (yaml_free((queue).start),                                                  \
192     (queue).start = (queue).head = (queue).tail = (queue).end = 0)
193
194#define QUEUE_EMPTY(context,queue)                                              \
195    ((queue).head == (queue).tail)
196
197#define ENQUEUE(context,queue,value)                                            \
198    (((queue).tail != (queue).end                                               \
199      || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head,     \
200            (void **)&(queue).tail, (void **)&(queue).end)) ?                   \
201        (*((queue).tail++) = value,                                             \
202         1) :                                                                   \
203        ((context)->error = YAML_MEMORY_ERROR,                                  \
204         0))
205
206#define DEQUEUE(context,queue)                                                  \
207    (*((queue).head++))
208
209#define QUEUE_INSERT(context,queue,index,value)                                 \
210    (((queue).tail != (queue).end                                               \
211      || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head,     \
212            (void **)&(queue).tail, (void **)&(queue).end)) ?                   \
213        (memmove((queue).head+(index)+1,(queue).head+(index),                   \
214            ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)),        \
215         *((queue).head+(index)) = value,                                       \
216         (queue).tail++,                                                        \
217         1) :                                                                   \
218        ((context)->error = YAML_MEMORY_ERROR,                                  \
219         0))
220
[211]221/*
222 * Token initializers.
223 */
224
225#define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark)            \
226    (memset(&(token), 0, sizeof(yaml_token_t)),                                 \
227     (token).type = (token_type),                                               \
228     (token).start_mark = (token_start_mark),                                   \
229     (token).end_mark = (token_end_mark))
230
231#define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark)       \
232    (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)),       \
233     (token).data.stream_start.encoding = (token_encoding))
234
235#define STREAM_END_TOKEN_INIT(token,start_mark,end_mark)                        \
236    (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark)))
237
238#define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark)                 \
239    (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)),              \
240     (token).data.alias.value = (token_value))
241
242#define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark)                \
243    (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)),             \
244     (token).data.anchor.value = (token_value))
245
246#define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark)     \
247    (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)),                \
248     (token).data.tag.handle = (token_handle),                                  \
249     (token).data.tag.suffix = (token_suffix))
250
251#define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark)   \
252    (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)),             \
253     (token).data.scalar.value = (token_value),                                 \
254     (token).data.scalar.length = (token_length),                               \
255     (token).data.scalar.style = (token_style))
256
257#define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark)     \
258    (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)),  \
259     (token).data.version_directive.major = (token_major),                      \
260     (token).data.version_directive.minor = (token_minor))
261
262#define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark)       \
263    (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)),      \
264     (token).data.tag_directive.handle = (token_handle),                        \
265     (token).data.tag_directive.prefix = (token_prefix))
266
267/*
268 * Event initializers.
269 */
270
271#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark)            \
272    (memset(&(event), 0, sizeof(yaml_event_t)),                                 \
273     (event).type = (event_type),                                               \
274     (event).start_mark = (event_start_mark),                                   \
275     (event).end_mark = (event_end_mark))
276
277#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark)       \
278    (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)),       \
279     (event).data.stream_start.encoding = (event_encoding))
280
281#define STREAM_END_EVENT_INIT(event,start_mark,end_mark)                        \
282    (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark)))
283
284#define DOCUMENT_START_EVENT_INIT(event,event_version_directive,                \
285        event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \
286    (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)),     \
287     (event).data.document_start.version_directive = (event_version_directive), \
288     (event).data.document_start.tag_directives.start = (event_tag_directives_start),   \
289     (event).data.document_start.tag_directives.end = (event_tag_directives_end),   \
290     (event).data.document_start.implicit = (event_implicit))
291
292#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark)       \
293    (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)),       \
294     (event).data.document_end.implicit = (event_implicit))
295
296#define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark)                \
297    (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)),              \
298     (event).data.alias.anchor = (event_anchor))
299
300#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length,    \
301        event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark)    \
302    (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)),             \
303     (event).data.scalar.anchor = (event_anchor),                               \
304     (event).data.scalar.tag = (event_tag),                                     \
305     (event).data.scalar.value = (event_value),                                 \
306     (event).data.scalar.length = (event_length),                               \
307     (event).data.scalar.plain_implicit = (event_plain_implicit),               \
308     (event).data.scalar.quoted_implicit = (event_quoted_implicit),             \
309     (event).data.scalar.style = (event_style))
310
311#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag,                 \
312        event_implicit,event_style,start_mark,end_mark)                         \
313    (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)),     \
314     (event).data.sequence_start.anchor = (event_anchor),                       \
315     (event).data.sequence_start.tag = (event_tag),                             \
316     (event).data.sequence_start.implicit = (event_implicit),                   \
317     (event).data.sequence_start.style = (event_style))
318
319#define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark)                      \
320    (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark)))
321
322#define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag,                  \
323        event_implicit,event_style,start_mark,end_mark)                         \
324    (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)),      \
325     (event).data.mapping_start.anchor = (event_anchor),                        \
326     (event).data.mapping_start.tag = (event_tag),                              \
327     (event).data.mapping_start.implicit = (event_implicit),                    \
328     (event).data.mapping_start.style = (event_style))
329
330#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark)                       \
331    (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark)))
332
Note: See TracBrowser for help on using the repository browser.