Add documentation to typet

Author: svorenova

src/util/type.cpp

@@ -1,27 +1,38 @@
 /*******************************************************************\
 
-Module:
+Module: Data structure for a type of an expression
 
 Author: Daniel Kroening, [email protected]
+        Maria Svorenova, [email protected]
 
 \*******************************************************************/
 
+/// \file
+/// Data structure for a type of an expression
+
 #include "type.h"
 #include "std_types.h"
 #include "namespace.h"
 
+/// Copy the provided type to the subtypes of this type.
+/// \param type The type to add to subtypes
 void typet::copy_to_subtypes(const typet &type)
 {
   subtypes().push_back(type);
 }
 
+/// Move the provided type to the subtypes of this type. Destroys the
+/// provided type.
+/// \param type The type to add to subtypes
 void typet::move_to_subtypes(typet &type)
 {
   subtypest &sub=subtypes();
   sub.push_back(static_cast<const typet &>(get_nil_irep()));
   sub.back().swap(type);
 }
 
+/// Returns true if the type is a rational, real, integer, natural, complex,
+/// unsignedbv, signedbv, floatbv or fixedbv.
 bool is_number(const typet &type)
 {
   const irep_idt &id=type.id();
@@ -36,8 +47,8 @@ bool is_number(const typet &type)
          id==ID_fixedbv;
 }
 
-/// Identify if a given type is constant itself or
-/// contains constant components. Examples include:
+/// Identify if a given type is constant itself or contains constant components.
+/// Examples include:
 ///  - const int a;
 ///  - struct contains_constant_pointer {  int x; int * const p; };
 ///  - const int b[3];

src/util/type.h

@@ -1,11 +1,14 @@
 /*******************************************************************\
 
-Module:
+Module: Data structure for a type of an expression
 
 Author: Daniel Kroening, [email protected]
+        Maria Svorenova, [email protected]
 
 \*******************************************************************/
 
+/// \file
+/// Data structure for a type of an expression
 
 #ifndef CPROVER_UTIL_TYPE_H
 #define CPROVER_UTIL_TYPE_H
@@ -17,8 +20,37 @@ Author: Daniel Kroening, [email protected]
 
 class namespacet;
 
-/*! \brief The type of an expression
-*/
+/// The type of an expression, extends irept. Types may have subtypes. This is
+/// modeled with two subs named “subtype” (a single type) and “subtypes”
+/// (a vector of types). The class typet only adds specialized methods
+/// for accessing the subtype information to the interface of irept.
+/// Pre-defined types:
+///   universe      - super type
+///   type          - another type
+///   predicate     - predicate expression (subtype and predicate)
+///   uninterpreted - uninterpreted type with identifier
+///   empty         - void
+///   bool          - true or false
+///   abstract      - abstract super type
+///   struct        - with components: each component has name and type,
+///                   the ordering matters
+///   rational
+///   real
+///   integer
+///   complex
+///   string
+///   enum          - with elements, the ordering does not matter
+///   tuple         - with components: each component has type,
+///                   the ordering matters
+///   mapping       - domain -> range
+///   bv            - no interpretation
+///   unsignedbv
+///   signedbv      - two's complement
+///   floatbv       - IEEE floating point format
+///   code
+///   pointer       - for ANSI-C (subtype)
+///   symbol        - look in symbol table (identifier)
+///   number        - generic number super type
 class typet:public irept
 {
 public:
@@ -90,7 +122,7 @@ class typet:public irept
   { remove(ID_subtype); }
   #endif
 
-  void move_to_subtypes(typet &type); // destroys expr
+  void move_to_subtypes(typet &type);
 
   void copy_to_subtypes(const typet &type);
 
@@ -115,6 +147,7 @@ class typet:public irept
   }
 };
 
+/// Type with a single subtype.
 class type_with_subtypet:public typet
 {
 public:
@@ -136,6 +169,7 @@ class type_with_subtypet:public typet
   #endif
 };
 
+/// Type with multiple subtypes.
 class type_with_subtypest:public typet
 {
 public:
@@ -169,43 +203,8 @@ class type_with_subtypest:public typet
     for(typet::subtypest::iterator it=(type).subtypes().begin(); \
         it!=(type).subtypes().end(); ++it)
 
-/*
-
-pre-defined types:
-  universe      // super type
-  type          // another type
-  predicate     // predicate expression (subtype and predicate)
-  uninterpreted // uninterpreted type with identifier
-  empty         // void
-  bool          // true or false
-  abstract      // abstract super type
-  struct        // with components: each component has name and type
-                // the ordering matters
-  rational
-  real
-  integer
-  complex
-  string
-  enum          // with elements
-                // the ordering does not matter
-  tuple         // with components: each component has type
-                // the ordering matters
-  mapping       // domain -> range
-  bv            // no interpretation
-  unsignedbv
-  signedbv      // two's complement
-  floatbv       // IEEE floating point format
-  code
-  pointer       // for ANSI-C (subtype)
-  symbol        // look in symbol table (identifier)
-  number        // generic number super type
-
-*/
-
 bool is_number(const typet &type);
-// rational, real, integer, complex, unsignedbv, signedbv, floatbv
 
-// Is the passed in type const qualified?
 bool is_constant_or_has_constant_components(
     const typet &type,
     const namespacet &ns);