自学教程：C++ to_struct_type函数代码示例

void c_typecheck_baset::designator_enter(  const typet &type,  designatort &designator){  designatort::entryt entry;  entry.type=type;  assert(entry.type.id()!=ID_symbol);    if(entry.type.id()==ID_struct)  {    entry.size=to_struct_type(entry.type).components().size();    if(entry.size!=0)      entry.subtype=to_struct_type(entry.type).components().front().type();    else      entry.subtype.make_nil();  }  else if(entry.type.id()==ID_union)  {    if(to_union_type(entry.type).components().empty())    {      entry.size=0;      entry.subtype.make_nil();    }    else    {      entry.size=1;      entry.subtype=to_union_type(entry.type).components().front().type();    }  }  else if(entry.type.id()==ID_array)  {    mp_integer array_size;    if(to_integer(to_array_type(entry.type).size(), array_size))    {      err_location(to_array_type(entry.type).size());      str << "array has non-constant size `"          << to_string(to_array_type(entry.type).size()) << "'";      throw 0;    }    entry.size=integer2long(array_size);    entry.subtype=entry.type.subtype();  }  else if(entry.type.id()==ID_incomplete_array)  {    entry.size=0;    entry.subtype=entry.type.subtype();  }  else    assert(false);  designator.push_entry(entry);}

bool refined_string_typet::is_c_string_type(const typet &type){  if (type.id() == ID_struct) {    irep_idt tag = to_struct_type(type).get_tag();    return (tag == irep_idt("__CPROVER_string"));  } else return false;}

void java_root_class(symbolt &class_symbol){  struct_typet &struct_type=to_struct_type(class_symbol.type);  struct_typet::componentst &components=struct_type.components();  {    // for monitorenter/monitorexit    struct_typet::componentt component;    component.set_name("@lock");    component.set_pretty_name("@lock");    component.type()=java_boolean_type();    // add at the beginning    components.insert(components.begin(), component);  }  {    // the class identifier is used for stuff such as 'instanceof'    struct_typet::componentt component;    component.set_name("@class_identifier");    component.set_pretty_name("@class_identifier");    component.type()=string_typet();    // add at the beginning    components.insert(components.begin(), component);  }}

void java_bytecode_parsert::get_class_refs_rec(const typet &src){  if(src.id()==ID_code)  {    const code_typet &ct=to_code_type(src);    const typet &rt=ct.return_type();    get_class_refs_rec(rt);    for(const auto &p : ct.parameters())      get_class_refs_rec(p.type());  }  else if(src.id()==ID_symbol)  {    irep_idt name=src.get(ID_C_base_name);    if(has_prefix(id2string(name), "array["))    {      const typet &element_type=        static_cast<const typet &>(src.find(ID_C_element_type));      get_class_refs_rec(element_type);    }    else      parse_tree.class_refs.insert(name);  }  else if(src.id()==ID_struct)  {    const struct_typet &struct_type=to_struct_type(src);    for(const auto &c : struct_type.components())      get_class_refs_rec(c.type());  }  else if(src.id()==ID_pointer)    get_class_refs_rec(src.subtype());}

bvt boolbvt::convert_struct(const struct_exprt &expr){  const struct_typet &struct_type=to_struct_type(ns.follow(expr.type()));  std::size_t width=boolbv_width(struct_type);  const struct_typet::componentst &components=struct_type.components();  if(expr.operands().size()!=components.size())  {    error().source_location=expr.find_source_location();    error() << "struct: wrong number of arguments" << eom;    throw 0;  }  bvt bv;  bv.resize(width);  std::size_t offset=0, i=0;  for(struct_typet::componentst::const_iterator      it=components.begin();      it!=components.end();      it++)  {    const typet &subtype=it->type();    const exprt &op=expr.operands()[i];    if(!base_type_eq(subtype, op.type(), ns))    {      error().source_location=expr.find_source_location();      error() << "struct: component type does not match: "              << subtype.pretty() << " vs. "              << op.type().pretty() << eom;      throw 0;    }    std::size_t subtype_width=boolbv_width(subtype);    if(subtype_width!=0)    {      const bvt &op_bv=convert_bv(op);      assert(offset<width);      assert(op_bv.size()==subtype_width);      assert(offset+op_bv.size()<=width);      for(std::size_t j=0; j<op_bv.size(); j++)        bv[offset+j]=op_bv[j];      offset+=op_bv.size();    }    i++;  }  assert(offset==width);  return bv;}

exprt remove_virtual_functionst::build_class_identifier(  const exprt &src){  // the class identifier is in the root class  exprt e=src;    while(1)  {    const typet &type=ns.follow(e.type());    assert(type.id()==ID_struct);        const struct_typet &struct_type=to_struct_type(type);    const struct_typet::componentst &components=struct_type.components();    assert(!components.empty());        member_exprt member_expr(      e, components.front().get_name(), components.front().type());        if(components.front().get_name()=="@class_identifier")    {      // found it      return member_expr;    }    else    {      e=member_expr;    }  }}

void boolbvt::convert_with(  const typet &type,  const exprt &op1,  const exprt &op2,  const bvt &prev_bv,  bvt &next_bv){  // we only do that on arrays, bitvectors, structs, and unions  next_bv.resize(prev_bv.size());  if(type.id()==ID_array)    return convert_with_array(to_array_type(type), op1, op2, prev_bv, next_bv);  else if(type.id()==ID_bv ||          type.id()==ID_unsignedbv ||          type.id()==ID_signedbv)    return convert_with_bv(type, op1, op2, prev_bv, next_bv);  else if(type.id()==ID_struct)    return convert_with_struct(to_struct_type(type), op1, op2, prev_bv, next_bv);  else if(type.id()==ID_union)    return convert_with_union(to_union_type(type), op1, op2, prev_bv, next_bv);  else if(type.id()==ID_symbol)    return convert_with(ns.follow(type), op1, op2, prev_bv, next_bv);  error().source_location=type.source_location();  error() << "unexpected with type: " << type.id();  throw 0;}

void path_slicert::get_suffixes(    const std::string &base,    const typet &type,    string_sett &s){    const irep_idt &type_id=ns.follow(type).id();    if(type_id==ID_struct || type_id==ID_union)    {        s.insert(base);        const struct_typet &struct_type=to_struct_type(ns.follow(type));        for(struct_typet::componentst::const_iterator                c_it=struct_type.components().begin();                c_it!=struct_type.components().end();                c_it++)        {            const typet &subtype=c_it->type();            const irep_idt &name=c_it->get(ID_name);            get_suffixes(base+"."+id2string(name), subtype, s);        }    }    else if(type_id==ID_array)    {        s.insert(base);        get_suffixes(base+"[]", ns.follow(type).subtype(), s);    }    else    {        // no suffixes        s.insert(base);    }}

exprt remove_const_function_pointerst::get_component_value(  const struct_exprt &struct_expr, const member_exprt &member_expr){  const struct_typet &struct_type=to_struct_type(ns.follow(struct_expr.type()));  size_t component_number=    struct_type.component_number(member_expr.get_component_name());  return struct_expr.operands()[component_number];}

bool is_jsa_heap(const typet &type){  const irep_idt &type_id=type.id();  if (ID_symbol == type_id)    return id2string(to_symbol_type(type).get_identifier()) == JSA_HEAP_TAG;  if (ID_struct != type_id) return false;  const irep_idt tag(to_struct_type(type).get_tag());  return id2string(tag) == JSA_HEAP_TAG;}

const exprt &get_controller_comp(const namespacet &ns,    const struct_exprt &value, const char * const comp){  const struct_typet &type=to_struct_type(ns.follow(value.type()));  const struct_typet::componentst &comps=type.components();  for (size_t i=0; i < comps.size(); ++i)    if (id2string(comps[i].get_name()) == comp) return value.operands()[i];  assert(!"Solution component not found.");}

const struct_typet &cpp_typecheckt::this_struct_type(){  const exprt &this_expr = cpp_scopes.current_scope().this_expr;  assert(this_expr.is_not_nil());  assert(this_expr.type().id() == "pointer");  const typet &t = follow(this_expr.type().subtype());  return to_struct_type(t);}

bool dereferencet::type_compatible(  const typet &object_type,  const typet &dereference_type) const{  if(dereference_type.id()==ID_empty)    return true; // always ok  if(base_type_eq(object_type, dereference_type, ns))    return true; // ok, they just match  // check for struct prefixes  if(object_type.id()==ID_struct &&     dereference_type.id()==ID_struct)  {    if(to_struct_type(dereference_type).is_prefix_of(         to_struct_type(object_type)))      return true; // ok, dreference_type is a prefix of object_type  }  // any code is ok  if(dereference_type.id()==ID_code &&     object_type.id()==ID_code)    return true;  // bit vectors of same size are ok  if((object_type.id()==ID_signedbv || object_type.id()==ID_unsignedbv) &&     (dereference_type.id()==ID_signedbv ||      dereference_type.id()==ID_unsignedbv))  {    return object_type.get(ID_width)==dereference_type.get(ID_width);  }  // Any pointer to pointer is always ok,  // but should likely check that width is the same.  if(object_type.id()==ID_pointer &&     dereference_type.id()==ID_pointer)    return true;  // really different  return false;}

void cpp_typecheckt::find_constructor(  const typet &start_dest_type,  exprt &constructor_expr){  constructor_expr.make_nil();  source_locationt source_location=start_dest_type.source_location();  typet dest_type(start_dest_type);  follow_symbol(dest_type);  if(dest_type.id()!=ID_struct)    return;  const struct_typet::componentst &components=    to_struct_type(dest_type).components();  for(struct_typet::componentst::const_iterator      it=components.begin();      it!=components.end();      it++)  {    const struct_typet::componentt &component=*it;    const typet &type=component.type();    if(type.find(ID_return_type).id()==ID_constructor)    {      const irept::subt &parameters=        type.find(ID_parameters).get_sub();      namespacet ns(symbol_table);      if(parameters.size()==1)      {        const exprt &parameter=(exprt &)parameters.front();        const typet &arg_type=parameter.type();        if(arg_type.id()==ID_pointer &&           type_eq(arg_type.subtype(), dest_type, ns))        {          // found!          const irep_idt &identifier=            component.get(ID_name);          if(identifier=="")            throw "constructor without identifier";          constructor_expr=exprt(ID_symbol, type);          constructor_expr.set(ID_identifier, identifier);          constructor_expr.add_source_location()=source_location;          return;        }      }    }  }}

bool value_set_dereferencet::dereference_type_compare(  const typet &object_type,  const typet &dereference_type) const{  if(dereference_type.id()==ID_empty)    return true; // always ok  if(base_type_eq(object_type, dereference_type, ns))    return true; // ok, they just match  // check for struct prefixes  const typet ot_base=ns.follow(object_type),              dt_base=ns.follow(dereference_type);  if(ot_base.id()==ID_struct &&     dt_base.id()==ID_struct)  {    if(to_struct_type(dt_base).is_prefix_of(         to_struct_type(ot_base)))      return true; // ok, dt is a prefix of ot  }  // we are generous about code pointers  if(dereference_type.id()==ID_code &&     object_type.id()==ID_code)    return true;  // bitvectors of same width are ok  if((dereference_type.id()==ID_signedbv ||      dereference_type.id()==ID_unsignedbv) &&     (object_type.id()==ID_signedbv ||      object_type.id()==ID_unsignedbv) &&     to_bitvector_type(dereference_type).get_width()==     to_bitvector_type(object_type).get_width())    return true;  // really different  return false;}

bool refined_string_typet::is_java_char_sequence_type(const typet &type){  if(type.id() == ID_pointer) {    pointer_typet pt = to_pointer_type(type);    typet subtype = pt.subtype();    if(subtype.id() == ID_struct) {      irep_idt tag = to_struct_type(subtype).get_tag();      return (tag == irep_idt("java.lang.CharSequence"));    }     else return false;  } else return false;}

mp_integer compute_pointer_offset(  const namespacet &ns,  const exprt &expr){  if(expr.id()==ID_symbol)    return 0;  else if(expr.id()==ID_index)  {    assert(expr.operands().size()==2);        const typet &array_type=ns.follow(expr.op0().type());    assert(array_type.id()==ID_array);    mp_integer o=compute_pointer_offset(ns, expr.op0());        if(o!=-1)    {      mp_integer sub_size=        pointer_offset_size(ns, array_type.subtype());      mp_integer i;      if(sub_size!=0 && !to_integer(expr.op1(), i))        return o+i*sub_size;    }          // don't know  }  else if(expr.id()==ID_member)  {    assert(expr.operands().size()==1);    const typet &type=ns.follow(expr.op0().type());        assert(type.id()==ID_struct ||           type.id()==ID_union);    mp_integer o=compute_pointer_offset(ns, expr.op0());    if(o!=-1)    {          if(type.id()==ID_union)        return o;          return o+member_offset(        ns, to_struct_type(type), expr.get(ID_component_name));    }  }  else if(expr.id()==ID_string_constant)    return 0;  return -1; // don't know}

/// /par parameters: a type/// /return Boolean telling whether the type is that of java char sequencebool refined_string_typet::is_java_char_sequence_type(const typet &type){  if(type.id()==ID_pointer)  {    const pointer_typet &pt=to_pointer_type(type);    const typet &subtype=pt.subtype();    if(subtype.id()==ID_struct)    {      const irep_idt &tag=to_struct_type(subtype).get_tag();      return tag=="java.lang.CharSequence";    }  }  return false;}

/// /par parameters: a type/// /return Boolean telling whether the type is that of java string builderbool refined_string_typet::is_java_string_builder_type(const typet &type){  if(type.id()==ID_pointer)  {    const pointer_typet &pt=to_pointer_type(type);    const typet &subtype=pt.subtype();    if(subtype.id()==ID_struct)    {      irep_idt tag=to_struct_type(subtype).get_tag();      return tag=="java.lang.StringBuilder";    }  }  return false;}

/// /par parameters: a type/// /return Boolean telling whether the type is that of java stringbool refined_string_typet::is_java_string_type(const typet &type){  if(type.id()==ID_symbol)  {    irep_idt tag=to_symbol_type(type).get_identifier();    return tag=="java::java.lang.String";  }  else if(type.id()==ID_struct)  {    irep_idt tag=to_struct_type(type).get_tag();    return tag=="java.lang.String";  }  return false;}

void c_typecheck_baset::increment_designator(designatort &designator){  assert(!designator.empty());  while(true)  {    designatort::entryt &entry=designator[designator.size()-1];    const typet &full_type=follow(entry.type);    entry.index++;    if(full_type.id()==ID_array &&       to_array_type(full_type).size().is_nil())      return; // we will keep going forever    if(full_type.id()==ID_struct &&       entry.index<entry.size)    {      // need to adjust subtype      const struct_typet &struct_type=        to_struct_type(full_type);      const struct_typet::componentst &components=        struct_type.components();      assert(components.size()==entry.size);      // we skip over any padding or code      while(entry.index<entry.size &&            (components[entry.index].get_is_padding() ||             components[entry.index].type().id()==ID_code))        entry.index++;      if(entry.index<entry.size)        entry.subtype=components[entry.index].type();    }    if(entry.index<entry.size)      return; // done    if(designator.size()==1)      return; // done    // pop entry    designator.pop_entry();    assert(!designator.empty());  }}

code_function_callt get_destructor(  const namespacet &ns,  const typet &type){  if(type.id()==ID_symbol)  {    return get_destructor(ns, ns.follow(type));  }  else if(type.id()==ID_struct)  {    const struct_typet &struct_type=to_struct_type(type);    const struct_typet::componentst &components=      struct_type.components();    for(struct_typet::componentst::const_iterator        it=components.begin();        it!=components.end();        it++)    {      if(it->type().id()==ID_code)      {        const code_typet &code_type=to_code_type(it->type());                if(code_type.return_type().id()==ID_destructor &&           code_type.parameters().size()==1)        {          const typet &arg_type=code_type.parameters().front().type();                    if(arg_type.id()==ID_pointer &&             ns.follow(arg_type.subtype())==type)          {            exprt symbol_expr(ID_symbol, it->type());            symbol_expr.set(ID_identifier, it->get(ID_name));                  code_function_callt function_call;            function_call.function()=symbol_expr;                        return function_call;          }        }      }    }  }  return static_cast<const code_function_callt &>(get_nil_irep());}

bool replace_symbolt::replace(typet &dest){  if(dest.has_subtype())    replace(dest.subtype());  Forall_subtypes(it, dest)    replace(*it);      if(dest.id()=="struct" ||     dest.id()=="union")  {    struct_typet &struct_type = to_struct_type(dest);        struct_typet::componentst &components = struct_type.components();    for (struct_typet::componentst::iterator it = components.begin();         it!=components.end();         it++)      replace(*it);  }   else if(dest.is_code())  {    code_typet &code_type=to_code_type(dest);    code_typet::argumentst &arguments=code_type.arguments();    for (code_typet::argumentst::iterator it = arguments.begin();         it!=arguments.end();         it++)      replace(*it);  }    if(dest.id()=="symbol")  {    type_mapt::const_iterator it=      type_map.find(dest.identifier());    if(it!=type_map.end())    {      dest=it->second;      return false;    }  }  return true;}

void cpp_typecheckt::clean_up(){  context.Foreach_operand([this](symbolt &s) {    if(s.type.get_bool("is_template"))    {      context.erase_symbol(s.name);      return;    }    if(s.type.is_struct() || s.type.is_union())    {      struct_typet &struct_type = to_struct_type(s.type);      const struct_typet::componentst &components = struct_type.components();      struct_typet::componentst data_members;      data_members.reserve(components.size());      struct_typet::componentst &function_members = struct_type.methods();      function_members.reserve(components.size());      for(const auto &component : components)      {        if(component.get_bool("is_static") || component.is_type())        {          // skip it        }        else if(component.type().id() == "code")        {          function_members.push_back(component);        }        else        {          data_members.push_back(component);        }      }      struct_type.components().swap(data_members);    }  });}

void set_class_identifier(  struct_exprt &expr,  const namespacet &ns,  const symbol_typet &class_type){  const struct_typet &struct_type=    to_struct_type(ns.follow(expr.type()));  const struct_typet::componentst &components=struct_type.components();  if(components.empty()) return;  assert(!expr.operands().empty());    if(components.front().get_name()=="@class_identifier")  {    assert(expr.op0().id()==ID_constant);    expr.op0()=constant_exprt(class_type.get_identifier(), string_typet());  }  else  {    assert(expr.op0().id()==ID_struct);    set_class_identifier(to_struct_expr(expr.op0()), ns, class_type);  }}

void invariant_propagationt::get_objects_rec(  const exprt &src,  std::list<exprt> &dest){  const typet &t=ns.follow(src.type());  if(t.id()==ID_struct ||     t.id()==ID_union)  {    const struct_typet &struct_type=to_struct_type(t);        const struct_typet::componentst &c=struct_type.components();        exprt member_expr(ID_member);    member_expr.copy_to_operands(src);        for(struct_typet::componentst::const_iterator        it=c.begin();        it!=c.end();        it++)    {      member_expr.set(ID_component_name, it->get_string(ID_name));      member_expr.type()=it->type();      // recursive call      get_objects_rec(member_expr, dest);    }  }  else if(t.id()==ID_array)  {    //get_objects_rec(identifier, suffix+"[]", t.subtype(), dest);    //we don't track these  }  else if(check_type(t))  {    dest.push_back(src);  }}

void value_set_analysis_fivrt::get_entries_rec(  const irep_idt &identifier,  const std::string &suffix,  const typet &type,  std::list<value_set_fivrt::entryt> &dest){  const typet &t=ns.follow(type);  if(t.id()==ID_struct ||     t.id()==ID_union)  {    const struct_typet &struct_type=to_struct_type(t);    const struct_typet::componentst &c=struct_type.components();    for(struct_typet::componentst::const_iterator        it=c.begin();        it!=c.end();        it++)    {      get_entries_rec(        identifier,        suffix+"."+it->get_string(ID_name),        it->type(),        dest);    }  }  else if(t.id()==ID_array)  {    get_entries_rec(identifier, suffix+"[]", t.subtype(), dest);  }  else if(check_type(t))  {    dest.push_back(value_set_fivrt::entryt(identifier, suffix));  }}

#include <util/std_types.h>#include <util/symbol_table.h>/// Looks for all the struct types in the symbol table and construct a map from/// class names to a data structure that contains lists of parent and child/// classes for each struct type (ie class)./// /param symbol_table: The symbol table to analyzevoid class_hierarchyt::operator()(const symbol_tablet &symbol_table){  forall_symbols(it, symbol_table.symbols)  {    if(it->second.is_type && it->second.type.id()==ID_struct)    {      const struct_typet &struct_type=        to_struct_type(it->second.type);      const irept::subt &bases=        struct_type.find(ID_bases).get_sub();      for(const auto &base : bases)      {        irep_idt parent=base.find(ID_type).get(ID_identifier);        if(parent.empty())          continue;        class_map[parent].children.push_back(it->first);        class_map[it->first].parents.push_back(parent);      }    }  }