 @@ -1,612 +1,583 @@
-/* $NetBSD: emit1.c,v 1.45 2021/07/05 19:39:12 rillig Exp $ */
+/* $NetBSD: emit1.c,v 1.46 2021/07/15 17:03:50 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * 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: emit1.c,v 1.45 2021/07/05 19:39:12 rillig Exp $");
+__RCSID("$NetBSD: emit1.c,v 1.46 2021/07/15 17:03:50 rillig Exp $");
 #endif
 #include "lint1.h"
 static	void	outtt(sym_t *, sym_t *);
 static	void	outfstrg(strg_t *);
 /*
  * Write type into the output buffer.
  * The type is written as a sequence of substrings, each of which describes a
  * node of type type_t
  * a node is encoded as follows:
  *	_Bool			B
  *	_Complex float		s X
  *	_Complex double		X
  *	_Complex long double	l X
  *	char			C
  *	signed char		s C
  *	unsigned char		u C
  *	short			S
  *	unsigned short		u S
  *	int			I
  *	unsigned int		u I
  *	long			L
  *	unsigned long		u L
  *	long long		Q
  *	unsigned long long	u Q
  *	float			s D
  *	double			D
  *	long double		l D
  *	void			V
  *	*			P
  *	[n]			A n
  *	()			F
  *	(void)			F 0
  *	(n parameters)		F n arg1 arg2 ... argn
  *	(n parameters, ...)	F n arg1 arg2 ... argn-1 E
  *	enum tag		e T tag_or_typename
  *	struct tag		s T tag_or_typename
  *	union tag		u T tag_or_typename
+ *
  *	tag_or_typename		0 (obsolete)		no tag or type name
  *				1 n tag			tagged type
  *				2 n typename		only type name
  *				3 line.file.uniq	anonymous types
+ *
  * spaces are only for better readability
  * additionally it is possible to prepend the characters 'c' (for const)
  * and 'v' (for volatile)
  */
 void
 outtype(const type_t *tp)
+{
 	int	t, s, na;
 	sym_t	*arg;
 	tspec_t	ts;
 	while (tp != NULL) {
 		if ((ts = tp->t_tspec) == INT && tp->t_is_enum)
 			ts = ENUM;
 		switch (ts) {
 		case BOOL:	t = 'B';	s = '\0';	break;
 		case CHAR:	t = 'C';	s = '\0';	break;
 		case SCHAR:	t = 'C';	s = 's';	break;
 		case UCHAR:	t = 'C';	s = 'u';	break;
 		case SHORT:	t = 'S';	s = '\0';	break;
 		case USHORT:	t = 'S';	s = 'u';	break;
 		case INT:	t = 'I';	s = '\0';	break;
 		case UINT:	t = 'I';	s = 'u';	break;
 		case LONG:	t = 'L';	s = '\0';	break;
 		case ULONG:	t = 'L';	s = 'u';	break;
 		case QUAD:	t = 'Q';	s = '\0';	break;
 		case UQUAD:	t = 'Q';	s = 'u';	break;
 		case FLOAT:	t = 'D';	s = 's';	break;
 		case DOUBLE:	t = 'D';	s = '\0';	break;
 		case LDOUBLE:	t = 'D';	s = 'l';	break;
 		case VOID:	t = 'V';	s = '\0';	break;
 		case PTR:	t = 'P';	s = '\0';	break;
 		case ARRAY:	t = 'A';	s = '\0';	break;
 		case FUNC:	t = 'F';	s = '\0';	break;
 		case ENUM:	t = 'T';	s = 'e';	break;
 		case STRUCT:	t = 'T';	s = 's';	break;
 		case UNION:	t = 'T';	s = 'u';	break;
 		case FCOMPLEX:	t = 'X';	s = 's';	break;
 		case DCOMPLEX:	t = 'X';	s = '\0';	break;
 		case LCOMPLEX:	t = 'X';	s = 'l';	break;
 		default:
 			lint_assert(/*CONSTCOND*/false);
+		}
 		if (tp->t_const)
 			outchar('c');
 		if (tp->t_volatile)
 			outchar('v');
 		if (s != '\0')
 			outchar(s);
 		outchar(t);
 		if (ts == ARRAY) {
 			outint(tp->t_dim);
 		} else if (ts == ENUM) {
 			outtt(tp->t_enum->en_tag, tp->t_enum->en_first_typedef);
 		} else if (ts == STRUCT || ts == UNION) {
 			outtt(tp->t_str->sou_tag, tp->t_str->sou_first_typedef);
 		} else if (ts == FUNC && tp->t_proto) {
 			na = 0;
 			for (arg = tp->t_args; arg != NULL; arg = arg->s_next)
 				na++;
 			if (tp->t_vararg)
 				na++;
 			outint(na);
 			for (arg = tp->t_args; arg != NULL; arg = arg->s_next)
 				outtype(arg->s_type);
 			if (tp->t_vararg)
 				outchar('E');
+		}
 		tp = tp->t_subt;
+	}
+}
 /*
  * type to string
  * used for debugging output
  * it uses its own output buffer for conversion
  */
 const char *
 ttos(const type_t *tp)
 	static	ob_t	tob;
 	ob_t	tmp;
 	if (tob.o_buf == NULL) {
 		tob.o_len = 64;
 		tob.o_buf = tob.o_next = xmalloc(tob.o_len);
 		tob.o_end = tob.o_buf + tob.o_len;
 	tmp = ob;
 	ob = tob;
 	ob.o_next = ob.o_buf;
 	outtype(tp);
 	outchar('\0');
 	tob = ob;
 	ob = tmp;
 	return tob.o_buf;
 /*
  * write the name of a tag or typename
+ *
  * if the tag is named, the name of the tag is written,
  * otherwise, if a typename exists which refers to this tag,
  * this typename is written
  */
 static void
 outtt(sym_t *tag, sym_t *tdef)
+{
 	/* 0 is no longer used. */
 	if (tag->s_name != unnamed) {
 		outint(1);
 		outname(tag->s_name);
 	} else if (tdef != NULL) {
 		outint(2);
 		outname(tdef->s_name);
 	} else {
 		outint(3);
 		outint(tag->s_def_pos.p_line);
 		outchar('.');
 		outint(get_filename_id(tag->s_def_pos.p_file));
 		outchar('.');
 		outint(tag->s_def_pos.p_uniq);
+	}
+}
 /*
  * write information about a globally declared/defined symbol
  * with storage class extern
+ *
  * information about function definitions are written in outfdef(),
  * not here
  */
 void
 outsym(const sym_t *sym, scl_t sc, def_t def)
+{
 	/*
 	 * Static function declarations must also be written to the output
 	 * file. Compatibility of function declarations (for both static
 	 * and extern functions) must be checked in lint2. Lint1 can't do
 	 * this, especially not if functions are declared at block level
 	 * before their first declaration at level 0.
 	 */
 	if (sc != EXTERN && !(sc == STATIC && sym->s_type->t_tspec == FUNC))
 		return;
 	/* reset buffer */
 	outclr();
 	/*
 	 * line number of .c source, 'd' for declaration, Id of current
 	 * source (.c or .h), and line in current source.
 	 */
 	outint(csrc_pos.p_line);
 	outchar('d');
 	outint(get_filename_id(sym->s_def_pos.p_file));
 	outchar('.');
 	outint(sym->s_def_pos.p_line);
 	/* flags */
 	switch (def) {
 	case DEF:
 		/* defined */
 		outchar('d');
 		break;
 	case TDEF:
 		/* tentative defined */
 		outchar('t');
 		break;
 	case DECL:
 		/* declared */
 		outchar('e');
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
 	if (llibflg && def != DECL) {
 		/*
 		 * mark it as used so we get no warnings from lint2 about
 		 * unused symbols in libraries.
 		 */
 		outchar('u');
+	}
 	if (sc == STATIC)
 		outchar('s');
 	/* name of the symbol */
 	outname(sym->s_name);
 	/* renamed name of symbol, if necessary */
 	if (sym->s_rename != NULL) {
 		outchar('r');
 		outname(sym->s_rename);
+	}
 	/* type of the symbol */
 	outtype(sym->s_type);
+}
 /*
  * write information about function definition
+ *
  * this is also done for static functions so we are able to check if
  * they are called with proper argument types
  */
 void
 outfdef(const sym_t *fsym, const pos_t *posp, bool rval, bool osdef,
 	const sym_t *args)
+{
 	int narg;
 	const sym_t *arg;
 	/* reset the buffer */
 	outclr();
 	/*
 	 * line number of .c source, 'd' for declaration, Id of current
 	 * source (.c or .h), and line in current source
+	 *
 	 * we are already at the end of the function. If we are in the
 	 * .c source, posp->p_line is correct, otherwise csrc_pos.p_line
 	 * (for functions defined in header files).
 	 */
 	if (posp->p_file == csrc_pos.p_file) {
 		outint(posp->p_line);
 	} else {
 		outint(csrc_pos.p_line);
+	}
 	outchar('d');
 	outint(get_filename_id(posp->p_file));
 	outchar('.');
 	outint(posp->p_line);
 	/* flags */
 	/* both SCANFLIKE and PRINTFLIKE imply VARARGS */
 	if (printflike_argnum != -1) {
 		nvararg = printflike_argnum;
 	} else if (scanflike_argnum != -1) {
 		nvararg = scanflike_argnum;
+	}
 	if (nvararg != -1) {
 		outchar('v');
 		outint(nvararg);
+	}
 	if (scanflike_argnum != -1) {
 		outchar('S');
 		outint(scanflike_argnum);
+	}
 	if (printflike_argnum != -1) {
 		outchar('P');
 		outint(printflike_argnum);
+	}
 	nvararg = printflike_argnum = scanflike_argnum = -1;
 	outchar('d');
 	if (rval)
 		/* has return value */
 		outchar('r');
 	if (llibflg)
 		/*
 		 * mark it as used so lint2 does not complain about
 		 * unused symbols in libraries
 		 */
 		outchar('u');
 	if (osdef)
 		/* old style function definition */
 		outchar('o');
 	if (fsym->s_inline)
 		outchar('i');
 	if (fsym->s_scl == STATIC)
 		outchar('s');
 	/* name of function */
 	outname(fsym->s_name);
 	/* renamed name of function, if necessary */
 	if (fsym->s_rename != NULL) {
 		outchar('r');
 		outname(fsym->s_rename);
+	}
 	/* argument types and return value */
 	if (osdef) {
 		narg = 0;
 		for (arg = args; arg != NULL; arg = arg->s_next)
 			narg++;
 		outchar('f');
 		outint(narg);
 		for (arg = args; arg != NULL; arg = arg->s_next)
 			outtype(arg->s_type);
 		outtype(fsym->s_type->t_subt);
 	} else {
 		outtype(fsym->s_type);
+	}
+}
 /*
  * write out all information necessary for lint2 to check function
  * calls
+ *
  * rvused is set if the return value is used (assigned to a variable)
  * rvdisc is set if the return value is not used and not ignored
  * (casted to void)
  */
 void
 outcall(const tnode_t *tn, bool rvused, bool rvdisc)
+{
 	tnode_t	*args, *arg;
 	int	narg, n, i;
 	int64_t	q;
 	tspec_t	t;
 	/* reset buffer */
 	outclr();
 	/*
 	 * line number of .c source, 'c' for function call, Id of current
 	 * source (.c or .h), and line in current source
 	 */
 	outint(csrc_pos.p_line);
 	outchar('c');
 	outint(get_filename_id(curr_pos.p_file));
 	outchar('.');
 	outint(curr_pos.p_line);
 	/*
 	 * flags; 'u' and 'i' must be last to make sure a letter
 	 * is between the numeric argument of a flag and the name of
 	 * the function
 	 */
 	narg = 0;
 	args = tn->tn_right;
 	for (arg = args; arg != NULL; arg = arg->tn_right)
 		narg++;
 	/* information about arguments */
 	for (n = 1; n <= narg; n++) {
 		/* the last argument is the top one in the tree */
 		for (i = narg, arg = args; i > n; i--, arg = arg->tn_right)
 			continue;
 		arg = arg->tn_left;
 		if (arg->tn_op == CON) {
 			if (is_integer(t = arg->tn_type->t_tspec)) {
 				/*
 				 * XXX it would probably be better to
 				 * explicitly test the sign
 				 */
 				if ((q = arg->tn_val->v_quad) == 0) {
 					/* zero constant */
 					outchar('z');
 				} else if (msb(q, t, 0) == 0) {
 					/* positive if casted to signed */
 					outchar('p');
 				} else {
 					/* negative if casted to signed */
 					outchar('n');
+				}
 				outint(n);
+			}
 		} else if (arg->tn_op == ADDR &&
 			   arg->tn_left->tn_op == STRING &&
 			   arg->tn_left->tn_string->st_tspec == CHAR) {
 			/* constant string, write all format specifiers */
 			outchar('s');
 			outint(n);
 			outfstrg(arg->tn_left->tn_string);
+		}
+	}
 	/* return value discarded/used/ignored */
 	outchar(rvdisc ? 'd' : (rvused ? 'u' : 'i'));
 	/* name of the called function */
 	outname(tn->tn_left->tn_left->tn_sym->s_name);
 	/* types of arguments */
 	outchar('f');
 	outint(narg);
 	for (n = 1; n <= narg; n++) {
 		/* the last argument is the top one in the tree */
 		for (i = narg, arg = args; i > n; i--, arg = arg->tn_right)
 			continue;
 		outtype(arg->tn_left->tn_type);
+	}
 	/* expected type of return value */
 	outtype(tn->tn_type);
+}
 /*
  * extracts potential format specifiers for printf() and scanf() and
  * writes them, enclosed in "" and quoted if necessary, to the output buffer
  */
 static void
 outfstrg(strg_t *strg)
+{
 	unsigned char c, oc;
 	bool	first;
 	u_char	*cp;
 	lint_assert(strg->st_tspec == CHAR);
 	cp = strg->st_cp;
 	outchar('"');
 	c = *cp++;
 	while (c != '\0') {
 		if (c != '%') {
 			c = *cp++;
 			continue;
+		}
 		outqchar('%');
 		c = *cp++;
 		/* flags for printf and scanf and *-fieldwidth for printf */
 		while (c != '\0' && (c == '-' || c == '+' || c == ' ' ||
 				     c == '#' || c == '0' || c == '*')) {
 			outqchar(c);
 			c = *cp++;
+		}
 		/* numeric field width */
 		while (c != '\0' && ch_isdigit((char)c)) {
 			outqchar(c);
 			c = *cp++;
+		}
 		/* precision for printf */
 		if (c == '.') {
 			outqchar(c);
 			if ((c = *cp++) == '*') {
 				outqchar(c);
 				c = *cp++;
 			} else {
 				while (c != '\0' && ch_isdigit((char)c)) {
 					outqchar(c);
 					c = *cp++;
+				}
+			}
+		}
 		/* h, l, L and q flags fpr printf and scanf */
 		if (c == 'h' || c == 'l' || c == 'L' || c == 'q') {
 			outqchar(c);
 			c = *cp++;
+		}
 		/*
 		 * The last character. It is always written so we can detect
 		 * invalid format specifiers.
 		 */
 		if (c != '\0') {
 			outqchar(c);
 			oc = c;
 			c = *cp++;
 			/*
 			 * handle [ for scanf. [-] means that a minus sign
 			 * was found at an undefined position.
 			 */
 			if (oc == '[') {
 				if (c == '^')
 					c = *cp++;
 				if (c == ']')
 					c = *cp++;
 				first = true;
 				while (c != '\0' && c != ']') {
 					if (c == '-') {
 						if (!first && *cp != ']')
 							outqchar(c);
+					}
 					first = false;
 					c = *cp++;
+				}
 				if (c == ']') {
 					outqchar(c);
 					c = *cp++;
+				}
+			}
+		}
+	}
 	outchar('"');
+}
 /*
  * writes a record if sym was used
  */
 void
 outusg(const sym_t *sym)
+{
 	/* reset buffer */
 	outclr();
 	/*
 	 * line number of .c source, 'u' for used, Id of current
 	 * source (.c or .h), and line in current source
 	 */
 	outint(csrc_pos.p_line);
 	outchar('u');
 	outint(get_filename_id(curr_pos.p_file));
 	outchar('.');
 	outint(curr_pos.p_line);
 	/* necessary to delimit both numbers */
 	outchar('x');
 	outname(sym->s_name);
+}

 @@ -1,1039 +1,1039 @@
-/*	$NetBSD: tree.c,v 1.314 2021/07/14 17:07:24 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.315 2021/07/15 17:03:50 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.314 2021/07/14 17:07:24 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.315 2021/07/15 17:03:50 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);
 static	void	check_pointer_comparison(op_t,
 					 const tnode_t *, const tnode_t *);
 static	bool	check_assign_types_compatible(op_t, int,
 					      const tnode_t *, const tnode_t *);
 static	void	check_bad_enum_operation(op_t,
 					 const tnode_t *, const tnode_t *);
 static	void	check_enum_type_mismatch(op_t, int,
 				         const tnode_t *, const tnode_t *);
 static	void	check_enum_int_mismatch(op_t, int,
 					const tnode_t *, const 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, const type_t *, tspec_t,
 					const type_t *, tspec_t);
 static	void	warn_incompatible_pointers(const mod_t *,
 					   const type_t *, const type_t *);
 static	bool	has_constant_member(const 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(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_address(tnode_t *, bool);
 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(const tnode_t *);
 static	void	display_expression(const tnode_t *, int);
 static	void	check_array_index(tnode_t *, bool);
 static	void	check_integer_comparison(op_t, tnode_t *, tnode_t *);
 static	void	check_precedence_confusion(tnode_t *);
 extern sig_atomic_t fpe;
 static const char *
 op_name(op_t op)
+{
 	return modtab[op].m_name;
+}
 #ifdef DEBUG
 void
 debug_node(const tnode_t *tn, int indent)
+{
 	op_t op;
 	if (tn == NULL) {
 		printf("%*s" "null\n", indent, "");
 		return;
+	}
 	op = tn->tn_op;
 	printf("%*s%s with type '%s'%s%s",
 * indent, "",
 	    op == CVT && !tn->tn_cast ? "convert" : op_name(op),
 	    type_name(tn->tn_type), tn->tn_lvalue ? ", lvalue" : "",
 	    tn->tn_parenthesized ? ", parenthesized" : "");
 	if (op == NAME)
 		printf(" %s\n", tn->tn_sym->s_name);
 	else if (op == CON && is_floating(tn->tn_type->t_tspec))
 		printf(", value %Lg", tn->tn_val->v_ldbl);
 	else if (op == CON && is_uinteger(tn->tn_type->t_tspec))
 		printf(", value %llu\n", (unsigned long long)tn->tn_val->v_quad);
 	else if (op == CON && is_integer(tn->tn_type->t_tspec))
 		printf(", value %lld\n", (long long)tn->tn_val->v_quad);
 	else if (op == CON)
 		printf(", unknown value\n");
 	else if (op == STRING)
 		printf(", length %zu\n", tn->tn_string->st_len);
 	else {
 		printf("\n");
 		debug_node(tn->tn_left, indent + 1);
 		if (modtab[op].m_binary || tn->tn_right != NULL)
 			debug_node(tn->tn_right, indent + 1);
+	}
+}
 #endif
 /* Build 'pointer to tp', 'array of tp' or 'function returning tp'. */
 type_t *
 derive_type(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
 	tp2 = getblk(sizeof(*tp2));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Build 'pointer to tp', 'array of tp' or 'function returning tp'.  The
  * memory is freed at the end of the current expression.
  */
 type_t *
 expr_derive_type(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
 	tp2 = expr_zalloc(sizeof(*tp2));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Create a node for a constant.
  */
 tnode_t *
 expr_new_constant(type_t *tp, val_t *v)
+{
 	tnode_t	*n;
 	n = expr_zalloc_tnode();
 	n->tn_op = CON;
 	n->tn_type = tp;
 	n->tn_val = expr_zalloc(sizeof(*n->tn_val));
 	n->tn_val->v_tspec = tp->t_tspec;
 	n->tn_val->v_unsigned_since_c90 = v->v_unsigned_since_c90;
 	n->tn_val->v_u = v->v_u;
 	free(v);
 	return n;
+}
 static tnode_t *
 expr_new_integer_constant(tspec_t t, int64_t q)
+{
 	tnode_t	*n;
 	n = expr_zalloc_tnode();
 	n->tn_op = CON;
 	n->tn_type = gettyp(t);
 	n->tn_val = expr_zalloc(sizeof(*n->tn_val));
 	n->tn_val->v_tspec = t;
 	n->tn_val->v_quad = q;
 	return n;
+}
 static void
 fallback_symbol(sym_t *sym)
+{
 	if (fallback_symbol_strict_bool(sym))
 		return;
 	if (block_level > 0 && (strcmp(sym->s_name, "__FUNCTION__") == 0 ||
 			   strcmp(sym->s_name, "__PRETTY_FUNCTION__") == 0)) {
 		/* __FUNCTION__/__PRETTY_FUNCTION__ is a GCC extension */
 		gnuism(316);
 		sym->s_type = derive_type(gettyp(CHAR), PTR);
 		sym->s_type->t_const = true;
 		return;
+	}
 	if (block_level > 0 && strcmp(sym->s_name, "__func__") == 0) {
 		if (!Sflag)
 			/* __func__ is a C9X feature */
 			warning(317);
 		sym->s_type = derive_type(gettyp(CHAR), PTR);
 		sym->s_type->t_const = true;
 		return;
+	}
 	/* '%s' undefined */
 	error(99, sym->s_name);
+}
 /* https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html */
 static bool
 is_gcc_builtin(const char *name)
+{
 	return strncmp(name, "__atomic_", 9) == 0 ||
 	       strncmp(name, "__builtin_", 10) == 0;
+}
 /*
  * Create a node for a name (symbol table entry).
  * follow_token is the token which follows the name.
  */
 tnode_t *
 new_name_node(sym_t *sym, int follow_token)
+{
 	tnode_t	*n;
 	if (sym->s_scl == NOSCL) {
 		sym->s_scl = EXTERN;
 		sym->s_def = DECL;
 		if (follow_token == T_LPAREN) {
 			if (gflag && is_gcc_builtin(sym->s_name)) {
 				/*
 				 * Do not warn about these, just assume that
 				 * they are regular functions compatible with
 				 * non-prototype calling conventions.
 				 */
 			} else if (Sflag) {
 				/* function '%s' implicitly declared to ... */
 				warning(215, sym->s_name);
 			} else if (sflag) {
 				/* function '%s' implicitly declared to ... */
 				warning(215, sym->s_name);
+			}
 			/*
 			 * XXX if tflag is set the symbol should be
 			 * exported to level 0
 			 */
 			sym->s_type = derive_type(sym->s_type, FUNC);
 		} else {
 			fallback_symbol(sym);
+		}
+	}
 	lint_assert(sym->s_kind == FVFT || sym->s_kind == FMEMBER);
 	n = expr_zalloc_tnode();
 	n->tn_type = sym->s_type;
 	if (sym->s_scl != CTCONST) {
 		n->tn_op = NAME;
 		n->tn_sym = sym;
 		if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC)
 			n->tn_lvalue = true;
 	} else {
 		n->tn_op = CON;
 		n->tn_val = expr_zalloc(sizeof(*n->tn_val));
 		*n->tn_val = sym->s_value;
+	}
 	return n;
+}
 tnode_t *
 new_string_node(strg_t *strg)
+{
 	size_t	len;
 	tnode_t	*n;
 	len = strg->st_len;
 	n = expr_zalloc_tnode();
 	n->tn_op = STRING;
 	n->tn_type = expr_derive_type(gettyp(strg->st_tspec), ARRAY);
 	n->tn_type->t_dim = len + 1;
 	n->tn_lvalue = true;
 	n->tn_string = expr_zalloc(sizeof(*n->tn_string));
 	n->tn_string->st_tspec = strg->st_tspec;
 	n->tn_string->st_len = len;
 	if (strg->st_tspec == CHAR) {
 		n->tn_string->st_cp = expr_zalloc(len + 1);
 		(void)memcpy(n->tn_string->st_cp, strg->st_cp, len + 1);
 		free(strg->st_cp);
 	} else {
 		size_t size = (len + 1) * sizeof(*n->tn_string->st_wcp);
 		n->tn_string->st_wcp = expr_zalloc(size);
 		(void)memcpy(n->tn_string->st_wcp, strg->st_wcp, size);
 		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)
+{
 	struct_or_union	*str;
 	type_t	*tp;
 	sym_t	*sym, *csym;
 	bool	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) {
 		/* type '%s' does not have member '%s' */
 		error(101, type_name(tn->tn_type), msym->s_name);
 		rmsym(msym);
 		msym->s_kind = FMEMBER;
 		msym->s_scl = MOS;
 		msym->s_styp = expr_zalloc(sizeof(*msym->s_styp));
 		msym->s_styp->sou_tag = expr_zalloc(
 		    sizeof(*msym->s_styp->sou_tag));
 		msym->s_styp->sou_tag->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 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 false if there are struct/union members with the same
 	 * name and different types and/or offsets.
 	 */
 	eq = true;
 	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) {
 			bool 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 = false;
 				break;
+			}
 			w = false;
 			eq = eqtype(csym->s_type, sym->s_type,
 			    false, false, &w) && !w;
 			if (!eq)
 				break;
 			if (csym->s_bitfield != sym->s_bitfield) {
 				eq = false;
 				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 = false;
 					break;
+				}
 				if (tp1->t_foffs != tp2->t_foffs) {
 					eq = false;
 					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, type_name(tn->tn_type));
 			} else {
 				/* left operand of '.' must be struct ... */
 				error(103, type_name(tn->tn_type));
+			}
 		} else {
 			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, op_name(op));
+		}
+	}
 	return msym;
+}
 tnode_t *
 build_generic_selection(const tnode_t *expr,
 			struct generic_association *sel)
+{
 	tnode_t *default_result = NULL;
 	for (; sel != NULL; sel = sel->ga_prev)
 		if (expr != NULL &&
 		    eqtype(sel->ga_arg, expr->tn_type, false, false, NULL))
 			return sel->ga_result;
 		else if (sel->ga_arg == NULL)
 			default_result = sel->ga_result;
 	return default_result;
+}
 /*
  * 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)
+{
 	const mod_t *mp;
 	tnode_t	*ntn;
 	type_t	*rettp;
 	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_left_value_context || mp->m_left_test_context)
 		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_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, 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, 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_unsigned_since_c90) {
 		/* ANSI C treats constant as unsigned, op %s */
 		warning(218, mp->m_name);
 		ln->tn_val->v_unsigned_since_c90 = false;
+	}
 	if (mp->m_warn_if_right_unsigned_in_c90 &&
 	    rn->tn_op == CON && rn->tn_val->v_unsigned_since_c90) {
 		/* ANSI C treats constant as unsigned, op %s */
 		warning(218, mp->m_name);
 		rn->tn_val->v_unsigned_since_c90 = false;
+	}
 	/* Make sure both operands are of the same type */
 	if (mp->m_balance_operands || (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 ADDR:
 		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:
 		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:
 		rettp = mp->m_returns_bool
 		    ? gettyp(Tflag ? BOOL : INT) : ln->tn_type;
 		lint_assert(mp->m_binary || rn == NULL);
 		ntn = new_tnode(op, rettp, ln, rn);
 		break;
+	}
 	/* Return if an error occurred. */
 	if (ntn == NULL)
 		return NULL;
 	/* Print a warning if precedence confusion is possible */
 	if (mp->m_possible_precedence_confusion)
 		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_left_test_context) {
 		if (ln->tn_op == CON ||
 		    ((mp->m_binary && op != QUEST) && rn->tn_op == CON)) {
 			if (hflag && !constcond_flag &&
 			    !ln->tn_system_dependent)
 				/* constant in conditional context */
 				warning(161);
+		}
+	}
 	/* Fold if the operator requires it */
 	if (mp->m_fold_constant_operands) {
 		if (ln->tn_op == CON && (!mp->m_binary || rn->tn_op == CON)) {
 			if (mp->m_left_test_context) {
 				ntn = fold_test(ntn);
 			} else if (is_floating(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 != 0
 			    ? rn->tn_left : rn->tn_right;
+		}
+	}
 	return ntn;
+}
 tnode_t *
 build_member_access(tnode_t *ln, op_t op, sbuf_t *member)
+{
 	sym_t	*msym;
 	if (ln == NULL)
 		return NULL;
 	if (op == ARROW) {
 		/* must do this before struct_or_union_member is called */
 		ln = cconv(ln);
+	}
 	msym = struct_or_union_member(ln, op, getsym(member));
 	return build(op, ln, new_name_node(msym, 0));
+}
 /*
  * 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.
+ *
  * C99 6.3 "Conversions"
  * C99 6.3.2 "Other operands"
  * C99 6.3.2.1 "Lvalues, arrays, and function designators"
  */
 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, "", 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);
 	/* lvalue to rvalue */
 	if (tn->tn_lvalue) {
 		tp = expr_dup_type(tn->tn_type);
 		/* C99 6.3.2.1p2 sentence 2 says to remove the qualifiers. */
 		tp->t_const = tp->t_volatile = false;
 		tn = new_tnode(LOAD, tp, tn, NULL);
+	}
 	return tn;
+}
 const tnode_t *
 before_conversion(const tnode_t *tn)
+{
 	while (tn->tn_op == CVT && !tn->tn_cast)
 		tn = tn->tn_left;
 	return tn;
+}
 static bool
 is_null_pointer(const tnode_t *tn)
+{
 	tspec_t t = tn->tn_type->t_tspec;
 	return ((t == PTR && tn->tn_type->t_subt->t_tspec == VOID) ||
 		is_integer(t))
 	       && (tn->tn_op == CON && tn->tn_val->v_quad == 0);
+}
 static bool
 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) {
 			/* a cast does not yield an lvalue */
 			error(163);
+		}
 		/* %soperand of '%s' must be lvalue */
 		error(114, "", op_name(op));
 		return false;
 	} else if (tp->t_const) {
 		if (!tflag)
 			/* %soperand of '%s' must be modifiable lvalue */
 			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) {
 			/* a cast does not yield an lvalue */
 			error(163);
+		}
 		/* %soperand of '%s' must be lvalue */
 		error(114, "", mp->m_name);
 		return false;
 	} else if (is_scalar(t)) {
 		if (tp->t_bitfield) {
 			/* cannot take address of bit-field */
 			error(112);
 			return false;
+		}
 	} else if (t != STRUCT && t != UNION) {
 		/* unacceptable operand of '%s' */
 		error(111, mp->m_name);
 		return false;
+	}
 	if (tn->tn_op == NAME && tn->tn_sym->s_reg) {
 		/* cannot take address of register %s */
 		error(113, tn->tn_sym->s_name);
 		return false;
+	}
 	return true;
+}
 static bool
 typeok_star(tspec_t t)
+{
 	/* until now there were no type checks for this operator */
 	if (t != PTR) {
 		/* cannot dereference non-pointer type */
 		error(96);
 		return false;
+	}
 	return true;
+}
 static bool
 typeok_plus(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 && !is_integer(lt))) {
 		warn_incompatible_types(op, ltp, lt, rtp, rt);
 		return false;
+	}
 	return true;
+}
 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, ltp, lt, rtp, rt);
 		return false;
 	} else if (rt == PTR && lt != PTR) {
 		warn_incompatible_types(op, ltp, lt, rtp, rt);
 		return false;
+	}
 	if (lt == PTR && rt == PTR) {
 		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;
 	olt = before_conversion(ln)->tn_type->t_tspec;
 	ort = before_conversion(rn)->tn_type->t_tspec;
 	/* operands have integer types (checked above) */
 	if (pflag && !is_uinteger(lt)) {
 		/*
 		 * The left operand is signed. This means that
 		 * the operation is (possibly) nonportable.
 		 */
 		if (ln->tn_op != CON) {
 			/* bitwise '%s' on signed value possibly nonportable */
 			warning(117, mp->m_name);
 		} else if (ln->tn_val->v_quad < 0) {
 			/* bitwise '%s' on signed value nonportable */
 			warning(120, mp->m_name);
+		}
 	} else if (!tflag && !sflag && !is_uinteger(olt) && is_uinteger(ort)) {
 		/*
 		 * The left operand would become unsigned in
 		 * traditional C.
 		 */
 		if (hflag && !Sflag &&
 		    (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
 			/* semantics of '%s' change in ANSI C; use ... */
 			warning(118, mp->m_name);
+		}
 	} else if (!tflag && !sflag && !is_uinteger(olt) && !is_uinteger(ort) &&
 		   portable_size_in_bits(lt) < portable_size_in_bits(rt)) {
 		/*
 		 * In traditional C the left operand would be extended,
 		 * possibly with 1, and then shifted.
 		 */
 		if (hflag && !Sflag &&
 		    (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
 			/* semantics of '%s' change in ANSI C; use ... */
 			warning(118, mp->m_name);
+		}
+	}
+}
 static void
 typeok_shl(const mod_t *mp, tspec_t lt, tspec_t rt)
+{
 	/*
 	 * C90 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, then 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 (portable_size_in_bits(lt) < portable_size_in_bits(rt)) {
 		/*
 		 * XXX If both operands are constant, make sure
 		 * that there is really a difference between
 		 * ANSI C and traditional C.
 		 */
 		if (hflag && !Sflag)
 			/* semantics of '%s' change in ANSI C; use ... */
 			warning(118, mp->m_name);
+	}
+}
 static void
 typeok_shift(tspec_t lt, const tnode_t *rn, tspec_t rt)
+{
 	if (rn->tn_op != CON)
 		return;
 	if (!is_uinteger(rt) && rn->tn_val->v_quad < 0) {
 		/* negative shift */
 		warning(121);
 	} else if ((uint64_t)rn->tn_val->v_quad ==
 		   (uint64_t)size_in_bits(lt)) {
 		/* shift equal to size of object */
 		warning(267);
 	} else if ((uint64_t)rn->tn_val->v_quad > (uint64_t)size_in_bits(lt)) {
 		/* shift amount %llu is greater than bit-size %llu of '%s' */
 		warning(122, (unsigned long long)rn->tn_val->v_quad,
 		    (unsigned long long)size_in_bits(lt),
 		    tspec_name(lt));
+	}
+}
 static bool
 is_typeok_eq(const tnode_t *ln, tspec_t lt, const tnode_t *rn, tspec_t rt)
+{
 	if (lt == PTR && is_null_pointer(rn))
 		return true;
 	if (rt == PTR && is_null_pointer(ln))
 		return true;
 	return false;
+}
 static bool
 typeok_ordered_comparison(op_t op,
 			  const tnode_t *ln, const type_t *ltp, tspec_t lt,
 			  const tnode_t *rn, const type_t *rtp, tspec_t rt)
+{
 	if (lt == PTR && rt == PTR) {
 		check_pointer_comparison(op, ln, rn);
 		return true;
+	}
 	if (lt != PTR && rt != PTR)
 		return true;
 	if (!is_integer(lt) && !is_integer(rt)) {
 		warn_incompatible_types(op, ltp, lt, rtp, rt);
 		return false;
+	}
 	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), op_name(op));
 	return true;
+}
 static bool
 typeok_quest(tspec_t lt, const tnode_t **rn)
+{
 	if (!is_scalar(lt)) {
 		/* first operand must have scalar type, op ? : */
 		error(170);
 		return false;
+	}
 	while ((*rn)->tn_op == CVT)
 		*rn = (*rn)->tn_left;
 	lint_assert((*rn)->tn_op == COLON);
 	return true;
+}
 static void
 typeok_colon_pointer(const mod_t *mp, const type_t *ltp, const type_t *rtp)
+{
 	type_t *lstp = ltp->t_subt;
 	type_t *rstp = rtp->t_subt;
 	tspec_t lst = lstp->t_tspec;
 	tspec_t rst = rstp->t_tspec;
 	if ((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;
+	}
 	if (eqptrtype(lstp, rstp, true))
 		return;
 	if (!eqtype(lstp, rstp, true, false, NULL))
 		warn_incompatible_pointers(mp, ltp, rtp);
+}
 static bool
 typeok_colon(const mod_t *mp,
 @@ -2819,1500 +2819,1500 @@ build_colon(tnode_t *ln, tnode_t *rn)
 	return ntn;
+}
 /*
  * Create a node for an assignment operator (both = and op= ).
  */
 static tnode_t *
 build_assignment(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	tspec_t	lt, rt;
 	tnode_t	*ntn, *ctn;
 	lint_assert(ln != NULL);
 	lint_assert(rn != NULL);
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	if ((op == ADDASS || op == SUBASS) && lt == PTR) {
 		lint_assert(is_integer(rt));
 		ctn = plength(ln->tn_type);
 		if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec)
 			rn = convert(NOOP, 0, ctn->tn_type, rn);
 		rn = new_tnode(MULT, rn->tn_type, rn, ctn);
 		if (rn->tn_left->tn_op == CON)
 			rn = fold(rn);
+	}
 	if ((op == ASSIGN || op == RETURN) && (lt == STRUCT || rt == STRUCT)) {
 		lint_assert(lt == rt);
 		lint_assert(ln->tn_type->t_str == rn->tn_type->t_str);
 		if (is_incomplete(ln->tn_type)) {
 			if (op == RETURN) {
 				/* cannot return incomplete type */
 				error(212);
 			} else {
 				/* unknown operand size, op %s */
 				error(138, op_name(op));
+			}
 			return NULL;
+		}
+	}
 	if (op == SHLASS) {
 		if (portable_size_in_bits(lt) < portable_size_in_bits(rt)) {
 			if (hflag)
 				/* semantics of '%s' change in ANSI C; ... */
 				warning(118, "<<=");
+		}
 	} else if (op != SHRASS) {
 		if (op == ASSIGN || lt != PTR) {
 			if (lt != rt ||
 			    (ln->tn_type->t_bitfield && rn->tn_op == CON)) {
 				rn = convert(op, 0, ln->tn_type, rn);
 				rt = lt;
+			}
+		}
+	}
 	ntn = new_tnode(op, ln->tn_type, ln, rn);
 	return ntn;
+}
 /*
  * Get length of type tp->t_subt.
  */
 static tnode_t *
 plength(type_t *tp)
+{
 	int	elem, elsz;
 	lint_assert(tp->t_tspec == PTR);
 	tp = tp->t_subt;
 	elem = 1;
 	elsz = 0;
 	while (tp->t_tspec == ARRAY) {
 		elem *= tp->t_dim;
 		tp = tp->t_subt;
+	}
 	switch (tp->t_tspec) {
 	case FUNC:
 		/* pointer to function is not allowed here */
 		error(110);
 		break;
 	case VOID:
 		/* cannot do pointer arithmetic on operand of unknown size */
 		gnuism(136);
 		break;
 	case STRUCT:
 	case UNION:
 		if ((elsz = tp->t_str->sou_size_in_bits) == 0)
 			/* cannot do pointer arithmetic on operand of ... */
 			error(136);
 		break;
 	case ENUM:
 		if (is_incomplete(tp)) {
 			/* cannot do pointer arithmetic on operand of ... */
 			warning(136);
+		}
 		/* FALLTHROUGH */
 	default:
 		if ((elsz = size_in_bits(tp->t_tspec)) == 0) {
 			/* cannot do pointer arithmetic on operand of ... */
 			error(136);
 		} else {
 			lint_assert(elsz != -1);
+		}
 		break;
+	}
 	if (elem == 0 && elsz != 0) {
 		/* cannot do pointer arithmetic on operand of unknown size */
 		error(136);
+	}
 	if (elsz == 0)
 		elsz = CHAR_SIZE;
 	return expr_new_integer_constant(PTRDIFF_TSPEC,
 	    (int64_t)(elem * elsz / CHAR_SIZE));
+}
 /*
  * XXX
  * Note: There appear to be a number of bugs in detecting overflow in
  * this function. An audit and a set of proper regression tests are needed.
  *     --Perry Metzger, Nov. 16, 2001
  */
 /*
  * Do only as much as necessary to compute constant expressions.
  * Called only if the operator allows folding and all operands are constants.
  */
 static tnode_t *
 fold(tnode_t *tn)
+{
 	val_t	*v;
 	tspec_t	t;
 	bool	utyp, ovfl;
 	int64_t	sl, sr = 0, q = 0, mask;
 	uint64_t ul, ur = 0;
 	tnode_t	*cn;
 	v = xcalloc(1, sizeof(*v));
 	v->v_tspec = t = tn->tn_type->t_tspec;
 	utyp = t == PTR || is_uinteger(t);
 	ul = sl = tn->tn_left->tn_val->v_quad;
 	if (modtab[tn->tn_op].m_binary)
 		ur = sr = tn->tn_right->tn_val->v_quad;
 	mask = value_bits(size_in_bits(t));
 	ovfl = false;
 	switch (tn->tn_op) {
 	case UPLUS:
 		q = sl;
 		break;
 	case UMINUS:
 		q = -sl;
 		if (sl != 0 && msb(q, t, -1) == msb(sl, t, -1))
 			ovfl = true;
 		break;
 	case COMPL:
 		q = ~sl;
 		break;
 	case MULT:
 		if (utyp) {
 			q = ul * ur;
 			if (q != (q & mask))
 				ovfl = true;
 			else if ((ul != 0) && ((q / ul) != ur))
 				ovfl = true;
 		} else {
 			q = sl * sr;
 			if (msb(q, t, -1) != (msb(sl, t, -1) ^ msb(sr, t, -1)))
 				ovfl = true;
+		}
 		break;
 	case DIV:
 		if (sr == 0) {
 			/* division by 0 */
 			error(139);
 			q = utyp ? UQUAD_MAX : QUAD_MAX;
 		} else {
 			q = utyp ? (int64_t)(ul / ur) : sl / sr;
+		}
 		break;
 	case MOD:
 		if (sr == 0) {
 			/* modulus by 0 */
 			error(140);
 			q = 0;
 		} else {
 			q = utyp ? (int64_t)(ul % ur) : sl % sr;
+		}
 		break;
 	case PLUS:
 		q = utyp ? (int64_t)(ul + ur) : sl + sr;
 		if (msb(sl, t, -1)  != 0 && msb(sr, t, -1) != 0) {
 			if (msb(q, t, -1) == 0)
 				ovfl = true;
 		} else if (msb(sl, t, -1) == 0 && msb(sr, t, -1) == 0) {
 			if (msb(q, t, -1) != 0)
 				ovfl = true;
+		}
 		break;
 	case MINUS:
 		q = utyp ? (int64_t)(ul - ur) : sl - sr;
 		if (msb(sl, t, -1) != 0 && msb(sr, t, -1) == 0) {
 			if (msb(q, t, -1) == 0)
 				ovfl = true;
 		} else if (msb(sl, t, -1) == 0 && msb(sr, t, -1) != 0) {
 			if (msb(q, t, -1) != 0)
 				ovfl = true;
+		}
 		break;
 	case SHL:
 		q = utyp ? (int64_t)(ul << sr) : sl << sr;
 		break;
 	case SHR:
 		/*
 		 * The sign must be explicitly extended because
 		 * shifts of signed values are implementation dependent.
 		 */
 		q = ul >> sr;
 		q = convert_integer(q, t, size_in_bits(t) - (int)sr);
 		break;
 	case LT:
 		q = (utyp ? ul < ur : sl < sr) ? 1 : 0;
 		break;
 	case LE:
 		q = (utyp ? ul <= ur : sl <= sr) ? 1 : 0;
 		break;
 	case GE:
 		q = (utyp ? ul >= ur : sl >= sr) ? 1 : 0;
 		break;
 	case GT:
 		q = (utyp ? ul > ur : sl > sr) ? 1 : 0;
 		break;
 	case EQ:
 		q = (utyp ? ul == ur : sl == sr) ? 1 : 0;
 		break;
 	case NE:
 		q = (utyp ? ul != ur : sl != sr) ? 1 : 0;
 		break;
 	case BITAND:
 		q = utyp ? (int64_t)(ul & ur) : sl & sr;
 		break;
 	case BITXOR:
 		q = utyp ? (int64_t)(ul ^ ur) : sl ^ sr;
 		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, op_name(tn->tn_op));
+	}
 	v->v_quad = convert_integer(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;
+}
 /*
  * Fold constant nodes, as much as is needed for comparing the value with 0
  * (test context, for controlling expressions).
  */
 static tnode_t *
 fold_test(tnode_t *tn)
+{
 	bool	l, r;
 	val_t	*v;
 	v = xcalloc(1, sizeof(*v));
 	v->v_tspec = tn->tn_type->t_tspec;
 	lint_assert(v->v_tspec == INT || (Tflag && v->v_tspec == BOOL));
 	l = constant_is_nonzero(tn->tn_left);
 	r = modtab[tn->tn_op].m_binary && constant_is_nonzero(tn->tn_right);
 	switch (tn->tn_op) {
 	case NOT:
 		if (hflag && !constcond_flag)
 			/* constant argument to '!' */
 			warning(239);
 		v->v_quad = !l ? 1 : 0;
 		break;
 	case LOGAND:
 		v->v_quad = l && r ? 1 : 0;
 		break;
 	case LOGOR:
 		v->v_quad = l || r ? 1 : 0;
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
 	return expr_new_constant(tn->tn_type, v);
+}
 /*
  * Fold constant nodes having operands with floating point type.
  */
 static tnode_t *
 fold_float(tnode_t *tn)
+{
 	val_t	*v;
 	tspec_t	t;
 	ldbl_t	l, r = 0;
 	fpe = 0;
 	v = xcalloc(1, sizeof(*v));
 	v->v_tspec = t = tn->tn_type->t_tspec;
 	lint_assert(is_floating(t));
 	lint_assert(t == tn->tn_left->tn_type->t_tspec);
 	lint_assert(!modtab[tn->tn_op].m_binary ||
 	    t == tn->tn_right->tn_type->t_tspec);
 	l = tn->tn_left->tn_val->v_ldbl;
 	if (modtab[tn->tn_op].m_binary)
 		r = tn->tn_right->tn_val->v_ldbl;
 	switch (tn->tn_op) {
 	case UPLUS:
 		v->v_ldbl = l;
 		break;
 	case UMINUS:
 		v->v_ldbl = -l;
 		break;
 	case MULT:
 		v->v_ldbl = l * r;
 		break;
 	case DIV:
 		if (r == 0.0) {
 			/* division by 0 */
 			error(139);
 			if (t == FLOAT) {
 				v->v_ldbl = l < 0 ? -FLT_MAX : FLT_MAX;
 			} else if (t == DOUBLE) {
 				v->v_ldbl = l < 0 ? -DBL_MAX : DBL_MAX;
 			} else {
 				v->v_ldbl = l < 0 ? -LDBL_MAX : LDBL_MAX;
+			}
 		} else {
 			v->v_ldbl = l / r;
+		}
 		break;
 	case PLUS:
 		v->v_ldbl = l + r;
 		break;
 	case MINUS:
 		v->v_ldbl = l - r;
 		break;
 	case LT:
 		v->v_quad = l < r ? 1 : 0;
 		break;
 	case LE:
 		v->v_quad = l <= r ? 1 : 0;
 		break;
 	case GE:
 		v->v_quad = l >= r ? 1 : 0;
 		break;
 	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) == 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, 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);
+}
 /*
  * Create a constant node for sizeof.
  */
 tnode_t *
 build_sizeof(const type_t *tp)
+{
 	int64_t size_in_bytes = type_size_in_bits(tp) / CHAR_SIZE;
 	tnode_t *tn = expr_new_integer_constant(SIZEOF_TSPEC, size_in_bytes);
 	tn->tn_system_dependent = true;
 	return tn;
+}
 /*
  * Create a constant node for offsetof.
  */
 tnode_t *
 build_offsetof(const type_t *tp, const sym_t *sym)
+{
 	tspec_t t = tp->t_tspec;
 	if (t != STRUCT && t != UNION)
 		/* unacceptable operand of '%s' */
 		error(111, "offsetof");
 	// XXX: wrong size, no checking for sym fixme
 	int64_t offset_in_bytes = type_size_in_bits(tp) / CHAR_SIZE;
 	tnode_t *tn = expr_new_integer_constant(SIZEOF_TSPEC, offset_in_bytes);
 	tn->tn_system_dependent = true;
 	return tn;
+}
 int64_t
 type_size_in_bits(const type_t *tp)
+{
 	int	elem, elsz;
 	bool	flex;
 	elem = 1;
 	flex = false;
 	while (tp->t_tspec == ARRAY) {
 		flex = true;	/* allow c99 flex arrays [] [0] */
 		elem *= tp->t_dim;
 		tp = tp->t_subt;
+	}
 	if (elem == 0) {
 		if (!flex) {
 			/* cannot take size/alignment of incomplete type */
 			error(143);
 			elem = 1;
+		}
+	}
 	switch (tp->t_tspec) {
 	case FUNC:
 		/* cannot take size/alignment of function */
 		error(144);
 		elsz = 1;
 		break;
 	case STRUCT:
 	case UNION:
 		if (is_incomplete(tp)) {
 			/* cannot take size/alignment of incomplete type */
 			error(143);
 			elsz = 1;
 		} else {
 			elsz = tp->t_str->sou_size_in_bits;
+		}
 		break;
 	case ENUM:
 		if (is_incomplete(tp)) {
 			/* cannot take size/alignment of incomplete type */
 			warning(143);
+		}
 		/* FALLTHROUGH */
 	default:
 		if (tp->t_bitfield) {
 			/* cannot take size/alignment of bit-field */
 			error(145);
+		}
 		if (tp->t_tspec == VOID) {
 			/* cannot take size/alignment of void */
 			error(146);
 			elsz = 1;
 		} else {
 			elsz = size_in_bits(tp->t_tspec);
 			lint_assert(elsz > 0);
+		}
 		break;
+	}
 	return (int64_t)elem * elsz;
+}
 tnode_t *
 build_alignof(const type_t *tp)
+{
 	switch (tp->t_tspec) {
 	case ARRAY:
 		break;
 	case FUNC:
 		/* cannot take size/alignment of function */
 		error(144);
 		return 0;
 	case STRUCT:
 	case UNION:
 		if (is_incomplete(tp)) {
 			/* cannot take size/alignment of incomplete type */
 			error(143);
 			return 0;
+		}
 		break;
 	case ENUM:
 		break;
 	default:
 		if (tp->t_bitfield) {
 			/* cannot take size/alignment of bit-field */
 			error(145);
 			return 0;
+		}
 		if (tp->t_tspec == VOID) {
 			/* cannot take size/alignment of void */
 			error(146);
 			return 0;
+		}
 		break;
+	}
 	return expr_new_integer_constant(SIZEOF_TSPEC,
 	    (int64_t)alignment_in_bits(tp) / CHAR_SIZE);
+}
 /*
  * Type casts.
  */
 tnode_t *
 cast(tnode_t *tn, type_t *tp)
+{
 	tspec_t	nt, ot;
 	if (tn == NULL)
 		return NULL;
 	/*
 	 * XXX: checking for tp == NULL is only a quick fix for PR 22119.
 	 *  The proper fix needs to be investigated properly.
 	 *  See d_pr_22119.c for how to get here.
 	 */
 	if (tp == NULL)
 		return NULL;
 	tn = cconv(tn);
 	nt = tp->t_tspec;
 	ot = tn->tn_type->t_tspec;
 	if (nt == VOID) {
 		/*
 		 * XXX ANSI C requires scalar types or void (Plauger & Brodie).
 		 * But this seems really questionable.
 		 */
 	} else if (nt == UNION) {
 		sym_t *m;
 		struct_or_union *str = tp->t_str;
 		if (!Sflag) {
 			/* union cast is a C9X feature */
 			error(328);
 			return NULL;
+		}
 		for (m = str->sou_first_member; m != NULL; m = m->s_next) {
 			if (sametype(m->s_type, tn->tn_type)) {
 				tn = expr_zalloc_tnode();
 				tn->tn_op = CVT;
 				tn->tn_type = tp;
 				tn->tn_cast = true;
 				tn->tn_right = NULL;
 				return tn;
+			}
+		}
 		/* type '%s' is not a member of '%s' */
 		error(329, type_name(tn->tn_type), type_name(tp));
 		return NULL;
 	} else if (nt == STRUCT || nt == ARRAY || nt == FUNC) {
 		if (!Sflag || nt == ARRAY || nt == FUNC) {
 			/* invalid cast expression */
 			error(147);
 			return NULL;
+		}
 	} else if (ot == STRUCT || ot == UNION) {
 		/* invalid cast expression */
 		error(147);
 		return NULL;
 	} else if (ot == VOID) {
 		/* improper cast of void expression */
 		error(148);
 		return NULL;
 	} else if (is_integer(nt) && is_scalar(ot)) {
 		/* ok */
 	} else if (is_floating(nt) && is_arithmetic(ot)) {
 		/* ok */
 	} else if (nt == PTR && is_integer(ot)) {
 		/* ok */
 	} else if (nt == PTR && ot == PTR) {
 		if (!tp->t_subt->t_const && tn->tn_type->t_subt->t_const) {
 			if (hflag)
 				/* cast discards 'const' from type '%s' */
 				warning(275, type_name(tn->tn_type));
+		}
 	} else {
 		/* invalid cast expression */
 		error(147);
 		return NULL;
+	}
 	tn = convert(CVT, 0, tp, tn);
 	tn->tn_cast = true;
 	return tn;
+}
 /*
  * Create the node for a function argument.
  * All necessary conversions and type checks are done in
  * new_function_call_node because new_function_argument_node has no
  * information about expected argument types.
  */
 tnode_t *
 new_function_argument_node(tnode_t *args, tnode_t *arg)
+{
 	tnode_t	*ntn;
 	/*
 	 * If there was a serious error in the expression for the argument,
 	 * create a dummy argument so the positions of the remaining arguments
 	 * will not change.
 	 */
 	if (arg == NULL)
 		arg = expr_new_integer_constant(INT, 0);
 	ntn = new_tnode(PUSH, arg->tn_type, arg, args);
 	return ntn;
+}
 /*
  * Create the node for a function call. Also check types of
  * function arguments and insert conversions, if necessary.
  */
 tnode_t *
 new_function_call_node(tnode_t *func, tnode_t *args)
+{
 	tnode_t	*ntn;
 	op_t	fcop;
 	if (func == NULL)
 		return NULL;
 	if (func->tn_op == NAME && func->tn_type->t_tspec == FUNC) {
 		fcop = CALL;
 	} else {
 		fcop = ICALL;
+	}
 	check_ctype_function_call(func, args);
 	/*
 	 * after cconv() func will always be a pointer to a function
 	 * if it is a valid function designator.
 	 */
 	func = cconv(func);
 	if (func->tn_type->t_tspec != PTR ||
 	    func->tn_type->t_subt->t_tspec != FUNC) {
 		/* illegal function (type %s) */
 		error(149, type_name(func->tn_type));
 		return NULL;
+	}
 	args = check_function_arguments(func->tn_type->t_subt, args);
 	ntn = new_tnode(fcop, func->tn_type->t_subt->t_subt, func, args);
 	return ntn;
+}
 /*
  * Check types of all function arguments and insert conversions,
  * if necessary.
  */
 static tnode_t *
 check_function_arguments(type_t *ftp, tnode_t *args)
+{
 	tnode_t	*arg;
 	sym_t	*asym;
 	tspec_t	at;
 	int	narg, npar, n, i;
 	/* get # of args in the prototype */
 	npar = 0;
 	for (asym = ftp->t_args; asym != NULL; asym = asym->s_next)
 		npar++;
 	/* get # of args in function call */
 	narg = 0;
 	for (arg = args; arg != NULL; arg = arg->tn_right)
 		narg++;
 	asym = ftp->t_args;
 	if (ftp->t_proto && npar != narg && !(ftp->t_vararg && npar < narg)) {
 		/* argument mismatch: %d arg%s passed, %d expected */
 		error(150, narg, narg > 1 ? "s" : "", npar);
 		asym = NULL;
+	}
 	for (n = 1; n <= narg; n++) {
 		/*
 		 * The rightmost argument is at the top of the argument
 		 * subtree.
 		 */
 		for (i = narg, arg = args; i > n; i--, arg = arg->tn_right)
 			continue;
 		/* some things which are always not allowed */
 		if ((at = arg->tn_left->tn_type->t_tspec) == VOID) {
 			/* void expressions may not be arguments, arg #%d */
 			error(151, n);
 			return NULL;
 		} else if ((at == STRUCT || at == UNION) &&
 			   is_incomplete(arg->tn_left->tn_type)) {
 			/* argument cannot have unknown size, arg #%d */
 			error(152, n);
 			return NULL;
 		} else if (is_integer(at) &&
 			   arg->tn_left->tn_type->t_is_enum &&
 			   is_incomplete(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, 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
  * are not the same, insert a conversion to convert the argument into
  * the type of the parameter.
  */
 static tnode_t *
 check_prototype_argument(
 	int	n,		/* pos of arg */
 	type_t	*tp,		/* expected type (from prototype) */
 	tnode_t	*tn)		/* argument */
+{
 	tnode_t	*ln;
 	bool	dowarn;
 	ln = xcalloc(1, sizeof(*ln));
 	ln->tn_type = expr_dup_type(tp);
 	ln->tn_type->t_const = false;
 	ln->tn_lvalue = true;
 	if (typeok(FARG, n, ln, tn)) {
 		if (!eqtype(tp, tn->tn_type,
 		    true, false, (dowarn = false, &dowarn)) || dowarn)
 			tn = convert(FARG, n, tp, tn);
+	}
 	free(ln);
 	return tn;
+}
 /*
  * 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, false, tn);
 	v = xcalloc(1, sizeof(*v));
 	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;
 	if (tn->tn_op == CON) {
 		lint_assert(tn->tn_type->t_tspec == tn->tn_val->v_tspec);
 		if (is_integer(tn->tn_val->v_tspec)) {
 			v->v_unsigned_since_c90 =
 			    tn->tn_val->v_unsigned_since_c90;
 			v->v_quad = tn->tn_val->v_quad;
 			return v;
+		}
 		v->v_quad = tn->tn_val->v_ldbl;
 	} else {
 		v->v_quad = 1;
+	}
 	if (required)
 		/* integral constant expression expected */
 		error(55);
 	else
 		/* variable array dimension is a C99/GCC extension */
 		c99ism(318);
 	if (!is_integer(v->v_tspec))
 		v->v_tspec = INT;
 	return v;
+}
 static bool
 is_constcond_false(const tnode_t *tn, tspec_t t)
+{
 	return (t == BOOL || t == INT) &&
 	       tn->tn_op == CON && tn->tn_val->v_quad == 0;
+}
 /*
  * Perform some tests on expressions which can't be done in build() and
  * functions called by build(). These tests must be done here because
  * we need some information about the context in which the operations
  * are performed.
  * After all tests are performed and dofreeblk is true, expr() frees the
  * memory which is used for the expression.
  */
 void
 expr(tnode_t *tn, bool vctx, bool tctx, bool dofreeblk, bool is_do_while)
+{
 	if (tn == NULL) {	/* in case of errors */
 		expr_free_all();
 		return;
+	}
 	/* expr() is also called in global initializations */
 	if (dcs->d_ctx != EXTERN && !is_do_while)
 		check_statement_reachable();
 	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 &&
 		    !tn->tn_system_dependent &&
 		    !(is_do_while &&
 		      is_constcond_false(tn, tn->tn_type->t_tspec)))
 			/* 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
 		 */
 		if (tn->tn_op != COMMA && !vctx && !tctx)
 			check_null_effect(tn);
+	}
 	if (dflag)
 		display_expression(tn, 0);
 	/* free the tree memory */
 	if (dofreeblk)
 		expr_free_all();
+}
 static bool
 has_side_effect(const tnode_t *tn) // NOLINT(misc-no-recursion)
+{
 	op_t op = tn->tn_op;
 	if (modtab[op].m_has_side_effect)
 		return true;
 	if (op == CVT && tn->tn_type->t_tspec == VOID)
 		return has_side_effect(tn->tn_left);
 	/* XXX: Why not has_side_effect(tn->tn_left) as well? */
 	if (op == LOGAND || op == LOGOR)
 		return has_side_effect(tn->tn_right);
 	/* XXX: Why not has_side_effect(tn->tn_left) as well? */
 	if (op == QUEST)
 		return has_side_effect(tn->tn_right);
 	if (op == COLON || op == COMMA) {
 		return has_side_effect(tn->tn_left) ||
 		       has_side_effect(tn->tn_right);
+	}
 	return false;
+}
 static void
 check_null_effect(const tnode_t *tn)
+{
 	if (hflag && !has_side_effect(tn)) {
 		/* expression has null effect */
 		warning(129);
+	}
+}
 /*
  * 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, "", 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 && tn->tn_type->t_tspec == BOOL) {
 		(void)printf("%s ",
 		    tn->tn_val->v_quad != 0 ? "true" : "false");
 	} else if (tn->tn_op == CON) {
 		lint_assert(tn->tn_type->t_tspec == PTR);
 		(void)printf("0x%0*lx ", (int)(sizeof(void *) * CHAR_BIT / 4),
 			     (u_long)tn->tn_val->v_quad);
 	} else if (tn->tn_op == STRING) {
 		if (tn->tn_string->st_tspec == CHAR) {
 			(void)printf("\"%s\"", tn->tn_string->st_cp);
 		} else {
 			char	*s;
 			size_t	n;
 			n = MB_CUR_MAX * (tn->tn_string->st_len + 1);
 			s = xmalloc(n);
 			(void)wcstombs(s, tn->tn_string->st_wcp, n);
 			(void)printf("L\"%s\"", s);
 			free(s);
+		}
 		(void)printf(" ");
 	} else if (tn->tn_op == FSEL) {
 		(void)printf("o=%d, l=%d ", tn->tn_type->t_foffs,
 			     tn->tn_type->t_flen);
+	}
-	(void)printf("%s\n", ttos(tn->tn_type));
+	(void)printf("%s\n", type_name(tn->tn_type));
 	if (tn->tn_op == NAME || tn->tn_op == CON || tn->tn_op == STRING)
 		return;
 	display_expression(tn->tn_left, offs + 2);
 	if (modtab[tn->tn_op].m_binary ||
 	    (tn->tn_op == PUSH && tn->tn_right != NULL)) {
 		display_expression(tn->tn_right, offs + 2);
+	}
+}
 /*
  * Called by expr() to recursively perform some tests.
  */
 /* ARGSUSED */
 void
 check_expr_misc(const tnode_t *tn, bool vctx, bool tctx,
 		bool eqwarn, bool fcall, bool rvdisc, bool szof)
+{
 	tnode_t	*ln, *rn;
 	const mod_t *mp;
 	op_t	op;
 	scl_t	sc;
 	dinfo_t	*di;
 	if (tn == NULL)
 		return;
 	ln = tn->tn_left;
 	rn = tn->tn_right;
 	mp = &modtab[op = tn->tn_op];
 	switch (op) {
 	case ADDR:
 		/* XXX: Taking warn_about_unreachable into account here feels wrong. */
 		if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) {
 			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, 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, 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:
 	case XORASS:
 	case SHLASS:
 	case SHRASS:
 	case REAL:
 	case IMAG:
 		/* XXX: Taking warn_about_unreachable into account here feels wrong. */
 		if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) {
 			sc = ln->tn_sym->s_scl;
 			/*
 			 * Look if there was a asm statement in one of the
 			 * 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, false, false);
+		}
 		break;
 	case ASSIGN:
 		/* XXX: Taking warn_about_unreachable into account here feels wrong. */
 		if (ln->tn_op == NAME && !szof && (reached || !warn_about_unreachable)) {
 			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, 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:
 	case NAME:
 	case STRING:
 		return;
 		/* LINTED206: (enumeration values not handled in switch) */
 	case BITOR:
 	case BITXOR:
 	case NE:
 	case GE:
 	case GT:
 	case LE:
 	case LT:
 	case SHR:
 	case SHL:
 	case MINUS:
 	case PLUS:
 	case MOD:
 	case DIV:
 	case MULT:
 	case INDIR:
 	case UMINUS:
 	case UPLUS:
 	case DEC:
 	case INC:
 	case COMPL:
 	case NOT:
 	case POINT:
 	case ARROW:
 	case NOOP:
 	case BITAND:
 	case FARG:
 	case CASE:
 	case INIT:
 	case RETURN:
 	case ICALL:
 	case CVT:
 	case COMMA:
 	case FSEL:
 	case COLON:
 	case QUEST:
 	case LOGOR:
 	case LOGAND:
 		break;
+	}
 	bool cvctx = mp->m_left_value_context;
 	bool ctctx = mp->m_left_test_context;
 	bool eq = mp->m_warn_if_operand_eq &&
 		  !ln->tn_parenthesized &&
 		  rn != NULL && !rn->tn_parenthesized;
 	/*
 	 * 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;
 	bool discard = op == CVT && tn->tn_type->t_tspec == VOID;
 	check_expr_misc(ln, cvctx, ctctx, eq, op == CALL, discard, szof);
 	switch (op) {
 	case PUSH:
 		if (rn != NULL)
 			check_expr_misc(rn, false, false, eq, false, false,
 			    szof);
 		break;
 	case LOGAND:
 	case LOGOR:
 		check_expr_misc(rn, false, true, eq, false, false, szof);
 		break;
 	case COLON:
 		check_expr_misc(rn, cvctx, ctctx, eq, false, false, szof);
 		break;
 	case COMMA:
 		check_expr_misc(rn, vctx, tctx, eq, false, false, szof);
 		break;
 	default:
 		if (mp->m_binary)
 			check_expr_misc(rn, true, false, 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)
+{
 	int	dim;
 	tnode_t	*ln, *rn;
 	int	elsz;
 	int64_t	con;
 	ln = tn->tn_left;
 	rn = tn->tn_right;
 	/* We can only check constant indices. */
 	if (rn->tn_op != CON)
 		return;
 	/* Return if the left node does not stem from an array. */
 	if (ln->tn_op != ADDR)
 		return;
 	if (ln->tn_left->tn_op != STRING && ln->tn_left->tn_op != NAME)
 		return;
 	if (ln->tn_left->tn_type->t_tspec != ARRAY)
 		return;
 	/*
 	 * For incomplete array types, we can print a warning only if
 	 * the index is negative.
 	 */
 	if (is_incomplete(ln->tn_left->tn_type) && rn->tn_val->v_quad >= 0)
 		return;
 	/* Get the size of one array element */
 	if ((elsz = length(ln->tn_type->t_subt, NULL)) == 0)
 		return;
 	elsz /= CHAR_SIZE;
 	/* Change the unit of the index from bytes to element size. */
 	if (is_uinteger(rn->tn_type->t_tspec)) {
 		con = (uint64_t)rn->tn_val->v_quad / elsz;
 	} else {
 		con = rn->tn_val->v_quad / elsz;
+	}
 	dim = ln->tn_left->tn_type->t_dim + (amper ? 1 : 0);
 	if (!is_uinteger(rn->tn_type->t_tspec) && con < 0) {
 		/* array subscript cannot be negative: %ld */
 		warning(167, (long)con);
 	} 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;
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	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, 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, 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", 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", 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), 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), 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.
+ *
  * The expression can consist of PLUS, MINUS, ADDR, NAME, STRING and
  * CON. Type conversions are allowed if they do not change binary
  * representation (including width).
+ *
  * C99 6.6 "Constant expressions"
  * C99 6.7.8p4 restricts initializers for static storage duration
  */
 bool
 constant_addr(const tnode_t *tn, const sym_t **symp, ptrdiff_t *offsp)
+{
 	const sym_t *sym;
 	ptrdiff_t offs1, offs2;
 	tspec_t	t, ot;
 	switch (tn->tn_op) {
 	case MINUS:
 		if (tn->tn_right->tn_op == CVT)
 			return constant_addr(tn->tn_right, symp, offsp);
 		else if (tn->tn_right->tn_op != CON)
 			return false;
 		/* FALLTHROUGH */
 	case PLUS:
 		offs1 = offs2 = 0;
 		if (tn->tn_left->tn_op == CON) {
 			offs1 = (ptrdiff_t)tn->tn_left->tn_val->v_quad;
 			if (!constant_addr(tn->tn_right, &sym, &offs2))
 				return false;
 		} else if (tn->tn_right->tn_op == CON) {
 			offs2 = (ptrdiff_t)tn->tn_right->tn_val->v_quad;
 			if (tn->tn_op == MINUS)
 				offs2 = -offs2;
 			if (!constant_addr(tn->tn_left, &sym, &offs1))
 				return false;
 		} else {
 			return false;
+		}
 		*symp = sym;
 		*offsp = offs1 + offs2;
 		return true;
 	case ADDR:
 		if (tn->tn_left->tn_op == NAME) {
 			*symp = tn->tn_left->tn_sym;
 			*offsp = 0;
 			return true;
 		} else {
 			/*
 			 * If this would be the front end of a compiler we
 			 * would return a label instead of 0, at least if
 			 * 'tn->tn_left->tn_op == STRING'.
 			 */
 			*symp = NULL;
 			*offsp = 0;
 			return true;
+		}
 	case CVT:
 		t = tn->tn_type->t_tspec;
 		ot = tn->tn_left->tn_type->t_tspec;
 		if ((!is_integer(t) && t != PTR) ||
 		    (!is_integer(ot) && ot != PTR)) {
 			return false;
+		}
 #ifdef notdef
 		/*
 		 * consider:
 		 *	struct foo {
 		 *		unsigned char a;
 		 *	} f = {
 		 *		(u_char)(u_long)(&(((struct foo *)0)->a))
 		 *	};
 		 * since psize(u_long) != psize(u_char) this fails.
 		 */
 		else if (psize(t) != psize(ot))
 			return -1;
 #endif
 		return constant_addr(tn->tn_left, symp, offsp);
 	default:
 		return false;
+	}
+}
 /*
  * Concatenate two string constants.
  */
 strg_t *
 cat_strings(strg_t *strg1, strg_t *strg2)
+{
 	size_t	len1, len2, len;
 	if (strg1->st_tspec != strg2->st_tspec) {
 		/* cannot concatenate wide and regular string literals */
 		error(292);
 		return strg1;
+	}
 	len1 = strg1->st_len;
 	len2 = strg2->st_len + 1;	/* + NUL */
 	len = len1 + len2;
 #define COPY(F) \
     do { \
 	strg1->F = xrealloc(strg1->F, len * sizeof(*strg1->F)); \
 	(void)memcpy(strg1->F + len1, strg2->F, len2 * sizeof(*strg1->F)); \
 	free(strg2->F); \
     } while (false)
 	if (strg1->st_tspec == CHAR)
 		COPY(st_cp);
 	else
 		COPY(st_wcp);
 	strg1->st_len = len - 1; /* - NUL */
 	free(strg2);
 	return strg1;
+}
 static bool
 is_confusing_precedence(op_t op, op_t lop, bool lparen, op_t rop, bool rparen)
+{
 	if (op == SHL || op == SHR) {
 		if (!lparen && (lop == PLUS || lop == MINUS))
 			return true;
 		if (!rparen && (rop == PLUS || rop == MINUS))
 			return true;
 		return false;
+	}
 	if (op == LOGOR) {
 		if (!lparen && lop == LOGAND)
 			return true;
 		if (!rparen && rop == LOGAND)
 			return true;
 		return false;
+	}
 	lint_assert(op == BITAND || op == BITXOR || op == BITOR);
 	if (!lparen && lop != op) {
 		if (lop == PLUS || lop == MINUS)
 			return true;
 		if (lop == BITAND || lop == BITXOR)
 			return true;
+	}
 	if (!rparen && rop != op) {
 		if (rop == PLUS || rop == MINUS)
 			return true;
 		if (rop == BITAND || rop == BITXOR)
 			return true;
+	}
 	return false;
+}
 /*
  * Print a warning if the given node has operands which should be
  * parenthesized.
+ *
  * XXX Does not work if an operand is a constant expression. Constant
  * expressions are already folded.
  */
 static void
 check_precedence_confusion(tnode_t *tn)
+{
 	tnode_t *ln, *rn;
 	if (!hflag)
 		return;
 	debug_node(tn, 0);
 	lint_assert(modtab[tn->tn_op].m_binary);
 	for (ln = tn->tn_left; ln->tn_op == CVT; ln = ln->tn_left)
 		continue;
 	for (rn = tn->tn_right; rn->tn_op == CVT; rn = rn->tn_left)
 		continue;
 	if (is_confusing_precedence(tn->tn_op,
 	    ln->tn_op, ln->tn_parenthesized,
 	    rn->tn_op, rn->tn_parenthesized)) {
 		/* precedence confusion possible: parenthesize! */
 		warning(169);
+	}
+}