Generate parser error messages (#4836)
Support parser error messages generation in tools/gen-strings.py. JerryScript-DCO-1.0-Signed-off-by: Csaba Repasi repasics@inf.u-szeged.hu
This commit is contained in:
Csaba Repasi
@@ -317,6 +317,7 @@ set(SOURCE_CORE_FILES
|
||||
parser/js/js-scanner-ops.c
|
||||
parser/js/js-scanner-util.c
|
||||
parser/js/js-scanner.c
|
||||
parser/js/parser-errors.c
|
||||
parser/regexp/re-bytecode.c
|
||||
parser/regexp/re-compiler.c
|
||||
parser/regexp/re-parser.c
|
||||
|
||||
@@ -25,6 +25,7 @@
|
||||
#include "js-parser-limits.h"
|
||||
#include "js-parser.h"
|
||||
#include "js-scanner.h"
|
||||
#include "parser-errors.h"
|
||||
|
||||
/** \addtogroup parser Parser
|
||||
* @{
|
||||
@@ -533,7 +534,7 @@ typedef struct parser_saved_context_t
|
||||
typedef struct
|
||||
{
|
||||
PARSER_TRY_CONTEXT (try_buffer); /**< try_buffer */
|
||||
parser_error_t error; /**< error code */
|
||||
parser_error_msg_t error; /**< error code */
|
||||
/** Union for rarely used members. */
|
||||
union
|
||||
{
|
||||
@@ -923,7 +924,7 @@ uint16_t parser_check_anonymous_function_declaration (parser_context_t *context_
|
||||
|
||||
/* Error management. */
|
||||
|
||||
void parser_raise_error (parser_context_t *context_p, parser_error_t error);
|
||||
void parser_raise_error (parser_context_t *context_p, parser_error_msg_t error);
|
||||
|
||||
/* Debug functions. */
|
||||
|
||||
|
||||
@@ -869,548 +869,6 @@ parser_reverse_class_fields (parser_context_t *context_p, /**< context */
|
||||
|
||||
#endif /* JERRY_ESNEXT */
|
||||
|
||||
#if JERRY_ERROR_MESSAGES
|
||||
/**
|
||||
* Returns with the string representation of the error
|
||||
*/
|
||||
const char *
|
||||
parser_error_to_string (parser_error_t error) /**< error code */
|
||||
{
|
||||
switch (error)
|
||||
{
|
||||
case PARSER_ERR_OUT_OF_MEMORY:
|
||||
{
|
||||
return "Out of memory";
|
||||
}
|
||||
case PARSER_ERR_LITERAL_LIMIT_REACHED:
|
||||
{
|
||||
return "Maximum number of literals reached";
|
||||
}
|
||||
case PARSER_ERR_SCOPE_STACK_LIMIT_REACHED:
|
||||
{
|
||||
return "Maximum depth of scope stack reached";
|
||||
}
|
||||
case PARSER_ERR_ARGUMENT_LIMIT_REACHED:
|
||||
{
|
||||
return "Maximum number of function arguments reached";
|
||||
}
|
||||
case PARSER_ERR_STACK_LIMIT_REACHED:
|
||||
{
|
||||
return "Maximum function stack size reached";
|
||||
}
|
||||
case PARSER_ERR_INVALID_CHARACTER:
|
||||
{
|
||||
return "Invalid (unexpected) character";
|
||||
}
|
||||
case PARSER_ERR_INVALID_OCTAL_DIGIT:
|
||||
{
|
||||
return "Invalid octal digit";
|
||||
}
|
||||
case PARSER_ERR_INVALID_HEX_DIGIT:
|
||||
{
|
||||
return "Invalid hexadecimal digit";
|
||||
}
|
||||
#if JERRY_ESNEXT
|
||||
case PARSER_ERR_INVALID_BIN_DIGIT:
|
||||
{
|
||||
return "Invalid binary digit";
|
||||
}
|
||||
#endif /* JERRY_ESNEXT */
|
||||
case PARSER_ERR_INVALID_ESCAPE_SEQUENCE:
|
||||
{
|
||||
return "Invalid escape sequence";
|
||||
}
|
||||
case PARSER_ERR_INVALID_UNICODE_ESCAPE_SEQUENCE:
|
||||
{
|
||||
return "Invalid unicode escape sequence";
|
||||
}
|
||||
case PARSER_ERR_INVALID_IDENTIFIER_START:
|
||||
{
|
||||
return "Character cannot be start of an identifier";
|
||||
}
|
||||
case PARSER_ERR_INVALID_IDENTIFIER_PART:
|
||||
{
|
||||
return "Character cannot be part of an identifier";
|
||||
}
|
||||
case PARSER_ERR_INVALID_KEYWORD:
|
||||
{
|
||||
return "Escape sequences are not allowed in keywords";
|
||||
}
|
||||
case PARSER_ERR_INVALID_NUMBER:
|
||||
{
|
||||
return "Invalid number";
|
||||
}
|
||||
case PARSER_ERR_MISSING_EXPONENT:
|
||||
{
|
||||
return "Missing exponent part";
|
||||
}
|
||||
case PARSER_ERR_INVALID_UNDERSCORE_IN_NUMBER:
|
||||
{
|
||||
return "Invalid use of underscore character in number literals";
|
||||
}
|
||||
case PARSER_ERR_IDENTIFIER_AFTER_NUMBER:
|
||||
{
|
||||
return "Identifier cannot start after a number";
|
||||
}
|
||||
#if JERRY_BUILTIN_BIGINT
|
||||
case PARSER_ERR_INVALID_BIGINT:
|
||||
{
|
||||
return "Number is not a valid BigInt";
|
||||
}
|
||||
#endif /* JERRY_BUILTIN_BIGINT */
|
||||
case PARSER_ERR_INVALID_REGEXP:
|
||||
{
|
||||
return "Invalid regular expression";
|
||||
}
|
||||
case PARSER_ERR_UNKNOWN_REGEXP_FLAG:
|
||||
{
|
||||
return "Unknown regexp flag";
|
||||
}
|
||||
case PARSER_ERR_DUPLICATED_REGEXP_FLAG:
|
||||
{
|
||||
return "Duplicated regexp flag";
|
||||
}
|
||||
case PARSER_ERR_UNSUPPORTED_REGEXP:
|
||||
{
|
||||
return "Regexp is not supported in the selected profile";
|
||||
}
|
||||
case PARSER_ERR_IDENTIFIER_TOO_LONG:
|
||||
{
|
||||
return "Identifier is too long";
|
||||
}
|
||||
case PARSER_ERR_STRING_TOO_LONG:
|
||||
{
|
||||
return "String is too long";
|
||||
}
|
||||
case PARSER_ERR_NUMBER_TOO_LONG:
|
||||
{
|
||||
return "Number is too long";
|
||||
}
|
||||
case PARSER_ERR_REGEXP_TOO_LONG:
|
||||
{
|
||||
return "Regexp is too long";
|
||||
}
|
||||
case PARSER_ERR_UNTERMINATED_MULTILINE_COMMENT:
|
||||
{
|
||||
return "Unterminated multiline comment";
|
||||
}
|
||||
case PARSER_ERR_UNTERMINATED_STRING:
|
||||
{
|
||||
return "Unterminated string literal";
|
||||
}
|
||||
case PARSER_ERR_UNTERMINATED_REGEXP:
|
||||
{
|
||||
return "Unterminated regexp literal";
|
||||
}
|
||||
case PARSER_ERR_NEWLINE_NOT_ALLOWED:
|
||||
{
|
||||
return "Newline is not allowed in strings or regexps";
|
||||
}
|
||||
case PARSER_ERR_OCTAL_NUMBER_NOT_ALLOWED:
|
||||
{
|
||||
return "Octal numbers are not allowed in strict mode";
|
||||
}
|
||||
case PARSER_ERR_OCTAL_ESCAPE_NOT_ALLOWED:
|
||||
{
|
||||
return "Octal escape sequences are not allowed in strict mode";
|
||||
}
|
||||
#if JERRY_ESNEXT
|
||||
case PARSER_ERR_TEMPLATE_STR_OCTAL_ESCAPE:
|
||||
{
|
||||
return "Octal escape sequences are not allowed in template strings";
|
||||
}
|
||||
#endif /* JERRY_ESNEXT */
|
||||
case PARSER_ERR_STRICT_IDENT_NOT_ALLOWED:
|
||||
{
|
||||
return "Identifier name is reserved in strict mode";
|
||||
}
|
||||
case PARSER_ERR_EVAL_NOT_ALLOWED:
|
||||
{
|
||||
return "Eval is not allowed to be used here in strict mode";
|
||||
}
|
||||
case PARSER_ERR_ARGUMENTS_NOT_ALLOWED:
|
||||
{
|
||||
return "Arguments is not allowed to be used here in strict mode";
|
||||
}
|
||||
#if JERRY_ESNEXT
|
||||
case PARSER_ERR_USE_STRICT_NOT_ALLOWED:
|
||||
{
|
||||
return "The 'use strict' directive is not allowed for functions with non-simple arguments";
|
||||
}
|
||||
case PARSER_ERR_YIELD_NOT_ALLOWED:
|
||||
{
|
||||
return "Yield expression is not allowed here";
|
||||
}
|
||||
case PARSER_ERR_AWAIT_NOT_ALLOWED:
|
||||
{
|
||||
return "Await expression is not allowed here";
|
||||
}
|
||||
case PARSER_ERR_FOR_IN_OF_DECLARATION:
|
||||
{
|
||||
return "for in-of loop variable declaration may not have an initializer";
|
||||
}
|
||||
case PARSER_ERR_FOR_AWAIT_NO_ASYNC:
|
||||
{
|
||||
return "for-await-of is only allowed inside async functions and generators";
|
||||
}
|
||||
case PARSER_ERR_FOR_AWAIT_NO_OF:
|
||||
{
|
||||
return "only 'of' form is allowed for for-await loops";
|
||||
}
|
||||
case PARSER_ERR_DUPLICATED_PROTO:
|
||||
{
|
||||
return "Duplicate __proto__ fields are not allowed in object literals";
|
||||
}
|
||||
case PARSER_ERR_INVALID_LHS_ASSIGNMENT:
|
||||
{
|
||||
return "Invalid left-hand side in assignment";
|
||||
}
|
||||
case PARSER_ERR_INVALID_LHS_POSTFIX_OP:
|
||||
{
|
||||
return "Invalid left-hand side expression in postfix operation";
|
||||
}
|
||||
case PARSER_ERR_INVALID_LHS_PREFIX_OP:
|
||||
{
|
||||
return "Invalid left-hand side expression in prefix operation";
|
||||
}
|
||||
case PARSER_ERR_INVALID_LHS_FOR_LOOP:
|
||||
{
|
||||
return "Invalid left-hand-side in for-loop";
|
||||
}
|
||||
#endif /* JERRY_ESNEXT */
|
||||
case PARSER_ERR_DELETE_IDENT_NOT_ALLOWED:
|
||||
{
|
||||
return "Deleting identifier is not allowed in strict mode";
|
||||
}
|
||||
case PARSER_ERR_EVAL_CANNOT_ASSIGNED:
|
||||
{
|
||||
return "Eval cannot be assigned to in strict mode";
|
||||
}
|
||||
case PARSER_ERR_ARGUMENTS_CANNOT_ASSIGNED:
|
||||
{
|
||||
return "Arguments cannot be assigned to in strict mode";
|
||||
}
|
||||
case PARSER_ERR_WITH_NOT_ALLOWED:
|
||||
{
|
||||
return "With statement not allowed in strict mode";
|
||||
}
|
||||
case PARSER_ERR_MULTIPLE_DEFAULTS_NOT_ALLOWED:
|
||||
{
|
||||
return "Multiple default cases are not allowed";
|
||||
}
|
||||
case PARSER_ERR_DEFAULT_NOT_IN_SWITCH:
|
||||
{
|
||||
return "Default statement must be in a switch block";
|
||||
}
|
||||
case PARSER_ERR_CASE_NOT_IN_SWITCH:
|
||||
{
|
||||
return "Case statement must be in a switch block";
|
||||
}
|
||||
case PARSER_ERR_LEFT_PAREN_EXPECTED:
|
||||
{
|
||||
return "Expected '(' token";
|
||||
}
|
||||
case PARSER_ERR_LEFT_BRACE_EXPECTED:
|
||||
{
|
||||
return "Expected '{' token";
|
||||
}
|
||||
case PARSER_ERR_RIGHT_PAREN_EXPECTED:
|
||||
{
|
||||
return "Expected ')' token";
|
||||
}
|
||||
case PARSER_ERR_RIGHT_SQUARE_EXPECTED:
|
||||
{
|
||||
return "Expected ']' token";
|
||||
}
|
||||
case PARSER_ERR_COLON_EXPECTED:
|
||||
{
|
||||
return "Expected ':' token";
|
||||
}
|
||||
case PARSER_ERR_COLON_FOR_CONDITIONAL_EXPECTED:
|
||||
{
|
||||
return "Expected ':' token for ?: conditional expression";
|
||||
}
|
||||
case PARSER_ERR_SEMICOLON_EXPECTED:
|
||||
{
|
||||
return "Expected ';' token";
|
||||
}
|
||||
case PARSER_ERR_IN_EXPECTED:
|
||||
{
|
||||
return "Expected 'in' token";
|
||||
}
|
||||
case PARSER_ERR_WHILE_EXPECTED:
|
||||
{
|
||||
return "While expected for do-while loop";
|
||||
}
|
||||
case PARSER_ERR_CATCH_FINALLY_EXPECTED:
|
||||
{
|
||||
return "Catch or finally block expected";
|
||||
}
|
||||
case PARSER_ERR_ARRAY_ITEM_SEPARATOR_EXPECTED:
|
||||
{
|
||||
return "Expected ',' or ']' after an array item";
|
||||
}
|
||||
case PARSER_ERR_OBJECT_ITEM_SEPARATOR_EXPECTED:
|
||||
{
|
||||
return "Expected ',' or '}' after a property definition";
|
||||
}
|
||||
case PARSER_ERR_IDENTIFIER_EXPECTED:
|
||||
{
|
||||
return "Identifier expected";
|
||||
}
|
||||
case PARSER_ERR_EXPRESSION_EXPECTED:
|
||||
{
|
||||
return "Expression expected";
|
||||
}
|
||||
case PARSER_ERR_UNEXPECTED_END:
|
||||
{
|
||||
return "Unexpected end of input";
|
||||
}
|
||||
case PARSER_ERR_LEFT_HAND_SIDE_EXP_EXPECTED:
|
||||
{
|
||||
return "Left-hand-side expression expected";
|
||||
}
|
||||
case PARSER_ERR_STATEMENT_EXPECTED:
|
||||
{
|
||||
return "Statement expected";
|
||||
}
|
||||
case PARSER_ERR_PROPERTY_IDENTIFIER_EXPECTED:
|
||||
{
|
||||
return "Property identifier expected";
|
||||
}
|
||||
case PARSER_ERR_ARGUMENT_LIST_EXPECTED:
|
||||
{
|
||||
return "Expected argument list";
|
||||
}
|
||||
case PARSER_ERR_NO_ARGUMENTS_EXPECTED:
|
||||
{
|
||||
return "Property getters must have no arguments";
|
||||
}
|
||||
case PARSER_ERR_ONE_ARGUMENT_EXPECTED:
|
||||
{
|
||||
return "Property setters must have one argument";
|
||||
}
|
||||
case PARSER_ERR_INVALID_EXPRESSION:
|
||||
{
|
||||
return "Invalid expression";
|
||||
}
|
||||
case PARSER_ERR_INVALID_SWITCH:
|
||||
{
|
||||
return "Invalid switch body";
|
||||
}
|
||||
case PARSER_ERR_INVALID_BREAK:
|
||||
{
|
||||
return "Break statement must be inside a loop or switch";
|
||||
}
|
||||
case PARSER_ERR_INVALID_BREAK_LABEL:
|
||||
{
|
||||
return "Labeled statement targeted by a break not found";
|
||||
}
|
||||
case PARSER_ERR_INVALID_CONTINUE:
|
||||
{
|
||||
return "Continue statement must be inside a loop";
|
||||
}
|
||||
case PARSER_ERR_INVALID_CONTINUE_LABEL:
|
||||
{
|
||||
return "Labeled statement targeted by a continue not found";
|
||||
}
|
||||
case PARSER_ERR_INVALID_RETURN:
|
||||
{
|
||||
return "Return statement must be inside a function body";
|
||||
}
|
||||
case PARSER_ERR_INVALID_RIGHT_SQUARE:
|
||||
{
|
||||
return "Unexpected '}' token";
|
||||
}
|
||||
case PARSER_ERR_DUPLICATED_LABEL:
|
||||
{
|
||||
return "Duplicated label";
|
||||
}
|
||||
case PARSER_ERR_OBJECT_PROPERTY_REDEFINED:
|
||||
{
|
||||
return "Property of object literal redefined";
|
||||
}
|
||||
case PARSER_ERR_NON_STRICT_ARG_DEFINITION:
|
||||
{
|
||||
return "Non-strict argument definition";
|
||||
}
|
||||
#if JERRY_ESNEXT
|
||||
case PARSER_ERR_VARIABLE_REDECLARED:
|
||||
{
|
||||
return (const char *) ecma_get_error_utf8 (ECMA_ERR_LOCAL_VARIABLE_IS_REDECLARED);
|
||||
}
|
||||
case PARSER_ERR_LEXICAL_SINGLE_STATEMENT:
|
||||
{
|
||||
return "Lexical declaration cannot appear in a single-statement context";
|
||||
}
|
||||
case PARSER_ERR_GENERATOR_IN_SINGLE_STATEMENT_POS:
|
||||
{
|
||||
return "Generator function cannot appear in a single-statement context";
|
||||
}
|
||||
case PARSER_ERR_LABELLED_FUNC_NOT_IN_BLOCK:
|
||||
{
|
||||
return "Labelled functions are only allowed inside blocks";
|
||||
}
|
||||
case PARSER_ERR_LEXICAL_LET_BINDING:
|
||||
{
|
||||
return "Let binding cannot appear in let/const declarations";
|
||||
}
|
||||
case PARSER_ERR_MISSING_ASSIGN_AFTER_CONST:
|
||||
{
|
||||
return "Value assignment is expected after a const declaration";
|
||||
}
|
||||
case PARSER_ERR_MULTIPLE_CLASS_CONSTRUCTORS:
|
||||
{
|
||||
return "Multiple constructors are not allowed";
|
||||
}
|
||||
case PARSER_ERR_CLASS_CONSTRUCTOR_AS_ACCESSOR:
|
||||
{
|
||||
return "Class constructor may not be an accessor";
|
||||
}
|
||||
case PARSER_ERR_INVALID_CLASS_CONSTRUCTOR:
|
||||
{
|
||||
return "Class constructor may not be a generator or async function";
|
||||
}
|
||||
case PARSER_ERR_CLASS_STATIC_PROTOTYPE:
|
||||
{
|
||||
return "Classes may not have a static property called 'prototype'";
|
||||
}
|
||||
case PARSER_ERR_UNEXPECTED_SUPER_KEYWORD:
|
||||
{
|
||||
return "Super is not allowed to be used here";
|
||||
}
|
||||
case PARSER_ERR_TOO_MANY_CLASS_FIELDS:
|
||||
{
|
||||
return "Too many computed class fields are declared";
|
||||
}
|
||||
case PARSER_ERR_ARGUMENTS_IN_CLASS_FIELD:
|
||||
{
|
||||
return "In class field declarations 'arguments' is not allowed";
|
||||
}
|
||||
case PARSER_ERR_RIGHT_BRACE_EXPECTED:
|
||||
{
|
||||
return "Expected '}' token";
|
||||
}
|
||||
case PARSER_ERR_OF_EXPECTED:
|
||||
{
|
||||
return "Expected 'of' token";
|
||||
}
|
||||
case PARSER_ERR_ASSIGNMENT_EXPECTED:
|
||||
{
|
||||
return "Unexpected arrow function or yield expression (parentheses around the expression may help)";
|
||||
}
|
||||
case PARSER_ERR_DUPLICATED_ARGUMENT_NAMES:
|
||||
{
|
||||
return "Duplicated function argument names are not allowed here";
|
||||
}
|
||||
case PARSER_ERR_INVALID_DESTRUCTURING_PATTERN:
|
||||
{
|
||||
return "Invalid destructuring assignment target";
|
||||
}
|
||||
case PARSER_ERR_ILLEGAL_PROPERTY_IN_DECLARATION:
|
||||
{
|
||||
return "Illegal property in declaration context";
|
||||
}
|
||||
case PARSER_ERR_INVALID_EXPONENTIATION:
|
||||
{
|
||||
return "Left operand of ** operator cannot be unary expression";
|
||||
}
|
||||
case PARSER_ERR_INVALID_NULLISH_COALESCING:
|
||||
{
|
||||
return "Cannot chain nullish with logical AND or OR";
|
||||
}
|
||||
case PARSER_ERR_FORMAL_PARAM_AFTER_REST_PARAMETER:
|
||||
{
|
||||
return "Rest parameter must be the last formal parameter";
|
||||
}
|
||||
case PARSER_ERR_SETTER_REST_PARAMETER:
|
||||
{
|
||||
return "Setter function argument must not be a rest parameter";
|
||||
}
|
||||
case PARSER_ERR_REST_PARAMETER_DEFAULT_INITIALIZER:
|
||||
{
|
||||
return "Rest parameter may not have a default initializer";
|
||||
}
|
||||
case PARSER_ERR_NEW_TARGET_EXPECTED:
|
||||
{
|
||||
return "Expected new.target expression";
|
||||
}
|
||||
case PARSER_ERR_NEW_TARGET_NOT_ALLOWED:
|
||||
{
|
||||
return "new.target expression is not allowed here";
|
||||
}
|
||||
#endif /* JERRY_ESNEXT */
|
||||
#if JERRY_MODULE_SYSTEM
|
||||
case PARSER_ERR_FILE_NOT_FOUND:
|
||||
{
|
||||
return "Requested module not found";
|
||||
}
|
||||
case PARSER_ERR_FROM_EXPECTED:
|
||||
{
|
||||
return "Expected 'from' token";
|
||||
}
|
||||
case PARSER_ERR_FROM_COMMA_EXPECTED:
|
||||
{
|
||||
return "Expected 'from' or ',' token";
|
||||
}
|
||||
case PARSER_ERR_AS_EXPECTED:
|
||||
{
|
||||
return "Expected 'as' token";
|
||||
}
|
||||
case PARSER_ERR_STRING_EXPECTED:
|
||||
{
|
||||
return "Expected a string literal";
|
||||
}
|
||||
case PARSER_ERR_MODULE_UNEXPECTED:
|
||||
{
|
||||
return "Unexpected import or export statement";
|
||||
}
|
||||
case PARSER_ERR_LEFT_BRACE_MULTIPLY_EXPECTED:
|
||||
{
|
||||
return "Expected '{' or '*' token";
|
||||
}
|
||||
case PARSER_ERR_LEFT_BRACE_MULTIPLY_LITERAL_EXPECTED:
|
||||
{
|
||||
return "Expected '{' or '*' or literal token";
|
||||
}
|
||||
case PARSER_ERR_RIGHT_BRACE_COMMA_EXPECTED:
|
||||
{
|
||||
return "Expected '}' or ',' token";
|
||||
}
|
||||
case PARSER_ERR_DUPLICATED_EXPORT_IDENTIFIER:
|
||||
{
|
||||
return "Duplicate exported identifier";
|
||||
}
|
||||
case PARSER_ERR_DUPLICATED_IMPORT_BINDING:
|
||||
{
|
||||
return "Duplicated imported binding name";
|
||||
}
|
||||
case PARSER_ERR_EXPORT_NOT_DEFINED:
|
||||
{
|
||||
return "Export not defined in module";
|
||||
}
|
||||
case PARSER_ERR_IMPORT_AFTER_NEW:
|
||||
{
|
||||
return "Module import call is not allowed after new";
|
||||
}
|
||||
case PARSER_ERR_META_EXPECTED:
|
||||
{
|
||||
return "Expected 'meta' keyword";
|
||||
}
|
||||
case PARSER_ERR_IMPORT_META_REQUIRE_MODULE:
|
||||
{
|
||||
return "Cannot use 'import.meta' outside a module";
|
||||
}
|
||||
#endif /* JERRY_MODULE_SYSTEM */
|
||||
default:
|
||||
{
|
||||
JERRY_ASSERT (error == PARSER_ERR_NO_ERROR);
|
||||
return "No error";
|
||||
}
|
||||
}
|
||||
} /* parser_error_to_string */
|
||||
#endif /* JERRY_ERROR_MESSAGES */
|
||||
|
||||
/**
|
||||
* @}
|
||||
* @}
|
||||
|
||||
@@ -1585,7 +1585,7 @@ parser_parse_function_arguments (parser_context_t *context_p, /**< context */
|
||||
{
|
||||
if (context_p->token.type != end_type)
|
||||
{
|
||||
parser_error_t error =
|
||||
parser_error_msg_t error =
|
||||
((end_type == LEXER_RIGHT_PAREN) ? PARSER_ERR_RIGHT_PAREN_EXPECTED : PARSER_ERR_IDENTIFIER_EXPECTED);
|
||||
|
||||
parser_raise_error (context_p, error);
|
||||
@@ -1729,7 +1729,7 @@ parser_parse_function_arguments (parser_context_t *context_p, /**< context */
|
||||
{
|
||||
if (context_p->token.type != end_type)
|
||||
{
|
||||
parser_error_t error =
|
||||
parser_error_msg_t error =
|
||||
((end_type == LEXER_RIGHT_PAREN) ? PARSER_ERR_RIGHT_PAREN_EXPECTED : PARSER_ERR_IDENTIFIER_EXPECTED);
|
||||
|
||||
parser_raise_error (context_p, error);
|
||||
@@ -2335,9 +2335,8 @@ parser_parse_source (void *source_p, /**< source code */
|
||||
}
|
||||
else
|
||||
{
|
||||
const lit_utf8_byte_t *err_bytes_p = (const lit_utf8_byte_t *) parser_error_to_string (context.error);
|
||||
lit_utf8_size_t err_bytes_size = lit_zt_utf8_string_size (err_bytes_p);
|
||||
err_str_p = ecma_new_ecma_string_from_utf8 (err_bytes_p, err_bytes_size);
|
||||
err_str_p =
|
||||
ecma_new_ecma_string_from_utf8 (parser_get_error_utf8 (context.error), parser_get_error_size (context.error));
|
||||
}
|
||||
ecma_value_t err_str_val = ecma_make_string_value (err_str_p);
|
||||
ecma_value_t line_str_val = ecma_make_uint32_value (context.token.line);
|
||||
@@ -3015,7 +3014,7 @@ parser_compiled_code_set_function_name (parser_context_t *context_p, /**< contex
|
||||
*/
|
||||
void
|
||||
parser_raise_error (parser_context_t *context_p, /**< context */
|
||||
parser_error_t error) /**< error code */
|
||||
parser_error_msg_t error) /**< error code */
|
||||
{
|
||||
/* Must be compatible with the scanner because
|
||||
* the lexer might throws errors during prescanning. */
|
||||
|
||||
@@ -28,175 +28,9 @@
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Error codes.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
PARSER_ERR_NO_ERROR, /**< no error */
|
||||
|
||||
PARSER_ERR_OUT_OF_MEMORY, /**< out of memory */
|
||||
PARSER_ERR_LITERAL_LIMIT_REACHED, /**< maximum number of literals reached */
|
||||
PARSER_ERR_SCOPE_STACK_LIMIT_REACHED, /**< maximum depth of scope stack reached */
|
||||
PARSER_ERR_ARGUMENT_LIMIT_REACHED, /**< maximum number of function arguments reached */
|
||||
PARSER_ERR_STACK_LIMIT_REACHED, /**< maximum function stack size reached */
|
||||
|
||||
PARSER_ERR_INVALID_CHARACTER, /**< unexpected character */
|
||||
PARSER_ERR_INVALID_OCTAL_DIGIT, /**< invalid octal digit */
|
||||
PARSER_ERR_INVALID_HEX_DIGIT, /**< invalid hexadecimal digit */
|
||||
#if JERRY_ESNEXT
|
||||
PARSER_ERR_INVALID_BIN_DIGIT, /**< invalid binary digit */
|
||||
#endif /* JERRY_ESNEXT */
|
||||
PARSER_ERR_INVALID_ESCAPE_SEQUENCE, /**< invalid escape sequence */
|
||||
PARSER_ERR_INVALID_UNICODE_ESCAPE_SEQUENCE, /**< invalid unicode escape sequence */
|
||||
PARSER_ERR_INVALID_IDENTIFIER_START, /**< character cannot be start of an identifier */
|
||||
PARSER_ERR_INVALID_IDENTIFIER_PART, /**< character cannot be part of an identifier */
|
||||
PARSER_ERR_INVALID_KEYWORD, /**< escape sequences are not allowed in keywords */
|
||||
|
||||
PARSER_ERR_INVALID_NUMBER, /**< invalid number literal */
|
||||
PARSER_ERR_MISSING_EXPONENT, /**< missing exponent */
|
||||
PARSER_ERR_IDENTIFIER_AFTER_NUMBER, /**< identifier start after number */
|
||||
PARSER_ERR_INVALID_UNDERSCORE_IN_NUMBER, /**< invalid use of underscore in number */
|
||||
#if JERRY_BUILTIN_BIGINT
|
||||
PARSER_ERR_INVALID_BIGINT, /**< number is not a valid BigInt */
|
||||
#endif /* JERRY_BUILTIN_BIGINT */
|
||||
|
||||
PARSER_ERR_INVALID_REGEXP, /**< invalid regular expression */
|
||||
PARSER_ERR_UNKNOWN_REGEXP_FLAG, /**< unknown regexp flag */
|
||||
PARSER_ERR_DUPLICATED_REGEXP_FLAG, /**< duplicated regexp flag */
|
||||
PARSER_ERR_UNSUPPORTED_REGEXP, /**< regular expression is not supported */
|
||||
|
||||
PARSER_ERR_IDENTIFIER_TOO_LONG, /**< too long identifier */
|
||||
PARSER_ERR_STRING_TOO_LONG, /**< too long string literal */
|
||||
PARSER_ERR_NUMBER_TOO_LONG, /**< too long number literal */
|
||||
PARSER_ERR_REGEXP_TOO_LONG, /**< too long regexp literal */
|
||||
|
||||
PARSER_ERR_UNTERMINATED_MULTILINE_COMMENT, /**< unterminated multiline comment */
|
||||
PARSER_ERR_UNTERMINATED_STRING, /**< unterminated string literal */
|
||||
PARSER_ERR_UNTERMINATED_REGEXP, /**< unterminated regexp literal */
|
||||
|
||||
PARSER_ERR_NEWLINE_NOT_ALLOWED, /**< newline is not allowed */
|
||||
PARSER_ERR_OCTAL_NUMBER_NOT_ALLOWED, /**< octal numbers are not allowed in strict mode */
|
||||
PARSER_ERR_OCTAL_ESCAPE_NOT_ALLOWED, /**< octal escape sequences are not allowed in strict mode */
|
||||
#if JERRY_ESNEXT
|
||||
PARSER_ERR_TEMPLATE_STR_OCTAL_ESCAPE, /**< octal escape sequences are not allowed in template strings */
|
||||
#endif /* JERRY_ESNEXT */
|
||||
PARSER_ERR_STRICT_IDENT_NOT_ALLOWED, /**< identifier name is reserved in strict mode */
|
||||
PARSER_ERR_EVAL_NOT_ALLOWED, /**< eval is not allowed here in strict mode */
|
||||
PARSER_ERR_ARGUMENTS_NOT_ALLOWED, /**< arguments is not allowed here in strict mode */
|
||||
#if JERRY_ESNEXT
|
||||
PARSER_ERR_USE_STRICT_NOT_ALLOWED, /**< use strict directive is not allowed */
|
||||
PARSER_ERR_YIELD_NOT_ALLOWED, /**< yield expression is not allowed */
|
||||
PARSER_ERR_AWAIT_NOT_ALLOWED, /**< await expression is not allowed */
|
||||
PARSER_ERR_FOR_IN_OF_DECLARATION, /**< variable declaration in for-in or for-of loop */
|
||||
PARSER_ERR_FOR_AWAIT_NO_ASYNC, /**< for-await-of is only allowed inside async functions */
|
||||
PARSER_ERR_FOR_AWAIT_NO_OF, /**< only 'of' form is allowed for for-await loops */
|
||||
PARSER_ERR_DUPLICATED_PROTO, /**< duplicated __proto__ fields are not allowed */
|
||||
PARSER_ERR_INVALID_LHS_ASSIGNMENT, /**< invalid LeftHandSide in assignment */
|
||||
PARSER_ERR_INVALID_LHS_POSTFIX_OP, /**< invalid LeftHandSide expression in postfix operation */
|
||||
PARSER_ERR_INVALID_LHS_PREFIX_OP, /**< invalid LeftHandSide expression in prefix operation */
|
||||
PARSER_ERR_INVALID_LHS_FOR_LOOP, /**< invalid LeftHandSide in for-loop */
|
||||
#endif /* JERRY_ESNEXT */
|
||||
PARSER_ERR_DELETE_IDENT_NOT_ALLOWED, /**< identifier delete is not allowed in strict mode */
|
||||
PARSER_ERR_EVAL_CANNOT_ASSIGNED, /**< eval cannot be assigned in strict mode */
|
||||
PARSER_ERR_ARGUMENTS_CANNOT_ASSIGNED, /**< arguments cannot be assigned in strict mode */
|
||||
PARSER_ERR_WITH_NOT_ALLOWED, /**< with statement is not allowed in strict mode */
|
||||
PARSER_ERR_MULTIPLE_DEFAULTS_NOT_ALLOWED, /**< multiple default cases are not allowed */
|
||||
PARSER_ERR_DEFAULT_NOT_IN_SWITCH, /**< default statement is not in switch block */
|
||||
PARSER_ERR_CASE_NOT_IN_SWITCH, /**< case statement is not in switch block */
|
||||
|
||||
PARSER_ERR_LEFT_PAREN_EXPECTED, /**< left paren expected */
|
||||
PARSER_ERR_LEFT_BRACE_EXPECTED, /**< left brace expected */
|
||||
PARSER_ERR_RIGHT_PAREN_EXPECTED, /**< right paren expected */
|
||||
PARSER_ERR_RIGHT_SQUARE_EXPECTED, /**< right square expected */
|
||||
|
||||
PARSER_ERR_UNEXPECTED_END, /**< unexpected end of input */
|
||||
PARSER_ERR_COLON_EXPECTED, /**< colon expected */
|
||||
PARSER_ERR_COLON_FOR_CONDITIONAL_EXPECTED, /**< colon expected for conditional expression */
|
||||
PARSER_ERR_SEMICOLON_EXPECTED, /**< semicolon expected */
|
||||
PARSER_ERR_IN_EXPECTED, /**< in keyword expected */
|
||||
PARSER_ERR_WHILE_EXPECTED, /**< while expected for do-while loop */
|
||||
PARSER_ERR_CATCH_FINALLY_EXPECTED, /**< catch or finally expected */
|
||||
PARSER_ERR_ARRAY_ITEM_SEPARATOR_EXPECTED, /**< array item separator expected */
|
||||
PARSER_ERR_OBJECT_ITEM_SEPARATOR_EXPECTED, /**< object item separator expected */
|
||||
PARSER_ERR_IDENTIFIER_EXPECTED, /**< identifier expected */
|
||||
PARSER_ERR_EXPRESSION_EXPECTED, /**< expression expected */
|
||||
PARSER_ERR_LEFT_HAND_SIDE_EXP_EXPECTED, /**< left-hand-side expression expected */
|
||||
PARSER_ERR_STATEMENT_EXPECTED, /**< statement expected */
|
||||
PARSER_ERR_PROPERTY_IDENTIFIER_EXPECTED, /**< property identifier expected */
|
||||
PARSER_ERR_ARGUMENT_LIST_EXPECTED, /**< argument list expected */
|
||||
PARSER_ERR_NO_ARGUMENTS_EXPECTED, /**< property getters must have no arguments */
|
||||
PARSER_ERR_ONE_ARGUMENT_EXPECTED, /**< property setters must have one argument */
|
||||
|
||||
PARSER_ERR_INVALID_EXPRESSION, /**< invalid expression */
|
||||
PARSER_ERR_INVALID_SWITCH, /**< invalid switch body */
|
||||
PARSER_ERR_INVALID_BREAK, /**< break must be inside a loop or switch */
|
||||
PARSER_ERR_INVALID_BREAK_LABEL, /**< break target not found */
|
||||
PARSER_ERR_INVALID_CONTINUE, /**< continue must be inside a loop */
|
||||
PARSER_ERR_INVALID_CONTINUE_LABEL, /**< continue target not found */
|
||||
PARSER_ERR_INVALID_RETURN, /**< return must be inside a function */
|
||||
PARSER_ERR_INVALID_RIGHT_SQUARE, /**< right square must terminate a block */
|
||||
PARSER_ERR_DUPLICATED_LABEL, /**< duplicated label */
|
||||
PARSER_ERR_OBJECT_PROPERTY_REDEFINED, /**< property of object literal redefined */
|
||||
#if JERRY_ESNEXT
|
||||
PARSER_ERR_VARIABLE_REDECLARED, /**< a variable redeclared */
|
||||
PARSER_ERR_LEXICAL_SINGLE_STATEMENT, /**< lexical declaration in single statement context */
|
||||
PARSER_ERR_GENERATOR_IN_SINGLE_STATEMENT_POS, /**< generator func not allowed in single statement position */
|
||||
PARSER_ERR_LABELLED_FUNC_NOT_IN_BLOCK, /**< labelled functions are only allowed inside blocks */
|
||||
PARSER_ERR_LEXICAL_LET_BINDING, /**< let binding cannot be declared in let/const */
|
||||
PARSER_ERR_MISSING_ASSIGN_AFTER_CONST, /**< an assignment is required after a const declaration */
|
||||
|
||||
PARSER_ERR_MULTIPLE_CLASS_CONSTRUCTORS, /**< multiple class constructor */
|
||||
PARSER_ERR_CLASS_CONSTRUCTOR_AS_ACCESSOR, /**< class constructor cannot be an accessor */
|
||||
PARSER_ERR_INVALID_CLASS_CONSTRUCTOR, /**< class constructor cannot be a generator or async function */
|
||||
PARSER_ERR_CLASS_STATIC_PROTOTYPE, /**< static method name 'prototype' is not allowed */
|
||||
PARSER_ERR_UNEXPECTED_SUPER_KEYWORD, /**< unexpected super keyword */
|
||||
PARSER_ERR_TOO_MANY_CLASS_FIELDS, /**< too many computed class fields */
|
||||
PARSER_ERR_ARGUMENTS_IN_CLASS_FIELD, /**< arguments is not allowed in class fields */
|
||||
|
||||
PARSER_ERR_RIGHT_BRACE_EXPECTED, /**< right brace expected */
|
||||
PARSER_ERR_OF_EXPECTED, /**< of keyword expected */
|
||||
|
||||
PARSER_ERR_ASSIGNMENT_EXPECTED, /**< assignment expression expected */
|
||||
PARSER_ERR_FORMAL_PARAM_AFTER_REST_PARAMETER, /**< formal parameter after rest parameter */
|
||||
PARSER_ERR_SETTER_REST_PARAMETER, /**< setter rest parameter */
|
||||
PARSER_ERR_REST_PARAMETER_DEFAULT_INITIALIZER, /**< rest parameter default initializer */
|
||||
PARSER_ERR_DUPLICATED_ARGUMENT_NAMES, /**< duplicated argument names */
|
||||
PARSER_ERR_INVALID_DESTRUCTURING_PATTERN, /**< invalid destructuring pattern */
|
||||
PARSER_ERR_ILLEGAL_PROPERTY_IN_DECLARATION, /**< illegal property in declaration context */
|
||||
PARSER_ERR_INVALID_EXPONENTIATION, /**< left operand of ** operator cannot be unary expression */
|
||||
PARSER_ERR_INVALID_NULLISH_COALESCING, /**< Cannot chain nullish with logical AND or OR. */
|
||||
PARSER_ERR_NEW_TARGET_EXPECTED, /**< expected new.target expression */
|
||||
PARSER_ERR_NEW_TARGET_NOT_ALLOWED, /**< new.target is not allowed in the given context */
|
||||
#endif /* JERRY_ESNEXT */
|
||||
#if JERRY_MODULE_SYSTEM
|
||||
PARSER_ERR_FILE_NOT_FOUND, /**< file not found*/
|
||||
PARSER_ERR_FROM_EXPECTED, /**< from expected */
|
||||
PARSER_ERR_FROM_COMMA_EXPECTED, /**< from or comma expected */
|
||||
PARSER_ERR_AS_EXPECTED, /**< as expected */
|
||||
PARSER_ERR_STRING_EXPECTED, /**< string literal expected */
|
||||
PARSER_ERR_MODULE_UNEXPECTED, /**< unexpected import or export statement */
|
||||
PARSER_ERR_LEFT_BRACE_MULTIPLY_LITERAL_EXPECTED, /**< left brace or multiply or literal expected */
|
||||
PARSER_ERR_LEFT_BRACE_MULTIPLY_EXPECTED, /**< left brace or multiply expected */
|
||||
PARSER_ERR_RIGHT_BRACE_COMMA_EXPECTED, /**< right brace or comma expected */
|
||||
PARSER_ERR_DUPLICATED_EXPORT_IDENTIFIER, /**< duplicated export identifier name */
|
||||
PARSER_ERR_DUPLICATED_IMPORT_BINDING, /**< duplicated import binding name */
|
||||
PARSER_ERR_EXPORT_NOT_DEFINED, /**< export is not defined in module */
|
||||
PARSER_ERR_IMPORT_AFTER_NEW, /**< module import call is not allowed after new */
|
||||
PARSER_ERR_META_EXPECTED, /**< meta keyword expected */
|
||||
PARSER_ERR_IMPORT_META_REQUIRE_MODULE, /**< cannot use 'import.meta' outside a module */
|
||||
#endif /* JERRY_MODULE_SYSTEM */
|
||||
|
||||
PARSER_ERR_NON_STRICT_ARG_DEFINITION /**< non-strict argument definition */
|
||||
} parser_error_t;
|
||||
|
||||
/* Note: source must be a valid UTF-8 string */
|
||||
ecma_compiled_code_t *parser_parse_script (void *source_p, uint32_t parse_opts, const jerry_parse_options_t *options_p);
|
||||
|
||||
#if JERRY_ERROR_MESSAGES
|
||||
const char *parser_error_to_string (parser_error_t);
|
||||
#endif /* JERRY_ERROR_MESSAGES */
|
||||
|
||||
/**
|
||||
* @}
|
||||
* @}
|
||||
|
||||
@@ -0,0 +1,297 @@
|
||||
/* Copyright JS Foundation and other contributors, http://js.foundation
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/* This file is automatically generated by the gen-strings.py script
|
||||
* from parser-error-messages.ini. Do not edit! */
|
||||
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_NO_ERROR, "No error")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_PARSER && !(JERRY_ESNEXT)
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_NUMBER, "Invalid number")
|
||||
#endif /* JERRY_PARSER && !(JERRY_ESNEXT) */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_DUPLICATED_LABEL, "Duplicated label")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LEFT_PAREN_EXPECTED, "Expected '(' token")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_RIGHT_PAREN_EXPECTED, "Expected ')' token")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_COLON_EXPECTED, "Expected ':' token")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_SEMICOLON_EXPECTED, "Expected ';' token")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_RIGHT_SQUARE_EXPECTED, "Expected ']' token")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LEFT_BRACE_EXPECTED, "Expected '{' token")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER || JERRY_MODULE_SYSTEM
|
||||
PARSER_ERROR_DEF (PARSER_ERR_RIGHT_BRACE_EXPECTED, "Expected '}' token")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER \
|
||||
|| JERRY_MODULE_SYSTEM */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_NUMBER_TOO_LONG, "Number is too long")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_BUILTIN_REGEXP && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_REGEXP_TOO_LONG, "Regexp is too long")
|
||||
#endif /* JERRY_BUILTIN_REGEXP && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_STATEMENT_EXPECTED, "Statement expected")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_STRING_TOO_LONG, "String is too long")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_AS_EXPECTED, "Expected 'as' token")
|
||||
#endif /* JERRY_MODULE_SYSTEM && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_IN_EXPECTED, "Expected 'in' token")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_OF_EXPECTED, "Expected 'of' token")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_EXPRESSION_EXPECTED, "Expression expected")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM || JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_IDENTIFIER_EXPECTED, "Identifier expected")
|
||||
#endif /* JERRY_MODULE_SYSTEM \
|
||||
|| JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_OCTAL_DIGIT, "Invalid octal digit")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_SWITCH, "Invalid switch body")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_BUILTIN_REGEXP && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_UNKNOWN_REGEXP_FLAG, "Unknown regexp flag")
|
||||
#endif /* JERRY_BUILTIN_REGEXP && JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_BIN_DIGIT, "Invalid binary digit")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_RIGHT_SQUARE, "Unexpected '}' token")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_FROM_EXPECTED, "Expected 'from' token")
|
||||
#endif /* JERRY_MODULE_SYSTEM && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_MISSING_EXPONENT, "Missing exponent part")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_BUILTIN_REGEXP && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_DUPLICATED_REGEXP_FLAG, "Duplicated regexp flag")
|
||||
#endif /* JERRY_BUILTIN_REGEXP && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ARGUMENT_LIST_EXPECTED, "Expected argument list")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_IDENTIFIER_TOO_LONG, "Identifier is too long")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_META_EXPECTED, "Expected 'meta' keyword")
|
||||
#endif /* JERRY_MODULE_SYSTEM && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_UNEXPECTED_END, "Unexpected end of input")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LEFT_BRACE_MULTIPLY_EXPECTED, "Expected '{' or '*' token")
|
||||
#endif /* JERRY_MODULE_SYSTEM && JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM
|
||||
PARSER_ERROR_DEF (PARSER_ERR_RIGHT_BRACE_COMMA_EXPECTED, "Expected '}' or ',' token")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_STRING_EXPECTED, "Expected a string literal")
|
||||
#endif /* JERRY_MODULE_SYSTEM */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_HEX_DIGIT, "Invalid hexadecimal digit")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_BUILTIN_REGEXP && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_UNTERMINATED_REGEXP, "Unterminated regexp literal")
|
||||
#endif /* JERRY_BUILTIN_REGEXP && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_UNTERMINATED_STRING, "Unterminated string literal")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_FROM_COMMA_EXPECTED, "Expected 'from' or ',' token")
|
||||
#endif /* JERRY_MODULE_SYSTEM && JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM
|
||||
PARSER_ERROR_DEF (PARSER_ERR_EXPORT_NOT_DEFINED, "Export not defined in module")
|
||||
#endif /* JERRY_MODULE_SYSTEM */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER || JERRY_MODULE_SYSTEM
|
||||
PARSER_ERROR_DEF (PARSER_ERR_VARIABLE_REDECLARED, "Local variable is redeclared")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER \
|
||||
|| JERRY_MODULE_SYSTEM */
|
||||
#if JERRY_BUILTIN_BIGINT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_BIGINT, "Number is not a valid BigInt")
|
||||
#endif /* JERRY_BUILTIN_BIGINT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_PROPERTY_IDENTIFIER_EXPECTED, "Property identifier expected")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM
|
||||
PARSER_ERROR_DEF (PARSER_ERR_DUPLICATED_EXPORT_IDENTIFIER, "Duplicate exported identifier")
|
||||
#endif /* JERRY_MODULE_SYSTEM */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_NEW_TARGET_EXPECTED, "Expected new.target expression")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_CHARACTER, "Invalid (unexpected) character")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_NON_STRICT_ARG_DEFINITION, "Non-strict argument definition")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_UNTERMINATED_MULTILINE_COMMENT, "Unterminated multiline comment")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_CATCH_FINALLY_EXPECTED, "Catch or finally block expected")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_UNICODE_ESCAPE_SEQUENCE, "Invalid unicode escape sequence")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM
|
||||
PARSER_ERROR_DEF (PARSER_ERR_DUPLICATED_IMPORT_BINDING, "Duplicated imported binding name")
|
||||
#endif /* JERRY_MODULE_SYSTEM */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_WHILE_EXPECTED, "While expected for do-while loop")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_LHS_FOR_LOOP, "Invalid left-hand-side in for-loop")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LEFT_HAND_SIDE_EXP_EXPECTED, "Left-hand-side expression expected")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LITERAL_LIMIT_REACHED, "Maximum number of literals reached")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_STACK_LIMIT_REACHED, "Maximum function stack size reached")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_AWAIT_NOT_ALLOWED, "Await expression is not allowed here")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LEFT_BRACE_MULTIPLY_LITERAL_EXPECTED, "Expected '{' or '*' or literal token")
|
||||
#endif /* JERRY_MODULE_SYSTEM && JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_LHS_ASSIGNMENT, "Invalid left-hand side in assignment")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_SCOPE_STACK_LIMIT_REACHED, "Maximum depth of scope stack reached")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if !JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_OBJECT_PROPERTY_REDEFINED, "Property of object literal redefined")
|
||||
#endif /* !JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_UNEXPECTED_SUPER_KEYWORD, "Super is not allowed to be used here")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_YIELD_NOT_ALLOWED, "Yield expression is not allowed here")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_MULTIPLE_CLASS_CONSTRUCTORS, "Multiple constructors are not allowed")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM
|
||||
PARSER_ERROR_DEF (PARSER_ERR_MODULE_UNEXPECTED, "Unexpected import or export statement")
|
||||
#endif /* JERRY_MODULE_SYSTEM */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_IDENTIFIER_AFTER_NUMBER, "Identifier cannot start after a number")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_MULTIPLE_DEFAULTS_NOT_ALLOWED, "Multiple default cases are not allowed")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ARRAY_ITEM_SEPARATOR_EXPECTED, "Expected ',' or ']' after an array item")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ILLEGAL_PROPERTY_IN_DECLARATION, "Illegal property in declaration context")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_DESTRUCTURING_PATTERN, "Invalid destructuring assignment target")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_NO_ARGUMENTS_EXPECTED, "Property getters must have no arguments")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ONE_ARGUMENT_EXPECTED, "Property setters must have one argument")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_CASE_NOT_IN_SWITCH, "Case statement must be in a switch block")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_CLASS_CONSTRUCTOR_AS_ACCESSOR, "Class constructor may not be an accessor")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_CONTINUE, "Continue statement must be inside a loop")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_IMPORT_META_REQUIRE_MODULE, "Cannot use 'import.meta' outside a module")
|
||||
#endif /* JERRY_MODULE_SYSTEM && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_IDENTIFIER_PART, "Character cannot be part of an identifier")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_EVAL_CANNOT_ASSIGNED, "Eval cannot be assigned to in strict mode")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_WITH_NOT_ALLOWED, "With statement not allowed in strict mode")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_NEW_TARGET_NOT_ALLOWED, "new.target expression is not allowed here")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_IDENTIFIER_START, "Character cannot be start of an identifier")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_STRICT_IDENT_NOT_ALLOWED, "Identifier name is reserved in strict mode")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_NULLISH_COALESCING, "Cannot chain nullish with logical AND or OR")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_DEFAULT_NOT_IN_SWITCH, "Default statement must be in a switch block")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_MODULE_SYSTEM && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_IMPORT_AFTER_NEW, "Module import call is not allowed after new")
|
||||
#endif /* JERRY_MODULE_SYSTEM && JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_TOO_MANY_CLASS_FIELDS, "Too many computed class fields are declared")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_KEYWORD, "Escape sequences are not allowed in keywords")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ARGUMENT_LIMIT_REACHED, "Maximum number of function arguments reached")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_NEWLINE_NOT_ALLOWED, "Newline is not allowed in strings or regexps")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_OCTAL_NUMBER_NOT_ALLOWED, "Octal numbers are not allowed in strict mode")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_FOR_AWAIT_NO_OF, "only 'of' form is allowed for for-await loops")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ARGUMENTS_CANNOT_ASSIGNED, "Arguments cannot be assigned to in strict mode")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_BREAK, "Break statement must be inside a loop or switch")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_OBJECT_ITEM_SEPARATOR_EXPECTED, "Expected ',' or '}' after a property definition")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_BREAK_LABEL, "Labeled statement targeted by a break not found")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_PARSER && !(JERRY_BUILTIN_REGEXP)
|
||||
PARSER_ERROR_DEF (PARSER_ERR_UNSUPPORTED_REGEXP, "Regexp is not supported in the selected profile")
|
||||
#endif /* JERRY_PARSER && !(JERRY_BUILTIN_REGEXP) */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_RETURN, "Return statement must be inside a function body")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_COLON_FOR_CONDITIONAL_EXPECTED, "Expected ':' token for ?: conditional expression")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_FORMAL_PARAM_AFTER_REST_PARAMETER, "Rest parameter must be the last formal parameter")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_DELETE_IDENT_NOT_ALLOWED, "Deleting identifier is not allowed in strict mode")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LABELLED_FUNC_NOT_IN_BLOCK, "Labelled functions are only allowed inside blocks")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_REST_PARAMETER_DEFAULT_INITIALIZER, "Rest parameter may not have a default initializer")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_EVAL_NOT_ALLOWED, "Eval is not allowed to be used here in strict mode")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_CONTINUE_LABEL, "Labeled statement targeted by a continue not found")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LEXICAL_LET_BINDING, "Let binding cannot appear in let/const declarations")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_LHS_PREFIX_OP, "Invalid left-hand side expression in prefix operation")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_OCTAL_ESCAPE_NOT_ALLOWED, "Octal escape sequences are not allowed in strict mode")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_SETTER_REST_PARAMETER, "Setter function argument must not be a rest parameter")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ARGUMENTS_IN_CLASS_FIELD, "In class field declarations 'arguments' is not allowed")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_LHS_POSTFIX_OP, "Invalid left-hand side expression in postfix operation")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_UNDERSCORE_IN_NUMBER, "Invalid use of underscore character in number literals")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_EXPONENTIATION, "Left operand of ** operator cannot be unary expression")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_MISSING_ASSIGN_AFTER_CONST, "Value assignment is expected after a const declaration")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
#if JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ARGUMENTS_NOT_ALLOWED, "Arguments is not allowed to be used here in strict mode")
|
||||
#endif /* JERRY_PARSER */
|
||||
#if JERRY_ESNEXT && JERRY_PARSER
|
||||
PARSER_ERROR_DEF (PARSER_ERR_DUPLICATED_ARGUMENT_NAMES, "Duplicated function argument names are not allowed here")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_CLASS_STATIC_PROTOTYPE, "Classes may not have a static property called 'prototype'")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_INVALID_CLASS_CONSTRUCTOR, "Class constructor may not be a generator or async function")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_TEMPLATE_STR_OCTAL_ESCAPE, "Octal escape sequences are not allowed in template strings")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_DUPLICATED_PROTO, "Duplicate __proto__ fields are not allowed in object literals")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_GENERATOR_IN_SINGLE_STATEMENT_POS,
|
||||
"Generator function cannot appear in a single-statement context")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_LEXICAL_SINGLE_STATEMENT,
|
||||
"Lexical declaration cannot appear in a single-statement context")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_FOR_IN_OF_DECLARATION, "for in-of loop variable declaration may not have an initializer")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_FOR_AWAIT_NO_ASYNC, "for-await-of is only allowed inside async functions and generators")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_USE_STRICT_NOT_ALLOWED,
|
||||
"The 'use strict' directive is not allowed for functions with non-simple arguments")
|
||||
PARSER_ERROR_DEF (PARSER_ERR_ASSIGNMENT_EXPECTED,
|
||||
"Unexpected arrow function or yield expression (parentheses around the expression may help)")
|
||||
#endif /* JERRY_ESNEXT && JERRY_PARSER */
|
||||
@@ -0,0 +1,140 @@
|
||||
# Copyright JS Foundation and other contributors, http://js.foundation
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
[PARSER_ERR_MSG]
|
||||
|
||||
PARSER_ERR_ARGUMENTS_CANNOT_ASSIGNED = "Arguments cannot be assigned to in strict mode"
|
||||
PARSER_ERR_ARGUMENTS_IN_CLASS_FIELD = "In class field declarations 'arguments' is not allowed"
|
||||
PARSER_ERR_ARGUMENTS_NOT_ALLOWED = "Arguments is not allowed to be used here in strict mode"
|
||||
PARSER_ERR_ARGUMENT_LIMIT_REACHED = "Maximum number of function arguments reached"
|
||||
PARSER_ERR_ARGUMENT_LIST_EXPECTED = "Expected argument list"
|
||||
PARSER_ERR_ARRAY_ITEM_SEPARATOR_EXPECTED = "Expected ',' or ']' after an array item"
|
||||
PARSER_ERR_ASSIGNMENT_EXPECTED = "Unexpected arrow function or yield expression (parentheses around the expression may help)"
|
||||
PARSER_ERR_AS_EXPECTED = "Expected 'as' token"
|
||||
PARSER_ERR_AWAIT_NOT_ALLOWED = "Await expression is not allowed here"
|
||||
PARSER_ERR_CASE_NOT_IN_SWITCH = "Case statement must be in a switch block"
|
||||
PARSER_ERR_CATCH_FINALLY_EXPECTED = "Catch or finally block expected"
|
||||
PARSER_ERR_CLASS_CONSTRUCTOR_AS_ACCESSOR = "Class constructor may not be an accessor"
|
||||
PARSER_ERR_CLASS_STATIC_PROTOTYPE = "Classes may not have a static property called 'prototype'"
|
||||
PARSER_ERR_COLON_EXPECTED = "Expected ':' token"
|
||||
PARSER_ERR_COLON_FOR_CONDITIONAL_EXPECTED = "Expected ':' token for ?: conditional expression"
|
||||
PARSER_ERR_DEFAULT_NOT_IN_SWITCH = "Default statement must be in a switch block"
|
||||
PARSER_ERR_DELETE_IDENT_NOT_ALLOWED = "Deleting identifier is not allowed in strict mode"
|
||||
PARSER_ERR_DUPLICATED_ARGUMENT_NAMES = "Duplicated function argument names are not allowed here"
|
||||
PARSER_ERR_DUPLICATED_EXPORT_IDENTIFIER = "Duplicate exported identifier"
|
||||
PARSER_ERR_DUPLICATED_IMPORT_BINDING = "Duplicated imported binding name"
|
||||
PARSER_ERR_DUPLICATED_LABEL = "Duplicated label"
|
||||
PARSER_ERR_DUPLICATED_PROTO = "Duplicate __proto__ fields are not allowed in object literals"
|
||||
PARSER_ERR_DUPLICATED_REGEXP_FLAG = "Duplicated regexp flag"
|
||||
PARSER_ERR_EVAL_CANNOT_ASSIGNED = "Eval cannot be assigned to in strict mode"
|
||||
PARSER_ERR_EVAL_NOT_ALLOWED = "Eval is not allowed to be used here in strict mode"
|
||||
PARSER_ERR_EXPORT_NOT_DEFINED = "Export not defined in module"
|
||||
PARSER_ERR_EXPRESSION_EXPECTED = "Expression expected"
|
||||
PARSER_ERR_FORMAL_PARAM_AFTER_REST_PARAMETER = "Rest parameter must be the last formal parameter"
|
||||
PARSER_ERR_FOR_AWAIT_NO_ASYNC = "for-await-of is only allowed inside async functions and generators"
|
||||
PARSER_ERR_FOR_AWAIT_NO_OF = "only 'of' form is allowed for for-await loops"
|
||||
PARSER_ERR_FOR_IN_OF_DECLARATION = "for in-of loop variable declaration may not have an initializer"
|
||||
PARSER_ERR_FROM_COMMA_EXPECTED = "Expected 'from' or ',' token"
|
||||
PARSER_ERR_FROM_EXPECTED = "Expected 'from' token"
|
||||
PARSER_ERR_GENERATOR_IN_SINGLE_STATEMENT_POS = "Generator function cannot appear in a single-statement context"
|
||||
PARSER_ERR_IDENTIFIER_AFTER_NUMBER = "Identifier cannot start after a number"
|
||||
PARSER_ERR_IDENTIFIER_EXPECTED = "Identifier expected"
|
||||
PARSER_ERR_IDENTIFIER_TOO_LONG = "Identifier is too long"
|
||||
PARSER_ERR_ILLEGAL_PROPERTY_IN_DECLARATION = "Illegal property in declaration context"
|
||||
PARSER_ERR_IMPORT_AFTER_NEW = "Module import call is not allowed after new"
|
||||
PARSER_ERR_IMPORT_META_REQUIRE_MODULE = "Cannot use 'import.meta' outside a module"
|
||||
PARSER_ERR_INVALID_BIGINT = "Number is not a valid BigInt"
|
||||
PARSER_ERR_INVALID_BIN_DIGIT = "Invalid binary digit"
|
||||
PARSER_ERR_INVALID_BREAK = "Break statement must be inside a loop or switch"
|
||||
PARSER_ERR_INVALID_BREAK_LABEL = "Labeled statement targeted by a break not found"
|
||||
PARSER_ERR_INVALID_CHARACTER = "Invalid (unexpected) character"
|
||||
PARSER_ERR_INVALID_CLASS_CONSTRUCTOR = "Class constructor may not be a generator or async function"
|
||||
PARSER_ERR_INVALID_CONTINUE = "Continue statement must be inside a loop"
|
||||
PARSER_ERR_INVALID_CONTINUE_LABEL = "Labeled statement targeted by a continue not found"
|
||||
PARSER_ERR_INVALID_DESTRUCTURING_PATTERN = "Invalid destructuring assignment target"
|
||||
PARSER_ERR_INVALID_EXPONENTIATION = "Left operand of ** operator cannot be unary expression"
|
||||
PARSER_ERR_INVALID_HEX_DIGIT = "Invalid hexadecimal digit"
|
||||
PARSER_ERR_INVALID_IDENTIFIER_PART = "Character cannot be part of an identifier"
|
||||
PARSER_ERR_INVALID_IDENTIFIER_START = "Character cannot be start of an identifier"
|
||||
PARSER_ERR_INVALID_KEYWORD = "Escape sequences are not allowed in keywords"
|
||||
PARSER_ERR_INVALID_LHS_ASSIGNMENT = "Invalid left-hand side in assignment"
|
||||
PARSER_ERR_INVALID_LHS_FOR_LOOP = "Invalid left-hand-side in for-loop"
|
||||
PARSER_ERR_INVALID_LHS_POSTFIX_OP = "Invalid left-hand side expression in postfix operation"
|
||||
PARSER_ERR_INVALID_LHS_PREFIX_OP = "Invalid left-hand side expression in prefix operation"
|
||||
PARSER_ERR_INVALID_NULLISH_COALESCING = "Cannot chain nullish with logical AND or OR"
|
||||
PARSER_ERR_INVALID_NUMBER = "Invalid number"
|
||||
PARSER_ERR_INVALID_OCTAL_DIGIT = "Invalid octal digit"
|
||||
PARSER_ERR_INVALID_RETURN = "Return statement must be inside a function body"
|
||||
PARSER_ERR_INVALID_RIGHT_SQUARE = "Unexpected '}' token"
|
||||
PARSER_ERR_INVALID_SWITCH = "Invalid switch body"
|
||||
PARSER_ERR_INVALID_UNDERSCORE_IN_NUMBER = "Invalid use of underscore character in number literals"
|
||||
PARSER_ERR_INVALID_UNICODE_ESCAPE_SEQUENCE = "Invalid unicode escape sequence"
|
||||
PARSER_ERR_IN_EXPECTED = "Expected 'in' token"
|
||||
PARSER_ERR_LABELLED_FUNC_NOT_IN_BLOCK = "Labelled functions are only allowed inside blocks"
|
||||
PARSER_ERR_LEFT_BRACE_EXPECTED = "Expected '{' token"
|
||||
PARSER_ERR_LEFT_BRACE_MULTIPLY_EXPECTED = "Expected '{' or '*' token"
|
||||
PARSER_ERR_LEFT_BRACE_MULTIPLY_LITERAL_EXPECTED = "Expected '{' or '*' or literal token"
|
||||
PARSER_ERR_LEFT_HAND_SIDE_EXP_EXPECTED = "Left-hand-side expression expected"
|
||||
PARSER_ERR_LEFT_PAREN_EXPECTED = "Expected '(' token"
|
||||
PARSER_ERR_LEXICAL_LET_BINDING = "Let binding cannot appear in let/const declarations"
|
||||
PARSER_ERR_LEXICAL_SINGLE_STATEMENT = "Lexical declaration cannot appear in a single-statement context"
|
||||
PARSER_ERR_LITERAL_LIMIT_REACHED = "Maximum number of literals reached"
|
||||
PARSER_ERR_META_EXPECTED = "Expected 'meta' keyword"
|
||||
PARSER_ERR_MISSING_ASSIGN_AFTER_CONST = "Value assignment is expected after a const declaration"
|
||||
PARSER_ERR_MISSING_EXPONENT = "Missing exponent part"
|
||||
PARSER_ERR_MODULE_UNEXPECTED = "Unexpected import or export statement"
|
||||
PARSER_ERR_MULTIPLE_CLASS_CONSTRUCTORS = "Multiple constructors are not allowed"
|
||||
PARSER_ERR_MULTIPLE_DEFAULTS_NOT_ALLOWED = "Multiple default cases are not allowed"
|
||||
PARSER_ERR_NEWLINE_NOT_ALLOWED = "Newline is not allowed in strings or regexps"
|
||||
PARSER_ERR_NEW_TARGET_EXPECTED = "Expected new.target expression"
|
||||
PARSER_ERR_NEW_TARGET_NOT_ALLOWED = "new.target expression is not allowed here"
|
||||
PARSER_ERR_NON_STRICT_ARG_DEFINITION = "Non-strict argument definition"
|
||||
PARSER_ERR_NO_ARGUMENTS_EXPECTED = "Property getters must have no arguments"
|
||||
PARSER_ERR_NUMBER_TOO_LONG = "Number is too long"
|
||||
PARSER_ERR_OBJECT_ITEM_SEPARATOR_EXPECTED = "Expected ',' or '}' after a property definition"
|
||||
PARSER_ERR_OBJECT_PROPERTY_REDEFINED = "Property of object literal redefined"
|
||||
PARSER_ERR_OCTAL_ESCAPE_NOT_ALLOWED = "Octal escape sequences are not allowed in strict mode"
|
||||
PARSER_ERR_OCTAL_NUMBER_NOT_ALLOWED = "Octal numbers are not allowed in strict mode"
|
||||
PARSER_ERR_OF_EXPECTED = "Expected 'of' token"
|
||||
PARSER_ERR_ONE_ARGUMENT_EXPECTED = "Property setters must have one argument"
|
||||
PARSER_ERR_PROPERTY_IDENTIFIER_EXPECTED = "Property identifier expected"
|
||||
PARSER_ERR_REGEXP_TOO_LONG = "Regexp is too long"
|
||||
PARSER_ERR_REST_PARAMETER_DEFAULT_INITIALIZER = "Rest parameter may not have a default initializer"
|
||||
PARSER_ERR_RIGHT_BRACE_COMMA_EXPECTED = "Expected '}' or ',' token"
|
||||
PARSER_ERR_RIGHT_BRACE_EXPECTED = "Expected '}' token"
|
||||
PARSER_ERR_RIGHT_PAREN_EXPECTED = "Expected ')' token"
|
||||
PARSER_ERR_RIGHT_SQUARE_EXPECTED = "Expected ']' token"
|
||||
PARSER_ERR_SCOPE_STACK_LIMIT_REACHED = "Maximum depth of scope stack reached"
|
||||
PARSER_ERR_SEMICOLON_EXPECTED = "Expected ';' token"
|
||||
PARSER_ERR_SETTER_REST_PARAMETER = "Setter function argument must not be a rest parameter"
|
||||
PARSER_ERR_STACK_LIMIT_REACHED = "Maximum function stack size reached"
|
||||
PARSER_ERR_STATEMENT_EXPECTED = "Statement expected"
|
||||
PARSER_ERR_STRICT_IDENT_NOT_ALLOWED = "Identifier name is reserved in strict mode"
|
||||
PARSER_ERR_STRING_EXPECTED = "Expected a string literal"
|
||||
PARSER_ERR_STRING_TOO_LONG = "String is too long"
|
||||
PARSER_ERR_TEMPLATE_STR_OCTAL_ESCAPE = "Octal escape sequences are not allowed in template strings"
|
||||
PARSER_ERR_TOO_MANY_CLASS_FIELDS = "Too many computed class fields are declared"
|
||||
PARSER_ERR_UNEXPECTED_END = "Unexpected end of input"
|
||||
PARSER_ERR_UNEXPECTED_SUPER_KEYWORD = "Super is not allowed to be used here"
|
||||
PARSER_ERR_UNKNOWN_REGEXP_FLAG = "Unknown regexp flag"
|
||||
PARSER_ERR_UNSUPPORTED_REGEXP = "Regexp is not supported in the selected profile"
|
||||
PARSER_ERR_UNTERMINATED_MULTILINE_COMMENT = "Unterminated multiline comment"
|
||||
PARSER_ERR_UNTERMINATED_REGEXP = "Unterminated regexp literal"
|
||||
PARSER_ERR_UNTERMINATED_STRING = "Unterminated string literal"
|
||||
PARSER_ERR_USE_STRICT_NOT_ALLOWED = "The 'use strict' directive is not allowed for functions with non-simple arguments"
|
||||
PARSER_ERR_VARIABLE_REDECLARED = "Local variable is redeclared"
|
||||
PARSER_ERR_WHILE_EXPECTED = "While expected for do-while loop"
|
||||
PARSER_ERR_WITH_NOT_ALLOWED = "With statement not allowed in strict mode"
|
||||
PARSER_ERR_YIELD_NOT_ALLOWED = "Yield expression is not allowed here"
|
||||
PARSER_ERR_NO_ERROR = "No error"
|
||||
@@ -0,0 +1,71 @@
|
||||
/* Copyright JS Foundation and other contributors, http://js.foundation
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "parser-errors.h"
|
||||
|
||||
#if JERRY_ERROR_MESSAGES
|
||||
/**
|
||||
* Struct to store parser error message with its size.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
lit_utf8_byte_t *text; /* Text of parser error message. */
|
||||
uint8_t size; /* Size of parser error message. */
|
||||
} parser_error_message_t;
|
||||
|
||||
/* Error message texts with size. */
|
||||
static parser_error_message_t parser_error_messages[] JERRY_ATTR_CONST_DATA = {
|
||||
{ (lit_utf8_byte_t *) "", 0 }, /* PARSER_ERR_EMPTY */
|
||||
/** @cond doxygen_suppress */
|
||||
#define PARSER_ERROR_DEF(id, utf8_string) { (lit_utf8_byte_t *) utf8_string, sizeof (utf8_string) - 1 },
|
||||
#include "parser-error-messages.inc.h"
|
||||
#undef PARSER_ERROR_DEF
|
||||
/** @endcond */
|
||||
};
|
||||
#endif /* JERRY_ERROR_MESSAGES */
|
||||
|
||||
/**
|
||||
* Get specified parser error as zero-terminated string
|
||||
*
|
||||
* @return pointer to zero-terminated parser error
|
||||
*/
|
||||
const lit_utf8_byte_t *
|
||||
parser_get_error_utf8 (uint32_t id) /**< parser error id */
|
||||
{
|
||||
JERRY_ASSERT (id < PARSER_ERR_OUT_OF_MEMORY);
|
||||
|
||||
#if JERRY_ERROR_MESSAGES
|
||||
return parser_error_messages[id].text;
|
||||
#else /* !JERRY_ERROR_MESSAGES */
|
||||
return NULL;
|
||||
#endif /* JERRY_ERROR_MESSAGES */
|
||||
} /* parser_get_error_utf8 */
|
||||
|
||||
/**
|
||||
* Get size of specified parser error
|
||||
*
|
||||
* @return size in bytes
|
||||
*/
|
||||
lit_utf8_size_t
|
||||
parser_get_error_size (uint32_t id) /**< parser error id */
|
||||
{
|
||||
JERRY_ASSERT (id < PARSER_ERR_OUT_OF_MEMORY);
|
||||
|
||||
#if JERRY_ERROR_MESSAGES
|
||||
return parser_error_messages[id].size;
|
||||
#else /* !JERRY_ERROR_MESSAGES */
|
||||
return 0;
|
||||
#endif /* JERRY_ERROR_MESSAGES */
|
||||
} /* parser_get_error_size */
|
||||
@@ -0,0 +1,40 @@
|
||||
/* Copyright JS Foundation and other contributors, http://js.foundation
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef PARSER_ERRORS_H
|
||||
#define PARSER_ERRORS_H
|
||||
|
||||
#include "lit-globals.h"
|
||||
|
||||
typedef enum
|
||||
{
|
||||
PARSER_ERR_EMPTY,
|
||||
/** @cond doxygen_suppress */
|
||||
#if JERRY_ERROR_MESSAGES
|
||||
#define PARSER_ERROR_DEF(id, ascii_zt_string) id,
|
||||
#else /* !JERRY_ERROR_MESSAGES */
|
||||
#define PARSER_ERROR_DEF(id, ascii_zt_string) id = PARSER_ERR_EMPTY,
|
||||
#endif /* JERRY_ERROR_MESSAGES */
|
||||
#include "parser-error-messages.inc.h"
|
||||
#undef PARSER_ERROR_DEF
|
||||
/** @endcond */
|
||||
PARSER_ERR_OUT_OF_MEMORY,
|
||||
PARSER_ERR_INVALID_REGEXP,
|
||||
} parser_error_msg_t;
|
||||
|
||||
const lit_utf8_byte_t* parser_get_error_utf8 (uint32_t id);
|
||||
lit_utf8_size_t parser_get_error_size (uint32_t id);
|
||||
|
||||
#endif /* !PARSER_ERRORS_H */
|
||||
@@ -37,6 +37,9 @@ MAGIC_STRINGS_INC_H = os.path.join(PROJECT_DIR, 'jerry-core', 'lit', 'lit-magic-
|
||||
ECMA_ERRORS_INI = os.path.join(PROJECT_DIR, 'jerry-core', 'ecma', 'base', 'ecma-error-messages.ini')
|
||||
ECMA_ERRORS_INC_H = os.path.join(PROJECT_DIR, 'jerry-core', 'ecma', 'base', 'ecma-error-messages.inc.h')
|
||||
|
||||
PARSER_ERRORS_INI = os.path.join(PROJECT_DIR, 'jerry-core', 'parser', 'js', 'parser-error-messages.ini')
|
||||
PARSER_ERRORS_INC_H = os.path.join(PROJECT_DIR, 'jerry-core', 'parser', 'js', 'parser-error-messages.inc.h')
|
||||
|
||||
LIMIT_MAGIC_STR_LENGTH = 255
|
||||
|
||||
def debug_dump(obj):
|
||||
@@ -317,6 +320,13 @@ def main():
|
||||
ECMA_ERRORS_INC_H,
|
||||
'ECMA_ERROR_DEF')
|
||||
|
||||
generate_magic_strings(args,
|
||||
PARSER_ERRORS_INI,
|
||||
'PARSER_ERR_MSG',
|
||||
'PARSER_ERR',
|
||||
PARSER_ERRORS_INC_H,
|
||||
'PARSER_ERROR_DEF')
|
||||
|
||||
subprocess.call([FORMAT_SCRIPT, '--fix'])
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
Reference in New Issue
Block a user