#include "yaml_private.h"
-/*
- * Event initializers.
- */
-
-#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark) \
- (memset(&(event), 0, sizeof(yaml_event_t)), \
- (event).type = (event_type), \
- (event).start_mark = (event_start_mark), \
- (event).end_mark = (event_end_mark))
-
-#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark) \
- (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \
- (event).data.stream_start.encoding = (event_encoding))
-
-#define STREAM_END_EVENT_INIT(event,start_mark,end_mark) \
- (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_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))
-
-#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark) \
- (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \
- (event).data.document_end.implicit = (event_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) \
- (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.style = (event_style))
-
-#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \
- event_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.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_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.style = (event_style))
-
-#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \
- (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark)))
-
/*
* Peek the next token in the token queue.
*/
assert(parser); /* Non-NULL parser object is expected. */
assert(event); /* Non-NULL event object is expected. */
+ /* Erase the event object. */
+
+ memset(event, 0, sizeof(yaml_event_t));
+
/* No events after the end of the stream or error. */
if (parser->stream_end_produced || parser->error ||
parser->state == YAML_PARSE_END_STATE) {
- memset(event, 0, sizeof(yaml_event_t));
-
return 1;
}
default:
assert(1); /* Invalid state. */
}
+
+ return 0;
}
/*
if (token->type != YAML_STREAM_START_TOKEN) {
return yaml_parser_set_parser_error(parser,
- "did not found expected <stream-start>", token->start_mark);
+ "did not find expected <stream-start>", token->start_mark);
}
parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
token = PEEK_TOKEN(parser);
if (!token) return 0;
+ /* Parse extra document end indicators. */
+
+ if (!implicit)
+ {
+ while (token->type == YAML_DOCUMENT_END_TOKEN) {
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ }
+ }
+
/* Parse an implicit document. */
if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&
if (!token) goto error;
if (token->type != YAML_DOCUMENT_START_TOKEN) {
yaml_parser_set_parser_error(parser,
- "did not found expected <document start>", token->start_mark);
+ "did not find expected <document start>", token->start_mark);
goto error;
}
if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
start_mark = end_mark = token->start_mark;
- while (token->type == YAML_DOCUMENT_END_TOKEN) {
+ if (token->type == YAML_DOCUMENT_END_TOKEN) {
end_mark = token->end_mark;
SKIP_TOKEN(parser);
- token = PEEK_TOKEN(parser);
- if (!token) return 0;
implicit = 0;
}
yaml_parser_set_parser_error_context(parser,
(block ? "while parsing a block node"
: "while parsing a flow node"), start_mark,
- "did not found expected node content", token->start_mark);
+ "did not find expected node content", token->start_mark);
goto error;
}
}
else if (token->type == YAML_BLOCK_END_TOKEN)
{
+ yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
parser->state = POP(parser, parser->states);
- POP(parser, parser->marks);
+ dummy_mark = POP(parser, parser->marks);
SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
{
return yaml_parser_set_parser_error_context(parser,
"while parsing a block collection", POP(parser, parser->marks),
- "did not found expected '-' indicator", token->start_mark);
+ "did not find expected '-' indicator", token->start_mark);
}
}
else if (token->type == YAML_BLOCK_END_TOKEN)
{
+ yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
parser->state = POP(parser, parser->states);
- POP(parser, parser->marks);
+ dummy_mark = POP(parser, parser->marks);
MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
{
return yaml_parser_set_parser_error_context(parser,
"while parsing a block mapping", POP(parser, parser->marks),
- "did not found expected key", token->start_mark);
+ "did not find expected key", token->start_mark);
}
}
yaml_event_t *event, int first)
{
yaml_token_t *token;
+ yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
if (first) {
token = PEEK_TOKEN(parser);
else {
return yaml_parser_set_parser_error_context(parser,
"while parsing a flow sequence", POP(parser, parser->marks),
- "did not found expected ',' or ']'", token->start_mark);
+ "did not find expected ',' or ']'", token->start_mark);
}
}
}
parser->state = POP(parser, parser->states);
- POP(parser, parser->marks);
+ dummy_mark = POP(parser, parser->marks);
SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
yaml_event_t *event, int first)
{
yaml_token_t *token;
+ yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
if (first) {
token = PEEK_TOKEN(parser);
else {
return yaml_parser_set_parser_error_context(parser,
"while parsing a flow mapping", POP(parser, parser->marks),
- "did not found expected ',' or '}'", token->start_mark);
+ "did not find expected ',' or '}'", token->start_mark);
}
}
}
parser->state = POP(parser, parser->states);
- POP(parser, parser->marks);
+ dummy_mark = POP(parser, parser->marks);
MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
SKIP_TOKEN(parser);
return 1;
goto error;
}
if (token->data.version_directive.major != 1
- && token->data.version_directive.minor != 1) {
+ || token->data.version_directive.minor != 1) {
yaml_parser_set_parser_error(parser,
"found incompatible YAML document", token->start_mark);
goto error;
}
else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
- yaml_tag_directive_t value = {
- token->data.tag_directive.handle,
- token->data.tag_directive.prefix
- };
+ 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;
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,
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.end;
+ *tag_directives_end_ref = tag_directives.top;
}
}
+ else {
+ STACK_DEL(parser, tag_directives);
+ }
return 1;
return 0;
}
+/*
+ * Append a tag directive to the directives stack.
+ */
+
static int
yaml_parser_append_tag_directive(yaml_parser_t *parser,
yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
{
yaml_tag_directive_t *tag_directive;
yaml_tag_directive_t copy = { NULL, NULL };
- int length;
for (tag_directive = parser->tag_directives.start;
tag_directive != parser->tag_directives.top; tag_directive ++) {
}
}
- copy.handle = (yaml_char_t *)yaml_strdup((char *)value.handle);
- copy.prefix = (yaml_char_t *)yaml_strdup((char *)value.prefix);
+ copy.handle = yaml_strdup(value.handle);
+ copy.prefix = yaml_strdup(value.prefix);
if (!copy.handle || !copy.prefix) {
parser->error = YAML_MEMORY_ERROR;
goto error;