int vtype = basetype;
int temptype;
size_t i;
+ bool variadic = false;
MEM_VECTOR_INIT(¶ms, p);
ast_value *param;
ast_value *fld;
bool isfield = false;
- bool dummy;
+ bool isfuncparam = false;
if (!parser_next(parser))
goto on_error;
}
}
+ 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;
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(¶m->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;
var = ast_value_new(ctx, "<unnamed>", vtype);
if (!var)
goto on_error;
+ var->expression.variadic = variadic;
MEM_VECTOR_MOVE(¶ms, p, &var->expression, params);
return var;
on_error:
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;
}
{
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);
}
}
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
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 */
varentry_t vx, vy, vz;
if (!create_vector_members(parser, var, &vx, &vy, &vz)) {
ast_delete(var);
+ ast_value_delete(typevar);
return false;
}
parser_pop_local(parser);
parser_pop_local(parser);
ast_value_delete(var);
+ ast_value_delete(typevar);
return false;
}
}
( 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);
ast_value_delete(var);
+ ast_value_delete(typevar);
return false;
}
}
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 ';'");
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);
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 {
}
}
- 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");
return false;
}
parser->function = old;
+ while (parser->locals_count)
+ parser_pop_local(parser);
if (!block) {
ast_value_delete(typevar);
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);
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);
}
}
}
fval->expression.next = (ast_expression*)var;
MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params);
+ fval->expression.variadic = var->expression.variadic;
var = fval;
}
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;
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);