source: libyaml/trunk/src/api.c @ 208

Revision 208, 9.8 KB checked in by xi, 8 years ago (diff)

Refactor internal and external API.

Line 
1
2#include "yaml_private.h"
3
4/*
5 * Get the library version.
6 */
7
8YAML_DECLARE(const char *)
9yaml_get_version_string(void)
10{
11    return YAML_VERSION_STRING;
12}
13
14/*
15 * Get the library version numbers.
16 */
17
18YAML_DECLARE(void)
19yaml_get_version(int *major, int *minor, int *patch)
20{
21    *major = YAML_VERSION_MAJOR;
22    *minor = YAML_VERSION_MINOR;
23    *patch = YAML_VERSION_PATCH;
24}
25
26/*
27 * Allocate a dynamic memory block.
28 */
29
30YAML_DECLARE(void *)
31yaml_malloc(size_t size)
32{
33    return malloc(size ? size : 1);
34}
35
36/*
37 * Reallocate a dynamic memory block.
38 */
39
40YAML_DECLARE(void *)
41yaml_realloc(void *ptr, size_t size)
42{
43    return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
44}
45
46/*
47 * Free a dynamic memory block.
48 */
49
50YAML_DECLARE(void)
51yaml_free(void *ptr)
52{
53    if (ptr) free(ptr);
54}
55
56/*
57 * Duplicate a string.
58 */
59
60YAML_DECLARE(char *)
61yaml_strdup(const char *str)
62{
63    return strdup(str);
64}
65
66/*
67 * Extend a string.
68 */
69
70YAML_DECLARE(int)
71yaml_string_extend(yaml_char_t **start,
72        yaml_char_t **pointer, yaml_char_t **end)
73{
74    void *new_start = yaml_realloc(*start, (*end - *start)*2);
75
76    if (!new_start) return 0;
77
78    memset(new_start + (*end - *start), 0, *end - *start);
79
80    *pointer = new_start + (*pointer - *start);
81    *end = new_start + (*end - *start)*2;
82    *start = new_start;
83
84    return 1;
85}
86
87/*
88 * Append a string B to a string A.
89 */
90
91YAML_DECLARE(int)
92yaml_string_join(
93        yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
94        yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
95{
96    if (*b_start == *b_pointer)
97        return 1;
98
99    while (*a_end - *a_pointer <= *b_pointer - *b_start) {
100        if (!yaml_string_extend(a_start, a_pointer, a_end))
101            return 0;
102    }
103
104    memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
105    *a_pointer += *b_pointer - *b_start;
106
107    return 1;
108}
109
110/*
111 * Extend a stack.
112 */
113
114YAML_DECLARE(int)
115yaml_stack_extend(void **start, void **top, void **end)
116{
117    void *new_start = yaml_realloc(*start, (*end - *start)*2);
118
119    if (!new_start) return 0;
120
121    *top = new_start + (*top - *start);
122    *end = new_start + (*end - *start)*2;
123    *start = new_start;
124
125    return 1;
126}
127
128/*
129 * Extend or move a queue.
130 */
131
132YAML_DECLARE(int)
133yaml_queue_extend(void **start, void **head, void **tail, void **end)
134{
135    /* Check if we need to resize the queue. */
136
137    if (*start == *head && *tail == *end) {
138        void *new_start = yaml_realloc(*start, (*end - *start)*2);
139
140        if (!new_start) return 0;
141
142        *head = new_start + (*head - *start);
143        *tail = new_start + (*tail - *start);
144        *end = new_start + (*end - *start)*2;
145        *start = new_start;
146    }
147
148    /* Check if we need to move the queue at the beginning of the buffer. */
149
150    if (*tail == *end) {
151        if (*head != *tail) {
152            memmove(*start, *head, *tail - *head);
153        }
154        *tail -= *head - *start;
155        *head = *start;
156    }
157
158    return 1;
159}
160
161
162/*
163 * Create a new parser object.
164 */
165
166YAML_DECLARE(int)
167yaml_parser_initialize(yaml_parser_t *parser)
168{
169    assert(parser);     /* Non-NULL parser object expected. */
170
171    memset(parser, 0, sizeof(yaml_parser_t));
172    if (!BUFFER_INIT(parser, parser->raw_buffer, RAW_BUFFER_SIZE))
173        goto error;
174    if (!BUFFER_INIT(parser, parser->buffer, BUFFER_SIZE))
175        goto error;
176    if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
177        goto error;
178    if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
179        goto error;
180    if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
181        goto error;
182    if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
183        goto error;
184    if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
185        goto error;
186    if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
187        goto error;
188
189    return 1;
190
191error:
192
193    BUFFER_DEL(parser, parser->raw_buffer);
194    BUFFER_DEL(parser, parser->buffer);
195    QUEUE_DEL(parser, parser->tokens);
196    STACK_DEL(parser, parser->indents);
197    STACK_DEL(parser, parser->simple_keys);
198    STACK_DEL(parser, parser->states);
199    STACK_DEL(parser, parser->marks);
200    STACK_DEL(parser, parser->tag_directives);
201
202    return 0;
203}
204
205/*
206 * Destroy a parser object.
207 */
208
209YAML_DECLARE(void)
210yaml_parser_delete(yaml_parser_t *parser)
211{
212    assert(parser); /* Non-NULL parser object expected. */
213
214    BUFFER_DEL(parser, parser->raw_buffer);
215    BUFFER_DEL(parser, parser->buffer);
216    while (!QUEUE_EMPTY(parser, parser->tokens)) {
217        yaml_token_delete(&DEQUEUE(parser, parser->tokens));
218    }
219    QUEUE_DEL(parser, parser->tokens);
220    STACK_DEL(parser, parser->indents);
221    STACK_DEL(parser, parser->simple_keys);
222    STACK_DEL(parser, parser->states);
223    STACK_DEL(parser, parser->marks);
224    while (!STACK_EMPTY(parser, parser->tag_directives)) {
225        yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
226        yaml_free(tag_directive.handle);
227        yaml_free(tag_directive.prefix);
228    }
229    STACK_DEL(parser, parser->tag_directives);
230
231    memset(parser, 0, sizeof(yaml_parser_t));
232}
233
234/*
235 * String read handler.
236 */
237
238static int
239yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
240        size_t *size_read)
241{
242    yaml_parser_t *parser = data;
243
244    if (parser->input.string.current == parser->input.string.end) {
245        *size_read = 0;
246        return 1;
247    }
248
249    if (size > (parser->input.string.end - parser->input.string.current)) {
250        size = parser->input.string.end - parser->input.string.current;
251    }
252
253    memcpy(buffer, parser->input.string.current, size);
254    parser->input.string.current += size;
255    *size_read = size;
256    return 1;
257}
258
259/*
260 * File read handler.
261 */
262
263static int
264yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
265        size_t *size_read)
266{
267    yaml_parser_t *parser = data;
268
269    *size_read = fread(buffer, 1, size, parser->input.file);
270    return !ferror(parser->input.file);
271}
272
273/*
274 * Set a string input.
275 */
276
277YAML_DECLARE(void)
278yaml_parser_set_input_string(yaml_parser_t *parser,
279        unsigned char *input, size_t size)
280{
281    assert(parser); /* Non-NULL parser object expected. */
282    assert(!parser->read_handler);  /* You can set the source only once. */
283    assert(input);  /* Non-NULL input string expected. */
284
285    parser->read_handler = yaml_string_read_handler;
286    parser->read_handler_data = parser;
287
288    parser->input.string.start = input;
289    parser->input.string.current = input;
290    parser->input.string.end = input+size;
291}
292
293/*
294 * Set a file input.
295 */
296
297YAML_DECLARE(void)
298yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
299{
300    assert(parser); /* Non-NULL parser object expected. */
301    assert(!parser->read_handler);  /* You can set the source only once. */
302    assert(file);   /* Non-NULL file object expected. */
303
304    parser->read_handler = yaml_file_read_handler;
305    parser->read_handler_data = parser;
306
307    parser->input.file = file;
308}
309
310/*
311 * Set a generic input.
312 */
313
314YAML_DECLARE(void)
315yaml_parser_set_input(yaml_parser_t *parser,
316        yaml_read_handler_t *handler, void *data)
317{
318    assert(parser); /* Non-NULL parser object expected. */
319    assert(!parser->read_handler);  /* You can set the source only once. */
320    assert(handler);    /* Non-NULL read handler expected. */
321
322    parser->read_handler = handler;
323    parser->read_handler_data = data;
324}
325
326/*
327 * Set the source encoding.
328 */
329
330YAML_DECLARE(void)
331yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
332{
333    assert(parser); /* Non-NULL parser object expected. */
334    assert(!parser->encoding); /* Encoding is already set or detected. */
335
336    parser->encoding = encoding;
337}
338
339/*
340 * Destroy a token object.
341 */
342
343YAML_DECLARE(void)
344yaml_token_delete(yaml_token_t *token)
345{
346    assert(token);  /* Non-NULL token object expected. */
347
348    switch (token->type)
349    {
350        case YAML_TAG_DIRECTIVE_TOKEN:
351            yaml_free(token->data.tag_directive.handle);
352            yaml_free(token->data.tag_directive.prefix);
353            break;
354
355        case YAML_ALIAS_TOKEN:
356            yaml_free(token->data.alias.value);
357            break;
358
359        case YAML_ANCHOR_TOKEN:
360            yaml_free(token->data.anchor.value);
361            break;
362
363        case YAML_TAG_TOKEN:
364            yaml_free(token->data.tag.handle);
365            yaml_free(token->data.tag.suffix);
366            break;
367
368        case YAML_SCALAR_TOKEN:
369            yaml_free(token->data.scalar.value);
370            break;
371    }
372
373    memset(token, 0, sizeof(yaml_token_t));
374}
375
376/*
377 * Destroy an event object.
378 */
379
380YAML_DECLARE(void)
381yaml_event_delete(yaml_event_t *event)
382{
383    yaml_tag_directive_t *tag_directive;
384
385    assert(event);  /* Non-NULL event object expected. */
386
387    switch (event->type)
388    {
389        case YAML_DOCUMENT_START_EVENT:
390            yaml_free(event->data.document_start.version_directive);
391            for (tag_directive = event->data.document_start.tag_directives.start;
392                    tag_directive != event->data.document_start.tag_directives.end;
393                    tag_directive++) {
394                yaml_free(tag_directive->handle);
395                yaml_free(tag_directive->prefix);
396            }
397            yaml_free(event->data.document_start.tag_directives.start);
398            break;
399
400        case YAML_ALIAS_EVENT:
401            yaml_free(event->data.alias.anchor);
402            break;
403
404        case YAML_SCALAR_EVENT:
405            yaml_free(event->data.scalar.anchor);
406            yaml_free(event->data.scalar.tag);
407            yaml_free(event->data.scalar.value);
408            break;
409
410        case YAML_SEQUENCE_START_EVENT:
411            yaml_free(event->data.sequence_start.anchor);
412            yaml_free(event->data.sequence_start.tag);
413            break;
414
415        case YAML_MAPPING_START_EVENT:
416            yaml_free(event->data.mapping_start.anchor);
417            yaml_free(event->data.mapping_start.tag);
418            break;
419    }
420
421    memset(event, 0, sizeof(yaml_event_t));
422}
423
Note: See TracBrowser for help on using the repository browser.