static int
_ympars_parsedocend(ym_pars_t *parser, ym_event_t *event)
{
ym_token_t *token;
ym_mark_t soevent, eoevent;
int implicit = 1;
token = PEEK_TOKEN(parser);
if (!token) return 0;
soevent = eoevent = token->soevent;
if (token->type == YAML_DOCUMENT_END_TOKEN) {
eoevent = token->eoevent;
SKIP_TOKEN(parser);
implicit = 0;
}
while (!STACK_EMPTY(parser, parser->tag_directives)) {
ym_ytag_t ytag = POP(parser, parser->tag_directives);
ym_free(ytag.handle);
ym_free(ytag.prefix);
}
parser->state = YAML_PARSE_DOCUMENT_START_STATE;
DOCUMENT_END_EVENT_INIT(*event, implicit, soevent, eoevent);
return 1;
}
static int
yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event)
{
yaml_token_t *token;
yaml_mark_t start_mark, end_mark;
int implicit = 1;
token = PEEK_TOKEN(parser);
if (!token) return 0;
start_mark = end_mark = token->start_mark;
if (token->type == YAML_DOCUMENT_END_TOKEN) {
end_mark = token->end_mark;
SKIP_TOKEN(parser);
implicit = 0;
}
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);
}
parser->state = YAML_PARSE_DOCUMENT_START_STATE;
DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark);
return 1;
}
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_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;
}
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_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;
}
/* Returns the index of the first unmatched character, or -1 if the match
* failed
*/
int run (Instruction *prog, const char *target)
{
unsigned int pc = 0;
unsigned int pos = 0;
void *capture = NULL;
size_t target_len = strlen(target);
Instruction *instr;
for (;;) {
if (pc == FAIL) {
/* Machine is in fail state */
if (STACK_EMPTY()) {
/* No further options */
return -1;
}
if (STACK_TOPTYPE() == BacktrackData) {
/* Backtrack to stacked alternative */
pc = STACK_TOP().alternative;
pos = STACK_TOP().pos;
capture = STACK_TOP().capture_info;
}
/* Pop one stack entry */
STACK_POP();
continue;
}
instr = &prog[pc];
#if 0
printf("pc = %d, pos = %d, instr = %s\n", pc, pos,
instruction_names[instr->instr]);
#endif
switch (instr->instr) {
case iEnd:
return pos;
case iChar:
if (target[pos] == instr->character) {
pos += 1;
pc += 1;
} else {
pc = FAIL;
}
break;
case iJump:
pc += instr->offset;
break;
case iChoice:
STACK_PUSHALT(pc + instr->offset, pos - instr->count, capture);
pc += 1;
break;
case iCall:
STACK_PUSHRET(pc + 1);
pc += instr->offset;
break;
case iReturn:
pc = STACK_TOP().ret;
STACK_POP();
break;
case iCommit:
STACK_POP();
pc += instr->offset;
break;
case iCapture:
/* TODO: Add capture info */
pc += 1;
break;
case iFail:
pc = FAIL;
break;
case iAny:
if (pos + instr->count <= target_len) {
pc += 1;
pos += instr->count;
} else {
pc = FAIL;
}
break;
case iCharset:
if (IN_CHARSET(instr->cset, target[pos])) {
pc += 1;
pos += 1;
} else {
pc = FAIL;
}
break;
case iPartialCommit:
if (STACK_TOPTYPE() == BacktrackData) {
/* Replace the backtrack data on the top of the stack */
STACK_TOP().pos = pos;
STACK_TOP().capture_info = capture;
} else {
/* Cannot happen */
assert(0);
}
pc += instr->offset;
break;
case iSpan:
if (IN_CHARSET(instr->cset, target[pos]))
pos += 1;
else
pc += 1;
break;
case iFailTwice:
STACK_POP();
pc = FAIL;
break;
case iBackCommit:
if (STACK_TOPTYPE() == BacktrackData) {
/* Pop the position and capture info, but jump */
pos = STACK_TOP().pos;
capture = STACK_TOP().capture_info;
STACK_POP();
} else {
/* Cannot happen */
assert(0);
}
pc += instr->offset;
break;
case iTestChar:
if (target[pos] == instr->character) {
pos += 1;
pc += 1;
} else {
pc += instr->offset;
}
break;
case iTestCharset:
if (IN_CHARSET(instr->cset, target[pos])) {
pos += 1;
pc += 1;
} else {
pc += instr->offset;
}
break;
case iTestAny:
if (pos + instr->count <= target_len) {
pos += instr->count;
pc += 1;
} else {
pc += instr->offset;
}
break;
default:
/* Cannot happen - skip the instruction */
pc += 1;
break;
}
}
/* We never actually reach here - we exit at the End instruction */
return pos;
}
