[qfcc] Support @reference() in the same vein as @pointer

This allows computed reference types, especially tagged references.

tools/qfcc/include/evaluate_type.h

@@ -40,6 +40,7 @@ enum {
 	tf_function,
 	tf_field,
 	tf_pointer,
+	tf_reference,
 	tf_array,
 	tf_base,
 	tf_width,

tools/qfcc/source/evaluate_type.c

@@ -136,6 +136,18 @@ tf_pointer_func (progs_t *pr, void *data)
 	R_UINT (pr) = type->id;
 }
 
+static void
+tf_reference_func (progs_t *pr, void *data)
+{
+	auto ctx = *(typectx_t **) data;
+	unsigned id = P_UINT (pr, 0);
+	unsigned tag = P_UINT (pr, 1);
+	auto type = fetch_type (id, ctx);
+	type = tagged_reference_type (tag, type);
+	type = find_type (type);
+	R_UINT (pr) = type->id;
+}
+
 static void
 tf_array_func (progs_t *pr, void *data)
 {
@@ -277,6 +289,7 @@ static bfunction_t type_functions[] = {
 	TF_FUNC(tf_function),
 	TF_FUNC(tf_field),
 	TF_FUNC(tf_pointer),
+	TF_FUNC(tf_reference),
 	TF_FUNC(tf_array),
 	TF_FUNC(tf_base),
 	TF_FUNC(tf_width),

tools/qfcc/source/expr_type.c

@@ -329,6 +329,19 @@ resolve_pointer (int arg_count, const expr_t **args, rua_ctx_t *ctx)
 	return type;
 }
 
+static const type_t *
+resolve_reference (int arg_count, const expr_t **args, rua_ctx_t *ctx)
+{
+	auto type = resolve_type (args[0], ctx);
+	if (arg_count > 1) {
+		unsigned tag = expr_integral (args[1]);
+		type = tagged_reference_type (tag, type);
+	} else {
+		type = reference_type (type);
+	}
+	return type;
+}
+
 static const type_t *
 resolve_array (int arg_count, const expr_t **args, rua_ctx_t *ctx)
 {
@@ -600,6 +613,21 @@ compute_pointer (int arg_count, const expr_t **args, comp_ctx_t *ctx)
 	return res;
 }
 
+static def_t *
+compute_reference (int arg_count, const expr_t **args, comp_ctx_t *ctx)
+{
+	auto type = compute_type (args[0], ctx);
+	auto res = compute_tmp (ctx);
+	def_t *tag = nullptr;
+	if (arg_count > 1) {
+		tag = compute_val (args[1], ctx);
+	}
+	C (OP_STORE_A_1, ctx->args[0],             nullptr, type);
+	C (OP_STORE_A_1, ctx->args[1],             nullptr, tag);
+	C (OP_CALL_B,    ctx->funcs[tf_reference], nullptr, res);
+	return res;
+}
+
 static def_t *
 compute_base (int arg_count, const expr_t **args, comp_ctx_t *ctx)
 {
@@ -744,6 +772,12 @@ static type_func_t type_funcs[] = {
 		.resolve = resolve_pointer,
 		.compute = compute_pointer,
 	},
+	[QC_REFERENCE] = {
+		.name = "@reference",
+		.check_params = single_type_opt_int,
+		.resolve = resolve_reference,
+		.compute = compute_reference,
+	},
 	[QC_AT_ARRAY] = {
 		.name = "@array",
 		.check_params = single_type_opt_int,
@@ -1115,7 +1149,11 @@ compute_type (const expr_t *arg, comp_ctx_t *ctx)
 		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);
+	if (type_funcs[op].compute) {
+		return type_funcs[op].compute (arg_count, args, ctx);
+	} else {
+		internal_error (arg, "invalid type op: %s", type_funcs[op].name);
+	}
 }
 
 typeeval_t *

tools/qfcc/source/qc-parse.y

@@ -1324,6 +1324,7 @@ type_func
 	: AT_FIELD					{ $$ = QC_AT_FIELD; }
 	| AT_FUNCTION				{ $$ = QC_AT_FUNCTION; }
 	| AT_POINTER				{ $$ = QC_AT_POINTER; }
+	| REFERENCE 				{ $$ = QC_REFERENCE; }
 	| AT_ARRAY					{ $$ = QC_AT_ARRAY; }
 	| AT_BASE					{ $$ = QC_AT_BASE; }
 	| AT_VECTOR					{ $$ = QC_AT_VECTOR; }