From 5d032144777d8020447a06fc77fa5d632572a6a9 Mon Sep 17 00:00:00 2001 From: Dibyendu Majumdar Date: Tue, 20 Aug 2019 22:12:17 +0100 Subject: [PATCH] issue #98 renaming of fields for consistency --- include/ravi_ast.h | 18 ++++++++-------- src/ravi_ast_parse.c | 46 ++++++++++++++++++++-------------------- src/ravi_ast_print.c | 26 +++++++++++------------ src/ravi_ast_typecheck.c | 8 +++---- 4 files changed, 49 insertions(+), 49 deletions(-) diff --git a/include/ravi_ast.h b/include/ravi_ast.h index b203f7e..063261c 100644 --- a/include/ravi_ast.h +++ b/include/ravi_ast.h @@ -143,7 +143,7 @@ struct ast_node { enum ast_node_type type; union { struct { - struct ast_node_list *exprlist; + struct ast_node_list *expr_list; } return_stmt; struct { struct lua_symbol *symbol; @@ -153,17 +153,17 @@ struct ast_node { struct ast_node *label_stmt; /* Initially this will be NULL; set by a separate pass */ } goto_stmt; struct { - struct lua_symbol_list *vars; - struct ast_node_list *exprlist; + struct lua_symbol_list *var_list; + struct ast_node_list *expr_list; } local_stmt; struct { struct ast_node_list *var_expr_list; /* Optional var expressions, comma separated */ - struct ast_node_list *exr_list; /* Comma separated expressions */ + struct ast_node_list *expr_list; /* Comma separated expressions */ } expression_stmt; /* Also covers assignments*/ struct { struct ast_node *name; /* base symbol to be looked up */ struct ast_node_list *selectors; /* Optional */ - struct ast_node *methodname; /* Optional */ + struct ast_node *method_name; /* Optional */ struct ast_node *function_expr; /* Function's AST */ } function_stmt; struct { @@ -187,7 +187,7 @@ struct ast_node { } while_or_repeat_stmt; struct { struct lua_symbol_list *symbols; - struct ast_node_list *expressions; + struct ast_node_list *expr_list; struct block_scope *for_body; struct ast_node_list *for_statement_list; /* statements in this block */ } for_stmt; /* Used for both generic and numeric for loops */ @@ -218,8 +218,8 @@ struct ast_node { struct { struct var_type type; BinOpr binary_op; - struct ast_node *exprleft; - struct ast_node *exprright; + struct ast_node *expr_left; + struct ast_node *expr_right; } binary_expr; struct { struct var_type type; @@ -250,7 +250,7 @@ struct ast_node { } suffixed_expr; struct { struct var_type type; - TString *methodname; /* Optional methodname */ + TString *method_name; /* Optional method_name */ struct ast_node_list *arg_list; /* Call arguments */ } function_call_expr; }; diff --git a/src/ravi_ast_parse.c b/src/ravi_ast_parse.c index 57bacd2..8a0b912 100644 --- a/src/ravi_ast_parse.c +++ b/src/ravi_ast_parse.c @@ -622,7 +622,7 @@ static struct ast_node *parse_function_call(struct parser_state *parser, TString LexState *ls = parser->ls; struct ast_node *call_expr = dmrC_allocator_allocate(&parser->container->ast_node_allocator, 0); call_expr->type = AST_FUNCTION_CALL_EXPR; - call_expr->function_call_expr.methodname = methodname; + call_expr->function_call_expr.method_name = methodname; call_expr->function_call_expr.arg_list = NULL; set_type(call_expr->function_call_expr.type, RAVI_TANY); switch (ls->t.token) { @@ -940,8 +940,8 @@ static struct ast_node *parse_sub_expression(struct parser_state *parser, int li struct ast_node *binexpr = dmrC_allocator_allocate(&parser->container->ast_node_allocator, 0); binexpr->type = AST_BINARY_EXPR; - binexpr->binary_expr.exprleft = expr; - binexpr->binary_expr.exprright = exprright; + binexpr->binary_expr.expr_left = expr; + binexpr->binary_expr.expr_right = exprright; binexpr->binary_expr.binary_op = op; expr = binexpr; // Becomes the left expr for next iteration op = nextop; @@ -1071,11 +1071,11 @@ static void parse_fornum_statement(struct parser_state *parser, struct ast_node add_symbol(parser->container, &stmt->for_stmt.symbols, new_local_symbol(parser, varname, RAVI_TANY, NULL)); checknext(ls, '='); /* get the type of each expression */ - add_ast_node(parser->container, &stmt->for_stmt.expressions, parse_expression(parser)); /* initial value */ + add_ast_node(parser->container, &stmt->for_stmt.expr_list, parse_expression(parser)); /* initial value */ checknext(ls, ','); - add_ast_node(parser->container, &stmt->for_stmt.expressions, parse_expression(parser)); /* limit */ + add_ast_node(parser->container, &stmt->for_stmt.expr_list, parse_expression(parser)); /* limit */ if (testnext(ls, ',')) { - add_ast_node(parser->container, &stmt->for_stmt.expressions, parse_expression(parser)); /* optional step */ + add_ast_node(parser->container, &stmt->for_stmt.expr_list, parse_expression(parser)); /* optional step */ } parse_forbody(parser, stmt, line, 1, 1); } @@ -1093,7 +1093,7 @@ static void parse_for_list(struct parser_state *parser, struct ast_node *stmt, T nvars++; } checknext(ls, TK_IN); - parse_expression_list(parser, &stmt->for_stmt.expressions); + parse_expression_list(parser, &stmt->for_stmt.expr_list); int line = ls->linenumber; parse_forbody(parser, stmt, line, nvars - 3, 0); } @@ -1106,7 +1106,7 @@ static struct ast_node *parse_for_statement(struct parser_state *parser, int lin struct ast_node *stmt = dmrC_allocator_allocate(&parser->container->ast_node_allocator, 0); stmt->type = AST_NONE; stmt->for_stmt.symbols = NULL; - stmt->for_stmt.expressions = NULL; + stmt->for_stmt.expr_list = NULL; stmt->for_stmt.for_body = NULL; stmt->for_stmt.for_statement_list = NULL; new_scope(parser); // For the loop variables @@ -1191,10 +1191,10 @@ static struct ast_node *parse_local_function_statement(struct parser_state *pars end_function(parser); struct ast_node *stmt = dmrC_allocator_allocate(&parser->container->ast_node_allocator, 0); stmt->type = AST_LOCAL_STMT; - stmt->local_stmt.vars = NULL; - stmt->local_stmt.exprlist = NULL; - add_symbol(parser->container, &stmt->local_stmt.vars, symbol); - add_ast_node(parser->container, &stmt->local_stmt.exprlist, function_ast); + stmt->local_stmt.var_list = NULL; + stmt->local_stmt.expr_list = NULL; + add_symbol(parser->container, &stmt->local_stmt.var_list, symbol); + add_ast_node(parser->container, &stmt->local_stmt.expr_list, function_ast); return stmt; } @@ -1203,19 +1203,19 @@ static struct ast_node *parse_local_statement(struct parser_state *parser) { /* stat -> LOCAL NAME {',' NAME} ['=' explist] */ struct ast_node *node = dmrC_allocator_allocate(&parser->container->ast_node_allocator, 0); node->type = AST_LOCAL_STMT; - node->local_stmt.vars = NULL; - node->local_stmt.exprlist = NULL; + node->local_stmt.var_list = NULL; + node->local_stmt.expr_list = NULL; int nvars = 0; do { /* local name : type = value */ struct lua_symbol *symbol = declare_local_variable(parser); - add_symbol(parser->container, &node->local_stmt.vars, symbol); + add_symbol(parser->container, &node->local_stmt.var_list, symbol); nvars++; if (nvars >= MAXVARS) luaX_syntaxerror(ls, "too many local variables"); } while (testnext(ls, ',')); if (testnext(ls, '=')) /* nexps = */ - parse_expression_list(parser, &node->local_stmt.exprlist); + parse_expression_list(parser, &node->local_stmt.expr_list); else { /* nexps = 0; */ ; @@ -1231,14 +1231,14 @@ static struct ast_node *parse_function_name(struct parser_state *parser) { struct ast_node *function_stmt = dmrC_allocator_allocate(&parser->container->ast_node_allocator, 0); function_stmt->type = AST_FUNCTION_STMT; function_stmt->function_stmt.function_expr = NULL; - function_stmt->function_stmt.methodname = NULL; + function_stmt->function_stmt.method_name = NULL; function_stmt->function_stmt.selectors = NULL; function_stmt->function_stmt.name = new_symbol_reference(parser); while (ls->t.token == '.') { add_ast_node(parser->container, &function_stmt->function_stmt.selectors, parse_field_selector(parser)); } if (ls->t.token == ':') { - function_stmt->function_stmt.methodname = parse_field_selector(parser); + function_stmt->function_stmt.method_name = parse_field_selector(parser); } return function_stmt; } @@ -1248,7 +1248,7 @@ static struct ast_node *parse_function_statement(struct parser_state *parser, in /* funcstat -> FUNCTION funcname body */ luaX_next(ls); /* skip FUNCTION */ struct ast_node *function_stmt = parse_function_name(parser); - int ismethod = function_stmt->function_stmt.methodname != NULL; + int ismethod = function_stmt->function_stmt.method_name != NULL; struct ast_node *function_ast = new_function(parser); parse_function_body(parser, function_ast, ismethod, line); end_function(parser); @@ -1261,7 +1261,7 @@ static struct ast_node *parse_expression_statement(struct parser_state *parser) struct ast_node *stmt = dmrC_allocator_allocate(&parser->container->ast_node_allocator, 0); stmt->type = AST_EXPR_STMT; stmt->expression_stmt.var_expr_list = NULL; - stmt->expression_stmt.exr_list = NULL; + stmt->expression_stmt.expr_list = NULL; LexState *ls = parser->ls; /* stat -> func | assignment */ /* Until we see '=' we do not know if this is an assignment or expr list*/ @@ -1276,7 +1276,7 @@ static struct ast_node *parse_expression_statement(struct parser_state *parser) current_list = NULL; parse_expression_list(parser, ¤t_list); } - stmt->expression_stmt.exr_list = current_list; + stmt->expression_stmt.expr_list = current_list; // TODO Check that if not assignment then it is a function call return stmt; } @@ -1286,12 +1286,12 @@ static struct ast_node *parse_return_statement(struct parser_state *parser) { /* stat -> RETURN [explist] [';'] */ struct ast_node *return_stmt = dmrC_allocator_allocate(&parser->container->ast_node_allocator, 0); return_stmt->type = AST_RETURN_STMT; - return_stmt->return_stmt.exprlist = NULL; + return_stmt->return_stmt.expr_list = NULL; if (block_follow(ls, 1) || ls->t.token == ';') /* nret = 0*/; /* return no values */ else { /*nret = */ - parse_expression_list(parser, &return_stmt->return_stmt.exprlist); /* optional return values */ + parse_expression_list(parser, &return_stmt->return_stmt.expr_list); /* optional return values */ } testnext(ls, ';'); /* skip optional semicolon */ return return_stmt; diff --git a/src/ravi_ast_print.c b/src/ravi_ast_print.c index b2195a8..4c2af07 100644 --- a/src/ravi_ast_print.c +++ b/src/ravi_ast_print.c @@ -293,16 +293,16 @@ void raviA_print_ast_node(membuff_t *buf, struct ast_node *node, int level) { break; case AST_RETURN_STMT: { printf_buf(buf, "%preturn\n", level); - print_ast_node_list(buf, node->return_stmt.exprlist, level + 1, ","); + print_ast_node_list(buf, node->return_stmt.expr_list, level + 1, ","); break; } case AST_LOCAL_STMT: { printf_buf(buf, "%plocal\n", level); printf_buf(buf, "%p%c\n", level, "[symbols]"); - print_symbol_list(buf, node->local_stmt.vars, level + 1, ","); - if (node->local_stmt.exprlist) { + print_symbol_list(buf, node->local_stmt.var_list, level + 1, ","); + if (node->local_stmt.expr_list) { printf_buf(buf, "%p%c\n", level, "[expressions]"); - print_ast_node_list(buf, node->local_stmt.exprlist, level + 1, ","); + print_ast_node_list(buf, node->local_stmt.expr_list, level + 1, ","); } break; } @@ -312,9 +312,9 @@ void raviA_print_ast_node(membuff_t *buf, struct ast_node *node, int level) { printf_buf(buf, "%p%c\n", level + 1, "[selectors]"); print_ast_node_list(buf, node->function_stmt.selectors, level + 2, NULL); } - if (node->function_stmt.methodname) { + if (node->function_stmt.method_name) { printf_buf(buf, "%p%c\n", level + 1, "[method name]"); - raviA_print_ast_node(buf, node->function_stmt.methodname, level + 2); + raviA_print_ast_node(buf, node->function_stmt.method_name, level + 2); } printf_buf(buf, "%p=\n", level + 1); raviA_print_ast_node(buf, node->function_stmt.function_expr, level + 2); @@ -342,7 +342,7 @@ void raviA_print_ast_node(membuff_t *buf, struct ast_node *node, int level) { printf_buf(buf, "%p= %c\n", level + 1, "[var list end]"); } printf_buf(buf, "%p%c\n", level + 1, "[expression list start]"); - print_ast_node_list(buf, node->expression_stmt.exr_list, level + 2, ","); + print_ast_node_list(buf, node->expression_stmt.expr_list, level + 2, ","); printf_buf(buf, "%p%c\n", level + 1, "[expression list end]"); printf_buf(buf, "%p%c\n", level, "[expression statement end]"); break; @@ -389,7 +389,7 @@ void raviA_print_ast_node(membuff_t *buf, struct ast_node *node, int level) { printf_buf(buf, "%pfor\n", level); print_symbol_list(buf, node->for_stmt.symbols, level + 1, ","); printf_buf(buf, "%pin\n", level); - print_ast_node_list(buf, node->for_stmt.expressions, level + 1, ","); + print_ast_node_list(buf, node->for_stmt.expr_list, level + 1, ","); printf_buf(buf, "%pdo\n", level); print_statement_list(buf, node->for_stmt.for_statement_list, level + 1); printf_buf(buf, "%pend\n", level); @@ -399,7 +399,7 @@ void raviA_print_ast_node(membuff_t *buf, struct ast_node *node, int level) { printf_buf(buf, "%pfor\n", level); print_symbol_list(buf, node->for_stmt.symbols, level + 1, NULL); printf_buf(buf, "%p=\n", level); - print_ast_node_list(buf, node->for_stmt.expressions, level + 1, ","); + print_ast_node_list(buf, node->for_stmt.expr_list, level + 1, ","); printf_buf(buf, "%pdo\n", level); print_statement_list(buf, node->for_stmt.for_statement_list, level + 1); printf_buf(buf, "%pend\n", level); @@ -420,8 +420,8 @@ void raviA_print_ast_node(membuff_t *buf, struct ast_node *node, int level) { } case AST_FUNCTION_CALL_EXPR: { printf_buf(buf, "%p%c\n", level, "[function call start]"); - if (node->function_call_expr.methodname) { - printf_buf(buf, "%p: %t (\n", level + 1, node->function_call_expr.methodname); + if (node->function_call_expr.method_name) { + printf_buf(buf, "%p: %t (\n", level + 1, node->function_call_expr.method_name); } else { printf_buf(buf, "%p(\n", level + 1); @@ -437,9 +437,9 @@ void raviA_print_ast_node(membuff_t *buf, struct ast_node *node, int level) { } case AST_BINARY_EXPR: { printf_buf(buf, "%p%c %T\n", level, "[binary expr start]", &node->binary_expr.type); - raviA_print_ast_node(buf, node->binary_expr.exprleft, level + 1); + raviA_print_ast_node(buf, node->binary_expr.expr_left, level + 1); printf_buf(buf, "%p%s\n", level, get_binary_opr_str(node->binary_expr.binary_op)); - raviA_print_ast_node(buf, node->binary_expr.exprright, level + 1); + raviA_print_ast_node(buf, node->binary_expr.expr_right, level + 1); printf_buf(buf, "%p%c\n", level, "[binary expr end]"); break; } diff --git a/src/ravi_ast_typecheck.c b/src/ravi_ast_typecheck.c index 043dcbd..69f522f 100644 --- a/src/ravi_ast_typecheck.c +++ b/src/ravi_ast_typecheck.c @@ -72,8 +72,8 @@ static void typecheck_unaryop(struct ast_node *function, struct ast_node *node) /* Type checker - WIP */ static void typecheck_binaryop(struct ast_node *function, struct ast_node *node) { BinOpr op = node->binary_expr.binary_op; - struct ast_node *e1 = node->binary_expr.exprleft; - struct ast_node *e2 = node->binary_expr.exprright; + struct ast_node *e1 = node->binary_expr.expr_left; + struct ast_node *e2 = node->binary_expr.expr_right; typecheck_ast_node(function, e1); typecheck_ast_node(function, e2); switch (op) { @@ -200,7 +200,7 @@ static void typecheck_ast_node(struct ast_node *function, struct ast_node *node) case AST_NONE: break; case AST_RETURN_STMT: { - typecheck_ast_list(function, node->return_stmt.exprlist); + typecheck_ast_list(function, node->return_stmt.expr_list); break; } case AST_LOCAL_STMT: { @@ -247,7 +247,7 @@ static void typecheck_ast_node(struct ast_node *function, struct ast_node *node) break; } case AST_FUNCTION_CALL_EXPR: { - if (node->function_call_expr.methodname) { + if (node->function_call_expr.method_name) { } else { }