Merge pull request #4267 from diffblue/instructiont-apply

instructiont::apply

Author: tautschnig

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

@@ -240,19 +240,20 @@ 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) {
+        for(auto subexpr_it = e.depth_begin(), subexpr_end = e.depth_end();
+            subexpr_it != subexpr_end;
+            ++subexpr_it)
         {
-          if(!first)
-            out << ", ";
-          first = true;
-          format_rec(out, subexpr_it->op0());
+          if(subexpr_it->id() == ID_dereference)
+          {
+            if(!first)
+              out << ", ";
+            first = true;
+            format_rec(out, to_dereference_expr(*subexpr_it).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/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,12 +54,11 @@ void compute_address_taken_functions(
   const goto_programt &goto_program,
   std::unordered_set<irep_idt> &address_taken)
 {
-  forall_goto_program_instructions(it, goto_program)
+  for(const auto &i : goto_program.instructions)
   {
-    if(it->has_condition())
-      compute_address_taken_functions(it->get_condition(), address_taken);
-
-    compute_address_taken_functions(it->code, address_taken);
+    i.apply([&address_taken](const exprt &expr) {
+      compute_address_taken_functions(expr, address_taken);
+    });
   }
 }
 

src/goto-programs/goto_program.cpp

@@ -992,6 +992,48 @@ void goto_programt::instructiont::transform(
   }
 }
 
+void goto_programt::instructiont::apply(
+  std::function<void(const exprt &)> f) const
+{
+  switch(type)
+  {
+  case OTHER:
+    if(get_other().get_statement() == ID_expression)
+      f(to_code_expression(get_other()).expression());
+    break;
+
+  case RETURN:
+    f(get_return().return_value());
+    break;
+
+  case ASSIGN:
+    f(get_assign().lhs());
+    f(get_assign().rhs());
+    break;
+
+  case DECL:
+    f(get_decl().symbol());
+    break;
+
+  case DEAD:
+    f(get_dead().symbol());
+    break;
+
+  case FUNCTION_CALL:
+  {
+    const auto &call = get_function_call();
+    f(call.lhs());
+    for(auto &a : call.arguments())
+      f(a);
+  }
+  break;
+
+  default:
+    if(has_condition())
+      f(get_condition());
+  }
+}
+
 bool goto_programt::equals(const goto_programt &other) const
 {
   if(instructions.size() != other.instructions.size())

src/goto-programs/goto_program.h

@@ -559,6 +559,9 @@ class goto_programt
     /// Apply given transformer to all expressions; no return value
     /// means no change needed.
     void transform(std::function<optionalt<exprt>(exprt)>);
+
+    /// Apply given function to all expressions
+    void apply(std::function<void(const exprt &)>) const;
   };
 
   // Never try to change this to vector-we mutate the list while iterating

src/goto-programs/slice_global_inits.cpp

@@ -61,22 +61,19 @@ 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)
+    for(const auto &i : it->second.body.instructions)
     {
-      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);
+      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");