 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.260 2021/04/02 15:06:35 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.261 2021/04/02 16:17:19 rillig Exp $	*/
 /*
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: tree.c,v 1.260 2021/04/02 15:06:35 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.261 2021/04/02 16:17:19 rillig Exp $");
 #endif
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 static	tnode_t	*expr_new_integer_constant(tspec_t, int64_t);
 @@ -685,27 +685,27 @@ build(op_t op, tnode_t *ln, tnode_t *rn)
 tnode_t *
 cconv(tnode_t *tn)
+{
 	type_t	*tp;
 	/*
 	 * Array-lvalue (array of type T) is converted into rvalue
 	 * (pointer to type T)
 	 */
 	if (tn->tn_type->t_tspec == ARRAY) {
 		if (!tn->tn_lvalue) {
 			/* XXX print correct operator */
 			/* %soperand of '%s' must be lvalue */
-			gnuism(114, "", modtab[ADDR].m_name);
+			gnuism(114, "", op_name(ADDR));
+		}
 		tn = new_tnode(ADDR,
 		    expr_derive_type(tn->tn_type->t_subt, PTR), tn, NULL);
+	}
 	/*
 	 * Expression of type function (function with return value of type T)
 	 * in rvalue-expression (pointer to function with return value
 	 * of type T)
 	 */
 	if (tn->tn_type->t_tspec == FUNC)
 		tn = build_address(tn, true);
 @@ -764,44 +764,44 @@ is_typeok_bool_operand(const tnode_t *tn
 	    tn->tn_left->tn_left->tn_type->t_tspec == ENUM &&
 	    /*
 	     * XXX: Somehow the type information got lost here.  The type
 	     * of the enum constant on the right-hand side should still be
 	     * ENUM, but is INT.
 	     */
 	    tn->tn_right->tn_type->t_tspec == INT)
 		return true;
 	return false;
+}
 static bool
-typeok_incdec(const mod_t *mp, const tnode_t *tn, const type_t *tp)
+typeok_incdec(op_t op, const tnode_t *tn, const type_t *tp)
+{
 	/* operand has scalar type (checked in typeok) */
 	if (!tn->tn_lvalue) {
 		if (tn->tn_op == CVT && tn->tn_cast &&
 		    tn->tn_left->tn_op == LOAD) {
 			if (tn->tn_type->t_tspec == PTR)
 				return true;
 			/* a cast does not yield an lvalue */
 			error(163);
+		}
 		/* %soperand of '%s' must be lvalue */
-		error(114, "", mp->m_name);
+		error(114, "", op_name(op));
 		return false;
 	} else if (tp->t_const) {
 		if (!tflag)
 			/* %soperand of '%s' must be modifiable lvalue */
-			warning(115, "", mp->m_name);
+			warning(115, "", op_name(op));
+	}
 	return true;
+}
 static bool
 typeok_address(const mod_t *mp,
 	    const tnode_t *tn, const type_t *tp, tspec_t t)
+{
 	if (t == ARRAY || t == FUNC) {
 		/* ok, a warning comes later (in build_address()) */
 	} else if (!tn->tn_lvalue) {
 		if (tn->tn_op == CVT && tn->tn_cast &&
 		    tn->tn_left->tn_op == LOAD) {
 @@ -1324,27 +1324,27 @@ typeok_op(op_t op, const mod_t *mp, int
 	case ARROW:
 		if (lt != PTR && !(tflag && is_integer(lt))) {
 			/* Without tflag we got already an error */
 			if (tflag)
 				/* unacceptable operand of '%s' */
 				error(111, mp->m_name);
 			return false;
+		}
 		break;
 	case INCAFT:
 	case DECAFT:
 	case INCBEF:
 	case DECBEF:
-		if (!typeok_incdec(mp, ln, ltp))
+		if (!typeok_incdec(op, ln, ltp))
 			return false;
 		break;
 	case ADDR:
 		if (!typeok_address(mp, ln, ltp, lt))
 			return false;
 		break;
 	case INDIR:
 		if (!typeok_star(lt))
 			return false;
 		break;
 	case PLUS:
 		if (!typeok_plus(op, ltp, lt, rtp, rt))
 			return false;
 @@ -2867,27 +2867,27 @@ build_colon(tnode_t *ln, tnode_t *rn)
 	 */
 	if (is_arithmetic(lt) && is_arithmetic(rt)) {
 		rtp = ln->tn_type;
 	} else if (lt == BOOL && rt == BOOL) {
 		rtp = ln->tn_type;
 	} else if (lt == VOID || rt == VOID) {
 		rtp = gettyp(VOID);
 	} else if (lt == STRUCT || lt == UNION) {
 		/* Both types must be identical. */
 		lint_assert(rt == STRUCT || rt == UNION);
 		lint_assert(ln->tn_type->t_str == rn->tn_type->t_str);
 		if (is_incomplete(ln->tn_type)) {
 			/* unknown operand size, op %s */
-			error(138, modtab[COLON].m_name);
+			error(138, op_name(COLON));
 			return NULL;
+		}
 		rtp = ln->tn_type;
 	} else if (lt == PTR && is_integer(rt)) {
 		if (rt != pdt) {
 			rn = convert(NOOP, 0, gettyp(pdt), rn);
 			rt = pdt;
+		}
 		rtp = ln->tn_type;
 	} else if (rt == PTR && is_integer(lt)) {
 		if (lt != pdt) {
 			ln = convert(NOOP, 0, gettyp(pdt), ln);
 			lt = pdt;
 @@ -3173,27 +3173,27 @@ fold(tnode_t *tn)
 		break;
 	case BITOR:
 		q = utyp ? (int64_t)(ul | ur) : sl | sr;
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
 	/* XXX does not work for quads. */
 	if (ovfl || ((uint64_t)(q | mask) != ~(uint64_t)0 &&
 	    (q & ~mask) != 0)) {
 		if (hflag)
 			/* integer overflow detected, op %s */
-			warning(141, modtab[tn->tn_op].m_name);
+			warning(141, op_name(tn->tn_op));
+	}
 	v->v_quad = xsign(q, t, -1);
 	cn = expr_new_constant(tn->tn_type, v);
 	if (tn->tn_left->tn_system_dependent)
 		cn->tn_system_dependent = true;
 	if (modtab[tn->tn_op].m_binary && tn->tn_right->tn_system_dependent)
 		cn->tn_system_dependent = true;
 	return cn;
+}
 @@ -3307,27 +3307,27 @@ fold_float(tnode_t *tn)
 		v->v_quad = l != r ? 1 : 0;
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
 	lint_assert(fpe != 0 || isnan((double)v->v_ldbl) == 0);
 	if (fpe != 0 || finite((double)v->v_ldbl) == 0 ||
 	    (t == FLOAT &&
 	     (v->v_ldbl > FLT_MAX || v->v_ldbl < -FLT_MAX)) ||
 	    (t == DOUBLE &&
 	     (v->v_ldbl > DBL_MAX || v->v_ldbl < -DBL_MAX))) {
 		/* floating point overflow detected, op %s */
-		warning(142, modtab[tn->tn_op].m_name);
+		warning(142, op_name(tn->tn_op));
 		if (t == FLOAT) {
 			v->v_ldbl = v->v_ldbl < 0 ? -FLT_MAX : FLT_MAX;
 		} else if (t == DOUBLE) {
 			v->v_ldbl = v->v_ldbl < 0 ? -DBL_MAX : DBL_MAX;
 		} else {
 			v->v_ldbl = v->v_ldbl < 0 ? -LDBL_MAX: LDBL_MAX;
+		}
 	    fpe = 0;
+	}
 	return expr_new_constant(tn->tn_type, v);
+}
 @@ -3868,27 +3868,27 @@ check_null_effect(const tnode_t *tn)
 /*
  * Dump an expression to stdout
  * only used for debugging
  */
 static void
 display_expression(const tnode_t *tn, int offs)
+{
 	uint64_t uq;
 	if (tn == NULL) {
 		(void)printf("%*s%s\n", offs, "", "NULL");
 		return;
+	}
-	(void)printf("%*sop %s  ", offs, "", modtab[tn->tn_op].m_name);
+	(void)printf("%*sop %s  ", offs, "", op_name(tn->tn_op));
 	if (tn->tn_op == NAME) {
 		(void)printf("%s: %s ",
 		    tn->tn_sym->s_name,
 		    storage_class_name(tn->tn_sym->s_scl));
 	} else if (tn->tn_op == CON && is_floating(tn->tn_type->t_tspec)) {
 		(void)printf("%#g ", (double)tn->tn_val->v_ldbl);
 	} else if (tn->tn_op == CON && is_integer(tn->tn_type->t_tspec)) {
 		uq = tn->tn_val->v_quad;
 		(void)printf("0x %08lx %08lx ",
 		    (long)(uq >> 32) & 0xffffffffl,
 		    (long)uq & 0xffffffffl);
 	} else if (tn->tn_op == CON) {
 @@ -4163,73 +4163,71 @@ check_array_index(tnode_t *tn, bool ampe
 	} else if (dim > 0 && (uint64_t)con >= (uint64_t)dim) {
 		/* array subscript cannot be > %d: %ld */
 		warning(168, dim - 1, (long)con);
+	}
+}
 /*
  * Check for ordered comparisons of unsigned values with 0.
  */
 static void
 check_integer_comparison(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	tspec_t	lt, rt;
 	const mod_t *mp;
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	mp = &modtab[op];
 	if (ln->tn_op != CON && rn->tn_op != CON)
 		return;
 	if (!is_integer(lt) || !is_integer(rt))
 		return;
 	if ((hflag || pflag) && lt == CHAR && rn->tn_op == CON &&
 	    (rn->tn_val->v_quad < 0 ||
 	     rn->tn_val->v_quad > (int)~(~0U << (CHAR_SIZE - 1)))) {
 		/* nonportable character comparison, op %s */
-		warning(230, mp->m_name);
+		warning(230, op_name(op));
 		return;
+	}
 	if ((hflag || pflag) && rt == CHAR && ln->tn_op == CON &&
 	    (ln->tn_val->v_quad < 0 ||
 	     ln->tn_val->v_quad > (int)~(~0U << (CHAR_SIZE - 1)))) {
 		/* nonportable character comparison, op %s */
-		warning(230, mp->m_name);
+		warning(230, op_name(op));
 		return;
+	}
 	if (is_uinteger(lt) && !is_uinteger(rt) &&
 	    rn->tn_op == CON && rn->tn_val->v_quad <= 0) {
 		if (rn->tn_val->v_quad < 0) {
 			/* comparison of %s with %s, op %s */
 			warning(162, type_name(ln->tn_type),
-			    "negative constant", mp->m_name);
+			    "negative constant", op_name(op));
 		} else if (op == LT || op == GE || (hflag && op == LE)) {
 			/* comparison of %s with %s, op %s */
-			warning(162, type_name(ln->tn_type), "0", mp->m_name);
+			warning(162, type_name(ln->tn_type), "0", op_name(op));
+		}
 		return;
+	}
 	if (is_uinteger(rt) && !is_uinteger(lt) &&
 	    ln->tn_op == CON && ln->tn_val->v_quad <= 0) {
 		if (ln->tn_val->v_quad < 0) {
 			/* comparison of %s with %s, op %s */
 			warning(162, "negative constant",
-			    type_name(rn->tn_type), mp->m_name);
+			    type_name(rn->tn_type), op_name(op));
 		} else if (op == GT || op == LE || (hflag && op == GE)) {
 			/* comparison of %s with %s, op %s */
-			warning(162, "0", type_name(rn->tn_type), mp->m_name);
+			warning(162, "0", type_name(rn->tn_type), op_name(op));
+		}
 		return;
+	}
+}
 /*
  * Return whether the expression can be used for static initialization.
+ *
  * Constant initialization expressions must be constant or an address
  * of a static object with an optional offset. In the first case,
  * the result is returned in *offsp. In the second case, the static
  * object is returned in *symp and the offset in *offsp.
+ *