return NJS_OK;
}
- switch (node->token) {
+ switch (node->token_type) {
case NJS_TOKEN_VAR:
return njs_generate_var_statement(vm, generator, node);
jump_offset = njs_code_offset(generator, cond_jump);
label_offset = jump_offset + offsetof(njs_vmcode_cond_jump_t, offset);
- if (node->right != NULL && node->right->token == NJS_TOKEN_BRANCHING) {
+ if (node->right != NULL && node->right->token_type == NJS_TOKEN_BRANCHING) {
/* The "then" branch in a case of "if/then/else" statement. */
for (branch = swtch->right; branch != NULL; branch = branch->left) {
- if (branch->token != NJS_TOKEN_DEFAULT) {
+ if (branch->token_type != NJS_TOKEN_DEFAULT) {
/* The "case" expression. */
for (branch = swtch->right; branch != NULL; branch = branch->left) {
- if (branch->token == NJS_TOKEN_DEFAULT) {
+ if (branch->token_type == NJS_TOKEN_DEFAULT) {
njs_code_set_jump_offset(generator, njs_vmcode_jump_t, jump_offset);
jump = NULL;
node = branch;
index = NJS_INDEX_NONE;
node = node->right;
- if (node != NULL && node->token != NJS_TOKEN_FUNCTION) {
+ if (node != NULL && node->token_type != NJS_TOKEN_FUNCTION) {
index = node->index;
}
expr = node->right;
expr->dest = NULL;
- if (lvalue->token == NJS_TOKEN_NAME) {
+ if (lvalue->token_type == NJS_TOKEN_NAME) {
ret = njs_generate_variable(vm, generator, lvalue, NJS_DECLARATION);
if (njs_slow_path(ret != NJS_OK)) {
* Preserve object and property values stored in variables in a case
* if the variables can be changed by side effects in expression.
*/
- if (object->token == NJS_TOKEN_NAME) {
+ if (object->token_type == NJS_TOKEN_NAME) {
src = object->index;
index = njs_generate_node_temp_index_get(vm, generator, object);
njs_generate_code_move(generator, move, index, src);
}
- if (property->token == NJS_TOKEN_NAME) {
+ if (property->token_type == NJS_TOKEN_NAME) {
src = property->index;
index = njs_generate_node_temp_index_get(vm, generator, property);
return ret;
}
- switch (lvalue->token) {
+ switch (lvalue->token_type) {
case NJS_TOKEN_PROPERTY_INIT:
njs_generate_code(generator, njs_vmcode_prop_set_t, prop_set,
NJS_VMCODE_PROPERTY_INIT, 3);
lvalue = node->left;
- if (lvalue->token == NJS_TOKEN_NAME) {
+ if (lvalue->token_type == NJS_TOKEN_NAME) {
ret = njs_generate_variable(vm, generator, lvalue, NJS_DECLARATION);
if (njs_slow_path(ret != NJS_OK)) {
accessor->value = function->index;
accessor->object = object->index;
accessor->property = property->index;
- accessor->type = (node->token == NJS_TOKEN_PROPERTY_GETTER)
+ accessor->type = (node->token_type == NJS_TOKEN_PROPERTY_GETTER)
? NJS_OBJECT_PROP_GETTER : NJS_OBJECT_PROP_SETTER;
return NJS_OK;
right = node->right;
- if (left->token == NJS_TOKEN_NAME) {
+ if (left->token_type == NJS_TOKEN_NAME) {
if (njs_slow_path(njs_parser_has_side_effect(right))) {
njs_generate_code(generator, njs_vmcode_move_t, move,
expr = node->left;
- if (expr->token == NJS_TOKEN_NAME) {
+ if (expr->token_type == NJS_TOKEN_NAME) {
ret = njs_generate_variable(vm, generator, expr, NJS_TYPEOF);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
lvalue = node->left;
- if (lvalue->token == NJS_TOKEN_NAME) {
+ if (lvalue->token_type == NJS_TOKEN_NAME) {
ret = njs_generate_variable(vm, generator, lvalue, NJS_DECLARATION);
if (njs_slow_path(ret != NJS_OK)) {
catch_exit_label = undef_label;
catch_cont_label = undef_label;
- if (node->token == NJS_TOKEN_CATCH) {
+ if (node->token_type == NJS_TOKEN_CATCH) {
/* A "try/catch" case. */
catch_index = njs_variable_index(vm, node->left);
}
-njs_token_t
+njs_token_type_t
njs_lexer_token(njs_vm_t *vm, njs_lexer_t *lexer)
{
njs_lexer_token_t *lt;
lexer->prev_start = lexer->start;
if (lexer->token != NULL) {
- lexer->prev_token = lexer->token->type;
+ lexer->prev_type = lexer->token->type;
njs_mp_free(vm->mem_pool, lexer->token);
}
}
-njs_token_t
+njs_token_type_t
njs_lexer_peek_token(njs_vm_t *vm, njs_lexer_t *lexer, size_t offset)
{
size_t i;
NJS_TOKEN_SUPER,
NJS_TOKEN_RESERVED,
-} njs_token_t;
+} njs_token_type_t;
typedef struct {
typedef struct {
njs_lexer_entry_t entry;
- njs_token_t type;
+ njs_token_type_t type;
} njs_keyword_t;
typedef struct {
- njs_token_t type:16;
+ njs_token_type_t type:16;
uint32_t line;
uintptr_t unique_id;
njs_str_t text;
uint8_t keyword;
u_char *prev_start;
- njs_token_t prev_token:16;
+ njs_token_type_t prev_type:16;
uint32_t line;
njs_str_t file;
njs_int_t njs_lexer_init(njs_vm_t *vm, njs_lexer_t *lexer, njs_str_t *file,
u_char *start, u_char *end);
-njs_token_t njs_lexer_token(njs_vm_t *vm, njs_lexer_t *lexer);
-njs_token_t njs_lexer_peek_token(njs_vm_t *vm, njs_lexer_t *lexer,
+njs_token_type_t njs_lexer_token(njs_vm_t *vm, njs_lexer_t *lexer);
+njs_token_type_t njs_lexer_peek_token(njs_vm_t *vm, njs_lexer_t *lexer,
size_t offset);
njs_int_t njs_lexer_rollback(njs_vm_t *vm, njs_lexer_t *lexer);
njs_str_t name, text;
njs_lexer_t *prev, lexer;
njs_module_t *module;
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node;
njs_module_info_t info;
parser->lexer = &lexer;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
goto fail;
}
- token = njs_parser_module_lambda(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_module_lambda(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
goto fail;
}
static njs_int_t njs_parser_scope_begin(njs_vm_t *vm, njs_parser_t *parser,
njs_scope_t type);
static void njs_parser_scope_end(njs_vm_t *vm, njs_parser_t *parser);
-static njs_token_t njs_parser_statement_chain(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token, njs_bool_t top);
-static njs_token_t njs_parser_statement(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
-static njs_token_t njs_parser_block_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_statement_chain(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type, njs_bool_t top);
+static njs_token_type_t njs_parser_statement(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type);
+static njs_token_type_t njs_parser_block_statement(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_block(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_labelled_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_block(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_labelled_statement(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_function_declaration(njs_vm_t *vm,
+static njs_token_type_t njs_parser_function_declaration(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_lambda_arguments(njs_vm_t *vm,
+static njs_token_type_t njs_parser_lambda_arguments(njs_vm_t *vm,
njs_parser_t *parser, njs_function_lambda_t *lambda, njs_index_t index,
- njs_token_t token);
-static njs_token_t njs_parser_lambda_argument(njs_vm_t *vm,
+ njs_token_type_t type);
+static njs_token_type_t njs_parser_lambda_argument(njs_vm_t *vm,
njs_parser_t *parser, njs_index_t index);
-static njs_token_t njs_parser_lambda_body(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
+static njs_token_type_t njs_parser_lambda_body(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
static njs_parser_node_t *njs_parser_return_set(njs_vm_t *vm,
njs_parser_t *parser, njs_parser_node_t *expr);
-static njs_token_t njs_parser_return_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_return_statement(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_var_statement(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t parent, njs_bool_t var_in);
-static njs_token_t njs_parser_if_statement(njs_vm_t *vm, njs_parser_t *parser);
-static njs_token_t njs_parser_switch_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_var_statement(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t parent, njs_bool_t var_in);
+static njs_token_type_t njs_parser_if_statement(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_while_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_switch_statement(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_do_while_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_while_statement(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_for_statement(njs_vm_t *vm, njs_parser_t *parser);
-static njs_token_t njs_parser_var_in_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_do_while_statement(njs_vm_t *vm,
+ njs_parser_t *parser);
+static njs_token_type_t njs_parser_for_statement(njs_vm_t *vm,
+ njs_parser_t *parser);
+static njs_token_type_t njs_parser_var_in_statement(njs_vm_t *vm,
njs_parser_t *parser, njs_parser_node_t *name);
-static njs_token_t njs_parser_for_in_statement(njs_vm_t *vm,
- njs_parser_t *parser, njs_str_t *name, njs_token_t token);
-static njs_token_t njs_parser_brk_statement(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_try_statement(njs_vm_t *vm, njs_parser_t *parser);
-static njs_token_t njs_parser_try_block(njs_vm_t *vm, njs_parser_t *parser);
-static njs_token_t njs_parser_throw_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_for_in_statement(njs_vm_t *vm,
+ njs_parser_t *parser, njs_str_t *name, njs_token_type_t type);
+static njs_token_type_t njs_parser_brk_statement(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_try_statement(njs_vm_t *vm,
+ njs_parser_t *parser);
+static njs_token_type_t njs_parser_try_block(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_import_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_throw_statement(njs_vm_t *vm,
njs_parser_t *parser);
-static njs_token_t njs_parser_export_statement(njs_vm_t *vm,
+static njs_token_type_t njs_parser_import_statement(njs_vm_t *vm,
+ njs_parser_t *parser);
+static njs_token_type_t njs_parser_export_statement(njs_vm_t *vm,
njs_parser_t *parser);
static njs_int_t njs_parser_export_sink(njs_vm_t *vm, njs_parser_t *parser);
-static njs_token_t njs_parser_grouping_expression(njs_vm_t *vm,
+static njs_token_type_t njs_parser_grouping_expression(njs_vm_t *vm,
njs_parser_t *parser);
njs_parser(njs_vm_t *vm, njs_parser_t *parser, njs_parser_t *prev)
{
njs_int_t ret;
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node;
ret = njs_parser_scope_begin(vm, parser, NJS_SCOPE_GLOBAL);
}
}
- token = njs_parser_token(vm, parser);
+ type = njs_parser_token(vm, parser);
- while (token != NJS_TOKEN_END) {
+ while (type != NJS_TOKEN_END) {
- token = njs_parser_statement_chain(vm, parser, token, 1);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_statement_chain(vm, parser, type, 1);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
return NJS_ERROR;
}
- if (token == NJS_TOKEN_CLOSE_BRACE && vm->options.trailer) {
+ if (type == NJS_TOKEN_CLOSE_BRACE && vm->options.trailer) {
parser->lexer->start--;
break;
}
njs_parser_chain_top_set(parser, node);
}
- node->token = NJS_TOKEN_END;
+ node->token_type = NJS_TOKEN_END;
if (njs_slow_path(parser->count != 0)) {
njs_internal_error(vm, "parser->count != 0");
}
-static njs_token_t
+static njs_token_type_t
njs_parser_statement_chain(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token, njs_bool_t top)
+ njs_token_type_t type, njs_bool_t top)
{
njs_parser_node_t *stmt, *last, *node, *new_node, **child;
njs_parser_enter(vm, parser);
- token = njs_parser_statement(vm, parser, token);
+ type = njs_parser_statement(vm, parser, type);
njs_parser_leave(parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return njs_parser_unexpected_token(vm, parser, token);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return njs_parser_unexpected_token(vm, parser, type);
}
if (parser->node == NULL) {
/* The statement is empty block or just semicolon. */
- return token;
+ return type;
}
new_node = parser->node;
*child = stmt;
- while (token == NJS_TOKEN_SEMICOLON) {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ while (type == NJS_TOKEN_SEMICOLON) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
break;
}
}
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_statement(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
size_t offset;
parser->node = NULL;
- switch (token) {
+ switch (type) {
case NJS_TOKEN_FUNCTION:
return njs_parser_function_declaration(vm, parser);
if (vm->options.trailer) {
parser->node = NULL;
njs_thread_log_debug("BLOCK END");
- return token;
+ return type;
}
/* Fall through. */
default:
- switch (token) {
+ switch (type) {
case NJS_TOKEN_VAR:
- token = njs_parser_var_statement(vm, parser, token, 0);
+ type = njs_parser_var_statement(vm, parser, type, 0);
break;
case NJS_TOKEN_RETURN:
- token = njs_parser_return_statement(vm, parser);
+ type = njs_parser_return_statement(vm, parser);
break;
case NJS_TOKEN_THROW:
- token = njs_parser_throw_statement(vm, parser);
+ type = njs_parser_throw_statement(vm, parser);
break;
case NJS_TOKEN_CONTINUE:
case NJS_TOKEN_BREAK:
- token = njs_parser_brk_statement(vm, parser, token);
+ type = njs_parser_brk_statement(vm, parser, type);
break;
case NJS_TOKEN_IMPORT:
- token = njs_parser_import_statement(vm, parser);
+ type = njs_parser_import_statement(vm, parser);
break;
case NJS_TOKEN_EXPORT:
- token = njs_parser_export_statement(vm, parser);
+ type = njs_parser_export_statement(vm, parser);
break;
case NJS_TOKEN_NAME:
/* Fall through. */
default:
- token = njs_parser_expression(vm, parser, token);
+ type = njs_parser_expression(vm, parser, type);
break;
}
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
/*
* An expression must be terminated by semicolon,
* or by a close curly brace or by the end of line.
*/
- switch (token) {
+ switch (type) {
case NJS_TOKEN_SEMICOLON:
return njs_parser_token(vm, parser);
case NJS_TOKEN_CLOSE_BRACE:
case NJS_TOKEN_END:
- return token;
+ return type;
default:
- if (parser->lexer->prev_token == NJS_TOKEN_LINE_END) {
- return token;
+ if (parser->lexer->prev_type == NJS_TOKEN_LINE_END) {
+ return type;
}
return NJS_TOKEN_ILLEGAL;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_block_statement(njs_vm_t *vm, njs_parser_t *parser)
{
njs_int_t ret;
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
ret = njs_parser_scope_begin(vm, parser, NJS_SCOPE_BLOCK);
parser->node = NULL;
- while (token != NJS_TOKEN_CLOSE_BRACE) {
- token = njs_parser_statement_chain(vm, parser, token, 0);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ while (type != NJS_TOKEN_CLOSE_BRACE) {
+ type = njs_parser_statement_chain(vm, parser, type, 0);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
}
}
-static njs_token_t
-njs_parser_block(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token)
+static njs_token_type_t
+njs_parser_block(njs_vm_t *vm, njs_parser_t *parser, njs_token_type_t type)
{
- if (token == NJS_TOKEN_FUNCTION) {
+ if (type == NJS_TOKEN_FUNCTION) {
njs_parser_syntax_error(vm, parser,
"Functions can only be declared at top level or inside a block");
return NJS_TOKEN_ILLEGAL;
}
- return njs_parser_statement(vm, parser, token);
+ return njs_parser_statement(vm, parser, type);
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_labelled_statement(njs_vm_t *vm, njs_parser_t *parser)
{
- uintptr_t unique_id;
- njs_int_t ret;
- njs_str_t name;
- njs_token_t token;
- njs_variable_t *label;
+ uintptr_t unique_id;
+ njs_int_t ret;
+ njs_str_t name;
+ njs_variable_t *label;
+ njs_token_type_t type;
name = *njs_parser_text(parser);
unique_id = njs_parser_key_hash(parser);
return NJS_TOKEN_ERROR;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_COLON);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_COLON);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_statement(vm, parser, token);
+ type = njs_parser_statement(vm, parser, type);
- if (njs_fast_path(token > NJS_TOKEN_ILLEGAL)) {
+ if (njs_fast_path(type > NJS_TOKEN_ILLEGAL)) {
if (parser->node != NULL) {
/* The statement is not empty block or just semicolon. */
}
}
- return token;
+ return type;
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_function_declaration(njs_vm_t *vm, njs_parser_t *parser)
{
njs_int_t ret;
- njs_token_t token;
njs_variable_t *var;
njs_function_t *function;
+ njs_token_type_t type;
njs_parser_node_t *node;
node = njs_parser_node_new(vm, parser, NJS_TOKEN_FUNCTION);
node->token_line = njs_parser_token_line(parser);
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token != NJS_TOKEN_NAME) {
- if (njs_parser_restricted_identifier(token)) {
+ if (type != NJS_TOKEN_NAME) {
+ if (njs_parser_restricted_identifier(type)) {
njs_parser_syntax_error(vm, parser, "Identifier \"%V\" "
"is forbidden in function declaration",
njs_parser_text(parser));
return NJS_TOKEN_ERROR;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
parser->node = node;
return NJS_TOKEN_ERROR;
}
- token = njs_parser_function_lambda(vm, parser, function->u.lambda, token);
+ type = njs_parser_function_lambda(vm, parser, function->u.lambda, type);
function->args_count = function->u.lambda->nargs
- function->u.lambda->rest_parameters;
- return token;
+ return type;
}
-njs_token_t
+njs_token_type_t
njs_parser_function_expression(njs_vm_t *vm, njs_parser_t *parser)
{
njs_int_t ret;
- njs_token_t token;
njs_variable_t *var;
njs_function_t *function;
+ njs_token_type_t type;
njs_parser_node_t *node;
njs_function_lambda_t *lambda;
node->token_line = njs_parser_token_line(parser);
parser->node = node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
/*
return NJS_TOKEN_ERROR;
}
- if (token == NJS_TOKEN_NAME) {
+ if (type == NJS_TOKEN_NAME) {
var = njs_parser_variable_add(vm, parser, NJS_VARIABLE_SHIM);
if (njs_slow_path(var == NULL)) {
return NJS_TOKEN_ERROR;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
function = njs_parser_function_alloc(vm, parser, var);
node->u.value.data.u.lambda = lambda;
- token = njs_parser_function_lambda(vm, parser, lambda, token);
+ type = njs_parser_function_lambda(vm, parser, lambda, type);
njs_parser_scope_end(vm, parser);
- return token;
+ return type;
}
-njs_token_t
+njs_token_type_t
njs_parser_function_lambda(njs_vm_t *vm, njs_parser_t *parser,
- njs_function_lambda_t *lambda, njs_token_t token)
+ njs_function_lambda_t *lambda, njs_token_type_t type)
{
njs_int_t ret;
njs_index_t index;
/* A "this" reservation. */
index += sizeof(njs_value_t);
- token = njs_parser_lambda_arguments(vm, parser, lambda, index, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_lambda_arguments(vm, parser, lambda, index, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_lambda_body(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_lambda_body(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
njs_parser_scope_end(vm, parser);
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_lambda_arguments(njs_vm_t *vm, njs_parser_t *parser,
- njs_function_lambda_t *lambda, njs_index_t index, njs_token_t token)
+ njs_function_lambda_t *lambda, njs_index_t index, njs_token_type_t type)
{
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_OPEN_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_OPEN_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
lambda->nargs = 0;
- while (token != NJS_TOKEN_CLOSE_PARENTHESIS) {
+ while (type != NJS_TOKEN_CLOSE_PARENTHESIS) {
if (njs_slow_path(lambda->rest_parameters)) {
return NJS_TOKEN_ILLEGAL;
}
- if (njs_slow_path(token == NJS_TOKEN_ELLIPSIS)) {
+ if (njs_slow_path(type == NJS_TOKEN_ELLIPSIS)) {
lambda->rest_parameters = 1;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
return NJS_TOKEN_ILLEGAL;
}
}
- if (njs_slow_path(token != NJS_TOKEN_NAME)) {
+ if (njs_slow_path(type != NJS_TOKEN_NAME)) {
return NJS_TOKEN_ILLEGAL;
}
- token = njs_parser_lambda_argument(vm, parser, index);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_lambda_argument(vm, parser, index);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token == NJS_TOKEN_COMMA) {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (type == NJS_TOKEN_COMMA) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_lambda_argument(njs_vm_t *vm, njs_parser_t *parser,
njs_index_t index)
{
}
-static njs_token_t
-njs_parser_lambda_body(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token)
+static njs_token_type_t
+njs_parser_lambda_body(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type)
{
njs_parser_node_t *body, *last, *parent;
parent = parser->node;
- token = njs_parser_lambda_statements(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_lambda_statements(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
last = NULL;
}
}
- if (last == NULL || last->token != NJS_TOKEN_RETURN) {
+ if (last == NULL || last->token_type != NJS_TOKEN_RETURN) {
/*
* There is no function body or the last function body
* body statement is not "return" statement.
parser->node = parent;
- return token;
+ return type;
}
}
-njs_token_t
+njs_token_type_t
njs_parser_lambda_statements(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_OPEN_BRACE);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_OPEN_BRACE);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
parser->node = NULL;
- while (token != NJS_TOKEN_CLOSE_BRACE) {
- token = njs_parser_statement_chain(vm, parser, token, 1);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ while (type != NJS_TOKEN_CLOSE_BRACE) {
+ type = njs_parser_statement_chain(vm, parser, type, 1);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_return_statement(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node;
njs_parser_scope_t *scope;
parser->node = node;
- token = njs_lexer_token(vm, parser->lexer);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_lexer_token(vm, parser->lexer);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- switch (token) {
+ switch (type) {
case NJS_TOKEN_LINE_END:
return njs_parser_token(vm, parser);
case NJS_TOKEN_SEMICOLON:
case NJS_TOKEN_CLOSE_BRACE:
case NJS_TOKEN_END:
- return token;
+ return type;
default:
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (parser->node->token == NJS_TOKEN_FUNCTION) {
+ if (parser->node->token_type == NJS_TOKEN_FUNCTION) {
/* TODO: test closure */
}
node->right = parser->node;
parser->node = node;
- return token;
+ return type;
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_var_statement(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t parent, njs_bool_t var_in)
+ njs_token_type_t parent, njs_bool_t var_in)
{
- njs_token_t token;
+ njs_token_type_t token_type;
njs_parser_node_t *left, *stmt, *name, *assign, *expr;
njs_variable_type_t type;
left = NULL;
do {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ token_type = njs_parser_token(vm, parser);
+ if (njs_slow_path(token_type <= NJS_TOKEN_ILLEGAL)) {
+ return token_type;
}
- if (token != NJS_TOKEN_NAME) {
- if (njs_parser_restricted_identifier(token)) {
+ if (token_type != NJS_TOKEN_NAME) {
+ if (njs_parser_restricted_identifier(token_type)) {
njs_parser_syntax_error(vm, parser, "Identifier \"%V\" "
"is forbidden in var declaration",
njs_parser_text(parser));
return NJS_TOKEN_ERROR;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ token_type = njs_parser_token(vm, parser);
+ if (njs_slow_path(token_type <= NJS_TOKEN_ILLEGAL)) {
+ return token_type;
}
if (var_in) {
- if (token == NJS_TOKEN_IN) {
+ if (token_type == NJS_TOKEN_IN) {
return njs_parser_var_in_statement(vm, parser, name);
}
expr = NULL;
- if (token == NJS_TOKEN_ASSIGNMENT) {
+ if (token_type == NJS_TOKEN_ASSIGNMENT) {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ token_type = njs_parser_token(vm, parser);
+ if (njs_slow_path(token_type <= NJS_TOKEN_ILLEGAL)) {
+ return token_type;
}
- token = njs_parser_assignment_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ token_type = njs_parser_assignment_expression(vm, parser,
+ token_type);
+ if (njs_slow_path(token_type <= NJS_TOKEN_ILLEGAL)) {
+ return token_type;
}
expr = parser->node;
left = stmt;
- } while (token == NJS_TOKEN_COMMA);
+ } while (token_type == NJS_TOKEN_COMMA);
- return token;
+ return token_type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_if_statement(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node, *cond, *stmt;
- token = njs_parser_grouping_expression(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_grouping_expression(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
cond = parser->node;
- token = njs_parser_block(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_block(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token == NJS_TOKEN_ELSE) {
+ if (type == NJS_TOKEN_ELSE) {
stmt = parser->node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_block(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_block(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node = njs_parser_node_new(vm, parser, NJS_TOKEN_BRANCHING);
node->right = parser->node;
parser->node = node;
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_switch_statement(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node, *swtch, *branch, *dflt, **last;
node = NULL;
branch = NULL;
dflt = NULL;
- token = njs_parser_grouping_expression(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_grouping_expression(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
swtch = njs_parser_node_new(vm, parser, NJS_TOKEN_SWITCH);
swtch->left = parser->node;
last = &swtch->right;
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_OPEN_BRACE);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_OPEN_BRACE);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- while (token != NJS_TOKEN_CLOSE_BRACE) {
+ while (type != NJS_TOKEN_CLOSE_BRACE) {
- if (token == NJS_TOKEN_CASE || token == NJS_TOKEN_DEFAULT) {
+ if (type == NJS_TOKEN_CASE || type == NJS_TOKEN_DEFAULT) {
do {
node = njs_parser_node_new(vm, parser, 0);
return NJS_TOKEN_ERROR;
}
- if (token == NJS_TOKEN_CASE) {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (type == NJS_TOKEN_CASE) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->left = parser->node;
}
branch = node;
- branch->token = NJS_TOKEN_DEFAULT;
+ branch->token_type = NJS_TOKEN_DEFAULT;
dflt = branch;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
}
*last = branch;
last = &branch->left;
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_COLON);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_COLON);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- } while (token == NJS_TOKEN_CASE || token == NJS_TOKEN_DEFAULT);
+ } while (type == NJS_TOKEN_CASE || type == NJS_TOKEN_DEFAULT);
parser->node = NULL;
- if (token == NJS_TOKEN_CLOSE_BRACE) {
+ if (type == NJS_TOKEN_CLOSE_BRACE) {
break;
}
return NJS_TOKEN_ILLEGAL;
}
- token = njs_parser_statement_chain(vm, parser, token, 0);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_statement_chain(vm, parser, type, 0);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_while_statement(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node, *cond;
- token = njs_parser_grouping_expression(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_grouping_expression(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
cond = parser->node;
- token = njs_parser_block(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_block(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node = njs_parser_node_new(vm, parser, NJS_TOKEN_WHILE);
node->right = cond;
parser->node = node;
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_do_while_statement(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node, *stmt;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_block(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_block(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
stmt = parser->node;
- if (njs_slow_path(token != NJS_TOKEN_WHILE)) {
+ if (njs_slow_path(type != NJS_TOKEN_WHILE)) {
return NJS_TOKEN_ILLEGAL;
}
- token = njs_parser_grouping_expression(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_grouping_expression(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node = njs_parser_node_new(vm, parser, NJS_TOKEN_DO);
node->right = parser->node;
parser->node = node;
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_for_statement(njs_vm_t *vm, njs_parser_t *parser)
{
njs_str_t name;
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node, *init, *condition, *update, *cond, *body;
init = NULL;
condition = NULL;
update = NULL;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_OPEN_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_OPEN_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token != NJS_TOKEN_SEMICOLON) {
+ if (type != NJS_TOKEN_SEMICOLON) {
- if (token == NJS_TOKEN_VAR) {
+ if (type == NJS_TOKEN_VAR) {
- token = njs_parser_var_statement(vm, parser, token, 1);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_var_statement(vm, parser, type, 1);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
init = parser->node;
- if (init->token == NJS_TOKEN_FOR_IN) {
+ if (init->token_type == NJS_TOKEN_FOR_IN) {
goto done;
}
name = *njs_parser_text(parser);
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
init = parser->node;
- if (init->token == NJS_TOKEN_IN) {
- token = njs_parser_for_in_statement(vm, parser, &name, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (init->token_type == NJS_TOKEN_IN) {
+ type = njs_parser_for_in_statement(vm, parser, &name, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
goto done;
}
}
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_SEMICOLON);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_SEMICOLON);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token != NJS_TOKEN_SEMICOLON) {
+ if (type != NJS_TOKEN_SEMICOLON) {
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
condition = parser->node;
}
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_SEMICOLON);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_SEMICOLON);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token != NJS_TOKEN_CLOSE_PARENTHESIS) {
+ if (type != NJS_TOKEN_CLOSE_PARENTHESIS) {
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
update = parser->node;
}
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_CLOSE_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_CLOSE_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_block(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_block(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node = njs_parser_node_new(vm, parser, NJS_TOKEN_FOR);
done:
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_var_in_statement(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *name)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node, *foreach;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node = njs_parser_node_new(vm, parser, NJS_TOKEN_IN);
node->left = name;
node->right = parser->node;
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_CLOSE_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_CLOSE_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_block(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_block(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
foreach = njs_parser_node_new(vm, parser, NJS_TOKEN_FOR_IN);
parser->node = foreach;
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_for_in_statement(njs_vm_t *vm, njs_parser_t *parser, njs_str_t *name,
- njs_token_t token)
+ njs_token_type_t type)
{
njs_parser_node_t *node;
node = parser->node->left;
- if (node->token != NJS_TOKEN_NAME) {
+ if (node->token_type != NJS_TOKEN_NAME) {
njs_parser_ref_error(vm, parser, "Invalid left-hand side \"%V\" "
"in for-in statement", name);
node->left = parser->node;
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_CLOSE_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_CLOSE_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_block(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_block(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
parser->node = node;
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_brk_statement(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
uintptr_t unique_id;
njs_int_t ret;
njs_str_t name;
njs_parser_node_t *node;
- node = njs_parser_node_new(vm, parser, token);
+ node = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(node == NULL)) {
return NJS_TOKEN_ERROR;
}
node->token_line = njs_parser_token_line(parser);
parser->node = node;
- token = njs_lexer_token(vm, parser->lexer);
+ type = njs_lexer_token(vm, parser->lexer);
- switch (token) {
+ switch (type) {
case NJS_TOKEN_LINE_END:
return njs_parser_token(vm, parser);
case NJS_TOKEN_SEMICOLON:
case NJS_TOKEN_CLOSE_BRACE:
case NJS_TOKEN_END:
- return token;
+ return type;
default:
/* TODO: LABEL */
}
-static njs_token_t
+static njs_token_type_t
njs_parser_try_statement(njs_vm_t *vm, njs_parser_t *parser)
{
njs_int_t ret;
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node, *try, *catch;
- token = njs_parser_try_block(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_try_block(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
try = njs_parser_node_new(vm, parser, NJS_TOKEN_TRY);
try->left = parser->node;
- if (token == NJS_TOKEN_CATCH) {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (type == NJS_TOKEN_CATCH) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_OPEN_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_OPEN_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token != NJS_TOKEN_NAME) {
+ if (type != NJS_TOKEN_NAME) {
return NJS_TOKEN_ILLEGAL;
}
catch->left = node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (njs_slow_path(token != NJS_TOKEN_CLOSE_PARENTHESIS)) {
+ if (njs_slow_path(type != NJS_TOKEN_CLOSE_PARENTHESIS)) {
return NJS_TOKEN_ILLEGAL;
}
- token = njs_parser_try_block(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_try_block(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
catch->right = parser->node;
njs_parser_scope_end(vm, parser);
}
- if (token == NJS_TOKEN_FINALLY) {
+ if (type == NJS_TOKEN_FINALLY) {
- token = njs_parser_try_block(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_try_block(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node = njs_parser_node_new(vm, parser, NJS_TOKEN_FINALLY);
parser->node = try;
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_try_block(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token != NJS_TOKEN_OPEN_BRACE)) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type != NJS_TOKEN_OPEN_BRACE)) {
return NJS_TOKEN_ILLEGAL;
}
- token = njs_parser_block_statement(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_block_statement(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node = parser->node;
- if (node != NULL && node->token == NJS_TOKEN_BLOCK) {
+ if (node != NULL && node->token_type == NJS_TOKEN_BLOCK) {
parser->node = node->left;
njs_mp_free(vm->mem_pool, node);
}
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_throw_statement(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node;
node = njs_parser_node_new(vm, parser, NJS_TOKEN_THROW);
return NJS_TOKEN_ERROR;
}
- token = njs_lexer_token(vm, parser->lexer);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_lexer_token(vm, parser->lexer);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- switch (token) {
+ switch (type) {
case NJS_TOKEN_LINE_END:
njs_parser_syntax_error(vm, parser, "Illegal newline after throw");
return NJS_TOKEN_ILLEGAL;
default:
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
parser->node = node;
- return token;
+ return type;
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_import_statement(njs_vm_t *vm, njs_parser_t *parser)
{
njs_int_t ret;
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *name, *import;
if (parser->scope->type != NJS_SCOPE_GLOBAL
return NJS_TOKEN_ERROR;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token != NJS_TOKEN_NAME) {
+ if (type != NJS_TOKEN_NAME) {
njs_parser_syntax_error(vm, parser,
"Non-default import is not supported");
return NJS_TOKEN_ILLEGAL;
return NJS_TOKEN_ERROR;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_match_name(vm, parser, token, "from");
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match_name(vm, parser, type, "from");
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token != NJS_TOKEN_STRING) {
+ if (type != NJS_TOKEN_STRING) {
return NJS_TOKEN_ILLEGAL;
}
}
-njs_token_t
+njs_token_type_t
njs_parser_module_lambda(njs_vm_t *vm, njs_parser_t *parser)
{
njs_int_t ret;
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node, *parent;
njs_function_lambda_t *lambda;
node->token_line = njs_parser_token_line(parser);
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
lambda = njs_function_lambda_alloc(vm, 1);
parser->scope->module = 1;
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_OPEN_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_OPEN_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
parent = parser->node;
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_CLOSE_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_CLOSE_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_lambda_statements(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_lambda_statements(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
ret = njs_parser_export_sink(vm, parser);
njs_parser_scope_end(vm, parser);
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_export_statement(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *node;
if (!parser->scope->module) {
parser->node = node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token != NJS_TOKEN_DEFAULT)) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type != NJS_TOKEN_DEFAULT)) {
njs_parser_syntax_error(vm, parser,
"Non-default export is not supported");
return NJS_TOKEN_ILLEGAL;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
parser->node = node;
- return token;
+ return type;
}
node = node->left)
{
if (node->right != NULL
- && node->right->token == NJS_TOKEN_EXPORT)
+ && node->right->token_type == NJS_TOKEN_EXPORT)
{
n++;
}
node = njs_parser_chain_top(parser);
- if (node->right && node->right->token == NJS_TOKEN_EXPORT) {
+ if (node->right && node->right->token_type == NJS_TOKEN_EXPORT) {
return NJS_OK;
}
node = prev->left;
if (node->right != NULL
- && node->right->token == NJS_TOKEN_EXPORT)
+ && node->right->token_type == NJS_TOKEN_EXPORT)
{
prev->left = node->left;
break;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_grouping_expression(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_OPEN_PARENTHESIS);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_OPEN_PARENTHESIS);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- return njs_parser_match(vm, parser, token, NJS_TOKEN_CLOSE_PARENTHESIS);
+ return njs_parser_match(vm, parser, type, NJS_TOKEN_CLOSE_PARENTHESIS);
}
njs_int_t
njs_parser_match_arrow_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
size_t offset;
njs_bool_t rest_parameters;
- if (token != NJS_TOKEN_OPEN_PARENTHESIS && token != NJS_TOKEN_NAME) {
+ if (type != NJS_TOKEN_OPEN_PARENTHESIS && type != NJS_TOKEN_NAME) {
return NJS_DECLINED;
}
offset = 0;
- if (token == NJS_TOKEN_NAME) {
+ if (type == NJS_TOKEN_NAME) {
goto arrow;
}
- token = njs_parser_peek_token(vm, parser, &offset);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_peek_token(vm, parser, &offset);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
return NJS_DECLINED;
}
rest_parameters = 0;
- while (token != NJS_TOKEN_CLOSE_PARENTHESIS) {
+ while (type != NJS_TOKEN_CLOSE_PARENTHESIS) {
if (rest_parameters) {
return NJS_DECLINED;
}
- if (njs_slow_path(token == NJS_TOKEN_ELLIPSIS)) {
+ if (njs_slow_path(type == NJS_TOKEN_ELLIPSIS)) {
rest_parameters = 1;
- token = njs_parser_peek_token(vm, parser, &offset);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_peek_token(vm, parser, &offset);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
return NJS_DECLINED;
}
}
- if (njs_slow_path(token != NJS_TOKEN_NAME)) {
+ if (njs_slow_path(type != NJS_TOKEN_NAME)) {
return NJS_DECLINED;
}
- token = njs_parser_peek_token(vm, parser, &offset);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_peek_token(vm, parser, &offset);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token == NJS_TOKEN_COMMA) {
- token = njs_parser_peek_token(vm, parser, &offset);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ if (type == NJS_TOKEN_COMMA) {
+ type = njs_parser_peek_token(vm, parser, &offset);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
return NJS_DECLINED;
}
}
arrow:
- token = njs_parser_peek_token(vm, parser, &offset);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_peek_token(vm, parser, &offset);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
return NJS_DECLINED;
}
- if (parser->lexer->prev_token == NJS_TOKEN_LINE_END) {
+ if (parser->lexer->prev_type == NJS_TOKEN_LINE_END) {
return NJS_DECLINED;
}
- if (njs_slow_path(token != NJS_TOKEN_ARROW)) {
+ if (njs_slow_path(type != NJS_TOKEN_ARROW)) {
return NJS_DECLINED;
}
}
-njs_token_t
+njs_token_type_t
njs_parser_arrow_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
njs_int_t ret;
njs_index_t index;
/* A "this" reservation. */
index += sizeof(njs_value_t);
- if (token == NJS_TOKEN_OPEN_PARENTHESIS) {
- token = njs_parser_lambda_arguments(vm, parser, lambda, index, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (type == NJS_TOKEN_OPEN_PARENTHESIS) {
+ type = njs_parser_lambda_arguments(vm, parser, lambda, index, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
} else {
- token = njs_parser_lambda_argument(vm, parser, index);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_lambda_argument(vm, parser, index);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
lambda->nargs = 1;
}
- if (parser->lexer->prev_token == NJS_TOKEN_LINE_END) {
+ if (parser->lexer->prev_type == NJS_TOKEN_LINE_END) {
return NJS_TOKEN_ILLEGAL;
}
- token = njs_parser_match(vm, parser, token, NJS_TOKEN_ARROW);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_ARROW);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token == NJS_TOKEN_OPEN_BRACE) {
- token = njs_parser_lambda_body(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (type == NJS_TOKEN_OPEN_BRACE) {
+ type = njs_parser_lambda_body(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
} else {
parent = parser->node;
- token = njs_parser_assignment_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_assignment_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
body = njs_parser_return_set(vm, parser, parser->node);
njs_parser_scope_end(vm, parser);
- return token;
+ return type;
}
return 0;
}
- if (node->token >= NJS_TOKEN_ASSIGNMENT
- && node->token <= NJS_TOKEN_LAST_ASSIGNMENT)
+ if (node->token_type >= NJS_TOKEN_ASSIGNMENT
+ && node->token_type <= NJS_TOKEN_LAST_ASSIGNMENT)
{
return 1;
}
- if (node->token == NJS_TOKEN_FUNCTION_CALL
- || node->token == NJS_TOKEN_METHOD_CALL)
+ if (node->token_type == NJS_TOKEN_FUNCTION_CALL
+ || node->token_type == NJS_TOKEN_METHOD_CALL)
{
return 1;
}
}
-njs_token_t
+njs_token_type_t
njs_parser_unexpected_token(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
- if (token != NJS_TOKEN_END) {
+ if (type != NJS_TOKEN_END) {
njs_parser_syntax_error(vm, parser, "Unexpected token \"%V\"",
njs_parser_text(parser));
struct njs_parser_node_s {
- njs_token_t token:16;
+ njs_token_type_t token_type:16;
uint8_t ctor:1;
uint8_t temporary; /* 1 bit */
uint8_t hoist; /* 1 bit */
njs_rbtree_node_t *node2);
njs_int_t njs_parser(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_t *prev);
-njs_token_t njs_parser_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
-njs_token_t njs_parser_assignment_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
-njs_token_t njs_parser_function_expression(njs_vm_t *vm, njs_parser_t *parser);
+njs_token_type_t njs_parser_expression(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type);
+njs_token_type_t njs_parser_assignment_expression(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+njs_token_type_t njs_parser_function_expression(njs_vm_t *vm,
+ njs_parser_t *parser);
njs_int_t njs_parser_match_arrow_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
-njs_token_t njs_parser_arrow_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
-njs_token_t njs_parser_module_lambda(njs_vm_t *vm, njs_parser_t *parser);
-njs_token_t njs_parser_terminal(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
-njs_token_t njs_parser_template_literal(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type);
+njs_token_type_t njs_parser_arrow_expression(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type);
+njs_token_type_t njs_parser_module_lambda(njs_vm_t *vm, njs_parser_t *parser);
+njs_token_type_t njs_parser_terminal(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type);
+njs_token_type_t njs_parser_template_literal(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *parent);
njs_parser_node_t *njs_parser_argument(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *expr, njs_index_t index);
njs_int_t njs_parser_string_create(njs_vm_t *vm, njs_value_t *value);
-njs_token_t njs_parser_function_lambda(njs_vm_t *vm, njs_parser_t *parser,
- njs_function_lambda_t *lambda, njs_token_t token);
-njs_token_t njs_parser_lambda_statements(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
+njs_token_type_t njs_parser_function_lambda(njs_vm_t *vm, njs_parser_t *parser,
+ njs_function_lambda_t *lambda, njs_token_type_t type);
+njs_token_type_t njs_parser_lambda_statements(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
njs_variable_t *njs_variable_resolve(njs_vm_t *vm, njs_parser_node_t *node);
njs_index_t njs_variable_typeof(njs_vm_t *vm, njs_parser_node_t *node);
njs_index_t njs_variable_index(njs_vm_t *vm, njs_parser_node_t *node);
njs_bool_t njs_parser_has_side_effect(njs_parser_node_t *node);
-njs_token_t njs_parser_unexpected_token(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token);
+njs_token_type_t njs_parser_unexpected_token(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type);
u_char *njs_parser_trace_handler(njs_trace_t *trace, njs_trace_data_t *td,
u_char *start);
void njs_parser_lexer_error(njs_vm_t *vm, njs_parser_t *parser,
#define njs_parser_is_lvalue(node) \
- ((node)->token == NJS_TOKEN_NAME || (node)->token == NJS_TOKEN_PROPERTY)
+ ((node)->token_type == NJS_TOKEN_NAME \
+ || (node)->token_type == NJS_TOKEN_PROPERTY)
#define njs_scope_accumulative(vm, scope) \
##__VA_ARGS__)
-njs_inline njs_token_t
+njs_inline njs_token_type_t
njs_parser_token(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
do {
- token = njs_lexer_token(vm, parser->lexer);
- } while (njs_slow_path(token == NJS_TOKEN_LINE_END));
+ type = njs_lexer_token(vm, parser->lexer);
+ } while (njs_slow_path(type == NJS_TOKEN_LINE_END));
- return token;
+ return type;
}
-njs_inline njs_token_t
+njs_inline njs_token_type_t
njs_parser_peek_token(njs_vm_t *vm, njs_parser_t *parser, size_t *offset)
{
- njs_token_t token;
+ njs_token_type_t type;
do {
- token = njs_lexer_peek_token(vm, parser->lexer, (*offset)++);
- } while (njs_slow_path(token == NJS_TOKEN_LINE_END));
+ type = njs_lexer_peek_token(vm, parser->lexer, (*offset)++);
+ } while (njs_slow_path(type == NJS_TOKEN_LINE_END));
- return token;
+ return type;
}
njs_inline njs_parser_node_t *
-njs_parser_node_new(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token)
+njs_parser_node_new(njs_vm_t *vm, njs_parser_t *parser, njs_token_type_t type)
{
njs_parser_node_t *node;
node = njs_mp_zalloc(vm->mem_pool, sizeof(njs_parser_node_t));
if (njs_fast_path(node != NULL)) {
- node->token = token;
+ node->token_type = type;
node->scope = parser->scope;
}
}
-njs_inline njs_token_t
-njs_parser_match(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token,
- njs_token_t match)
+njs_inline njs_token_type_t
+njs_parser_match(njs_vm_t *vm, njs_parser_t *parser, njs_token_type_t type,
+ njs_token_type_t match)
{
- if (njs_fast_path(token == match)) {
+ if (njs_fast_path(type == match)) {
return njs_parser_token(vm, parser);
}
- return njs_parser_unexpected_token(vm, parser, token);
+ return njs_parser_unexpected_token(vm, parser, type);
}
-njs_inline njs_token_t
-njs_parser_match_name(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token,
+njs_inline njs_token_type_t
+njs_parser_match_name(njs_vm_t *vm, njs_parser_t *parser, njs_token_type_t type,
const char *name)
{
size_t len;
len = njs_strlen(name);
text = njs_parser_text(parser);
- if (njs_fast_path(token == NJS_TOKEN_NAME
+ if (njs_fast_path(type == NJS_TOKEN_NAME
&& text->length == len
&& memcmp(text->start, name, len) == 0))
{
return njs_parser_token(vm, parser);
}
- return njs_parser_unexpected_token(vm, parser, token);
+ return njs_parser_unexpected_token(vm, parser, type);
}
typedef struct {
- njs_token_t token;
+ njs_token_type_t type;
njs_vmcode_operation_t operation;
} njs_parser_operation_t;
typedef struct njs_parser_expression_s njs_parser_expression_t;
struct njs_parser_expression_s {
- njs_token_t (*next)(njs_vm_t *,
+ njs_token_type_t (*next)(njs_vm_t *,
njs_parser_t *,
const njs_parser_expression_t *,
- njs_token_t);
+ njs_token_type_t);
const njs_parser_expression_t *expression;
njs_uint_t count;
};
-static njs_token_t njs_parser_any_expression(njs_vm_t *vm,
+static njs_token_type_t njs_parser_any_expression(njs_vm_t *vm,
njs_parser_t *parser, const njs_parser_expression_t *expr,
- njs_token_t token);
-static njs_token_t njs_parser_conditional_expression(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_coalesce_expression(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_binary_expression(njs_vm_t *vm,
+ njs_token_type_t type);
+static njs_token_type_t njs_parser_conditional_expression(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_coalesce_expression(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_binary_expression(njs_vm_t *vm,
njs_parser_t *parser, const njs_parser_expression_t *expr,
- njs_token_t token);
-static njs_token_t njs_parser_exponential_expression(njs_vm_t *vm,
+ njs_token_type_t type);
+static njs_token_type_t njs_parser_exponential_expression(njs_vm_t *vm,
njs_parser_t *parser, const njs_parser_expression_t *expr,
- njs_token_t token);
-static njs_token_t njs_parser_unary_expression(njs_vm_t *vm,
+ njs_token_type_t type);
+static njs_token_type_t njs_parser_unary_expression(njs_vm_t *vm,
njs_parser_t *parser, const njs_parser_expression_t *expr,
- njs_token_t token);
-static njs_token_t njs_parser_inc_dec_expression(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_post_inc_dec_expression(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_call_expression(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_new_expression(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_property_expression(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_property_brackets(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token);
-static njs_token_t njs_parser_call(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token, uint8_t ctor);
-static njs_token_t njs_parser_arguments(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type);
+static njs_token_type_t njs_parser_inc_dec_expression(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_post_inc_dec_expression(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_call_expression(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_new_expression(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_property_expression(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_property_brackets(njs_vm_t *vm,
+ njs_parser_t *parser, njs_token_type_t type);
+static njs_token_type_t njs_parser_call(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t type, uint8_t ctor);
+static njs_token_type_t njs_parser_arguments(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *parent);
};
-njs_token_t
-njs_parser_expression(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token)
+njs_token_type_t
+njs_parser_expression(njs_vm_t *vm, njs_parser_t *parser, njs_token_type_t type)
{
return njs_parser_binary_expression(vm, parser,
- &njs_parser_comma_expression, token);
+ &njs_parser_comma_expression, type);
}
-static njs_token_t
+static njs_token_type_t
njs_parser_any_expression(njs_vm_t *vm, njs_parser_t *parser,
- const njs_parser_expression_t *expr, njs_token_t token)
+ const njs_parser_expression_t *expr, njs_token_type_t type)
{
- return njs_parser_assignment_expression(vm, parser, token);
+ return njs_parser_assignment_expression(vm, parser, type);
}
-njs_token_t
+njs_token_type_t
njs_parser_assignment_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
njs_parser_node_t *node;
njs_vmcode_operation_t operation;
njs_parser_enter(vm, parser);
- token = njs_parser_conditional_expression(vm, parser, token);
+ type = njs_parser_conditional_expression(vm, parser, type);
njs_parser_leave(parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
for ( ;; ) {
- switch (token) {
+ switch (type) {
case NJS_TOKEN_ASSIGNMENT:
njs_thread_log_debug("JS: =");
break;
default:
- return token;
+ return type;
}
if (!njs_parser_is_lvalue(parser->node)) {
- token = parser->node->token;
+ type = parser->node->token_type;
- if (njs_parser_restricted_identifier(token)) {
+ if (njs_parser_restricted_identifier(type)) {
njs_parser_syntax_error(vm, parser, "Identifier \"%s\" "
"is forbidden as left-hand in assignment",
- (token == NJS_TOKEN_EVAL) ? "eval"
- : "arguments");
+ (type == NJS_TOKEN_EVAL) ? "eval"
+ : "arguments");
} else {
njs_parser_ref_error(vm, parser,
return NJS_TOKEN_ILLEGAL;
}
- node = njs_parser_node_new(vm, parser, token);
+ node = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(node == NULL)) {
return NJS_TOKEN_ERROR;
}
node->u.operation = operation;
node->left = parser->node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
njs_parser_enter(vm, parser);
- token = njs_parser_assignment_expression(vm, parser, token);
+ type = njs_parser_assignment_expression(vm, parser, type);
njs_parser_leave(parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
}
-njs_token_t
+njs_token_type_t
njs_parser_conditional_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
njs_parser_node_t *node, *cond;
- token = njs_parser_coalesce_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_coalesce_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
for ( ;; ) {
- if (token != NJS_TOKEN_CONDITIONAL) {
- return token;
+ if (type != NJS_TOKEN_CONDITIONAL) {
+ return type;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
cond = njs_parser_node_new(vm, parser, NJS_TOKEN_CONDITIONAL);
cond->right = node;
- token = njs_parser_assignment_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_assignment_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (njs_slow_path(token != NJS_TOKEN_COLON)) {
+ if (njs_slow_path(type != NJS_TOKEN_COLON)) {
return NJS_TOKEN_ILLEGAL;
}
node->left = parser->node;
node->left->dest = cond;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_assignment_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_assignment_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_coalesce_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
- njs_token_t prev_token, next_token;
+ njs_token_type_t prev_token, next_token;
njs_parser_node_t *node;
- token = njs_parser_binary_expression(vm, parser,
- &njs_parser_logical_or_expression,
- token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_binary_expression(vm, parser,
+ &njs_parser_logical_or_expression,
+ type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
for ( ;; ) {
- if (token != NJS_TOKEN_COALESCE) {
- return token;
+ if (type != NJS_TOKEN_COALESCE) {
+ return type;
}
- prev_token = parser->lexer->prev_token;
+ prev_token = parser->lexer->prev_type;
node = njs_parser_node_new(vm, parser, NJS_TOKEN_COALESCE);
if (njs_slow_path(node == NULL)) {
node->left = parser->node;
node->left->dest = node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- next_token = token;
+ next_token = type;
- token = njs_parser_binary_expression(vm, parser,
- &njs_parser_logical_or_expression,
- token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_binary_expression(vm, parser,
+ &njs_parser_logical_or_expression,
+ type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
parser->node = node;
if (prev_token != NJS_TOKEN_CLOSE_PARENTHESIS
- && njs_slow_path(node->left->token == NJS_TOKEN_LOGICAL_OR
- || node->left->token == NJS_TOKEN_LOGICAL_AND))
+ && njs_slow_path(node->left->token_type == NJS_TOKEN_LOGICAL_OR
+ || node->left->token_type == NJS_TOKEN_LOGICAL_AND))
{
- token = node->left->token;
+ type = node->left->token_type;
goto require_parentheses;
}
if (next_token != NJS_TOKEN_OPEN_PARENTHESIS
- && njs_slow_path(node->right->token == NJS_TOKEN_LOGICAL_OR
- || node->right->token == NJS_TOKEN_LOGICAL_AND))
+ && njs_slow_path(node->right->token_type == NJS_TOKEN_LOGICAL_OR
+ || node->right->token_type == NJS_TOKEN_LOGICAL_AND))
{
- token = node->right->token;
+ type = node->right->token_type;
goto require_parentheses;
}
}
njs_parser_syntax_error(vm, parser, "Either \"??\" or \"%s\" expression "
"must be parenthesized",
- (token == NJS_TOKEN_LOGICAL_OR) ? "||"
- : "&&");
+ (type == NJS_TOKEN_LOGICAL_OR) ? "||"
+ : "&&");
return NJS_TOKEN_ILLEGAL;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_binary_expression(njs_vm_t *vm, njs_parser_t *parser,
- const njs_parser_expression_t *expr, njs_token_t token)
+ const njs_parser_expression_t *expr, njs_token_type_t type)
{
njs_int_t n;
njs_parser_node_t *node;
const njs_parser_operation_t *op;
- token = expr->next(vm, parser, expr->expression, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = expr->next(vm, parser, expr->expression, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
for ( ;; ) {
op = expr->op;
do {
- if (op->token == token) {
+ if (op->type == type) {
goto found;
}
} while (n != 0);
- return token;
+ return type;
found:
- node = njs_parser_node_new(vm, parser, token);
+ node = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(node == NULL)) {
return NJS_TOKEN_ERROR;
}
node->left = parser->node;
node->left->dest = node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = expr->next(vm, parser, expr->expression, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = expr->next(vm, parser, expr->expression, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_exponential_expression(njs_vm_t *vm, njs_parser_t *parser,
- const njs_parser_expression_t *expr, njs_token_t token)
+ const njs_parser_expression_t *expr, njs_token_type_t type)
{
njs_parser_node_t *node;
- token = njs_parser_unary_expression(vm, parser, NULL, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_unary_expression(vm, parser, NULL, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token == NJS_TOKEN_EXPONENTIATION) {
+ if (type == NJS_TOKEN_EXPONENTIATION) {
- node = njs_parser_node_new(vm, parser, token);
+ node = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(node == NULL)) {
return NJS_TOKEN_ERROR;
}
node->left = parser->node;
node->left->dest = node;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
njs_parser_enter(vm, parser);
- token = njs_parser_exponential_expression(vm, parser, NULL, token);
+ type = njs_parser_exponential_expression(vm, parser, NULL, type);
njs_parser_leave(parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node->right = parser->node;
parser->node = node;
}
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_unary_expression(njs_vm_t *vm, njs_parser_t *parser,
- const njs_parser_expression_t *expr, njs_token_t token)
+ const njs_parser_expression_t *expr, njs_token_type_t type)
{
double num;
- njs_token_t next;
+ njs_token_type_t next;
njs_parser_node_t *node;
njs_vmcode_operation_t operation;
- switch (token) {
+ switch (type) {
case NJS_TOKEN_ADDITION:
- token = NJS_TOKEN_UNARY_PLUS;
+ type = NJS_TOKEN_UNARY_PLUS;
operation = NJS_VMCODE_UNARY_PLUS;
break;
case NJS_TOKEN_SUBSTRACTION:
- token = NJS_TOKEN_UNARY_NEGATION;
+ type = NJS_TOKEN_UNARY_NEGATION;
operation = NJS_VMCODE_UNARY_NEGATION;
break;
break;
default:
- return njs_parser_inc_dec_expression(vm, parser, token);
+ return njs_parser_inc_dec_expression(vm, parser, type);
}
next = njs_parser_token(vm, parser);
node = parser->node;
- if (token == NJS_TOKEN_UNARY_PLUS && node->token == NJS_TOKEN_NUMBER) {
+ if (type == NJS_TOKEN_UNARY_PLUS && node->token_type == NJS_TOKEN_NUMBER) {
/* Skip the unary plus of number. */
return next;
}
- if (token == NJS_TOKEN_UNARY_NEGATION && node->token == NJS_TOKEN_NUMBER) {
-
+ if (type == NJS_TOKEN_UNARY_NEGATION
+ && node->token_type == NJS_TOKEN_NUMBER)
+ {
/* Optimization of common negative number. */
num = -njs_number(&node->u.value);
njs_set_number(&node->u.value, num);
return next;
}
- if (token == NJS_TOKEN_DELETE) {
+ if (type == NJS_TOKEN_DELETE) {
- switch (node->token) {
+ switch (node->token_type) {
case NJS_TOKEN_PROPERTY:
- node->token = NJS_TOKEN_PROPERTY_DELETE;
+ node->token_type = NJS_TOKEN_PROPERTY_DELETE;
node->u.operation = NJS_VMCODE_PROPERTY_DELETE;
return next;
}
}
- if (token == NJS_TOKEN_TYPEOF && node->token == NJS_TOKEN_NAME) {
+ if (type == NJS_TOKEN_TYPEOF && node->token_type == NJS_TOKEN_NAME) {
node->u.reference.type = NJS_TYPEOF;
}
- node = njs_parser_node_new(vm, parser, token);
+ node = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(node == NULL)) {
return NJS_TOKEN_ERROR;
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_inc_dec_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
- njs_token_t next;
+ njs_token_type_t next;
njs_parser_node_t *node;
njs_vmcode_operation_t operation;
- switch (token) {
+ switch (type) {
case NJS_TOKEN_INCREMENT:
operation = NJS_VMCODE_INCREMENT;
break;
default:
- return njs_parser_post_inc_dec_expression(vm, parser, token);
+ return njs_parser_post_inc_dec_expression(vm, parser, type);
}
next = njs_parser_token(vm, parser);
return NJS_TOKEN_ILLEGAL;
}
- node = njs_parser_node_new(vm, parser, token);
+ node = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(node == NULL)) {
return NJS_TOKEN_ERROR;
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_post_inc_dec_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
njs_int_t ret;
njs_parser_node_t *node;
njs_vmcode_operation_t operation;
- token = njs_parser_call_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_call_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- switch (token) {
+ switch (type) {
case NJS_TOKEN_INCREMENT:
- token = NJS_TOKEN_POST_INCREMENT;
+ type = NJS_TOKEN_POST_INCREMENT;
operation = NJS_VMCODE_POST_INCREMENT;
break;
case NJS_TOKEN_DECREMENT:
- token = NJS_TOKEN_POST_DECREMENT;
+ type = NJS_TOKEN_POST_DECREMENT;
operation = NJS_VMCODE_POST_DECREMENT;
break;
default:
- return token;
+ return type;
}
/* Automatic semicolon insertion. */
- if (parser->lexer->prev_token == NJS_TOKEN_LINE_END) {
+ if (parser->lexer->prev_type == NJS_TOKEN_LINE_END) {
ret = njs_lexer_rollback(vm, parser->lexer);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_TOKEN_ERROR;
return NJS_TOKEN_ILLEGAL;
}
- node = njs_parser_node_new(vm, parser, token);
+ node = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(node == NULL)) {
return NJS_TOKEN_ERROR;
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_call_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
njs_parser_enter(vm, parser);
- if (token == NJS_TOKEN_NEW) {
- token = njs_parser_new_expression(vm, parser, token);
+ if (type == NJS_TOKEN_NEW) {
+ type = njs_parser_new_expression(vm, parser, type);
} else {
- token = njs_parser_terminal(vm, parser, token);
+ type = njs_parser_terminal(vm, parser, type);
}
njs_parser_leave(parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
for ( ;; ) {
- token = njs_parser_property_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_property_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token != NJS_TOKEN_OPEN_PARENTHESIS && token != NJS_TOKEN_GRAVE) {
- return token;
+ if (type != NJS_TOKEN_OPEN_PARENTHESIS && type != NJS_TOKEN_GRAVE) {
+ return type;
}
njs_parser_enter(vm, parser);
- token = njs_parser_call(vm, parser, token, 0);
+ type = njs_parser_call(vm, parser, type, 0);
njs_parser_leave(parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
}
}
-static njs_token_t
-njs_parser_call(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token,
+static njs_token_type_t
+njs_parser_call(njs_vm_t *vm, njs_parser_t *parser, njs_token_type_t type,
uint8_t ctor)
{
njs_parser_node_t *func, *node;
node = parser->node;
- switch (node->token) {
+ switch (node->token_type) {
case NJS_TOKEN_NAME:
func = node;
- func->token = NJS_TOKEN_FUNCTION_CALL;
+ func->token_type = NJS_TOKEN_FUNCTION_CALL;
break;
func->ctor = ctor;
- switch (token) {
+ switch (type) {
case NJS_TOKEN_OPEN_PARENTHESIS:
- token = njs_parser_arguments(vm, parser, func);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_arguments(vm, parser, func);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
break;
case NJS_TOKEN_GRAVE:
- token = njs_parser_template_literal(vm, parser, func);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_template_literal(vm, parser, func);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
break;
parser->node = func;
- return token;
+ return type;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_new_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
njs_parser_enter(vm, parser);
- if (token == NJS_TOKEN_NEW) {
- token = njs_parser_new_expression(vm, parser, token);
+ if (type == NJS_TOKEN_NEW) {
+ type = njs_parser_new_expression(vm, parser, type);
} else {
- token = njs_parser_terminal(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_terminal(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
njs_parser_leave(parser);
- return token;
+ return type;
}
- token = njs_parser_property_expression(vm, parser, token);
+ type = njs_parser_property_expression(vm, parser, type);
}
njs_parser_leave(parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- return njs_parser_call(vm, parser, token, 1);
+ return njs_parser_call(vm, parser, type, 1);
}
-static njs_token_t
+static njs_token_type_t
njs_parser_property_expression(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
njs_parser_node_t *node, *prop_node;
for ( ;; ) {
- if (token != NJS_TOKEN_DOT
- && token != NJS_TOKEN_OPEN_BRACKET)
+ if (type != NJS_TOKEN_DOT
+ && type != NJS_TOKEN_OPEN_BRACKET)
{
- return token;
+ return type;
}
node = njs_parser_node_new(vm, parser, NJS_TOKEN_PROPERTY);
node->u.operation = NJS_VMCODE_PROPERTY_GET;
node->left = parser->node;
- if (token == NJS_TOKEN_DOT) {
- token = njs_parser_token(vm, parser);
+ if (type == NJS_TOKEN_DOT) {
+ type = njs_parser_token(vm, parser);
- if (token != NJS_TOKEN_NAME && !parser->lexer->keyword) {
+ if (type != NJS_TOKEN_NAME && !parser->lexer->keyword) {
return NJS_TOKEN_ILLEGAL;
}
return NJS_TOKEN_ERROR;
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
} else {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_property_brackets(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_property_brackets(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
prop_node = parser->node;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_property_brackets(njs_vm_t *vm, njs_parser_t *parser,
- njs_token_t token)
+ njs_token_type_t type)
{
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (njs_slow_path(token != NJS_TOKEN_CLOSE_BRACKET)) {
+ if (njs_slow_path(type != NJS_TOKEN_CLOSE_BRACKET)) {
return NJS_TOKEN_ERROR;
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_arguments(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *parent)
{
- njs_token_t token;
njs_index_t index;
+ njs_token_type_t type;
njs_parser_node_t *node;
index = NJS_SCOPE_CALLEE_ARGUMENTS;
do {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token == NJS_TOKEN_CLOSE_PARENTHESIS) {
+ if (type == NJS_TOKEN_CLOSE_PARENTHESIS) {
break;
}
- token = njs_parser_assignment_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_assignment_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
node = njs_parser_argument(vm, parser, parser->node, index);
index += sizeof(njs_value_t);
- } while (token == NJS_TOKEN_COMMA);
+ } while (type == NJS_TOKEN_COMMA);
- if (njs_slow_path(token != NJS_TOKEN_CLOSE_PARENTHESIS)) {
+ if (njs_slow_path(type != NJS_TOKEN_CLOSE_PARENTHESIS)) {
return NJS_TOKEN_ILLEGAL;
}
static njs_parser_node_t *njs_parser_reference(njs_vm_t *vm,
- njs_parser_t *parser, njs_token_t token, njs_str_t *name,
+ njs_parser_t *parser, njs_token_type_t type, njs_str_t *name,
uintptr_t hash, uint32_t token_line);
-static njs_token_t njs_parser_object(njs_vm_t *vm, njs_parser_t *parser,
+static njs_token_type_t njs_parser_object(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *obj);
static njs_int_t njs_parser_object_property(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *parent, njs_parser_node_t *property,
static njs_int_t njs_parser_property_accessor(njs_vm_t *vm,
njs_parser_t *parser, njs_parser_node_t *parent,
njs_parser_node_t *property, njs_parser_node_t *value,
- njs_token_t accessor);
-static njs_token_t njs_parser_array(njs_vm_t *vm, njs_parser_t *parser,
+ njs_token_type_t accessor);
+static njs_token_type_t njs_parser_array(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *array);
static njs_int_t njs_parser_array_item(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *array, njs_parser_node_t *value);
njs_parser_t *parser);
static njs_int_t njs_parser_escape_string_calc_length(njs_vm_t *vm,
njs_parser_t *parser, size_t *out_size, size_t *out_length);
-static njs_token_t njs_parser_escape_string_create(njs_vm_t *vm,
+static njs_token_type_t njs_parser_escape_string_create(njs_vm_t *vm,
njs_parser_t *parser, njs_value_t *value);
-njs_token_t
-njs_parser_terminal(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token)
+njs_token_type_t
+njs_parser_terminal(njs_vm_t *vm, njs_parser_t *parser, njs_token_type_t type)
{
double num;
njs_int_t ret;
njs_parser_node_t *node;
- ret = njs_parser_match_arrow_expression(vm, parser, token);
+ ret = njs_parser_match_arrow_expression(vm, parser, type);
if (ret == NJS_OK) {
- return njs_parser_arrow_expression(vm, parser, token);
+ return njs_parser_arrow_expression(vm, parser, type);
}
- if (token == NJS_TOKEN_OPEN_PARENTHESIS) {
+ if (type == NJS_TOKEN_OPEN_PARENTHESIS) {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- return njs_parser_match(vm, parser, token, NJS_TOKEN_CLOSE_PARENTHESIS);
+ return njs_parser_match(vm, parser, type, NJS_TOKEN_CLOSE_PARENTHESIS);
}
- if (token == NJS_TOKEN_FUNCTION) {
+ if (type == NJS_TOKEN_FUNCTION) {
return njs_parser_function_expression(vm, parser);
}
- switch (token) {
+ switch (type) {
case NJS_TOKEN_OPEN_BRACE:
njs_thread_log_debug("JS: OBJECT");
return NJS_TOKEN_ERROR;
}
- token = njs_regexp_literal(vm, parser, &node->u.value);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_regexp_literal(vm, parser, &node->u.value);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
njs_thread_log_debug("REGEX: '%V'", njs_parser_text(parser));
break;
default:
- node = njs_parser_reference(vm, parser, token, njs_parser_text(parser),
+ node = njs_parser_reference(vm, parser, type, njs_parser_text(parser),
njs_parser_key_hash(parser),
njs_parser_token_line(parser));
if (njs_slow_path(node == NULL)) {
static njs_parser_node_t *
-njs_parser_reference(njs_vm_t *vm, njs_parser_t *parser, njs_token_t token,
+njs_parser_reference(njs_vm_t *vm, njs_parser_t *parser, njs_token_type_t type,
njs_str_t *name, uintptr_t unique_id, uint32_t token_line)
{
njs_int_t ret;
njs_parser_node_t *node;
njs_parser_scope_t *scope;
- node = njs_parser_node_new(vm, parser, token);
+ node = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(node == NULL)) {
return NULL;
}
- switch (token) {
+ switch (type) {
case NJS_TOKEN_NULL:
njs_thread_log_debug("JS: null");
node->index = NJS_INDEX_THIS;
} else {
- node->token = NJS_TOKEN_NON_LOCAL_THIS;
+ node->token_type = NJS_TOKEN_NON_LOCAL_THIS;
node->token_line = token_line;
break;
}
- node->token = NJS_TOKEN_GLOBAL_OBJECT;
+ node->token_type = NJS_TOKEN_GLOBAL_OBJECT;
break;
break;
default:
- (void) njs_parser_unexpected_token(vm, parser, token);
+ (void) njs_parser_unexpected_token(vm, parser, type);
return NULL;
}
}
-static njs_token_t
+static njs_token_type_t
njs_parser_object(njs_vm_t *vm, njs_parser_t *parser, njs_parser_node_t *obj)
{
uintptr_t unique_id;
njs_int_t ret, __proto__;
njs_str_t name;
njs_bool_t computed, proto_init;
- njs_token_t token, accessor;
+ njs_token_type_t type, accessor;
njs_lexer_t *lexer;
njs_parser_node_t *object, *property, *expression;
njs_function_lambda_t *lambda;
object->u.object = obj;
for ( ;; ) {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
accessor = 0;
proto_init = 0;
njs_memzero(&name, sizeof(njs_str_t));
- if (token == NJS_TOKEN_NAME || lexer->keyword) {
+ if (type == NJS_TOKEN_NAME || lexer->keyword) {
name = *njs_parser_text(parser);
unique_id = njs_parser_key_hash(parser);
token_line = njs_parser_token_line(parser);
return NJS_TOKEN_ERROR;
}
- if (token == NJS_TOKEN_NAME && name.length == 3
+ if (type == NJS_TOKEN_NAME && name.length == 3
&& (memcmp(name.start, "get", 3) == 0
|| memcmp(name.start, "set", 3) == 0))
{
accessor = (name.start[0] == 'g') ? NJS_TOKEN_PROPERTY_GETTER
: NJS_TOKEN_PROPERTY_SETTER;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
}
}
- switch (token) {
+ switch (type) {
case NJS_TOKEN_CLOSE_BRACE:
if (accessor) {
goto done;
case NJS_TOKEN_OPEN_BRACKET:
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token == NJS_TOKEN_CLOSE_BRACKET) {
+ if (type == NJS_TOKEN_CLOSE_BRACKET) {
return NJS_TOKEN_ILLEGAL;
}
- token = njs_parser_assignment_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_assignment_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
property = parser->node;
- token = njs_parser_match(vm, parser, token,
- NJS_TOKEN_CLOSE_BRACKET);
+ type = njs_parser_match(vm, parser, type, NJS_TOKEN_CLOSE_BRACKET);
computed = 1;
case NJS_TOKEN_NUMBER:
case NJS_TOKEN_STRING:
case NJS_TOKEN_ESCAPE_STRING:
- token = njs_parser_terminal(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_terminal(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
property = parser->node;
break;
default:
- if (token != NJS_TOKEN_NAME && !lexer->keyword) {
+ if (type != NJS_TOKEN_NAME && !lexer->keyword) {
if (name.length == 0) {
return NJS_TOKEN_ILLEGAL;
}
}
}
- token = njs_parser_token(vm, parser);
+ type = njs_parser_token(vm, parser);
break;
}
expression->u.value.data.u.lambda = lambda;
- token = njs_parser_function_lambda(vm, parser, lambda, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_function_lambda(vm, parser, lambda, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
if (accessor == NJS_TOKEN_PROPERTY_GETTER) {
}
} else {
- switch (token) {
+ switch (type) {
case NJS_TOKEN_COMMA:
case NJS_TOKEN_CLOSE_BRACE:
if (name.length == 0
- || lexer->prev_token == NJS_TOKEN_THIS
- || lexer->prev_token == NJS_TOKEN_GLOBAL_OBJECT)
+ || lexer->prev_type == NJS_TOKEN_THIS
+ || lexer->prev_type == NJS_TOKEN_GLOBAL_OBJECT)
{
return NJS_TOKEN_ILLEGAL;
}
- expression = njs_parser_reference(vm, parser, lexer->prev_token,
+ expression = njs_parser_reference(vm, parser, lexer->prev_type,
&name, unique_id, token_line);
if (njs_slow_path(expression == NULL)) {
return NJS_TOKEN_ERROR;
}
}
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- token = njs_parser_assignment_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_assignment_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
expression = parser->node;
expression->u.value.data.u.lambda = lambda;
- token = njs_parser_function_lambda(vm, parser, lambda, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_function_lambda(vm, parser, lambda, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
break;
}
}
- if (token == NJS_TOKEN_CLOSE_BRACE) {
+ if (type == NJS_TOKEN_CLOSE_BRACE) {
break;
}
- if (njs_slow_path(token != NJS_TOKEN_COMMA)) {
+ if (njs_slow_path(type != NJS_TOKEN_COMMA)) {
return NJS_TOKEN_ILLEGAL;
}
}
njs_parser_node_t *parent, njs_parser_node_t *property,
njs_parser_node_t *value, njs_bool_t proto_init)
{
- njs_token_t token;
+ njs_token_type_t type;
njs_parser_node_t *stmt, *assign, *object, *propref;
object = njs_parser_node_new(vm, parser, NJS_TOKEN_OBJECT_VALUE);
object->u.object = parent;
- token = proto_init ? NJS_TOKEN_PROTO_INIT : NJS_TOKEN_PROPERTY_INIT;
+ type = proto_init ? NJS_TOKEN_PROTO_INIT : NJS_TOKEN_PROPERTY_INIT;
- propref = njs_parser_node_new(vm, parser, token);
+ propref = njs_parser_node_new(vm, parser, type);
if (njs_slow_path(propref == NULL)) {
return NJS_ERROR;
}
static njs_int_t
njs_parser_property_accessor(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *parent, njs_parser_node_t *property,
- njs_parser_node_t *value, njs_token_t accessor)
+ njs_parser_node_t *value, njs_token_type_t accessor)
{
njs_parser_node_t *node, *stmt, *object, *propref;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_array(njs_vm_t *vm, njs_parser_t *parser, njs_parser_node_t *array)
{
- njs_int_t ret;
- njs_token_t token;
+ njs_int_t ret;
+ njs_token_type_t type;
for ( ;; ) {
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
- if (token == NJS_TOKEN_CLOSE_BRACKET) {
+ if (type == NJS_TOKEN_CLOSE_BRACKET) {
break;
}
- if (token == NJS_TOKEN_COMMA) {
+ if (type == NJS_TOKEN_COMMA) {
array->ctor = 1;
array->u.length++;
continue;
}
- token = njs_parser_assignment_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
- return token;
+ type = njs_parser_assignment_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
+ return type;
}
ret = njs_parser_array_item(vm, parser, array, parser->node);
return NJS_TOKEN_ERROR;
}
- if (token == NJS_TOKEN_CLOSE_BRACKET) {
+ if (type == NJS_TOKEN_CLOSE_BRACKET) {
break;
}
- if (njs_slow_path(token != NJS_TOKEN_COMMA)) {
+ if (njs_slow_path(type != NJS_TOKEN_COMMA)) {
return NJS_TOKEN_ILLEGAL;
}
}
}
-njs_token_t
+njs_token_type_t
njs_parser_template_literal(njs_vm_t *vm, njs_parser_t *parser,
njs_parser_node_t *parent)
{
njs_index_t index;
njs_parser_node_t *node, *array;
- tagged_template = (parent->token != NJS_TOKEN_TEMPLATE_LITERAL);
+ tagged_template = (parent->token_type != NJS_TOKEN_TEMPLATE_LITERAL);
index = NJS_SCOPE_CALLEE_ARGUMENTS;
static njs_int_t
njs_parser_template_expression(njs_vm_t *vm, njs_parser_t *parser)
{
- njs_token_t token;
+ njs_token_type_t type;
- token = njs_parser_token(vm, parser);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_token(vm, parser);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
return NJS_ERROR;
}
- token = njs_parser_expression(vm, parser, token);
- if (njs_slow_path(token <= NJS_TOKEN_ILLEGAL)) {
+ type = njs_parser_expression(vm, parser, type);
+ if (njs_slow_path(type <= NJS_TOKEN_ILLEGAL)) {
return NJS_ERROR;
}
- if (token != NJS_TOKEN_CLOSE_BRACE) {
+ if (type != NJS_TOKEN_CLOSE_BRACE) {
njs_parser_syntax_error(vm, parser,
"Missing \"}\" in template expression");
return NJS_ERROR;
}
-static njs_token_t
+static njs_token_type_t
njs_parser_escape_string_create(njs_vm_t *vm, njs_parser_t *parser,
njs_value_t *value)
{
}
-njs_token_t
+njs_token_type_t
njs_regexp_literal(njs_vm_t *vm, njs_parser_t *parser, njs_value_t *value)
{
u_char *p;
njs_int_t njs_regexp_init(njs_vm_t *vm);
njs_int_t njs_regexp_create(njs_vm_t *vm, njs_value_t *value, u_char *start,
size_t length, njs_regexp_flags_t flags);
-njs_token_t njs_regexp_literal(njs_vm_t *vm, njs_parser_t *parser,
+njs_token_type_t njs_regexp_literal(njs_vm_t *vm, njs_parser_t *parser,
njs_value_t *value);
njs_regexp_pattern_t *njs_regexp_pattern_create(njs_vm_t *vm,
u_char *string, size_t length, njs_regexp_flags_t flags);
projects / njs.git / commitdiff