libdpkg: Uppercase dpkg_relation enum values

dselect/pkgdepcon.cc

@@ -414,7 +414,7 @@ packagelist::deppossatisfied(deppossi *possi, perpackagestate **fixbyupgrade)
       return false;
     }
   }
-  if (possi->verrel != dpkg_relation_none)
+  if (possi->verrel != DPKG_RELATION_NONE)
     return false;
   deppossi *provider;
 

dselect/pkgsublist.cc

@@ -131,21 +131,21 @@ packagelist::add(dependency *depends, showpriority displayimportance)
        possi=possi->next, comma=(possi && possi->next ? ", " : _(" or "))) {
     info(comma);
     info(possi->ed->name);
-    if (possi->verrel != dpkg_relation_none) {
+    if (possi->verrel != DPKG_RELATION_NONE) {
       switch (possi->verrel) {
-      case dpkg_relation_le:
+      case DPKG_RELATION_LE:
         info(" (<= ");
         break;
-      case dpkg_relation_ge:
+      case DPKG_RELATION_GE:
         info(" (>= ");
         break;
-      case dpkg_relation_lt:
+      case DPKG_RELATION_LT:
         info(" (<< ");
         break;
-      case dpkg_relation_gt:
+      case DPKG_RELATION_GT:
         info(" (>> ");
         break;
-      case dpkg_relation_eq:
+      case DPKG_RELATION_EQ:
         info(" (= ");
         break;
       default:
@@ -159,7 +159,7 @@ packagelist::add(dependency *depends, showpriority displayimportance)
   add(depends->up,info.string(),displayimportance);
   for (possi=depends->list; possi; possi=possi->next) {
     add(&possi->ed->pkg, info.string(), displayimportance);
-    if (possi->verrel == dpkg_relation_none && depends->type != dep_provides) {
+    if (possi->verrel == DPKG_RELATION_NONE && depends->type != dep_provides) {
       // providers aren't relevant if a version was specified, or
       // if we're looking at a provider relationship already
       deppossi *provider;

lib/dpkg/dump.c

@@ -302,22 +302,22 @@ void varbufdependency(struct varbuf *vb, struct dependency *dep) {
     varbuf_add_str(vb, dop->ed->name);
     if (!dop->arch_is_implicit)
       varbuf_add_archqual(vb, dop->arch);
-    if (dop->verrel != dpkg_relation_none) {
+    if (dop->verrel != DPKG_RELATION_NONE) {
       varbuf_add_str(vb, " (");
       switch (dop->verrel) {
-      case dpkg_relation_eq:
+      case DPKG_RELATION_EQ:
         varbuf_add_char(vb, '=');
         break;
-      case dpkg_relation_ge:
+      case DPKG_RELATION_GE:
         varbuf_add_str(vb, ">=");
         break;
-      case dpkg_relation_le:
+      case DPKG_RELATION_LE:
         varbuf_add_str(vb, "<=");
         break;
-      case dpkg_relation_gt:
+      case DPKG_RELATION_GT:
         varbuf_add_str(vb, ">>");
         break;
-      case dpkg_relation_lt:
+      case DPKG_RELATION_LT:
         varbuf_add_str(vb, "<<");
         break;
       default:

lib/dpkg/fields.c

@@ -479,9 +479,9 @@ f_dependency(struct pkginfo *pkg, struct pkgbin *pkgbin,
         c1= *p;
         if (c1 == '<' || c1 == '>') {
           c2= *++p;
-          dop->verrel = (c1 == '<') ? dpkg_relation_lt : dpkg_relation_gt;
+          dop->verrel = (c1 == '<') ? DPKG_RELATION_LT : DPKG_RELATION_GT;
           if (c2 == '=') {
-            dop->verrel |= dpkg_relation_eq;
+            dop->verrel |= DPKG_RELATION_EQ;
             p++;
           } else if (c2 == c1) {
             /* Either ‘<<’ or ‘>>’. */
@@ -491,16 +491,16 @@ f_dependency(struct pkginfo *pkg, struct pkgbin *pkgbin,
                         _("`%s' field, reference to `%.255s':\n"
                           " bad version relationship %c%c"),
                         fip->name, depname.buf, c1, c2);
-            dop->verrel = dpkg_relation_none;
+            dop->verrel = DPKG_RELATION_NONE;
           } else {
             parse_warn(ps,
                        _("`%s' field, reference to `%.255s':\n"
                          " `%c' is obsolete, use `%c=' or `%c%c' instead"),
                        fip->name, depname.buf, c1, c1, c1, c1);
-            dop->verrel |= dpkg_relation_eq;
+            dop->verrel |= DPKG_RELATION_EQ;
           }
         } else if (c1 == '=') {
-          dop->verrel = dpkg_relation_eq;
+          dop->verrel = DPKG_RELATION_EQ;
           p++;
         } else {
           parse_warn(ps,
@@ -508,9 +508,9 @@ f_dependency(struct pkginfo *pkg, struct pkgbin *pkgbin,
                        " implicit exact match on version number, "
                        "suggest using `=' instead"),
                      fip->name, depname.buf);
-          dop->verrel = dpkg_relation_eq;
+          dop->verrel = DPKG_RELATION_EQ;
         }
-        if ((dop->verrel != dpkg_relation_eq) && (fip->integer == dep_provides))
+        if ((dop->verrel != DPKG_RELATION_EQ) && (fip->integer == dep_provides))
           parse_warn(ps,
                      _("only exact versions may be used for '%s' field"),
                      "Provides");
@@ -552,7 +552,7 @@ f_dependency(struct pkginfo *pkg, struct pkgbin *pkgbin,
                            "error in version"), fip->name, depname.buf);
         p++; while (isspace(*p)) p++;
       } else {
-        dop->verrel = dpkg_relation_none;
+        dop->verrel = DPKG_RELATION_NONE;
         dpkg_version_blank(&dop->version);
       }
       if (!*p || *p == ',') break;

lib/dpkg/test/t-version.c

@@ -2,7 +2,7 @@
  * libdpkg - Debian packaging suite library routines
  * t-version.c - test version handling
  *
- * Copyright © 2009-2012 Guillem Jover <guillem@debian.org>
+ * Copyright © 2009-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
@@ -118,31 +118,31 @@ test_version_relate(void)
 
 	dpkg_version_blank(&a);
 	dpkg_version_blank(&b);
-	test_pass(dpkg_version_relate(&a, dpkg_relation_none, &b));
+	test_pass(dpkg_version_relate(&a, DPKG_RELATION_NONE, &b));
 
 	a = DPKG_VERSION_OBJECT(0, "1", "1");
 	b = DPKG_VERSION_OBJECT(0, "1", "1");
-	test_pass(dpkg_version_relate(&a, dpkg_relation_eq, &b));
-	test_fail(dpkg_version_relate(&a, dpkg_relation_lt, &b));
-	test_pass(dpkg_version_relate(&a, dpkg_relation_le, &b));
-	test_fail(dpkg_version_relate(&a, dpkg_relation_gt, &b));
-	test_pass(dpkg_version_relate(&a, dpkg_relation_ge, &b));
+	test_pass(dpkg_version_relate(&a, DPKG_RELATION_EQ, &b));
+	test_fail(dpkg_version_relate(&a, DPKG_RELATION_LT, &b));
+	test_pass(dpkg_version_relate(&a, DPKG_RELATION_LE, &b));
+	test_fail(dpkg_version_relate(&a, DPKG_RELATION_GT, &b));
+	test_pass(dpkg_version_relate(&a, DPKG_RELATION_GE, &b));
 
 	a = DPKG_VERSION_OBJECT(0, "1", "1");
 	b = DPKG_VERSION_OBJECT(0, "2", "1");
-	test_fail(dpkg_version_relate(&a, dpkg_relation_eq, &b));
-	test_pass(dpkg_version_relate(&a, dpkg_relation_lt, &b));
-	test_pass(dpkg_version_relate(&a, dpkg_relation_le, &b));
-	test_fail(dpkg_version_relate(&a, dpkg_relation_gt, &b));
-	test_fail(dpkg_version_relate(&a, dpkg_relation_ge, &b));
+	test_fail(dpkg_version_relate(&a, DPKG_RELATION_EQ, &b));
+	test_pass(dpkg_version_relate(&a, DPKG_RELATION_LT, &b));
+	test_pass(dpkg_version_relate(&a, DPKG_RELATION_LE, &b));
+	test_fail(dpkg_version_relate(&a, DPKG_RELATION_GT, &b));
+	test_fail(dpkg_version_relate(&a, DPKG_RELATION_GE, &b));
 
 	a = DPKG_VERSION_OBJECT(0, "2", "1");
 	b = DPKG_VERSION_OBJECT(0, "1", "1");
-	test_fail(dpkg_version_relate(&a, dpkg_relation_eq, &b));
-	test_fail(dpkg_version_relate(&a, dpkg_relation_lt, &b));
-	test_fail(dpkg_version_relate(&a, dpkg_relation_le, &b));
-	test_pass(dpkg_version_relate(&a, dpkg_relation_gt, &b));
-	test_pass(dpkg_version_relate(&a, dpkg_relation_ge, &b));
+	test_fail(dpkg_version_relate(&a, DPKG_RELATION_EQ, &b));
+	test_fail(dpkg_version_relate(&a, DPKG_RELATION_LT, &b));
+	test_fail(dpkg_version_relate(&a, DPKG_RELATION_LE, &b));
+	test_pass(dpkg_version_relate(&a, DPKG_RELATION_GT, &b));
+	test_pass(dpkg_version_relate(&a, DPKG_RELATION_GE, &b));
 }
 
 static void

lib/dpkg/version.c

@@ -3,6 +3,7 @@
  * version.c - version handling functions
  *
  * Copyright © 1995 Ian Jackson <ian@chiark.greenend.org.uk>
+ * Copyright © 2008-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
@@ -161,7 +162,7 @@ dpkg_version_compare(const struct dpkg_version *a,
  * @param b The second version.
  *
  * @retval true If the expression “a rel b” is true.
- * @retval true If rel is #dpkg_relation_none.
+ * @retval true If rel is #DPKG_RELATION_NONE.
  * @retval false Otherwise.
  *
  * @warning If rel is not a valid relation, this function will terminate
@@ -174,21 +175,21 @@ dpkg_version_relate(const struct dpkg_version *a,
 {
 	int rc;
 
-	if (rel == dpkg_relation_none)
+	if (rel == DPKG_RELATION_NONE)
 		return true;
 
 	rc = dpkg_version_compare(a, b);
 
 	switch (rel) {
-	case dpkg_relation_eq:
+	case DPKG_RELATION_EQ:
 		return rc == 0;
-	case dpkg_relation_lt:
+	case DPKG_RELATION_LT:
 		return rc < 0;
-	case dpkg_relation_le:
+	case DPKG_RELATION_LE:
 		return rc <= 0;
-	case dpkg_relation_gt:
+	case DPKG_RELATION_GT:
 		return rc > 0;
-	case dpkg_relation_ge:
+	case DPKG_RELATION_GE:
 		return rc >= 0;
 	default:
 		internerr("unknown dpkg_relation %d", rel);

lib/dpkg/version.h

@@ -3,7 +3,7 @@
  * version.h - version handling routines
  *
  * Copyright © 1994,1995 Ian Jackson <ian@chiark.greenend.org.uk>
- * Copyright © 2011-2012 Guillem Jover <guillem@debian.org>
+ * Copyright © 2011-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
@@ -60,17 +60,17 @@ struct dpkg_version {
  */
 enum dpkg_relation {
 	/** The “none” relation, sentinel value. */
-	dpkg_relation_none	= 0,
+	DPKG_RELATION_NONE	= 0,
 	/** Equality relation (‘=’). */
-	dpkg_relation_eq	= DPKG_BIT(0),
+	DPKG_RELATION_EQ	= DPKG_BIT(0),
 	/** Less than relation (‘<<’). */
-	dpkg_relation_lt	= DPKG_BIT(1),
+	DPKG_RELATION_LT	= DPKG_BIT(1),
 	/** Less than or equal to relation (‘<=’). */
-	dpkg_relation_le	= dpkg_relation_lt | dpkg_relation_eq,
+	DPKG_RELATION_LE	= DPKG_RELATION_LT | DPKG_RELATION_EQ,
 	/** Greater than relation (‘>>’). */
-	dpkg_relation_gt	= DPKG_BIT(2),
+	DPKG_RELATION_GT	= DPKG_BIT(2),
 	/** Greater than or equal to relation (‘>=’). */
-	dpkg_relation_ge	= dpkg_relation_gt | dpkg_relation_eq,
+	DPKG_RELATION_GE	= DPKG_RELATION_GT | DPKG_RELATION_EQ,
 };
 
 void dpkg_version_blank(struct dpkg_version *version);

src/depcon.c

@@ -3,7 +3,7 @@
  * depcon.c - dependency and conflict checking
  *
  * Copyright © 1994,1995 Ian Jackson <ian@chiark.greenend.org.uk>
- * Copyright © 2006-2011 Guillem Jover <guillem@debian.org>
+ * Copyright © 2006-2014 Guillem Jover <guillem@debian.org>
  * Copyright © 2011 Linaro Limited
  * Copyright © 2011 Raphaël Hertzog <hertzog@debian.org>
  *
@@ -455,7 +455,7 @@ depisok(struct dependency *dep, struct varbuf *whynot,
       deppossi_pkg_iter_free(possi_iter);
 
       /* If there was no version specified we try looking for Providers. */
-      if (possi->verrel == dpkg_relation_none) {
+      if (possi->verrel == DPKG_RELATION_NONE) {
         /* See if the package we're about to install Provides it. */
         for (provider = possi->ed->depended.available;
              provider;
@@ -594,7 +594,7 @@ depisok(struct dependency *dep, struct varbuf *whynot,
     }
 
     /* If there was no version specified we try looking for Providers. */
-    if (possi->verrel == dpkg_relation_none) {
+    if (possi->verrel == DPKG_RELATION_NONE) {
       /* See if the package we're about to install Provides it. */
       for (provider = possi->ed->depended.available;
            provider;

src/enquiry.c

@@ -372,7 +372,7 @@ assert_version_support(const char *const *argv,
     return 0;
   case stat_unpacked: case stat_halfconfigured: case stat_halfinstalled:
   case stat_triggersawaited:
-    if (dpkg_version_relate(&pkg->configversion, dpkg_relation_ge, version))
+    if (dpkg_version_relate(&pkg->configversion, DPKG_RELATION_GE, version))
       return 0;
     printf(_("Version of dpkg with working %s support not yet configured.\n"
              " Please use 'dpkg --configure dpkg', and then try again.\n"),
@@ -501,7 +501,7 @@ predeppackage(const char *const *argv)
           pkg = trypkg;
           break;
         }
-        if (possi->verrel != dpkg_relation_none)
+        if (possi->verrel != DPKG_RELATION_NONE)
           continue;
         for (provider = possi->ed->depended.available;
              !pkg && provider;

src/packages.c

@@ -359,7 +359,7 @@ deppossi_ok_found(struct pkginfo *possdependee, struct pkginfo *requiredby,
                     pkg_name(possdependee, pnaw_nonambig),
                     versiondescribe(&possdependee->installed.version,
                                     vdew_nonambig));
-      assert(checkversion->verrel != dpkg_relation_none);
+      assert(checkversion->verrel != DPKG_RELATION_NONE);
       if (fc_dependsversion)
         thisf = (dependtry >= 3) ? found_forced : found_defer;
       debug(dbg_depcondetail,"      bad version, returning %d",thisf);
@@ -487,7 +487,7 @@ breaks_check_one(struct varbuf *aemsgs, enum dep_check *ok,
                   pkg_name(broken, pnaw_nonambig),
                   versiondescribe(&broken->installed.version, vdew_nonambig),
                   virtbroken->name);
-  } else if (breaks->verrel != dpkg_relation_none) {
+  } else if (breaks->verrel != DPKG_RELATION_NONE) {
     varbuf_printf(aemsgs, _("  Version of %s to be configured is %s.\n"),
                   pkg_name(broken, pnaw_nonambig),
                   versiondescribe(&broken->installed.version, vdew_nonambig));
@@ -506,7 +506,7 @@ breaks_check_target(struct varbuf *aemsgs, enum dep_check *ok,
 
   for (possi = target->depended.installed; possi; possi = possi->rev_next) {
     if (possi->up->type != dep_breaks) continue;
-    if (virtbroken && possi->verrel != dpkg_relation_none)
+    if (virtbroken && possi->verrel != DPKG_RELATION_NONE)
       continue;
     breaks_check_one(aemsgs, ok, possi, broken, possi->up->up, virtbroken);
   }
@@ -589,7 +589,7 @@ dependencies_ok(struct pkginfo *pkg, struct pkginfo *removing,
       }
       deppossi_pkg_iter_free(possi_iter);
 
-      if (found != found_ok && possi->verrel == dpkg_relation_none) {
+      if (found != found_ok && possi->verrel == DPKG_RELATION_NONE) {
         for (provider = possi->ed->depended.installed;
              found != found_ok && provider;
              provider = provider->rev_next) {

src/unpack.c

@@ -1178,7 +1178,7 @@ void process_archive(const char *filename) {
       newpossi->arch_is_implicit = possi->arch_is_implicit;
       newpossi->arch = possi->arch;
       newpossi->verrel= possi->verrel;
-      if (possi->verrel != dpkg_relation_none)
+      if (possi->verrel != DPKG_RELATION_NONE)
         newpossi->version= possi->version;
       else
         dpkg_version_blank(&newpossi->version);