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

[qfcc] Clean up handling of value expressions

Browse source 
I'd created new_value_expr some time ago, but never used it...
Also, replace convert_* with cast_expr to the appropriate type (removes
a pile of value check and create code).
This commit is contained in:
Bill Currie 2022-04-28 17:37:56 +09:00
parent 04f60e5ff1
commit 1eb8b61b83
7 changed files with 39 additions and 170 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -768,10 +768,6 @@ expr_t *reverse_expr_list (expr_t *e);
void print_expr (expr_t *e);
void dump_dot_expr (void *e, const char *filename);
void convert_int (expr_t *e);
void convert_short (expr_t *e);
void convert_short_int (expr_t *e);
void convert_double (expr_t *e);
expr_t *convert_nil (expr_t *e, struct type_s *t);
expr_t *test_expr (expr_t *e);

70
tools/qfcc/source/constfold.c
View file

@ -55,13 +55,6 @@
typedef expr_t *(*operation_t) (int op, expr_t *e, expr_t *e1, expr_t *e2);
typedef expr_t *(*unaryop_t) (int op, expr_t *e, expr_t *e1);
static expr_t *
cf_cast_expr (type_t *type, expr_t *e)
{
e = cast_expr (type, e);
return e;
}
static __attribute__((pure)) int
valid_op (int op, int *valid_ops)
{
@ -162,33 +155,10 @@ convert_to_float (expr_t *e)
if (is_float(get_type (e)))
return e;
switch (e->type) {
case ex_value:
switch (e->e.value->lltype) {
case ev_int:
convert_int (e);
return e;
case ev_short:
convert_short (e);
return e;
case ev_double:
convert_double (e);
return e;
default:
internal_error (e, "bad conversion to float: %d",
e->e.value->lltype);
}
break;
case ex_symbol:
case ex_expr:
case ex_uexpr:
case ex_temp:
case ex_block:
e = cf_cast_expr (&type_float, e);
return e;
default:
internal_error (e, 0);
}
expr_t *n = cast_expr (&type_float, e);
n->file = e->file;
n->line = e->line;
return n;
}
static expr_t *
@ -197,32 +167,10 @@ convert_to_double (expr_t *e)
if (is_double(get_type (e)))
return e;
switch (e->type) {
case ex_value:
switch (e->e.value->lltype) {
case ev_int:
e->e.value = new_double_val (expr_int (e));
return e;
case ev_short:
e->e.value = new_double_val (expr_short (e));
return e;
case ev_float:
e->e.value = new_double_val (expr_float (e));
return e;
default:
internal_error (e, 0);
}
break;
case ex_symbol:
case ex_expr:
case ex_uexpr:
case ex_temp:
case ex_block:
e = cf_cast_expr (&type_float, e);
return e;
default:
internal_error (e, 0);
}
expr_t *n = cast_expr (&type_double, e);
n->file = e->file;
n->line = e->line;
return n;
}
static expr_t *
@ -634,7 +582,7 @@ do_op_pointer (int op, expr_t *e, expr_t *e1, expr_t *e2)
if (op != '.' && extract_type (e1) != extract_type (e2))
return type_mismatch (e1, e2, op);
if (op == '.' && is_uint(get_type (e2)))
e->e.expr.e2 = cf_cast_expr (&type_int, e2);
e->e.expr.e2 = cast_expr (&type_int, e2);
return e;
}

13
tools/qfcc/source/def.c
View file

@ -380,12 +380,13 @@ init_elements (struct def_s *def, expr_t *eles)
reloc_def_op (c->e.labelref.label, &dummy);
continue;
} else if (c->type == ex_value) {
if (c->e.value->lltype == ev_int && is_float (element->type)) {
convert_int (c);
}
if (is_double (get_type (c)) && is_float (element->type)
&& c->implicit) {
convert_double (c);
if (is_float (element->type)
&& (is_int (get_type (c))
|| (is_double (get_type (c)) && c->implicit))) {
expr_t *n = cast_expr (&type_float, c);
n->line = c->line;
n->file = c->line;
c = n;
}
if (get_type (c) != element->type) {
error (c, "type mismatch in initializer");

104
tools/qfcc/source/expr.c
View file

@ -689,109 +689,73 @@ new_name_expr (const char *name)
expr_t *
new_string_expr (const char *string_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_string_val (string_val);
return e;
return new_value_expr (new_string_val (string_val));
}
expr_t *
new_double_expr (double double_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_double_val (double_val);
return e;
return new_value_expr (new_double_val (double_val));
}
expr_t *
new_float_expr (float float_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_float_val (float_val);
return e;
return new_value_expr (new_float_val (float_val));
}
expr_t *
new_vector_expr (const float *vector_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_vector_val (vector_val);
return e;
return new_value_expr (new_vector_val (vector_val));
}
expr_t *
new_entity_expr (int entity_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_entity_val (entity_val);
return e;
return new_value_expr (new_entity_val (entity_val));
}
expr_t *
new_field_expr (int field_val, type_t *type, def_t *def)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_field_val (field_val, type, def);
return e;
return new_value_expr (new_field_val (field_val, type, def));
}
expr_t *
new_func_expr (int func_val, type_t *type)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_func_val (func_val, type);
return e;
return new_value_expr (new_func_val (func_val, type));
}
expr_t *
new_pointer_expr (int val, type_t *type, def_t *def)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_pointer_val (val, type, def, 0);
return e;
return new_value_expr (new_pointer_val (val, type, def, 0));
}
expr_t *
new_quaternion_expr (const float *quaternion_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_quaternion_val (quaternion_val);
return e;
return new_value_expr (new_quaternion_val (quaternion_val));
}
expr_t *
new_int_expr (int int_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_int_val (int_val);
return e;
return new_value_expr (new_int_val (int_val));
}
expr_t *
new_uint_expr (unsigned uint_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_uint_val (uint_val);
return e;
return new_value_expr (new_uint_val (uint_val));
}
expr_t *
new_short_expr (short short_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_short_val (short_val);
return e;
return new_value_expr (new_short_val (short_val));
}
int
@ -853,11 +817,9 @@ constant_expr (expr_t *e)
} else {
return e;
}
new = new_expr ();
new->type = ex_value;
new = new_value_expr (value);
new->line = e->line;
new->file = e->file;
new->e.value = value;
return new;
}
@ -1508,38 +1470,6 @@ convert_from_bool (expr_t *e, type_t *type)
return e;
}
void
convert_int (expr_t *e)
{
float float_val = expr_int (e);
e->type = ex_value;
e->e.value = new_float_val (float_val);
}
void
convert_short (expr_t *e)
{
float float_val = expr_short (e);
e->type = ex_value;
e->e.value = new_float_val (float_val);
}
void
convert_short_int (expr_t *e)
{
float int_val = expr_short (e);
e->type = ex_value;
e->e.value = new_int_val (int_val);
}
void
convert_double (expr_t *e)
{
float float_val = expr_double (e);
e->type = ex_value;
e->e.value = new_float_val (float_val);
}
expr_t *
convert_nil (expr_t *e, type_t *t)
{
@ -2063,7 +1993,7 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params)
convert_from_bool (e, get_type (e));
if (is_int_val (e)
&& options.code.progsversion == PROG_ID_VERSION)
convert_int (e);
e = cast_expr (&type_float, e);
if (options.code.promote_float) {
if (is_float (get_type (e))) {
t = &type_double;
@ -2280,7 +2210,7 @@ return_expr (function_t *f, expr_t *e)
e = convert_from_bool (e, (type_t *) ret_type); //FIXME cast
}
if (is_float(ret_type) && is_int_val (e)) {
convert_int (e);
e = cast_expr (&type_float, e);
t = &type_float;
}
if (is_void(t)) {
@ -2828,7 +2758,7 @@ build_state_expr (expr_t *e)
if (think->type == ex_symbol)
think = think_expr (think->e.symbol);
if (is_int_val (frame))
convert_int (frame);
frame = cast_expr (&type_float, frame);
if (!type_assignable (&type_float, get_type (frame)))
return error (frame, "invalid type for frame number");
if (extract_type (think) != ev_func)
@ -2837,7 +2767,7 @@ build_state_expr (expr_t *e)
if (step->next)
return error (step->next, "too many state arguments");
if (is_int_val (step))
convert_int (step);
step = cast_expr (&type_float, step);
if (!type_assignable (&type_float, get_type (step)))
return error (step, "invalid type for step");
}

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

@ -787,11 +787,11 @@ double_compare (int op, expr_t *e1, expr_t *e2)
if (is_constant (e1) && e1->implicit && is_double (t1) && is_float (t2)) {
t1 = &type_float;
convert_double (e1);
e1 = cast_expr (t1, e1);
}
if (is_float (t1) && is_constant (e2) && e2->implicit && is_double (t2)) {
t2 = &type_float;
convert_double (e2);
e2 = cast_expr (t2, e2);
}
if (is_double (t1)) {
if (is_float (t2)) {
@ -1009,11 +1009,11 @@ binary_expr (int op, expr_t *e1, expr_t *e2)
if (is_constant (e1) && is_double (t1) && e1->implicit && is_float (t2)) {
t1 = &type_float;
convert_double (e1);
e1 = cast_expr (t1, e1);
}
if (is_constant (e2) && is_double (t2) && e2->implicit && is_float (t1)) {
t2 = &type_float;
convert_double (e2);
e2 = cast_expr (t2, e2);
}
et1 = low_level_type (t1);

5
tools/qfcc/source/expr_cast.c
View file

@ -78,10 +78,7 @@ cast_math (type_t *dstType, type_t *srcType, expr_t *expr)
do_conversion (dst_value, dstType, src_value, srcType, expr);
expr_t *val = new_expr ();
val->type = ex_value;
val->e.value = new_type_value (dstType, dst_value);
return val;
return new_value_expr (new_type_value (dstType, dst_value));
}
expr_t *

5
tools/qfcc/source/expr_vector.c
View file

@ -153,10 +153,7 @@ new_vector_list (expr_t *expr_list)
offs += type_size (src_type);
}
expr_t *vec = new_expr ();
vec->type = ex_value;
vec->e.value = new_type_value (vec_type, value);
return vec;
return new_value_expr (new_type_value (vec_type, value));
}
for (int i = 0; i < count; i++) {