yaml_emitter_initialize(yaml_emitter_t *emitter)
{
assert(emitter); /* Non-NULL emitter object expected. */
memset(emitter, 0, sizeof(yaml_emitter_t));
if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
goto error;
if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
goto error;
if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))
goto error;
if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))
goto error;
if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))
goto error;
if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))
goto error;
return 1;
error:
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;
}
static void
yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
{
int index;
if (!emitter->anchors) {
yaml_document_delete(emitter->document);
emitter->document = NULL;
return;
}
for (index = 0; emitter->document->nodes.start + index
< emitter->document->nodes.top; index ++) {
yaml_node_t node = emitter->document->nodes.start[index];
if (!emitter->anchors[index].serialized) {
yaml_free(node.tag);
if (node.type == YAML_SCALAR_NODE) {
yaml_free(node.data.scalar.value);
}
}
if (node.type == YAML_SEQUENCE_NODE) {
STACK_DEL(emitter, node.data.sequence.items);
}
if (node.type == YAML_MAPPING_NODE) {
STACK_DEL(emitter, node.data.mapping.pairs);
}
}
STACK_DEL(emitter, emitter->document->nodes);
yaml_free(emitter->anchors);
emitter->anchors = NULL;
emitter->last_anchor_id = 0;
emitter->document = NULL;
}
static void
yaml_parser_delete_aliases(yaml_parser_t *parser)
{
while (!STACK_EMPTY(parser, parser->aliases)) {
yaml_free(POP(parser, parser->aliases).anchor);
}
STACK_DEL(parser, parser->aliases);
}
yaml_document_delete(yaml_document_t *document)
{
struct {
yaml_error_type_t error;
} context;
(void)context;
yaml_tag_directive_t *tag_directive;
context.error = YAML_NO_ERROR; /* Eliminate a compliler warning. */
assert(document); /* Non-NULL document object is expected. */
while (!STACK_EMPTY(&context, document->nodes)) {
yaml_node_t node = POP(&context, document->nodes);
yaml_free(node.tag);
switch (node.type) {
case YAML_SCALAR_NODE:
yaml_free(node.data.scalar.value);
break;
case YAML_SEQUENCE_NODE:
STACK_DEL(&context, node.data.sequence.items);
break;
case YAML_MAPPING_NODE:
STACK_DEL(&context, node.data.mapping.pairs);
break;
default:
assert(0); /* Should not happen. */
}
}
STACK_DEL(&context, document->nodes);
yaml_free(document->version_directive);
for (tag_directive = document->tag_directives.start;
tag_directive != document->tag_directives.end;
tag_directive++) {
yaml_free(tag_directive->handle);
yaml_free(tag_directive->prefix);
}
yaml_free(document->tag_directives.start);
memset(document, 0, sizeof(yaml_document_t));
}
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);
STACK_DEL(emitter, emitter->states);
while (!QUEUE_EMPTY(emitter, emitter->events)) {
yaml_event_delete(&DEQUEUE(emitter, emitter->events));
}
QUEUE_DEL(emitter, emitter->events);
STACK_DEL(emitter, emitter->indents);
while (!STACK_EMPTY(empty, emitter->tag_directives)) {
yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
yaml_free(tag_directive.handle);
yaml_free(tag_directive.prefix);
}
STACK_DEL(emitter, emitter->tag_directives);
yaml_free(emitter->anchors);
memset(emitter, 0, sizeof(yaml_emitter_t));
}
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);
while (!QUEUE_EMPTY(parser, parser->tokens)) {
yaml_token_delete(&DEQUEUE(parser, parser->tokens));
}
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);
while (!STACK_EMPTY(parser, parser->tag_directives)) {
yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
yaml_free(tag_directive.handle);
yaml_free(tag_directive.prefix);
}
STACK_DEL(parser, parser->tag_directives);
memset(parser, 0, sizeof(yaml_parser_t));
}
yaml_parser_initialize(yaml_parser_t *parser)
{
assert(parser); /* Non-NULL parser object expected. */
memset(parser, 0, sizeof(yaml_parser_t));
if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
goto error;
if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
goto error;
if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
goto error;
if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
goto error;
if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
goto error;
if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
goto error;
if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
goto error;
if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
goto error;
return 1;
error:
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;
}
yaml_document_add_mapping(yaml_document_t *document,
yaml_char_t *tag, yaml_mapping_style_t style)
{
struct {
yaml_error_type_t error;
} context;
yaml_mark_t mark = { 0, 0, 0 };
yaml_char_t *tag_copy = NULL;
struct {
yaml_node_pair_t *start;
yaml_node_pair_t *end;
yaml_node_pair_t *top;
} pairs = { NULL, NULL, NULL };
yaml_node_t node;
assert(document); /* Non-NULL document object is expected. */
if (!tag) {
tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
}
if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
tag_copy = yaml_strdup(tag);
if (!tag_copy) goto error;
if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;
MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
style, mark, mark);
if (!PUSH(&context, document->nodes, node)) goto error;
return document->nodes.top - document->nodes.start;
error:
STACK_DEL(&context, pairs);
yaml_free(tag_copy);
return 0;
}
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)
{
struct {
yaml_error_type_t error;
} context;
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 };
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;
}
if (tag_directives_start != tag_directives_end) {
yaml_tag_directive_t *tag_directive;
if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
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)))
goto error;
if (!yaml_check_utf8(tag_directive->prefix,
strlen((char *)tag_directive->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))
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);
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);
yaml_free(value.handle);
yaml_free(value.prefix);
}
STACK_DEL(context, tag_directives_copy);
yaml_free(value.handle);
yaml_free(value.prefix);
return 0;
}
static int
yaml_parser_process_directives(yaml_parser_t *parser,
yaml_version_directive_t **version_directive_ref,
yaml_tag_directive_t **tag_directives_start_ref,
yaml_tag_directive_t **tag_directives_end_ref)
{
yaml_tag_directive_t default_tag_directives[] = {
{(yaml_char_t *)"!", (yaml_char_t *)"!"},
{(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
{NULL, NULL}
};
yaml_tag_directive_t *default_tag_directive;
yaml_version_directive_t *version_directive = NULL;
struct {
yaml_tag_directive_t *start;
yaml_tag_directive_t *end;
yaml_tag_directive_t *top;
} tag_directives = { NULL, NULL, NULL };
yaml_token_t *token;
if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))
goto error;
token = PEEK_TOKEN(parser);
if (!token) goto error;
while (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
token->type == YAML_TAG_DIRECTIVE_TOKEN)
{
if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) {
if (version_directive) {
yaml_parser_set_parser_error(parser,
"found duplicate %YAML directive", token->start_mark);
goto error;
}
if (token->data.version_directive.major != 1
|| token->data.version_directive.minor != 1) {
yaml_parser_set_parser_error(parser,
"found incompatible YAML document", token->start_mark);
goto error;
}
version_directive = yaml_malloc(sizeof(yaml_version_directive_t));
if (!version_directive) {
parser->error = YAML_MEMORY_ERROR;
goto error;
}
version_directive->major = token->data.version_directive.major;
version_directive->minor = token->data.version_directive.minor;
}
else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
yaml_tag_directive_t value;
value.handle = token->data.tag_directive.handle;
value.prefix = token->data.tag_directive.prefix;
if (!yaml_parser_append_tag_directive(parser, value, 0,
token->start_mark))
goto error;
if (!PUSH(parser, tag_directives, value))
goto error;
}
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser);
if (!token) goto error;
}
for (default_tag_directive = default_tag_directives;
default_tag_directive->handle; default_tag_directive++) {
if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1,
token->start_mark))
goto error;
}
if (version_directive_ref) {
*version_directive_ref = version_directive;
}
if (tag_directives_start_ref) {
if (STACK_EMPTY(parser, tag_directives)) {
*tag_directives_start_ref = *tag_directives_end_ref = NULL;
STACK_DEL(parser, tag_directives);
}
else {
*tag_directives_start_ref = tag_directives.start;
*tag_directives_end_ref = tag_directives.top;
}
}
else {
STACK_DEL(parser, tag_directives);
}
return 1;
error:
yaml_free(version_directive);
while (!STACK_EMPTY(parser, tag_directives)) {
yaml_tag_directive_t tag_directive = POP(parser, tag_directives);
yaml_free(tag_directive.handle);
yaml_free(tag_directive.prefix);
}
STACK_DEL(parser, tag_directives);
return 0;
}
