use instructiont::apply

Author: Daniel Kroening

src/analyses/dirty.cpp

@@ -17,13 +17,8 @@ Date: March 2013
 
 void dirtyt::build(const goto_functiont &goto_function)
 {
-  forall_goto_program_instructions(it, goto_function.body)
-  {
-    find_dirty(it->code);
-
-    if(it->has_condition())
-      find_dirty(it->get_condition());
-  }
+  for(const auto &i : goto_function.body.instructions)
+    i.apply([this](const exprt &e) { find_dirty(e); });
 }
 
 void dirtyt::find_dirty(const exprt &expr)

src/analyses/interval_analysis.cpp

@@ -32,11 +32,8 @@ void instrument_intervals(
 {
   std::set<symbol_exprt> symbols;
 
-  forall_goto_program_instructions(i_it, goto_function.body)
-  {
-    find_symbols(i_it->code, symbols);
-    find_symbols(i_it->guard, symbols);
-  }
+  for(const auto &i : goto_function.body.instructions)
+    i.apply([&symbols](const exprt &e) { find_symbols(e, symbols); });
 
   Forall_goto_program_instructions(i_it, goto_function.body)
   {

src/analyses/local_safe_pointers.cpp

@@ -237,19 +237,15 @@ void local_safe_pointerst::output_safe_dereferences(
     {
       out << "{";
       bool first = true;
-      for(auto subexpr_it = i_it->code.depth_begin(),
-            subexpr_end = i_it->code.depth_end();
-          subexpr_it != subexpr_end;
-          ++subexpr_it)
-      {
-        if(subexpr_it->id() == ID_dereference)
+      i_it->apply([&first, &out](const exprt &e) {
+        if(e.id() == ID_dereference)
         {
           if(!first)
             out << ", ";
           first = true;
-          format_rec(out, subexpr_it->op0());
+          format_rec(out, to_dereference_expr(e).pointer());
         }
-      }
+      });
       out << "}";
     }
 

src/goto-instrument/concurrency.cpp

@@ -186,14 +186,7 @@ void concurrency_instrumentationt::collect(
   forall_goto_program_instructions(i_it, goto_program)
   {
     if(is_threaded(i_it))
-    {
-      if(i_it->is_assign())
-        collect(i_it->code);
-      else if(i_it->is_assume() || i_it->is_assert() || i_it->is_goto())
-        collect(i_it->guard);
-      else if(i_it->is_function_call())
-        collect(i_it->code);
-    }
+      i_it->apply([this](const exprt &e) { collect(e); });
   }
 }
 

src/goto-instrument/cover_util.cpp

@@ -48,22 +48,11 @@ std::set<exprt> collect_conditions(const exprt &src)
 
 std::set<exprt> collect_conditions(const goto_programt::const_targett t)
 {
-  switch(t->type)
-  {
-  case GOTO:
-  case ASSERT:
-    return collect_conditions(t->guard);
+  std::set<exprt> result;
 
-  case ASSIGN:
-  case FUNCTION_CALL:
-    return collect_conditions(t->code);
+  t->apply([&result](const exprt &e) { collect_conditions_rec(e, result); });
 
-  default:
-  {
-  }
-  }
-
-  return std::set<exprt>();
+  return result;
 }
 
 void collect_operands(const exprt &src, std::vector<exprt> &dest)
@@ -115,20 +104,9 @@ std::set<exprt> collect_decisions(const exprt &src)
 
 std::set<exprt> collect_decisions(const goto_programt::const_targett t)
 {
-  switch(t->type)
-  {
-  case GOTO:
-  case ASSERT:
-    return collect_decisions(t->guard);
+  std::set<exprt> result;
 
-  case ASSIGN:
-  case FUNCTION_CALL:
-    return collect_decisions(t->code);
+  t->apply([&result](const exprt &e) { collect_decisions_rec(e, result); });
 
-  default:
-  {
-  }
-  }
-
-  return std::set<exprt>();
+  return result;
 }

src/goto-instrument/full_slicer.cpp

@@ -66,8 +66,8 @@ void full_slicert::add_decl_dead(
     return;
 
   find_symbols_sett syms;
-  find_symbols(node.PC->code, syms);
-  find_symbols(node.PC->guard, syms);
+
+  node.PC->apply([&syms](const exprt &e) { find_symbols(e, syms); });
 
   for(find_symbols_sett::const_iterator
       it=syms.begin();

src/goto-programs/compute_called_functions.cpp

@@ -54,13 +54,10 @@ void compute_address_taken_functions(
   const goto_programt &goto_program,
   std::unordered_set<irep_idt> &address_taken)
 {
-  forall_goto_program_instructions(it, goto_program)
-  {
-    if(it->has_condition())
-      compute_address_taken_functions(it->get_condition(), address_taken);
-
-    compute_address_taken_functions(it->code, address_taken);
-  }
+  for(const auto &i : goto_program.instructions)
+    i.apply([&address_taken](const exprt &expr) {
+      compute_address_taken_functions(expr, address_taken);
+    });
 }
 
 /// get all functions whose address is taken

src/goto-programs/slice_global_inits.cpp

@@ -61,22 +61,17 @@ void slice_global_inits(goto_modelt &goto_model)
     if(it == goto_functions.function_map.end())
       continue;
 
-    const goto_programt &goto_program = it->second.body;
-
-    forall_goto_program_instructions(i_it, goto_program)
-    {
-      const codet &code = i_it->code;
-      find_symbols(code, symbols, true, false);
-
-      if(i_it->has_condition())
-        find_symbols(i_it->get_condition(), symbols, true, false);
-    }
+    for(const auto &i : it->second.body.instructions)
+      i.apply([&symbols](const exprt &expr) {
+        find_symbols(expr, symbols, true, false);
+      });
   }
 
   // now remove unnecessary initializations
 
   goto_functionst::function_mapt::iterator f_it;
   f_it=goto_functions.function_map.find(INITIALIZE_FUNCTION);
+
   if(f_it == goto_functions.function_map.end())
     throw incorrect_goto_program_exceptiont("initialize function not found");