Add search terms ?architecture, ?multiarch

* ?architecture(architecture)
  Select packages for the given architecture (such as
  "amd64", or "all").

* ?multiarch(multiarch)
  Select packages with a multi-arch capability of multiarch
  (that is, either "foreign", "same", "allowed", or "none").

6 files changed, 221 insertions, 0 deletions

diff --git a/src/generic/apt/matching/compare_patterns.cc b/src/generic/apt/matching/compare_patterns.cc
index 10992a4f..3aae4246 100644
--- a/src/generic/apt/matching/compare_patterns.cc
+++ b/src/generic/apt/matching/compare_patterns.cc
@@ -98,6 +98,10 @@ namespace aptitude
 	    return compare_patterns(p1->get_any_version_pattern(),
 				    p2->get_any_version_pattern());
 
+	  case pattern::architecture:
+	    return compare_regex_info(p1->get_architecture_regex_info(),
+				      p2->get_architecture_regex_info());
+
 	  case pattern::automatic:
 	    return 0;
 
@@ -192,6 +196,10 @@ namespace aptitude
 	    return compare_regex_info(p1->get_maintainer_regex_info(),
 				      p2->get_maintainer_regex_info());
 
+	  case pattern::multiarch:
+	    return compare_int(p1->get_multiarch_multiarch_type(),
+			       p2->get_multiarch_multiarch_type());
+
 	  case pattern::name:
 	    return compare_regex_info(p1->get_name_regex_info(),
 				      p2->get_name_regex_info());
diff --git a/src/generic/apt/matching/match.cc b/src/generic/apt/matching/match.cc
index a42a6b81..78ab09b4 100644
--- a/src/generic/apt/matching/match.cc
+++ b/src/generic/apt/matching/match.cc
@@ -894,6 +894,25 @@ namespace aptitude
 
 	    break;
 
+	  case pattern::architecture:
+	    if(!target.get_has_version())
+	      return NULL;
+
+	    {
+	      pkgCache::VerIterator ver(target.get_version_iterator(cache));
+
+	      ref_ptr<match> m = evaluate_regexp(p,
+						 p->get_architecture_regex_info(),
+						 ver.Arch(),
+						 debug);
+
+	      if(m.valid())
+		return m;
+	      else
+		return NULL;
+	    }
+	    break;
+
 	  case pattern::automatic:
 	    {
 	      pkgCache::PkgIterator pkg(target.get_package_iterator(cache));
@@ -1182,6 +1201,46 @@ namespace aptitude
 	      }
 	    break;
 
+	  case pattern::multiarch:
+	    if(!target.get_has_version())
+	      return NULL;
+	    else
+	      {
+		bool matches = false;
+		const int multiarch = target.get_ver()->MultiArch;
+
+		switch(p->get_multiarch_multiarch_type())
+		  {
+		  case pattern::multiarch_none:
+		    matches = (multiarch == pkgCache::Version::None ||
+			       multiarch == pkgCache::Version::All);
+		    break;
+
+		  case pattern::multiarch_foreign:
+		    matches = (multiarch == pkgCache::Version::Foreign ||
+			       multiarch == pkgCache::Version::AllForeign);
+		    break;
+
+		  case pattern::multiarch_same:
+		    matches = multiarch == pkgCache::Version::Same;
+		    break;
+
+		  case pattern::multiarch_allowed:
+		    matches = (multiarch == pkgCache::Version::Allowed ||
+			       multiarch == pkgCache::Version::AllAllowed);
+		    break;
+
+		  default:
+		    throw MatchingException("Internal error: bad multiarch-type flag.");
+		  }
+
+		if(matches)
+		  return match::make_atomic(p);
+		else
+		  return NULL;
+	      }
+	    break;
+
 	  case pattern::name:
 	    return evaluate_regexp(p,
 				   p->get_name_regex_info(),
@@ -2013,6 +2072,7 @@ namespace aptitude
 
 	  case pattern::archive:
 	  case pattern::action:
+	  case pattern::architecture:
 	  case pattern::automatic:
 	  case pattern::bind:
 	  case pattern::broken:
@@ -2030,6 +2090,7 @@ namespace aptitude
 	  case pattern::install_version:
 	  case pattern::installed:
 	  case pattern::maintainer:
+	  case pattern::multiarch:
 	  case pattern::name:
 	  case pattern::new_tp:
 	  case pattern::obsolete:
@@ -2223,6 +2284,7 @@ namespace aptitude
 
 	  case pattern::archive:
 	  case pattern::action:
+	  case pattern::architecture:
 	  case pattern::automatic:
 	  case pattern::bind:
 	  case pattern::broken:
@@ -2239,6 +2301,7 @@ namespace aptitude
 	  case pattern::install_version:
 	  case pattern::installed:
 	  case pattern::maintainer:
+	  case pattern::multiarch:
 	  case pattern::name:
 	  case pattern::new_tp:
 	  case pattern::obsolete:
@@ -2345,6 +2408,7 @@ namespace aptitude
 
 	  case pattern::archive:
 	  case pattern::action:
+	  case pattern::architecture:
 	  case pattern::automatic:
 	  case pattern::bind:
 	  case pattern::broken:
@@ -2361,6 +2425,7 @@ namespace aptitude
 	  case pattern::install_version:
 	  case pattern::installed:
 	  case pattern::maintainer:
+	  case pattern::multiarch:
 	  case pattern::name:
 	  case pattern::new_tp:
 	  case pattern::obsolete:
@@ -2540,6 +2605,7 @@ namespace aptitude
 	    // Various non-Xapian patterns, along with ?term.
 	  case pattern::archive:
 	  case pattern::action:
+	  case pattern::architecture:
 	  case pattern::automatic:
 	  case pattern::bind:
 	  case pattern::broken:
@@ -2557,6 +2623,7 @@ namespace aptitude
 	  case pattern::install_version:
 	  case pattern::installed:
 	  case pattern::maintainer:
+	  case pattern::multiarch:
 	  case pattern::name:
 	  case pattern::new_tp:
 	  case pattern::obsolete:
@@ -2828,6 +2895,7 @@ namespace aptitude
 
 	  case pattern::archive:
 	  case pattern::action:
+	  case pattern::architecture:
 	  case pattern::automatic:
 	  case pattern::bind:
 	  case pattern::broken:
@@ -2844,6 +2912,7 @@ namespace aptitude
 	  case pattern::install_version:
 	  case pattern::installed:
 	  case pattern::maintainer:
+	  case pattern::multiarch:
 	  case pattern::name:
 	  case pattern::new_tp:
 	  case pattern::obsolete:
diff --git a/src/generic/apt/matching/parse.cc b/src/generic/apt/matching/parse.cc
index bceffe8e..b4d80c4c 100644
--- a/src/generic/apt/matching/parse.cc
+++ b/src/generic/apt/matching/parse.cc
@@ -107,6 +107,7 @@ namespace
       term_type_all,
       term_type_and,
       term_type_any,
+      term_type_architecture,
       term_type_archive,
       term_type_automatic,
       term_type_bind,
@@ -120,6 +121,7 @@ namespace
       term_type_garbage,
       term_type_installed,
       term_type_maintainer,
+      term_type_multiarch,
       term_type_name,
       term_type_narrow,
       term_type_new,
@@ -160,6 +162,7 @@ namespace
     { "all-versions", term_type_all },
     { "and", term_type_and },
     { "any-version", term_type_any },
+    { "architecture", term_type_architecture },
     { "archive", term_type_archive },
     { "automatic", term_type_automatic },
     { "bind", term_type_bind },
@@ -174,6 +177,7 @@ namespace
     { "garbage", term_type_garbage },
     { "installed", term_type_installed },
     { "maintainer", term_type_maintainer },
+    { "multiarch", term_type_multiarch },
     { "name", term_type_name },
     /* ForTranslators: Opposite of widen. Search for "widen" in this file for details. */
     { "narrow", term_type_narrow },
@@ -311,6 +315,20 @@ namespace
       throw MatchingException(ssprintf(_("Unknown action type: %s"),
 				       s.c_str()));
   }
+
+  pattern::multiarch_type parse_multiarch(const std::string &s)
+  {
+    if(!strcasecmp(s.c_str(), "none"))
+      return pattern::multiarch_none;
+    else if(!strcasecmp(s.c_str(), "foreign"))
+      return pattern::multiarch_foreign;
+    else if(!strcasecmp(s.c_str(), "same"))
+      return pattern::multiarch_same;
+    else if(!strcasecmp(s.c_str(), "allowed"))
+      return pattern::multiarch_allowed;
+    else
+      throw MatchingException(ssprintf(_("Unknown multiarch type: %s"), s.c_str()));
+  }
 }
 
 static
@@ -889,6 +907,8 @@ ref_ptr<pattern> parse_term_args(const string &term_name,
 					 "widen"));
       else
 	return pattern::make_any_version(parse_term_args(start, end, terminators, false, name_context));
+    case term_type_architecture:
+      return pattern::make_architecture(parse_string_match_args(start, end));
     case term_type_archive:
       return pattern::make_archive(parse_string_match_args(start, end));
     case term_type_automatic:
@@ -938,6 +958,11 @@ ref_ptr<pattern> parse_term_args(const string &term_name,
       return pattern::make_installed();
     case term_type_maintainer:
       return pattern::make_maintainer(parse_string_match_args(start, end));
+    case term_type_multiarch:
+      {
+	std::string s(parse_string_match_args(start, end));
+	return pattern::make_multiarch(parse_multiarch(s));
+      }
     case term_type_name:
       return pattern::make_name(parse_string_match_args(start, end));
     case term_type_narrow:
diff --git a/src/generic/apt/matching/pattern.cc b/src/generic/apt/matching/pattern.cc
index e3bfeb06..bb874f4c 100644
--- a/src/generic/apt/matching/pattern.cc
+++ b/src/generic/apt/matching/pattern.cc
@@ -103,6 +103,7 @@ switch(p->get_type())
     // Atomic patterns:
   case pattern::archive:
   case pattern::action:
+  case pattern::architecture:
   case pattern::automatic:
   case pattern::bind:
   case pattern::broken:
@@ -119,6 +120,7 @@ switch(p->get_type())
   case pattern::install_version:
   case pattern::installed:
   case pattern::maintainer:
+  case pattern::multiarch:
   case pattern::name:
   case pattern::new_tp:
   case pattern::obsolete:
diff --git a/src/generic/apt/matching/pattern.h b/src/generic/apt/matching/pattern.h
index 037d38f4..65f8fd35 100644
--- a/src/generic/apt/matching/pattern.h
+++ b/src/generic/apt/matching/pattern.h
@@ -238,6 +238,13 @@ namespace aptitude
 	   *  Fields: pattern.
 	   */
 	  any_version,
+          /** \brief ?architecture(PATTERN)
+           *
+           *  Matches packages by their architecture.
+           *
+           *  Fields: regex_info.
+           */
+          architecture,
 	  /** \brief ?automatic
 	   *
 	   *  Matches packages that were automatically installed.
@@ -356,6 +363,13 @@ namespace aptitude
 	   *  Fields: regex_info.
 	   */
 	  maintainer,
+	  /** \brief ?multiarch(MULTIARCH)
+	   *
+	   *  Matches packages by their Multi-Arch field.
+	   *
+	   *  Fields: multiarch_type.
+	   */
+	  multiarch,
 	  /** \brief ?name(PATTERN)
 	   *
 	   *  Matches packages by their name.
@@ -618,6 +632,19 @@ namespace aptitude
 	  action_keep
 	};
 
+      /** \brief The Multi-Arch capabilities that can be matched against. */
+      enum multiarch_type
+	{
+	  /** \brief Match packages that have no Multi-Arch capability. */
+	  multiarch_none,
+	  /** \brief Match packages that are Multi-Arch: foreign. */
+	  multiarch_foreign,
+	  /** \brief Match packages that are Multi-Arch: same. */
+	  multiarch_same,
+	  /** \brief Match packages that are Multi-Arch: allowed. */
+	  multiarch_allowed
+	};
+
     private:
 
       // The type of this node.
@@ -652,6 +679,9 @@ namespace aptitude
 
 	// The priority, if applicable.
 	pkgCache::State::VerPriority priority;
+
+	// The multiarch type being selected, if applicable.
+	multiarch_type multiarch;
       } info;
 
       // Disallow copy-construction.
@@ -756,6 +786,14 @@ namespace aptitude
 	info.action = action_type;
       }
 
+      // Allocate a pattern that has multi-arch info.
+      pattern(type _tp,
+	      multiarch_type multiarch_type)
+	: tp(_tp)
+      {
+	info.multiarch = multiarch_type;
+      }
+
     public:
 
       /** \name archive term constructor and accessors. */
@@ -853,6 +891,29 @@ namespace aptitude
 
       // @}
 
+      /** \name architecture term constructor and accessors. */
+
+      // @{
+
+      /** \brief Create an ?architecture term.
+       *
+       *  \param s  The regular expression to match against.
+       */
+      static cwidget::util::ref_ptr<pattern>
+      make_architecture(const std::string &s)
+      {
+        return new pattern(architecture, regex_info(s));
+      }
+
+      const regex_info &get_architecture_regex_info() const
+      {
+        eassert(tp == architecture);
+
+        return regex_information;
+      }
+
+      // @}
+
       /** \name automatic term constructor. */
 
       // @{
@@ -1281,6 +1342,32 @@ namespace aptitude
 
       // @}
 
+      /** \name multiarch term constructor and accessors. */
+
+      // @{
+
+      /** \brief Create a ?multiarch term.
+       *
+       *  \param ma  The multiarch type to match.
+       */
+      static cwidget::util::ref_ptr<pattern>
+      make_multiarch(const multiarch_type ma)
+      {
+	return new pattern(multiarch, ma);
+      }
+
+      /** \brief Retrieve the information associated with a ?multiarch
+       *  term.
+       */
+      const multiarch_type get_multiarch_multiarch_type() const
+      {
+	eassert(tp == multiarch);
+
+	return info.multiarch;
+      }
+
+      // @}
+
       /** \name name term constructor and accessors */
 
       // @{
diff --git a/src/generic/apt/matching/serialize.cc b/src/generic/apt/matching/serialize.cc
index 220e97cc..7e4be96b 100644
--- a/src/generic/apt/matching/serialize.cc
+++ b/src/generic/apt/matching/serialize.cc
@@ -252,6 +252,10 @@ namespace aptitude
 				   variable_name_stack);
 	    break;
 
+	  case pattern::architecture:
+	    serialize_regexp_term("architecture", p->get_architecture_regex_info(), out);
+	    break;
+
 	  case pattern::automatic:
 	    out << "?automatic";
 	    break;
@@ -370,6 +374,32 @@ namespace aptitude
 				  out);
 	    break;
 
+	  case pattern::multiarch:
+	    out << "?multiarch(";
+	    switch(p->get_multiarch_multiarch_type())
+	      {
+	      case pattern::multiarch_none:
+		out << "none";
+		break;
+
+	      case pattern::multiarch_foreign:
+		out << "foreign";
+		break;
+
+	      case pattern::multiarch_same:
+		out << "same";
+		break;
+
+	      case pattern::multiarch_allowed:
+		out << "allowed";
+		break;
+
+	      default:
+		throw MatchingException("Internal error: bad multiarch-type flag.");
+	      }
+	    out << ')';
+	    break;
+
 	  case pattern::name:
 	    serialize_regexp_term("name",
 				  p->get_name_regex_info(),