	@@ -1,1964 +1,1972 @@		@@ -1,1964 +1,1972 @@
1	%{	1	%{
2	/* $NetBSD: cgram.y,v 1.57 2014/02/04 08:08:59 njoly Exp $ */	2	/* $NetBSD: cgram.y,v 1.58 2014/02/18 22:01:36 christos Exp $ */
3		3
4	/*	4	/*
5	* Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved.	5	* Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved.
6	* Copyright (c) 1994, 1995 Jochen Pohl	6	* Copyright (c) 1994, 1995 Jochen Pohl
7	* All Rights Reserved.	7	* All Rights Reserved.
8	*	8	*
9	* Redistribution and use in source and binary forms, with or without	9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions	10	* modification, are permitted provided that the following conditions
11	* are met:	11	* are met:
12	* 1. Redistributions of source code must retain the above copyright	12	* 1. Redistributions of source code must retain the above copyright
13	* notice, this list of conditions and the following disclaimer.	13	* notice, this list of conditions and the following disclaimer.
14	* 2. Redistributions in binary form must reproduce the above copyright	14	* 2. Redistributions in binary form must reproduce the above copyright
15	* notice, this list of conditions and the following disclaimer in the	15	* notice, this list of conditions and the following disclaimer in the
16	* documentation and/or other materials provided with the distribution.	16	* documentation and/or other materials provided with the distribution.
17	* 3. All advertising materials mentioning features or use of this software	17	* 3. All advertising materials mentioning features or use of this software
18	* must display the following acknowledgement:	18	* must display the following acknowledgement:
19	* This product includes software developed by Jochen Pohl for	19	* This product includes software developed by Jochen Pohl for
20	* The NetBSD Project.	20	* The NetBSD Project.
21	* 4. The name of the author may not be used to endorse or promote products	21	* 4. The name of the author may not be used to endorse or promote products
22	* derived from this software without specific prior written permission.	22	* derived from this software without specific prior written permission.
23	*	23	*
24	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	24	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
25	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	25	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	26	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	27	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	28	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	29	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	30	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	31	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	32	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	33	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34	*/	34	*/
35		35
36	#include <sys/cdefs.h>	36	#include <sys/cdefs.h>
37	#if defined(__RCSID) && !defined(lint)	37	#if defined(__RCSID) && !defined(lint)
38	__RCSID("$NetBSD: cgram.y,v 1.57 2014/02/04 08:08:59 njoly Exp $");	38	__RCSID("$NetBSD: cgram.y,v 1.58 2014/02/18 22:01:36 christos Exp $");
39	#endif	39	#endif
40		40
41	#include <stdlib.h>	41	#include <stdlib.h>
42	#include <string.h>	42	#include <string.h>
43	#include <limits.h>	43	#include <limits.h>
44		44
45	#include "lint1.h"	45	#include "lint1.h"
46		46
47	extern char *yytext;	47	extern char *yytext;
48	/*	48	/*
49	* Contains the level of current declaration. 0 is extern.	49	* Contains the level of current declaration. 0 is extern.
50	* Used for symbol table entries.	50	* Used for symbol table entries.
51	*/	51	*/
52	int blklev;	52	int blklev;
53		53
54	/*	54	/*
55	* level for memory allocation. Normaly the same as blklev.	55	* level for memory allocation. Normaly the same as blklev.
56	* An exception is the declaration of arguments in prototypes. Memory	56	* An exception is the declaration of arguments in prototypes. Memory
57	* for these can't be freed after the declaration, but symbols must	57	* for these can't be freed after the declaration, but symbols must
58	* be removed from the symbol table after the declaration.	58	* be removed from the symbol table after the declaration.
59	*/	59	*/
60	int mblklev;	60	int mblklev;
61		61
62	/*	62	/*
63	* Save the no-warns state and restore it to avoid the problem where	63	* Save the no-warns state and restore it to avoid the problem where
64	* if (expr) { stmt } / * NOLINT * / stmt;	64	* if (expr) { stmt } / * NOLINT * / stmt;
65	*/	65	*/
66	static int olwarn = LWARN_BAD;	66	static int olwarn = LWARN_BAD;
67		67
68	static int toicon(tnode_t *, int);	68	static int toicon(tnode_t *, int);
69	static void idecl(sym_t , int, sbuf_t );	69	static void idecl(sym_t , int, sbuf_t );
70	static void ignuptorp(void);	70	static void ignuptorp(void);
71		71
72	#ifdef DEBUG	72	#ifdef DEBUG
73	static inline void CLRWFLGS(const char *file, size_t line);	73	static inline void CLRWFLGS(const char *file, size_t line);
74	static inline void CLRWFLGS(const char *file, size_t line)	74	static inline void CLRWFLGS(const char *file, size_t line)
75	{	75	{
76	printf("%s, %d: clear flags %s %zu\n", curr_pos.p_file,	76	printf("%s, %d: clear flags %s %zu\n", curr_pos.p_file,
77	curr_pos.p_line, file, line);	77	curr_pos.p_line, file, line);
78	clrwflgs();	78	clrwflgs();
79	olwarn = LWARN_BAD;	79	olwarn = LWARN_BAD;
80	}	80	}
81		81
82	static inline void SAVE(const char *file, size_t line);	82	static inline void SAVE(const char *file, size_t line);
83	static inline void SAVE(const char *file, size_t line)	83	static inline void SAVE(const char *file, size_t line)
84	{	84	{
85	if (olwarn != LWARN_BAD)	85	if (olwarn != LWARN_BAD)
86	abort();	86	abort();
87	printf("%s, %d: save flags %s %zu = %d\n", curr_pos.p_file,	87	printf("%s, %d: save flags %s %zu = %d\n", curr_pos.p_file,
88	curr_pos.p_line, file, line, lwarn);	88	curr_pos.p_line, file, line, lwarn);
89	olwarn = lwarn;	89	olwarn = lwarn;
90	}	90	}
91		91
92	static inline void RESTORE(const char *file, size_t line);	92	static inline void RESTORE(const char *file, size_t line);
93	static inline void RESTORE(const char *file, size_t line)	93	static inline void RESTORE(const char *file, size_t line)
94	{	94	{
95	if (olwarn != LWARN_BAD) {	95	if (olwarn != LWARN_BAD) {
96	lwarn = olwarn;	96	lwarn = olwarn;
97	printf("%s, %d: restore flags %s %zu = %d\n", curr_pos.p_file,	97	printf("%s, %d: restore flags %s %zu = %d\n", curr_pos.p_file,
98	curr_pos.p_line, file, line, lwarn);	98	curr_pos.p_line, file, line, lwarn);
99	olwarn = LWARN_BAD;	99	olwarn = LWARN_BAD;
100	} else	100	} else
101	CLRWFLGS(file, line);	101	CLRWFLGS(file, line);
102	}	102	}
103	#else	103	#else
104	#define CLRWFLGS(f, l) clrwflgs(), olwarn = LWARN_BAD	104	#define CLRWFLGS(f, l) clrwflgs(), olwarn = LWARN_BAD
105	#define SAVE(f, l) olwarn = lwarn	105	#define SAVE(f, l) olwarn = lwarn
106	#define RESTORE(f, l) (void)(olwarn == LWARN_BAD ? (clrwflgs(), 0) : (lwarn = olwarn))	106	#define RESTORE(f, l) (void)(olwarn == LWARN_BAD ? (clrwflgs(), 0) : (lwarn = olwarn))
107	#endif	107	#endif
108	%}	108	%}
109		109
110	%expect 5	110	%expect 5
111		111
112	%union {	112	%union {
113	int y_int;	113	int y_int;
114	val_t *y_val;	114	val_t *y_val;
115	sbuf_t *y_sb;	115	sbuf_t *y_sb;
116	sym_t *y_sym;	116	sym_t *y_sym;
117	op_t y_op;	117	op_t y_op;
118	scl_t y_scl;	118	scl_t y_scl;
119	tspec_t y_tspec;	119	tspec_t y_tspec;
120	tqual_t y_tqual;	120	tqual_t y_tqual;
121	type_t *y_type;	121	type_t *y_type;
122	tnode_t *y_tnode;	122	tnode_t *y_tnode;
123	range_t y_range;	123	range_t y_range;
124	strg_t *y_strg;	124	strg_t *y_strg;
125	pqinf_t *y_pqinf;	125	pqinf_t *y_pqinf;
126	};	126	};
127		127
128	%token T_LBRACE T_RBRACE T_LBRACK T_RBRACK T_LPARN T_RPARN	128	%token T_LBRACE T_RBRACE T_LBRACK T_RBRACK T_LPARN T_RPARN
129	%token <y_op> T_STROP	129	%token <y_op> T_STROP
130	%token <y_op> T_UNOP	130	%token <y_op> T_UNOP
131	%token <y_op> T_INCDEC	131	%token <y_op> T_INCDEC
132	%token T_SIZEOF	132	%token T_SIZEOF
		133	%token T_TYPEOF
		134	%token T_EXTENSION
133	%token T_ALIGNOF	135	%token T_ALIGNOF
134	%token <y_op> T_MULT	136	%token <y_op> T_MULT
135	%token <y_op> T_DIVOP	137	%token <y_op> T_DIVOP
136	%token <y_op> T_ADDOP	138	%token <y_op> T_ADDOP
137	%token <y_op> T_SHFTOP	139	%token <y_op> T_SHFTOP
138	%token <y_op> T_RELOP	140	%token <y_op> T_RELOP
139	%token <y_op> T_EQOP	141	%token <y_op> T_EQOP
140	%token <y_op> T_AND	142	%token <y_op> T_AND
141	%token <y_op> T_XOR	143	%token <y_op> T_XOR
142	%token <y_op> T_OR	144	%token <y_op> T_OR
143	%token <y_op> T_LOGAND	145	%token <y_op> T_LOGAND
144	%token <y_op> T_LOGOR	146	%token <y_op> T_LOGOR
145	%token T_QUEST	147	%token T_QUEST
146	%token T_COLON	148	%token T_COLON
147	%token <y_op> T_ASSIGN	149	%token <y_op> T_ASSIGN
148	%token <y_op> T_OPASS	150	%token <y_op> T_OPASS
149	%token T_COMMA	151	%token T_COMMA
150	%token T_SEMI	152	%token T_SEMI
151	%token T_ELLIPSE	153	%token T_ELLIPSE
152	%token T_REAL	154	%token T_REAL
153	%token T_IMAG	155	%token T_IMAG
154		156
155	/* storage classes (extern, static, auto, register and typedef) */	157	/* storage classes (extern, static, auto, register and typedef) */
156	%token <y_scl> T_SCLASS	158	%token <y_scl> T_SCLASS
157		159
158	/* types (char, int, short, long, unsigned, signed, float, double, void) */	160	/* types (char, int, short, long, unsigned, signed, float, double, void) */
159	%token <y_tspec> T_TYPE	161	%token <y_tspec> T_TYPE
160		162
161	/* qualifiers (const, volatile) */	163	/* qualifiers (const, volatile) */
162	%token <y_tqual> T_QUAL	164	%token <y_tqual> T_QUAL
163		165
164	/* struct or union */	166	/* struct or union */
165	%token <y_tspec> T_SOU	167	%token <y_tspec> T_SOU
166		168
167	/* enum */	169	/* enum */
168	%token T_ENUM	170	%token T_ENUM
169		171
170	/* remaining keywords */	172	/* remaining keywords */
171	%token T_CASE	173	%token T_CASE
172	%token T_DEFAULT	174	%token T_DEFAULT
173	%token T_IF	175	%token T_IF
174	%token T_ELSE	176	%token T_ELSE
175	%token T_SWITCH	177	%token T_SWITCH
176	%token T_DO	178	%token T_DO
177	%token T_WHILE	179	%token T_WHILE
178	%token T_FOR	180	%token T_FOR
179	%token T_GOTO	181	%token T_GOTO
180	%token T_CONTINUE	182	%token T_CONTINUE
181	%token T_BREAK	183	%token T_BREAK
182	%token T_RETURN	184	%token T_RETURN
183	%token T_ASM	185	%token T_ASM
184	%token T_SYMBOLRENAME	186	%token T_SYMBOLRENAME
185	%token T_PACKED	187	%token T_PACKED
186	/* Type Attributes */	188	/* Type Attributes */
187	%token <y_type> T_ATTRIBUTE	189	%token <y_type> T_ATTRIBUTE
188	%token <y_type> T_AT_ALIGNED	190	%token <y_type> T_AT_ALIGNED
189	%token <y_type> T_AT_DEPRECATED	191	%token <y_type> T_AT_DEPRECATED
190	%token <y_type> T_AT_MAY_ALIAS	192	%token <y_type> T_AT_MAY_ALIAS
191	%token <y_type> T_AT_PACKED	193	%token <y_type> T_AT_PACKED
192	%token <y_type> T_AT_TUINION	194	%token <y_type> T_AT_TUINION
193	%token <y_type> T_AT_TUNION	195	%token <y_type> T_AT_TUNION
194	%token <y_type> T_AT_UNUSED	196	%token <y_type> T_AT_UNUSED
195		197
196		198
197		199
198	%left T_COMMA	200	%left T_COMMA
199	%right T_ASSIGN T_OPASS	201	%right T_ASSIGN T_OPASS
200	%right T_QUEST T_COLON	202	%right T_QUEST T_COLON
201	%left T_LOGOR	203	%left T_LOGOR
202	%left T_LOGAND	204	%left T_LOGAND
203	%left T_OR	205	%left T_OR
204	%left T_XOR	206	%left T_XOR
205	%left T_AND	207	%left T_AND
206	%left T_EQOP	208	%left T_EQOP
207	%left T_RELOP	209	%left T_RELOP
208	%left T_SHFTOP	210	%left T_SHFTOP
209	%left T_ADDOP	211	%left T_ADDOP
210	%left T_MULT T_DIVOP	212	%left T_MULT T_DIVOP
211	%right T_UNOP T_INCDEC T_SIZEOF T_ALIGNOF T_REAL T_IMAG	213	%right T_UNOP T_INCDEC T_SIZEOF T_ALIGNOF T_REAL T_IMAG
212	%left T_LPARN T_LBRACK T_STROP	214	%left T_LPARN T_LBRACK T_STROP
213		215
214	%token <y_sb> T_NAME	216	%token <y_sb> T_NAME
215	%token <y_sb> T_TYPENAME	217	%token <y_sb> T_TYPENAME
216	%token <y_val> T_CON	218	%token <y_val> T_CON
217	%token <y_strg> T_STRING	219	%token <y_strg> T_STRING
218		220
219	%type <y_sym> func_decl	221	%type <y_sym> func_decl
220	%type <y_sym> notype_decl	222	%type <y_sym> notype_decl
221	%type <y_sym> type_decl	223	%type <y_sym> type_decl
222	%type <y_type> typespec	224	%type <y_type> typespec
223	%type <y_type> clrtyp_typespec	225	%type <y_type> clrtyp_typespec
224	%type <y_type> notype_typespec	226	%type <y_type> notype_typespec
225	%type <y_type> struct_spec	227	%type <y_type> struct_spec
226	%type <y_type> enum_spec	228	%type <y_type> enum_spec
227	%type <y_type> type_attribute	229	%type <y_type> type_attribute
228	%type <y_type> type_attribute_spec	230	%type <y_type> type_attribute_spec
229	%type <y_sym> struct_tag	231	%type <y_sym> struct_tag
230	%type <y_sym> enum_tag	232	%type <y_sym> enum_tag
231	%type <y_tspec> struct	233	%type <y_tspec> struct
232	%type <y_sym> struct_declaration	234	%type <y_sym> struct_declaration
233	%type <y_sb> identifier	235	%type <y_sb> identifier
234	%type <y_sym> member_declaration_list_with_rbrace	236	%type <y_sym> member_declaration_list_with_rbrace
235	%type <y_sym> member_declaration_list	237	%type <y_sym> member_declaration_list
236	%type <y_sym> member_declaration	238	%type <y_sym> member_declaration
237	%type <y_sym> notype_member_decls	239	%type <y_sym> notype_member_decls
238	%type <y_sym> type_member_decls	240	%type <y_sym> type_member_decls
239	%type <y_sym> notype_member_decl	241	%type <y_sym> notype_member_decl
240	%type <y_sym> type_member_decl	242	%type <y_sym> type_member_decl
241	%type <y_tnode> constant	243	%type <y_tnode> constant
242	%type <y_sym> enum_declaration	244	%type <y_sym> enum_declaration
243	%type <y_sym> enums_with_opt_comma	245	%type <y_sym> enums_with_opt_comma
244	%type <y_sym> enums	246	%type <y_sym> enums
245	%type <y_sym> enumerator	247	%type <y_sym> enumerator
246	%type <y_sym> ename	248	%type <y_sym> ename
247	%type <y_sym> notype_direct_decl	249	%type <y_sym> notype_direct_decl
248	%type <y_sym> type_direct_decl	250	%type <y_sym> type_direct_decl
249	%type <y_pqinf> pointer	251	%type <y_pqinf> pointer
250	%type <y_pqinf> asterisk	252	%type <y_pqinf> asterisk
251	%type <y_sym> param_decl	253	%type <y_sym> param_decl
252	%type <y_sym> param_list	254	%type <y_sym> param_list
253	%type <y_sym> abs_decl_param_list	255	%type <y_sym> abs_decl_param_list
254	%type <y_sym> direct_param_decl	256	%type <y_sym> direct_param_decl
255	%type <y_sym> notype_param_decl	257	%type <y_sym> notype_param_decl
256	%type <y_sym> direct_notype_param_decl	258	%type <y_sym> direct_notype_param_decl
257	%type <y_pqinf> type_qualifier_list	259	%type <y_pqinf> type_qualifier_list
258	%type <y_pqinf> type_qualifier	260	%type <y_pqinf> type_qualifier
259	%type <y_sym> identifier_list	261	%type <y_sym> identifier_list
260	%type <y_sym> abs_decl	262	%type <y_sym> abs_decl
261	%type <y_sym> direct_abs_decl	263	%type <y_sym> direct_abs_decl
262	%type <y_sym> vararg_parameter_type_list	264	%type <y_sym> vararg_parameter_type_list
263	%type <y_sym> parameter_type_list	265	%type <y_sym> parameter_type_list
264	%type <y_sym> parameter_declaration	266	%type <y_sym> parameter_declaration
265	%type <y_tnode> expr	267	%type <y_tnode> expr
266	%type <y_tnode> expr_stmnt_val	268	%type <y_tnode> expr_stmnt_val
267	%type <y_tnode> expr_stmnt_list	269	%type <y_tnode> expr_stmnt_list
268	%type <y_tnode> term	270	%type <y_tnode> term
269	%type <y_tnode> func_arg_list	271	%type <y_tnode> func_arg_list
270	%type <y_op> point_or_arrow	272	%type <y_op> point_or_arrow
271	%type <y_type> type_name	273	%type <y_type> type_name
272	%type <y_sym> abstract_declaration	274	%type <y_sym> abstract_declaration
273	%type <y_tnode> do_while_expr	275	%type <y_tnode> do_while_expr
274	%type <y_tnode> opt_expr	276	%type <y_tnode> opt_expr
275	%type <y_strg> string	277	%type <y_strg> string
276	%type <y_strg> string2	278	%type <y_strg> string2
277	%type <y_sb> opt_asm_or_symbolrename	279	%type <y_sb> opt_asm_or_symbolrename
278	%type <y_range> range	280	%type <y_range> range
279	%type <y_range> lorange	281	%type <y_range> lorange
280		282
281		283
282	%%	284	%%
283		285
284	program:	286	program:
285	/* empty */ {	287	/* empty */ {
286	if (sflag) {	288	if (sflag) {
287	/* empty translation unit */	289	/* empty translation unit */
288	error(272);	290	error(272);
289	} else if (!tflag) {	291	} else if (!tflag) {
290	/* empty translation unit */	292	/* empty translation unit */
291	warning(272);	293	warning(272);
292	}	294	}
293	}	295	}
294	\| translation_unit	296	\| translation_unit
295	;	297	;
296		298
297	translation_unit:	299	translation_unit:
298	ext_decl	300	ext_decl
299	\| translation_unit ext_decl	301	\| translation_unit ext_decl
300	;	302	;
301		303
302	ext_decl:	304	ext_decl:
303	asm_stmnt	305	asm_stmnt
304	\| func_def {	306	\| func_def {
305	glclup(0);	307	glclup(0);
306	CLRWFLGS(__FILE__, __LINE__);	308	CLRWFLGS(__FILE__, __LINE__);
307	}	309	}
308	\| data_def {	310	\| data_def {
309	glclup(0);	311	glclup(0);
310	CLRWFLGS(__FILE__, __LINE__);	312	CLRWFLGS(__FILE__, __LINE__);
311	}	313	}
312	;	314	;
313		315
314	data_def:	316	data_def:
315	T_SEMI {	317	T_SEMI {
316	if (sflag) {	318	if (sflag) {
317	/* syntax error: empty declaration */	319	/* syntax error: empty declaration */
318	error(0);	320	error(0);
319	} else if (!tflag) {	321	} else if (!tflag) {
320	/* syntax error: empty declaration */	322	/* syntax error: empty declaration */
321	warning(0);	323	warning(0);
322	}	324	}
323	}	325	}
324	\| clrtyp deftyp notype_init_decls T_SEMI {	326	\| clrtyp deftyp notype_init_decls T_SEMI {
325	if (sflag) {	327	if (sflag) {
326	/* old style declaration; add "int" */	328	/* old style declaration; add "int" */
327	error(1);	329	error(1);
328	} else if (!tflag) {	330	} else if (!tflag) {
329	/* old style declaration; add "int" */	331	/* old style declaration; add "int" */
330	warning(1);	332	warning(1);
331	}	333	}
332	}	334	}
333	\| declmods deftyp T_SEMI {	335	\| declmods deftyp T_SEMI {
334	if (dcs->d_scl == TYPEDEF) {	336	if (dcs->d_scl == TYPEDEF) {
335	/* typedef declares no type name */	337	/* typedef declares no type name */
336	warning(72);	338	warning(72);
337	} else {	339	} else {
338	/* empty declaration */	340	/* empty declaration */
339	warning(2);	341	warning(2);
340	}	342	}
341	}	343	}
342	\| declmods deftyp notype_init_decls T_SEMI	344	\| declmods deftyp notype_init_decls T_SEMI
343	\| declspecs deftyp T_SEMI {	345	\| declspecs deftyp T_SEMI {
344	if (dcs->d_scl == TYPEDEF) {	346	if (dcs->d_scl == TYPEDEF) {
345	/* typedef declares no type name */	347	/* typedef declares no type name */
346	warning(72);	348	warning(72);
347	} else if (!dcs->d_nedecl) {	349	} else if (!dcs->d_nedecl) {
348	/* empty declaration */	350	/* empty declaration */
349	warning(2);	351	warning(2);
350	}	352	}
351	}	353	}
352	\| declspecs deftyp type_init_decls T_SEMI	354	\| declspecs deftyp type_init_decls T_SEMI
353	\| error T_SEMI {	355	\| error T_SEMI {
354	globclup();	356	globclup();
355	}	357	}
356	\| error T_RBRACE {	358	\| error T_RBRACE {
357	globclup();	359	globclup();
358	}	360	}
359	;	361	;
360		362
361	func_def:	363	func_def:
362	func_decl {	364	func_decl {
363	if ($1->s_type->t_tspec != FUNC) {	365	if ($1->s_type->t_tspec != FUNC) {
364	/* syntax error */	366	/* syntax error */
365	error(249, yytext);	367	error(249, yytext);
366	YYERROR;	368	YYERROR;
367	}	369	}
368	if ($1->s_type->t_typedef) {	370	if ($1->s_type->t_typedef) {
369	/* ()-less function definition */	371	/* ()-less function definition */
370	error(64);	372	error(64);
371	YYERROR;	373	YYERROR;
372	}	374	}
373	funcdef($1);	375	funcdef($1);
374	blklev++;	376	blklev++;
375	pushdecl(ARG);	377	pushdecl(ARG);
376	if (lwarn == LWARN_NONE)	378	if (lwarn == LWARN_NONE)
377	$1->s_used = 1;	379	$1->s_used = 1;
378	} opt_arg_declaration_list {	380	} opt_arg_declaration_list {
379	popdecl();	381	popdecl();
380	blklev--;	382	blklev--;
381	cluparg();	383	cluparg();
382	pushctrl(0);	384	pushctrl(0);
383	} comp_stmnt {	385	} comp_stmnt {
384	funcend();	386	funcend();
385	popctrl(0);	387	popctrl(0);
386	}	388	}
387	;	389	;
388		390
389	func_decl:	391	func_decl:
390	clrtyp deftyp notype_decl {	392	clrtyp deftyp notype_decl {
391	$$ = $3;	393	$$ = $3;
392	}	394	}
393	\| declmods deftyp notype_decl {	395	\| declmods deftyp notype_decl {
394	$$ = $3;	396	$$ = $3;
395	}	397	}
396	\| declspecs deftyp type_decl {	398	\| declspecs deftyp type_decl {
397	$$ = $3;	399	$$ = $3;
398	}	400	}
399	;	401	;
400		402
401	opt_arg_declaration_list:	403	opt_arg_declaration_list:
402	/* empty */	404	/* empty */
403	\| arg_declaration_list	405	\| arg_declaration_list
404	;	406	;
405		407
406	arg_declaration_list:	408	arg_declaration_list:
407	arg_declaration	409	arg_declaration
408	\| arg_declaration_list arg_declaration	410	\| arg_declaration_list arg_declaration
409	/* XXX or better "arg_declaration error" ? */	411	/* XXX or better "arg_declaration error" ? */
410	\| error	412	\| error
411	;	413	;
412		414
413	/*	415	/*
414	* "arg_declaration" is separated from "declaration" because it	416	* "arg_declaration" is separated from "declaration" because it
415	* needs other error handling.	417	* needs other error handling.
416	*/	418	*/
417		419
418	arg_declaration:	420	arg_declaration:
419	declmods deftyp T_SEMI {	421	declmods deftyp T_SEMI {
420	/* empty declaration */	422	/* empty declaration */
421	warning(2);	423	warning(2);
422	}	424	}
423	\| declmods deftyp notype_init_decls T_SEMI	425	\| declmods deftyp notype_init_decls T_SEMI
424	\| declspecs deftyp T_SEMI {	426	\| declspecs deftyp T_SEMI {
425	if (!dcs->d_nedecl) {	427	if (!dcs->d_nedecl) {
426	/* empty declaration */	428	/* empty declaration */
427	warning(2);	429	warning(2);
428	} else {	430	} else {
429	tspec_t ts = dcs->d_type->t_tspec;	431	tspec_t ts = dcs->d_type->t_tspec;
430	/* %s declared in argument declaration list */	432	/* %s declared in argument declaration list */
431	warning(3, ts == STRUCT ? "struct" :	433	warning(3, ts == STRUCT ? "struct" :
432	(ts == UNION ? "union" : "enum"));	434	(ts == UNION ? "union" : "enum"));
433	}	435	}
434	}	436	}
435	\| declspecs deftyp type_init_decls T_SEMI {	437	\| declspecs deftyp type_init_decls T_SEMI {
436	if (dcs->d_nedecl) {	438	if (dcs->d_nedecl) {
437	tspec_t ts = dcs->d_type->t_tspec;	439	tspec_t ts = dcs->d_type->t_tspec;
438	/* %s declared in argument declaration list */	440	/* %s declared in argument declaration list */
439	warning(3, ts == STRUCT ? "struct" :	441	warning(3, ts == STRUCT ? "struct" :
440	(ts == UNION ? "union" : "enum"));	442	(ts == UNION ? "union" : "enum"));
441	}	443	}
442	}	444	}
443	\| declmods error	445	\| declmods error
444	\| declspecs error	446	\| declspecs error
445	;	447	;
446		448
447	declaration:	449	declaration:
448	declmods deftyp T_SEMI {	450	declmods deftyp T_SEMI {
449	if (dcs->d_scl == TYPEDEF) {	451	if (dcs->d_scl == TYPEDEF) {
450	/* typedef declares no type name */	452	/* typedef declares no type name */
451	warning(72);	453	warning(72);
452	} else {	454	} else {
453	/* empty declaration */	455	/* empty declaration */
454	warning(2);	456	warning(2);
455	}	457	}
456	}	458	}
457	\| declmods deftyp notype_init_decls T_SEMI	459	\| declmods deftyp notype_init_decls T_SEMI
458	\| declspecs deftyp T_SEMI {	460	\| declspecs deftyp T_SEMI {
459	if (dcs->d_scl == TYPEDEF) {	461	if (dcs->d_scl == TYPEDEF) {
460	/* typedef declares no type name */	462	/* typedef declares no type name */
461	warning(72);	463	warning(72);
462	} else if (!dcs->d_nedecl) {	464	} else if (!dcs->d_nedecl) {
463	/* empty declaration */	465	/* empty declaration */
464	warning(2);	466	warning(2);
465	}	467	}
466	}	468	}
467	\| declspecs deftyp type_init_decls T_SEMI	469	\| declspecs deftyp type_init_decls T_SEMI
468	\| error T_SEMI	470	\| error T_SEMI
469	;	471	;
470		472
471	type_attribute_spec:	473	type_attribute_spec:
472	T_AT_DEPRECATED	474	T_AT_DEPRECATED
473	\| T_AT_ALIGNED T_LPARN constant T_RPARN	475	\| T_AT_ALIGNED T_LPARN constant T_RPARN
474	\| T_AT_MAY_ALIAS	476	\| T_AT_MAY_ALIAS
475	\| T_AT_PACKED {	477	\| T_AT_PACKED {
476	addpacked();	478	addpacked();
477	}	479	}
478	\| T_AT_TUNION	480	\| T_AT_TUNION
479	\| T_AT_UNUSED	481	\| T_AT_UNUSED
480	;	482	;
481		483
482	type_attribute:	484	type_attribute:
483	T_ATTRIBUTE T_LPARN T_LPARN type_attribute_spec T_RPARN T_RPARN	485	T_ATTRIBUTE T_LPARN T_LPARN type_attribute_spec T_RPARN T_RPARN
484	\| T_PACKED {	486	\| T_PACKED {
485	addpacked();	487	addpacked();
486	}	488	}
487	;	489	;
488		490
489	clrtyp:	491	clrtyp:
490	{	492	{
491	clrtyp();	493	clrtyp();
492	}	494	}
493	;	495	;
494		496
495	deftyp:	497	deftyp:
496	/* empty */ {	498	/* empty */ {
497	deftyp();	499	deftyp();
498	}	500	}
499	;	501	;
500		502
501	declspecs:	503	declspecs:
502	clrtyp_typespec {	504	clrtyp_typespec {
503	addtype($1);	505	addtype($1);
504	}	506	}
505	\| declmods typespec {	507	\| declmods typespec {
506	addtype($2);	508	addtype($2);
507	}	509	}
508	\| declspecs type_attribute	510	\| declspecs type_attribute
509	\| declspecs declmod	511	\| declspecs declmod
510	\| declspecs notype_typespec {	512	\| declspecs notype_typespec {
511	addtype($2);	513	addtype($2);
512	}	514	}
513	;	515	;
514		516
515	declmods:	517	declmods:
516	clrtyp T_QUAL {	518	clrtyp T_QUAL {
517	addqual($2);	519	addqual($2);
518	}	520	}
519	\| clrtyp T_SCLASS {	521	\| clrtyp T_SCLASS {
520	addscl($2);	522	addscl($2);
521	}	523	}
522	\| declmods declmod	524	\| declmods declmod
523	;	525	;
524		526
525	declmod:	527	declmod:
526	T_QUAL {	528	T_QUAL {
527	addqual($1);	529	addqual($1);
528	}	530	}
529	\| T_SCLASS {	531	\| T_SCLASS {
530	addscl($1);	532	addscl($1);
531	}	533	}
532	;	534	;
533		535
534	clrtyp_typespec:	536	clrtyp_typespec:
535	clrtyp notype_typespec {	537	clrtyp notype_typespec {
536	$$ = $2;	538	$$ = $2;
537	}	539	}
538	\| T_TYPENAME clrtyp {	540	\| T_TYPENAME clrtyp {
539	$$ = getsym($1)->s_type;	541	$$ = getsym($1)->s_type;
540	}	542	}
541	;	543	;
542		544
543	typespec:	545	typespec:
544	notype_typespec {	546	notype_typespec {
545	$$ = $1;	547	$$ = $1;
546	}	548	}
547	\| T_TYPENAME {	549	\| T_TYPENAME {
548	$$ = getsym($1)->s_type;	550	$$ = getsym($1)->s_type;
549	}	551	}
550	;	552	;
551		553
552	notype_typespec:	554	notype_typespec:
553	T_TYPE {	555	T_TYPE {
554	$$ = gettyp($1);	556	$$ = gettyp($1);
555	}	557	}
		558	\| T_TYPEOF T_LPARN term T_RPARN {
		559	$$ = $3->tn_type;
		560	}
556	\| struct_spec {	561	\| struct_spec {
557	popdecl();	562	popdecl();
558	$$ = $1;	563	$$ = $1;
559	}	564	}
560	\| enum_spec {	565	\| enum_spec {
561	popdecl();	566	popdecl();
562	$$ = $1;	567	$$ = $1;
563	}	568	}
564	;	569	;
565		570
566	struct_spec:	571	struct_spec:
567	struct struct_tag {	572	struct struct_tag {
568	/*	573	/*
569	* STDC requires that "struct a;" always introduces	574	* STDC requires that "struct a;" always introduces
570	* a new tag if "a" is not declared at current level	575	* a new tag if "a" is not declared at current level
571	*	576	*
572	* yychar is valid because otherwise the parser would	577	* yychar is valid because otherwise the parser would
573	* not been able to deceide if he must shift or reduce	578	* not been able to deceide if he must shift or reduce
574	*/	579	*/
575	$$ = mktag($2, $1, 0, yychar == T_SEMI);	580	$$ = mktag($2, $1, 0, yychar == T_SEMI);
576	}	581	}
577	\| struct struct_tag {	582	\| struct struct_tag {
578	dcs->d_tagtyp = mktag($2, $1, 1, 0);	583	dcs->d_tagtyp = mktag($2, $1, 1, 0);
579	} struct_declaration {	584	} struct_declaration {
580	$$ = compltag(dcs->d_tagtyp, $4);	585	$$ = compltag(dcs->d_tagtyp, $4);
581	}	586	}
582	\| struct {	587	\| struct {
583	dcs->d_tagtyp = mktag(NULL, $1, 1, 0);	588	dcs->d_tagtyp = mktag(NULL, $1, 1, 0);
584	} struct_declaration {	589	} struct_declaration {
585	$$ = compltag(dcs->d_tagtyp, $3);	590	$$ = compltag(dcs->d_tagtyp, $3);
586	}	591	}
587	\| struct error {	592	\| struct error {
588	symtyp = FVFT;	593	symtyp = FVFT;
589	$$ = gettyp(INT);	594	$$ = gettyp(INT);
590	}	595	}
591	;	596	;
592		597
593	struct:	598	struct:
594	struct type_attribute	599	struct type_attribute
595	\| T_SOU {	600	\| T_SOU {
596	symtyp = FTAG;	601	symtyp = FTAG;
597	pushdecl($1 == STRUCT ? MOS : MOU);	602	pushdecl($1 == STRUCT ? MOS : MOU);
598	dcs->d_offset = 0;	603	dcs->d_offset = 0;
599	dcs->d_stralign = CHAR_BIT;	604	dcs->d_stralign = CHAR_BIT;
600	$$ = $1;	605	$$ = $1;
601	}	606	}
602	;	607	;
603		608
604	struct_tag:	609	struct_tag:
605	identifier {	610	identifier {
606	$$ = getsym($1);	611	$$ = getsym($1);
607	}	612	}
608	;	613	;
609		614
610	struct_declaration:	615	struct_declaration:
611	struct_decl_lbrace member_declaration_list_with_rbrace {	616	struct_decl_lbrace member_declaration_list_with_rbrace {
612	$$ = $2;	617	$$ = $2;
613	}	618	}
614	;	619	;
615		620
616	struct_decl_lbrace:	621	struct_decl_lbrace:
617	T_LBRACE {	622	T_LBRACE {
618	symtyp = FVFT;	623	symtyp = FVFT;
619	}	624	}
620	;	625	;
621		626
622	member_declaration_list_with_rbrace:	627	member_declaration_list_with_rbrace:
623	member_declaration_list T_SEMI T_RBRACE {	628	member_declaration_list T_SEMI T_RBRACE {
624	$$ = $1;	629	$$ = $1;
625	}	630	}
626	\| member_declaration_list T_RBRACE {	631	\| member_declaration_list T_RBRACE {
627	if (sflag) {	632	if (sflag) {
628	/* syntax req. ";" after last struct/union member */	633	/* syntax req. ";" after last struct/union member */
629	error(66);	634	error(66);
630	} else {	635	} else {
631	/* syntax req. ";" after last struct/union member */	636	/* syntax req. ";" after last struct/union member */
632	warning(66);	637	warning(66);
633	}	638	}
634	$$ = $1;	639	$$ = $1;
635	}	640	}
636	\| T_RBRACE {	641	\| T_RBRACE {
637	$$ = NULL;	642	$$ = NULL;
638	}	643	}
639	;	644	;
640		645
641	member_declaration_list:	646	member_declaration_list:
642	member_declaration {	647	member_declaration {
643	$$ = $1;	648	$$ = $1;
644	}	649	}
645	\| member_declaration_list T_SEMI member_declaration {	650	\| member_declaration_list T_SEMI member_declaration {
646	$$ = lnklst($1, $3);	651	$$ = lnklst($1, $3);
647	}	652	}
648	;	653	;
649		654
650	member_declaration:	655	member_declaration:
651	noclass_declmods deftyp {	656	noclass_declmods deftyp {
652	/* too late, i know, but getsym() compensates it */	657	/* too late, i know, but getsym() compensates it */
653	symtyp = FMOS;	658	symtyp = FMOS;
654	} notype_member_decls {	659	} notype_member_decls {
655	symtyp = FVFT;	660	symtyp = FVFT;
656	$$ = $4;	661	$$ = $4;
657	}	662	}
658	\| noclass_declspecs deftyp {	663	\| noclass_declspecs deftyp {
659	symtyp = FMOS;	664	symtyp = FMOS;
660	} type_member_decls {	665	} type_member_decls {
661	symtyp = FVFT;	666	symtyp = FVFT;
662	$$ = $4;	667	$$ = $4;
663	}	668	}
664	\| noclass_declmods deftyp {	669	\| noclass_declmods deftyp {
665	/* struct or union member must be named */	670	/* struct or union member must be named */
666	warning(49);	671	warning(49);
667	$$ = NULL;	672	$$ = NULL;
668	}	673	}
669	\| noclass_declspecs deftyp {	674	\| noclass_declspecs deftyp {
670	/* struct or union member must be named */	675	/* struct or union member must be named */
671	warning(49);	676	warning(49);
672	$$ = NULL;	677	$$ = NULL;
673	}	678	}
674	\| error {	679	\| error {
675	symtyp = FVFT;	680	symtyp = FVFT;
676	$$ = NULL;	681	$$ = NULL;
677	}	682	}
678	;	683	;
679		684
680	noclass_declspecs:	685	noclass_declspecs:
681	clrtyp_typespec {	686	clrtyp_typespec {
682	addtype($1);	687	addtype($1);
683	}	688	}
684	\| noclass_declmods typespec {	689	\| noclass_declmods typespec {
685	addtype($2);	690	addtype($2);
686	}	691	}
687	\| noclass_declspecs T_QUAL {	692	\| noclass_declspecs T_QUAL {
688	addqual($2);	693	addqual($2);
689	}	694	}
690	\| noclass_declspecs notype_typespec {	695	\| noclass_declspecs notype_typespec {
691	addtype($2);	696	addtype($2);
692	}	697	}
693	\| noclass_declspecs type_attribute	698	\| noclass_declspecs type_attribute
694	;	699	;
695		700
696	noclass_declmods:	701	noclass_declmods:
697	clrtyp T_QUAL {	702	clrtyp T_QUAL {
698	addqual($2);	703	addqual($2);
699	}	704	}
700	\| noclass_declmods T_QUAL {	705	\| noclass_declmods T_QUAL {
701	addqual($2);	706	addqual($2);
702	}	707	}
703	;	708	;
704		709
705	notype_member_decls:	710	notype_member_decls:
706	notype_member_decl {	711	notype_member_decl {
707	$$ = decl1str($1);	712	$$ = decl1str($1);
708	}	713	}
709	\| notype_member_decls {	714	\| notype_member_decls {
710	symtyp = FMOS;	715	symtyp = FMOS;
711	} T_COMMA type_member_decl {	716	} T_COMMA type_member_decl {
712	$$ = lnklst($1, decl1str($4));	717	$$ = lnklst($1, decl1str($4));
713	}	718	}
714	;	719	;
715		720
716	type_member_decls:	721	type_member_decls:
717	type_member_decl {	722	type_member_decl {
718	$$ = decl1str($1);	723	$$ = decl1str($1);
719	}	724	}
720	\| type_member_decls {	725	\| type_member_decls {
721	symtyp = FMOS;	726	symtyp = FMOS;
722	} T_COMMA type_member_decl {	727	} T_COMMA type_member_decl {
723	$$ = lnklst($1, decl1str($4));	728	$$ = lnklst($1, decl1str($4));
724	}	729	}
725	;	730	;
726		731
727	notype_member_decl:	732	notype_member_decl:
728	notype_decl {	733	notype_decl {
729	$$ = $1;	734	$$ = $1;
730	}	735	}
731	\| notype_decl T_COLON constant {	736	\| notype_decl T_COLON constant {
732	$$ = bitfield($1, toicon($3, 1));	737	$$ = bitfield($1, toicon($3, 1));
733	}	738	}
734	\| {	739	\| {
735	symtyp = FVFT;	740	symtyp = FVFT;
736	} T_COLON constant {	741	} T_COLON constant {
737	$$ = bitfield(NULL, toicon($3, 1));	742	$$ = bitfield(NULL, toicon($3, 1));
738	}	743	}
739	;	744	;
740		745
741	type_member_decl:	746	type_member_decl:
742	type_decl {	747	type_decl {
743	$$ = $1;	748	$$ = $1;
744	}	749	}
745	\| type_decl T_COLON constant {	750	\| type_decl T_COLON constant {
746	$$ = bitfield($1, toicon($3, 1));	751	$$ = bitfield($1, toicon($3, 1));
747	}	752	}
748	\| {	753	\| {
749	symtyp = FVFT;	754	symtyp = FVFT;
750	} T_COLON constant {	755	} T_COLON constant {
751	$$ = bitfield(NULL, toicon($3, 1));	756	$$ = bitfield(NULL, toicon($3, 1));
752	}	757	}
753	;	758	;
754		759
755	enum_spec:	760	enum_spec:
756	enum enum_tag {	761	enum enum_tag {
757	$$ = mktag($2, ENUM, 0, 0);	762	$$ = mktag($2, ENUM, 0, 0);
758	}	763	}
759	\| enum enum_tag {	764	\| enum enum_tag {
760	dcs->d_tagtyp = mktag($2, ENUM, 1, 0);	765	dcs->d_tagtyp = mktag($2, ENUM, 1, 0);
761	} enum_declaration {	766	} enum_declaration {
762	$$ = compltag(dcs->d_tagtyp, $4);	767	$$ = compltag(dcs->d_tagtyp, $4);
763	}	768	}
764	\| enum {	769	\| enum {
765	dcs->d_tagtyp = mktag(NULL, ENUM, 1, 0);	770	dcs->d_tagtyp = mktag(NULL, ENUM, 1, 0);
766	} enum_declaration {	771	} enum_declaration {
767	$$ = compltag(dcs->d_tagtyp, $3);	772	$$ = compltag(dcs->d_tagtyp, $3);
768	}	773	}
769	\| enum error {	774	\| enum error {
770	symtyp = FVFT;	775	symtyp = FVFT;
771	$$ = gettyp(INT);	776	$$ = gettyp(INT);
772	}	777	}
773	;	778	;
774		779
775	enum:	780	enum:
776	T_ENUM {	781	T_ENUM {
777	symtyp = FTAG;	782	symtyp = FTAG;
778	pushdecl(ENUMCON);	783	pushdecl(ENUMCON);
779	}	784	}
780	;	785	;
781		786
782	enum_tag:	787	enum_tag:
783	identifier {	788	identifier {
784	$$ = getsym($1);	789	$$ = getsym($1);
785	}	790	}
786	;	791	;
787		792
788	enum_declaration:	793	enum_declaration:
789	enum_decl_lbrace enums_with_opt_comma T_RBRACE {	794	enum_decl_lbrace enums_with_opt_comma T_RBRACE {
790	$$ = $2;	795	$$ = $2;
791	}	796	}
792	;	797	;
793		798
794	enum_decl_lbrace:	799	enum_decl_lbrace:
795	T_LBRACE {	800	T_LBRACE {
796	symtyp = FVFT;	801	symtyp = FVFT;
797	enumval = 0;	802	enumval = 0;
798	}	803	}
799	;	804	;
800		805
801	enums_with_opt_comma:	806	enums_with_opt_comma:
802	enums {	807	enums {
803	$$ = $1;	808	$$ = $1;
804	}	809	}
805	\| enums T_COMMA {	810	\| enums T_COMMA {
806	if (sflag) {	811	if (sflag) {
807	/* trailing "," prohibited in enum declaration */	812	/* trailing "," prohibited in enum declaration */
808	error(54);	813	error(54);
809	} else {	814	} else {
810	/* trailing "," prohibited in enum declaration */	815	/* trailing "," prohibited in enum declaration */
811	c99ism(54);	816	c99ism(54);
812	}	817	}
813	$$ = $1;	818	$$ = $1;
814	}	819	}
815	;	820	;
816		821
817	enums:	822	enums:
818	enumerator {	823	enumerator {
819	$$ = $1;	824	$$ = $1;
820	}	825	}
821	\| enums T_COMMA enumerator {	826	\| enums T_COMMA enumerator {
822	$$ = lnklst($1, $3);	827	$$ = lnklst($1, $3);
823	}	828	}
824	\| error {	829	\| error {
825	$$ = NULL;	830	$$ = NULL;
826	}	831	}
827	;	832	;
828		833
829	enumerator:	834	enumerator:
830	ename {	835	ename {
831	$$ = ename($1, enumval, 1);	836	$$ = ename($1, enumval, 1);
832	}	837	}
833	\| ename T_ASSIGN constant {	838	\| ename T_ASSIGN constant {
834	$$ = ename($1, toicon($3, 1), 0);	839	$$ = ename($1, toicon($3, 1), 0);
835	}	840	}
836	;	841	;
837		842
838	ename:	843	ename:
839	identifier {	844	identifier {
840	$$ = getsym($1);	845	$$ = getsym($1);
841	}	846	}
842	;	847	;
843		848
844		849
845	notype_init_decls:	850	notype_init_decls:
846	notype_init_decl	851	notype_init_decl
847	\| notype_init_decls T_COMMA type_init_decl	852	\| notype_init_decls T_COMMA type_init_decl
848	;	853	;
849		854
850	type_init_decls:	855	type_init_decls:
851	type_init_decl	856	type_init_decl
852	\| type_init_decls T_COMMA type_init_decl	857	\| type_init_decls T_COMMA type_init_decl
853	;	858	;
854		859
855	notype_init_decl:	860	notype_init_decl:
856	notype_decl opt_asm_or_symbolrename {	861	notype_decl opt_asm_or_symbolrename {
857	idecl($1, 0, $2);	862	idecl($1, 0, $2);
858	chksz($1);	863	chksz($1);
859	}	864	}
860	\| notype_decl opt_asm_or_symbolrename {	865	\| notype_decl opt_asm_or_symbolrename {
861	idecl($1, 1, $2);	866	idecl($1, 1, $2);
862	} T_ASSIGN initializer {	867	} T_ASSIGN initializer {
863	chksz($1);	868	chksz($1);
864	}	869	}
865	;	870	;
866		871
867	type_init_decl:	872	type_init_decl:
868	type_decl opt_asm_or_symbolrename {	873	type_decl opt_asm_or_symbolrename {
869	idecl($1, 0, $2);	874	idecl($1, 0, $2);
870	chksz($1);	875	chksz($1);
871	}	876	}
872	\| type_decl opt_asm_or_symbolrename {	877	\| type_decl opt_asm_or_symbolrename {
873	idecl($1, 1, $2);	878	idecl($1, 1, $2);
874	} T_ASSIGN initializer {	879	} T_ASSIGN initializer {
875	chksz($1);	880	chksz($1);
876	}	881	}
877	;	882	;
878		883
879	notype_decl:	884	notype_decl:
880	notype_direct_decl {	885	notype_direct_decl {
881	$$ = $1;	886	$$ = $1;
882	}	887	}
883	\| pointer notype_direct_decl {	888	\| pointer notype_direct_decl {
884	$$ = addptr($2, $1);	889	$$ = addptr($2, $1);
885	}	890	}
886	;	891	;
887		892
888	notype_direct_decl:	893	notype_direct_decl:
889	T_NAME {	894	T_NAME {
890	$$ = dname(getsym($1));	895	$$ = dname(getsym($1));
891	}	896	}
892	\| T_LPARN type_decl T_RPARN {	897	\| T_LPARN type_decl T_RPARN {
893	$$ = $2;	898	$$ = $2;
894	}	899	}
895	\| notype_direct_decl T_LBRACK T_RBRACK {	900	\| notype_direct_decl T_LBRACK T_RBRACK {
896	$$ = addarray($1, 0, 0);	901	$$ = addarray($1, 0, 0);
897	}	902	}
898	\| notype_direct_decl T_LBRACK constant T_RBRACK {	903	\| notype_direct_decl T_LBRACK constant T_RBRACK {
899	$$ = addarray($1, 1, toicon($3, 0));	904	$$ = addarray($1, 1, toicon($3, 0));
900	}	905	}
901	\| notype_direct_decl param_list {	906	\| notype_direct_decl param_list {
902	$$ = addfunc($1, $2);	907	$$ = addfunc($1, $2);
903	popdecl();	908	popdecl();
904	blklev--;	909	blklev--;
905	}	910	}
906	\| notype_direct_decl type_attribute	911	\| notype_direct_decl type_attribute
907	;	912	;
908		913
909	type_decl:	914	type_decl:
910	type_direct_decl {	915	type_direct_decl {
911	$$ = $1;	916	$$ = $1;
912	}	917	}
913	\| pointer type_direct_decl {	918	\| pointer type_direct_decl {
914	$$ = addptr($2, $1);	919	$$ = addptr($2, $1);
915	}	920	}
916	;	921	;
917		922
918	type_direct_decl:	923	type_direct_decl:
919	identifier {	924	identifier {
920	$$ = dname(getsym($1));	925	$$ = dname(getsym($1));
921	}	926	}
922	\| T_LPARN type_decl T_RPARN {	927	\| T_LPARN type_decl T_RPARN {
923	$$ = $2;	928	$$ = $2;
924	}	929	}
925	\| type_direct_decl T_LBRACK T_RBRACK {	930	\| type_direct_decl T_LBRACK T_RBRACK {
926	$$ = addarray($1, 0, 0);	931	$$ = addarray($1, 0, 0);
927	}	932	}
928	\| type_direct_decl T_LBRACK constant T_RBRACK {	933	\| type_direct_decl T_LBRACK constant T_RBRACK {
929	$$ = addarray($1, 1, toicon($3, 0));	934	$$ = addarray($1, 1, toicon($3, 0));
930	}	935	}
931	\| type_direct_decl param_list {	936	\| type_direct_decl param_list {
932	$$ = addfunc($1, $2);	937	$$ = addfunc($1, $2);
933	popdecl();	938	popdecl();
934	blklev--;	939	blklev--;
935	}	940	}
936	\| type_direct_decl type_attribute	941	\| type_direct_decl type_attribute
937	;	942	;
938		943
939	/*	944	/*
940	* param_decl and notype_param_decl exist to avoid a conflict in	945	* param_decl and notype_param_decl exist to avoid a conflict in
941	* argument lists. A typename enclosed in parens should always be	946	* argument lists. A typename enclosed in parens should always be
942	* treated as a typename, not an argument.	947	* treated as a typename, not an argument.
943	* "typedef int a; f(int (a));" is "typedef int a; f(int foo(a));"	948	* "typedef int a; f(int (a));" is "typedef int a; f(int foo(a));"
944	* not "typedef int a; f(int a);"	949	* not "typedef int a; f(int a);"
945	*/	950	*/
946	param_decl:	951	param_decl:
947	direct_param_decl {	952	direct_param_decl {
948	$$ = $1;	953	$$ = $1;
949	}	954	}
950	\| pointer direct_param_decl {	955	\| pointer direct_param_decl {
951	$$ = addptr($2, $1);	956	$$ = addptr($2, $1);
952	}	957	}
953	;	958	;
954		959
955	direct_param_decl:	960	direct_param_decl:
956	identifier {	961	identifier {
957	$$ = dname(getsym($1));	962	$$ = dname(getsym($1));
958	}	963	}
959	\| T_LPARN notype_param_decl T_RPARN {	964	\| T_LPARN notype_param_decl T_RPARN {
960	$$ = $2;	965	$$ = $2;
961	}	966	}
962	\| direct_param_decl T_LBRACK T_RBRACK {	967	\| direct_param_decl T_LBRACK T_RBRACK {
963	$$ = addarray($1, 0, 0);	968	$$ = addarray($1, 0, 0);
964	}	969	}
965	\| direct_param_decl T_LBRACK constant T_RBRACK {	970	\| direct_param_decl T_LBRACK constant T_RBRACK {
966	$$ = addarray($1, 1, toicon($3, 0));	971	$$ = addarray($1, 1, toicon($3, 0));
967	}	972	}
968	\| direct_param_decl param_list {	973	\| direct_param_decl param_list {
969	$$ = addfunc($1, $2);	974	$$ = addfunc($1, $2);
970	popdecl();	975	popdecl();
971	blklev--;	976	blklev--;
972	}	977	}
973	;	978	;
974		979
975	notype_param_decl:	980	notype_param_decl:
976	direct_notype_param_decl {	981	direct_notype_param_decl {
977	$$ = $1;	982	$$ = $1;
978	}	983	}
979	\| pointer direct_notype_param_decl {	984	\| pointer direct_notype_param_decl {
980	$$ = addptr($2, $1);	985	$$ = addptr($2, $1);
981	}	986	}
982	;	987	;
983		988
984	direct_notype_param_decl:	989	direct_notype_param_decl:
985	T_NAME {	990	T_NAME {
986	$$ = dname(getsym($1));	991	$$ = dname(getsym($1));
987	}	992	}
988	\| T_LPARN notype_param_decl T_RPARN {	993	\| T_LPARN notype_param_decl T_RPARN {
989	$$ = $2;	994	$$ = $2;
990	}	995	}
991	\| direct_notype_param_decl T_LBRACK T_RBRACK {	996	\| direct_notype_param_decl T_LBRACK T_RBRACK {
992	$$ = addarray($1, 0, 0);	997	$$ = addarray($1, 0, 0);
993	}	998	}
994	\| direct_notype_param_decl T_LBRACK constant T_RBRACK {	999	\| direct_notype_param_decl T_LBRACK constant T_RBRACK {
995	$$ = addarray($1, 1, toicon($3, 0));	1000	$$ = addarray($1, 1, toicon($3, 0));
996	}	1001	}
997	\| direct_notype_param_decl param_list {	1002	\| direct_notype_param_decl param_list {
998	$$ = addfunc($1, $2);	1003	$$ = addfunc($1, $2);
999	popdecl();	1004	popdecl();
1000	blklev--;	1005	blklev--;
1001	}	1006	}
1002	;	1007	;
1003		1008
1004	pointer:	1009	pointer:
1005	asterisk {	1010	asterisk {
1006	$$ = $1;	1011	$$ = $1;
1007	}	1012	}
1008	\| asterisk type_qualifier_list {	1013	\| asterisk type_qualifier_list {
1009	$$ = mergepq($1, $2);	1014	$$ = mergepq($1, $2);
1010	}	1015	}
1011	\| asterisk pointer {	1016	\| asterisk pointer {
1012	$$ = mergepq($1, $2);	1017	$$ = mergepq($1, $2);
1013	}	1018	}
1014	\| asterisk type_qualifier_list pointer {	1019	\| asterisk type_qualifier_list pointer {
1015	$$ = mergepq(mergepq($1, $2), $3);	1020	$$ = mergepq(mergepq($1, $2), $3);
1016	}	1021	}
1017	;	1022	;
1018		1023
1019	asterisk:	1024	asterisk:
1020	T_MULT {	1025	T_MULT {
1021	$$ = xcalloc(1, sizeof (pqinf_t));	1026	$$ = xcalloc(1, sizeof (pqinf_t));
1022	$$->p_pcnt = 1;	1027	$$->p_pcnt = 1;
1023	}	1028	}
1024	;	1029	;
1025		1030
1026	type_qualifier_list:	1031	type_qualifier_list:
1027	type_qualifier {	1032	type_qualifier {
1028	$$ = $1;	1033	$$ = $1;
1029	}	1034	}
1030	\| type_qualifier_list type_qualifier {	1035	\| type_qualifier_list type_qualifier {
1031	$$ = mergepq($1, $2);	1036	$$ = mergepq($1, $2);
1032	}	1037	}
1033	;	1038	;
1034		1039
1035	type_qualifier:	1040	type_qualifier:
1036	T_QUAL {	1041	T_QUAL {
1037	$$ = xcalloc(1, sizeof (pqinf_t));	1042	$$ = xcalloc(1, sizeof (pqinf_t));
1038	if ($1 == CONST) {	1043	if ($1 == CONST) {
1039	$$->p_const = 1;	1044	$$->p_const = 1;
1040	} else {	1045	} else {
1041	$$->p_volatile = 1;	1046	$$->p_volatile = 1;
1042	}	1047	}
1043	}	1048	}
1044	;	1049	;
1045		1050
1046	param_list:	1051	param_list:
1047	id_list_lparn identifier_list T_RPARN {	1052	id_list_lparn identifier_list T_RPARN {
1048	$$ = $2;	1053	$$ = $2;
1049	}	1054	}
1050	\| abs_decl_param_list {	1055	\| abs_decl_param_list {
1051	$$ = $1;	1056	$$ = $1;
1052	}	1057	}
1053	;	1058	;
1054		1059
1055	id_list_lparn:	1060	id_list_lparn:
1056	T_LPARN {	1061	T_LPARN {
1057	blklev++;	1062	blklev++;
1058	pushdecl(PARG);	1063	pushdecl(PARG);
1059	}	1064	}
1060	;	1065	;
1061		1066
1062	identifier_list:	1067	identifier_list:
1063	T_NAME {	1068	T_NAME {
1064	$$ = iname(getsym($1));	1069	$$ = iname(getsym($1));
1065	}	1070	}
1066	\| identifier_list T_COMMA T_NAME {	1071	\| identifier_list T_COMMA T_NAME {
1067	$$ = lnklst($1, iname(getsym($3)));	1072	$$ = lnklst($1, iname(getsym($3)));
1068	}	1073	}
1069	\| identifier_list error {	1074	\| identifier_list error {
1070	$$ = $1;	1075	$$ = $1;
1071	}	1076	}
1072	;	1077	;
1073		1078
1074	abs_decl_param_list:	1079	abs_decl_param_list:
1075	abs_decl_lparn T_RPARN {	1080	abs_decl_lparn T_RPARN {
1076	$$ = NULL;	1081	$$ = NULL;
1077	}	1082	}
1078	\| abs_decl_lparn vararg_parameter_type_list T_RPARN {	1083	\| abs_decl_lparn vararg_parameter_type_list T_RPARN {
1079	dcs->d_proto = 1;	1084	dcs->d_proto = 1;
1080	$$ = $2;	1085	$$ = $2;
1081	}	1086	}
1082	\| abs_decl_lparn error T_RPARN {	1087	\| abs_decl_lparn error T_RPARN {
1083	$$ = NULL;	1088	$$ = NULL;
1084	}	1089	}
1085	;	1090	;
1086		1091
1087	abs_decl_lparn:	1092	abs_decl_lparn:
1088	T_LPARN {	1093	T_LPARN {
1089	blklev++;	1094	blklev++;
1090	pushdecl(PARG);	1095	pushdecl(PARG);
1091	}	1096	}
1092	;	1097	;
1093		1098
1094	vararg_parameter_type_list:	1099	vararg_parameter_type_list:
1095	parameter_type_list {	1100	parameter_type_list {
1096	$$ = $1;	1101	$$ = $1;
1097	}	1102	}
1098	\| parameter_type_list T_COMMA T_ELLIPSE {	1103	\| parameter_type_list T_COMMA T_ELLIPSE {
1099	dcs->d_vararg = 1;	1104	dcs->d_vararg = 1;
1100	$$ = $1;	1105	$$ = $1;
1101	}	1106	}
1102	\| T_ELLIPSE {	1107	\| T_ELLIPSE {
1103	if (sflag) {	1108	if (sflag) {
1104	/* ANSI C requires formal parameter before "..." */	1109	/* ANSI C requires formal parameter before "..." */
1105	error(84);	1110	error(84);
1106	} else if (!tflag) {	1111	} else if (!tflag) {
1107	/* ANSI C requires formal parameter before "..." */	1112	/* ANSI C requires formal parameter before "..." */
1108	warning(84);	1113	warning(84);
1109	}	1114	}
1110	dcs->d_vararg = 1;	1115	dcs->d_vararg = 1;
1111	$$ = NULL;	1116	$$ = NULL;
1112	}	1117	}
1113	;	1118	;
1114		1119
1115	parameter_type_list:	1120	parameter_type_list:
1116	parameter_declaration {	1121	parameter_declaration {
1117	$$ = $1;	1122	$$ = $1;
1118	}	1123	}
1119	\| parameter_type_list T_COMMA parameter_declaration {	1124	\| parameter_type_list T_COMMA parameter_declaration {
1120	$$ = lnklst($1, $3);	1125	$$ = lnklst($1, $3);
1121	}	1126	}
1122	;	1127	;
1123		1128
1124	parameter_declaration:	1129	parameter_declaration:
1125	declmods deftyp {	1130	declmods deftyp {
1126	$$ = decl1arg(aname(), 0);	1131	$$ = decl1arg(aname(), 0);
1127	}	1132	}
1128	\| declspecs deftyp {	1133	\| declspecs deftyp {
1129	$$ = decl1arg(aname(), 0);	1134	$$ = decl1arg(aname(), 0);
1130	}	1135	}
1131	\| declmods deftyp notype_param_decl {	1136	\| declmods deftyp notype_param_decl {
1132	$$ = decl1arg($3, 0);	1137	$$ = decl1arg($3, 0);
1133	}	1138	}
1134	/*	1139	/*
1135	* param_decl is needed because of following conflict:	1140	* param_decl is needed because of following conflict:
1136	* "typedef int a; f(int (a));" could be parsed as	1141	* "typedef int a; f(int (a));" could be parsed as
1137	* "function with argument a of type int", or	1142	* "function with argument a of type int", or
1138	* "function with an abstract argument of type function".	1143	* "function with an abstract argument of type function".
1139	* This grammar realizes the second case.	1144	* This grammar realizes the second case.
1140	*/	1145	*/
1141	\| declspecs deftyp param_decl {	1146	\| declspecs deftyp param_decl {
1142	$$ = decl1arg($3, 0);	1147	$$ = decl1arg($3, 0);
1143	}	1148	}
1144	\| declmods deftyp abs_decl {	1149	\| declmods deftyp abs_decl {
1145	$$ = decl1arg($3, 0);	1150	$$ = decl1arg($3, 0);
1146	}	1151	}
1147	\| declspecs deftyp abs_decl {	1152	\| declspecs deftyp abs_decl {
1148	$$ = decl1arg($3, 0);	1153	$$ = decl1arg($3, 0);
1149	}	1154	}
1150	;	1155	;
1151		1156
1152	opt_asm_or_symbolrename: /* expect only one */	1157	opt_asm_or_symbolrename: /* expect only one */
1153	/* empty */ {	1158	/* empty */ {
1154	$$ = NULL;	1159	$$ = NULL;
1155	}	1160	}
1156	\| T_ASM T_LPARN T_STRING T_RPARN {	1161	\| T_ASM T_LPARN T_STRING T_RPARN {
1157	freeyyv(&$3, T_STRING);	1162	freeyyv(&$3, T_STRING);
1158	$$ = NULL;	1163	$$ = NULL;
1159	}	1164	}
1160	\| T_SYMBOLRENAME T_LPARN T_NAME T_RPARN {	1165	\| T_SYMBOLRENAME T_LPARN T_NAME T_RPARN {
1161	$$ = $3;	1166	$$ = $3;
1162	}	1167	}
1163	;	1168	;
1164		1169
1165	initializer:	1170	initializer:
1166	init_expr	1171	init_expr
1167	;	1172	;
1168		1173
1169	init_expr:	1174	init_expr:
1170	expr %prec T_COMMA {	1175	expr %prec T_COMMA {
1171	mkinit($1);	1176	mkinit($1);
1172	}	1177	}
1173	\| init_by_name init_expr %prec T_COMMA	1178	\| init_by_name init_expr %prec T_COMMA
1174	\| init_lbrace init_rbrace	1179	\| init_lbrace init_rbrace
1175	\| init_lbrace init_expr_list init_rbrace	1180	\| init_lbrace init_expr_list init_rbrace
1176	\| init_lbrace init_expr_list T_COMMA init_rbrace	1181	\| init_lbrace init_expr_list T_COMMA init_rbrace
1177	\| error	1182	\| error
1178	;	1183	;
1179		1184
1180	init_expr_list:	1185	init_expr_list:
1181	init_expr %prec T_COMMA	1186	init_expr %prec T_COMMA
1182	\| init_expr_list T_COMMA init_expr	1187	\| init_expr_list T_COMMA init_expr
1183	;	1188	;
1184		1189
1185	lorange:	1190	lorange:
1186	constant T_ELLIPSE {	1191	constant T_ELLIPSE {
1187	$$.lo = toicon($1, 1);	1192	$$.lo = toicon($1, 1);
1188	}	1193	}
1189	;	1194	;
1190	range:	1195	range:
1191	constant {	1196	constant {
1192	$$.lo = toicon($1, 1);	1197	$$.lo = toicon($1, 1);
1193	$$.hi = $$.lo + 1;	1198	$$.hi = $$.lo + 1;
1194	}	1199	}
1195	\| lorange constant {	1200	\| lorange constant {
1196	$$.lo = $1.lo;	1201	$$.lo = $1.lo;
1197	$$.hi = toicon($2, 1);	1202	$$.hi = toicon($2, 1);
1198	}	1203	}
1199	;	1204	;
1200		1205
1201	init_by_name:	1206	init_by_name:
1202	T_LBRACK range T_RBRACK T_ASSIGN {	1207	T_LBRACK range T_RBRACK T_ASSIGN {
1203	if (!Sflag)	1208	if (!Sflag)
1204	warning(321);	1209	warning(321);
1205	}	1210	}
1206	\| point identifier T_ASSIGN {	1211	\| point identifier T_ASSIGN {
1207	if (!Sflag)	1212	if (!Sflag)
1208	warning(313);	1213	warning(313);
1209	memberpush($2);	1214	memberpush($2);
1210	}	1215	}
1211	\| identifier T_COLON {	1216	\| identifier T_COLON {
1212	gnuism(315);	1217	gnuism(315);
1213	memberpush($1);	1218	memberpush($1);
1214	}	1219	}
1215	;	1220	;
1216		1221
1217	init_lbrace:	1222	init_lbrace:
1218	T_LBRACE {	1223	T_LBRACE {
1219	initlbr();	1224	initlbr();
1220	}	1225	}
1221	;	1226	;
1222		1227
1223	init_rbrace:	1228	init_rbrace:
1224	T_RBRACE {	1229	T_RBRACE {
1225	initrbr();	1230	initrbr();
1226	}	1231	}
1227	;	1232	;
1228		1233
1229	type_name:	1234	type_name:
1230	{	1235	{
1231	pushdecl(ABSTRACT);	1236	pushdecl(ABSTRACT);
1232	} abstract_declaration {	1237	} abstract_declaration {
1233	popdecl();	1238	popdecl();
1234	$$ = $2->s_type;	1239	$$ = $2->s_type;
1235	}	1240	}
1236	;	1241	;
1237		1242
1238	abstract_declaration:	1243	abstract_declaration:
1239	noclass_declmods deftyp {	1244	noclass_declmods deftyp {
1240	$$ = decl1abs(aname());	1245	$$ = decl1abs(aname());
1241	}	1246	}
1242	\| noclass_declspecs deftyp {	1247	\| noclass_declspecs deftyp {
1243	$$ = decl1abs(aname());	1248	$$ = decl1abs(aname());
1244	}	1249	}
1245	\| noclass_declmods deftyp abs_decl {	1250	\| noclass_declmods deftyp abs_decl {
1246	$$ = decl1abs($3);	1251	$$ = decl1abs($3);
1247	}	1252	}
1248	\| noclass_declspecs deftyp abs_decl {	1253	\| noclass_declspecs deftyp abs_decl {
1249	$$ = decl1abs($3);	1254	$$ = decl1abs($3);
1250	}	1255	}
1251	;	1256	;
1252		1257
1253	abs_decl:	1258	abs_decl:
1254	pointer {	1259	pointer {
1255	$$ = addptr(aname(), $1);	1260	$$ = addptr(aname(), $1);
1256	}	1261	}
1257	\| direct_abs_decl {	1262	\| direct_abs_decl {
1258	$$ = $1;	1263	$$ = $1;
1259	}	1264	}
1260	\| pointer direct_abs_decl {	1265	\| pointer direct_abs_decl {
1261	$$ = addptr($2, $1);	1266	$$ = addptr($2, $1);
1262	}	1267	}
1263	;	1268	;
1264		1269
1265	direct_abs_decl:	1270	direct_abs_decl:
1266	T_LPARN abs_decl T_RPARN {	1271	T_LPARN abs_decl T_RPARN {
1267	$$ = $2;	1272	$$ = $2;
1268	}	1273	}
1269	\| T_LBRACK T_RBRACK {	1274	\| T_LBRACK T_RBRACK {
1270	$$ = addarray(aname(), 0, 0);	1275	$$ = addarray(aname(), 0, 0);
1271	}	1276	}
1272	\| T_LBRACK constant T_RBRACK {	1277	\| T_LBRACK constant T_RBRACK {
1273	$$ = addarray(aname(), 1, toicon($2, 0));	1278	$$ = addarray(aname(), 1, toicon($2, 0));
1274	}	1279	}
1275	\| direct_abs_decl T_LBRACK T_RBRACK {	1280	\| direct_abs_decl T_LBRACK T_RBRACK {
1276	$$ = addarray($1, 0, 0);	1281	$$ = addarray($1, 0, 0);
1277	}	1282	}
1278	\| direct_abs_decl T_LBRACK constant T_RBRACK {	1283	\| direct_abs_decl T_LBRACK constant T_RBRACK {
1279	$$ = addarray($1, 1, toicon($3, 0));	1284	$$ = addarray($1, 1, toicon($3, 0));
1280	}	1285	}
1281	\| abs_decl_param_list {	1286	\| abs_decl_param_list {
1282	$$ = addfunc(aname(), $1);	1287	$$ = addfunc(aname(), $1);
1283	popdecl();	1288	popdecl();
1284	blklev--;	1289	blklev--;
1285	}	1290	}
1286	\| direct_abs_decl abs_decl_param_list {	1291	\| direct_abs_decl abs_decl_param_list {
1287	$$ = addfunc($1, $2);	1292	$$ = addfunc($1, $2);
1288	popdecl();	1293	popdecl();
1289	blklev--;	1294	blklev--;
1290	}	1295	}
1291	\| direct_abs_decl type_attribute	1296	\| direct_abs_decl type_attribute
1292	;	1297	;
1293		1298
1294	non_expr_stmnt:	1299	non_expr_stmnt:
1295	labeled_stmnt	1300	labeled_stmnt
1296	\| comp_stmnt	1301	\| comp_stmnt
1297	\| selection_stmnt	1302	\| selection_stmnt
1298	\| iteration_stmnt	1303	\| iteration_stmnt
1299	\| jump_stmnt {	1304	\| jump_stmnt {
1300	ftflg = 0;	1305	ftflg = 0;
1301	}	1306	}
1302	\| asm_stmnt	1307	\| asm_stmnt
1303		1308
1304	stmnt:	1309	stmnt:
1305	expr_stmnt	1310	expr_stmnt
1306	\| non_expr_stmnt	1311	\| non_expr_stmnt
1307	;	1312	;
1308		1313
1309	labeled_stmnt:	1314	labeled_stmnt:
1310	label stmnt	1315	label stmnt
1311	;	1316	;
1312		1317
1313	label:	1318	label:
1314	T_NAME T_COLON {	1319	T_NAME T_COLON {
1315	symtyp = FLAB;	1320	symtyp = FLAB;
1316	label(T_NAME, getsym($1), NULL);	1321	label(T_NAME, getsym($1), NULL);
1317	}	1322	}
1318	\| T_CASE constant T_COLON {	1323	\| T_CASE constant T_COLON {
1319	label(T_CASE, NULL, $2);	1324	label(T_CASE, NULL, $2);
1320	ftflg = 1;	1325	ftflg = 1;
1321	}	1326	}
1322	\| T_CASE constant T_ELLIPSE constant T_COLON {	1327	\| T_CASE constant T_ELLIPSE constant T_COLON {
1323	/* XXX: We don't fill all cases */	1328	/* XXX: We don't fill all cases */
1324	label(T_CASE, NULL, $2);	1329	label(T_CASE, NULL, $2);
1325	ftflg = 1;	1330	ftflg = 1;
1326	}	1331	}
1327	\| T_DEFAULT T_COLON {	1332	\| T_DEFAULT T_COLON {
1328	label(T_DEFAULT, NULL, NULL);	1333	label(T_DEFAULT, NULL, NULL);
1329	ftflg = 1;	1334	ftflg = 1;
1330	}	1335	}
1331	;	1336	;
1332		1337
1333	stmnt_d_list:	1338	stmnt_d_list:
1334	stmnt_list	1339	stmnt_list
1335	\| stmnt_d_list declaration_list stmnt_list {	1340	\| stmnt_d_list declaration_list stmnt_list {
1336	if (!Sflag)	1341	if (!Sflag)
1337	c99ism(327);	1342	c99ism(327);
1338	}	1343	}
1339	;	1344	;
1340		1345
1341	comp_stmnt:	1346	comp_stmnt:
1342	comp_stmnt_lbrace comp_stmnt_rbrace	1347	comp_stmnt_lbrace comp_stmnt_rbrace
1343	\| comp_stmnt_lbrace stmnt_d_list comp_stmnt_rbrace	1348	\| comp_stmnt_lbrace stmnt_d_list comp_stmnt_rbrace
1344	\| comp_stmnt_lbrace declaration_list comp_stmnt_rbrace	1349	\| comp_stmnt_lbrace declaration_list comp_stmnt_rbrace
1345	\| comp_stmnt_lbrace declaration_list stmnt_d_list comp_stmnt_rbrace	1350	\| comp_stmnt_lbrace declaration_list stmnt_d_list comp_stmnt_rbrace
1346	;	1351	;
1347		1352
1348	comp_stmnt_lbrace:	1353	comp_stmnt_lbrace:
1349	T_LBRACE {	1354	T_LBRACE {
1350	blklev++;	1355	blklev++;
1351	mblklev++;	1356	mblklev++;
1352	pushdecl(AUTO);	1357	pushdecl(AUTO);
1353	}	1358	}
1354	;	1359	;
1355		1360
1356	comp_stmnt_rbrace:	1361	comp_stmnt_rbrace:
1357	T_RBRACE {	1362	T_RBRACE {
1358	popdecl();	1363	popdecl();
1359	freeblk();	1364	freeblk();
1360	mblklev--;	1365	mblklev--;
1361	blklev--;	1366	blklev--;
1362	ftflg = 0;	1367	ftflg = 0;
1363	}	1368	}
1364	;	1369	;
1365		1370
1366	stmnt_list:	1371	stmnt_list:
1367	stmnt	1372	stmnt
1368	\| stmnt_list stmnt {	1373	\| stmnt_list stmnt {
1369	RESTORE(__FILE__, __LINE__);	1374	RESTORE(__FILE__, __LINE__);
1370	}	1375	}
1371	\| stmnt_list error T_SEMI	1376	\| stmnt_list error T_SEMI
1372	;	1377	;
1373		1378
1374	expr_stmnt:	1379	expr_stmnt:
1375	expr T_SEMI {	1380	expr T_SEMI {
1376	expr($1, 0, 0, 1);	1381	expr($1, 0, 0, 1);
1377	ftflg = 0;	1382	ftflg = 0;
1378	}	1383	}
1379	\| T_SEMI {	1384	\| T_SEMI {
1380	ftflg = 0;	1385	ftflg = 0;
1381	}	1386	}
1382	;	1387	;
1383		1388
1384	/*	1389	/*
1385	* The following two productions are used to implement	1390	* The following two productions are used to implement
1386	* ({ [[decl-list] stmt-list] }).	1391	* ({ [[decl-list] stmt-list] }).
1387	* XXX: This is not well tested.	1392	* XXX: This is not well tested.
1388	*/	1393	*/
1389	expr_stmnt_val:	1394	expr_stmnt_val:
1390	expr T_SEMI {	1395	expr T_SEMI {
1391	/* XXX: We should really do that only on the last name */	1396	/* XXX: We should really do that only on the last name */
1392	if ($1->tn_op == NAME)	1397	if ($1->tn_op == NAME)
1393	$1->tn_sym->s_used = 1;	1398	$1->tn_sym->s_used = 1;
1394	$$ = $1;	1399	$$ = $1;
1395	expr($1, 0, 0, 0);	1400	expr($1, 0, 0, 0);
1396	ftflg = 0;	1401	ftflg = 0;
1397	}	1402	}
1398	\| non_expr_stmnt {	1403	\| non_expr_stmnt {
1399	$$ = getnode();	1404	$$ = getnode();
1400	$$->tn_type = gettyp(VOID);	1405	$$->tn_type = gettyp(VOID);
1401	}	1406	}
1402	;	1407	;
1403		1408
1404	expr_stmnt_list:	1409	expr_stmnt_list:
1405	expr_stmnt_val	1410	expr_stmnt_val
1406	\| expr_stmnt_list expr_stmnt_val {	1411	\| expr_stmnt_list expr_stmnt_val {
1407	$$ = $2;	1412	$$ = $2;
1408	}	1413	}
1409	;	1414	;
1410		1415
1411	selection_stmnt:	1416	selection_stmnt:
1412	if_without_else {	1417	if_without_else {
1413	SAVE(__FILE__, __LINE__);	1418	SAVE(__FILE__, __LINE__);
1414	if2();	1419	if2();
1415	if3(0);	1420	if3(0);
1416	}	1421	}
1417	\| if_without_else T_ELSE {	1422	\| if_without_else T_ELSE {
1418	SAVE(__FILE__, __LINE__);	1423	SAVE(__FILE__, __LINE__);
1419	if2();	1424	if2();
1420	} stmnt {	1425	} stmnt {
1421	CLRWFLGS(__FILE__, __LINE__);	1426	CLRWFLGS(__FILE__, __LINE__);
1422	if3(1);	1427	if3(1);
1423	}	1428	}
1424	\| if_without_else T_ELSE error {	1429	\| if_without_else T_ELSE error {
1425	CLRWFLGS(__FILE__, __LINE__);	1430	CLRWFLGS(__FILE__, __LINE__);
1426	if3(0);	1431	if3(0);
1427	}	1432	}
1428	\| switch_expr stmnt {	1433	\| switch_expr stmnt {
1429	CLRWFLGS(__FILE__, __LINE__);	1434	CLRWFLGS(__FILE__, __LINE__);
1430	switch2();	1435	switch2();
1431	}	1436	}
1432	\| switch_expr error {	1437	\| switch_expr error {
1433	CLRWFLGS(__FILE__, __LINE__);	1438	CLRWFLGS(__FILE__, __LINE__);
1434	switch2();	1439	switch2();
1435	}	1440	}
1436	;	1441	;
1437		1442
1438	if_without_else:	1443	if_without_else:
1439	if_expr stmnt	1444	if_expr stmnt
1440	\| if_expr error	1445	\| if_expr error
1441	;	1446	;
1442		1447
1443	if_expr:	1448	if_expr:
1444	T_IF T_LPARN expr T_RPARN {	1449	T_IF T_LPARN expr T_RPARN {
1445	if1($3);	1450	if1($3);
1446	CLRWFLGS(__FILE__, __LINE__);	1451	CLRWFLGS(__FILE__, __LINE__);
1447	}	1452	}
1448	;	1453	;
1449		1454
1450	switch_expr:	1455	switch_expr:
1451	T_SWITCH T_LPARN expr T_RPARN {	1456	T_SWITCH T_LPARN expr T_RPARN {
1452	switch1($3);	1457	switch1($3);
1453	CLRWFLGS(__FILE__, __LINE__);	1458	CLRWFLGS(__FILE__, __LINE__);
1454	}	1459	}
1455	;	1460	;
1456		1461
1457	do_stmnt:	1462	do_stmnt:
1458	do stmnt {	1463	do stmnt {
1459	CLRWFLGS(__FILE__, __LINE__);	1464	CLRWFLGS(__FILE__, __LINE__);
1460	}	1465	}
1461	;	1466	;
1462		1467
1463	iteration_stmnt:	1468	iteration_stmnt:
1464	while_expr stmnt {	1469	while_expr stmnt {
1465	CLRWFLGS(__FILE__, __LINE__);	1470	CLRWFLGS(__FILE__, __LINE__);
1466	while2();	1471	while2();
1467	}	1472	}
1468	\| while_expr error {	1473	\| while_expr error {
1469	CLRWFLGS(__FILE__, __LINE__);	1474	CLRWFLGS(__FILE__, __LINE__);
1470	while2();	1475	while2();
1471	}	1476	}
1472	\| do_stmnt do_while_expr {	1477	\| do_stmnt do_while_expr {
1473	do2($2);	1478	do2($2);
1474	ftflg = 0;	1479	ftflg = 0;
1475	}	1480	}
1476	\| do error {	1481	\| do error {
1477	CLRWFLGS(__FILE__, __LINE__);	1482	CLRWFLGS(__FILE__, __LINE__);
1478	do2(NULL);	1483	do2(NULL);
1479	}	1484	}
1480	\| for_exprs stmnt {	1485	\| for_exprs stmnt {
1481	CLRWFLGS(__FILE__, __LINE__);	1486	CLRWFLGS(__FILE__, __LINE__);
1482	for2();	1487	for2();
1483	}	1488	}
1484	\| for_exprs error {	1489	\| for_exprs error {
1485	CLRWFLGS(__FILE__, __LINE__);	1490	CLRWFLGS(__FILE__, __LINE__);
1486	for2();	1491	for2();
1487	}	1492	}
1488	;	1493	;
1489		1494
1490	while_expr:	1495	while_expr:
1491	T_WHILE T_LPARN expr T_RPARN {	1496	T_WHILE T_LPARN expr T_RPARN {
1492	while1($3);	1497	while1($3);
1493	CLRWFLGS(__FILE__, __LINE__);	1498	CLRWFLGS(__FILE__, __LINE__);
1494	}	1499	}
1495	;	1500	;
1496		1501
1497	do:	1502	do:
1498	T_DO {	1503	T_DO {
1499	do1();	1504	do1();
1500	}	1505	}
1501	;	1506	;
1502		1507
1503	do_while_expr:	1508	do_while_expr:
1504	T_WHILE T_LPARN expr T_RPARN T_SEMI {	1509	T_WHILE T_LPARN expr T_RPARN T_SEMI {
1505	$$ = $3;	1510	$$ = $3;
1506	}	1511	}
1507	;	1512	;
1508		1513
1509	for_exprs:	1514	for_exprs:
1510	T_FOR T_LPARN declspecs deftyp notype_init_decls T_SEMI opt_expr	1515	T_FOR T_LPARN declspecs deftyp notype_init_decls T_SEMI opt_expr
1511	T_SEMI opt_expr T_RPARN {	1516	T_SEMI opt_expr T_RPARN {
1512	c99ism(325);	1517	c99ism(325);
1513	for1(NULL, $7, $9);	1518	for1(NULL, $7, $9);
1514	CLRWFLGS(__FILE__, __LINE__);	1519	CLRWFLGS(__FILE__, __LINE__);
1515	}	1520	}
1516	\| T_FOR T_LPARN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPARN {	1521	\| T_FOR T_LPARN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPARN {
1517	for1($3, $5, $7);	1522	for1($3, $5, $7);
1518	CLRWFLGS(__FILE__, __LINE__);	1523	CLRWFLGS(__FILE__, __LINE__);
1519	}	1524	}
1520	;	1525	;
1521		1526
1522	opt_expr:	1527	opt_expr:
1523	/* empty */ {	1528	/* empty */ {
1524	$$ = NULL;	1529	$$ = NULL;
1525	}	1530	}
1526	\| expr {	1531	\| expr {
1527	$$ = $1;	1532	$$ = $1;
1528	}	1533	}
1529	;	1534	;
1530		1535
1531	jump_stmnt:	1536	jump_stmnt:
1532	goto identifier T_SEMI {	1537	goto identifier T_SEMI {
1533	dogoto(getsym($2));	1538	dogoto(getsym($2));
1534	}	1539	}
1535	\| goto error T_SEMI {	1540	\| goto error T_SEMI {
1536	symtyp = FVFT;	1541	symtyp = FVFT;
1537	}	1542	}
1538	\| T_CONTINUE T_SEMI {	1543	\| T_CONTINUE T_SEMI {
1539	docont();	1544	docont();
1540	}	1545	}
1541	\| T_BREAK T_SEMI {	1546	\| T_BREAK T_SEMI {
1542	dobreak();	1547	dobreak();
1543	}	1548	}
1544	\| T_RETURN T_SEMI {	1549	\| T_RETURN T_SEMI {
1545	doreturn(NULL);	1550	doreturn(NULL);
1546	}	1551	}
1547	\| T_RETURN expr T_SEMI {	1552	\| T_RETURN expr T_SEMI {
1548	doreturn($2);	1553	doreturn($2);
1549	}	1554	}
1550	;	1555	;
1551		1556
1552	goto:	1557	goto:
1553	T_GOTO {	1558	T_GOTO {
1554	symtyp = FLAB;	1559	symtyp = FLAB;
1555	}	1560	}
1556	;	1561	;
1557		1562
1558	asm_stmnt:	1563	asm_stmnt:
1559	T_ASM T_LPARN read_until_rparn T_SEMI {	1564	T_ASM T_LPARN read_until_rparn T_SEMI {
1560	setasm();	1565	setasm();
1561	}	1566	}
1562	\| T_ASM T_QUAL T_LPARN read_until_rparn T_SEMI {	1567	\| T_ASM T_QUAL T_LPARN read_until_rparn T_SEMI {
1563	setasm();	1568	setasm();
1564	}	1569	}
1565	\| T_ASM error	1570	\| T_ASM error
1566	;	1571	;
1567		1572
1568	read_until_rparn:	1573	read_until_rparn:
1569	/* empty */ {	1574	/* empty */ {
1570	ignuptorp();	1575	ignuptorp();
1571	}	1576	}
1572	;	1577	;
1573		1578
1574	declaration_list:	1579	declaration_list:
1575	declaration {	1580	declaration {
1576	CLRWFLGS(__FILE__, __LINE__);	1581	CLRWFLGS(__FILE__, __LINE__);
1577	}	1582	}
1578	\| declaration_list declaration {	1583	\| declaration_list declaration {
1579	CLRWFLGS(__FILE__, __LINE__);	1584	CLRWFLGS(__FILE__, __LINE__);
1580	}	1585	}
1581	;	1586	;
1582		1587
1583	constant:	1588	constant:
1584	expr %prec T_COMMA {	1589	expr %prec T_COMMA {
1585	$$ = $1;	1590	$$ = $1;
1586	}	1591	}
1587	;	1592	;
1588		1593
1589	expr:	1594	expr:
1590	expr T_MULT expr {	1595	expr T_MULT expr {
1591	$$ = build(MULT, $1, $3);	1596	$$ = build(MULT, $1, $3);
1592	}	1597	}
1593	\| expr T_DIVOP expr {	1598	\| expr T_DIVOP expr {
1594	$$ = build($2, $1, $3);	1599	$$ = build($2, $1, $3);
1595	}	1600	}
1596	\| expr T_ADDOP expr {	1601	\| expr T_ADDOP expr {
1597	$$ = build($2, $1, $3);	1602	$$ = build($2, $1, $3);
1598	}	1603	}
1599	\| expr T_SHFTOP expr {	1604	\| expr T_SHFTOP expr {
1600	$$ = build($2, $1, $3);	1605	$$ = build($2, $1, $3);
1601	}	1606	}
1602	\| expr T_RELOP expr {	1607	\| expr T_RELOP expr {
1603	$$ = build($2, $1, $3);	1608	$$ = build($2, $1, $3);
1604	}	1609	}
1605	\| expr T_EQOP expr {	1610	\| expr T_EQOP expr {
1606	$$ = build($2, $1, $3);	1611	$$ = build($2, $1, $3);
1607	}	1612	}
1608	\| expr T_AND expr {	1613	\| expr T_AND expr {
1609	$$ = build(AND, $1, $3);	1614	$$ = build(AND, $1, $3);
1610	}	1615	}
1611	\| expr T_XOR expr {	1616	\| expr T_XOR expr {
1612	$$ = build(XOR, $1, $3);	1617	$$ = build(XOR, $1, $3);
1613	}	1618	}
1614	\| expr T_OR expr {	1619	\| expr T_OR expr {
1615	$$ = build(OR, $1, $3);	1620	$$ = build(OR, $1, $3);
1616	}	1621	}
1617	\| expr T_LOGAND expr {	1622	\| expr T_LOGAND expr {
1618	$$ = build(LOGAND, $1, $3);	1623	$$ = build(LOGAND, $1, $3);
1619	}	1624	}
1620	\| expr T_LOGOR expr {	1625	\| expr T_LOGOR expr {
1621	$$ = build(LOGOR, $1, $3);	1626	$$ = build(LOGOR, $1, $3);
1622	}	1627	}
1623	\| expr T_QUEST expr T_COLON expr {	1628	\| expr T_QUEST expr T_COLON expr {
1624	$$ = build(QUEST, $1, build(COLON, $3, $5));	1629	$$ = build(QUEST, $1, build(COLON, $3, $5));
1625	}	1630	}
1626	\| expr T_ASSIGN expr {	1631	\| expr T_ASSIGN expr {
1627	$$ = build(ASSIGN, $1, $3);	1632	$$ = build(ASSIGN, $1, $3);
1628	}	1633	}
1629	\| expr T_OPASS expr {	1634	\| expr T_OPASS expr {
1630	$$ = build($2, $1, $3);	1635	$$ = build($2, $1, $3);
1631	}	1636	}
1632	\| expr T_COMMA expr {	1637	\| expr T_COMMA expr {
1633	$$ = build(COMMA, $1, $3);	1638	$$ = build(COMMA, $1, $3);
1634	}	1639	}
1635	\| term {	1640	\| term {
1636	$$ = $1;	1641	$$ = $1;
1637	}	1642	}
1638	;	1643	;
1639		1644
1640	term:	1645	term:
1641	T_NAME {	1646	T_NAME {
1642	/* XXX really necessary? */	1647	/* XXX really necessary? */
1643	if (yychar < 0)	1648	if (yychar < 0)
1644	yychar = yylex();	1649	yychar = yylex();
1645	$$ = getnnode(getsym($1), yychar);	1650	$$ = getnnode(getsym($1), yychar);
1646	}	1651	}
1647	\| string {	1652	\| string {
1648	$$ = getsnode($1);	1653	$$ = getsnode($1);
1649	}	1654	}
1650	\| T_CON {	1655	\| T_CON {
1651	$$ = getcnode(gettyp($1->v_tspec), $1);	1656	$$ = getcnode(gettyp($1->v_tspec), $1);
1652	}	1657	}
1653	\| T_LPARN expr T_RPARN {	1658	\| T_LPARN expr T_RPARN {
1654	if ($2 != NULL)	1659	if ($2 != NULL)
1655	$2->tn_parn = 1;	1660	$2->tn_parn = 1;
1656	$$ = $2;	1661	$$ = $2;
1657	}	1662	}
1658	\| T_LPARN comp_stmnt_lbrace declaration_list expr_stmnt_list {	1663	\| T_LPARN comp_stmnt_lbrace declaration_list expr_stmnt_list {
1659	blklev--;	1664	blklev--;
1660	mblklev--;	1665	mblklev--;
1661	initsym = mktempsym(duptyp($4->tn_type));	1666	initsym = mktempsym(duptyp($4->tn_type));
1662	mblklev++;	1667	mblklev++;
1663	blklev++;	1668	blklev++;
1664	gnuism(320);	1669	gnuism(320);
1665	} comp_stmnt_rbrace T_RPARN {	1670	} comp_stmnt_rbrace T_RPARN {
1666	$$ = getnnode(initsym, 0);	1671	$$ = getnnode(initsym, 0);
1667	}	1672	}
1668	\| T_LPARN comp_stmnt_lbrace expr_stmnt_list {	1673	\| T_LPARN comp_stmnt_lbrace expr_stmnt_list {
1669	blklev--;	1674	blklev--;
1670	mblklev--;	1675	mblklev--;
1671	initsym = mktempsym($3->tn_type);	1676	initsym = mktempsym($3->tn_type);
1672	mblklev++;	1677	mblklev++;
1673	blklev++;	1678	blklev++;
1674	gnuism(320);	1679	gnuism(320);
1675	} comp_stmnt_rbrace T_RPARN {	1680	} comp_stmnt_rbrace T_RPARN {
1676	$$ = getnnode(initsym, 0);	1681	$$ = getnnode(initsym, 0);
1677	}	1682	}
1678	\| term T_INCDEC {	1683	\| term T_INCDEC {
1679	$$ = build($2 == INC ? INCAFT : DECAFT, $1, NULL);	1684	$$ = build($2 == INC ? INCAFT : DECAFT, $1, NULL);
1680	}	1685	}
1681	\| T_INCDEC term {	1686	\| T_INCDEC term {
1682	$$ = build($1 == INC ? INCBEF : DECBEF, $2, NULL);	1687	$$ = build($1 == INC ? INCBEF : DECBEF, $2, NULL);
1683	}	1688	}
1684	\| T_MULT term {	1689	\| T_MULT term {
1685	$$ = build(STAR, $2, NULL);	1690	$$ = build(STAR, $2, NULL);
1686	}	1691	}
1687	\| T_AND term {	1692	\| T_AND term {
1688	$$ = build(AMPER, $2, NULL);	1693	$$ = build(AMPER, $2, NULL);
1689	}	1694	}
1690	\| T_UNOP term {	1695	\| T_UNOP term {
1691	$$ = build($1, $2, NULL);	1696	$$ = build($1, $2, NULL);
1692	}	1697	}
1693	\| T_ADDOP term {	1698	\| T_ADDOP term {
1694	if (tflag && $1 == PLUS) {	1699	if (tflag && $1 == PLUS) {
1695	/* unary + is illegal in traditional C */	1700	/* unary + is illegal in traditional C */
1696	warning(100);	1701	warning(100);
1697	}	1702	}
1698	$$ = build($1 == PLUS ? UPLUS : UMINUS, $2, NULL);	1703	$$ = build($1 == PLUS ? UPLUS : UMINUS, $2, NULL);
1699	}	1704	}
1700	\| term T_LBRACK expr T_RBRACK {	1705	\| term T_LBRACK expr T_RBRACK {
1701	$$ = build(STAR, build(PLUS, $1, $3), NULL);	1706	$$ = build(STAR, build(PLUS, $1, $3), NULL);
1702	}	1707	}
1703	\| term T_LPARN T_RPARN {	1708	\| term T_LPARN T_RPARN {
1704	$$ = funccall($1, NULL);	1709	$$ = funccall($1, NULL);
1705	}	1710	}
1706	\| term T_LPARN func_arg_list T_RPARN {	1711	\| term T_LPARN func_arg_list T_RPARN {
1707	$$ = funccall($1, $3);	1712	$$ = funccall($1, $3);
1708	}	1713	}
1709	\| term point_or_arrow T_NAME {	1714	\| term point_or_arrow T_NAME {
1710	if ($1 != NULL) {	1715	if ($1 != NULL) {
1711	sym_t *msym;	1716	sym_t *msym;
1712	/* XXX strmemb should be integrated in build() */	1717	/* XXX strmemb should be integrated in build() */
1713	if ($2 == ARROW) {	1718	if ($2 == ARROW) {
1714	/* must to this before strmemb is called */	1719	/* must to this before strmemb is called */
1715	$1 = cconv($1);	1720	$1 = cconv($1);
1716	}	1721	}
1717	msym = strmemb($1, $2, getsym($3));	1722	msym = strmemb($1, $2, getsym($3));
1718	$$ = build($2, $1, getnnode(msym, 0));	1723	$$ = build($2, $1, getnnode(msym, 0));
1719	} else {	1724	} else {
1720	$$ = NULL;	1725	$$ = NULL;
1721	}	1726	}
1722	}	1727	}
1723	\| T_REAL term {	1728	\| T_REAL term {
1724	$$ = build(REAL, $2, NULL);	1729	$$ = build(REAL, $2, NULL);
1725	}	1730	}
1726	\| T_IMAG term {	1731	\| T_IMAG term {
1727	$$ = build(IMAG, $2, NULL);	1732	$$ = build(IMAG, $2, NULL);
1728	}	1733	}
1729	\| T_REAL T_LPARN term T_RPARN {	1734	\| T_REAL T_LPARN term T_RPARN {
1730	$$ = build(REAL, $3, NULL);	1735	$$ = build(REAL, $3, NULL);
1731	}	1736	}
1732	\| T_IMAG T_LPARN term T_RPARN {	1737	\| T_IMAG T_LPARN term T_RPARN {
1733	$$ = build(IMAG, $3, NULL);	1738	$$ = build(IMAG, $3, NULL);
1734	}	1739	}
		1740	\| T_EXTENSION T_LPARN term T_RPARN {
		1741	$$ = $3;
		1742	}
1735	\| T_SIZEOF term %prec T_SIZEOF {	1743	\| T_SIZEOF term %prec T_SIZEOF {
1736	if (($$ = $2 == NULL ? NULL : bldszof($2->tn_type)) != NULL)	1744	if (($$ = $2 == NULL ? NULL : bldszof($2->tn_type)) != NULL)
1737	chkmisc($2, 0, 0, 0, 0, 0, 1);	1745	chkmisc($2, 0, 0, 0, 0, 0, 1);
1738	}	1746	}
1739	\| T_SIZEOF T_LPARN type_name T_RPARN %prec T_SIZEOF {	1747	\| T_SIZEOF T_LPARN type_name T_RPARN %prec T_SIZEOF {
1740	$$ = bldszof($3);	1748	$$ = bldszof($3);
1741	}	1749	}
1742	\| T_ALIGNOF T_LPARN type_name T_RPARN %prec T_ALIGNOF {	1750	\| T_ALIGNOF T_LPARN type_name T_RPARN %prec T_ALIGNOF {
1743	$$ = bldalof($3);	1751	$$ = bldalof($3);
1744	}	1752	}
1745	\| T_LPARN type_name T_RPARN term %prec T_UNOP {	1753	\| T_LPARN type_name T_RPARN term %prec T_UNOP {
1746	$$ = cast($4, $2);	1754	$$ = cast($4, $2);
1747	}	1755	}
1748	\| T_LPARN type_name T_RPARN %prec T_UNOP {	1756	\| T_LPARN type_name T_RPARN %prec T_UNOP {
1749	sym_t *tmp = mktempsym($2);	1757	sym_t *tmp = mktempsym($2);
1750	idecl(tmp, 1, NULL);	1758	idecl(tmp, 1, NULL);
1751	} init_lbrace init_expr_list init_rbrace {	1759	} init_lbrace init_expr_list init_rbrace {
1752	if (!Sflag)	1760	if (!Sflag)
1753	gnuism(319);	1761	gnuism(319);
1754	$$ = getnnode(initsym, 0);	1762	$$ = getnnode(initsym, 0);
1755	}	1763	}
1756	;	1764	;
1757		1765
1758	string:	1766	string:
1759	T_STRING {	1767	T_STRING {
1760	$$ = $1;	1768	$$ = $1;
1761	}	1769	}
1762	\| T_STRING string2 {	1770	\| T_STRING string2 {
1763	$$ = catstrg($1, $2);	1771	$$ = catstrg($1, $2);
1764	}	1772	}
1765	;	1773	;
1766		1774
1767	string2:	1775	string2:
1768	T_STRING {	1776	T_STRING {
1769	if (tflag) {	1777	if (tflag) {
1770	/* concatenated strings are illegal in traditional C */	1778	/* concatenated strings are illegal in traditional C */
1771	warning(219);	1779	warning(219);
1772	}	1780	}
1773	$$ = $1;	1781	$$ = $1;
1774	}	1782	}
1775	\| string2 T_STRING {	1783	\| string2 T_STRING {
1776	$$ = catstrg($1, $2);	1784	$$ = catstrg($1, $2);
1777	}	1785	}
1778	;	1786	;
1779		1787
1780	func_arg_list:	1788	func_arg_list:
1781	expr %prec T_COMMA {	1789	expr %prec T_COMMA {
1782	$$ = funcarg(NULL, $1);	1790	$$ = funcarg(NULL, $1);
1783	}	1791	}
1784	\| func_arg_list T_COMMA expr {	1792	\| func_arg_list T_COMMA expr {
1785	$$ = funcarg($1, $3);	1793	$$ = funcarg($1, $3);
1786	}	1794	}
1787	;	1795	;
1788		1796
1789	point_or_arrow:	1797	point_or_arrow:
1790	T_STROP {	1798	T_STROP {
1791	symtyp = FMOS;	1799	symtyp = FMOS;
1792	$$ = $1;	1800	$$ = $1;
1793	}	1801	}
1794	;	1802	;
1795		1803
1796	point:	1804	point:
1797	T_STROP {	1805	T_STROP {
1798	if ($1 != POINT) {	1806	if ($1 != POINT) {
1799	error(249, yytext);	1807	error(249, yytext);
1800	}	1808	}
1801	}	1809	}
1802	;	1810	;
1803		1811
1804	identifier:	1812	identifier:
1805	T_NAME {	1813	T_NAME {
1806	$$ = $1;	1814	$$ = $1;
1807	}	1815	}
1808	\| T_TYPENAME {	1816	\| T_TYPENAME {
1809	$$ = $1;	1817	$$ = $1;
1810	}	1818	}
1811	;	1819	;
1812		1820
1813	%%	1821	%%
1814		1822
1815	/* ARGSUSED */	1823	/* ARGSUSED */
1816	int	1824	int
1817	yyerror(const char *msg)	1825	yyerror(const char *msg)
1818	{	1826	{
1819	error(249, yytext);	1827	error(249, yytext);
1820	if (++sytxerr >= 5)	1828	if (++sytxerr >= 5)
1821	norecover();	1829	norecover();
1822	return (0);	1830	return (0);
1823	}	1831	}
1824		1832
1825	static __inline int uq_gt(uint64_t, uint64_t);	1833	static __inline int uq_gt(uint64_t, uint64_t);
1826	static __inline int q_gt(int64_t, int64_t);	1834	static __inline int q_gt(int64_t, int64_t);
1827		1835
1828	static __inline int	1836	static __inline int
1829	uq_gt(uint64_t a, uint64_t b)	1837	uq_gt(uint64_t a, uint64_t b)
1830	{	1838	{
1831		1839
1832	return (a > b);	1840	return (a > b);
1833	}	1841	}
1834		1842
1835	static __inline int	1843	static __inline int
1836	q_gt(int64_t a, int64_t b)	1844	q_gt(int64_t a, int64_t b)
1837	{	1845	{
1838		1846
1839	return (a > b);	1847	return (a > b);
1840	}	1848	}
1841		1849
1842	#define q_lt(a, b) q_gt(b, a)	1850	#define q_lt(a, b) q_gt(b, a)
1843		1851
1844	/*	1852	/*
1845	* Gets a node for a constant and returns the value of this constant	1853	* Gets a node for a constant and returns the value of this constant
1846	* as integer.	1854	* as integer.
1847	* Is the node not constant or too large for int or of type float,	1855	* Is the node not constant or too large for int or of type float,
1848	* a warning will be printed.	1856	* a warning will be printed.
1849	*	1857	*
1850	* toicon() should be used only inside declarations. If it is used in	1858	* toicon() should be used only inside declarations. If it is used in
1851	* expressions, it frees the memory used for the expression.	1859	* expressions, it frees the memory used for the expression.
1852	*/	1860	*/
1853	static int	1861	static int
1854	toicon(tnode_t *tn, int required)	1862	toicon(tnode_t *tn, int required)
1855	{	1863	{
1856	int i;	1864	int i;
1857	tspec_t t;	1865	tspec_t t;
1858	val_t *v;	1866	val_t *v;
1859		1867
1860	v = constant(tn, required);	1868	v = constant(tn, required);
1861		1869
1862	/*	1870	/*
1863	* Abstract declarations are used inside expression. To free	1871	* Abstract declarations are used inside expression. To free
1864	* the memory would be a fatal error.	1872	* the memory would be a fatal error.
1865	*/	1873	*/
1866	if (dcs->d_ctx != ABSTRACT)	1874	if (dcs->d_ctx != ABSTRACT)
1867	tfreeblk();	1875	tfreeblk();
1868		1876
1869	if ((t = v->v_tspec) == FLOAT \|\| t == DOUBLE \|\| t == LDOUBLE) {	1877	if ((t = v->v_tspec) == FLOAT \|\| t == DOUBLE \|\| t == LDOUBLE) {
1870	i = (int)v->v_ldbl;	1878	i = (int)v->v_ldbl;
1871	/* integral constant expression expected */	1879	/* integral constant expression expected */
1872	error(55);	1880	error(55);
1873	} else {	1881	} else {
1874	i = (int)v->v_quad;	1882	i = (int)v->v_quad;
1875	if (isutyp(t)) {	1883	if (isutyp(t)) {
1876	if (uq_gt((uint64_t)v->v_quad,	1884	if (uq_gt((uint64_t)v->v_quad,
1877	(uint64_t)TARG_INT_MAX)) {	1885	(uint64_t)TARG_INT_MAX)) {
1878	/* integral constant too large */	1886	/* integral constant too large */
1879	warning(56);	1887	warning(56);
1880	}	1888	}
1881	} else {	1889	} else {
1882	if (q_gt(v->v_quad, (int64_t)TARG_INT_MAX) \|\|	1890	if (q_gt(v->v_quad, (int64_t)TARG_INT_MAX) \|\|
1883	q_lt(v->v_quad, (int64_t)TARG_INT_MIN)) {	1891	q_lt(v->v_quad, (int64_t)TARG_INT_MIN)) {
1884	/* integral constant too large */	1892	/* integral constant too large */
1885	warning(56);	1893	warning(56);
1886	}	1894	}
1887	}	1895	}
1888	}	1896	}
1889	free(v);	1897	free(v);
1890	return (i);	1898	return (i);
1891	}	1899	}
1892		1900
1893	static void	1901	static void
1894	idecl(sym_t decl, int initflg, sbuf_t renaming)	1902	idecl(sym_t decl, int initflg, sbuf_t renaming)
1895	{	1903	{
1896	char *s;	1904	char *s;
1897		1905
1898	initerr = 0;	1906	initerr = 0;
1899	initsym = decl;	1907	initsym = decl;
1900		1908
1901	switch (dcs->d_ctx) {	1909	switch (dcs->d_ctx) {
1902	case EXTERN:	1910	case EXTERN:
1903	if (renaming != NULL) {	1911	if (renaming != NULL) {
1904	if (decl->s_rename != NULL)	1912	if (decl->s_rename != NULL)
1905	LERROR("idecl()");	1913	LERROR("idecl()");
1906		1914
1907	s = getlblk(1, renaming->sb_len + 1);	1915	s = getlblk(1, renaming->sb_len + 1);
1908	(void)memcpy(s, renaming->sb_name, renaming->sb_len + 1);	1916	(void)memcpy(s, renaming->sb_name, renaming->sb_len + 1);
1909	decl->s_rename = s;	1917	decl->s_rename = s;
1910	freeyyv(&renaming, T_NAME);	1918	freeyyv(&renaming, T_NAME);
1911	}	1919	}
1912	decl1ext(decl, initflg);	1920	decl1ext(decl, initflg);
1913	break;	1921	break;
1914	case ARG:	1922	case ARG:
1915	if (renaming != NULL) {	1923	if (renaming != NULL) {
1916	/* symbol renaming can't be used on function arguments */	1924	/* symbol renaming can't be used on function arguments */
1917	error(310);	1925	error(310);
1918	freeyyv(&renaming, T_NAME);	1926	freeyyv(&renaming, T_NAME);
1919	break;	1927	break;
1920	}	1928	}
1921	(void)decl1arg(decl, initflg);	1929	(void)decl1arg(decl, initflg);
1922	break;	1930	break;
1923	case AUTO:	1931	case AUTO:
1924	if (renaming != NULL) {	1932	if (renaming != NULL) {
1925	/* symbol renaming can't be used on automatic variables */	1933	/* symbol renaming can't be used on automatic variables */
1926	error(311);	1934	error(311);
1927	freeyyv(&renaming, T_NAME);	1935	freeyyv(&renaming, T_NAME);
1928	break;	1936	break;
1929	}	1937	}
1930	decl1loc(decl, initflg);	1938	decl1loc(decl, initflg);
1931	break;	1939	break;
1932	default:	1940	default:
1933	LERROR("idecl()");	1941	LERROR("idecl()");
1934	}	1942	}
1935		1943
1936	if (initflg && !initerr)	1944	if (initflg && !initerr)
1937	prepinit();	1945	prepinit();
1938	}	1946	}
1939		1947
1940	/*	1948	/*
1941	* Discard all input tokens up to and including the next	1949	* Discard all input tokens up to and including the next
1942	* unmatched right paren	1950	* unmatched right paren
1943	*/	1951	*/
1944	static void	1952	static void
1945	ignuptorp(void)	1953	ignuptorp(void)
1946	{	1954	{
1947	int level;	1955	int level;
1948		1956
1949	if (yychar < 0)	1957	if (yychar < 0)
1950	yychar = yylex();	1958	yychar = yylex();
1951	freeyyv(&yylval, yychar);	1959	freeyyv(&yylval, yychar);
1952		1960
1953	level = 1;	1961	level = 1;
1954	while (yychar != T_RPARN \|\| --level > 0) {	1962	while (yychar != T_RPARN \|\| --level > 0) {
1955	if (yychar == T_LPARN) {	1963	if (yychar == T_LPARN) {
1956	level++;	1964	level++;
1957	} else if (yychar <= 0) {	1965	} else if (yychar <= 0) {
1958	break;	1966	break;
1959	}	1967	}
1960	freeyyv(&yylval, yychar = yylex());	1968	freeyyv(&yylval, yychar = yylex());
1961	}	1969	}
1962		1970
1963	yyclearin;	1971	yyclearin;
1964	}	1972	}

 @@ -1,563 +1,563 @@
-/*	$NetBSD: err.c,v 1.46 2013/04/19 17:43:05 christos Exp $	*/
+/*	$NetBSD: err.c,v 1.47 2014/02/18 22:01:36 christos 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: err.c,v 1.46 2013/04/19 17:43:05 christos Exp $");
+__RCSID("$NetBSD: err.c,v 1.47 2014/02/18 22:01:36 christos Exp $");
 #endif
 #include <sys/types.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include "lint1.h"
 /* number of errors found */
 int	nerr;
 /* number of syntax errors */
 int	sytxerr;
 static	const	char *lbasename(const char *);
 static	void	verror(int, va_list);
 static	void	vwarning(int, va_list);
 const	char *msgs[] = {
 	"empty declaration",					      /* 0 */
 	"old style declaration; add int",			      /* 1 */
 	"empty declaration",					      /* 2 */
 	"%s declared in argument declaration list",		      /* 3 */
 	"illegal type combination",				      /* 4 */
 	"modifying typedef with '%s'; only qualifiers allowed",	      /* 5 */
 	"use 'double' instead of 'long float'",			      /* 6 */
 	"only one storage class allowed",			      /* 7 */
 	"illegal storage class",				      /* 8 */
 	"only register valid as formal parameter storage class",      /* 9 */
 	"duplicate '%s'",					      /* 10 */
 	"bit-field initializer out of range",			      /* 11 */
 	"compiler takes size of function",			      /* 12 */
 	"incomplete enum type: %s",				      /* 13 */
 	"compiler takes alignment of function",			      /* 14 */
 	"function returns illegal type",			      /* 15 */
 	"array of function is illegal",				      /* 16 */
 	"null dimension",					      /* 17 */
 	"illegal use of 'void'",				      /* 18 */
 	"void type for %s",					      /* 19 */
 	"negative array dimension (%d)",			      /* 20 */
 	"redeclaration of formal parameter %s",			      /* 21 */
 	"incomplete or misplaced function definition",		      /* 22 */
 	"undefined label %s",					      /* 23 */
 	"cannot initialize function: %s",			      /* 24 */
 	"cannot initialize typedef: %s",			      /* 25 */
 	"cannot initialize extern declaration: %s",		      /* 26 */
 	"redeclaration of %s",					      /* 27 */
 	"redefinition of %s",					      /* 28 */
 	"previously declared extern, becomes static: %s",	      /* 29 */
 	"redeclaration of %s; ANSI C requires static",		      /* 30 */
 	"incomplete structure or union %s: %s",			      /* 31 */
 	"argument type defaults to 'int': %s",			      /* 32 */
 	"duplicate member name: %s",				      /* 33 */
 	"nonportable bit-field type",				      /* 34 */
 	"illegal bit-field type",				      /* 35 */
 	"illegal bit-field size",				      /* 36 */
 	"zero size bit-field",					      /* 37 */
 	"function illegal in structure or union",		      /* 38 */
 	"zero sized array in struct is a C99 extension: %s",	      /* 39 */
 	"unknown size: %s",					      /* 40 */
 	"illegal use of bit-field",				      /* 41 */
 	"forward reference to enum type",			      /* 42 */
 	"redefinition hides earlier one: %s",			      /* 43 */
 	"declaration introduces new type in ANSI C: %s %s",	      /* 44 */
 	"base type is really '%s %s'",				      /* 45 */
 	"(%s) tag redeclared",					      /* 46 */
 	"zero sized %s is a C9X feature",			      /* 47 */
 	"overflow in enumeration values: %s",			      /* 48 */
 	"struct or union member must be named",			      /* 49 */
 	"a function is declared as an argument: %s",		      /* 50 */
 	"parameter mismatch: %d declared, %d defined",		      /* 51 */
 	"cannot initialize parameter: %s",			      /* 52 */
 	"declared argument %s is missing",			      /* 53 */
 	"trailing ',' prohibited in enum declaration",		      /* 54 */
 	"integral constant expression expected",		      /* 55 */
 	"integral constant too large",				      /* 56 */
 	"enumeration constant hides parameter: %s",		      /* 57 */
 	"type does not match prototype: %s",			      /* 58 */
 	"formal parameter lacks name: param #%d",		      /* 59 */
 	"void must be sole parameter",				      /* 60 */
 	"void parameter cannot have name: %s",			      /* 61 */
 	"function prototype parameters must have types",	      /* 62 */
 	"prototype does not match old-style definition",	      /* 63 */
 	"()-less function definition",				      /* 64 */
 	"%s has no named members",				      /* 65 */
 	"syntax requires ';' after last struct/union member",	      /* 66 */
 	"cannot return incomplete type",			      /* 67 */
 	"typedef already qualified with '%s'",			      /* 68 */
 	"inappropriate qualifiers with 'void'",			      /* 69 */
 	"%soperand of '%s' is unsigned in ANSI C",		      /* 70 */
 	"too many characters in character constant",		      /* 71 */
 	"typedef declares no type name",			      /* 72 */
 	"empty character constant",				      /* 73 */
 	"no hex digits follow \\x",				      /* 74 */
 	"overflow in hex escape",				      /* 75 */
 	"character escape does not fit in character",		      /* 76 */
 	"bad octal digit %c",					      /* 77 */
 	"nonportable character escape",				      /* 78 */
 	"dubious escape \\%c",					      /* 79 */
 	"dubious escape \\%o",					      /* 80 */
 	"\\a undefined in traditional C",			      /* 81 */
 	"\\x undefined in traditional C",			      /* 82 */
 	"storage class after type is obsolescent",		      /* 83 */
 	"ANSI C requires formal parameter before '...'",	      /* 84 */
 	"dubious tag declaration: %s %s",			      /* 85 */
 	"automatic hides external declaration: %s",		      /* 86 */
 	"static hides external declaration: %s",		      /* 87 */
 	"typedef hides external declaration: %s",		      /* 88 */
 	"typedef redeclared: %s",				      /* 89 */
 	"inconsistent redeclaration of extern: %s",		      /* 90 */
 	"declaration hides parameter: %s",			      /* 91 */
 	"inconsistent redeclaration of static: %s",		      /* 92 */
 	"dubious static function at block level: %s",		      /* 93 */
 	"function has illegal storage class: %s",		      /* 94 */
 	"declaration hides earlier one: %s",			      /* 95 */
 	"cannot dereference non-pointer type",			      /* 96 */
 	"suffix U is illegal in traditional C",			      /* 97 */
 	"suffixes F and L are illegal in traditional C",	      /* 98 */
 	"%s undefined",						      /* 99 */
 	"unary + is illegal in traditional C",			      /* 100 */
 	"undefined struct/union member: %s",			      /* 101 */
 	"illegal member use: %s",				      /* 102 */
 	"left operand of '.' must be struct/union object",	      /* 103 */
 	"left operand of '->' must be pointer to struct/union",	      /* 104 */
 	"non-unique member requires struct/union %s",		      /* 105 */
 	"left operand of '->' must be pointer",			      /* 106 */
 	"operands of '%s' have incompatible types (%s != %s)",		      /* 107 */
 	"operand of '%s' has incompatible type (%s != %s)",		      /* 108 */
 	"void type illegal in expression",			      /* 109 */
 	"pointer to function is not allowed here",		      /* 110 */
 	"unacceptable operand of '%s'",				      /* 111 */
 	"cannot take address of bit-field",			      /* 112 */
 	"cannot take address of register %s",			      /* 113 */
 	"%soperand of '%s' must be lvalue",			      /* 114 */
 	"%soperand of '%s' must be modifiable lvalue",		      /* 115 */
 	"illegal pointer subtraction",				      /* 116 */
 	"bitwise operation on signed value possibly nonportable",     /* 117 */
 	"semantics of '%s' change in ANSI C; use explicit cast",      /* 118 */
 	"conversion of '%s' to '%s' is out of range",		      /* 119 */
 	"bitwise operation on signed value nonportable",	      /* 120 */
 	"negative shift",					      /* 121 */
 	"shift greater than size of object",			      /* 122 */
 	"illegal combination of pointer and integer, op %s",	      /* 123 */
 	"illegal pointer combination, op %s",			      /* 124 */
 	"ANSI C forbids ordered comparisons of pointers to functions",/* 125 */
 	"incompatible types in conditional",			      /* 126 */
 	"'&' before array or function: ignored",		      /* 127 */
 	"operands have incompatible pointer types, op %s (%s != %s)", /* 128 */
 	"expression has null effect",				      /* 129 */
 	"enum type mismatch, op %s",				      /* 130 */
 	"conversion to '%s' may sign-extend incorrectly",	      /* 131 */
 	"conversion from '%s' to '%s' may lose accuracy",	      /* 132 */
 	"conversion of pointer to '%s' loses bits",		      /* 133 */
 	"conversion of pointer to '%s' may lose bits",		      /* 134 */
 	"possible pointer alignment problem",			      /* 135 */
 	"cannot do pointer arithmetic on operand of unknown size",    /* 136 */
 	"use of incomplete enum type, op %s",			      /* 137 */
 	"unknown operand size, op %s",				      /* 138 */
 	"division by 0",					      /* 139 */
 	"modulus by 0",						      /* 140 */
 	"integer overflow detected, op %s",			      /* 141 */
 	"floating point overflow detected, op %s",		      /* 142 */
 	"cannot take size/alignment of incomplete type",	      /* 143 */
 	"cannot take size/alignment of function",		      /* 144 */
 	"cannot take size/alignment of bit-field",		      /* 145 */
 	"cannot take size/alignment of void",			      /* 146 */
 	"invalid cast expression",				      /* 147 */
 	"improper cast of void expression",			      /* 148 */
-	"illegal function",					      /* 149 */
+	"illegal function (type %s)",				      /* 149 */
 	"argument mismatch: %d arg%s passed, %d expected",	      /* 150 */
 	"void expressions may not be arguments, arg #%d",	      /* 151 */
 	"argument cannot have unknown size, arg #%d",		      /* 152 */
 	"argument has incompatible pointer type, arg #%d (%s != %s)", /* 153 */
 	"illegal combination of pointer and integer, arg #%d",	      /* 154 */
 	"argument is incompatible with prototype, arg #%d",	      /* 155 */
 	"enum type mismatch, arg #%d",			       	      /* 156 */
 	"ANSI C treats constant as unsigned",			      /* 157 */
 	"%s may be used before set",			      	      /* 158 */
 	"assignment in conditional context",			      /* 159 */
 	"operator '==' found where '=' was expected",		      /* 160 */
 	"constant in conditional context",			      /* 161 */
 	"comparison of %s with %s, op %s",			      /* 162 */
 	"a cast does not yield an lvalue",			      /* 163 */
 	"assignment of negative constant to unsigned type",	      /* 164 */
 	"constant truncated by assignment",			      /* 165 */
 	"precision lost in bit-field assignment",		      /* 166 */
 	"array subscript cannot be negative: %ld",		      /* 167 */
 	"array subscript cannot be > %d: %ld",			      /* 168 */
 	"precedence confusion possible: parenthesize!",		      /* 169 */
 	"first operand must have scalar type, op ? :",		      /* 170 */
 	"assignment type mismatch (%s != %s)",			      /* 171 */
 	"too many struct/union initializers",			      /* 172 */
 	"too many array initializers, expected %d",		      /* 173 */
 	"too many initializers",				      /* 174 */
 	"initialisation of an incomplete type",			      /* 175 */
 	"invalid initializer type %s",				      /* 176 */
 	"non-constant initializer",				      /* 177 */
 	"initializer does not fit",				      /* 178 */
 	"cannot initialize struct/union with no named member",	      /* 179 */
 	"bit-field initializer does not fit",			      /* 180 */
 	"{}-enclosed initializer required",			      /* 181 */
 	"incompatible pointer types (%s != %s)",		      /* 182 */
 	"illegal combination of pointer and integer",		      /* 183 */
 	"illegal pointer combination",				      /* 184 */
 	"initialisation type mismatch",				      /* 185 */
 	"bit-field initialisation is illegal in traditional C",	      /* 186 */
 	"non-null byte ignored in string initializer",		      /* 187 */
 	"no automatic aggregate initialization in traditional C",     /* 188 */
 	"assignment of struct/union illegal in traditional C",	      /* 189 */
 	"empty array declaration: %s",				      /* 190 */
 	"%s set but not used in function %s",		      	      /* 191 */
 	"%s unused in function %s",				      /* 192 */
 	"statement not reached",				      /* 193 */
 	"label %s redefined",					      /* 194 */
 	"case not in switch",					      /* 195 */
 	"case label affected by conversion",			      /* 196 */
 	"non-constant case expression",				      /* 197 */
 	"non-integral case expression",				      /* 198 */
 	"duplicate case in switch: %ld",			      /* 199 */
 	"duplicate case in switch: %lu",			      /* 200 */
 	"default outside switch",				      /* 201 */
 	"duplicate default in switch",				      /* 202 */
 	"case label must be of type `int' in traditional C",	      /* 203 */
 	"controlling expressions must have scalar type",	      /* 204 */
 	"switch expression must have integral type",		      /* 205 */
 	"enumeration value(s) not handled in switch",		      /* 206 */
 	"loop not entered at top",				      /* 207 */
 	"break outside loop or switch",				      /* 208 */
 	"continue outside loop",				      /* 209 */
 	"enum type mismatch in initialisation",			      /* 210 */
 	"return value type mismatch",				      /* 211 */
 	"cannot return incomplete type",			      /* 212 */
 	"void function %s cannot return value",			      /* 213 */
 	"function %s expects to return value",			      /* 214 */
 	"function implicitly declared to return int",		      /* 215 */
 	"function %s has return (e); and return;",		      /* 216 */
 	"function %s falls off bottom without returning value",	      /* 217 */
 	"ANSI C treats constant as unsigned, op %s",		      /* 218 */
 	"concatenated strings are illegal in traditional C",	      /* 219 */
 	"fallthrough on case statement",			      /* 220 */
 	"initialisation of unsigned with negative constant",	      /* 221 */
 	"conversion of negative constant to unsigned type",	      /* 222 */
 	"end-of-loop code not reached",				      /* 223 */
 	"cannot recover from previous errors",			      /* 224 */
 	"static function called but not defined: %s()",		      /* 225 */
 	"static variable %s unused",				      /* 226 */
 	"const object %s should have initializer",		      /* 227 */
 	"function cannot return const or volatile object",	      /* 228 */
 	"questionable conversion of function pointer",		      /* 229 */
 	"nonportable character comparison, op %s",		      /* 230 */
 	"argument %s unused in function %s",			      /* 231 */
 	"label %s unused in function %s",			      /* 232 */
 	"struct %s never defined",				      /* 233 */
 	"union %s never defined",				      /* 234 */
 	"enum %s never defined",				      /* 235 */
 	"static function %s unused",				      /* 236 */
 	"redeclaration of formal parameter %s",			      /* 237 */
 	"initialisation of union is illegal in traditional C",	      /* 238 */
 	"constant argument to NOT",				      /* 239 */
 	"assignment of different structures (%s != %s)",	      /* 240 */
 	"dubious operation on enum, op %s",			      /* 241 */
 	"combination of '%s' and '%s', op %s",			      /* 242 */
 	"dubious comparison of enums, op %s",			      /* 243 */
 	"illegal structure pointer combination",		      /* 244 */
 	"illegal structure pointer combination, op %s",		      /* 245 */
 	"dubious conversion of enum to '%s'",			      /* 246 */
 	"pointer casts may be troublesome",			      /* 247 */
 	"floating-point constant out of range",			      /* 248 */
 	"syntax error '%s'",					      /* 249 */
 	"unknown character \\%o",				      /* 250 */
 	"malformed integer constant",				      /* 251 */
 	"integer constant out of range",			      /* 252 */
 	"unterminated character constant",			      /* 253 */
 	"newline in string or char constant",			      /* 254 */
 	"undefined or invalid # directive",			      /* 255 */
 	"unterminated comment",					      /* 256 */
 	"extra characters in lint comment",			      /* 257 */
 	"unterminated string constant",				      /* 258 */
 	"conversion to '%s' due to prototype, arg #%d",		      /* 259 */
 	"previous declaration of %s",				      /* 260 */
 	"previous definition of %s",				      /* 261 */
 	"\\\" inside character constants undefined in traditional C", /* 262 */
 	"\\? undefined in traditional C",			      /* 263 */
 	"\\v undefined in traditional C",			      /* 264 */
 	"%s C does not support 'long long'",			      /* 265 */
 	"'long double' is illegal in traditional C",		      /* 266 */
 	"shift equal to size of object",			      /* 267 */
 	"variable declared inline: %s",				      /* 268 */
 	"argument declared inline: %s",				      /* 269 */
 	"function prototypes are illegal in traditional C",	      /* 270 */
 	"switch expression must be of type `int' in traditional C",   /* 271 */
 	"empty translation unit",				      /* 272 */
 	"bit-field type '%s' invalid in ANSI C",		      /* 273 */
 	"ANSI C forbids comparison of %s with %s",		      /* 274 */
 	"cast discards 'const' from pointer target type",	      /* 275 */
 	"__%s__ is illegal for type %s",			      /* 276 */
 	"initialisation of '%s' with '%s'",			      /* 277 */
 	"combination of '%s' and '%s', arg #%d",		      /* 278 */
 	"combination of '%s' and '%s' in return",		      /* 279 */
 	"must be outside function: /* %s */",			      /* 280 */
 	"duplicate use of /* %s */",				      /* 281 */
 	"must precede function definition: /* %s */",		      /* 282 */
 	"argument number mismatch with directive: /* %s */",	      /* 283 */
 	"fallthrough on default statement",			      /* 284 */
 	"prototype declaration",				      /* 285 */
 	"function definition is not a prototype",		      /* 286 */
 	"function declaration is not a prototype",		      /* 287 */
 	"dubious use of /* VARARGS */ with /* %s */",		      /* 288 */
 	"can't be used together: /* PRINTFLIKE */ /* SCANFLIKE */",   /* 289 */
 	"static function %s declared but not defined",		      /* 290 */
 	"invalid multibyte character",				      /* 291 */
 	"cannot concatenate wide and regular string literals",	      /* 292 */
 	"argument %d must be 'char *' for PRINTFLIKE/SCANFLIKE",      /* 293 */
 	"multi-character character constant",			      /* 294 */
 	"conversion of '%s' to '%s' is out of range, arg #%d",	      /* 295 */
 	"conversion of negative constant to unsigned type, arg #%d",  /* 296 */
 	"conversion to '%s' may sign-extend incorrectly, arg #%d",    /* 297 */
 	"conversion from '%s' to '%s' may lose accuracy, arg #%d",    /* 298 */
 	"prototype does not match old style definition, arg #%d",     /* 299 */
 	"old style definition",					      /* 300 */
 	"array of incomplete type",				      /* 301 */
 	"%s returns pointer to automatic object",		      /* 302 */
 	"ANSI C forbids conversion of %s to %s",		      /* 303 */
 	"ANSI C forbids conversion of %s to %s, arg #%d",	      /* 304 */
 	"ANSI C forbids conversion of %s to %s, op %s",		      /* 305 */
 	"constant truncated by conversion, op %s",		      /* 306 */
 	"static variable %s set but not used",			      /* 307 */
 	"Invalid type %s for _Complex",				      /* 308 */
 	"extra bits set to 0 in conversion of '%s' to '%s', op %s",   /* 309 */
 	"symbol renaming can't be used on function arguments",	      /* 310 */
 	"symbol renaming can't be used on automatic variables",	      /* 311 */
 	"%s C does not support // comments",			      /* 312 */
 	"struct or union member name in initializer is a C9X feature",/* 313 */
 	"%s is not a structure or a union",			      /* 314 */
 	"GCC style struct or union member name in initializer",	      /* 315 */
 	"__FUNCTION__/__PRETTY_FUNCTION__ is a GCC extension",	      /* 316 */
 	"__func__ is a C9X feature",				      /* 317 */
 	"variable array dimension is a C99/GCC extension",	      /* 318 */
 	"compound literals are a C9X/GCC extension",		      /* 319 */
 	"({ }) is a GCC extension",				      /* 320 */
 	"array initializer with designators is a C9X feature",	      /* 321 */
 	"zero sized array is a C99 extension",			      /* 322 */
 	"continue in 'do ... while (0)' loop",			      /* 323 */
 	"suggest cast from '%s' to '%s' on op %s to avoid overflow",  /* 324 */
 	"variable declaration in for loop", 			      /* 325 */
 	"%s attribute ignored for %s",				      /* 326 */
 	"declarations after statements is a C9X feature",	      /* 327 */
 };
 /*
  * print a list of the messages with their ids
  */
 void
 msglist(void)
+{
 	size_t i;
 	for (i = 0; i < sizeof(msgs) / sizeof(msgs[0]); i++)
 		printf("%zu\t%s\n", i, msgs[i]);
+}
 /*
  * If Fflag is not set lbasename() returns a pointer to the last
  * component of the path, otherwise it returns the argument.
  */
 static const char *
 lbasename(const char *path)
+{
 	const	char *cp, *cp1, *cp2;
 	if (Fflag)
 		return (path);
 	cp = cp1 = cp2 = path;
 	while (*cp != '\0') {
 		if (*cp++ == '/') {
 			cp2 = cp1;
 			cp1 = cp;
+		}
+	}
 	return (*cp1 == '\0' ? cp2 : cp1);
+}
 static void
 verror( int n, va_list ap)
+{
 	const	char *fn;
 	if (ERR_ISSET(n, &msgset))
 		return;
 	fn = lbasename(curr_pos.p_file);
 	(void)printf("%s(%d): ", fn, curr_pos.p_line);
 	(void)vprintf(msgs[n], ap);
 	(void)printf(" [%d]\n", n);
 	nerr++;
+}
 static void
 vwarning(int n, va_list ap)
+{
 	const	char *fn;
 	if (ERR_ISSET(n, &msgset))
 		return;
 #ifdef DEBUG
 	printf("%s: lwarn=%d n=%d\n", __func__, lwarn, n);
 #endif
 	if (lwarn == LWARN_NONE || lwarn == n)
 		/* this warning is suppressed by a LINTED comment */
 		return;
 	fn = lbasename(curr_pos.p_file);
 	(void)printf("%s(%d): warning: ", fn, curr_pos.p_line);
 	(void)vprintf(msgs[n], ap);
 	(void)printf(" [%d]\n", n);
 	if (wflag)
 		nerr++;
+}
 void
 error(int n, ...)
+{
 	va_list	ap;
 	va_start(ap, n);
 	verror(n, ap);
 	va_end(ap);
+}
 void
 lerror(const char *file, int line, const char *msg, ...)
+{
 	va_list	ap;
 	const	char *fn;
 	va_start(ap, msg);
 	fn = lbasename(curr_pos.p_file);
 	(void)fprintf(stderr, "%s(%d): lint error: %s, %d: ",
 	    fn, curr_pos.p_line, file, line);
 	(void)vfprintf(stderr, msg, ap);
 	(void)fprintf(stderr, "\n");
 	va_end(ap);
 	abort();
+}
 void
 warning(int n, ...)
+{
 	va_list	ap;
 	va_start(ap, n);
 	vwarning(n, ap);
 	va_end(ap);
+}
 void
 message(int n, ...)
+{
 	va_list	ap;
 	const	char *fn;
 	if (ERR_ISSET(n, &msgset))
 		return;
 	va_start(ap, n);
 	fn = lbasename(curr_pos.p_file);
 	(void)printf("%s(%d): ", fn, curr_pos.p_line);
 	(void)vprintf(msgs[n], ap);
 	(void)printf(" [%d]\n", n);
 	va_end(ap);
+}
 /*
  * XXX I think the logic is possibly somewhat screwed up here. The
  * question is, how do we want to interpret the -s and -S flags going
  * forward? We need to answer that and then we can fix this to be
  * "right"... [perry, 2 Nov 2002]
 */
 int
 c99ism(int n, ...)
+{
 	va_list	ap;
 	int	msg;
 	va_start(ap, n);
 	if (sflag && !(Sflag || gflag)) {
 		verror(n, ap);
 		msg = 1;
 	} else if (!sflag && (Sflag || gflag)) {
 		msg = 0;
 	} else {
 		vwarning(n, ap);
 		msg = 1;
+	}
 	va_end(ap);
 	return (msg);
+}
 int
 gnuism(int n, ...)
+{
 	va_list	ap;
 	int	msg;
 	va_start(ap, n);
 	if (sflag && !gflag) {
 		verror(n, ap);
 		msg = 1;
 	} else if (!sflag && gflag) {
 		msg = 0;
 	} else {
 		vwarning(n, ap);
 		msg = 1;
+	}
 	va_end(ap);
 	return (msg);
+}

 @@ -1,1257 +1,1261 @@
 %{
-/* $NetBSD: scan.l,v 1.53 2013/10/18 20:46:09 christos Exp $ */
+/* $NetBSD: scan.l,v 1.54 2014/02/18 22:01:36 christos 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.
  */
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: scan.l,v 1.53 2013/10/18 20:46:09 christos Exp $");
+__RCSID("$NetBSD: scan.l,v 1.54 2014/02/18 22:01:36 christos Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
 #include <float.h>
 #include <ctype.h>
 #include <errno.h>
 #include <math.h>
 #include "lint1.h"
 #include "cgram.h"
 #define CHAR_MASK	(~(~0 << CHAR_BIT))
 /* Current position (its also updated when an included file is parsed) */
 pos_t	curr_pos = { 1, "", 0 };
 /*
  * Current position in C source (not updated when an included file is
  * parsed).
  */
 pos_t	csrc_pos = { 1, "", 0 };
 static	void	incline(void);
 static	void	badchar(int);
 static	sbuf_t	*allocsb(void);
 static	void	freesb(sbuf_t *);
 static	int	inpc(void);
 static	int	hash(const char *);
 static	sym_t	*search(sbuf_t *);
 static	int	name(void);
 static	int	keyw(sym_t *);
 static	int	icon(int);
 static	int	fcon(void);
 static	int	operator(int, op_t);
 static	int	ccon(void);
 static	int	wccon(void);
 static	int	getescc(int);
 static	void	directive(void);
 static	void	comment(void);
 static	void	slashslashcomment(void);
 static	int	string(void);
 static	int	wcstrg(void);
 %}
 L	[_A-Za-z]
 D	[0-9]
 NZD	[1-9]
 OD	[0-7]
 HD	[0-9A-Fa-f]
 EX	([eE][+-]?[0-9]+)
 HX	(p[+-]?[0-9A-Fa-f]+)
 TL	([fFlL]?[i]?)
 %option nounput
 %%
 {L}({L}|{D})*		 	return (name());
 {OD}*[lLuU]*			return (icon(8));
 {NZD}{D}*[lLuU]*		return (icon(10));
 [xX]{HD}+[lLuU]*		return (icon(16));
 {D}+\.{D}*{EX}?{TL}	|
 {D}+{EX}{TL}		|
 [xX]{HD}+\.{HD}*{HX}{TL} |
 [xX]{HD}+{HX}{TL} 	|
 \.{D}+{EX}?{TL}		return (fcon());
 "="				return (operator(T_ASSIGN, ASSIGN));
 "*="				return (operator(T_OPASS, MULASS));
 "/="				return (operator(T_OPASS, DIVASS));
 "%="				return (operator(T_OPASS, MODASS));
 "+="				return (operator(T_OPASS, ADDASS));
 "-="				return (operator(T_OPASS, SUBASS));
 "<<="				return (operator(T_OPASS, SHLASS));
 ">>="				return (operator(T_OPASS, SHRASS));
 "&="				return (operator(T_OPASS, ANDASS));
 "^="				return (operator(T_OPASS, XORASS));
 "|="				return (operator(T_OPASS, ORASS));
 "||"				return (operator(T_LOGOR, LOGOR));
 "&&"				return (operator(T_LOGAND, LOGAND));
 "|"				return (operator(T_OR, OR));
 "&"				return (operator(T_AND, AND));
 "^"				return (operator(T_XOR, XOR));
 "=="				return (operator(T_EQOP, EQ));
 "!="				return (operator(T_EQOP, NE));
 "<"				return (operator(T_RELOP, LT));
 ">"				return (operator(T_RELOP, GT));
 "<="				return (operator(T_RELOP, LE));
 ">="				return (operator(T_RELOP, GE));
 "<<"				return (operator(T_SHFTOP, SHL));
 ">>"				return (operator(T_SHFTOP, SHR));
 "++"				return (operator(T_INCDEC, INC));
 "--"				return (operator(T_INCDEC, DEC));
 "->"				return (operator(T_STROP, ARROW));
 "."				return (operator(T_STROP, POINT));
 "+"				return (operator(T_ADDOP, PLUS));
 "-"				return (operator(T_ADDOP, MINUS));
 "*"				return (operator(T_MULT, MULT));
 "/"				return (operator(T_DIVOP, DIV));
 "%"				return (operator(T_DIVOP, MOD));
 "!"				return (operator(T_UNOP, NOT));
 "~"				return (operator(T_UNOP, COMPL));
 "\""				return (string());
 "L\""				return (wcstrg());
 ";"				return (T_SEMI);
 "{"				return (T_LBRACE);
 "}"				return (T_RBRACE);
 ","				return (T_COMMA);
 ":"				return (T_COLON);
 "?"				return (T_QUEST);
 "["				return (T_LBRACK);
 "]"				return (T_RBRACK);
 "("				return (T_LPARN);
 ")"				return (T_RPARN);
 "..."				return (T_ELLIPSE);
 "'"				return (ccon());
 "L'"				return (wccon());
 ^#.*$				directive();
 \n				incline();
 \t|" "|\f|\v			;
 "/*"				comment();
 "//"				slashslashcomment();
 .				badchar(yytext[0]);
 %%
 static void
 incline(void)
+{
 	curr_pos.p_line++;
 	curr_pos.p_uniq = 0;
 	if (curr_pos.p_file == csrc_pos.p_file) {
 		csrc_pos.p_line++;
 		csrc_pos.p_uniq = 0;
+	}
+}
 static void
 badchar(int c)
+{
 	/* unknown character \%o */
 	error(250, c);
+}
 /*
  * Keywords.
  * During initialisation they are written to the symbol table.
  */
 static	struct	kwtab {
 	const	char *kw_name;	/* keyword */
 	int	kw_token;	/* token returned by yylex() */
 	scl_t	kw_scl;		/* storage class if kw_token T_SCLASS */
 	tspec_t	kw_tspec;	/* type spec. if kw_token T_TYPE or T_SOU */
 	tqual_t	kw_tqual;	/* type qual. fi kw_token T_QUAL */
 	u_int	kw_c89;		/* c89 keyword */
 	u_int	kw_c99;		/* c99 keyword */
 	u_int	kw_gcc;		/* GCC keyword */
 } kwtab[] = {
 	{ "__alignof__", T_ALIGNOF,	0,	0,	0,	  0, 0, 0 },
 	{ "__attribute__",T_ATTRIBUTE,	0,	0,	0,	  0, 0, 1 },
 	{ "attribute",	T_ATTRIBUTE,	0,	0,	0,	  0, 0, 1 },
 	{ "__packed__",	T_AT_PACKED,	0,	0,	0,	  0, 0, 1 },
 	{ "packed",	T_AT_PACKED,	0,	0,	0,	  0, 0, 1 },
 	{ "__aligned__",T_AT_ALIGNED,	0,	0,	0,	  0, 0, 1 },
 	{ "aligned",	T_AT_ALIGNED,	0,	0,	0,	  0, 0, 1 },
 	{ "__transparent_union__",T_AT_TUNION,0,0,	0,	  0, 0, 1 },
 	{ "transparent_union",T_AT_TUNION,0,	0,	0,	  0, 0, 1 },
 	{ "__unused__",	T_AT_UNUSED,	0,	0,	0,	  0, 0, 1 },
 	{ "unused",	T_AT_UNUSED,	0,	0,	0,	  0, 0, 1 },
 	{ "__deprecated__",T_AT_DEPRECATED,0,	0,	0,	  0, 0, 1 },
 	{ "deprecated",	T_AT_DEPRECATED,0,	0,	0,	  0, 0, 1 },
 	{ "__may_alias__",T_AT_MAY_ALIAS,0,	0,	0,	  0, 0, 1 },
 	{ "may_alias",	T_AT_MAY_ALIAS,	0,	0,	0,	  0, 0, 1 },
 	{ "asm",	T_ASM,		0,	0,	0,	  0, 0, 1 },
 	{ "__asm",	T_ASM,		0,	0,	0,	  0, 0, 0 },
 	{ "__asm__",	T_ASM,		0,	0,	0,	  0, 0, 0 },
 	{ "auto",	T_SCLASS,	AUTO,	0,	0,	  0, 0, 0 },
 	{ "break",	T_BREAK,	0,	0,	0,	  0, 0, 0 },
 	{ "_Bool",	T_TYPE,		0,	BOOL,	0,	  0, 1, 0 },
 	{ "case",	T_CASE,		0,	0,	0,	  0, 0, 0 },
 	{ "char",	T_TYPE,		0,	CHAR,	0,	  0, 0, 0 },
 	{ "const",	T_QUAL,		0,	0,	CONST,	  1, 0, 0 },
 	{ "_Complex",	T_TYPE,		0,	COMPLEX,0,	  0, 1, 0 },
 	{ "__const__",	T_QUAL,		0,	0,	CONST,	  0, 0, 0 },
 	{ "__const",	T_QUAL,		0,	0,	CONST,	  0, 0, 0 },
 	{ "continue",	T_CONTINUE,	0,	0,	0,	  0, 0, 0 },
 	{ "default",	T_DEFAULT,	0,	0,	0,	  0, 0, 0 },
 	{ "do",		T_DO,		0,	0,	0,	  0, 0, 0 },
 	{ "double",	T_TYPE,		0,	DOUBLE,	0,	  0, 0, 0 },
 	{ "else",	T_ELSE,		0,	0,	0,	  0, 0, 0 },
 	{ "enum",	T_ENUM,		0,	0,	0,	  0, 0, 0 },
 	{ "__extension__", T_EXTENSION,	0,	0,	0,	  0, 0, 1 },
 	{ "extern",	T_SCLASS,	EXTERN,	0,	0,	  0, 0, 0 },
 	{ "float",	T_TYPE,		0,	FLOAT,	0,	  0, 0, 0 },
 	{ "for",	T_FOR,		0,	0,	0,	  0, 0, 0 },
 	{ "goto",	T_GOTO,		0,	0,	0,	  0, 0, 0 },
 	{ "if",		T_IF,		0,	0,	0,	  0, 0, 0 },
 	{ "__imag__",	T_IMAG,		0,	0,	0,	  0, 1, 0 },
 	{ "inline",	T_SCLASS,	INLINE,	0,	0,	  0, 1, 0 },
 	{ "__inline__",	T_SCLASS,	INLINE,	0,	0,	  0, 0, 0 },
 	{ "__inline",	T_SCLASS,	INLINE,	0,	0,	  0, 0, 0 },
 	{ "int",	T_TYPE,		0,	INT,	0,	  0, 0, 0 },
 	{ "__symbolrename", T_SYMBOLRENAME, 0,	0,	0,	  0, 0, 0 },
 	{ "long",	T_TYPE,		0,	LONG,	0,	  0, 0, 0 },
 	{ "__real__",	T_REAL,		0,	0,	0,	  0, 1, 0 },
 	{ "register",	T_SCLASS,	REG,	0,	0,	  0, 0, 0 },
 	{ "restrict",	T_QUAL,		0,	0,	RESTRICT, 0, 1, 0 },
 	{ "return",	T_RETURN,	0,	0,	0,	  0, 0, 0 },
 	{ "__packed",	T_PACKED,	0,	0,	0,	  0, 0, 0 },
 	{ "short",	T_TYPE,		0,	SHORT,	0,	  0, 0, 0 },
 	{ "signed",	T_TYPE,		0,	SIGNED,	0,	  1, 0, 0 },
 	{ "__signed__",	T_TYPE,		0,	SIGNED,	0,	  0, 0, 0 },
 	{ "__signed",	T_TYPE,		0,	SIGNED,	0,	  0, 0, 0 },
 	{ "sizeof",	T_SIZEOF,	0,	0,	0,	  0, 0, 0 },
 	{ "static",	T_SCLASS,	STATIC,	0,	0,	  0, 0, 0 },
 	{ "struct",	T_SOU,		0,	STRUCT,	0,	  0, 0, 0 },
 	{ "switch",	T_SWITCH,	0,	0,	0,	  0, 0, 0 },
 	{ "typedef",	T_SCLASS,	TYPEDEF, 0,	0,	  0, 0, 0 },
 	{ "typeof",	T_TYPEOF,	0,	0,	0,	  0, 0, 1 },
 	{ "__typeof",	T_TYPEOF,	0,	0,	0,	  0, 0, 1 },
 	{ "__typeof__",	T_TYPEOF,	0,	0,	0,	  0, 0, 1 },
 	{ "union",	T_SOU,		0,	UNION,	0,	  0, 0, 0 },
 	{ "unsigned",	T_TYPE,		0,	UNSIGN,	0,	  0, 0, 0 },
 	{ "void",	T_TYPE,		0,	VOID,	0,	  0, 0, 0 },
 	{ "volatile",	T_QUAL,		0,	0,	VOLATILE, 1, 0, 0 },
 	{ "__volatile__", T_QUAL,	0,	0,	VOLATILE, 0, 0, 0 },
 	{ "__volatile",	T_QUAL,		0,	0,	VOLATILE, 0, 0, 0 },
 	{ "while",	T_WHILE,	0,	0,	0,	  0, 0, 0 },
 	{ NULL,		0,		0,	0,	0,	  0, 0, 0 }
 };
 /* Symbol table */
 static	sym_t	*symtab[HSHSIZ1];
 /* bit i of the entry with index i is set */
 uint64_t qbmasks[sizeof(uint64_t) * CHAR_BIT];
 /* least significant i bits are set in the entry with index i */
 uint64_t qlmasks[sizeof(uint64_t) * CHAR_BIT + 1];
 /* least significant i bits are not set in the entry with index i */
 uint64_t qumasks[sizeof(uint64_t) * CHAR_BIT + 1];
 /* free list for sbuf structures */
 static	sbuf_t	 *sbfrlst;
 /* Typ of next expected symbol */
 symt_t	symtyp;
 /*
  * All keywords are written to the symbol table. This saves us looking
  * in a extra table for each name we found.
  */
 void
 initscan(void)
+{
 	struct	kwtab *kw;
 	sym_t	*sym;
 	size_t	h, i;
 	uint64_t uq;
 	for (kw = kwtab; kw->kw_name != NULL; kw++) {
 		if ((kw->kw_c89 || kw->kw_c99) && tflag)
 			continue;
 		if (kw->kw_c99 && !(Sflag || gflag))
 			continue;
 		if (kw->kw_gcc && !gflag)
 			continue;
 		sym = getblk(sizeof (sym_t));
 		sym->s_name = kw->kw_name;
 		sym->s_keyw = 1;
 		sym->s_value.v_quad = kw->kw_token;
 		if (kw->kw_token == T_TYPE || kw->kw_token == T_SOU) {
 			sym->s_tspec = kw->kw_tspec;
 		} else if (kw->kw_token == T_SCLASS) {
 			sym->s_scl = kw->kw_scl;
 		} else if (kw->kw_token == T_QUAL) {
 			sym->s_tqual = kw->kw_tqual;
+		}
 		h = hash(sym->s_name);
 		if ((sym->s_link = symtab[h]) != NULL)
 			symtab[h]->s_rlink = &sym->s_link;
 		sym->s_rlink = &symtab[h];
 		symtab[h] = sym;
+	}
 	/* initialize bit-masks for quads */
 	for (i = 0; i < sizeof (uint64_t) * CHAR_BIT; i++) {
 		qbmasks[i] = (uint64_t)1 << i;
 		uq = ~(uint64_t)0 << i;
 		qumasks[i] = uq;
 		qlmasks[i] = ~uq;
+	}
 	qumasks[i] = 0;
 	qlmasks[i] = ~(uint64_t)0;
+}
 /*
  * Get a free sbuf structure, if possible from the free list
  */
 static sbuf_t *
 allocsb(void)
+{
 	sbuf_t	*sb;
 	if ((sb = sbfrlst) != NULL) {
 		sbfrlst = sb->sb_nxt;
 	} else {
 		sb = xmalloc(sizeof (sbuf_t));
+	}
 	(void)memset(sb, 0, sizeof (*sb));
 	return (sb);
+}
 /*
  * Put a sbuf structure to the free list
  */
 static void
 freesb(sbuf_t *sb)
+{
 	sb->sb_nxt = sbfrlst;
 	sbfrlst = sb;
+}
 /*
  * Read a character and ensure that it is positive (except EOF).
  * Increment line count(s) if necessary.
  */
 static int
 inpc(void)
+{
 	int	c;
 	if ((c = input()) != EOF && (c &= CHAR_MASK) == '\n')
 		incline();
 	return (c);
+}
 static int
 hash(const char *s)
+{
 	u_int	v;
 	const	u_char *us;
 	v = 0;
 	for (us = (const u_char *)s; *us != '\0'; us++) {
 		v = (v << sizeof (v)) + *us;
 		v ^= v >> (sizeof (v) * CHAR_BIT - sizeof (v));
+	}
 	return (v % HSHSIZ1);
+}
 /*
  * Lex has found a letter followed by zero or more letters or digits.
  * It looks for a symbol in the symbol table with the same name. This
  * symbol must either be a keyword or a symbol of the type required by
  * symtyp (label, member, tag, ...).
+ *
  * If it is a keyword, the token is returned. In some cases it is described
  * more deeply by data written to yylval.
+ *
  * If it is a symbol, T_NAME is returned and the pointer to a sbuf struct
  * is stored in yylval. This struct contains the name of the symbol, it's
  * length and hash value. If there is already a symbol of the same name
  * and type in the symbol table, the sbuf struct also contains a pointer
  * to the symbol table entry.
  */
 static int
 name(void)
+{
 	char	*s;
 	sbuf_t	*sb;
 	sym_t	*sym;
 	int	tok;
 	sb = allocsb();
 	sb->sb_name = yytext;
 	sb->sb_len = yyleng;
 	sb->sb_hash = hash(yytext);
 	if ((sym = search(sb)) != NULL && sym->s_keyw) {
 		freesb(sb);
 		return (keyw(sym));
+	}
 	sb->sb_sym = sym;
 	if (sym != NULL) {
 		if (blklev < sym->s_blklev)
 			LERROR("name()");
 		sb->sb_name = sym->s_name;
 		sb->sb_len = strlen(sym->s_name);
 		tok = sym->s_scl == TYPEDEF ? T_TYPENAME : T_NAME;
 	} else {
 		s = getblk(yyleng + 1);
 		(void)memcpy(s, yytext, yyleng + 1);
 		sb->sb_name = s;
 		sb->sb_len = yyleng;
 		tok = T_NAME;
+	}
 	yylval.y_sb = sb;
 	return (tok);
+}
 static sym_t *
 search(sbuf_t *sb)
+{
 	sym_t	*sym;
 	for (sym = symtab[sb->sb_hash]; sym != NULL; sym = sym->s_link) {
 		if (strcmp(sym->s_name, sb->sb_name) == 0) {
 			if (sym->s_keyw || sym->s_kind == symtyp)
 				return (sym);
+		}
+	}
 	return (NULL);
+}
 static int
 keyw(sym_t *sym)
+{
 	int	t;
 	if ((t = (int)sym->s_value.v_quad) == T_SCLASS) {
 		yylval.y_scl = sym->s_scl;
 	} else if (t == T_TYPE || t == T_SOU) {
 		yylval.y_tspec = sym->s_tspec;
 	} else if (t == T_QUAL) {
 		yylval.y_tqual = sym->s_tqual;
+	}
 	return (t);
+}
 /*
  * Convert a string representing an integer into internal representation.
  * The value is returned in yylval. icon() (and yylex()) returns T_CON.
  */
 static int
 icon(int base)
+{
 	int	l_suffix, u_suffix;
 	int	len;
 	const	char *cp;
 	char	c, *eptr;
 	tspec_t	typ;
 	uint64_t uq = 0;
 	int	ansiu;
 	static	tspec_t contypes[2][3] = {
 		{ INT,  LONG,  QUAD },
 		{ UINT, ULONG, UQUAD }
 	};
 	cp = yytext;
 	len = yyleng;
 	/* skip 0x */
 	if (base == 16) {
 		cp += 2;
 		len -= 2;
+	}
 	/* read suffixes */
 	l_suffix = u_suffix = 0;
 	for ( ; ; ) {
 		if ((c = cp[len - 1]) == 'l' || c == 'L') {
 			l_suffix++;
 		} else if (c == 'u' || c == 'U') {
 			u_suffix++;
 		} else {
 			break;
+		}
 		len--;
+	}
 	if (l_suffix > 2 || u_suffix > 1) {
 		/* malformed integer constant */
 		warning(251);
 		if (l_suffix > 2)
 			l_suffix = 2;
 		if (u_suffix > 1)
 			u_suffix = 1;
+	}
 	if (tflag && u_suffix != 0) {
 		/* suffix U is illegal in traditional C */
 		warning(97);
+	}
 	typ = contypes[u_suffix][l_suffix];
 	errno = 0;
 	uq = strtouq(cp, &eptr, base);
 	if (eptr != cp + len)
 		LERROR("icon()");
 	if (errno != 0)
 		/* integer constant out of range */
 		warning(252);
 	/*
 	 * If the value is too big for the current type, we must choose
 	 * another type.
 	 */
 	ansiu = 0;
 	switch (typ) {
 	case INT:
 		if (uq <= TARG_INT_MAX) {
 			/* ok */
 		} else if (uq <= TARG_UINT_MAX && base != 10) {
 			typ = UINT;
 		} else if (uq <= TARG_LONG_MAX) {
 			typ = LONG;
 		} else {
 			typ = ULONG;
 			if (uq > TARG_ULONG_MAX) {
 				/* integer constant out of range */
 				warning(252);
+			}
+		}
 		if (typ == UINT || typ == ULONG) {
 			if (tflag) {
 				typ = LONG;
 			} else if (!sflag) {
 				/*
 				 * Remember that the constant is unsigned
 				 * only in ANSI C
 				 */
 				ansiu = 1;
+			}
+		}
 		break;
 	case UINT:
 		if (uq > TARG_UINT_MAX) {
 			typ = ULONG;
 			if (uq > TARG_ULONG_MAX) {
 				/* integer constant out of range */
 				warning(252);
+			}
+		}
 		break;
 	case LONG:
 		if (uq > TARG_LONG_MAX && !tflag) {
 			typ = ULONG;
 			if (!sflag)
 				ansiu = 1;
 			if (uq > TARG_ULONG_MAX) {
 				/* integer constant out of range */
 				warning(252);
+			}
+		}
 		break;
 	case ULONG:
 		if (uq > TARG_ULONG_MAX) {
 			/* integer constant out of range */
 			warning(252);
+		}
 		break;
 	case QUAD:
 		if (uq > TARG_QUAD_MAX && !tflag) {
 			typ = UQUAD;
 			if (!sflag)
 				ansiu = 1;
+		}
 		break;
 	case UQUAD:
 		if (uq > TARG_UQUAD_MAX) {
 			/* integer constant out of range */
 			warning(252);
+		}
 		break;
 		/* LINTED206: (enumeration values not handled in switch) */
 	case STRUCT:
 	case VOID:
 	case LDOUBLE:
 	case FUNC:
 	case ARRAY:
 	case PTR:
 	case ENUM:
 	case UNION:
 	case SIGNED:
 	case NOTSPEC:
 	case DOUBLE:
 	case FLOAT:
 	case USHORT:
 	case SHORT:
 	case UCHAR:
 	case SCHAR:
 	case CHAR:
 	case BOOL:
 	case UNSIGN:
 	case FCOMPLEX:
 	case DCOMPLEX:
 	case LCOMPLEX:
 	case COMPLEX:
 		break;
 	case NTSPEC:	/* this value unused */
 		break;
+	}
 	uq = (uint64_t)xsign((int64_t)uq, typ, -1);
 	(yylval.y_val = xcalloc(1, sizeof (val_t)))->v_tspec = typ;
 	yylval.y_val->v_ansiu = ansiu;
 	yylval.y_val->v_quad = (int64_t)uq;
 	return (T_CON);
+}
 /*
  * Returns 1 if t is a signed type and the value is negative.
+ *
  * len is the number of significant bits. If len is -1, len is set
  * to the width of type t.
  */
 int
 sign(int64_t q, tspec_t t, int len)
+{
 	if (t == PTR || isutyp(t))
 		return (0);
 	return (msb(q, t, len));
+}
 int
 msb(int64_t q, tspec_t t, int len)
+{
 	if (len <= 0)
 		len = size(t);
 	return ((q & qbmasks[len - 1]) != 0);
+}
 /*
  * Extends the sign of q.
  */
 int64_t
 xsign(int64_t q, tspec_t t, int len)
+{
 	if (len <= 0)
 		len = size(t);
 	if (t == PTR || isutyp(t) || !sign(q, t, len)) {
 		q &= qlmasks[len];
 	} else {
 		q |= qumasks[len];
+	}
 	return (q);
+}
 /*
  * Convert a string representing a floating point value into its interal
  * representation. Type and value are returned in yylval. fcon()
  * (and yylex()) returns T_CON.
  * XXX Currently it is not possible to convert constants of type
  * long double which are greater than DBL_MAX.
  */
 static int
 fcon(void)
+{
 	const	char *cp;
 	int	len;
 	tspec_t typ;
 	char	c, *eptr;
 	double	d;
 	float	f = 0;
 	cp = yytext;
 	len = yyleng;
 	if (cp[len - 1] == 'i') {
 		/* imaginary, do nothing for now */
 		len--;
+	}
 	if ((c = cp[len - 1]) == 'f' || c == 'F') {
 		typ = FLOAT;
 		len--;
 	} else if (c == 'l' || c == 'L') {
 		typ = LDOUBLE;
 		len--;
 	} else {
 		if (c == 'd' || c == 'D')
 			len--;
 		typ = DOUBLE;
+	}
 	if (tflag && typ != DOUBLE) {
 		/* suffixes F and L are illegal in traditional C */
 		warning(98);
+	}
 	errno = 0;
 	d = strtod(cp, &eptr);
 	if (eptr != cp + len) {
 		switch (*eptr) {
 		/*
 		 * XXX: non-native non-current strtod() may not handle hex
 		 * floats, ignore the rest if we find traces of hex float
 		 * syntax...
 		 */
 		case 'p':
 		case 'P':
 		case 'x':
 		case 'X':
 			d = 0;
 			errno = 0;
 			break;
 		default:
 			LERROR("fcon(%s->%s)", cp, eptr);
+		}
+	}
 	if (errno != 0)
 		/* floating-point constant out of range */
 		warning(248);
 	if (typ == FLOAT) {
 		f = (float)d;
 		if (!finite(f)) {
 			/* floating-point constant out of range */
 			warning(248);
 			f = f > 0 ? FLT_MAX : -FLT_MAX;
+		}
+	}
 	(yylval.y_val = xcalloc(1, sizeof (val_t)))->v_tspec = typ;
 	if (typ == FLOAT) {
 		yylval.y_val->v_ldbl = f;
 	} else {
 		yylval.y_val->v_ldbl = d;
+	}
 	return (T_CON);
+}
 static int
 operator(int t, op_t o)
+{
 	yylval.y_op = o;
 	return (t);
+}
 /*
  * Called if lex found a leading \'.
  */
 static int
 ccon(void)
+{
 	size_t	n;
 	int val, c;
 	char	cv;
 	n = 0;
 	val = 0;
 	while ((c = getescc('\'')) >= 0) {
 		val = (val << CHAR_BIT) + c;
 		n++;
+	}
 	if (c == -2) {
 		/* unterminated character constant */
 		error(253);
 	} else {
 		if (n > sizeof (int) || (n > 1 && (pflag || hflag))) {
 			/* too many characters in character constant */
 			error(71);
 		} else if (n > 1) {
 			/* multi-character character constant */
 			warning(294);
 		} else if (n == 0) {
 			/* empty character constant */
 			error(73);
+		}
+	}
 	if (n == 1) {
 		cv = (char)val;
 		val = cv;
+	}
 	yylval.y_val = xcalloc(1, sizeof (val_t));
 	yylval.y_val->v_tspec = INT;
 	yylval.y_val->v_quad = val;
 	return (T_CON);
+}
 /*
  * Called if lex found a leading L\'
  */
 static int
 wccon(void)
+{
 	static	char buf[MB_LEN_MAX + 1];
 	size_t	i;
 	int c;
 	wchar_t	wc;
 	i = 0;
 	while ((c = getescc('\'')) >= 0) {
 		if (i < MB_CUR_MAX)
 			buf[i] = (char)c;
 		i++;
+	}
 	wc = 0;
 	if (c == -2) {
 		/* unterminated character constant */
 		error(253);
 	} else if (c == 0) {
 		/* empty character constant */
 		error(73);
 	} else {
 		if (i > MB_CUR_MAX) {
 			i = MB_CUR_MAX;
 			/* too many characters in character constant */
 			error(71);
 		} else {
 			buf[i] = '\0';
 			(void)mbtowc(NULL, NULL, 0);
 			if (mbtowc(&wc, buf, MB_CUR_MAX) < 0)
 				/* invalid multibyte character */
 				error(291);
+		}
+	}
 	yylval.y_val = xcalloc(1, sizeof (val_t));
 	yylval.y_val->v_tspec = WCHAR;
 	yylval.y_val->v_quad = wc;
 	return (T_CON);
+}
 /*
  * Read a character which is part of a character constant or of a string
  * and handle escapes.
+ *
  * The Argument is the character which delimits the character constant or
  * string.
+ *
  * Returns -1 if the end of the character constant or string is reached,
  * -2 if the EOF is reached, and the character otherwise.
  */
 static int
 getescc(int d)
+{
 	static	int pbc = -1;
 	int	n, c, v;
 	if (pbc == -1) {
 		c = inpc();
 	} else {
 		c = pbc;
 		pbc = -1;
+	}
 	if (c == d)
 		return (-1);
 	switch (c) {
 	case '\n':
 		if (tflag) {
 			/* newline in string or char constant */
 			error(254);
 			return (-2);
+		}
 		return (c);
 	case EOF:
 		return (-2);
 	case '\\':
 		switch (c = inpc()) {
 		case '"':
 			if (tflag && d == '\'')
 				/* \" inside character constant undef. ... */
 				warning(262);
 			return ('"');
 		case '\'':
 			return ('\'');
 		case '?':
 			if (tflag)
 				/* \? undefined in traditional C */
 				warning(263);
 			return ('?');
 		case '\\':
 			return ('\\');
 		case 'a':
 			if (tflag)
 				/* \a undefined in traditional C */
 				warning(81);
 			return ('\a');
 		case 'b':
 			return ('\b');
 		case 'f':
 			return ('\f');
 		case 'n':
 			return ('\n');
 		case 'r':
 			return ('\r');
 		case 't':
 			return ('\t');
 		case 'v':
 			if (tflag)
 				/* \v undefined in traditional C */
 				warning(264);
 			return ('\v');
 		case '8': case '9':
 			/* bad octal digit %c */
 			warning(77, c);
 			/* FALLTHROUGH */
 		case '0': case '1': case '2': case '3':
 		case '4': case '5': case '6': case '7':
 			n = 3;
 			v = 0;
 			do {
 				v = (v << 3) + (c - '0');
 				c = inpc();
 			} while (--n && isdigit(c) && (tflag || c <= '7'));
 			if (tflag && n > 0 && isdigit(c))
 				/* bad octal digit %c */
 				warning(77, c);
 			pbc = c;
 			if (v > TARG_UCHAR_MAX) {
 				/* character escape does not fit in char. */
 				warning(76);
 				v &= CHAR_MASK;
+			}
 			return (v);
 		case 'x':
 			if (tflag)
 				/* \x undefined in traditional C */
 				warning(82);
 			v = 0;
 			n = 0;
 			while ((c = inpc()) >= 0 && isxdigit(c)) {
 				c = isdigit(c) ?
 					c - '0' : toupper(c) - 'A' + 10;
 				v = (v << 4) + c;
 				if (n >= 0) {
 					if ((v & ~CHAR_MASK) != 0) {
 						/* overflow in hex escape */
 						warning(75);
 						n = -1;
 					} else {
 						n++;
+					}
+				}
+			}
 			pbc = c;
 			if (n == 0) {
 				/* no hex digits follow \x */
 				error(74);
 			} if (n == -1) {
 				v &= CHAR_MASK;
+			}
 			return (v);
 		case '\n':
 			return (getescc(d));
 		case EOF:
 			return (-2);
 		default:
 			if (isprint(c)) {
 				/* dubious escape \%c */
 				warning(79, c);
 			} else {
 				/* dubious escape \%o */
 				warning(80, c);
+			}
+		}
+	}
 	return (c);
+}
 /*
  * Called for preprocessor directives. Currently implemented are:
  *	# lineno
  *	# lineno "filename"
  */
 static void
 directive(void)
+{
 	const	char *cp, *fn;
 	char	c, *eptr;
 	size_t	fnl;
 	long	ln;
 	static	int first = 1;
 	/* Go to first non-whitespace after # */
 	for (cp = yytext + 1; (c = *cp) == ' ' || c == '\t'; cp++)
 		continue;
 	if (!isdigit((unsigned char)c)) {
 	error:
 		/* undefined or invalid # directive */
 		warning(255);
 		return;
+	}
 	ln = strtol(--cp, &eptr, 10);
 	if (cp == eptr)
 		goto error;
 	if ((c = *(cp = eptr)) != ' ' && c != '\t' && c != '\0')
 		goto error;
 	while ((c = *cp++) == ' ' || c == '\t')
 		continue;
 	if (c != '\0') {
 		if (c != '"')
 			goto error;
 		fn = cp;
 		while ((c = *cp) != '"' && c != '\0')
 			cp++;
 		if (c != '"')
 			goto error;
 		if ((fnl = cp++ - fn) > PATH_MAX)
 			goto error;
 		while ((c = *cp++) == ' ' || c == '\t')
 			continue;
 #if 0
 		if (c != '\0')
 			warning("extra character(s) after directive");
 #endif
 		/* empty string means stdin */
 		if (fnl == 0) {
 			fn = "{standard input}";
 			fnl = 16;			/* strlen (fn) */
+		}
 		curr_pos.p_file = fnnalloc(fn, fnl);
 		/*
 		 * If this is the first directive, the name is the name
 		 * of the C source file as specified at the command line.
 		 * It is written to the output file.
 		 */
 		if (first) {
 			csrc_pos.p_file = curr_pos.p_file;
 			outsrc(curr_pos.p_file);
 			first = 0;
+		}
+	}
 	curr_pos.p_line = (int)ln - 1;
 	curr_pos.p_uniq = 0;
 	if (curr_pos.p_file == csrc_pos.p_file) {
 		csrc_pos.p_line = (int)ln - 1;
 		csrc_pos.p_uniq = 0;
+	}
+}
 /*
  * Handle lint comments. Following comments are currently understood:
  *	ARGSUSEDn
  *	BITFIELDTYPE
  *	CONSTCOND CONSTANTCOND CONSTANTCONDITION
  *	FALLTHRU FALLTHROUGH
  *	LINTLIBRARY
  *	LINTEDn NOSTRICTn
  *	LONGLONG
  *	NOTREACHED
  *	PRINTFLIKEn
  *	PROTOLIB
  *	SCANFLIKEn
  *	VARARGSn
  * If one of this comments is recognized, the arguments, if any, are
  * parsed and a function which handles this comment is called.
  */
 static void
 comment(void)
+{
 	int	c, lc;
 	static struct {
 		const	char *keywd;
 		int	arg;
 		void	(*func)(int);
 	} keywtab[] = {
 		{ "ARGSUSED",		1,	argsused	},
 		{ "BITFIELDTYPE",	0,	bitfieldtype	},
 		{ "CONSTCOND",		0,	constcond	},
 		{ "CONSTANTCOND",	0,	constcond	},
 		{ "CONSTANTCONDITION",	0,	constcond	},
 		{ "FALLTHRU",		0,	fallthru	},
 		{ "FALLTHROUGH",	0,	fallthru	},
 		{ "LINTLIBRARY",	0,	lintlib		},
 		{ "LINTED",		1,	linted		},
 		{ "LONGLONG",		0,	longlong	},
 		{ "NOSTRICT",		1,	linted		},
 		{ "NOTREACHED",		0,	notreach	},
 		{ "PRINTFLIKE",		1,	printflike	},
 		{ "PROTOLIB",		1,	protolib	},
 		{ "SCANFLIKE",		1,	scanflike	},
 		{ "VARARGS",		1,	varargs		},
 	};
 	char	keywd[32];
 	char	arg[32];
 	size_t	l, i;
 	int	a;
 	int	eoc;
 	eoc = 0;
 	/* Skip white spaces after the start of the comment */
 	while ((c = inpc()) != EOF && isspace(c))
 		continue;
 	/* Read the potential keyword to keywd */
 	l = 0;
 	while (c != EOF && isupper(c) && l < sizeof (keywd) - 1) {
 		keywd[l++] = (char)c;
 		c = inpc();
+	}
 	keywd[l] = '\0';
 	/* look for the keyword */
 	for (i = 0; i < sizeof (keywtab) / sizeof (keywtab[0]); i++) {
 		if (strcmp(keywtab[i].keywd, keywd) == 0)
 			break;
+	}
 	if (i == sizeof (keywtab) / sizeof (keywtab[0]))
 		goto skip_rest;
 	/* skip white spaces after the keyword */
 	while (c != EOF && isspace(c))
 		c = inpc();
 	/* read the argument, if the keyword accepts one and there is one */
 	l = 0;
 	if (keywtab[i].arg) {
 		while (c != EOF && isdigit(c) && l < sizeof (arg) - 1) {
 			arg[l++] = (char)c;
 			c = inpc();
+		}
+	}
 	arg[l] = '\0';
 	a = l != 0 ? atoi(arg) : -1;
 	/* skip white spaces after the argument */
 	while (c != EOF && isspace(c))
 		c = inpc();
 	if (c != '*' || (c = inpc()) != '/') {
 		if (keywtab[i].func != linted)
 			/* extra characters in lint comment */
 			warning(257);
 	} else {
 		/*
 		 * remember that we have already found the end of the
 		 * comment
 		 */
 		eoc = 1;
+	}
 	if (keywtab[i].func != NULL)
 		(*keywtab[i].func)(a);
  skip_rest:
 	while (!eoc) {
 		lc = c;
 		if ((c = inpc()) == EOF) {
 			/* unterminated comment */
 			error(256);
 			break;
+		}
 		if (lc == '*' && c == '/')
 			eoc = 1;
+	}
+}
 /*
  * Handle // style comments
  */
 static void
 slashslashcomment(void)
+{
 	int c;
 	if (!Sflag && !gflag)
 		/* // comments only supported in C99 */
 		(void)gnuism(312, tflag ? "traditional" : "ANSI");
 	while ((c = inpc()) != EOF && c != '\n')
 		continue;
+}
 /*
  * Clear flags for lint comments LINTED, LONGLONG and CONSTCOND.
  * clrwflgs() is called after function definitions and global and
  * local declarations and definitions. It is also called between
  * the controlling expression and the body of control statements
  * (if, switch, for, while).
  */
 void
 clrwflgs(void)
+{
 	lwarn = LWARN_ALL;
 	quadflg = 0;
 	ccflg = 0;
+}
 /*
  * Strings are stored in a dynamically alloceted buffer and passed
  * in yylval.y_xstrg to the parser. The parser or the routines called
  * by the parser are responsible for freeing this buffer.
  */
 static int
 string(void)
+{
 	u_char	*s;
 	int	c;
 	size_t	len, max;
 	strg_t	*strg;
 	s = xmalloc(max = 64);
 	len = 0;
 	while ((c = getescc('"')) >= 0) {
 		/* +1 to reserve space for a trailing NUL character */
 		if (len + 1 == max)
 			s = xrealloc(s, max *= 2);
 		s[len++] = (char)c;
+	}
 	s[len] = '\0';
 	if (c == -2)
 		/* unterminated string constant */
 		error(258);

 @@ -1,1039 +1,1039 @@
-/*	$NetBSD: tree.c,v 1.74 2014/02/18 20:43:36 christos Exp $	*/
+/*	$NetBSD: tree.c,v 1.75 2014/02/18 22:01:36 christos 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.74 2014/02/18 20:43:36 christos Exp $");
+__RCSID("$NetBSD: tree.c,v 1.75 2014/02/18 22:01:36 christos Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <signal.h>
 #include "lint1.h"
 #include "cgram.h"
 #include "externs1.h"
 static	tnode_t	*getinode(tspec_t, int64_t);
 static	void	ptrcmpok(op_t, tnode_t *, tnode_t *);
 static	int	asgntypok(op_t, int, tnode_t *, tnode_t *);
 static	void	chkbeop(op_t, tnode_t *, tnode_t *);
 static	void	chkeop2(op_t, int, tnode_t *, tnode_t *);
 static	void	chkeop1(op_t, int, tnode_t *, tnode_t *);
 static	tnode_t	*mktnode(op_t, type_t *, tnode_t *, tnode_t *);
 static	void	balance(op_t, tnode_t **, tnode_t **);
 static	void	incompat(op_t, tspec_t, tspec_t);
 static	void	illptrc(mod_t *, type_t *, type_t *);
 static	void	mrgqual(type_t **, type_t *, type_t *);
 static	int	conmemb(type_t *);
 static	void	ptconv(int, tspec_t, tspec_t, type_t *, tnode_t *);
 static	void	iiconv(op_t, int, tspec_t, tspec_t, type_t *, tnode_t *);
 static	void	piconv(op_t, tspec_t, type_t *, tnode_t *);
 static	void	ppconv(op_t, tnode_t *, type_t *);
 static	tnode_t	*bldstr(op_t, tnode_t *, tnode_t *);
 static	tnode_t	*bldincdec(op_t, tnode_t *);
 static	tnode_t	*bldri(op_t, tnode_t *);
 static	tnode_t	*bldamper(tnode_t *, int);
 static	tnode_t	*bldplmi(op_t, tnode_t *, tnode_t *);
 static	tnode_t	*bldshft(op_t, tnode_t *, tnode_t *);
 static	tnode_t	*bldcol(tnode_t *, tnode_t *);
 static	tnode_t	*bldasgn(op_t, tnode_t *, tnode_t *);
 static	tnode_t	*plength(type_t *);
 static	tnode_t	*fold(tnode_t *);
 static	tnode_t	*foldtst(tnode_t *);
 static	tnode_t	*foldflt(tnode_t *);
 static	tnode_t	*chkfarg(type_t *, tnode_t *);
 static	tnode_t	*parg(int, type_t *, tnode_t *);
 static	void	nulleff(tnode_t *);
 static	void	displexpr(tnode_t *, int);
 static	void	chkaidx(tnode_t *, int);
 static	void	chkcomp(op_t, tnode_t *, tnode_t *);
 static	void	precconf(tnode_t *);
 extern sig_atomic_t fpe;
 /*
  * 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 *
 getinode(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_LPARN) {
 			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) {
 					gnuism(316);
 					fixtype = 1;
 				} else if (strcmp(sym->s_name, "__func__") == 0) {
 					if (!Sflag)
 						warning(317);
 					fixtype = 1;
 				} else {
 					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 != FMOS)
 		LERROR("getnnode()");
 	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_strg = tgetblk(sizeof (strg_t));
 	n->tn_strg->st_tspec = strg->st_tspec;
 	n->tn_strg->st_len = len;
 	if (strg->st_tspec == CHAR) {
 		n->tn_strg->st_cp = tgetblk(len + 1);
 		(void)memcpy(n->tn_strg->st_cp, strg->st_cp, len + 1);
 		free(strg->st_cp);
 	} else {
 		n->tn_strg->st_wcp = tgetblk((len + 1) * sizeof (wchar_t));
 		(void)memcpy(n->tn_strg->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 *
 strmemb(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 = FMOS;
 		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_field != sym->s_field) {
 				eq = 0;
 				break;
+			}
 			if (csym->s_field) {
 				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) {
 		/* illegal member use: %s */
 		if (eq && tflag) {
 			warning(102, msym->s_name);
 		} else {
 			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) {
 			/* left operand of "." must be struct/union object */
 			if (tflag) {
 				warning(103);
 			} else {
 				error(103);
+			}
 		} else {
 			/* left operand of "->" must be pointer to ... */
 			if (tflag && tn->tn_type->t_tspec == PTR) {
 				warning(104);
 			} else {
 				error(104);
+			}
+		}
 	} 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 compaired 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)
 		chkcomp(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 serios problems.
 	 */
 	if (!typeok(op, 0, ln, rn))
 		return (NULL);
 	/* And now create the node. */
 	switch (op) {
 	case POINT:
 	case ARROW:
 		ntn = bldstr(op, ln, rn);
 		break;
 	case INCAFT:
 	case DECAFT:
 	case INCBEF:
 	case DECBEF:
 		ntn = bldincdec(op, ln);
 		break;
 	case AMPER:
 		ntn = bldamper(ln, 0);
 		break;
 	case STAR:
 		ntn = mktnode(STAR, ln->tn_type->t_subt, ln, NULL);
 		break;
 	case PLUS:
 	case MINUS:
 		ntn = bldplmi(op, ln, rn);
 		break;
 	case SHL:
 	case SHR:
 		ntn = bldshft(op, ln, rn);
 		break;
 	case COLON:
 		ntn = bldcol(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 = bldasgn(op, ln, rn);
 		break;
 	case COMMA:
 	case QUEST:
 		ntn = mktnode(op, rn->tn_type, ln, rn);
 		break;
 	case REAL:
 	case IMAG:
 		ntn = bldri(op, ln);
 		break;
 	default:
 		rtp = mp->m_logop ? gettyp(INT) : ln->tn_type;
 		if (!mp->m_binary && rn != NULL)
 			LERROR("build()");
 		ntn = mktnode(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)
 		precconf(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 && !ccflg)
 				/* 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 = foldtst(ntn);
 			} else if (isftyp(ntn->tn_type->t_tspec)) {
 				ntn = foldflt(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) {
 			/* %soperand of '%s' must be lvalue */
 			/* XXX print correct operator */
 			(void)gnuism(114, "", modtab[AMPER].m_name);
+		}
 		tn = mktnode(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 = bldamper(tn, 1);
 	/* lvalue to rvalue */
 	if (tn->tn_lvalue) {
 		tp = tduptyp(tn->tn_type);
 		tp->t_const = tp->t_volatile = 0;
 		tn = mktnode(LOAD, tp, tn, NULL);
+	}
 	return (tn);
+}
 /*
  * Perform most type checks. First the types are checked using
  * informations 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];
 	if ((ltp = ln->tn_type) == NULL)
 		LERROR("typeok()");
 	if ((lt = ltp->t_tspec) == PTR)
 		lst = (lstp = ltp->t_subt)->t_tspec;
 	if (mp->m_binary) {
 		if ((rtp = rn->tn_type) == NULL)
 			LERROR("typeok()");
 		if ((rt = rtp->t_tspec) == PTR)
 			rst = (rstp = rtp->t_subt)->t_tspec;
+	}
 	if (mp->m_rqint) {
 		/* integertypes required */
 		if (!isityp(lt) || (mp->m_binary && !isityp(rt))) {
 			incompat(op, lt, rt);
 			return (0);
+		}
 	} else if (mp->m_rqintcomp) {
 		/* integertypes required */
 		if ((!isityp(lt) && !isctyp(lt)) ||
 		    (mp->m_binary && (!isityp(rt) && !isctyp(rt)))) {
 			incompat(op, lt, rt);
 			return (0);
+		}
 	} else if (mp->m_rqsclt) {
 		/* scalar types required */
 		if (!issclt(lt) || (mp->m_binary && !issclt(rt))) {
 			incompat(op, lt, rt);
 			return (0);
+		}
 	} else if (mp->m_rqatyp) {
 		/* arithmetic types required */
 		if (!isatyp(lt) || (mp->m_binary && !isatyp(rt))) {
 			incompat(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 strmemb().
 		 * Here we only must check for totaly 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 && isityp(lt))) {
 			/* Without tflag we got already an error */
 			if (tflag)
 				/* unacceptabel 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) {
 				/* a cast to non-ptr does not yield an lvalue */
 				if (ln->tn_type->t_tspec == PTR)
 					break;
 				error(163);
+			}
 			/* %soperand of %s must be lvalue */
 			error(114, "", mp->m_name);
 			return (0);
 		} else if (ltp->t_const) {
 			/* %soperand of %s must be modifiable lvalue */
 			if (!tflag)
 				warning(115, "", mp->m_name);
+		}
 		break;
 	case AMPER:
 		if (lt == ARRAY || lt == FUNC) {
 			/* ok, a warning comes later (in bldamper()) */
 		} else if (!ln->tn_lvalue) {
 			if (ln->tn_op == CVT && ln->tn_cast &&
 			    ln->tn_left->tn_op == LOAD) {
 				/* a cast to non-ptr does not yield an lvalue */
 				if (ln->tn_type->t_tspec == PTR)
 					break;
 				error(163);
+			}
 			/* %soperand of %s must be lvalue */
 			error(114, "", mp->m_name);
 			return (0);
 		} else if (issclt(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 && !isityp(rt)) || (rt == PTR && !isityp(lt))) {
 			incompat(op, lt, rt);
 			return (0);
+		}
 		break;
 	case MINUS:
 		/* operands have scalar types (checked above) */
 		if (lt == PTR && (!isityp(rt) && rt != PTR)) {
 			incompat(op, lt, rt);
 			return (0);
 		} else if (rt == PTR && lt != PTR) {
 			incompat(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 && !isutyp(lt)) {
 			/*
 			 * The left operand is signed. This means that
 			 * the operation is (possibly) nonportable.
 			 */
 			/* bitwise operation on signed value nonportable */
 			if (ln->tn_op != CON) {
 				/* possibly nonportable */
 				warning(117);
 			} else if (ln->tn_val->v_quad < 0) {
 				warning(120);
+			}
 		} else if (!tflag && !sflag && !isutyp(olt) && isutyp(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; use ... */
 				warning(118, mp->m_name);
+			}
 		} else if (!tflag && !sflag && !isutyp(olt) && !isutyp(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; use ... */
 				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 greather than the width of the left operand, than in
 		 * traditional C the left operand would be extendet 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 differencs between
 			 * ANSI C and traditional C.
 			 */
 			if (hflag)
 				/* semantics of %s change in ANSI C; use ... */
 				warning(118, mp->m_name);
+		}
 	shift:
 		if (rn->tn_op == CON) {
 			if (!isutyp(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 fo 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) || isityp(rt))) {
 			if (rn->tn_op == CON && rn->tn_val->v_quad == 0)
 				break;
+		}
 		if (rt == PTR && ((lt == PTR && lst == VOID) || isityp(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 (isityp(lt) || isityp(rt)) {
 				/* illegal comb. of pointer and int., op %s */
 				warning(123, mp->m_name);
 			} else {
 				incompat(op, lt, rt);
 				return (0);
+			}
 		} else if (lt == PTR && rt == PTR) {
 			ptrcmpok(op, ln, rn);
+		}
 		break;
 	case QUEST:
 		if (!issclt(lt)) {
 			/* first operand must have scalar type, op ? : */
 			error(170);
 			return (0);
+		}
 		while (rn->tn_op == CVT)
 			rn = rn->tn_left;
 		if (rn->tn_op != COLON)
 			LERROR("typeok()");
 		break;
 	case COLON:
 		if (isatyp(lt) && isatyp(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) || isityp(rt))) {
 			if (rn->tn_op == CON && rn->tn_val->v_quad == 0)
 				break;
+		}
 		if (rt == PTR && ((lt == PTR && lst == VOID) || isityp(lt))) {
 			if (ln->tn_op == CON && ln->tn_val->v_quad == 0)
 				break;
+		}
 		if ((lt == PTR && isityp(rt)) || (isityp(lt) && rt == PTR)) {
 			/* illegal comb. of ptr. and int., op %s */
 			warning(123, 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))
 				illptrc(mp, ltp, rtp);
 			break;
+		}
 		/* incompatible types in conditional */
 		error(126);
 		return (0);
 	case ASSIGN:
 	case INIT:
 	case FARG:
 	case RETURN:
 		if (!asgntypok(op, arg, ln, rn))
 			return (0);
 		goto assign;
 	case MULASS:
 	case DIVASS:
 	case MODASS:
 		goto assign;
 	case ADDASS:
 	case SUBASS:
 		/* operands have scalar types (checked above) */
 		if ((lt == PTR && !isityp(rt)) || rt == PTR) {
 			incompat(op, lt, rt);
 			return (0);
+		}
 		goto assign;
 	case SHLASS:
 		goto assign;
 	case SHRASS:
 		if (pflag && !isutyp(lt) && !(tflag && isutyp(rt))) {
 			/* bitwise operation on s.v. possibly nonportable */
 			warning(117);
+		}
 		goto assign;
 	case ANDASS:
 	case XORASS:
 	case ORASS:
 		goto assign;
 	assign:
 		if (!ln->tn_lvalue) {
 			if (ln->tn_op == CVT && ln->tn_cast &&
 			    ln->tn_left->tn_op == LOAD) {
 				/* a cast to non-ptr does not yield an lvalue */
 				if (ln->tn_type->t_tspec == PTR)
 					break;
 				error(163);
+			}
 			/* %soperand of %s must be lvalue */
 			error(114, "left ", mp->m_name);
 			return (0);
 		} else if (ltp->t_const || ((lt == STRUCT || lt == UNION) &&
 					    conmemb(ltp))) {
 			/* %soperand of %s must be modifiable lvalue */
 			if (!tflag)
 				warning(115, "left ", mp->m_name);
+		}
 		break;
 	case COMMA:
 		if (!modtab[ln->tn_op].m_sideeff)
 @@ -2175,1864 +2175,1865 @@ illptrc(mod_t *mp, type_t *ltp, type_t *
 		} else {
 			/* illegal pointer combination, op %s */
 			warning(124, mp->m_name);
+		}
+	}
+}
 /*
  * Make sure type (*tpp)->t_subt has at least the qualifiers
  * of tp1->t_subt and tp2->t_subt.
  */
 static void
 mrgqual(type_t **tpp, type_t *tp1, type_t *tp2)
+{
 	if ((*tpp)->t_tspec != PTR ||
 	    tp1->t_tspec != PTR || tp2->t_tspec != PTR) {
 		LERROR("mrgqual()");
+	}
 	if ((*tpp)->t_subt->t_const ==
 	    (tp1->t_subt->t_const | tp2->t_subt->t_const) &&
 	    (*tpp)->t_subt->t_volatile ==
 	    (tp1->t_subt->t_volatile | tp2->t_subt->t_volatile)) {
 		return;
+	}
 	*tpp = tduptyp(*tpp);
 	(*tpp)->t_subt = tduptyp((*tpp)->t_subt);
 	(*tpp)->t_subt->t_const =
 		tp1->t_subt->t_const | tp2->t_subt->t_const;
 	(*tpp)->t_subt->t_volatile =
 		tp1->t_subt->t_volatile | tp2->t_subt->t_volatile;
+}
 /*
  * Returns 1 if the given structure or union has a constant member
  * (maybe recursively).
  */
 static int
 conmemb(type_t *tp)
+{
 	sym_t	*m;
 	tspec_t	t;
 	if ((t = tp->t_tspec) != STRUCT && t != UNION)
 		LERROR("conmemb()");
 	for (m = tp->t_str->memb; m != NULL; m = m->s_nxt) {
 		tp = m->s_type;
 		if (tp->t_const)
 			return (1);
 		if ((t = tp->t_tspec) == STRUCT || t == UNION) {
 			if (conmemb(m->s_type))
 				return (1);
+		}
+	}
 	return (0);
+}
 /*
  * Create a new node for one of the operators POINT and ARROW.
  */
 static tnode_t *
 bldstr(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	tnode_t	*ntn, *ctn;
 	int	nolval;
 	if (rn->tn_op != NAME)
 		LERROR("bldstr()");
 	if (rn->tn_sym->s_value.v_tspec != INT)
 		LERROR("bldstr()");
 	if (rn->tn_sym->s_scl != MOS && rn->tn_sym->s_scl != MOU)
 		LERROR("bldstr()");
 	/*
 	 * Remember if the left operand is an lvalue (structure members
 	 * are lvalues if and only if the structure itself is an lvalue).
 	 */
 	nolval = op == POINT && !ln->tn_lvalue;
 	if (op == POINT) {
 		ln = bldamper(ln, 1);
 	} else if (ln->tn_type->t_tspec != PTR) {
 		if (!tflag || !isityp(ln->tn_type->t_tspec))
 			LERROR("bldstr()");
 		ln = convert(NOOP, 0, tincref(gettyp(VOID), PTR), ln);
+	}
 #if PTRDIFF_IS_LONG
 	ctn = getinode(LONG, rn->tn_sym->s_value.v_quad / CHAR_BIT);
 #else
 	ctn = getinode(INT, rn->tn_sym->s_value.v_quad / CHAR_BIT);
 #endif
 	ntn = mktnode(PLUS, tincref(rn->tn_type, PTR), ln, ctn);
 	if (ln->tn_op == CON)
 		ntn = fold(ntn);
 	if (rn->tn_type->t_isfield) {
 		ntn = mktnode(FSEL, ntn->tn_type->t_subt, ntn, NULL);
 	} else {
 		ntn = mktnode(STAR, ntn->tn_type->t_subt, ntn, NULL);
+	}
 	if (nolval)
 		ntn->tn_lvalue = 0;
 	return (ntn);
+}
 /*
  * Create a node for INCAFT, INCBEF, DECAFT and DECBEF.
  */
 static tnode_t *
 bldincdec(op_t op, tnode_t *ln)
+{
 	tnode_t	*cn, *ntn;
 	if (ln == NULL)
 		LERROR("bldincdec()");
 	if (ln->tn_type->t_tspec == PTR) {
 		cn = plength(ln->tn_type);
 	} else {
 		cn = getinode(INT, (int64_t)1);
+	}
 	ntn = mktnode(op, ln->tn_type, ln, cn);
 	return (ntn);
+}
 /*
  * Create a node for REAL, IMAG
  */
 static tnode_t *
 bldri(op_t op, tnode_t *ln)
+{
 	tnode_t	*cn, *ntn;
 	char buf[64];
 	if (ln == NULL)
 		LERROR("bldincdec()");
 	switch (ln->tn_type->t_tspec) {
 	case LCOMPLEX:
 		cn = getinode(LDOUBLE, (int64_t)1);
 		break;
 	case DCOMPLEX:
 		cn = getinode(DOUBLE, (int64_t)1);
 		break;
 	case FCOMPLEX:
 		cn = getinode(FLOAT, (int64_t)1);
 		break;
 	default:
 		error(276, op == REAL ? "real" : "imag",
 		    tyname(buf, sizeof(buf), ln->tn_type));
 		return NULL;
+	}
 	ntn = mktnode(op, cn->tn_type, ln, cn);
 	ntn->tn_lvalue = 1;
 	return (ntn);
+}
 /*
  * Create a tree node for the & operator
  */
 static tnode_t *
 bldamper(tnode_t *tn, int noign)
+{
 	tnode_t	*ntn;
 	tspec_t	t;
 	if (!noign && ((t = tn->tn_type->t_tspec) == ARRAY || t == FUNC)) {
 		/* & before array or function: ignored */
 		if (tflag)
 			warning(127);
 		return (tn);
+	}
 	/* eliminate &* */
 	if (tn->tn_op == STAR &&
 	    tn->tn_left->tn_type->t_tspec == PTR &&
 	    tn->tn_left->tn_type->t_subt == tn->tn_type) {
 		return (tn->tn_left);
+	}
 	ntn = mktnode(AMPER, tincref(tn->tn_type, PTR), tn, NULL);
 	return (ntn);
+}
 /*
  * Create a node for operators PLUS and MINUS.
  */
 static tnode_t *
 bldplmi(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	tnode_t	*ntn, *ctn;
 	type_t	*tp;
 	/* If pointer and integer, then pointer to the lhs. */
 	if (rn->tn_type->t_tspec == PTR && isityp(ln->tn_type->t_tspec)) {
 		ntn = ln;
 		ln = rn;
 		rn = ntn;
+	}
 	if (ln->tn_type->t_tspec == PTR && rn->tn_type->t_tspec != PTR) {
 		if (!isityp(rn->tn_type->t_tspec))
 			LERROR("bldplmi()");
 		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 = mktnode(MULT, rn->tn_type, rn, ctn);
 		if (rn->tn_left->tn_op == CON)
 			rn = fold(rn);
 		ntn = mktnode(op, ln->tn_type, ln, rn);
 	} else if (rn->tn_type->t_tspec == PTR) {
 		if (ln->tn_type->t_tspec != PTR || op != MINUS)
 			LERROR("bldplmi()");
 #if PTRDIFF_IS_LONG
 		tp = gettyp(LONG);
 #else
 		tp = gettyp(INT);
 #endif
 		ntn = mktnode(op, tp, ln, rn);
 		if (ln->tn_op == CON && rn->tn_op == CON)
 			ntn = fold(ntn);
 		ctn = plength(ln->tn_type);
 		balance(NOOP, &ntn, &ctn);
 		ntn = mktnode(DIV, tp, ntn, ctn);
 	} else {
 		ntn = mktnode(op, ln->tn_type, ln, rn);
+	}
 	return (ntn);
+}
 /*
  * Create a node for operators SHL and SHR.
  */
 static tnode_t *
 bldshft(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	tspec_t	t;
 	tnode_t	*ntn;
 	if ((t = rn->tn_type->t_tspec) != INT && t != UINT)
 		rn = convert(CVT, 0, gettyp(INT), rn);
 	ntn = mktnode(op, ln->tn_type, ln, rn);
 	return (ntn);
+}
 /*
  * Create a node for COLON.
  */
 static tnode_t *
 bldcol(tnode_t *ln, tnode_t *rn)
+{
 	tspec_t	lt, rt, pdt;
 	type_t	*rtp;
 	tnode_t	*ntn;
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 #if PTRDIFF_IS_LONG
 	pdt = LONG;
 #else
 	pdt = INT;
 #endif
 	/*
 	 * Arithmetic types are balanced, all other type combinations
 	 * still need to be handled.
 	 */
 	if (isatyp(lt) && isatyp(rt)) {
 		rtp = ln->tn_type;
 	} else if (lt == VOID || rt == VOID) {
 		rtp = gettyp(VOID);
 	} else if (lt == STRUCT || lt == UNION) {
 		/* Both types must be identical. */
 		if (rt != STRUCT && rt != UNION)
 			LERROR("bldcol()");
 		if (ln->tn_type->t_str != rn->tn_type->t_str)
 			LERROR("bldcol()");
 		if (incompl(ln->tn_type)) {
 			/* unknown operand size, op %s */
 			error(138, modtab[COLON].m_name);
 			return (NULL);
+		}
 		rtp = ln->tn_type;
 	} else if (lt == PTR && isityp(rt)) {
 		if (rt != pdt) {
 			rn = convert(NOOP, 0, gettyp(pdt), rn);
 			rt = pdt;
+		}
 		rtp = ln->tn_type;
 	} else if (rt == PTR && isityp(lt)) {
 		if (lt != pdt) {
 			ln = convert(NOOP, 0, gettyp(pdt), ln);
 			lt = pdt;
+		}
 		rtp = rn->tn_type;
 	} else if (lt == PTR && ln->tn_type->t_subt->t_tspec == VOID) {
 		if (rt != PTR)
 			LERROR("bldcol()");
 		rtp = ln->tn_type;
 		mrgqual(&rtp, ln->tn_type, rn->tn_type);
 	} else if (rt == PTR && rn->tn_type->t_subt->t_tspec == VOID) {
 		if (lt != PTR)
 			LERROR("bldcol()");
 		rtp = rn->tn_type;
 		mrgqual(&rtp, ln->tn_type, rn->tn_type);
 	} else {
 		if (lt != PTR || rt != PTR)
 			LERROR("bldcol()");
 		/*
 		 * XXX For now we simply take the left type. This is
 		 * probably wrong, if one type contains a functionprototype
 		 * and the other one, at the same place, only an old style
 		 * declaration.
 		 */
 		rtp = ln->tn_type;
 		mrgqual(&rtp, ln->tn_type, rn->tn_type);
+	}
 	ntn = mktnode(COLON, rtp, ln, rn);
 	return (ntn);
+}
 /*
  * Create a node for an assignment operator (both = and op= ).
  */
 static tnode_t *
 bldasgn(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	tspec_t	lt, rt;
 	tnode_t	*ntn, *ctn;
 	if (ln == NULL || rn == NULL)
 		LERROR("bldasgn()");
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	if ((op == ADDASS || op == SUBASS) && lt == PTR) {
 		if (!isityp(rt))
 			LERROR("bldasgn()");
 		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 = mktnode(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)) {
 		if (rt != lt || ln->tn_type->t_str != rn->tn_type->t_str)
 			LERROR("bldasgn()");
 		if (incompl(ln->tn_type)) {
 			if (op == RETURN) {
 				/* cannot return incomplete type */
 				error(212);
 			} else {
 				/* unknown operand size, op %s */
 				error(138, modtab[op].m_name);
+			}
 			return (NULL);
+		}
+	}
 	if (op == SHLASS) {
 		if (psize(lt) < psize(rt)) {
 			if (hflag)
 				/* semantics of %s change in ANSI C; use ... */
 				warning(118, "<<=");
+		}
 	} else if (op != SHRASS) {
 		if (op == ASSIGN || lt != PTR) {
 			if (lt != rt ||
 			    (ln->tn_type->t_isfield && rn->tn_op == CON)) {
 				rn = convert(op, 0, ln->tn_type, rn);
 				rt = lt;
+			}
+		}
+	}
 	ntn = mktnode(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;
 	tspec_t	st;
 	if (tp->t_tspec != PTR)
 		LERROR("plength()");
 	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 ... */
 		(void)gnuism(136);
 		break;
 	case STRUCT:
 	case UNION:
 		if ((elsz = tp->t_str->size) == 0)
 			/* cannot do pointer arithmetic on operand of ... */
 			error(136);
 		break;
 	case ENUM:
 		if (incompl(tp)) {
 			/* cannot do pointer arithmetic on operand of ... */
 			warning(136);
+		}
 		/* FALLTHROUGH */
 	default:
 		if ((elsz = size(tp->t_tspec)) == 0) {
 			/* cannot do pointer arithmetic on operand of ... */
 			error(136);
 		} else if (elsz == -1) {
 			LERROR("plength()");
+		}
 		break;
+	}
 	if (elem == 0 && elsz != 0) {
 		/* cannot do pointer arithmetic on operand of ... */
 		error(136);
+	}
 	if (elsz == 0)
 		elsz = CHAR_BIT;
 #if PTRDIFF_IS_LONG
 	st = LONG;
 #else
 	st = INT;
 #endif
 	return (getinode(st, (int64_t)(elem * elsz / CHAR_BIT)));
+}
 /*
  * 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 (both) operands
  * are constants.
  */
 static tnode_t *
 fold(tnode_t *tn)
+{
 	val_t	*v;
 	tspec_t	t;
 	int	utyp, ovfl;
 	int64_t	sl, sr = 0, q = 0, mask;
 	uint64_t ul, ur = 0;
 	tnode_t	*cn;
 	v = xcalloc(1, sizeof (val_t));
 	v->v_tspec = t = tn->tn_type->t_tspec;
 	utyp = t == PTR || isutyp(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 = qlmasks[size(t)];
 	ovfl = 0;
 	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 = 1;
 		break;
 	case COMPL:
 		q = ~sl;
 		break;
 	case MULT:
 		if (utyp) {
 			q = ul * ur;
 			if (q != (q & mask))
 				ovfl = 1;
 			else if ((ul != 0) && ((q / ul) != ur))
 				ovfl = 1;
 		} else {
 			q = sl * sr;
 			if (msb(q, t, -1) != (msb(sl, t, -1) ^ msb(sr, t, -1)))
 				ovfl = 1;
+		}
 		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 = 1;
 		} else if (msb(sl, t, -1) == 0 && msb(sr, t, -1) == 0) {
 			if (msb(q, t, -1) != 0)
 				ovfl = 1;
+		}
 		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 = 1;
 		} else if (msb(sl, t, -1) == 0 && msb(sr, t, -1) != 0) {
 			if (msb(q, t, -1) != 0)
 				ovfl = 1;
+		}
 		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 = xsign(q, t, size(t) - (int)sr);
 		break;
 	case LT:
 		q = utyp ? ul < ur : sl < sr;
 		break;
 	case LE:
 		q = utyp ? ul <= ur : sl <= sr;
 		break;
 	case GE:
 		q = utyp ? ul >= ur : sl >= sr;
 		break;
 	case GT:
 		q = utyp ? ul > ur : sl > sr;
 		break;
 	case EQ:
 		q = utyp ? ul == ur : sl == sr;
 		break;
 	case NE:
 		q = utyp ? ul != ur : sl != sr;
 		break;
 	case AND:
 		q = utyp ? (int64_t)(ul & ur) : sl & sr;
 		break;
 	case XOR:
 		q = utyp ? (int64_t)(ul ^ ur) : sl ^ sr;
 		break;
 	case OR:
 		q = utyp ? (int64_t)(ul | ur) : sl | sr;
 		break;
 	default:
 		LERROR("fold()");
+	}
 	/* XXX does not work for quads. */
 	if (ovfl || ((uint64_t)(q | mask) != ~(uint64_t)0 &&
 	    (q & ~mask) != 0)) {
 		if (hflag)
 			/* integer overflow detected, op %s */
 			warning(141, modtab[tn->tn_op].m_name);
+	}
 	v->v_quad = xsign(q, t, -1);
 	cn = getcnode(tn->tn_type, v);
 	return (cn);
+}
 /*
  * Same for operators whose operands are compared with 0 (test context).
  */
 static tnode_t *
 foldtst(tnode_t *tn)
+{
 	int	l, r = 0;
 	val_t	*v;
 	v = xcalloc(1, sizeof (val_t));
 	v->v_tspec = tn->tn_type->t_tspec;
 	if (tn->tn_type->t_tspec != INT)
 		LERROR("foldtst()");
 	if (isftyp(tn->tn_left->tn_type->t_tspec)) {
 		l = tn->tn_left->tn_val->v_ldbl != 0.0;
 	} else {
 		l = tn->tn_left->tn_val->v_quad != 0;
+	}
 	if (modtab[tn->tn_op].m_binary) {
 		if (isftyp(tn->tn_right->tn_type->t_tspec)) {
 			r = tn->tn_right->tn_val->v_ldbl != 0.0;
 		} else {
 			r = tn->tn_right->tn_val->v_quad != 0;
+		}
+	}
 	switch (tn->tn_op) {
 	case NOT:
 		if (hflag && !ccflg)
 			/* constant argument to NOT */
 			warning(239);
 		v->v_quad = !l;
 		break;
 	case LOGAND:
 		v->v_quad = l && r;
 		break;
 	case LOGOR:
 		v->v_quad = l || r;
 		break;
 	default:
 		LERROR("foldtst()");
+	}
 	return (getcnode(tn->tn_type, v));
+}
 /*
  * Same for operands with floating point type.
  */
 static tnode_t *
 foldflt(tnode_t *tn)
+{
 	val_t	*v;
 	tspec_t	t;
 	ldbl_t	l, r = 0;
 	fpe = 0;
 	v = xcalloc(1, sizeof (val_t));
 	v->v_tspec = t = tn->tn_type->t_tspec;
 	if (!isftyp(t))
 		LERROR("foldflt()");
 	if (t != tn->tn_left->tn_type->t_tspec)
 		LERROR("foldflt()");
 	if (modtab[tn->tn_op].m_binary && t != tn->tn_right->tn_type->t_tspec)
 		LERROR("foldflt()");
 	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;
 		break;
 	case LE:
 		v->v_quad = l <= r;
 		break;
 	case GE:
 		v->v_quad = l >= r;
 		break;
 	case GT:
 		v->v_quad = l > r;
 		break;
 	case EQ:
 		v->v_quad = l == r;
 		break;
 	case NE:
 		v->v_quad = l != r;
 		break;
 	default:
 		LERROR("foldflt()");
+	}
 	if (!fpe && isnan((double)v->v_ldbl))
 		LERROR("foldflt()");
 	if (fpe || !finite((double)v->v_ldbl) ||
 	    (t == FLOAT &&
 	     (v->v_ldbl > FLT_MAX || v->v_ldbl < -FLT_MAX)) ||
 	    (t == DOUBLE &&
 	     (v->v_ldbl > DBL_MAX || v->v_ldbl < -DBL_MAX))) {
 		/* floating point overflow detected, op %s */
 		warning(142, modtab[tn->tn_op].m_name);
 		if (t == FLOAT) {
 			v->v_ldbl = v->v_ldbl < 0 ? -FLT_MAX : FLT_MAX;
 		} else if (t == DOUBLE) {
 			v->v_ldbl = v->v_ldbl < 0 ? -DBL_MAX : DBL_MAX;
 		} else {
 			v->v_ldbl = v->v_ldbl < 0 ? -LDBL_MAX: LDBL_MAX;
+		}
 	    fpe = 0;
+	}
 	return (getcnode(tn->tn_type, v));
+}
 /*
  * Create a constant node for sizeof.
  */
 tnode_t *
 bldszof(type_t *tp)
+{
 	tspec_t	st;
 #if SIZEOF_IS_ULONG
 	st = ULONG;
 #else
 	st = UINT;
 #endif
 	return getinode(st, tsize(tp) / CHAR_BIT);
+}
 int64_t
 tsize(type_t *tp)
+{
 	int	elem, elsz;
 	elem = 1;
 	while (tp->t_tspec == ARRAY) {
 		elem *= tp->t_dim;
 		tp = tp->t_subt;
+	}
 	if (elem == 0) {
 		/* cannot take size of incomplete type */
 		error(143);
 		elem = 1;
+	}
 	switch (tp->t_tspec) {
 	case FUNC:
 		/* cannot take size of function */
 		error(144);
 		elsz = 1;
 		break;
 	case STRUCT:
 	case UNION:
 		if (incompl(tp)) {
 			/* cannot take size of incomplete type */
 			error(143);
 			elsz = 1;
 		} else {
 			elsz = tp->t_str->size;
+		}
 		break;
 	case ENUM:
 		if (incompl(tp)) {
 			/* cannot take size of incomplete type */
 			warning(143);
+		}
 		/* FALLTHROUGH */
 	default:
 		if (tp->t_isfield) {
 			/* cannot take size of bit-field */
 			error(145);
+		}
 		if (tp->t_tspec == VOID) {
 			/* cannot take size of void */
 			error(146);
 			elsz = 1;
 		} else {
 			elsz = size(tp->t_tspec);
 			if (elsz <= 0)
 				LERROR("bldszof()");
+		}
 		break;
+	}
 	return (int64_t)(elem * elsz);
+}
 /*
  */
 tnode_t *
 bldalof(type_t *tp)
+{
 	tspec_t	st;
 	switch (tp->t_tspec) {
 	case ARRAY:
 		break;
 	case FUNC:
 		/* cannot take align of function */
 		error(144);
 		return 0;
 	case STRUCT:
 	case UNION:
 		if (incompl(tp)) {
 			/* cannot take align of incomplete type */
 			error(143);
 			return 0;
+		}
 		break;
 	case ENUM:
 		break;
 	default:
 		if (tp->t_isfield) {
 			/* cannot take align of bit-field */
 			error(145);
 			return 0;
+		}
 		if (tp->t_tspec == VOID) {
 			/* cannot take alignsize of void */
 			error(146);
 			return 0;
+		}
 		break;
+	}
 #if SIZEOF_IS_ULONG
 	st = ULONG;
 #else
 	st = UINT;
 #endif
 	return getinode(st, (int64_t)getbound(tp));
+}
 /*
  * Type casts.
  */
 tnode_t *
 cast(tnode_t *tn, type_t *tp)
+{
 	tspec_t	nt, ot;
 	if (tn == 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 seams really questionable.
 		 */
 	} else if (nt == STRUCT || nt == UNION || 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 (isityp(nt) && issclt(ot)) {
 		/* ok */
 	} else if (isftyp(nt) && isatyp(ot)) {
 		/* ok */
 	} else if (nt == PTR && isityp(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 ... */
 				warning(275);
+		}
 	} else {
 		/* invalid cast expression */
 		error(147);
 		return (NULL);
+	}
 	tn = convert(CVT, 0, tp, tn);
 	tn->tn_cast = 1;
 	return (tn);
+}
 /*
  * Create the node for a function argument.
  * All necessary conversions and type checks are done in funccall(), because
  * in funcarg() we have no information about expected argument types.
  */
 tnode_t *
 funcarg(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 = getinode(INT, (int64_t)0);
 	ntn = mktnode(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 *
 funccall(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;
+	}
 	/*
 	 * 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) {
 		char buf[256];
 		/* illegal function */
-		error(149);
+		error(149, tyname(buf, sizeof(buf), func->tn_type));
 		return (NULL);
+	}
 	args = chkfarg(func->tn_type->t_subt, args);
 	ntn = mktnode(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 *
 chkfarg(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_nxt)
 		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 allowd */
 		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) &&
 			   incompl(arg->tn_left->tn_type)) {
 			/* argument cannot have unknown size, arg #%d */
 			error(152, n);
 			return (NULL);
 		} else if (isityp(at) && arg->tn_left->tn_type->t_isenum &&
 			   incompl(arg->tn_left->tn_type)) {
 			/* argument cannot have unknown size, arg #%d */
 			warning(152, n);
+		}
 		/* class conversions (arg in value context) */
 		arg->tn_left = cconv(arg->tn_left);
 		if (asym != NULL) {
 			arg->tn_left = parg(n, asym->s_type, arg->tn_left);
 		} else {
 			arg->tn_left = promote(NOOP, 1, arg->tn_left);
+		}
 		arg->tn_type = arg->tn_left->tn_type;
 		if (asym != NULL)
 			asym = asym->s_nxt;
+	}
 	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 *
 parg(	int	n,		/* pos of arg */
 	type_t	*tp,		/* expected type (from prototype) */
 	tnode_t	*tn)		/* argument */
+{
 	tnode_t	*ln;
 	int	dowarn;
 	ln = xcalloc(1, sizeof (tnode_t));
 	ln->tn_type = tduptyp(tp);
 	ln->tn_type->t_const = 0;
 	ln->tn_lvalue = 1;
 	if (typeok(FARG, n, ln, tn)) {
 		if (!eqtype(tp, tn->tn_type, 1, 0, (dowarn = 0, &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, int required)
+{
 	val_t	*v;
 	if (tn != NULL)
 		tn = cconv(tn);
 	if (tn != NULL)
 		tn = promote(NOOP, 0, tn);
 	v = xcalloc(1, sizeof (val_t));
 	if (tn == NULL) {
 		if (nerr == 0)
 			LERROR("constant()");
 		v->v_tspec = INT;
 		v->v_quad = 1;
 		return (v);
+	}
 	v->v_tspec = tn->tn_type->t_tspec;
 	if (tn->tn_op == CON) {
 		if (tn->tn_type->t_tspec != tn->tn_val->v_tspec)
 			LERROR("constant()");
 		if (isityp(tn->tn_val->v_tspec)) {
 			v->v_ansiu = tn->tn_val->v_ansiu;
 			v->v_quad = tn->tn_val->v_quad;
 			return (v);
+		}
 		v->v_quad = tn->tn_val->v_ldbl;
 	} else {
 		v->v_quad = 1;
+	}
 	/* integral constant expression expected */
 	if (required)
 		error(55);
 	else
 		c99ism(318);
 	if (!isityp(v->v_tspec))
 		v->v_tspec = INT;
 	return (v);
+}
 /*
  * 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, expr() frees the memory which is used
  * for the expression.
  */
 void
 expr(tnode_t *tn, int vctx, int tctx, int dofreeblk)
+{
 	if (tn == NULL && nerr == 0)
 		LERROR("expr()");
 	if (tn == NULL) {
 		tfreeblk();
 		return;
+	}
 	/* expr() is also called in global initialisations */
 	if (dcs->d_ctx != EXTERN)
 		chkreach();
 	chkmisc(tn, vctx, tctx, !tctx, 0, 0, 0);
 	if (tn->tn_op == ASSIGN) {
 		if (hflag && tctx)
 			/* assignment in conditional context */
 			warning(159);
 	} else if (tn->tn_op == CON) {
 		if (hflag && tctx && !ccflg)
 			/* constant in conditional context */
 			warning(161);
+	}
 	if (!modtab[tn->tn_op].m_sideeff) {
 		/*
 		 * for left operands of COMMA this warning is already
 		 * printed
 		 */
 		if (tn->tn_op != COMMA && !vctx && !tctx)
 			nulleff(tn);
+	}
 	if (dflag)
 		displexpr(tn, 0);
 	/* free the tree memory */
 	if (dofreeblk)
 		tfreeblk();
+}
 static void
 nulleff(tnode_t *tn)
+{
 	if (!hflag)
 		return;
 	while (!modtab[tn->tn_op].m_sideeff) {
 		if (tn->tn_op == CVT && tn->tn_type->t_tspec == VOID) {
 			tn = tn->tn_left;
 		} else if (tn->tn_op == LOGAND || tn->tn_op == LOGOR) {
 			/*
 			 * && and || have a side effect if the right operand
 			 * has a side effect.
 			 */
 			tn = tn->tn_right;
 		} else if (tn->tn_op == QUEST) {
 			/*
 			 * ? has a side effect if at least one of its right
 			 * operands has a side effect
 			 */
 			tn = tn->tn_right;
 		} else if (tn->tn_op == COLON || tn->tn_op == COMMA) {
 			/*
 			 * : has a side effect if at least one of its operands
 			 * has a side effect
 			 */
 			if (modtab[tn->tn_left->tn_op].m_sideeff) {
 				tn = tn->tn_left;
 			} else if (modtab[tn->tn_right->tn_op].m_sideeff) {
 				tn = tn->tn_right;
 			} else {
 				break;
+			}
 		} else {
 			break;
+		}
+	}
 	if (!modtab[tn->tn_op].m_sideeff)
 		/* expression has null effect */
 		warning(129);
+}
 /*
  * Dump an expression to stdout
  * only used for debugging
  */
 static void
 displexpr(tnode_t *tn, int offs)
+{
 	uint64_t uq;
 	if (tn == NULL) {
 		(void)printf("%*s%s\n", offs, "", "NULL");
 		return;
+	}
 	(void)printf("%*sop %s  ", offs, "", modtab[tn->tn_op].m_name);
 	if (tn->tn_op == NAME) {
 		(void)printf("%s: %s ",
 			     tn->tn_sym->s_name, scltoa(tn->tn_sym->s_scl));
 	} else if (tn->tn_op == CON && isftyp(tn->tn_type->t_tspec)) {
 		(void)printf("%#g ", (double)tn->tn_val->v_ldbl);
 	} else if (tn->tn_op == CON && isityp(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) {
 		if (tn->tn_type->t_tspec != PTR)
 			LERROR("displexpr()");
 		(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_strg->st_tspec == CHAR) {
 			(void)printf("\"%s\"", tn->tn_strg->st_cp);
 		} else {
 			char	*s;
 			size_t	n;
 			n = MB_CUR_MAX * (tn->tn_strg->st_len + 1);
 			s = xmalloc(n);
 			(void)wcstombs(s, tn->tn_strg->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));
 	if (tn->tn_op == NAME || tn->tn_op == CON || tn->tn_op == STRING)
 		return;
 	displexpr(tn->tn_left, offs + 2);
 	if (modtab[tn->tn_op].m_binary ||
 	    (tn->tn_op == PUSH && tn->tn_right != NULL)) {
 		displexpr(tn->tn_right, offs + 2);
+	}
+}
 /*
  * Called by expr() to recursively perform some tests.
  */
 /* ARGSUSED */
 void
 chkmisc(tnode_t *tn, int vctx, int tctx, int eqwarn, int fcall, int rvdisc,
 	int szof)
+{
 	tnode_t	*ln, *rn;
 	mod_t	*mp;
 	int	nrvdisc, cvctx, ctctx;
 	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 AMPER:
 		if (ln->tn_op == NAME && (reached || rchflg)) {
 			if (!szof)
 				setsflg(ln->tn_sym);
 			setuflg(ln->tn_sym, fcall, szof);
+		}
 		if (ln->tn_op == STAR && ln->tn_left->tn_op == PLUS)
 			/* check the range of array indices */
 			chkaidx(ln->tn_left, 1);
 		break;
 	case LOAD:
 		if (ln->tn_op == STAR && ln->tn_left->tn_op == PLUS)
 			/* check the range of array indices */
 			chkaidx(ln->tn_left, 0);
 		/* 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:
 		if (ln->tn_op == NAME && (reached || rchflg)) {
 			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_nxt) {
 				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);
 				setsflg(ln->tn_sym);
+			}
 			setuflg(ln->tn_sym, 0, 0);
+		}
 		break;
 	case ASSIGN:
 		if (ln->tn_op == NAME && !szof && (reached || rchflg)) {
 			setsflg(ln->tn_sym);
 			if (ln->tn_sym->s_scl == EXTERN)
 				outusg(ln->tn_sym);
+		}
 		if (ln->tn_op == STAR && ln->tn_left->tn_op == PLUS)
 			/* check the range of array indices */
 			chkaidx(ln->tn_left, 0);
 		break;
 	case CALL:
 		if (ln->tn_op != AMPER || ln->tn_left->tn_op != NAME)
 			LERROR("chkmisc()");
 		if (!szof)
 			outcall(tn, vctx || tctx, rvdisc);
 		break;
 	case EQ:
 		/* equality operator "==" found where "=" was exp. */
 		if (hflag && eqwarn)
 			warning(160);
 		break;
 	case CON:
 	case NAME:
 	case STRING:
 		return;
 		/* LINTED206: (enumeration values not handled in switch) */
 	case OR:
 	case XOR:
 	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 STAR:
 	case UMINUS:
 	case UPLUS:
 	case DEC:
 	case INC:
 	case COMPL:
 	case NOT:
 	case POINT:
 	case ARROW:
 	case NOOP:
 	case AND:
 	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;
+	}
 	cvctx = mp->m_vctx;
 	ctctx = mp->m_tctx;
 	/*
 	 * 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 = 0;
 	nrvdisc = op == CVT && tn->tn_type->t_tspec == VOID;
 	chkmisc(ln, cvctx, ctctx, mp->m_eqwarn, op == CALL, nrvdisc, szof);
 	switch (op) {
 	case PUSH:
 		if (rn != NULL)
 			chkmisc(rn, 0, 0, mp->m_eqwarn, 0, 0, szof);
 		break;
 	case LOGAND:
 	case LOGOR:
 		chkmisc(rn, 0, 1, mp->m_eqwarn, 0, 0, szof);
 		break;
 	case COLON:
 		chkmisc(rn, cvctx, ctctx, mp->m_eqwarn, 0, 0, szof);
 		break;
 	case COMMA:
 		chkmisc(rn, vctx, tctx, mp->m_eqwarn, 0, 0, szof);
 		break;
 	default:
 		if (mp->m_binary)
 			chkmisc(rn, 1, 0, mp->m_eqwarn, 0, 0, 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 allowd to refere to the first element
  * after the array.
  */
 static void
 chkaidx(tnode_t *tn, int 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 != AMPER)
 		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 (incompl(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_BIT;
 	/* Change the unit of the index from bytes to element size. */
 	if (isutyp(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 (!isutyp(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
 chkcomp(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	char buf[64];
 	tspec_t	lt, rt;
 	mod_t	*mp;
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	mp = &modtab[op];
 	if (ln->tn_op != CON && rn->tn_op != CON)
 		return;
 	if (!isityp(lt) || !isityp(rt))
 		return;
 	if ((hflag || pflag) && lt == CHAR && rn->tn_op == CON &&
 	    (rn->tn_val->v_quad < 0 ||
 	     rn->tn_val->v_quad > ~(~0 << (CHAR_BIT - 1)))) {
 		/* nonportable character comparison, op %s */
 		warning(230, mp->m_name);
 		return;
+	}
 	if ((hflag || pflag) && rt == CHAR && ln->tn_op == CON &&
 	    (ln->tn_val->v_quad < 0 ||
 	     ln->tn_val->v_quad > ~(~0 << (CHAR_BIT - 1)))) {
 		/* nonportable character comparison, op %s */
 		warning(230, mp->m_name);
 		return;
+	}
 	if (isutyp(lt) && !isutyp(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, tyname(buf, sizeof(buf), ln->tn_type),
 			    "negative constant", mp->m_name);
 		} else if (op == LT || op == GE || (hflag && op == LE)) {
 			/* comparison of %s with %s, op %s */
 			warning(162, tyname(buf, sizeof(buf), ln->tn_type),
 			    "0", mp->m_name);
+		}
 		return;
+	}
 	if (isutyp(rt) && !isutyp(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",
 			    tyname(buf, sizeof(buf), rn->tn_type), mp->m_name);
 		} else if (op == GT || op == LE || (hflag && op == GE)) {
 			/* comparison of %s with %s, op %s */
 			warning(162, "0", tyname(buf, sizeof(buf), rn->tn_type),
 			    mp->m_name);
+		}
 		return;
+	}
+}
 /*
  * Takes an expression an returns 0 if this expression can be used
  * for static initialisation, otherwise -1.
+ *
  * Constant initialisation 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, AMPER, NAME, STRING and
  * CON. Type conversions are allowed if they do not change binary
  * representation (including width).
  */
 int
 conaddr(tnode_t *tn, sym_t **symp, ptrdiff_t *offsp)
+{
 	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 conaddr(tn->tn_right, symp, offsp);
 		else if (tn->tn_right->tn_op != CON)
 			return (-1);
 		/* FALLTHROUGH */
 	case PLUS:
 		offs1 = offs2 = 0;
 		if (tn->tn_left->tn_op == CON) {
 			offs1 = (ptrdiff_t)tn->tn_left->tn_val->v_quad;
 			if (conaddr(tn->tn_right, &sym, &offs2) == -1)
 				return (-1);
 		} 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 (conaddr(tn->tn_left, &sym, &offs1) == -1)
 				return (-1);
 		} else {
 			return (-1);
+		}
 		*symp = sym;
 		*offsp = offs1 + offs2;
 		break;
 	case AMPER:
 		if (tn->tn_left->tn_op == NAME) {
 			*symp = tn->tn_left->tn_sym;
 			*offsp = 0;
 		} else if (tn->tn_left->tn_op == STRING) {
 			/*
 			 * If this would be the front end of a compiler we
 			 * would return a label instead of 0.
 			 */
 			*offsp = 0;
+		}
 		break;
 	case CVT:
 		t = tn->tn_type->t_tspec;
 		ot = tn->tn_left->tn_type->t_tspec;
 		if ((!isityp(t) && t != PTR) || (!isityp(ot) && ot != PTR))
 			return (-1);
 #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
 		if (conaddr(tn->tn_left, symp, offsp) == -1)
 			return (-1);
 		break;
 	default:
 		return (-1);
+	}
 	return (0);
+}
 /*
  * Concatenate two string constants.
  */
 strg_t *
 catstrg(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 (/*CONSTCOND*/0)
 	if (strg1->st_tspec == CHAR)
 		COPY(st_cp);
 	else
 		COPY(st_wcp);
 	strg1->st_len = len - 1; /* - NUL */;
 	free(strg2);
 	return (strg1);
+}
 /*
  * 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
 precconf(tnode_t *tn)
+{
 	tnode_t	*ln, *rn;
 	op_t	lop, rop = NOOP;
 	int	lparn, rparn = 0;
 	mod_t	*mp;
 	int	dowarn;
 	if (!hflag)
 		return;
 	mp = &modtab[tn->tn_op];
 	lparn = 0;
 	for (ln = tn->tn_left; ln->tn_op == CVT; ln = ln->tn_left)
 		lparn |= ln->tn_parn;
 	lparn |= ln->tn_parn;
 	lop = ln->tn_op;
 	if (mp->m_binary) {
 		rparn = 0;
 		for (rn = tn->tn_right; tn->tn_op == CVT; rn = rn->tn_left)
 			rparn |= rn->tn_parn;
 		rparn |= rn->tn_parn;
 		rop = rn->tn_op;
+	}
 	dowarn = 0;
 	switch (tn->tn_op) {
 	case SHL:
 	case SHR:
 		if (!lparn && (lop == PLUS || lop == MINUS)) {
 			dowarn = 1;
 		} else if (!rparn && (rop == PLUS || rop == MINUS)) {
 			dowarn = 1;
+		}
 		break;
 	case LOGOR:
 		if (!lparn && lop == LOGAND) {
 			dowarn = 1;
 		} else if (!rparn && rop == LOGAND) {
 			dowarn = 1;
+		}
 		break;
 	case AND:
 	case XOR:
 	case OR:
 		if (!lparn && lop != tn->tn_op) {
 			if (lop == PLUS || lop == MINUS) {
 				dowarn = 1;
 			} else if (lop == AND || lop == XOR) {
 				dowarn = 1;
+			}
+		}
 		if (!dowarn && !rparn && rop != tn->tn_op) {
 			if (rop == PLUS || rop == MINUS) {
 				dowarn = 1;
 			} else if (rop == AND || rop == XOR) {
 				dowarn = 1;
+			}
+		}
 		break;
 		/* LINTED206: (enumeration values not handled in switch) */
 	case DECAFT:
 	case XORASS:
 	case SHLASS:
 	case NOOP:
 	case ARROW:
 	case ORASS:
 	case POINT:
 	case NAME:
 	case NOT:
 	case COMPL:
 	case CON:
 	case INC:
 	case STRING:
 	case DEC:
 	case INCBEF:
 	case DECBEF:
 	case INCAFT:
 	case FSEL:
 	case CALL:
 	case COMMA:
 	case CVT:
 	case ICALL:
 	case LOAD:
 	case PUSH:
 	case RETURN:
 	case INIT:
 	case CASE:
 	case FARG:
 	case SUBASS:
 	case ADDASS:
 	case MODASS:
 	case DIVASS:
 	case MULASS:
 	case ASSIGN:
 	case COLON:
 	case QUEST:
 	case LOGAND:
 	case NE:
 	case EQ:
 	case GE:
 	case GT:
 	case LE:
 	case LT:
 	case MINUS:
 	case PLUS:
 	case MOD:
 	case DIV:
 	case MULT:
 	case AMPER:
 	case STAR:
 	case UMINUS:
 	case SHRASS:
 	case UPLUS:
 	case ANDASS:
 	case REAL:
 	case IMAG:
 		break;
+	}
 	if (dowarn) {
 		/* precedence confusion possible: parenthesize! */
 		warning(169);
+	}
+}