diff mbox series

[20/21] Default construct suppression types.

Message ID 20200423154441.170531-21-gprocida@google.com
State Superseded
Headers show
Series Simplify regex and suppression parsing. | expand

Commit Message

Giuliano Procida April 23, 2020, 3:44 p.m. UTC
The current constructors for the various suppression types are not a
good match for their current uses. Given that every member is
effectively optional, default constructing these to a default
unpopulated state makes the code simpler.

There are no behavioural changes.

Signed-off-by: Giuliano Procida <gprocida@google.com>
---
 include/abg-suppression.h  |  48 +------
 src/abg-suppression-priv.h |  28 ++--
 src/abg-suppression.cc     | 255 +++++++------------------------------
 src/abg-tools-utils.cc     |   7 +-
 4 files changed, 58 insertions(+), 280 deletions(-)
diff mbox series

Patch

diff --git a/include/abg-suppression.h b/include/abg-suppression.h
index 02e77ea9..4c987a79 100644
--- a/include/abg-suppression.h
+++ b/include/abg-suppression.h
@@ -56,17 +56,10 @@  class suppression_base
   class priv;
   typedef shared_ptr<priv> priv_sptr;
 
-  // Forbid default constructor
-  suppression_base();
-
 public:
   priv_sptr priv_;
 
-  suppression_base(const string& label);
-
-  suppression_base(const string& label,
-		   const regex::regex_t_sptr& file_name_regex,
-		   const regex::regex_t_sptr& file_name_not_regex);
+  suppression_base();
 
   bool
   get_drops_artifact_from_ir() const;
@@ -153,9 +146,6 @@  class type_suppression : public suppression_base
   class priv;
   typedef shared_ptr<priv> priv_sptr;
 
-  // Forbid this;
-  type_suppression();
-
 public:
 
   priv_sptr priv_;
@@ -201,9 +191,7 @@  public:
   /// A convenience typedef for a vector of @ref insertion_range_sptr.
   typedef vector<insertion_range_sptr> insertion_ranges;
 
-  type_suppression(const string& label,
-		   const regex::regex_t_sptr& type_name_regexp,
-		   const string& type_name);
+  type_suppression();
 
   virtual ~type_suppression();
 
@@ -458,17 +446,6 @@  public:
 
   function_suppression();
 
-  function_suppression(const string&			label,
-		       const string&			name,
-		       const regex::regex_t_sptr&	name_regex,
-		       const string&			return_type_name,
-		       const regex::regex_t_sptr&	return_type_regex,
-		       parameter_specs_type&		parm_specs,
-		       const string&			symbol_name,
-		       const regex::regex_t_sptr&	symbol_name_regex,
-		       const string&			symbol_version,
-		       const regex::regex_t_sptr&	symbol_version_regex);
-
   virtual ~function_suppression();
 
   static change_kind
@@ -675,19 +652,7 @@  public:
 
   priv_sptr priv_;
 
-  variable_suppression(const string& label = "",
-		       const string& name = "",
-		       const regex::regex_t_sptr& name_regex =
-			 regex::regex_t_sptr(),
-		       const string& symbol_name = "",
-		       const regex::regex_t_sptr& symbol_name_regex =
-			 regex::regex_t_sptr(),
-		       const string& symbol_version = "",
-		       const regex::regex_t_sptr& symbol_version_regex =
-			 regex::regex_t_sptr(),
-		       const string& type_name = "",
-		       const regex::regex_t_sptr& type_name_regex =
-			 regex::regex_t_sptr());
+  variable_suppression();
 
   virtual ~variable_suppression();
 
@@ -812,14 +777,9 @@  class file_suppression: public suppression_base
 
   priv_sptr priv_;
 
-  // Forbid this
-  file_suppression();
-
 public:
 
-  file_suppression(const string& label,
-		   const regex::regex_t_sptr& file_name_regex,
-		   const regex::regex_t_sptr& file_name_not_regex);
+  file_suppression();
 
   virtual bool
   suppresses_diff(const diff* diff) const;
diff --git a/src/abg-suppression-priv.h b/src/abg-suppression-priv.h
index 78f11e2f..7f98fb08 100644
--- a/src/abg-suppression-priv.h
+++ b/src/abg-suppression-priv.h
@@ -236,23 +236,8 @@  struct variable_suppression::priv
   string				type_name_;
   regex::regex_t_sptr			type_name_regex_;
 
-  priv(const string& name,
-       const regex::regex_t_sptr& name_regex,
-       const string& symbol_name,
-       const regex::regex_t_sptr& symbol_name_regex,
-       const string& symbol_version,
-       const regex::regex_t_sptr& symbol_version_regex,
-       const string& type_name,
-       const regex::regex_t_sptr& type_name_regex)
-    : change_kind_(ALL_CHANGE_KIND),
-      name_(name),
-      name_regex_(name_regex),
-      symbol_name_(symbol_name),
-      symbol_name_regex_(symbol_name_regex),
-      symbol_version_(symbol_version),
-      symbol_version_regex_(symbol_version_regex),
-      type_name_(type_name),
-      type_name_regex_(type_name_regex)
+  priv()
+    : change_kind_(ALL_CHANGE_KIND)
   {}
 };// end class variable_supppression::priv
 
@@ -300,9 +285,14 @@  class type_suppression::priv
   regex::regex_t_sptr			source_location_to_keep_regex_;
   mutable vector<string>		changed_enumerator_names_;
 
-  priv();
-
 public:
+  priv()
+    : consider_type_kind_(false),
+      type_kind_(CLASS_TYPE_KIND),
+      consider_reach_kind_(false),
+      reach_kind_(DIRECT_REACH_KIND)
+  {}
+
   priv(const regex::regex_t_sptr&	type_name_regexp,
        const string&			type_name,
        bool				consider_type_kind,
diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc
index 8632d028..31a70e77 100644
--- a/src/abg-suppression.cc
+++ b/src/abg-suppression.cc
@@ -53,33 +53,11 @@  using regex::regex_t_sptr;
 
 // <suppression_base stuff>
 
-/// Constructor for @ref suppression_base
-///
-/// @param a label for the suppression.  This represents just a
-/// comment.
-suppression_base::suppression_base(const string& label)
-  : priv_(new priv(label))
+/// Default constructor for @ref suppression_base
+suppression_base::suppression_base()
+  : priv_(new priv())
 {}
 
-/// Constructor for @ref suppression_base
-///
-/// @param a label for the suppression.  This represents just a
-/// comment.
-///
-/// @param file_name_regex the regular expression that denotes the
-/// file name to match.
-///
-/// @param file_name_not_regex the regular expression that denotes
-/// the file name to *NOT* match.
-suppression_base::suppression_base(const string& label,
-				   const regex_t_sptr& file_name_regex,
-				   const regex_t_sptr& file_name_not_regex)
-  : priv_(new priv(label,
-		   file_name_regex,
-		   file_name_not_regex))
-{
-}
-
 /// Tests if the current suppression specification is to avoid adding
 /// the matched ABI artifact to the internal representation or not.
 ///
@@ -473,16 +451,8 @@  read_suppressions(const string& file_path,
 /// Note that parameter @p type_name_regexp and @p type_name_regexp
 /// should not necessarily be populated.  It usually is either one or
 /// the other that the user wants.
-type_suppression::type_suppression(const string& label,
-				   const regex_t_sptr& type_name_regexp,
-				   const string& type_name)
-  : suppression_base(label),
-    priv_(new priv(type_name_regexp,
-		   type_name,
-		   /*consider_type_kind=*/false,
-		   /*type_kind=*/CLASS_TYPE_KIND,
-		   /*consider_reach_kind=*/false,
-		   /*reach_kind=*/DIRECT_REACH_KIND))
+type_suppression::type_suppression()
+  : suppression_base(), priv_(new priv)
 {}
 
 type_suppression::~type_suppression()
@@ -1916,7 +1886,10 @@  read_type_suppression(const ini::config::section& section)
 	changed_enumerator_names.push_back(p->get_value()->as_string());
     }
 
-  result.reset(new type_suppression(label_str, name_regex, name_str));
+  result.reset(new type_suppression());
+  result->set_label(label_str);
+  result->set_type_name_regex(name_regex);
+  result->set_type_name(name_str);
 
   if (consider_type_kind)
     {
@@ -2053,77 +2026,7 @@  function_suppression::parameter_spec::set_parameter_type_name_regex
 /// specified by using the various accessors of the @ref
 /// function_suppression type.
 function_suppression::function_suppression()
-  :  suppression_base(/*label=*/""), priv_(new priv)
-{}
-
-/// Constructor for the @ref function_suppression type.
-///
-/// @param label an informative text string that the evalution code
-/// might use to designate this function suppression specification in
-/// error messages.  This parameter might be empty, in which case it's
-/// ignored at evaluation time.
-///
-/// @param the name of the function the user wants the current
-/// specification to designate.  This parameter might be empty, in
-/// which case it's ignored at evaluation time.
-///
-/// @param nr if @p name is empty this parameter is a regular
-/// expression for a family of names of functions the user wants the
-/// current specification to designate.  If @p name is not empty, this
-/// parameter is ignored at specification evaluation time.  This
-/// parameter might be empty, in which case it's ignored at evaluation
-/// time.
-///
-/// @param ret_tn the name of the return type of the function the user
-/// wants this specification to designate.  This parameter might be
-/// empty, in which case it's ignored at evaluation time.
-///
-/// @param ret_tr if @p ret_tn is empty, then this is a regular
-/// expression for a family of return type names for functions the
-/// user wants the current specification to designate.  If @p ret_tn
-/// is not empty, then this parameter is ignored at specification
-/// evaluation time.  This parameter might be empty, in which case
-/// it's ignored at evaluation time.
-///
-/// @param ps a vector of parameter specifications to specify
-/// properties of the parameters of the functions the user wants this
-/// specification to designate.  This parameter might be empty, in
-/// which case it's ignored at evaluation time.
-///
-/// @param sym_n the name of symbol of the function the user wants
-/// this specification to designate.  This parameter might be empty,
-/// in which case it's ignored at evaluation time.
-///
-/// @param sym_nr if the parameter @p sym_n is empty, then this
-/// parameter is a regular expression for a family of names of symbols
-/// of functions the user wants this specification to designate.  If
-/// the parameter @p sym_n is not empty, then this parameter is
-/// ignored at specification evaluation time.  This parameter might be
-/// empty, in which case it's ignored at evaluation time.
-///
-/// @param sym_v the name of the version of the symbol of the function
-/// the user wants this specification to designate.  This parameter
-/// might be empty, in which case it's ignored at evaluation time.
-///
-/// @param sym_vr if the parameter @p sym_v is empty, then this
-/// parameter is a regular expression for a family of versions of
-/// symbols of functions the user wants the current specification to
-/// designate.  If the parameter @p sym_v is non empty, then this
-/// parameter is ignored.  This parameter might be empty, in which
-/// case it's ignored at evaluation time.
-function_suppression::function_suppression(const string&		label,
-					   const string&		name,
-					   const regex_t_sptr&		nr,
-					   const string&		ret_tn,
-					   const regex_t_sptr&		ret_tr,
-					   parameter_specs_type&	ps,
-					   const string&		sym_n,
-					   const regex_t_sptr&		sym_nr,
-					   const string&		sym_v,
-					   const regex_t_sptr&		sym_vr)
-  : suppression_base(label),
-    priv_(new priv(name, nr, ret_tn, ret_tr, ps,
-		   sym_n, sym_nr, sym_v, sym_vr))
+  : suppression_base(), priv_(new priv)
 {}
 
 function_suppression::~function_suppression()
@@ -3261,16 +3164,17 @@  read_function_suppression(const ini::config::section& section)
 	  parms.push_back(parm);
       }
 
-  result.reset(new function_suppression(label_str,
-					name,
-					name_regex,
-					return_type_name,
-					return_type_regex,
-					parms,
-					sym_name,
-					sym_name_regex,
-					sym_version,
-					sym_ver_regex));
+  result.reset(new function_suppression());
+  result->set_label(label_str);
+  result->set_name(name);
+  result->set_name_regex(name_regex);
+  result->set_return_type_name(return_type_name);
+  result->set_return_type_regex(return_type_regex);
+  result->set_parameter_specs(parms);
+  result->set_symbol_name(sym_name);
+  result->set_symbol_name_regex(sym_name_regex);
+  result->set_symbol_version(sym_version);
+  result->set_symbol_version_regex(sym_ver_regex);
 
   if ((drop_artifact_str == "yes" || drop_artifact_str == "true")
       && (!name.empty()
@@ -3314,71 +3218,13 @@  read_function_suppression(const ini::config::section& section)
 
 // <variable_suppression stuff>
 
-/// Constructor for the @ref variable_suppression type.
-///
-/// @param label an informative text string that the evalution code
-/// might use to designate this variable suppression specification in
-/// error messages.  This parameter might be empty, in which case it's
-/// ignored at evaluation time.
-///
-/// @param name the name of the variable the user wants the current
-/// specification to designate.  This parameter might be empty, in
-/// which case it's ignored at evaluation time.
-///
-/// @param name_regex if @p name is empty, this parameter is a
-/// regular expression for a family of names of variables the user
-/// wants the current specification to designate.  If @p name is not
-/// empty, then this parameter is ignored at evaluation time.  This
-/// parameter might be empty, in which case it's ignored at evaluation
-/// time.
-///
-/// @param symbol_name the name of the symbol of the variable the user
-/// wants the current specification to designate.  This parameter
-/// might be empty, in which case it's ignored at evaluation time.
-///
-/// @param symbol_name_str if @p symbol_name is empty, this parameter
-/// is a regular expression for a family of names of symbols of
-/// variables the user wants the current specification to designate.
-/// If @p symbol_name is not empty, then this parameter is ignored at
-/// evaluation time.  This parameter might be empty, in which case
-/// it's ignored at evaluation time.
-///
-/// @param symbol_version the version of the symbol of the variable
-/// the user wants the current specification to designate.  This
-/// parameter might be empty, in which case it's ignored at evaluation
-/// time.
-///
-/// @param symbol_version_regex if @p symbol_version is empty, then
-/// this parameter is a regular expression for a family of versions of
-/// symbol for the variables the user wants the current specification
-/// to designate.  If @p symbol_version is not empty, then this
-/// parameter is ignored at evaluation time.  This parameter might be
-/// empty, in which case it's ignored at evaluation time.
-///
-/// @param type_name the name of the type of the variable the user
-/// wants the current specification to designate.  This parameter
-/// might be empty, in which case it's ignored at evaluation time.
+/// Default constructor for the @ref variable_suppression type.
 ///
-/// @param type_name_regex if @p type_name is empty, then this
-/// parameter is a regular expression for a family of type names of
-/// variables the user wants the current specification to designate.
-/// If @p type_name is not empty, then this parameter is ignored at
-/// evluation time.  This parameter might be empty, in which case it's
-/// ignored at evaluation time.
-variable_suppression::variable_suppression(const string& label,
-					   const string& name,
-					   const regex_t_sptr& name_regex,
-					   const string& symbol_name,
-					   const regex_t_sptr& symbol_name_regex,
-					   const string& symbol_version,
-					   const regex_t_sptr& symbol_version_regex,
-					   const string& type_name,
-					   const regex_t_sptr& type_name_regex)
-  : suppression_base(label),
-    priv_(new priv(name, name_regex,
-		   symbol_name, symbol_name_regex,
-		   symbol_version, symbol_version_regex,
-		   type_name, type_name_regex))
+/// It defines no suppression for now.  Suppressions have to be
+/// specified by using the various accessors of the @ref
+/// variable_suppression type.
+variable_suppression::variable_suppression()
+  : suppression_base(), priv_(new priv)
 {}
 
 /// Virtual destructor for the @erf variable_suppression type.
@@ -4035,15 +3881,16 @@  read_variable_suppression(const ini::config::section& section)
   regex_t_sptr type_name_regex;
   maybe_get_regex_prop(section, "type_name_regexp", type_name_regex);
 
-  result.reset(new variable_suppression(label_str,
-					name_str,
-					name_regex,
-					symbol_name,
-					symbol_name_regex,
-					symbol_version,
-					symbol_version_regex,
-					type_name_str,
-					type_name_regex));
+  result.reset(new variable_suppression);
+  result->set_label(label_str);
+  result->set_name(name_str);
+  result->set_name_regex(name_regex);
+  result->set_symbol_name(symbol_name);
+  result->set_symbol_name_regex(symbol_name_regex);
+  result->set_symbol_version(symbol_version);
+  result->set_symbol_version_regex(symbol_version_regex);
+  result->set_type_name(type_name_str);
+  result->set_type_name_regex(type_name_regex);
 
   if ((drop_artifact_str == "yes" || drop_artifact_str == "true")
       && (!name_str.empty()
@@ -4083,25 +3930,8 @@  read_variable_suppression(const ini::config::section& section)
 
 // <file_suppression stuff>
 
-/// Constructor for the the @ref file_suppression type.
-///
-/// @param label the label of the suppression directive.
-///
-/// @param fname_regex the regular expression string that
-/// designates the file name that instances of @ref file_suppression
-/// should match.
-///
-/// @param fname_not_regex the regular expression string that
-/// designates the file name that instances of @ref file_suppression
-/// shoult *NOT* match.  In other words, this file_suppression should
-/// be activated if its file name does not match the regular
-/// expression @p fname_not_regex.
-file_suppression::file_suppression(const string& label,
-				   const regex_t_sptr& fname_regex,
-				   const regex_t_sptr& fname_not_regex)
-  : suppression_base(label,
-		     fname_regex,
-		     fname_not_regex)
+/// Default constructor for the the @ref file_suppression type.
+file_suppression::file_suppression()
 {}
 
 /// Test if instances of this @ref file_suppression suppresses a
@@ -4188,9 +4018,10 @@  read_file_suppression(const ini::config::section& section)
   regex_t_sptr soname_not_regex;
   maybe_get_regex_prop(section, "soname_not_regexp", soname_not_regex);
 
-  result.reset(new file_suppression(label_str,
-				    file_name_regex,
-				    file_name_not_regex));
+  result.reset(new file_suppression);
+  result->set_label(label_str);
+  result->set_file_name_regex(file_name_regex);
+  result->set_file_name_not_regex(file_name_not_regex);
 
   if (soname_regex)
     {
diff --git a/src/abg-tools-utils.cc b/src/abg-tools-utils.cc
index 3af9fc49..4cef400d 100644
--- a/src/abg-tools-utils.cc
+++ b/src/abg-tools-utils.cc
@@ -1810,11 +1810,8 @@  handle_file_entry(const string& file_path,
 {
   if (!suppr)
     {
-      suppr.reset(
-	new type_suppression(get_private_types_suppr_spec_label(),
-			     /*type_name_regexp=*/regex::regex_t_sptr(),
-			     /*type_name=*/""));
-
+      suppr.reset(new type_suppression());
+      suppr->set_label(get_private_types_suppr_spec_label());
       // Types that are defined in system headers are usually
       // OK to be considered as public types.
       regex::regex_t_sptr headers_regex = regex::compile("^/usr/include/");