Reformat so that comments pass linting

Author: martin

src/analyses/variable-sensitivity/abstract_enviroment.cpp

@@ -259,15 +259,16 @@ bool abstract_environmentt::assign(
 
 /// Function: abstract_object_pointert abstract_environmentt::write
 ///
-/// \param lhs: the abstract object for the left hand side of the write (i.e. the one
-///             to update).
+/// \param lhs: the abstract object for the left hand side of the write
+///             (i.e. the one to update).
 /// \param rhs: the value we are trying to write to the left hand side
-/// \param remaining_stack: what is left of the stack before the rhs can replace or be
-///                         merged with the rhs
+/// \param remaining_stack: what is left of the stack before the rhs can replace
+///                         or be merged with the rhs
 /// \param ns: the namespace
-/// \param merge_write: Are we replacing the left hand side with the right hand side
-///                     (e.g. we know for a fact that we are overwriting this object)
-///                     or could the write in fact not take place and therefore we
+/// \param merge_write: Are we replacing the left hand side with the
+///                     right hand side (e.g. we know for a fact that
+///                     we are overwriting this object) or could the
+///                     write in fact not take place and therefore we
 ///                     should merge to model the case where it did not.
 ///
 /// \return A modified version of the rhs after the write has taken place
@@ -383,7 +384,8 @@ bool abstract_environmentt::assume(const exprt &expr, const namespacet &ns)
 ///
 /// \param type: the type of the object whose state should be tracked
 /// \param top: does the type of the object start as top
-/// \param bottom: does the type of the object start as bottom in the two-value domain
+/// \param bottom: does the type of the object start as bottom in
+///                the two-value domain
 ///
 /// \return The abstract object that has been created
 ///
@@ -421,8 +423,10 @@ abstract_object_pointert abstract_environmentt::abstract_object_factory(
 ///
 /// \param type: the type of the object whose state should be tracked
 /// \param top: does the type of the object start as top in the two-value domain
-/// \param bottom: does the type of the object start as bottom in the two-value domain
-/// \param expr: the starting value of the symbol if top and bottom are both false
+/// \param bottom: does the type of the object start as bottom in
+///                the two-value domain
+/// \param expr: the starting value of the symbol if top and bottom
+///              are both false
 ///
 /// \return The abstract object that has been created
 ///

src/analyses/variable-sensitivity/abstract_object.cpp

@@ -178,10 +178,11 @@ abstract_object_pointert abstract_objectt::abstract_object_meet_internal(
 /// \param expr: the expression to evaluate and find the result of it. this will
 ///              be the symbol referred to be op0()
 ///
-/// \return Returns the abstract_object representing the result of this expression
-///         to the maximum precision available.
+/// \return Returns the abstract_object representing the result of
+///         this expression to the maximum precision available.
 ///
-/// To try and resolve different expressions with the maximum level of precision available.
+/// To try and resolve different expressions with the maximum level
+/// of precision available.
 abstract_object_pointert abstract_objectt::expression_transform(
   const exprt &expr,
   const std::vector<abstract_object_pointert> &operands,

src/analyses/variable-sensitivity/abstract_value.cpp

@@ -36,7 +36,8 @@ abstract_valuet::abstract_valuet(const typet &type, bool top, bool bottom)
 
 /// Function: abstract_valuet::abstract_valuet
 ///
-/// \param expr: the expression to use as the starting pointer for an abstract object
+/// \param expr: the expression to use as the starting pointer for
+///              an abstract object
 /// \param environment: The environment this abstract object is being created in
 /// \param ns: the namespace
 ///

src/analyses/variable-sensitivity/array_abstract_object.cpp

@@ -39,7 +39,8 @@ array_abstract_objectt::array_abstract_objectt(
 
 /// Function: array_abstract_objectt::array_abstract_objectt
 ///
-/// \param expr: the expression to use as the starting pointer for an abstract object
+/// \param expr: the expression to use as the starting pointer for
+///              an abstract object
 /// \param environment: the environment the abstract object is being created in
 /// \param ns: the namespace
 array_abstract_objectt::array_abstract_objectt(

src/analyses/variable-sensitivity/constant_array_abstract_object.cpp

@@ -42,7 +42,8 @@ constant_array_abstract_objectt::constant_array_abstract_objectt(
 
 /// Function: constant_array_abstract_objectt::constant_array_abstract_objectt
 ///
-/// \param expr: the expression to use as the starting pointer for an abstract object
+/// \param expr: the expression to use as the starting pointer for
+///              an abstract object
 /// \param environment: the environment the abstract object is being created in
 /// \param ns: the namespace
 constant_array_abstract_objectt::constant_array_abstract_objectt(
@@ -260,8 +261,8 @@ abstract_object_pointert constant_array_abstract_objectt::read_index(
 /// \param stack: the remaining stack of expressions on the LHS to evaluate
 /// \param index_expr: the expression uses to access a specific index
 /// \param value: the value we are trying to assign to that value in the array
-/// \param merging_write: Should this and all future writes be merged with the current
-///                       value
+/// \param merging_write: Should this and all future writes be merged with the
+///                       current value
 /// \return The array_abstract_objectt representing the result of writing
 ///         to a specific index.
 ///

src/analyses/variable-sensitivity/constant_pointer_abstract_object.cpp

@@ -14,8 +14,6 @@
 #include <util/std_expr.h>
 #include <util/std_types.h>
 
-/// Function: constant_pointer_abstract_objectt::constant_pointer_abstract_objectt
-///
 /// \param type: the type the abstract_object is representing
 constant_pointer_abstract_objectt::constant_pointer_abstract_objectt(
   const typet &t)
@@ -24,8 +22,6 @@ constant_pointer_abstract_objectt::constant_pointer_abstract_objectt(
   PRECONDITION(t.id() == ID_pointer);
 }
 
-/// Function: constant_pointer_abstract_objectt::constant_pointer_abstract_objectt
-///
 /// \param type: the type the abstract_object is representing
 /// \param top: is the abstract_object starting as top
 /// \param bottom: is the abstract_object starting as bottom
@@ -41,18 +37,15 @@ constant_pointer_abstract_objectt::constant_pointer_abstract_objectt(
   PRECONDITION(t.id() == ID_pointer);
 }
 
-/// Function: constant_pointer_abstract_objectt::constant_pointer_abstract_objectt
-///
 /// \param old: the abstract object to copy from
 constant_pointer_abstract_objectt::constant_pointer_abstract_objectt(
   const constant_pointer_abstract_objectt &old)
   : pointer_abstract_objectt(old), value_stack(old.value_stack)
 {
 }
 
-/// Function: constant_pointer_abstract_objectt::constant_pointer_abstract_objectt
-///
-/// \param expr: the expression to use as the starting pointer for an abstract object
+/// \param expr: the expression to use as the starting pointer for
+///              an abstract object
 constant_pointer_abstract_objectt::constant_pointer_abstract_objectt(
   const exprt &e,
   const abstract_environmentt &environment,
@@ -70,17 +63,14 @@ constant_pointer_abstract_objectt::constant_pointer_abstract_objectt(
     clear_top();
   }
 }
-
-/// Function: constant_pointer_abstract_objectt::merge
-///
-/// \param other: the pointer being merged
-///
-/// \return Returns the result of the merge.
-///
 /// Set this abstract object to be the result of merging this
 /// abstract object. This calls the merge_constant_pointers if
 /// we are trying to merge a constant pointer we use the constant pointer
 /// constant pointer merge
+///
+/// \param other: the pointer being merged
+///
+/// \return Returns the result of the merge.
 abstract_object_pointert
 constant_pointer_abstract_objectt::merge(abstract_object_pointert other) const
 {
@@ -97,16 +87,14 @@ constant_pointer_abstract_objectt::merge(abstract_object_pointert other) const
   }
 }
 
-/// Function: constant_pointer_abstract_objectt::merge_constant_pointers
+/// Merges two constant pointers. If they are pointing at the same
+/// value, we merge, otherwise we set to top.
 ///
 /// \param other: the pointer being merged
 ///
 /// \return Returns a new abstract object that is the result of the merge
 ///         unless the merge is the same as this abstract object, in which
 ///         case it returns this.
-///
-/// Merges two constant pointers. If they are pointing at the same
-/// value, we merge, otherwise we set to top.
 abstract_object_pointert
 constant_pointer_abstract_objectt::merge_constant_pointers(
   const constant_pointer_abstract_pointert other) const
@@ -131,7 +119,7 @@ constant_pointer_abstract_objectt::merge_constant_pointers(
   }
 }
 
-/// Function: constant_pointer_abstract_objectt::to_constant
+/// To try and find a constant expression for this abstract object
 ///
 /// \return Returns an expression representing the value if it can.
 ///          Returns a nil expression if it can be more than one value.
@@ -140,7 +128,6 @@ constant_pointer_abstract_objectt::merge_constant_pointers(
 ///          result of to_constant called on whatever abstract object this
 ///          pointer is pointing to.
 ///
-/// To try and find a constant expression for this abstract object
 exprt constant_pointer_abstract_objectt::to_constant() const
 {
   if(is_top() || is_bottom())
@@ -155,14 +142,12 @@ exprt constant_pointer_abstract_objectt::to_constant() const
   }
 }
 
-/// Function: constant_pointer_abstract_objectt::output
+/// Print the value of the pointer. Either NULL if nullpointer or
+/// ptr -> ( output of what the pointer is pointing to).
 ///
 /// \param out: the stream to write to
 /// \param ai: ?
 /// \param ns: ?
-///
-/// Print the value of the pointer. Either NULL if nullpointer or
-/// ptr -> ( output of what the pointer is pointing to).
 void constant_pointer_abstract_objectt::output(
   std::ostream &out,
   const ai_baset &ai,
@@ -206,17 +191,15 @@ void constant_pointer_abstract_objectt::output(
   }
 }
 
-/// Function: constant_pointer_abstract_objectt::read_dereference
+/// A helper function to dereference a value from a pointer. Providing
+/// the pointer can only be pointing at one thing, returns an abstract
+/// object representing that thing. If null or top will return top.
 ///
 /// \param env: the environment
 /// \param ns: the namespace
 ///
 /// \return An abstract object representing the value this pointer is pointing
 ///         to
-///
-/// A helper function to dereference a value from a pointer. Providing
-/// the pointer can only be pointing at one thing, returns an abstract
-/// object representing that thing. If null or top will return top.
 abstract_object_pointert constant_pointer_abstract_objectt::read_dereference(
   const abstract_environmentt &env,
   const namespacet &ns) const
@@ -235,25 +218,23 @@ abstract_object_pointert constant_pointer_abstract_objectt::read_dereference(
   }
 }
 
-/// Function: constant_pointer_abstract_objectt::write_dereference
+/// A helper function to evaluate writing to a pointers value.
+/// If the pointer can only be pointing to one element that it overwrites
+/// that element (or merges if merging_write) with the new value.
+/// If don't know what we are pointing to, we delegate to the parent.
 ///
 /// \param environment: the environment
 /// \param ns: the namespace
 /// \param stack: the remaining stack
 /// \param new_value: the value to write to the dereferenced pointer
 /// \param merging_write: is it a merging write (i.e. we aren't certain
 ///                       we are writing to this particular pointer therefore
-///                       the value should be merged with whatever is already there
-///                       or we are certain we are writing to this pointer so
-///                      therefore the value can be replaced
+///                       the value should be merged with whatever is already
+///                       there or we are certain we are writing to this pointer
+///                       so therefore the value can be replaced
 ///
 /// \return A modified abstract object representing this pointer after it
 ///         has been written to.
-///
-/// A helper function to evaluate writing to a pointers value.
-/// If the pointer can only be pointing to one element that it overwrites
-/// that element (or merges if merging_write) with the new value.
-/// If don't know what we are pointing to, we delegate to the parent.
 sharing_ptrt<pointer_abstract_objectt>
 constant_pointer_abstract_objectt::write_dereference(
   abstract_environmentt &environment,

src/analyses/variable-sensitivity/pointer_abstract_object.cpp

@@ -40,7 +40,8 @@ pointer_abstract_objectt::pointer_abstract_objectt(
 
 /// Function: pointer_abstract_objectt::pointer_abstract_objectt
 ///
-/// \param expr: the expression to use as the starting pointer for an abstract object
+/// \param expr: the expression to use as the starting pointer for
+///              an abstract object
 pointer_abstract_objectt::pointer_abstract_objectt(
   const exprt &e,
   const abstract_environmentt &environment,
@@ -125,9 +126,9 @@ abstract_object_pointert pointer_abstract_objectt::read_dereference(
 ///               pointing to
 /// \param merging_write: is it a merging write (i.e. we aren't certain
 ///                       we are writing to this particular pointer therefore
-///                       the value should be merged with whatever is already there
-///                       or we are certain we are writing to this pointer so
-///                       therefore the value can be replaced
+///                       the value should be merged with whatever is already
+///                       there or we are certain we are writing to this pointer
+///                       so therefore the value can be replaced
 ///
 /// \return A modified abstract object representing this pointer after it
 ///         has been written to.

src/analyses/variable-sensitivity/struct_abstract_object.cpp

@@ -41,7 +41,8 @@ struct_abstract_objectt::struct_abstract_objectt(
 
 /// Function: struct_abstract_objectt::struct_abstract_objectt
 ///
-/// \param expr: the expression to use as the starting pointer for an abstract object
+/// \param expr: the expression to use as the starting pointer for
+/// an abstract object
 struct_abstract_objectt::struct_abstract_objectt(
   const exprt &e,
   const abstract_environmentt &environment,

src/analyses/variable-sensitivity/union_abstract_object.cpp

@@ -40,8 +40,10 @@ union_abstract_objectt::union_abstract_objectt(
 
 /// Function: union_abstract_objectt::union_abstract_objectt
 ///
-/// \param expr: the expression to use as the starting pointer for an abstract object
-/// \param environment: the environment the abstract object is going to be evaluated in.
+/// \param expr: the expression to use as the starting pointer for
+///              an abstract object
+/// \param environment: the environment the abstract object is going
+///                     to be evaluated in.
 union_abstract_objectt::union_abstract_objectt(
   const exprt &expr,
   const abstract_environmentt &environment,

src/analyses/variable-sensitivity/variable_sensitivity_domain.cpp

@@ -324,7 +324,8 @@ std::vector<irep_idt> variable_sensitivity_domaint::get_modified_symbols(
 /// Function: variable_sensitivity_domaint::transform_function_call
 ///
 /// \param from: the location to transform from which is a function call
-/// \param to: the destination of the transform (potentially inside the function call)
+/// \param to: the destination of the transform
+///            (potentially inside the function call)
 /// \param ai: the abstract interpreter
 /// \param ns: the namespace of the current state
 ///