From 2f85d6e8bc85b36ed0eff18413076bff8d37b6fe Mon Sep 17 00:00:00 2001 From: Dibyendu Majumdar Date: Sat, 30 Mar 2019 19:28:44 +0000 Subject: [PATCH] issue #98 reformat --- .clang-format | 8 +- src/ravi_ast.c | 418 ++++++++++++++++++++++++++++++++----------------- 2 files changed, 278 insertions(+), 148 deletions(-) diff --git a/.clang-format b/.clang-format index fea6a49..a3e54f0 100644 --- a/.clang-format +++ b/.clang-format @@ -9,11 +9,11 @@ AlignEscapedNewlinesLeft: true AlignOperands: true AlignTrailingComments: true AllowAllParametersOfDeclarationOnNextLine: true -AllowShortBlocksOnASingleLine: true -AllowShortCaseLabelsOnASingleLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false AllowShortFunctionsOnASingleLine: All -AllowShortIfStatementsOnASingleLine: true -AllowShortLoopsOnASingleLine: true +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false AlwaysBreakAfterDefinitionReturnType: None AlwaysBreakBeforeMultilineStrings: true AlwaysBreakTemplateDeclarations: true diff --git a/src/ravi_ast.c b/src/ravi_ast.c index cf1e4c1..85bb7df 100644 --- a/src/ravi_ast.c +++ b/src/ravi_ast.c @@ -50,7 +50,7 @@ struct ast_container { struct allocator block_scope_allocator; struct allocator symbol_allocator; struct ast_node *main_function; - bool killed; /* flag to check if this is already destroyed */ + bool killed; /* flag to check if this is already destroyed */ }; struct ast_node; @@ -93,16 +93,16 @@ struct lua_symbol { struct block_scope *block; } label; struct { - struct lua_symbol *var; /* variable reference */ + struct lua_symbol *var; /* variable reference */ struct ast_node *function; /* Where the upvalue lives */ } upvalue; }; }; struct block_scope { - struct ast_node *function; /* function owning this block - of type FUNCTION_EXPR */ - struct block_scope *parent; /* parent block, may belong to parent function */ - struct lua_symbol_list *symbol_list; /* symbols defined in this block */ + struct ast_node *function; /* function owning this block - of type FUNCTION_EXPR */ + struct block_scope *parent; /* parent block, may belong to parent function */ + struct lua_symbol_list *symbol_list; /* symbols defined in this block */ }; enum ast_node_type { @@ -164,14 +164,14 @@ struct ast_node { struct ast_node *function_expr; /* Function's AST */ } function_stmt; struct { - struct block_scope *scope; /* The do statement only creates a new scope */ + struct block_scope *scope; /* The do statement only creates a new scope */ struct ast_node_list *do_statement_list; /* statements in this block */ } do_stmt; struct { struct ast_node *condition; struct block_scope *test_then_scope; struct ast_node_list *test_then_statement_list; /* statements in this block */ - } test_then_block; /* Used internally in if_stmt, not an independent AST node */ + } test_then_block; /* Used internally in if_stmt, not an independent AST node */ struct { struct ast_node_list *if_condition_list; /* Actually a list of test_then_blocks */ struct block_scope *else_block; @@ -187,7 +187,7 @@ struct ast_node { struct ast_node_list *expressions; 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 */ + } for_stmt; /* Used for both generic and numeric for loops */ struct { struct var_type type; } common_expr; /* To access the type field common to all expr objects */ @@ -222,12 +222,12 @@ struct ast_node { struct var_type type; unsigned int is_vararg : 1; unsigned int is_method : 1; - struct ast_node *parent_function; /* parent function or NULL if main chunk */ - struct block_scope *main_block; /* the function's main block */ + struct ast_node *parent_function; /* parent function or NULL if main chunk */ + struct block_scope *main_block; /* the function's main block */ struct ast_node_list *function_statement_list; /* statements in this block */ struct lua_symbol_list *args; /* arguments, also must be part of the function block's symbol list */ struct ast_node_list *child_functions; /* child functions declared in this function */ - struct lua_symbol_list *upvalues; /* List of upvalues */ + struct lua_symbol_list *upvalues; /* List of upvalues */ } function_expr; /* a literal expression whose result is a value of type function */ struct { struct var_type type; @@ -303,7 +303,8 @@ static int testnext(LexState *ls, int c) { } static void check(LexState *ls, int c) { - if (ls->t.token != c) error_expected(ls, c); + if (ls->t.token != c) + error_expected(ls, c); } static void checknext(LexState *ls, int c) { @@ -325,9 +326,12 @@ static int block_follow(LexState *ls, int withuntil) { case TK_ELSE: case TK_ELSEIF: case TK_END: - case TK_EOS: return 1; - case TK_UNTIL: return withuntil; - default: return 0; + case TK_EOS: + return 1; + case TK_UNTIL: + return withuntil; + default: + return 0; } } @@ -413,17 +417,20 @@ static struct lua_symbol *search_for_variable_in_block(struct block_scope *scope FOR_EACH_PTR_REVERSE(scope->symbol_list, symbol) { switch (symbol->symbol_type) { case SYM_LOCAL: { - if (varname == symbol->var.var_name) { return symbol; } + if (varname == symbol->var.var_name) { + return symbol; + } break; } - default: break; + default: + break; } } END_FOR_EACH_PTR_REVERSE(symbol); return NULL; } -//static struct lua_symbol *search_for_label_in_block(struct block_scope *scope, const TString *name) { +// static struct lua_symbol *search_for_label_in_block(struct block_scope *scope, const TString *name) { // struct lua_symbol *symbol; // // Lookup in reverse order so that we discover the // // most recently added local symbol - as Lua allows same @@ -449,15 +456,18 @@ static struct lua_symbol *search_for_variable_in_block(struct block_scope *scope static struct lua_symbol *search_upvalue_in_function(struct ast_node *function, const TString *name) { struct lua_symbol *symbol; FOR_EACH_PTR(function->function_expr.upvalues, symbol) { - switch (symbol->symbol_type) { - case SYM_UPVALUE: { - assert(symbol->upvalue.var->symbol_type == SYM_LOCAL); - if (name == symbol->upvalue.var->var.var_name) { return symbol; } - break; + switch (symbol->symbol_type) { + case SYM_UPVALUE: { + assert(symbol->upvalue.var->symbol_type == SYM_LOCAL); + if (name == symbol->upvalue.var->var.var_name) { + return symbol; } - default: break; + break; } + default: + break; } + } END_FOR_EACH_PTR(symbol); return NULL; } @@ -468,15 +478,18 @@ static struct lua_symbol *search_upvalue_in_function(struct ast_node *function, static bool add_upvalue_in_function(struct parser_state *parser, struct ast_node *function, struct lua_symbol *sym) { struct lua_symbol *symbol; FOR_EACH_PTR(function->function_expr.upvalues, symbol) { - switch (symbol->symbol_type) { - case SYM_UPVALUE: { - assert(symbol->upvalue.var->symbol_type == SYM_LOCAL); - if (sym == symbol->upvalue.var) { return false; } - break; + switch (symbol->symbol_type) { + case SYM_UPVALUE: { + assert(symbol->upvalue.var->symbol_type == SYM_LOCAL); + if (sym == symbol->upvalue.var) { + return false; } - default: break; + break; } + default: + break; } + } END_FOR_EACH_PTR(symbol); struct lua_symbol *upvalue = dmrC_allocator_allocate(&parser->container->symbol_allocator, 0); upvalue->symbol_type = SYM_UPVALUE; @@ -487,7 +500,6 @@ static bool add_upvalue_in_function(struct parser_state *parser, struct ast_node return true; } - /* Searches for a variable starting from current scope, going up the * scope chain within the current function. If the variable is not found in any scope of the function, then * search the function's upvalue list. Repeat the exercise in parent function until either @@ -501,12 +513,14 @@ static struct lua_symbol *search_for_variable(struct parser_state *parser, const struct ast_node *current_function = current_scope->function; while (current_scope && current_function == current_scope->function) { struct lua_symbol *symbol = search_for_variable_in_block(current_scope, varname); - if (symbol) return symbol; + if (symbol) + return symbol; current_scope = current_scope->parent; } // search upvalues in the function struct lua_symbol *symbol = search_upvalue_in_function(current_function, varname); - if (symbol) return symbol; + if (symbol) + return symbol; // try in parent function } return NULL; @@ -514,7 +528,7 @@ static struct lua_symbol *search_for_variable(struct parser_state *parser, const /* Searches for a label in current function */ -//static struct lua_symbol *search_for_label(struct parser_state *parser, const TString *name) { +// static struct lua_symbol *search_for_label(struct parser_state *parser, const TString *name) { // struct block_scope *current_scope = parser->current_scope; // while (current_scope && current_scope->function == parser->current_function) { // struct lua_symbol *symbol = search_for_label_in_block(current_scope, name); @@ -528,7 +542,8 @@ static struct lua_symbol *search_for_variable(struct parser_state *parser, const * exists as a local or an upvalue. If the symbol is found in a function's upvalue list then there is no need to * check parent functions. */ -static void add_upvalue_in_levels_upto(struct parser_state *parser, struct ast_node *current_function, struct ast_node *var_function, struct lua_symbol *symbol) { +static void add_upvalue_in_levels_upto(struct parser_state *parser, struct ast_node *current_function, + struct ast_node *var_function, struct lua_symbol *symbol) { assert(current_function != var_function); while (current_function && current_function != var_function) { bool added = add_upvalue_in_function(parser, current_function, symbol); @@ -570,7 +585,7 @@ static struct ast_node *new_symbol_reference(struct parser_state *parser) { global->symbol_type = SYM_GLOBAL; global->var.var_name = varname; global->var.block = NULL; - set_type(global->value_type, RAVI_TANY); // Globals are always ANY type + set_type(global->value_type, RAVI_TANY); // Globals are always ANY type // We don't add globals to any scope so that they are // always looked up symbol = global; @@ -701,7 +716,8 @@ static struct ast_node *parse_table_constructor(struct parser_state *parser) { table_expr->table_expr.expr_list = NULL; table_expr->type = AST_TABLE_EXPR; do { - if (ls->t.token == '}') break; + if (ls->t.token == '}') + break; struct ast_node *field_expr = parse_field(parser); add_ast_node(parser->container, &table_expr->table_expr.expr_list, field_expr); } while (testnext(ls, ',') || testnext(ls, ';')); @@ -781,7 +797,7 @@ static struct lua_symbol *declare_local_variable(struct parser_state *parser) { /* default is a userdata type */ tt = RAVI_TUSERDATA; typename = user_defined_type_name(ls, typename); - //str = getstr(typename); + // str = getstr(typename); pusertype = typename; } if (tt == RAVI_TNUMFLT || tt == RAVI_TNUMINT) { @@ -815,7 +831,8 @@ static bool parse_parameter_list(struct parser_state *parser, struct lua_symbol_ is_vararg = true; /* declared vararg */ break; } - default: luaX_syntaxerror(ls, " or '...' expected"); + default: + luaX_syntaxerror(ls, " or '...' expected"); } } while (!is_vararg && testnext(ls, ',')); } @@ -961,7 +978,8 @@ static struct ast_node *parse_suffixed_expression(struct parser_state *parser) { add_ast_node(parser->container, &suffixed_expr->suffixed_expr.suffix_list, suffix); break; } - default: return suffixed_expr; + default: + return suffixed_expr; } } } @@ -1015,7 +1033,8 @@ static struct ast_node *parse_simple_expression(struct parser_state *parser) { expr = NULL; break; } - case '{': { /* constructor */ return parse_table_constructor(parser); + case '{': { /* constructor */ + return parse_table_constructor(parser); } case TK_FUNCTION: { luaX_next(ls); @@ -1033,46 +1052,81 @@ static struct ast_node *parse_simple_expression(struct parser_state *parser) { static UnOpr get_unary_opr(int op) { switch (op) { - case TK_NOT: return OPR_NOT; - case '-': return OPR_MINUS; - case '~': return OPR_BNOT; - case '#': return OPR_LEN; - case TK_TO_INTEGER: return OPR_TO_INTEGER; - case TK_TO_NUMBER: return OPR_TO_NUMBER; - case TK_TO_INTARRAY: return OPR_TO_INTARRAY; - case TK_TO_NUMARRAY: return OPR_TO_NUMARRAY; - case TK_TO_TABLE: return OPR_TO_TABLE; - case TK_TO_STRING: return OPR_TO_STRING; - case TK_TO_CLOSURE: return OPR_TO_CLOSURE; - case '@': return OPR_TO_TYPE; - default: return OPR_NOUNOPR; + case TK_NOT: + return OPR_NOT; + case '-': + return OPR_MINUS; + case '~': + return OPR_BNOT; + case '#': + return OPR_LEN; + case TK_TO_INTEGER: + return OPR_TO_INTEGER; + case TK_TO_NUMBER: + return OPR_TO_NUMBER; + case TK_TO_INTARRAY: + return OPR_TO_INTARRAY; + case TK_TO_NUMARRAY: + return OPR_TO_NUMARRAY; + case TK_TO_TABLE: + return OPR_TO_TABLE; + case TK_TO_STRING: + return OPR_TO_STRING; + case TK_TO_CLOSURE: + return OPR_TO_CLOSURE; + case '@': + return OPR_TO_TYPE; + default: + return OPR_NOUNOPR; } } static BinOpr get_binary_opr(int op) { switch (op) { - case '+': return OPR_ADD; - case '-': return OPR_SUB; - case '*': return OPR_MUL; - case '%': return OPR_MOD; - case '^': return OPR_POW; - case '/': return OPR_DIV; - case TK_IDIV: return OPR_IDIV; - case '&': return OPR_BAND; - case '|': return OPR_BOR; - case '~': return OPR_BXOR; - case TK_SHL: return OPR_SHL; - case TK_SHR: return OPR_SHR; - case TK_CONCAT: return OPR_CONCAT; - case TK_NE: return OPR_NE; - case TK_EQ: return OPR_EQ; - case '<': return OPR_LT; - case TK_LE: return OPR_LE; - case '>': return OPR_GT; - case TK_GE: return OPR_GE; - case TK_AND: return OPR_AND; - case TK_OR: return OPR_OR; - default: return OPR_NOBINOPR; + case '+': + return OPR_ADD; + case '-': + return OPR_SUB; + case '*': + return OPR_MUL; + case '%': + return OPR_MOD; + case '^': + return OPR_POW; + case '/': + return OPR_DIV; + case TK_IDIV: + return OPR_IDIV; + case '&': + return OPR_BAND; + case '|': + return OPR_BOR; + case '~': + return OPR_BXOR; + case TK_SHL: + return OPR_SHL; + case TK_SHR: + return OPR_SHR; + case TK_CONCAT: + return OPR_CONCAT; + case TK_NE: + return OPR_NE; + case TK_EQ: + return OPR_EQ; + case '<': + return OPR_LT; + case TK_LE: + return OPR_LE; + case '>': + return OPR_GT; + case TK_GE: + return OPR_GE; + case TK_AND: + return OPR_AND; + case TK_OR: + return OPR_OR; + default: + return OPR_NOBINOPR; } } @@ -1198,7 +1252,8 @@ static struct ast_node *parse_goto_statment(struct parser_state *parser) { /* skip no-op statements */ static void skip_noop_statements(struct parser_state *parser) { LexState *ls = parser->ls; - while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) parse_statement(parser); + while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) + parse_statement(parser); } static struct ast_node *generate_label(struct parser_state *parser, TString *label) { @@ -1321,7 +1376,8 @@ static struct ast_node *parse_for_statement(struct parser_state *parser, int lin stmt->type = AST_FORIN_STMT; parse_for_list(parser, stmt, varname); break; - default: luaX_syntaxerror(ls, "'=' or 'in' expected"); + default: + luaX_syntaxerror(ls, "'=' or 'in' expected"); } check_match(ls, TK_END, TK_FOR, line); end_scope(parser); @@ -1374,7 +1430,8 @@ static struct ast_node *parse_if_statement(struct parser_state *parser, int line test_then_block = parse_if_cond_then_block(parser); /* ELSEIF cond THEN block */ add_ast_node(parser->container, &stmt->if_stmt.if_condition_list, test_then_block); } - if (testnext(ls, TK_ELSE)) stmt->if_stmt.else_block = parse_block(parser, &stmt->if_stmt.else_statement_list); /* 'else' part */ + if (testnext(ls, TK_ELSE)) + stmt->if_stmt.else_block = parse_block(parser, &stmt->if_stmt.else_statement_list); /* 'else' part */ check_match(ls, TK_END, TK_IF, line); return stmt; } @@ -1407,7 +1464,8 @@ static struct ast_node *parse_local_statement(struct parser_state *parser) { struct lua_symbol *symbol = declare_local_variable(parser); add_symbol(parser->container, &node->local_stmt.vars, symbol); nvars++; - if (nvars >= MAXVARS) luaX_syntaxerror(ls, "too many local variables"); + 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); @@ -1432,7 +1490,9 @@ static struct ast_node *parse_function_name(struct parser_state *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); } + if (ls->t.token == ':') { + function_stmt->function_stmt.methodname = parse_field_selector(parser); + } return function_stmt; } @@ -1509,17 +1569,29 @@ static struct ast_node *parse_statement(struct parser_state *parser) { luaX_next(ls); /* skip ';' */ break; } - case TK_IF: { /* stat -> ifstat */ stmt = parse_if_statement(parser, line); break; + case TK_IF: { /* stat -> ifstat */ + stmt = parse_if_statement(parser, line); + break; } - case TK_WHILE: { /* stat -> whilestat */ stmt = parse_while_statement(parser, line); break; + case TK_WHILE: { /* stat -> whilestat */ + stmt = parse_while_statement(parser, line); + break; } - case TK_DO: { /* stat -> DO block END */ stmt = parse_do_statement(parser, line); break; + case TK_DO: { /* stat -> DO block END */ + stmt = parse_do_statement(parser, line); + break; } - case TK_FOR: { /* stat -> forstat */ stmt = parse_for_statement(parser, line); break; + case TK_FOR: { /* stat -> forstat */ + stmt = parse_for_statement(parser, line); + break; } - case TK_REPEAT: { /* stat -> repeatstat */ stmt = parse_repeat_statement(parser, line); break; + case TK_REPEAT: { /* stat -> repeatstat */ + stmt = parse_repeat_statement(parser, line); + break; } - case TK_FUNCTION: { /* stat -> funcstat */ stmt = parse_function_statement(parser, line); break; + case TK_FUNCTION: { /* stat -> funcstat */ + stmt = parse_function_statement(parser, line); + break; } case TK_LOCAL: { /* stat -> localstat */ luaX_next(ls); /* skip LOCAL */ @@ -1539,10 +1611,14 @@ static struct ast_node *parse_statement(struct parser_state *parser) { stmt = parse_return_statement(parser); break; } - case TK_BREAK: /* stat -> breakstat */ - case TK_GOTO: { /* stat -> 'goto' NAME */ stmt = parse_goto_statment(parser); break; + case TK_BREAK: /* stat -> breakstat */ + case TK_GOTO: { /* stat -> 'goto' NAME */ + stmt = parse_goto_statment(parser); + break; } - default: { /* stat -> func | assignment */ stmt = parse_expression_statement(parser); break; + default: { /* stat -> func | assignment */ + stmt = parse_expression_statement(parser); + break; } } return stmt; @@ -1555,8 +1631,10 @@ static void parse_statement_list(struct parser_state *parser, struct ast_node_li while (!block_follow(ls, 1)) { bool was_return = ls->t.token == TK_RETURN; struct ast_node *stmt = parse_statement(parser); - if (stmt) add_ast_node(parser->container, list, stmt); - if (was_return) break; /* 'return' must be last statement */ + if (stmt) + add_ast_node(parser->container, list, stmt); + if (was_return) + break; /* 'return' must be last statement */ } } @@ -1569,12 +1647,13 @@ static struct block_scope *new_scope(struct parser_state *parser) { struct ast_container *container = parser->container; struct block_scope *scope = dmrC_allocator_allocate(&container->block_scope_allocator, 0); scope->symbol_list = NULL; - //scope->do_statement_list = NULL; + // scope->do_statement_list = NULL; scope->function = parser->current_function; assert(scope->function && scope->function->type == AST_FUNCTION_EXPR); scope->parent = parser->current_scope; parser->current_scope = scope; - if (!parser->current_function->function_expr.main_block) parser->current_function->function_expr.main_block = scope; + if (!parser->current_function->function_expr.main_block) + parser->current_function->function_expr.main_block = scope; return scope; } @@ -1713,8 +1792,7 @@ static void print_ast_node_list(membuff_t *buf, struct ast_node_list *list, int END_FOR_EACH_PTR(node); } -static void print_statement_list(membuff_t *buf, struct ast_node_list *statement_list, - int level) { +static void print_statement_list(membuff_t *buf, struct ast_node_list *statement_list, int level) { print_ast_node_list(buf, statement_list, level + 1, NULL); } @@ -1738,7 +1816,8 @@ static void print_symbol(membuff_t *buf, struct lua_symbol *sym, int level) { get_as_str(sym->upvalue.var->value_type.type_name)); break; } - default: assert(0); + default: + assert(0); } } @@ -1757,46 +1836,81 @@ static void print_symbol_list(membuff_t *buf, struct lua_symbol_list *list, int static const char *get_unary_opr_str(UnOpr op) { switch (op) { - case OPR_NOT: return "not"; - case OPR_MINUS: return "-"; - case OPR_BNOT: return "~"; - case OPR_LEN: return "#"; - case OPR_TO_INTEGER: return "@integer"; - case OPR_TO_NUMBER: return "@number"; - case OPR_TO_INTARRAY: return "@integer[]"; - case OPR_TO_NUMARRAY: return "@number[]"; - case OPR_TO_TABLE: return "@table"; - case OPR_TO_CLOSURE: return "@closure"; - case OPR_TO_STRING: return "@string"; - case OPR_TO_TYPE: return "@"; - default: return ""; + case OPR_NOT: + return "not"; + case OPR_MINUS: + return "-"; + case OPR_BNOT: + return "~"; + case OPR_LEN: + return "#"; + case OPR_TO_INTEGER: + return "@integer"; + case OPR_TO_NUMBER: + return "@number"; + case OPR_TO_INTARRAY: + return "@integer[]"; + case OPR_TO_NUMARRAY: + return "@number[]"; + case OPR_TO_TABLE: + return "@table"; + case OPR_TO_CLOSURE: + return "@closure"; + case OPR_TO_STRING: + return "@string"; + case OPR_TO_TYPE: + return "@"; + default: + return ""; } } static const char *get_binary_opr_str(BinOpr op) { switch (op) { - case OPR_ADD: return "+"; - case OPR_SUB: return "-"; - case OPR_MUL: return "*"; - case OPR_MOD: return "%"; - case OPR_POW: return "^"; - case OPR_DIV: return "/"; - case OPR_IDIV: return "//"; - case OPR_BAND: return "&"; - case OPR_BOR: return "|"; - case OPR_BXOR: return "~"; - case OPR_SHL: return "<<"; - case OPR_SHR: return ">>"; - case OPR_CONCAT: return ".."; - case OPR_NE: return "~="; - case OPR_EQ: return "=="; - case OPR_LT: return "<"; - case OPR_LE: return "<="; - case OPR_GT: return ">"; - case OPR_GE: return ">="; - case OPR_AND: return "and"; - case OPR_OR: return "or"; - default: return ""; + case OPR_ADD: + return "+"; + case OPR_SUB: + return "-"; + case OPR_MUL: + return "*"; + case OPR_MOD: + return "%"; + case OPR_POW: + return "^"; + case OPR_DIV: + return "/"; + case OPR_IDIV: + return "//"; + case OPR_BAND: + return "&"; + case OPR_BOR: + return "|"; + case OPR_BXOR: + return "~"; + case OPR_SHL: + return "<<"; + case OPR_SHR: + return ">>"; + case OPR_CONCAT: + return ".."; + case OPR_NE: + return "~="; + case OPR_EQ: + return "=="; + case OPR_LT: + return "<"; + case OPR_LE: + return "<="; + case OPR_GT: + return ">"; + case OPR_GE: + return ">="; + case OPR_AND: + return "and"; + case OPR_OR: + return "or"; + default: + return ""; } } @@ -1817,7 +1931,8 @@ static void print_ast_node(membuff_t *buf, struct ast_node *node, int level) { printf_buf(buf, "%pend\n", level); break; } - case AST_NONE: break; + case AST_NONE: + break; case AST_RETURN_STMT: { printf_buf(buf, "%preturn\n", level); print_ast_node_list(buf, node->return_stmt.exprlist, level + 1, ","); @@ -1978,12 +2093,23 @@ static void print_ast_node(membuff_t *buf, struct ast_node *node, int level) { case AST_LITERAL_EXPR: { printf_buf(buf, "%p", level); switch (node->literal_expr.type.type_code) { - case RAVI_TNIL: printf_buf(buf, "nil"); break; - case RAVI_TBOOLEAN: printf_buf(buf, "%b", node->literal_expr.u.i); break; - case RAVI_TNUMINT: printf_buf(buf, "%i", node->literal_expr.u.i); break; - case RAVI_TNUMFLT: printf_buf(buf, "%f", node->literal_expr.u.n); break; - case RAVI_TSTRING: printf_buf(buf, "'%t'", node->literal_expr.u.s); break; - default: assert(0); + case RAVI_TNIL: + printf_buf(buf, "nil"); + break; + case RAVI_TBOOLEAN: + printf_buf(buf, "%b", node->literal_expr.u.i); + break; + case RAVI_TNUMINT: + printf_buf(buf, "%i", node->literal_expr.u.i); + break; + case RAVI_TNUMFLT: + printf_buf(buf, "%f", node->literal_expr.u.n); + break; + case RAVI_TSTRING: + printf_buf(buf, "'%t'", node->literal_expr.u.s); + break; + default: + assert(0); } printf_buf(buf, "\n"); break; @@ -2022,7 +2148,9 @@ static void print_ast_node(membuff_t *buf, struct ast_node *node, int level) { printf_buf(buf, "%p} %c\n", level, "[table constructor end]"); break; } - default: printf_buf(buf, "%pUnsupported node type %d\n", level, node->type); assert(0); + default: + printf_buf(buf, "%pUnsupported node type %d\n", level, node->type); + assert(0); } } @@ -2120,7 +2248,8 @@ static int protected_ast_builder(lua_State *L, ZIO *z, const char *name, const c static int build_ast_from_reader(lua_State *L, lua_Reader reader, void *data, const char *chunkname, const char *mode) { ZIO z; int status; - if (!chunkname) chunkname = "?"; + if (!chunkname) + chunkname = "?"; luaZ_init(L, &z, reader, data); status = protected_ast_builder(L, &z, chunkname, mode); return status; @@ -2164,7 +2293,8 @@ typedef struct string_buffer { static const char *string_reader(lua_State *L, void *ud, size_t *size) { String_buffer *ls = (String_buffer *)ud; (void)L; /* not used */ - if (ls->size == 0) return NULL; + if (ls->size == 0) + return NULL; *size = ls->size; ls->size = 0; return ls->s; @@ -2201,8 +2331,8 @@ static int build_ast(lua_State *L) { } if (status != 0) { lua_pushnil(L); - lua_insert(L, -2); /* put before error message */ - return 2; /* return nil plus error message */ + lua_insert(L, -2); /* put before error message */ + return 2; /* return nil plus error message */ } return 1; }