	@@ -1,1992 +1,1983 @@		@@ -1,1992 +1,1983 @@
1	%{	1	%{
2	/* $NetBSD: cgram.y,v 1.327 2021/07/15 18:18:15 rillig Exp $ */	2	/* $NetBSD: cgram.y,v 1.328 2021/07/15 20:05:49 rillig 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.327 2021/07/15 18:18:15 rillig Exp $");	38	__RCSID("$NetBSD: cgram.y,v 1.328 2021/07/15 20:05:49 rillig Exp $");
39	#endif	39	#endif
40		40
41	#include <limits.h>	41	#include <limits.h>
42	#include <stdlib.h>	42	#include <stdlib.h>
43	#include <string.h>	43	#include <string.h>
44		44
45	#include "lint1.h"	45	#include "lint1.h"
46		46
47	extern char *yytext;	47	extern char *yytext;
48		48
49	/*	49	/*
50	* Contains the level of current declaration, used for symbol table entries.	50	* Contains the level of current declaration, used for symbol table entries.
51	* 0 is the top-level, > 0 is inside a function body.	51	* 0 is the top-level, > 0 is inside a function body.
52	*/	52	*/
53	int block_level;	53	int block_level;
54		54
55	/*	55	/*
56	* level for memory allocation. Normally the same as block_level.	56	* level for memory allocation. Normally the same as block_level.
57	* An exception is the declaration of arguments in prototypes. Memory	57	* An exception is the declaration of arguments in prototypes. Memory
58	* for these can't be freed after the declaration, but symbols must	58	* for these can't be freed after the declaration, but symbols must
59	* be removed from the symbol table after the declaration.	59	* be removed from the symbol table after the declaration.
60	*/	60	*/
61	int mem_block_level;	61	int mem_block_level;
62		62
63	/*	63	/*
64	* Save the no-warns state and restore it to avoid the problem where	64	* Save the no-warns state and restore it to avoid the problem where
65	* if (expr) { stmt } / * NOLINT * / stmt;	65	* if (expr) { stmt } / * NOLINT * / stmt;
66	*/	66	*/
67	static int olwarn = LWARN_BAD;	67	static int olwarn = LWARN_BAD;
68		68
69	static void cgram_declare(sym_t , bool, sbuf_t );	69	static void cgram_declare(sym_t , bool, sbuf_t );
70	static void ignore_up_to_rparen(void);	70	static void ignore_up_to_rparen(void);
71	static sym_t symbolrename(sym_t , sbuf_t *);	71	static sym_t symbolrename(sym_t , sbuf_t *);
72		72
73		73
74	#ifdef DEBUG	74	#ifdef DEBUG
75	static void	75	static void
76	CLEAR_WARN_FLAGS(const char *file, size_t line)	76	CLEAR_WARN_FLAGS(const char *file, size_t line)
77	{	77	{
78	printf("%s:%d: %s:%zu: clearing flags\n",	78	printf("%s:%d: %s:%zu: clearing flags\n",
79	curr_pos.p_file, curr_pos.p_line, file, line);	79	curr_pos.p_file, curr_pos.p_line, file, line);
80	clear_warn_flags();	80	clear_warn_flags();
81	olwarn = LWARN_BAD;	81	olwarn = LWARN_BAD;
82	}	82	}
83		83
84	static void	84	static void
85	SAVE_WARN_FLAGS(const char *file, size_t line)	85	SAVE_WARN_FLAGS(const char *file, size_t line)
86	{	86	{
87	lint_assert(olwarn == LWARN_BAD);	87	lint_assert(olwarn == LWARN_BAD);
88	printf("%s:%d: %s:%zu: saving flags %d\n",	88	printf("%s:%d: %s:%zu: saving flags %d\n",
89	curr_pos.p_file, curr_pos.p_line, file, line, lwarn);	89	curr_pos.p_file, curr_pos.p_line, file, line, lwarn);
90	olwarn = lwarn;	90	olwarn = lwarn;
91	}	91	}
92		92
93	static void	93	static void
94	RESTORE_WARN_FLAGS(const char *file, size_t line)	94	RESTORE_WARN_FLAGS(const char *file, size_t line)
95	{	95	{
96	if (olwarn != LWARN_BAD) {	96	if (olwarn != LWARN_BAD) {
97	lwarn = olwarn;	97	lwarn = olwarn;
98	printf("%s:%d: %s:%zu: restoring flags %d\n",	98	printf("%s:%d: %s:%zu: restoring flags %d\n",
99	curr_pos.p_file, curr_pos.p_line, file, line, lwarn);	99	curr_pos.p_file, curr_pos.p_line, file, line, lwarn);
100	olwarn = LWARN_BAD;	100	olwarn = LWARN_BAD;
101	} else	101	} else
102	CLEAR_WARN_FLAGS(file, line);	102	CLEAR_WARN_FLAGS(file, line);
103	}	103	}
104	#define cgram_debug(fmt, args...) printf("cgram_debug: " fmt "\n", ##args)	104	#define cgram_debug(fmt, args...) printf("cgram_debug: " fmt "\n", ##args)
105	#else	105	#else
106	#define CLEAR_WARN_FLAGS(f, l) clear_warn_flags(), olwarn = LWARN_BAD	106	#define CLEAR_WARN_FLAGS(f, l) clear_warn_flags(), olwarn = LWARN_BAD
107	#define SAVE_WARN_FLAGS(f, l) olwarn = lwarn	107	#define SAVE_WARN_FLAGS(f, l) olwarn = lwarn
108	#define RESTORE_WARN_FLAGS(f, l) \	108	#define RESTORE_WARN_FLAGS(f, l) \
109	(void)(olwarn == LWARN_BAD ? (clear_warn_flags(), 0) : (lwarn = olwarn))	109	(void)(olwarn == LWARN_BAD ? (clear_warn_flags(), 0) : (lwarn = olwarn))
110	#define cgram_debug(fmt, args...) do { } while (false)	110	#define cgram_debug(fmt, args...) do { } while (false)
111	#endif	111	#endif
112		112
113	#define clear_warning_flags() CLEAR_WARN_FLAGS(__FILE__, __LINE__)	113	#define clear_warning_flags() CLEAR_WARN_FLAGS(__FILE__, __LINE__)
114	#define save_warning_flags() SAVE_WARN_FLAGS(__FILE__, __LINE__)	114	#define save_warning_flags() SAVE_WARN_FLAGS(__FILE__, __LINE__)
115	#define restore_warning_flags() RESTORE_WARN_FLAGS(__FILE__, __LINE__)	115	#define restore_warning_flags() RESTORE_WARN_FLAGS(__FILE__, __LINE__)
116		116
117	/* unbind the anonymous struct members from the struct */	117	/* unbind the anonymous struct members from the struct */
118	static void	118	static void
119	anonymize(sym_t *s)	119	anonymize(sym_t *s)
120	{	120	{
121	for ( ; s != NULL; s = s->s_next)	121	for ( ; s != NULL; s = s->s_next)
122	s->s_styp = NULL;	122	s->s_styp = NULL;
123	}	123	}
124		124
125	%}	125	%}
126		126
127	%expect 165	127	%expect 165
128		128
129	%union {	129	%union {
130	val_t *y_val;	130	val_t *y_val;
131	sbuf_t *y_name;	131	sbuf_t *y_name;
132	sym_t *y_sym;	132	sym_t *y_sym;
133	op_t y_op;	133	op_t y_op;
134	scl_t y_scl;	134	scl_t y_scl;
135	tspec_t y_tspec;	135	tspec_t y_tspec;
136	tqual_t y_tqual;	136	tqual_t y_tqual;
137	type_t *y_type;	137	type_t *y_type;
138	tnode_t *y_tnode;	138	tnode_t *y_tnode;
139	range_t y_range;	139	range_t y_range;
140	strg_t *y_string;	140	strg_t *y_string;
141	qual_ptr *y_qual_ptr;	141	qual_ptr *y_qual_ptr;
142	bool y_seen_statement;	142	bool y_seen_statement;
143	struct generic_association *y_generic;	143	struct generic_association *y_generic;
144	};	144	};
145		145
146	%token T_LBRACE T_RBRACE T_LBRACK T_RBRACK T_LPAREN T_RPAREN	146	%token T_LBRACE T_RBRACE T_LBRACK T_RBRACK T_LPAREN T_RPAREN
147	%token T_POINT T_ARROW	147	%token T_POINT T_ARROW
148	%token T_COMPLEMENT T_LOGNOT	148	%token T_COMPLEMENT T_LOGNOT
149	%token <y_op> T_INCDEC	149	%token <y_op> T_INCDEC
150	%token T_SIZEOF	150	%token T_SIZEOF
151	%token T_BUILTIN_OFFSETOF	151	%token T_BUILTIN_OFFSETOF
152	%token T_TYPEOF	152	%token T_TYPEOF
153	%token T_EXTENSION	153	%token T_EXTENSION
154	%token T_ALIGNAS	154	%token T_ALIGNAS
155	%token T_ALIGNOF	155	%token T_ALIGNOF
156	%token T_ASTERISK	156	%token T_ASTERISK
157	%token <y_op> T_MULTIPLICATIVE	157	%token <y_op> T_MULTIPLICATIVE
158	%token <y_op> T_ADDITIVE	158	%token <y_op> T_ADDITIVE
159	%token <y_op> T_SHIFT	159	%token <y_op> T_SHIFT
160	%token <y_op> T_RELATIONAL	160	%token <y_op> T_RELATIONAL
161	%token <y_op> T_EQUALITY	161	%token <y_op> T_EQUALITY
162	%token T_AMPER	162	%token T_AMPER
163	%token T_BITXOR	163	%token T_BITXOR
164	%token T_BITOR	164	%token T_BITOR
165	%token T_LOGAND	165	%token T_LOGAND
166	%token T_LOGOR	166	%token T_LOGOR
167	%token T_QUEST	167	%token T_QUEST
168	%token T_COLON	168	%token T_COLON
169	%token T_ASSIGN	169	%token T_ASSIGN
170	%token <y_op> T_OPASSIGN	170	%token <y_op> T_OPASSIGN
171	%token T_COMMA	171	%token T_COMMA
172	%token T_SEMI	172	%token T_SEMI
173	%token T_ELLIPSIS	173	%token T_ELLIPSIS
174	%token T_REAL	174	%token T_REAL
175	%token T_IMAG	175	%token T_IMAG
176	%token T_GENERIC	176	%token T_GENERIC
177	%token T_NORETURN	177	%token T_NORETURN
178		178
179	/* storage classes (extern, static, auto, register and typedef) */	179	/* storage classes (extern, static, auto, register and typedef) */
180	%token <y_scl> T_SCLASS	180	%token <y_scl> T_SCLASS
181		181
182	/*	182	/*
183	* predefined type keywords (char, int, short, long, unsigned, signed,	183	* predefined type keywords (char, int, short, long, unsigned, signed,
184	* float, double, void); see T_TYPENAME for types from typedef	184	* float, double, void); see T_TYPENAME for types from typedef
185	*/	185	*/
186	%token <y_tspec> T_TYPE	186	%token <y_tspec> T_TYPE
187		187
188	/* qualifiers (const, volatile, restrict, _Thread_local) */	188	/* qualifiers (const, volatile, restrict, _Thread_local) */
189	%token <y_tqual> T_QUAL	189	%token <y_tqual> T_QUAL
190		190
191	/* struct or union */	191	/* struct or union */
192	%token <y_tspec> T_STRUCT_OR_UNION	192	%token <y_tspec> T_STRUCT_OR_UNION
193		193
194	/* remaining keywords */	194	/* remaining keywords */
195	%token T_ASM	195	%token T_ASM
196	%token T_BREAK	196	%token T_BREAK
197	%token T_CASE	197	%token T_CASE
198	%token T_CONTINUE	198	%token T_CONTINUE
199	%token T_DEFAULT	199	%token T_DEFAULT
200	%token T_DO	200	%token T_DO
201	%token T_ELSE	201	%token T_ELSE
202	%token T_ENUM	202	%token T_ENUM
203	%token T_FOR	203	%token T_FOR
204	%token T_GOTO	204	%token T_GOTO
205	%token T_IF	205	%token T_IF
206	%token T_PACKED	206	%token T_PACKED
207	%token T_RETURN	207	%token T_RETURN
208	%token T_SWITCH	208	%token T_SWITCH
209	%token T_SYMBOLRENAME	209	%token T_SYMBOLRENAME
210	%token T_WHILE	210	%token T_WHILE
211		211
212	%token T_ATTRIBUTE	212	%token T_ATTRIBUTE
213	%token T_AT_ALIAS	213	%token T_AT_ALIAS
214	%token T_AT_ALIGNED	214	%token T_AT_ALIGNED
215	%token T_AT_ALLOC_SIZE	215	%token T_AT_ALLOC_SIZE
216	%token T_AT_ALWAYS_INLINE	216	%token T_AT_ALWAYS_INLINE
217	%token T_AT_BOUNDED	217	%token T_AT_BOUNDED
218	%token T_AT_BUFFER	218	%token T_AT_BUFFER
219	%token T_AT_COLD	219	%token T_AT_COLD
220	%token T_AT_COMMON	220	%token T_AT_COMMON
221	%token T_AT_CONSTRUCTOR	221	%token T_AT_CONSTRUCTOR
222	%token T_AT_DEPRECATED	222	%token T_AT_DEPRECATED
223	%token T_AT_DESTRUCTOR	223	%token T_AT_DESTRUCTOR
224	%token T_AT_FALLTHROUGH	224	%token T_AT_FALLTHROUGH
225	%token T_AT_FORMAT	225	%token T_AT_FORMAT
226	%token T_AT_FORMAT_ARG	226	%token T_AT_FORMAT_ARG
227	%token T_AT_FORMAT_GNU_PRINTF	227	%token T_AT_FORMAT_GNU_PRINTF
228	%token T_AT_FORMAT_PRINTF	228	%token T_AT_FORMAT_PRINTF
229	%token T_AT_FORMAT_SCANF	229	%token T_AT_FORMAT_SCANF
230	%token T_AT_FORMAT_STRFMON	230	%token T_AT_FORMAT_STRFMON
231	%token T_AT_FORMAT_STRFTIME	231	%token T_AT_FORMAT_STRFTIME
232	%token T_AT_FORMAT_SYSLOG	232	%token T_AT_FORMAT_SYSLOG
233	%token T_AT_GNU_INLINE	233	%token T_AT_GNU_INLINE
234	%token T_AT_HOT	234	%token T_AT_HOT
235	%token T_AT_MALLOC	235	%token T_AT_MALLOC
236	%token T_AT_MAY_ALIAS	236	%token T_AT_MAY_ALIAS
237	%token T_AT_MINBYTES	237	%token T_AT_MINBYTES
238	%token T_AT_MODE	238	%token T_AT_MODE
239	%token T_AT_NOINLINE	239	%token T_AT_NOINLINE
240	%token T_AT_NONNULL	240	%token T_AT_NONNULL
241	%token T_AT_NONSTRING	241	%token T_AT_NONSTRING
242	%token T_AT_NORETURN	242	%token T_AT_NORETURN
243	%token T_AT_NOTHROW	243	%token T_AT_NOTHROW
244	%token T_AT_NO_INSTRUMENT_FUNCTION	244	%token T_AT_NO_INSTRUMENT_FUNCTION
245	%token T_AT_OPTIMIZE	245	%token T_AT_OPTIMIZE
246	%token T_AT_PACKED	246	%token T_AT_PACKED
247	%token T_AT_PCS	247	%token T_AT_PCS
248	%token T_AT_PURE	248	%token T_AT_PURE
249	%token T_AT_RETURNS_TWICE	249	%token T_AT_RETURNS_TWICE
250	%token T_AT_SECTION	250	%token T_AT_SECTION
251	%token T_AT_SENTINEL	251	%token T_AT_SENTINEL
252	%token T_AT_STRING	252	%token T_AT_STRING
253	%token T_AT_TLS_MODEL	253	%token T_AT_TLS_MODEL
254	%token T_AT_TUNION	254	%token T_AT_TUNION
255	%token T_AT_UNUSED	255	%token T_AT_UNUSED
256	%token T_AT_USED	256	%token T_AT_USED
257	%token T_AT_VISIBILITY	257	%token T_AT_VISIBILITY
258	%token T_AT_WARN_UNUSED_RESULT	258	%token T_AT_WARN_UNUSED_RESULT
259	%token T_AT_WEAK	259	%token T_AT_WEAK
260		260
261	%left T_THEN	261	%left T_THEN
262	%left T_ELSE	262	%left T_ELSE
263	%left T_COMMA	263	%left T_COMMA
264	%right T_ASSIGN T_OPASSIGN	264	%right T_ASSIGN T_OPASSIGN
265	%right T_QUEST T_COLON	265	%right T_QUEST T_COLON
266	%left T_LOGOR	266	%left T_LOGOR
267	%left T_LOGAND	267	%left T_LOGAND
268	%left T_BITOR	268	%left T_BITOR
269	%left T_BITXOR	269	%left T_BITXOR
270	%left T_AMPER	270	%left T_AMPER
271	%left T_EQUALITY	271	%left T_EQUALITY
272	%left T_RELATIONAL	272	%left T_RELATIONAL
273	%left T_SHIFT	273	%left T_SHIFT
274	%left T_ADDITIVE	274	%left T_ADDITIVE
275	%left T_ASTERISK T_MULTIPLICATIVE	275	%left T_ASTERISK T_MULTIPLICATIVE
276		276
277	%token <y_name> T_NAME	277	%token <y_name> T_NAME
278	%token <y_name> T_TYPENAME	278	%token <y_name> T_TYPENAME
279	%token <y_val> T_CON	279	%token <y_val> T_CON
280	%token <y_string> T_STRING	280	%token <y_string> T_STRING
281		281
282	%type <y_sym> identifier_sym	282	%type <y_sym> identifier_sym
283	%type <y_name> identifier	283	%type <y_name> identifier
284	%type <y_string> string	284	%type <y_string> string
285	%type <y_string> string2	285	%type <y_string> string2
286		286
287	%type <y_tnode> primary_expression	287	%type <y_tnode> primary_expression
288	%type <y_tnode> generic_selection	288	%type <y_tnode> generic_selection
289	%type <y_generic> generic_assoc_list	289	%type <y_generic> generic_assoc_list
290	%type <y_generic> generic_association	290	%type <y_generic> generic_association
291	%type <y_tnode> postfix_expression	291	%type <y_tnode> postfix_expression
292	%type <y_tnode> gcc_statement_expr_list	292	%type <y_tnode> gcc_statement_expr_list
293	%type <y_tnode> gcc_statement_expr_item	293	%type <y_tnode> gcc_statement_expr_item
294	%type <y_op> point_or_arrow	294	%type <y_op> point_or_arrow
295	%type <y_tnode> argument_expression_list	295	%type <y_tnode> argument_expression_list
296	%type <y_tnode> unary_expression	296	%type <y_tnode> unary_expression
297	%type <y_tnode> cast_expression	297	%type <y_tnode> cast_expression
298	%type <y_tnode> conditional_expression	298	%type <y_tnode> conditional_expression
299	%type <y_tnode> assignment_expression	299	%type <y_tnode> assignment_expression
300	%type <y_tnode> expression_opt	300	%type <y_tnode> expression_opt
301	%type <y_tnode> expression	301	%type <y_tnode> expression
302	%type <y_tnode> constant_expr	302	%type <y_tnode> constant_expr
303		303
304	%type <y_type> begin_type_typespec	304	%type <y_type> begin_type_typespec
305	%type <y_type> type_specifier	305	%type <y_type> type_specifier
306	%type <y_type> notype_type_specifier	306	%type <y_type> notype_type_specifier
307	%type <y_type> struct_or_union_specifier	307	%type <y_type> struct_or_union_specifier
308	%type <y_tspec> struct_or_union	308	%type <y_tspec> struct_or_union
309	%type <y_sym> braced_struct_declaration_list	309	%type <y_sym> braced_struct_declaration_list
310	%type <y_sym> struct_declaration_list_with_rbrace	310	%type <y_sym> struct_declaration_list_with_rbrace
311	%type <y_sym> struct_declaration_list	311	%type <y_sym> struct_declaration_list
312	%type <y_sym> struct_declaration	312	%type <y_sym> struct_declaration
313	%type <y_sym> notype_struct_declarators	313	%type <y_sym> notype_struct_declarators
314	%type <y_sym> type_struct_declarators	314	%type <y_sym> type_struct_declarators
315	%type <y_sym> notype_struct_declarator	315	%type <y_sym> notype_struct_declarator
316	%type <y_sym> type_struct_declarator	316	%type <y_sym> type_struct_declarator
317	%type <y_type> enum_specifier	317	%type <y_type> enum_specifier
318	%type <y_sym> enum_declaration	318	%type <y_sym> enum_declaration
319	%type <y_sym> enums_with_opt_comma	319	%type <y_sym> enums_with_opt_comma
320	%type <y_sym> enumerator_list	320	%type <y_sym> enumerator_list
321	%type <y_sym> enumerator	321	%type <y_sym> enumerator
322	%type <y_qual_ptr> type_qualifier	322	%type <y_qual_ptr> type_qualifier
323	%type <y_qual_ptr> pointer	323	%type <y_qual_ptr> pointer
324	%type <y_qual_ptr> asterisk	324	%type <y_qual_ptr> asterisk
325	%type <y_qual_ptr> type_qualifier_list_opt	325	%type <y_qual_ptr> type_qualifier_list_opt
326	%type <y_qual_ptr> type_qualifier_list	326	%type <y_qual_ptr> type_qualifier_list
327	%type <y_sym> notype_declarator	327	%type <y_sym> notype_declarator
328	%type <y_sym> type_declarator	328	%type <y_sym> type_declarator
329	%type <y_sym> notype_direct_declarator	329	%type <y_sym> notype_direct_declarator
330	%type <y_sym> type_direct_declarator	330	%type <y_sym> type_direct_declarator
331	%type <y_sym> type_param_declarator	331	%type <y_sym> type_param_declarator
332	%type <y_sym> notype_param_declarator	332	%type <y_sym> notype_param_declarator
333	%type <y_sym> direct_param_declarator	333	%type <y_sym> direct_param_declarator
334	%type <y_sym> direct_notype_param_declarator	334	%type <y_sym> direct_notype_param_declarator
335	%type <y_sym> param_list	335	%type <y_sym> param_list
336	%type <y_tnode> array_size	336	%type <y_tnode> array_size
337	%type <y_sym> identifier_list	337	%type <y_sym> identifier_list
338	%type <y_type> type_name	338	%type <y_type> type_name
339	%type <y_sym> abstract_declaration	339	%type <y_sym> abstract_declaration
340	%type <y_sym> abstract_declarator	340	%type <y_sym> abstract_declarator
341	%type <y_sym> direct_abstract_declarator	341	%type <y_sym> direct_abstract_declarator
342	%type <y_sym> abstract_decl_param_list	342	%type <y_sym> abstract_decl_param_list
343	%type <y_sym> vararg_parameter_type_list	343	%type <y_sym> vararg_parameter_type_list
344	%type <y_sym> parameter_type_list	344	%type <y_sym> parameter_type_list
345	%type <y_sym> parameter_declaration	345	%type <y_sym> parameter_declaration
346	%type <y_range> range	346	%type <y_range> range
347	%type <y_name> asm_or_symbolrename_opt	347	%type <y_name> asm_or_symbolrename_opt
348		348
349	%type <y_seen_statement> block_item_list	349	%type <y_seen_statement> block_item_list
350	%type <y_seen_statement> block_item	350	%type <y_seen_statement> block_item
351	%type <y_tnode> do_while_expr	351	%type <y_tnode> do_while_expr
352	%type <y_sym> func_declarator	352	%type <y_sym> func_declarator
353		353
354	%%	354	%%
355		355
356	program:	356	program:
357	/* empty */ {	357	/* empty */ {
358	if (sflag) {	358	if (sflag) {
359	/* empty translation unit */	359	/* empty translation unit */
360	error(272);	360	error(272);
361	} else if (!tflag) {	361	} else if (!tflag) {
362	/* empty translation unit */	362	/* empty translation unit */
363	warning(272);	363	warning(272);
364	}	364	}
365	}	365	}
366	\| translation_unit	366	\| translation_unit
367	;	367	;
368		368
369	identifier_sym: /* helper for struct/union/enum */	369	identifier_sym: /* helper for struct/union/enum */
370	identifier {	370	identifier {
371	$$ = getsym($1);	371	$$ = getsym($1);
372	}	372	}
373	;	373	;
374		374
375	/* K&R ???, C90 ???, C99 6.4.2.1, C11 ??? */	375	/* K&R ???, C90 ???, C99 6.4.2.1, C11 ??? */
376	identifier:	376	identifier:
377	T_NAME {	377	T_NAME {
378	$$ = $1;	378	$$ = $1;
379	cgram_debug("name '%s'", $$->sb_name);	379	cgram_debug("name '%s'", $$->sb_name);
380	}	380	}
381	\| T_TYPENAME {	381	\| T_TYPENAME {
382	$$ = $1;	382	$$ = $1;
383	cgram_debug("typename '%s'", $$->sb_name);	383	cgram_debug("typename '%s'", $$->sb_name);
384	}	384	}
385	;	385	;
386		386
387	/* see C99 6.4.5, string literals are joined by 5.1.1.2 */	387	/* see C99 6.4.5, string literals are joined by 5.1.1.2 */
388	string:	388	string:
389	T_STRING	389	T_STRING
390	\| T_STRING string2 {	390	\| T_STRING string2 {
391	$$ = cat_strings($1, $2);	391	$$ = cat_strings($1, $2);
392	}	392	}
393	;	393	;
394		394
395	/* see C99 6.4.5, string literals are joined by 5.1.1.2 */	395	/* see C99 6.4.5, string literals are joined by 5.1.1.2 */
396	string2:	396	string2:
397	T_STRING {	397	T_STRING {
398	if (tflag) {	398	if (tflag) {
399	/* concatenated strings are illegal in traditional C */	399	/* concatenated strings are illegal in traditional C */
400	warning(219);	400	warning(219);
401	}	401	}
402	$$ = $1;	402	$$ = $1;
403	}	403	}
404	\| string2 T_STRING {	404	\| string2 T_STRING {
405	$$ = cat_strings($1, $2);	405	$$ = cat_strings($1, $2);
406	}	406	}
407	;	407	;
408		408
409	/* K&R 7.1, C90 ???, C99 6.5.1, C11 6.5.1 */	409	/* K&R 7.1, C90 ???, C99 6.5.1, C11 6.5.1 */
410	primary_expression:	410	primary_expression:
411	T_NAME {	411	T_NAME {
412	/* XXX really necessary? */	412	/* XXX really necessary? */
413	if (yychar < 0)	413	if (yychar < 0)
414	yychar = yylex();	414	yychar = yylex();
415	$$ = new_name_node(getsym($1), yychar);	415	$$ = new_name_node(getsym($1), yychar);
416	}	416	}
417	\| T_CON {	417	\| T_CON {
418	$$ = expr_new_constant(gettyp($1->v_tspec), $1);	418	$$ = expr_new_constant(gettyp($1->v_tspec), $1);
419	}	419	}
420	\| string {	420	\| string {
421	$$ = new_string_node($1);	421	$$ = new_string_node($1);
422	}	422	}
423	\| T_LPAREN expression T_RPAREN {	423	\| T_LPAREN expression T_RPAREN {
424	if ($2 != NULL)	424	if ($2 != NULL)
425	$2->tn_parenthesized = true;	425	$2->tn_parenthesized = true;
426	$$ = $2;	426	$$ = $2;
427	}	427	}
428	\| generic_selection	428	\| generic_selection
429	/* GCC primary-expression, see c_parser_postfix_expression */	429	/* GCC primary-expression, see c_parser_postfix_expression */
430	\| T_BUILTIN_OFFSETOF T_LPAREN type_name T_COMMA identifier T_RPAREN {	430	\| T_BUILTIN_OFFSETOF T_LPAREN type_name T_COMMA identifier T_RPAREN {
431	symtyp = FMEMBER;	431	symtyp = FMEMBER;
432	$$ = build_offsetof($3, getsym($5));	432	$$ = build_offsetof($3, getsym($5));
433	}	433	}
434	;	434	;
435		435
436	/* K&R ---, C90 ---, C99 ---, C11 6.5.1.1 */	436	/* K&R ---, C90 ---, C99 ---, C11 6.5.1.1 */
437	generic_selection:	437	generic_selection:
438	T_GENERIC T_LPAREN assignment_expression T_COMMA	438	T_GENERIC T_LPAREN assignment_expression T_COMMA
439	generic_assoc_list T_RPAREN {	439	generic_assoc_list T_RPAREN {
440	/* generic selection requires C11 or later */	440	/* generic selection requires C11 or later */
441	c11ism(345);	441	c11ism(345);
442	$$ = build_generic_selection($3, $5);	442	$$ = build_generic_selection($3, $5);
443	}	443	}
444	;	444	;
445		445
446	/* K&R ---, C90 ---, C99 ---, C11 6.5.1.1 */	446	/* K&R ---, C90 ---, C99 ---, C11 6.5.1.1 */
447	generic_assoc_list:	447	generic_assoc_list:
448	generic_association	448	generic_association
449	\| generic_assoc_list T_COMMA generic_association {	449	\| generic_assoc_list T_COMMA generic_association {
450	$3->ga_prev = $1;	450	$3->ga_prev = $1;
451	$$ = $3;	451	$$ = $3;
452	}	452	}
453	;	453	;
454		454
455	/* K&R ---, C90 ---, C99 ---, C11 6.5.1.1 */	455	/* K&R ---, C90 ---, C99 ---, C11 6.5.1.1 */
456	generic_association:	456	generic_association:
457	type_name T_COLON assignment_expression {	457	type_name T_COLON assignment_expression {
458	$$ = getblk(sizeof(*$$));	458	$$ = getblk(sizeof(*$$));
459	$$->ga_arg = $1;	459	$$->ga_arg = $1;
460	$$->ga_result = $3;	460	$$->ga_result = $3;
461	}	461	}
462	\| T_DEFAULT T_COLON assignment_expression {	462	\| T_DEFAULT T_COLON assignment_expression {
463	$$ = getblk(sizeof(*$$));	463	$$ = getblk(sizeof(*$$));
464	$$->ga_arg = NULL;	464	$$->ga_arg = NULL;
465	$$->ga_result = $3;	465	$$->ga_result = $3;
466	}	466	}
467	;	467	;
468		468
469	/* K&R 7.1, C90 ???, C99 6.5.2, C11 6.5.2 */	469	/* K&R 7.1, C90 ???, C99 6.5.2, C11 6.5.2 */
470	postfix_expression:	470	postfix_expression:
471	primary_expression	471	primary_expression
472	\| postfix_expression T_LBRACK expression T_RBRACK {	472	\| postfix_expression T_LBRACK expression T_RBRACK {
473	$$ = build(INDIR, build(PLUS, $1, $3), NULL);	473	$$ = build(INDIR, build(PLUS, $1, $3), NULL);
474	}	474	}
475	\| postfix_expression T_LPAREN T_RPAREN {	475	\| postfix_expression T_LPAREN T_RPAREN {
476	$$ = new_function_call_node($1, NULL);	476	$$ = new_function_call_node($1, NULL);
477	}	477	}
478	\| postfix_expression T_LPAREN argument_expression_list T_RPAREN {	478	\| postfix_expression T_LPAREN argument_expression_list T_RPAREN {
479	$$ = new_function_call_node($1, $3);	479	$$ = new_function_call_node($1, $3);
480	}	480	}
481	\| postfix_expression point_or_arrow T_NAME {	481	\| postfix_expression point_or_arrow T_NAME {
482	$$ = build_member_access($1, $2, $3);	482	$$ = build_member_access($1, $2, $3);
483	}	483	}
484	\| postfix_expression T_INCDEC {	484	\| postfix_expression T_INCDEC {
485	$$ = build($2 == INC ? INCAFT : DECAFT, $1, NULL);	485	$$ = build($2 == INC ? INCAFT : DECAFT, $1, NULL);
486	}	486	}
487	\| T_LPAREN type_name T_RPAREN { /* C99 6.5.2.5 "Compound literals" */	487	\| T_LPAREN type_name T_RPAREN { /* C99 6.5.2.5 "Compound literals" */
488	sym_t *tmp = mktempsym($2);	488	sym_t *tmp = mktempsym($2);
489	begin_initialization(tmp);	489	begin_initialization(tmp);
490	cgram_declare(tmp, true, NULL);	490	cgram_declare(tmp, true, NULL);
491	} init_lbrace initializer_list comma_opt init_rbrace {	491	} init_lbrace initializer_list comma_opt init_rbrace {
492	if (!Sflag)	492	if (!Sflag)
493	/* compound literals are a C9X/GCC extension */	493	/* compound literals are a C9X/GCC extension */
494	gnuism(319);	494	gnuism(319);
495	$$ = new_name_node(*current_initsym(), 0);	495	$$ = new_name_node(*current_initsym(), 0);
496	end_initialization();	496	end_initialization();
497	}	497	}
498	\| T_LPAREN compound_statement_lbrace gcc_statement_expr_list {	498	\| T_LPAREN compound_statement_lbrace gcc_statement_expr_list {
499	block_level--;	499	block_level--;
500	mem_block_level--;	500	mem_block_level--;
501	begin_initialization(mktempsym(dup_type($3->tn_type)));	501	begin_initialization(mktempsym(dup_type($3->tn_type)));
502	mem_block_level++;	502	mem_block_level++;
503	block_level++;	503	block_level++;
504	/* ({ }) is a GCC extension */	504	/* ({ }) is a GCC extension */
505	gnuism(320);	505	gnuism(320);
506	} compound_statement_rbrace T_RPAREN {	506	} compound_statement_rbrace T_RPAREN {
507	$$ = new_name_node(*current_initsym(), 0);	507	$$ = new_name_node(*current_initsym(), 0);
508	end_initialization();	508	end_initialization();
509	}	509	}
510	;	510	;
511		511
512	comma_opt: /* helper for 'postfix_expression' */	512	comma_opt: /* helper for 'postfix_expression' */
513	/* empty */	513	/* empty */
514	\| T_COMMA	514	\| T_COMMA
515	;	515	;
516		516
517	/*	517	/*
518	* The inner part of a GCC statement-expression of the form ({ ... }).	518	* The inner part of a GCC statement-expression of the form ({ ... }).
519	*	519	*
520	* https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html	520	* https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html
521	*/	521	*/
522	gcc_statement_expr_list:	522	gcc_statement_expr_list:
523	gcc_statement_expr_item	523	gcc_statement_expr_item
524	\| gcc_statement_expr_list gcc_statement_expr_item {	524	\| gcc_statement_expr_list gcc_statement_expr_item {
525	$$ = $2;	525	$$ = $2;
526	}	526	}
527	;	527	;
528		528
529	gcc_statement_expr_item:	529	gcc_statement_expr_item:
530	declaration_or_error {	530	declaration_or_error {
531	clear_warning_flags();	531	clear_warning_flags();
532	$$ = NULL;	532	$$ = NULL;
533	}	533	}
534	\| non_expr_statement {	534	\| non_expr_statement {
535	$$ = expr_zalloc_tnode();	535	$$ = expr_zalloc_tnode();
536	$$->tn_type = gettyp(VOID);	536	$$->tn_type = gettyp(VOID);
537	}	537	}
538	\| expression T_SEMI {	538	\| expression T_SEMI {
539	if ($1 == NULL) { /* in case of syntax errors */	539	if ($1 == NULL) { /* in case of syntax errors */
540	$$ = expr_zalloc_tnode();	540	$$ = expr_zalloc_tnode();
541	$$->tn_type = gettyp(VOID);	541	$$->tn_type = gettyp(VOID);
542	} else {	542	} else {
543	/* XXX: do that only on the last name */	543	/* XXX: do that only on the last name */
544	if ($1->tn_op == NAME)	544	if ($1->tn_op == NAME)
545	$1->tn_sym->s_used = true;	545	$1->tn_sym->s_used = true;
546	$$ = $1;	546	$$ = $1;
547	expr($1, false, false, false, false);	547	expr($1, false, false, false, false);
548	seen_fallthrough = false;	548	seen_fallthrough = false;
549	}	549	}
550	}	550	}
551	;	551	;
552		552
553	point_or_arrow: /* helper for 'postfix_expression' */	553	point_or_arrow: /* helper for 'postfix_expression' */
554	T_POINT {	554	T_POINT {
555	symtyp = FMEMBER;	555	symtyp = FMEMBER;
556	$$ = POINT;	556	$$ = POINT;
557	}	557	}
558	\| T_ARROW {	558	\| T_ARROW {
559	symtyp = FMEMBER;	559	symtyp = FMEMBER;
560	$$ = ARROW;	560	$$ = ARROW;
561	}	561	}
562	;	562	;
563		563
564	/* K&R 7.1, C90 ???, C99 6.5.2, C11 6.5.2 */	564	/* K&R 7.1, C90 ???, C99 6.5.2, C11 6.5.2 */
565	argument_expression_list:	565	argument_expression_list:
566	assignment_expression {	566	assignment_expression {
567	$$ = new_function_argument_node(NULL, $1);	567	$$ = new_function_argument_node(NULL, $1);
568	}	568	}
569	\| argument_expression_list T_COMMA assignment_expression {	569	\| argument_expression_list T_COMMA assignment_expression {
570	$$ = new_function_argument_node($1, $3);	570	$$ = new_function_argument_node($1, $3);
571	}	571	}
572	;	572	;
573		573
574	/* K&R 7.2, C90 ???, C99 6.5.3, C11 6.5.3 */	574	/* K&R 7.2, C90 ???, C99 6.5.3, C11 6.5.3 */
575	unary_expression:	575	unary_expression:
576	postfix_expression	576	postfix_expression
577	\| T_INCDEC unary_expression {	577	\| T_INCDEC unary_expression {
578	$$ = build($1 == INC ? INCBEF : DECBEF, $2, NULL);	578	$$ = build($1 == INC ? INCBEF : DECBEF, $2, NULL);
579	}	579	}
580	\| T_AMPER cast_expression {	580	\| T_AMPER cast_expression {
581	$$ = build(ADDR, $2, NULL);	581	$$ = build(ADDR, $2, NULL);
582	}	582	}
583	\| T_ASTERISK cast_expression {	583	\| T_ASTERISK cast_expression {
584	$$ = build(INDIR, $2, NULL);	584	$$ = build(INDIR, $2, NULL);
585	}	585	}
586	\| T_ADDITIVE cast_expression {	586	\| T_ADDITIVE cast_expression {
587	if (tflag && $1 == PLUS) {	587	if (tflag && $1 == PLUS) {
588	/* unary + is illegal in traditional C */	588	/* unary + is illegal in traditional C */
589	warning(100);	589	warning(100);
590	}	590	}
591	$$ = build($1 == PLUS ? UPLUS : UMINUS, $2, NULL);	591	$$ = build($1 == PLUS ? UPLUS : UMINUS, $2, NULL);
592	}	592	}
593	\| T_COMPLEMENT cast_expression {	593	\| T_COMPLEMENT cast_expression {
594	$$ = build(COMPL, $2, NULL);	594	$$ = build(COMPL, $2, NULL);
595	}	595	}
596	\| T_LOGNOT cast_expression {	596	\| T_LOGNOT cast_expression {
597	$$ = build(NOT, $2, NULL);	597	$$ = build(NOT, $2, NULL);
598	}	598	}
599	\| T_REAL cast_expression { /* GCC c_parser_unary_expression */	599	\| T_REAL cast_expression { /* GCC c_parser_unary_expression */
600	$$ = build(REAL, $2, NULL);	600	$$ = build(REAL, $2, NULL);
601	}	601	}
602	\| T_IMAG cast_expression { /* GCC c_parser_unary_expression */	602	\| T_IMAG cast_expression { /* GCC c_parser_unary_expression */
603	$$ = build(IMAG, $2, NULL);	603	$$ = build(IMAG, $2, NULL);
604	}	604	}
605	\| T_EXTENSION cast_expression { /* GCC c_parser_unary_expression */	605	\| T_EXTENSION cast_expression { /* GCC c_parser_unary_expression */
606	$$ = $2;	606	$$ = $2;
607	}	607	}
608	\| T_SIZEOF unary_expression {	608	\| T_SIZEOF unary_expression {
609	$$ = $2 == NULL ? NULL : build_sizeof($2->tn_type);	609	$$ = $2 == NULL ? NULL : build_sizeof($2->tn_type);
610	if ($$ != NULL)	610	if ($$ != NULL)
611	check_expr_misc($2, false, false, false, false, false, true);	611	check_expr_misc($2, false, false, false, false, false, true);
612	}	612	}
613	\| T_SIZEOF T_LPAREN type_name T_RPAREN {	613	\| T_SIZEOF T_LPAREN type_name T_RPAREN {
614	$$ = build_sizeof($3);	614	$$ = build_sizeof($3);
615	}	615	}
616	/* K&R ---, C90 ---, C99 ---, C11 6.5.3 */	616	/* K&R ---, C90 ---, C99 ---, C11 6.5.3 */
617	\| T_ALIGNOF T_LPAREN type_name T_RPAREN {	617	\| T_ALIGNOF T_LPAREN type_name T_RPAREN {
618	$$ = build_alignof($3);	618	$$ = build_alignof($3);
619	}	619	}
620	;	620	;
621		621
622	/* The rule 'unary_operator' is inlined into unary_expression. */	622	/* The rule 'unary_operator' is inlined into unary_expression. */
623		623
624	/* K&R 7.2, C90 ???, C99 6.5.4, C11 6.5.4 */	624	/* K&R 7.2, C90 ???, C99 6.5.4, C11 6.5.4 */
625	cast_expression:	625	cast_expression:
626	unary_expression	626	unary_expression
627	\| T_LPAREN type_name T_RPAREN cast_expression {	627	\| T_LPAREN type_name T_RPAREN cast_expression {
628	$$ = cast($4, $2);	628	$$ = cast($4, $2);
629	}	629	}
630	;	630	;
631		631
632	expression_opt:	632	expression_opt:
633	/* empty */ {	633	/* empty */ {
634	$$ = NULL;	634	$$ = NULL;
635	}	635	}
636	\| expression	636	\| expression
637	;	637	;
638		638
639	/* 'conditional_expression' also implements 'multiplicative_expression'. */	639	/* 'conditional_expression' also implements 'multiplicative_expression'. */
640	/* 'conditional_expression' also implements 'additive_expression'. */	640	/* 'conditional_expression' also implements 'additive_expression'. */
641	/* 'conditional_expression' also implements 'shift_expression'. */	641	/* 'conditional_expression' also implements 'shift_expression'. */
642	/* 'conditional_expression' also implements 'relational_expression'. */	642	/* 'conditional_expression' also implements 'relational_expression'. */
643	/* 'conditional_expression' also implements 'equality_expression'. */	643	/* 'conditional_expression' also implements 'equality_expression'. */
644	/* 'conditional_expression' also implements 'AND_expression'. */	644	/* 'conditional_expression' also implements 'AND_expression'. */
645	/* 'conditional_expression' also implements 'exclusive_OR_expression'. */	645	/* 'conditional_expression' also implements 'exclusive_OR_expression'. */
646	/* 'conditional_expression' also implements 'inclusive_OR_expression'. */	646	/* 'conditional_expression' also implements 'inclusive_OR_expression'. */
647	/* 'conditional_expression' also implements 'logical_AND_expression'. */	647	/* 'conditional_expression' also implements 'logical_AND_expression'. */
648	/* 'conditional_expression' also implements 'logical_OR_expression'. */	648	/* 'conditional_expression' also implements 'logical_OR_expression'. */
649	/* K&R ???, C90 ???, C99 6.5.5 to 6.5.15, C11 6.5.5 to 6.5.15 */	649	/* K&R ???, C90 ???, C99 6.5.5 to 6.5.15, C11 6.5.5 to 6.5.15 */
650	conditional_expression:	650	conditional_expression:
651	conditional_expression T_ASTERISK conditional_expression {	651	conditional_expression T_ASTERISK conditional_expression {
652	$$ = build(MULT, $1, $3);	652	$$ = build(MULT, $1, $3);
653	}	653	}
654	\| conditional_expression T_MULTIPLICATIVE conditional_expression {	654	\| conditional_expression T_MULTIPLICATIVE conditional_expression {
655	$$ = build($2, $1, $3);	655	$$ = build($2, $1, $3);
656	}	656	}
657	\| conditional_expression T_ADDITIVE conditional_expression {	657	\| conditional_expression T_ADDITIVE conditional_expression {
658	$$ = build($2, $1, $3);	658	$$ = build($2, $1, $3);
659	}	659	}
660	\| conditional_expression T_SHIFT conditional_expression {	660	\| conditional_expression T_SHIFT conditional_expression {
661	$$ = build($2, $1, $3);	661	$$ = build($2, $1, $3);
662	}	662	}
663	\| conditional_expression T_RELATIONAL conditional_expression {	663	\| conditional_expression T_RELATIONAL conditional_expression {
664	$$ = build($2, $1, $3);	664	$$ = build($2, $1, $3);
665	}	665	}
666	\| conditional_expression T_EQUALITY conditional_expression {	666	\| conditional_expression T_EQUALITY conditional_expression {
667	$$ = build($2, $1, $3);	667	$$ = build($2, $1, $3);
668	}	668	}
669	\| conditional_expression T_AMPER conditional_expression {	669	\| conditional_expression T_AMPER conditional_expression {
670	$$ = build(BITAND, $1, $3);	670	$$ = build(BITAND, $1, $3);
671	}	671	}
672	\| conditional_expression T_BITXOR conditional_expression {	672	\| conditional_expression T_BITXOR conditional_expression {
673	$$ = build(BITXOR, $1, $3);	673	$$ = build(BITXOR, $1, $3);
674	}	674	}
675	\| conditional_expression T_BITOR conditional_expression {	675	\| conditional_expression T_BITOR conditional_expression {
676	$$ = build(BITOR, $1, $3);	676	$$ = build(BITOR, $1, $3);
677	}	677	}
678	\| conditional_expression T_LOGAND conditional_expression {	678	\| conditional_expression T_LOGAND conditional_expression {
679	$$ = build(LOGAND, $1, $3);	679	$$ = build(LOGAND, $1, $3);
680	}	680	}
681	\| conditional_expression T_LOGOR conditional_expression {	681	\| conditional_expression T_LOGOR conditional_expression {
682	$$ = build(LOGOR, $1, $3);	682	$$ = build(LOGOR, $1, $3);
683	}	683	}
684	\| conditional_expression T_QUEST conditional_expression	684	\| conditional_expression T_QUEST conditional_expression
685	T_COLON conditional_expression {	685	T_COLON conditional_expression {
686	$$ = build(QUEST, $1, build(COLON, $3, $5));	686	$$ = build(QUEST, $1, build(COLON, $3, $5));
687	}	687	}
688	\| cast_expression;	688	\| cast_expression;
689		689
690	/* K&R ???, C90 ???, C99 6.5.16, C11 6.5.16 */	690	/* K&R ???, C90 ???, C99 6.5.16, C11 6.5.16 */
691	assignment_expression:	691	assignment_expression:
692	conditional_expression	692	conditional_expression
693	\| assignment_expression T_ASSIGN conditional_expression {	693	\| assignment_expression T_ASSIGN conditional_expression {
694	$$ = build(ASSIGN, $1, $3);	694	$$ = build(ASSIGN, $1, $3);
695	}	695	}
696	\| assignment_expression T_OPASSIGN conditional_expression {	696	\| assignment_expression T_OPASSIGN conditional_expression {
697	$$ = build($2, $1, $3);	697	$$ = build($2, $1, $3);
698	}	698	}
699	;	699	;
700		700
701	/* K&R ???, C90 ???, C99 6.5.17, C11 6.5.17 */	701	/* K&R ???, C90 ???, C99 6.5.17, C11 6.5.17 */
702	expression:	702	expression:
703	assignment_expression	703	assignment_expression
704	\| expression T_COMMA assignment_expression {	704	\| expression T_COMMA assignment_expression {
705	$$ = build(COMMA, $1, $3);	705	$$ = build(COMMA, $1, $3);
706	}	706	}
707	;	707	;
708		708
709	constant_expr_list_opt: /* helper for gcc_attribute */	709	constant_expr_list_opt: /* helper for gcc_attribute */
710	/* empty */	710	/* empty */
711	\| constant_expr_list	711	\| constant_expr_list
712	;	712	;
713		713
714	constant_expr_list: /* helper for gcc_attribute */	714	constant_expr_list: /* helper for gcc_attribute */
715	constant_expr	715	constant_expr
716	\| constant_expr_list T_COMMA constant_expr	716	\| constant_expr_list T_COMMA constant_expr
717	;	717	;
718		718
719	constant_expr: /* C99 6.6 */	719	constant_expr: /* C99 6.6 */
720	conditional_expression	720	conditional_expression
721	;	721	;
722		722
723	declaration_or_error:	723	declaration_or_error:
724	declaration	724	declaration
725	\| error T_SEMI	725	\| error T_SEMI
726	;	726	;
727		727
728	declaration: /* C99 6.7 */	728	declaration: /* C99 6.7 */
729	begin_type_declmods end_type T_SEMI {	729	begin_type_declmods end_type T_SEMI {
730	if (dcs->d_scl == TYPEDEF) {	730	if (dcs->d_scl == TYPEDEF) {
731	/* typedef declares no type name */	731	/* typedef declares no type name */
732	warning(72);	732	warning(72);
733	} else {	733	} else {
734	/* empty declaration */	734	/* empty declaration */
735	warning(2);	735	warning(2);
736	}	736	}
737	}	737	}
738	\| begin_type_declmods end_type notype_init_declarators T_SEMI	738	\| begin_type_declmods end_type notype_init_declarators T_SEMI
739	\| begin_type_declaration_specifiers end_type T_SEMI {	739	\| begin_type_declaration_specifiers end_type T_SEMI {
740	if (dcs->d_scl == TYPEDEF) {	740	if (dcs->d_scl == TYPEDEF) {
741	/* typedef declares no type name */	741	/* typedef declares no type name */
742	warning(72);	742	warning(72);
743	} else if (!dcs->d_nonempty_decl) {	743	} else if (!dcs->d_nonempty_decl) {
744	/* empty declaration */	744	/* empty declaration */
745	warning(2);	745	warning(2);
746	}	746	}
747	}	747	}
748	\| begin_type_declaration_specifiers end_type	748	\| begin_type_declaration_specifiers end_type
749	type_init_declarators T_SEMI	749	type_init_declarators T_SEMI
750	;	750	;
751		751
752	begin_type_declaration_specifiers: /* see C99 6.7 */	752	begin_type_declaration_specifiers: /* see C99 6.7 */
753	begin_type_typespec {	753	begin_type_typespec {
754	add_type($1);	754	add_type($1);
755	}	755	}
756	\| begin_type_declmods type_specifier {	756	\| begin_type_declmods type_specifier {
757	add_type($2);	757	add_type($2);
758	}	758	}
759	\| type_attribute begin_type_declaration_specifiers	759	\| type_attribute begin_type_declaration_specifiers
760	\| begin_type_declaration_specifiers declmod	760	\| begin_type_declaration_specifiers declmod
761	\| begin_type_declaration_specifiers notype_type_specifier {	761	\| begin_type_declaration_specifiers notype_type_specifier {
762	add_type($2);	762	add_type($2);
763	}	763	}
764	;	764	;
765		765
766	begin_type_declmods: /* see C99 6.7 */	766	begin_type_declmods: /* see C99 6.7 */
767	begin_type T_QUAL {	767	begin_type T_QUAL {
768	add_qualifier($2);	768	add_qualifier($2);
769	}	769	}
770	\| begin_type T_SCLASS {	770	\| begin_type T_SCLASS {
771	add_storage_class($2);	771	add_storage_class($2);
772	}	772	}
773	\| begin_type_declmods declmod	773	\| begin_type_declmods declmod
774	;	774	;
775		775
776	begin_type_noclass_declspecs:	776	begin_type_noclass_declspecs:
777	begin_type_typespec {	777	begin_type_typespec {
778	add_type($1);	778	add_type($1);
779	}	779	}
780	\| type_attribute begin_type_noclass_declspecs	780	\| type_attribute begin_type_noclass_declspecs
781	\| begin_type_noclass_declmods type_specifier {	781	\| begin_type_noclass_declmods type_specifier {
782	add_type($2);	782	add_type($2);
783	}	783	}
784	\| begin_type_noclass_declspecs T_QUAL {	784	\| begin_type_noclass_declspecs T_QUAL {
785	add_qualifier($2);	785	add_qualifier($2);
786	}	786	}
787	\| begin_type_noclass_declspecs notype_type_specifier {	787	\| begin_type_noclass_declspecs notype_type_specifier {
788	add_type($2);	788	add_type($2);
789	}	789	}
790	\| begin_type_noclass_declspecs type_attribute	790	\| begin_type_noclass_declspecs type_attribute
791	;	791	;
792		792
793	begin_type_typespec:	793	begin_type_typespec:
794	begin_type notype_type_specifier {	794	begin_type notype_type_specifier {
795	$$ = $2;	795	$$ = $2;
796	}	796	}
797	\| T_TYPENAME begin_type {	797	\| T_TYPENAME begin_type {
798	$$ = getsym($1)->s_type;	798	$$ = getsym($1)->s_type;
799	}	799	}
800	;	800	;
801		801
802	begin_type_noclass_declmods:	802	begin_type_noclass_declmods:
803	begin_type T_QUAL {	803	begin_type T_QUAL {
804	add_qualifier($2);	804	add_qualifier($2);
805	}	805	}
806	\| begin_type_noclass_declmods T_QUAL {	806	\| begin_type_noclass_declmods T_QUAL {
807	add_qualifier($2);	807	add_qualifier($2);
808	}	808	}
809	;	809	;
810		810
811	declmod:	811	declmod:
812	T_QUAL {	812	T_QUAL {
813	add_qualifier($1);	813	add_qualifier($1);
814	}	814	}
815	\| T_SCLASS {	815	\| T_SCLASS {
816	add_storage_class($1);	816	add_storage_class($1);
817	}	817	}
818	\| type_attribute_list	818	\| type_attribute_list
819	;	819	;
820		820
821	type_attribute_list:	821	type_attribute_list:
822	type_attribute	822	type_attribute
823	\| type_attribute_list type_attribute	823	\| type_attribute_list type_attribute
824	;	824	;
825		825
826	type_attribute_opt:	826	type_attribute_opt:
827	/* empty */	827	/* empty */
828	\| type_attribute	828	\| type_attribute
829	;	829	;
830		830
831	type_attribute: /* See C11 6.7 declaration-specifiers */	831	type_attribute: /* See C11 6.7 declaration-specifiers */
832	T_ATTRIBUTE T_LPAREN T_LPAREN {	832	T_ATTRIBUTE T_LPAREN T_LPAREN {
833	attron = true;	833	attron = true;
834	} gcc_attribute_spec_list {	834	} gcc_attribute_spec_list {
835	attron = false;	835	attron = false;
836	} T_RPAREN T_RPAREN	836	} T_RPAREN T_RPAREN
837	\| T_ALIGNAS T_LPAREN align_as T_RPAREN	837	\| T_ALIGNAS T_LPAREN align_as T_RPAREN
838	\| T_PACKED {	838	\| T_PACKED {
839	addpacked();	839	addpacked();
840	}	840	}
841	\| T_NORETURN	841	\| T_NORETURN
842	;	842	;
843		843
844	align_as: /* See alignment-specifier in C11 6.7.5 */	844	align_as: /* See alignment-specifier in C11 6.7.5 */
845	type_specifier	845	type_specifier
846	\| constant_expr	846	\| constant_expr
847	;	847	;
848		848
849	begin_type:	849	begin_type:
850	/* empty */ {	850	/* empty */ {
851	begin_type();	851	begin_type();
852	}	852	}
853	;	853	;
854		854
855	end_type:	855	end_type:
856	/* empty */ {	856	/* empty */ {
857	end_type();	857	end_type();
858	}	858	}
859	;	859	;
860		860
861	type_specifier: /* C99 6.7.2 */	861	type_specifier: /* C99 6.7.2 */
862	notype_type_specifier	862	notype_type_specifier
863	\| T_TYPENAME {	863	\| T_TYPENAME {
864	$$ = getsym($1)->s_type;	864	$$ = getsym($1)->s_type;
865	}	865	}
866	;	866	;
867		867
868	notype_type_specifier: /* see C99 6.7.2 */	868	notype_type_specifier: /* see C99 6.7.2 */
869	T_TYPE {	869	T_TYPE {
870	$$ = gettyp($1);	870	$$ = gettyp($1);
871	}	871	}
872	\| T_TYPEOF cast_expression { /* GCC extension */	872	\| T_TYPEOF cast_expression { /* GCC extension */
873	$$ = $2->tn_type;	873	$$ = $2->tn_type;
874	}	874	}
875	\| struct_or_union_specifier {	875	\| struct_or_union_specifier {
876	end_declaration_level();	876	end_declaration_level();
877	$$ = $1;	877	$$ = $1;
878	}	878	}
879	\| enum_specifier {	879	\| enum_specifier {
880	end_declaration_level();	880	end_declaration_level();
881	$$ = $1;	881	$$ = $1;
882	}	882	}
883	;	883	;
884		884
885	struct_or_union_specifier: /* C99 6.7.2.1 */	885	struct_or_union_specifier: /* C99 6.7.2.1 */
886	struct_or_union identifier_sym {	886	struct_or_union identifier_sym {
887	/*	887	/*
888	* STDC requires that "struct a;" always introduces	888	* STDC requires that "struct a;" always introduces
889	* a new tag if "a" is not declared at current level	889	* a new tag if "a" is not declared at current level
890	*	890	*
891	* yychar is valid because otherwise the parser would not	891	* yychar is valid because otherwise the parser would not
892	* have been able to decide if it must shift or reduce	892	* have been able to decide if it must shift or reduce
893	*/	893	*/
894	$$ = mktag($2, $1, false, yychar == T_SEMI);	894	$$ = mktag($2, $1, false, yychar == T_SEMI);
895	}	895	}
896	\| struct_or_union identifier_sym {	896	\| struct_or_union identifier_sym {
897	dcs->d_tagtyp = mktag($2, $1, true, false);	897	dcs->d_tagtyp = mktag($2, $1, true, false);
898	} braced_struct_declaration_list {	898	} braced_struct_declaration_list {
899	$$ = complete_tag_struct_or_union(dcs->d_tagtyp, $4);	899	$$ = complete_tag_struct_or_union(dcs->d_tagtyp, $4);
900	}	900	}
901	\| struct_or_union {	901	\| struct_or_union {
902	dcs->d_tagtyp = mktag(NULL, $1, true, false);	902	dcs->d_tagtyp = mktag(NULL, $1, true, false);
903	} braced_struct_declaration_list {	903	} braced_struct_declaration_list {
904	$$ = complete_tag_struct_or_union(dcs->d_tagtyp, $3);	904	$$ = complete_tag_struct_or_union(dcs->d_tagtyp, $3);
905	}	905	}
906	\| struct_or_union error {	906	\| struct_or_union error {
907	symtyp = FVFT;	907	symtyp = FVFT;
908	$$ = gettyp(INT);	908	$$ = gettyp(INT);
909	}	909	}
910	;	910	;
911		911
912	struct_or_union: /* C99 6.7.2.1 */	912	struct_or_union: /* C99 6.7.2.1 */
913	struct_or_union type_attribute	913	struct_or_union type_attribute
914	\| T_STRUCT_OR_UNION {	914	\| T_STRUCT_OR_UNION {
915	symtyp = FTAG;	915	symtyp = FTAG;
916	begin_declaration_level($1 == STRUCT ? MOS : MOU);	916	begin_declaration_level($1 == STRUCT ? MOS : MOU);
917	dcs->d_offset = 0;	917	dcs->d_offset = 0;
918	dcs->d_sou_align_in_bits = CHAR_SIZE;	918	dcs->d_sou_align_in_bits = CHAR_SIZE;
919	$$ = $1;	919	$$ = $1;
920	}	920	}
921	;	921	;
922		922
923	braced_struct_declaration_list: /* see C99 6.7.2.1 */	923	braced_struct_declaration_list: /* see C99 6.7.2.1 */
924	struct_declaration_lbrace struct_declaration_list_with_rbrace {	924	struct_declaration_lbrace struct_declaration_list_with_rbrace {
925	$$ = $2;	925	$$ = $2;
926	}	926	}
927	;	927	;
928		928
929	struct_declaration_lbrace: /* see C99 6.7.2.1 */	929	struct_declaration_lbrace: /* see C99 6.7.2.1 */
930	T_LBRACE {	930	T_LBRACE {
931	symtyp = FVFT;	931	symtyp = FVFT;
932	}	932	}
933	;	933	;
934		934
935	struct_declaration_list_with_rbrace: /* see C99 6.7.2.1 */	935	struct_declaration_list_with_rbrace: /* see C99 6.7.2.1 */
936	struct_declaration_list T_SEMI T_RBRACE	936	struct_declaration_list T_RBRACE
937	\| struct_declaration_list T_RBRACE {
938	if (sflag) {
939	/* syntax req. ';' after last struct/union member */
940	error(66);
941	} else {
942	/* syntax req. ';' after last struct/union member */
943	warning(66);
944	}
945	$$ = $1;
946	}
947	\| T_RBRACE {	937	\| T_RBRACE {
		938	/* XXX: This is not allowed by any C standard. */
948	$$ = NULL;	939	$$ = NULL;
949	}	940	}
950	;	941	;
951		942
952	struct_declaration_list: /* C99 6.7.2.1 */	943	struct_declaration_list: /* C99 6.7.2.1 */
953	struct_declaration	944	struct_declaration
954	\| struct_declaration_list T_SEMI struct_declaration {	945	\| struct_declaration_list struct_declaration {
955	$$ = lnklst($1, $3);	946	$$ = lnklst($1, $2);
956	}	947	}
957	;	948	;
958		949
959	struct_declaration: /* C99 6.7.2.1 */	950	struct_declaration: /* C99 6.7.2.1 */
960	begin_type_noclass_declmods end_type {	951	begin_type_noclass_declmods end_type {
961	/* too late, i know, but getsym() compensates it */	952	/* too late, i know, but getsym() compensates it */
962	symtyp = FMEMBER;	953	symtyp = FMEMBER;
963	} notype_struct_declarators type_attribute_opt {	954	} notype_struct_declarators type_attribute_opt T_SEMI {
964	symtyp = FVFT;	955	symtyp = FVFT;
965	$$ = $4;	956	$$ = $4;
966	}	957	}
967	\| begin_type_noclass_declspecs end_type {	958	\| begin_type_noclass_declspecs end_type {
968	symtyp = FMEMBER;	959	symtyp = FMEMBER;
969	} type_struct_declarators type_attribute_opt {	960	} type_struct_declarators type_attribute_opt T_SEMI {
970	symtyp = FVFT;	961	symtyp = FVFT;
971	$$ = $4;	962	$$ = $4;
972	}	963	}
973	\| begin_type_noclass_declmods end_type type_attribute_opt {	964	\| begin_type_noclass_declmods end_type type_attribute_opt T_SEMI {
974	/* syntax error '%s' */	965	/* syntax error '%s' */
975	error(249, "member without type");	966	error(249, "member without type");
976	$$ = NULL;	967	$$ = NULL;
977	}	968	}
978	\| begin_type_noclass_declspecs end_type type_attribute_opt {	969	\| begin_type_noclass_declspecs end_type type_attribute_opt T_SEMI {
979	symtyp = FVFT;	970	symtyp = FVFT;
980	if (!Sflag)	971	if (!Sflag)
981	/* anonymous struct/union members is a C9X feature */	972	/* anonymous struct/union members is a C9X feature */
982	warning(49);	973	warning(49);
983	if (is_struct_or_union(dcs->d_type->t_tspec)) {	974	if (is_struct_or_union(dcs->d_type->t_tspec)) {
984	$$ = dcs->d_type->t_str->sou_first_member;	975	$$ = dcs->d_type->t_str->sou_first_member;
985	/* add all the members of the anonymous struct/union */	976	/* add all the members of the anonymous struct/union */
986	anonymize($$);	977	anonymize($$);
987	} else {	978	} else {
988	/* syntax error '%s' */	979	/* syntax error '%s' */
989	error(249, "unnamed member");	980	error(249, "unnamed member");
990	$$ = NULL;	981	$$ = NULL;
991	}	982	}
992	}	983	}
993	\| error {	984	\| error T_SEMI {
994	symtyp = FVFT;	985	symtyp = FVFT;
995	$$ = NULL;	986	$$ = NULL;
996	}	987	}
997	;	988	;
998		989
999	notype_struct_declarators:	990	notype_struct_declarators:
1000	notype_struct_declarator {	991	notype_struct_declarator {
1001	$$ = declarator_1_struct_union($1);	992	$$ = declarator_1_struct_union($1);
1002	}	993	}
1003	\| notype_struct_declarators {	994	\| notype_struct_declarators {
1004	symtyp = FMEMBER;	995	symtyp = FMEMBER;
1005	} T_COMMA type_struct_declarator {	996	} T_COMMA type_struct_declarator {
1006	$$ = lnklst($1, declarator_1_struct_union($4));	997	$$ = lnklst($1, declarator_1_struct_union($4));
1007	}	998	}
1008	;	999	;
1009		1000
1010	type_struct_declarators:	1001	type_struct_declarators:
1011	type_struct_declarator {	1002	type_struct_declarator {
1012	$$ = declarator_1_struct_union($1);	1003	$$ = declarator_1_struct_union($1);
1013	}	1004	}
1014	\| type_struct_declarators {	1005	\| type_struct_declarators {
1015	symtyp = FMEMBER;	1006	symtyp = FMEMBER;
1016	} T_COMMA type_struct_declarator {	1007	} T_COMMA type_struct_declarator {
1017	$$ = lnklst($1, declarator_1_struct_union($4));	1008	$$ = lnklst($1, declarator_1_struct_union($4));
1018	}	1009	}
1019	;	1010	;
1020		1011
1021	notype_struct_declarator:	1012	notype_struct_declarator:
1022	notype_declarator	1013	notype_declarator
1023	\| notype_declarator T_COLON constant_expr { /* C99 6.7.2.1 */	1014	\| notype_declarator T_COLON constant_expr { /* C99 6.7.2.1 */
1024	$$ = bitfield($1, to_int_constant($3, true));	1015	$$ = bitfield($1, to_int_constant($3, true));
1025	}	1016	}
1026	\| {	1017	\| {
1027	symtyp = FVFT;	1018	symtyp = FVFT;
1028	} T_COLON constant_expr { /* C99 6.7.2.1 */	1019	} T_COLON constant_expr { /* C99 6.7.2.1 */
1029	$$ = bitfield(NULL, to_int_constant($3, true));	1020	$$ = bitfield(NULL, to_int_constant($3, true));
1030	}	1021	}
1031	;	1022	;
1032		1023
1033	type_struct_declarator:	1024	type_struct_declarator:
1034	type_declarator	1025	type_declarator
1035	\| type_declarator T_COLON constant_expr {	1026	\| type_declarator T_COLON constant_expr {
1036	$$ = bitfield($1, to_int_constant($3, true));	1027	$$ = bitfield($1, to_int_constant($3, true));
1037	}	1028	}
1038	\| {	1029	\| {
1039	symtyp = FVFT;	1030	symtyp = FVFT;
1040	} T_COLON constant_expr {	1031	} T_COLON constant_expr {
1041	$$ = bitfield(NULL, to_int_constant($3, true));	1032	$$ = bitfield(NULL, to_int_constant($3, true));
1042	}	1033	}
1043	;	1034	;
1044		1035
1045	enum_specifier: /* C99 6.7.2.2 */	1036	enum_specifier: /* C99 6.7.2.2 */
1046	enum identifier_sym {	1037	enum identifier_sym {
1047	$$ = mktag($2, ENUM, false, false);	1038	$$ = mktag($2, ENUM, false, false);
1048	}	1039	}
1049	\| enum identifier_sym {	1040	\| enum identifier_sym {
1050	dcs->d_tagtyp = mktag($2, ENUM, true, false);	1041	dcs->d_tagtyp = mktag($2, ENUM, true, false);
1051	} enum_declaration {	1042	} enum_declaration {
1052	$$ = complete_tag_enum(dcs->d_tagtyp, $4);	1043	$$ = complete_tag_enum(dcs->d_tagtyp, $4);
1053	}	1044	}
1054	\| enum {	1045	\| enum {
1055	dcs->d_tagtyp = mktag(NULL, ENUM, true, false);	1046	dcs->d_tagtyp = mktag(NULL, ENUM, true, false);
1056	} enum_declaration {	1047	} enum_declaration {
1057	$$ = complete_tag_enum(dcs->d_tagtyp, $3);	1048	$$ = complete_tag_enum(dcs->d_tagtyp, $3);
1058	}	1049	}
1059	\| enum error {	1050	\| enum error {
1060	symtyp = FVFT;	1051	symtyp = FVFT;
1061	$$ = gettyp(INT);	1052	$$ = gettyp(INT);
1062	}	1053	}
1063	;	1054	;
1064		1055
1065	enum: /* helper for C99 6.7.2.2 */	1056	enum: /* helper for C99 6.7.2.2 */
1066	T_ENUM {	1057	T_ENUM {
1067	symtyp = FTAG;	1058	symtyp = FTAG;
1068	begin_declaration_level(CTCONST);	1059	begin_declaration_level(CTCONST);
1069	}	1060	}
1070	;	1061	;
1071		1062
1072	enum_declaration: /* helper for C99 6.7.2.2 */	1063	enum_declaration: /* helper for C99 6.7.2.2 */
1073	enum_decl_lbrace enums_with_opt_comma T_RBRACE {	1064	enum_decl_lbrace enums_with_opt_comma T_RBRACE {
1074	$$ = $2;	1065	$$ = $2;
1075	}	1066	}
1076	;	1067	;
1077		1068
1078	enum_decl_lbrace: /* helper for C99 6.7.2.2 */	1069	enum_decl_lbrace: /* helper for C99 6.7.2.2 */
1079	T_LBRACE {	1070	T_LBRACE {
1080	symtyp = FVFT;	1071	symtyp = FVFT;
1081	enumval = 0;	1072	enumval = 0;
1082	}	1073	}
1083	;	1074	;
1084		1075
1085	enums_with_opt_comma: /* helper for C99 6.7.2.2 */	1076	enums_with_opt_comma: /* helper for C99 6.7.2.2 */
1086	enumerator_list	1077	enumerator_list
1087	\| enumerator_list T_COMMA {	1078	\| enumerator_list T_COMMA {
1088	if (sflag) {	1079	if (sflag) {
1089	/* trailing ',' prohibited in enum declaration */	1080	/* trailing ',' prohibited in enum declaration */
1090	error(54);	1081	error(54);
1091	} else {	1082	} else {
1092	/* trailing ',' prohibited in enum declaration */	1083	/* trailing ',' prohibited in enum declaration */
1093	c99ism(54);	1084	c99ism(54);
1094	}	1085	}
1095	$$ = $1;	1086	$$ = $1;
1096	}	1087	}
1097	;	1088	;
1098		1089
1099	enumerator_list: /* C99 6.7.2.2 */	1090	enumerator_list: /* C99 6.7.2.2 */
1100	enumerator	1091	enumerator
1101	\| enumerator_list T_COMMA enumerator {	1092	\| enumerator_list T_COMMA enumerator {
1102	$$ = lnklst($1, $3);	1093	$$ = lnklst($1, $3);
1103	}	1094	}
1104	\| error {	1095	\| error {
1105	$$ = NULL;	1096	$$ = NULL;
1106	}	1097	}
1107	;	1098	;
1108		1099
1109	enumerator: /* C99 6.7.2.2 */	1100	enumerator: /* C99 6.7.2.2 */
1110	identifier_sym {	1101	identifier_sym {
1111	$$ = enumeration_constant($1, enumval, true);	1102	$$ = enumeration_constant($1, enumval, true);
1112	}	1103	}
1113	\| identifier_sym T_ASSIGN constant_expr {	1104	\| identifier_sym T_ASSIGN constant_expr {
1114	$$ = enumeration_constant($1, to_int_constant($3, true), false);	1105	$$ = enumeration_constant($1, to_int_constant($3, true), false);
1115	}	1106	}
1116	;	1107	;
1117		1108
1118	type_qualifier: /* C99 6.7.3 */	1109	type_qualifier: /* C99 6.7.3 */
1119	T_QUAL {	1110	T_QUAL {
1120	$$ = xcalloc(1, sizeof(*$$));	1111	$$ = xcalloc(1, sizeof(*$$));
1121	if ($1 == CONST) {	1112	if ($1 == CONST) {
1122	$$->p_const = true;	1113	$$->p_const = true;
1123	} else if ($1 == VOLATILE) {	1114	} else if ($1 == VOLATILE) {
1124	$$->p_volatile = true;	1115	$$->p_volatile = true;
1125	} else {	1116	} else {
1126	lint_assert($1 == RESTRICT \|\| $1 == THREAD);	1117	lint_assert($1 == RESTRICT \|\| $1 == THREAD);
1127	}	1118	}
1128	}	1119	}
1129	;	1120	;
1130		1121
1131	pointer: /* C99 6.7.5 */	1122	pointer: /* C99 6.7.5 */
1132	asterisk type_qualifier_list_opt {	1123	asterisk type_qualifier_list_opt {
1133	$$ = merge_qualified_pointer($1, $2);	1124	$$ = merge_qualified_pointer($1, $2);
1134	}	1125	}
1135	\| asterisk type_qualifier_list_opt pointer {	1126	\| asterisk type_qualifier_list_opt pointer {
1136	$$ = merge_qualified_pointer($1, $2);	1127	$$ = merge_qualified_pointer($1, $2);
1137	$$ = merge_qualified_pointer($$, $3);	1128	$$ = merge_qualified_pointer($$, $3);
1138	}	1129	}
1139	;	1130	;
1140		1131
1141	asterisk: /* helper for 'pointer' */	1132	asterisk: /* helper for 'pointer' */
1142	T_ASTERISK {	1133	T_ASTERISK {
1143	$$ = xcalloc(1, sizeof(*$$));	1134	$$ = xcalloc(1, sizeof(*$$));
1144	$$->p_pointer = true;	1135	$$->p_pointer = true;
1145	}	1136	}
1146	;	1137	;
1147		1138
1148	type_qualifier_list_opt: /* see C99 6.7.5 */	1139	type_qualifier_list_opt: /* see C99 6.7.5 */
1149	/* empty */ {	1140	/* empty */ {
1150	$$ = NULL;	1141	$$ = NULL;
1151	}	1142	}
1152	\| type_qualifier_list	1143	\| type_qualifier_list
1153	;	1144	;
1154		1145
1155	type_qualifier_list: /* C99 6.7.5 */	1146	type_qualifier_list: /* C99 6.7.5 */
1156	type_qualifier	1147	type_qualifier
1157	\| type_qualifier_list type_qualifier {	1148	\| type_qualifier_list type_qualifier {
1158	$$ = merge_qualified_pointer($1, $2);	1149	$$ = merge_qualified_pointer($1, $2);
1159	}	1150	}
1160	;	1151	;
1161		1152
1162	/*	1153	/*
1163	* For an explanation of 'notype' in the following rules, see the Bison	1154	* For an explanation of 'notype' in the following rules, see the Bison
1164	* manual, section 7.1 "Semantic Info in Token Kinds".	1155	* manual, section 7.1 "Semantic Info in Token Kinds".
1165	*/	1156	*/
1166		1157
1167	notype_init_declarators:	1158	notype_init_declarators:
1168	notype_init_declarator	1159	notype_init_declarator
1169	\| notype_init_declarators T_COMMA type_init_declarator	1160	\| notype_init_declarators T_COMMA type_init_declarator
1170	;	1161	;
1171		1162
1172	type_init_declarators:	1163	type_init_declarators:
1173	type_init_declarator	1164	type_init_declarator
1174	\| type_init_declarators T_COMMA type_init_declarator	1165	\| type_init_declarators T_COMMA type_init_declarator
1175	;	1166	;
1176		1167
1177	notype_init_declarator:	1168	notype_init_declarator:
1178	notype_declarator asm_or_symbolrename_opt {	1169	notype_declarator asm_or_symbolrename_opt {
1179	cgram_declare($1, false, $2);	1170	cgram_declare($1, false, $2);
1180	check_size($1);	1171	check_size($1);
1181	}	1172	}
1182	\| notype_declarator asm_or_symbolrename_opt {	1173	\| notype_declarator asm_or_symbolrename_opt {
1183	begin_initialization($1);	1174	begin_initialization($1);
1184	cgram_declare($1, true, $2);	1175	cgram_declare($1, true, $2);
1185	} T_ASSIGN initializer {	1176	} T_ASSIGN initializer {
1186	check_size($1);	1177	check_size($1);
1187	end_initialization();	1178	end_initialization();
1188	}	1179	}
1189	;	1180	;
1190		1181
1191	type_init_declarator:	1182	type_init_declarator:
1192	type_declarator asm_or_symbolrename_opt {	1183	type_declarator asm_or_symbolrename_opt {
1193	cgram_declare($1, false, $2);	1184	cgram_declare($1, false, $2);
1194	check_size($1);	1185	check_size($1);
1195	}	1186	}
1196	\| type_declarator asm_or_symbolrename_opt {	1187	\| type_declarator asm_or_symbolrename_opt {
1197	begin_initialization($1);	1188	begin_initialization($1);
1198	cgram_declare($1, true, $2);	1189	cgram_declare($1, true, $2);
1199	} T_ASSIGN initializer {	1190	} T_ASSIGN initializer {
1200	check_size($1);	1191	check_size($1);
1201	end_initialization();	1192	end_initialization();
1202	}	1193	}
1203	;	1194	;
1204		1195
1205	notype_declarator:	1196	notype_declarator:
1206	notype_direct_declarator	1197	notype_direct_declarator
1207	\| pointer notype_direct_declarator {	1198	\| pointer notype_direct_declarator {
1208	$$ = add_pointer($2, $1);	1199	$$ = add_pointer($2, $1);
1209	}	1200	}
1210	;	1201	;
1211		1202
1212	type_declarator:	1203	type_declarator:
1213	type_direct_declarator	1204	type_direct_declarator
1214	\| pointer type_direct_declarator {	1205	\| pointer type_direct_declarator {
1215	$$ = add_pointer($2, $1);	1206	$$ = add_pointer($2, $1);
1216	}	1207	}
1217	;	1208	;
1218		1209
1219	notype_direct_declarator:	1210	notype_direct_declarator:
1220	T_NAME {	1211	T_NAME {
1221	$$ = declarator_name(getsym($1));	1212	$$ = declarator_name(getsym($1));
1222	}	1213	}
1223	\| T_LPAREN type_declarator T_RPAREN {	1214	\| T_LPAREN type_declarator T_RPAREN {
1224	$$ = $2;	1215	$$ = $2;
1225	}	1216	}
1226	\| type_attribute notype_direct_declarator {	1217	\| type_attribute notype_direct_declarator {
1227	$$ = $2;	1218	$$ = $2;
1228	}	1219	}
1229	\| notype_direct_declarator T_LBRACK T_RBRACK {	1220	\| notype_direct_declarator T_LBRACK T_RBRACK {
1230	$$ = add_array($1, false, 0);	1221	$$ = add_array($1, false, 0);
1231	}	1222	}
1232	\| notype_direct_declarator T_LBRACK array_size T_RBRACK {	1223	\| notype_direct_declarator T_LBRACK array_size T_RBRACK {
1233	$$ = add_array($1, true, to_int_constant($3, false));	1224	$$ = add_array($1, true, to_int_constant($3, false));
1234	}	1225	}
1235	\| notype_direct_declarator param_list asm_or_symbolrename_opt {	1226	\| notype_direct_declarator param_list asm_or_symbolrename_opt {
1236	$$ = add_function(symbolrename($1, $3), $2);	1227	$$ = add_function(symbolrename($1, $3), $2);
1237	end_declaration_level();	1228	end_declaration_level();
1238	block_level--;	1229	block_level--;
1239	}	1230	}
1240	\| notype_direct_declarator type_attribute	1231	\| notype_direct_declarator type_attribute
1241	;	1232	;
1242		1233
1243	type_direct_declarator:	1234	type_direct_declarator:
1244	identifier {	1235	identifier {
1245	$$ = declarator_name(getsym($1));	1236	$$ = declarator_name(getsym($1));
1246	}	1237	}
1247	\| T_LPAREN type_declarator T_RPAREN {	1238	\| T_LPAREN type_declarator T_RPAREN {
1248	$$ = $2;	1239	$$ = $2;
1249	}	1240	}
1250	\| type_attribute type_direct_declarator {	1241	\| type_attribute type_direct_declarator {
1251	$$ = $2;	1242	$$ = $2;
1252	}	1243	}
1253	\| type_direct_declarator T_LBRACK T_RBRACK {	1244	\| type_direct_declarator T_LBRACK T_RBRACK {
1254	$$ = add_array($1, false, 0);	1245	$$ = add_array($1, false, 0);
1255	}	1246	}
1256	\| type_direct_declarator T_LBRACK array_size T_RBRACK {	1247	\| type_direct_declarator T_LBRACK array_size T_RBRACK {
1257	$$ = add_array($1, true, to_int_constant($3, false));	1248	$$ = add_array($1, true, to_int_constant($3, false));
1258	}	1249	}
1259	\| type_direct_declarator param_list asm_or_symbolrename_opt {	1250	\| type_direct_declarator param_list asm_or_symbolrename_opt {
1260	$$ = add_function(symbolrename($1, $3), $2);	1251	$$ = add_function(symbolrename($1, $3), $2);
1261	end_declaration_level();	1252	end_declaration_level();
1262	block_level--;	1253	block_level--;
1263	}	1254	}
1264	\| type_direct_declarator type_attribute	1255	\| type_direct_declarator type_attribute
1265	;	1256	;
1266		1257
1267	/*	1258	/*
1268	* The two distinct rules type_param_declarator and notype_param_declarator avoid a	1259	* The two distinct rules type_param_declarator and notype_param_declarator avoid a
1269	* conflict in argument lists. A typename enclosed in parentheses is always	1260	* conflict in argument lists. A typename enclosed in parentheses is always
1270	* treated as a typename, not an argument name. For example, after	1261	* treated as a typename, not an argument name. For example, after
1271	* "typedef double a;", the declaration "f(int (a));" is interpreted as	1262	* "typedef double a;", the declaration "f(int (a));" is interpreted as
1272	* "f(int (double));", not "f(int a);".	1263	* "f(int (double));", not "f(int a);".
1273	*/	1264	*/
1274	type_param_declarator:	1265	type_param_declarator:
1275	direct_param_declarator	1266	direct_param_declarator
1276	\| pointer direct_param_declarator {	1267	\| pointer direct_param_declarator {
1277	$$ = add_pointer($2, $1);	1268	$$ = add_pointer($2, $1);
1278	}	1269	}
1279	;	1270	;
1280		1271
1281	notype_param_declarator:	1272	notype_param_declarator:
1282	direct_notype_param_declarator	1273	direct_notype_param_declarator
1283	\| pointer direct_notype_param_declarator {	1274	\| pointer direct_notype_param_declarator {
1284	$$ = add_pointer($2, $1);	1275	$$ = add_pointer($2, $1);
1285	}	1276	}
1286	;	1277	;
1287		1278
1288	direct_param_declarator:	1279	direct_param_declarator:
1289	identifier type_attribute_list {	1280	identifier type_attribute_list {
1290	$$ = declarator_name(getsym($1));	1281	$$ = declarator_name(getsym($1));
1291	}	1282	}
1292	\| identifier {	1283	\| identifier {
1293	$$ = declarator_name(getsym($1));	1284	$$ = declarator_name(getsym($1));
1294	}	1285	}
1295	\| T_LPAREN notype_param_declarator T_RPAREN {	1286	\| T_LPAREN notype_param_declarator T_RPAREN {
1296	$$ = $2;	1287	$$ = $2;
1297	}	1288	}
1298	\| direct_param_declarator T_LBRACK T_RBRACK {	1289	\| direct_param_declarator T_LBRACK T_RBRACK {
1299	$$ = add_array($1, false, 0);	1290	$$ = add_array($1, false, 0);
1300	}	1291	}
1301	\| direct_param_declarator T_LBRACK array_size T_RBRACK {	1292	\| direct_param_declarator T_LBRACK array_size T_RBRACK {
1302	$$ = add_array($1, true, to_int_constant($3, false));	1293	$$ = add_array($1, true, to_int_constant($3, false));
1303	}	1294	}
1304	\| direct_param_declarator param_list asm_or_symbolrename_opt {	1295	\| direct_param_declarator param_list asm_or_symbolrename_opt {
1305	$$ = add_function(symbolrename($1, $3), $2);	1296	$$ = add_function(symbolrename($1, $3), $2);
1306	end_declaration_level();	1297	end_declaration_level();
1307	block_level--;	1298	block_level--;
1308	}	1299	}
1309	;	1300	;
1310		1301
1311	direct_notype_param_declarator:	1302	direct_notype_param_declarator:
1312	identifier {	1303	identifier {
1313	$$ = declarator_name(getsym($1));	1304	$$ = declarator_name(getsym($1));
1314	}	1305	}
1315	\| T_LPAREN notype_param_declarator T_RPAREN {	1306	\| T_LPAREN notype_param_declarator T_RPAREN {
1316	$$ = $2;	1307	$$ = $2;
1317	}	1308	}
1318	\| direct_notype_param_declarator T_LBRACK T_RBRACK {	1309	\| direct_notype_param_declarator T_LBRACK T_RBRACK {
1319	$$ = add_array($1, false, 0);	1310	$$ = add_array($1, false, 0);
1320	}	1311	}
1321	\| direct_notype_param_declarator T_LBRACK array_size T_RBRACK {	1312	\| direct_notype_param_declarator T_LBRACK array_size T_RBRACK {
1322	$$ = add_array($1, true, to_int_constant($3, false));	1313	$$ = add_array($1, true, to_int_constant($3, false));
1323	}	1314	}
1324	\| direct_notype_param_declarator param_list asm_or_symbolrename_opt {	1315	\| direct_notype_param_declarator param_list asm_or_symbolrename_opt {
1325	$$ = add_function(symbolrename($1, $3), $2);	1316	$$ = add_function(symbolrename($1, $3), $2);
1326	end_declaration_level();	1317	end_declaration_level();
1327	block_level--;	1318	block_level--;
1328	}	1319	}
1329	;	1320	;
1330		1321
1331	param_list:	1322	param_list:
1332	id_list_lparen identifier_list T_RPAREN {	1323	id_list_lparen identifier_list T_RPAREN {
1333	$$ = $2;	1324	$$ = $2;
1334	}	1325	}
1335	\| abstract_decl_param_list	1326	\| abstract_decl_param_list
1336	;	1327	;
1337		1328
1338	id_list_lparen:	1329	id_list_lparen:
1339	T_LPAREN {	1330	T_LPAREN {
1340	block_level++;	1331	block_level++;
1341	begin_declaration_level(PROTO_ARG);	1332	begin_declaration_level(PROTO_ARG);
1342	}	1333	}
1343	;	1334	;
1344		1335
1345	array_size:	1336	array_size:
1346	type_qualifier_list_opt T_SCLASS constant_expr {	1337	type_qualifier_list_opt T_SCLASS constant_expr {
1347	/* C11 6.7.6.3p7 */	1338	/* C11 6.7.6.3p7 */
1348	if ($2 != STATIC)	1339	if ($2 != STATIC)
1349	yyerror("Bad attribute");	1340	yyerror("Bad attribute");
1350	/* static array size is a C11 extension */	1341	/* static array size is a C11 extension */
1351	c11ism(343);	1342	c11ism(343);
1352	$$ = $3;	1343	$$ = $3;
1353	}	1344	}
1354	\| constant_expr	1345	\| constant_expr
1355	;	1346	;
1356		1347
1357	identifier_list: /* C99 6.7.5 */	1348	identifier_list: /* C99 6.7.5 */
1358	T_NAME {	1349	T_NAME {
1359	$$ = old_style_function_name(getsym($1));	1350	$$ = old_style_function_name(getsym($1));
1360	}	1351	}
1361	\| identifier_list T_COMMA T_NAME {	1352	\| identifier_list T_COMMA T_NAME {
1362	$$ = lnklst($1, old_style_function_name(getsym($3)));	1353	$$ = lnklst($1, old_style_function_name(getsym($3)));
1363	}	1354	}
1364	\| identifier_list error	1355	\| identifier_list error
1365	;	1356	;
1366		1357
1367	/* XXX: C99 requires an additional specifier-qualifier-list. */	1358	/* XXX: C99 requires an additional specifier-qualifier-list. */
1368	type_name: /* C99 6.7.6 */	1359	type_name: /* C99 6.7.6 */
1369	{	1360	{
1370	begin_declaration_level(ABSTRACT);	1361	begin_declaration_level(ABSTRACT);
1371	} abstract_declaration {	1362	} abstract_declaration {
1372	end_declaration_level();	1363	end_declaration_level();
1373	$$ = $2->s_type;	1364	$$ = $2->s_type;
1374	}	1365	}
1375	;	1366	;
1376		1367
1377	abstract_declaration:	1368	abstract_declaration:
1378	begin_type_noclass_declmods end_type {	1369	begin_type_noclass_declmods end_type {
1379	$$ = declare_1_abstract(abstract_name());	1370	$$ = declare_1_abstract(abstract_name());
1380	}	1371	}
1381	\| begin_type_noclass_declspecs end_type {	1372	\| begin_type_noclass_declspecs end_type {
1382	$$ = declare_1_abstract(abstract_name());	1373	$$ = declare_1_abstract(abstract_name());
1383	}	1374	}
1384	\| begin_type_noclass_declmods end_type abstract_declarator {	1375	\| begin_type_noclass_declmods end_type abstract_declarator {
1385	$$ = declare_1_abstract($3);	1376	$$ = declare_1_abstract($3);
1386	}	1377	}
1387	\| begin_type_noclass_declspecs end_type abstract_declarator {	1378	\| begin_type_noclass_declspecs end_type abstract_declarator {
1388	$$ = declare_1_abstract($3);	1379	$$ = declare_1_abstract($3);
1389	}	1380	}
1390	;	1381	;
1391		1382
1392	abstract_declarator: /* C99 6.7.6 */	1383	abstract_declarator: /* C99 6.7.6 */
1393	pointer {	1384	pointer {
1394	$$ = add_pointer(abstract_name(), $1);	1385	$$ = add_pointer(abstract_name(), $1);
1395	}	1386	}
1396	\| direct_abstract_declarator	1387	\| direct_abstract_declarator
1397	\| pointer direct_abstract_declarator {	1388	\| pointer direct_abstract_declarator {
1398	$$ = add_pointer($2, $1);	1389	$$ = add_pointer($2, $1);
1399	}	1390	}
1400	\| T_TYPEOF cast_expression { /* GCC extension */	1391	\| T_TYPEOF cast_expression { /* GCC extension */
1401	$$ = mktempsym($2->tn_type);	1392	$$ = mktempsym($2->tn_type);
1402	}	1393	}
1403	;	1394	;
1404		1395
1405	direct_abstract_declarator: /* C99 6.7.6 */	1396	direct_abstract_declarator: /* C99 6.7.6 */
1406	T_LPAREN abstract_declarator T_RPAREN {	1397	T_LPAREN abstract_declarator T_RPAREN {
1407	$$ = $2;	1398	$$ = $2;
1408	}	1399	}
1409	\| T_LBRACK T_RBRACK {	1400	\| T_LBRACK T_RBRACK {
1410	$$ = add_array(abstract_name(), false, 0);	1401	$$ = add_array(abstract_name(), false, 0);
1411	}	1402	}
1412	\| T_LBRACK array_size T_RBRACK {	1403	\| T_LBRACK array_size T_RBRACK {
1413	$$ = add_array(abstract_name(), true, to_int_constant($2, false));	1404	$$ = add_array(abstract_name(), true, to_int_constant($2, false));
1414	}	1405	}
1415	\| type_attribute direct_abstract_declarator {	1406	\| type_attribute direct_abstract_declarator {
1416	$$ = $2;	1407	$$ = $2;
1417	}	1408	}
1418	\| direct_abstract_declarator T_LBRACK T_RBRACK {	1409	\| direct_abstract_declarator T_LBRACK T_RBRACK {
1419	$$ = add_array($1, false, 0);	1410	$$ = add_array($1, false, 0);
1420	}	1411	}
1421	\| direct_abstract_declarator T_LBRACK T_ASTERISK T_RBRACK { /* C99 */	1412	\| direct_abstract_declarator T_LBRACK T_ASTERISK T_RBRACK { /* C99 */
1422	$$ = add_array($1, false, 0);	1413	$$ = add_array($1, false, 0);
1423	}	1414	}
1424	\| direct_abstract_declarator T_LBRACK array_size T_RBRACK {	1415	\| direct_abstract_declarator T_LBRACK array_size T_RBRACK {
1425	$$ = add_array($1, true, to_int_constant($3, false));	1416	$$ = add_array($1, true, to_int_constant($3, false));
1426	}	1417	}
1427	\| abstract_decl_param_list asm_or_symbolrename_opt {	1418	\| abstract_decl_param_list asm_or_symbolrename_opt {
1428	$$ = add_function(symbolrename(abstract_name(), $2), $1);	1419	$$ = add_function(symbolrename(abstract_name(), $2), $1);
1429	end_declaration_level();	1420	end_declaration_level();
1430	block_level--;	1421	block_level--;
1431	}	1422	}
1432	\| direct_abstract_declarator abstract_decl_param_list asm_or_symbolrename_opt {	1423	\| direct_abstract_declarator abstract_decl_param_list asm_or_symbolrename_opt {
1433	$$ = add_function(symbolrename($1, $3), $2);	1424	$$ = add_function(symbolrename($1, $3), $2);
1434	end_declaration_level();	1425	end_declaration_level();
1435	block_level--;	1426	block_level--;
1436	}	1427	}
1437	\| direct_abstract_declarator type_attribute_list	1428	\| direct_abstract_declarator type_attribute_list
1438	;	1429	;
1439		1430
1440	abstract_decl_param_list:	1431	abstract_decl_param_list:
1441	abstract_decl_lparen T_RPAREN type_attribute_opt {	1432	abstract_decl_lparen T_RPAREN type_attribute_opt {
1442	$$ = NULL;	1433	$$ = NULL;
1443	}	1434	}
1444	\| abstract_decl_lparen vararg_parameter_type_list T_RPAREN type_attribute_opt {	1435	\| abstract_decl_lparen vararg_parameter_type_list T_RPAREN type_attribute_opt {
1445	dcs->d_proto = true;	1436	dcs->d_proto = true;
1446	$$ = $2;	1437	$$ = $2;
1447	}	1438	}
1448	\| abstract_decl_lparen error T_RPAREN type_attribute_opt {	1439	\| abstract_decl_lparen error T_RPAREN type_attribute_opt {
1449	$$ = NULL;	1440	$$ = NULL;
1450	}	1441	}
1451	;	1442	;
1452		1443
1453	abstract_decl_lparen:	1444	abstract_decl_lparen:
1454	T_LPAREN {	1445	T_LPAREN {
1455	block_level++;	1446	block_level++;
1456	begin_declaration_level(PROTO_ARG);	1447	begin_declaration_level(PROTO_ARG);
1457	}	1448	}
1458	;	1449	;
1459		1450
1460	vararg_parameter_type_list:	1451	vararg_parameter_type_list:
1461	parameter_type_list	1452	parameter_type_list
1462	\| parameter_type_list T_COMMA T_ELLIPSIS {	1453	\| parameter_type_list T_COMMA T_ELLIPSIS {
1463	dcs->d_vararg = true;	1454	dcs->d_vararg = true;
1464	$$ = $1;	1455	$$ = $1;
1465	}	1456	}
1466	\| T_ELLIPSIS {	1457	\| T_ELLIPSIS {
1467	if (sflag) {	1458	if (sflag) {
1468	/* ANSI C requires formal parameter before '...' */	1459	/* ANSI C requires formal parameter before '...' */
1469	error(84);	1460	error(84);
1470	} else if (!tflag) {	1461	} else if (!tflag) {
1471	/* ANSI C requires formal parameter before '...' */	1462	/* ANSI C requires formal parameter before '...' */
1472	warning(84);	1463	warning(84);
1473	}	1464	}
1474	dcs->d_vararg = true;	1465	dcs->d_vararg = true;
1475	$$ = NULL;	1466	$$ = NULL;
1476	}	1467	}
1477	;	1468	;
1478		1469
1479	/* XXX: C99 6.7.5 defines the same name, but it looks different. */	1470	/* XXX: C99 6.7.5 defines the same name, but it looks different. */
1480	parameter_type_list:	1471	parameter_type_list:
1481	parameter_declaration	1472	parameter_declaration
1482	\| parameter_type_list T_COMMA parameter_declaration {	1473	\| parameter_type_list T_COMMA parameter_declaration {
1483	$$ = lnklst($1, $3);	1474	$$ = lnklst($1, $3);
1484	}	1475	}
1485	;	1476	;
1486		1477
1487	/* XXX: C99 6.7.5 defines the same name, but it looks completely different. */	1478	/* XXX: C99 6.7.5 defines the same name, but it looks completely different. */
1488	parameter_declaration:	1479	parameter_declaration:
1489	begin_type_declmods end_type {	1480	begin_type_declmods end_type {
1490	$$ = declare_argument(abstract_name(), false);	1481	$$ = declare_argument(abstract_name(), false);
1491	}	1482	}
1492	\| begin_type_declaration_specifiers end_type {	1483	\| begin_type_declaration_specifiers end_type {
1493	$$ = declare_argument(abstract_name(), false);	1484	$$ = declare_argument(abstract_name(), false);
1494	}	1485	}
1495	\| begin_type_declmods end_type notype_param_declarator {	1486	\| begin_type_declmods end_type notype_param_declarator {
1496	$$ = declare_argument($3, false);	1487	$$ = declare_argument($3, false);
1497	}	1488	}
1498	/*	1489	/*
1499	* type_param_declarator is needed because of following conflict:	1490	* type_param_declarator is needed because of following conflict:
1500	* "typedef int a; f(int (a));" could be parsed as	1491	* "typedef int a; f(int (a));" could be parsed as
1501	* "function with argument a of type int", or	1492	* "function with argument a of type int", or
1502	* "function with an abstract argument of type function".	1493	* "function with an abstract argument of type function".
1503	* This grammar realizes the second case.	1494	* This grammar realizes the second case.
1504	*/	1495	*/
1505	\| begin_type_declaration_specifiers end_type type_param_declarator {	1496	\| begin_type_declaration_specifiers end_type type_param_declarator {
1506	$$ = declare_argument($3, false);	1497	$$ = declare_argument($3, false);
1507	}	1498	}
1508	\| begin_type_declmods end_type abstract_declarator {	1499	\| begin_type_declmods end_type abstract_declarator {
1509	$$ = declare_argument($3, false);	1500	$$ = declare_argument($3, false);
1510	}	1501	}
1511	\| begin_type_declaration_specifiers end_type abstract_declarator {	1502	\| begin_type_declaration_specifiers end_type abstract_declarator {
1512	$$ = declare_argument($3, false);	1503	$$ = declare_argument($3, false);
1513	}	1504	}
1514	;	1505	;
1515		1506
1516	initializer: /* C99 6.7.8 "Initialization" */	1507	initializer: /* C99 6.7.8 "Initialization" */
1517	assignment_expression {	1508	assignment_expression {
1518	init_expr($1);	1509	init_expr($1);
1519	}	1510	}
1520	\| init_lbrace init_rbrace {	1511	\| init_lbrace init_rbrace {
1521	/* XXX: Empty braces are not covered by C99 6.7.8. */	1512	/* XXX: Empty braces are not covered by C99 6.7.8. */
1522	}	1513	}
1523	\| init_lbrace initializer_list comma_opt init_rbrace	1514	\| init_lbrace initializer_list comma_opt init_rbrace
1524	\| error	1515	\| error
1525	;	1516	;
1526		1517
1527	initializer_list: /* C99 6.7.8 "Initialization" */	1518	initializer_list: /* C99 6.7.8 "Initialization" */
1528	initializer_list_item	1519	initializer_list_item
1529	\| initializer_list T_COMMA initializer_list_item	1520	\| initializer_list T_COMMA initializer_list_item
1530	;	1521	;
1531		1522
1532	initializer_list_item: /* helper */	1523	initializer_list_item: /* helper */
1533	designation initializer	1524	designation initializer
1534	\| initializer	1525	\| initializer
1535	;	1526	;
1536		1527
1537	designation: /* C99 6.7.8 "Initialization" */	1528	designation: /* C99 6.7.8 "Initialization" */
1538	designator_list T_ASSIGN	1529	designator_list T_ASSIGN
1539	\| identifier T_COLON {	1530	\| identifier T_COLON {
1540	/* GCC style struct or union member name in initializer */	1531	/* GCC style struct or union member name in initializer */
1541	gnuism(315);	1532	gnuism(315);
1542	add_designator_member($1);	1533	add_designator_member($1);
1543	}	1534	}
1544	;	1535	;
1545		1536
1546	designator_list: /* C99 6.7.8 "Initialization" */	1537	designator_list: /* C99 6.7.8 "Initialization" */
1547	designator	1538	designator
1548	\| designator_list designator	1539	\| designator_list designator
1549	;	1540	;
1550		1541
1551	designator: /* C99 6.7.8 "Initialization" */	1542	designator: /* C99 6.7.8 "Initialization" */
1552	T_LBRACK range T_RBRACK {	1543	T_LBRACK range T_RBRACK {
1553	add_designator_subscript($2);	1544	add_designator_subscript($2);
1554	if (!Sflag)	1545	if (!Sflag)
1555	/* array initializer with des.s is a C9X feature */	1546	/* array initializer with des.s is a C9X feature */
1556	warning(321);	1547	warning(321);
1557	}	1548	}
1558	\| T_POINT identifier {	1549	\| T_POINT identifier {
1559	if (!Sflag)	1550	if (!Sflag)
1560	/* struct or union member name in initializer is ... */	1551	/* struct or union member name in initializer is ... */
1561	warning(313);	1552	warning(313);
1562	add_designator_member($2);	1553	add_designator_member($2);
1563	}	1554	}
1564	;	1555	;
1565		1556
1566	range:	1557	range:
1567	constant_expr {	1558	constant_expr {
1568	$$.lo = to_int_constant($1, true);	1559	$$.lo = to_int_constant($1, true);
1569	$$.hi = $$.lo;	1560	$$.hi = $$.lo;
1570	}	1561	}
1571	\| constant_expr T_ELLIPSIS constant_expr {	1562	\| constant_expr T_ELLIPSIS constant_expr {
1572	$$.lo = to_int_constant($1, true);	1563	$$.lo = to_int_constant($1, true);
1573	$$.hi = to_int_constant($3, true);	1564	$$.hi = to_int_constant($3, true);
1574	/* initialization with '[a...b]' is a GCC extension */	1565	/* initialization with '[a...b]' is a GCC extension */
1575	gnuism(340);	1566	gnuism(340);
1576	}	1567	}
1577	;	1568	;
1578		1569
1579	init_lbrace: /* helper */	1570	init_lbrace: /* helper */
1580	T_LBRACE {	1571	T_LBRACE {
1581	init_lbrace();	1572	init_lbrace();
1582	}	1573	}
1583	;	1574	;
1584		1575
1585	init_rbrace: /* helper */	1576	init_rbrace: /* helper */
1586	T_RBRACE {	1577	T_RBRACE {
1587	init_rbrace();	1578	init_rbrace();
1588	}	1579	}
1589	;	1580	;
1590		1581
1591	asm_or_symbolrename_opt: /* GCC extensions */	1582	asm_or_symbolrename_opt: /* GCC extensions */
1592	/* empty */ {	1583	/* empty */ {
1593	$$ = NULL;	1584	$$ = NULL;
1594	}	1585	}
1595	\| T_ASM T_LPAREN T_STRING T_RPAREN {	1586	\| T_ASM T_LPAREN T_STRING T_RPAREN {
1596	freeyyv(&$3, T_STRING);	1587	freeyyv(&$3, T_STRING);
1597	$$ = NULL;	1588	$$ = NULL;
1598	}	1589	}
1599	\| T_SYMBOLRENAME T_LPAREN T_NAME T_RPAREN {	1590	\| T_SYMBOLRENAME T_LPAREN T_NAME T_RPAREN {
1600	$$ = $3;	1591	$$ = $3;
1601	}	1592	}
1602	;	1593	;
1603		1594
1604	statement: /* C99 6.8 */	1595	statement: /* C99 6.8 */
1605	expression_statement	1596	expression_statement
1606	\| non_expr_statement	1597	\| non_expr_statement
1607	;	1598	;
1608		1599
1609	non_expr_statement: /* helper for C99 6.8 */	1600	non_expr_statement: /* helper for C99 6.8 */
1610	type_attribute T_SEMI	1601	type_attribute T_SEMI
1611	\| labeled_statement	1602	\| labeled_statement
1612	\| compound_statement	1603	\| compound_statement
1613	\| selection_statement	1604	\| selection_statement
1614	\| iteration_statement	1605	\| iteration_statement
1615	\| jump_statement {	1606	\| jump_statement {
1616	seen_fallthrough = false;	1607	seen_fallthrough = false;
1617	}	1608	}
1618	\| asm_statement	1609	\| asm_statement
1619	;	1610	;
1620		1611
1621	labeled_statement: /* C99 6.8.1 */	1612	labeled_statement: /* C99 6.8.1 */
1622	label type_attribute_opt statement	1613	label type_attribute_opt statement
1623	;	1614	;
1624		1615
1625	label:	1616	label:
1626	T_NAME T_COLON {	1617	T_NAME T_COLON {
1627	symtyp = FLABEL;	1618	symtyp = FLABEL;
1628	named_label(getsym($1));	1619	named_label(getsym($1));
1629	}	1620	}
1630	\| T_CASE constant_expr T_COLON {	1621	\| T_CASE constant_expr T_COLON {
1631	case_label($2);	1622	case_label($2);
1632	seen_fallthrough = true;	1623	seen_fallthrough = true;
1633	}	1624	}
1634	\| T_CASE constant_expr T_ELLIPSIS constant_expr T_COLON {	1625	\| T_CASE constant_expr T_ELLIPSIS constant_expr T_COLON {
1635	/* XXX: We don't fill all cases */	1626	/* XXX: We don't fill all cases */
1636	case_label($2);	1627	case_label($2);
1637	seen_fallthrough = true;	1628	seen_fallthrough = true;
1638	}	1629	}
1639	\| T_DEFAULT T_COLON {	1630	\| T_DEFAULT T_COLON {
1640	default_label();	1631	default_label();
1641	seen_fallthrough = true;	1632	seen_fallthrough = true;
1642	}	1633	}
1643	;	1634	;
1644		1635
1645	compound_statement: /* C99 6.8.2 */	1636	compound_statement: /* C99 6.8.2 */
1646	compound_statement_lbrace compound_statement_rbrace	1637	compound_statement_lbrace compound_statement_rbrace
1647	\| compound_statement_lbrace block_item_list compound_statement_rbrace	1638	\| compound_statement_lbrace block_item_list compound_statement_rbrace
1648	;	1639	;
1649		1640
1650	compound_statement_lbrace:	1641	compound_statement_lbrace:
1651	T_LBRACE {	1642	T_LBRACE {
1652	block_level++;	1643	block_level++;
1653	mem_block_level++;	1644	mem_block_level++;
1654	begin_declaration_level(AUTO);	1645	begin_declaration_level(AUTO);
1655	}	1646	}
1656	;	1647	;
1657		1648
1658	compound_statement_rbrace:	1649	compound_statement_rbrace:
1659	T_RBRACE {	1650	T_RBRACE {
1660	end_declaration_level();	1651	end_declaration_level();
1661	freeblk();	1652	freeblk();
1662	mem_block_level--;	1653	mem_block_level--;
1663	block_level--;	1654	block_level--;
1664	seen_fallthrough = false;	1655	seen_fallthrough = false;
1665	}	1656	}
1666	;	1657	;
1667		1658
1668	block_item_list: /* C99 6.8.2 */	1659	block_item_list: /* C99 6.8.2 */
1669	block_item	1660	block_item
1670	\| block_item_list block_item {	1661	\| block_item_list block_item {
1671	if (!Sflag && $1 && !$2)	1662	if (!Sflag && $1 && !$2)
1672	/* declarations after statements is a C99 feature */	1663	/* declarations after statements is a C99 feature */
1673	c99ism(327);	1664	c99ism(327);
1674	$$ = $1 \|\| $2;	1665	$$ = $1 \|\| $2;
1675	}	1666	}
1676	;	1667	;
1677		1668
1678	block_item: /* C99 6.8.2 */	1669	block_item: /* C99 6.8.2 */
1679	declaration_or_error {	1670	declaration_or_error {
1680	$$ = false;	1671	$$ = false;
1681	restore_warning_flags();	1672	restore_warning_flags();
1682	}	1673	}
1683	\| statement {	1674	\| statement {
1684	$$ = true;	1675	$$ = true;
1685	restore_warning_flags();	1676	restore_warning_flags();
1686	}	1677	}
1687	;	1678	;
1688		1679
1689	expression_statement: /* C99 6.8.3 */	1680	expression_statement: /* C99 6.8.3 */
1690	expression T_SEMI {	1681	expression T_SEMI {
1691	expr($1, false, false, false, false);	1682	expr($1, false, false, false, false);
1692	seen_fallthrough = false;	1683	seen_fallthrough = false;
1693	}	1684	}
1694	\| T_SEMI {	1685	\| T_SEMI {
1695	seen_fallthrough = false;	1686	seen_fallthrough = false;
1696	}	1687	}
1697	;	1688	;
1698		1689
1699	selection_statement: /* C99 6.8.4 */	1690	selection_statement: /* C99 6.8.4 */
1700	if_without_else %prec T_THEN {	1691	if_without_else %prec T_THEN {
1701	save_warning_flags();	1692	save_warning_flags();
1702	if2();	1693	if2();
1703	if3(false);	1694	if3(false);
1704	}	1695	}
1705	\| if_without_else T_ELSE {	1696	\| if_without_else T_ELSE {
1706	save_warning_flags();	1697	save_warning_flags();
1707	if2();	1698	if2();
1708	} statement {	1699	} statement {
1709	clear_warning_flags();	1700	clear_warning_flags();
1710	if3(true);	1701	if3(true);
1711	}	1702	}
1712	\| if_without_else T_ELSE error {	1703	\| if_without_else T_ELSE error {
1713	clear_warning_flags();	1704	clear_warning_flags();
1714	if3(false);	1705	if3(false);
1715	}	1706	}
1716	\| switch_expr statement {	1707	\| switch_expr statement {
1717	clear_warning_flags();	1708	clear_warning_flags();
1718	switch2();	1709	switch2();
1719	}	1710	}
1720	\| switch_expr error {	1711	\| switch_expr error {
1721	clear_warning_flags();	1712	clear_warning_flags();
1722	switch2();	1713	switch2();
1723	}	1714	}
1724	;	1715	;
1725		1716
1726	if_without_else: /* see C99 6.8.4 */	1717	if_without_else: /* see C99 6.8.4 */
1727	if_expr statement	1718	if_expr statement
1728	\| if_expr error	1719	\| if_expr error
1729	;	1720	;
1730		1721
1731	if_expr: /* see C99 6.8.4 */	1722	if_expr: /* see C99 6.8.4 */
1732	T_IF T_LPAREN expression T_RPAREN {	1723	T_IF T_LPAREN expression T_RPAREN {
1733	if1($3);	1724	if1($3);
1734	clear_warning_flags();	1725	clear_warning_flags();
1735	}	1726	}
1736	;	1727	;
1737		1728
1738	switch_expr: /* see C99 6.8.4 */	1729	switch_expr: /* see C99 6.8.4 */
1739	T_SWITCH T_LPAREN expression T_RPAREN {	1730	T_SWITCH T_LPAREN expression T_RPAREN {
1740	switch1($3);	1731	switch1($3);
1741	clear_warning_flags();	1732	clear_warning_flags();
1742	}	1733	}
1743	;	1734	;
1744		1735
1745	iteration_statement: /* C99 6.8.5 */	1736	iteration_statement: /* C99 6.8.5 */
1746	while_expr statement {	1737	while_expr statement {
1747	clear_warning_flags();	1738	clear_warning_flags();
1748	while2();	1739	while2();
1749	}	1740	}
1750	\| while_expr error {	1741	\| while_expr error {
1751	clear_warning_flags();	1742	clear_warning_flags();
1752	while2();	1743	while2();
1753	}	1744	}
1754	\| do_statement do_while_expr {	1745	\| do_statement do_while_expr {
1755	do2($2);	1746	do2($2);
1756	seen_fallthrough = false;	1747	seen_fallthrough = false;
1757	}	1748	}
1758	\| do error {	1749	\| do error {
1759	clear_warning_flags();	1750	clear_warning_flags();
1760	do2(NULL);	1751	do2(NULL);
1761	}	1752	}
1762	\| for_exprs statement {	1753	\| for_exprs statement {
1763	clear_warning_flags();	1754	clear_warning_flags();
1764	for2();	1755	for2();
1765	end_declaration_level();	1756	end_declaration_level();
1766	block_level--;	1757	block_level--;
1767	}	1758	}
1768	\| for_exprs error {	1759	\| for_exprs error {
1769	clear_warning_flags();	1760	clear_warning_flags();
1770	for2();	1761	for2();
1771	end_declaration_level();	1762	end_declaration_level();
1772	block_level--;	1763	block_level--;
1773	}	1764	}
1774	;	1765	;
1775		1766
1776	while_expr: /* see C99 6.8.5 */	1767	while_expr: /* see C99 6.8.5 */
1777	T_WHILE T_LPAREN expression T_RPAREN {	1768	T_WHILE T_LPAREN expression T_RPAREN {
1778	while1($3);	1769	while1($3);
1779	clear_warning_flags();	1770	clear_warning_flags();
1780	}	1771	}
1781	;	1772	;
1782		1773
1783	do_statement: /* see C99 6.8.5 */	1774	do_statement: /* see C99 6.8.5 */
1784	do statement {	1775	do statement {
1785	clear_warning_flags();	1776	clear_warning_flags();
1786	}	1777	}
1787	;	1778	;
1788		1779
1789	do: /* see C99 6.8.5 */	1780	do: /* see C99 6.8.5 */
1790	T_DO {	1781	T_DO {
1791	do1();	1782	do1();
1792	}	1783	}
1793	;	1784	;
1794		1785
1795	do_while_expr: /* see C99 6.8.5 */	1786	do_while_expr: /* see C99 6.8.5 */
1796	T_WHILE T_LPAREN expression T_RPAREN T_SEMI {	1787	T_WHILE T_LPAREN expression T_RPAREN T_SEMI {
1797	$$ = $3;	1788	$$ = $3;
1798	}	1789	}
1799	;	1790	;
1800		1791
1801	for_start: /* see C99 6.8.5 */	1792	for_start: /* see C99 6.8.5 */
1802	T_FOR T_LPAREN {	1793	T_FOR T_LPAREN {
1803	begin_declaration_level(AUTO);	1794	begin_declaration_level(AUTO);
1804	block_level++;	1795	block_level++;
1805	}	1796	}
1806	;	1797	;
1807		1798
1808	for_exprs: /* see C99 6.8.5 */	1799	for_exprs: /* see C99 6.8.5 */
1809	for_start	1800	for_start
1810	begin_type_declaration_specifiers end_type	1801	begin_type_declaration_specifiers end_type
1811	notype_init_declarators T_SEMI	1802	notype_init_declarators T_SEMI
1812	expression_opt T_SEMI expression_opt T_RPAREN {	1803	expression_opt T_SEMI expression_opt T_RPAREN {
1813	/* variable declaration in for loop */	1804	/* variable declaration in for loop */
1814	c99ism(325);	1805	c99ism(325);
1815	for1(NULL, $6, $8);	1806	for1(NULL, $6, $8);
1816	clear_warning_flags();	1807	clear_warning_flags();
1817	}	1808	}
1818	\| for_start	1809	\| for_start
1819	expression_opt T_SEMI	1810	expression_opt T_SEMI
1820	expression_opt T_SEMI	1811	expression_opt T_SEMI
1821	expression_opt T_RPAREN {	1812	expression_opt T_RPAREN {
1822	for1($2, $4, $6);	1813	for1($2, $4, $6);
1823	clear_warning_flags();	1814	clear_warning_flags();
1824	}	1815	}
1825	;	1816	;
1826		1817
1827	jump_statement: /* C99 6.8.6 */	1818	jump_statement: /* C99 6.8.6 */
1828	goto identifier T_SEMI {	1819	goto identifier T_SEMI {
1829	do_goto(getsym($2));	1820	do_goto(getsym($2));
1830	}	1821	}
1831	\| goto error T_SEMI {	1822	\| goto error T_SEMI {
1832	symtyp = FVFT;	1823	symtyp = FVFT;
1833	}	1824	}
1834	\| T_CONTINUE T_SEMI {	1825	\| T_CONTINUE T_SEMI {
1835	do_continue();	1826	do_continue();
1836	}	1827	}
1837	\| T_BREAK T_SEMI {	1828	\| T_BREAK T_SEMI {
1838	do_break();	1829	do_break();
1839	}	1830	}
1840	\| T_RETURN T_SEMI {	1831	\| T_RETURN T_SEMI {
1841	do_return(NULL);	1832	do_return(NULL);
1842	}	1833	}
1843	\| T_RETURN expression T_SEMI {	1834	\| T_RETURN expression T_SEMI {
1844	do_return($2);	1835	do_return($2);
1845	}	1836	}
1846	;	1837	;
1847		1838
1848	goto: /* see C99 6.8.6 */	1839	goto: /* see C99 6.8.6 */
1849	T_GOTO {	1840	T_GOTO {
1850	symtyp = FLABEL;	1841	symtyp = FLABEL;
1851	}	1842	}
1852	;	1843	;
1853		1844
1854	asm_statement: /* GCC extension */	1845	asm_statement: /* GCC extension */
1855	T_ASM T_LPAREN read_until_rparen T_SEMI {	1846	T_ASM T_LPAREN read_until_rparen T_SEMI {
1856	setasm();	1847	setasm();
1857	}	1848	}
1858	\| T_ASM T_QUAL T_LPAREN read_until_rparen T_SEMI {	1849	\| T_ASM T_QUAL T_LPAREN read_until_rparen T_SEMI {
1859	setasm();	1850	setasm();
1860	}	1851	}
1861	\| T_ASM error	1852	\| T_ASM error
1862	;	1853	;
1863		1854
1864	read_until_rparen: /* helper for 'asm_statement' */	1855	read_until_rparen: /* helper for 'asm_statement' */
1865	/* empty */ {	1856	/* empty */ {
1866	ignore_up_to_rparen();	1857	ignore_up_to_rparen();
1867	}	1858	}
1868	;	1859	;
1869		1860
1870	translation_unit: /* C99 6.9 */	1861	translation_unit: /* C99 6.9 */
1871	external_declaration	1862	external_declaration
1872	\| translation_unit external_declaration	1863	\| translation_unit external_declaration
1873	;	1864	;
1874		1865
1875	external_declaration: /* C99 6.9 */	1866	external_declaration: /* C99 6.9 */
1876	asm_statement	1867	asm_statement
1877	\| function_definition {	1868	\| function_definition {
1878	global_clean_up_decl(false);	1869	global_clean_up_decl(false);
1879	clear_warning_flags();	1870	clear_warning_flags();
1880	}	1871	}
1881	\| top_level_declaration {	1872	\| top_level_declaration {
1882	global_clean_up_decl(false);	1873	global_clean_up_decl(false);
1883	clear_warning_flags();	1874	clear_warning_flags();
1884	}	1875	}
1885	;	1876	;
1886		1877
1887	/*	1878	/*
1888	* On the top level, lint allows several forms of declarations that it doesn't	1879	* On the top level, lint allows several forms of declarations that it doesn't
1889	* allow in functions. For example, a single ';' is an empty declaration and	1880	* allow in functions. For example, a single ';' is an empty declaration and
1890	* is supported by some compilers, but in a function it would be an empty	1881	* is supported by some compilers, but in a function it would be an empty
1891	* statement, not a declaration. This makes a difference in C90 mode, where	1882	* statement, not a declaration. This makes a difference in C90 mode, where
1892	* a statement must not be followed by a declaration.	1883	* a statement must not be followed by a declaration.
1893	*	1884	*
1894	* See 'declaration' for all other declarations.	1885	* See 'declaration' for all other declarations.
1895	*/	1886	*/
1896	top_level_declaration: /* C99 6.9 calls this 'declaration' */	1887	top_level_declaration: /* C99 6.9 calls this 'declaration' */
1897	T_SEMI {	1888	T_SEMI {
1898	if (sflag) {	1889	if (sflag) {
1899	/* empty declaration */	1890	/* empty declaration */
1900	error(0);	1891	error(0);
1901	} else if (!tflag) {	1892	} else if (!tflag) {
1902	/* empty declaration */	1893	/* empty declaration */
1903	warning(0);	1894	warning(0);
1904	}	1895	}
1905	}	1896	}
1906	\| begin_type end_type notype_init_declarators T_SEMI {	1897	\| begin_type end_type notype_init_declarators T_SEMI {
1907	if (sflag) {	1898	if (sflag) {
1908	/* old style declaration; add 'int' */	1899	/* old style declaration; add 'int' */
1909	error(1);	1900	error(1);
1910	} else if (!tflag) {	1901	} else if (!tflag) {
1911	/* old style declaration; add 'int' */	1902	/* old style declaration; add 'int' */
1912	warning(1);	1903	warning(1);
1913	}	1904	}
1914	}	1905	}
1915	\| declaration	1906	\| declaration
1916	\| error T_SEMI {	1907	\| error T_SEMI {
1917	global_clean_up();	1908	global_clean_up();
1918	}	1909	}
1919	\| error T_RBRACE {	1910	\| error T_RBRACE {
1920	global_clean_up();	1911	global_clean_up();
1921	}	1912	}
1922	;	1913	;
1923		1914
1924	function_definition: /* C99 6.9.1 */	1915	function_definition: /* C99 6.9.1 */
1925	func_declarator {	1916	func_declarator {
1926	if ($1->s_type->t_tspec != FUNC) {	1917	if ($1->s_type->t_tspec != FUNC) {
1927	/* syntax error '%s' */	1918	/* syntax error '%s' */
1928	error(249, yytext);	1919	error(249, yytext);
1929	YYERROR;	1920	YYERROR;
1930	}	1921	}
1931	if ($1->s_type->t_typedef) {	1922	if ($1->s_type->t_typedef) {
1932	/* ()-less function definition */	1923	/* ()-less function definition */
1933	error(64);	1924	error(64);
1934	YYERROR;	1925	YYERROR;
1935	}	1926	}
1936	funcdef($1);	1927	funcdef($1);
1937	block_level++;	1928	block_level++;
1938	begin_declaration_level(ARG);	1929	begin_declaration_level(ARG);
1939	if (lwarn == LWARN_NONE)	1930	if (lwarn == LWARN_NONE)
1940	$1->s_used = true;	1931	$1->s_used = true;
1941	} arg_declaration_list_opt {	1932	} arg_declaration_list_opt {
1942	end_declaration_level();	1933	end_declaration_level();
1943	block_level--;	1934	block_level--;
1944	check_func_lint_directives();	1935	check_func_lint_directives();
1945	check_func_old_style_arguments();	1936	check_func_old_style_arguments();
1946	begin_control_statement(CS_FUNCTION_BODY);	1937	begin_control_statement(CS_FUNCTION_BODY);
1947	} compound_statement {	1938	} compound_statement {
1948	funcend();	1939	funcend();
1949	end_control_statement(CS_FUNCTION_BODY);	1940	end_control_statement(CS_FUNCTION_BODY);
1950	}	1941	}
1951	;	1942	;
1952		1943
1953	func_declarator:	1944	func_declarator:
1954	begin_type end_type notype_declarator {	1945	begin_type end_type notype_declarator {
1955	$$ = $3;	1946	$$ = $3;
1956	}	1947	}
1957	\| begin_type_declmods end_type notype_declarator {	1948	\| begin_type_declmods end_type notype_declarator {
1958	$$ = $3;	1949	$$ = $3;
1959	}	1950	}
1960	\| begin_type_declaration_specifiers end_type type_declarator {	1951	\| begin_type_declaration_specifiers end_type type_declarator {
1961	$$ = $3;	1952	$$ = $3;
1962	}	1953	}
1963	;	1954	;
1964		1955
1965	arg_declaration_list_opt: /* C99 6.9.1p13 example 1 */	1956	arg_declaration_list_opt: /* C99 6.9.1p13 example 1 */
1966	/* empty */	1957	/* empty */
1967	\| arg_declaration_list	1958	\| arg_declaration_list
1968	;	1959	;
1969		1960
1970	arg_declaration_list: /* C99 6.9.1p13 example 1 */	1961	arg_declaration_list: /* C99 6.9.1p13 example 1 */
1971	arg_declaration	1962	arg_declaration
1972	\| arg_declaration_list arg_declaration	1963	\| arg_declaration_list arg_declaration
1973	/* XXX or better "arg_declaration error" ? */	1964	/* XXX or better "arg_declaration error" ? */
1974	\| error	1965	\| error
1975	;	1966	;
1976		1967
1977	/*	1968	/*
1978	* "arg_declaration" is separated from "declaration" because it	1969	* "arg_declaration" is separated from "declaration" because it
1979	* needs other error handling.	1970	* needs other error handling.
1980	*/	1971	*/
1981	arg_declaration:	1972	arg_declaration:
1982	begin_type_declmods end_type T_SEMI {	1973	begin_type_declmods end_type T_SEMI {
1983	/* empty declaration */	1974	/* empty declaration */
1984	warning(2);	1975	warning(2);
1985	}	1976	}
1986	\| begin_type_declmods end_type notype_init_declarators T_SEMI	1977	\| begin_type_declmods end_type notype_init_declarators T_SEMI
1987	\| begin_type_declaration_specifiers end_type T_SEMI {	1978	\| begin_type_declaration_specifiers end_type T_SEMI {
1988	if (!dcs->d_nonempty_decl) {	1979	if (!dcs->d_nonempty_decl) {
1989	/* empty declaration */	1980	/* empty declaration */
1990	warning(2);	1981	warning(2);
1991	} else {	1982	} else {
1992	/* '%s' declared in argument declaration list */	1983	/* '%s' declared in argument declaration list */

 @@ -1,682 +1,682 @@
-/*	$NetBSD: err.c,v 1.129 2021/07/13 22:01:34 rillig Exp $	*/
+/*	$NetBSD: err.c,v 1.130 2021/07/15 20:05:49 rillig Exp $	*/
 /*
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Jochen Pohl for
  *	The NetBSD Project.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: err.c,v 1.129 2021/07/13 22:01:34 rillig Exp $");
+__RCSID("$NetBSD: err.c,v 1.130 2021/07/15 20:05:49 rillig Exp $");
 #endif
 #include <sys/types.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include "lint1.h"
 /* number of errors found */
 int	nerr;
 /* number of syntax errors */
 int	sytxerr;
 const char *const 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 */
 	"'%s' has incomplete type '%s'",			      /* 31 */
 	"argument type defaults to 'int': %s",			      /* 32 */
 	"duplicate member name: %s",				      /* 33 */
 	"nonportable bit-field type '%s'",			      /* 34 */
 	"illegal bit-field type '%s'",				      /* 35 */
 	"illegal bit-field size: %d",				      /* 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 */
 	"anonymous struct/union members is a C9X feature",	      /* 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 */
+	"",							      /* 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 */
 	"type '%s' does not have member '%s'",			      /* 101 */
 	"illegal member use: %s",				      /* 102 */
 	"left operand of '.' must be struct or union, not '%s'",      /* 103 */
 	"left operand of '->' must be pointer to struct or union, not '%s'", /* 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 invalid type (%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 '%s' 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 '%s' on signed value nonportable",		      /* 120 */
 	"negative shift",					      /* 121 */
 	"shift amount %llu is greater than bit-size %llu of '%s'",    /* 122 */
 	"illegal combination of %s (%s) and %s (%s), op %s",	      /* 123 */
 	"illegal pointer combination (%s) and (%s), op %s",	      /* 124 */
 	"ANSI C forbids ordered comparisons of pointers to functions",/* 125 */
 	"incompatible types '%s' and '%s' 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: '%s' '%s' '%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 */
 	"converting '%s' to '%s' may cause 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 (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 */
 	"converting '%s' to incompatible '%s' for argument %d",	      /* 153 */
 	"illegal combination of %s (%s) and %s (%s), arg #%d",	      /* 154 */
 	"passing '%s' to incompatible '%s', arg #%d",		      /* 155 */
 	"enum type mismatch, arg #%d (%s != %s)",		      /* 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 */
 	"cannot assign to '%s' from '%s'",			      /* 171 */
 	"too many struct/union initializers",			      /* 172 */
 	"too many array initializers, expected %d",		      /* 173 */
 	"too many initializers",				      /* 174 */
 	"initialization of incomplete type '%s'",		      /* 175 */
 	"",			/* no longer used */		      /* 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 %s (%s) and %s (%s)",		      /* 183 */
 	"illegal pointer combination",				      /* 184 */
 	"cannot initialize '%s' from '%s'",			      /* 185 */
 	"bit-field initialization is illegal in traditional C",	      /* 186 */
 	"non-null byte ignored in string initializer",		      /* 187 */
 	"no automatic aggregate initialization in traditional C",     /* 188 */
 	"",			/* no longer used */		      /* 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 between '%s' and '%s' in initialization", /* 210 */
 	"return value type mismatch (%s) and (%s)",		      /* 211 */
 	"cannot return incomplete type",			      /* 212 */
 	"void function %s cannot return value",			      /* 213 */
 	"function %s expects to return value",			      /* 214 */
 	"function '%s' 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 */
 	"initialization 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 */
 	"converting '%s' to '%s' is questionable",		      /* 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 */
 	"initialization of union is illegal in traditional C",	      /* 238 */
 	"constant argument to '!'",				      /* 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 */
 	"incompatible structure pointers: '%s' '%s' '%s'",	      /* 245 */
 	"dubious conversion of enum to '%s'",			      /* 246 */
 	"pointer cast from '%s' to '%s' 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 */
 	"argument #%d is converted from '%s' to '%s' due to prototype", /* 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 type '%s'",			      /* 275 */
 	"__%s__ is illegal for type %s",			      /* 276 */
 	"initialization 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 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 C99 feature",	      /* 327 */
 	"union cast is a C9X feature",				      /* 328 */
 	"type '%s' is not a member of '%s'",			      /* 329 */
 	"operand of '%s' must be bool, not '%s'",		      /* 330 */
 	"left operand of '%s' must be bool, not '%s'",		      /* 331 */
 	"right operand of '%s' must be bool, not '%s'",		      /* 332 */
 	"controlling expression must be bool, not '%s'",	      /* 333 */
 	"argument #%d expects '%s', gets passed '%s'",		      /* 334 */
 	"operand of '%s' must not be bool",			      /* 335 */
 	"left operand of '%s' must not be bool",		      /* 336 */
 	"right operand of '%s' must not be bool",		      /* 337 */
 	"option '%c' should be handled in the switch",		      /* 338 */
 	"option '%c' should be listed in the options string",	      /* 339 */
 	"initialization with '[a...b]' is a GCC extension",	      /* 340 */
 	"argument to '%s' must be 'unsigned char' or EOF, not '%s'",  /* 341 */
 	"argument to '%s' must be cast to 'unsigned char', not to '%s'", /* 342 */
 	"static array size is a C11 extension",			      /* 343 */
 	"bit-field of type plain 'int' has implementation-defined signedness", /* 344 */
 	"generic selection requires C11 or later",		      /* 345 */
 };
 static struct include_level {
 	const char *filename;
 	int lineno;
 	struct include_level *by;
 } *includes;
 void
 update_location(const char *filename, int lineno, bool is_begin, bool is_end)
+{
 	struct include_level *top;
 	top = includes;
 	if (is_begin && top != NULL)
 		top->lineno = curr_pos.p_line;
 	if (top == NULL || is_begin) {
 		top = xmalloc(sizeof(*top));
 		top->filename = filename;
 		top->lineno = lineno;
 		top->by = includes;
 		includes = top;
 	} else {
 		if (is_end) {
 			includes = top->by;
 			free(top);
 			top = includes;
+		}
 		if (top != NULL) {
 			top->filename = filename;
 			top->lineno = lineno;
+		}
+	}
+}
 static void
 print_stack_trace(void)
+{
 	const struct include_level *top;
 	if ((top = includes) == NULL)
 		return;
 	/*
 	 * Skip the innermost include level since it is already listed in the
 	 * diagnostic itself.  Furthermore, its lineno is the line number of
 	 * the last '#' line, not the current line.
 	 */
 	for (top = top->by; top != NULL; top = top->by)
 		printf("\tincluded from %s(%d)\n", top->filename, top->lineno);
+}
 /*
  * 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 *p, *base, *dir;
 	if (Fflag)
 		return path;
 	p = base = dir = path;
 	while (*p != '\0') {
 		if (*p++ == '/') {
 			dir = base;
 			base = p;
+		}
+	}
 	return *base != '\0' ? base : dir;
+}
 static void
 verror_at(int msgid, const pos_t *pos, va_list ap)
+{
 	const	char *fn;
 	if (ERR_ISSET(msgid, &msgset))
 		return;
 	fn = lbasename(pos->p_file);
 	(void)printf("%s(%d): error: ", fn, pos->p_line);
 	(void)vprintf(msgs[msgid], ap);
 	(void)printf(" [%d]\n", msgid);
 	nerr++;
 	print_stack_trace();
+}
 static void
 vwarning_at(int msgid, const pos_t *pos, va_list ap)
+{
 	const	char *fn;
 	if (ERR_ISSET(msgid, &msgset))
 		return;
 #ifdef DEBUG
 	printf("%s: lwarn=%d msgid=%d\n", __func__, lwarn, msgid);
 #endif
 	if (lwarn == LWARN_NONE || lwarn == msgid)
 		/* this warning is suppressed by a LINTED comment */
 		return;
 	fn = lbasename(pos->p_file);
 	(void)printf("%s(%d): warning: ", fn, pos->p_line);
 	(void)vprintf(msgs[msgid], ap);
 	(void)printf(" [%d]\n", msgid);
 	if (wflag)
 		nerr++;
 	print_stack_trace();
+}
 static void
 vmessage_at(int msgid, const pos_t *pos, va_list ap)
+{
 	const char *fn;
 	if (ERR_ISSET(msgid, &msgset))
 		return;
 	fn = lbasename(pos->p_file);
 	(void)printf("%s(%d): ", fn, pos->p_line);
 	(void)vprintf(msgs[msgid], ap);
 	(void)printf(" [%d]\n", msgid);
 	print_stack_trace();
+}
 void
 (error_at)(int msgid, const pos_t *pos, ...)
+{
 	va_list	ap;
 	va_start(ap, pos);
 	verror_at(msgid, pos, ap);
 	va_end(ap);
+}
 void
 (error)(int msgid, ...)
+{
 	va_list	ap;
 	va_start(ap, msgid);
 	verror_at(msgid, &curr_pos, ap);
 	va_end(ap);
+}
 void
 internal_error(const char *file, int line, const char *msg, ...)
+{
 	va_list	ap;
 	const	char *fn;
 	fn = lbasename(curr_pos.p_file);
 	fflush(stdout);
 	(void)fprintf(stderr, "lint: internal error in %s:%d near %s:%d: ",
 	    file, line, fn, curr_pos.p_line);
 	va_start(ap, msg);
 	(void)vfprintf(stderr, msg, ap);
 	va_end(ap);
 	(void)fprintf(stderr, "\n");
 	print_stack_trace();
 	abort();
+}
 void
 assert_failed(const char *file, int line, const char *func, const char *cond)
+{
 	const	char *fn;
 	fn = lbasename(curr_pos.p_file);
 	fflush(stdout);
 	(void)fprintf(stderr,
 	    "lint: assertion \"%s\" failed in %s at %s:%d near %s:%d\n",
 	    cond, func, file, line, fn, curr_pos.p_line);
 	print_stack_trace();
 	abort();
+}
 void
 (warning_at)(int msgid, const pos_t *pos, ...)
+{
 	va_list	ap;
 	va_start(ap, pos);
 	vwarning_at(msgid, pos, ap);
 	va_end(ap);
+}
 void
 (warning)(int msgid, ...)
+{
 	va_list	ap;
 	va_start(ap, msgid);
 	vwarning_at(msgid, &curr_pos, ap);
 	va_end(ap);
+}
 void
 (message_at)(int msgid, const pos_t *pos, ...)
+{
 	va_list ap;
 	va_start(ap, pos);
 	vmessage_at(msgid, pos, ap);
 	va_end(ap);
+}
 void
 (message)(int msgid, ...)
+{
 	va_list	ap;
 	va_start(ap, msgid);
 	vmessage_at(msgid, &curr_pos, ap);
 	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]
 */
 void
 (c99ism)(int msgid, ...)
+{
 	va_list	ap;
 	bool extensions_ok = Sflag || gflag;
 	va_start(ap, msgid);
 	if (sflag && !extensions_ok) {
 		verror_at(msgid, &curr_pos, ap);
 	} else if (sflag || !extensions_ok) {
 		vwarning_at(msgid, &curr_pos, ap);
+	}
 	va_end(ap);
+}
 void
 (c11ism)(int msgid, ...)
+{
 	va_list	ap;
 	if (c11flag || gflag)
 		return;
 	va_start(ap, msgid);
 	verror_at(msgid, &curr_pos, ap);
 	va_end(ap);
+}
 void
 (gnuism)(int msgid, ...)
+{
 	va_list	ap;
 	va_start(ap, msgid);
 	if (sflag && !gflag) {
 		verror_at(msgid, &curr_pos, ap);
 	} else if (sflag || !gflag) {
 		vwarning_at(msgid, &curr_pos, ap);
+	}
 	va_end(ap);
+}

 @@ -1,8 +1,7 @@
 decl_struct_member.c(34): error: syntax error 'goto' [249]
 decl_struct_member.c(36): error: illegal type combination [4]
 decl_struct_member.c(38): error: syntax error '}' [249]
 decl_struct_member.c(38): warning: empty declaration [0]
 decl_struct_member.c(47): error: syntax error 'unnamed member' [249]
 decl_struct_member.c(54): error: syntax error '0' [249]
 decl_struct_member.c(55): warning: syntax requires ';' after last struct/union member [66]
 decl_struct_member.c(62): error: cannot recover from previous errors [224]

 @@ -1,8 +1,15 @@
-/*	$NetBSD: msg_066.c,v 1.3 2021/01/31 11:12:07 rillig Exp $	*/
+/*	$NetBSD: msg_066.c,v 1.4 2021/07/15 20:05:49 rillig Exp $	*/
 # 3 "msg_066.c"
 // Test for message: syntax requires ';' after last struct/union member [66]
 /*
  * This message was removed in cgram.y 1.328 from 2021-07-15 because all
  * C standards and even K&R require a semicolon.
  */
 struct number {
 	int value
-};				/* expect: 66 */
+};
 /* expect-1: syntax error '}' [249] */
 /* expect+1: error: cannot recover from previous errors [224] */

 @@ -1,18 +1,21 @@
-/*	$NetBSD: decl_struct_c90.c,v 1.1 2021/07/15 19:51:29 rillig Exp $	*/
+/*	$NetBSD: decl_struct_c90.c,v 1.2 2021/07/15 20:05:49 rillig Exp $	*/
 # 3 "decl_struct_c90.c"
 /*
  * Test declaration of struct types, in C90 without any GNU extensions.
  */
 /* lint1-flags: -sw */
 /*
  * All of K&R, C90, C99 require that a struct member declaration is
- * terminated with a semicolon.  No idea why lint allows the missing
+ * terminated with a semicolon.
  * semicolon in non-C90 mode.
  * Before cgram.y 1.328 from 2021-07-15, lint allowed the missing semicolon
  * in non-C90 mode, no idea why.
  */
 struct missing_semicolon {
 	int member
 };
-/* expect-1: error: syntax requires ';' after last struct/union member [66] */
+/* expect-1: error: syntax error '}' [249] */
 /* expect+1: error: cannot recover from previous errors [224] */

 @@ -1,61 +1,61 @@
-/*	$NetBSD: decl_struct_member.c,v 1.7 2021/07/15 19:51:29 rillig Exp $	*/
+/*	$NetBSD: decl_struct_member.c,v 1.8 2021/07/15 20:05:49 rillig Exp $	*/
 # 3 "decl_struct_member.c"
 struct multi_attributes {
 	__attribute__((deprecated))
 	__attribute__((deprecated))
 	__attribute__((deprecated))
 	int deprecated;
 };
 struct cover_begin_type_noclass_declspecs {
 	int m1;
 	__attribute__((deprecated)) int m2;
 	const int m3;
 	int const m4;
 	int const long m5;
 	int __attribute__((deprecated)) m6;
 };
 typedef int number;
 struct cover_begin_type_typespec {
 	int m1;
 	number m2;
 };
 struct cover_begin_type_noclass_declmods {
 	const m1;
 	const volatile m2;
 };
 /* cover struct_or_union_specifier: struct_or_union error */
 /* expect+1: error: syntax error 'goto' [249] */
 struct goto {
 	/* expect+1: error: illegal type combination [4] */
 	int member;
 	/* expect+1: error: syntax error '}' [249] */
 };
 /* expect-1: warning: empty declaration [0] */
 /*
  * Before cgram.y 1.228 from 2021-06-19, lint ran into an assertion failure:
+ *
  * "is_struct_or_union(dcs->d_type->t_tspec)" at cgram.y:846
  */
 struct {
 	char;			/* expect: syntax error 'unnamed member' */
 };
 /*
  * Before decl.c 1.188 from 2021-06-20, lint ran into a segmentation fault.
  */
 struct {
 	char a(_)0		/* expect: syntax error '0' */
 }				/* expect: ';' after last */
 /*
  * FIXME: adding a semicolon here triggers another assertion:
+ *
  * assertion "t == NOTSPEC" failed in end_type at decl.c:774
  */
 /* expect+1: cannot recover from previous errors */