qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-02-25 05:01:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

[qfcc] Rename type attributes to properties

Browse source 
I had a feeling that attribute was wrong at the time, then I got
reminded of properties.
This commit is contained in:
Bill Currie 2025-01-16 17:31:04 +09:00
parent 6ff1704246
commit e0e168620f
11 changed files with 69 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -36,7 +36,7 @@
enum {
tf_null,
tf_eval,
tf_attribute,
tf_property,
tf_function,
tf_field,
tf_pointer,

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

@ -331,7 +331,7 @@ typedef struct {
typedef struct {
int op; ///< type "function"
const expr_t *params; ///< if dynamic
const attribute_t *attrib;
const attribute_t *property;
const type_t *type;
const symbol_t *sym;
} ex_type_t;

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

@ -103,7 +103,7 @@ typedef struct type_s {
int allocated;
struct protocollist_s *protos;
const char *encoding; ///< Objective-QC encoding
const expr_t *(*attrib) (const type_t *type, const attribute_t *attr);
const expr_t *(*property) (const type_t *type, const attribute_t *attr);
} type_t;
#define EV_TYPE(type) extern type_t type_##type;

6
tools/qfcc/source/algebra.c
View file

@ -343,7 +343,7 @@ is_algebra (const type_t *type)
}
static const expr_t *
algebra_attrib (const type_t *type, const attribute_t *attr)
algebra_property (const type_t *type, const attribute_t *attr)
{
type = algebra_subtype (type, attr);
return new_type_expr (type);
@ -419,7 +419,7 @@ algebra_type (const type_t *type, const expr_t *params)
t->type = ev_invalid;
t->alignment = (dim > 1 ? 4 : 2) * type->alignment;
t->algebra = algebra;
t->attrib = algebra_attrib;
t->property = algebra_property;
algebra->algebra_type = t;
return find_type (t);
}
@ -540,7 +540,7 @@ algebra_mvec_type (algebra_t *algebra, pr_uint_t group_mask)
.algebra = (algebra_t *) mvec,
.freeable = true,
.allocated = true,
.attrib = algebra_attrib,
.property = algebra_property,
};
chain_type (type);
if (!(group_mask & (group_mask - 1))) {

14
tools/qfcc/source/dot_expr.c
View file

@ -107,7 +107,7 @@ get_op_string (int op)
case QC_REVERSE: return "@reverse";
case QC_DUAL: return "@dual";
case QC_UNDUAL: return "@undual";
case QC_ATTRIBUTE: return ".attribute";
case QC_ATTRIBUTE: return ".property";
case QC_AT_FUNCTION:return "@function";
case QC_AT_FIELD: return "@field";
case QC_AT_POINTER: return "@pointer";
@ -349,14 +349,14 @@ print_type_expr (dstring_t *dstr, const expr_t *e, int level, int id,
if (!str) {
str = type_get_encoding (e->typ.type);
}
} else if (e->typ.attrib) {
auto attrib = e->typ.attrib;
if (attrib->params) {
_print_expr (dstr, attrib->params, level + 1, id, nullptr);
} else if (e->typ.property) {
auto property = e->typ.property;
if (property->params) {
_print_expr (dstr, property->params, level + 1, id, nullptr);
dasprintf (dstr, "%*se_%p -> e_%p;\n", indent, "", e,
attrib->params);
property->params);
}
str = attrib->name;
str = property->name;
} else if (e->typ.sym) {
str = e->typ.sym->name;
}

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

@ -76,29 +76,29 @@ fetch_type (unsigned id, typectx_t *ctx)
}
static void
tf_attribute_func (progs_t *pr, void *data)
tf_property_func (progs_t *pr, void *data)
{
auto ctx = *(typectx_t **) data;
unsigned id = P_UINT (pr, 0);
auto type = fetch_type (id, ctx);
if (!type->attrib) {
if (!type->property) {
error (ctx->expr, "type doesn't support attributes");
Sys_longjmp (ctx->jmpbuf);
}
auto attr_params = &P_STRUCT (pr, pr_int_t, 1);
auto name = PR_GetString (pr, attr_params[0]);
int count = attr_params[1];
attribute_t *attrib = nullptr;
attribute_t *property = nullptr;
if (count) {
const expr_t *param_exprs[count] = {};
internal_error (ctx->expr, "not implemented");
auto params = new_list_expr (nullptr);
list_gather (&params->list, param_exprs, count);
attrib = new_attribute (name, params);
property = new_attribute (name, params);
} else {
attrib = new_attribute (name, nullptr);
property = new_attribute (name, nullptr);
}
auto e = type->attrib (type, attrib);
auto e = type->property (type, property);
if (is_error (e)) {
Sys_longjmp (ctx->jmpbuf);
}
@ -272,7 +272,7 @@ static typectx_t *type_genfunc;
static bfunction_t type_functions[] = {
{}, // null function
[tf_eval] = { .first_statement = 1 },
TF_FUNC(tf_attribute),
TF_FUNC(tf_property),
TF_FUNC(tf_function),
TF_FUNC(tf_field),
TF_FUNC(tf_pointer),

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

@ -84,9 +84,9 @@ check_type (const expr_t *arg)
}
static bool
check_attribute (const expr_t *arg)
check_property (const expr_t *arg)
{
if (arg->type != ex_type && !arg->typ.attrib) {
if (arg->type != ex_type && !arg->typ.property) {
return false;
}
return true;
@ -132,7 +132,7 @@ single_type (int arg_count, const expr_t **args)
}
static const char *
single_type_attribute (int arg_count, const expr_t **args)
single_type_property (int arg_count, const expr_t **args)
{
if (arg_count < 1) {
return "too few arguments";
@ -143,8 +143,8 @@ single_type_attribute (int arg_count, const expr_t **args)
if (!check_type (args[0])) {
return "first parameter must be a type";
}
if (!check_attribute (args[1])) {
return "second parameter must be a type attribute";
if (!check_property (args[1])) {
return "second parameter must be a type property";
}
return nullptr;
}
@ -189,16 +189,16 @@ single_type_opt_int_pair (int arg_count, const expr_t **args)
}
static const expr_t *
evaluate_attribute (int arg_count, const expr_t **args, rua_ctx_t *ctx)
evaluate_property (int arg_count, const expr_t **args, rua_ctx_t *ctx)
{
auto type = resolve_type (args[0], ctx);
if (!type) {
return error (args[0], "could not resolve type");
}
if (!type->attrib) {
return error (args[0], "type doesn't support attributes");
if (!type->property) {
return error (args[0], "type doesn't support properties");
} else {
auto e = type->attrib (type, args[1]->typ.attrib);
auto e = type->property (type, args[1]->typ.property);
if (!is_error (e)) {
e = eval_type (e, ctx);
}
@ -249,14 +249,14 @@ evaluate_int_op (int arg_count, const expr_t **args, rua_ctx_t *ctx)
}
static const type_t *
resolve_attribute (int arg_count, const expr_t **args, rua_ctx_t *ctx)
resolve_property (int arg_count, const expr_t **args, rua_ctx_t *ctx)
{
auto type = resolve_type (args[0], ctx);
if (type) {
if (!type->attrib) {
error (args[0], "type doesn't support attributes");
if (!type->property) {
error (args[0], "type doesn't support properties");
} else {
auto e = type->attrib (type, args[1]->typ.attrib);
auto e = type->property (type, args[1]->typ.property);
if (is_error (e)) {
type = nullptr;
} else {
@ -502,21 +502,21 @@ static def_t *compute_val (const expr_t *arg, comp_ctx_t *ctx);
#define C(op, a, b, c) codespace_addcode (ctx->code, I(op, a, b, c), 1)
static def_t *
compute_attribute (int arg_count, const expr_t **args, comp_ctx_t *ctx)
compute_property (int arg_count, const expr_t **args, comp_ctx_t *ctx)
{
auto type = compute_type (args[0], ctx);
auto res = compute_tmp (ctx);
auto attrib = args[1]->typ.attrib;
int count = attrib->params ? list_count (&attrib->params->list) : 0;
auto property = args[1]->typ.property;
int count = property->params ? list_count (&property->params->list) : 0;
// FIXME assumes simple 1-component types
auto attr_params = compute_sized_tmp (2 + 2 * count, ctx);
def_t ndef = { .offset = attr_params->offset + 0, .space = ctx->data };
def_t cdef = { .offset = attr_params->offset + 1, .space = ctx->data };
D_STRING (&ndef) = compute_str (attrib->name, ctx);
D_STRING (&ndef) = compute_str (property->name, ctx);
D_INT (&cdef) = count;
if (count) {
const expr_t *params[count];
list_scatter (&attrib->params->list, params);
list_scatter (&property->params->list, params);
for (int i = 0; i < count; i++) {
auto p = compute_type (params[i], ctx);
auto s = codespace_newstatement (ctx->code);
@ -530,7 +530,7 @@ compute_attribute (int arg_count, const expr_t **args, comp_ctx_t *ctx)
}
C (OP_STORE_A_1, ctx->args[0], nullptr, type);
C (OP_LEA_A, attr_params, nullptr, ctx->args[1]);
C (OP_CALL_B, ctx->funcs[tf_attribute], nullptr, res);
C (OP_CALL_B, ctx->funcs[tf_property], nullptr, res);
return res;
}
@ -684,11 +684,11 @@ compute_cols (int arg_count, const expr_t **args, comp_ctx_t *ctx)
static type_func_t type_funcs[] = {
[QC_ATTRIBUTE] = {
.name = ".attribute",
.check_params = single_type_attribute,
.resolve = resolve_attribute,
.evaluate = evaluate_attribute,
.compute = compute_attribute,
.name = ".property",
.check_params = single_type_property,
.resolve = resolve_property,
.evaluate = evaluate_property,
.compute = compute_property,
},
[QC_AT_FUNCTION] = {
.name = "@function",
@ -1036,9 +1036,9 @@ compute_type (const expr_t *arg, comp_ctx_t *ctx)
return res;
}
if (arg->type == ex_field) {
// type attribute
// type property
const expr_t *args[2] = {arg->field.object, arg->field.member};
return compute_attribute (2, args, ctx);
return compute_property (2, args, ctx);
}
if (arg->type != ex_type) {
internal_error (arg, "not a type expression");

24
tools/qfcc/source/glsl-builtins.c
View file

@ -68,7 +68,7 @@ static int size_widths[7] = { 1, 2, 3, 2, 2, 1, 0 };
static int shadow_widths[7] = { 3, 3, 0, 4, 3, 0, 0 };
static const expr_t *
image_attrib (const type_t *type, const attribute_t *attr)
image_property (const type_t *type, const attribute_t *property)
{
auto image = &glsl_imageset.a[type->handle.extra];
@ -76,9 +76,9 @@ image_attrib (const type_t *type, const attribute_t *attr)
internal_error (0, "image has bogus dimension");
}
if (strcmp (attr->name, "sample_type") == 0) {
if (strcmp (property->name, "sample_type") == 0) {
return new_type_expr (image->sample_type);
} else if (strcmp (attr->name, "image_coord") == 0) {
} else if (strcmp (property->name, "image_coord") == 0) {
int width = dim_widths[image->dim];
if (!width) {
return new_type_expr (&type_void);
@ -87,7 +87,7 @@ image_attrib (const type_t *type, const attribute_t *attr)
width += image->arrayed;
}
return new_type_expr (vector_type (&type_float, width));
} else if (strcmp (attr->name, "size_type") == 0) {
} else if (strcmp (property->name, "size_type") == 0) {
int width = size_widths[image->dim];
if (!width) {
return new_type_expr (&type_void);
@ -97,11 +97,11 @@ image_attrib (const type_t *type, const attribute_t *attr)
}
return new_type_expr (vector_type (&type_int, width));
}
return error (0, "no attribute %s on %s", attr->name, type->name + 4);
return error (0, "no property %s on %s", property->name, type->name + 4);
}
static const expr_t *
sampled_image_attrib (const type_t *type, const attribute_t *attr)
sampled_image_property (const type_t *type, const attribute_t *property)
{
auto image = &glsl_imageset.a[type->handle.extra];
@ -109,7 +109,7 @@ sampled_image_attrib (const type_t *type, const attribute_t *attr)
internal_error (0, "image has bogus dimension");
}
if (strcmp (attr->name, "tex_coord") == 0) {
if (strcmp (property->name, "tex_coord") == 0) {
int width = dim_widths[image->dim];
if (!width) {
return new_type_expr (&type_void);
@ -118,8 +118,8 @@ sampled_image_attrib (const type_t *type, const attribute_t *attr)
width += image->arrayed;
}
return new_type_expr (vector_type (&type_float, width));
} else if (strcmp (attr->name, "shadow_coord") == 0) {
if (attr->params) {
} else if (strcmp (property->name, "shadow_coord") == 0) {
if (property->params) {
} else {
int width = shadow_widths[image->dim];
if (!image->depth || !width) {
@ -131,18 +131,18 @@ sampled_image_attrib (const type_t *type, const attribute_t *attr)
return new_type_expr (vector_type (&type_float, width));
}
}
return image_attrib (type, attr);
return image_property (type, property);
}
type_t type_glsl_image = {
.type = ev_invalid,
.meta = ty_struct,
.attrib = image_attrib,
.property = image_property,
};
type_t type_glsl_sampled_image = {
.type = ev_invalid,
.meta = ty_struct,
.attrib = sampled_image_attrib,
.property = sampled_image_property,
};
type_t type_glsl_sampler = {
.type = ev_int,

6
tools/qfcc/source/glsl-parse.y
View file

@ -1633,9 +1633,9 @@ find_image_sub (image_sub_t *sub, const char *str)
}
static const expr_t *
image_attrib (const type_t *type, const attribute_t *attr)
image_property (const type_t *type, const attribute_t *attr)
{
return type->handle.type->attrib (type, attr);
return type->handle.type->property (type, attr);
}
static symbol_t *
@ -1759,7 +1759,7 @@ glsl_parse_image (const char *token, rua_ctx_t *ctx)
}
t->handle.type = type.htype;
t->handle.extra = index;
t->attrib = image_attrib;
t->property = image_property;
return sym;
invalid:

14
tools/qfcc/source/qc-parse.y
View file

@ -285,16 +285,16 @@ type_spec (const type_t *type)
}
static const expr_t *
type_attribute (specifier_t spec, const attribute_t *attrib)
type_property (specifier_t spec, const attribute_t *property)
{
auto type_expr = spec.type_expr;
if (!type_expr) {
type_expr = new_type_expr (spec.type);
}
auto params = new_list_expr (type_expr);
auto attr = new_type_expr (nullptr);
attr->typ.attrib = attrib;
expr_append_expr (params, attr);
auto prop = new_type_expr (nullptr);
prop->typ.property = property;
expr_append_expr (params, prop);
return new_type_function (QC_ATTRIBUTE, params);
}
@ -1160,7 +1160,7 @@ typespec_nonreserved
: TYPE_NAME %prec LOW
| TYPE_NAME[spec] '.' attribute
{
auto te = type_attribute ($spec, $attribute);
auto te = type_property ($spec, $attribute);
$$ = (specifier_t) { .type_expr = te };
}
| OBJECT_NAME protocolrefs
@ -1371,7 +1371,7 @@ type_ref
}
| TYPE_NAME[spec] '.' attribute
{
$$ = type_attribute ($spec, $attribute);
$$ = type_property ($spec, $attribute);
}
;
@ -2852,7 +2852,7 @@ obj_messageexpr
}
| '[' TYPE_NAME[spec] attrfunc ']'
{
$$ = type_attribute ($spec, $attrfunc);
$$ = type_property ($spec, $attrfunc);
}
;

2
tools/qfcc/source/type.c
View file

@ -1056,7 +1056,7 @@ alias_type (const type_t *type, const type_t *alias_chain, const char *name)
if (name) {
alias->name = save_string (name);
}
alias->attrib = type->attrib;
alias->property = type->property;
return alias;
}