static yaml_char_t *
yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id)
{
yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);
if (!anchor) return NULL;
sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id);
return anchor;
}
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_scalar_style_t style)
{
yaml_mark_t mark = { 0, 0, 0 };
yaml_char_t *anchor_copy = NULL;
yaml_char_t *tag_copy = NULL;
yaml_char_t *value_copy = NULL;
assert(event); /* Non-NULL event object is expected. */
/* following line added for Haskell yaml library */
if (!value && !length) value = "";
assert(value); /* Non-NULL anchor is expected. */
if (anchor) {
if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
anchor_copy = yaml_strdup(anchor);
if (!anchor_copy) goto error;
}
if (tag) {
if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
tag_copy = yaml_strdup(tag);
if (!tag_copy) goto error;
}
if (length < 0) {
length = strlen((char *)value);
}
if (!yaml_check_utf8(value, length)) goto error;
value_copy = yaml_malloc(length+1);
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);
return 1;
error:
yaml_free(anchor_copy);
yaml_free(tag_copy);
yaml_free(value_copy);
return 0;
}
yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
{
yaml_event_t event;
yaml_mark_t mark = { 0, 0, 0 };
assert(emitter); /* Non-NULL emitter object is required. */
assert(document); /* Non-NULL emitter object is expected. */
emitter->document = document;
if (!emitter->opened) {
if (!yaml_emitter_open(emitter)) goto error;
}
if (STACK_EMPTY(emitter, document->nodes)) {
if (!yaml_emitter_close(emitter)) goto error;
yaml_emitter_delete_document_and_anchors(emitter);
return 1;
}
assert(emitter->opened); /* Emitter should be opened. */
emitter->anchors = yaml_malloc(sizeof(*(emitter->anchors))
* (document->nodes.top - document->nodes.start));
if (!emitter->anchors) goto error;
memset(emitter->anchors, 0, sizeof(*(emitter->anchors))
* (document->nodes.top - document->nodes.start));
DOCUMENT_START_EVENT_INIT(event, document->version_directive,
document->tag_directives.start, document->tag_directives.end,
document->start_implicit, mark, mark);
if (!yaml_emitter_emit(emitter, &event)) goto error;
yaml_emitter_anchor_node(emitter, 1);
if (!yaml_emitter_dump_node(emitter, 1)) goto error;
DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark);
if (!yaml_emitter_emit(emitter, &event)) goto error;
yaml_emitter_delete_document_and_anchors(emitter);
return 1;
error:
yaml_emitter_delete_document_and_anchors(emitter);
return 0;
}
static int yaml_parser_process_empty_scalar (yaml_parser_t * parser, yaml_event_t * event, yaml_mark_t mark)
{
yaml_char_t *value;
value = yaml_malloc (1);
if (!value)
{
parser->error = YAML_MEMORY_ERROR;
return 0;
}
value[0] = '\0';
SCALAR_EVENT_INIT (*event, NULL, NULL, value, 0, 1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark);
return 1;
}
yaml_document_add_scalar(yaml_document_t *document,
yaml_char_t *tag, yaml_char_t *value, int length,
yaml_scalar_style_t style)
{
struct {
yaml_error_type_t error;
} context;
yaml_mark_t mark = { 0, 0, 0 };
yaml_char_t *tag_copy = NULL;
yaml_char_t *value_copy = NULL;
yaml_node_t node;
assert(document); /* Non-NULL document object is expected. */
assert(value); /* Non-NULL value is expected. */
if (!tag) {
tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;
}
if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
tag_copy = yaml_strdup(tag);
if (!tag_copy) goto error;
if (length < 0) {
length = strlen((char *)value);
}
if (!yaml_check_utf8(value, length)) goto error;
value_copy = yaml_malloc(length+1);
if (!value_copy) goto error;
memcpy(value_copy, value, length);
value_copy[length] = '\0';
SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);
if (!PUSH(&context, document->nodes, node)) goto error;
return document->nodes.top - document->nodes.start;
error:
yaml_free(tag_copy);
yaml_free(value_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_parse_node(yaml_parser_t *parser, yaml_event_t *event,
int block, int indentless_sequence)
{
yaml_token_t *token;
yaml_char_t *anchor = NULL;
yaml_char_t *tag_handle = NULL;
yaml_char_t *tag_suffix = NULL;
yaml_char_t *tag = NULL;
yaml_mark_t start_mark, end_mark, tag_mark;
int implicit;
token = PEEK_TOKEN(parser);
if (!token) return 0;
if (token->type == YAML_ALIAS_TOKEN)
{
parser->state = POP(parser, parser->states);
ALIAS_EVENT_INIT(*event, token->data.alias.value,
token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
}
else
{
start_mark = end_mark = tag_mark = token->start_mark;
if (token->type == YAML_ANCHOR_TOKEN)
{
anchor = token->data.anchor.value;
start_mark = token->start_mark;
end_mark = token->end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser);
if (!token) goto error;
if (token->type == YAML_TAG_TOKEN)
{
tag_handle = token->data.tag.handle;
tag_suffix = token->data.tag.suffix;
tag_mark = token->start_mark;
end_mark = token->end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser);
if (!token) goto error;
}
}
else if (token->type == YAML_TAG_TOKEN)
{
tag_handle = token->data.tag.handle;
tag_suffix = token->data.tag.suffix;
start_mark = tag_mark = token->start_mark;
end_mark = token->end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser);
if (!token) goto error;
if (token->type == YAML_ANCHOR_TOKEN)
{
anchor = token->data.anchor.value;
end_mark = token->end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser);
if (!token) goto error;
}
}
if (tag_handle) {
if (!*tag_handle) {
tag = tag_suffix;
yaml_free(tag_handle);
tag_handle = tag_suffix = NULL;
}
else {
yaml_tag_directive_t *tag_directive;
for (tag_directive = parser->tag_directives.start;
tag_directive != parser->tag_directives.top;
tag_directive ++) {
if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
size_t prefix_len = strlen((char *)tag_directive->prefix);
size_t suffix_len = strlen((char *)tag_suffix);
tag = yaml_malloc(prefix_len+suffix_len+1);
if (!tag) {
parser->error = YAML_MEMORY_ERROR;
goto error;
}
memcpy(tag, tag_directive->prefix, prefix_len);
memcpy(tag+prefix_len, tag_suffix, suffix_len);
tag[prefix_len+suffix_len] = '\0';
yaml_free(tag_handle);
yaml_free(tag_suffix);
tag_handle = tag_suffix = NULL;
break;
}
}
if (!tag) {
yaml_parser_set_parser_error_context(parser,
"while parsing a node", start_mark,
"found undefined tag handle", tag_mark);
goto error;
}
}
}
implicit = (!tag || !*tag);
if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) {
end_mark = token->end_mark;
parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
return 1;
}
else {
if (token->type == YAML_SCALAR_TOKEN) {
int plain_implicit = 0;
int quoted_implicit = 0;
end_mark = token->end_mark;
if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag)
|| (tag && strcmp((char *)tag, "!") == 0)) {
plain_implicit = 1;
}
else if (!tag) {
quoted_implicit = 1;
}
parser->state = POP(parser, parser->states);
SCALAR_EVENT_INIT(*event, anchor, tag,
token->data.scalar.value, token->data.scalar.length,
plain_implicit, quoted_implicit,
token->data.scalar.style, start_mark, end_mark);
SKIP_TOKEN(parser);
return 1;
}
else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) {
end_mark = token->end_mark;
parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark);
return 1;
}
else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) {
end_mark = token->end_mark;
parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
YAML_FLOW_MAPPING_STYLE, start_mark, end_mark);
return 1;
}
else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) {
end_mark = token->end_mark;
parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
return 1;
}
else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) {
end_mark = token->end_mark;
parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark);
return 1;
}
else if (anchor || tag) {
yaml_char_t *value = yaml_malloc(1);
if (!value) {
parser->error = YAML_MEMORY_ERROR;
goto error;
}
value[0] = '\0';
parser->state = POP(parser, parser->states);
SCALAR_EVENT_INIT(*event, anchor, tag, value, 0,
implicit, 0, YAML_PLAIN_SCALAR_STYLE,
start_mark, end_mark);
return 1;
}
else {
yaml_parser_set_parser_error_context(parser,
(block ? "while parsing a block node"
: "while parsing a flow node"), start_mark,
"did not find expected node content", token->start_mark);
goto error;
}
}
}
error:
yaml_free(anchor);
yaml_free(tag_handle);
yaml_free(tag_suffix);
yaml_free(tag);
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;
}
