X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=a818cf567270f3f3fa5dcb2214128422a19810bf;hb=e0ea1018388b38e1aa2f504518d5ba347cded35b;hp=5129962c768c216f8a1e16d15e78b4a8e4026d8c;hpb=a985a5cab14ff367bcbde95f613a438e835ead4c;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 5129962..a818cf5 100644 --- a/parser.c +++ b/parser.c @@ -26,14 +26,13 @@ #include "gmqcc.h" #include "lexer.h" -#define PARSER_HT_FIELDS 0 -#define PARSER_HT_GLOBALS 1 /* beginning of locals */ #define PARSER_HT_LOCALS 2 #define PARSER_HT_SIZE 1024 #define TYPEDEF_HT_SIZE 16 +enum parser_pot { POT_PAREN, POT_TERNARY1, POT_TERNARY2 }; typedef struct { lex_file *lex; int tok; @@ -92,7 +91,7 @@ typedef struct { * If we reach a 'comma' operator in a ternary without a paren, * we shall trigger -Wternary-precedence. */ - enum { POT_PAREN, POT_TERNARY1, POT_TERNARY2 } *pot; + enum parser_pot *pot; /* pragma flags */ bool noref; @@ -236,7 +235,7 @@ static char *parser_strdup(const char *str) { if (str && !*str) { /* actually dup empty strings */ - char *out = mem_a(1); + char *out = (char*)mem_a(1); *out = 0; return out; } @@ -298,12 +297,12 @@ static ast_value* parser_const_vector_0(parser_t *parser) static ast_expression* parser_find_field(parser_t *parser, const char *name) { - return util_htget(parser->htfields, name); + return ( ast_expression*)util_htget(parser->htfields, name); } static ast_expression* parser_find_global(parser_t *parser, const char *name) { - return util_htget(parser->htglobals, name); + return (ast_expression*)util_htget(parser->htglobals, name); } static ast_expression* parser_find_param(parser_t *parser, const char *name) @@ -330,7 +329,7 @@ static ast_expression* parser_find_local(parser_t *parser, const char *name, siz *isparam = false; for (i = vec_size(parser->variables); i > upto;) { --i; - if ( (e = util_htgeth(parser->variables[i], name, hash)) ) + if ( (e = (ast_expression*)util_htgeth(parser->variables[i], name, hash)) ) return e; } *isparam = true; @@ -892,23 +891,28 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) parseerror(parser, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2); return false; } - if (OPTS_FLAG(CORRECT_LOGIC)) { - /* non-floats need to be NOTed */ - for (i = 0; i < 2; ++i) { - if (exprs[i]->expression.vtype != TYPE_FLOAT) { - if (type_not_instr[exprs[i]->expression.vtype] == AINSTR_END) { - ast_type_to_string(exprs[0], ty1, sizeof(ty1)); - ast_type_to_string(exprs[1], ty2, sizeof(ty2)); - parseerror(parser, "invalid types for logical operation with -fcorrect-logic: %s and %s", ty1, ty2); - return false; - } - out = (ast_expression*)ast_unary_new(ctx, type_not_instr[exprs[i]->expression.vtype], exprs[i]); - if (!out) - break; - exprs[i] = out; out = NULL; + for (i = 0; i < 2; ++i) { + if (OPTS_FLAG(CORRECT_LOGIC) && exprs[i]->expression.vtype == TYPE_VECTOR) { + out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_V, exprs[i]); + if (!out) break; + out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out); + if (!out) break; + exprs[i] = out; out = NULL; + if (OPTS_FLAG(PERL_LOGIC)) { + /* here we want to keep the right expressions' type */ + break; } - if (OPTS_FLAG(PERL_LOGIC)) + } + else if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && exprs[i]->expression.vtype == TYPE_STRING) { + out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_S, exprs[i]); + if (!out) break; + out = (ast_expression*)ast_unary_new(ctx, INSTR_NOT_F, out); + if (!out) break; + exprs[i] = out; out = NULL; + if (OPTS_FLAG(PERL_LOGIC)) { + /* here we want to keep the right expressions' type */ break; + } } } out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]); @@ -1476,7 +1480,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma val = parser_const_string(parser, parser_tokval(parser), true); wantop = true; if (!val) - return false; + return NULL; vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); DEBUGSHUNTDO(con_out("push string\n")); @@ -1553,7 +1557,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma wantop = true; val = parser_const_float(parser, (parser_token(parser)->constval.f)); if (!val) - return false; + return NULL; vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); DEBUGSHUNTDO(con_out("push %g\n", parser_token(parser)->constval.f)); } @@ -1566,7 +1570,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma wantop = true; val = parser_const_float(parser, (double)(parser_token(parser)->constval.i)); if (!val) - return false; + return NULL; vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); DEBUGSHUNTDO(con_out("push %i\n", parser_token(parser)->constval.i)); } @@ -1579,7 +1583,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma wantop = true; val = parser_const_string(parser, parser_tokval(parser), false); if (!val) - return false; + return NULL; vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); DEBUGSHUNTDO(con_out("push string\n")); } @@ -1592,7 +1596,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma wantop = true; val = parser_const_vector(parser, parser_token(parser)->constval.v); if (!val) - return false; + return NULL; vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val)); DEBUGSHUNTDO(con_out("push '%g %g %g'\n", parser_token(parser)->constval.v.x, @@ -1900,7 +1904,8 @@ static ast_expression* process_condition(parser_t *parser, ast_expression *cond, ast_unary *unary; ast_expression *prev; - if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && cond->expression.vtype == TYPE_STRING) { + if (OPTS_FLAG(FALSE_EMPTY_STRINGS) && cond->expression.vtype == TYPE_STRING) + { prev = cond; cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_S, cond); if (!cond) { @@ -1910,14 +1915,15 @@ static ast_expression* process_condition(parser_t *parser, ast_expression *cond, } ifnot = !ifnot; } - else if (OPTS_FLAG(CORRECT_LOGIC)) { - /* everything must use a NOT_ */ - unary = (ast_unary*)cond; - if (!ast_istype(cond, ast_unary) || unary->op < INSTR_NOT_F || unary->op > INSTR_NOT_FNC) + else if (OPTS_FLAG(CORRECT_LOGIC) && cond->expression.vtype == TYPE_VECTOR) + { + /* vector types need to be cast to true booleans */ + ast_binary *bin = (ast_binary*)cond; + if (!OPTS_FLAG(PERL_LOGIC) || !ast_istype(cond, ast_binary) || !(bin->op == INSTR_AND || bin->op == INSTR_OR)) { - /* use the right NOT_ */ + /* in perl-logic, AND and OR take care of the -fcorrect-logic */ prev = cond; - cond = (ast_expression*)ast_unary_new(ast_ctx(cond), type_not_instr[cond->expression.vtype], cond); + cond = (ast_expression*)ast_unary_new(ast_ctx(cond), INSTR_NOT_V, cond); if (!cond) { ast_unref(prev); parseerror(parser, "internal error: failed to process condition"); @@ -1929,7 +1935,6 @@ static ast_expression* process_condition(parser_t *parser, ast_expression *cond, unary = (ast_unary*)cond; while (ast_istype(cond, ast_unary) && unary->op == INSTR_NOT_F) - /*&& unary->operand->expression.vtype != TYPE_STRING) */ { cond = unary->operand; unary->operand = NULL; @@ -2255,9 +2260,11 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) if (!parse_statement_or_block(parser, &ontrue)) goto onerr; - cond = process_condition(parser, cond, &ifnot); - if (!cond) - goto onerr; + if (cond) { + cond = process_condition(parser, cond, &ifnot); + if (!cond) + goto onerr; + } aloop = ast_loop_new(ctx, initexpr, cond, ifnot, NULL, false, increment, ontrue); *out = (ast_expression*)aloop; @@ -2343,9 +2350,48 @@ static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bo bool had_var = false; bool had_noref = false; bool had_noreturn = false; + bool had_attrib = false; + *cvq = CV_NONE; for (;;) { - if (!strcmp(parser_tokval(parser), "const")) + if (parser->tok == TOKEN_ATTRIBUTE_OPEN) { + had_attrib = true; + /* parse an attribute */ + if (!parser_next(parser)) { + parseerror(parser, "expected attribute after `[[`"); + *cvq = CV_WRONG; + return false; + } + if (!strcmp(parser_tokval(parser), "noreturn")) { + had_noreturn = true; + if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) { + parseerror(parser, "`noreturn` attribute has no parameters, expected `]]`"); + *cvq = CV_WRONG; + return false; + } + } + else if (!strcmp(parser_tokval(parser), "noref")) { + had_noref = true; + if (!parser_next(parser) || parser->tok != TOKEN_ATTRIBUTE_CLOSE) { + parseerror(parser, "`noref` attribute has no parameters, expected `]]`"); + *cvq = CV_WRONG; + return false; + } + } + else + { + /* Skip tokens until we hit a ]] */ + (void)!parsewarning(parser, WARN_UNKNOWN_ATTRIBUTE, "unknown attribute starting with `%s`", parser_tokval(parser)); + while (parser->tok != TOKEN_ATTRIBUTE_CLOSE) { + if (!parser_next(parser)) { + parseerror(parser, "error inside attribute"); + *cvq = CV_WRONG; + return false; + } + } + } + } + else if (!strcmp(parser_tokval(parser), "const")) had_const = true; else if (!strcmp(parser_tokval(parser), "var")) had_var = true; @@ -2353,9 +2399,7 @@ static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bo had_var = true; else if (!strcmp(parser_tokval(parser), "noref")) had_noref = true; - else if (!strcmp(parser_tokval(parser), "noreturn")) - had_noreturn = true; - else if (!had_const && !had_var && !had_noref && !had_noreturn) { + else if (!had_const && !had_var && !had_noref && !had_noreturn && !had_attrib) { return false; } else @@ -2923,7 +2967,7 @@ static bool create_vector_members(ast_value *var, ast_member **me) size_t len = strlen(var->name); for (i = 0; i < 3; ++i) { - char *name = mem_a(len+3); + char *name = (char*)mem_a(len+3); memcpy(name, var->name, len); name[len+0] = '_'; name[len+1] = 'x'+i; @@ -3660,9 +3704,9 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) goto on_error; vec_push(params, param); if (param->expression.vtype >= TYPE_VARIANT) { - char typename[1024]; - ast_type_to_string((ast_expression*)param, typename, sizeof(typename)); - parseerror(parser, "type not supported as part of a parameter list: %s", typename); + char tname[1024]; /* typename is reserved in C++ */ + ast_type_to_string((ast_expression*)param, tname, sizeof(tname)); + parseerror(parser, "type not supported as part of a parameter list: %s", tname); goto on_error; } } @@ -4364,7 +4408,6 @@ skipvar: } else if (parser->tok == '{' || parser->tok == '[') { - size_t i; if (localblock) { parseerror(parser, "cannot declare functions within functions"); break; @@ -4682,7 +4725,7 @@ bool parser_compile_file(const char *filename) return parser_compile(); } -bool parser_compile_string_len(const char *name, const char *str, size_t len) +bool parser_compile_string(const char *name, const char *str, size_t len) { parser->lex = lex_open_string(str, len, name); if (!parser->lex) { @@ -4692,16 +4735,6 @@ bool parser_compile_string_len(const char *name, const char *str, size_t len) return parser_compile(); } -bool parser_compile_string(const char *name, const char *str) -{ - parser->lex = lex_open_string(str, strlen(str), name); - if (!parser->lex) { - con_err("failed to create lexer for string \"%s\"\n", name); - return false; - } - return parser_compile(); -} - void parser_cleanup() { size_t i;