 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.171 2021/01/17 15:06:54 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.172 2021/01/17 15:24:03 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.171 2021/01/17 15:06:54 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.172 2021/01/17 15:24:03 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	*new_integer_constant_node(tspec_t, int64_t);
 @@ -524,34 +524,34 @@ build(op_t op, tnode_t *ln, tnode_t *rn)
 	 * Print some warnings for comparisons of unsigned values with
 	 * constants lower than or equal to null. This must be done
 	 * before promote() because otherwise unsigned char and unsigned
 	 * short would be promoted to int. Also types are tested to be
 	 * CHAR, which would also become int.
 	 */
 	if (mp->m_comparison)
 		check_integer_comparison(op, ln, rn);
 	/*
 	 * Promote the left operand if it is in a test or value context
 	 */
 	if (mp->m_left_value_context || mp->m_left_test_context)
-		ln = promote(op, 0, ln);
+		ln = promote(op, false, ln);
 	/*
 	 * Promote the right operand, but only if it is no struct or
 	 * union member, or if it is not to be assigned to the left operand
 	 */
 	if (mp->m_binary && op != ARROW && op != POINT &&
 	    op != ASSIGN && op != RETURN) {
-		rn = promote(op, 0, rn);
+		rn = promote(op, false, rn);
+	}
 	/*
 	 * If the result of the operation is different for signed or
 	 * unsigned operands and one of the operands is signed only in
 	 * ANSI C, print a warning.
 	 */
 	if (mp->m_warn_if_left_unsigned_in_c90 &&
 	    ln->tn_op == CON && ln->tn_val->v_ansiu) {
 		/* ANSI C treats constant as unsigned, op %s */
 		warning(218, mp->m_name);
 		ln->tn_val->v_ansiu = false;
+	}
 @@ -576,27 +576,27 @@ build(op_t op, tnode_t *ln, tnode_t *rn)
 	/* And now create the node. */
 	switch (op) {
 	case POINT:
 	case ARROW:
 		ntn = build_struct_access(op, ln, rn);
 		break;
 	case INCAFT:
 	case DECAFT:
 	case INCBEF:
 	case DECBEF:
 		ntn = build_prepost_incdec(op, ln);
 		break;
 	case ADDR:
-		ntn = build_address(ln, 0);
+		ntn = build_address(ln, false);
 		break;
 	case INDIR:
 		ntn = new_tnode(INDIR, ln->tn_type->t_subt, ln, NULL);
 		break;
 	case PLUS:
 	case MINUS:
 		ntn = build_plus_minus(op, ln, rn);
 		break;
 	case SHL:
 	case SHR:
 		ntn = build_bit_shift(op, ln, rn);
 		break;
 	case COLON:
 @@ -694,27 +694,27 @@ cconv(tnode_t *tn)
 			/* %soperand of '%s' must be lvalue */
 			gnuism(114, "", modtab[ADDR].m_name);
+		}
 		tn = new_tnode(ADDR, tincref(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, 1);
+		tn = build_address(tn, true);
 	/* lvalue to rvalue */
 	if (tn->tn_lvalue) {
 		tp = tduptyp(tn->tn_type);
 		tp->t_const = tp->t_volatile = false;
 		tn = new_tnode(LOAD, tp, tn, NULL);
+	}
 	return tn;
+}
 static const tnode_t *
 before_conversion(const tnode_t *tn)
 @@ -838,27 +838,27 @@ static bool
 typeok_minus(op_t op,
 	     const type_t *ltp, tspec_t lt,
 	     const type_t *rtp, tspec_t rt)
+{
 	/* operands have scalar types (checked above) */
 	if (lt == PTR && (!is_integer(rt) && rt != PTR)) {
 		warn_incompatible_types(op, lt, rt);
 		return false;
 	} else if (rt == PTR && lt != PTR) {
 		warn_incompatible_types(op, lt, rt);
 		return false;
+	}
 	if (lt == PTR && rt == PTR) {
-		if (!eqtype(ltp->t_subt, rtp->t_subt, 1, 0, NULL)) {
+		if (!eqtype(ltp->t_subt, rtp->t_subt, true, false, NULL)) {
 			/* illegal pointer subtraction */
 			error(116);
+		}
+	}
 	return true;
+}
 static void
 typeok_shr(const mod_t *mp,
 	   const tnode_t *ln, tspec_t lt,
 	   const tnode_t *rn, tspec_t rt)
+{
 	tspec_t olt, ort;
 @@ -1046,29 +1046,29 @@ typeok_colon(const mod_t *mp,
+	}
 	if (lt == PTR && rt == PTR && ((lst == VOID && rst == FUNC) ||
 				       (lst == FUNC && rst == VOID))) {
 		/* (void *)0 handled above */
 		if (sflag)
 			/* ANSI C forbids conv. of %s to %s, op %s */
 			warning(305, "function pointer", "'void *'",
 			    mp->m_name);
 		return true;
+	}
 	if (rt == PTR && lt == PTR) {
-		if (eqptrtype(lstp, rstp, 1))
+		if (eqptrtype(lstp, rstp, true))
 			return true;
-		if (!eqtype(lstp, rstp, 1, 0, NULL))
+		if (!eqtype(lstp, rstp, true, false, NULL))
 			warn_incompatible_pointers(mp, ltp, rtp);
 		return true;
+	}
 	/* incompatible types in conditional */
 	error(126);
 	return false;
+}
 static bool
 typeok_assign(const mod_t *mp, const tnode_t *ln, const type_t *ltp, tspec_t lt)
+{
 	if (!ln->tn_lvalue) {
 @@ -1465,27 +1465,27 @@ check_pointer_comparison(op_t op, const
 	rt = (rtp = rn->tn_type)->t_subt->t_tspec;
 	if (lt == VOID || rt == VOID) {
 		if (sflag && (lt == FUNC || rt == FUNC)) {
 			/* (void *)0 already handled in typeok() */
 			*(lt == FUNC ? &lts : &rts) = "function pointer";
 			*(lt == VOID ? &lts : &rts) = "'void *'";
 			/* ANSI C forbids comparison of %s with %s */
 			warning(274, lts, rts);
+		}
 		return;
+	}
-	if (!eqtype(ltp->t_subt, rtp->t_subt, 1, 0, NULL)) {
+	if (!eqtype(ltp->t_subt, rtp->t_subt, true, false, NULL)) {
 		warn_incompatible_pointers(&modtab[op], ltp, rtp);
 		return;
+	}
 	if (lt == FUNC && rt == FUNC) {
 		if (sflag && op != EQ && op != NE)
 			/* ANSI C forbids ordered comparisons of ... */
 			warning(125);
+	}
+}
 /*
  * Checks type compatibility for ASSIGN, INIT, FARG and RETURN
 @@ -1538,27 +1538,27 @@ check_assign_types_compatible(op_t op, i
 			case FARG:
 				/* ANSI C forbids conv. of %s to %s, arg #%d */
 				warning(304, rts, lts, arg);
 				break;
 			default:
 				/* ANSI C forbids conv. of %s to %s, op %s */
 				warning(305, rts, lts, mp->m_name);
 				break;
+			}
+		}
+	}
 	if (lt == PTR && rt == PTR && (lst == VOID || rst == VOID ||
-				       eqtype(lstp, rstp, 1, 0, NULL))) {
+				       eqtype(lstp, rstp, true, false, NULL))) {
 		/* compatible pointer types (qualifiers ignored) */
 		if (!tflag &&
 		    ((!lstp->t_const && rstp->t_const) ||
 		     (!lstp->t_volatile && rstp->t_volatile))) {
 			/* left side has not all qualifiers of right */
 			switch (op) {
 			case INIT:
 			case RETURN:
 				/* incompatible pointer types (%s != %s) */
 				warning(182, type_name(lstp), type_name(rstp));
 				break;
 			case FARG:
 				/* argument has incompatible pointer type... */
 @@ -2042,27 +2042,27 @@ check_prototype_conversion(int arg, tspe
 	if (!is_arithmetic(nt) || !is_arithmetic(ot))
 		return;
 	/*
 	 * If the type of the formal parameter is char/short, a warning
 	 * would be useless, because functions declared the old style
 	 * can't expect char/short arguments.
 	 */
 	if (nt == CHAR || nt == UCHAR || nt == SHORT || nt == USHORT)
 		return;
 	/* get default promotion */
-	ptn = promote(NOOP, 1, tn);
+	ptn = promote(NOOP, true, tn);
 	ot = ptn->tn_type->t_tspec;
 	/* return if types are the same with and without prototype */
 	if (nt == ot || (nt == ENUM && ot == INT))
 		return;
 	if (is_floating(nt) != is_floating(ot) ||
 	    psize(nt) != psize(ot)) {
 		/* representation and/or width change */
 		if (!is_integer(ot) || psize(ot) > psize(INT)) {
 			/* conversion to '%s' due to prototype, arg #%d */
 			warning(259, type_name(tp), arg);
+		}
 @@ -2604,27 +2604,27 @@ build_struct_access(op_t op, tnode_t *ln
 	bool	nolval;
 	lint_assert(rn->tn_op == NAME);
 	lint_assert(rn->tn_sym->s_value.v_tspec == INT);
 	lint_assert(rn->tn_sym->s_scl == MOS || rn->tn_sym->s_scl == MOU);
 	/*
 	 * Remember if the left operand is an lvalue (structure members
 	 * are lvalues if and only if the structure itself is an lvalue).
 	 */
 	nolval = op == POINT && !ln->tn_lvalue;
 	if (op == POINT) {
-		ln = build_address(ln, 1);
+		ln = build_address(ln, true);
 	} else if (ln->tn_type->t_tspec != PTR) {
 		lint_assert(tflag);
 		lint_assert(is_integer(ln->tn_type->t_tspec));
 		ln = convert(NOOP, 0, tincref(gettyp(VOID), PTR), ln);
+	}
 #if PTRDIFF_IS_LONG
 	ctn = new_integer_constant_node(LONG,
 	    rn->tn_sym->s_value.v_quad / CHAR_SIZE);
 #else
 	ctn = new_integer_constant_node(INT,
 	    rn->tn_sym->s_value.v_quad / CHAR_SIZE);
 #endif
 @@ -3250,28 +3250,28 @@ fold_float(tnode_t *tn)
 	case GT:
 		v->v_quad = (l > r) ? 1 : 0;
 		break;
 	case EQ:
 		v->v_quad = (l == r) ? 1 : 0;
 		break;
 	case NE:
 		v->v_quad = (l != r) ? 1 : 0;
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
-	lint_assert(fpe != 0 || isnan((double)v->v_ldbl) == false);
+	lint_assert(fpe != 0 || isnan((double)v->v_ldbl) == 0);
-	if (fpe != 0 || finite((double)v->v_ldbl) == false ||
+	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);
 		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;
+		}
 @@ -3624,27 +3624,27 @@ check_function_arguments(type_t *ftp, tn
 			   arg->tn_left->tn_type->t_isenum &&
 			   incompl(arg->tn_left->tn_type)) {
 			/* argument cannot have unknown size, arg #%d */
 			warning(152, n);
+		}
 		/* class conversions (arg in value context) */
 		arg->tn_left = cconv(arg->tn_left);
 		if (asym != NULL) {
 			arg->tn_left = check_prototype_argument(
 			    n, asym->s_type, arg->tn_left);
 		} else {
-			arg->tn_left = promote(NOOP, 1, arg->tn_left);
+			arg->tn_left = promote(NOOP, true, arg->tn_left);
+		}
 		arg->tn_type = arg->tn_left->tn_type;
 		if (asym != NULL)
 			asym = asym->s_next;
+	}
 	return args;
+}
 /*
  * Compare the type of an argument with the corresponding type of a
  * prototype parameter. If it is a valid combination, but both types
 @@ -3676,27 +3676,27 @@ check_prototype_argument(
 /*
  * Return the value of an integral constant expression.
  * If the expression is not constant or its type is not an integer
  * type, an error message is printed.
  */
 val_t *
 constant(tnode_t *tn, bool required)
+{
 	val_t	*v;
 	if (tn != NULL)
 		tn = cconv(tn);
 	if (tn != NULL)
-		tn = promote(NOOP, 0, tn);
+		tn = promote(NOOP, false, tn);
 	v = xcalloc(1, sizeof (val_t));
 	if (tn == NULL) {
 		lint_assert(nerr != 0);
 		if (dflag)
 			printf("constant node is null; returning 1 instead\n");
 		v->v_tspec = INT;
 		v->v_quad = 1;
 		return v;
+	}
 	v->v_tspec = tn->tn_type->t_tspec;
 @@ -3739,27 +3739,27 @@ expr(tnode_t *tn, bool vctx, bool tctx,
+{
 	lint_assert(tn != NULL || nerr != 0);
 	if (tn == NULL) {
 		tfreeblk();
 		return;
+	}
 	/* expr() is also called in global initialisations */
 	if (dcs->d_ctx != EXTERN)
 		check_statement_reachable();
-	check_expr_misc(tn, vctx, tctx, !tctx, 0, 0, 0);
+	check_expr_misc(tn, vctx, tctx, !tctx, false, false, false);
 	if (tn->tn_op == ASSIGN) {
 		if (hflag && tctx)
 			/* assignment in conditional context */
 			warning(159);
 	} else if (tn->tn_op == CON) {
 		if (hflag && tctx && !constcond_flag)
 			/* constant in conditional context */
 			warning(161);
+	}
 	if (!modtab[tn->tn_op].m_has_side_effect) {
 		/*
 		 * for left operands of COMMA this warning is already
 		 * printed
 @@ -3896,32 +3896,32 @@ check_expr_misc(const tnode_t *tn, bool
 	ln = tn->tn_left;
 	rn = tn->tn_right;
 	mp = &modtab[op = tn->tn_op];
 	switch (op) {
 	case ADDR:
 		if (ln->tn_op == NAME && (reached || rchflg)) {
 			if (!szof)
 				mark_as_set(ln->tn_sym);
 			mark_as_used(ln->tn_sym, fcall, szof);
+		}
 		if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS)
 			/* check the range of array indices */
-			check_array_index(ln->tn_left, 1);
+			check_array_index(ln->tn_left, true);
 		break;
 	case LOAD:
 		if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS)
 			/* check the range of array indices */
-			check_array_index(ln->tn_left, 0);
+			check_array_index(ln->tn_left, false);
 		/* FALLTHROUGH */
 	case PUSH:
 	case INCBEF:
 	case DECBEF:
 	case INCAFT:
 	case DECAFT:
 	case ADDASS:
 	case SUBASS:
 	case MULASS:
 	case DIVASS:
 	case MODASS:
 	case ANDASS:
 	case ORASS:
 @@ -3937,38 +3937,38 @@ check_expr_misc(const tnode_t *tn, bool
 			 * compound statements we are in. If not, we don't
 			 * print a warning.
 			 */
 			for (di = dcs; di != NULL; di = di->d_next) {
 				if (di->d_asm)
 					break;
+			}
 			if (sc != EXTERN && sc != STATIC &&
 			    !ln->tn_sym->s_set && !szof && di == NULL) {
 				/* %s may be used before set */
 				warning(158, ln->tn_sym->s_name);
 				mark_as_set(ln->tn_sym);
+			}
-			mark_as_used(ln->tn_sym, 0, 0);
+			mark_as_used(ln->tn_sym, false, false);
+		}
 		break;
 	case ASSIGN:
 		if (ln->tn_op == NAME && !szof && (reached || rchflg)) {
 			mark_as_set(ln->tn_sym);
 			if (ln->tn_sym->s_scl == EXTERN)
 				outusg(ln->tn_sym);
+		}
 		if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS)
 			/* check the range of array indices */
-			check_array_index(ln->tn_left, 0);
+			check_array_index(ln->tn_left, false);
 		break;
 	case CALL:
 		lint_assert(ln->tn_op == ADDR);
 		lint_assert(ln->tn_left->tn_op == NAME);
 		if (!szof)
 			outcall(tn, vctx || tctx, rvdisc);
 		break;
 	case EQ:
 		if (hflag && eqwarn)
 			/* operator '==' found where '=' was expected */
 			warning(160);
 		break;
 	case CON:
 @@ -4022,41 +4022,41 @@ check_expr_misc(const tnode_t *tn, bool
 	 * values of operands of ':' are not used if the type of at least
 	 * one of the operands (for gcc compatibility) is void
 	 * XXX test/value context of QUEST should probably be used as
 	 * context for both operands of COLON
 	 */
 	if (op == COLON && tn->tn_type->t_tspec == VOID)
 		cvctx = ctctx = false;
 	nrvdisc = op == CVT && tn->tn_type->t_tspec == VOID;
 	check_expr_misc(ln, cvctx, ctctx, mp->m_warn_if_operand_eq, op == CALL, nrvdisc, szof);
 	switch (op) {
 	case PUSH:
 		if (rn != NULL)
-			check_expr_misc(rn, 0, 0, mp->m_warn_if_operand_eq, 0, 0, szof);
+			check_expr_misc(rn, false, false, mp->m_warn_if_operand_eq, false, false, szof);
 		break;
 	case LOGAND:
 	case LOGOR:
-		check_expr_misc(rn, 0, 1, mp->m_warn_if_operand_eq, 0, 0, szof);
+		check_expr_misc(rn, false, true, mp->m_warn_if_operand_eq, false, false, szof);
 		break;
 	case COLON:
-		check_expr_misc(rn, cvctx, ctctx, mp->m_warn_if_operand_eq, 0, 0, szof);
+		check_expr_misc(rn, cvctx, ctctx, mp->m_warn_if_operand_eq, false, false, szof);
 		break;
 	case COMMA:
-		check_expr_misc(rn, vctx, tctx, mp->m_warn_if_operand_eq, 0, 0, szof);
+		check_expr_misc(rn, vctx, tctx, mp->m_warn_if_operand_eq, false, false, szof);
 		break;
 	default:
 		if (mp->m_binary)
-			check_expr_misc(rn, 1, 0, mp->m_warn_if_operand_eq, 0, 0, szof);
+			check_expr_misc(rn, true, false, mp->m_warn_if_operand_eq, false, false, szof);
 		break;
+	}
+}
 /*
  * Checks the range of array indices, if possible.
  * amper is set if only the address of the element is used. This
  * means that the index is allowed to refer to the first element
  * after the array.
  */
 static void
 check_array_index(tnode_t *tn, bool amper)