mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2025-02-25 13:11:00 +00:00
[qfcc] Make the type union anonymous
This one has bothered me for a long time. I don't remember why it was difficult at one stage, maybe I had some poor name choices.
This commit is contained in:
Bill Currie
parent
e5bd2591c2
commit
561f4c2ea0
24 changed files with 279 additions and 282 deletions
|
|
@ -84,7 +84,7 @@ typedef struct type_s {
|
|||
struct algebra_s *algebra;
|
||||
struct multivector_s *multivec;
|
||||
ty_alias_t alias;
|
||||
} t;
|
||||
};
|
||||
struct type_s *next;
|
||||
int freeable;
|
||||
int allocated;
|
||||
|
|
|
|||
|
|
@ -327,7 +327,7 @@ algebra_init (algebra_t *a)
|
|||
}
|
||||
}
|
||||
auto type = algebra_mvec_type (a, (1 << a->layout.count) - 1);
|
||||
a->mvec_sym = type->t.multivec->mvec_sym;
|
||||
a->mvec_sym = type->multivec->mvec_sym;
|
||||
}
|
||||
|
||||
bool
|
||||
|
|
@ -406,7 +406,7 @@ algebra_type (const type_t *type, const expr_t *params)
|
|||
t->meta = ty_algebra;
|
||||
t->type = ev_invalid;
|
||||
t->alignment = (dim > 1 ? 4 : 2) * type->alignment;
|
||||
t->t.algebra = algebra;
|
||||
t->algebra = algebra;
|
||||
algebra->algebra_type = t;
|
||||
return find_type (t);
|
||||
}
|
||||
|
|
@ -435,7 +435,7 @@ algebra_subtype (const type_t *type, attribute_t *attr)
|
|||
}
|
||||
return algebra_mvec_type (algebra, mask);
|
||||
}
|
||||
auto symtab = algebra->mvec_sym->type->t.symtab;
|
||||
auto symtab = algebra->mvec_sym->type->symtab;
|
||||
auto field = symtab_lookup (symtab, attr->name);
|
||||
if (field) {
|
||||
return field->type;
|
||||
|
|
@ -524,7 +524,7 @@ algebra_mvec_type (algebra_t *algebra, pr_uint_t group_mask)
|
|||
.alignment = algebra_alignment (algebra->type, components),
|
||||
.width = components,
|
||||
.meta = ty_algebra,
|
||||
.t.algebra = (algebra_t *) mvec,
|
||||
.algebra = (algebra_t *) mvec,
|
||||
.freeable = true,
|
||||
.allocated = true,
|
||||
};
|
||||
|
|
@ -662,7 +662,7 @@ algebra_scope (const type_t *type, symtab_t *curscope)
|
|||
return scope;
|
||||
}
|
||||
scope->procsymbol = algebra_symbol;
|
||||
scope->procsymbol_data = unalias_type (type)->t.algebra;
|
||||
scope->procsymbol_data = unalias_type (type)->algebra;
|
||||
return scope;
|
||||
}
|
||||
|
||||
|
|
@ -671,9 +671,9 @@ algebra_get (const type_t *type)
|
|||
{
|
||||
type = unalias_type (type);
|
||||
if (type->type == ev_invalid) {
|
||||
return type->t.algebra;
|
||||
return type->algebra;
|
||||
} else {
|
||||
return type->t.multivec->algebra;
|
||||
return type->multivec->algebra;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -700,11 +700,11 @@ void
|
|||
algebra_print_type_str (dstring_t *str, const type_t *type)
|
||||
{
|
||||
if (type->type == ev_invalid) {
|
||||
auto a = type->t.algebra;
|
||||
auto a = type->algebra;
|
||||
dasprintf (str, " algebra(%s(%d,%d,%d))", a->type->name,
|
||||
a->plus, a->minus, a->zero);
|
||||
} else if (type->type == ev_float || type->type == ev_double) {
|
||||
auto m = type->t.multivec;
|
||||
auto m = type->multivec;
|
||||
auto a = m->algebra;
|
||||
dasprintf (str, " algebra(%s(%d,%d,%d):%04x)", a->type->name,
|
||||
a->plus, a->minus, a->zero, m->group_mask);
|
||||
|
|
@ -717,12 +717,12 @@ void
|
|||
algebra_encode_type (dstring_t *encoding, const type_t *type)
|
||||
{
|
||||
if (type->type == ev_invalid) {
|
||||
auto a = type->t.algebra;
|
||||
auto a = type->algebra;
|
||||
dasprintf (encoding, "{∧");
|
||||
encode_type (encoding, a->type);
|
||||
dasprintf (encoding, "(%d,%d,%d)}", a->plus, a->minus, a->zero);
|
||||
} else if (type->type == ev_float || type->type == ev_double) {
|
||||
auto m = type->t.multivec;
|
||||
auto m = type->multivec;
|
||||
auto a = m->algebra;
|
||||
dasprintf (encoding, "{∧");
|
||||
encode_type (encoding, a->type);
|
||||
|
|
@ -737,10 +737,10 @@ int
|
|||
algebra_type_size (const type_t *type)
|
||||
{
|
||||
if (type->type == ev_invalid) {
|
||||
auto a = type->t.algebra;
|
||||
auto a = type->algebra;
|
||||
return a->num_components * type_size (a->type);
|
||||
} else if (type->type == ev_float || type->type == ev_double) {
|
||||
auto m = type->t.multivec;
|
||||
auto m = type->multivec;
|
||||
int size = 0;
|
||||
if (m->group_mask & (m->group_mask - 1)) {
|
||||
if (!m->mvec_sym) {
|
||||
|
|
@ -762,7 +762,7 @@ algebra_type_width (const type_t *type)
|
|||
if (type->type == ev_invalid) {
|
||||
return 0;
|
||||
} else if (type->type == ev_float || type->type == ev_double) {
|
||||
auto m = type->t.multivec;
|
||||
auto m = type->multivec;
|
||||
return m->num_components;
|
||||
} else {
|
||||
internal_error (0, "invalid algebra type");
|
||||
|
|
@ -793,7 +793,7 @@ algebra_type_assignable (const type_t *dst, const type_t *src)
|
|||
if (src->meta != ty_algebra) {
|
||||
return 0;
|
||||
}
|
||||
if (src->t.multivec->algebra != dst->t.algebra) {
|
||||
if (src->multivec->algebra != dst->algebra) {
|
||||
return 0;
|
||||
}
|
||||
// the multivec is a member of the destination algebra
|
||||
|
|
@ -801,10 +801,10 @@ algebra_type_assignable (const type_t *dst, const type_t *src)
|
|||
}
|
||||
if (!is_algebra (src)) {
|
||||
if (is_scalar (src)) {
|
||||
auto algebra = dst->t.multivec->algebra;
|
||||
auto algebra = dst->multivec->algebra;
|
||||
auto layout = &algebra->layout;
|
||||
int group = layout->group_map[layout->mask_map[0]][0];
|
||||
if (dst->t.multivec->group_mask & (1u << group)) {
|
||||
if (dst->multivec->group_mask & (1u << group)) {
|
||||
// the source scalar is a member of the destination
|
||||
// multi-vector
|
||||
return 1;
|
||||
|
|
@ -812,10 +812,10 @@ algebra_type_assignable (const type_t *dst, const type_t *src)
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
if (dst->t.multivec->algebra != src->t.multivec->algebra) {
|
||||
if (dst->multivec->algebra != src->multivec->algebra) {
|
||||
return 0;
|
||||
}
|
||||
if (src->t.multivec->group_mask & ~dst->t.multivec->group_mask) {
|
||||
if (src->multivec->group_mask & ~dst->multivec->group_mask) {
|
||||
return 0;
|
||||
}
|
||||
// the source multi-vector is a subset of the destinatin multi-vector
|
||||
|
|
@ -826,7 +826,7 @@ const type_t *
|
|||
algebra_base_type (const type_t *type)
|
||||
{
|
||||
if (type->type == ev_invalid) {
|
||||
return type->t.algebra->type;
|
||||
return type->algebra->type;
|
||||
}
|
||||
return ev_types[type->type];
|
||||
}
|
||||
|
|
@ -837,9 +837,9 @@ algebra_struct_type (const type_t *type)
|
|||
symbol_t *sym = 0;
|
||||
|
||||
if (type->type == ev_invalid) {
|
||||
sym = type->t.algebra->mvec_sym;
|
||||
sym = type->algebra->mvec_sym;
|
||||
} else {
|
||||
sym = type->t.multivec->mvec_sym;
|
||||
sym = type->multivec->mvec_sym;
|
||||
}
|
||||
return sym ? sym->type : 0;
|
||||
}
|
||||
|
|
@ -861,7 +861,7 @@ is_mono_grade (const type_t *type)
|
|||
}
|
||||
auto alg = algebra_get (type);
|
||||
auto layout = &alg->layout;
|
||||
auto multivec = type->t.multivec;
|
||||
auto multivec = type->multivec;
|
||||
int grade = -1;
|
||||
for (int i = 0; i < layout->count; i++) {
|
||||
pr_uint_t mask = 1u << i;
|
||||
|
|
@ -892,7 +892,7 @@ algebra_get_grade (const type_t *type)
|
|||
}
|
||||
auto alg = algebra_get (type);
|
||||
auto layout = &alg->layout;
|
||||
auto multivec = type->t.multivec;
|
||||
auto multivec = type->multivec;
|
||||
for (int i = 0; i < layout->count; i++) {
|
||||
pr_uint_t mask = 1u << i;
|
||||
if (mask & multivec->group_mask) {
|
||||
|
|
|
|||
|
|
@ -415,10 +415,10 @@ is_id (const type_t *type)
|
|||
// a qualified obj_object struct
|
||||
if (type->type != ev_ptr)
|
||||
return 0;
|
||||
if (!is_struct (type->t.fldptr.type))
|
||||
if (!is_struct (type->fldptr.type))
|
||||
return 0;
|
||||
// if the the symtabs match, then type is id in disguise
|
||||
if (type->t.fldptr.type->t.symtab == type_object.t.symtab)
|
||||
if (type->fldptr.type->symtab == type_object.symtab)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -447,7 +447,7 @@ is_classptr (const type_t *type)
|
|||
return 1;
|
||||
if (type->type != ev_ptr)
|
||||
return 0;
|
||||
type = type->t.fldptr.type;
|
||||
type = type->fldptr.type;
|
||||
if (is_class (type))
|
||||
return 1;
|
||||
return 0;
|
||||
|
|
@ -481,9 +481,9 @@ static protocollist_t *
|
|||
obj_get_class_protos (const type_t *type)
|
||||
{
|
||||
if (is_ptr (type))
|
||||
type = type->t.fldptr.type;
|
||||
type = type->fldptr.type;
|
||||
if (is_class (type))
|
||||
return type->t.class->protocols;
|
||||
return type->class->protocols;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -491,7 +491,7 @@ static protocollist_t *
|
|||
obj_get_protos (const type_t *type)
|
||||
{
|
||||
if (is_ptr (type))
|
||||
type = type->t.fldptr.type;
|
||||
type = type->fldptr.type;
|
||||
return type->protos;
|
||||
}
|
||||
|
||||
|
|
@ -499,9 +499,9 @@ static category_t *
|
|||
obj_get_categories (const type_t *type)
|
||||
{
|
||||
if (is_ptr (type))
|
||||
type = type->t.fldptr.type;
|
||||
type = type->fldptr.type;
|
||||
if (is_class (type))
|
||||
return type->t.class->categories;
|
||||
return type->class->categories;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -520,9 +520,9 @@ obj_classname (const type_t *type)
|
|||
dstring_copystr (str, "Class");
|
||||
} else {
|
||||
if (is_ptr (type))
|
||||
type = type->t.fldptr.type;
|
||||
type = type->fldptr.type;
|
||||
if (is_class (type))
|
||||
dstring_copystr (str, type->t.class->name);
|
||||
dstring_copystr (str, type->class->name);
|
||||
}
|
||||
if ((protos = obj_get_protos (type)))
|
||||
print_protocollist (str, protos);
|
||||
|
|
@ -595,9 +595,9 @@ obj_types_assignable (const type_t *dst, const type_t *src)
|
|||
return 1;
|
||||
|
||||
// check dst is a base class of src
|
||||
dst_class = dst->t.fldptr.type->t.class;
|
||||
if (src->t.fldptr.type->meta == ty_class) {
|
||||
src_class = src->t.fldptr.type->t.class;
|
||||
dst_class = dst->fldptr.type->class;
|
||||
if (src->fldptr.type->meta == ty_class) {
|
||||
src_class = src->fldptr.type->class;
|
||||
}
|
||||
//printf ("%s %s\n", dst_class->name, src_class->name);
|
||||
while (dst_class != src_class && src_class) {
|
||||
|
|
@ -714,7 +714,7 @@ get_class (symbol_t *sym, int create)
|
|||
new.type = ev_invalid;
|
||||
new.name = c->name;
|
||||
new.meta = ty_class;
|
||||
new.t.class = c;
|
||||
new.class = c;
|
||||
c->type = find_type (&new);
|
||||
if (sym)
|
||||
sym->type = c->type;
|
||||
|
|
@ -913,7 +913,7 @@ begin_class (class_t *class)
|
|||
// root class of the hierachy.
|
||||
// NOTE: type_class is not actually a class
|
||||
EMIT_DEF (space, meta->ivars,
|
||||
emit_ivars (type_class.t.symtab, "Class"));
|
||||
emit_ivars (type_class.symtab, "Class"));
|
||||
} else {
|
||||
meta->ivars = 0;
|
||||
}
|
||||
|
|
@ -1254,7 +1254,7 @@ class_message_response (const type_t *clstype, int class_msg, const expr_t *sel)
|
|||
return 0;
|
||||
}
|
||||
if (is_id (clstype)) {
|
||||
protocollist_t *protos = clstype->t.fldptr.type->protos;
|
||||
protocollist_t *protos = clstype->fldptr.type->protos;
|
||||
if (protos) {
|
||||
if ((m = protocollist_find_method (protos, selector, !class_msg))) {
|
||||
return m;
|
||||
|
|
@ -1267,9 +1267,9 @@ class_message_response (const type_t *clstype, int class_msg, const expr_t *sel)
|
|||
}
|
||||
} else {
|
||||
if (is_class (clstype)) {
|
||||
class = clstype->t.class;
|
||||
} else if (is_class (clstype->t.fldptr.type)) {
|
||||
class = clstype->t.fldptr.type->t.class;
|
||||
class = clstype->class;
|
||||
} else if (is_class (clstype->fldptr.type)) {
|
||||
class = clstype->fldptr.type->class;
|
||||
}
|
||||
if (class && !is_object(class->type)) {
|
||||
if (!class->interface_declared) {
|
||||
|
|
@ -1503,7 +1503,7 @@ emit_symtab_ref_cnt (def_t *def, void *data, int index)
|
|||
internal_error (0, "%s: expected int def", __FUNCTION__);
|
||||
D_INT (def) = 0;
|
||||
if (da->refs)
|
||||
D_INT (def) = da->refs->type->t.array.size;
|
||||
D_INT (def) = da->refs->type->array.size;
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
|
|||
|
|
@ -155,7 +155,7 @@ new_def (const char *name, const type_t *type, defspace_t *space,
|
|||
if (is_class (type)
|
||||
|| (is_array (type) && is_class(dereference_type (type)))) {
|
||||
error (0, "statically allocated instance of class %s",
|
||||
type->t.class->name);
|
||||
type->class->name);
|
||||
return def;
|
||||
}
|
||||
|
||||
|
|
@ -300,7 +300,7 @@ def_to_ddef (def_t *def, ddef_t *ddef, int aux)
|
|||
const type_t *type = unalias_type (def->type);
|
||||
|
||||
if (aux)
|
||||
type = type->t.fldptr.type; // aux is true only for fields
|
||||
type = type->fldptr.type; // aux is true only for fields
|
||||
ddef->type = type->type;
|
||||
ddef->ofs = def->offset;
|
||||
ddef->name = ReuseString (def->name);
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ static void
|
|||
print_pointer (dstring_t *dstr, const type_t *t, int level, int id)
|
||||
{
|
||||
int indent = level * 2 + 2;
|
||||
auto aux = t->t.fldptr.type;
|
||||
auto aux = t->fldptr.type;
|
||||
|
||||
dot_print_type (dstr, aux, level, id);
|
||||
dasprintf (dstr, "%*st_%p -> \"t_%p\";\n", indent, "", t, aux);
|
||||
|
|
@ -81,7 +81,7 @@ static void
|
|||
print_function (dstring_t *dstr, const type_t *t, int level, int id)
|
||||
{
|
||||
int indent = level * 2 + 2;
|
||||
const ty_func_t *func = &t->t.func;
|
||||
const ty_func_t *func = &t->func;
|
||||
const type_t *ret = func->ret_type;
|
||||
const type_t *param;
|
||||
|
||||
|
|
@ -132,7 +132,7 @@ static void
|
|||
print_struct (dstring_t *dstr, const type_t *t, int level, int id)
|
||||
{
|
||||
int indent = level * 2 + 2;
|
||||
const symtab_t *symtab = t->t.symtab;
|
||||
const symtab_t *symtab = t->symtab;
|
||||
const symbol_t *sym;
|
||||
int pnum;
|
||||
static const char *struct_type_names[3] = {"struct", "union", "enum"};
|
||||
|
|
@ -189,17 +189,16 @@ static void
|
|||
print_array (dstring_t *dstr, const type_t *t, int level, int id)
|
||||
{
|
||||
int indent = level * 2 + 2;
|
||||
auto type = t->t.array.type;
|
||||
auto type = t->array.type;
|
||||
|
||||
dot_print_type (dstr, type, level, id);
|
||||
dasprintf (dstr, "%*st_%p -> \"t_%p\";\n", indent, "", t, type);
|
||||
if (t->t.array.base) {
|
||||
if (t->array.base) {
|
||||
dasprintf (dstr, "%*st_%p [label=\"[%d..%d]\"];\n", indent, "", t,
|
||||
t->t.array.base,
|
||||
t->t.array.base + t->t.array.size - 1);
|
||||
t->array.base, t->array.base + t->array.size - 1);
|
||||
} else {
|
||||
dasprintf (dstr, "%*st_%p [label=\"[%d]\"];\n", indent, "", t,
|
||||
t->t.array.size);
|
||||
t->array.size);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -208,15 +207,15 @@ print_class (dstring_t *dstr, const type_t *t, int level, int id)
|
|||
{
|
||||
int indent = level * 2 + 2;
|
||||
dasprintf (dstr, "%*st_%p [label=\"class '%s'\"];\n", indent, "", t,
|
||||
t->t.class->name);
|
||||
t->class->name);
|
||||
}
|
||||
|
||||
static void
|
||||
print_alias (dstring_t *dstr, const type_t *t, int level, int id)
|
||||
{
|
||||
int indent = level * 2 + 2;
|
||||
auto aux = t->t.alias.aux_type;
|
||||
auto full = t->t.alias.full_type;
|
||||
auto aux = t->alias.aux_type;
|
||||
auto full = t->alias.full_type;
|
||||
|
||||
dot_print_type (dstr, aux, level, id);
|
||||
dot_print_type (dstr, full, level, id);
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ get_value_def (const expr_t *expr, ex_value_t *value, const type_t *type)
|
|||
}
|
||||
if (is_ptr (type) && value->pointer.tempop && !value->pointer.def) {
|
||||
value->pointer.def = get_tempop_def (expr, value->pointer.tempop,
|
||||
type->t.fldptr.type);
|
||||
type->fldptr.type);
|
||||
}
|
||||
def = emit_value (value, 0);
|
||||
if (type != def->type)
|
||||
|
|
|
|||
|
|
@ -1466,7 +1466,7 @@ get_name (const expr_t *e)
|
|||
symbol_t *
|
||||
get_struct_field (const type_t *t1, const expr_t *e1, const expr_t *e2)
|
||||
{
|
||||
symtab_t *strct = t1->t.symtab;
|
||||
symtab_t *strct = t1->symtab;
|
||||
symbol_t *sym = get_name (e2);
|
||||
symbol_t *field;
|
||||
|
||||
|
|
@ -1527,15 +1527,15 @@ field_expr (const expr_t *e1, const expr_t *e2)
|
|||
return e2;
|
||||
if (t2->type == ev_field) {
|
||||
e = new_binary_expr ('.', e1, e2);
|
||||
e->expr.type = t2->t.fldptr.type;
|
||||
e->expr.type = t2->fldptr.type;
|
||||
return e;
|
||||
}
|
||||
}
|
||||
} else if (is_ptr (t1)) {
|
||||
if (is_struct (t1->t.fldptr.type) || is_union (t1->t.fldptr.type)) {
|
||||
if (is_struct (t1->fldptr.type) || is_union (t1->fldptr.type)) {
|
||||
symbol_t *field;
|
||||
|
||||
field = get_struct_field (t1->t.fldptr.type, e1, e2);
|
||||
field = get_struct_field (t1->fldptr.type, e1, e2);
|
||||
if (!field)
|
||||
return e1;
|
||||
|
||||
|
|
@ -1546,8 +1546,8 @@ field_expr (const expr_t *e1, const expr_t *e2)
|
|||
}
|
||||
e1 = cast_expr (pointer_type (field->type), e1);
|
||||
return unary_expr ('.', e1);
|
||||
} else if (is_class (t1->t.fldptr.type)) {
|
||||
class_t *class = t1->t.fldptr.type->t.class;
|
||||
} else if (is_class (t1->fldptr.type)) {
|
||||
class_t *class = t1->fldptr.type->class;
|
||||
symbol_t *sym = e2->symbol;//FIXME need to check
|
||||
symbol_t *ivar;
|
||||
int protected = class_access (current_class, class);
|
||||
|
|
@ -2115,7 +2115,7 @@ bitnot_expr:
|
|||
return error (e, "invalid type for unary .");
|
||||
scoped_src_loc (e);
|
||||
auto new = new_unary_expr ('.', e);
|
||||
new->expr.type = get_type (e)->t.fldptr.type;
|
||||
new->expr.type = get_type (e)->fldptr.type;
|
||||
return new;
|
||||
}
|
||||
case '+':
|
||||
|
|
@ -2169,24 +2169,24 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
|
|||
return error (fexpr, "more than %d parameters", PR_MAX_PARAMS);
|
||||
}
|
||||
|
||||
if (ftype->t.func.num_params < -1) {
|
||||
if (-arg_count > ftype->t.func.num_params + 1) {
|
||||
if (ftype->func.num_params < -1) {
|
||||
if (-arg_count > ftype->func.num_params + 1) {
|
||||
if (!options.traditional)
|
||||
return error (fexpr, "too few arguments");
|
||||
if (options.warnings.traditional)
|
||||
warning (fexpr, "too few arguments");
|
||||
}
|
||||
param_count = -ftype->t.func.num_params - 1;
|
||||
} else if (ftype->t.func.num_params >= 0) {
|
||||
if (arg_count > ftype->t.func.num_params) {
|
||||
param_count = -ftype->func.num_params - 1;
|
||||
} else if (ftype->func.num_params >= 0) {
|
||||
if (arg_count > ftype->func.num_params) {
|
||||
return error (fexpr, "too many arguments");
|
||||
} else if (arg_count < ftype->t.func.num_params) {
|
||||
} else if (arg_count < ftype->func.num_params) {
|
||||
if (!options.traditional)
|
||||
return error (fexpr, "too few arguments");
|
||||
if (options.warnings.traditional)
|
||||
warning (fexpr, "too few arguments");
|
||||
}
|
||||
param_count = ftype->t.func.num_params;
|
||||
param_count = ftype->func.num_params;
|
||||
}
|
||||
|
||||
const type_t *arg_types[arg_count + 1];
|
||||
|
|
@ -2197,7 +2197,7 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
|
|||
|
||||
if (e->type == ex_compound) {
|
||||
if (i < param_count) {
|
||||
t = ftype->t.func.param_types[i];
|
||||
t = ftype->func.param_types[i];
|
||||
} else {
|
||||
return error (e, "cannot pass compound initializer "
|
||||
"through ...");
|
||||
|
|
@ -2219,16 +2219,16 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
|
|||
}
|
||||
if (i < param_count) {
|
||||
if (e->type == ex_nil)
|
||||
e = convert_nil (e, t = ftype->t.func.param_types[i]);
|
||||
e = convert_nil (e, t = ftype->func.param_types[i]);
|
||||
if (e->type == ex_bool)
|
||||
e = convert_from_bool (e, ftype->t.func.param_types[i]);
|
||||
e = convert_from_bool (e, ftype->func.param_types[i]);
|
||||
if (e->type == ex_error)
|
||||
return e;
|
||||
if (!type_assignable (ftype->t.func.param_types[i], t)) {
|
||||
if (!type_assignable (ftype->func.param_types[i], t)) {
|
||||
err = param_mismatch (e, i + 1, fexpr->symbol->name,
|
||||
ftype->t.func.param_types[i], t);
|
||||
ftype->func.param_types[i], t);
|
||||
}
|
||||
t = ftype->t.func.param_types[i];
|
||||
t = ftype->func.param_types[i];
|
||||
} else {
|
||||
if (e->type == ex_nil)
|
||||
e = convert_nil (e, t = type_nil);
|
||||
|
|
@ -2261,8 +2261,8 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
|
|||
}
|
||||
|
||||
bool emit_args = false;
|
||||
if (ftype->t.func.num_params < 0) {
|
||||
emit_args = !ftype->t.func.no_va_list;
|
||||
if (ftype->func.num_params < 0) {
|
||||
emit_args = !ftype->func.no_va_list;
|
||||
}
|
||||
scoped_src_loc (fexpr);
|
||||
call = new_block_expr (0);
|
||||
|
|
@ -2314,7 +2314,7 @@ build_function_call (const expr_t *fexpr, const type_t *ftype, const expr_t *par
|
|||
arg_exprs[arg_expr_count - 1][0]);
|
||||
append_expr (call, e);
|
||||
}
|
||||
auto ret_type = ftype->t.func.ret_type;
|
||||
auto ret_type = ftype->func.ret_type;
|
||||
call->block.result = call_expr (fexpr, args, ret_type);
|
||||
return call;
|
||||
}
|
||||
|
|
@ -2430,7 +2430,7 @@ const expr_t *
|
|||
return_expr (function_t *f, const expr_t *e)
|
||||
{
|
||||
const type_t *t;
|
||||
const type_t *ret_type = unalias_type (f->type->t.func.ret_type);
|
||||
const type_t *ret_type = unalias_type (f->type->func.ret_type);
|
||||
|
||||
e = convert_name (e);
|
||||
if (!e) {
|
||||
|
|
@ -2500,7 +2500,7 @@ return_expr (function_t *f, const expr_t *e)
|
|||
} else {
|
||||
if (ret_type != t) {
|
||||
e = cast_expr ((type_t *) ret_type, e);//FIXME cast
|
||||
t = f->sym->type->t.func.ret_type;
|
||||
t = f->sym->type->func.ret_type;
|
||||
}
|
||||
}
|
||||
if (e->type == ex_vector) {
|
||||
|
|
@ -2515,7 +2515,7 @@ return_expr (function_t *f, const expr_t *e)
|
|||
const expr_t *
|
||||
at_return_expr (function_t *f, const expr_t *e)
|
||||
{
|
||||
const type_t *ret_type = unalias_type (f->type->t.func.ret_type);
|
||||
const type_t *ret_type = unalias_type (f->type->func.ret_type);
|
||||
|
||||
if (!is_void(ret_type)) {
|
||||
return error (e, "use of @return in non-void function");
|
||||
|
|
@ -2528,7 +2528,7 @@ at_return_expr (function_t *f, const expr_t *e)
|
|||
}
|
||||
const expr_t *call_expr = e->block.result->branch.target;
|
||||
const auto call_type = get_type (call_expr);
|
||||
if (!is_func (call_type) && !call_type->t.func.void_return) {
|
||||
if (!is_func (call_type) && !call_type->func.void_return) {
|
||||
return error (e, "@return function not void_return");
|
||||
}
|
||||
expr_t *ret_expr = new_return_expr (e);
|
||||
|
|
@ -2651,10 +2651,10 @@ array_expr (const expr_t *array, const expr_t *index)
|
|||
if (is_int_val (index))
|
||||
ind = expr_int (index);
|
||||
if (is_array (array_type)
|
||||
&& array_type->t.array.size
|
||||
&& array_type->array.size
|
||||
&& is_constant (index)
|
||||
&& (ind < array_type->t.array.base
|
||||
|| ind - array_type->t.array.base >= array_type->t.array.size)) {
|
||||
&& (ind < array_type->array.base
|
||||
|| ind - array_type->array.base >= array_type->array.size)) {
|
||||
return error (index, "array index out of bounds");
|
||||
}
|
||||
if (is_nonscalar (array_type)
|
||||
|
|
@ -2664,9 +2664,9 @@ array_expr (const expr_t *array, const expr_t *index)
|
|||
}
|
||||
if (is_array (array_type)) {
|
||||
ele_type = dereference_type (array_type);
|
||||
base = new_int_expr (array_type->t.array.base, false);
|
||||
base = new_int_expr (array_type->array.base, false);
|
||||
} else if (is_ptr (array_type)) {
|
||||
ele_type = array_type->t.fldptr.type;
|
||||
ele_type = array_type->fldptr.type;
|
||||
base = new_int_expr (0, false);
|
||||
} else {
|
||||
ele_type = ev_types[array_type->type];
|
||||
|
|
@ -2735,7 +2735,7 @@ offset_pointer_expr (const expr_t *pointer, const expr_t *offset)
|
|||
if (pointer->address.offset) {
|
||||
offset = binary_expr ('+', pointer->address.offset, offset);
|
||||
}
|
||||
ptr = new_address_expr (ptr_type->t.fldptr.type,
|
||||
ptr = new_address_expr (ptr_type->fldptr.type,
|
||||
pointer->address.lvalue, offset);
|
||||
return ptr;
|
||||
} else {
|
||||
|
|
@ -3059,8 +3059,8 @@ think_expr (symbol_t *think_sym)
|
|||
sym = symtab_lookup (current_symtab, "think");
|
||||
if (sym && sym->sy_type == sy_var && sym->type
|
||||
&& sym->type->type == ev_field
|
||||
&& sym->type->t.fldptr.type->type == ev_func) {
|
||||
think_sym->type = sym->type->t.fldptr.type;
|
||||
&& sym->type->fldptr.type->type == ev_func) {
|
||||
think_sym->type = sym->type->fldptr.type;
|
||||
} else {
|
||||
think_sym->type = &type_func;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ get_group (const type_t *type, algebra_t *algebra)
|
|||
}
|
||||
pr_uint_t group_mask = (1u << layout->count) - 1;
|
||||
if (type->type != ev_invalid) {
|
||||
group_mask = type->t.multivec->group_mask;
|
||||
group_mask = type->multivec->group_mask;
|
||||
}
|
||||
if (group_mask & (group_mask - 1)) {
|
||||
internal_error (0, "multi-group mult-vector");
|
||||
|
|
@ -72,7 +72,7 @@ get_group_mask (const type_t *type, algebra_t *algebra)
|
|||
if (type->type == ev_invalid) {
|
||||
return (1 << algebra->layout.count) - 1;
|
||||
}
|
||||
return type->t.multivec->group_mask;
|
||||
return type->multivec->group_mask;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -246,11 +246,11 @@ get_mvec_struct (const type_t *type)
|
|||
{
|
||||
symbol_t *sym = 0;
|
||||
if (type->type == ev_invalid) {
|
||||
sym = type->t.algebra->mvec_sym;
|
||||
sym = type->algebra->mvec_sym;
|
||||
} else {
|
||||
sym = type->t.multivec->mvec_sym;
|
||||
sym = type->multivec->mvec_sym;
|
||||
}
|
||||
return sym ? sym->type->t.symtab : 0;
|
||||
return sym ? sym->type->symtab : 0;
|
||||
}
|
||||
|
||||
static symbol_t *
|
||||
|
|
@ -309,7 +309,7 @@ mvec_expr (const expr_t *expr, algebra_t *algebra)
|
|||
auto layout = &algebra->layout;
|
||||
pr_uint_t group_mask = (1u << layout->count) - 1;
|
||||
if (mvtype->type != ev_invalid) {
|
||||
group_mask = mvtype->t.multivec->group_mask;
|
||||
group_mask = mvtype->multivec->group_mask;
|
||||
}
|
||||
if (!(group_mask & (group_mask - 1))) {
|
||||
return expr;
|
||||
|
|
@ -346,7 +346,7 @@ mvec_scatter (const expr_t **components, const expr_t *mvec, algebra_t *algebra)
|
|||
if (type->type == ev_invalid) {
|
||||
internal_error (mvec, "full algebra in mvec_scatter");
|
||||
}
|
||||
pr_uint_t mask = type->t.multivec->group_mask;
|
||||
pr_uint_t mask = type->multivec->group_mask;
|
||||
if (mask & (mask - 1)) {
|
||||
internal_error (mvec, "bare multivector in mvec_scatter");
|
||||
}
|
||||
|
|
@ -361,7 +361,7 @@ mvec_scatter (const expr_t **components, const expr_t *mvec, algebra_t *algebra)
|
|||
if (!is_algebra (ct)) {
|
||||
group = layout->group_map[layout->mask_map[0]][0];
|
||||
} else if (ct->meta == ty_algebra && ct->type != ev_invalid) {
|
||||
pr_uint_t mask = ct->t.multivec->group_mask;
|
||||
pr_uint_t mask = ct->multivec->group_mask;
|
||||
if (mask & (mask - 1)) {
|
||||
internal_error (mvec, "multivector in multivec expression");
|
||||
}
|
||||
|
|
@ -3023,7 +3023,7 @@ algebra_field_expr (const expr_t *mvec, const expr_t *field_name)
|
|||
auto mvec_struct = get_mvec_struct (mvec_type);
|
||||
auto field = mvec_struct ? symtab_lookup (mvec_struct, field_sym->name) : 0;
|
||||
if (!field) {
|
||||
mvec_struct = algebra->mvec_sym->type->t.symtab;
|
||||
mvec_struct = algebra->mvec_sym->type->symtab;
|
||||
field = symtab_lookup (mvec_struct, field_sym->name);
|
||||
if (field) {
|
||||
debug (field_name, "'%s' not in sub-type '%s' of '%s', "
|
||||
|
|
|
|||
|
|
@ -366,7 +366,7 @@ assign_expr (const expr_t *dst, const expr_t *src)
|
|||
if (is_ptr (dst_type) && is_array (src_type)) {
|
||||
// assigning an array to a pointer is the same as taking the address of
|
||||
// the array but using the type of the array elements
|
||||
src = address_expr (src, src_type->t.fldptr.type);
|
||||
src = address_expr (src, src_type->fldptr.type);
|
||||
src_type = get_type (src);
|
||||
}
|
||||
if (src->type == ex_bool) {
|
||||
|
|
|
|||
|
|
@ -924,7 +924,7 @@ pointer_arithmetic (int op, const expr_t *e1, const expr_t *e2)
|
|||
}
|
||||
e1 = cast_expr (&type_int, e1);
|
||||
e2 = cast_expr (&type_int, e2);
|
||||
psize = new_int_expr (type_size (t1->t.fldptr.type), false);
|
||||
psize = new_int_expr (type_size (t1->fldptr.type), false);
|
||||
return binary_expr ('/', binary_expr ('-', e1, e2), psize);
|
||||
} else if (is_ptr (t1)) {
|
||||
offset = cast_expr (&type_int, e2);
|
||||
|
|
@ -936,7 +936,7 @@ pointer_arithmetic (int op, const expr_t *e1, const expr_t *e2)
|
|||
ptype = t2;
|
||||
}
|
||||
// op is known to be + or -
|
||||
psize = new_int_expr (type_size (ptype->t.fldptr.type), false);
|
||||
psize = new_int_expr (type_size (ptype->fldptr.type), false);
|
||||
offset = unary_expr (op, binary_expr ('*', offset, psize));
|
||||
return offset_pointer_expr (ptr, offset);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ cast_expr (const type_t *dstType, const expr_t *e)
|
|||
return cast_error (e, srcType, dstType);
|
||||
}
|
||||
if (is_array (srcType)) {
|
||||
return address_expr (e, dstType->t.fldptr.type);
|
||||
return address_expr (e, dstType->fldptr.type);
|
||||
}
|
||||
if (is_short (srcType)) {
|
||||
e = new_int_expr (expr_short (e), false);
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ designator_field (const designator_t *des, const type_t *type)
|
|||
error (des->index, "designator index in non-array");
|
||||
return 0;
|
||||
}
|
||||
symtab_t *symtab = type->t.symtab;
|
||||
symtab_t *symtab = type->symtab;
|
||||
symbol_t *sym = des->field->symbol;
|
||||
symbol_t *field = symtab_lookup (symtab, sym->name);
|
||||
if (!field) {
|
||||
|
|
@ -161,12 +161,12 @@ get_designated_offset (const type_t *type, const designator_t *des)
|
|||
offset = field->offset;
|
||||
ele_type = field->type;
|
||||
} else if (is_array (type)) {
|
||||
int array_size = type->t.array.size;
|
||||
int array_size = type->array.size;
|
||||
ele_type = dereference_type (type);
|
||||
offset = designator_index (des, type_size (ele_type), array_size);
|
||||
} else if (is_nonscalar (type)) {
|
||||
ele_type = ev_types[type->type];
|
||||
if (type->t.symtab && des->field) {
|
||||
if (type->symtab && des->field) {
|
||||
field = designator_field (des, type);
|
||||
offset = field->offset;
|
||||
} else {
|
||||
|
|
@ -220,8 +220,8 @@ build_element_chain (element_chain_t *element_chain, const type_t *type,
|
|||
}
|
||||
type = t;
|
||||
} else if (is_struct (type) || is_union (type)
|
||||
|| (is_nonscalar (type) && type->t.symtab)) {
|
||||
state.field = type->t.symtab->symbols;
|
||||
|| (is_nonscalar (type) && type->symtab)) {
|
||||
state.field = type->symtab->symbols;
|
||||
while (state.field && skip_field (state.field)) {
|
||||
state.field = state.field->next;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -99,13 +99,13 @@ selector_expr (keywordarg_t *selector)
|
|||
selector = (keywordarg_t *) reverse_params ((param_t *) selector);
|
||||
selector_name (sel_id, selector);
|
||||
index = selector_index (sel_id->str);
|
||||
index *= type_size (type_SEL.t.fldptr.type);
|
||||
index *= type_size (type_SEL.fldptr.type);
|
||||
sel_sym = make_symbol ("_OBJ_SELECTOR_TABLE_PTR", &type_SEL,
|
||||
pr.near_data, sc_static);
|
||||
if (!sel_sym->table) {
|
||||
symtab_addsymbol (pr.symtab, sel_sym);
|
||||
sel_table = make_symbol ("_OBJ_SELECTOR_TABLE",
|
||||
array_type (type_SEL.t.fldptr.type, 0),
|
||||
array_type (type_SEL.fldptr.type, 0),
|
||||
pr.far_data, sc_extern);
|
||||
if (!sel_table->table)
|
||||
symtab_addsymbol (pr.symtab, sel_table);
|
||||
|
|
@ -211,7 +211,7 @@ message_expr (const expr_t *receiver, keywordarg_t *message)
|
|||
} else if (receiver->symbol->sy_type == sy_class) {
|
||||
class_t *class;
|
||||
rec_type = receiver->symbol->type;
|
||||
class = rec_type->t.class;
|
||||
class = rec_type->class;
|
||||
class_msg = 1;
|
||||
receiver = new_symbol_expr (class_pointer_symbol (class));
|
||||
}
|
||||
|
|
@ -226,7 +226,7 @@ message_expr (const expr_t *receiver, keywordarg_t *message)
|
|||
return_type = &type_id;
|
||||
method = class_message_response (rec_type, class_msg, selector);
|
||||
if (method)
|
||||
return_type = method->type->t.func.ret_type;
|
||||
return_type = method->type->func.ret_type;
|
||||
|
||||
scoped_src_loc (receiver);
|
||||
expr_t *args = new_list_expr (0);
|
||||
|
|
|
|||
|
|
@ -278,7 +278,7 @@ parse_generic_function (const char *name, specifier_t spec)
|
|||
// fake parameter for the return type
|
||||
param_t ret_param = {
|
||||
.next = spec.sym->params,
|
||||
.type = spec.sym->type->t.func.ret_type,
|
||||
.type = spec.sym->type->func.ret_type,
|
||||
.type_expr = spec.type_expr,
|
||||
};
|
||||
int num_params = 0;
|
||||
|
|
@ -448,8 +448,8 @@ parse_params (const type_t *return_type, param_t *parms)
|
|||
new->alignment = 1;
|
||||
new->width = 1;
|
||||
new->columns = 1;
|
||||
new->t.func.ret_type = return_type;
|
||||
new->t.func.num_params = 0;
|
||||
new->func.ret_type = return_type;
|
||||
new->func.num_params = 0;
|
||||
|
||||
for (p = parms; p; p = p->next) {
|
||||
if (p->type) {
|
||||
|
|
@ -457,21 +457,21 @@ parse_params (const type_t *return_type, param_t *parms)
|
|||
}
|
||||
}
|
||||
if (count) {
|
||||
new->t.func.param_types = malloc (count * sizeof (type_t));
|
||||
new->func.param_types = malloc (count * sizeof (type_t));
|
||||
}
|
||||
for (p = parms; p; p = p->next) {
|
||||
if (!p->selector && !p->type && !p->name) {
|
||||
if (p->next)
|
||||
internal_error (0, 0);
|
||||
new->t.func.num_params = -(new->t.func.num_params + 1);
|
||||
new->func.num_params = -(new->func.num_params + 1);
|
||||
} else if (p->type) {
|
||||
if (is_class (p->type)) {
|
||||
error (0, "cannot use an object as a parameter (forgot *?)");
|
||||
p->type = &type_id;
|
||||
}
|
||||
auto ptype = unalias_type (p->type);
|
||||
new->t.func.param_types[new->t.func.num_params] = ptype;
|
||||
new->t.func.num_params++;
|
||||
new->func.param_types[new->func.num_params] = ptype;
|
||||
new->func.num_params++;
|
||||
}
|
||||
}
|
||||
return new;
|
||||
|
|
@ -596,8 +596,8 @@ func_compare (const void *a, const void *b)
|
|||
overloaded_function_t *fb = *(overloaded_function_t **) b;
|
||||
const type_t *ta = fa->type;
|
||||
const type_t *tb = fb->type;
|
||||
int na = ta->t.func.num_params;
|
||||
int nb = tb->t.func.num_params;
|
||||
int na = ta->func.num_params;
|
||||
int nb = tb->func.num_params;
|
||||
int ret, i;
|
||||
|
||||
if (na < 0)
|
||||
|
|
@ -606,10 +606,10 @@ func_compare (const void *a, const void *b)
|
|||
nb = ~nb;
|
||||
if (na != nb)
|
||||
return nb - na;
|
||||
if ((ret = (tb->t.func.num_params - ta->t.func.num_params)))
|
||||
if ((ret = (tb->func.num_params - ta->func.num_params)))
|
||||
return ret;
|
||||
for (i = 0; i < na && i < nb; i++) {
|
||||
auto diff = tb->t.func.param_types[i] - ta->t.func.param_types[i];
|
||||
auto diff = tb->func.param_types[i] - ta->func.param_types[i];
|
||||
if (diff) {
|
||||
return diff < 0 ? -1 : 1;
|
||||
}
|
||||
|
|
@ -663,8 +663,8 @@ find_generic_function (const expr_t *fexpr, genfunc_t **genfuncs,
|
|||
for (auto gf = genfuncs; *gf; gf++, num_funcs++) continue;
|
||||
unsigned costs[num_funcs] = {};
|
||||
|
||||
int num_params = call_type->t.func.num_params;
|
||||
auto call_params = call_type->t.func.param_types;
|
||||
int num_params = call_type->func.num_params;
|
||||
auto call_params = call_type->func.param_types;
|
||||
for (int j = 0; j < num_funcs; j++) {
|
||||
auto g = genfuncs[j];
|
||||
if (g->num_params != num_params) {
|
||||
|
|
@ -742,7 +742,7 @@ find_generic_function (const expr_t *fexpr, genfunc_t **genfuncs,
|
|||
type_t ftype = {
|
||||
.type = ev_func,
|
||||
|
||||
.t.func = {
|
||||
.func = {
|
||||
.ret_type = return_type,
|
||||
.num_params = num_params,
|
||||
.param_types = param_types,
|
||||
|
|
@ -791,7 +791,7 @@ find_function (const expr_t *fexpr, const expr_t *params)
|
|||
|
||||
type_t call_type = {
|
||||
.type = ev_func,
|
||||
.t.func = {
|
||||
.func = {
|
||||
.num_params = num_params,
|
||||
.param_types = arg_types,
|
||||
},
|
||||
|
|
@ -813,7 +813,7 @@ find_function (const expr_t *fexpr, const expr_t *params)
|
|||
return fexpr;
|
||||
}
|
||||
}
|
||||
call_type.t.func.ret_type = funcs[0]->type->t.func.ret_type;
|
||||
call_type.func.ret_type = funcs[0]->type->func.ret_type;
|
||||
dummy.type = find_type (&call_type);
|
||||
|
||||
qsort (funcs, func_count, sizeof (void *), func_compare);
|
||||
|
|
@ -831,9 +831,9 @@ find_function (const expr_t *fexpr, const expr_t *params)
|
|||
}
|
||||
for (int i = 0; i < func_count; i++) {
|
||||
auto f = (overloaded_function_t *) funcs[i];
|
||||
parm_count = f->type->t.func.num_params;
|
||||
if ((parm_count >= 0 && parm_count != call_type.t.func.num_params)
|
||||
|| (parm_count < 0 && ~parm_count > call_type.t.func.num_params)) {
|
||||
parm_count = f->type->func.num_params;
|
||||
if ((parm_count >= 0 && parm_count != call_type.func.num_params)
|
||||
|| (parm_count < 0 && ~parm_count > call_type.func.num_params)) {
|
||||
funcs[i] = 0;
|
||||
continue;
|
||||
}
|
||||
|
|
@ -841,8 +841,8 @@ find_function (const expr_t *fexpr, const expr_t *params)
|
|||
parm_count = ~parm_count;
|
||||
int j;
|
||||
for (j = 0; j < parm_count; j++) {
|
||||
if (!type_assignable (f->type->t.func.param_types[j],
|
||||
call_type.t.func.param_types[j])) {
|
||||
if (!type_assignable (f->type->func.param_types[j],
|
||||
call_type.func.param_types[j])) {
|
||||
funcs[i] = 0;
|
||||
break;
|
||||
}
|
||||
|
|
@ -899,14 +899,14 @@ check_function (symbol_t *fsym)
|
|||
param_t *p;
|
||||
int i;
|
||||
|
||||
if (!type_size (fsym->type->t.func.ret_type)) {
|
||||
if (!type_size (fsym->type->func.ret_type)) {
|
||||
error (0, "return type is an incomplete type");
|
||||
//fsym->type->t.func.type = &type_void;//FIXME better type?
|
||||
//fsym->type->func.type = &type_void;//FIXME better type?
|
||||
}
|
||||
if (value_too_large (fsym->type->t.func.ret_type)) {
|
||||
if (value_too_large (fsym->type->func.ret_type)) {
|
||||
error (0, "return value too large to be passed by value (%d)",
|
||||
type_size (&type_param));
|
||||
//fsym->type->t.func.type = &type_void;//FIXME better type?
|
||||
//fsym->type->func.type = &type_void;//FIXME better type?
|
||||
}
|
||||
for (p = params, i = 0; p; p = p->next, i++) {
|
||||
if (!p->selector && !p->type && !p->name)
|
||||
|
|
@ -934,7 +934,7 @@ build_v6p_scope (symbol_t *fsym)
|
|||
symtab_t *parameters = fsym->func->parameters;
|
||||
symtab_t *locals = fsym->func->locals;
|
||||
|
||||
if (fsym->func->type->t.func.num_params < 0) {
|
||||
if (fsym->func->type->func.num_params < 0) {
|
||||
args = new_symbol_type (".args", &type_va_list);
|
||||
initialize_def (args, 0, parameters->space, sc_param, locals);
|
||||
}
|
||||
|
|
@ -1129,7 +1129,7 @@ static void
|
|||
build_function (symbol_t *fsym)
|
||||
{
|
||||
const type_t *func_type = fsym->func->type;
|
||||
if (func_type->t.func.num_params > PR_MAX_PARAMS) {
|
||||
if (func_type->func.num_params > PR_MAX_PARAMS) {
|
||||
error (0, "too many params");
|
||||
}
|
||||
}
|
||||
|
|
@ -1327,7 +1327,7 @@ int
|
|||
function_parms (function_t *f, byte *parm_size)
|
||||
{
|
||||
int count, i;
|
||||
auto func = &f->sym->type->t.func;
|
||||
auto func = &f->sym->type->func;
|
||||
|
||||
if (func->num_params >= 0)
|
||||
count = func->num_params;
|
||||
|
|
|
|||
|
|
@ -496,7 +496,7 @@ get_selector (const expr_t *sel)
|
|||
return 0;
|
||||
}
|
||||
_sel.index = expr_short (sel->address.offset);
|
||||
_sel.index /= type_size (type_SEL.t.fldptr.type);
|
||||
_sel.index /= type_size (type_SEL.fldptr.type);
|
||||
return (selector_t *) Hash_FindElement (sel_index_hash, &_sel);
|
||||
}
|
||||
|
||||
|
|
@ -512,7 +512,7 @@ emit_selectors (void)
|
|||
if (!sel_index)
|
||||
return 0;
|
||||
|
||||
sel_type = array_type (type_SEL.t.fldptr.type, sel_index);
|
||||
sel_type = array_type (type_SEL.fldptr.type, sel_index);
|
||||
sel_sym = make_symbol ("_OBJ_SELECTOR_TABLE", sel_type,
|
||||
pr.far_data, sc_static);
|
||||
if (!sel_sym->table)
|
||||
|
|
@ -707,25 +707,25 @@ method_check_params (method_t *method, const expr_t *args)
|
|||
const expr_t *err = 0;
|
||||
auto mtype = method->type;
|
||||
|
||||
if (mtype->t.func.num_params == -1)
|
||||
if (mtype->func.num_params == -1)
|
||||
return 0;
|
||||
|
||||
if (mtype->t.func.num_params >= 0)
|
||||
param_count = mtype->t.func.num_params;
|
||||
if (mtype->func.num_params >= 0)
|
||||
param_count = mtype->func.num_params;
|
||||
else
|
||||
param_count = -mtype->t.func.num_params - 1;
|
||||
param_count = -mtype->func.num_params - 1;
|
||||
|
||||
int count = list_count (&args->list);
|
||||
if (count < param_count)
|
||||
return error (args, "too few arguments");
|
||||
if (mtype->t.func.num_params >= 0 && count > mtype->t.func.num_params)
|
||||
if (mtype->func.num_params >= 0 && count > mtype->func.num_params)
|
||||
return error (args, "too many arguments");
|
||||
|
||||
const expr_t *arg_list[count];
|
||||
list_scatter_rev (&args->list, arg_list);
|
||||
for (i = 2; i < count; i++) {
|
||||
const expr_t *e = arg_list[i];
|
||||
const type_t *arg_type = i < param_count ? mtype->t.func.param_types[i]
|
||||
const type_t *arg_type = i < param_count ? mtype->func.param_types[i]
|
||||
: nullptr;
|
||||
if (e->type == ex_compound) {
|
||||
scoped_src_loc (e);
|
||||
|
|
|
|||
|
|
@ -106,14 +106,13 @@ qfo_encode_func (const type_t *type, defspace_t *space)
|
|||
def_t *def;
|
||||
int i;
|
||||
|
||||
param_count = type->t.func.num_params;
|
||||
param_count = type->func.num_params;
|
||||
if (param_count < 0)
|
||||
param_count = ~param_count;
|
||||
param_type_defs = alloca (param_count * sizeof (def_t *));
|
||||
return_type_def = qfo_encode_type (type->t.func.ret_type, space);
|
||||
return_type_def = qfo_encode_type (type->func.ret_type, space);
|
||||
for (i = 0; i < param_count; i++)
|
||||
param_type_defs[i] = qfo_encode_type (type->t.func.param_types[i],
|
||||
space);
|
||||
param_type_defs[i] = qfo_encode_type (type->func.param_types[i], space);
|
||||
size = field_offset (qfot_func_t, param_types[param_count]);
|
||||
|
||||
def = qfo_new_encoding (type, size, space);
|
||||
|
|
@ -121,7 +120,7 @@ qfo_encode_func (const type_t *type, defspace_t *space)
|
|||
func = &enc->func;
|
||||
func->type = ev_func;
|
||||
ENC_DEF (func->return_type, return_type_def);
|
||||
func->num_params = type->t.func.num_params;
|
||||
func->num_params = type->func.num_params;
|
||||
for (i = 0; i < param_count; i++)
|
||||
ENC_DEF (func->param_types[i], param_type_defs[i]);
|
||||
return def;
|
||||
|
|
@ -134,7 +133,7 @@ qfo_encode_fldptr (const type_t *type, defspace_t *space)
|
|||
def_t *def;
|
||||
def_t *type_def;
|
||||
|
||||
type_def = qfo_encode_type (type->t.fldptr.type, space);
|
||||
type_def = qfo_encode_type (type->fldptr.type, space);
|
||||
def = qfo_new_encoding (type, sizeof (enc->fldptr), space);
|
||||
enc = D_POINTER (qfot_type_t, def);
|
||||
enc->fldptr.type = type->type;
|
||||
|
|
@ -178,11 +177,11 @@ qfo_encode_struct (const type_t *type, defspace_t *space)
|
|||
sy = sy_var;
|
||||
if (type->meta == ty_enum)
|
||||
sy = sy_const;
|
||||
if (!type->t.symtab) {
|
||||
if (!type->symtab) {
|
||||
def = new_def (type->encoding, 0, pr.type_data, sc_extern);
|
||||
return def;
|
||||
}
|
||||
for (num_fields = 0, sym = type->t.symtab->symbols; sym; sym = sym->next) {
|
||||
for (num_fields = 0, sym = type->symtab->symbols; sym; sym = sym->next) {
|
||||
if (sym->sy_type != sy)
|
||||
continue;
|
||||
num_fields++;
|
||||
|
|
@ -198,7 +197,7 @@ qfo_encode_struct (const type_t *type, defspace_t *space)
|
|||
((type_t *)type)->type_def = def; // avoid infinite recursion
|
||||
|
||||
field_types = alloca (num_fields * sizeof (def_t *));
|
||||
for (i = 0, sym = type->t.symtab->symbols; sym; sym = sym->next) {
|
||||
for (i = 0, sym = type->symtab->symbols; sym; sym = sym->next) {
|
||||
if (sym->sy_type != sy)
|
||||
continue;
|
||||
if (i == num_fields)
|
||||
|
|
@ -211,7 +210,7 @@ qfo_encode_struct (const type_t *type, defspace_t *space)
|
|||
i++;
|
||||
}
|
||||
|
||||
for (i = 0, sym = type->t.symtab->symbols; sym; sym = sym->next) {
|
||||
for (i = 0, sym = type->symtab->symbols; sym; sym = sym->next) {
|
||||
if (sym->sy_type != sy)
|
||||
continue;
|
||||
if (i == num_fields)
|
||||
|
|
@ -235,13 +234,13 @@ qfo_encode_array (const type_t *type, defspace_t *space)
|
|||
def_t *def;
|
||||
def_t *array_type_def;
|
||||
|
||||
array_type_def = qfo_encode_type (type->t.array.type, space);
|
||||
array_type_def = qfo_encode_type (type->array.type, space);
|
||||
|
||||
def = qfo_new_encoding (type, sizeof (enc->array), space);
|
||||
enc = D_POINTER (qfot_type_t, def);
|
||||
ENC_DEF (enc->array.type, array_type_def);
|
||||
enc->array.base = type->t.array.base;
|
||||
enc->array.size = type->t.array.size;
|
||||
enc->array.base = type->array.base;
|
||||
enc->array.size = type->array.size;
|
||||
return def;
|
||||
}
|
||||
|
||||
|
|
@ -253,7 +252,7 @@ qfo_encode_class (const type_t *type, defspace_t *space)
|
|||
|
||||
def = qfo_new_encoding (type, sizeof (enc->class), space);
|
||||
enc = D_POINTER (qfot_type_t, def);
|
||||
ENC_STR (enc->class, type->t.class->name);
|
||||
ENC_STR (enc->class, type->class->name);
|
||||
return def;
|
||||
}
|
||||
|
||||
|
|
@ -265,8 +264,8 @@ qfo_encode_alias (const type_t *type, defspace_t *space)
|
|||
def_t *type_def;
|
||||
def_t *full_def;
|
||||
|
||||
type_def = qfo_encode_type (type->t.alias.aux_type, space);
|
||||
full_def = qfo_encode_type (type->t.alias.full_type, space);
|
||||
type_def = qfo_encode_type (type->alias.aux_type, space);
|
||||
full_def = qfo_encode_type (type->alias.full_type, space);
|
||||
|
||||
def = qfo_new_encoding (type, sizeof (enc->alias), space);
|
||||
enc = D_POINTER (qfot_type_t, def);
|
||||
|
|
@ -300,7 +299,7 @@ qfo_encode_algebra (const type_t *type, defspace_t *space)
|
|||
def_t *algebra_type_def = 0;
|
||||
|
||||
if (type->type != ev_invalid) {
|
||||
auto m = (multivector_t *) type->t.algebra;
|
||||
auto m = (multivector_t *) type->algebra;
|
||||
algebra_type_def = qfo_encode_type (m->algebra->type, space);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -451,7 +451,7 @@ qc_function_spec (specifier_t spec, param_t *params)
|
|||
// .float () foo; is a field holding a function variable rather
|
||||
// than a function that returns a float field.
|
||||
for (type = &spec.type; *type && is_field (*type);
|
||||
type = (const type_t **) &(*type)->t.fldptr.type) {
|
||||
type = (const type_t **) &(*type)->fldptr.type) {
|
||||
}
|
||||
const type_t *ret_type = *type;
|
||||
*type = 0;
|
||||
|
|
@ -527,7 +527,7 @@ is_anonymous_struct (specifier_t spec)
|
|||
if (!is_struct (spec.type) && !is_union (spec.type)) {
|
||||
return 0;
|
||||
}
|
||||
if (!spec.type->t.symtab || spec.type->t.symtab->parent) {
|
||||
if (!spec.type->symtab || spec.type->symtab->parent) {
|
||||
return 0;
|
||||
}
|
||||
// struct and union type names always begin with "tag ". Untagged s/u
|
||||
|
|
@ -1042,7 +1042,7 @@ typespec_nonreserved
|
|||
| OBJECT_NAME protocolrefs
|
||||
{
|
||||
if ($2) {
|
||||
type_t type = *type_id.t.fldptr.type;
|
||||
type_t type = *type_id.fldptr.type;
|
||||
type.next = 0;
|
||||
type.protos = $2;
|
||||
$$ = type_spec (pointer_type (find_type (&type)));
|
||||
|
|
@ -1288,7 +1288,7 @@ enum_init
|
|||
{
|
||||
$$ = find_enum ($<symbol>-1);
|
||||
start_enum ($$);
|
||||
current_symtab = $$->type->t.symtab;
|
||||
current_symtab = $$->type->symtab;
|
||||
}
|
||||
;
|
||||
|
||||
|
|
@ -1381,7 +1381,7 @@ struct_defs
|
|||
// replace the struct symbol table with one built from
|
||||
// the class ivars and the current struct fields. ivars
|
||||
// will replace any fields of the same name.
|
||||
current_symtab = class_to_struct ($3->type->t.class,
|
||||
current_symtab = class_to_struct ($3->type->class,
|
||||
current_symtab);
|
||||
}
|
||||
}
|
||||
|
|
@ -2110,7 +2110,7 @@ class_name
|
|||
error (0, "`%s' is not a class", $1->name);
|
||||
$$ = get_class (0, 1);
|
||||
} else {
|
||||
$$ = $1->type->t.class;
|
||||
$$ = $1->type->class;
|
||||
}
|
||||
}
|
||||
;
|
||||
|
|
|
|||
|
|
@ -186,10 +186,10 @@ static symbol_t *
|
|||
function_value (function_t *func)
|
||||
{
|
||||
symbol_t *ret = 0;
|
||||
if (func->type->t.func.ret_type) {
|
||||
if (func->type->func.ret_type) {
|
||||
ret = symtab_lookup (func->locals, ".ret");
|
||||
if (!ret || ret->table != func->locals) {
|
||||
ret = new_symbol_type (".ret", func->type->t.func.ret_type);
|
||||
ret = new_symbol_type (".ret", func->type->func.ret_type);
|
||||
initialize_def (ret, 0, func->locals->space, sc_local,
|
||||
func->locals);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -686,7 +686,7 @@ statement_get_targetlist (statement_t *s)
|
|||
count = 1;
|
||||
} else if (statement_is_jumpb (s)) {
|
||||
table = s->opa->def;
|
||||
count = table->type->t.array.size;
|
||||
count = table->type->array.size;
|
||||
}
|
||||
target_list = malloc ((count + 1) * sizeof (sblock_t *));
|
||||
target_list[count] = 0;
|
||||
|
|
@ -1349,7 +1349,7 @@ ptr_addressing_mode (sblock_t *sblock, const expr_t *ref,
|
|||
offs = lvalue->alias.offset;
|
||||
}
|
||||
}
|
||||
type = type->t.fldptr.type;
|
||||
type = type->fldptr.type;
|
||||
if (offs) {
|
||||
const expr_t *lv = lvalue->alias.expr;
|
||||
auto lvtype = get_type (lv);
|
||||
|
|
@ -2627,7 +2627,7 @@ check_final_block (sblock_t *sblock)
|
|||
if (statement_is_return (s))
|
||||
return;
|
||||
}
|
||||
if (!is_void(current_func->sym->type->t.func.ret_type))
|
||||
if (!is_void(current_func->sym->type->func.ret_type))
|
||||
warning (0, "control reaches end of non-void function");
|
||||
if (s && s->type >= st_func) {
|
||||
// func and flow end blocks, so we need to add a new block to take the
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ start_struct (int *su, symbol_t *tag, symtab_t *parent)
|
|||
tag->type = sym->type;
|
||||
}
|
||||
if (sym->type->meta == ty_enum
|
||||
|| (sym->type->meta == ty_struct && sym->type->t.symtab)) {
|
||||
|| (sym->type->meta == ty_struct && sym->type->symtab)) {
|
||||
error (0, "%s %s redefined",
|
||||
*su == 's' ? "struct" : "union", tag->name);
|
||||
*su = 0;
|
||||
|
|
@ -166,7 +166,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
|
|||
|
||||
symtab->parent = 0; // disconnect struct's symtab from parent scope
|
||||
|
||||
if (sym->table == current_symtab && sym->type->t.symtab) {
|
||||
if (sym->table == current_symtab && sym->type->symtab) {
|
||||
error (0, "%s defined as wrong kind of tag", tag->name);
|
||||
return sym;
|
||||
}
|
||||
|
|
@ -175,7 +175,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
|
|||
continue;
|
||||
if (is_class (s->type)) {
|
||||
error (0, "statically allocated instance of class %s",
|
||||
s->type->t.class->name);
|
||||
s->type->class->name);
|
||||
}
|
||||
if (su == 's') {
|
||||
symtab->size = RUP (symtab->size + base, s->type->alignment) - base;
|
||||
|
|
@ -198,7 +198,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
|
|||
if (!is_struct (s->type) && !is_union (s->type)) {
|
||||
internal_error (0, "non-struct/union anonymous field");
|
||||
}
|
||||
anonymous = s->type->t.symtab;
|
||||
anonymous = s->type->symtab;
|
||||
for (as = anonymous->symbols; as; as = as->next) {
|
||||
if (as->visibility == vis_anonymous || as->sy_type!= sy_var) {
|
||||
continue;
|
||||
|
|
@ -220,7 +220,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
|
|||
}
|
||||
if (!type)
|
||||
sym->type = find_type (sym->type); // checks the tag, not the symtab
|
||||
((type_t *) sym->type)->t.symtab = symtab;
|
||||
((type_t *) sym->type)->symtab = symtab;
|
||||
if (alignment > sym->type->alignment) {
|
||||
((type_t *) sym->type)->alignment = alignment;
|
||||
}
|
||||
|
|
@ -239,15 +239,15 @@ find_enum (symbol_t *tag)
|
|||
symtab_t *
|
||||
start_enum (symbol_t *sym)
|
||||
{
|
||||
if (sym->table == current_symtab && sym->type->t.symtab) {
|
||||
if (sym->table == current_symtab && sym->type->symtab) {
|
||||
error (0, "%s defined as wrong kind of tag", sym->name);
|
||||
sym = find_enum (0);
|
||||
}
|
||||
((type_t *) sym->type)->t.symtab = new_symtab (current_symtab, stab_enum);
|
||||
((type_t *) sym->type)->symtab = new_symtab (current_symtab, stab_enum);
|
||||
((type_t *) sym->type)->alignment = 1;
|
||||
((type_t *) sym->type)->width = 1;
|
||||
((type_t *) sym->type)->columns = 1;
|
||||
return sym->type->t.symtab;
|
||||
return sym->type->symtab;
|
||||
}
|
||||
|
||||
symbol_t *
|
||||
|
|
@ -258,7 +258,7 @@ finish_enum (symbol_t *sym)
|
|||
symtab_t *enum_tab;
|
||||
|
||||
auto enum_type = sym->type = find_type (sym->type);
|
||||
enum_tab = enum_type->t.symtab;
|
||||
enum_tab = enum_type->symtab;
|
||||
|
||||
for (name = enum_tab->symbols; name; name = name->next) {
|
||||
name->type = sym->type;
|
||||
|
|
@ -275,7 +275,7 @@ void
|
|||
add_enum (symbol_t *enm, symbol_t *name, const expr_t *val)
|
||||
{
|
||||
auto enum_type = enm->type;
|
||||
symtab_t *enum_tab = enum_type->t.symtab;
|
||||
symtab_t *enum_tab = enum_type->symtab;
|
||||
int value;
|
||||
|
||||
if (name->table == current_symtab || name->table == enum_tab)
|
||||
|
|
@ -303,7 +303,7 @@ add_enum (symbol_t *enm, symbol_t *name, const expr_t *val)
|
|||
int
|
||||
enum_as_bool (const type_t *enm, expr_t **zero, expr_t **one)
|
||||
{
|
||||
symtab_t *symtab = enm->t.symtab;
|
||||
symtab_t *symtab = enm->symtab;
|
||||
symbol_t *zero_sym = 0;
|
||||
symbol_t *one_sym = 0;
|
||||
symbol_t *sym;
|
||||
|
|
@ -377,7 +377,7 @@ emit_structure (const char *name, int su, struct_def_t *defs,
|
|||
type = make_structure (0, su, defs, 0)->type;
|
||||
if ((su == 's' && !is_struct (type)) || (su == 'u' && !is_union (type)))
|
||||
internal_error (0, "structure %s type mismatch", name);
|
||||
for (i = 0, field_sym = type->t.symtab->symbols; field_sym;
|
||||
for (i = 0, field_sym = type->symtab->symbols; field_sym;
|
||||
i++, field_sym = field_sym->next) {
|
||||
if (!defs[i].name)
|
||||
internal_error (0, "structure %s unexpected end of defs", name);
|
||||
|
|
@ -407,7 +407,7 @@ emit_structure (const char *name, int su, struct_def_t *defs,
|
|||
struct_def->initialized = struct_def->constant = 1;
|
||||
struct_def->nosave = 1;
|
||||
|
||||
for (i = 0, field_sym = type->t.symtab->symbols; field_sym;
|
||||
for (i = 0, field_sym = type->symtab->symbols; field_sym;
|
||||
i++, field_sym = field_sym->next) {
|
||||
field_def.type = field_sym->type;
|
||||
field_def.name = save_string (va (0, "%s.%s", name, field_sym->name));
|
||||
|
|
@ -422,7 +422,7 @@ emit_structure (const char *name, int su, struct_def_t *defs,
|
|||
} else {
|
||||
if (is_array (field_def.type)) {
|
||||
auto type = dereference_type (field_def.type);
|
||||
for (j = 0; j < field_def.type->t.array.size; j++) {
|
||||
for (j = 0; j < field_def.type->array.size; j++) {
|
||||
defs[i].emit (&field_def, data, j);
|
||||
field_def.offset += type_size (type);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -381,7 +381,7 @@ check_enum_switch (switch_block_t *switch_block)
|
|||
symbol_t *enum_val;
|
||||
auto type = get_type (switch_block->test);
|
||||
|
||||
for (enum_val = type->t.symtab->symbols; enum_val;
|
||||
for (enum_val = type->symtab->symbols; enum_val;
|
||||
enum_val = enum_val->next) {
|
||||
cl.value = new_int_expr (enum_val->value->int_val, false);
|
||||
if (!Hash_FindElement (switch_block->labels, &cl)) {
|
||||
|
|
|
|||
|
|
@ -229,8 +229,7 @@ make_symbol (const char *name, const type_t *type, defspace_t *space,
|
|||
sym = new_symbol_type (name, type);
|
||||
}
|
||||
if (sym->type != type) {
|
||||
if (is_array (sym->type) && is_array (type)
|
||||
&& !sym->type->t.array.size) {
|
||||
if (is_array (sym->type) && is_array (type) && !sym->type->array.size) {
|
||||
sym->type = type;
|
||||
} else {
|
||||
error (0, "%s redefined", name);
|
||||
|
|
|
|||
|
|
@ -306,14 +306,14 @@ free_type (type_t *type)
|
|||
break;
|
||||
case ev_field:
|
||||
case ev_ptr:
|
||||
free_type ((type_t *) type->t.fldptr.type);
|
||||
free_type ((type_t *) type->fldptr.type);
|
||||
break;
|
||||
case ev_func:
|
||||
free_type ((type_t *) type->t.func.ret_type);
|
||||
free_type ((type_t *) type->func.ret_type);
|
||||
break;
|
||||
case ev_invalid:
|
||||
if (type->meta == ty_array)
|
||||
free_type ((type_t *) type->t.array.type);
|
||||
free_type ((type_t *) type->array.type);
|
||||
break;
|
||||
}
|
||||
memset (type, 0, sizeof (*type));
|
||||
|
|
@ -350,12 +350,12 @@ copy_chain (type_t *type, type_t *append)
|
|||
internal_error (0, "copy basic type");
|
||||
case ev_field:
|
||||
case ev_ptr:
|
||||
n = (type_t **) &(*n)->t.fldptr.type;
|
||||
type = (type_t *) type->t.fldptr.type;
|
||||
n = (type_t **) &(*n)->fldptr.type;
|
||||
type = (type_t *) type->fldptr.type;
|
||||
break;
|
||||
case ev_func:
|
||||
n = (type_t **) &(*n)->t.func.ret_type;
|
||||
type = (type_t *) type->t.func.ret_type;
|
||||
n = (type_t **) &(*n)->func.ret_type;
|
||||
type = (type_t *) type->func.ret_type;
|
||||
break;
|
||||
case ev_invalid:
|
||||
internal_error (0, "invalid basic type");
|
||||
|
|
@ -363,8 +363,8 @@ copy_chain (type_t *type, type_t *append)
|
|||
}
|
||||
break;
|
||||
case ty_array:
|
||||
n = (type_t **) &(*n)->t.array.type;
|
||||
type = (type_t *) type->t.array.type;
|
||||
n = (type_t **) &(*n)->array.type;
|
||||
type = (type_t *) type->array.type;
|
||||
break;
|
||||
case ty_struct:
|
||||
case ty_union:
|
||||
|
|
@ -408,13 +408,13 @@ append_type (const type_t *type, const type_t *new)
|
|||
internal_error (0, "append to basic type");
|
||||
case ev_field:
|
||||
case ev_ptr:
|
||||
t = (const type_t **) &(*t)->t.fldptr.type;
|
||||
t = (const type_t **) &(*t)->fldptr.type;
|
||||
((type_t *) type)->alignment = 1;
|
||||
((type_t *) type)->width = 1;
|
||||
((type_t *) type)->columns = 1;
|
||||
break;
|
||||
case ev_func:
|
||||
t = (const type_t **) &(*t)->t.func.ret_type;
|
||||
t = (const type_t **) &(*t)->func.ret_type;
|
||||
((type_t *) type)->alignment = 1;
|
||||
((type_t *) type)->width = 1;
|
||||
((type_t *) type)->columns = 1;
|
||||
|
|
@ -425,7 +425,7 @@ append_type (const type_t *type, const type_t *new)
|
|||
}
|
||||
break;
|
||||
case ty_array:
|
||||
t = (const type_t **) &(*t)->t.array.type;
|
||||
t = (const type_t **) &(*t)->array.type;
|
||||
((type_t *) type)->alignment = new->alignment;
|
||||
((type_t *) type)->width = new->width;
|
||||
((type_t *) type)->columns = new->columns;
|
||||
|
|
@ -443,7 +443,7 @@ append_type (const type_t *type, const type_t *new)
|
|||
}
|
||||
if (type && new->meta == ty_alias) {
|
||||
auto chain = find_type (copy_chain ((type_t *) type, (type_t *) new));
|
||||
*t = new->t.alias.aux_type;
|
||||
*t = new->alias.aux_type;
|
||||
type = alias_type (type, chain, 0);
|
||||
} else {
|
||||
*t = new;
|
||||
|
|
@ -454,8 +454,8 @@ append_type (const type_t *type, const type_t *new)
|
|||
void
|
||||
set_func_type_attrs (const type_t *func, specifier_t spec)
|
||||
{
|
||||
((type_t *) func)->t.func.no_va_list = spec.no_va_list;//FIXME
|
||||
((type_t *) func)->t.func.void_return = spec.void_return;
|
||||
((type_t *) func)->func.no_va_list = spec.no_va_list;//FIXME
|
||||
((type_t *) func)->func.void_return = spec.void_return;
|
||||
}
|
||||
|
||||
specifier_t
|
||||
|
|
@ -554,16 +554,16 @@ find_type (const type_t *type)
|
|||
switch (type->type) {
|
||||
case ev_field:
|
||||
case ev_ptr:
|
||||
((type_t *) type)->t.fldptr.type = find_type (type->t.fldptr.type);
|
||||
((type_t *) type)->fldptr.type = find_type (type->fldptr.type);
|
||||
break;
|
||||
case ev_func:
|
||||
((type_t *) type)->t.func.ret_type = find_type (type->t.func.ret_type);
|
||||
count = type->t.func.num_params;
|
||||
((type_t *) type)->func.ret_type = find_type (type->func.ret_type);
|
||||
count = type->func.num_params;
|
||||
if (count < 0)
|
||||
count = ~count; // param count is one's complement
|
||||
for (i = 0; i < count; i++)
|
||||
((type_t *) type)->t.func.param_types[i]
|
||||
= find_type (type->t.func.param_types[i]);
|
||||
((type_t *) type)->func.param_types[i]
|
||||
= find_type (type->func.param_types[i]);
|
||||
break;
|
||||
default: // other types don't have aux data
|
||||
break;
|
||||
|
|
@ -574,13 +574,13 @@ find_type (const type_t *type)
|
|||
case ty_enum:
|
||||
break;
|
||||
case ty_array:
|
||||
((type_t *) type)->t.array.type = find_type (type->t.array.type);
|
||||
((type_t *) type)->array.type = find_type (type->array.type);
|
||||
break;
|
||||
case ty_class:
|
||||
break;
|
||||
case ty_alias:
|
||||
((type_t *) type)->t.alias.aux_type = find_type (type->t.alias.aux_type);
|
||||
((type_t *) type)->t.alias.full_type = find_type (type->t.alias.full_type);
|
||||
((type_t *) type)->alias.aux_type = find_type (type->alias.aux_type);
|
||||
((type_t *) type)->alias.full_type = find_type (type->alias.full_type);
|
||||
break;
|
||||
case ty_handle:
|
||||
break;
|
||||
|
|
@ -600,16 +600,16 @@ find_type (const type_t *type)
|
|||
check = new_type ();
|
||||
*check = *type;
|
||||
if (is_func (type)) {
|
||||
check->t.func.param_types = 0;
|
||||
check->func.param_types = 0;
|
||||
const type_t *t = unalias_type (type);
|
||||
int num_params = t->t.func.num_params;
|
||||
int num_params = t->func.num_params;
|
||||
if (num_params < 0) {
|
||||
num_params = ~num_params;
|
||||
}
|
||||
if (num_params) {
|
||||
check->t.func.param_types = malloc (sizeof (type_t *) * num_params);
|
||||
check->func.param_types = malloc (sizeof (type_t *) * num_params);
|
||||
for (int i = 0; i < num_params; i++) {
|
||||
check->t.func.param_types[i] = t->t.func.param_types[i];
|
||||
check->func.param_types[i] = t->func.param_types[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -799,7 +799,7 @@ array_type (const type_t *aux, int size)
|
|||
new->alignment = aux->alignment;
|
||||
new->width = aux->width;
|
||||
}
|
||||
new->t.array.size = size;
|
||||
new->array.size = size;
|
||||
if (aux) {
|
||||
return find_type (append_type (new, aux));
|
||||
}
|
||||
|
|
@ -822,9 +822,9 @@ based_array_type (const type_t *aux, int base, int top)
|
|||
new->width = aux->width;
|
||||
}
|
||||
new->meta = ty_array;
|
||||
new->t.array.type = aux;
|
||||
new->t.array.base = base;
|
||||
new->t.array.size = top - base + 1;
|
||||
new->array.type = aux;
|
||||
new->array.base = base;
|
||||
new->array.size = top - base + 1;
|
||||
if (aux) {
|
||||
return find_type (new);
|
||||
}
|
||||
|
|
@ -842,15 +842,15 @@ alias_type (const type_t *type, const type_t *alias_chain, const char *name)
|
|||
if (type == alias_chain && type->meta == ty_alias) {
|
||||
// typedef of a type that contains a typedef somewhere
|
||||
// grab the alias-free branch for type
|
||||
type = alias_chain->t.alias.aux_type;
|
||||
type = alias_chain->alias.aux_type;
|
||||
if (!alias_chain->name) {
|
||||
// the other typedef is further inside, so replace the unnamed
|
||||
// alias node with the typedef
|
||||
alias_chain = alias_chain->t.alias.full_type;
|
||||
alias_chain = alias_chain->alias.full_type;
|
||||
}
|
||||
}
|
||||
alias->t.alias.aux_type = type;
|
||||
alias->t.alias.full_type = alias_chain;
|
||||
alias->alias.aux_type = type;
|
||||
alias->alias.full_type = alias_chain;
|
||||
if (name) {
|
||||
alias->name = save_string (name);
|
||||
}
|
||||
|
|
@ -861,7 +861,7 @@ const type_t *
|
|||
unalias_type (const type_t *type)
|
||||
{
|
||||
if (type->meta == ty_alias) {
|
||||
type = type->t.alias.aux_type;
|
||||
type = type->alias.aux_type;
|
||||
if (type->meta == ty_alias) {
|
||||
internal_error (0, "alias type node in alias-free chain");
|
||||
}
|
||||
|
|
@ -876,9 +876,9 @@ dereference_type (const type_t *type)
|
|||
internal_error (0, "dereference non pointer/field/array type");
|
||||
}
|
||||
if (type->meta == ty_alias) {
|
||||
type = type->t.alias.full_type;
|
||||
type = type->alias.full_type;
|
||||
}
|
||||
return type->t.fldptr.type;
|
||||
return type->fldptr.type;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -899,11 +899,11 @@ print_type_str (dstring_t *str, const type_t *type)
|
|||
return;
|
||||
case ty_alias:
|
||||
dasprintf (str, "({%s=", type->name);
|
||||
print_type_str (str, type->t.alias.aux_type);
|
||||
print_type_str (str, type->alias.aux_type);
|
||||
dstring_appendstr (str, "})");
|
||||
return;
|
||||
case ty_class:
|
||||
dasprintf (str, " %s", type->t.class->name);
|
||||
dasprintf (str, " %s", type->class->name);
|
||||
if (type->protos)
|
||||
print_protocollist (str, type->protos);
|
||||
return;
|
||||
|
|
@ -917,12 +917,12 @@ print_type_str (dstring_t *str, const type_t *type)
|
|||
dasprintf (str, " union %s", type->name);
|
||||
return;
|
||||
case ty_array:
|
||||
print_type_str (str, type->t.array.type);
|
||||
if (type->t.array.base) {
|
||||
dasprintf (str, "[%d..%d]", type->t.array.base,
|
||||
type->t.array.base + type->t.array.size - 1);
|
||||
print_type_str (str, type->array.type);
|
||||
if (type->array.base) {
|
||||
dasprintf (str, "[%d..%d]", type->array.base,
|
||||
type->array.base + type->array.size - 1);
|
||||
} else {
|
||||
dasprintf (str, "[%d]", type->t.array.size);
|
||||
dasprintf (str, "[%d]", type->array.size);
|
||||
}
|
||||
return;
|
||||
case ty_bool:
|
||||
|
|
@ -934,32 +934,32 @@ print_type_str (dstring_t *str, const type_t *type)
|
|||
switch (type->type) {
|
||||
case ev_field:
|
||||
dasprintf (str, ".(");
|
||||
print_type_str (str, type->t.fldptr.type);
|
||||
print_type_str (str, type->fldptr.type);
|
||||
dasprintf (str, ")");
|
||||
return;
|
||||
case ev_func:
|
||||
print_type_str (str, type->t.func.ret_type);
|
||||
if (type->t.func.num_params == -1) {
|
||||
print_type_str (str, type->func.ret_type);
|
||||
if (type->func.num_params == -1) {
|
||||
dasprintf (str, "(...)");
|
||||
} else {
|
||||
int c, i;
|
||||
dasprintf (str, "(");
|
||||
if ((c = type->t.func.num_params) < 0)
|
||||
if ((c = type->func.num_params) < 0)
|
||||
c = ~c; // num_params is one's compliment
|
||||
for (i = 0; i < c; i++) {
|
||||
if (i)
|
||||
dasprintf (str, ", ");
|
||||
print_type_str (str, type->t.func.param_types[i]);
|
||||
print_type_str (str, type->func.param_types[i]);
|
||||
}
|
||||
if (type->t.func.num_params < 0)
|
||||
if (type->func.num_params < 0)
|
||||
dasprintf (str, ", ...");
|
||||
dasprintf (str, ")");
|
||||
}
|
||||
return;
|
||||
case ev_ptr:
|
||||
if (type->t.fldptr.type) {
|
||||
if (type->fldptr.type) {
|
||||
if (is_id (type)) {
|
||||
__auto_type ptr = type->t.fldptr.type;
|
||||
__auto_type ptr = type->fldptr.type;
|
||||
dasprintf (str, "id");
|
||||
if (ptr->protos)
|
||||
print_protocollist (str, ptr->protos);
|
||||
|
|
@ -971,7 +971,7 @@ print_type_str (dstring_t *str, const type_t *type)
|
|||
}
|
||||
}
|
||||
dasprintf (str, "(*");
|
||||
print_type_str (str, type->t.fldptr.type);
|
||||
print_type_str (str, type->fldptr.type);
|
||||
dasprintf (str, ")");
|
||||
return;
|
||||
case ev_void:
|
||||
|
|
@ -1035,13 +1035,13 @@ encode_params (const type_t *type)
|
|||
dstring_t *encoding = dstring_newstr ();
|
||||
int i, count;
|
||||
|
||||
if (type->t.func.num_params < 0)
|
||||
count = -type->t.func.num_params - 1;
|
||||
if (type->func.num_params < 0)
|
||||
count = -type->func.num_params - 1;
|
||||
else
|
||||
count = type->t.func.num_params;
|
||||
count = type->func.num_params;
|
||||
for (i = 0; i < count; i++)
|
||||
encode_type (encoding, unalias_type (type->t.func.param_types[i]));
|
||||
if (type->t.func.num_params < 0)
|
||||
encode_type (encoding, unalias_type (type->func.param_types[i]));
|
||||
if (type->func.num_params < 0)
|
||||
dasprintf (encoding, ".");
|
||||
|
||||
ret = save_string (encoding->str);
|
||||
|
|
@ -1052,7 +1052,7 @@ encode_params (const type_t *type)
|
|||
static void
|
||||
encode_class (dstring_t *encoding, const type_t *type)
|
||||
{
|
||||
class_t *class = type->t.class;
|
||||
class_t *class = type->class;
|
||||
const char *name ="?";
|
||||
|
||||
if (class->name)
|
||||
|
|
@ -1101,7 +1101,7 @@ encode_type (dstring_t *encoding, const type_t *type)
|
|||
return;
|
||||
case ty_alias:
|
||||
dasprintf (encoding, "{%s>", type->name ? type->name : "");
|
||||
encode_type (encoding, type->t.alias.full_type);
|
||||
encode_type (encoding, type->alias.full_type);
|
||||
dasprintf (encoding, "}");
|
||||
return;
|
||||
case ty_class:
|
||||
|
|
@ -1116,11 +1116,11 @@ encode_type (dstring_t *encoding, const type_t *type)
|
|||
return;
|
||||
case ty_array:
|
||||
dasprintf (encoding, "[");
|
||||
dasprintf (encoding, "%d", type->t.array.size);
|
||||
if (type->t.array.base)
|
||||
dasprintf (encoding, ":%d", type->t.array.base);
|
||||
dasprintf (encoding, "%d", type->array.size);
|
||||
if (type->array.base)
|
||||
dasprintf (encoding, ":%d", type->array.base);
|
||||
dasprintf (encoding, "=");
|
||||
encode_type (encoding, type->t.array.type);
|
||||
encode_type (encoding, type->array.type);
|
||||
dasprintf (encoding, "]");
|
||||
return;
|
||||
case ty_bool:
|
||||
|
|
@ -1167,11 +1167,11 @@ encode_type (dstring_t *encoding, const type_t *type)
|
|||
return;
|
||||
case ev_field:
|
||||
dasprintf (encoding, "F");
|
||||
encode_type (encoding, type->t.fldptr.type);
|
||||
encode_type (encoding, type->fldptr.type);
|
||||
return;
|
||||
case ev_func:
|
||||
dasprintf (encoding, "(");
|
||||
encode_type (encoding, type->t.func.ret_type);
|
||||
encode_type (encoding, type->func.ret_type);
|
||||
dasprintf (encoding, "%s)", encode_params (type));
|
||||
return;
|
||||
case ev_ptr:
|
||||
|
|
@ -1187,7 +1187,7 @@ encode_type (dstring_t *encoding, const type_t *type)
|
|||
dasprintf (encoding, "#");
|
||||
return;
|
||||
}
|
||||
type = type->t.fldptr.type;
|
||||
type = type->fldptr.type;
|
||||
dasprintf (encoding, "^");
|
||||
encode_type (encoding, type);
|
||||
return;
|
||||
|
|
@ -1407,8 +1407,8 @@ type_assignable (const type_t *dst, const type_t *src)
|
|||
return 1;
|
||||
// pointer = array
|
||||
if (is_ptr (dst) && is_array (src)) {
|
||||
if (is_void (dst->t.fldptr.type)
|
||||
|| dst->t.fldptr.type == src->t.array.type)
|
||||
if (is_void (dst->fldptr.type)
|
||||
|| dst->fldptr.type == src->array.type)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1434,8 +1434,8 @@ type_assignable (const type_t *dst, const type_t *src)
|
|||
if (ret >= 0)
|
||||
return ret;
|
||||
|
||||
dst = dst->t.fldptr.type;
|
||||
src = src->t.fldptr.type;
|
||||
dst = dst->fldptr.type;
|
||||
src = src->fldptr.type;
|
||||
if (dst == src) {
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1507,18 +1507,18 @@ type_size (const type_t *type)
|
|||
return pr_type_size[type->type] * type->width;
|
||||
case ty_struct:
|
||||
case ty_union:
|
||||
if (!type->t.symtab)
|
||||
if (!type->symtab)
|
||||
return 0;
|
||||
return type->t.symtab->size;
|
||||
return type->symtab->size;
|
||||
case ty_enum:
|
||||
if (!type->t.symtab)
|
||||
if (!type->symtab)
|
||||
return 0;
|
||||
return type_size (&type_int);
|
||||
case ty_array:
|
||||
return type->t.array.size * type_size (type->t.array.type);
|
||||
return type->array.size * type_size (type->array.type);
|
||||
case ty_class:
|
||||
{
|
||||
class_t *class = type->t.class;
|
||||
class_t *class = type->class;
|
||||
int size;
|
||||
if (!class->ivars)
|
||||
return 0;
|
||||
|
|
@ -1528,7 +1528,7 @@ type_size (const type_t *type)
|
|||
return size;
|
||||
}
|
||||
case ty_alias:
|
||||
return type_size (type->t.alias.aux_type);
|
||||
return type_size (type->alias.aux_type);
|
||||
case ty_algebra:
|
||||
return algebra_type_size (type);
|
||||
case ty_meta_count:
|
||||
|
|
@ -1555,15 +1555,15 @@ type_width (const type_t *type)
|
|||
case ty_union:
|
||||
return 1;
|
||||
case ty_enum:
|
||||
if (!type->t.symtab)
|
||||
if (!type->symtab)
|
||||
return 0;
|
||||
return type_width (&type_int);
|
||||
case ty_array:
|
||||
return type_width (type->t.array.type);
|
||||
return type_width (type->array.type);
|
||||
case ty_class:
|
||||
return 1;
|
||||
case ty_alias:
|
||||
return type_width (type->t.alias.aux_type);
|
||||
return type_width (type->alias.aux_type);
|
||||
case ty_algebra:
|
||||
return algebra_type_width (type);
|
||||
case ty_meta_count:
|
||||
|
|
@ -1602,7 +1602,7 @@ type_aligned_size (const type_t *type)
|
|||
static void
|
||||
chain_basic_types (void)
|
||||
{
|
||||
type_entity.t.symtab = pr.entity_fields;
|
||||
type_entity.symtab = pr.entity_fields;
|
||||
if (options.code.progsversion == PROG_VERSION) {
|
||||
type_quaternion.alignment = 4;
|
||||
}
|
||||
|
|
@ -1789,11 +1789,11 @@ init_types (void)
|
|||
|
||||
sym = new_symbol_type ("v", &type_vector);
|
||||
sym->offset = 0;
|
||||
symtab_addsymbol (type_quaternion.t.symtab, sym);
|
||||
symtab_addsymbol (type_quaternion.symtab, sym);
|
||||
|
||||
sym = new_symbol_type ("s", &type_float);
|
||||
sym->offset = 3;
|
||||
symtab_addsymbol (type_quaternion.t.symtab, sym);
|
||||
symtab_addsymbol (type_quaternion.symtab, sym);
|
||||
}
|
||||
#define VEC_TYPE(type_name, base_type) build_vector_struct (&type_##type_name);
|
||||
#include "tools/qfcc/include/vec_types.h"
|
||||
|
|
|
|||
|
|
@ -280,7 +280,7 @@ new_nil_val (const type_t *type)
|
|||
val.lltype = type_nil->type;
|
||||
}
|
||||
if (val.lltype == ev_ptr || val.lltype == ev_field )
|
||||
val.pointer.type = type->t.fldptr.type;
|
||||
val.pointer.type = type->fldptr.type;
|
||||
if (val.lltype == ev_func)
|
||||
val.func_val.type = type;
|
||||
return find_value (&val);
|
||||
|
|
|
|||
Loading…
Reference in a new issue