use ranged for over components

Author: Daniel Kroening

src/ansi-c/c_typecheck_type.cpp

@@ -913,15 +913,12 @@ void c_typecheck_baset::typecheck_compound_body(
   {
     std::unordered_set<irep_idt> members;
 
-    for(struct_union_typet::componentst::iterator
-        it=components.begin();
-        it!=components.end();
-        it++)
+    for(const auto &c : components)
     {
-      if(!members.insert(it->get_name()).second)
+      if(!members.insert(c.get_name()).second)
       {
-        error().source_location=it->source_location();
-        error() << "duplicate member '" << it->get_name() << '\'' << eom;
+        error().source_location = c.source_location();
+        error() << "duplicate member '" << c.get_name() << '\'' << eom;
         throw 0;
       }
     }

src/ansi-c/expr2c.cpp

@@ -353,13 +353,10 @@ std::string expr2ct::convert_rec(
       dest+=" "+id2string(tag);
     dest+=" {";
 
-    for(union_typet::componentst::const_iterator
-        it=union_type.components().begin();
-        it!=union_type.components().end();
-        it++)
+    for(const auto &c : union_type.components())
     {
       dest+=' ';
-      dest+=convert_rec(it->type(), c_qualifierst(), id2string(it->get_name()));
+      dest += convert_rec(c.type(), c_qualifierst(), id2string(c.get_name()));
       dest+=';';
     }
 
@@ -724,8 +721,7 @@ std::string expr2ct::convert_struct_type(
   {
     dest+=" {";
 
-    for(const struct_union_typet::componentt &component :
-      struct_type.components())
+    for(const auto &component : struct_type.components())
     {
       // Skip padding parameters unless we including them
       if(component.get_is_padding() && !inc_padding_components)
@@ -2071,8 +2067,7 @@ std::string expr2ct::convert_struct(
   bool newline=false;
   size_t last_size=0;
 
-  for(const struct_union_typet::componentt &component :
-    struct_type.components())
+  for(const auto &component : struct_type.components())
   {
     if(o_it->type().id()==ID_code)
       continue;

src/cpp/cpp_constructor.cpp

@@ -213,18 +213,15 @@ optionalt<codet> cpp_typecheckt::cpp_constructor(
 
     irep_idt constructor_name;
 
-    for(struct_typet::componentst::const_iterator
-        it=components.begin();
-        it!=components.end();
-        it++)
+    for(const auto &c : components)
     {
-      const typet &type=it->type();
+      const typet &type = c.type();
 
-      if(!it->get_bool(ID_from_base) &&
-         type.id()==ID_code &&
-         type.find(ID_return_type).id()==ID_constructor)
+      if(
+        !c.get_bool(ID_from_base) && type.id() == ID_code &&
+        type.find(ID_return_type).id() == ID_constructor)
       {
-        constructor_name=it->get(ID_base_name);
+        constructor_name = c.get(ID_base_name);
         break;
       }
     }

src/cpp/cpp_destructor.cpp

@@ -86,18 +86,15 @@ optionalt<codet> cpp_typecheckt::cpp_destructor(
 
     irep_idt dtor_name;
 
-    for(struct_typet::componentst::const_iterator
-        it=components.begin();
-        it!=components.end();
-        it++)
+    for(const auto &c : components)
     {
-      const typet &type=it->type();
+      const typet &type = c.type();
 
-      if(!it->get_bool(ID_from_base) &&
-         type.id()==ID_code &&
-         type.find(ID_return_type).id()==ID_destructor)
+      if(
+        !c.get_bool(ID_from_base) && type.id() == ID_code &&
+        type.find(ID_return_type).id() == ID_destructor)
       {
-        dtor_name=it->get(ID_base_name);
+        dtor_name = c.get(ID_base_name);
         break;
       }
     }

src/cpp/cpp_is_pod.cpp

@@ -31,25 +31,22 @@ bool cpp_typecheckt::cpp_is_pod(const typet &type) const
     const struct_typet::componentst &components=
       struct_type.components();
 
-    for(struct_typet::componentst::const_iterator
-        it=components.begin();
-        it!=components.end();
-        it++)
+    for(const auto &c : components)
     {
-      if(it->get_bool(ID_is_type))
+      if(c.get_bool(ID_is_type))
         continue;
 
-      if(it->get_base_name()=="operator=")
+      if(c.get_base_name() == "operator=")
         return false;
 
-      if(it->get_bool(ID_is_virtual))
+      if(c.get_bool(ID_is_virtual))
         return false;
 
-      const typet &sub_type=it->type();
+      const typet &sub_type = c.type();
 
       if(sub_type.id()==ID_code)
       {
-        if(it->get_bool(ID_is_virtual))
+        if(c.get_bool(ID_is_virtual))
           return false;
 
         const typet &return_type=to_code_type(sub_type).return_type();
@@ -58,8 +55,7 @@ bool cpp_typecheckt::cpp_is_pod(const typet &type) const
            return_type.id()==ID_destructor)
           return false;
       }
-      else if(it->get(ID_access)!=ID_public &&
-              !it->get_bool(ID_is_static))
+      else if(c.get(ID_access) != ID_public && !c.get_bool(ID_is_static))
         return false;
 
       if(!cpp_is_pod(sub_type))

src/cpp/cpp_typecheck_bases.cpp

@@ -169,19 +169,15 @@ void cpp_typecheckt::add_base_components(
   }
 
   // add the components
-  const struct_typet::componentst &src_c=from.components();
   struct_typet::componentst &dest_c=to.components();
 
-  for(struct_typet::componentst::const_iterator
-      it=src_c.begin();
-      it!=src_c.end();
-      it++)
+  for(const auto &c : from.components())
   {
-    if(it->get_bool(ID_from_base))
+    if(c.get_bool(ID_from_base))
       continue;
 
     // copy the component
-    dest_c.push_back(*it);
+    dest_c.push_back(c);
 
     // now twiddle the copy
     struct_typet::componentt &component=dest_c.back();

src/cpp/cpp_typecheck_constructor.cpp

@@ -283,48 +283,47 @@ void cpp_typecheckt::default_cpctor(
   // Then, we add the member initializers
   const struct_typet::componentst &components=
     to_struct_type(symbol.type).components();
-  for(struct_typet::componentst::const_iterator mem_it=components.begin();
-      mem_it!=components.end(); mem_it++)
+
+  for(const auto &mem_c : components)
   {
     // Take care of virtual tables
-    if(mem_it->get_bool("is_vtptr"))
+    if(mem_c.get_bool("is_vtptr"))
     {
       exprt name(ID_name);
-      name.set(ID_identifier, mem_it->get(ID_base_name));
+      name.set(ID_identifier, mem_c.get(ID_base_name));
       name.add_source_location()=source_location;
 
       cpp_namet cppname;
       cppname.move_to_sub(name);
 
       const symbolt &virtual_table_symbol_type =
-        lookup(mem_it->type().subtype().get(ID_identifier));
+        lookup(mem_c.type().subtype().get(ID_identifier));
 
       const symbolt &virtual_table_symbol_var = lookup(
         id2string(virtual_table_symbol_type.name) + "@" +
         id2string(symbol.name));
 
       exprt var=virtual_table_symbol_var.symbol_expr();
       address_of_exprt address(var);
-      assert(address.type()==mem_it->type());
+      assert(address.type() == mem_c.type());
 
       already_typechecked(address);
 
       exprt ptrmember(ID_ptrmember);
-      ptrmember.set(ID_component_name, mem_it->get(ID_name));
+      ptrmember.set(ID_component_name, mem_c.get(ID_name));
       ptrmember.operands().push_back(exprt("cpp-this"));
 
       code_assignt assign(ptrmember, address);
       initializers.move_to_sub(assign);
       continue;
     }
 
-    if( mem_it->get_bool("from_base")
-      || mem_it->get_bool(ID_is_type)
-      || mem_it->get_bool(ID_is_static)
-      || mem_it->type().id()==ID_code)
-        continue;
+    if(
+      mem_c.get_bool("from_base") || mem_c.get_bool(ID_is_type) ||
+      mem_c.get_bool(ID_is_static) || mem_c.type().id() == ID_code)
+      continue;
 
-    irep_idt mem_name=mem_it->get(ID_base_name);
+    irep_idt mem_name = mem_c.get(ID_base_name);
 
     exprt name(ID_name);
     name.set(ID_identifier, mem_name);
@@ -343,7 +342,7 @@ void cpp_typecheckt::default_cpctor(
       static_cast<const exprt &>(static_cast<const irept &>(cpp_parameter)));
     memberexpr.add_source_location()=source_location;
 
-    if(mem_it->type().id()==ID_array)
+    if(mem_c.type().id() == ID_array)
       memberexpr.set(ID_C_array_ini, true);
 
     mem_init.move_to_operands(memberexpr);
@@ -563,27 +562,24 @@ void cpp_typecheckt::check_member_initializers(
     irep_idt base_name=member_name.get_base_name();
     bool ok=false;
 
-    for(struct_typet::componentst::const_iterator
-        c_it=components.begin();
-        c_it!=components.end();
-        c_it++)
+    for(const auto &c : components)
     {
-      if(c_it->get(ID_base_name)!=base_name)
+      if(c.get(ID_base_name) != base_name)
         continue;
 
       // Data member
-      if(!c_it->get_bool(ID_from_base) &&
-         !c_it->get_bool(ID_is_static) &&
-         c_it->get(ID_type)!=ID_code)
+      if(
+        !c.get_bool(ID_from_base) && !c.get_bool(ID_is_static) &&
+        c.get(ID_type) != ID_code)
       {
         ok=true;
         break;
       }
 
       // Maybe it is a parent constructor?
-      if(c_it->get_bool("is_type"))
+      if(c.get_bool("is_type"))
       {
-        typet type=static_cast<const typet&>(c_it->find(ID_type));
+        typet type = static_cast<const typet &>(c.find(ID_type));
         if(type.id() != ID_symbol_type)
           continue;
 
@@ -605,11 +601,10 @@ void cpp_typecheckt::check_member_initializers(
       }
 
       // Parent constructor
-      if(c_it->get_bool(ID_from_base) &&
-         !c_it->get_bool(ID_is_type) &&
-         !c_it->get_bool(ID_is_static) &&
-         c_it->get(ID_type)==ID_code &&
-         c_it->find(ID_type).get(ID_return_type)==ID_constructor)
+      if(
+        c.get_bool(ID_from_base) && !c.get_bool(ID_is_type) &&
+        !c.get_bool(ID_is_static) && c.get(ID_type) == ID_code &&
+        c.find(ID_type).get(ID_return_type) == ID_constructor)
       {
         typet member_type=(typet&) initializer.find(ID_member);
         typecheck_type(member_type);
@@ -743,12 +738,11 @@ void cpp_typecheckt::full_member_initialization(
           // check if the initializer is a data
           bool is_data=false;
 
-          for(struct_typet::componentst::const_iterator c_it =
-              components.begin(); c_it!=components.end(); c_it++)
+          for(const auto &c : components)
           {
-            if(c_it->get(ID_base_name)==base_name &&
-               c_it->get(ID_type)!=ID_code &&
-               !c_it->get_bool(ID_is_type))
+            if(
+              c.get(ID_base_name) == base_name && c.get(ID_type) != ID_code &&
+              !c.get_bool(ID_is_type))
             {
               is_data=true;
               break;

src/cpp/cpp_typecheck_resolve.cpp

@@ -647,16 +647,9 @@ void cpp_typecheck_resolvet::make_constructors(
     {
       const struct_typet &struct_type=to_struct_type(symbol_type);
 
-      const struct_typet::componentst &components =
-        struct_type.components();
-
       // go over components
-      for(struct_typet::componentst::const_iterator
-          itc=components.begin();
-          itc!=components.end();
-          itc++)
+      for(const auto &component : struct_type.components())
       {
-        const struct_typet::componentt &component=*itc;
         const typet &type=component.type();
 
         if(component.get_bool(ID_from_base))

src/cpp/expr2cpp.cpp

@@ -68,12 +68,9 @@ std::string expr2cppt::convert_struct(
   bool first=true;
   size_t last_size=0;
 
-  for(struct_typet::componentst::const_iterator
-      c_it=components.begin();
-      c_it!=components.end();
-      c_it++)
+  for(const auto &c : components)
   {
-    if(c_it->type().id()==ID_code)
+    if(c.type().id() == ID_code)
     {
     }
     else
@@ -96,7 +93,7 @@ std::string expr2cppt::convert_struct(
 
       dest+=sep;
       dest+='.';
-      dest+=c_it->get_string(ID_pretty_name);
+      dest += c.get_string(ID_pretty_name);
       dest+='=';
       dest+=tmp;
     }

src/solvers/flattening/boolbv.cpp

@@ -88,14 +88,11 @@ bool boolbvt::literal(
 
       std::size_t offset=0;
 
-      for(struct_typet::componentst::const_iterator
-          it=components.begin();
-          it!=components.end();
-          it++)
+      for(const auto &c : components)
       {
-        const typet &subtype=it->type();
+        const typet &subtype = c.type();
 
-        if(it->get_name()==component_name)
+        if(c.get_name() == component_name)
           return literal(expr.op0(), bit+offset, dest);
 
         std::size_t element_width=boolbv_width(subtype);

src/solvers/flattening/boolbv_get.cpp

@@ -141,12 +141,9 @@ exprt boolbvt::bv_get_rec(
       exprt::operandst op;
       op.reserve(components.size());
 
-      for(struct_typet::componentst::const_iterator
-          it=components.begin();
-          it!=components.end();
-          it++)
+      for(const auto &c : components)
       {
-        const typet &subtype=ns.follow(it->type());
+        const typet &subtype = ns.follow(c.type());
         op.push_back(nil_exprt());
 
         std::size_t sub_width=boolbv_width(subtype);