mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2025-02-25 05:01:24 +00:00
[qfcc] Make the symbol union anonymous
And now that little s. goes away. Yay, one bit less noise when reading code.
This commit is contained in:
Bill Currie
parent
6bd26a0f61
commit
ce8c72c323
24 changed files with 245 additions and 247 deletions
|
|
@ -83,7 +83,7 @@ typedef struct symbol_s {
|
|||
struct function_s *func; ///< sy_func
|
||||
symconv_t convert; ///< sy_convert
|
||||
struct rua_macro_s *macro; ///< sy_macro
|
||||
} s;
|
||||
};
|
||||
} symbol_t;
|
||||
|
||||
typedef enum {
|
||||
|
|
|
|||
|
|
@ -645,7 +645,7 @@ algebra_symbol (const char *name, symtab_t *symtab)
|
|||
if (blade_val) {
|
||||
sym = new_symbol_type (name, blade_val->type);
|
||||
sym->sy_type = sy_const;
|
||||
sym->s.value = blade_val;
|
||||
sym->value = blade_val;
|
||||
symtab_addsymbol (symtab, sym);
|
||||
}
|
||||
return sym;
|
||||
|
|
|
|||
|
|
@ -393,7 +393,7 @@ emit_static_instances_list (void)
|
|||
if (!instance_lists_sym->table) {
|
||||
symtab_addsymbol (pr.symtab, instance_lists_sym);
|
||||
}
|
||||
instance_lists_def = instance_lists_sym->s.def;
|
||||
instance_lists_def = instance_lists_sym->def;
|
||||
instance_lists_def->initialized = instance_lists_def->constant = 1;
|
||||
instance_lists_def->nosave = 1;
|
||||
|
||||
|
|
@ -696,7 +696,7 @@ _get_class (symbol_t *sym, int create)
|
|||
}
|
||||
|
||||
sym = class_symbol (&c->class_type, 1);
|
||||
c->def = sym->s.def;
|
||||
c->def = sym->def;
|
||||
|
||||
return c;
|
||||
}
|
||||
|
|
@ -793,7 +793,7 @@ begin_category (category_t *category)
|
|||
|
||||
current_class = &category->class_type;
|
||||
sym = class_symbol (current_class, 0);
|
||||
category->def = def = sym->s.def;
|
||||
category->def = def = sym->def;
|
||||
def->initialized = def->constant = def->nosave = 1;
|
||||
space = def->space;
|
||||
|
||||
|
|
@ -855,7 +855,7 @@ emit_ivar_list_item (def_t *def, void *data, int index)
|
|||
EMIT_STRING (space, ivar->ivar_name, ivar_sym->name);
|
||||
encode_type (ivar_data->encoding, ivar_sym->type);
|
||||
EMIT_STRING (space, ivar->ivar_type, ivar_data->encoding->str);
|
||||
ivar->ivar_offset = ivar_sym->s.offset;
|
||||
ivar->ivar_offset = ivar_sym->offset;
|
||||
}
|
||||
|
||||
static def_t *
|
||||
|
|
@ -898,7 +898,7 @@ begin_class (class_t *class)
|
|||
|
||||
sym = make_symbol (va (0, "_OBJ_METACLASS_%s", class->name),
|
||||
&type_class, pr.far_data, sc_static);
|
||||
meta_def = sym->s.def;
|
||||
meta_def = sym->def;
|
||||
meta_def->initialized = meta_def->constant = meta_def->nosave = 1;
|
||||
space = meta_def->space;
|
||||
meta = &D_STRUCT (pr_class_t, meta_def);
|
||||
|
|
@ -919,7 +919,7 @@ begin_class (class_t *class)
|
|||
}
|
||||
current_class = &class->class_type;
|
||||
sym = class_symbol (current_class, 0);
|
||||
class->def = def = sym->s.def;
|
||||
class->def = def = sym->def;
|
||||
def->initialized = def->constant = def->nosave = 1;
|
||||
space = def->space;
|
||||
|
||||
|
|
@ -969,7 +969,7 @@ emit_class_ref (const char *class_name)
|
|||
&type_ptr, pr.far_data, sc_static);
|
||||
if (!ref_sym->table)
|
||||
symtab_addsymbol (pr.symtab, ref_sym);
|
||||
ref_def = ref_sym->s.def;
|
||||
ref_def = ref_sym->def;
|
||||
if (ref_def->initialized)
|
||||
return;
|
||||
ref_def->initialized = ref_def->constant = ref_def->nosave = 1;
|
||||
|
|
@ -977,7 +977,7 @@ emit_class_ref (const char *class_name)
|
|||
&type_ptr, pr.far_data, sc_extern);
|
||||
if (!name_sym->table)
|
||||
symtab_addsymbol (pr.symtab, name_sym);
|
||||
name_def = name_sym->s.def;
|
||||
name_def = name_sym->def;
|
||||
if (!name_def->external)
|
||||
D_INT (ref_def) = name_def->offset;
|
||||
reloc_def_def (name_def, ref_def);
|
||||
|
|
@ -993,7 +993,7 @@ emit_class_name (const char *class_name)
|
|||
&type_ptr, pr.far_data, sc_global);
|
||||
if (!name_sym->table)
|
||||
symtab_addsymbol (pr.symtab, name_sym);
|
||||
name_def = name_sym->s.def;
|
||||
name_def = name_sym->def;
|
||||
if (name_def->initialized)
|
||||
return;
|
||||
name_def->initialized = name_def->constant = 1;
|
||||
|
|
@ -1014,7 +1014,7 @@ emit_category_ref (const char *class_name, const char *category_name)
|
|||
&type_ptr, pr.far_data, sc_static);
|
||||
if (!ref_sym->table)
|
||||
symtab_addsymbol (pr.symtab, ref_sym);
|
||||
ref_def = ref_sym->s.def;
|
||||
ref_def = ref_sym->def;
|
||||
if (ref_def->initialized)
|
||||
return;
|
||||
ref_def->initialized = ref_def->constant = 1;
|
||||
|
|
@ -1024,7 +1024,7 @@ emit_category_ref (const char *class_name, const char *category_name)
|
|||
&type_ptr, pr.far_data, sc_extern);
|
||||
if (!name_sym->table)
|
||||
symtab_addsymbol (pr.symtab, name_sym);
|
||||
name_def = name_sym->s.def;
|
||||
name_def = name_sym->def;
|
||||
if (!name_def->external)
|
||||
D_INT (ref_def) = name_def->offset;
|
||||
reloc_def_def (name_def, ref_def);
|
||||
|
|
@ -1041,7 +1041,7 @@ emit_category_name (const char *class_name, const char *category_name)
|
|||
&type_ptr, pr.far_data, sc_global);
|
||||
if (!name_sym->table)
|
||||
symtab_addsymbol (pr.symtab, name_sym);
|
||||
name_def = name_sym->s.def;
|
||||
name_def = name_sym->def;
|
||||
if (name_def->initialized)
|
||||
return;
|
||||
name_def->initialized = name_def->constant = 1;
|
||||
|
|
@ -1342,7 +1342,7 @@ class_add_ivars (class_t *class, symtab_t *ivars)
|
|||
if (class->super_class)
|
||||
base = type_size (class->super_class->type);
|
||||
for (sym = ivars->symbols; sym; sym = sym->next)
|
||||
sym->s.offset += base;
|
||||
sym->offset += base;
|
||||
class->ivars = ivars;
|
||||
}
|
||||
|
||||
|
|
@ -1471,13 +1471,13 @@ class_pointer_symbol (class_t *class)
|
|||
&type_Class, pr.near_data, sc_static);
|
||||
if (!sym->table)
|
||||
symtab_addsymbol (pr.symtab, sym);
|
||||
def = sym->s.def;
|
||||
def = sym->def;
|
||||
if (def->initialized)
|
||||
return sym;
|
||||
def->initialized = def->constant = 1;
|
||||
def->nosave = 1;
|
||||
if (!class->def)
|
||||
class->def = class_symbol (&class_type, 1)->s.def;
|
||||
class->def = class_symbol (&class_type, 1)->def;
|
||||
if (!class->def->external)
|
||||
D_INT (def) = class->def->offset;
|
||||
reloc_def_def (class->def, def);
|
||||
|
|
@ -1625,11 +1625,10 @@ class_finish_module (void)
|
|||
module_sym = make_symbol ("_OBJ_MODULE", &type_module, pr.far_data,
|
||||
sc_static);
|
||||
symtab_addsymbol (current_symtab, module_sym);
|
||||
module = &D_STRUCT (pr_module_t, module_sym->s.def);
|
||||
module = &D_STRUCT (pr_module_t, module_sym->def);
|
||||
module->size = type_size (&type_module);
|
||||
EMIT_STRING (module_sym->s.def->space, module->name,
|
||||
GETSTR (pr.loc.file));
|
||||
EMIT_DEF (module_sym->s.def->space, module->symtab, symtab_def);
|
||||
EMIT_STRING (module_sym->def->space, module->name, GETSTR (pr.loc.file));
|
||||
EMIT_DEF (module_sym->def->space, module->symtab, symtab_def);
|
||||
|
||||
exec_class_sym = symtab_lookup (pr.symtab, "__obj_exec_class");
|
||||
if (!exec_class_sym) {
|
||||
|
|
@ -1810,7 +1809,7 @@ emit_protocol (protocol_t *protocol)
|
|||
defspace_t *space;
|
||||
|
||||
proto_def = make_symbol (va (0, "_OBJ_PROTOCOL_%s", protocol->name),
|
||||
&type_protocol, pr.far_data, sc_static)->s.def;
|
||||
&type_protocol, pr.far_data, sc_static)->def;
|
||||
if (proto_def->initialized)
|
||||
return proto_def;
|
||||
proto_def->initialized = proto_def->constant = 1;
|
||||
|
|
@ -1967,8 +1966,8 @@ class_finish_ivar_scope (class_type_t *class_type, symtab_t *ivar_scope,
|
|||
if (sym->sy_type != sy_var)
|
||||
continue;
|
||||
sym->sy_type = sy_convert;
|
||||
sym->s.convert.conv = class_dereference_ivar;
|
||||
sym->s.convert.data = (void *) self_expr;
|
||||
sym->convert.conv = class_dereference_ivar;
|
||||
sym->convert.data = (void *) self_expr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -399,7 +399,7 @@ make_magic_macro (symtab_t *tab, const char *name, rua_macro_f update)
|
|||
}
|
||||
sym = new_symbol (macro->name);
|
||||
sym->sy_type = sy_macro;
|
||||
sym->s.macro = macro;
|
||||
sym->macro = macro;
|
||||
symtab_addsymbol (tab, sym);
|
||||
return macro;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -455,14 +455,14 @@ init_vector_components (symbol_t *vector_sym, int is_field, symtab_t *symtab)
|
|||
error (0, "%s redefined", name);
|
||||
sym = 0;
|
||||
} else {
|
||||
expr = sym->s.expr;
|
||||
expr = sym->expr;
|
||||
if (is_field) {
|
||||
if (expr->type != ex_value
|
||||
|| expr->value->lltype != ev_field) {
|
||||
error (0, "%s redefined", name);
|
||||
sym = 0;
|
||||
} else {
|
||||
expr->value->v.pointer.def = vector_sym->s.def;
|
||||
expr->value->v.pointer.def = vector_sym->def;
|
||||
expr->value->v.pointer.val = i;
|
||||
}
|
||||
}
|
||||
|
|
@ -475,14 +475,14 @@ init_vector_components (symbol_t *vector_sym, int is_field, symtab_t *symtab)
|
|||
sym = new_symbol (name);
|
||||
if (!expr) {
|
||||
if (is_field) {
|
||||
expr = new_field_expr (i, &type_float, vector_sym->s.def);
|
||||
expr = new_field_expr (i, &type_float, vector_sym->def);
|
||||
} else {
|
||||
expr = field_expr (vector_expr,
|
||||
new_symbol_expr (new_symbol (fields[i])));
|
||||
}
|
||||
}
|
||||
sym->sy_type = sy_expr;
|
||||
sym->s.expr = expr;
|
||||
sym->expr = expr;
|
||||
if (!sym->table)
|
||||
symtab_addsymbol (symtab, sym);
|
||||
}
|
||||
|
|
@ -501,18 +501,18 @@ init_field_def (def_t *def, const expr_t *init, storage_class_t storage,
|
|||
field_sym = symtab_lookup (pr.entity_fields, def->name);
|
||||
if (!field_sym)
|
||||
field_sym = new_symbol_type (def->name, type);
|
||||
if (field_sym->s.def && field_sym->s.def->external) {
|
||||
if (field_sym->def && field_sym->def->external) {
|
||||
//FIXME this really is not the right way
|
||||
relocs = field_sym->s.def->relocs;
|
||||
free_def (field_sym->s.def);
|
||||
field_sym->s.def = 0;
|
||||
relocs = field_sym->def->relocs;
|
||||
free_def (field_sym->def);
|
||||
field_sym->def = 0;
|
||||
}
|
||||
if (!field_sym->s.def) {
|
||||
field_sym->s.def = new_def (def->name, type, pr.entity_data, storage);
|
||||
reloc_attach_relocs (relocs, &field_sym->s.def->relocs);
|
||||
field_sym->s.def->nosave = 1;
|
||||
if (!field_sym->def) {
|
||||
field_sym->def = new_def (def->name, type, pr.entity_data, storage);
|
||||
reloc_attach_relocs (relocs, &field_sym->def->relocs);
|
||||
field_sym->def->nosave = 1;
|
||||
}
|
||||
field_def = field_sym->s.def;
|
||||
field_def = field_sym->def;
|
||||
if (!field_sym->table)
|
||||
symtab_addsymbol (pr.entity_fields, field_sym);
|
||||
if (storage != sc_extern) {
|
||||
|
|
@ -529,7 +529,7 @@ init_field_def (def_t *def, const expr_t *init, storage_class_t storage,
|
|||
symbol_t *field = symtab_lookup (pr.entity_fields, sym->name);
|
||||
if (field) {
|
||||
scoped_src_loc (init);
|
||||
auto new = new_field_expr (0, field->type, field->s.def);
|
||||
auto new = new_field_expr (0, field->type, field->def);
|
||||
if (new->type != ex_value) {
|
||||
internal_error (init, "expected value expression");
|
||||
}
|
||||
|
|
@ -565,14 +565,14 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
|
|||
error (0, "%s redefined", sym->name);
|
||||
} else {
|
||||
// is var and same type
|
||||
if (!check->s.def)
|
||||
if (!check->def)
|
||||
internal_error (0, "half defined var");
|
||||
if (storage == sc_extern) {
|
||||
if (init)
|
||||
error (0, "initializing external variable");
|
||||
return;
|
||||
}
|
||||
if (init && check->s.def->initialized) {
|
||||
if (init && check->def->initialized) {
|
||||
error (0, "%s redefined", sym->name);
|
||||
return;
|
||||
}
|
||||
|
|
@ -583,13 +583,13 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
|
|||
if (!sym->table)
|
||||
symtab_addsymbol (symtab, sym);
|
||||
|
||||
if (sym->s.def && sym->s.def->external) {
|
||||
if (sym->def && sym->def->external) {
|
||||
//FIXME this really is not the right way
|
||||
relocs = sym->s.def->relocs;
|
||||
free_def (sym->s.def);
|
||||
sym->s.def = 0;
|
||||
relocs = sym->def->relocs;
|
||||
free_def (sym->def);
|
||||
sym->def = 0;
|
||||
}
|
||||
if (!sym->s.def) {
|
||||
if (!sym->def) {
|
||||
if (is_array (sym->type) && !type_size (sym->type)
|
||||
&& init && init->type == ex_compound) {
|
||||
auto ele_type = dereference_type (sym->type);
|
||||
|
|
@ -605,14 +605,14 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
|
|||
sym->type = type_default;
|
||||
}
|
||||
}
|
||||
sym->s.def = new_def (sym->name, sym->type, space, storage);
|
||||
reloc_attach_relocs (relocs, &sym->s.def->relocs);
|
||||
sym->def = new_def (sym->name, sym->type, space, storage);
|
||||
reloc_attach_relocs (relocs, &sym->def->relocs);
|
||||
}
|
||||
if (is_vector(sym->type) && options.code.vector_components)
|
||||
init_vector_components (sym, 0, symtab);
|
||||
if (sym->type->type == ev_field && storage != sc_local
|
||||
&& storage != sc_param)
|
||||
init = init_field_def (sym->s.def, init, storage, symtab);
|
||||
init = init_field_def (sym->def, init, storage, symtab);
|
||||
if (storage == sc_extern) {
|
||||
if (init)
|
||||
error (0, "initializing external variable");
|
||||
|
|
@ -625,8 +625,8 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
|
|||
return;
|
||||
if ((is_structural (sym->type) || is_nonscalar (sym->type))
|
||||
&& (init->type == ex_compound || init->type == ex_nil)) {
|
||||
init_elements (sym->s.def, init);
|
||||
sym->s.def->initialized = 1;
|
||||
init_elements (sym->def, init);
|
||||
sym->def->initialized = 1;
|
||||
} else {
|
||||
if (init->type == ex_nil) {
|
||||
init = convert_nil (init, sym->type);
|
||||
|
|
@ -638,7 +638,7 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
|
|||
return;
|
||||
}
|
||||
if (storage == sc_local && local_expr) {
|
||||
sym->s.def->initialized = 1;
|
||||
sym->def->initialized = 1;
|
||||
init = assign_expr (new_symbol_expr (sym), init);
|
||||
// fold_constants takes care of int/float conversions
|
||||
append_expr (local_expr, fold_constants (init));
|
||||
|
|
@ -657,9 +657,9 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
|
|||
if (init->value->lltype == ev_ptr
|
||||
|| init->value->lltype == ev_field) {
|
||||
// FIXME offset pointers
|
||||
D_INT (sym->s.def) = init->value->v.pointer.val;
|
||||
D_INT (sym->def) = init->value->v.pointer.val;
|
||||
if (init->value->v.pointer.def)
|
||||
reloc_def_field (init->value->v.pointer.def, sym->s.def);
|
||||
reloc_def_field (init->value->v.pointer.def, sym->def);
|
||||
} else {
|
||||
ex_value_t *v = init->value;
|
||||
if (!init->implicit
|
||||
|
|
@ -671,21 +671,21 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
|
|||
if (!type_same (sym->type, init_type))
|
||||
v = convert_value (v, sym->type);
|
||||
if (v->lltype == ev_string) {
|
||||
EMIT_STRING (sym->s.def->space, D_STRING (sym->s.def),
|
||||
EMIT_STRING (sym->def->space, D_STRING (sym->def),
|
||||
v->v.string_val);
|
||||
} else {
|
||||
memcpy (D_POINTER (pr_type_t, sym->s.def), &v->v,
|
||||
memcpy (D_POINTER (pr_type_t, sym->def), &v->v,
|
||||
type_size (sym->type) * sizeof (pr_type_t));
|
||||
}
|
||||
}
|
||||
sym->s.def->initialized = 1;
|
||||
sym->def->initialized = 1;
|
||||
if (options.code.const_initializers) {
|
||||
sym->s.def->constant = 1;
|
||||
sym->s.def->nosave = 1;
|
||||
sym->def->constant = 1;
|
||||
sym->def->nosave = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
sym->s.def->initializer = init;
|
||||
sym->def->initializer = init;
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
|
|||
|
|
@ -169,12 +169,12 @@ print_struct (dstring_t *dstr, const type_t *t, int level, int id)
|
|||
int val;
|
||||
const char *port = "";
|
||||
if (sym->sy_type == sy_const) {
|
||||
val = sym->s.value->v.int_val;
|
||||
val = sym->value->v.int_val;
|
||||
} else {
|
||||
if (sym->sy_type != sy_var) {
|
||||
continue;
|
||||
}
|
||||
val = sym->s.offset;
|
||||
val = sym->offset;
|
||||
port = va (0, " port=\"f%d\"", pnum++);
|
||||
}
|
||||
dasprintf (dstr, "%*s<tr><td>%s</td><td%s>%d</td></tr>\n",
|
||||
|
|
|
|||
|
|
@ -106,10 +106,10 @@ convert_name (const expr_t *e)
|
|||
return e;
|
||||
}
|
||||
if (sym->sy_type == sy_convert) {
|
||||
return sym->s.convert.conv (sym, sym->s.convert.data);
|
||||
return sym->convert.conv (sym, sym->convert.data);
|
||||
}
|
||||
if (sym->sy_type == sy_expr) {
|
||||
return sym->s.expr;
|
||||
return sym->expr;
|
||||
}
|
||||
if (sym->sy_type == sy_type)
|
||||
internal_error (e, "unexpected typedef");
|
||||
|
|
@ -488,16 +488,16 @@ named_label_expr (symbol_t *label)
|
|||
sym = symtab_lookup (current_func->label_scope, label->name);
|
||||
|
||||
if (sym) {
|
||||
return sym->s.expr;
|
||||
return sym->expr;
|
||||
}
|
||||
l = new_label_expr ();
|
||||
l->label.name = save_string (va (0, "%s_%s", l->label.name,
|
||||
label->name));
|
||||
l->label.symbol = label;
|
||||
label->sy_type = sy_expr;
|
||||
label->s.expr = l;
|
||||
label->expr = l;
|
||||
symtab_addsymbol (current_func->label_scope, label);
|
||||
return label->s.expr;
|
||||
return label->expr;
|
||||
}
|
||||
|
||||
expr_t *
|
||||
|
|
@ -876,7 +876,7 @@ is_constant (const expr_t *e)
|
|||
if (e->type == ex_nil || e->type == ex_value || e->type == ex_labelref
|
||||
|| (e->type == ex_symbol && e->symbol->sy_type == sy_const)
|
||||
|| (e->type == ex_symbol && e->symbol->sy_type == sy_var
|
||||
&& e->symbol->s.def->constant))
|
||||
&& e->symbol->def->constant))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -915,13 +915,13 @@ constant_expr (const expr_t *e)
|
|||
return e;
|
||||
sym = e->symbol;
|
||||
if (sym->sy_type == sy_const) {
|
||||
value = sym->s.value;
|
||||
} else if (sym->sy_type == sy_var && sym->s.def->constant) {
|
||||
value = sym->value;
|
||||
} else if (sym->sy_type == sy_var && sym->def->constant) {
|
||||
//FIXME pointers and fields
|
||||
internal_error (e, "what to do here?");
|
||||
//memset (&value, 0, sizeof (value));
|
||||
//memcpy (&value.v, &D_INT (sym->s.def),
|
||||
//type_size (sym->s.def->type) * sizeof (pr_type_t));
|
||||
//memcpy (&value.v, &D_INT (sym->def),
|
||||
//type_size (sym->def->type) * sizeof (pr_type_t));
|
||||
} else {
|
||||
return e;
|
||||
}
|
||||
|
|
@ -980,11 +980,11 @@ expr_double (const expr_t *e)
|
|||
return e->value->v.double_val;
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& e->symbol->type->type == ev_double)
|
||||
return e->symbol->s.value->v.double_val;
|
||||
return e->symbol->value->v.double_val;
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_var
|
||||
&& e->symbol->s.def->constant
|
||||
&& is_double (e->symbol->s.def->type))
|
||||
return D_DOUBLE (e->symbol->s.def);
|
||||
&& e->symbol->def->constant
|
||||
&& is_double (e->symbol->def->type))
|
||||
return D_DOUBLE (e->symbol->def);
|
||||
internal_error (e, "not a double constant");
|
||||
}
|
||||
|
||||
|
|
@ -997,11 +997,11 @@ expr_float (const expr_t *e)
|
|||
return e->value->v.float_val;
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& e->symbol->type->type == ev_float)
|
||||
return e->symbol->s.value->v.float_val;
|
||||
return e->symbol->value->v.float_val;
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_var
|
||||
&& e->symbol->s.def->constant
|
||||
&& is_float (e->symbol->s.def->type))
|
||||
return D_FLOAT (e->symbol->s.def);
|
||||
&& e->symbol->def->constant
|
||||
&& is_float (e->symbol->def->type))
|
||||
return D_FLOAT (e->symbol->def);
|
||||
internal_error (e, "not a float constant");
|
||||
}
|
||||
|
||||
|
|
@ -1027,11 +1027,11 @@ expr_vector (const expr_t *e)
|
|||
return e->value->v.vector_val;
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& e->symbol->type->type == ev_vector)
|
||||
return e->symbol->s.value->v.vector_val;
|
||||
return e->symbol->value->v.vector_val;
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_var
|
||||
&& e->symbol->s.def->constant
|
||||
&& e->symbol->s.def->type->type == ev_vector)
|
||||
return D_VECTOR (e->symbol->s.def);
|
||||
&& e->symbol->def->constant
|
||||
&& e->symbol->def->type->type == ev_vector)
|
||||
return D_VECTOR (e->symbol->def);
|
||||
internal_error (e, "not a vector constant");
|
||||
}
|
||||
|
||||
|
|
@ -1057,11 +1057,11 @@ expr_quaternion (const expr_t *e)
|
|||
return e->value->v.quaternion_val;
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& e->symbol->type->type == ev_quaternion)
|
||||
return e->symbol->s.value->v.quaternion_val;
|
||||
return e->symbol->value->v.quaternion_val;
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_var
|
||||
&& e->symbol->s.def->constant
|
||||
&& e->symbol->s.def->type->type == ev_quaternion)
|
||||
return D_QUAT (e->symbol->s.def);
|
||||
&& e->symbol->def->constant
|
||||
&& e->symbol->def->type->type == ev_quaternion)
|
||||
return D_QUAT (e->symbol->def);
|
||||
internal_error (e, "not a quaternion constant");
|
||||
}
|
||||
|
||||
|
|
@ -1100,12 +1100,12 @@ expr_int (const expr_t *e)
|
|||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& (e->symbol->type->type == ev_int
|
||||
|| is_enum (e->symbol->type))) {
|
||||
return e->symbol->s.value->v.int_val;
|
||||
return e->symbol->value->v.int_val;
|
||||
}
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_var
|
||||
&& e->symbol->s.def->constant
|
||||
&& is_integral (e->symbol->s.def->type)) {
|
||||
return D_INT (e->symbol->s.def);
|
||||
&& e->symbol->def->constant
|
||||
&& is_integral (e->symbol->def->type)) {
|
||||
return D_INT (e->symbol->def);
|
||||
}
|
||||
if (e->type == ex_def && e->def->constant
|
||||
&& is_integral (e->def->type)) {
|
||||
|
|
@ -1145,12 +1145,12 @@ expr_uint (const expr_t *e)
|
|||
}
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& e->symbol->type->type == ev_uint) {
|
||||
return e->symbol->s.value->v.uint_val;
|
||||
return e->symbol->value->v.uint_val;
|
||||
}
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_var
|
||||
&& e->symbol->s.def->constant
|
||||
&& is_integral (e->symbol->s.def->type)) {
|
||||
return D_INT (e->symbol->s.def);
|
||||
&& e->symbol->def->constant
|
||||
&& is_integral (e->symbol->def->type)) {
|
||||
return D_INT (e->symbol->def);
|
||||
}
|
||||
if (e->type == ex_def && e->def->constant
|
||||
&& is_integral (e->def->type)) {
|
||||
|
|
@ -1186,7 +1186,7 @@ expr_short (const expr_t *e)
|
|||
}
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& e->symbol->type->type == ev_short) {
|
||||
return e->symbol->s.value->v.short_val;
|
||||
return e->symbol->value->v.short_val;
|
||||
}
|
||||
internal_error (e, "not a short constant");
|
||||
}
|
||||
|
|
@ -1202,7 +1202,7 @@ expr_ushort (const expr_t *e)
|
|||
}
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& e->symbol->type->type == ev_ushort) {
|
||||
return e->symbol->s.value->v.ushort_val;
|
||||
return e->symbol->value->v.ushort_val;
|
||||
}
|
||||
internal_error (e, "not a ushort constant");
|
||||
}
|
||||
|
|
@ -1260,7 +1260,7 @@ is_math_val (const expr_t *e)
|
|||
return 1;
|
||||
}
|
||||
if (e->type == ex_symbol && e->symbol->sy_type == sy_const
|
||||
&& is_math (e->symbol->s.value->type)) {
|
||||
&& is_math (e->symbol->value->type)) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -1516,7 +1516,7 @@ field_expr (const expr_t *e1, const expr_t *e2)
|
|||
if (e2->type == ex_symbol)
|
||||
field = get_struct_field (&type_entity, e1, e2);
|
||||
if (field) {
|
||||
e2 = new_field_expr (0, field->type, field->s.def);
|
||||
e2 = new_field_expr (0, field->type, field->def);
|
||||
e = new_binary_expr ('.', e1, e2);
|
||||
e->expr.type = field->type;
|
||||
return e;
|
||||
|
|
@ -1539,7 +1539,7 @@ field_expr (const expr_t *e1, const expr_t *e2)
|
|||
if (!field)
|
||||
return e1;
|
||||
|
||||
const expr_t *offset = new_short_expr (field->s.offset);
|
||||
const expr_t *offset = new_short_expr (field->offset);
|
||||
e1 = offset_pointer_expr (e1, offset);
|
||||
if (e1->type == ex_error) {
|
||||
return e1;
|
||||
|
|
@ -1555,7 +1555,7 @@ field_expr (const expr_t *e1, const expr_t *e2)
|
|||
ivar = class_find_ivar (class, protected, sym->name);
|
||||
if (!ivar)
|
||||
return new_error_expr ();
|
||||
const expr_t *offset = new_short_expr (ivar->s.offset);
|
||||
const expr_t *offset = new_short_expr (ivar->offset);
|
||||
e1 = offset_pointer_expr (e1, offset);
|
||||
e1 = cast_expr (pointer_type (ivar->type), e1);
|
||||
if (e1->type == ex_error) {
|
||||
|
|
@ -1590,25 +1590,25 @@ field_expr (const expr_t *e1, const expr_t *e2)
|
|||
internal_error (e2, "failed to find entity field %s",
|
||||
e2->symbol->name);
|
||||
}
|
||||
def = sym->s.def;
|
||||
def = sym->def;
|
||||
e2 = new_field_expr (0, field->type, def);
|
||||
} else if (e2->type != ex_value
|
||||
|| e2->value->lltype != ev_field) {
|
||||
internal_error (e2, "unexpected field exression");
|
||||
}
|
||||
auto fv = new_field_val (e2->value->v.pointer.val + field->s.offset, field->type, e2->value->v.pointer.def);
|
||||
auto fv = new_field_val (e2->value->v.pointer.val + field->offset, field->type, e2->value->v.pointer.def);
|
||||
scoped_src_loc (e2);
|
||||
e2 = new_value_expr (fv, false);
|
||||
// create a new . expression
|
||||
return field_expr (e1, e2);
|
||||
} else {
|
||||
if (e1->type == ex_uexpr && e1->expr.op == '.') {
|
||||
const expr_t *offset = new_short_expr (field->s.offset);
|
||||
const expr_t *offset = new_short_expr (field->offset);
|
||||
e1 = offset_pointer_expr (e1->expr.e1, offset);
|
||||
e1 = cast_expr (pointer_type (field->type), e1);
|
||||
return unary_expr ('.', e1);
|
||||
} else {
|
||||
return new_offset_alias_expr (field->type, e1, field->s.offset);
|
||||
return new_offset_alias_expr (field->type, e1, field->offset);
|
||||
}
|
||||
}
|
||||
} else if (is_class (t1)) {
|
||||
|
|
@ -2782,7 +2782,7 @@ address_expr (const expr_t *e1, const type_t *t)
|
|||
break;
|
||||
case ex_symbol:
|
||||
if (e1->symbol->sy_type == sy_var) {
|
||||
auto def = e1->symbol->s.def;
|
||||
auto def = e1->symbol->def;
|
||||
auto type = def->type;
|
||||
|
||||
//FIXME this test should be in statements.c
|
||||
|
|
|
|||
|
|
@ -324,7 +324,7 @@ mvec_expr (const expr_t *expr, algebra_t *algebra)
|
|||
int count = 0;
|
||||
for (auto sym = get_mvec_sym (mvtype); sym; sym = sym->next) {
|
||||
auto c = &components[count++];
|
||||
*c = new_offset_alias_expr (sym->type, expr, sym->s.offset);
|
||||
*c = new_offset_alias_expr (sym->type, expr, sym->offset);
|
||||
*c = edag_add_expr (*c);
|
||||
}
|
||||
list_gather (&mvec->multivec.components, components, count);
|
||||
|
|
@ -2990,18 +2990,18 @@ algebra_assign_expr (const expr_t *dst, const expr_t *src)
|
|||
while (sym->type != get_type (c[i])) {
|
||||
sym = sym->next;
|
||||
}
|
||||
int size = sym->s.offset - memset_base;
|
||||
int size = sym->offset - memset_base;
|
||||
if (size) {
|
||||
zero_components (block, dst, memset_base, size);
|
||||
}
|
||||
auto dst_alias = new_offset_alias_expr (sym->type, dst, sym->s.offset);
|
||||
auto dst_alias = new_offset_alias_expr (sym->type, dst, sym->offset);
|
||||
if (summed_extend (c[i])) {
|
||||
assign_extend (block, dst_alias, c[i]);
|
||||
} else {
|
||||
append_expr (block,
|
||||
edag_add_expr (new_assign_expr (dst_alias, c[i])));
|
||||
}
|
||||
memset_base = sym->s.offset + type_size (sym->type);
|
||||
memset_base = sym->offset + type_size (sym->type);
|
||||
}
|
||||
if (type_size (dstType) - memset_base) {
|
||||
zero_components (block, dst, memset_base,
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ get_designated_offset (const type_t *type, const designator_t *des)
|
|||
|
||||
if (is_struct (type) || is_union (type)) {
|
||||
field = designator_field (des, type);
|
||||
offset = field->s.offset;
|
||||
offset = field->offset;
|
||||
ele_type = field->type;
|
||||
} else if (is_array (type)) {
|
||||
int array_size = type->t.array.size;
|
||||
|
|
@ -168,7 +168,7 @@ get_designated_offset (const type_t *type, const designator_t *des)
|
|||
ele_type = ev_types[type->type];
|
||||
if (type->t.symtab && des->field) {
|
||||
field = designator_field (des, type);
|
||||
offset = field->s.offset;
|
||||
offset = field->offset;
|
||||
} else {
|
||||
int vec_width = type_width (type);
|
||||
offset = designator_index (des, type_size (ele_type), vec_width);
|
||||
|
|
@ -227,7 +227,7 @@ build_element_chain (element_chain_t *element_chain, const type_t *type,
|
|||
}
|
||||
if (state.field) {
|
||||
state.type = state.field->type;
|
||||
state.offset = state.field->s.offset;
|
||||
state.offset = state.field->offset;
|
||||
}
|
||||
} else if (is_array (type)) {
|
||||
state.type = dereference_type (type);
|
||||
|
|
@ -269,7 +269,7 @@ build_element_chain (element_chain_t *element_chain, const type_t *type,
|
|||
}
|
||||
if (state.field) {
|
||||
state.type = state.field->type;
|
||||
state.offset = state.field->s.offset;
|
||||
state.offset = state.field->offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ selector_expr (keywordarg_t *selector)
|
|||
pr.far_data, sc_extern);
|
||||
if (!sel_table->table)
|
||||
symtab_addsymbol (pr.symtab, sel_table);
|
||||
reloc_def_def (sel_table->s.def, sel_sym->s.def);
|
||||
reloc_def_def (sel_table->def, sel_sym->def);
|
||||
}
|
||||
sel_ref = new_symbol_expr (sel_sym);
|
||||
sel_ref = new_address_expr (&type_selector, sel_ref,
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ check_int (const expr_t *arg)
|
|||
&& arg->type != ex_type) {
|
||||
return false;
|
||||
}
|
||||
int op = arg->symbol->s.expr->typ.op;
|
||||
int op = arg->symbol->expr->typ.op;
|
||||
if (op != QC_AT_WIDTH && op != QC_AT_ROWS && op != QC_AT_COLS) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -500,7 +500,7 @@ type_parameter (symbol_t *sym, const expr_t *type)
|
|||
sym = new_symbol (sym->name);
|
||||
}
|
||||
sym->sy_type = sy_type_param;
|
||||
sym->s.expr = type;
|
||||
sym->expr = type;
|
||||
return sym;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -653,7 +653,7 @@ flow_build_vars (function_t *func)
|
|||
}
|
||||
// count .return and .param_[0-7] as they are always needed
|
||||
for (i = 0; i < num_flow_params; i++) {
|
||||
def_t *def = param_symbol (flow_params[i].name)->s.def;
|
||||
def_t *def = param_symbol (flow_params[i].name)->def;
|
||||
def_visit_all (def, 0, flow_def_clear_flowvars, 0);
|
||||
flow_params[i].op.def = def;
|
||||
num_vars += count_operand (&flow_params[i].op);
|
||||
|
|
|
|||
|
|
@ -230,8 +230,8 @@ make_gentype (const expr_t *expr)
|
|||
auto sym = expr->symbol;
|
||||
gentype_t gentype = {
|
||||
.name = save_string (sym->name),
|
||||
.compute = check_compute_type (sym->s.expr),
|
||||
.valid_types = valid_type_list (sym->s.expr),
|
||||
.compute = check_compute_type (sym->expr),
|
||||
.valid_types = valid_type_list (sym->expr),
|
||||
};
|
||||
if (gentype.compute && gentype.valid_types) {
|
||||
internal_error (expr, "both computed type and type list");
|
||||
|
|
@ -582,7 +582,7 @@ function_symbol (symbol_t *sym, specifier_t spec)
|
|||
s->sy_type = sy_func;
|
||||
s->type = unalias_type (sym->type);
|
||||
s->params = sym->params;
|
||||
s->s.func = 0; // function not yet defined
|
||||
s->func = 0; // function not yet defined
|
||||
symtab_addsymbol (current_symtab, s);
|
||||
}
|
||||
return s;
|
||||
|
|
@ -758,7 +758,7 @@ find_generic_function (const expr_t *fexpr, genfunc_t **genfuncs,
|
|||
sym->sy_type = sy_func;
|
||||
sym->type = type;
|
||||
sym->params = params;
|
||||
sym->s.func = nullptr;
|
||||
sym->func = nullptr;
|
||||
symtab_addsymbol (fsym->table, sym);
|
||||
}
|
||||
return new_symbol_expr (sym);
|
||||
|
|
@ -931,10 +931,10 @@ build_v6p_scope (symbol_t *fsym)
|
|||
param_t *p;
|
||||
symbol_t *args = 0;
|
||||
symbol_t *param;
|
||||
symtab_t *parameters = fsym->s.func->parameters;
|
||||
symtab_t *locals = fsym->s.func->locals;
|
||||
symtab_t *parameters = fsym->func->parameters;
|
||||
symtab_t *locals = fsym->func->locals;
|
||||
|
||||
if (fsym->s.func->type->t.func.num_params < 0) {
|
||||
if (fsym->func->type->t.func.num_params < 0) {
|
||||
args = new_symbol_type (".args", &type_va_list);
|
||||
initialize_def (args, 0, parameters->space, sc_param, locals);
|
||||
}
|
||||
|
|
@ -974,7 +974,7 @@ create_param (symtab_t *parameters, symbol_t *param)
|
|||
}
|
||||
def->offset = defspace_alloc_aligned_highwater (space, size, alignment);
|
||||
def->type = param->type;
|
||||
param->s.def = def;
|
||||
param->def = def;
|
||||
param->sy_type = sy_var;
|
||||
symtab_addsymbol (parameters, param);
|
||||
if (is_vector(param->type) && options.code.vector_components)
|
||||
|
|
@ -999,8 +999,8 @@ build_rua_scope (symbol_t *fsym)
|
|||
}
|
||||
param = new_symbol_type (p->name, p->type);
|
||||
}
|
||||
create_param (fsym->s.func->parameters, param);
|
||||
param->s.def->reg = fsym->s.func->temp_reg;
|
||||
create_param (fsym->func->parameters, param);
|
||||
param->def->reg = fsym->func->temp_reg;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1010,24 +1010,24 @@ build_scope (symbol_t *fsym, symtab_t *parent)
|
|||
symtab_t *parameters;
|
||||
symtab_t *locals;
|
||||
|
||||
if (!fsym->s.func) {
|
||||
if (!fsym->func) {
|
||||
internal_error (0, "function %s not defined", fsym->name);
|
||||
}
|
||||
if (!is_func (fsym->s.func->type)) {
|
||||
if (!is_func (fsym->func->type)) {
|
||||
internal_error (0, "function type %s not a funciton", fsym->name);
|
||||
}
|
||||
|
||||
check_function (fsym);
|
||||
|
||||
fsym->s.func->label_scope = new_symtab (0, stab_label);
|
||||
fsym->func->label_scope = new_symtab (0, stab_label);
|
||||
|
||||
parameters = new_symtab (parent, stab_param);
|
||||
parameters->space = defspace_new (ds_virtual);
|
||||
fsym->s.func->parameters = parameters;
|
||||
fsym->func->parameters = parameters;
|
||||
|
||||
locals = new_symtab (parameters, stab_local);
|
||||
locals->space = defspace_new (ds_virtual);
|
||||
fsym->s.func->locals = locals;
|
||||
fsym->func->locals = locals;
|
||||
|
||||
if (options.code.progsversion == PROG_VERSION) {
|
||||
build_rua_scope (fsym);
|
||||
|
|
@ -1056,23 +1056,23 @@ make_function (symbol_t *sym, const char *nice_name, defspace_t *space,
|
|||
reloc_t *relocs = 0;
|
||||
if (sym->sy_type != sy_func)
|
||||
internal_error (0, "%s is not a function", sym->name);
|
||||
if (storage == sc_extern && sym->s.func)
|
||||
if (storage == sc_extern && sym->func)
|
||||
return;
|
||||
if (!sym->s.func) {
|
||||
sym->s.func = new_function (sym->name, nice_name);
|
||||
sym->s.func->sym = sym;
|
||||
sym->s.func->type = unalias_type (sym->type);
|
||||
if (!sym->func) {
|
||||
sym->func = new_function (sym->name, nice_name);
|
||||
sym->func->sym = sym;
|
||||
sym->func->type = unalias_type (sym->type);
|
||||
}
|
||||
if (sym->s.func->def && sym->s.func->def->external
|
||||
if (sym->func->def && sym->func->def->external
|
||||
&& storage != sc_extern) {
|
||||
//FIXME this really is not the right way
|
||||
relocs = sym->s.func->def->relocs;
|
||||
free_def (sym->s.func->def);
|
||||
sym->s.func->def = 0;
|
||||
relocs = sym->func->def->relocs;
|
||||
free_def (sym->func->def);
|
||||
sym->func->def = 0;
|
||||
}
|
||||
if (!sym->s.func->def) {
|
||||
sym->s.func->def = new_def (sym->name, sym->type, space, storage);
|
||||
reloc_attach_relocs (relocs, &sym->s.func->def->relocs);
|
||||
if (!sym->func->def) {
|
||||
sym->func->def = new_def (sym->name, sym->type, space, storage);
|
||||
reloc_attach_relocs (relocs, &sym->func->def->relocs);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1095,7 +1095,7 @@ begin_function (symbol_t *sym, const char *nicename, symtab_t *parent,
|
|||
sym = new_symbol_type (sym->name, &type_func);
|
||||
sym = function_symbol (sym, (specifier_t) { .is_overload = true });
|
||||
}
|
||||
if (sym->s.func && sym->s.func->def && sym->s.func->def->initialized) {
|
||||
if (sym->func && sym->func->def && sym->func->def->initialized) {
|
||||
error (0, "%s redefined", sym->name);
|
||||
sym = new_symbol_type (sym->name, sym->type);
|
||||
sym = function_symbol (sym, (specifier_t) { .is_overload = true });
|
||||
|
|
@ -1104,31 +1104,31 @@ begin_function (symbol_t *sym, const char *nicename, symtab_t *parent,
|
|||
if (far)
|
||||
space = pr.far_data;
|
||||
make_function (sym, nicename, space, storage);
|
||||
if (!sym->s.func->def->external) {
|
||||
sym->s.func->def->initialized = 1;
|
||||
sym->s.func->def->constant = 1;
|
||||
sym->s.func->def->nosave = 1;
|
||||
add_function (sym->s.func);
|
||||
reloc_def_func (sym->s.func, sym->s.func->def);
|
||||
if (!sym->func->def->external) {
|
||||
sym->func->def->initialized = 1;
|
||||
sym->func->def->constant = 1;
|
||||
sym->func->def->nosave = 1;
|
||||
add_function (sym->func);
|
||||
reloc_def_func (sym->func, sym->func->def);
|
||||
|
||||
sym->s.func->def->loc = pr.loc;
|
||||
sym->func->def->loc = pr.loc;
|
||||
}
|
||||
sym->s.func->code = pr.code->size;
|
||||
sym->func->code = pr.code->size;
|
||||
|
||||
sym->s.func->s_file = pr.loc.file;
|
||||
sym->func->s_file = pr.loc.file;
|
||||
if (options.code.debug) {
|
||||
pr_lineno_t *lineno = new_lineno ();
|
||||
sym->s.func->line_info = lineno - pr.linenos;
|
||||
sym->func->line_info = lineno - pr.linenos;
|
||||
}
|
||||
|
||||
build_scope (sym, parent);
|
||||
return sym->s.func;
|
||||
return sym->func;
|
||||
}
|
||||
|
||||
static void
|
||||
build_function (symbol_t *fsym)
|
||||
{
|
||||
const type_t *func_type = fsym->s.func->type;
|
||||
const type_t *func_type = fsym->func->type;
|
||||
if (func_type->t.func.num_params > PR_MAX_PARAMS) {
|
||||
error (0, "too many params");
|
||||
}
|
||||
|
|
@ -1170,7 +1170,7 @@ build_code_function (symbol_t *fsym, const expr_t *state_expr,
|
|||
if (state_expr) {
|
||||
prepend_expr (statements, state_expr);
|
||||
}
|
||||
function_t *func = fsym->s.func;
|
||||
function_t *func = fsym->func;
|
||||
if (options.code.progsversion == PROG_VERSION) {
|
||||
/* Create a function entry block to set up the stack frame and add the
|
||||
* actual function code to that block. This ensure that the adjstk and
|
||||
|
|
@ -1254,7 +1254,7 @@ build_code_function (symbol_t *fsym, const expr_t *state_expr,
|
|||
// the final parameter is smaller than STACK_ALIGN words
|
||||
defspace_alloc_aligned_highwater (space, 0, STACK_ALIGN);
|
||||
}
|
||||
return fsym->s.func;
|
||||
return fsym->func;
|
||||
}
|
||||
|
||||
function_t *
|
||||
|
|
@ -1268,7 +1268,7 @@ build_builtin_function (symbol_t *sym, const expr_t *bi_val, int far,
|
|||
error (bi_val, "%s is not a function", sym->name);
|
||||
return 0;
|
||||
}
|
||||
if (sym->s.func && sym->s.func->def && sym->s.func->def->initialized) {
|
||||
if (sym->func && sym->func->def && sym->func->def->initialized) {
|
||||
error (bi_val, "%s redefined", sym->name);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1280,13 +1280,13 @@ build_builtin_function (symbol_t *sym, const expr_t *bi_val, int far,
|
|||
if (far)
|
||||
space = pr.far_data;
|
||||
make_function (sym, 0, space, storage);
|
||||
if (sym->s.func->def->external)
|
||||
if (sym->func->def->external)
|
||||
return 0;
|
||||
|
||||
sym->s.func->def->initialized = 1;
|
||||
sym->s.func->def->constant = 1;
|
||||
sym->s.func->def->nosave = 1;
|
||||
add_function (sym->s.func);
|
||||
sym->func->def->initialized = 1;
|
||||
sym->func->def->constant = 1;
|
||||
sym->func->def->nosave = 1;
|
||||
add_function (sym->func);
|
||||
|
||||
if (is_int_val (bi_val))
|
||||
bi = expr_int (bi_val);
|
||||
|
|
@ -1296,15 +1296,15 @@ build_builtin_function (symbol_t *sym, const expr_t *bi_val, int far,
|
|||
error (bi_val, "builtin functions must be positive or 0");
|
||||
return 0;
|
||||
}
|
||||
sym->s.func->builtin = bi;
|
||||
reloc_def_func (sym->s.func, sym->s.func->def);
|
||||
sym->func->builtin = bi;
|
||||
reloc_def_func (sym->func, sym->func->def);
|
||||
build_function (sym);
|
||||
|
||||
// for debug info
|
||||
build_scope (sym, current_symtab);
|
||||
sym->s.func->parameters->space->size = 0;
|
||||
sym->s.func->locals->space = sym->s.func->parameters->space;
|
||||
return sym->s.func;
|
||||
sym->func->parameters->space->size = 0;
|
||||
sym->func->locals->space = sym->func->parameters->space;
|
||||
return sym->func;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
|||
|
|
@ -517,7 +517,7 @@ emit_selectors (void)
|
|||
pr.far_data, sc_static);
|
||||
if (!sel_sym->table)
|
||||
symtab_addsymbol (pr.symtab, sel_sym);
|
||||
sel_def = sel_sym->s.def;
|
||||
sel_def = sel_sym->def;
|
||||
sel_def->initialized = sel_def->constant = 1;
|
||||
sel_def->nosave = 1;
|
||||
|
||||
|
|
|
|||
|
|
@ -217,9 +217,9 @@ qfo_encode_struct (const type_t *type, defspace_t *space)
|
|||
if (i == num_fields)
|
||||
internal_error (0, "whoa, what happened?");
|
||||
if (sym->sy_type == sy_const)
|
||||
offset = sym->s.value->v.int_val;
|
||||
offset = sym->value->v.int_val;
|
||||
else
|
||||
offset = sym->s.offset;
|
||||
offset = sym->offset;
|
||||
ENC_DEF (strct->fields[i].type, field_types[i]);
|
||||
ENC_STR (strct->fields[i].name, sym->name);
|
||||
strct->fields[i].offset = offset;
|
||||
|
|
|
|||
|
|
@ -1182,7 +1182,7 @@ get_arg_token (bool last, const rua_tok_t *arg, const rua_macro_t *macro,
|
|||
|
||||
if (arg->token == -rua_va_opt) {
|
||||
sym = symtab_lookup (macro->params, arg->text);
|
||||
auto m = sym->s.macro;
|
||||
auto m = sym->macro;
|
||||
m->update (m, scanner);
|
||||
if (last) {
|
||||
if (m->tokens) {
|
||||
|
|
@ -1195,8 +1195,8 @@ get_arg_token (bool last, const rua_tok_t *arg, const rua_macro_t *macro,
|
|||
}
|
||||
if (arg->token == -rua_id && macro->params
|
||||
&& (sym = symtab_lookup (macro->params, arg->text))
|
||||
&& !macro->args[sym->s.offset]->next) {
|
||||
auto a = macro->args[sym->s.offset];
|
||||
&& !macro->args[sym->offset]->next) {
|
||||
auto a = macro->args[sym->offset];
|
||||
if (last) {
|
||||
if (a->tokens) {
|
||||
return (rua_tok_t *) a->tail;
|
||||
|
|
@ -1244,11 +1244,11 @@ copy_arg_token (rua_macro_t *dst, bool skip_first, bool skip_last,
|
|||
if (arg->token == -rua_va_opt) {
|
||||
sym = symtab_lookup (macro->params, arg->text);
|
||||
// __VA_OPT__'s macro was updated by get_arg_token
|
||||
do_arg_copy (dst, sym->s.macro, skip_first, skip_last);
|
||||
do_arg_copy (dst, sym->macro, skip_first, skip_last);
|
||||
} else if (arg->token == -rua_id && macro->params
|
||||
&& (sym = symtab_lookup (macro->params, arg->text))
|
||||
&& !macro->args[sym->s.offset]->next) {
|
||||
do_arg_copy (dst, macro->args[sym->s.offset], skip_first, skip_last);
|
||||
&& !macro->args[sym->offset]->next) {
|
||||
do_arg_copy (dst, macro->args[sym->offset], skip_first, skip_last);
|
||||
} else if (!skip_first && !skip_last) {
|
||||
copy_token (dst, arg);
|
||||
}
|
||||
|
|
@ -1412,12 +1412,12 @@ rescan:
|
|||
macro->cursor = macro->cursor->next; // consume arg
|
||||
if (n->token == -rua_va_opt) {
|
||||
sym = symtab_lookup (macro->params, n->text);
|
||||
auto m = sym->s.macro;
|
||||
auto m = sym->macro;
|
||||
m->update (m, scanner);
|
||||
arg = m;
|
||||
} else {
|
||||
sym = symtab_lookup (macro->params, n->text);
|
||||
arg = macro->args[sym->s.offset];
|
||||
arg = macro->args[sym->offset];
|
||||
}
|
||||
stringize_arg (&e, arg, extra);
|
||||
} else if (e.next && e.next->token == PRE_CONCAT) {
|
||||
|
|
@ -1456,22 +1456,22 @@ rescan:
|
|||
goto rescan;
|
||||
}
|
||||
sym = symtab_lookup (macro->params, e.text);
|
||||
auto m = sym->s.macro;
|
||||
auto m = sym->macro;
|
||||
m->update (m, scanner);
|
||||
queue_macro (extra, m);
|
||||
goto rescan;
|
||||
} else if (token == -rua_id && macro->params
|
||||
&& (sym = symtab_lookup (macro->params, e.text))
|
||||
&& !macro->args[sym->s.offset]->next) {
|
||||
auto arg = macro->args[sym->s.offset];
|
||||
&& !macro->args[sym->offset]->next) {
|
||||
auto arg = macro->args[sym->offset];
|
||||
queue_macro (extra, arg);
|
||||
goto rescan;
|
||||
} else if (token == -rua_id && !macro->name // in an arg
|
||||
&& (sym = symtab_lookup (extra->macro_tab, e.text))
|
||||
&& !sym->s.macro->next
|
||||
&& !sym->s.macro->params) {
|
||||
&& !sym->macro->next
|
||||
&& !sym->macro->params) {
|
||||
// force object-type macros in macro arguments to be expanded
|
||||
auto m = sym->s.macro;
|
||||
auto m = sym->macro;
|
||||
if (m->update) {
|
||||
m->update (m, scanner);
|
||||
}
|
||||
|
|
@ -1480,10 +1480,10 @@ rescan:
|
|||
#if 0 // causes preproc-1.r to fail (see XXX below)
|
||||
} else if (token == -rua_id && !macro->name // in an arg
|
||||
&& (sym = symtab_lookup (extra->macro_tab, e.text))
|
||||
&& !sym->s.macro->next
|
||||
&& sym->s.macro->params) {
|
||||
&& !sym->macro->next
|
||||
&& sym->macro->params) {
|
||||
// force function-type macros in macro arguments to be expanded
|
||||
auto m = sym->s.macro;
|
||||
auto m = sym->macro;
|
||||
auto c = macro->cursor;
|
||||
// XXX breakage for preproc-1.r: collect_args assumes the macro
|
||||
// is complete, but in the case of preproc-1.r, it is not. In fact,
|
||||
|
|
@ -1541,8 +1541,8 @@ rescan:
|
|||
if ((extra->expand || !(extra->preprocessor || extra->suppressed))
|
||||
&& token == -rua_id
|
||||
&& (sym = symtab_lookup (extra->macro_tab, e.text))
|
||||
&& !sym->s.macro->next) {
|
||||
auto macro = sym->s.macro;
|
||||
&& !sym->macro->next) {
|
||||
auto macro = sym->macro;
|
||||
if (macro->update) {
|
||||
macro->update (macro, scanner);
|
||||
}
|
||||
|
|
@ -1692,7 +1692,7 @@ rua_macro_param (rua_macro_t *macro, const rua_tok_t *token, void *scanner)
|
|||
}
|
||||
auto sym = new_symbol (token->text);
|
||||
sym->sy_type = sy_var;
|
||||
sym->s.offset = macro->num_params++;
|
||||
sym->offset = macro->num_params++;
|
||||
symtab_addsymbol (macro->params, sym);
|
||||
if (token->token == -rua_ellipsis) {
|
||||
macro->num_params = -macro->num_params;
|
||||
|
|
@ -1734,7 +1734,7 @@ build_va_opt (rua_macro_t *macro, rua_tok_t *t, rua_tok_t *u, int va_opt_ind)
|
|||
|
||||
auto sym = new_symbol (va_opt_name);
|
||||
sym->sy_type = sy_macro;
|
||||
sym->s.macro = va_opt;
|
||||
sym->macro = va_opt;
|
||||
symtab_addsymbol (macro->params, sym);
|
||||
return va_opt_tok;
|
||||
}
|
||||
|
|
@ -1817,7 +1817,7 @@ hashhash_error:
|
|||
auto macro_tab = extra->macro_tab;
|
||||
auto sym = symtab_lookup (macro_tab, macro->name);
|
||||
if (sym) {
|
||||
auto o = sym->s.macro->tokens;
|
||||
auto o = sym->macro->tokens;
|
||||
auto n = macro->tokens;
|
||||
while (o && n && o->text == n->text) {
|
||||
o = o->next;
|
||||
|
|
@ -1830,7 +1830,7 @@ hashhash_error:
|
|||
}
|
||||
sym = new_symbol (macro->name);
|
||||
sym->sy_type = sy_macro;
|
||||
sym->s.macro = macro;
|
||||
sym->macro = macro;
|
||||
symtab_addsymbol (macro_tab, sym);
|
||||
}
|
||||
|
||||
|
|
@ -2287,8 +2287,8 @@ macro_empty (rua_macro_t *macro, yyscan_t scanner)
|
|||
symbol_t *sym;
|
||||
if (macro->params
|
||||
&& (sym = symtab_lookup (macro->params, t->text))
|
||||
&& !macro->args[sym->s.offset]->next) {
|
||||
auto arg = macro->args[sym->s.offset];
|
||||
&& !macro->args[sym->offset]->next) {
|
||||
auto arg = macro->args[sym->offset];
|
||||
arg->next = macro;
|
||||
bool empty = macro_empty (arg, scanner);
|
||||
arg->next = 0;
|
||||
|
|
@ -2297,8 +2297,8 @@ macro_empty (rua_macro_t *macro, yyscan_t scanner)
|
|||
}
|
||||
}
|
||||
if ((sym = symtab_lookup (extra->macro_tab, t->text))
|
||||
&& !sym->s.macro->next) {
|
||||
auto m = sym->s.macro;
|
||||
&& !sym->macro->next) {
|
||||
auto m = sym->macro;
|
||||
if (m->params) {
|
||||
macro->cursor = t;
|
||||
collect_args (m, macro, scanner);
|
||||
|
|
|
|||
|
|
@ -773,8 +773,8 @@ qc_nocode_func
|
|||
} else {
|
||||
initialize_def (sym, 0, current_symtab->space, spec.storage,
|
||||
current_symtab);
|
||||
if (sym->s.def)
|
||||
sym->s.def->nosave |= spec.nosave;
|
||||
if (sym->def)
|
||||
sym->def->nosave |= spec.nosave;
|
||||
}
|
||||
}
|
||||
;
|
||||
|
|
@ -2460,8 +2460,8 @@ methoddef
|
|||
sc_static);
|
||||
class_finish_ivar_scope (current_class, ivar_scope,
|
||||
current_func->locals);
|
||||
method->func = sym->s.func;
|
||||
method->def = sym->s.func->def;
|
||||
method->func = sym->func;
|
||||
method->def = sym->func->def;
|
||||
current_symtab = current_func->locals;
|
||||
current_storage = sc_local;
|
||||
}
|
||||
|
|
@ -2481,8 +2481,8 @@ methoddef
|
|||
method = class_find_method (current_class, method);
|
||||
sym = method_symbol (current_class, method);
|
||||
build_builtin_function (sym, $5, 1, sc_static);
|
||||
method->func = sym->s.func;
|
||||
method->def = sym->s.func->def;
|
||||
method->func = sym->func;
|
||||
method->def = sym->func->def;
|
||||
}
|
||||
;
|
||||
|
||||
|
|
|
|||
|
|
@ -246,8 +246,8 @@ program_head
|
|||
sym->type = &type_int;
|
||||
initialize_def (sym, 0, current_symtab->space, sc_global,
|
||||
current_symtab);
|
||||
if (sym->s.def) {
|
||||
sym->s.def->nosave = 1;
|
||||
if (sym->def) {
|
||||
sym->def->nosave = 1;
|
||||
}
|
||||
}
|
||||
$$->type = parse_params (&type_void, 0);
|
||||
|
|
@ -426,7 +426,7 @@ statement
|
|||
{
|
||||
$$ = $1;
|
||||
if ($$->type == ex_symbol && $$->symbol->sy_type == sy_func) {
|
||||
if ($$->symbol->s.func != current_func) {
|
||||
if ($$->symbol->func != current_func) {
|
||||
$$ = error ($$, "cannot assign to other function");
|
||||
} else {
|
||||
symbol_t *ret = function_value (current_func);
|
||||
|
|
|
|||
|
|
@ -387,7 +387,7 @@ return_operand (const type_t *type, const expr_t *expr)
|
|||
if (!return_symbol->table) {
|
||||
symtab_addsymbol (pr.symtab, return_symbol);
|
||||
}
|
||||
def_t *return_def = return_symbol->s.def;
|
||||
def_t *return_def = return_symbol->def;
|
||||
return def_operand (alias_def (return_def, type, 0), 0, expr);
|
||||
}
|
||||
|
||||
|
|
@ -1892,14 +1892,14 @@ expr_symbol (sblock_t *sblock, const expr_t *e, operand_t **op)
|
|||
symbol_t *sym = e->symbol;
|
||||
|
||||
if (sym->sy_type == sy_var) {
|
||||
*op = def_operand (sym->s.def, sym->type, e);
|
||||
*op = def_operand (sym->def, sym->type, e);
|
||||
} else if (sym->sy_type == sy_const) {
|
||||
*op = value_operand (sym->s.value, e);
|
||||
*op = value_operand (sym->value, e);
|
||||
} else if (sym->sy_type == sy_func) {
|
||||
if (!sym->s.func) {
|
||||
if (!sym->func) {
|
||||
make_function (sym, 0, pr.symtab->space, sc_extern);
|
||||
}
|
||||
*op = def_operand (sym->s.func->def, 0, e);
|
||||
*op = def_operand (sym->func->def, 0, e);
|
||||
} else {
|
||||
internal_error (e, "unexpected symbol type: %s for %s",
|
||||
symtype_str (sym->sy_type), sym->name);
|
||||
|
|
|
|||
|
|
@ -179,7 +179,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
|
|||
}
|
||||
if (su == 's') {
|
||||
symtab->size = RUP (symtab->size + base, s->type->alignment) - base;
|
||||
s->s.offset = symtab->size;
|
||||
s->offset = symtab->size;
|
||||
symtab->size += type_size (s->type);
|
||||
} else {
|
||||
int size = type_size (s->type);
|
||||
|
|
@ -193,7 +193,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
|
|||
if (s->visibility == vis_anonymous) {
|
||||
symtab_t *anonymous;
|
||||
symbol_t *t = s->next;
|
||||
int offset = s->s.offset;
|
||||
int offset = s->offset;
|
||||
|
||||
if (!is_struct (s->type) && !is_union (s->type)) {
|
||||
internal_error (0, "non-struct/union anonymous field");
|
||||
|
|
@ -209,7 +209,7 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, const type_t *type,
|
|||
} else {
|
||||
s->next = copy_symbol (as);
|
||||
s = s->next;
|
||||
s->s.offset += offset;
|
||||
s->offset += offset;
|
||||
s->table = symtab;
|
||||
s->no_auto_init = 1;
|
||||
Hash_Add (symtab->tab, s);
|
||||
|
|
@ -265,7 +265,7 @@ finish_enum (symbol_t *sym)
|
|||
|
||||
enum_sym = new_symbol_type (name->name, enum_type);
|
||||
enum_sym->sy_type = sy_const;
|
||||
enum_sym->s.value = name->s.value;
|
||||
enum_sym->value = name->value;
|
||||
symtab_addsymbol (enum_tab->parent, enum_sym);
|
||||
}
|
||||
return sym;
|
||||
|
|
@ -286,7 +286,7 @@ add_enum (symbol_t *enm, symbol_t *name, const expr_t *val)
|
|||
name->type = enum_type;
|
||||
value = 0;
|
||||
if (enum_tab->symbols)
|
||||
value = ((symbol_t *)(enum_tab->symtail))->s.value->v.uint_val + 1;
|
||||
value = ((symbol_t *)(enum_tab->symtail))->value->v.uint_val + 1;
|
||||
if (val) {
|
||||
val = convert_name (val);
|
||||
if (!is_constant (val))
|
||||
|
|
@ -296,7 +296,7 @@ add_enum (symbol_t *enm, symbol_t *name, const expr_t *val)
|
|||
else
|
||||
value = expr_int (val);
|
||||
}
|
||||
name->s.value = new_int_val (value);
|
||||
name->value = new_int_val (value);
|
||||
symtab_addsymbol (enum_tab, name);
|
||||
}
|
||||
|
||||
|
|
@ -314,12 +314,12 @@ enum_as_bool (const type_t *enm, expr_t **zero, expr_t **one)
|
|||
for (sym = symtab->symbols; sym; sym = sym->next) {
|
||||
if (sym->sy_type != sy_const)
|
||||
continue;
|
||||
val = sym->s.value->v.int_val;
|
||||
val = sym->value->v.int_val;
|
||||
if (!val) {
|
||||
zero_sym = sym;
|
||||
} else {
|
||||
if (one_sym) {
|
||||
v = one_sym->s.value->v.int_val;
|
||||
v = one_sym->value->v.int_val;
|
||||
if (val * val > v * v)
|
||||
continue;
|
||||
}
|
||||
|
|
@ -401,7 +401,7 @@ emit_structure (const char *name, int su, struct_def_t *defs,
|
|||
}
|
||||
struct_sym = make_symbol (name, type, space, storage);
|
||||
|
||||
struct_def = struct_sym->s.def;
|
||||
struct_def = struct_sym->def;
|
||||
if (struct_def->initialized)
|
||||
internal_error (0, "structure %s already initialized", name);
|
||||
struct_def->initialized = struct_def->constant = 1;
|
||||
|
|
@ -412,7 +412,7 @@ emit_structure (const char *name, int su, struct_def_t *defs,
|
|||
field_def.type = field_sym->type;
|
||||
field_def.name = save_string (va (0, "%s.%s", name, field_sym->name));
|
||||
field_def.space = struct_def->space;
|
||||
field_def.offset = struct_def->offset + field_sym->s.offset;
|
||||
field_def.offset = struct_def->offset + field_sym->offset;
|
||||
if (!defs[i].emit) {
|
||||
//FIXME relocs? arrays? structs?
|
||||
pr_type_t *val = (pr_type_t *) data;
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ static ex_value_t * __attribute__((pure))
|
|||
get_value (const expr_t *e)
|
||||
{
|
||||
if (e->type == ex_symbol)
|
||||
return e->symbol->s.value;
|
||||
return e->symbol->value;
|
||||
if (e->type != ex_value)
|
||||
internal_error (e, "bogus case label");
|
||||
return e->value;
|
||||
|
|
@ -383,7 +383,7 @@ check_enum_switch (switch_block_t *switch_block)
|
|||
|
||||
for (enum_val = type->t.symtab->symbols; enum_val;
|
||||
enum_val = enum_val->next) {
|
||||
cl.value = new_int_expr (enum_val->s.value->v.int_val, false);
|
||||
cl.value = new_int_expr (enum_val->value->v.int_val, false);
|
||||
if (!Hash_FindElement (switch_block->labels, &cl)) {
|
||||
warning (switch_block->test,
|
||||
"enumeration value `%s' not handled in switch",
|
||||
|
|
|
|||
|
|
@ -176,11 +176,10 @@ symbol_t *
|
|||
copy_symbol (symbol_t *symbol)
|
||||
{
|
||||
symbol_t *sym = new_symbol (symbol->name);
|
||||
sym->visibility = symbol->visibility;
|
||||
sym->type = symbol->type;
|
||||
*sym = *symbol;
|
||||
sym->next = nullptr;
|
||||
sym->table = nullptr;
|
||||
sym->params = copy_params (symbol->params);
|
||||
sym->sy_type = symbol->sy_type;
|
||||
sym->s = symbol->s;
|
||||
return sym;
|
||||
}
|
||||
|
||||
|
|
@ -238,15 +237,15 @@ make_symbol (const char *name, const type_t *type, defspace_t *space,
|
|||
sym = new_symbol_type (name, type);
|
||||
}
|
||||
}
|
||||
if (sym->s.def && sym->s.def->external && storage != sc_extern) {
|
||||
if (sym->def && sym->def->external && storage != sc_extern) {
|
||||
//FIXME this really is not the right way
|
||||
relocs = sym->s.def->relocs;
|
||||
free_def (sym->s.def);
|
||||
sym->s.def = 0;
|
||||
relocs = sym->def->relocs;
|
||||
free_def (sym->def);
|
||||
sym->def = 0;
|
||||
}
|
||||
if (!sym->s.def) {
|
||||
sym->s.def = new_def (name, type, space, storage);
|
||||
reloc_attach_relocs (relocs, &sym->s.def->relocs);
|
||||
if (!sym->def) {
|
||||
sym->def = new_def (name, type, space, storage);
|
||||
reloc_attach_relocs (relocs, &sym->def->relocs);
|
||||
}
|
||||
sym->sy_type = sy_var;
|
||||
return sym;
|
||||
|
|
@ -303,8 +302,8 @@ declare_symbol (specifier_t spec, const expr_t *init, symtab_t *symtab)
|
|||
} else {
|
||||
s->type = find_type (s->type);
|
||||
initialize_def (s, init, space, spec.storage, symtab);
|
||||
if (s->s.def) {
|
||||
s->s.def->nosave |= spec.nosave;
|
||||
if (s->def) {
|
||||
s->def->nosave |= spec.nosave;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1788,11 +1788,11 @@ init_types (void)
|
|||
symbol_t *sym;
|
||||
|
||||
sym = new_symbol_type ("v", &type_vector);
|
||||
sym->s.offset = 0;
|
||||
sym->offset = 0;
|
||||
symtab_addsymbol (type_quaternion.t.symtab, sym);
|
||||
|
||||
sym = new_symbol_type ("s", &type_float);
|
||||
sym->s.offset = 3;
|
||||
sym->offset = 3;
|
||||
symtab_addsymbol (type_quaternion.t.symtab, sym);
|
||||
}
|
||||
#define VEC_TYPE(type_name, base_type) build_vector_struct (&type_##type_name);
|
||||
|
|
|
|||
|
|
@ -308,7 +308,7 @@ value_store (pr_type_t *dst, const type_t *dstType, const expr_t *src)
|
|||
if (src->type == ex_symbol && src->symbol->sy_type == sy_var) {
|
||||
// initialized global def treated as a constant
|
||||
// from the tests in cast_expr, the def is known to be constant
|
||||
def_t *def = src->symbol->s.def;
|
||||
def_t *def = src->symbol->def;
|
||||
memcpy (dst, &D_PACKED (pr_type_t, def), dstSize);
|
||||
return;
|
||||
}
|
||||
|
|
@ -317,7 +317,7 @@ value_store (pr_type_t *dst, const type_t *dstType, const expr_t *src)
|
|||
val = src->value;
|
||||
}
|
||||
if (src->type == ex_symbol && src->symbol->sy_type == sy_const) {
|
||||
val = src->symbol->s.value;
|
||||
val = src->symbol->value;
|
||||
}
|
||||
if (!val) {
|
||||
internal_error (src, "unexpected constant expression type");
|
||||
|
|
@ -671,7 +671,7 @@ emit_value (ex_value_t *value, def_t *def)
|
|||
} else {
|
||||
symbol_t *sym;
|
||||
sym = make_symbol (".zero", &type_zero, 0, sc_extern);
|
||||
return sym->s.def;
|
||||
return sym->def;
|
||||
}
|
||||
}
|
||||
if (imm) {
|
||||
|
|
@ -742,7 +742,7 @@ clear_immediates (void)
|
|||
Hash_SetHashCompare (value_imm_defs, imm_get_hash, imm_compare);
|
||||
}
|
||||
|
||||
def = make_symbol (".zero", &type_zero, 0, sc_extern)->s.def;
|
||||
def = make_symbol (".zero", &type_zero, 0, sc_extern)->def;
|
||||
|
||||
memset (&zero_val, 0, sizeof (zero_val));
|
||||
make_def_imm (def, string_imm_defs, &zero_val);
|
||||
|
|
|
|||
Loading…
Reference in a new issue