Make the lexer use the correct error-printing mechanism

[xonotic/gmqcc.git] / parser.c

diff --git a/parser.c b/parser.c
index 9db84bbc2de1ebd15d3b96fdf9982c914e3ca005..657a35f0a5338495c382060c3e059f8303d48cdb 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -306,6 +306,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);
 
@@ -333,6 +334,22 @@ 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;
@@ -359,6 +376,7 @@ static ast_value *parser_parse_type(parser_t *parser, int basetype, bool *isfunc
                 }
                 fval->expression.next = (ast_expression*)param;
                 MEM_VECTOR_MOVE(&param->expression, params, &fval->expression, params);
+                fval->expression.variadic = param->expression.variadic;
                 param = fval;
             }
 
@@ -387,6 +405,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:
@@ -952,16 +971,21 @@ 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",
+                    parseerror(parser, "too %s parameters for call to %s: expected %i, got %i", fewmany,
                                fval->name, (int)fun->expression.params_count, paramcount);
                 else
-                    parseerror(parser, "too few parameters for function call: expected %i, got %i",
+                    parseerror(parser, "too %s parameters for function call: expected %i, got %i", fewmany,
                                (int)fun->expression.params_count, paramcount);
                 return false;
             }
@@ -969,11 +993,11 @@ static bool parser_close_call(parser_t *parser, shunt *sy)
             {
                 if (fval)
                     return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
-                                         "too few parameters for call to %s: expected %i, got %i",
+                                         "too %s parameters for call to %s: expected %i, got %i", fewmany,
                                          fval->name, (int)fun->expression.params_count, paramcount);
                 else
                     return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
-                                         "too few parameters for function call: expected %i, got %i",
+                                         "too %s parameters for function call: expected %i, got %i", fewmany,
                                          (int)fun->expression.params_count, paramcount);
             }
         }
@@ -2024,6 +2048,7 @@ static bool parser_variable(parser_t *parser, ast_block *localblock)
 
             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
@@ -2217,6 +2242,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);
@@ -2448,6 +2482,8 @@ nextvar:
                 return false;
             }
             parser->function = old;
+            while (parser->locals_count)
+                parser_pop_local(parser);
 
             if (!block) {
                 ast_value_delete(typevar);
@@ -2473,6 +2509,11 @@ nextvar:
             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");
@@ -2577,6 +2618,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;
             }
 
@@ -2765,27 +2807,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;
@@ -2821,6 +2842,27 @@ 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->functions_count; ++i) {
             if (!ast_function_codegen(parser->functions[i], ir)) {
                 printf("failed to generate function %s\n", parser->functions[i]->name);