Introduce abstract qualifierst base class

Author: NathanJPhillips

src/ansi-c/c_qualifiers.cpp

@@ -24,11 +24,11 @@ c_qualifierst &c_qualifierst::operator=(const c_qualifierst &other)
   return *this;
 }
 
-std::unique_ptr<c_qualifierst> c_qualifierst::clone() const
+std::unique_ptr<qualifierst> c_qualifierst::clone() const
 {
   auto other = util_make_unique<c_qualifierst>();
   *other = *this;
-  return other;
+  return std::move(other);
 }
 
 std::string c_qualifierst::as_string() const
@@ -141,9 +141,7 @@ void c_qualifierst::clear(typet &dest)
 }
 
 /// pretty-print the qualifiers
-std::ostream &operator << (
-  std::ostream &out,
-  const c_qualifierst &c_qualifiers)
+std::ostream &operator<<(std::ostream &out, const qualifierst &qualifiers)
 {
-  return out << c_qualifiers.as_string();
+  return out << qualifiers.as_string();
 }

src/ansi-c/c_qualifiers.h

@@ -15,7 +15,49 @@ Author: Daniel Kroening, [email protected]
 
 #include <util/expr.h>
 
-class c_qualifierst
+class qualifierst
+{
+protected:
+  // Only derived classes can construct
+  qualifierst() = default;
+
+public:
+  // Copy/move construction/assignment is deleted here and in derived classes
+  qualifierst(const qualifierst &) = delete;
+  qualifierst(qualifierst &&) = delete;
+  qualifierst &operator=(const qualifierst &) = delete;
+  qualifierst &operator=(qualifierst &&) = delete;
+
+  // Destruction is virtual
+  virtual ~qualifierst() = default;
+
+public:
+  virtual std::unique_ptr<qualifierst> clone() const = 0;
+
+  virtual qualifierst &operator+=(const qualifierst &b) = 0;
+
+  virtual std::size_t count() const = 0;
+
+  virtual void clear() = 0;
+
+  virtual void read(const typet &src) = 0;
+  virtual void write(typet &src) const = 0;
+
+  // Comparisons
+  virtual bool is_subset_of(const qualifierst &q) const = 0;
+  virtual bool operator==(const qualifierst &other) const = 0;
+  bool operator!=(const qualifierst &other) const
+  {
+    return !(*this == other);
+  }
+
+  // String conversion
+  virtual std::string as_string() const = 0;
+  friend std::ostream &operator<<(std::ostream &, const qualifierst &);
+};
+
+
+class c_qualifierst : public qualifierst
 {
 public:
   c_qualifierst()
@@ -29,13 +71,12 @@ class c_qualifierst
     read(src);
   }
 
-  c_qualifierst(const c_qualifierst &other) = delete;
-  virtual c_qualifierst &operator=(const c_qualifierst &other);
-  virtual std::unique_ptr<c_qualifierst> clone() const;
-
-  virtual ~c_qualifierst() = default;
+protected:
+  c_qualifierst &operator=(const c_qualifierst &other);
+public:
+  virtual std::unique_ptr<qualifierst> clone() const override;
 
-  virtual void clear()
+  virtual void clear() override
   {
     is_constant=false;
     is_volatile=false;
@@ -57,62 +98,60 @@ class c_qualifierst
 
   // will likely add alignment here as well
 
-  virtual std::string as_string() const;
-  virtual void read(const typet &src);
-  virtual void write(typet &src) const;
+  virtual std::string as_string() const override;
+  virtual void read(const typet &src) override;
+  virtual void write(typet &src) const override;
 
   static void clear(typet &dest);
 
-  virtual bool is_subset_of(const c_qualifierst &q) const
+  virtual bool is_subset_of(const qualifierst &other) const override
   {
-    return (!is_constant || q.is_constant) &&
-           (!is_volatile || q.is_volatile) &&
-           (!is_restricted || q.is_restricted) &&
-           (!is_atomic || q.is_atomic) &&
-           (!is_ptr32 || q.is_ptr32) &&
-           (!is_ptr64 || q.is_ptr64) &&
-           (!is_noreturn || q.is_noreturn);
+    const c_qualifierst *cq = dynamic_cast<const c_qualifierst *>(&other);
+    return
+      (!is_constant || cq->is_constant) &&
+      (!is_volatile || cq->is_volatile) &&
+      (!is_restricted || cq->is_restricted) &&
+      (!is_atomic || cq->is_atomic) &&
+      (!is_ptr32 || cq->is_ptr32) &&
+      (!is_ptr64 || cq->is_ptr64) &&
+      (!is_noreturn || cq->is_noreturn);
 
     // is_transparent_union isn't checked
   }
 
-  virtual bool operator==(const c_qualifierst &other) const
+  virtual bool operator==(const qualifierst &other) const override
   {
-    return is_constant==other.is_constant &&
-           is_volatile==other.is_volatile &&
-           is_restricted==other.is_restricted &&
-           is_atomic==other.is_atomic &&
-           is_ptr32==other.is_ptr32 &&
-           is_ptr64==other.is_ptr64 &&
-           is_transparent_union==other.is_transparent_union &&
-           is_noreturn==other.is_noreturn;
+    const c_qualifierst *cq = dynamic_cast<const c_qualifierst *>(&other);
+    return
+      is_constant == cq->is_constant &&
+      is_volatile == cq->is_volatile &&
+      is_restricted == cq->is_restricted &&
+      is_atomic == cq->is_atomic &&
+      is_ptr32 == cq->is_ptr32 &&
+      is_ptr64 == cq->is_ptr64 &&
+      is_transparent_union == cq->is_transparent_union &&
+      is_noreturn == cq->is_noreturn;
   }
 
-  bool operator!=(const c_qualifierst &other) const
+  virtual qualifierst &operator+=(const qualifierst &other) override
   {
-    return !(*this==other);
-  }
-
-  virtual c_qualifierst &operator+=(const c_qualifierst &b)
-  {
-    is_constant|=b.is_constant;
-    is_volatile|=b.is_volatile;
-    is_restricted|=b.is_restricted;
-    is_atomic|=b.is_atomic;
-    is_ptr32|=b.is_ptr32;
-    is_ptr64|=b.is_ptr64;
-    is_transparent_union|=b.is_transparent_union;
-    is_noreturn|=b.is_noreturn;
+    const c_qualifierst *cq = dynamic_cast<const c_qualifierst *>(&other);
+    is_constant |= cq->is_constant;
+    is_volatile |= cq->is_volatile;
+    is_restricted |= cq->is_restricted;
+    is_atomic |= cq->is_atomic;
+    is_ptr32 |= cq->is_ptr32;
+    is_ptr64 |= cq->is_ptr64;
+    is_transparent_union |= cq->is_transparent_union;
+    is_noreturn |= cq->is_noreturn;
     return *this;
   }
 
-  virtual std::size_t count() const
+  virtual std::size_t count() const override
   {
     return is_constant+is_volatile+is_restricted+is_atomic+
            is_ptr32+is_ptr64+is_noreturn;
   }
 };
 
-std::ostream &operator << (std::ostream &, const c_qualifierst &);
-
 #endif // CPROVER_ANSI_C_C_QUALIFIERS_H

src/ansi-c/expr2c.cpp

@@ -162,11 +162,11 @@ std::string expr2ct::convert(const typet &src)
 
 std::string expr2ct::convert_rec(
   const typet &src,
-  const c_qualifierst &qualifiers,
+  const qualifierst &qualifiers,
   const std::string &declarator)
 {
-  std::unique_ptr<c_qualifierst> clone = qualifiers.clone();
-  c_qualifierst &new_qualifiers = *clone;
+  std::unique_ptr<qualifierst> clone = qualifiers.clone();
+  c_qualifierst &new_qualifiers = dynamic_cast<c_qualifierst &>(*clone);
   new_qualifiers.read(src);
 
   std::string q=new_qualifiers.as_string();
@@ -737,7 +737,7 @@ std::string expr2ct::convert_struct_type(
 /// \return A C-like type declaration of an array
 std::string expr2ct::convert_array_type(
   const typet &src,
-  const c_qualifierst &qualifiers,
+  const qualifierst &qualifiers,
   const std::string &declarator_str)
 {
   return convert_array_type(src, qualifiers, declarator_str, true);
@@ -753,7 +753,7 @@ std::string expr2ct::convert_array_type(
 /// \return A C-like type declaration of an array
 std::string expr2ct::convert_array_type(
   const typet &src,
-  const c_qualifierst &qualifiers,
+  const qualifierst &qualifiers,
   const std::string &declarator_str,
   bool inc_size_if_possible)
 {

src/ansi-c/expr2c_class.h

@@ -17,7 +17,7 @@ Author: Daniel Kroening, [email protected]
 #include <util/std_code.h>
 #include <util/std_expr.h>
 
-class c_qualifierst;
+class qualifierst;
 class namespacet;
 
 class expr2ct
@@ -36,7 +36,7 @@ class expr2ct
 
   virtual std::string convert_rec(
     const typet &src,
-    const c_qualifierst &qualifiers,
+    const qualifierst &qualifiers,
     const std::string &declarator);
 
   virtual std::string convert_struct_type(
@@ -53,12 +53,12 @@ class expr2ct
 
   virtual std::string convert_array_type(
     const typet &src,
-    const c_qualifierst &qualifiers,
+    const qualifierst &qualifiers,
     const std::string &declarator_str);
 
   std::string convert_array_type(
     const typet &src,
-    const c_qualifierst &qualifiers,
+    const qualifierst &qualifiers,
     const std::string &declarator_str,
     bool inc_size_if_possible);
 

src/cpp/expr2cpp.cpp

@@ -41,7 +41,7 @@ class expr2cppt:public expr2ct
 
   std::string convert_rec(
     const typet &src,
-    const c_qualifierst &qualifiers,
+    const qualifierst &qualifiers,
     const std::string &declarator) override;
 
   typedef std::unordered_set<std::string, string_hash> id_sett;
@@ -129,11 +129,11 @@ std::string expr2cppt::convert_constant(
 
 std::string expr2cppt::convert_rec(
   const typet &src,
-  const c_qualifierst &qualifiers,
+  const qualifierst &qualifiers,
   const std::string &declarator)
 {
-  std::unique_ptr<c_qualifierst> clone = qualifiers.clone();
-  c_qualifierst &new_qualifiers = *clone;
+  std::unique_ptr<qualifierst> clone = qualifiers.clone();
+  qualifierst &new_qualifiers = *clone;
   new_qualifiers.read(src);
 
   const std::string d=

src/java_bytecode/expr2java.cpp

@@ -251,11 +251,11 @@ std::string expr2javat::convert_constant(
 
 std::string expr2javat::convert_rec(
   const typet &src,
-  const c_qualifierst &qualifiers,
+  const qualifierst &qualifiers,
   const std::string &declarator)
 {
-  std::unique_ptr<c_qualifierst> clone = qualifiers.clone();
-  c_qualifierst &new_qualifiers = *clone;
+  std::unique_ptr<qualifierst> clone = qualifiers.clone();
+  qualifierst &new_qualifiers = *clone;
   new_qualifiers.read(src);
 
   const std::string d=

src/java_bytecode/expr2java.h

@@ -41,7 +41,7 @@ class expr2javat:public expr2ct
 
   virtual std::string convert_rec(
     const typet &src,
-    const c_qualifierst &qualifiers,
+    const qualifierst &qualifiers,
     const std::string &declarator) override;
 
   // length of string representation of Java Char

src/java_bytecode/java_qualifiers.cpp

@@ -19,30 +19,7 @@ java_qualifierst &java_qualifierst::operator=(const java_qualifierst &other)
   return *this;
 }
 
-java_qualifierst &java_qualifierst::operator=(java_qualifierst &&other)
-{
-  INVARIANT(
-    &other.ns == &ns,
-    "Can only assign from a java_qualifierst using the same namespace");
-  annotations = std::move(other.annotations);
-  c_qualifierst::operator=(other);
-  return *this;
-}
-
-c_qualifierst &java_qualifierst::operator=(const c_qualifierst &c_other)
-{
-  auto other = dynamic_cast<const java_qualifierst *>(&c_other);
-  if(other != nullptr)
-    *this = *other;
-  else
-  {
-    annotations.clear();
-    c_qualifierst::operator=(c_other);
-  }
-  return *this;
-}
-
-std::unique_ptr<c_qualifierst> java_qualifierst::clone() const
+std::unique_ptr<qualifierst> java_qualifierst::clone() const
 {
   auto other = util_make_unique<java_qualifierst>(ns);
   *other = *this;
@@ -74,37 +51,36 @@ void java_qualifierst::write(typet &src) const
   annotated_type.get_annotations() = annotations;
 }
 
-c_qualifierst &java_qualifierst::operator+=(const c_qualifierst &c_other)
+qualifierst &java_qualifierst::operator+=(const qualifierst &other)
 {
-  c_qualifierst::operator+=(c_other);
-  auto other = dynamic_cast<const java_qualifierst *>(&c_other);
-  if(other != nullptr)
+  c_qualifierst::operator+=(other);
+  auto jq = dynamic_cast<const java_qualifierst *>(&other);
+  if(jq != nullptr)
   {
     std::copy(
-      other->annotations.begin(),
-      other->annotations.end(),
+      jq->annotations.begin(),
+      jq->annotations.end(),
       std::back_inserter(annotations));
   }
   return *this;
 }
 
-bool java_qualifierst::operator==(const c_qualifierst &c_other) const
+bool java_qualifierst::operator==(const qualifierst &other) const
 {
-  auto other = dynamic_cast<const java_qualifierst *>(&c_other);
-  if(other == nullptr)
+  auto jq = dynamic_cast<const java_qualifierst *>(&other);
+  if(jq == nullptr)
     return false;
-  return
-    c_qualifierst::operator==(c_other) && annotations == other->annotations;
+  return c_qualifierst::operator==(other) && annotations == jq->annotations;
 }
 
-bool java_qualifierst::is_subset_of(const c_qualifierst &c_other) const
+bool java_qualifierst::is_subset_of(const qualifierst &other) const
 {
-  if(!c_qualifierst::is_subset_of(c_other))
+  if(!c_qualifierst::is_subset_of(other))
     return false;
-  auto other = dynamic_cast<const java_qualifierst *>(&c_other);
-  if(other == nullptr)
+  auto jq = dynamic_cast<const java_qualifierst *>(&other);
+  if(jq == nullptr)
     return annotations.empty();
-  auto &other_a = other->annotations;
+  auto &other_a = jq->annotations;
   for(const auto &annotation : annotations)
   {
     if(std::find(other_a.begin(), other_a.end(), annotation) == other_a.end())