void c_typecheck_baset::typecheck_compound_type(struct_union_typet &type)
{
// These get replaced by symbol types later.
irep_idt identifier;
bool have_body=type.find(ID_components).is_not_nil();
if(type.find(ID_tag).is_nil())
{
// Anonymous? Must come with body.
assert(have_body);
// produce symbol
symbolt compound_symbol;
compound_symbol.is_type=true;
compound_symbol.type=type;
compound_symbol.location=type.source_location();
typecheck_compound_body(to_struct_union_type(compound_symbol.type));
std::string typestr=type2name(compound_symbol.type);
compound_symbol.base_name="#anon-"+typestr;
compound_symbol.name="tag-#anon#"+typestr;
identifier=compound_symbol.name;
// We might already have the same anonymous union/struct,
// and this is simply ok. Note that the C standard treats
// these as different types.
if(symbol_table.symbols.find(identifier)==symbol_table.symbols.end())
{
symbolt *new_symbol;
move_symbol(compound_symbol, new_symbol);
}
}
else
{
identifier=type.find(ID_tag).get(ID_identifier);
// does it exist already?
symbol_tablet::symbolst::iterator s_it=
symbol_table.symbols.find(identifier);
if(s_it==symbol_table.symbols.end())
{
// no, add new symbol
irep_idt base_name=type.find(ID_tag).get(ID_C_base_name);
type.remove(ID_tag);
type.set(ID_tag, base_name);
symbolt compound_symbol;
compound_symbol.is_type=true;
compound_symbol.name=identifier;
compound_symbol.base_name=base_name;
compound_symbol.type=type;
compound_symbol.location=type.source_location();
compound_symbol.pretty_name=id2string(type.id())+" "+id2string(base_name);
typet new_type=compound_symbol.type;
if(compound_symbol.type.id()==ID_struct)
compound_symbol.type.id(ID_incomplete_struct);
else if(compound_symbol.type.id()==ID_union)
compound_symbol.type.id(ID_incomplete_union);
else
assert(false);
symbolt *new_symbol;
move_symbol(compound_symbol, new_symbol);
if(have_body)
{
typecheck_compound_body(to_struct_union_type(new_type));
new_symbol->type.swap(new_type);
}
}
else
{
// yes, it exists already
if(s_it->second.type.id()==ID_incomplete_struct ||
s_it->second.type.id()==ID_incomplete_union)
{
// Maybe we got a body now.
if(have_body)
{
irep_idt base_name=type.find(ID_tag).get(ID_C_base_name);
type.remove(ID_tag);
type.set(ID_tag, base_name);
typecheck_compound_body(type);
s_it->second.type.swap(type);
}
}
else if(have_body)
{
error().source_location=type.source_location();
error() << "redefinition of body of `"
<< s_it->second.pretty_name << "'" << eom;
throw 0;
}
}
}
symbol_typet symbol_type;
symbol_type.add_source_location()=type.source_location();
symbol_type.set_identifier(identifier);
c_qualifierst original_qualifiers(type);
type.swap(symbol_type);
original_qualifiers.write(type);
}
void cpp_typecheckt::typecheck_compound_type(
struct_union_typet &type)
{
// first save qualifiers
c_qualifierst qualifiers(type);
// now clear them from the type
type.remove(ID_C_constant);
type.remove(ID_C_volatile);
type.remove(ID_C_restricted);
// get the tag name
bool anonymous=type.find(ID_tag).is_nil();
irep_idt base_name;
cpp_scopet *dest_scope=NULL;
bool has_body=type.find(ID_body).is_not_nil();
bool tag_only_declaration=type.get_bool(ID_C_tag_only_declaration);
if(anonymous)
{
base_name="#anon_"+type.id_string()+i2string(anon_counter++);
type.set("#is_anonymous", true);
// anonymous structs always go into the current scope
dest_scope=&cpp_scopes.current_scope();
}
else
{
const cpp_namet &cpp_name=
to_cpp_name(type.find(ID_tag));
// scope given?
if(cpp_name.is_simple_name())
{
base_name=cpp_name.get_base_name();
dest_scope=&tag_scope(base_name, has_body, tag_only_declaration);
}
else
{
cpp_save_scopet cpp_save_scope(cpp_scopes);
cpp_typecheck_resolvet cpp_typecheck_resolve(*this);
cpp_template_args_non_tct t_args;
dest_scope=&cpp_typecheck_resolve.resolve_scope(cpp_name, base_name, t_args);
}
}
const irep_idt symbol_name=
language_prefix+
dest_scope->prefix+
"tag."+id2string(base_name);
// check if we have it already
contextt::symbolst::iterator previous_symbol=
context.symbols.find(symbol_name);
if(previous_symbol!=context.symbols.end())
{
// we do!
symbolt &symbol=previous_symbol->second;
if(has_body)
{
if(symbol.type.id()=="incomplete_"+type.id_string())
{
// a previously incomplete struct/union becomes complete
symbol.type.swap(type);
typecheck_compound_body(symbol);
}
else
{
err_location(type.location());
str << "error: struct symbol `" << base_name
<< "' declared previously" << std::endl;
str << "location of previous definition: "
<< symbol.location;
throw 0;
}
}
}
else
{
// produce new symbol
symbolt symbol;
symbol.name=symbol_name;
symbol.base_name=base_name;
symbol.value.make_nil();
symbol.location=type.location();
symbol.mode=ID_cpp;
symbol.module=module;
symbol.type.swap(type);
symbol.is_type=true;
symbol.is_macro=false;
symbol.pretty_name=cpp_scopes.current_scope().prefix+id2string(symbol.base_name);
symbol.type.set(ID_tag, symbol.pretty_name);
// move early, must be visible before doing body
symbolt *new_symbol;
if(context.move(symbol, new_symbol))
throw "cpp_typecheckt::typecheck_compound_type: context.move() failed";
// put into dest_scope
cpp_idt &id=cpp_scopes.put_into_scope(*new_symbol, *dest_scope);
id.id_class=cpp_idt::CLASS;
id.is_scope=true;
id.prefix=cpp_scopes.current_scope().prefix+
id2string(new_symbol->base_name)+"::";
id.class_identifier=new_symbol->name;
id.id_class=cpp_idt::CLASS;
if(has_body)
typecheck_compound_body(*new_symbol);
else
{
typet new_type("incomplete_"+new_symbol->type.id_string());
new_type.set(ID_tag, new_symbol->base_name);
new_symbol->type.swap(new_type);
}
}
// create type symbol
typet symbol_type(ID_symbol);
symbol_type.set(ID_identifier, symbol_name);
qualifiers.write(symbol_type);
type.swap(symbol_type);
}
