 @@ -1,1051 +1,1050 @@
-/*	$NetBSD: tree.c,v 1.118 2021/01/03 17:42:45 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.119 2021/01/03 18:35:51 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.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Jochen Pohl for
  *	The NetBSD Project.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * 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.118 2021/01/03 17:42:45 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.119 2021/01/03 18:35:51 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"
 #include "externs1.h"
 static	tnode_t	*new_int_const_node(tspec_t, int64_t);
 static	void	check_pointer_comparison(op_t, tnode_t *, tnode_t *);
 static	int	check_assign_types_compatible(op_t, int, tnode_t *, tnode_t *);
 static	void	check_bad_enum_operation(op_t, tnode_t *, tnode_t *);
 static	void	check_enum_type_mismatch(op_t, int, tnode_t *, tnode_t *);
 static	void	check_enum_int_mismatch(op_t, int, tnode_t *, tnode_t *);
 static	tnode_t	*new_tnode(op_t, type_t *, tnode_t *, tnode_t *);
 static	void	balance(op_t, tnode_t **, tnode_t **);
 static	void	warn_incompatible_types(op_t, tspec_t, tspec_t);
 static	void	warn_incompatible_pointers(mod_t *, type_t *, type_t *);
 static	void	merge_qualifiers(type_t **, type_t *, type_t *);
 static	int	has_constant_member(type_t *);
 static	void	check_prototype_conversion(int, tspec_t, tspec_t, type_t *,
 					   tnode_t *);
 static	void	check_integer_conversion(op_t, int, tspec_t, tspec_t, type_t *,
 					 tnode_t *);
 static	void	check_pointer_integer_conversion(op_t, tspec_t, type_t *,
 						 tnode_t *);
 static	void	check_pointer_conversion(op_t, tnode_t *, type_t *);
 static	tnode_t	*build_struct_access(op_t, tnode_t *, tnode_t *);
 static	tnode_t	*build_prepost_incdec(op_t, tnode_t *);
 static	tnode_t	*build_real_imag(op_t, tnode_t *);
 static	tnode_t	*build_ampersand(tnode_t *, int);
 static	tnode_t	*build_plus_minus(op_t, tnode_t *, tnode_t *);
 static	tnode_t	*build_bit_shift(op_t, tnode_t *, tnode_t *);
 static	tnode_t	*build_colon(tnode_t *, tnode_t *);
 static	tnode_t	*build_assignment(op_t, tnode_t *, tnode_t *);
 static	tnode_t	*plength(type_t *);
 static	tnode_t	*fold(tnode_t *);
 static	tnode_t	*fold_test(tnode_t *);
 static	tnode_t	*fold_float(tnode_t *);
 static	tnode_t	*check_function_arguments(type_t *, tnode_t *);
 static	tnode_t	*check_prototype_argument(int, type_t *, tnode_t *);
 static	void	check_null_effect(tnode_t *);
 static	void	display_expression(tnode_t *, int);
 static	void	check_array_index(tnode_t *, int);
 static	void	check_integer_comparison(op_t, tnode_t *, tnode_t *);
 static	void	check_precedence_confusion(tnode_t *);
 extern sig_atomic_t fpe;
 #if 0
 static char *
 dumpnode(char *buf, size_t len, tnode_t *tn) {
 	const char *n = getopname(tn->tn_op);
 	const char *s;
 	switch (tn->tn_op) {
 	case NAME:
 		s = tn->tn_sym->s_name;
 		break;
 	case CON:
 	case STRING:
 		s = "*";	/* todo */
 		break;
 	default:
 		s = NULL;
 		break;
+	}
 	char lb[1024];
 	char rb[1024];
 	if (s == NULL && tn->tn_left != NULL)
 		dumpnode(lb, sizeof(lb), tn->tn_left);
 	else
 		strcpy(lb, "(null)");
 	if (s == NULL && tn->tn_right != NULL)
 		dumpnode(rb, sizeof(rb), tn->tn_right);
 	else
 		strcpy(rb, "(null)");
 	snprintf(buf, len, "%s: (%s) = %s [%s, %s]", n,
 	    type_name(tn->tn_type), s, lb, rb);
 	return buf;
+}
 #endif
 /*
  * Increase degree of reference.
  * This is most often used to change type "T" in type "pointer to T".
  */
 type_t *
 incref(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
 	tp2 = getblk(sizeof (type_t));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * same for use in expressions
  */
 type_t *
 tincref(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
 	tp2 = tgetblk(sizeof (type_t));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Create a node for a constant.
  */
 tnode_t *
 getcnode(type_t *tp, val_t *v)
+{
 	tnode_t	*n;
 	n = getnode();
 	n->tn_op = CON;
 	n->tn_type = tp;
 	n->tn_val = tgetblk(sizeof (val_t));
 	n->tn_val->v_tspec = tp->t_tspec;
 	n->tn_val->v_ansiu = v->v_ansiu;
 	n->tn_val->v_u = v->v_u;
 	free(v);
 	return n;
+}
 /*
  * Create a node for a integer constant.
  */
 static tnode_t *
 new_int_const_node(tspec_t t, int64_t q)
+{
 	tnode_t	*n;
 	n = getnode();
 	n->tn_op = CON;
 	n->tn_type = gettyp(t);
 	n->tn_val = tgetblk(sizeof (val_t));
 	n->tn_val->v_tspec = t;
 	n->tn_val->v_quad = q;
 	return n;
+}
 /*
  * Create a node for a name (symbol table entry).
  * ntok is the token which follows the name.
  */
 tnode_t *
 getnnode(sym_t *sym, int ntok)
+{
 	tnode_t	*n;
 	if (sym->s_scl == NOSCL) {
 		sym->s_scl = EXTERN;
 		sym->s_def = DECL;
 		if (ntok == T_LPAREN) {
 			if (sflag) {
 				/* function implicitly declared to ... */
 				warning(215);
+			}
 			/*
 			 * XXX if tflag is set the symbol should be
 			 * exported to level 0
 			 */
 			sym->s_type = incref(sym->s_type, FUNC);
 		} else {
 			if (!blklev) {
 				/* %s undefined */
 				error(99, sym->s_name);
 			} else {
 				int fixtype;
 				if (strcmp(sym->s_name, "__FUNCTION__") == 0 ||
 				    strcmp(sym->s_name, "__PRETTY_FUNCTION__")
 				    == 0) {
 					/* __FUNCTION__/__PRETTY_FUNCTION... */
 					gnuism(316);
 					fixtype = 1;
 				} else if (strcmp(sym->s_name, "__func__") == 0) {
 					if (!Sflag)
 						/* __func__ is a C9X feature */
 						warning(317);
 					fixtype = 1;
 				} else {
 					/* %s undefined */
 					error(99, sym->s_name);
 					fixtype = 0;
+				}
 				if (fixtype) {
 					sym->s_type = incref(gettyp(CHAR), PTR);
 					sym->s_type->t_const = 1;
+				}
+			}
+		}
+	}
 	if (sym->s_kind != FVFT && sym->s_kind != FMEMBER)
 		LERROR("getnnode(%d)", sym->s_kind);
 	n = getnode();
 	n->tn_type = sym->s_type;
 	if (sym->s_scl != ENUMCON) {
 		n->tn_op = NAME;
 		n->tn_sym = sym;
 		if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC)
 			n->tn_lvalue = 1;
 	} else {
 		n->tn_op = CON;
 		n->tn_val = tgetblk(sizeof (val_t));
 		*n->tn_val = sym->s_value;
+	}
 	return n;
+}
 /*
  * Create a node for a string.
  */
 tnode_t *
 getsnode(strg_t *strg)
+{
 	size_t	len;
 	tnode_t	*n;
 	len = strg->st_len;
 	n = getnode();
 	n->tn_op = STRING;
 	n->tn_type = tincref(gettyp(strg->st_tspec), ARRAY);
 	n->tn_type->t_dim = len + 1;
 	n->tn_lvalue = 1;
 	n->tn_string = tgetblk(sizeof (strg_t));
 	n->tn_string->st_tspec = strg->st_tspec;
 	n->tn_string->st_len = len;
 	if (strg->st_tspec == CHAR) {
 		n->tn_string->st_cp = tgetblk(len + 1);
 		(void)memcpy(n->tn_string->st_cp, strg->st_cp, len + 1);
 		free(strg->st_cp);
 	} else {
 		n->tn_string->st_wcp = tgetblk((len + 1) * sizeof (wchar_t));
 		(void)memcpy(n->tn_string->st_wcp, strg->st_wcp,
 			     (len + 1) * sizeof (wchar_t));
 		free(strg->st_wcp);
+	}
 	free(strg);
 	return n;
+}
 /*
  * Returns a symbol which has the same name as the msym argument and is a
  * member of the struct or union specified by the tn argument.
  */
 sym_t *
 struct_or_union_member(tnode_t *tn, op_t op, sym_t *msym)
+{
 	str_t	*str;
 	type_t	*tp;
 	sym_t	*sym, *csym;
 	int	eq;
 	tspec_t	t;
 	/*
 	 * Remove the member if it was unknown until now (Which means
 	 * that no defined struct or union has a member with the same name).
 	 */
 	if (msym->s_scl == NOSCL) {
 		/* undefined struct/union member: %s */
 		error(101, msym->s_name);
 		rmsym(msym);
 		msym->s_kind = FMEMBER;
 		msym->s_scl = MOS;
 		msym->s_styp = tgetblk(sizeof (str_t));
 		msym->s_styp->stag = tgetblk(sizeof (sym_t));
 		msym->s_styp->stag->s_name = unnamed;
 		msym->s_value.v_tspec = INT;
 		return msym;
+	}
 	/* Set str to the tag of which msym is expected to be a member. */
 	str = NULL;
 	t = (tp = tn->tn_type)->t_tspec;
 	if (op == POINT) {
 		if (t == STRUCT || t == UNION)
 			str = tp->t_str;
 	} else if (op == ARROW && t == PTR) {
 		t = (tp = tp->t_subt)->t_tspec;
 		if (t == STRUCT || t == UNION)
 			str = tp->t_str;
+	}
 	/*
 	 * If this struct/union has a member with the name of msym, return
 	 * return this it.
 	 */
 	if (str != NULL) {
 		for (sym = msym; sym != NULL; sym = sym->s_link) {
 			if (sym->s_scl != MOS && sym->s_scl != MOU)
 				continue;
 			if (sym->s_styp != str)
 				continue;
 			if (strcmp(sym->s_name, msym->s_name) != 0)
 				continue;
 			return sym;
+		}
+	}
 	/*
 	 * Set eq to 0 if there are struct/union members with the same name
 	 * and different types and/or offsets.
 	 */
 	eq = 1;
 	for (csym = msym; csym != NULL; csym = csym->s_link) {
 		if (csym->s_scl != MOS && csym->s_scl != MOU)
 			continue;
 		if (strcmp(msym->s_name, csym->s_name) != 0)
 			continue;
 		for (sym = csym->s_link ; sym != NULL; sym = sym->s_link) {
 			int w;
 			if (sym->s_scl != MOS && sym->s_scl != MOU)
 				continue;
 			if (strcmp(csym->s_name, sym->s_name) != 0)
 				continue;
 			if (csym->s_value.v_quad != sym->s_value.v_quad) {
 				eq = 0;
 				break;
+			}
 			w = 0;
 			eq = eqtype(csym->s_type, sym->s_type, 0, 0, &w) && !w;
 			if (!eq)
 				break;
 			if (csym->s_bitfield != sym->s_bitfield) {
 				eq = 0;
 				break;
+			}
 			if (csym->s_bitfield) {
 				type_t	*tp1, *tp2;
 				tp1 = csym->s_type;
 				tp2 = sym->s_type;
 				if (tp1->t_flen != tp2->t_flen) {
 					eq = 0;
 					break;
+				}
 				if (tp1->t_foffs != tp2->t_foffs) {
 					eq = 0;
 					break;
+				}
+			}
+		}
 		if (!eq)
 			break;
+	}
 	/*
 	 * Now handle the case in which the left operand refers really
 	 * to a struct/union, but the right operand is not member of it.
 	 */
 	if (str != NULL) {
 		if (eq && tflag) {
 			/* illegal member use: %s */
 			warning(102, msym->s_name);
 		} else {
 			/* illegal member use: %s */
 			error(102, msym->s_name);
+		}
 		return msym;
+	}
 	/*
 	 * Now the left operand of ARROW does not point to a struct/union
 	 * or the left operand of POINT is no struct/union.
 	 */
 	if (eq) {
 		if (op == POINT) {
 			if (tflag) {
 				/* left operand of '.' must be struct/... */
 				warning(103);
 			} else {
 				/* left operand of '.' must be struct/... */
 				error(103);
+			}
 		} else {
 			/* left operand of "->" must be pointer to ... */
 			if (tflag && tn->tn_type->t_tspec == PTR) {
 				/* left operand of '->' must be pointer ... */
 				warning(104, type_name(tn->tn_type));
 			} else {
 				/* left operand of '->' must be pointer ... */
 				error(104, type_name(tn->tn_type));
+			}
+		}
 	} else {
 		if (tflag) {
 			/* non-unique member requires struct/union %s */
 			error(105, op == POINT ? "object" : "pointer");
 		} else {
 			/* unacceptable operand of '%s' */
 			error(111, modtab[op].m_name);
+		}
+	}
 	return msym;
+}
 /*
  * Create a tree node. Called for most operands except function calls,
  * sizeof and casts.
+ *
  * op	operator
  * ln	left operand
  * rn	if not NULL, right operand
  */
 tnode_t *
 build(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	mod_t	*mp;
 	tnode_t	*ntn;
 	type_t	*rtp;
 	mp = &modtab[op];
 	/* If there was an error in one of the operands, return. */
 	if (ln == NULL || (mp->m_binary && rn == NULL))
 		return NULL;
 	/*
 	 * Apply class conversions to the left operand, but only if its
 	 * value is needed or it is compared with null.
 	 */
 	if (mp->m_vctx || mp->m_tctx)
 		ln = cconv(ln);
 	/*
 	 * The right operand is almost always in a test or value context,
 	 * except if it is a struct or union member.
 	 */
 	if (mp->m_binary && op != ARROW && op != POINT)
 		rn = cconv(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_comp)
 		check_integer_comparison(op, ln, rn);
 	/*
 	 * Promote the left operand if it is in a test or value context
 	 */
 	if (mp->m_vctx || mp->m_tctx)
 		ln = promote(op, 0, 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);
+	}
 	/*
 	 * 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_tlansiu && 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 = 0;
+	}
 	if (mp->m_transiu && rn->tn_op == CON && rn->tn_val->v_ansiu) {
 		/* ANSI C treats constant as unsigned, op %s */
 		warning(218, mp->m_name);
 		rn->tn_val->v_ansiu = 0;
+	}
 	/* Make sure both operands are of the same type */
 	if (mp->m_balance || (tflag && (op == SHL || op == SHR)))
 		balance(op, &ln, &rn);
 	/*
 	 * Check types for compatibility with the operation and mutual
 	 * compatibility. Return if there are serious problems.
 	 */
 	if (!typeok(op, 0, ln, rn))
 		return NULL;
 	/* 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 AMPER:
 		ntn = build_ampersand(ln, 0);
 		break;
 	case STAR:
 		ntn = new_tnode(STAR, 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:
 		ntn = build_colon(ln, rn);
 		break;
 	case ASSIGN:
 	case MULASS:
 	case DIVASS:
 	case MODASS:
 	case ADDASS:
 	case SUBASS:
 	case SHLASS:
 	case SHRASS:
 	case ANDASS:
 	case XORASS:
 	case ORASS:
 	case RETURN:
 		ntn = build_assignment(op, ln, rn);
 		break;
 	case COMMA:
 	case QUEST:
 		ntn = new_tnode(op, rn->tn_type, ln, rn);
 		break;
 	case REAL:
 	case IMAG:
 		ntn = build_real_imag(op, ln);
 		break;
 	default:
 		rtp = mp->m_logical ? gettyp(INT) : ln->tn_type;
 		lint_assert(mp->m_binary || rn == NULL);
 		ntn = new_tnode(op, rtp, ln, rn);
 		break;
+	}
 	/* Return if an error occurred. */
 	if (ntn == NULL)
 		return NULL;
 	/* Print a warning if precedence confusion is possible */
 	if (mp->m_tpconf)
 		check_precedence_confusion(ntn);
 	/*
 	 * Print a warning if one of the operands is in a context where
 	 * it is compared with null and if this operand is a constant.
 	 */
 	if (mp->m_tctx) {
 		if (ln->tn_op == CON ||
 		    ((mp->m_binary && op != QUEST) && rn->tn_op == CON)) {
 			if (hflag && !constcond_flag)
 				/* constant in conditional context */
 				warning(161);
+		}
+	}
 	/* Fold if the operator requires it */
 	if (mp->m_fold) {
 		if (ln->tn_op == CON && (!mp->m_binary || rn->tn_op == CON)) {
 			if (mp->m_tctx) {
 				ntn = fold_test(ntn);
 			} else if (tspec_is_float(ntn->tn_type->t_tspec)) {
 				ntn = fold_float(ntn);
 			} else {
 				ntn = fold(ntn);
+			}
 		} else if (op == QUEST && ln->tn_op == CON) {
 			ntn = ln->tn_val->v_quad ? rn->tn_left : rn->tn_right;
+		}
+	}
 	return ntn;
+}
 /*
  * Perform class conversions.
+ *
  * Arrays of type T are converted into pointers to type T.
  * Functions are converted to pointers to functions.
  * Lvalues are converted to rvalues.
  */
 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[AMPER].m_name);
+		}
 		tn = new_tnode(AMPER, 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_ampersand(tn, 1);
 	/* lvalue to rvalue */
 	if (tn->tn_lvalue) {
 		tp = tduptyp(tn->tn_type);
 		tp->t_const = tp->t_volatile = 0;
 		tn = new_tnode(LOAD, tp, tn, NULL);
+	}
 	return tn;
+}
 /*
  * Perform most type checks. First the types are checked using
  * the information from modtab[]. After that it is done by hand for
  * more complicated operators and type combinations.
+ *
  * If the types are ok, typeok() returns 1, otherwise 0.
  */
 int
 typeok(op_t op, int arg, tnode_t *ln, tnode_t *rn)
+{
 	mod_t	*mp;
 	tspec_t	lt, rt = NOTSPEC, lst = NOTSPEC, rst = NOTSPEC, olt = NOTSPEC,
 	    ort = NOTSPEC;
 	type_t	*ltp, *rtp = NULL, *lstp = NULL, *rstp = NULL;
 	tnode_t	*tn;
 	mp = &modtab[op];
 	lint_assert((ltp = ln->tn_type) != NULL);
 	if ((lt = ltp->t_tspec) == PTR)
 		lst = (lstp = ltp->t_subt)->t_tspec;
 	if (mp->m_binary) {
 		lint_assert((rtp = rn->tn_type) != NULL);
 		if ((rt = rtp->t_tspec) == PTR)
 			rst = (rstp = rtp->t_subt)->t_tspec;
+	}
 	if (mp->m_requires_integer) {
 		if (!tspec_is_int(lt) || (mp->m_binary && !tspec_is_int(rt))) {
 			warn_incompatible_types(op, lt, rt);
 			return 0;
+		}
 	} else if (mp->m_requires_integer_or_complex) {
 		if ((!tspec_is_int(lt) && !tspec_is_complex(lt)) ||
 		    (mp->m_binary &&
 		     (!tspec_is_int(rt) && !tspec_is_complex(rt)))) {
 			warn_incompatible_types(op, lt, rt);
 			return 0;
+		}
 	} else if (mp->m_requires_scalar) {
 		if (!tspec_is_scalar(lt) ||
 		    (mp->m_binary && !tspec_is_scalar(rt))) {
 			warn_incompatible_types(op, lt, rt);
 			return 0;
+		}
 	} else if (mp->m_requires_arith) {
 		if (!tspec_is_arith(lt) ||
 		    (mp->m_binary && !tspec_is_arith(rt))) {
 			warn_incompatible_types(op, lt, rt);
 			return 0;
+		}
+	}
 	if (op == SHL || op == SHR || op == SHLASS || op == SHRASS) {
 		/*
 		 * For these operations we need the types before promotion
 		 * and balancing.
 		 */
 		for (tn=ln; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left)
 			continue;
 		olt = tn->tn_type->t_tspec;
 		for (tn=rn; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left)
 			continue;
 		ort = tn->tn_type->t_tspec;
+	}
 	switch (op) {
 	case POINT:
 		/*
 		 * Most errors required by ANSI C are reported in
 		 * struct_or_union_member().
 		 * Here we only must check for totally wrong things.
 		 */
 		if (lt == FUNC || lt == VOID || ltp->t_isfield ||
 		    ((lt != STRUCT && lt != UNION) && !ln->tn_lvalue)) {
 			/* Without tflag we got already an error */
 			if (tflag)
 				/* unacceptable operand of '%s' */
 				error(111, mp->m_name);
 			return 0;
+		}
 		/* Now we have an object we can create a pointer to */
 		break;
 	case ARROW:
 		if (lt != PTR && !(tflag && tspec_is_int(lt))) {
 			/* Without tflag we got already an error */
 			if (tflag)
 				/* unacceptable operand of '%s' */
 				error(111, mp->m_name);
 			return 0;
+		}
 		break;
 	case INCAFT:
 	case DECAFT:
 	case INCBEF:
 	case DECBEF:
 		/* operands have scalar types (checked above) */
 		if (!ln->tn_lvalue) {
 			if (ln->tn_op == CVT && ln->tn_cast &&
 			    ln->tn_left->tn_op == LOAD) {
 				if (ln->tn_type->t_tspec == PTR)
 					break;
 				/* a cast does not yield an lvalue */
 				error(163);
+			}
 			/* %soperand of '%s' must be lvalue */
 			error(114, "", mp->m_name);
 			return 0;
 		} else if (ltp->t_const) {
 			if (!tflag)
 				/* %soperand of '%s' must be modifiable ... */
 				warning(115, "", mp->m_name);
+		}
 		break;
 	case AMPER:
 		if (lt == ARRAY || lt == FUNC) {
 			/* ok, a warning comes later (in build_ampersand()) */
 		} else if (!ln->tn_lvalue) {
 			if (ln->tn_op == CVT && ln->tn_cast &&
 			    ln->tn_left->tn_op == LOAD) {
 				if (ln->tn_type->t_tspec == PTR)
 					break;
 				/* a cast does not yield an lvalue */
 				error(163);
+			}
 			/* %soperand of '%s' must be lvalue */
 			error(114, "", mp->m_name);
 			return 0;
 		} else if (tspec_is_scalar(lt)) {
 			if (ltp->t_isfield) {
 				/* cannot take address of bit-field */
 				error(112);
 				return 0;
+			}
 		} else if (lt != STRUCT && lt != UNION) {
 			/* unacceptable operand of '%s' */
 			error(111, mp->m_name);
 			return 0;
+		}
 		if (ln->tn_op == NAME && ln->tn_sym->s_reg) {
 			/* cannot take address of register %s */
 			error(113, ln->tn_sym->s_name);
 			return 0;
+		}
 		break;
 	case STAR:
 		/* until now there were no type checks for this operator */
 		if (lt != PTR) {
 			/* cannot dereference non-pointer type */
 			error(96);
 			return 0;
+		}
 		break;
 	case PLUS:
 		/* operands have scalar types (checked above) */
 		if ((lt == PTR && !tspec_is_int(rt)) ||
 		    (rt == PTR && !tspec_is_int(lt))) {
 			warn_incompatible_types(op, lt, rt);
 			return 0;
+		}
 		break;
 	case MINUS:
 		/* operands have scalar types (checked above) */
 		if (lt == PTR && (!tspec_is_int(rt) && rt != PTR)) {
 			warn_incompatible_types(op, lt, rt);
 			return 0;
 		} else if (rt == PTR && lt != PTR) {
 			warn_incompatible_types(op, lt, rt);
 			return 0;
+		}
 		if (lt == PTR && rt == PTR) {
 			if (!eqtype(lstp, rstp, 1, 0, NULL)) {
 				/* illegal pointer subtraction */
 				error(116);
+			}
+		}
 		break;
 	case SHR:
 		/* operands have integer types (checked above) */
 		if (pflag && !tspec_is_uint(lt)) {
 			/*
 			 * The left operand is signed. This means that
 			 * the operation is (possibly) nonportable.
 			 */
 			if (ln->tn_op != CON) {
 				/* bitop. on signed value poss. nonportable */
 				warning(117);
 			} else if (ln->tn_val->v_quad < 0) {
 				/* bitop. on signed value nonportable */
 				warning(120);
+			}
 		} else if (!tflag && !sflag &&
 		    !tspec_is_uint(olt) && tspec_is_uint(ort)) {
 			/*
 			 * The left operand would become unsigned in
 			 * traditional C.
 			 */
 			if (hflag &&
 			    (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
 				/* semantics of '%s' change in ANSI C; ... */
 				warning(118, mp->m_name);
+			}
 		} else if (!tflag && !sflag &&
 		    !tspec_is_uint(olt) && !tspec_is_uint(ort) &&
 			   psize(lt) < psize(rt)) {
 			/*
 			 * In traditional C the left operand would be extended,
 			 * possibly with 1, and then shifted.
 			 */
 			if (hflag &&
 			    (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
 				/* semantics of '%s' change in ANSI C; ... */
 				warning(118, mp->m_name);
+			}
+		}
 		goto shift;
 	case SHL:
 		/*
 		 * ANSI C does not perform balancing for shift operations,
 		 * but traditional C does. If the width of the right operand
 		 * is greater than the width of the left operand, than in
 		 * traditional C the left operand would be extended to the
 		 * width of the right operand. For SHL this may result in
 		 * different results.
 		 */
 		if (psize(lt) < psize(rt)) {
 			/*
 			 * XXX If both operands are constant, make sure
 			 * that there is really a difference between
 			 * ANSI C and traditional C.
 			 */
 			if (hflag)
 				/* semantics of '%s' change in ANSI C; ... */
 				warning(118, mp->m_name);
+		}
 	shift:
 		if (rn->tn_op == CON) {
 			if (!tspec_is_uint(rt) && rn->tn_val->v_quad < 0) {
 				/* negative shift */
 				warning(121);
 			} else if ((uint64_t)rn->tn_val->v_quad == (uint64_t)size(lt)) {
 				/* shift equal to size of object */
 				warning(267);
 			} else if ((uint64_t)rn->tn_val->v_quad > (uint64_t)size(lt)) {
 				/* shift greater than size of object */
 				warning(122);
+			}
+		}
 		break;
 	case EQ:
 	case NE:
 		/*
 		 * Accept some things which are allowed with EQ and NE,
 		 * but not with ordered comparisons.
 		 */
 		if (lt == PTR && ((rt == PTR && rst == VOID) ||
 				  tspec_is_int(rt))) {
 			if (rn->tn_op == CON && rn->tn_val->v_quad == 0)
 				break;
+		}
 		if (rt == PTR && ((lt == PTR && lst == VOID) ||
 				  tspec_is_int(lt))) {
 			if (ln->tn_op == CON && ln->tn_val->v_quad == 0)
 				break;
+		}
 		/* FALLTHROUGH */
 	case LT:
 	case GT:
 	case LE:
 	case GE:
 		if ((lt == PTR || rt == PTR) && lt != rt) {
 			if (tspec_is_int(lt) || tspec_is_int(rt)) {
 				const char *lx = lt == PTR ?
 				    "pointer" : "integer";
 				const char *rx = rt == PTR ?
 				    "pointer" : "integer";
 				/* illegal combination of %s (%s) and ... */
 				warning(123, lx, type_name(ltp),
 				    rx, type_name(rtp), mp->m_name);
 			} else {
 				warn_incompatible_types(op, lt, rt);
 				return 0;
+			}
 		} else if (lt == PTR && rt == PTR) {
 			check_pointer_comparison(op, ln, rn);
+		}
 		break;
 	case QUEST:
 		if (!tspec_is_scalar(lt)) {
 			/* first operand must have scalar type, op ? : */
 			error(170);
 			return 0;
+		}
 		while (rn->tn_op == CVT)
 			rn = rn->tn_left;
 		lint_assert(rn->tn_op == COLON);
 		break;
 	case COLON:
 		if (tspec_is_arith(lt) && tspec_is_arith(rt))
 			break;
 		if (lt == STRUCT && rt == STRUCT && ltp->t_str == rtp->t_str)
 			break;
 		if (lt == UNION && rt == UNION && ltp->t_str == rtp->t_str)
 			break;
 		/* combination of any pointer and 0, 0L or (void *)0 is ok */
 		if (lt == PTR && ((rt == PTR && rst == VOID) ||
 				  tspec_is_int(rt))) {
 			if (rn->tn_op == CON && rn->tn_val->v_quad == 0)
 				break;
+		}
 		if (rt == PTR && ((lt == PTR && lst == VOID) ||
 				  tspec_is_int(lt))) {
 			if (ln->tn_op == CON && ln->tn_val->v_quad == 0)
 				break;
+		}
 		if ((lt == PTR && tspec_is_int(rt)) ||
 		    (tspec_is_int(lt) && rt == PTR)) {
 			const char *lx = lt == PTR ?  "pointer" : "integer";
 			const char *rx = rt == PTR ?  "pointer" : "integer";
 			/* illegal combination of %s (%s) and %s (%s), op %s */
 			warning(123, lx, type_name(ltp),
 			    rx, type_name(rtp), mp->m_name);
 			break;
+		}
 		if (lt == VOID || rt == VOID) {
 			if (lt != VOID || rt != VOID)
 				/* incompatible types in conditional */
 				warning(126);
 			break;
+		}
 		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);
 			break;
+		}
 		if (rt == PTR && lt == PTR) {
 			if (eqptrtype(lstp, rstp, 1))
 				break;
 			if (!eqtype(lstp, rstp, 1, 0, NULL))
 				warn_incompatible_pointers(mp, ltp, rtp);
 			break;
+		}
 		/* incompatible types in conditional */
 		error(126);
 		return 0;
 	case ASSIGN:
 	case INIT:
 	case FARG:
 	case RETURN:
 		if (!check_assign_types_compatible(op, arg, ln, rn))

 @@ -1,154 +1,153 @@
-/*	$NetBSD: print.c,v 1.7 2020/12/30 10:56:51 rillig Exp $	*/
+/*	$NetBSD: print.c,v 1.8 2021/01/03 18:35:51 rillig Exp $	*/
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Christos Zoulas.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT 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>
 #ifndef lint
-__RCSID("$NetBSD: print.c,v 1.7 2020/12/30 10:56:51 rillig Exp $");
+__RCSID("$NetBSD: print.c,v 1.8 2021/01/03 18:35:51 rillig Exp $");
 #endif
 #include <stdio.h>
 #include "lint1.h"
 #include "externs1.h"
 static const char *str_op_t[] =
+{
 	"*noop*",
 	"->",
 	".",
 	"!",
 	"~",
 	"++",
 	"--",
 	"++<",
 	"--<",
 	"++>",
 	"-->",
 	"+",
 	"-",
 	"*",
 	"&",
 	"*",
 	"/",
 	"%",
 	"+",
 	"-",
 	"<<",
 	">>",
 	"<",
 	"<=",
 	">",
 	">=",
 	"==",
 	"!=",
 	"&",
 	"^",
 	"|",
 	"&&",
 	"||",
 	"?",
 	":",
 	"=",
 	"*=",
 	"/=",
 	"%=",
 	"+=",
 	"-=",
 	"<<=",
 	">>=",
 	"&=",
 	"^=",
 	"|=",
 	"*name*",
 	"*constant*",
 	"*string*",
 	"*field select*",
 	"*call*",
 	",",
 	"*(cast)*",
 	"*icall*",
 	"*load*",
 	"*push*",
 	"return",
 	"*init*",
 	"*case*",
 	"*farg*",
 };
 char *
 print_tnode(char *buf, size_t bufsiz, const tnode_t *tn)
+{
 	strg_t *st;
 	val_t *v;
 	sym_t *s;
 	switch (tn->tn_op) {
 	case NAME:
 		s = tn->tn_sym;
 		(void)snprintf(buf, bufsiz, "%s", s->s_name);
 		break;
 	case CON:
 		v = tn->tn_val;
 		switch (v->v_tspec) {
 		case FLOAT:
 		case DOUBLE:
 		case LDOUBLE:
 			(void)snprintf(buf, bufsiz, "%Lg", v->v_ldbl);
 			break;
 		default:
 			(void)snprintf(buf, bufsiz, v->v_ansiu ? "%llu" :
 			    "%lld", (unsigned long long)v->v_quad);
 			break;
+		}
 		break;
 	case STRING:
 		st = tn->tn_string;
 		switch (st->st_tspec) {
 		case CHAR:
 		case SCHAR:
 		case UCHAR:
 			(void)snprintf(buf, bufsiz, "\"%s\"", st->st_cp);
 			break;
 		default:
 			(void)snprintf(buf, bufsiz, "\"*wide string*\"");
 			break;
+		}
 		break;
 	default:
 		(void)snprintf(buf, bufsiz, "%s", str_op_t[tn->tn_op]);
 		break;
+	}
 	return buf;
+}