libdpkg: Uppercase and namespace pkgwant enum values

dselect/pkgcmds.cc

@@ -91,14 +91,14 @@ void packagelist::movecursorafter(int ncursor) {
 pkgwant
 packagelist::reallywant(pkgwant nwarg, struct perpackagestate *pkgstate)
 {
-  if (nwarg != want_sentinel)
+  if (nwarg != PKG_WANT_SENTINEL)
     return nwarg;
   pkgstatus status = pkgstate->pkg->status;
   if (status == stat_notinstalled)
-    return want_purge;
+    return PKG_WANT_PURGE;
   if (status == stat_configfiles)
-    return want_deinstall;
-  return want_install;
+    return PKG_WANT_DEINSTALL;
+  return PKG_WANT_INSTALL;
 }
 
 void
@@ -127,8 +127,8 @@ packagelist::setwant(pkgwant nwarg)
         continue;
       nw= reallywant(nwarg,table[index]);
       if (table[index]->selected == nw ||
-          (table[index]->selected == want_purge &&
-           nw == want_deinstall))
+          (table[index]->selected == PKG_WANT_PURGE &&
+           nw == PKG_WANT_DEINSTALL))
         continue;
       sub->add(table[index]->pkg,nw);
     }
@@ -144,13 +144,13 @@ bool manual_install = false;
 
 void packagelist::kd_select()   {
 	manual_install = true;
-	setwant(want_install);
+	setwant(PKG_WANT_INSTALL);
 	manual_install = false;
 }
-void packagelist::kd_hold()     { setwant(want_hold);      }
-void packagelist::kd_deselect() { setwant(want_deinstall); }
-void packagelist::kd_unhold()   { setwant(want_sentinel);  }
-void packagelist::kd_purge()    { setwant(want_purge);     }
+void packagelist::kd_hold()     { setwant(PKG_WANT_HOLD);      }
+void packagelist::kd_deselect() { setwant(PKG_WANT_DEINSTALL); }
+void packagelist::kd_unhold()   { setwant(PKG_WANT_SENTINEL);  }
+void packagelist::kd_purge()    { setwant(PKG_WANT_PURGE);     }
 
 int
 would_like_to_install(pkgwant wantvalue, pkginfo *pkg)
@@ -159,9 +159,9 @@ would_like_to_install(pkgwant wantvalue, pkginfo *pkg)
   debug(dbg_general, "would_like_to_install(%d, %s) status %d",
         wantvalue, pkg_name(pkg, pnaw_always), pkg->status);
 
-  if (wantvalue == want_install)
+  if (wantvalue == PKG_WANT_INSTALL)
     return 1;
-  if (wantvalue != want_hold)
+  if (wantvalue != PKG_WANT_HOLD)
     return 0;
   if (pkg->status == stat_installed)
     return 1;
@@ -293,7 +293,7 @@ packagelist::kd_revertinstalled()
 
   for (i = 0; i < nitems; i++) {
     if (table[i]->pkg->set->name)
-      table[i]->selected = reallywant(want_sentinel, table[i]);
+      table[i]->selected = reallywant(PKG_WANT_SENTINEL, table[i]);
     ldrawnstart = ldrawnend = -1;
   }
 

dselect/pkgdepcon.cc

@@ -36,7 +36,7 @@ bool
 packagelist::useavailable(pkginfo *pkg)
 {
   if (pkg->clientdata &&
-      pkg->clientdata->selected == want_install &&
+      pkg->clientdata->selected == PKG_WANT_INSTALL &&
       pkg_is_informative(pkg, &pkg->available) &&
       (!(pkg->status == stat_installed ||
          pkg->status == stat_triggersawaited ||
@@ -205,7 +205,7 @@ packagelist::deselect_one_of(pkginfo *per, pkginfo *ped, dependency *dep)
   if (best->spriority >= sp_deselecting) return 0;
   best->suggested=
     best->pkg->status == stat_notinstalled
-      ? want_purge : want_deinstall; // FIXME: configurable.
+      ? PKG_WANT_PURGE : PKG_WANT_DEINSTALL; // FIXME: configurable.
   best->selected= best->suggested;
   best->spriority= sp_deselecting;
 
@@ -312,7 +312,7 @@ int packagelist::resolvedepcon(dependency *depends) {
     /* Always select depends. Only select recommends if we got here because
      * of a manually-initiated install request. */
     if (depends->type != dep_recommends || manual_install) {
-      best->selected = best->suggested = want_install;
+      best->selected = best->suggested = PKG_WANT_INSTALL;
       best->spriority= sp_selecting;
     }
     return rc ? 2 : 0;
@@ -329,7 +329,7 @@ int packagelist::resolvedepcon(dependency *depends) {
     if (depends->type != dep_recommends) {
       best->selected= best->suggested=
         best->pkg->status == stat_notinstalled
-          ? want_purge : want_deinstall; // FIXME: configurable
+          ? PKG_WANT_PURGE : PKG_WANT_DEINSTALL; // FIXME: configurable
       best->spriority= sp_deselecting;
     }
     return rc ? 2 : 0;
@@ -384,7 +384,7 @@ packagelist::deppossatisfied(deppossi *possi, perpackagestate **fixbyupgrade)
   // ‘satisfied’ here for Conflicts and Breaks means that the
   //  restriction is violated ie that the target package is wanted
   int would;
-  pkgwant want = want_purge;
+  pkgwant want = PKG_WANT_PURGE;
 
   if (possi->ed->pkg.clientdata) {
     want = possi->ed->pkg.clientdata->selected;
@@ -401,12 +401,12 @@ packagelist::deppossatisfied(deppossi *possi, perpackagestate **fixbyupgrade)
     // been specified, in which case we don't need to look at the rest
     // anyway.
     if (useavailable(&possi->ed->pkg)) {
-      assert(want == want_install);
+      assert(want == PKG_WANT_INSTALL);
       return versionsatisfied(&possi->ed->pkg.available, possi);
     } else {
       if (versionsatisfied(&possi->ed->pkg.installed, possi))
         return true;
-      if (want == want_hold && fixbyupgrade && !*fixbyupgrade &&
+      if (want == PKG_WANT_HOLD && fixbyupgrade && !*fixbyupgrade &&
           versionsatisfied(&possi->ed->pkg.available, possi) &&
           dpkg_version_compare(&possi->ed->pkg.available.version,
                                &possi->ed->pkg.installed.version) > 1)

dselect/pkglist.cc

@@ -197,7 +197,7 @@ void packagelist::ensurestatsortinfo() {
 // FIXME: Disable for now as a workaround, until dselect knows how to properly
 //        store seen packages.
 #if 0
-        } else if (table[index]->original == want_unknown) {
+        } else if (table[index]->original == PKG_WANT_UNKNOWN) {
           table[index]->ssavail= ssa_notinst_unseen;
 #endif
         } else {
@@ -394,18 +394,18 @@ packagelist::packagelist(keybindings *kb) : baselist(kb) {
     state->pkg= pkg;
     if (pkg->status == stat_notinstalled &&
         !pkg->files &&
-        pkg->want != want_install) {
+        pkg->want != PKG_WANT_INSTALL) {
       pkg->clientdata = nullptr;
       continue;
     }
     // treat all unknown packages as already seen
-    state->direct = state->original = (pkg->want == want_unknown ? want_purge : pkg->want);
+    state->direct = state->original = (pkg->want == PKG_WANT_UNKNOWN ? PKG_WANT_PURGE : pkg->want);
     if (modstatdb_get_status() == msdbrw_write &&
-        state->original == want_unknown) {
+        state->original == PKG_WANT_UNKNOWN) {
       state->suggested=
         pkg->status == stat_installed ||
           pkg->priority <= pri_standard /* FIXME: configurable */
-            ? want_install : want_purge;
+            ? PKG_WANT_INSTALL : PKG_WANT_PURGE;
       state->spriority= sp_inherit;
     } else {
       state->suggested= state->original;
@@ -460,7 +460,7 @@ perpackagestate::free(bool recursive)
       } else {
         assert(!recursive);
         if (pkg->want != selected &&
-            !(pkg->want == want_unknown && selected == want_purge)) {
+            !(pkg->want == PKG_WANT_UNKNOWN && selected == PKG_WANT_PURGE)) {
           pkg->want= selected;
         }
         pkg->clientdata = nullptr;

lib/dpkg/dpkg-db.h

@@ -151,13 +151,13 @@ struct trigaw {
 struct perpackagestate;
 
 enum pkgwant {
-	want_unknown,
-	want_install,
-	want_hold,
-	want_deinstall,
-	want_purge,
+	PKG_WANT_UNKNOWN,
+	PKG_WANT_INSTALL,
+	PKG_WANT_HOLD,
+	PKG_WANT_DEINSTALL,
+	PKG_WANT_PURGE,
 	/** Not allowed except as special sentinel value in some places. */
-	want_sentinel,
+	PKG_WANT_SENTINEL,
 };
 
 enum pkgeflag {

lib/dpkg/dump.c

@@ -246,7 +246,7 @@ w_status(struct varbuf *vb,
 {
   if (pkgbin != &pkg->installed)
     return;
-  assert(pkg->want <= want_purge);
+  assert(pkg->want <= PKG_WANT_PURGE);
   assert(pkg->eflag <= eflag_reinstreq);
 
 #define PEND pkg->trigpend_head

lib/dpkg/parse.c

@@ -279,10 +279,10 @@ pkg_parse_verify(struct parsedb_state *ps,
   if (!(ps->flags & pdb_recordavailable) &&
       pkg->status == stat_notinstalled &&
       pkg->eflag == eflag_ok &&
-      (pkg->want == want_purge ||
-       pkg->want == want_deinstall ||
-       pkg->want == want_hold)) {
-    pkg_set_want(pkg, want_unknown);
+      (pkg->want == PKG_WANT_PURGE ||
+       pkg->want == PKG_WANT_DEINSTALL ||
+       pkg->want == PKG_WANT_HOLD)) {
+    pkg_set_want(pkg, PKG_WANT_UNKNOWN);
   }
 
   /* XXX: Mark not-installed non-arch-qualified selections for automatic
@@ -292,9 +292,9 @@ pkg_parse_verify(struct parsedb_state *ps,
   if (ps->type == pdb_file_status &&
       pkg->status == stat_notinstalled &&
       pkg->eflag == eflag_ok &&
-      pkg->want == want_install &&
+      pkg->want == PKG_WANT_INSTALL &&
       pkgbin->arch->type == DPKG_ARCH_EMPTY)
-    pkg->want = want_unknown;
+    pkg->want = PKG_WANT_UNKNOWN;
 }
 
 struct pkgcount {

lib/dpkg/pkg-namevalue.c

@@ -51,11 +51,11 @@ const struct namevalue priorityinfos[] = {
 };
 
 const struct namevalue wantinfos[] = {
-	NAMEVALUE_DEF("unknown",		want_unknown),
-	NAMEVALUE_DEF("install",		want_install),
-	NAMEVALUE_DEF("hold",			want_hold),
-	NAMEVALUE_DEF("deinstall",		want_deinstall),
-	NAMEVALUE_DEF("purge",			want_purge),
+	NAMEVALUE_DEF("unknown",		PKG_WANT_UNKNOWN),
+	NAMEVALUE_DEF("install",		PKG_WANT_INSTALL),
+	NAMEVALUE_DEF("hold",			PKG_WANT_HOLD),
+	NAMEVALUE_DEF("deinstall",		PKG_WANT_DEINSTALL),
+	NAMEVALUE_DEF("purge",			PKG_WANT_PURGE),
 	{ .name = NULL }
 };
 

lib/dpkg/pkg.c

@@ -114,7 +114,7 @@ pkg_blank(struct pkginfo *pkg)
 {
 	pkg->status = stat_notinstalled;
 	pkg->eflag = eflag_ok;
-	pkg->want = want_unknown;
+	pkg->want = PKG_WANT_UNKNOWN;
 	pkg->priority = pri_unknown;
 	pkg->otherpriority = NULL;
 	pkg->section = NULL;
@@ -187,7 +187,7 @@ pkg_is_informative(struct pkginfo *pkg, struct pkgbin *pkgbin)
 {
 	/* We ignore Section and Priority, as these tend to hang around. */
 	if (pkgbin == &pkg->installed &&
-	    (pkg->want != want_unknown ||
+	    (pkg->want != PKG_WANT_UNKNOWN ||
 	     pkg->eflag != eflag_ok ||
 	     pkg->status != stat_notinstalled ||
 	     dpkg_version_is_informative(&pkg->configversion)))

lib/dpkg/test/t-pkginfo.c

@@ -2,7 +2,7 @@
  * libdpkg - Debian packaging suite library routines
  * t-pkginfo.c - test pkginfo handling
  *
- * Copyright © 2009-2010,2012 Guillem Jover <guillem@debian.org>
+ * Copyright © 2009-2010,2012-2014 Guillem Jover <guillem@debian.org>
  *
  * This is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -33,7 +33,7 @@ test_pkginfo_informative(void)
 	pkg_blank(&pkg);
 	test_fail(pkg_is_informative(&pkg, &pkg.installed));
 
-	pkg_set_want(&pkg, want_purge);
+	pkg_set_want(&pkg, PKG_WANT_PURGE);
 	test_pass(pkg_is_informative(&pkg, &pkg.installed));
 
 	pkg_blank(&pkg);

src/archives.c

@@ -1435,7 +1435,8 @@ void check_conflict(struct dependency *dep, struct pkginfo *pkg,
       ensure_package_clientdata(fixbyrm);
     }
     if (((pkg->available.essential && fixbyrm->installed.essential) ||
-         (((fixbyrm->want != want_install && fixbyrm->want != want_hold) ||
+         (((fixbyrm->want != PKG_WANT_INSTALL &&
+            fixbyrm->want != PKG_WANT_HOLD) ||
            does_replace(pkg, &pkg->available, fixbyrm, &fixbyrm->installed)) &&
           (!fixbyrm->installed.essential || fc_removeessential)))) {
       assert(fixbyrm->clientdata->istobe == PKG_ISTOBE_NORMAL ||
@@ -1699,7 +1700,7 @@ wanttoinstall(struct pkginfo *pkg)
 {
   int rc;
 
-  if (pkg->want != want_install && pkg->want != want_hold) {
+  if (pkg->want != PKG_WANT_INSTALL && pkg->want != PKG_WANT_HOLD) {
     if (f_alsoselect) {
       printf(_("Selecting previously unselected package %s.\n"),
              pkgbin_name(pkg, &pkg->available, pnaw_nonambig));

src/enquiry.c

@@ -245,7 +245,7 @@ struct sectionentry {
 static bool
 yettobeunpacked(struct pkginfo *pkg, const char **thissect)
 {
-  if (pkg->want != want_install)
+  if (pkg->want != PKG_WANT_INSTALL)
     return false;
 
   switch (pkg->status) {
@@ -460,7 +460,7 @@ predeppackage(const char *const *argv)
   it = pkg_db_iter_new();
   while (!dep && (pkg = pkg_db_iter_next_pkg(it))) {
     /* Ignore packages user doesn't want. */
-    if (pkg->want != want_install)
+    if (pkg->want != PKG_WANT_INSTALL)
       continue;
     /* Ignore packages not available. */
     if (!pkg->files)

src/errors.c

@@ -3,6 +3,7 @@
  * errors.c - per package error handling
  *
  * Copyright © 1994,1995 Ian Jackson <ian@chiark.greenend.org.uk>
+ * Copyright © 2007-2014 Guillem Jover <guillem@debian.org>
  *
  * This is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -121,7 +122,7 @@ reportbroken_retexitstatus(int ret)
 bool
 skip_due_to_hold(struct pkginfo *pkg)
 {
-  if (pkg->want != want_hold)
+  if (pkg->want != PKG_WANT_HOLD)
     return false;
   if (fc_hold) {
     notice(_("package %s was on hold, processing it anyway as you requested"),

src/packages.c

@@ -73,19 +73,19 @@ enqueue_pending(void)
             pkg->status == stat_halfconfigured ||
             pkg->trigpend_head))
         continue;
-      if (pkg->want != want_install)
+      if (pkg->want != PKG_WANT_INSTALL)
         continue;
       break;
     case act_triggers:
       if (!pkg->trigpend_head)
         continue;
-      if (pkg->want != want_install)
+      if (pkg->want != PKG_WANT_INSTALL)
         continue;
       break;
     case act_remove:
     case act_purge:
-      if (pkg->want != want_purge) {
-        if (pkg->want != want_deinstall)
+      if (pkg->want != PKG_WANT_PURGE) {
+        if (pkg->want != PKG_WANT_DEINSTALL)
           continue;
         if (pkg->status == stat_configfiles)
           continue;

src/querycmd.c

@@ -464,7 +464,7 @@ enqperpackage(const char *const *argv)
           pkg->priority == pri_unknown &&
           str_is_unset(pkg->section) &&
           !pkg->files &&
-          pkg->want == want_unknown &&
+          pkg->want == PKG_WANT_UNKNOWN &&
           !pkg_is_informative(pkg, &pkg->installed)) {
         notice(_("package '%s' is not installed and no information is available"),
                pkg_name(pkg, pnaw_nonambig));

src/remove.c

@@ -93,11 +93,11 @@ void deferred_remove(struct pkginfo *pkg) {
   debug(dbg_general, "deferred_remove package %s",
         pkg_name(pkg, pnaw_always));
 
-  if (!f_pending && pkg->want != want_unknown) {
+  if (!f_pending && pkg->want != PKG_WANT_UNKNOWN) {
     if (cipaction->arg_int == act_purge)
-      pkg_set_want(pkg, want_purge);
+      pkg_set_want(pkg, PKG_WANT_PURGE);
     else
-      pkg_set_want(pkg, want_deinstall);
+      pkg_set_want(pkg, PKG_WANT_DEINSTALL);
 
     if (!f_noact)
       modstatdb_note(pkg);
@@ -613,16 +613,16 @@ void removal_bulk(struct pkginfo *pkg) {
      * go straight into ‘purge’.  */
     debug(dbg_general, "removal_bulk no postrm, no conffiles, purging");
 
-    pkg_set_want(pkg, want_purge);
+    pkg_set_want(pkg, PKG_WANT_PURGE);
     dpkg_version_blank(&pkg->configversion);
-  } else if (pkg->want == want_purge) {
+  } else if (pkg->want == PKG_WANT_PURGE) {
 
     removal_bulk_remove_configfiles(pkg);
 
   }
 
   /* I.e., either of the two branches above. */
-  if (pkg->want == want_purge) {
+  if (pkg->want == PKG_WANT_PURGE) {
     const char *filename;
 
     /* Retry empty directories, and warn on any leftovers that aren't. */
@@ -641,7 +641,7 @@ void removal_bulk(struct pkginfo *pkg) {
       ohshite(_("can't remove old postrm script"));
 
     pkg_set_status(pkg, stat_notinstalled);
-    pkg_set_want(pkg, want_unknown);
+    pkg_set_want(pkg, PKG_WANT_UNKNOWN);
 
     /* This will mess up reverse links, but if we follow them
      * we won't go back because pkg->status is stat_notinstalled. */

src/select.c

@@ -46,7 +46,8 @@ static void getsel1package(struct pkginfo *pkg) {
   const char *pkgname;
   int l;
 
-  if (pkg->want == want_unknown) return;
+  if (pkg->want == PKG_WANT_UNKNOWN)
+    return;
   pkgname = pkg_name(pkg, pnaw_nonambig);
   l = strlen(pkgname);
   l >>= 3;
@@ -204,7 +205,7 @@ clearselections(const char *const *argv)
   it = pkg_db_iter_new();
   while ((pkg = pkg_db_iter_next_pkg(it))) {
     if (!pkg->installed.essential)
-      pkg_set_want(pkg, want_deinstall);
+      pkg_set_want(pkg, PKG_WANT_DEINSTALL);
   }
   pkg_db_iter_free(it);
 

src/unpack.c

@@ -358,7 +358,7 @@ pkg_disappear(struct pkginfo *pkg, struct pkginfo *infavour)
   dir_sync_path(pkg_infodb_get_dir());
 
   pkg_set_status(pkg, stat_notinstalled);
-  pkg_set_want(pkg, want_unknown);
+  pkg_set_want(pkg, PKG_WANT_UNKNOWN);
   pkg_reset_eflags(pkg);
 
   dpkg_version_blank(&pkg->configversion);
@@ -518,7 +518,7 @@ void process_archive(const char *filename) {
   clear_istobes();
 
   if (wanttoinstall(pkg)) {
-    pkg_set_want(pkg, want_install);
+    pkg_set_want(pkg, PKG_WANT_INSTALL);
   } else {
       pop_cleanup(ehflag_normaltidy);
       return;