warnings: rename ERR_WARN_* to WARN_*

The prefix ERR_WARN_ is unnecessarily long and may be a disincentive
to create new warning categories. Change it to WARN_*, it is still
plenty distinctive.

This is equivalent to nasm-2.14.xx checkin 77f53ba6d4cb90e5a7e09b33357ed7c1fe9f6b9d.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>

13 files changed, 73 insertions, 73 deletions

diff --git a/asm/assemble.c b/asm/assemble.c
index d32a67e2..10d9ec91 100644
--- a/asm/assemble.c
+++ b/asm/assemble.c
@@ -293,7 +293,7 @@ static const char *size_name(int size)
 
 static void warn_overflow(int size)
 {
-    nasm_warnf(ERR_PASS2 | ERR_WARN_NOV, "%s data exceeds bounds",
+    nasm_warnf(ERR_PASS2 | WARN_NOV, "%s data exceeds bounds",
                size_name(size));
 }
 
@@ -405,7 +405,7 @@ static void out(struct out_data *data)
             nasm_nonfatal("%u-bit signed relocation unsupported by output format %s",
                           (unsigned int)(asize << 3), ofmt->shortname);
         } else {
-            nasm_warnf(ERR_WARN_ZEXTRELOC,
+            nasm_warnf(WARN_ZEXTRELOC,
                        "%u-bit %s relocation zero-extended from %u bits",
                        (unsigned int)(asize << 3),
                        data->type == OUT_SEGMENT ? "segment" : "unsigned",
@@ -555,7 +555,7 @@ static bool jmp_match(int32_t segment, int64_t offset, int bits,
     if (is_byte && c == 0371 && ins->prefixes[PPS_REP] == P_BND) {
         /* jmp short (opcode eb) cannot be used with bnd prefix. */
         ins->prefixes[PPS_REP] = P_none;
-        nasm_warnf(ERR_WARN_BND | ERR_PASS2 ,
+        nasm_warnf(WARN_BND | ERR_PASS2 ,
                    "jmp short does not init bnd regs - bnd prefix dropped.");
     }
 
@@ -910,14 +910,14 @@ static void bad_hle_warn(const insn * ins, uint8_t hleok)
 
     case w_lock:
         if (ins->prefixes[PPS_LOCK] != P_LOCK) {
-            nasm_warnf(ERR_WARN_HLE | ERR_PASS2,
+            nasm_warnf(WARN_HLE | ERR_PASS2,
                        "%s with this instruction requires lock",
                        prefix_name(rep_pfx));
         }
         break;
 
     case w_inval:
-        nasm_warnf(ERR_WARN_HLE | ERR_PASS2,
+        nasm_warnf(WARN_HLE | ERR_PASS2,
                    "%s invalid with this instruction",
                    prefix_name(rep_pfx));
         break;
@@ -1398,7 +1398,7 @@ static int64_t calcsize(int32_t segment, int64_t offset, int bits,
 
     if (has_prefix(ins, PPS_LOCK, P_LOCK) && lockcheck &&
         (!itemp_has(temp,IF_LOCK) || !is_class(MEMORY, ins->oprs[0].type))) {
-        nasm_warnf(ERR_WARN_LOCK | ERR_PASS2 , "instruction is not lockable");
+        nasm_warnf(WARN_LOCK | ERR_PASS2 , "instruction is not lockable");
     }
 
     bad_hle_warn(ins, hleok);
@@ -1674,7 +1674,7 @@ static void gencode(struct out_data *data, insn *ins)
                 nasm_nonfatal("non-absolute expression not permitted "
                               "as argument %d", c & 7);
             else if (opy->offset & ~mask)
-                nasm_warnf(ERR_PASS2 | ERR_WARN_NOV,
+                nasm_warnf(ERR_PASS2 | WARN_NOV,
                            "is4 argument exceeds bounds");
             c = opy->offset & mask;
             goto emit_is4;
@@ -1696,7 +1696,7 @@ static void gencode(struct out_data *data, insn *ins)
         case4(0254):
             if (absolute_op(opx) &&
                 (int32_t)opx->offset != (int64_t)opx->offset) {
-                nasm_warnf(ERR_PASS2 | ERR_WARN_NOV,
+                nasm_warnf(ERR_PASS2 | WARN_NOV,
                            "signed dword immediate exceeds bounds");
             }
             out_imm(data, opx, 4, OUT_SIGNED);
@@ -1766,7 +1766,7 @@ static void gencode(struct out_data *data, insn *ins)
                     /* If this wasn't explicitly byte-sized, warn as though we
                      * had fallen through to the imm16/32/64 case.
                      */
-                    nasm_warnf(ERR_PASS2 | ERR_WARN_NOV,
+                    nasm_warnf(ERR_PASS2 | WARN_NOV,
                                "%s value exceeds bounds",
                                (opx->type & BITS8) ? "signed byte" :
                                s == 16 ? "word" :
diff --git a/asm/directiv.c b/asm/directiv.c
index 46ff7842..90b8b7b2 100644
--- a/asm/directiv.c
+++ b/asm/directiv.c
@@ -436,7 +436,7 @@ bool process_directives(char *directive)
 
     case D_WARNING:         /* [WARNING {+|-|*}warn-name] */
         if (!set_warning_status(value)) {
-            nasm_warnf(ERR_WARN_UNK_WARNING, "unknown warning option: %s", value);
+            nasm_warnf(WARN_UNK_WARNING, "unknown warning option: %s", value);
         }
         break;
 
diff --git a/asm/error.c b/asm/error.c
index 88e3a1b2..969bb28f 100644
--- a/asm/error.c
+++ b/asm/error.c
@@ -46,7 +46,7 @@
  * Description of the suppressible warnings for the command line and
  * the [warning] directive.
  */
-const struct warning warnings[ERR_WARN_ALL+1] = {
+const struct warning warnings[WARN_ALL+1] = {
 	{ "other",		"any warning not specifially mentioned below", true },
 	{ "macro-params",	"macro calls with wrong parameter count", true },
 	{ "macro-selfref",	"cyclic macro references", false },
@@ -76,8 +76,8 @@ const struct warning warnings[ERR_WARN_ALL+1] = {
 };
 
 /* Current state and command-line state, for reset */
-uint8_t warning_state[ERR_WARN_ALL];
-uint8_t warning_state_init[ERR_WARN_ALL];
+uint8_t warning_state[WARN_ALL];
+uint8_t warning_state_init[WARN_ALL];
 
 /* Global error handling function */
 vefunc nasm_verror;
@@ -190,7 +190,7 @@ bool set_warning_status(const char *value)
 		value = NULL;
 
 	/* This is inefficient, but it shouldn't matter... */
-	for (i = 0; i < ERR_WARN_ALL; i++) {
+	for (i = 0; i < WARN_ALL; i++) {
 		if (!value || !nasm_stricmp(value, warnings[i].name)) {
 			ok = true; /* At least one action taken */
 			switch (action) {
diff --git a/asm/float.c b/asm/float.c
index eaa6cd21..e857045b 100644
--- a/asm/float.c
+++ b/asm/float.c
@@ -232,7 +232,7 @@ static bool ieee_flconvert(const char *string, fp_limb *mant,
                     *p++ = *string - '0';
                 } else {
                     if (!warned) {
-                        nasm_warnf(ERR_WARN_FL_TOOLONG|ERR_PASS2,
+                        nasm_warnf(WARN_FL_TOOLONG|ERR_PASS2,
                                    "floating-point constant significand contains "
                                    "more than %i digits", MANT_DIGITS);
                         warned = true;
@@ -799,7 +799,7 @@ static int to_float(const char *str, int s, uint8_t *result,
                 type = FL_NORMAL;
             } else if (exponent > 0) {
                 if (pass0 == 1)
-                    nasm_warnf(ERR_WARN_FL_OVERFLOW|ERR_PASS2,
+                    nasm_warnf(WARN_FL_OVERFLOW|ERR_PASS2,
                                "overflow in floating-point constant");
                 type = FL_INFINITY;
             } else {
@@ -834,11 +834,11 @@ static int to_float(const char *str, int s, uint8_t *result,
         } else {
             if (daz || is_zero(mant)) {
                 /* Flush denormals to zero */
-                nasm_warnf(ERR_WARN_FL_UNDERFLOW|ERR_PASS2,
+                nasm_warnf(WARN_FL_UNDERFLOW|ERR_PASS2,
                            "underflow in floating-point constant");
                 goto zero;
             } else
-                nasm_warnf(ERR_WARN_FL_DENORM|ERR_PASS2,
+                nasm_warnf(WARN_FL_DENORM|ERR_PASS2,
                            "denormal floating-point constant");
         }
         break;
@@ -853,7 +853,7 @@ static int to_float(const char *str, int s, uint8_t *result,
             ieee_shr(mant, 1);
             exponent++;
             if (exponent >= (expmax << 1)-1) {
-                    nasm_warnf(ERR_WARN_FL_OVERFLOW|ERR_PASS2,
+                    nasm_warnf(WARN_FL_OVERFLOW|ERR_PASS2,
                                "overflow in floating-point constant");
                 type = FL_INFINITY;
                 goto overflow;
diff --git a/asm/nasm.c b/asm/nasm.c
index 0517697d..a8d10783 100644
--- a/asm/nasm.c
+++ b/asm/nasm.c
@@ -203,7 +203,7 @@ nasm_set_limit(const char *limit, const char *valstr)
         if (passn == 0)
             errlevel = ERR_WARNING|ERR_USAGE;
         else
-            errlevel = ERR_WARNING|ERR_PASS1|ERR_WARN_UNKNOWN_PRAGMA;
+            errlevel = ERR_WARNING|ERR_PASS1|WARN_UNKNOWN_PRAGMA;
         nasm_error(errlevel, "unknown limit: `%s'", limit);
         return DIRR_ERROR;
     }
@@ -216,7 +216,7 @@ nasm_set_limit(const char *limit, const char *valstr)
             if (passn == 0)
                 errlevel = ERR_WARNING|ERR_USAGE;
             else
-                errlevel = ERR_WARNING|ERR_PASS1|ERR_WARN_BAD_PRAGMA;
+                errlevel = ERR_WARNING|ERR_PASS1|WARN_BAD_PRAGMA;
             nasm_error(errlevel, "invalid limit value: `%s'", limit);
             return DIRR_ERROR;
         }
@@ -1043,7 +1043,7 @@ static bool process_arg(char *p, char *q, int pass)
         case 'W':
             if (pass == 2) {
                 if (!set_warning_status(param)) {
-                    nasm_warnf(ERR_WARN_UNK_WARNING, "unknown warning option: %s", param);
+                    nasm_warnf(WARN_UNK_WARNING, "unknown warning option: %s", param);
                 }
             }
         break;
@@ -1327,7 +1327,7 @@ static void parse_cmdline(int argc, char **argv, int pass)
     int i;
 
     /* Initialize all the warnings to their default state */
-    for (i = 0; i < ERR_WARN_ALL; i++) {
+    for (i = 0; i < WARN_ALL; i++) {
         warning_state_init[i] = warning_state[i] =
 	    warnings[i].enabled ? WARN_ST_ENABLED : 0;
     }
@@ -1641,7 +1641,7 @@ static void assemble_file(const char *fname, struct strlist *depend_list)
         if (global_offset_changed && !terminate_after_phase) {
             switch (pass0) {
             case 1:
-                nasm_warnf(ERR_WARN_PHASE, "phase error during stabilization pass, hoping for the best");
+                nasm_warnf(WARN_PHASE, "phase error during stabilization pass, hoping for the best");
                 break;
 
             case 2:
@@ -1707,7 +1707,7 @@ static inline bool is_valid_warning(int severity)
     if ((severity & ERR_MASK) != ERR_WARNING)
         return false;
 
-    return WARN_IDX(severity) < ERR_WARN_ALL;
+    return WARN_IDX(severity) < WARN_ALL;
 }
 
 /**
@@ -1771,7 +1771,7 @@ static void nasm_verror_asm(int severity, const char *fmt, va_list args)
     char linestr[64];
     const char *pfx;
     bool warn_is_err = warning_is_error(severity);
-    bool warn_is_other = WARN_IDX(severity) == ERR_WARN_OTHER;
+    bool warn_is_other = WARN_IDX(severity) == WARN_OTHER;
     const char *currentfile = NULL;
     int32_t lineno = 0;
 
@@ -1995,10 +1995,10 @@ static void help(const char xopt)
 
     printf("\nWarnings for the -W/-w options:\n");
 
-    for (i = 0; i <= ERR_WARN_ALL; i++)
+    for (i = 0; i <= WARN_ALL; i++)
         printf("    %-23s %s%s\n",
                warnings[i].name, warnings[i].help,
-               i == ERR_WARN_ALL ? "\n" :
+               i == WARN_ALL ? "\n" :
                warnings[i].enabled ? " (default on)" :
                " (default off)");
 
diff --git a/asm/parser.c b/asm/parser.c
index 8f081986..dbfb11cb 100644
--- a/asm/parser.c
+++ b/asm/parser.c
@@ -463,7 +463,7 @@ restart_parse:
         if (i == ':') {         /* skip over the optional colon */
             i = stdscan(NULL, &tokval);
         } else if (i == 0) {
-            nasm_warnf(ERR_WARN_OL | ERR_PASS1,
+            nasm_warnf(WARN_OL | ERR_PASS1,
                        "label alone on a line without a colon might be in error");
         }
         if (i != TOKEN_INSN || tokval.t_integer != I_EQU) {
diff --git a/asm/pragma.c b/asm/pragma.c
index a4e76094..85e8c9cd 100644
--- a/asm/pragma.c
+++ b/asm/pragma.c
@@ -146,11 +146,11 @@ found_it:
     case DIRR_UNKNOWN:
         switch (pragma->opcode) {
         case D_none:
-            nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_BAD_PRAGMA,
+            nasm_error(ERR_WARNING|ERR_PASS2|WARN_BAD_PRAGMA,
                        "empty %%pragma %s", pragma->facility_name);
             break;
         default:
-            nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_UNKNOWN_PRAGMA,
+            nasm_error(ERR_WARNING|ERR_PASS2|WARN_UNKNOWN_PRAGMA,
                        "unknown %%pragma %s %s",
                        pragma->facility_name, pragma->opname);
             break;
@@ -185,7 +185,7 @@ void process_pragma(char *str)
 
     pragma.facility_name = nasm_get_word(str, &p);
     if (!pragma.facility_name) {
-	nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_BAD_PRAGMA,
+	nasm_error(ERR_WARNING|ERR_PASS2|WARN_BAD_PRAGMA,
 		   "empty pragma directive");
         return;                 /* Empty pragma */
     }
diff --git a/asm/preproc.c b/asm/preproc.c
index 9d16d539..314a2013 100644
--- a/asm/preproc.c
+++ b/asm/preproc.c
@@ -2133,7 +2133,7 @@ static bool parse_mmacro_spec(Token *tline, MMacro *def, const char *directive)
 
     if (def->defaults && def->ndefs > def->nparam_max - def->nparam_min &&
         !def->plus)
-        nasm_warnf(ERR_PASS1|ERR_WARN_MDP, "too many default macro parameters in macro `%s'", def->name);
+        nasm_warnf(ERR_PASS1|WARN_MDP, "too many default macro parameters in macro `%s'", def->name);
 
     return true;
 }
@@ -2655,7 +2655,7 @@ static int do_directive(Token *tline, char **output)
         severity = ERR_NONFATAL;
         goto issue_error;
     case PP_WARNING:
-        severity = ERR_WARNING|ERR_WARN_USER;
+        severity = ERR_WARNING|WARN_USER;
         goto issue_error;
 
 issue_error:
@@ -2966,7 +2966,7 @@ issue_error:
                               count, nasm_limit[LIMIT_REP]);
                 count = 0;
             } else if (count < 0) {
-                nasm_warnf(ERR_PASS2|ERR_WARN_NEG_REP,
+                nasm_warnf(ERR_PASS2|WARN_NEG_REP,
                            "negative `%%rep' count: %"PRId64, count);
                 count = 0;
             } else {
@@ -4285,7 +4285,7 @@ again:
                                              m->casesense)))
                             m = m->next;
                         if (!m)
-                            nasm_warnf(ERR_PASS1|ERR_WARN_MNP,
+                            nasm_warnf(ERR_PASS1|WARN_MNP,
                                        "macro `%s' exists, "
                                        "but not taking %d parameters",
                                        mstart->text, nparam);
@@ -4585,7 +4585,7 @@ static MMacro *is_mmacro(Token * tline, Token *** params_array)
      * After all that, we didn't find one with the right number of
      * parameters. Issue a warning, and fail to expand the macro.
      */
-    nasm_warnf(ERR_PASS1|ERR_WARN_MNP,
+    nasm_warnf(ERR_PASS1|WARN_MNP,
                "macro `%s' exists, but not taking %d parameters",
                tline->text, nparam);
     nasm_free(params);
diff --git a/asm/stdscan.c b/asm/stdscan.c
index 9194a925..b197b27f 100644
--- a/asm/stdscan.c
+++ b/asm/stdscan.c
@@ -167,7 +167,7 @@ int stdscan(void *private_data, struct tokenval *tv)
         token_type = nasm_token_hash(ourcopy, tv);
 
         if (unlikely(tv->t_flag & TFLAG_WARN)) {
-            nasm_warnf(ERR_PASS1|ERR_WARN_PTR, "`%s' is not a NASM keyword",
+            nasm_warnf(ERR_PASS1|WARN_PTR, "`%s' is not a NASM keyword",
                        tv->t_charptr);
         }
 
diff --git a/include/error.h b/include/error.h
index 18b2bed7..db3e0785 100644
--- a/include/error.h
+++ b/include/error.h
@@ -96,53 +96,53 @@ static inline vefunc nasm_set_verror(vefunc ve)
  * These codes define specific types of suppressible warning.
  */
 
-#define ERR_WARN_MASK		0xFFFFF000	/* the mask for this feature */
-#define ERR_WARN_SHR		12		/* how far to shift right */
+#define WARN_MASK		0xFFFFF000	/* the mask for this feature */
+#define WARN_SHR		12		/* how far to shift right */
 
-#define WARN(x)			((x) << ERR_WARN_SHR)
-#define WARN_IDX(x)		(((x) & ERR_WARN_MASK) >> ERR_WARN_SHR)
+#define WARN(x)			((x) << WARN_SHR)
+#define WARN_IDX(x)		(((x) & WARN_MASK) >> WARN_SHR)
 
-#define ERR_WARN_OTHER		WARN( 0) /* any noncategorized warning */
-#define ERR_WARN_MNP		WARN( 1) /* macro-num-parameters warning */
-#define ERR_WARN_MSR		WARN( 2) /* macro self-reference */
-#define ERR_WARN_MDP		WARN( 3) /* macro default parameters check */
-#define ERR_WARN_OL		WARN( 4) /* orphan label (no colon, and
+#define WARN_OTHER		WARN( 0) /* any noncategorized warning */
+#define WARN_MNP		WARN( 1) /* macro-num-parameters warning */
+#define WARN_MSR		WARN( 2) /* macro self-reference */
+#define WARN_MDP		WARN( 3) /* macro default parameters check */
+#define WARN_OL		WARN( 4) /* orphan label (no colon, and
                                           * alone on line) */
-#define ERR_WARN_NOV		WARN( 5) /* numeric overflow */
-#define ERR_WARN_GNUELF		WARN( 6) /* using GNU ELF extensions */
-#define ERR_WARN_FL_OVERFLOW	WARN( 7) /* FP overflow */
-#define ERR_WARN_FL_DENORM	WARN( 8) /* FP denormal */
-#define ERR_WARN_FL_UNDERFLOW	WARN( 9) /* FP underflow */
-#define ERR_WARN_FL_TOOLONG	WARN(10) /* FP too many digits */
-#define ERR_WARN_USER		WARN(11) /* %warning directives */
-#define ERR_WARN_LOCK		WARN(12) /* bad LOCK prefixes */
-#define ERR_WARN_HLE		WARN(13) /* bad HLE prefixes */
-#define ERR_WARN_BND		WARN(14) /* bad BND prefixes */
-#define ERR_WARN_ZEXTRELOC	WARN(15) /* relocation zero-extended */
-#define ERR_WARN_PTR		WARN(16) /* not a NASM keyword */
-#define ERR_WARN_BAD_PRAGMA	WARN(17) /* malformed pragma */
-#define ERR_WARN_UNKNOWN_PRAGMA	WARN(18) /* unknown pragma */
-#define ERR_WARN_NOTMY_PRAGMA	WARN(19) /* pragma inapplicable */
-#define ERR_WARN_UNK_WARNING	WARN(20) /* unknown warning */
-#define ERR_WARN_NEG_REP	WARN(21) /* negative repeat count */
-#define ERR_WARN_PHASE		WARN(22) /* phase error in pass 1 */
+#define WARN_NOV		WARN( 5) /* numeric overflow */
+#define WARN_GNUELF		WARN( 6) /* using GNU ELF extensions */
+#define WARN_FL_OVERFLOW	WARN( 7) /* FP overflow */
+#define WARN_FL_DENORM	WARN( 8) /* FP denormal */
+#define WARN_FL_UNDERFLOW	WARN( 9) /* FP underflow */
+#define WARN_FL_TOOLONG	WARN(10) /* FP too many digits */
+#define WARN_USER		WARN(11) /* %warning directives */
+#define WARN_LOCK		WARN(12) /* bad LOCK prefixes */
+#define WARN_HLE		WARN(13) /* bad HLE prefixes */
+#define WARN_BND		WARN(14) /* bad BND prefixes */
+#define WARN_ZEXTRELOC	WARN(15) /* relocation zero-extended */
+#define WARN_PTR		WARN(16) /* not a NASM keyword */
+#define WARN_BAD_PRAGMA	WARN(17) /* malformed pragma */
+#define WARN_UNKNOWN_PRAGMA	WARN(18) /* unknown pragma */
+#define WARN_NOTMY_PRAGMA	WARN(19) /* pragma inapplicable */
+#define WARN_UNK_WARNING	WARN(20) /* unknown warning */
+#define WARN_NEG_REP	WARN(21) /* negative repeat count */
+#define WARN_PHASE		WARN(22) /* phase error in pass 1 */
 
 /* The "all" warning acts as a global switch, it must come last */
-#define ERR_WARN_ALL		23 /* Do not use WARN() here */
+#define WARN_ALL		23 /* Do not use WARN() here */
 
 struct warning {
 	const char	*name;
 	const char	*help;
 	bool		enabled;
 };
-extern const struct warning warnings[ERR_WARN_ALL+1];
+extern const struct warning warnings[WARN_ALL+1];
 
 /* This is a bitmask */
 #define WARN_ST_ENABLED		1 /* Warning is currently enabled */
 #define WARN_ST_ERROR		2 /* Treat this warning as an error */
 
-extern uint8_t warning_state[ERR_WARN_ALL];
-extern uint8_t warning_state_init[ERR_WARN_ALL];
+extern uint8_t warning_state[WARN_ALL];
+extern uint8_t warning_state_init[WARN_ALL];
 
 /* Process a warning option or directive */
 bool set_warning_status(const char *value);
diff --git a/nasmlib/readnum.c b/nasmlib/readnum.c
index 47080884..60d856e1 100644
--- a/nasmlib/readnum.c
+++ b/nasmlib/readnum.c
@@ -164,7 +164,7 @@ int64_t readnum(const char *str, bool *error)
     }
 
     if (warn)
-        nasm_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
+        nasm_error(ERR_WARNING | ERR_PASS1 | WARN_NOV,
 		   "numeric constant %s does not fit in 64 bits",
 		   str);
 
diff --git a/output/outdbg.c b/output/outdbg.c
index a318f921..b5496b98 100644
--- a/output/outdbg.c
+++ b/output/outdbg.c
@@ -375,7 +375,7 @@ dbg_pragma(const struct pragma *pragma)
                 errno = 0;
                 arg = strtoul(pragma->tail, &ep, 0);
                 if (errno || *nasm_skip_spaces(ep)) {
-                    nasm_error(ERR_WARNING | ERR_WARN_BAD_PRAGMA | ERR_PASS2,
+                    nasm_error(ERR_WARNING | WARN_BAD_PRAGMA | ERR_PASS2,
                                "invalid %%pragma dbg maxdump argument");
                     return DIRR_ERROR;
                 } else {
diff --git a/output/outelf.c b/output/outelf.c
index 3fe76810..2ac8eb44 100644
--- a/output/outelf.c
+++ b/output/outelf.c
@@ -919,7 +919,7 @@ static void elf32_out(int32_t segto, const void *data,
         }
 
         if (gnu16) {
-            nasm_warnf(ERR_WARN_GNUELF, "8- or 16-bit relocations "
+            nasm_warnf(WARN_GNUELF, "8- or 16-bit relocations "
                        "in ELF32 is a GNU extension");
         } else if (asize != 4 && segment != NO_SEG) {
             nasm_nonfatal("Unsupported non-32-bit ELF relocation");
@@ -945,7 +945,7 @@ rel12adr:
                           " segment base references");
         } else {
             if (wrt == NO_SEG) {
-                nasm_warnf(ERR_WARN_GNUELF, "8- or 16-bit relocations "
+                nasm_warnf(WARN_GNUELF, "8- or 16-bit relocations "
                            "in ELF is a GNU extension");
                 elf_add_reloc(s, segment, 0, reltype);
             } else {