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

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

Add yaml_emitter_emit_* set of functions.

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