Merge pull request #5615 from tautschnig/remove-forall-macros

Remove {f,F}orall_goto_functions

Author: tautschnig

.clang-format

@@ -30,8 +30,6 @@ DerivePointerAlignment: 'false'
 DisableFormat: 'false'
 ExperimentalAutoDetectBinPacking: 'false'
 ForEachMacros: [
-  'forall_goto_functions',
-  'Forall_goto_functions',
   'forall_goto_program_instructions',
   'Forall_goto_program_instructions',
   'forall_operands',

jbmc/src/janalyzer/janalyzer_parse_options.cpp

@@ -558,13 +558,13 @@ int janalyzer_parse_optionst::perform_analysis(
   {
     namespacet ns(goto_model.symbol_table);
 
-    forall_goto_functions(it, goto_model.goto_functions)
+    for(const auto &gf_entry : goto_model.goto_functions.function_map)
     {
       std::cout << ">>>>\n";
-      std::cout << ">>>> " << it->first << '\n';
+      std::cout << ">>>> " << gf_entry.first << '\n';
       std::cout << ">>>>\n";
-      local_may_aliast local_may_alias(it->second);
-      local_may_alias.output(std::cout, it->second, ns);
+      local_may_aliast local_may_alias(gf_entry.second);
+      local_may_alias.output(std::cout, gf_entry.second, ns);
       std::cout << '\n';
     }
 

jbmc/src/java_bytecode/remove_exceptions.cpp

@@ -619,8 +619,8 @@ void remove_exceptionst::instrument_exceptions(
 
 void remove_exceptionst::operator()(goto_functionst &goto_functions)
 {
-  Forall_goto_functions(it, goto_functions)
-    instrument_exceptions(it->first, it->second.body);
+  for(auto &gf_entry : goto_functions.function_map)
+    instrument_exceptions(gf_entry.first, gf_entry.second.body);
 }
 
 void remove_exceptionst::

jbmc/src/jdiff/java_syntactic_diff.cpp

@@ -16,25 +16,25 @@ Author: Peter Schrammel
 
 bool java_syntactic_difft::operator()()
 {
-  forall_goto_functions(it, goto_model1.goto_functions)
+  for(const auto &gf_entry : goto_model1.goto_functions.function_map)
   {
-    if(!it->second.body_available())
+    if(!gf_entry.second.body_available())
       continue;
 
     goto_functionst::function_mapt::const_iterator f_it =
-      goto_model2.goto_functions.function_map.find(it->first);
+      goto_model2.goto_functions.function_map.find(gf_entry.first);
     if(
       f_it == goto_model2.goto_functions.function_map.end() ||
       !f_it->second.body_available())
     {
-      deleted_functions.insert(it->first);
+      deleted_functions.insert(gf_entry.first);
       continue;
     }
 
     // check access qualifiers
-    const symbolt *fun1 = goto_model1.symbol_table.lookup(it->first);
+    const symbolt *fun1 = goto_model1.symbol_table.lookup(gf_entry.first);
     CHECK_RETURN(fun1 != nullptr);
-    const symbolt *fun2 = goto_model2.symbol_table.lookup(it->first);
+    const symbolt *fun2 = goto_model2.symbol_table.lookup(gf_entry.first);
     CHECK_RETURN(fun2 != nullptr);
     const optionalt<irep_idt> class_name = declaring_class(*fun1);
     bool function_access_changed =
@@ -67,29 +67,29 @@ bool java_syntactic_difft::operator()()
     }
     if(function_access_changed || class_access_changed || field_access_changed)
     {
-      modified_functions.insert(it->first);
+      modified_functions.insert(gf_entry.first);
       continue;
     }
 
-    if(!it->second.body.equals(f_it->second.body))
+    if(!gf_entry.second.body.equals(f_it->second.body))
     {
-      modified_functions.insert(it->first);
+      modified_functions.insert(gf_entry.first);
       continue;
     }
   }
-  forall_goto_functions(it, goto_model2.goto_functions)
+  for(const auto &gf_entry : goto_model2.goto_functions.function_map)
   {
-    if(!it->second.body_available())
+    if(!gf_entry.second.body_available())
       continue;
 
     total_functions_count++;
 
     goto_functionst::function_mapt::const_iterator f_it =
-      goto_model1.goto_functions.function_map.find(it->first);
+      goto_model1.goto_functions.function_map.find(gf_entry.first);
     if(
       f_it == goto_model1.goto_functions.function_map.end() ||
       !f_it->second.body_available())
-      new_functions.insert(it->first);
+      new_functions.insert(gf_entry.first);
   }
 
   return !(

src/analyses/ai.cpp

@@ -24,16 +24,16 @@ void ai_baset::output(
   const goto_functionst &goto_functions,
   std::ostream &out) const
 {
-  forall_goto_functions(f_it, goto_functions)
+  for(const auto &gf_entry : goto_functions.function_map)
   {
-    if(f_it->second.body_available())
+    if(gf_entry.second.body_available())
     {
       out << "////\n";
-      out << "//// Function: " << f_it->first << "\n";
+      out << "//// Function: " << gf_entry.first << "\n";
       out << "////\n";
       out << "\n";
 
-      output(ns, f_it->first, f_it->second.body, out);
+      output(ns, gf_entry.first, gf_entry.second.body, out);
     }
   }
 }
@@ -64,16 +64,16 @@ jsont ai_baset::output_json(
 {
   json_objectt result;
 
-  forall_goto_functions(f_it, goto_functions)
+  for(const auto &gf_entry : goto_functions.function_map)
   {
-    if(f_it->second.body_available())
+    if(gf_entry.second.body_available())
     {
-      result[id2string(f_it->first)] =
-        output_json(ns, f_it->first, f_it->second.body);
+      result[id2string(gf_entry.first)] =
+        output_json(ns, gf_entry.first, gf_entry.second.body);
     }
     else
     {
-      result[id2string(f_it->first)]=json_arrayt();
+      result[id2string(gf_entry.first)] = json_arrayt();
     }
   }
 
@@ -111,17 +111,18 @@ xmlt ai_baset::output_xml(
 {
   xmlt program("program");
 
-  forall_goto_functions(f_it, goto_functions)
+  for(const auto &gf_entry : goto_functions.function_map)
   {
     xmlt function(
       "function",
-      {{"name", id2string(f_it->first)},
-       {"body_available", f_it->second.body_available() ? "true" : "false"}},
+      {{"name", id2string(gf_entry.first)},
+       {"body_available", gf_entry.second.body_available() ? "true" : "false"}},
       {});
 
-    if(f_it->second.body_available())
+    if(gf_entry.second.body_available())
     {
-      function.new_element(output_xml(ns, f_it->first, f_it->second.body));
+      function.new_element(
+        output_xml(ns, gf_entry.first, gf_entry.second.body));
     }
 
     program.new_element(function);
@@ -194,8 +195,8 @@ void ai_baset::initialize(const irep_idt &, const goto_programt &goto_program)
 
 void ai_baset::initialize(const goto_functionst &goto_functions)
 {
-  forall_goto_functions(it, goto_functions)
-    initialize(it->first, it->second);
+  for(const auto &gf_entry : goto_functions.function_map)
+    initialize(gf_entry.first, gf_entry.second);
 }
 
 void ai_baset::finalize()

src/analyses/ai.h

@@ -706,20 +706,23 @@ class concurrency_aware_ait:public ait<domainT>
     typedef std::list<wl_entryt> thread_wlt;
     thread_wlt thread_wl;
 
-    forall_goto_functions(it, goto_functions)
-      forall_goto_program_instructions(t_it, it->second.body)
+    for(const auto &gf_entry : goto_functions.function_map)
+    {
+      forall_goto_program_instructions(t_it, gf_entry.second.body)
       {
         if(is_threaded(t_it))
         {
-          thread_wl.push_back(wl_entryt(it->first, it->second.body, t_it));
+          thread_wl.push_back(
+            wl_entryt(gf_entry.first, gf_entry.second.body, t_it));
 
           goto_programt::const_targett l_end =
-            it->second.body.instructions.end();
+            gf_entry.second.body.instructions.end();
           --l_end;
 
           merge_shared(shared_state, l_end, sh_target, ns);
         }
       }
+    }
 
     // now feed in the shared state into all concurrently executing
     // functions, and iterate until the shared state stabilizes

src/analyses/call_graph.cpp

@@ -39,10 +39,10 @@ call_grapht::call_grapht(
   const goto_functionst &goto_functions, bool collect_callsites):
   collect_callsites(collect_callsites)
 {
-  forall_goto_functions(f_it, goto_functions)
+  for(const auto &gf_entry : goto_functions.function_map)
   {
-    const irep_idt &function_name = f_it->first;
-    const goto_programt &body = f_it->second.body;
+    const irep_idt &function_name = gf_entry.first;
+    const goto_programt &body = gf_entry.second.body;
     nodes.insert(function_name);
     add(function_name, body);
   }

src/analyses/constant_propagator.cpp

@@ -741,8 +741,8 @@ void constant_propagator_ait::replace(
   goto_functionst &goto_functions,
   const namespacet &ns)
 {
-  Forall_goto_functions(f_it, goto_functions)
-    replace(f_it->second, ns);
+  for(auto &gf_entry : goto_functions.function_map)
+    replace(gf_entry.second, ns);
 }
 
 

src/analyses/custom_bitvector_analysis.cpp

@@ -776,19 +776,19 @@ void custom_bitvector_analysist::check(
 {
   unsigned pass=0, fail=0, unknown=0;
 
-  forall_goto_functions(f_it, goto_model.goto_functions)
+  for(const auto &gf_entry : goto_model.goto_functions.function_map)
   {
-    if(!f_it->second.body.has_assertion())
-       continue;
+    if(!gf_entry.second.body.has_assertion())
+      continue;
 
     // TODO this is a hard-coded hack
-    if(f_it->first=="__actual_thread_spawn")
+    if(gf_entry.first == "__actual_thread_spawn")
       continue;
 
     if(!use_xml)
-      out << "******** Function " << f_it->first << '\n';
+      out << "******** Function " << gf_entry.first << '\n';
 
-    forall_goto_program_instructions(i_it, f_it->second.body)
+    forall_goto_program_instructions(i_it, gf_entry.second.body)
     {
       exprt result;
       irep_idt description;
@@ -836,7 +836,7 @@ void custom_bitvector_analysist::check(
           out << ", " << description;
         out << ": ";
         const namespacet ns(goto_model.symbol_table);
-        out << from_expr(ns, f_it->first, result);
+        out << from_expr(ns, gf_entry.first, result);
         out << '\n';
       }
 

src/analyses/dirty.h

@@ -90,8 +90,8 @@ class dirtyt
   {
     // dirtyts should not be initialized twice
     PRECONDITION(!initialized);
-    forall_goto_functions(it, goto_functions)
-      build(it->second);
+    for(const auto &gf_entry : goto_functions.function_map)
+      build(gf_entry.second);
     initialized = true;
   }