diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/api.c | 809 | ||||
-rw-r--r-- | src/yaml_private.h | 965 |
2 files changed, 1331 insertions, 443 deletions
@@ -71,41 +71,39 @@ yaml_strdup(const yaml_char_t *str) */ YAML_DECLARE(int) -yaml_string_extend(yaml_char_t **start, - yaml_char_t **pointer, yaml_char_t **end) +yaml_string_extend(yaml_char_t **buffer, size_t *capacity) { - yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2); + yaml_char_t *new_buffer = yaml_realloc(*buffer, (*capacity)*2); - if (!new_start) return 0; + if (!new_buffer) return 0; - memset(new_start + (*end - *start), 0, *end - *start); + memset(new_buffer + *capacity, 0, *capacity); - *pointer = new_start + (*pointer - *start); - *end = new_start + (*end - *start)*2; - *start = new_start; + *buffer = new_buffer; + *capacity *= 2; return 1; } /* - * Append a string B to a string A. + * Append an adjunct string to a base string. */ YAML_DECLARE(int) yaml_string_join( - yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end, - yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end) + yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity, + yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity) { - if (*b_start == *b_pointer) + if (!adj_pointer) return 1; - while (*a_end - *a_pointer <= *b_pointer - *b_start) { - if (!yaml_string_extend(a_start, a_pointer, a_end)) + while (*base_capacity - *base_pointer <= adj_pointer) { + if (!yaml_string_extend(base_buffer, base_capacity)) return 0; } - memcpy(*a_pointer, *b_start, *b_pointer - *b_start); - *a_pointer += *b_pointer - *b_start; + memcpy(*base_buffer+*base_pointer, adj_buffer, adj_pointer); + *base_pointer += adj_pointer; return 1; } @@ -115,15 +113,14 @@ yaml_string_join( */ YAML_DECLARE(int) -yaml_stack_extend(void **start, void **top, void **end) +yaml_stack_extend(void **list, size_t size, size_t *length, size_t *capacity) { - void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2); + void *new_list = yaml_realloc(*list, (*capacity)*size*2); - if (!new_start) return 0; + if (!new_list) return 0; - *top = (char *)new_start + ((char *)*top - (char *)*start); - *end = (char *)new_start + ((char *)*end - (char *)*start)*2; - *start = new_start; + *list = new_list; + *capacity *= 2; return 1; } @@ -133,30 +130,29 @@ yaml_stack_extend(void **start, void **top, void **end) */ YAML_DECLARE(int) -yaml_queue_extend(void **start, void **head, void **tail, void **end) +yaml_queue_extend(void **list, size_t size, + size_t *head, size_t *tail, size_t *capacity) { /* Check if we need to resize the queue. */ - if (*start == *head && *tail == *end) { - void *new_start = yaml_realloc(*start, - ((char *)*end - (char *)*start)*2); + if (*head == 0 && *tail == *capacity) { + void *new_list = yaml_realloc(*list, (*capacity)*size*2); - if (!new_start) return 0; + if (!new_list) return 0; - *head = (char *)new_start + ((char *)*head - (char *)*start); - *tail = (char *)new_start + ((char *)*tail - (char *)*start); - *end = (char *)new_start + ((char *)*end - (char *)*start)*2; - *start = new_start; + *list = new_list; + *capacity *= 2; } /* Check if we need to move the queue at the beginning of the buffer. */ - if (*tail == *end) { + if (*tail == *capacity) { if (*head != *tail) { - memmove(*start, *head, (char *)*tail - (char *)*head); + memmove((char *)*list, (char *)*list + (*head)*size, + (*tail-*head)*size); } - *tail = (char *)*tail - (char *)*head + (char *)*start; - *head = *start; + *tail -= *head; + *head = 0; } return 1; @@ -167,43 +163,38 @@ yaml_queue_extend(void **start, void **head, void **tail, void **end) * Create a new parser object. */ -YAML_DECLARE(int) -yaml_parser_initialize(yaml_parser_t *parser) +YAML_DECLARE(yaml_parser_t *) +yaml_parser_new(void) { - assert(parser); /* Non-NULL parser object expected. */ + yaml_parser_t *parser = yaml_malloc(sizeof(yaml_parser_t)); + + if (!parser) + return NULL; memset(parser, 0, sizeof(yaml_parser_t)); - if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE)) + if (!BUFFER_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY)) goto error; - if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE)) + if (!BUFFER_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY)) goto error; - if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE)) + if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_CAPACITY)) goto error; - if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE)) + if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_CAPACITY)) goto error; - if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE)) + if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_CAPACITY)) goto error; - if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE)) + if (!STACK_INIT(parser, parser->states, INITIAL_STACK_CAPACITY)) goto error; - if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE)) + if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_CAPACITY)) goto error; - if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE)) + if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_CAPACITY)) goto error; - return 1; + return parser; error: + yaml_parser_delete(parser); - BUFFER_DEL(parser, parser->raw_buffer); - BUFFER_DEL(parser, parser->buffer); - QUEUE_DEL(parser, parser->tokens); - STACK_DEL(parser, parser->indents); - STACK_DEL(parser, parser->simple_keys); - STACK_DEL(parser, parser->states); - STACK_DEL(parser, parser->marks); - STACK_DEL(parser, parser->tag_directives); - - return 0; + return NULL; } /* @@ -215,10 +206,10 @@ yaml_parser_delete(yaml_parser_t *parser) { assert(parser); /* Non-NULL parser object expected. */ - BUFFER_DEL(parser, parser->raw_buffer); - BUFFER_DEL(parser, parser->buffer); + BUFFER_DEL(parser, parser->raw_input); + BUFFER_DEL(parser, parser->input); while (!QUEUE_EMPTY(parser, parser->tokens)) { - yaml_token_delete(&DEQUEUE(parser, parser->tokens)); + yaml_token_destroy(&DEQUEUE(parser, parser->tokens)); } QUEUE_DEL(parser, parser->tokens); STACK_DEL(parser, parser->indents); @@ -233,46 +224,58 @@ yaml_parser_delete(yaml_parser_t *parser) STACK_DEL(parser, parser->tag_directives); memset(parser, 0, sizeof(yaml_parser_t)); + yaml_free(parser); } /* - * String read handler. + * Get the current parser error. + */ + +YAML_DECLARE(void) +yaml_parser_get_error(yaml_parser_t *parser, yaml_error_t *error) +{ + assert(parser); /* Non-NULL parser object expected. */ + + *error = parser->error; +} + +/* + * Standard string read handler. */ static int -yaml_string_read_handler(void *data, unsigned char *buffer, size_t size, - size_t *size_read) +yaml_string_reader(void *untyped_data, unsigned char *buffer, size_t capacity, + size_t *length) { - yaml_parser_t *parser = data; + yaml_standard_reader_data_t *data = untyped_data; - if (parser->input.string.current == parser->input.string.end) { - *size_read = 0; + if (data->string.pointer == data->string.capacity) { + *length = 0; return 1; } - if (size > (size_t)(parser->input.string.end - - parser->input.string.current)) { - size = parser->input.string.end - parser->input.string.current; + if (capacity > (size_t)(data->string.capacity - data->string.pointer)) { + capacity = data->string.capacity - data->string.pointer; } - memcpy(buffer, parser->input.string.current, size); - parser->input.string.current += size; - *size_read = size; + memcpy(buffer, data->string.buffer + data->string.pointer, capacity); + data->string.pointer += capacity; + *length = capacity; return 1; } /* - * File read handler. + * Standard file read handler. */ static int -yaml_file_read_handler(void *data, unsigned char *buffer, size_t size, - size_t *size_read) +yaml_file_reader(void *untyped_data, unsigned char *buffer, size_t capacity, + size_t *length) { - yaml_parser_t *parser = data; + yaml_standard_reader_data_t *data = untyped_data; - *size_read = fread(buffer, 1, size, parser->input.file); - return !ferror(parser->input.file); + *length = fread(buffer, 1, capacity, data->file); + return !ferror(data->file); } /* @@ -280,19 +283,19 @@ yaml_file_read_handler(void *data, unsigned char *buffer, size_t size, */ YAML_DECLARE(void) -yaml_parser_set_input_string(yaml_parser_t *parser, - const unsigned char *input, size_t size) +yaml_parser_set_string_reader(yaml_parser_t *parser, + const unsigned char *buffer, size_t length) { assert(parser); /* Non-NULL parser object expected. */ - assert(!parser->read_handler); /* You can set the source only once. */ - assert(input); /* Non-NULL input string expected. */ + assert(!parser->reader); /* You can set the input handler only once. */ + assert(buffer); /* Non-NULL input string expected. */ - parser->read_handler = yaml_string_read_handler; - parser->read_handler_data = parser; + parser->reader = yaml_string_reader; + parser->reader_data = &(parser->standard_reader_data); - parser->input.string.start = input; - parser->input.string.current = input; - parser->input.string.end = input+size; + parser->standard_reader_data.string.buffer = (unsigned char *)buffer; + parser->standard_reader_data.string.pointer = 0; + parser->standard_reader_data.string.capacity = length; } /* @@ -300,16 +303,16 @@ yaml_parser_set_input_string(yaml_parser_t *parser, */ YAML_DECLARE(void) -yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file) +yaml_parser_set_file_reader(yaml_parser_t *parser, FILE *file) { assert(parser); /* Non-NULL parser object expected. */ - assert(!parser->read_handler); /* You can set the source only once. */ + assert(!parser->reader); /* You can set the input handler only once. */ assert(file); /* Non-NULL file object expected. */ - parser->read_handler = yaml_file_read_handler; - parser->read_handler_data = parser; + parser->reader = yaml_file_reader; + parser->reader_data = &(parser->standard_reader_data); - parser->input.file = file; + parser->standard_reader_data.file = file; } /* @@ -317,15 +320,15 @@ yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file) */ YAML_DECLARE(void) -yaml_parser_set_input(yaml_parser_t *parser, - yaml_read_handler_t *handler, void *data) +yaml_parser_set_reader(yaml_parser_t *parser, + yaml_reader_t *reader, void *data) { assert(parser); /* Non-NULL parser object expected. */ - assert(!parser->read_handler); /* You can set the source only once. */ - assert(handler); /* Non-NULL read handler expected. */ + assert(!parser->reader); /* You can set the input handler only once. */ + assert(reader); /* Non-NULL read handler expected. */ - parser->read_handler = handler; - parser->read_handler_data = data; + parser->reader = reader; + parser->reader_data = data; } /* @@ -336,7 +339,7 @@ YAML_DECLARE(void) yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding) { assert(parser); /* Non-NULL parser object expected. */ - assert(!parser->encoding); /* Encoding is already set or detected. */ + assert(!parser->encoding); /* Encoding is already set or detected. */ parser->encoding = encoding; } @@ -345,37 +348,34 @@ yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding) * Create a new emitter object. */ -YAML_DECLARE(int) -yaml_emitter_initialize(yaml_emitter_t *emitter) +YAML_DECLARE(yaml_emitter_t *) +yaml_emitter_new(void) { - assert(emitter); /* Non-NULL emitter object expected. */ + yaml_emitter_t *emitter = yaml_malloc(sizeof(yaml_emitter_t)); + + if (!emitter) + return NULL; memset(emitter, 0, sizeof(yaml_emitter_t)); - if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE)) + if (!BUFFER_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY)) goto error; - if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE)) + if (!BUFFER_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY)) goto error; - if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE)) + if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_CAPACITY)) goto error; - if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE)) + if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_CAPACITY)) goto error; - if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE)) + if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_CAPACITY)) goto error; - if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE)) + if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_CAPACITY)) goto error; - return 1; + return emitter; error: + yaml_emitter_delete(emitter); - BUFFER_DEL(emitter, emitter->buffer); - BUFFER_DEL(emitter, emitter->raw_buffer); - STACK_DEL(emitter, emitter->states); - QUEUE_DEL(emitter, emitter->events); - STACK_DEL(emitter, emitter->indents); - STACK_DEL(emitter, emitter->tag_directives); - - return 0; + return NULL; } /* @@ -387,8 +387,8 @@ yaml_emitter_delete(yaml_emitter_t *emitter) { assert(emitter); /* Non-NULL emitter object expected. */ - BUFFER_DEL(emitter, emitter->buffer); - BUFFER_DEL(emitter, emitter->raw_buffer); + BUFFER_DEL(emitter, emitter->output); + BUFFER_DEL(emitter, emitter->raw_output); STACK_DEL(emitter, emitter->states); while (!QUEUE_EMPTY(emitter, emitter->events)) { yaml_event_delete(&DEQUEUE(emitter, emitter->events)); @@ -404,6 +404,19 @@ yaml_emitter_delete(yaml_emitter_t *emitter) yaml_free(emitter->anchors); memset(emitter, 0, sizeof(yaml_emitter_t)); + yaml_free(emitter); +} + +/* + * Get the current emitter error. + */ + +YAML_DECLARE(void) +yaml_emitter_get_error(yaml_emitter_t *emitter, yaml_error_t *error) +{ + assert(emitter); /* Non-NULL emitter object expected. */ + + *error = emitter->error; } /* @@ -411,25 +424,21 @@ yaml_emitter_delete(yaml_emitter_t *emitter) */ static int -yaml_string_write_handler(void *data, unsigned char *buffer, size_t size) +yaml_string_writer(void *untyped_data, unsigned char *buffer, size_t length) { - yaml_emitter_t *emitter = data; - - if (emitter->output.string.size + *emitter->output.string.size_written - < size) { - memcpy(emitter->output.string.buffer - + *emitter->output.string.size_written, - buffer, - emitter->output.string.size - - *emitter->output.string.size_written); - *emitter->output.string.size_written = emitter->output.string.size; - return 0; + yaml_standard_writer_data_t *data = untyped_data; + int result = 1; + + if (data->string.capacity - data->string.pointer < length) { + length = data->string.capacity - data->string.pointer; + result = 0; } - memcpy(emitter->output.string.buffer - + *emitter->output.string.size_written, buffer, size); - *emitter->output.string.size_written += size; - return 1; + memcpy(data->string.buffer + data->string.pointer, buffer, length); + data->string.pointer += length; + *data->length += length; + + return result; } /* @@ -437,31 +446,33 @@ yaml_string_write_handler(void *data, unsigned char *buffer, size_t size) */ static int -yaml_file_write_handler(void *data, unsigned char *buffer, size_t size) +yaml_file_writer(void *untyped_data, unsigned char *buffer, size_t length) { - yaml_emitter_t *emitter = data; + yaml_standard_writer_data_t *data = untyped_data; - return (fwrite(buffer, 1, size, emitter->output.file) == size); + return (fwrite(buffer, 1, length, data->file) == length); } /* * Set a string output. */ YAML_DECLARE(void) -yaml_emitter_set_output_string(yaml_emitter_t *emitter, - unsigned char *output, size_t size, size_t *size_written) +yaml_emitter_set_string_writer(yaml_emitter_t *emitter, + unsigned char *buffer, size_t *length, size_t capacity) { assert(emitter); /* Non-NULL emitter object expected. */ - assert(!emitter->write_handler); /* You can set the output only once. */ - assert(output); /* Non-NULL output string expected. */ + assert(!emitter->writer); /* You can set the output only once. */ + assert(buffer); /* Non-NULL output string expected. */ - emitter->write_handler = yaml_string_write_handler; - emitter->write_handler_data = emitter; + emitter->writer = yaml_string_writer; + emitter->writer_data = &(emitter->standard_writer_data); - emitter->output.string.buffer = output; - emitter->output.string.size = size; - emitter->output.string.size_written = size_written; - *size_written = 0; + emitter->standard_writer_data.string.buffer = buffer; + emitter->standard_writer_data.string.pointer = 0; + emitter->standard_writer_data.string.capacity = capacity; + emitter->standard_writer_data.length = length; + + *length = 0; } /* @@ -469,16 +480,16 @@ yaml_emitter_set_output_string(yaml_emitter_t *emitter, */ YAML_DECLARE(void) -yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file) +yaml_emitter_set_file_writer(yaml_emitter_t *emitter, FILE *file) { assert(emitter); /* Non-NULL emitter object expected. */ - assert(!emitter->write_handler); /* You can set the output only once. */ + assert(!emitter->writer); /* You can set the output only once. */ assert(file); /* Non-NULL file object expected. */ - emitter->write_handler = yaml_file_write_handler; - emitter->write_handler_data = emitter; + emitter->writer = yaml_string_writer; + emitter->writer_data = &(emitter->standard_writer_data); - emitter->output.file = file; + emitter->standard_writer_data.file = file; } /* @@ -486,15 +497,15 @@ yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file) */ YAML_DECLARE(void) -yaml_emitter_set_output(yaml_emitter_t *emitter, - yaml_write_handler_t *handler, void *data) +yaml_emitter_set_writer(yaml_emitter_t *emitter, + yaml_writer_t *writer, void *data) { assert(emitter); /* Non-NULL emitter object expected. */ - assert(!emitter->write_handler); /* You can set the output only once. */ - assert(handler); /* Non-NULL handler object expected. */ + assert(!emitter->writer); /* You can set the output only once. */ + assert(writer); /* Non-NULL handler object expected. */ - emitter->write_handler = handler; - emitter->write_handler_data = data; + emitter->writer = writer; + emitter->writer_data = data; } /* @@ -515,11 +526,11 @@ yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding) */ YAML_DECLARE(void) -yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical) +yaml_emitter_set_canonical(yaml_emitter_t *emitter, int is_canonical) { assert(emitter); /* Non-NULL emitter object expected. */ - emitter->canonical = (canonical != 0); + emitter->is_canonical = (is_canonical != 0); } /* @@ -551,11 +562,11 @@ yaml_emitter_set_width(yaml_emitter_t *emitter, int width) */ YAML_DECLARE(void) -yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode) +yaml_emitter_set_unicode(yaml_emitter_t *emitter, int is_unicode) { assert(emitter); /* Non-NULL emitter object expected. */ - emitter->unicode = (unicode != 0); + emitter->is_unicode = (is_unicode != 0); } /* @@ -571,7 +582,24 @@ yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break) } /* - * Destroy a token object. + * Allocate a token object. + */ + +YAML_DECLARE(yaml_token_t *) +yaml_token_new(void) +{ + yaml_token_t *token = yaml_malloc(sizeof(yaml_token_t)); + + if (!token) + return NULL; + + memset(token, 0, sizeof(yaml_token_t)); + + return token; +} + +/* + * Deallocate a token object. */ YAML_DECLARE(void) @@ -579,6 +607,98 @@ yaml_token_delete(yaml_token_t *token) { assert(token); /* Non-NULL token object expected. */ + yaml_token_destroy(token); + yaml_free(token); +} + +/* + * Duplicate a token object. + */ + +YAML_DECLARE(int) +yaml_token_duplicate(yaml_token_t *token, yaml_token_t *model) +{ + assert(token); /* Non-NULL token object is expected. */ + assert(model); /* Non-NULL model token object is expected. */ + + memset(token, 0, sizeof(yaml_token_t)); + + token->type = model->type; + token->start_mark = model->start_mark; + token->end_mark = model->end_mark; + + switch (token->type) + { + case YAML_STREAM_START_TOKEN: + token->data.stream_start.encoding = + model->data.stream_start.encoding; + break; + + case YAML_VERSION_DIRECTIVE_TOKEN: + token->data.version_directive.major = + model->data.version_directive.major; + token->data.version_directive.minor = + model->data.version_directive.minor; + break; + + case YAML_TAG_DIRECTIVE_TOKEN: + if (!(token->data.tag_directive.handle = + yaml_strdup(model->data.tag_directive.handle))) + goto error; + if (!(token->data.tag_directive.prefix = + yaml_strdup(model->data.tag_directive.prefix))) + goto error; + break; + + case YAML_ALIAS_TOKEN: + if (!(token->data.alias.value = + yaml_strdup(model->data.alias.value))) + goto error; + break; + + case YAML_ANCHOR_TOKEN: + if (!(token->data.anchor.value = + yaml_strdup(model->data.anchor.value))) + goto error; + break; + + case YAML_TAG_TOKEN: + if (!(token->data.tag.handle = yaml_strdup(model->data.tag.handle))) + goto error; + if (!(token->data.tag.suffix = yaml_strdup(model->data.tag.suffix))) + goto error; + break; + + case YAML_SCALAR_TOKEN: + if (!(token->data.scalar.value = + yaml_malloc(model->data.scalar.length+1))) + goto error; + memcpy(token->data.scalar.value, model->data.scalar.value, + model->data.scalar.length+1); + token->data.scalar.length = model->data.scalar.length; + break; + + default: + break; + } + + return 1; + +error: + yaml_token_destroy(token); + + return 0; +} + +/* + * Destroy a token object. + */ + +YAML_DECLARE(void) +yaml_token_destroy(yaml_token_t *token) +{ + assert(token); /* Non-NULL token object expected. */ + switch (token->type) { case YAML_TAG_DIRECTIVE_TOKEN: @@ -617,18 +737,17 @@ yaml_token_delete(yaml_token_t *token) */ static int -yaml_check_utf8(yaml_char_t *start, size_t length) +yaml_valid_utf8(const yaml_char_t *buffer, size_t length) { - yaml_char_t *end = start+length; - yaml_char_t *pointer = start; + size_t pointer = 0; - while (pointer < end) { + while (pointer < length) { unsigned char octet; unsigned int width; unsigned int value; size_t k; - octet = pointer[0]; + octet = buffer[pointer]; width = (octet & 0x80) == 0x00 ? 1 : (octet & 0xE0) == 0xC0 ? 2 : (octet & 0xF0) == 0xE0 ? 3 : @@ -638,9 +757,9 @@ yaml_check_utf8(yaml_char_t *start, size_t length) (octet & 0xF0) == 0xE0 ? octet & 0x0F : (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; if (!width) return 0; - if (pointer+width > end) return 0; + if (pointer+width > length) return 0; for (k = 1; k < width; k ++) { - octet = pointer[k]; + octet = buffer[pointer+k]; if ((octet & 0xC0) != 0x80) return 0; value = (value << 6) + (octet & 0x3F); } @@ -656,11 +775,171 @@ yaml_check_utf8(yaml_char_t *start, size_t length) } /* + * Allocate an event object. + */ + +YAML_DECLARE(yaml_event_t *) +yaml_event_new(void) +{ + yaml_event_t *event = yaml_malloc(sizeof(yaml_event_t)); + + if (!event) + return NULL; + + memset(event, 0, sizeof(yaml_event_t)); + + return event; +} + +/* + * Deallocate an event object. + */ + +YAML_DECLARE(void) +yaml_event_delete(yaml_event_t *event) +{ + assert(event); /* Non-NULL event object expected. */ + + yaml_event_destroy(event); + yaml_free(event); +} + +/* + * Duplicate an event object. + */ + +YAML_DECLARE(int) +yaml_event_duplicate(yaml_event_t *event, yaml_event_t *model) +{ + struct { + yaml_error_t error; + } self; + + assert(event); /* Non-NULL event object is expected. */ + assert(model); /* Non-NULL model event object is expected. */ + + memset(event, 0, sizeof(yaml_event_t)); + + event->type = model->type; + event->start_mark = model->start_mark; + event->end_mark = model->end_mark; + + switch (event->type) + { + case YAML_STREAM_START_EVENT: + event->data.stream_start.encoding = + model->data.stream_start.encoding; + break; + + case YAML_DOCUMENT_START_EVENT: + if (model->data.document_start.version_directive) { + if (!(event->data.document_start.version_directive = + yaml_malloc(sizeof(yaml_version_directive_t)))) + goto error; + *event->data.document_start.version_directive = + *model->data.document_start.version_directive; + } + if (model->data.document_start.tag_directives.length) { + yaml_tag_directive_t *tag_directives = + model->data.document_start.tag_directives.list; + if (!STACK_INIT(&self, event->data.document_start.tag_directives, + model->data.document_start.tag_directives.capacity)) + goto error; + while (event->data.document_start.tag_directives.length != + model->data.document_start.tag_directives.length) { + yaml_tag_directive_t value; + value.handle = yaml_strdup(tag_directives->handle); + value.prefix = yaml_strdup(tag_directives->prefix); + PUSH(&self, event->data.document_start.tag_directives, value); + if (!value.handle || !value.prefix) + goto error; + tag_directives ++; + } + } + event->data.document_start.is_implicit = + model->data.document_start.is_implicit; + break; + + case YAML_DOCUMENT_END_EVENT: + event->data.document_end.is_implicit = + model->data.document_end.is_implicit; + + case YAML_ALIAS_EVENT: + if (!(event->data.alias.anchor = + yaml_strdup(model->data.alias.anchor))) + goto error; + break; + + case YAML_SCALAR_EVENT: + if (model->data.scalar.anchor && + !(event->data.scalar.anchor = + yaml_strdup(model->data.scalar.anchor))) + goto error; + if (event->data.scalar.tag && + !(event->data.scalar.tag = + yaml_strdup(model->data.scalar.tag))) + goto error; + if (!(event->data.scalar.value = + yaml_malloc(model->data.scalar.length+1))) + goto error; + memcpy(event->data.scalar.value, model->data.scalar.value, + model->data.scalar.length+1); + event->data.scalar.length = model->data.scalar.length; + event->data.scalar.is_plain_implicit = + model->data.scalar.is_plain_implicit; + event->data.scalar.is_quoted_implicit = + model->data.scalar.is_quoted_implicit; + event->data.scalar.style = model->data.scalar.style; + break; + + case YAML_SEQUENCE_START_EVENT: + if (model->data.sequence_start.anchor && + !(event->data.sequence_start.anchor = + yaml_strdup(model->data.sequence_start.anchor))) + goto error; + if (event->data.sequence_start.tag && + !(event->data.sequence_start.tag = + yaml_strdup(model->data.sequence_start.tag))) + goto error; + event->data.sequence_start.is_implicit = + model->data.sequence_start.is_implicit; + event->data.sequence_start.style = + model->data.sequence_start.style; + break; + + case YAML_MAPPING_START_EVENT: + if (model->data.mapping_start.anchor && + !(event->data.mapping_start.anchor = + yaml_strdup(model->data.mapping_start.anchor))) + goto error; + if (event->data.mapping_start.tag && + !(event->data.mapping_start.tag = + yaml_strdup(model->data.mapping_start.tag))) + goto error; + event->data.mapping_start.is_implicit = + model->data.mapping_start.is_implicit; + event->data.mapping_start.style = + model->data.mapping_start.style; + break; + + default: + break; + } + + return 1; + +error: + yaml_event_destroy(event); + + return 0; +} + +/* * Create STREAM-START. */ YAML_DECLARE(int) -yaml_stream_start_event_initialize(yaml_event_t *event, +yaml_event_create_stream_start(yaml_event_t *event, yaml_encoding_t encoding) { yaml_mark_t mark = { 0, 0, 0 }; @@ -677,7 +956,7 @@ yaml_stream_start_event_initialize(yaml_event_t *event, */ YAML_DECLARE(int) -yaml_stream_end_event_initialize(yaml_event_t *event) +yaml_event_create_stream_end(yaml_event_t *event) { yaml_mark_t mark = { 0, 0, 0 }; @@ -693,76 +972,65 @@ yaml_stream_end_event_initialize(yaml_event_t *event) */ YAML_DECLARE(int) -yaml_document_start_event_initialize(yaml_event_t *event, - yaml_version_directive_t *version_directive, - yaml_tag_directive_t *tag_directives_start, - yaml_tag_directive_t *tag_directives_end, - int implicit) +yaml_event_create_document_start(yaml_event_t *event, + const yaml_version_directive_t *version_directive, + const yaml_tag_directive_t *tag_directives, + int is_implicit) { struct { - yaml_error_type_t error; - } context; + yaml_error_t error; + } self; yaml_mark_t mark = { 0, 0, 0 }; yaml_version_directive_t *version_directive_copy = NULL; struct { - yaml_tag_directive_t *start; - yaml_tag_directive_t *end; - yaml_tag_directive_t *top; - } tag_directives_copy = { NULL, NULL, NULL }; - yaml_tag_directive_t value = { NULL, NULL }; + yaml_tag_directive_t *list; + size_t length; + size_t capacity; + } tag_directives_copy = { NULL, 0, 0 }; assert(event); /* Non-NULL event object is expected. */ - assert((tag_directives_start && tag_directives_end) || - (tag_directives_start == tag_directives_end)); - /* Valid tag directives are expected. */ if (version_directive) { version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t)); if (!version_directive_copy) goto error; - version_directive_copy->major = version_directive->major; - version_directive_copy->minor = version_directive->minor; + *version_directive_copy = *version_directive; } - if (tag_directives_start != tag_directives_end) { - yaml_tag_directive_t *tag_directive; - if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE)) + if (tag_directives && (tag_directives->handle || tag_directives->prefix)) { + if (!STACK_INIT(&self, tag_directives_copy, INITIAL_STACK_CAPACITY)) goto error; - for (tag_directive = tag_directives_start; - tag_directive != tag_directives_end; tag_directive ++) { - assert(tag_directive->handle); - assert(tag_directive->prefix); - if (!yaml_check_utf8(tag_directive->handle, - strlen((char *)tag_directive->handle))) + while (tag_directives->handle || tag_directives->prefix) { + yaml_tag_directive_t value = *tag_directives; + assert(value.handle); + assert(value.prefix); + if (!yaml_valid_utf8(value.handle, strlen((char *)value.handle))) goto error; - if (!yaml_check_utf8(tag_directive->prefix, - strlen((char *)tag_directive->prefix))) + if (!yaml_valid_utf8(value.prefix, strlen((char *)value.prefix))) goto error; - value.handle = yaml_strdup(tag_directive->handle); - value.prefix = yaml_strdup(tag_directive->prefix); - if (!value.handle || !value.prefix) goto error; - if (!PUSH(&context, tag_directives_copy, value)) + if (!PUSH(&self, tag_directives_copy, value)) + goto error; + value.handle = yaml_strdup(value.handle); + value.prefix = yaml_strdup(value.prefix); + tag_directives_copy.list[tag_directives_copy.length-1] = value; + if (!value.handle || !value.prefix) goto error; - value.handle = NULL; - value.prefix = NULL; } } DOCUMENT_START_EVENT_INIT(*event, version_directive_copy, - tag_directives_copy.start, tag_directives_copy.top, - implicit, mark, mark); + tag_directives_copy.list, tag_directives_copy.length, + tag_directives_copy.capacity, is_implicit, mark, mark); return 1; error: yaml_free(version_directive_copy); - while (!STACK_EMPTY(context, tag_directives_copy)) { - yaml_tag_directive_t value = POP(context, tag_directives_copy); + while (!STACK_EMPTY(&self, tag_directives_copy)) { + yaml_tag_directive_t value = POP(&self, tag_directives_copy); yaml_free(value.handle); yaml_free(value.prefix); } - STACK_DEL(context, tag_directives_copy); - yaml_free(value.handle); - yaml_free(value.prefix); + STACK_DEL(&self, tag_directives_copy); return 0; } @@ -772,13 +1040,13 @@ error: */ YAML_DECLARE(int) -yaml_document_end_event_initialize(yaml_event_t *event, int implicit) +yaml_event_create_document_end(yaml_event_t *event, int is_implicit) { yaml_mark_t mark = { 0, 0, 0 }; assert(event); /* Non-NULL emitter object is expected. */ - DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark); + DOCUMENT_END_EVENT_INIT(*event, is_implicit, mark, mark); return 1; } @@ -788,7 +1056,7 @@ yaml_document_end_event_initialize(yaml_event_t *event, int implicit) */ YAML_DECLARE(int) -yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor) +yaml_event_create_alias(yaml_event_t *event, const yaml_char_t *anchor) { yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *anchor_copy = NULL; @@ -796,7 +1064,7 @@ yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor) assert(event); /* Non-NULL event object is expected. */ assert(anchor); /* Non-NULL anchor is expected. */ - if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0; + if (!yaml_valid_utf8(anchor, strlen((char *)anchor))) return 0; anchor_copy = yaml_strdup(anchor); if (!anchor_copy) @@ -812,10 +1080,10 @@ yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor) */ YAML_DECLARE(int) -yaml_scalar_event_initialize(yaml_event_t *event, - yaml_char_t *anchor, yaml_char_t *tag, - yaml_char_t *value, int length, - int plain_implicit, int quoted_implicit, +yaml_event_create_scalar(yaml_event_t *event, + const yaml_char_t *anchor, const yaml_char_t *tag, + const yaml_char_t *value, size_t length, + int is_plain_implicit, int is_quoted_implicit, yaml_scalar_style_t style) { yaml_mark_t mark = { 0, 0, 0 }; @@ -827,29 +1095,35 @@ yaml_scalar_event_initialize(yaml_event_t *event, assert(value); /* Non-NULL anchor is expected. */ if (anchor) { - if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; + if (!yaml_valid_utf8(anchor, strlen((char *)anchor))) + goto error; anchor_copy = yaml_strdup(anchor); - if (!anchor_copy) goto error; + if (!anchor_copy) + goto error; } if (tag) { - if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; + if (!yaml_valid_utf8(tag, strlen((char *)tag))) + goto error; tag_copy = yaml_strdup(tag); - if (!tag_copy) goto error; + if (!tag_copy) + goto error; } if (length < 0) { length = strlen((char *)value); } - if (!yaml_check_utf8(value, length)) goto error; + if (!yaml_valid_utf8(value, length)) + goto error; value_copy = yaml_malloc(length+1); - if (!value_copy) goto error; + if (!value_copy) + goto error; memcpy(value_copy, value, length); value_copy[length] = '\0'; SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length, - plain_implicit, quoted_implicit, style, mark, mark); + is_plain_implicit, is_quoted_implicit, style, mark, mark); return 1; @@ -866,9 +1140,9 @@ error: */ YAML_DECLARE(int) -yaml_sequence_start_event_initialize(yaml_event_t *event, - yaml_char_t *anchor, yaml_char_t *tag, int implicit, - yaml_sequence_style_t style) +yaml_event_create_sequence_start(yaml_event_t *event, + const yaml_char_t *anchor, const yaml_char_t *tag, + int is_implicit, yaml_sequence_style_t style) { yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *anchor_copy = NULL; @@ -877,19 +1151,23 @@ yaml_sequence_start_event_initialize(yaml_event_t *event, assert(event); /* Non-NULL event object is expected. */ if (anchor) { - if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; + if (!yaml_valid_utf8(anchor, strlen((char *)anchor))) + goto error; anchor_copy = yaml_strdup(anchor); - if (!anchor_copy) goto error; + if (!anchor_copy) + goto error; } if (tag) { - if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; + if (!yaml_valid_utf8(tag, strlen((char *)tag))) + goto error; tag_copy = yaml_strdup(tag); - if (!tag_copy) goto error; + if (!tag_copy) + goto error; } SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy, - implicit, style, mark, mark); + is_implicit, style, mark, mark); return 1; @@ -905,7 +1183,7 @@ error: */ YAML_DECLARE(int) -yaml_sequence_end_event_initialize(yaml_event_t *event) +yaml_event_create_sequence_end(yaml_event_t *event) { yaml_mark_t mark = { 0, 0, 0 }; @@ -921,9 +1199,9 @@ yaml_sequence_end_event_initialize(yaml_event_t *event) */ YAML_DECLARE(int) -yaml_mapping_start_event_initialize(yaml_event_t *event, - yaml_char_t *anchor, yaml_char_t *tag, int implicit, - yaml_mapping_style_t style) +yaml_event_create_mapping_start(yaml_event_t *event, + const yaml_char_t *anchor, const yaml_char_t *tag, + int is_implicit, yaml_mapping_style_t style) { yaml_mark_t mark = { 0, 0, 0 }; yaml_char_t *anchor_copy = NULL; @@ -932,19 +1210,23 @@ yaml_mapping_start_event_initialize(yaml_event_t *event, assert(event); /* Non-NULL event object is expected. */ if (anchor) { - if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; + if (!yaml_valid_utf8(anchor, strlen((char *)anchor))) + goto error; anchor_copy = yaml_strdup(anchor); - if (!anchor_copy) goto error; + if (!anchor_copy) + goto error; } if (tag) { - if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; + if (!yaml_valid_utf8(tag, strlen((char *)tag))) + goto error; tag_copy = yaml_strdup(tag); - if (!tag_copy) goto error; + if (!tag_copy) + goto error; } MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy, - implicit, style, mark, mark); + is_implicit, style, mark, mark); return 1; @@ -960,7 +1242,7 @@ error: */ YAML_DECLARE(int) -yaml_mapping_end_event_initialize(yaml_event_t *event) +yaml_event_create_mapping_end(yaml_event_t *event) { yaml_mark_t mark = { 0, 0, 0 }; @@ -976,9 +1258,11 @@ yaml_mapping_end_event_initialize(yaml_event_t *event) */ YAML_DECLARE(void) -yaml_event_delete(yaml_event_t *event) +yaml_event_destroy(yaml_event_t *event) { - yaml_tag_directive_t *tag_directive; + struct { + yaml_error_t error; + } self; assert(event); /* Non-NULL event object expected. */ @@ -986,13 +1270,13 @@ yaml_event_delete(yaml_event_t *event) { case YAML_DOCUMENT_START_EVENT: yaml_free(event->data.document_start.version_directive); - for (tag_directive = event->data.document_start.tag_directives.start; - tag_directive != event->data.document_start.tag_directives.end; - tag_directive++) { - yaml_free(tag_directive->handle); - yaml_free(tag_directive->prefix); + while (!STACK_EMPTY(&self, event->data.document_start.tag_directives)) { + yaml_tag_directive_t value = POP(&self, + event->data.document_start.tag_directives); + yaml_free(value.handle); + yaml_free(value.prefix); } - yaml_free(event->data.document_start.tag_directives.start); + STACK_DEL(&self, event->data.document_start.tag_directives); break; case YAML_ALIAS_EVENT: @@ -1022,6 +1306,8 @@ yaml_event_delete(yaml_event_t *event) memset(event, 0, sizeof(yaml_event_t)); } +#if 0 + /* * Create a document object. */ @@ -1072,10 +1358,10 @@ yaml_document_initialize(yaml_document_t *document, tag_directive != tag_directives_end; tag_directive ++) { assert(tag_directive->handle); assert(tag_directive->prefix); - if (!yaml_check_utf8(tag_directive->handle, + if (!yaml_valid_utf8(tag_directive->handle, strlen((char *)tag_directive->handle))) goto error; - if (!yaml_check_utf8(tag_directive->prefix, + if (!yaml_valid_utf8(tag_directive->prefix, strlen((char *)tag_directive->prefix))) goto error; value.handle = yaml_strdup(tag_directive->handle); @@ -1210,7 +1496,7 @@ yaml_document_add_scalar(yaml_document_t *document, tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG; } - if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; + if (!yaml_valid_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; @@ -1218,7 +1504,7 @@ yaml_document_add_scalar(yaml_document_t *document, length = strlen((char *)value); } - if (!yaml_check_utf8(value, length)) goto error; + if (!yaml_valid_utf8(value, length)) goto error; value_copy = yaml_malloc(length+1); if (!value_copy) goto error; memcpy(value_copy, value, length); @@ -1262,7 +1548,7 @@ yaml_document_add_sequence(yaml_document_t *document, tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG; } - if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; + if (!yaml_valid_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; @@ -1307,7 +1593,7 @@ yaml_document_add_mapping(yaml_document_t *document, tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG; } - if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; + if (!yaml_valid_utf8(tag, strlen((char *)tag))) goto error; tag_copy = yaml_strdup(tag); if (!tag_copy) goto error; @@ -1385,4 +1671,5 @@ yaml_document_append_mapping_pair(yaml_document_t *document, return 1; } +#endif diff --git a/src/yaml_private.h b/src/yaml_private.h index 6320caf..8fe55f0 100644 --- a/src/yaml_private.h +++ b/src/yaml_private.h @@ -25,123 +25,196 @@ YAML_DECLARE(yaml_char_t *) yaml_strdup(const yaml_char_t *); /* - * Reader: Ensure that the buffer contains at least `length` characters. - */ - -YAML_DECLARE(int) -yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); - -/* - * Scanner: Ensure that the token stack contains at least one token ready. + * Error management. */ -YAML_DECLARE(int) -yaml_parser_fetch_more_tokens(yaml_parser_t *parser); +#define MEMORY_ERROR_INIT(error) \ + (memset(&(error), 0, sizeof(error)), \ + (error).type = YAML_MEMORY_ERROR, \ + 0) + +#define READING_ERROR_INIT(error,error_type,error_problem,error_offset,error_value) \ + (memset(&(error), 0, sizeof(error)), \ + (error).type = (error_type), \ + (error).data.reading.problem = (error_problem), \ + (error).data.reading.offset = (error_offset), \ + (error).data.reading.value = (error_value), \ + 0) + +#define LOADING_ERROR_INIT(error,error_type,error_problem,error_problem_mark) \ + (memset(&(error), 0, sizeof(error)), \ + (error).type = (error_type), \ + (error).data.loading.context = NULL, \ + (error).data.loading.context_mark.index = 0, \ + (error).data.loading.context_mark.line = 0, \ + (error).data.loading.context_mark.column = 0, \ + (error).data.loading.problem = (error_problem), \ + (error).data.loading.problem_mark = (error_problem_mark), \ + 0) + +#define LOADING_ERROR_WITH_CONTEXT_INIT(error,error_type,error_context,error_context_mark,error_problem,error_problem_mark) \ + (memset(&(error), 0, sizeof(error)), \ + (error).type = (error_type), \ + (error).data.loading.context = (error_context), \ + (error).data.loading.context_mark = (error_context_mark), \ + (error).data.loading.problem = (error_problem), \ + (error).data.loading.problem_mark = (error_problem_mark), \ + 0) + +#define WRITING_ERROR_INIT(error,error_type,error_problem,error_offset) \ + (memset(&(error), 0, sizeof(error)), \ + (error).type = (error_type), \ + (error).data.writing.problem = (error_problem), \ + (error).data.writing.offset = (error_offset), \ + 0) + +#define DUMPING_ERROR_INIT(error,error_type,error_problem) \ + (memset(&(error), 0, sizeof(error)), \ + (error).type = (error_type), \ + (error).type.dumping.problem = (error_problem), \ + 0) + +#define READER_ERROR_INIT(error,problem,offset) \ + READING_ERROR_INIT(error,YAML_READER_ERROR,problem,offset,-1) + +#define DECODER_ERROR_INIT(error,problem,offset,value) \ + READING_ERROR_INIT(error,YAML_DECODER_ERROR,problem,offset,value) + +#define SCANNER_ERROR_INIT(error,problem,problem_mark) \ + LOADING_ERROR_INIT(error,YAML_SCANNER_ERROR,problem,problem_mark) + +#define SCANNER_ERROR_WITH_CONTEXT_INIT(error,context,context_mark,problem,problem_mark) \ + LOADING_ERROR_WITH_CONTEXT_INIT(error,YAML_SCANNER_ERROR,context,context_mark,problem,problem_mark) + +#define PARSER_ERROR_INIT(error,problem,problem_mark) \ + LOADING_ERROR_INIT(error,YAML_PARSER_ERROR,problem,problem_mark) + +#define PARSER_ERROR_WITH_CONTEXT_INIT(error,context,context_mark,problem,problem_mark) \ + LOADING_ERROR_WITH_CONTEXT_INIT(error,YAML_PARSER_ERROR,context,context_mark,problem,problem_mark) + +#define COMPOSER_ERROR_INIT(error,problem,problem_mark) \ + LOADING_ERROR_INIT(error,YAML_COMPOSER_ERROR,problem,problem_mark) + +#define COMPOSER_ERROR_WITH_CONTEXT_INIT(error,context,context_mark,problem,problem_mark) \ + LOADING_ERROR_WITH_CONTEXT_INIT(error,YAML_COMPOSER_ERROR,context,context_mark,problem,problem_mark) + +#define WRITER_ERROR_INIT(error,problem,offset) \ + WRITING_ERROR_INIT(error,YAML_WRITER_ERROR,problem,offset) + +#define EMITTER_ERROR_INIT(error,context,problem) \ + DUMPING_ERROR_INIT(error,YAML_EMITTER_ERROR,problem) + +#define SERIALIZER_ERROR_INIT(error,context) \ + DUMPING_ERROR_INIT(error,YAML_SERIALIZER_ERROR,problem) /* * The size of the input raw buffer. */ -#define INPUT_RAW_BUFFER_SIZE 16384 +#define RAW_INPUT_BUFFER_CAPACITY 16384 /* * The size of the input buffer. * - * It should be possible to decode the whole raw buffer. + * The input buffer should be large enough to hold the content of the raw + * buffer after it is decoded. */ -#define INPUT_BUFFER_SIZE (INPUT_RAW_BUFFER_SIZE*3) +#define INPUT_BUFFER_CAPACITY (RAW_INPUT_BUFFER_CAPACITY*3) /* * The size of the output buffer. */ -#define OUTPUT_BUFFER_SIZE 16384 +#define OUTPUT_BUFFER_CAPACITY 16384 /* * The size of the output raw buffer. * - * It should be possible to encode the whole output buffer. + * The raw buffer should be able to hold the content of the output buffer + * after it is encoded. */ -#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2) +#define RAW_OUTPUT_BUFFER_CAPACITY (OUTPUT_BUFFER_CAPACITY*2+2) /* * The size of other stacks and queues. */ -#define INITIAL_STACK_SIZE 16 -#define INITIAL_QUEUE_SIZE 16 -#define INITIAL_STRING_SIZE 16 +#define INITIAL_STACK_CAPACITY 16 +#define INITIAL_QUEUE_CAPACITY 16 +#define INITIAL_STRING_CAPACITY 16 /* - * Buffer management. + * Input/output buffer management. */ -#define BUFFER_INIT(context,buffer,size) \ - (((buffer).start = yaml_malloc(size)) ? \ - ((buffer).last = (buffer).pointer = (buffer).start, \ - (buffer).end = (buffer).start+(size), \ +#define STORAGE_INIT(self,storage,storage_capacity) \ + (((storage).buffer = yaml_malloc(storage_capacity)) ? \ + ((storage).pointer = (storage).length = 0, \ + (buffer).capacity = (storage_capacity) \ 1) : \ - ((context)->error = YAML_MEMORY_ERROR, \ + ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define BUFFER_DEL(context,buffer) \ - (yaml_free((buffer).start), \ - (buffer).start = (buffer).pointer = (buffer).end = 0) +#define STORAGE_DEL(self,storage) \ + (yaml_free((storage).buffer), \ + (storage).pointer = (storage).length = (storage).capacity = 0) /* * String management. */ -typedef struct { - yaml_char_t *start; - yaml_char_t *end; - yaml_char_t *pointer; +typedef struct yaml_string_s { + yaml_char_t *buffer; + size_t pointer; + size_t capacity; } yaml_string_t; YAML_DECLARE(int) -yaml_string_extend(yaml_char_t **start, - yaml_char_t **pointer, yaml_char_t **end); +yaml_string_extend(yaml_char_t **buffer, size_t *capacity); YAML_DECLARE(int) yaml_string_join( - yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end, - yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end); + yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity, + yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity); #define NULL_STRING { NULL, NULL, NULL } -#define STRING(string,length) { (string), (string)+(length), (string) } +#define STRING(string,capacity) { (string), 0, (capacity) } -#define STRING_INIT(context,string,size) \ - (((string).start = yaml_malloc(size)) ? \ - ((string).pointer = (string).start, \ - (string).end = (string).start+(size), \ - memset((string).start, 0, (size)), \ +#define STRING_INIT(self,string,string_capacity) \ + (((string).buffer = yaml_malloc(string_capacity)) ? \ + ((string).pointer = 0, \ + (string).capacity = (string_capacity), \ + memset((string).buffer, 0, (string_capacity)), \ 1) : \ - ((context)->error = YAML_MEMORY_ERROR, \ + ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define STRING_DEL(context,string) \ - (yaml_free((string).start), \ - (string).start = (string).pointer = (string).end = 0) - -#define STRING_EXTEND(context,string) \ - (((string).pointer+5 < (string).end) \ - || yaml_string_extend(&(string).start, \ - &(string).pointer, &(string).end)) - -#define CLEAR(context,string) \ - ((string).pointer = (string).start, \ - memset((string).start, 0, (string).end-(string).start)) - -#define JOIN(context,string_a,string_b) \ - ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ - &(string_a).end, &(string_b).start, \ - &(string_b).pointer, &(string_b).end)) ? \ - ((string_b).pointer = (string_b).start, \ +#define STRING_DEL(self,string) \ + (yaml_free((string).buffer), \ + (string).buffer = NULL, \ + ((string).pointer = (string).capacity = 0)) + +#define STRING_EXTEND(self,string) \ + ((((string).pointer+5 < (string).capacity) \ + || yaml_string_extend(&(string).buffer, &(string).capacity)) ? \ + 1 : \ + ((self)->error.type = YAML_MEMORY_ERROR, \ + 0)) + +#define CLEAR(self,string) \ + ((string).pointer = 0, \ + memset((string).buffer, 0, (string).capacity)) + +#define JOIN(self,base_string,adj_string) \ + ((yaml_string_join(&(base_string).buffer, &(base_string).pointer, \ + &(base_string).capacity, (adj_string).buffer, \ + (adj_string).pointer, (adj_string).capacity)) ? \ + ((adj_string).pointer = 0, \ 1) : \ - ((context)->error = YAML_MEMORY_ERROR, \ + ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) /* @@ -149,11 +222,24 @@ yaml_string_join( */ /* + * Get the octet at the specified position. + */ + +#define OCTET_AT(string,offset) \ + ((string).buffer[(string).pointer+(offset)]) + +/* + * Get the current offset. + */ + +#define OCTET(string) OCTET_AT((string),0) + +/* * Check the octet at the specified position. */ #define CHECK_AT(string,octet,offset) \ - ((string).pointer[offset] == (yaml_char_t)(octet)) + (OCTET_AT((string),(offset)) == (yaml_char_t)(octet)) /* * Check the current octet in the buffer. @@ -167,14 +253,14 @@ yaml_string_join( */ #define IS_ALPHA_AT(string,offset) \ - (((string).pointer[offset] >= (yaml_char_t) '0' && \ - (string).pointer[offset] <= (yaml_char_t) '9') || \ - ((string).pointer[offset] >= (yaml_char_t) 'A' && \ - (string).pointer[offset] <= (yaml_char_t) 'Z') || \ - ((string).pointer[offset] >= (yaml_char_t) 'a' && \ - (string).pointer[offset] <= (yaml_char_t) 'z') || \ - (string).pointer[offset] == '_' || \ - (string).pointer[offset] == '-') + ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) '9') || \ + (OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) 'Z') || \ + (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) 'z') || \ + OCTET_AT((string),(offset)) == '_' || \ + OCTET_AT((string),(offset)) == '-') #define IS_ALPHA(string) IS_ALPHA_AT((string),0) @@ -183,8 +269,8 @@ yaml_string_join( */ #define IS_DIGIT_AT(string,offset) \ - (((string).pointer[offset] >= (yaml_char_t) '0' && \ - (string).pointer[offset] <= (yaml_char_t) '9')) + ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) '9')) #define IS_DIGIT(string) IS_DIGIT_AT((string),0) @@ -193,7 +279,7 @@ yaml_string_join( */ #define AS_DIGIT_AT(string,offset) \ - ((string).pointer[offset] - (yaml_char_t) '0') + (OCTET_AT((string),(offset)) - (yaml_char_t) '0') #define AS_DIGIT(string) AS_DIGIT_AT((string),0) @@ -202,12 +288,12 @@ yaml_string_join( */ #define IS_HEX_AT(string,offset) \ - (((string).pointer[offset] >= (yaml_char_t) '0' && \ - (string).pointer[offset] <= (yaml_char_t) '9') || \ - ((string).pointer[offset] >= (yaml_char_t) 'A' && \ - (string).pointer[offset] <= (yaml_char_t) 'F') || \ - ((string).pointer[offset] >= (yaml_char_t) 'a' && \ - (string).pointer[offset] <= (yaml_char_t) 'f')) + ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) '9') || \ + (OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) 'F') || \ + (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) 'f')) #define IS_HEX(string) IS_HEX_AT((string),0) @@ -216,13 +302,13 @@ yaml_string_join( */ #define AS_HEX_AT(string,offset) \ - (((string).pointer[offset] >= (yaml_char_t) 'A' && \ - (string).pointer[offset] <= (yaml_char_t) 'F') ? \ - ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ - ((string).pointer[offset] >= (yaml_char_t) 'a' && \ - (string).pointer[offset] <= (yaml_char_t) 'f') ? \ - ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ - ((string).pointer[offset] - (yaml_char_t) '0')) + ((OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) 'F') ? \ + (OCTET_AT((string),(offset)) - (yaml_char_t) 'A' + 10) : \ + (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' && \ + OCTET_AT((string),(offset)) <= (yaml_char_t) 'f') ? \ + (OCTET_AT((string),(offset)) - (yaml_char_t) 'a' + 10) : \ + (OCTET_AT((string),(offset)) - (yaml_char_t) '0')) #define AS_HEX(string) AS_HEX_AT((string),0) @@ -231,7 +317,7 @@ yaml_string_join( */ #define IS_ASCII_AT(string,offset) \ - ((string).pointer[offset] <= (yaml_char_t) '\x7F') + (OCTET_AT((string),(offset)) <= (yaml_char_t) '\x7F') #define IS_ASCII(string) IS_ASCII_AT((string),0) @@ -240,22 +326,22 @@ yaml_string_join( */ #define IS_PRINTABLE_AT(string,offset) \ - (((string).pointer[offset] == 0x0A) /* . == #x0A */ \ - || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \ - && (string).pointer[offset] <= 0x7E) \ - || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ - && (string).pointer[offset+1] >= 0xA0) \ - || ((string).pointer[offset] > 0xC2 \ - && (string).pointer[offset] < 0xED) \ - || ((string).pointer[offset] == 0xED \ - && (string).pointer[offset+1] < 0xA0) \ - || ((string).pointer[offset] == 0xEE) \ - || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \ - && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \ - && (string).pointer[offset+2] == 0xBF) \ - && !((string).pointer[offset+1] == 0xBF \ - && ((string).pointer[offset+2] == 0xBE \ - || (string).pointer[offset+2] == 0xBF)))) + ((OCTET_AT((string),(offset)) == 0x0A) /* . == #x0A */ \ + || (OCTET_AT((string),(offset)) >= 0x20 /* #x20 <= . <= #x7E */ \ + && OCTET_AT((string),(offset)) <= 0x7E) \ + || (OCTET_AT((string),(offset)) == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ + && OCTET_AT((string),(offset)+1) >= 0xA0) \ + || (OCTET_AT((string),(offset)) > 0xC2 \ + && OCTET_AT((string),(offset)) < 0xED) \ + || (OCTET_AT((string),(offset)) == 0xED \ + && OCTET_AT((string),(offset)+1) < 0xA0) \ + || (OCTET_AT((string),(offset)) == 0xEE) \ + || (OCTET_AT((string),(offset)) == 0xEF /* #xE000 <= . <= #xFFFD */ \ + && !(OCTET_AT((string),(offset)+1) == 0xBB /* && . != #xFEFF */ \ + && OCTET_AT((string),(offset)+2) == 0xBF) \ + && !(OCTET_AT((string),(offset)+1) == 0xBF \ + && (OCTET_AT((string),(offset)+2) == 0xBE \ + || OCTET_AT((string),(offset)+2) == 0xBF)))) #define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0) @@ -358,10 +444,10 @@ yaml_string_join( */ #define WIDTH_AT(string,offset) \ - (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ - ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ - ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ - ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) + ((OCTET_AT((string),(offset)) & 0x80) == 0x00 ? 1 : \ + (OCTET_AT((string),(offset)) & 0xE0) == 0xC0 ? 2 : \ + (OCTET_AT((string),(offset)) & 0xF0) == 0xE0 ? 3 : \ + (OCTET_AT((string),(offset)) & 0xF8) == 0xF0 ? 4 : 0) #define WIDTH(string) WIDTH_AT((string),0) @@ -372,99 +458,111 @@ yaml_string_join( #define MOVE(string) ((string).pointer += WIDTH((string))) /* + * Copy a single octet and bump the pointers. + */ + +#define COPY_OCTET(string_a,string_b) \ + ((string_a).buffer[(string_a).pointer++] \ + = (string_b).buffer[(string_b).pointer++]) + +/* * Copy a character and move the pointers of both strings. */ #define COPY(string_a,string_b) \ - ((*(string_b).pointer & 0x80) == 0x00 ? \ - (*((string_a).pointer++) = *((string_b).pointer++)) : \ - (*(string_b).pointer & 0xE0) == 0xC0 ? \ - (*((string_a).pointer++) = *((string_b).pointer++), \ - *((string_a).pointer++) = *((string_b).pointer++)) : \ - (*(string_b).pointer & 0xF0) == 0xE0 ? \ - (*((string_a).pointer++) = *((string_b).pointer++), \ - *((string_a).pointer++) = *((string_b).pointer++), \ - *((string_a).pointer++) = *((string_b).pointer++)) : \ - (*(string_b).pointer & 0xF8) == 0xF0 ? \ - (*((string_a).pointer++) = *((string_b).pointer++), \ - *((string_a).pointer++) = *((string_b).pointer++), \ - *((string_a).pointer++) = *((string_b).pointer++), \ - *((string_a).pointer++) = *((string_b).pointer++)) : 0) + ((OCTET(string_b) & 0x80) == 0x00 ? \ + COPY_OCTET((string_a),(string_b)) : \ + (OCTET(string_b) & 0xE0) == 0xC0 ? \ + (COPY_OCTET((string_a),(string_b)), \ + COPY_OCTET((string_a),(string_b))) : \ + (OCTET(string_b) & 0xF0) == 0xE0 ? \ + (COPY_OCTET((string_a),(string_b)), \ + COPY_OCTET((string_a),(string_b)), \ + COPY_OCTET((string_a),(string_b))) : \ + (OCTET(string_b) & 0xF8) == 0xF0 ? \ + (COPY_OCTET((string_a),(string_b)), \ + COPY_OCTET((string_a),(string_b)), \ + COPY_OCTET((string_a),(string_b)), \ + COPY_OCTET((string_a),(string_b))) : 0) \ /* * Stack and queue management. */ YAML_DECLARE(int) -yaml_stack_extend(void **start, void **top, void **end); +yaml_stack_extend(void **list, size_t size, size_t *length, size_t *capacity); YAML_DECLARE(int) -yaml_queue_extend(void **start, void **head, void **tail, void **end); +yaml_queue_extend(void **list, size_t size, + size_t *head, size_t *tail, size_t *capacity); -#define STACK_INIT(context,stack,size) \ - (((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ? \ - ((stack).top = (stack).start, \ - (stack).end = (stack).start+(size), \ +#define STACK_INIT(self,stack,stack_capacity) \ + (((stack).list = yaml_malloc((stack_capacity)*sizeof(*(stack).list))) ? \ + ((stack).length = 0, \ + (stack).capacity = (stack_capacity), \ 1) : \ - ((context)->error = YAML_MEMORY_ERROR, \ + ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define STACK_DEL(context,stack) \ - (yaml_free((stack).start), \ - (stack).start = (stack).top = (stack).end = 0) +#define STACK_DEL(self,stack) \ + (yaml_free((stack).list), \ + (stack).list = NULL, \ + (stack).length = (stack).capacity = 0) -#define STACK_EMPTY(context,stack) \ - ((stack).start == (stack).top) +#define STACK_EMPTY(self,stack) \ + ((stack).length == 0) -#define PUSH(context,stack,value) \ - (((stack).top != (stack).end \ - || yaml_stack_extend((void **)&(stack).start, \ - (void **)&(stack).top, (void **)&(stack).end)) ? \ - (*((stack).top++) = value, \ +#define PUSH(self,stack,value) \ + (((stack).length < (stack).capacity \ + || yaml_stack_extend((void **)&(stack).list, sizeof(*(stack).list), \ + &(stack).length, &(stack).capacity)) ? \ + ((stack).list[(stack).length++] = (value), \ 1) : \ - ((context)->error = YAML_MEMORY_ERROR, \ + ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define POP(context,stack) \ - (*(--(stack).top)) +#define POP(self,stack) \ + ((stack).list[--(stack).length]) -#define QUEUE_INIT(context,queue,size) \ - (((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ? \ - ((queue).head = (queue).tail = (queue).start, \ - (queue).end = (queue).start+(size), \ +#define QUEUE_INIT(self,queue,queue_capacity) \ + (((queue).list = yaml_malloc((queue_capacity)*sizeof(*(queue).list))) ? \ + ((queue).head = (queue).tail = 0, \ + (queue).capacity = (queue_capacity), \ 1) : \ - ((context)->error = YAML_MEMORY_ERROR, \ + ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define QUEUE_DEL(context,queue) \ - (yaml_free((queue).start), \ - (queue).start = (queue).head = (queue).tail = (queue).end = 0) +#define QUEUE_DEL(self,queue) \ + (yaml_free((queue).list), \ + (queue).list = NULL, \ + (queue).head = (queue).tail = (queue).capacity = 0) -#define QUEUE_EMPTY(context,queue) \ +#define QUEUE_EMPTY(self,queue) \ ((queue).head == (queue).tail) -#define ENQUEUE(context,queue,value) \ - (((queue).tail != (queue).end \ - || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ - (void **)&(queue).tail, (void **)&(queue).end)) ? \ - (*((queue).tail++) = value, \ +#define ENQUEUE(self,queue,value) \ + (((queue).tail != (queue).capacity \ + || yaml_queue_extend((void **)&(queue).list, sizeof(*(queue).list), \ + &(queue).head, &(queue).tail, &(queue).capacity)) ? \ + ((queue).list[(queue).tail++] = (value), \ 1) : \ - ((context)->error = YAML_MEMORY_ERROR, \ + ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define DEQUEUE(context,queue) \ - (*((queue).head++)) - -#define QUEUE_INSERT(context,queue,index,value) \ - (((queue).tail != (queue).end \ - || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ - (void **)&(queue).tail, (void **)&(queue).end)) ? \ - (memmove((queue).head+(index)+1,(queue).head+(index), \ - ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \ - *((queue).head+(index)) = value, \ +#define DEQUEUE(self,queue) \ + ((queue).list[(queue).head++]) + +#define QUEUE_INSERT(self,queue,index,value) \ + (((queue).tail != (queue).capacity \ + || yaml_queue_extend((void **)&(queue).list, sizeof(*(queue).list), \ + &(queue).head, &(queue).tail, &(queue).capacity)) ? \ + (memmove((queue).list+(queue).head+(index)+1, \ + (queue).list+(queue).head+(index), \ + ((queue).tail-(queue).head-(index))*sizeof(*(queue).list)), \ + (queue).list[(queue).head+(index)] = (value), \ (queue).tail++, \ 1) : \ - ((context)->error = YAML_MEMORY_ERROR, \ + ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) /* @@ -531,49 +629,52 @@ yaml_queue_extend(void **start, void **head, void **tail, void **end); (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) #define DOCUMENT_START_EVENT_INIT(event,event_version_directive, \ - event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \ + event_tag_directives_list,event_tag_directives_length, \ + event_tag_directives_capacity,event_is_implicit,start_mark,end_mark) \ (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ (event).data.document_start.version_directive = (event_version_directive), \ - (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ - (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ - (event).data.document_start.implicit = (event_implicit)) + (event).data.document_start.tag_directives.list = (event_tag_directives_list), \ + (event).data.document_start.tag_directives.length = (event_tag_directives_length), \ + (event).data.document_start.tag_directives.capacity = (event_tag_directives_capacity), \ + (event).data.document_start.is_implicit = (event_is_implicit)) -#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark) \ +#define DOCUMENT_END_EVENT_INIT(event,event_is_implicit,start_mark,end_mark) \ (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \ - (event).data.document_end.implicit = (event_implicit)) + (event).data.document_end.is_implicit = (event_is_implicit)) #define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark) \ (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \ (event).data.alias.anchor = (event_anchor)) -#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length, \ - event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark) \ +#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value, \ + event_length,event_is_plain_implicit,event_is_quoted_implicit, \ + event_style,start_mark,end_mark) \ (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ (event).data.scalar.anchor = (event_anchor), \ (event).data.scalar.tag = (event_tag), \ (event).data.scalar.value = (event_value), \ (event).data.scalar.length = (event_length), \ - (event).data.scalar.plain_implicit = (event_plain_implicit), \ - (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ + (event).data.scalar.is_plain_implicit = (event_is_plain_implicit), \ + (event).data.scalar.is_quoted_implicit = (event_is_quoted_implicit), \ (event).data.scalar.style = (event_style)) #define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \ - event_implicit,event_style,start_mark,end_mark) \ + event_is_implicit,event_style,start_mark,end_mark) \ (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ (event).data.sequence_start.anchor = (event_anchor), \ (event).data.sequence_start.tag = (event_tag), \ - (event).data.sequence_start.implicit = (event_implicit), \ + (event).data.sequence_start.is_implicit = (event_is_implicit), \ (event).data.sequence_start.style = (event_style)) #define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark) \ (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) #define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag, \ - event_implicit,event_style,start_mark,end_mark) \ + event_is_implicit,event_style,start_mark,end_mark) \ (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ (event).data.mapping_start.anchor = (event_anchor), \ (event).data.mapping_start.tag = (event_tag), \ - (event).data.mapping_start.implicit = (event_implicit), \ + (event).data.mapping_start.is_implicit = (event_is_implicit), \ (event).data.mapping_start.style = (event_style)) #define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \ @@ -633,3 +734,503 @@ yaml_queue_extend(void **start, void **head, void **tail, void **end); (node).data.mapping.pairs.top = (node_pairs_start), \ (node).data.mapping.style = (node_style)) +/* + * This structure holds information about a potential simple key. + */ + +typedef struct yaml_simple_key_s { + /* Is a simple key possible? */ + int is_possible; + /* Is a simple key required? */ + int is_required; + /* The number of the token. */ + size_t token_number; + /* The position mark. */ + yaml_mark_t mark; +} yaml_simple_key_t; + +/* + * The states of the parser. + */ + +typedef enum yaml_parser_state_e { + /* Expect STREAM-START. */ + YAML_PARSE_STREAM_START_STATE, + /* Expect the beginning of an implicit document. */ + YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE, + /* Expect DOCUMENT-START. */ + YAML_PARSE_DOCUMENT_START_STATE, + /* Expect the content of a document. */ + YAML_PARSE_DOCUMENT_CONTENT_STATE, + /* Expect DOCUMENT-END. */ + YAML_PARSE_DOCUMENT_END_STATE, + /* Expect a block node. */ + YAML_PARSE_BLOCK_NODE_STATE, + /* Expect a block node or indentless sequence. */ + YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE, + /* Expect a flow node. */ + YAML_PARSE_FLOW_NODE_STATE, + /* Expect the first entry of a block sequence. */ + YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE, + /* Expect an entry of a block sequence. */ + YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE, + /* Expect an entry of an indentless sequence. */ + YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE, + /* Expect the first key of a block mapping. */ + YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE, + /* Expect a block mapping key. */ + YAML_PARSE_BLOCK_MAPPING_KEY_STATE, + /* Expect a block mapping value. */ + YAML_PARSE_BLOCK_MAPPING_VALUE_STATE, + /* Expect the first entry of a flow sequence. */ + YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE, + /* Expect an entry of a flow sequence. */ + YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE, + /* Expect a key of an ordered mapping. */ + YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE, + /* Expect a value of an ordered mapping. */ + YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE, + /* Expect the and of an ordered mapping entry. */ + YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE, + /* Expect the first key of a flow mapping. */ + YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE, + /* Expect a key of a flow mapping. */ + YAML_PARSE_FLOW_MAPPING_KEY_STATE, + /* Expect a value of a flow mapping. */ + YAML_PARSE_FLOW_MAPPING_VALUE_STATE, + /* Expect an empty value of a flow mapping. */ + YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE, + /* Expect nothing. */ + YAML_PARSE_END_STATE +} yaml_parser_state_t; + +/* + * This structure holds aliases data. + */ + +typedef struct yaml_alias_data_s { + /* The anchor. */ + yaml_char_t *anchor; + /* The node id. */ + int index; + /* The anchor mark. */ + yaml_mark_t mark; +} yaml_alias_data_t; + +/* + * The structure that holds data used by the file and string readers. + */ + +typedef union yaml_standard_reader_data_u { + /* String input data. */ + yaml_string_t string; + /* File input data. */ + FILE *file; +} yaml_standard_reader_data_t; + +/* + * The internal parser structure. + */ + +struct yaml_parser_s { + + /* + * Error stuff. + */ + + yaml_error_t error; + + /* + * Reader stuff. + */ + + /* The read handler. */ + yaml_reader_t *reader; + + /* The application data to be passed to the reader. */ + void *reader_data; + + /* Standard (string or file) input data. */ + yaml_standard_reader_data_t standard_reader_data; + + /* EOF flag. */ + int is_eof; + + /* The working buffer. */ + struct { + yaml_char_t *buffer; + size_t pointer; + size_t length; + size_t capacity; + } input; + + /* The number of unread characters in the buffer. */ + size_t unread; + + /* The raw buffer. */ + struct { + unsigned char *buffer; + size_t pointer; + size_t length; + size_t capacity; + } raw_input; + + /* The input encoding. */ + yaml_encoding_t encoding; + + /* The offset of the current position (in bytes). */ + size_t offset; + + /* The mark of the current position. */ + yaml_mark_t mark; + + /* + * Scanner stuff. + */ + + /* Have we started to scan the input stream? */ + int is_stream_start_produced; + + /* Have we reached the end of the input stream? */ + int is_stream_end_produced; + + /* The number of unclosed '[' and '{' indicators. */ + int flow_level; + + /* The tokens queue. */ + struct { + yaml_token_t *list; + size_t head; + size_t tail; + size_t capacity; + } tokens; + + /* The number of tokens fetched from the queue. */ + size_t tokens_parsed; + + /* Does the tokens queue contain a token ready for dequeueing. */ + int is_token_available; + + /* The indentation levels stack. */ + struct { + int *list; + size_t length; + size_t capacity; + } indents; + + /* The current indentation level. */ + int indent; + + /* May a simple key occur at the current position? */ + int is_simple_key_allowed; + + /* The stack of simple keys. */ + struct { + yaml_simple_key_t *list; + size_t length; + size_t capacity; + } simple_keys; + + /* + * Parser stuff. + */ + + /* The parser states stack. */ + struct { + yaml_parser_state_t *list; + size_t length; + size_t capacity; + } states; + + /* The current parser state. */ + yaml_parser_state_t state; + + /* The stack of marks. */ + struct { + yaml_mark_t *list; + size_t length; + size_t capacity; + } marks; + + /* The list of TAG directives. */ + struct { + yaml_tag_directive_t *list; + size_t length; + size_t capacity; + } tag_directives; + + /* + * Dumper stuff. + */ + + /* The resolve handler. */ + yaml_resolver_t *resolver; + + /* The application data to be passed to the resolver. */ + void *resolver_data; + + /* The alias data. */ + struct { + yaml_alias_data_t *list; + size_t length; + size_t capacity; + } aliases; + + /* The currently parsed document. */ + yaml_document_t *document; + +}; + +/* + * The emitter states. + */ + +typedef enum yaml_emitter_state_e { + /** Expect STREAM-START. */ + YAML_EMIT_STREAM_START_STATE, + /** Expect the first DOCUMENT-START or STREAM-END. */ + YAML_EMIT_FIRST_DOCUMENT_START_STATE, + /** Expect DOCUMENT-START or STREAM-END. */ + YAML_EMIT_DOCUMENT_START_STATE, + /** Expect the content of a document. */ + YAML_EMIT_DOCUMENT_CONTENT_STATE, + /** Expect DOCUMENT-END. */ + YAML_EMIT_DOCUMENT_END_STATE, + /** Expect the first item of a flow sequence. */ + YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE, + /** Expect an item of a flow sequence. */ + YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE, + /** Expect the first key of a flow mapping. */ + YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE, + /** Expect a key of a flow mapping. */ + YAML_EMIT_FLOW_MAPPING_KEY_STATE, + /** Expect a value for a simple key of a flow mapping. */ + YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE, + /** Expect a value of a flow mapping. */ + YAML_EMIT_FLOW_MAPPING_VALUE_STATE, + /** Expect the first item of a block sequence. */ + YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE, + /** Expect an item of a block sequence. */ + YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE, + /** Expect the first key of a block mapping. */ + YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE, + /** Expect the key of a block mapping. */ + YAML_EMIT_BLOCK_MAPPING_KEY_STATE, + /** Expect a value for a simple key of a block mapping. */ + YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE, + /** Expect a value of a block mapping. */ + YAML_EMIT_BLOCK_MAPPING_VALUE_STATE, + /** Expect nothing. */ + YAML_EMIT_END_STATE +} yaml_emitter_state_t; + +/* + * The structure that holds data used by the file and string readers. + */ + +typedef union yaml_standard_writer_data_u { + /* String output data. */ + yaml_string_t string; + size_t *length; + /* File output data. */ + FILE *file; +} yaml_standard_writer_data_t; + +/* + * The internals emitter structure. + */ + +struct yaml_emitter_s { + + /* + * Error stuff. + */ + + yaml_error_t error; + + /* + * Writer stuff. + */ + + /* Write handler. */ + yaml_writer_t *writer; + + /* A pointer for passing to the white handler. */ + void *writer_data; + + /* Standard (string or file) output data. */ + yaml_standard_writer_data_t standard_writer_data; + + /* The working buffer. */ + struct { + yaml_char_t *buffer; + size_t pointer; + size_t length; + size_t capacity; + } output; + + /* The raw buffer. */ + struct { + yaml_char_t *buffer; + size_t pointer; + size_t length; + size_t capacity; + } raw_output; + + /* The stream encoding. */ + yaml_encoding_t encoding; + + /* + * Emitter stuff. + */ + + /* If the output is in the canonical style? */ + int is_canonical; + /* The number of indentation spaces. */ + int best_indent; + /* The preferred width of the output lines. */ + int best_width; + /* Allow unescaped non-ASCII characters? */ + int is_unicode; + /* The preferred line break. */ + yaml_break_t line_break; + + /* The stack of states. */ + struct { + yaml_emitter_state_t *list; + size_t length; + size_t capacity; + } states; + + /* The current emitter state. */ + yaml_emitter_state_t state; + + /* The event queue. */ + struct { + yaml_event_t *list; + size_t head; + size_t tail; + size_t capacity; + } events; + + /* The stack of indentation levels. */ + struct { + int *list; + size_t length; + size_t capacity; + } indents; + + /* The list of tag directives. */ + struct { + yaml_tag_directive_t *list; + size_t length; + size_t capacity; + } tag_directives; + + /* The current indentation level. */ + int indent; + + /* The current flow level. */ + int flow_level; + + /* Is it the document root context? */ + int is_root_context; + /* Is it a sequence context? */ + int is_sequence_context; + /* Is it a mapping context? */ + int is_mapping_context; + /* Is it a simple mapping key context? */ + int is_simple_key_context; + + /* The current line. */ + int line; + /* The current column. */ + int column; + /* If the last character was a whitespace? */ + int whitespace; + /* If the last character was an indentation character (' ', '-', '?', ':')? */ + int indention; + + /* Anchor analysis. */ + struct { + /* The anchor value. */ + yaml_char_t *anchor; + /* The anchor length. */ + size_t anchor_length; + /* Is it an alias? */ + int is_alias; + } anchor_data; + + /* Tag analysis. */ + struct { + /* The tag handle. */ + yaml_char_t *handle; + /* The tag handle length. */ + size_t handle_length; + /* The tag suffix. */ + yaml_char_t *suffix; + /* The tag suffix length. */ + size_t suffix_length; + } tag_data; + + /* Scalar analysis. */ + struct { + /* The scalar value. */ + yaml_char_t *value; + /* The scalar length. */ + size_t length; + /* Does the scalar contain line breaks? */ + int is_multiline; + /* Can the scalar be expessed in the flow plain style? */ + int is_flow_plain_allowed; + /* Can the scalar be expressed in the block plain style? */ + int is_block_plain_allowed; + /* Can the scalar be expressed in the single quoted style? */ + int is_single_quoted_allowed; + /* Can the scalar be expressed in the literal or folded styles? */ + int is_block_allowed; + /* The output style. */ + yaml_scalar_style_t style; + } scalar_data; + + /* + * Dumper stuff. + */ + + /* If the stream was already opened? */ + int is_opened; + /* If the stream was already closed? */ + int is_closed; + + /* The information associated with the document nodes. */ + struct { + /* The number of references. */ + size_t references; + /* The anchor id. */ + int anchor; + /* If the node has been emitted? */ + int is_serialized; + } *anchors; + + /* The last assigned anchor id. */ + int last_anchor_id; + + /* The currently emitted document. */ + yaml_document_t *document; + +}; + +/* + * Reader: Ensure that the buffer contains at least `length` characters. + */ + +YAML_DECLARE(int) +yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); + +/* + * Scanner: Ensure that the token stack contains at least one token ready. + */ + +YAML_DECLARE(int) +yaml_parser_fetch_more_tokens(yaml_parser_t *parser); + |