* BLOCK-END # Indentation decrease.
* FLOW-SEQUENCE-START # '['
* FLOW-SEQUENCE-END # ']'
- * BLOCK-SEQUENCE-START # '{'
- * BLOCK-SEQUENCE-END # '}'
+ * FLOW-MAPPING-START # '{'
+ * FLOW-MAPPING-END # '}'
* BLOCK-ENTRY # '-'
* FLOW-ENTRY # ','
* KEY # '?' or nothing (simple keys).
* %TAG !yaml! tag:yaml.org,2002:
* ---
*
- * The correspoding sequence of tokens:
+ * The corresponding sequence of tokens:
*
* STREAM-START(utf-8)
* VERSION-DIRECTIVE(1,1)
}
/* Fetch the next token from the queue. */
-
+
*token = DEQUEUE(parser, parser->tokens);
parser->token_available = 0;
parser->tokens_parsed ++;
yaml_simple_key_t simple_key;
simple_key.possible = 1;
simple_key.required = required;
- simple_key.token_number =
+ simple_key.token_number =
parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head);
simple_key.mark = parser->mark;
static int
yaml_parser_decrease_flow_level(yaml_parser_t *parser)
{
- yaml_simple_key_t dummy_key; /* Used to eliminate a compiler warning. */
-
if (parser->flow_level) {
parser->flow_level --;
- dummy_key = POP(parser, parser->simple_keys);
+ (void)POP(parser, parser->simple_keys);
}
return 1;
* Push the current indentation level to the stack and set the new level
* the current column is greater than the indentation level. In this case,
* append or insert the specified token into the token queue.
- *
+ *
*/
static int
/*
* Pop indentation levels from the indents stack until the current level
- * becomes less or equal to the column. For each intendation level, append
+ * becomes less or equal to the column. For each indentation level, append
* the BLOCK-END token.
*/
if (parser->flow_level)
return 1;
- /* Loop through the intendation levels in the stack. */
+ /* Loop through the indentation levels in the stack. */
while (parser->indent > column)
{
*
* - in the flow context;
* - in the block context, but not at the beginning of the line or
- * after '-', '?', or ':' (complex value).
+ * after '-', '?', or ':' (complex value).
*/
if (!CACHE(parser, 1)) return 0;
else
{
yaml_parser_set_scanner_error(parser, "while scanning a directive",
- start_mark, "found uknown directive name");
+ start_mark, "found unknown directive name");
goto error;
}
{
/* Set the handle to '' */
- handle = yaml_malloc(1);
+ handle = YAML_MALLOC(1);
if (!handle) goto error;
handle[0] = '\0';
/* Set the handle to '!'. */
yaml_free(handle);
- handle = yaml_malloc(2);
+ handle = YAML_MALLOC(2);
if (!handle) goto error;
handle[0] = '!';
handle[1] = '\0';
if (IS_DIGIT(parser->buffer))
{
- /* Check that the intendation is greater than 0. */
+ /* Check that the indentation is greater than 0. */
if (CHECK(parser->buffer, '0')) {
yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found an intendation indicator equal to 0");
+ start_mark, "found an indentation indicator equal to 0");
goto error;
}
- /* Get the intendation level and eat the indicator. */
+ /* Get the indentation level and eat the indicator. */
increment = AS_DIGIT(parser->buffer);
{
if (CHECK(parser->buffer, '0')) {
yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found an intendation indicator equal to 0");
+ start_mark, "found an indentation indicator equal to 0");
goto error;
}
end_mark = parser->mark;
- /* Set the intendation level if it was specified. */
+ /* Set the indentation level if it was specified. */
if (increment) {
indent = parser->indent >= 0 ? parser->indent+increment : increment;
if (!READ_LINE(parser, leading_break)) goto error;
- /* Eat the following intendation spaces and line breaks. */
+ /* Eat the following indentation spaces and line breaks. */
if (!yaml_parser_scan_block_scalar_breaks(parser,
&indent, &trailing_breaks, start_mark, &end_mark)) goto error;
}
/*
- * Scan intendation spaces and line breaks for a block scalar. Determine the
- * intendation level if needed.
+ * Scan indentation spaces and line breaks for a block scalar. Determine the
+ * indentation level if needed.
*/
static int
*end_mark = parser->mark;
- /* Eat the intendation spaces and line breaks. */
+ /* Eat the indentation spaces and line breaks. */
while (1)
{
- /* Eat the intendation spaces. */
+ /* Eat the indentation spaces. */
if (!CACHE(parser, 1)) return 0;
if ((int)parser->mark.column > max_indent)
max_indent = (int)parser->mark.column;
- /* Check for a tab character messing the intendation. */
+ /* Check for a tab character messing the indentation. */
if ((!*indent || (int)parser->mark.column < *indent)
&& IS_TAB(parser->buffer)) {
return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found a tab character where an intendation space is expected");
+ start_mark, "found a tab character where an indentation space is expected");
}
/* Have we found a non-empty line? */
*indent = 1;
}
- return 1;
+ return 1;
}
/*
*(string.pointer++) = '/';
break;
- case '\'':
- *(string.pointer++) = '\'';
- break;
-
case '\\':
*(string.pointer++) = '\\';
break;
/* Check if we are at the end of the scalar. */
+ /* Fix for crash unitialized value crash
+ * Credit for the bug and input is to OSS Fuzz
+ * Credit for the fix to Alex Gaynor
+ */
+ if (!CACHE(parser, 1)) goto error;
if (CHECK(parser->buffer, single ? '\'' : '"'))
break;
{
if (IS_BLANK(parser->buffer))
{
- /* Check for tab character that abuse intendation. */
+ /* Check for tab character that abuse indentation. */
if (leading_blanks && (int)parser->mark.column < indent
&& IS_TAB(parser->buffer)) {
yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
- start_mark, "found a tab character that violate intendation");
+ start_mark, "found a tab character that violate indentation");
goto error;
}
if (!CACHE(parser, 1)) goto error;
}
- /* Check intendation level. */
+ /* Check indentation level. */
if (!parser->flow_level && (int)parser->mark.column < indent)
break;
return 0;
}
-