qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-04-06 01:11:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

[qfcc] Process and check for errors in compute_type

Browse source 
It turned out error checking on type functions was broken by generic
functions because type_function wasn't being called. The rest of the
changes were for error recovery.
This commit is contained in:
Bill Currie 2025-01-21 19:47:23 +09:00
parent b9c3f427b7
commit cdfc6bc704
4 changed files with 49 additions and 12 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
tools/qfcc/include/evaluate_type.h
View file

@ -73,7 +73,7 @@ typedef struct gentype_s gentype_t;
typedef struct rua_ctx_s rua_ctx_t;
typeeval_t *build_type_function (const expr_t *te, int num_types,
gentype_t *types);
gentype_t *types, rua_ctx_t *rua_ctx);
const type_t *evaluate_type (const typeeval_t *typeeval, int num_types,
const type_t **types, const expr_t *expr,
rua_ctx_t *rua_ctx);

3
tools/qfcc/source/evaluate_type.c
View file

@ -338,6 +338,9 @@ const type_t *
evaluate_type (const typeeval_t *typeeval, int num_types, const type_t **types,
const expr_t *expr, rua_ctx_t *rua_ctx)
{
if (!typeeval->code) {
return &type_void;
}
typectx_t ctx = {
.types = types,
.num_types = num_types,

48
tools/qfcc/source/expr_type.c
View file

@ -57,6 +57,7 @@ typedef struct {
sys_jmpbuf jmpbuf;
def_t *args[3];
def_t *funcs[tf_num_functions];
rua_ctx_t *rua_ctx;
} comp_ctx_t;
typedef struct {
@ -76,11 +77,24 @@ static type_func_t type_funcs[];
static bool
check_type (const expr_t *arg)
{
if ((arg->type != ex_symbol || arg->symbol->sy_type != sy_type_param)
&& arg->type != ex_type) {
return false;
if (arg->type == ex_symbol && arg->symbol->sy_type == sy_type_param) {
return true;
}
return true;
if (arg->type == ex_symbol && arg->symbol->sy_type == sy_type) {
return true;
}
if (arg->type == ex_type) {
return true;
}
if (arg->type == ex_list) {
for (auto le = arg->list.head; le; le = le->next) {
if (!check_type (le->expr)) {
return false;
}
}
return true;
}
return false;
}
static bool
@ -1074,11 +1088,29 @@ compute_type (const expr_t *arg, comp_ctx_t *ctx)
int arg_count = list_count (&arg->typ.params->list);
const expr_t *args[arg_count];
list_scatter (&arg->typ.params->list, args);
bool fail = false;
for (int i = 0; i < arg_count; i++) {
if (((args[i]->type == ex_expr || args[i]->type == ex_uexpr)
&& !args[i]->expr.type)
|| (args[i]->type == ex_field && !args[i]->field.type)) {
args[i] = expr_process (args[i], ctx->rua_ctx);
fail |= is_error (args[i]);
}
}
if (fail) {
Sys_longjmp (ctx->jmpbuf);
}
const char *msg = type_funcs[op].check_params (arg_count, args);
if (msg) {
error (arg->typ.params, "%s for %s", msg, type_funcs[op].name);
Sys_longjmp (ctx->jmpbuf);
}
return type_funcs[op].compute (arg_count, args, ctx);
}
typeeval_t *
build_type_function (const expr_t *te, int num_types, gentype_t *types)
build_type_function (const expr_t *te, int num_types, gentype_t *types,
rua_ctx_t *rua_ctx)
{
auto code = codespace_new ();
auto data = defspace_new (ds_backed);
@ -1089,6 +1121,7 @@ build_type_function (const expr_t *te, int num_types, gentype_t *types)
.code = code,
.data = data,
.strings = strings,
.rua_ctx = rua_ctx,
};
compute_tmp (ctx);
for (int i = 0; i < 3; i++) {
@ -1100,11 +1133,10 @@ build_type_function (const expr_t *te, int num_types, gentype_t *types)
}
C (OP_NOP, nullptr, nullptr, nullptr);
def_t *res = nullptr;
typeeval_t *func = nullptr;
typeeval_t *func = malloc (sizeof (typeeval_t));
if (!Sys_setjmp (ctx->jmpbuf)) {
res = compute_type (te, ctx);
C (OP_RETURN, res, nullptr, 0);
func = malloc (sizeof (typeeval_t));
*func = (typeeval_t) {
.code = code->code,
.data = data->data,
@ -1113,6 +1145,8 @@ build_type_function (const expr_t *te, int num_types, gentype_t *types)
.data_size = data->size,
.string_size = strings->size,
};
} else {
*func = (typeeval_t) { };
}
code->code = nullptr;
data->data = nullptr;

8
tools/qfcc/source/function.c
View file

@ -294,13 +294,13 @@ find_gentype (const expr_t *expr, genfunc_t *genfunc)
}
static genparam_t
make_genparam (param_t *param, genfunc_t *genfunc)
make_genparam (param_t *param, genfunc_t *genfunc, rua_ctx_t *ctx)
{
int gentype = find_gentype (param->type_expr, genfunc);
typeeval_t *compute = nullptr;
if (gentype < 0 && param->type_expr) {
compute = build_type_function (param->type_expr,
genfunc->num_types, genfunc->types);
genfunc->num_types, genfunc->types, ctx);
}
genparam_t genparam = {
.name = save_string (param->name),
@ -390,9 +390,9 @@ parse_generic_function (const char *name, specifier_t spec, rua_ctx_t *ctx)
num_params = 0;
// skip return type so it can be done last to support complex expressions
for (auto p = ret_param.next; p; p = p->next) {
genfunc->params[num_params++] = make_genparam (p, genfunc);
genfunc->params[num_params++] = make_genparam (p, genfunc, ctx);
}
*genfunc->ret_type = make_genparam (&ret_param, genfunc);
*genfunc->ret_type = make_genparam (&ret_param, genfunc, ctx);
return genfunc;
}