clang-format fixes

Author: jezhiggins

src/analyses/variable-sensitivity/abstract_aggregate_object.h

@@ -1,16 +1,17 @@
 #ifndef CBMC_ABSTRACT_AGGREGATE_OBJECT_H
 #define CBMC_ABSTRACT_AGGREGATE_OBJECT_H
 
-#include <analyses/variable-sensitivity/abstract_object.h>
 #include <analyses/variable-sensitivity/abstract_environment.h>
+#include <analyses/variable-sensitivity/abstract_object.h>
 #include <stack>
 
-class abstract_aggregate_tag { };
+class abstract_aggregate_tag
+{
+};
 
-template<class aggregate_typet, class aggregate_traitst>
-class abstract_aggregate_objectt :
-  public abstract_objectt,
-  public abstract_aggregate_tag
+template <class aggregate_typet, class aggregate_traitst>
+class abstract_aggregate_objectt : public abstract_objectt,
+                                   public abstract_aggregate_tag
 {
 public:
   explicit abstract_aggregate_objectt(const typet &type)
@@ -40,20 +41,21 @@ class abstract_aggregate_objectt :
     const abstract_environmentt &environment,
     const namespacet &ns) const override
   {
-    if (expr.id() == aggregate_traitst::ACCESS_EXPR_ID())
+    if(expr.id() == aggregate_traitst::ACCESS_EXPR_ID())
       return read_component(environment, expr, ns);
 
     return abstract_objectt::expression_transform(
       expr, operands, environment, ns);
   }
 
   abstract_object_pointert write(
-    abstract_environmentt& environment,
+    abstract_environmentt &environment,
     const namespacet &ns,
     const std::stack<exprt> &stack,
     const exprt &specifier,
     const abstract_object_pointert &value,
-    bool merging_write) const override {
+    bool merging_write) const override
+  {
     return write_component(
       environment, ns, stack, specifier, value, merging_write);
   }
@@ -117,7 +119,7 @@ class abstract_aggregate_objectt :
     bool modified = false;
 
     typename sharing_mapt<keyt, abstract_object_pointert, false, hash>::
-    delta_viewt delta_view;
+      delta_viewt delta_view;
     map1.get_delta_view(map2, delta_view, true);
 
     for(auto &item : delta_view)
@@ -136,10 +138,18 @@ class abstract_aggregate_objectt :
   }
 };
 
-struct array_aggregate_typet {
-  static const irep_idt TYPE_ID() { return ID_array; }
-  static const irep_idt ACCESS_EXPR_ID() { return ID_index; }
-  static typet read_type(const typet &, const typet &object_type) {
+struct array_aggregate_typet
+{
+  static const irep_idt TYPE_ID()
+  {
+    return ID_array;
+  }
+  static const irep_idt ACCESS_EXPR_ID()
+  {
+    return ID_index;
+  }
+  static typet read_type(const typet &, const typet &object_type)
+  {
     array_typet array_type(to_array_type(object_type));
     return array_type.subtype();
   }
@@ -148,39 +158,58 @@ struct array_aggregate_typet {
     abstract_object_statisticst &statistics,
     abstract_object_visitedt &visited,
     const abstract_environmentt &env,
-    const namespacet &ns) {
+    const namespacet &ns)
+  {
     ++statistics.number_of_arrays;
   }
 };
 
-struct struct_aggregate_typet {
-  static const irep_idt& TYPE_ID() { return ID_struct; }
-  static const irep_idt& ACCESS_EXPR_ID() { return ID_member; }
-  static const typet & read_type(const typet &expr_type, const typet &) {
+struct struct_aggregate_typet
+{
+  static const irep_idt &TYPE_ID()
+  {
+    return ID_struct;
+  }
+  static const irep_idt &ACCESS_EXPR_ID()
+  {
+    return ID_member;
+  }
+  static const typet &read_type(const typet &expr_type, const typet &)
+  {
     return expr_type;
   }
 
   static void get_statistics(
     abstract_object_statisticst &statistics,
     abstract_object_visitedt &visited,
     const abstract_environmentt &env,
-    const namespacet &ns) {
+    const namespacet &ns)
+  {
     ++statistics.number_of_structs;
   }
 };
 
-struct union_aggregate_typet {
-  static const irep_idt TYPE_ID() { return ID_union; }
-  static const irep_idt ACCESS_EXPR_ID() { return ID_member; }
-  static typet read_type(const typet &, const typet &object_type) {
+struct union_aggregate_typet
+{
+  static const irep_idt TYPE_ID()
+  {
+    return ID_union;
+  }
+  static const irep_idt ACCESS_EXPR_ID()
+  {
+    return ID_member;
+  }
+  static typet read_type(const typet &, const typet &object_type)
+  {
     return object_type;
   }
 
   static void get_statistics(
     abstract_object_statisticst &statistics,
     abstract_object_visitedt &visited,
     const abstract_environmentt &env,
-    const namespacet &ns) {
+    const namespacet &ns)
+  {
   }
 };
 

src/analyses/variable-sensitivity/abstract_environment.cpp

@@ -7,23 +7,23 @@
 \*******************************************************************/
 
 #include <analyses/ai.h>
+#include <analyses/variable-sensitivity/abstract_environment.h>
 #include <analyses/variable-sensitivity/abstract_object.h>
+#include <analyses/variable-sensitivity/abstract_object_statistics.h>
 #include <analyses/variable-sensitivity/constant_abstract_value.h>
 #include <analyses/variable-sensitivity/pointer_abstract_object.h>
 #include <analyses/variable-sensitivity/two_value_array_abstract_object.h>
 #include <analyses/variable-sensitivity/two_value_struct_abstract_object.h>
 #include <analyses/variable-sensitivity/variable_sensitivity_object_factory.h>
-#include <util/pointer_expr.h>
 #include <langapi/language_util.h>
+#include <util/pointer_expr.h>
 #include <util/simplify_expr.h>
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <ostream>
 #include <stack>
-#include "abstract_environment.h"
-#include "abstract_object_statistics.h"
 
 #ifdef DEBUG
 #  include <iostream>
@@ -79,18 +79,18 @@ abstract_environmentt::eval(const exprt &expr, const namespacet &ns) const
   }
 }
 
-abstract_object_pointert
-abstract_environmentt::resolve_symbol(const exprt &expr, const namespacet &ns) const
+abstract_object_pointert abstract_environmentt::resolve_symbol(
+  const exprt &expr,
+  const namespacet &ns) const
 {
   const symbol_exprt &symbol(to_symbol_expr(expr));
   const auto symbol_entry = map.find(symbol.get_identifier());
 
-  if (symbol_entry.has_value())
-     return symbol_entry.value();
+  if(symbol_entry.has_value())
+    return symbol_entry.value();
   return abstract_object_factory(expr.type(), ns, true, false);
 }
 
-
 bool abstract_environmentt::assign(
   const exprt &expr,
   const abstract_object_pointert &value,
@@ -194,9 +194,9 @@ abstract_object_pointert abstract_environmentt::write(
 
   const irep_idt &stack_head_id = next_expr.id();
   INVARIANT(
-    stack_head_id == ID_index || stack_head_id == ID_member || stack_head_id == ID_dereference,
-    "Write stack expressions must be index, member, or dereference"
-  );
+    stack_head_id == ID_index || stack_head_id == ID_member ||
+      stack_head_id == ID_dereference,
+    "Write stack expressions must be index, member, or dereference");
 
   return lhs->write(*this, ns, remaining_stack, next_expr, rhs, merge_write);
 }

src/analyses/variable-sensitivity/abstract_object.h

@@ -258,9 +258,8 @@ class abstract_objectt : public std::enable_shared_from_this<abstract_objectt>
     abstract_object_pointert op1,
     abstract_object_pointert op2,
     bool &out_modifications);
-  static abstract_object_pointert merge(
-    abstract_object_pointert op1,
-    abstract_object_pointert op2);
+  static abstract_object_pointert
+  merge(abstract_object_pointert op1, abstract_object_pointert op2);
 
   /// Interface method for the meet operation. Decides whether to use the base
   /// implementation or if a more precise abstraction is attainable.

src/analyses/variable-sensitivity/abstract_value_object.cpp

@@ -1,30 +1,35 @@
 #include <analyses/variable-sensitivity/abstract_value_object.h>
 
-class empty_index_ranget : public index_ranget {
+class empty_index_ranget : public index_ranget
+{
 public:
-  const exprt &current() const override { return nil; }
-  bool advance_to_next() override { return false; }
+  const exprt &current() const override
+  {
+    return nil;
+  }
+  bool advance_to_next() override
+  {
+    return false;
+  }
 
 private:
   exprt nil = nil_exprt();
 };
 
-class indeterminate_index_ranget : public single_value_index_ranget {
+class indeterminate_index_ranget : public single_value_index_ranget
+{
 public:
-  indeterminate_index_ranget()
-    : single_value_index_ranget(nil_exprt())
+  indeterminate_index_ranget() : single_value_index_ranget(nil_exprt())
   {
   }
 };
 
-
 single_value_index_ranget::single_value_index_ranget(const exprt &val)
-  : value(val),
-    available(true)
+  : value(val), available(true)
 {
 }
 
-const exprt & single_value_index_ranget::current() const
+const exprt &single_value_index_ranget::current() const
 {
   return value;
 }

src/analyses/variable-sensitivity/abstract_value_object.h

@@ -3,18 +3,23 @@
 
 #include <analyses/variable-sensitivity/abstract_object.h>
 
-class abstract_value_tag { };
+class abstract_value_tag
+{
+};
 
-class index_ranget {
+class index_ranget
+{
 public:
   virtual ~index_ranget() = default;
   virtual const exprt &current() const = 0;
   virtual bool advance_to_next() = 0;
 };
 
-class single_value_index_ranget : public index_ranget {
+class single_value_index_ranget : public index_ranget
+{
 protected:
   explicit single_value_index_ranget(const exprt &val);
+
 public:
   const exprt &current() const override;
   bool advance_to_next() override;
@@ -29,14 +34,11 @@ typedef std::shared_ptr<index_ranget> index_range_ptrt;
 index_range_ptrt make_empty_index_range();
 index_range_ptrt make_indeterminate_index_range();
 
-
-class abstract_value_objectt :
-  public abstract_objectt,
-  public abstract_value_tag
+class abstract_value_objectt : public abstract_objectt,
+                               public abstract_value_tag
 {
 public:
-  explicit abstract_value_objectt(const typet &type)
-    : abstract_objectt(type)
+  explicit abstract_value_objectt(const typet &type) : abstract_objectt(type)
   {
   }
 

src/analyses/variable-sensitivity/constant_abstract_value.cpp

@@ -19,9 +19,10 @@
 #include "abstract_environment.h"
 #include "constant_abstract_value.h"
 
-class constant_index_ranget : public single_value_index_ranget {
+class constant_index_ranget : public single_value_index_ranget
+{
 public:
-  explicit constant_index_ranget(const exprt& val)
+  explicit constant_index_ranget(const exprt &val)
     : single_value_index_ranget(val)
   {
   }
@@ -32,7 +33,6 @@ index_range_ptrt make_constant_index_range(const exprt &val)
   return std::make_shared<constant_index_ranget>(val);
 }
 
-
 constant_abstract_valuet::constant_abstract_valuet(typet t)
   : abstract_value_objectt(t), value()
 {
@@ -51,16 +51,16 @@ constant_abstract_valuet::constant_abstract_valuet(
 {
 }
 
-index_range_ptrt constant_abstract_valuet::index_range(const namespacet &ns) const {
+index_range_ptrt
+constant_abstract_valuet::index_range(const namespacet &ns) const
+{
   exprt val = to_constant();
   if(!val.is_constant())
     return make_indeterminate_index_range();
 
   return make_constant_index_range(val);
 }
 
-
-
 abstract_object_pointert constant_abstract_valuet::expression_transform(
   const exprt &expr,
   const std::vector<abstract_object_pointert> &operands,

src/analyses/variable-sensitivity/constant_pointer_abstract_object.cpp

@@ -9,8 +9,8 @@
 #include "constant_pointer_abstract_object.h"
 
 #include <analyses/ai.h>
-#include <util/pointer_expr.h>
 #include <analyses/variable-sensitivity/abstract_environment.h>
+#include <util/pointer_expr.h>
 #include <util/std_expr.h>
 #include <util/std_types.h>