Let DEBUG be overridden on the command line with lib/libc/resolv

[ngie]

Summary

Let DEBUG be overridden on the command line with lib/libc/resolv

I ran into compilation issues when trying to do make DEBUG_FLAGS="-g -O0 -DDEBUG"
with libc because the definitions mismatched (nothing vs #defined as 1).

This fixes the issues in lib/libc/resolv with duplicate definitions

MFC after: 1 week
Sponsored by: EMC / Isilon Storage Division

[ume]

No, please don't do that. It looses the feature of the resolver. You should change as follows like NetBSD did:

#ifndef DEBUG
#define DEBUG
#endif

[ngie]

Allow DEBUG to be overridden by values on the command line instead of just removing them

Requested by: ume

[ume]

It seems good to me.

head/lib/libc/resolv/res_init.c

 {
         FILE                    *f;
         int                        i, j, n;
         size_t                  sz;
         int32_t                 pri;
         collelem_t              *ce;
         collchar_t              *cc;
         subst_t                 *sb;
-        char                    vers[COLLATE_STR_LEN];
+        char                        fmt_version[COLLATE_FMT_VERSION_LEN];
+        char                    def_version[XLOCALE_DEF_VERSION_LEN];
         collate_char_t                chars[UCHAR_MAX + 1];
         collate_large_t         *large;
         collate_subst_t         *subst[COLL_WEIGHTS_MAX];
         collate_chain_t         *chain;
 
         /*
          * We have to run through a preliminary pass to identify all the
          * weights that we use for each sorting level.
for (i = 0; i < NUM_WT; i++) {
                 weight_t *w;
                 RB_FOREACH(w, weights, &weights[i]) {
                         w->opt = nweight[i];
                         nweight[i] += 1;
                 }
         }
 
         (void) memset(&chars, 0, sizeof (chars));
-        (void) memset(vers, 0, COLLATE_STR_LEN);
-        (void) strlcpy(vers, COLLATE_VERSION, sizeof (vers));
+        (void) memset(fmt_version, 0, COLLATE_FMT_VERSION_LEN);
+        (void) strlcpy(fmt_version, COLLATE_FMT_VERSION, sizeof (fmt_version));
+        (void) memset(def_version, 0, XLOCALE_DEF_VERSION_LEN);
+        if (version)
+                (void) strlcpy(def_version, version, sizeof (def_version));
 
         /*
          * We need to make sure we arrange for the UNDEFINED field
          * to show up.  Also, set the total weight counts.
          */
         for (i = 0; i < NUM_WT; i++) {
                 if (resolve_pri(pri_undefined[i]) == -1) {
                         set_pri(pri_undefined[i], -1, RESOLVED);
dump_collate(void)
 
         /* Time to write the entire data set out */
 
         for (i = 0; i < NUM_WT; i++)
                 collinfo.subst_count[i] = htote(subst_count[i]);
         collinfo.chain_count = htote(chain_count);
         collinfo.large_count = htote(large_count);
 
-        if ((wr_category(vers, COLLATE_STR_LEN, f) < 0) ||
+        if ((wr_category(fmt_version, COLLATE_FMT_VERSION_LEN, f) < 0) ||
+            (wr_category(def_version, XLOCALE_DEF_VERSION_LEN, f) < 0) ||
             (wr_category(&collinfo, sizeof (collinfo), f) < 0) ||
             (wr_category(&chars, sizeof (chars), f) < 0)) {
                 return;
         }
 
         for (i = 0; i < NUM_WT; i++) {
                 sz = sizeof (collate_subst_t) * subst_count[i];
                 if (wr_category(subst[i], sz, f) < 0) {

head/lib/libc/resolv/res_mkquery.c

 {
         FILE                    *f;
         int                        i, j, n;
         size_t                  sz;
         int32_t                 pri;
         collelem_t              *ce;
         collchar_t              *cc;
         subst_t                 *sb;
-        char                    vers[COLLATE_STR_LEN];
+        char                        fmt_version[COLLATE_FMT_VERSION_LEN];
+        char                    def_version[XLOCALE_DEF_VERSION_LEN];
         collate_char_t                chars[UCHAR_MAX + 1];
         collate_large_t         *large;
         collate_subst_t         *subst[COLL_WEIGHTS_MAX];
         collate_chain_t         *chain;
 
         /*
          * We have to run through a preliminary pass to identify all the
          * weights that we use for each sorting level.
for (i = 0; i < NUM_WT; i++) {
                 weight_t *w;
                 RB_FOREACH(w, weights, &weights[i]) {
                         w->opt = nweight[i];
                         nweight[i] += 1;
                 }
         }
 
         (void) memset(&chars, 0, sizeof (chars));
-        (void) memset(vers, 0, COLLATE_STR_LEN);
-        (void) strlcpy(vers, COLLATE_VERSION, sizeof (vers));
+        (void) memset(fmt_version, 0, COLLATE_FMT_VERSION_LEN);
+        (void) strlcpy(fmt_version, COLLATE_FMT_VERSION, sizeof (fmt_version));
+        (void) memset(def_version, 0, XLOCALE_DEF_VERSION_LEN);
+        if (version)
+                (void) strlcpy(def_version, version, sizeof (def_version));
 
         /*
          * We need to make sure we arrange for the UNDEFINED field
          * to show up.  Also, set the total weight counts.
          */
         for (i = 0; i < NUM_WT; i++) {
                 if (resolve_pri(pri_undefined[i]) == -1) {
                         set_pri(pri_undefined[i], -1, RESOLVED);
dump_collate(void)
 
         /* Time to write the entire data set out */
 
         for (i = 0; i < NUM_WT; i++)
                 collinfo.subst_count[i] = htote(subst_count[i]);
         collinfo.chain_count = htote(chain_count);
         collinfo.large_count = htote(large_count);
 
-        if ((wr_category(vers, COLLATE_STR_LEN, f) < 0) ||
+        if ((wr_category(fmt_version, COLLATE_FMT_VERSION_LEN, f) < 0) ||
+            (wr_category(def_version, XLOCALE_DEF_VERSION_LEN, f) < 0) ||
             (wr_category(&collinfo, sizeof (collinfo), f) < 0) ||
             (wr_category(&chars, sizeof (chars), f) < 0)) {
                 return;
         }
 
         for (i = 0; i < NUM_WT; i++) {
                 sz = sizeof (collate_subst_t) * subst_count[i];
                 if (wr_category(subst[i], sz, f) < 0) {

head/lib/libc/resolv/res_mkupdate.c

 {
         FILE                    *f;
         int                        i, j, n;
         size_t                  sz;
         int32_t                 pri;
         collelem_t              *ce;
         collchar_t              *cc;
         subst_t                 *sb;
-        char                    vers[COLLATE_STR_LEN];
+        char                        fmt_version[COLLATE_FMT_VERSION_LEN];
+        char                    def_version[XLOCALE_DEF_VERSION_LEN];
         collate_char_t                chars[UCHAR_MAX + 1];
         collate_large_t         *large;
         collate_subst_t         *subst[COLL_WEIGHTS_MAX];
         collate_chain_t         *chain;
 
         /*
          * We have to run through a preliminary pass to identify all the
          * weights that we use for each sorting level.
for (i = 0; i < NUM_WT; i++) {
                 weight_t *w;
                 RB_FOREACH(w, weights, &weights[i]) {
                         w->opt = nweight[i];
                         nweight[i] += 1;
                 }
         }
 
         (void) memset(&chars, 0, sizeof (chars));
-        (void) memset(vers, 0, COLLATE_STR_LEN);
-        (void) strlcpy(vers, COLLATE_VERSION, sizeof (vers));
+        (void) memset(fmt_version, 0, COLLATE_FMT_VERSION_LEN);
+        (void) strlcpy(fmt_version, COLLATE_FMT_VERSION, sizeof (fmt_version));
+        (void) memset(def_version, 0, XLOCALE_DEF_VERSION_LEN);
+        if (version)
+                (void) strlcpy(def_version, version, sizeof (def_version));
 
         /*
          * We need to make sure we arrange for the UNDEFINED field
          * to show up.  Also, set the total weight counts.
          */
         for (i = 0; i < NUM_WT; i++) {
                 if (resolve_pri(pri_undefined[i]) == -1) {
                         set_pri(pri_undefined[i], -1, RESOLVED);
dump_collate(void)
 
         /* Time to write the entire data set out */
 
         for (i = 0; i < NUM_WT; i++)
                 collinfo.subst_count[i] = htote(subst_count[i]);
         collinfo.chain_count = htote(chain_count);
         collinfo.large_count = htote(large_count);
 
-        if ((wr_category(vers, COLLATE_STR_LEN, f) < 0) ||
+        if ((wr_category(fmt_version, COLLATE_FMT_VERSION_LEN, f) < 0) ||
+            (wr_category(def_version, XLOCALE_DEF_VERSION_LEN, f) < 0) ||
             (wr_category(&collinfo, sizeof (collinfo), f) < 0) ||
             (wr_category(&chars, sizeof (chars), f) < 0)) {
                 return;
         }
 
         for (i = 0; i < NUM_WT; i++) {
                 sz = sizeof (collate_subst_t) * subst_count[i];
                 if (wr_category(subst[i], sz, f) < 0) {

head/lib/libc/resolv/res_query.c

 {
         FILE                    *f;
         int                        i, j, n;
         size_t                  sz;
         int32_t                 pri;
         collelem_t              *ce;
         collchar_t              *cc;
         subst_t                 *sb;
-        char                    vers[COLLATE_STR_LEN];
+        char                        fmt_version[COLLATE_FMT_VERSION_LEN];
+        char                    def_version[XLOCALE_DEF_VERSION_LEN];
         collate_char_t                chars[UCHAR_MAX + 1];
         collate_large_t         *large;
         collate_subst_t         *subst[COLL_WEIGHTS_MAX];
         collate_chain_t         *chain;
 
         /*
          * We have to run through a preliminary pass to identify all the
          * weights that we use for each sorting level.
for (i = 0; i < NUM_WT; i++) {
                 weight_t *w;
                 RB_FOREACH(w, weights, &weights[i]) {
                         w->opt = nweight[i];
                         nweight[i] += 1;
                 }
         }
 
         (void) memset(&chars, 0, sizeof (chars));
-        (void) memset(vers, 0, COLLATE_STR_LEN);
-        (void) strlcpy(vers, COLLATE_VERSION, sizeof (vers));
+        (void) memset(fmt_version, 0, COLLATE_FMT_VERSION_LEN);
+        (void) strlcpy(fmt_version, COLLATE_FMT_VERSION, sizeof (fmt_version));
+        (void) memset(def_version, 0, XLOCALE_DEF_VERSION_LEN);
+        if (version)
+                (void) strlcpy(def_version, version, sizeof (def_version));
 
         /*
          * We need to make sure we arrange for the UNDEFINED field
          * to show up.  Also, set the total weight counts.
          */
         for (i = 0; i < NUM_WT; i++) {
                 if (resolve_pri(pri_undefined[i]) == -1) {
                         set_pri(pri_undefined[i], -1, RESOLVED);
dump_collate(void)
 
         /* Time to write the entire data set out */
 
         for (i = 0; i < NUM_WT; i++)
                 collinfo.subst_count[i] = htote(subst_count[i]);
         collinfo.chain_count = htote(chain_count);
         collinfo.large_count = htote(large_count);
 
-        if ((wr_category(vers, COLLATE_STR_LEN, f) < 0) ||
+        if ((wr_category(fmt_version, COLLATE_FMT_VERSION_LEN, f) < 0) ||
+            (wr_category(def_version, XLOCALE_DEF_VERSION_LEN, f) < 0) ||
             (wr_category(&collinfo, sizeof (collinfo), f) < 0) ||
             (wr_category(&chars, sizeof (chars), f) < 0)) {
                 return;
         }
 
         for (i = 0; i < NUM_WT; i++) {
                 sz = sizeof (collate_subst_t) * subst_count[i];
                 if (wr_category(subst[i], sz, f) < 0) {