X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=5bdb7e7cbeacb805b1bb66425f579809a6106a0e;hb=5e4b8846d1838c6c0244646b2a3f81c94a647b13;hp=4f5b7be4e9594c40b07f63d13954caedab82d552;hpb=198e35a823325bb2396e0ad9d69dacc0f2298f71;p=xonotic%2Fgmqcc.git

diff --git a/parser.c b/parser.c
index 4f5b7be..5bdb7e7 100644
--- a/parser.c
+++ b/parser.c
@@ -44,7 +44,7 @@ MEM_VEC_FUNCTIONS(parser_t, ast_value*, imm_vector)
 MEM_VEC_FUNCTIONS(parser_t, varentry_t, locals)
 MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions)
 
-static void parser_pop_local(parser_t *parser);
+static bool GMQCC_WARN parser_pop_local(parser_t *parser);
 static bool parser_variable(parser_t *parser, ast_block *localblock);
 static ast_block* parser_parse_block(parser_t *parser, bool warnreturn);
 static bool parser_parse_block_into(parser_t *parser, ast_block *block, bool warnreturn);
@@ -52,7 +52,7 @@ static ast_expression* parser_parse_statement_or_block(parser_t *parser);
 static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomma);
 static ast_expression* parser_expression(parser_t *parser, bool stopatcomma);
 
-void parseerror(parser_t *parser, const char *fmt, ...)
+static void parseerror(parser_t *parser, const char *fmt, ...)
 {
 	va_list ap;
 
@@ -64,7 +64,7 @@ void parseerror(parser_t *parser, const char *fmt, ...)
 }
 
 /* returns true if it counts as an error */
-bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
+static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
 {
 	va_list ap;
 	int lvl = LVL_WARNING;
@@ -84,6 +84,24 @@ bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ..
 	return opts_werror;
 }
 
+static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
+{
+	va_list ap;
+	int lvl = LVL_WARNING;
+
+    if (!OPTS_WARN(warntype))
+        return false;
+
+    if (opts_werror)
+	    lvl = LVL_ERROR;
+
+	va_start(ap, fmt);
+    vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap);
+	va_end(ap);
+
+	return opts_werror;
+}
+
 /**********************************************************************
  * some maths used for constant folding
  */
@@ -129,7 +147,7 @@ bool parser_next(parser_t *parser)
     /* lex_do kills the previous token */
     parser->tok = lex_do(parser->lex);
     if (parser->tok == TOKEN_EOF)
-        return false;
+        return true;
     if (parser->tok >= TOKEN_ERROR) {
         parseerror(parser, "lex error");
         return false;
@@ -306,6 +324,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
     int vtype = basetype;
     int temptype;
     size_t i;
+    bool variadic = false;
 
     MEM_VECTOR_INIT(&params, p);
 
@@ -317,7 +336,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
             ast_value *param;
             ast_value *fld;
             bool isfield = false;
-            bool dummy;
+            bool isfuncparam = false;
 
             if (!parser_next(parser))
                 goto on_error;
@@ -333,12 +352,27 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
                 }
             }
 
+            if (parser->tok == TOKEN_DOTS) {
+                /* variadic args */
+                variadic = true;
+                if (!parser_next(parser))
+                    goto on_error;
+                if (parser->tok != ')') {
+                    parseerror(parser, "`...` must be the last parameter of a variadic function declaration");
+                    goto on_error;
+                }
+                if (opts_standard == COMPILER_QCC) {
+                    if (parsewarning(parser, WARN_EXTENSIONS, "variadic functions are not available in this standard"))
+                        goto on_error;
+                }
+                break;
+            }
+
             temptype = parser_token(parser)->constval.t;
             if (!parser_next(parser))
                 goto on_error;
 
-            param = parser_parse_type(parser, temptype, &dummy);
-            (void)dummy;
+            param = parser_parse_type(parser, temptype, &isfuncparam);
 
             if (!param)
                 goto on_error;
@@ -351,6 +385,19 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
                     goto on_error;
             }
 
+            /* This comes before the isfield part! */
+            if (isfuncparam) {
+                ast_value *fval = ast_value_new(ast_ctx(param), param->name, TYPE_FUNCTION);
+                if (!fval) {
+                    ast_delete(param);
+                    goto on_error;
+                }
+                fval->expression.next = (ast_expression*)param;
+                MEM_VECTOR_MOVE(&param->expression, params, &fval->expression, params);
+                fval->expression.variadic = param->expression.variadic;
+                param = fval;
+            }
+
             if (isfield) {
                 fld = ast_value_new(ctx, param->name, TYPE_FIELD);
                 fld->expression.next = (ast_expression*)param;
@@ -376,6 +423,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
     var = ast_value_new(ctx, "<unnamed>", vtype);
     if (!var)
         goto on_error;
+    var->expression.variadic = variadic;
     MEM_VECTOR_MOVE(&params, p, &var->expression, params);
     return var;
 on_error:
@@ -941,29 +989,42 @@ static bool parser_close_call(parser_t *parser, shunt *sy)
         parseerror(parser, "could not determine function return type");
         return false;
     } else {
-        if (fun->expression.params_count != paramcount) {
+        if (fun->expression.params_count != paramcount &&
+            !(fun->expression.variadic &&
+              fun->expression.params_count < paramcount))
+        {
             ast_value *fval;
+            const char *fewmany = (fun->expression.params_count > paramcount) ? "few" : "many";
+
             fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL);
             if (opts_standard == COMPILER_GMQCC)
             {
                 if (fval)
-                    parseerror(parser, "too few parameters for call to %s: expected %i, got %i",
-                               fval->name, (int)fun->expression.params_count, paramcount);
+                    parseerror(parser, "too %s parameters for call to %s: expected %i, got %i\n"
+                               " -> `%s` has been declared here: %s:%i",
+                               fewmany, fval->name, (int)fun->expression.params_count, (int)paramcount,
+                               fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
                 else
-                    parseerror(parser, "too few parameters for function call: expected %i, got %i",
-                               (int)fun->expression.params_count, paramcount);
+                    parseerror(parser, "too %s parameters for function call: expected %i, got %i\n"
+                               " -> `%s` has been declared here: %s:%i",
+                               fewmany, fval->name, (int)fun->expression.params_count, (int)paramcount,
+                               fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
                 return false;
             }
             else
             {
                 if (fval)
                     return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
-                                         "too few parameters for call to %s: expected %i, got %i",
-                                         fval->name, (int)fun->expression.params_count, paramcount);
+                                         "too %s parameters for call to %s: expected %i, got %i\n"
+                                         " -> `%s` has been declared here: %s:%i",
+                                         fewmany, fval->name, (int)fun->expression.params_count, (int)paramcount,
+                                         fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
                 else
                     return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
-                                         "too few parameters for function call: expected %i, got %i",
-                                         (int)fun->expression.params_count, paramcount);
+                                         "too %s parameters for function call: expected %i, got %i\n"
+                                         " -> `%s` has been declared here: %s:%i",
+                                         fewmany, fval->name, (int)fun->expression.params_count, (int)paramcount,
+                                         fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
             }
         }
     }
@@ -1073,6 +1134,8 @@ static ast_expression* parser_expression_leave(parser_t *parser, bool stopatcomm
                 parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
                 goto onerr;
             }
+            if (ast_istype(var, ast_value))
+                ((ast_value*)var)->uses++;
             if (!shunt_out_add(&sy, syexp(parser_ctx(parser), var))) {
                 parseerror(parser, "out of memory");
                 goto onerr;
@@ -1485,6 +1548,7 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression
     ast_loop *aloop;
     ast_expression *initexpr, *cond, *increment, *ontrue;
     size_t oldblocklocal;
+    bool   retval = true;
 
     lex_ctx ctx = parser_ctx(parser);
 
@@ -1558,6 +1622,13 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression
         increment = parser_expression_leave(parser, false);
         if (!increment)
             goto onerr;
+        if (!ast_istype(increment, ast_store) &&
+            !ast_istype(increment, ast_call) &&
+            !ast_istype(increment, ast_binstore))
+        {
+            if (genwarning(ast_ctx(increment), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
+                goto onerr;
+        }
     }
 
     /* closing paren */
@@ -1579,15 +1650,15 @@ static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression
     *out = (ast_expression*)aloop;
 
     while (parser->locals_count > parser->blocklocal)
-        parser_pop_local(parser);
+        retval = retval && parser_pop_local(parser);
     parser->blocklocal = oldblocklocal;
-    return true;
+    return retval;
 onerr:
     if (initexpr)  ast_delete(initexpr);
     if (cond)      ast_delete(cond);
     if (increment) ast_delete(increment);
     while (parser->locals_count > parser->blocklocal)
-        parser_pop_local(parser);
+        (void)!parser_pop_local(parser);
     parser->blocklocal = oldblocklocal;
     return false;
 }
@@ -1704,19 +1775,35 @@ static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expre
         if (!exp)
             return false;
         *out = exp;
+        if (!ast_istype(exp, ast_store) &&
+            !ast_istype(exp, ast_call) &&
+            !ast_istype(exp, ast_binstore))
+        {
+            if (genwarning(ast_ctx(exp), WARN_EFFECTLESS_STATEMENT, "statement has no effect"))
+                return false;
+        }
         return true;
     }
 }
 
-static void parser_pop_local(parser_t *parser)
+static bool GMQCC_WARN parser_pop_local(parser_t *parser)
 {
+    varentry_t *ve;
     parser->locals_count--;
+
+    ve = &parser->locals[parser->locals_count];
+    if (ast_istype(ve->var, ast_value) && !(((ast_value*)(ve->var))->uses)) {
+        if (parsewarning(parser, WARN_UNUSED_VARIABLE, "unused variable: `%s`", ve->name))
+            return false;
+    }
     mem_d(parser->locals[parser->locals_count].name);
+    return true;
 }
 
 static bool parser_parse_block_into(parser_t *parser, ast_block *block, bool warnreturn)
 {
     size_t oldblocklocal;
+    bool   retval = true;
 
     oldblocklocal = parser->blocklocal;
     parser->blocklocal = parser->locals_count;
@@ -1765,7 +1852,7 @@ static bool parser_parse_block_into(parser_t *parser, ast_block *block, bool war
 
 cleanup:
     while (parser->locals_count > parser->blocklocal)
-        parser_pop_local(parser);
+        retval = retval && parser_pop_local(parser);
     parser->blocklocal = oldblocklocal;
     return !!block;
 }
@@ -1867,6 +1954,8 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
     bool hadproto;
     bool isparam;
 
+    bool retval = true;
+
     int basetype = parser_token(parser)->constval.t;
 
     if (!parser_next(parser)) {
@@ -2006,12 +2095,14 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
             fval = ast_value_new(ctx, var->name, TYPE_FUNCTION);
             if (!fval) {
                 ast_value_delete(var);
+                ast_value_delete(typevar);
                 if (fval) ast_value_delete(fval);
                 return false;
             }
 
             fval->expression.next = (ast_expression*)var;
             MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
+            fval->expression.variadic = var->expression.variadic;
 
             /* we compare the type late here, but it's easier than
              * messing with the parameter-vector etc. earlier
@@ -2023,6 +2114,7 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
                                proto->name,
                                ast_ctx(proto).file, ast_ctx(proto).line);
                     ast_value_delete(fval);
+                    ast_value_delete(typevar);
                     return false;
                 }
                 /* copy over the parameter names */
@@ -2048,6 +2140,7 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
                 varentry_t vx, vy, vz;
                 if (!create_vector_members(parser, var, &vx, &vy, &vz)) {
                     ast_delete(var);
+                    ast_value_delete(typevar);
                     return false;
                 }
 
@@ -2066,11 +2159,12 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
                         !ast_block_collect(localblock, vy.var) ||
                         !ast_block_collect(localblock, vz.var))
                     {
-                        parser_pop_local(parser);
-                        parser_pop_local(parser);
-                        parser_pop_local(parser);
-                        parser_pop_local(parser);
+                        (void)!parser_pop_local(parser);
+                        (void)!parser_pop_local(parser);
+                        (void)!parser_pop_local(parser);
+                        (void)!parser_pop_local(parser);
                         ast_value_delete(var);
+                        ast_value_delete(typevar);
                         return false;
                     }
                 }
@@ -2081,12 +2175,14 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
                      ( localblock && !parser_t_locals_add(parser, varent)) )
                 {
                     ast_value_delete(var);
+                    ast_value_delete(typevar);
                     return false;
                 }
                 if (localblock && !ast_block_locals_add(localblock, var))
                 {
-                    parser_pop_local(parser);
+                    (void)!parser_pop_local(parser);
                     ast_value_delete(var);
+                    ast_value_delete(typevar);
                     return false;
                 }
             }
@@ -2115,6 +2211,16 @@ nextvar:
             continue;
         }
 
+        if (localblock && opts_standard == COMPILER_QCC) {
+            if (parsewarning(parser, WARN_LOCAL_CONSTANTS,
+                             "initializing expression turns variable `%s` into a constant in this standard",
+                             var->name) )
+            {
+                ast_value_delete(typevar);
+                return false;
+            }
+        }
+
         if (parser->tok != '=') {
             ast_value_delete(typevar);
             parseerror(parser, "expected '=' or ';'");
@@ -2190,6 +2296,15 @@ nextvar:
             has_frame_think = false;
             old = parser->function;
 
+            if (var->expression.variadic) {
+                if (parsewarning(parser, WARN_VARIADIC_FUNCTION,
+                                 "variadic function with implementation will not be able to access additional parameters"))
+                {
+                    ast_value_delete(typevar);
+                    return false;
+                }
+            }
+
             if (localblock) {
                 parseerror(parser, "cannot declare functions within functions");
                 ast_value_delete(typevar);
@@ -2277,24 +2392,7 @@ nextvar:
 
                     varent.var = (ast_expression*)thinkfunc;
                     varent.name = util_strdup(thinkfunc->name);
-                    if (thinkfunc->expression.vtype == TYPE_FUNCTION)
-                    {
-                        ast_function *func;
-
-                        func = ast_function_new(parser_ctx(parser), thinkfunc->name, thinkfunc);
-                        if (!func) {
-                            ast_delete(thinkfunc);
-                            ast_unref(framenum);
-                            parseerror(parser, "failed to create function for implicit prototype for `%s`",
-                                       thinkfunc->name);
-                            ast_value_delete(typevar);
-                            return false;
-                        }
-                        (void)!parser_t_functions_add(parser, func);
-                        (void)!parser_t_globals_add(parser, varent);
-                    }
-                    else
-                        (void)!parser_t_globals_add(parser, varent);
+                    (void)!parser_t_globals_add(parser, varent);
                     nextthink = (ast_expression*)thinkfunc;
 
                 } else {
@@ -2307,7 +2405,7 @@ nextvar:
                     }
                 }
 
-                if (!ast_istype(nextthink, ast_value) || !( (ast_value*)nextthink )->isconst) {
+                if (!ast_istype(nextthink, ast_value)) {
                     ast_unref(nextthink);
                     ast_unref(framenum);
                     parseerror(parser, "think-function in [frame,think] notation must be a constant");
@@ -2403,9 +2501,9 @@ nextvar:
                     !ast_block_collect(block, vy.var) ||
                     !ast_block_collect(block, vz.var) )
                 {
-                    parser_pop_local(parser);
-                    parser_pop_local(parser);
-                    parser_pop_local(parser);
+                    (void)!parser_pop_local(parser);
+                    (void)!parser_pop_local(parser);
+                    (void)!parser_pop_local(parser);
                     ast_block_delete(block);
                     ast_value_delete(typevar);
                     return false;
@@ -2438,6 +2536,8 @@ nextvar:
                 return false;
             }
             parser->function = old;
+            while (parser->locals_count)
+                retval = retval && parser_pop_local(parser);
 
             if (!block) {
                 ast_value_delete(typevar);
@@ -2450,25 +2550,34 @@ nextvar:
                 return false;
             }
 
-            if (parser->tok == ';')
+            if (parser->tok == ';') {
+                ast_value_delete(typevar);
                 return parser_next(parser) || parser->tok == TOKEN_EOF;
+            }
             else if (opts_standard == COMPILER_QCC)
                 parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
             ast_value_delete(typevar);
-            return true;
+            return retval;
         } else {
             ast_expression *cexp;
             ast_value      *cval;
 
             cexp = parser_expression_leave(parser, true);
+            if (!cexp) {
+                ast_value_delete(typevar);
+                return false;
+            }
+
             cval = (ast_value*)cexp;
             if (!ast_istype(cval, ast_value) || !cval->isconst)
                 parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
             else
             {
                 var->isconst = true;
-                memcpy(&var->constval, &cval->constval, sizeof(var->constval));
-                memset(&cval->constval, 0, sizeof(cval->constval));
+                if (cval->expression.vtype == TYPE_STRING)
+                    var->constval.vstring = parser_strdup(cval->constval.vstring);
+                else
+                    memcpy(&var->constval, &cval->constval, sizeof(var->constval));
                 ast_unref(cval);
             }
         }
@@ -2563,6 +2672,7 @@ static bool parser_do(parser_t *parser)
                 }
                 fval->expression.next = (ast_expression*)var;
                 MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
+                fval->expression.variadic = var->expression.variadic;
                 var = fval;
             }
 
@@ -2685,12 +2795,17 @@ bool parser_compile(const char *filename)
                 if (parser->tok == TOKEN_EOF)
                     parseerror(parser, "unexpected eof");
                 else if (!parser->errors)
-                    parseerror(parser, "parse error\n");
+                    parseerror(parser, "parse error");
                 lex_close(parser->lex);
                 parser->lex = NULL;
                 return false;
             }
         }
+    } else {
+        parseerror(parser, "parse error");
+        lex_close(parser->lex);
+        parser->lex = NULL;
+        return false;
     }
 
     lex_close(parser->lex);
@@ -2737,6 +2852,7 @@ bool parser_finish(const char *output)
 {
     size_t i;
     ir_builder *ir;
+    bool retval = true;
 
     if (!parser->errors)
     {
@@ -2746,27 +2862,6 @@ bool parser_finish(const char *output)
             return false;
         }
 
-        for (i = 0; i < parser->imm_float_count; ++i) {
-            if (!ast_global_codegen(parser->imm_float[i], ir)) {
-                printf("failed to generate global %s\n", parser->imm_float[i]->name);
-                ir_builder_delete(ir);
-                return false;
-            }
-        }
-        for (i = 0; i < parser->imm_string_count; ++i) {
-            if (!ast_global_codegen(parser->imm_string[i], ir)) {
-                printf("failed to generate global %s\n", parser->imm_string[i]->name);
-                ir_builder_delete(ir);
-                return false;
-            }
-        }
-        for (i = 0; i < parser->imm_vector_count; ++i) {
-            if (!ast_global_codegen(parser->imm_vector[i], ir)) {
-                printf("failed to generate global %s\n", parser->imm_vector[i]->name);
-                ir_builder_delete(ir);
-                return false;
-            }
-        }
         for (i = 0; i < parser->fields_count; ++i) {
             ast_value *field;
             bool isconst;
@@ -2794,14 +2889,41 @@ bool parser_finish(const char *output)
             }
         }
         for (i = 0; i < parser->globals_count; ++i) {
+            ast_value *asvalue;
             if (!ast_istype(parser->globals[i].var, ast_value))
                 continue;
-            if (!ast_global_codegen((ast_value*)(parser->globals[i].var), ir)) {
+            asvalue = (ast_value*)(parser->globals[i].var);
+            if (!asvalue->uses && !asvalue->isconst && asvalue->expression.vtype != TYPE_FUNCTION) {
+                retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE,
+                                               "unused global: `%s`", asvalue->name);
+            }
+            if (!ast_global_codegen(asvalue, ir)) {
                 printf("failed to generate global %s\n", parser->globals[i].name);
                 ir_builder_delete(ir);
                 return false;
             }
         }
+        for (i = 0; i < parser->imm_float_count; ++i) {
+            if (!ast_global_codegen(parser->imm_float[i], ir)) {
+                printf("failed to generate global %s\n", parser->imm_float[i]->name);
+                ir_builder_delete(ir);
+                return false;
+            }
+        }
+        for (i = 0; i < parser->imm_string_count; ++i) {
+            if (!ast_global_codegen(parser->imm_string[i], ir)) {
+                printf("failed to generate global %s\n", parser->imm_string[i]->name);
+                ir_builder_delete(ir);
+                return false;
+            }
+        }
+        for (i = 0; i < parser->imm_vector_count; ++i) {
+            if (!ast_global_codegen(parser->imm_vector[i], ir)) {
+                printf("failed to generate global %s\n", parser->imm_vector[i]->name);
+                ir_builder_delete(ir);
+                return false;
+            }
+        }
         for (i = 0; i < parser->functions_count; ++i) {
             if (!ast_function_codegen(parser->functions[i], ir)) {
                 printf("failed to generate function %s\n", parser->functions[i]->name);
@@ -2815,17 +2937,19 @@ bool parser_finish(const char *output)
             }
         }
 
-        if (opts_dump)
-            ir_builder_dump(ir, printf);
+        if (retval) {
+            if (opts_dump)
+                ir_builder_dump(ir, printf);
 
-        if (!ir_builder_generate(ir, output)) {
-            printf("*** failed to generate output file\n");
-            ir_builder_delete(ir);
-            return false;
+            if (!ir_builder_generate(ir, output)) {
+                printf("*** failed to generate output file\n");
+                ir_builder_delete(ir);
+                return false;
+            }
         }
 
         ir_builder_delete(ir);
-        return true;
+        return retval;
     }
 
     printf("*** there were compile errors\n");