src/api.c

   1
   2 #include "yaml_private.h"
   3
   4 /*
   5  * Get the library version.
   6  */
   7
   8 YAML_DECLARE(const char *)
   9 yaml_get_version_string(void)
  10 {
  11     return YAML_VERSION_STRING;
  12 }
  13
  14 /*
  15  * Get the library version numbers.
  16  */
  17
  18 YAML_DECLARE(void)
  19 yaml_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
  30 YAML_DECLARE(void *)
  31 yaml_malloc(size_t size)
  32 {
  33     return malloc(size ? size : 1);
  34 }
  35
  36 /*
  37  * Reallocate a dynamic memory block.
  38  */
  39
  40 YAML_DECLARE(void *)
  41 yaml_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
  50 YAML_DECLARE(void)
  51 yaml_free(void *ptr)
  52 {
  53     if (ptr) free(ptr);
  54 }
  55
  56 /*
  57  * Duplicate a string.
  58  */
  59
  60 YAML_DECLARE(char *)
  61 yaml_strdup(const char *str)
  62 {
  63     return strdup(str);
  64 }
  65
  66 /*
  67  * Extend a string.
  68  */
  69
  70 YAML_DECLARE(int)
  71 yaml_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
  91 YAML_DECLARE(int)
  92 yaml_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
 114 YAML_DECLARE(int)
 115 yaml_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
 132 YAML_DECLARE(int)
 133 yaml_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
 166 YAML_DECLARE(int)
 167 yaml_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
 191 error:
 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
 209 YAML_DECLARE(void)
 210 yaml_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
 238 static int
 239 yaml_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
 263 static int
 264 yaml_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
 277 YAML_DECLARE(void)
 278 yaml_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
 297 YAML_DECLARE(void)
 298 yaml_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
 314 YAML_DECLARE(void)
 315 yaml_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
 330 YAML_DECLARE(void)
 331 yaml_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
 343 YAML_DECLARE(void)
 344 yaml_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
 380 YAML_DECLARE(void)
 381 yaml_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