OSDN Git Service

[gcc/ChangeLog]
[pf3gnuchains/gcc-fork.git] / gcc / c-parse.in
1 /* YACC parser for C syntax and for Objective C.  -*-c-*-
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3    1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 /* This file defines the grammar of C and that of Objective C.
23    @@ifobjc ... @@end_ifobjc  conditionals contain code for Objective C only.
24    @@ifc ... @@end_ifc  conditionals contain code for C only.
25    Sed commands in Makefile.in are used to convert this file into
26    c-parse.y and into objc-parse.y.  */
27
28 /* To whomever it may concern: I have heard that such a thing was once
29    written by AT&T, but I have never seen it.  */
30
31 @@ifc
32 %expect 13 /* shift/reduce conflicts, and no reduce/reduce conflicts.  */
33 @@end_ifc
34
35 %{
36 #include "config.h"
37 #include "system.h"
38 #include "coretypes.h"
39 #include "tm.h"
40 #include "tree.h"
41 #include "langhooks.h"
42 #include "input.h"
43 #include "cpplib.h"
44 #include "intl.h"
45 #include "timevar.h"
46 #include "c-pragma.h"           /* For YYDEBUG definition, and parse_in.  */
47 #include "c-tree.h"
48 #include "flags.h"
49 #include "varray.h"
50 #include "output.h"
51 #include "toplev.h"
52 #include "ggc.h"
53
54 @@ifobjc
55 #include "objc-act.h"
56 @@end_ifobjc
57
58 /* Like YYERROR but do call yyerror.  */
59 #define YYERROR1 { yyerror ("syntax error"); YYERROR; }
60
61 /* Like the default stack expander, except (1) use realloc when possible,
62    (2) impose no hard maxiumum on stack size, (3) REALLY do not use alloca.
63
64    Irritatingly, YYSTYPE is defined after this %{ %} block, so we cannot
65    give malloced_yyvs its proper type.  This is ok since all we need from
66    it is to be able to free it.  */
67
68 static short *malloced_yyss;
69 static void *malloced_yyvs;
70
71 #define yyoverflow(MSG, SS, SSSIZE, VS, VSSIZE, YYSSZ)                  \
72 do {                                                                    \
73   size_t newsize;                                                       \
74   short *newss;                                                         \
75   YYSTYPE *newvs;                                                       \
76   newsize = *(YYSSZ) *= 2;                                              \
77   if (malloced_yyss)                                                    \
78     {                                                                   \
79       newss = really_call_realloc (*(SS), newsize * sizeof (short));    \
80       newvs = really_call_realloc (*(VS), newsize * sizeof (YYSTYPE));  \
81     }                                                                   \
82   else                                                                  \
83     {                                                                   \
84       newss = really_call_malloc (newsize * sizeof (short));            \
85       newvs = really_call_malloc (newsize * sizeof (YYSTYPE));          \
86       if (newss)                                                        \
87         memcpy (newss, *(SS), (SSSIZE));                                \
88       if (newvs)                                                        \
89         memcpy (newvs, *(VS), (VSSIZE));                                \
90     }                                                                   \
91   if (!newss || !newvs)                                                 \
92     {                                                                   \
93       yyerror (MSG);                                                    \
94       return 2;                                                         \
95     }                                                                   \
96   *(SS) = newss;                                                        \
97   *(VS) = newvs;                                                        \
98   malloced_yyss = newss;                                                \
99   malloced_yyvs = (void *) newvs;                                       \
100 } while (0)
101 %}
102
103 %start program
104
105 %union {long itype; tree ttype; struct c_expr exprtype; enum tree_code code;
106         location_t location; }
107
108 /* All identifiers that are not reserved words
109    and are not declared typedefs in the current block */
110 %token IDENTIFIER
111
112 /* All identifiers that are declared typedefs in the current block.
113    In some contexts, they are treated just like IDENTIFIER,
114    but they can also serve as typespecs in declarations.  */
115 %token TYPENAME
116
117 /* Reserved words that specify storage class.
118    yylval contains an IDENTIFIER_NODE which indicates which one.  */
119 %token SCSPEC                   /* Storage class other than static.  */
120 %token STATIC                   /* Static storage class.  */
121
122 /* Reserved words that specify type.
123    yylval contains an IDENTIFIER_NODE which indicates which one.  */
124 %token TYPESPEC
125
126 /* Reserved words that qualify type: "const", "volatile", or "restrict".
127    yylval contains an IDENTIFIER_NODE which indicates which one.  */
128 %token TYPE_QUAL
129
130 /* Objective-C protocol qualifiers.  These acquire their magic powers
131    only in certain contexts.  */
132 %token OBJC_TYPE_QUAL
133
134 /* Character or numeric constants.
135    yylval is the node for the constant.  */
136 %token CONSTANT
137
138 /* String constants in raw form.
139    yylval is a STRING_CST node.  */
140
141 %token STRING
142
143 /* "...", used for functions with variable arglists.  */
144 %token ELLIPSIS
145
146 /* the reserved words */
147 /* SCO include files test "ASM", so use something else. */
148 %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
149 %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF
150 %token ATTRIBUTE EXTENSION LABEL
151 %token REALPART IMAGPART VA_ARG CHOOSE_EXPR TYPES_COMPATIBLE_P
152 %token PTR_VALUE PTR_BASE PTR_EXTENT
153 %token FUNC_NAME OFFSETOF
154
155 /* Add precedence rules to solve dangling else s/r conflict */
156 %nonassoc IF
157 %nonassoc ELSE
158
159 /* Define the operator tokens and their precedences.
160    The value is an integer because, if used, it is the tree code
161    to use in the expression made from the operator.  */
162
163 %right <code> ASSIGN '='
164 %right <code> '?' ':'
165 %left <code> OROR
166 %left <code> ANDAND
167 %left <code> '|'
168 %left <code> '^'
169 %left <code> '&'
170 %left <code> EQCOMPARE
171 %left <code> ARITHCOMPARE
172 %left <code> LSHIFT RSHIFT
173 %left <code> '+' '-'
174 %left <code> '*' '/' '%'
175 %right <code> UNARY PLUSPLUS MINUSMINUS
176 %left HYPERUNARY
177 %left <code> POINTSAT '.' '(' '['
178
179 /* The Objective-C keywords.  These are included in C and in
180    Objective C, so that the token codes are the same in both.  */
181 %token AT_INTERFACE AT_IMPLEMENTATION AT_END AT_SELECTOR AT_DEFS AT_ENCODE
182 %token CLASSNAME AT_PUBLIC AT_PRIVATE AT_PROTECTED AT_PROTOCOL 
183 %token OBJECTNAME AT_CLASS AT_ALIAS
184 %token AT_THROW AT_TRY AT_CATCH AT_FINALLY AT_SYNCHRONIZED
185 %token OBJC_STRING
186
187 %type <code> unop
188 %type <ttype> ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
189 %type <ttype> BREAK CONTINUE RETURN GOTO ASM_KEYWORD SIZEOF TYPEOF ALIGNOF
190
191 %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT STRING FUNC_NAME
192 %type <ttype> nonnull_exprlist exprlist
193 %type <exprtype> expr expr_no_commas cast_expr unary_expr primary
194 %type <ttype> declspecs_nosc_nots_nosa_noea declspecs_nosc_nots_nosa_ea
195 %type <ttype> declspecs_nosc_nots_sa_noea declspecs_nosc_nots_sa_ea
196 %type <ttype> declspecs_nosc_ts_nosa_noea declspecs_nosc_ts_nosa_ea
197 %type <ttype> declspecs_nosc_ts_sa_noea declspecs_nosc_ts_sa_ea
198 %type <ttype> declspecs_sc_nots_nosa_noea declspecs_sc_nots_nosa_ea
199 %type <ttype> declspecs_sc_nots_sa_noea declspecs_sc_nots_sa_ea
200 %type <ttype> declspecs_sc_ts_nosa_noea declspecs_sc_ts_nosa_ea
201 %type <ttype> declspecs_sc_ts_sa_noea declspecs_sc_ts_sa_ea
202 %type <ttype> declspecs_ts declspecs_nots
203 %type <ttype> declspecs_ts_nosa declspecs_nots_nosa
204 %type <ttype> declspecs_nosc_ts declspecs_nosc_nots declspecs_nosc declspecs
205 %type <ttype> maybe_type_quals_attrs typespec_nonattr typespec_attr
206 %type <ttype> typespec_reserved_nonattr typespec_reserved_attr
207 %type <ttype> typespec_nonreserved_nonattr
208 %type <ttype> offsetof_member_designator
209
210 %type <ttype> scspec SCSPEC STATIC TYPESPEC TYPE_QUAL maybe_volatile
211 %type <ttype> initdecls notype_initdecls initdcl notype_initdcl
212 %type <exprtype> init
213 %type <ttype> simple_asm_expr maybeasm asm_stmt asm_argument
214 %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
215 %type <ttype> maybe_attribute attributes attribute attribute_list attrib
216 %type <ttype> any_word
217
218 %type <ttype> compstmt compstmt_start compstmt_primary_start
219 %type <ttype> stmt label stmt_nocomp start_break start_continue
220
221 %type <ttype> c99_block_start c99_block_lineno_labeled_stmt
222 %type <ttype> if_statement_1 if_statement_2
223 %type <ttype> declarator
224 %type <ttype> notype_declarator after_type_declarator
225 %type <ttype> parm_declarator
226 %type <ttype> parm_declarator_starttypename parm_declarator_nostarttypename
227 %type <ttype> array_declarator
228
229 %type <ttype> structsp_attr structsp_nonattr
230 %type <ttype> component_decl_list component_decl_list2
231 %type <ttype> component_decl components components_notype component_declarator
232 %type <ttype> component_notype_declarator
233 %type <ttype> enumlist enumerator
234 %type <ttype> struct_head union_head enum_head
235 %type <ttype> typename absdcl absdcl1 absdcl1_ea absdcl1_noea
236 %type <ttype> direct_absdcl1 absdcl_maybe_attribute
237 %type <ttype> condition xexpr for_cond_expr for_incr_expr
238 %type <ttype> parms parm firstparm identifiers
239
240 %type <ttype> parmlist parmlist_1 parmlist_2
241 %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
242 %type <ttype> identifiers_or_typenames
243
244 %type <itype> setspecs setspecs_fp extension
245
246 %type <location> save_location
247 \f
248 @@ifobjc
249 /* the Objective-C nonterminals */
250
251 %type <ttype> ivar_decl_list ivar_decls ivar_decl ivars ivar_declarator
252 %type <ttype> methoddecl unaryselector keywordselector selector
253 %type <ttype> keyworddecl receiver objcmessageexpr messageargs
254 %type <ttype> keywordexpr keywordarglist keywordarg
255 %type <ttype> myparms myparm optparmlist reservedwords objcselectorexpr
256 %type <ttype> selectorarg keywordnamelist keywordname objcencodeexpr
257 %type <ttype> non_empty_protocolrefs protocolrefs identifier_list objcprotocolexpr
258
259 %type <ttype> CLASSNAME OBJECTNAME OBJC_STRING
260
261 %type <ttype> superclass
262 @@end_ifobjc
263 \f
264 %{
265 /* List of types and structure classes of the current declaration.  */
266 static GTY(()) tree current_declspecs;
267 static GTY(()) tree prefix_attributes;
268
269 /* List of all the attributes applying to the identifier currently being
270    declared; includes prefix_attributes and possibly some more attributes
271    just after a comma.  */
272 static GTY(()) tree all_prefix_attributes;
273
274 /* Stack of saved values of current_declspecs, prefix_attributes and
275    all_prefix_attributes.  */
276 static GTY(()) tree declspec_stack;
277
278 /* INDIRECT_REF with a TREE_TYPE of the type being queried for offsetof.  */
279 static tree offsetof_base;
280
281 /* PUSH_DECLSPEC_STACK is called from setspecs; POP_DECLSPEC_STACK
282    should be called from the productions making use of setspecs.  */
283 #define PUSH_DECLSPEC_STACK                                              \
284   do {                                                                   \
285     declspec_stack = tree_cons (build_tree_list (prefix_attributes,      \
286                                                  all_prefix_attributes), \
287                                 current_declspecs,                       \
288                                 declspec_stack);                         \
289   } while (0)
290
291 #define POP_DECLSPEC_STACK                                              \
292   do {                                                                  \
293     current_declspecs = TREE_VALUE (declspec_stack);                    \
294     prefix_attributes = TREE_PURPOSE (TREE_PURPOSE (declspec_stack));   \
295     all_prefix_attributes = TREE_VALUE (TREE_PURPOSE (declspec_stack)); \
296     declspec_stack = TREE_CHAIN (declspec_stack);                       \
297   } while (0)
298
299 /* For __extension__, save/restore the warning flags which are
300    controlled by __extension__.  */
301 #define SAVE_EXT_FLAGS()                \
302         (pedantic                       \
303          | (warn_pointer_arith << 1)    \
304          | (warn_traditional << 2)      \
305          | (flag_iso << 3))
306
307 #define RESTORE_EXT_FLAGS(val)                  \
308   do {                                          \
309     pedantic = val & 1;                         \
310     warn_pointer_arith = (val >> 1) & 1;        \
311     warn_traditional = (val >> 2) & 1;          \
312     flag_iso = (val >> 3) & 1;                  \
313   } while (0)
314
315 @@ifobjc
316 /* Objective-C specific parser/lexer information */
317
318 static enum tree_code objc_inherit_code;
319 static int objc_pq_context = 0, objc_public_flag = 0;
320
321 /* The following flag is needed to contextualize ObjC lexical analysis.
322    In some cases (e.g., 'int NSObject;'), it is undesirable to bind
323    an identifier to an ObjC class, even if a class with that name
324    exists.  */
325 static int objc_need_raw_identifier;
326 #define OBJC_NEED_RAW_IDENTIFIER(VAL)   objc_need_raw_identifier = VAL
327 @@end_ifobjc
328
329 @@ifc
330 #define OBJC_NEED_RAW_IDENTIFIER(VAL)   /* nothing */
331 @@end_ifc
332
333 /* Tell yyparse how to print a token's value, if yydebug is set.  */
334
335 #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
336
337 static void yyprint (FILE *, int, YYSTYPE);
338 static void yyerror (const char *);
339 static int yylexname (void);
340 static inline int _yylex (void);
341 static int  yylex (void);
342 static void init_reswords (void);
343
344   /* Initialisation routine for this file.  */
345 void
346 c_parse_init (void)
347 {
348   init_reswords ();
349 }
350
351 %}
352 \f
353 %%
354 program: /* empty */
355                 { if (pedantic)
356                     pedwarn ("ISO C forbids an empty source file");
357                 }
358         | extdefs
359         ;
360
361 /* the reason for the strange actions in this rule
362  is so that notype_initdecls when reached via datadef
363  can find a valid list of type and sc specs in $0. */
364
365 extdefs:
366         {$<ttype>$ = NULL_TREE; } extdef
367         | extdefs {$<ttype>$ = NULL_TREE; ggc_collect(); } extdef
368         ;
369
370 extdef:
371         fndef
372         | datadef
373         | asmdef
374         | extension extdef
375                 { RESTORE_EXT_FLAGS ($1); }
376 @@ifobjc
377         | objcdef
378 @@end_ifobjc
379         ;
380
381 datadef:
382           setspecs notype_initdecls ';'
383                 { if (pedantic)
384                     error ("ISO C forbids data definition with no type or storage class");
385                   else
386                     warning ("data definition has no type or storage class");
387
388                   POP_DECLSPEC_STACK; }
389         | declspecs_nots setspecs notype_initdecls ';'
390                 { POP_DECLSPEC_STACK; }
391         | declspecs_ts setspecs initdecls ';'
392                 { POP_DECLSPEC_STACK; }
393         | declspecs ';'
394           { shadow_tag ($1); }
395         | error ';'
396         | error '}'
397         | ';'
398                 { if (pedantic)
399                     pedwarn ("ISO C does not allow extra `;' outside of a function"); }
400         ;
401 \f
402 fndef:
403           declspecs_ts setspecs declarator
404                 { if (! start_function (current_declspecs, $3,
405                                         all_prefix_attributes))
406                     YYERROR1;
407                 }
408           old_style_parm_decls save_location
409                 { DECL_SOURCE_LOCATION (current_function_decl) = $6;
410                   store_parm_decls (); }
411           compstmt_or_error
412                 { finish_function ();
413                   POP_DECLSPEC_STACK; }
414         | declspecs_ts setspecs declarator error
415                 { POP_DECLSPEC_STACK; }
416         | declspecs_nots setspecs notype_declarator
417                 { if (! start_function (current_declspecs, $3,
418                                         all_prefix_attributes))
419                     YYERROR1;
420                 }
421           old_style_parm_decls save_location
422                 { DECL_SOURCE_LOCATION (current_function_decl) = $6;
423                   store_parm_decls (); }
424           compstmt_or_error
425                 { finish_function ();
426                   POP_DECLSPEC_STACK; }
427         | declspecs_nots setspecs notype_declarator error
428                 { POP_DECLSPEC_STACK; }
429         | setspecs notype_declarator
430                 { if (! start_function (NULL_TREE, $2,
431                                         all_prefix_attributes))
432                     YYERROR1;
433                 }
434           old_style_parm_decls save_location
435                 { DECL_SOURCE_LOCATION (current_function_decl) = $5;
436                   store_parm_decls (); }
437           compstmt_or_error
438                 { finish_function ();
439                   POP_DECLSPEC_STACK; }
440         | setspecs notype_declarator error
441                 { POP_DECLSPEC_STACK; }
442         ;
443
444 identifier:
445         IDENTIFIER
446         | TYPENAME
447 @@ifobjc
448         | OBJECTNAME
449         | CLASSNAME
450 @@end_ifobjc
451         ;
452
453 unop:     '&'
454                 { $$ = ADDR_EXPR; }
455         | '-'
456                 { $$ = NEGATE_EXPR; }
457         | '+'
458                 { $$ = CONVERT_EXPR;
459 @@ifc
460   if (warn_traditional && !in_system_header)
461     warning ("traditional C rejects the unary plus operator");
462 @@end_ifc
463                 }
464         | PLUSPLUS
465                 { $$ = PREINCREMENT_EXPR; }
466         | MINUSMINUS
467                 { $$ = PREDECREMENT_EXPR; }
468         | '~'
469                 { $$ = BIT_NOT_EXPR; }
470         | '!'
471                 { $$ = TRUTH_NOT_EXPR; }
472         ;
473
474 expr:   expr_no_commas
475         | expr ',' expr_no_commas
476                 { $$.value = build_compound_expr ($1.value, $3.value);
477                   $$.original_code = COMPOUND_EXPR; }
478         ;
479
480 exprlist:
481           /* empty */
482                 { $$ = NULL_TREE; }
483         | nonnull_exprlist
484         ;
485
486 nonnull_exprlist:
487         expr_no_commas
488                 { $$ = build_tree_list (NULL_TREE, $1.value); }
489         | nonnull_exprlist ',' expr_no_commas
490                 { chainon ($1, build_tree_list (NULL_TREE, $3.value)); }
491         ;
492
493 unary_expr:
494         primary
495         | '*' cast_expr   %prec UNARY
496                 { $$.value = build_indirect_ref ($2.value, "unary *");
497                   $$.original_code = ERROR_MARK; }
498         /* __extension__ turns off -pedantic for following primary.  */
499         | extension cast_expr     %prec UNARY
500                 { $$ = $2;
501                   RESTORE_EXT_FLAGS ($1); }
502         | unop cast_expr  %prec UNARY
503                 { $$.value = build_unary_op ($1, $2.value, 0);
504                   overflow_warning ($$.value);
505                   $$.original_code = ERROR_MARK; }
506         /* Refer to the address of a label as a pointer.  */
507         | ANDAND identifier
508                 { $$.value = finish_label_address_expr ($2);
509                   $$.original_code = ERROR_MARK; }
510         | sizeof unary_expr  %prec UNARY
511                 { skip_evaluation--;
512                   if (TREE_CODE ($2.value) == COMPONENT_REF
513                       && DECL_C_BIT_FIELD (TREE_OPERAND ($2.value, 1)))
514                     error ("`sizeof' applied to a bit-field");
515                   $$.value = c_sizeof (TREE_TYPE ($2.value));
516                   $$.original_code = ERROR_MARK; }
517         | sizeof '(' typename ')'  %prec HYPERUNARY
518                 { skip_evaluation--;
519                   $$.value = c_sizeof (groktypename ($3));
520                   $$.original_code = ERROR_MARK; }
521         | alignof unary_expr  %prec UNARY
522                 { skip_evaluation--;
523                   $$.value = c_alignof_expr ($2.value);
524                   $$.original_code = ERROR_MARK; }
525         | alignof '(' typename ')'  %prec HYPERUNARY
526                 { skip_evaluation--;
527                   $$.value = c_alignof (groktypename ($3));
528                   $$.original_code = ERROR_MARK; }
529         | REALPART cast_expr %prec UNARY
530                 { $$.value = build_unary_op (REALPART_EXPR, $2.value, 0);
531                   $$.original_code = ERROR_MARK; }
532         | IMAGPART cast_expr %prec UNARY
533                 { $$.value = build_unary_op (IMAGPART_EXPR, $2.value, 0);
534                   $$.original_code = ERROR_MARK; }
535         ;
536
537 sizeof:
538         SIZEOF { skip_evaluation++; }
539         ;
540
541 alignof:
542         ALIGNOF { skip_evaluation++; }
543         ;
544
545 typeof:
546         TYPEOF { skip_evaluation++; }
547         ;
548
549 cast_expr:
550         unary_expr
551         | '(' typename ')' cast_expr  %prec UNARY
552                 { $$.value = c_cast_expr ($2, $4.value);
553                   $$.original_code = ERROR_MARK; }
554         ;
555
556 expr_no_commas:
557           cast_expr
558         | expr_no_commas '+' expr_no_commas
559                 { $$ = parser_build_binary_op ($2, $1, $3); }
560         | expr_no_commas '-' expr_no_commas
561                 { $$ = parser_build_binary_op ($2, $1, $3); }
562         | expr_no_commas '*' expr_no_commas
563                 { $$ = parser_build_binary_op ($2, $1, $3); }
564         | expr_no_commas '/' expr_no_commas
565                 { $$ = parser_build_binary_op ($2, $1, $3); }
566         | expr_no_commas '%' expr_no_commas
567                 { $$ = parser_build_binary_op ($2, $1, $3); }
568         | expr_no_commas LSHIFT expr_no_commas
569                 { $$ = parser_build_binary_op ($2, $1, $3); }
570         | expr_no_commas RSHIFT expr_no_commas
571                 { $$ = parser_build_binary_op ($2, $1, $3); }
572         | expr_no_commas ARITHCOMPARE expr_no_commas
573                 { $$ = parser_build_binary_op ($2, $1, $3); }
574         | expr_no_commas EQCOMPARE expr_no_commas
575                 { $$ = parser_build_binary_op ($2, $1, $3); }
576         | expr_no_commas '&' expr_no_commas
577                 { $$ = parser_build_binary_op ($2, $1, $3); }
578         | expr_no_commas '|' expr_no_commas
579                 { $$ = parser_build_binary_op ($2, $1, $3); }
580         | expr_no_commas '^' expr_no_commas
581                 { $$ = parser_build_binary_op ($2, $1, $3); }
582         | expr_no_commas ANDAND
583                 { $1.value = lang_hooks.truthvalue_conversion
584                     (default_conversion ($1.value));
585                   skip_evaluation += $1.value == truthvalue_false_node; }
586           expr_no_commas
587                 { skip_evaluation -= $1.value == truthvalue_false_node;
588                   $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $4); }
589         | expr_no_commas OROR
590                 { $1.value = lang_hooks.truthvalue_conversion
591                     (default_conversion ($1.value));
592                   skip_evaluation += $1.value == truthvalue_true_node; }
593           expr_no_commas
594                 { skip_evaluation -= $1.value == truthvalue_true_node;
595                   $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $4); }
596         | expr_no_commas '?'
597                 { $1.value = lang_hooks.truthvalue_conversion
598                     (default_conversion ($1.value));
599                   skip_evaluation += $1.value == truthvalue_false_node; }
600           expr ':'
601                 { skip_evaluation += (($1.value == truthvalue_true_node)
602                                       - ($1.value == truthvalue_false_node)); }
603           expr_no_commas
604                 { skip_evaluation -= $1.value == truthvalue_true_node;
605                   $$.value = build_conditional_expr ($1.value, $4.value,
606                                                      $7.value);
607                   $$.original_code = ERROR_MARK; }
608         | expr_no_commas '?'
609                 { if (pedantic)
610                     pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
611                   /* Make sure first operand is calculated only once.  */
612                   $<ttype>2 = save_expr (default_conversion ($1.value));
613                   $1.value = lang_hooks.truthvalue_conversion ($<ttype>2);
614                   skip_evaluation += $1.value == truthvalue_true_node; }
615           ':' expr_no_commas
616                 { skip_evaluation -= $1.value == truthvalue_true_node;
617                   $$.value = build_conditional_expr ($1.value, $<ttype>2,
618                                                      $5.value);
619                   $$.original_code = ERROR_MARK; }
620         | expr_no_commas '=' expr_no_commas
621                 { $$.value = build_modify_expr ($1.value, NOP_EXPR, $3.value);
622                   $$.original_code = MODIFY_EXPR;
623                 }
624         | expr_no_commas ASSIGN expr_no_commas
625                 { $$.value = build_modify_expr ($1.value, $2, $3.value);
626                   TREE_NO_WARNING ($$.value) = 1;
627                   $$.original_code = ERROR_MARK;
628                 }
629         ;
630
631 primary:
632         IDENTIFIER
633                 {
634                   if (yychar == YYEMPTY)
635                     yychar = YYLEX;
636                   $$.value = build_external_ref ($1, yychar == '(');
637                   $$.original_code = ERROR_MARK;
638                 }
639         | CONSTANT
640                 { $$.value = $1; $$.original_code = ERROR_MARK; }
641         | STRING
642                 { $$.value = $1; $$.original_code = STRING_CST; }
643         | FUNC_NAME
644                 { $$.value = fname_decl (C_RID_CODE ($1), $1);
645                   $$.original_code = ERROR_MARK; }
646         | '(' typename ')' '{'
647                 { start_init (NULL_TREE, NULL, 0);
648                   $2 = groktypename ($2);
649                   really_start_incremental_init ($2); }
650           initlist_maybe_comma '}'  %prec UNARY
651                 { struct c_expr init = pop_init_level (0);
652                   tree constructor = init.value;
653                   tree type = $2;
654                   finish_init ();
655                   maybe_warn_string_init (type, init);
656
657                   if (pedantic && ! flag_isoc99)
658                     pedwarn ("ISO C90 forbids compound literals");
659                   $$.value = build_compound_literal (type, constructor);
660                   $$.original_code = ERROR_MARK;
661                 }
662         | '(' expr ')'
663                 { $$.value = $2.value;
664                   if (TREE_CODE ($$.value) == MODIFY_EXPR)
665                     TREE_NO_WARNING ($$.value) = 1;
666                   $$.original_code = ERROR_MARK; }
667         | '(' error ')'
668                 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
669         | compstmt_primary_start compstmt_nostart ')'
670                 { if (pedantic)
671                     pedwarn ("ISO C forbids braced-groups within expressions");
672                   $$.value = c_finish_stmt_expr ($1);
673                   $$.original_code = ERROR_MARK;
674                 }
675         | compstmt_primary_start error ')'
676                 { c_finish_stmt_expr ($1);
677                   $$.value = error_mark_node;
678                   $$.original_code = ERROR_MARK;
679                 }
680         | primary '(' exprlist ')'   %prec '.'
681                 { $$.value = build_function_call ($1.value, $3);
682                   $$.original_code = ERROR_MARK; }
683         | VA_ARG '(' expr_no_commas ',' typename ')'
684                 { $$.value = build_va_arg ($3.value, groktypename ($5));
685                   $$.original_code = ERROR_MARK; }
686
687         | OFFSETOF '(' typename ','
688                 { tree type = groktypename ($3);
689                   if (type == error_mark_node)
690                     offsetof_base = error_mark_node;
691                   else
692                     offsetof_base = build1 (INDIRECT_REF, type, NULL);
693                 }
694           offsetof_member_designator ')'
695                 { $$.value = fold_offsetof ($6);
696                   $$.original_code = ERROR_MARK; }
697         | OFFSETOF '(' error ')'
698                 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
699         | CHOOSE_EXPR '(' expr_no_commas ',' expr_no_commas ','
700                           expr_no_commas ')'
701                 {
702                   tree c;
703
704                   c = fold ($3.value);
705                   STRIP_NOPS (c);
706                   if (TREE_CODE (c) != INTEGER_CST)
707                     error ("first argument to __builtin_choose_expr not"
708                            " a constant");
709                   $$ = integer_zerop (c) ? $7 : $5;
710                 }
711         | CHOOSE_EXPR '(' error ')'
712                 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
713         | TYPES_COMPATIBLE_P '(' typename ',' typename ')'
714                 {
715                   tree e1, e2;
716
717                   e1 = TYPE_MAIN_VARIANT (groktypename ($3));
718                   e2 = TYPE_MAIN_VARIANT (groktypename ($5));
719
720                   $$.value = comptypes (e1, e2)
721                     ? build_int_cst (NULL_TREE, 1)
722                     : build_int_cst (NULL_TREE, 0);
723                   $$.original_code = ERROR_MARK;
724                 }
725         | TYPES_COMPATIBLE_P '(' error ')'
726                 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
727         | primary '[' expr ']'   %prec '.'
728                 { $$.value = build_array_ref ($1.value, $3.value);
729                   $$.original_code = ERROR_MARK; }
730         | primary '.' identifier
731                 { $$.value = build_component_ref ($1.value, $3);
732                   $$.original_code = ERROR_MARK; }
733         | primary POINTSAT identifier
734                 {
735                   tree expr = build_indirect_ref ($1.value, "->");
736                   $$.value = build_component_ref (expr, $3);
737                   $$.original_code = ERROR_MARK;
738                 }
739         | primary PLUSPLUS
740                 { $$.value = build_unary_op (POSTINCREMENT_EXPR, $1.value, 0);
741                   $$.original_code = ERROR_MARK; }
742         | primary MINUSMINUS
743                 { $$.value = build_unary_op (POSTDECREMENT_EXPR, $1.value, 0);
744                   $$.original_code = ERROR_MARK; }
745 @@ifobjc
746         | objcmessageexpr
747                 { $$.value = objc_build_message_expr ($1);
748                   $$.original_code = ERROR_MARK; }
749         | objcselectorexpr
750                 { $$.value = objc_build_selector_expr ($1);
751                   $$.original_code = ERROR_MARK; }
752         | objcprotocolexpr
753                 { $$.value = objc_build_protocol_expr ($1);
754                   $$.original_code = ERROR_MARK; }
755         | objcencodeexpr
756                 { $$.value = objc_build_encode_expr ($1);
757                   $$.original_code = ERROR_MARK; }
758         | OBJC_STRING
759                 { $$.value = objc_build_string_object ($1);
760                   $$.original_code = ERROR_MARK; }
761 @@end_ifobjc
762         ;
763
764 /* This is the second argument to __builtin_offsetof.  We must have one
765    identifier, and beyond that we want to accept sub structure and sub
766    array references.  */
767
768 offsetof_member_designator:
769           identifier
770                 { $$ = build_component_ref (offsetof_base, $1); }
771         | offsetof_member_designator '.' identifier
772                 { $$ = build_component_ref ($1, $3); }
773         | offsetof_member_designator '[' expr ']'
774                 { $$ = build_array_ref ($1, $3.value); }
775         ;
776
777 old_style_parm_decls:
778         /* empty */
779         | datadecls
780         ;
781
782 /* The following are analogous to lineno_decl, decls and decl
783    except that they do not allow nested functions.
784    They are used for old-style parm decls.  */
785 lineno_datadecl:
786           save_location datadecl
787                 { }
788         ;
789
790 datadecls:
791         lineno_datadecl
792         | errstmt
793         | datadecls lineno_datadecl
794         | lineno_datadecl errstmt
795         ;
796
797 /* We don't allow prefix attributes here because they cause reduce/reduce
798    conflicts: we can't know whether we're parsing a function decl with
799    attribute suffix, or function defn with attribute prefix on first old
800    style parm.  */
801 datadecl:
802         declspecs_ts_nosa setspecs initdecls ';'
803                 { POP_DECLSPEC_STACK; }
804         | declspecs_nots_nosa setspecs notype_initdecls ';'
805                 { POP_DECLSPEC_STACK; }
806         | declspecs_ts_nosa ';'
807                 { shadow_tag_warned ($1, 1);
808                   pedwarn ("empty declaration"); }
809         | declspecs_nots_nosa ';'
810                 { pedwarn ("empty declaration"); }
811         ;
812
813 /* This combination which saves a lineno before a decl
814    is the normal thing to use, rather than decl itself.
815    This is to avoid shift/reduce conflicts in contexts
816    where statement labels are allowed.  */
817 lineno_decl:
818           save_location decl
819                 { }
820         ;
821
822 /* records the type and storage class specs to use for processing
823    the declarators that follow.
824    Maintains a stack of outer-level values of current_declspecs,
825    for the sake of parm declarations nested in function declarators.  */
826 setspecs: /* empty */
827                 { pending_xref_error ();
828                   PUSH_DECLSPEC_STACK;
829                   split_specs_attrs ($<ttype>0,
830                                      &current_declspecs, &prefix_attributes);
831                   all_prefix_attributes = prefix_attributes; }
832         ;
833
834 /* Possibly attributes after a comma, which should reset all_prefix_attributes
835    to prefix_attributes with these ones chained on the front.  */
836 maybe_resetattrs:
837           maybe_attribute
838                 { all_prefix_attributes = chainon ($1, prefix_attributes); }
839         ;
840
841 decl:
842         declspecs_ts setspecs initdecls ';'
843                 { POP_DECLSPEC_STACK; }
844         | declspecs_nots setspecs notype_initdecls ';'
845                 { POP_DECLSPEC_STACK; }
846         | declspecs_ts setspecs nested_function
847                 { POP_DECLSPEC_STACK; }
848         | declspecs_nots setspecs notype_nested_function
849                 { POP_DECLSPEC_STACK; }
850         | declspecs ';'
851                 { shadow_tag ($1); }
852         | extension decl
853                 { RESTORE_EXT_FLAGS ($1); }
854         ;
855
856 /* A list of declaration specifiers.  These are:
857
858    - Storage class specifiers (scspec), which for GCC currently includes
859    function specifiers ("inline").
860
861    - Type specifiers (typespec_*).
862
863    - Type qualifiers (TYPE_QUAL).
864
865    - Attribute specifier lists (attributes).
866
867    These are stored as a TREE_LIST; the head of the list is the last
868    item in the specifier list.  Each entry in the list has either a
869    TREE_PURPOSE that is an attribute specifier list, or a TREE_VALUE that
870    is a single other specifier or qualifier; and a TREE_CHAIN that is the
871    rest of the list.  TREE_STATIC is set on the list if something other
872    than a storage class specifier or attribute has been seen; this is used
873    to warn for the obsolescent usage of storage class specifiers other than
874    at the start of the list.  (Doing this properly would require function
875    specifiers to be handled separately from storage class specifiers.)
876
877    The various cases below are classified according to:
878
879    (a) Whether a storage class specifier is included or not; some
880    places in the grammar disallow storage class specifiers (_sc or _nosc).
881
882    (b) Whether a type specifier has been seen; after a type specifier,
883    a typedef name is an identifier to redeclare (_ts or _nots).
884
885    (c) Whether the list starts with an attribute; in certain places,
886    the grammar requires specifiers that don't start with an attribute
887    (_sa or _nosa).
888
889    (d) Whether the list ends with an attribute (or a specifier such that
890    any following attribute would have been parsed as part of that specifier);
891    this avoids shift-reduce conflicts in the parsing of attributes
892    (_ea or _noea).
893
894    TODO:
895
896    (i) Distinguish between function specifiers and storage class specifiers,
897    at least for the purpose of warnings about obsolescent usage.
898
899    (ii) Halve the number of productions here by eliminating the _sc/_nosc
900    distinction and instead checking where required that storage class
901    specifiers aren't present.  */
902
903 /* Declspecs which contain at least one type specifier or typedef name.
904    (Just `const' or `volatile' is not enough.)
905    A typedef'd name following these is taken as a name to be declared.
906    Declspecs have a non-NULL TREE_VALUE, attributes do not.  */
907
908 declspecs_nosc_nots_nosa_noea:
909           TYPE_QUAL
910                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
911                   TREE_STATIC ($$) = 1; }
912         | declspecs_nosc_nots_nosa_noea TYPE_QUAL
913                 { $$ = tree_cons (NULL_TREE, $2, $1);
914                   TREE_STATIC ($$) = 1; }
915         | declspecs_nosc_nots_nosa_ea TYPE_QUAL
916                 { $$ = tree_cons (NULL_TREE, $2, $1);
917                   TREE_STATIC ($$) = 1; }
918         ;
919
920 declspecs_nosc_nots_nosa_ea:
921           declspecs_nosc_nots_nosa_noea attributes
922                 { $$ = tree_cons ($2, NULL_TREE, $1);
923                   TREE_STATIC ($$) = TREE_STATIC ($1); }
924         ;
925
926 declspecs_nosc_nots_sa_noea:
927           declspecs_nosc_nots_sa_noea TYPE_QUAL
928                 { $$ = tree_cons (NULL_TREE, $2, $1);
929                   TREE_STATIC ($$) = 1; }
930         | declspecs_nosc_nots_sa_ea TYPE_QUAL
931                 { $$ = tree_cons (NULL_TREE, $2, $1);
932                   TREE_STATIC ($$) = 1; }
933         ;
934
935 declspecs_nosc_nots_sa_ea:
936           attributes
937                 { $$ = tree_cons ($1, NULL_TREE, NULL_TREE);
938                   TREE_STATIC ($$) = 0; }
939         | declspecs_nosc_nots_sa_noea attributes
940                 { $$ = tree_cons ($2, NULL_TREE, $1);
941                   TREE_STATIC ($$) = TREE_STATIC ($1); }
942         ;
943
944 declspecs_nosc_ts_nosa_noea:
945           typespec_nonattr
946                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
947                   TREE_STATIC ($$) = 1; }
948         | declspecs_nosc_ts_nosa_noea TYPE_QUAL
949                 { $$ = tree_cons (NULL_TREE, $2, $1);
950                   TREE_STATIC ($$) = 1; }
951         | declspecs_nosc_ts_nosa_ea TYPE_QUAL
952                 { $$ = tree_cons (NULL_TREE, $2, $1);
953                   TREE_STATIC ($$) = 1; }
954         | declspecs_nosc_ts_nosa_noea typespec_reserved_nonattr
955                 { $$ = tree_cons (NULL_TREE, $2, $1);
956                   TREE_STATIC ($$) = 1; }
957         | declspecs_nosc_ts_nosa_ea typespec_reserved_nonattr
958                 { $$ = tree_cons (NULL_TREE, $2, $1);
959                   TREE_STATIC ($$) = 1; }
960         | declspecs_nosc_nots_nosa_noea typespec_nonattr
961                 { $$ = tree_cons (NULL_TREE, $2, $1);
962                   TREE_STATIC ($$) = 1; }
963         | declspecs_nosc_nots_nosa_ea typespec_nonattr
964                 { $$ = tree_cons (NULL_TREE, $2, $1);
965                   TREE_STATIC ($$) = 1; }
966         ;
967
968 declspecs_nosc_ts_nosa_ea:
969           typespec_attr
970                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
971                   TREE_STATIC ($$) = 1; }
972         | declspecs_nosc_ts_nosa_noea attributes
973                 { $$ = tree_cons ($2, NULL_TREE, $1);
974                   TREE_STATIC ($$) = TREE_STATIC ($1); }
975         | declspecs_nosc_ts_nosa_noea typespec_reserved_attr
976                 { $$ = tree_cons (NULL_TREE, $2, $1);
977                   TREE_STATIC ($$) = 1; }
978         | declspecs_nosc_ts_nosa_ea typespec_reserved_attr
979                 { $$ = tree_cons (NULL_TREE, $2, $1);
980                   TREE_STATIC ($$) = 1; }
981         | declspecs_nosc_nots_nosa_noea typespec_attr
982                 { $$ = tree_cons (NULL_TREE, $2, $1);
983                   TREE_STATIC ($$) = 1; }
984         | declspecs_nosc_nots_nosa_ea typespec_attr
985                 { $$ = tree_cons (NULL_TREE, $2, $1);
986                   TREE_STATIC ($$) = 1; }
987         ;
988
989 declspecs_nosc_ts_sa_noea:
990           declspecs_nosc_ts_sa_noea TYPE_QUAL
991                 { $$ = tree_cons (NULL_TREE, $2, $1);
992                   TREE_STATIC ($$) = 1; }
993         | declspecs_nosc_ts_sa_ea TYPE_QUAL
994                 { $$ = tree_cons (NULL_TREE, $2, $1);
995                   TREE_STATIC ($$) = 1; }
996         | declspecs_nosc_ts_sa_noea typespec_reserved_nonattr
997                 { $$ = tree_cons (NULL_TREE, $2, $1);
998                   TREE_STATIC ($$) = 1; }
999         | declspecs_nosc_ts_sa_ea typespec_reserved_nonattr
1000                 { $$ = tree_cons (NULL_TREE, $2, $1);
1001                   TREE_STATIC ($$) = 1; }
1002         | declspecs_nosc_nots_sa_noea typespec_nonattr
1003                 { $$ = tree_cons (NULL_TREE, $2, $1);
1004                   TREE_STATIC ($$) = 1; }
1005         | declspecs_nosc_nots_sa_ea typespec_nonattr
1006                 { $$ = tree_cons (NULL_TREE, $2, $1);
1007                   TREE_STATIC ($$) = 1; }
1008         ;
1009
1010 declspecs_nosc_ts_sa_ea:
1011           declspecs_nosc_ts_sa_noea attributes
1012                 { $$ = tree_cons ($2, NULL_TREE, $1);
1013                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1014         | declspecs_nosc_ts_sa_noea typespec_reserved_attr
1015                 { $$ = tree_cons (NULL_TREE, $2, $1);
1016                   TREE_STATIC ($$) = 1; }
1017         | declspecs_nosc_ts_sa_ea typespec_reserved_attr
1018                 { $$ = tree_cons (NULL_TREE, $2, $1);
1019                   TREE_STATIC ($$) = 1; }
1020         | declspecs_nosc_nots_sa_noea typespec_attr
1021                 { $$ = tree_cons (NULL_TREE, $2, $1);
1022                   TREE_STATIC ($$) = 1; }
1023         | declspecs_nosc_nots_sa_ea typespec_attr
1024                 { $$ = tree_cons (NULL_TREE, $2, $1);
1025                   TREE_STATIC ($$) = 1; }
1026         ;
1027
1028 declspecs_sc_nots_nosa_noea:
1029           scspec
1030                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
1031                   TREE_STATIC ($$) = 0; }
1032         | declspecs_sc_nots_nosa_noea TYPE_QUAL
1033                 { $$ = tree_cons (NULL_TREE, $2, $1);
1034                   TREE_STATIC ($$) = 1; }
1035         | declspecs_sc_nots_nosa_ea TYPE_QUAL
1036                 { $$ = tree_cons (NULL_TREE, $2, $1);
1037                   TREE_STATIC ($$) = 1; }
1038         | declspecs_nosc_nots_nosa_noea scspec
1039                 { if (extra_warnings && TREE_STATIC ($1))
1040                     warning ("`%s' is not at beginning of declaration",
1041                              IDENTIFIER_POINTER ($2));
1042                   $$ = tree_cons (NULL_TREE, $2, $1);
1043                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1044         | declspecs_nosc_nots_nosa_ea scspec
1045                 { if (extra_warnings && TREE_STATIC ($1))
1046                     warning ("`%s' is not at beginning of declaration",
1047                              IDENTIFIER_POINTER ($2));
1048                   $$ = tree_cons (NULL_TREE, $2, $1);
1049                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1050         | declspecs_sc_nots_nosa_noea scspec
1051                 { if (extra_warnings && TREE_STATIC ($1))
1052                     warning ("`%s' is not at beginning of declaration",
1053                              IDENTIFIER_POINTER ($2));
1054                   $$ = tree_cons (NULL_TREE, $2, $1);
1055                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1056         | declspecs_sc_nots_nosa_ea scspec
1057                 { if (extra_warnings && TREE_STATIC ($1))
1058                     warning ("`%s' is not at beginning of declaration",
1059                              IDENTIFIER_POINTER ($2));
1060                   $$ = tree_cons (NULL_TREE, $2, $1);
1061                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1062         ;
1063
1064 declspecs_sc_nots_nosa_ea:
1065           declspecs_sc_nots_nosa_noea attributes
1066                 { $$ = tree_cons ($2, NULL_TREE, $1);
1067                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1068         ;
1069
1070 declspecs_sc_nots_sa_noea:
1071           declspecs_sc_nots_sa_noea TYPE_QUAL
1072                 { $$ = tree_cons (NULL_TREE, $2, $1);
1073                   TREE_STATIC ($$) = 1; }
1074         | declspecs_sc_nots_sa_ea TYPE_QUAL
1075                 { $$ = tree_cons (NULL_TREE, $2, $1);
1076                   TREE_STATIC ($$) = 1; }
1077         | declspecs_nosc_nots_sa_noea scspec
1078                 { if (extra_warnings && TREE_STATIC ($1))
1079                     warning ("`%s' is not at beginning of declaration",
1080                              IDENTIFIER_POINTER ($2));
1081                   $$ = tree_cons (NULL_TREE, $2, $1);
1082                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1083         | declspecs_nosc_nots_sa_ea scspec
1084                 { if (extra_warnings && TREE_STATIC ($1))
1085                     warning ("`%s' is not at beginning of declaration",
1086                              IDENTIFIER_POINTER ($2));
1087                   $$ = tree_cons (NULL_TREE, $2, $1);
1088                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1089         | declspecs_sc_nots_sa_noea scspec
1090                 { if (extra_warnings && TREE_STATIC ($1))
1091                     warning ("`%s' is not at beginning of declaration",
1092                              IDENTIFIER_POINTER ($2));
1093                   $$ = tree_cons (NULL_TREE, $2, $1);
1094                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1095         | declspecs_sc_nots_sa_ea scspec
1096                 { if (extra_warnings && TREE_STATIC ($1))
1097                     warning ("`%s' is not at beginning of declaration",
1098                              IDENTIFIER_POINTER ($2));
1099                   $$ = tree_cons (NULL_TREE, $2, $1);
1100                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1101         ;
1102
1103 declspecs_sc_nots_sa_ea:
1104           declspecs_sc_nots_sa_noea attributes
1105                 { $$ = tree_cons ($2, NULL_TREE, $1);
1106                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1107         ;
1108
1109 declspecs_sc_ts_nosa_noea:
1110           declspecs_sc_ts_nosa_noea TYPE_QUAL
1111                 { $$ = tree_cons (NULL_TREE, $2, $1);
1112                   TREE_STATIC ($$) = 1; }
1113         | declspecs_sc_ts_nosa_ea TYPE_QUAL
1114                 { $$ = tree_cons (NULL_TREE, $2, $1);
1115                   TREE_STATIC ($$) = 1; }
1116         | declspecs_sc_ts_nosa_noea typespec_reserved_nonattr
1117                 { $$ = tree_cons (NULL_TREE, $2, $1);
1118                   TREE_STATIC ($$) = 1; }
1119         | declspecs_sc_ts_nosa_ea typespec_reserved_nonattr
1120                 { $$ = tree_cons (NULL_TREE, $2, $1);
1121                   TREE_STATIC ($$) = 1; }
1122         | declspecs_sc_nots_nosa_noea typespec_nonattr
1123                 { $$ = tree_cons (NULL_TREE, $2, $1);
1124                   TREE_STATIC ($$) = 1; }
1125         | declspecs_sc_nots_nosa_ea typespec_nonattr
1126                 { $$ = tree_cons (NULL_TREE, $2, $1);
1127                   TREE_STATIC ($$) = 1; }
1128         | declspecs_nosc_ts_nosa_noea scspec
1129                 { if (extra_warnings && TREE_STATIC ($1))
1130                     warning ("`%s' is not at beginning of declaration",
1131                              IDENTIFIER_POINTER ($2));
1132                   $$ = tree_cons (NULL_TREE, $2, $1);
1133                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1134         | declspecs_nosc_ts_nosa_ea scspec
1135                 { if (extra_warnings && TREE_STATIC ($1))
1136                     warning ("`%s' is not at beginning of declaration",
1137                              IDENTIFIER_POINTER ($2));
1138                   $$ = tree_cons (NULL_TREE, $2, $1);
1139                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1140         | declspecs_sc_ts_nosa_noea scspec
1141                 { if (extra_warnings && TREE_STATIC ($1))
1142                     warning ("`%s' is not at beginning of declaration",
1143                              IDENTIFIER_POINTER ($2));
1144                   $$ = tree_cons (NULL_TREE, $2, $1);
1145                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1146         | declspecs_sc_ts_nosa_ea scspec
1147                 { if (extra_warnings && TREE_STATIC ($1))
1148                     warning ("`%s' is not at beginning of declaration",
1149                              IDENTIFIER_POINTER ($2));
1150                   $$ = tree_cons (NULL_TREE, $2, $1);
1151                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1152         ;
1153
1154 declspecs_sc_ts_nosa_ea:
1155           declspecs_sc_ts_nosa_noea attributes
1156                 { $$ = tree_cons ($2, NULL_TREE, $1);
1157                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1158         | declspecs_sc_ts_nosa_noea typespec_reserved_attr
1159                 { $$ = tree_cons (NULL_TREE, $2, $1);
1160                   TREE_STATIC ($$) = 1; }
1161         | declspecs_sc_ts_nosa_ea typespec_reserved_attr
1162                 { $$ = tree_cons (NULL_TREE, $2, $1);
1163                   TREE_STATIC ($$) = 1; }
1164         | declspecs_sc_nots_nosa_noea typespec_attr
1165                 { $$ = tree_cons (NULL_TREE, $2, $1);
1166                   TREE_STATIC ($$) = 1; }
1167         | declspecs_sc_nots_nosa_ea typespec_attr
1168                 { $$ = tree_cons (NULL_TREE, $2, $1);
1169                   TREE_STATIC ($$) = 1; }
1170         ;
1171
1172 declspecs_sc_ts_sa_noea:
1173           declspecs_sc_ts_sa_noea TYPE_QUAL
1174                 { $$ = tree_cons (NULL_TREE, $2, $1);
1175                   TREE_STATIC ($$) = 1; }
1176         | declspecs_sc_ts_sa_ea TYPE_QUAL
1177                 { $$ = tree_cons (NULL_TREE, $2, $1);
1178                   TREE_STATIC ($$) = 1; }
1179         | declspecs_sc_ts_sa_noea typespec_reserved_nonattr
1180                 { $$ = tree_cons (NULL_TREE, $2, $1);
1181                   TREE_STATIC ($$) = 1; }
1182         | declspecs_sc_ts_sa_ea typespec_reserved_nonattr
1183                 { $$ = tree_cons (NULL_TREE, $2, $1);
1184                   TREE_STATIC ($$) = 1; }
1185         | declspecs_sc_nots_sa_noea typespec_nonattr
1186                 { $$ = tree_cons (NULL_TREE, $2, $1);
1187                   TREE_STATIC ($$) = 1; }
1188         | declspecs_sc_nots_sa_ea typespec_nonattr
1189                 { $$ = tree_cons (NULL_TREE, $2, $1);
1190                   TREE_STATIC ($$) = 1; }
1191         | declspecs_nosc_ts_sa_noea scspec
1192                 { if (extra_warnings && TREE_STATIC ($1))
1193                     warning ("`%s' is not at beginning of declaration",
1194                              IDENTIFIER_POINTER ($2));
1195                   $$ = tree_cons (NULL_TREE, $2, $1);
1196                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1197         | declspecs_nosc_ts_sa_ea scspec
1198                 { if (extra_warnings && TREE_STATIC ($1))
1199                     warning ("`%s' is not at beginning of declaration",
1200                              IDENTIFIER_POINTER ($2));
1201                   $$ = tree_cons (NULL_TREE, $2, $1);
1202                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1203         | declspecs_sc_ts_sa_noea scspec
1204                 { if (extra_warnings && TREE_STATIC ($1))
1205                     warning ("`%s' is not at beginning of declaration",
1206                              IDENTIFIER_POINTER ($2));
1207                   $$ = tree_cons (NULL_TREE, $2, $1);
1208                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1209         | declspecs_sc_ts_sa_ea scspec
1210                 { if (extra_warnings && TREE_STATIC ($1))
1211                     warning ("`%s' is not at beginning of declaration",
1212                              IDENTIFIER_POINTER ($2));
1213                   $$ = tree_cons (NULL_TREE, $2, $1);
1214                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1215         ;
1216
1217 declspecs_sc_ts_sa_ea:
1218           declspecs_sc_ts_sa_noea attributes
1219                 { $$ = tree_cons ($2, NULL_TREE, $1);
1220                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1221         | declspecs_sc_ts_sa_noea typespec_reserved_attr
1222                 { $$ = tree_cons (NULL_TREE, $2, $1);
1223                   TREE_STATIC ($$) = 1; }
1224         | declspecs_sc_ts_sa_ea typespec_reserved_attr
1225                 { $$ = tree_cons (NULL_TREE, $2, $1);
1226                   TREE_STATIC ($$) = 1; }
1227         | declspecs_sc_nots_sa_noea typespec_attr
1228                 { $$ = tree_cons (NULL_TREE, $2, $1);
1229                   TREE_STATIC ($$) = 1; }
1230         | declspecs_sc_nots_sa_ea typespec_attr
1231                 { $$ = tree_cons (NULL_TREE, $2, $1);
1232                   TREE_STATIC ($$) = 1; }
1233         ;
1234
1235 /* Particular useful classes of declspecs.  */
1236 declspecs_ts:
1237           declspecs_nosc_ts_nosa_noea
1238         | declspecs_nosc_ts_nosa_ea
1239         | declspecs_nosc_ts_sa_noea
1240         | declspecs_nosc_ts_sa_ea
1241         | declspecs_sc_ts_nosa_noea
1242         | declspecs_sc_ts_nosa_ea
1243         | declspecs_sc_ts_sa_noea
1244         | declspecs_sc_ts_sa_ea
1245         ;
1246
1247 declspecs_nots:
1248           declspecs_nosc_nots_nosa_noea
1249         | declspecs_nosc_nots_nosa_ea
1250         | declspecs_nosc_nots_sa_noea
1251         | declspecs_nosc_nots_sa_ea
1252         | declspecs_sc_nots_nosa_noea
1253         | declspecs_sc_nots_nosa_ea
1254         | declspecs_sc_nots_sa_noea
1255         | declspecs_sc_nots_sa_ea
1256         ;
1257
1258 declspecs_ts_nosa:
1259           declspecs_nosc_ts_nosa_noea
1260         | declspecs_nosc_ts_nosa_ea
1261         | declspecs_sc_ts_nosa_noea
1262         | declspecs_sc_ts_nosa_ea
1263         ;
1264
1265 declspecs_nots_nosa:
1266           declspecs_nosc_nots_nosa_noea
1267         | declspecs_nosc_nots_nosa_ea
1268         | declspecs_sc_nots_nosa_noea
1269         | declspecs_sc_nots_nosa_ea
1270         ;
1271
1272 declspecs_nosc_ts:
1273           declspecs_nosc_ts_nosa_noea
1274         | declspecs_nosc_ts_nosa_ea
1275         | declspecs_nosc_ts_sa_noea
1276         | declspecs_nosc_ts_sa_ea
1277         ;
1278
1279 declspecs_nosc_nots:
1280           declspecs_nosc_nots_nosa_noea
1281         | declspecs_nosc_nots_nosa_ea
1282         | declspecs_nosc_nots_sa_noea
1283         | declspecs_nosc_nots_sa_ea
1284         ;
1285
1286 declspecs_nosc:
1287           declspecs_nosc_ts_nosa_noea
1288         | declspecs_nosc_ts_nosa_ea
1289         | declspecs_nosc_ts_sa_noea
1290         | declspecs_nosc_ts_sa_ea
1291         | declspecs_nosc_nots_nosa_noea
1292         | declspecs_nosc_nots_nosa_ea
1293         | declspecs_nosc_nots_sa_noea
1294         | declspecs_nosc_nots_sa_ea
1295         ;
1296
1297 declspecs:
1298           declspecs_nosc_nots_nosa_noea
1299         | declspecs_nosc_nots_nosa_ea
1300         | declspecs_nosc_nots_sa_noea
1301         | declspecs_nosc_nots_sa_ea
1302         | declspecs_nosc_ts_nosa_noea
1303         | declspecs_nosc_ts_nosa_ea
1304         | declspecs_nosc_ts_sa_noea
1305         | declspecs_nosc_ts_sa_ea
1306         | declspecs_sc_nots_nosa_noea
1307         | declspecs_sc_nots_nosa_ea
1308         | declspecs_sc_nots_sa_noea
1309         | declspecs_sc_nots_sa_ea
1310         | declspecs_sc_ts_nosa_noea
1311         | declspecs_sc_ts_nosa_ea
1312         | declspecs_sc_ts_sa_noea
1313         | declspecs_sc_ts_sa_ea
1314         ;
1315
1316 /* A (possibly empty) sequence of type qualifiers and attributes.  */
1317 maybe_type_quals_attrs:
1318           /* empty */
1319                 { $$ = NULL_TREE; }
1320         | declspecs_nosc_nots
1321                 { $$ = $1; }
1322         ;
1323
1324 /* A type specifier (but not a type qualifier).
1325    Once we have seen one of these in a declaration,
1326    if a typedef name appears then it is being redeclared.
1327
1328    The _reserved versions start with a reserved word and may appear anywhere
1329    in the declaration specifiers; the _nonreserved versions may only
1330    appear before any other type specifiers, and after that are (if names)
1331    being redeclared.
1332
1333    FIXME: should the _nonreserved version be restricted to names being
1334    redeclared only?  The other entries there relate only the GNU extensions
1335    and Objective C, and are historically parsed thus, and don't make sense
1336    after other type specifiers, but it might be cleaner to count them as
1337    _reserved.
1338
1339    _attr means: specifiers that either end with attributes,
1340    or are such that any following attributes would
1341    be parsed as part of the specifier.
1342
1343    _nonattr: specifiers.  */
1344
1345 typespec_nonattr:
1346           typespec_reserved_nonattr
1347         | typespec_nonreserved_nonattr
1348         ;
1349
1350 typespec_attr:
1351           typespec_reserved_attr
1352         ;
1353
1354 typespec_reserved_nonattr:
1355           TYPESPEC
1356                 { OBJC_NEED_RAW_IDENTIFIER (1); }
1357         | structsp_nonattr
1358         ;
1359
1360 typespec_reserved_attr:
1361           structsp_attr
1362         ;
1363
1364 typespec_nonreserved_nonattr:
1365           TYPENAME
1366                 { /* For a typedef name, record the meaning, not the name.
1367                      In case of `foo foo, bar;'.  */
1368                   $$ = lookup_name ($1); }
1369 @@ifobjc
1370         | CLASSNAME protocolrefs
1371                 { $$ = get_static_reference ($1, $2); }
1372         | OBJECTNAME protocolrefs
1373                 { $$ = get_protocol_reference ($2); }
1374
1375 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>"
1376    - nisse@lysator.liu.se */
1377         | non_empty_protocolrefs
1378                 { $$ = get_protocol_reference ($1); }
1379 @@end_ifobjc
1380         | typeof '(' expr ')'
1381                 { skip_evaluation--;
1382                   if (TREE_CODE ($3.value) == COMPONENT_REF
1383                       && DECL_C_BIT_FIELD (TREE_OPERAND ($3.value, 1)))
1384                     error ("`typeof' applied to a bit-field");
1385                   $$ = TREE_TYPE ($3.value); }
1386         | typeof '(' typename ')'
1387                 { skip_evaluation--; $$ = groktypename ($3); }
1388         ;
1389
1390 /* typespec_nonreserved_attr does not exist.  */
1391
1392 initdecls:
1393         initdcl
1394         | initdecls ',' maybe_resetattrs initdcl
1395         ;
1396
1397 notype_initdecls:
1398         notype_initdcl
1399         | notype_initdecls ',' maybe_resetattrs notype_initdcl
1400         ;
1401
1402 initdcl:
1403           declarator maybeasm maybe_attribute '='
1404                 { $<ttype>$ = start_decl ($1, current_declspecs, true,
1405                                           chainon ($3, all_prefix_attributes));
1406                   start_init ($<ttype>$, $2, global_bindings_p ()); }
1407           init
1408 /* Note how the declaration of the variable is in effect while its init is parsed! */
1409                 { finish_init ();
1410                   maybe_warn_string_init (TREE_TYPE ($<ttype>5), $6);
1411                   finish_decl ($<ttype>5, $6.value, $2); }
1412         | declarator maybeasm maybe_attribute
1413                 { tree d = start_decl ($1, current_declspecs, false,
1414                                        chainon ($3, all_prefix_attributes));
1415                   finish_decl (d, NULL_TREE, $2);
1416                 }
1417         ;
1418
1419 notype_initdcl:
1420           notype_declarator maybeasm maybe_attribute '='
1421                 { $<ttype>$ = start_decl ($1, current_declspecs, true,
1422                                           chainon ($3, all_prefix_attributes));
1423                   start_init ($<ttype>$, $2, global_bindings_p ()); }
1424           init
1425 /* Note how the declaration of the variable is in effect while its init is parsed! */
1426                 { finish_init ();
1427                   maybe_warn_string_init (TREE_TYPE ($<ttype>5), $6);
1428                   finish_decl ($<ttype>5, $6.value, $2); }
1429         | notype_declarator maybeasm maybe_attribute
1430                 { tree d = start_decl ($1, current_declspecs, false,
1431                                        chainon ($3, all_prefix_attributes));
1432                   finish_decl (d, NULL_TREE, $2); }
1433         ;
1434 /* the * rules are dummies to accept the Apollo extended syntax
1435    so that the header files compile. */
1436 maybe_attribute:
1437       /* empty */
1438                 { $$ = NULL_TREE; }
1439         | attributes
1440                 { $$ = $1; }
1441         ;
1442
1443 attributes:
1444       attribute
1445                 { $$ = $1; }
1446         | attributes attribute
1447                 { $$ = chainon ($1, $2); }
1448         ;
1449
1450 attribute:
1451       ATTRIBUTE stop_string_translation
1452                 '(' '(' attribute_list ')' ')' start_string_translation
1453                 { $$ = $5; }
1454       | ATTRIBUTE error start_string_translation
1455                 {}
1456         ;
1457
1458 attribute_list:
1459       attrib
1460                 { $$ = $1; }
1461         | attribute_list ',' attrib
1462                 { $$ = chainon ($1, $3); }
1463         ;
1464
1465 attrib:
1466     /* empty */
1467                 { $$ = NULL_TREE; }
1468         | any_word
1469                 { $$ = build_tree_list ($1, NULL_TREE); }
1470         | any_word '(' IDENTIFIER ')'
1471                 { $$ = build_tree_list ($1, build_tree_list (NULL_TREE, $3)); }
1472         | any_word '(' IDENTIFIER ',' nonnull_exprlist ')'
1473                 { $$ = build_tree_list ($1, tree_cons (NULL_TREE, $3, $5)); }
1474         | any_word '(' exprlist ')'
1475                 { $$ = build_tree_list ($1, $3); }
1476         ;
1477
1478 /* This still leaves out most reserved keywords,
1479    shouldn't we include them?  */
1480
1481 any_word:
1482           identifier
1483         | scspec
1484         | TYPESPEC
1485         | TYPE_QUAL
1486         ;
1487
1488 scspec:
1489           STATIC
1490         | SCSPEC
1491         ;
1492 \f
1493 /* Initializers.  `init' is the entry point.  */
1494
1495 init:
1496         expr_no_commas
1497                 { $$ = $1; }
1498         | '{'
1499                 { really_start_incremental_init (NULL_TREE); }
1500           initlist_maybe_comma '}'
1501                 { $$ = pop_init_level (0); }
1502         | error
1503                 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
1504         ;
1505
1506 /* `initlist_maybe_comma' is the guts of an initializer in braces.  */
1507 initlist_maybe_comma:
1508           /* empty */
1509                 { if (pedantic)
1510                     pedwarn ("ISO C forbids empty initializer braces"); }
1511         | initlist1 maybecomma
1512         ;
1513
1514 initlist1:
1515           initelt
1516         | initlist1 ',' initelt
1517         ;
1518
1519 /* `initelt' is a single element of an initializer.
1520    It may use braces.  */
1521 initelt:
1522           designator_list '=' initval
1523                 { if (pedantic && ! flag_isoc99)
1524                     pedwarn ("ISO C90 forbids specifying subobject to initialize"); }
1525         | designator initval
1526                 { if (pedantic)
1527                     pedwarn ("obsolete use of designated initializer without `='"); }
1528         | identifier ':'
1529                 { set_init_label ($1);
1530                   if (pedantic)
1531                     pedwarn ("obsolete use of designated initializer with `:'"); }
1532           initval
1533                 {}
1534         | initval
1535         ;
1536
1537 initval:
1538           '{'
1539                 { push_init_level (0); }
1540           initlist_maybe_comma '}'
1541                 { process_init_element (pop_init_level (0)); }
1542         | expr_no_commas
1543                 { process_init_element ($1); }
1544         | error
1545         ;
1546
1547 designator_list:
1548           designator
1549         | designator_list designator
1550         ;
1551
1552 designator:
1553           '.' identifier
1554                 { set_init_label ($2); }
1555         | '[' expr_no_commas ELLIPSIS expr_no_commas ']'
1556                 { set_init_index ($2.value, $4.value);
1557                   if (pedantic)
1558                     pedwarn ("ISO C forbids specifying range of elements to initialize"); }
1559         | '[' expr_no_commas ']'
1560                 { set_init_index ($2.value, NULL_TREE); }
1561         ;
1562 \f
1563 nested_function:
1564         declarator
1565                 { if (pedantic)
1566                     pedwarn ("ISO C forbids nested functions");
1567
1568                   push_function_context ();
1569                   if (! start_function (current_declspecs, $1,
1570                                         all_prefix_attributes))
1571                     {
1572                       pop_function_context ();
1573                       YYERROR1;
1574                     }
1575                 }
1576         old_style_parm_decls save_location
1577                 { tree decl = current_function_decl;
1578                   DECL_SOURCE_LOCATION (decl) = $4;
1579                   store_parm_decls (); }
1580         /* This used to use compstmt_or_error.  That caused a bug with
1581            input `f(g) int g {}', where the use of YYERROR1 above caused
1582            an error which then was handled by compstmt_or_error.  There
1583            followed a repeated execution of that same rule, which called
1584            YYERROR1 again, and so on.  */
1585         compstmt
1586                 { tree decl = current_function_decl;
1587                   add_stmt ($6);
1588                   finish_function ();
1589                   pop_function_context ();
1590                   add_stmt (build_stmt (DECL_EXPR, decl)); }
1591         ;
1592
1593 notype_nested_function:
1594         notype_declarator
1595                 { if (pedantic)
1596                     pedwarn ("ISO C forbids nested functions");
1597
1598                   push_function_context ();
1599                   if (! start_function (current_declspecs, $1,
1600                                         all_prefix_attributes))
1601                     {
1602                       pop_function_context ();
1603                       YYERROR1;
1604                     }
1605                 }
1606         old_style_parm_decls save_location
1607                 { tree decl = current_function_decl;
1608                   DECL_SOURCE_LOCATION (decl) = $4;
1609                   store_parm_decls (); }
1610         /* This used to use compstmt_or_error.  That caused a bug with
1611            input `f(g) int g {}', where the use of YYERROR1 above caused
1612            an error which then was handled by compstmt_or_error.  There
1613            followed a repeated execution of that same rule, which called
1614            YYERROR1 again, and so on.  */
1615         compstmt
1616                 { tree decl = current_function_decl;
1617                   add_stmt ($6);
1618                   finish_function ();
1619                   pop_function_context ();
1620                   add_stmt (build_stmt (DECL_EXPR, decl)); }
1621         ;
1622
1623 /* Any kind of declarator (thus, all declarators allowed
1624    after an explicit typespec).  */
1625
1626 declarator:
1627           after_type_declarator
1628         | notype_declarator
1629         ;
1630
1631 /* A declarator that is allowed only after an explicit typespec.  */
1632
1633 after_type_declarator:
1634           '(' maybe_attribute after_type_declarator ')'
1635                 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1636         | after_type_declarator '(' parmlist_or_identifiers  %prec '.'
1637                 { $$ = build_function_declarator ($3, $1); }
1638         | after_type_declarator array_declarator  %prec '.'
1639                 { $$ = set_array_declarator_inner ($2, $1, false); }
1640         | '*' maybe_type_quals_attrs after_type_declarator  %prec UNARY
1641                 { $$ = make_pointer_declarator ($2, $3); }
1642         | TYPENAME
1643 @@ifobjc
1644         | OBJECTNAME
1645 @@end_ifobjc
1646         ;
1647
1648 /* Kinds of declarator that can appear in a parameter list
1649    in addition to notype_declarator.  This is like after_type_declarator
1650    but does not allow a typedef name in parentheses as an identifier
1651    (because it would conflict with a function with that typedef as arg).  */
1652 parm_declarator:
1653           parm_declarator_starttypename
1654         | parm_declarator_nostarttypename
1655         ;
1656
1657 parm_declarator_starttypename:
1658           parm_declarator_starttypename '(' parmlist_or_identifiers  %prec '.'
1659                 { $$ = build_function_declarator ($3, $1); }
1660         | parm_declarator_starttypename array_declarator  %prec '.'
1661                 { $$ = set_array_declarator_inner ($2, $1, false); }
1662         | TYPENAME
1663 @@ifobjc
1664         | OBJECTNAME
1665 @@end_ifobjc
1666         ;
1667
1668 parm_declarator_nostarttypename:
1669           parm_declarator_nostarttypename '(' parmlist_or_identifiers  %prec '.'
1670                 { $$ = build_function_declarator ($3, $1); }
1671         | parm_declarator_nostarttypename array_declarator  %prec '.'
1672                 { $$ = set_array_declarator_inner ($2, $1, false); }
1673         | '*' maybe_type_quals_attrs parm_declarator_starttypename  %prec UNARY
1674                 { $$ = make_pointer_declarator ($2, $3); }
1675         | '*' maybe_type_quals_attrs parm_declarator_nostarttypename  %prec UNARY
1676                 { $$ = make_pointer_declarator ($2, $3); }
1677         | '(' maybe_attribute parm_declarator_nostarttypename ')'
1678                 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1679         ;
1680
1681 /* A declarator allowed whether or not there has been
1682    an explicit typespec.  These cannot redeclare a typedef-name.  */
1683
1684 notype_declarator:
1685           notype_declarator '(' parmlist_or_identifiers  %prec '.'
1686                 { $$ = build_function_declarator ($3, $1); }
1687         | '(' maybe_attribute notype_declarator ')'
1688                 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1689         | '*' maybe_type_quals_attrs notype_declarator  %prec UNARY
1690                 { $$ = make_pointer_declarator ($2, $3); }
1691         | notype_declarator array_declarator  %prec '.'
1692                 { $$ = set_array_declarator_inner ($2, $1, false); }
1693         | IDENTIFIER
1694         ;
1695
1696 struct_head:
1697           STRUCT
1698                 { $$ = NULL_TREE; }
1699         | STRUCT attributes
1700                 { $$ = $2; }
1701         ;
1702
1703 union_head:
1704           UNION
1705                 { $$ = NULL_TREE; }
1706         | UNION attributes
1707                 { $$ = $2; }
1708         ;
1709
1710 enum_head:
1711           ENUM
1712                 { $$ = NULL_TREE; }
1713         | ENUM attributes
1714                 { $$ = $2; }
1715         ;
1716
1717 /* structsp_attr: struct/union/enum specifiers that either
1718    end with attributes, or are such that any following attributes would
1719    be parsed as part of the struct/union/enum specifier.
1720
1721    structsp_nonattr: other struct/union/enum specifiers.  */
1722
1723 structsp_attr:
1724           struct_head identifier '{'
1725                 { $$ = start_struct (RECORD_TYPE, $2);
1726                   /* Start scope of tag before parsing components.  */
1727                 }
1728           component_decl_list '}' maybe_attribute
1729                 { $$ = finish_struct ($<ttype>4, nreverse ($5),
1730                                       chainon ($1, $7)); }
1731         | struct_head '{' component_decl_list '}' maybe_attribute
1732                 { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
1733                                       nreverse ($3), chainon ($1, $5));
1734                 }
1735         | union_head identifier '{'
1736                 { $$ = start_struct (UNION_TYPE, $2); }
1737           component_decl_list '}' maybe_attribute
1738                 { $$ = finish_struct ($<ttype>4, nreverse ($5),
1739                                       chainon ($1, $7)); }
1740         | union_head '{' component_decl_list '}' maybe_attribute
1741                 { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
1742                                       nreverse ($3), chainon ($1, $5));
1743                 }
1744         | enum_head identifier '{'
1745                 { $$ = start_enum ($2); }
1746           enumlist maybecomma_warn '}' maybe_attribute
1747                 { $$ = finish_enum ($<ttype>4, nreverse ($5),
1748                                     chainon ($1, $8)); }
1749         | enum_head '{'
1750                 { $$ = start_enum (NULL_TREE); }
1751           enumlist maybecomma_warn '}' maybe_attribute
1752                 { $$ = finish_enum ($<ttype>3, nreverse ($4),
1753                                     chainon ($1, $7)); }
1754         ;
1755
1756 structsp_nonattr:
1757           struct_head identifier
1758                 { $$ = xref_tag (RECORD_TYPE, $2); }
1759         | union_head identifier
1760                 { $$ = xref_tag (UNION_TYPE, $2); }
1761         | enum_head identifier
1762                 { $$ = xref_tag (ENUMERAL_TYPE, $2);
1763                   /* In ISO C, enumerated types can be referred to
1764                      only if already defined.  */
1765                   if (pedantic && !COMPLETE_TYPE_P ($$))
1766                     pedwarn ("ISO C forbids forward references to `enum' types"); }
1767         ;
1768
1769 maybecomma:
1770           /* empty */
1771         | ','
1772         ;
1773
1774 maybecomma_warn:
1775           /* empty */
1776         | ','
1777                 { if (pedantic && ! flag_isoc99)
1778                     pedwarn ("comma at end of enumerator list"); }
1779         ;
1780
1781 /* We chain the components in reverse order.  They are put in forward
1782    order in structsp_attr.
1783
1784    Note that component_declarator returns single decls, so components
1785    and components_notype can use TREE_CHAIN directly, wheras components
1786    and components_notype return lists (of comma separated decls), so
1787    component_decl_list and component_decl_list2 must use chainon.
1788
1789    The theory behind all this is that there will be more semicolon
1790    separated fields than comma separated fields, and so we'll be
1791    minimizing the number of node traversals required by chainon.  */
1792
1793 component_decl_list:
1794           component_decl_list2
1795                 { $$ = $1; }
1796         | component_decl_list2 component_decl
1797                 { $$ = chainon ($2, $1);
1798                   pedwarn ("no semicolon at end of struct or union"); }
1799         ;
1800
1801 component_decl_list2:   /* empty */
1802                 { $$ = NULL_TREE; }
1803         | component_decl_list2 component_decl ';'
1804                 { $$ = chainon ($2, $1); }
1805         | component_decl_list2 ';'
1806                 { if (pedantic)
1807                     pedwarn ("extra semicolon in struct or union specified"); }
1808 @@ifobjc
1809         /* foo(sizeof(struct{ @defs(ClassName)})); */
1810         | AT_DEFS '(' CLASSNAME ')'
1811                 { $$ = nreverse (objc_get_class_ivars ($3)); }
1812 @@end_ifobjc
1813         ;
1814
1815 component_decl:
1816           declspecs_nosc_ts setspecs components
1817                 { $$ = $3;
1818                   POP_DECLSPEC_STACK; }
1819         | declspecs_nosc_ts setspecs
1820                 {
1821                   /* Support for unnamed structs or unions as members of
1822                      structs or unions (which is [a] useful and [b] supports
1823                      MS P-SDK).  */
1824                   if (pedantic)
1825                     pedwarn ("ISO C doesn't support unnamed structs/unions");
1826
1827                   $$ = grokfield(NULL, current_declspecs, NULL_TREE);
1828                   POP_DECLSPEC_STACK; }
1829         | declspecs_nosc_nots setspecs components_notype
1830                 { $$ = $3;
1831                   POP_DECLSPEC_STACK; }
1832         | declspecs_nosc_nots
1833                 { if (pedantic)
1834                     pedwarn ("ISO C forbids member declarations with no members");
1835                   shadow_tag_warned ($1, pedantic);
1836                   $$ = NULL_TREE; }
1837         | error
1838                 { $$ = NULL_TREE; }
1839         | extension component_decl
1840                 { $$ = $2;
1841                   RESTORE_EXT_FLAGS ($1); }
1842         ;
1843
1844 components:
1845           component_declarator
1846         | components ',' maybe_resetattrs component_declarator
1847                 { TREE_CHAIN ($4) = $1; $$ = $4; }
1848         ;
1849
1850 components_notype:
1851           component_notype_declarator
1852         | components_notype ',' maybe_resetattrs component_notype_declarator
1853                 { TREE_CHAIN ($4) = $1; $$ = $4; }
1854         ;
1855
1856 component_declarator:
1857           declarator maybe_attribute
1858                 { $$ = grokfield ($1, current_declspecs, NULL_TREE);
1859                   decl_attributes (&$$,
1860                                    chainon ($2, all_prefix_attributes), 0); }
1861         | declarator ':' expr_no_commas maybe_attribute
1862                 { $$ = grokfield ($1, current_declspecs, $3.value);
1863                   decl_attributes (&$$,
1864                                    chainon ($4, all_prefix_attributes), 0); }
1865         | ':' expr_no_commas maybe_attribute
1866                 { $$ = grokfield (NULL_TREE, current_declspecs, $2.value);
1867                   decl_attributes (&$$,
1868                                    chainon ($3, all_prefix_attributes), 0); }
1869         ;
1870
1871 component_notype_declarator:
1872           notype_declarator maybe_attribute
1873                 { $$ = grokfield ($1, current_declspecs, NULL_TREE);
1874                   decl_attributes (&$$,
1875                                    chainon ($2, all_prefix_attributes), 0); }
1876         | notype_declarator ':' expr_no_commas maybe_attribute
1877                 { $$ = grokfield ($1, current_declspecs, $3.value);
1878                   decl_attributes (&$$,
1879                                    chainon ($4, all_prefix_attributes), 0); }
1880         | ':' expr_no_commas maybe_attribute
1881                 { $$ = grokfield (NULL_TREE, current_declspecs, $2.value);
1882                   decl_attributes (&$$,
1883                                    chainon ($3, all_prefix_attributes), 0); }
1884         ;
1885
1886 /* We chain the enumerators in reverse order.
1887    They are put in forward order in structsp_attr.  */
1888
1889 enumlist:
1890           enumerator
1891         | enumlist ',' enumerator
1892                 { if ($1 == error_mark_node)
1893                     $$ = $1;
1894                   else
1895                     TREE_CHAIN ($3) = $1, $$ = $3; }
1896         | error
1897                 { $$ = error_mark_node; }
1898         ;
1899
1900
1901 enumerator:
1902           identifier
1903                 { $$ = build_enumerator ($1, NULL_TREE); }
1904         | identifier '=' expr_no_commas
1905                 { $$ = build_enumerator ($1, $3.value); }
1906         ;
1907
1908 typename:
1909           declspecs_nosc
1910                 { pending_xref_error ();
1911                   $<ttype>$ = $1; }
1912           absdcl
1913                 { $$ = build_tree_list ($<ttype>2, $3); }
1914         ;
1915
1916 absdcl:   /* an absolute declarator */
1917         /* empty */
1918                 { $$ = NULL_TREE; }
1919         | absdcl1
1920         ;
1921
1922 absdcl_maybe_attribute:   /* absdcl maybe_attribute, but not just attributes */
1923         /* empty */
1924                 { $$ = build_c_parm (current_declspecs, all_prefix_attributes,
1925                                      NULL_TREE); }
1926         | absdcl1
1927                 { $$ = build_c_parm (current_declspecs, all_prefix_attributes,
1928                                      $1); }
1929         | absdcl1_noea attributes
1930                 { $$ = build_c_parm (current_declspecs,
1931                                      chainon ($2, all_prefix_attributes),
1932                                      $1); }
1933         ;
1934
1935 absdcl1:  /* a nonempty absolute declarator */
1936           absdcl1_ea
1937         | absdcl1_noea
1938         ;
1939
1940 absdcl1_noea:
1941           direct_absdcl1
1942         | '*' maybe_type_quals_attrs absdcl1_noea
1943                 { $$ = make_pointer_declarator ($2, $3); }
1944         ;
1945
1946 absdcl1_ea:
1947           '*' maybe_type_quals_attrs
1948                 { $$ = make_pointer_declarator ($2, NULL_TREE); }
1949         | '*' maybe_type_quals_attrs absdcl1_ea
1950                 { $$ = make_pointer_declarator ($2, $3); }
1951         ;
1952
1953 direct_absdcl1:
1954           '(' maybe_attribute absdcl1 ')'
1955                 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1956         | direct_absdcl1 '(' parmlist
1957                 { $$ = build_function_declarator ($3, $1); }
1958         | direct_absdcl1 array_declarator
1959                 { $$ = set_array_declarator_inner ($2, $1, true); }
1960         | '(' parmlist
1961                 { $$ = build_function_declarator ($2, NULL_TREE); }
1962         | array_declarator
1963                 { $$ = set_array_declarator_inner ($1, NULL_TREE, true); }
1964         ;
1965
1966 /* The [...] part of a declarator for an array type.  */
1967
1968 array_declarator:
1969         '[' maybe_type_quals_attrs expr_no_commas ']'
1970                 { $$ = build_array_declarator ($3.value, $2, false, false); }
1971         | '[' maybe_type_quals_attrs ']'
1972                 { $$ = build_array_declarator (NULL_TREE, $2, false, false); }
1973         | '[' maybe_type_quals_attrs '*' ']'
1974                 { $$ = build_array_declarator (NULL_TREE, $2, false, true); }
1975         | '[' STATIC maybe_type_quals_attrs expr_no_commas ']'
1976                 { $$ = build_array_declarator ($4.value, $3, true, false); }
1977         /* declspecs_nosc_nots is a synonym for type_quals_attrs.  */
1978         | '[' declspecs_nosc_nots STATIC expr_no_commas ']'
1979                 { $$ = build_array_declarator ($4.value, $2, true, false); }
1980         ;
1981
1982 /* A nonempty series of declarations and statements (possibly followed by
1983    some labels) that can form the body of a compound statement.
1984    NOTE: we don't allow labels on declarations; this might seem like a
1985    natural extension, but there would be a conflict between attributes
1986    on the label and prefix attributes on the declaration.  */
1987
1988 stmts_and_decls:
1989           lineno_stmt_decl_or_labels_ending_stmt
1990         | lineno_stmt_decl_or_labels_ending_decl
1991         | lineno_stmt_decl_or_labels_ending_label
1992                 {
1993                   error ("label at end of compound statement");
1994                 }
1995         | lineno_stmt_decl_or_labels_ending_error
1996         ;
1997
1998 lineno_stmt_decl_or_labels_ending_stmt:
1999           lineno_stmt
2000         | lineno_stmt_decl_or_labels_ending_stmt lineno_stmt
2001         | lineno_stmt_decl_or_labels_ending_decl lineno_stmt
2002         | lineno_stmt_decl_or_labels_ending_label lineno_stmt
2003         | lineno_stmt_decl_or_labels_ending_error lineno_stmt
2004         ;
2005
2006 lineno_stmt_decl_or_labels_ending_decl:
2007           lineno_decl
2008         | lineno_stmt_decl_or_labels_ending_stmt lineno_decl
2009                 {
2010                   if ((pedantic && !flag_isoc99)
2011                       || warn_declaration_after_statement)
2012                     pedwarn_c90 ("ISO C90 forbids mixed declarations and code");
2013                 }
2014         | lineno_stmt_decl_or_labels_ending_decl lineno_decl
2015         | lineno_stmt_decl_or_labels_ending_error lineno_decl
2016         ;
2017
2018 lineno_stmt_decl_or_labels_ending_label:
2019           lineno_label
2020         | lineno_stmt_decl_or_labels_ending_stmt lineno_label
2021         | lineno_stmt_decl_or_labels_ending_decl lineno_label
2022         | lineno_stmt_decl_or_labels_ending_label lineno_label
2023         | lineno_stmt_decl_or_labels_ending_error lineno_label
2024         ;
2025
2026 lineno_stmt_decl_or_labels_ending_error:
2027         errstmt
2028         | lineno_stmt_decl_or_labels errstmt
2029         ;
2030
2031 lineno_stmt_decl_or_labels:
2032           lineno_stmt_decl_or_labels_ending_stmt
2033         | lineno_stmt_decl_or_labels_ending_decl
2034         | lineno_stmt_decl_or_labels_ending_label
2035         | lineno_stmt_decl_or_labels_ending_error
2036         ;
2037
2038 errstmt:  error ';'
2039         ;
2040
2041 /* Start and end blocks created for the new scopes of C99.  */
2042 c99_block_start: /* empty */
2043                 { $$ = c_begin_compound_stmt (flag_isoc99); }
2044         ;
2045
2046 /* Read zero or more forward-declarations for labels
2047    that nested functions can jump to.  */
2048 maybe_label_decls:
2049           /* empty */
2050         | label_decls
2051                 { if (pedantic)
2052                     pedwarn ("ISO C forbids label declarations"); }
2053         ;
2054
2055 label_decls:
2056           label_decl
2057         | label_decls label_decl
2058         ;
2059
2060 label_decl:
2061           LABEL identifiers_or_typenames ';'
2062                 { tree link;
2063                   for (link = $2; link; link = TREE_CHAIN (link))
2064                     {
2065                       tree label = declare_label (TREE_VALUE (link));
2066                       C_DECLARED_LABEL_FLAG (label) = 1;
2067                       add_stmt (build_stmt (DECL_EXPR, label));
2068                     }
2069                 }
2070         ;
2071
2072 /* This is the body of a function definition.
2073    It causes syntax errors to ignore to the next openbrace.  */
2074 compstmt_or_error:
2075           compstmt
2076                 { add_stmt ($1); }
2077         | error compstmt
2078         ;
2079
2080 compstmt_start: '{' { $$ = c_begin_compound_stmt (true); }
2081         ;
2082
2083 compstmt_nostart: '}'
2084         | maybe_label_decls compstmt_contents_nonempty '}'
2085         ;
2086
2087 compstmt_contents_nonempty:
2088           stmts_and_decls
2089         | error
2090         ;
2091
2092 compstmt_primary_start:
2093         '(' '{'
2094                 { if (current_function_decl == 0)
2095                     {
2096                       error ("braced-group within expression allowed "
2097                              "only inside a function");
2098                       YYERROR;
2099                     }
2100                   $$ = c_begin_stmt_expr ();
2101                 }
2102         ;
2103
2104 compstmt: compstmt_start compstmt_nostart
2105                 { $$ = c_end_compound_stmt ($1, true); }
2106         ;
2107
2108 /* The forced readahead in here is because we might be at the end of a
2109    line, and the line and file won't be bumped until yylex absorbs the
2110    first token on the next line.  */
2111
2112 save_location:
2113                 { if (yychar == YYEMPTY)
2114                     yychar = YYLEX;
2115                   $$ = input_location; }
2116         ;
2117
2118 lineno_labels:
2119           /* empty */
2120         | lineno_labels lineno_label
2121         ;
2122
2123 /* A labeled statement.  In C99 it also generates an implicit block.  */
2124 c99_block_lineno_labeled_stmt:
2125           c99_block_start lineno_labels lineno_stmt
2126                 { $$ = c_end_compound_stmt ($1, flag_isoc99); }
2127         ;
2128
2129 lineno_stmt:
2130           save_location stmt
2131                 { 
2132                   /* Two cases cannot and do not have line numbers associated:
2133                      If stmt is degenerate, such as "2;", then stmt is an 
2134                      INTEGER_CST, which cannot hold line numbers.  But that's
2135                      ok because the statement will either be changed to a
2136                      MODIFY_EXPR during gimplification of the statement expr,
2137                      or discarded.  If stmt was compound, but without new
2138                      variables, we will have skipped the creation of a BIND
2139                      and will have a bare STATEMENT_LIST.  But that's ok
2140                      because (recursively) all of the component statments
2141                      should already have line numbers assigned.  */
2142                   if ($2 && EXPR_P ($2))
2143                     SET_EXPR_LOCATION ($2, $1);
2144                 }
2145         ;
2146
2147 lineno_label:
2148           save_location label
2149                 { if ($2) SET_EXPR_LOCATION ($2, $1); }
2150         ;
2151
2152 condition: save_location expr
2153                 { $$ = lang_hooks.truthvalue_conversion ($2.value);
2154                   if (EXPR_P ($$))
2155                     SET_EXPR_LOCATION ($$, $1); }
2156         ;
2157
2158 /* Implement -Wparenthesis by special casing IF statement directly nested
2159    within IF statement.  This requires some amount of duplication of the
2160    productions under c99_block_lineno_labeled_stmt in order to work out.
2161    But it's still likely more maintainable than lots of state outside the
2162    parser...  */
2163
2164 if_statement_1:
2165         c99_block_start lineno_labels if_statement
2166                 { $$ = c_end_compound_stmt ($1, flag_isoc99); }
2167         ;
2168
2169 if_statement_2:
2170           c99_block_start lineno_labels ';'
2171                 { if (extra_warnings)
2172                     add_stmt (build (NOP_EXPR, NULL_TREE, NULL_TREE));
2173                   $$ = c_end_compound_stmt ($1, flag_isoc99); }
2174         | c99_block_lineno_labeled_stmt
2175         ;
2176
2177 if_statement:
2178           IF c99_block_start save_location '(' condition ')'
2179             if_statement_1 ELSE if_statement_2
2180                 { c_finish_if_stmt ($3, $5, $7, $9, true);
2181                   add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2182         | IF c99_block_start save_location '(' condition ')'
2183             if_statement_2 ELSE if_statement_2
2184                 { c_finish_if_stmt ($3, $5, $7, $9, false);
2185                   add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2186         | IF c99_block_start save_location '(' condition ')'
2187             if_statement_1                              %prec IF
2188                 { c_finish_if_stmt ($3, $5, $7, NULL, true);
2189                   add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2190         | IF c99_block_start save_location '(' condition ')'
2191             if_statement_2                              %prec IF
2192                 { c_finish_if_stmt ($3, $5, $7, NULL, false);
2193                   add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2194         ;
2195
2196 start_break: /* empty */
2197                 { $$ = c_break_label; c_break_label = NULL; }
2198         ;
2199
2200 start_continue: /* empty */
2201                 { $$ = c_cont_label; c_cont_label = NULL; }
2202         ;
2203
2204 while_statement:
2205         WHILE c99_block_start save_location '(' condition ')'
2206         start_break start_continue c99_block_lineno_labeled_stmt
2207                 { c_finish_loop ($3, $5, NULL, $9, c_break_label,
2208                                  c_cont_label, true);
2209                   add_stmt (c_end_compound_stmt ($2, flag_isoc99));
2210                   c_break_label = $7; c_cont_label = $8; }
2211         ;
2212
2213 do_statement:
2214         DO c99_block_start save_location start_break start_continue
2215         c99_block_lineno_labeled_stmt WHILE
2216                 { $<ttype>$ = c_break_label; c_break_label = $4; }
2217                 { $<ttype>$ = c_cont_label; c_cont_label = $5; }
2218         '(' condition ')' ';'
2219                 { c_finish_loop ($3, $11, NULL, $6, $<ttype>8,
2220                                  $<ttype>9, false);
2221                   add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2222         ;
2223
2224 xexpr:
2225         /* empty */
2226                 { $$ = NULL_TREE; }
2227         | expr
2228                 { $$ = $1.value; }
2229         ;
2230
2231 for_init_stmt:
2232           xexpr ';'
2233                 { c_finish_expr_stmt ($1); }
2234         | decl
2235                 { check_for_loop_decls (); }
2236         ;
2237
2238 for_cond_expr: save_location xexpr
2239                 { if ($2)
2240                     {
2241                       $$ = lang_hooks.truthvalue_conversion ($2);
2242                       if (EXPR_P ($$))
2243                         SET_EXPR_LOCATION ($$, $1);
2244                     }
2245                   else
2246                     $$ = NULL;
2247                 }
2248         ;
2249
2250 for_incr_expr: xexpr
2251                 { $$ = c_process_expr_stmt ($1); }
2252         ;
2253
2254 for_statement:
2255         FOR c99_block_start '(' for_init_stmt
2256         save_location for_cond_expr ';' for_incr_expr ')'
2257         start_break start_continue c99_block_lineno_labeled_stmt
2258                 { c_finish_loop ($5, $6, $8, $12, c_break_label,
2259                                  c_cont_label, true);
2260                   add_stmt (c_end_compound_stmt ($2, flag_isoc99));
2261                   c_break_label = $10; c_cont_label = $11; }
2262         ;
2263
2264 switch_statement:
2265         SWITCH c99_block_start '(' expr ')'
2266                 { $<ttype>$ = c_start_case ($4.value); }
2267         start_break c99_block_lineno_labeled_stmt
2268                 { c_finish_case ($8);
2269                   if (c_break_label)
2270                     add_stmt (build (LABEL_EXPR, void_type_node,
2271                                      c_break_label));
2272                   c_break_label = $7;
2273                   add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2274         ;
2275
2276 /* Parse a single real statement, not including any labels or compounds.  */
2277 stmt_nocomp:
2278           expr ';'
2279                 { $$ = c_finish_expr_stmt ($1.value); }
2280         | if_statement
2281                 { $$ = NULL_TREE; }
2282         | while_statement
2283                 { $$ = NULL_TREE; }
2284         | do_statement
2285                 { $$ = NULL_TREE; }
2286         | for_statement
2287                 { $$ = NULL_TREE; }
2288         | switch_statement
2289                 { $$ = NULL_TREE; }
2290         | BREAK ';'
2291                 { $$ = c_finish_bc_stmt (&c_break_label, true); }
2292         | CONTINUE ';'
2293                 { $$ = c_finish_bc_stmt (&c_cont_label, false); }
2294         | RETURN ';'
2295                 { $$ = c_finish_return (NULL_TREE); }
2296         | RETURN expr ';'
2297                 { $$ = c_finish_return ($2.value); }
2298         | asm_stmt
2299         | GOTO identifier ';'
2300                 { $$ = c_finish_goto_label ($2); }
2301         | GOTO '*' expr ';'
2302                 { $$ = c_finish_goto_ptr ($3.value); }
2303         | ';'
2304                 { $$ = NULL_TREE; }
2305 @@ifobjc
2306         | AT_THROW expr ';'
2307                 { $$ = objc_build_throw_stmt ($2.value); }
2308         | AT_THROW ';'
2309                 { $$ = objc_build_throw_stmt (NULL_TREE); }
2310         | objc_try_catch_stmt
2311                 { $$ = NULL_TREE; }
2312         | AT_SYNCHRONIZED save_location '(' expr ')' compstmt
2313                 { objc_build_synchronized ($2, $4.value, $6); $$ = NULL_TREE; }
2314         ;
2315
2316 objc_catch_prefix:
2317         AT_CATCH '(' parm ')'
2318                 { objc_begin_catch_clause ($3); }
2319         ;
2320
2321 objc_catch_clause:
2322           objc_catch_prefix '{' compstmt_nostart
2323                 { objc_finish_catch_clause (); }
2324         | objc_catch_prefix '{' error '}'
2325                 { objc_finish_catch_clause (); }
2326         ;
2327
2328 objc_opt_catch_list:
2329           /* empty */
2330         | objc_opt_catch_list objc_catch_clause
2331         ;
2332
2333 objc_try_catch_clause:
2334         AT_TRY save_location compstmt
2335                 { objc_begin_try_stmt ($2, $3); }
2336         objc_opt_catch_list
2337         ;
2338
2339 objc_finally_clause:
2340         AT_FINALLY save_location compstmt
2341                 { objc_build_finally_clause ($2, $3); }
2342         ;
2343
2344 objc_try_catch_stmt:
2345           objc_try_catch_clause
2346                 { objc_finish_try_stmt (); }
2347         | objc_try_catch_clause objc_finally_clause
2348                 { objc_finish_try_stmt (); }
2349 @@end_ifobjc
2350         ;
2351
2352 /* Parse a single or compound real statement, not including any labels.  */
2353 stmt:
2354           compstmt
2355                 { add_stmt ($1); $$ = NULL_TREE; }
2356         | stmt_nocomp
2357         ;
2358
2359 /* Any kind of label, including jump labels and case labels.
2360    ANSI C accepts labels only before statements, but we allow them
2361    also at the end of a compound statement.  */
2362
2363 label:    CASE expr_no_commas ':'
2364                 { $$ = do_case ($2.value, NULL_TREE); }
2365         | CASE expr_no_commas ELLIPSIS expr_no_commas ':'
2366                 { $$ = do_case ($2.value, $4.value); }
2367         | DEFAULT ':'
2368                 { $$ = do_case (NULL_TREE, NULL_TREE); }
2369         | identifier save_location ':' maybe_attribute
2370                 { tree label = define_label ($2, $1);
2371                   if (label)
2372                     {
2373                       decl_attributes (&label, $4, 0);
2374                       $$ = add_stmt (build_stmt (LABEL_EXPR, label));
2375                     }
2376                   else
2377                     $$ = NULL_TREE;
2378                 }
2379         ;
2380
2381 /* Asm expressions and statements */
2382
2383 /* simple_asm_expr is used in restricted contexts, where a full
2384    expression with inputs and outputs does not make sense.  */
2385 simple_asm_expr:
2386         ASM_KEYWORD stop_string_translation
2387               '(' STRING ')' start_string_translation
2388                 { $$ = $4; }
2389         ;
2390
2391 /* maybeasm: used for assembly names for declarations */
2392 maybeasm:
2393           /* empty */
2394                 { $$ = NULL_TREE; }
2395         | simple_asm_expr
2396         ;
2397
2398 /* asmdef: asm() outside a function body.  */
2399 asmdef:
2400         simple_asm_expr ';'
2401                 { assemble_asm ($1); }
2402         | ASM_KEYWORD error start_string_translation ';'
2403                 {}
2404         ;
2405
2406 /* Full-blown asm statement with inputs, outputs, clobbers, and
2407    volatile tag allowed.  */
2408 asm_stmt:
2409         ASM_KEYWORD maybe_volatile stop_string_translation
2410                 '(' asm_argument ')' start_string_translation ';'
2411                 { $$ = build_asm_stmt ($2, $5); }
2412         ;
2413
2414 asm_argument:
2415         /* no operands */
2416         STRING
2417                 { $$ = build_asm_expr ($1, 0, 0, 0, true); }
2418         /* output operands */
2419         | STRING ':' asm_operands
2420                 { $$ = build_asm_expr ($1, $3, 0, 0, false); }
2421         /* output and input operands */
2422         | STRING ':' asm_operands ':' asm_operands
2423                 { $$ = build_asm_expr ($1, $3, $5, 0, false); }
2424         /* output and input operands and clobbers */
2425         | STRING ':' asm_operands ':' asm_operands ':' asm_clobbers
2426                 { $$ = build_asm_expr ($1, $3, $5, $7, false); }
2427         ;
2428
2429 /* Either 'volatile' or nothing.  First thing in an `asm' statement.  */
2430
2431 maybe_volatile:
2432         /* empty */
2433                 { $$ = 0; }
2434         | TYPE_QUAL
2435                 { if ($1 != ridpointers[RID_VOLATILE])
2436                     {
2437                       warning ("%E qualifier ignored on asm", $1);
2438                       $$ = 0;
2439                     }
2440                   else
2441                     $$ = $1;
2442                 }
2443         ;
2444
2445 /* These are the operands other than the first string and colon
2446    in  asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x))  */
2447 asm_operands: /* empty */
2448                 { $$ = NULL_TREE; }
2449         | nonnull_asm_operands
2450         ;
2451
2452 nonnull_asm_operands:
2453           asm_operand
2454         | nonnull_asm_operands ',' asm_operand
2455                 { $$ = chainon ($1, $3); }
2456         ;
2457
2458 asm_operand:
2459           STRING start_string_translation '(' expr ')' stop_string_translation
2460                 { $$ = build_tree_list (build_tree_list (NULL_TREE, $1),
2461                                         $4.value); }
2462         | '[' identifier ']' STRING start_string_translation
2463           '(' expr ')' stop_string_translation
2464                 { $2 = build_string (IDENTIFIER_LENGTH ($2),
2465                                      IDENTIFIER_POINTER ($2));
2466                   $$ = build_tree_list (build_tree_list ($2, $4), $7.value); }
2467         ;
2468
2469 asm_clobbers:
2470           STRING
2471                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
2472         | asm_clobbers ',' STRING
2473                 { $$ = tree_cons (NULL_TREE, $3, $1); }
2474         ;
2475
2476 stop_string_translation:
2477         { c_lex_string_translate = 0; }
2478         ;
2479
2480 start_string_translation:
2481         { c_lex_string_translate = 1; }
2482         ;
2483
2484 \f
2485 /* This is what appears inside the parens in a function declarator.
2486    Its value is a list of ..._TYPE nodes.  Attributes must appear here
2487    to avoid a conflict with their appearance after an open parenthesis
2488    in an abstract declarator, as in
2489    "void bar (int (__attribute__((__mode__(SI))) int foo));".  */
2490 parmlist:
2491           maybe_attribute
2492                 { push_scope ();
2493                   declare_parm_level (); }
2494           parmlist_1
2495                 { $$ = $3;
2496                   pop_scope (); }
2497         ;
2498
2499 parmlist_1:
2500           parmlist_2 ')'
2501         | parms ';'
2502                 { mark_forward_parm_decls (); }
2503           maybe_attribute
2504                 { /* Dummy action so attributes are in known place
2505                      on parser stack.  */ }
2506           parmlist_1
2507                 { $$ = $6; }
2508         | error ')'
2509                 { $$ = make_node (TREE_LIST); }
2510         ;
2511
2512 /* This is what appears inside the parens in a function declarator.
2513    Is value is represented in the format that grokdeclarator expects.  */
2514 parmlist_2:  /* empty */
2515                 { $$ = make_node (TREE_LIST); }
2516         | ELLIPSIS
2517                 { $$ = make_node (TREE_LIST); 
2518                   /* Suppress -Wold-style-definition for this case.  */
2519                   TREE_CHAIN ($$) = error_mark_node;
2520                   error ("ISO C requires a named argument before `...'");
2521                 }
2522         | parms
2523                 { $$ = get_parm_info (/*ellipsis=*/false); }
2524         | parms ',' ELLIPSIS
2525                 { $$ = get_parm_info (/*ellipsis=*/true); }
2526         ;
2527
2528 parms:
2529         firstparm
2530                 { push_parm_decl ($1); }
2531         | parms ',' parm
2532                 { push_parm_decl ($3); }
2533         ;
2534
2535 /* A single parameter declaration or parameter type name,
2536    as found in a parmlist.  */
2537 parm:
2538           declspecs_ts setspecs parm_declarator maybe_attribute
2539                 { $$ = build_c_parm (current_declspecs,
2540                                      chainon ($4, all_prefix_attributes), $3);
2541                   POP_DECLSPEC_STACK; }
2542         | declspecs_ts setspecs notype_declarator maybe_attribute
2543                 { $$ = build_c_parm (current_declspecs,
2544                                      chainon ($4, all_prefix_attributes), $3);
2545                   POP_DECLSPEC_STACK; }
2546         | declspecs_ts setspecs absdcl_maybe_attribute
2547                 { $$ = $3;
2548                   POP_DECLSPEC_STACK; }
2549         | declspecs_nots setspecs notype_declarator maybe_attribute
2550                 { $$ = build_c_parm (current_declspecs,
2551                                      chainon ($4, all_prefix_attributes), $3);
2552                   POP_DECLSPEC_STACK; }
2553
2554         | declspecs_nots setspecs absdcl_maybe_attribute
2555                 { $$ = $3;
2556                   POP_DECLSPEC_STACK; }
2557         ;
2558
2559 /* The first parm, which must suck attributes from off the top of the parser
2560    stack.  */
2561 firstparm:
2562           declspecs_ts_nosa setspecs_fp parm_declarator maybe_attribute
2563                 { $$ = build_c_parm (current_declspecs,
2564                                      chainon ($4, all_prefix_attributes), $3);
2565                   POP_DECLSPEC_STACK; }
2566         | declspecs_ts_nosa setspecs_fp notype_declarator maybe_attribute
2567                 { $$ = build_c_parm (current_declspecs,
2568                                      chainon ($4, all_prefix_attributes), $3);
2569                   POP_DECLSPEC_STACK; }
2570         | declspecs_ts_nosa setspecs_fp absdcl_maybe_attribute
2571                 { $$ = $3;
2572                   POP_DECLSPEC_STACK; }
2573         | declspecs_nots_nosa setspecs_fp notype_declarator maybe_attribute
2574                 { $$ = build_c_parm (current_declspecs,
2575                                      chainon ($4, all_prefix_attributes), $3);
2576                   POP_DECLSPEC_STACK; }
2577
2578         | declspecs_nots_nosa setspecs_fp absdcl_maybe_attribute
2579                 { $$ = $3;
2580                   POP_DECLSPEC_STACK; }
2581         ;
2582
2583 setspecs_fp:
2584           setspecs
2585                 { prefix_attributes = chainon (prefix_attributes, $<ttype>-2);
2586                   all_prefix_attributes = prefix_attributes; }
2587         ;
2588
2589 /* This is used in a function definition
2590    where either a parmlist or an identifier list is ok.
2591    Its value is a list of ..._TYPE nodes or a list of identifiers.  */
2592 parmlist_or_identifiers:
2593           maybe_attribute
2594                 { push_scope ();
2595                   declare_parm_level (); }
2596           parmlist_or_identifiers_1
2597                 { $$ = $3;
2598                   pop_scope (); }
2599         ;
2600
2601 parmlist_or_identifiers_1:
2602           parmlist_1
2603         | identifiers ')'
2604                 { $$ = tree_cons (NULL_TREE, NULL_TREE, $1);
2605
2606                   /* Make sure we have a parmlist after attributes.  */
2607                   if ($<ttype>-1 != 0)
2608                     YYERROR1;
2609                 }
2610         ;
2611
2612 /* A nonempty list of identifiers.  */
2613 identifiers:
2614         IDENTIFIER
2615                 { $$ = build_tree_list (NULL_TREE, $1); }
2616         | identifiers ',' IDENTIFIER
2617                 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2618         ;
2619
2620 /* A nonempty list of identifiers, including typenames.  */
2621 identifiers_or_typenames:
2622         identifier
2623                 { $$ = build_tree_list (NULL_TREE, $1); }
2624         | identifiers_or_typenames ',' identifier
2625                 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2626         ;
2627
2628 extension:
2629         EXTENSION
2630                 { $$ = SAVE_EXT_FLAGS();
2631                   pedantic = 0;
2632                   warn_pointer_arith = 0;
2633                   warn_traditional = 0;
2634                   flag_iso = 0; }
2635         ;
2636 \f
2637 @@ifobjc
2638 /* Objective-C productions.  */
2639
2640 objcdef:
2641           classdef
2642         | classdecl
2643         | aliasdecl
2644         | protocoldef
2645         | methoddef
2646         | AT_END
2647                 {
2648                   if (objc_implementation_context)
2649                     {
2650                       finish_class (objc_implementation_context);
2651                       objc_ivar_chain = NULL_TREE;
2652                       objc_implementation_context = NULL_TREE;
2653                     }
2654                   else
2655                     warning ("`@end' must appear in an implementation context");
2656                 }
2657         ;
2658
2659 /* A nonempty list of identifiers.  */
2660 identifier_list:
2661         identifier
2662                 { $$ = build_tree_list (NULL_TREE, $1); }
2663         | identifier_list ',' identifier
2664                 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2665         ;
2666
2667 classdecl:
2668           AT_CLASS identifier_list ';'
2669                 {
2670                   objc_declare_class ($2);
2671                 }
2672         ;
2673
2674 aliasdecl:
2675           AT_ALIAS identifier identifier ';'
2676                 {
2677                   objc_declare_alias ($2, $3);
2678                 }
2679         ;
2680
2681 superclass:
2682           ':' identifier { $$ = $2; }
2683         | /* NULL */ %prec HYPERUNARY    { $$ = NULL_TREE; }
2684         ;
2685
2686 class_ivars:
2687           '{' ivar_decl_list '}'
2688         | /* NULL */
2689         ;
2690
2691 classdef:
2692           AT_INTERFACE identifier superclass protocolrefs
2693                 {
2694                   objc_interface_context = objc_ivar_context
2695                     = start_class (CLASS_INTERFACE_TYPE, $2, $3, $4);
2696                   objc_public_flag = 0;
2697                 }
2698           class_ivars
2699                 {
2700                   continue_class (objc_interface_context);
2701                 }
2702           methodprotolist AT_END
2703                 {
2704                   finish_class (objc_interface_context);
2705                   objc_interface_context = NULL_TREE;
2706                 }
2707
2708         | AT_IMPLEMENTATION identifier superclass
2709                 {
2710                   objc_implementation_context = objc_ivar_context
2711                     = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $3, NULL_TREE);
2712                   objc_public_flag = 0;
2713                 }
2714           class_ivars
2715                 {
2716                   objc_ivar_chain
2717                     = continue_class (objc_implementation_context);
2718                 }
2719
2720         | AT_INTERFACE identifier '(' identifier ')' protocolrefs
2721                 {
2722                   objc_interface_context
2723                     = start_class (CATEGORY_INTERFACE_TYPE, $2, $4, $6);
2724                   continue_class (objc_interface_context);
2725                 }
2726           methodprotolist AT_END
2727                 {
2728                   finish_class (objc_interface_context);
2729                   objc_interface_context = NULL_TREE;
2730                 }
2731
2732         | AT_IMPLEMENTATION identifier '(' identifier ')'
2733                 {
2734                   objc_implementation_context
2735                     = start_class (CATEGORY_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE);
2736                   objc_ivar_chain
2737                     = continue_class (objc_implementation_context);
2738                 }
2739         ;
2740
2741 protocoldef:
2742           AT_PROTOCOL identifier protocolrefs
2743                 {
2744                   objc_pq_context = 1;
2745                   objc_interface_context
2746                     = start_protocol(PROTOCOL_INTERFACE_TYPE, $2, $3);
2747                 }
2748           methodprotolist AT_END
2749                 {
2750                   objc_pq_context = 0;
2751                   finish_protocol(objc_interface_context);
2752                   objc_interface_context = NULL_TREE;
2753                 }
2754         /* The @protocol forward-declaration production introduces a
2755            reduce/reduce conflict on ';', which should be resolved in
2756            favor of the production 'identifier_list -> identifier'.  */
2757         | AT_PROTOCOL identifier_list ';'
2758                 {
2759                   objc_declare_protocols ($2);
2760                 }
2761         ;
2762
2763 protocolrefs:
2764           /* empty */
2765                 {
2766                   $$ = NULL_TREE;
2767                 }
2768         | non_empty_protocolrefs
2769         ;
2770
2771 non_empty_protocolrefs:
2772           ARITHCOMPARE identifier_list ARITHCOMPARE
2773                 {
2774                   if ($1 == LT_EXPR && $3 == GT_EXPR)
2775                     $$ = $2;
2776                   else
2777                     YYERROR1;
2778                 }
2779         ;
2780
2781 ivar_decl_list:
2782           ivar_decl_list visibility_spec ivar_decls
2783         | ivar_decls
2784         ;
2785
2786 visibility_spec:
2787           AT_PRIVATE { objc_public_flag = 2; }
2788         | AT_PROTECTED { objc_public_flag = 0; }
2789         | AT_PUBLIC { objc_public_flag = 1; }
2790         ;
2791
2792 ivar_decls:
2793           /* empty */
2794                 {
2795                   $$ = NULL_TREE;
2796                 }
2797         | ivar_decls ivar_decl ';'
2798         | ivar_decls ';'
2799                 {
2800                   if (pedantic)
2801                     pedwarn ("extra semicolon in struct or union specified");
2802                 }
2803         ;
2804
2805
2806 /* There is a shift-reduce conflict here, because `components' may
2807    start with a `typename'.  It happens that shifting (the default resolution)
2808    does the right thing, because it treats the `typename' as part of
2809    a `typed_typespecs'.
2810
2811    It is possible that this same technique would allow the distinction
2812    between `notype_initdecls' and `initdecls' to be eliminated.
2813    But I am being cautious and not trying it.  */
2814
2815 ivar_decl:
2816         declspecs_nosc_ts setspecs ivars
2817                 { $$ = $3;
2818                   POP_DECLSPEC_STACK; }
2819         | declspecs_nosc_nots setspecs ivars
2820                 { $$ = $3;
2821                   POP_DECLSPEC_STACK; }
2822         | error
2823                 { $$ = NULL_TREE; }
2824         ;
2825
2826 ivars:
2827           /* empty */
2828                 { $$ = NULL_TREE; }
2829         | ivar_declarator
2830         | ivars ',' maybe_resetattrs ivar_declarator
2831         ;
2832
2833 ivar_declarator:
2834           declarator
2835                 {
2836                   $$ = add_instance_variable (objc_ivar_context,
2837                                               objc_public_flag,
2838                                               $1, current_declspecs,
2839                                               NULL_TREE);
2840                 }
2841         | declarator ':' expr_no_commas
2842                 {
2843                   $$ = add_instance_variable (objc_ivar_context,
2844                                               objc_public_flag,
2845                                               $1, current_declspecs, $3.value);
2846                 }
2847         | ':' expr_no_commas
2848                 {
2849                   $$ = add_instance_variable (objc_ivar_context,
2850                                               objc_public_flag,
2851                                               NULL_TREE,
2852                                               current_declspecs, $2.value);
2853                 }
2854         ;
2855
2856 methodtype:
2857           '+'
2858                 { objc_inherit_code = CLASS_METHOD_DECL; }
2859         | '-'
2860                 { objc_inherit_code = INSTANCE_METHOD_DECL; }
2861         ;
2862
2863 methoddef:
2864           methodtype
2865                 {
2866                   objc_pq_context = 1;
2867                   if (!objc_implementation_context)
2868                     fatal_error ("method definition not in class context");
2869                 }
2870           methoddecl
2871                 {
2872                   objc_pq_context = 0;
2873                   objc_add_method (objc_implementation_context,
2874                                    $3,
2875                                    objc_inherit_code == CLASS_METHOD_DECL);
2876                   start_method_def ($3);
2877                 }
2878           optarglist
2879                 {
2880                   continue_method_def ();
2881                 }
2882           compstmt_or_error
2883                 {
2884                   finish_method_def ();
2885                 }
2886         ;
2887
2888 /* the reason for the strange actions in this rule
2889  is so that notype_initdecls when reached via datadef
2890  can find a valid list of type and sc specs in $0. */
2891
2892 methodprotolist:
2893           /* empty  */
2894         | methodprotolist methodproto
2895         | methodprotolist { $<ttype>$ = NULL_TREE; } datadef
2896         ;
2897
2898 semi_or_error:
2899           ';'
2900         | error
2901         ;
2902
2903 methodproto:
2904           methodtype
2905                 {
2906                   /* Remember protocol qualifiers in prototypes.  */
2907                   objc_pq_context = 1;
2908                 }
2909           methoddecl
2910                 {
2911                   /* Forget protocol qualifiers here.  */
2912                   objc_pq_context = 0;
2913                   objc_add_method (objc_interface_context,
2914                                    $3,
2915                                    objc_inherit_code == CLASS_METHOD_DECL);
2916                 }
2917           semi_or_error
2918         ;
2919
2920 methoddecl:
2921           '(' typename ')' unaryselector
2922                 {
2923                   $$ = build_method_decl (objc_inherit_code, $2, $4, NULL_TREE);
2924                 }
2925
2926         | unaryselector
2927                 {
2928                   $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, NULL_TREE);
2929                 }
2930
2931         | '(' typename ')' keywordselector optparmlist
2932                 {
2933                   $$ = build_method_decl (objc_inherit_code, $2, $4, $5);
2934                 }
2935
2936         | keywordselector optparmlist
2937                 {
2938                   $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, $2);
2939                 }
2940         ;
2941
2942 /* "optarglist" assumes that start_method_def has already been called...
2943    if it is not, the "xdecls" will not be placed in the proper scope */
2944
2945 optarglist:
2946           /* empty */
2947         | ';' myxdecls
2948         ;
2949
2950 /* to get around the following situation: "int foo (int a) int b; {}" that
2951    is synthesized when parsing "- a:a b:b; id c; id d; { ... }" */
2952
2953 myxdecls:
2954           /* empty */
2955         | mydecls
2956         ;
2957
2958 mydecls:
2959         mydecl
2960         | errstmt
2961         | mydecls mydecl
2962         | mydecl errstmt
2963         ;
2964
2965 mydecl:
2966         declspecs_ts setspecs myparms ';'
2967                 { POP_DECLSPEC_STACK; }
2968         | declspecs_ts ';'
2969                 { shadow_tag ($1); }
2970         | declspecs_nots ';'
2971                 { pedwarn ("empty declaration"); }
2972         ;
2973
2974 myparms:
2975         myparm
2976                 { push_parm_decl ($1); }
2977         | myparms ',' myparm
2978                 { push_parm_decl ($3); }
2979         ;
2980
2981 /* A single parameter declaration or parameter type name,
2982    as found in a parmlist. DOES NOT ALLOW AN INITIALIZER OR ASMSPEC */
2983
2984 myparm:
2985           parm_declarator maybe_attribute
2986                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2987                                                          $1),
2988                                         chainon ($2, all_prefix_attributes)); }
2989         | notype_declarator maybe_attribute
2990                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2991                                                          $1),
2992                                         chainon ($2, all_prefix_attributes)); }
2993         | absdcl_maybe_attribute
2994                 { $$ = $1; }
2995         ;
2996
2997 optparmlist:
2998           /* empty */
2999                 {
3000                   $$ = NULL_TREE;
3001                 }
3002         | ',' ELLIPSIS
3003                 {
3004                   /* oh what a kludge! */
3005                   $$ = objc_ellipsis_node;
3006                 }
3007         | ','
3008                 {
3009                   push_scope ();
3010                 }
3011           parmlist_2
3012                 {
3013                   /* returns a tree list node generated by get_parm_info */
3014                   $$ = $3;
3015                   pop_scope ();
3016                 }
3017         ;
3018
3019 unaryselector:
3020           selector
3021         ;
3022
3023 keywordselector:
3024           keyworddecl
3025
3026         | keywordselector keyworddecl
3027                 {
3028                   $$ = chainon ($1, $2);
3029                 }
3030         ;
3031
3032 selector:
3033           IDENTIFIER
3034         | TYPENAME
3035         | CLASSNAME
3036         | OBJECTNAME
3037         | reservedwords
3038         ;
3039
3040 reservedwords:
3041           ENUM | STRUCT | UNION | IF | ELSE | WHILE | DO | FOR
3042         | SWITCH | CASE | DEFAULT | BREAK | CONTINUE | RETURN
3043         | GOTO | ASM_KEYWORD | SIZEOF | TYPEOF | ALIGNOF
3044         | TYPESPEC | TYPE_QUAL
3045         ;
3046
3047 keyworddecl:
3048           selector ':' '(' typename ')' identifier
3049                 {
3050                   $$ = objc_build_keyword_decl ($1, $4, $6);
3051                 }
3052
3053         | selector ':' identifier
3054                 {
3055                   $$ = objc_build_keyword_decl ($1, NULL_TREE, $3);
3056                 }
3057
3058         | ':' '(' typename ')' identifier
3059                 {
3060                   $$ = objc_build_keyword_decl (NULL_TREE, $3, $5);
3061                 }
3062
3063         | ':' identifier
3064                 {
3065                   $$ = objc_build_keyword_decl (NULL_TREE, NULL_TREE, $2);
3066                 }
3067         ;
3068
3069 messageargs:
3070           selector
3071         | keywordarglist
3072         ;
3073
3074 keywordarglist:
3075           keywordarg
3076         | keywordarglist keywordarg
3077                 {
3078                   $$ = chainon ($1, $2);
3079                 }
3080         ;
3081
3082
3083 keywordexpr:
3084           nonnull_exprlist
3085                 {
3086                   if (TREE_CHAIN ($1) == NULL_TREE)
3087                     /* just return the expr., remove a level of indirection */
3088                     $$ = TREE_VALUE ($1);
3089                   else
3090                     /* we have a comma expr., we will collapse later */
3091                     $$ = $1;
3092                 }
3093         ;
3094
3095 keywordarg:
3096           selector ':' keywordexpr
3097                 {
3098                   $$ = build_tree_list ($1, $3);
3099                 }
3100         | ':' keywordexpr
3101                 {
3102                   $$ = build_tree_list (NULL_TREE, $2);
3103                 }
3104         ;
3105
3106 receiver:
3107           expr
3108                 { $$ = $1.value; }
3109         | CLASSNAME
3110                 {
3111                   $$ = objc_get_class_reference ($1);
3112                 }
3113         | TYPENAME
3114                 {
3115                   $$ = objc_get_class_reference ($1);
3116                 }
3117         ;
3118
3119 objcmessageexpr:
3120           '[' receiver messageargs ']'
3121                 { $$ = build_tree_list ($2, $3); }
3122         ;
3123
3124 selectorarg:
3125           selector
3126         | keywordnamelist
3127         ;
3128
3129 keywordnamelist:
3130           keywordname
3131         | keywordnamelist keywordname
3132                 {
3133                   $$ = chainon ($1, $2);
3134                 }
3135         ;
3136
3137 keywordname:
3138           selector ':'
3139                 {
3140                   $$ = build_tree_list ($1, NULL_TREE);
3141                 }
3142         | ':'
3143                 {
3144                   $$ = build_tree_list (NULL_TREE, NULL_TREE);
3145                 }
3146         ;
3147
3148 objcselectorexpr:
3149           AT_SELECTOR '(' selectorarg ')'
3150                 {
3151                   $$ = $3;
3152                 }
3153         ;
3154
3155 objcprotocolexpr:
3156           AT_PROTOCOL '(' identifier ')'
3157                 {
3158                   $$ = $3;
3159                 }
3160         ;
3161
3162 /* extension to support C-structures in the archiver */
3163
3164 objcencodeexpr:
3165           AT_ENCODE '(' typename ')'
3166                 {
3167                   $$ = groktypename ($3);
3168                 }
3169         ;
3170
3171 @@end_ifobjc
3172 %%
3173
3174 /* yylex() is a thin wrapper around c_lex(), all it does is translate
3175    cpplib.h's token codes into yacc's token codes.  */
3176
3177 static enum cpp_ttype last_token;
3178
3179 /* The reserved keyword table.  */
3180 struct resword
3181 {
3182   const char *word;
3183   ENUM_BITFIELD(rid) rid : 16;
3184   unsigned int disable   : 16;
3185 };
3186
3187 /* Disable mask.  Keywords are disabled if (reswords[i].disable & mask) is
3188    _true_.  */
3189 #define D_C89   0x01    /* not in C89 */
3190 #define D_EXT   0x02    /* GCC extension */
3191 #define D_EXT89 0x04    /* GCC extension incorporated in C99 */
3192 #define D_OBJC  0x08    /* Objective C only */
3193
3194 static const struct resword reswords[] =
3195 {
3196   { "_Bool",            RID_BOOL,       0 },
3197   { "_Complex",         RID_COMPLEX,    0 },
3198   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
3199   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
3200   { "__alignof",        RID_ALIGNOF,    0 },
3201   { "__alignof__",      RID_ALIGNOF,    0 },
3202   { "__asm",            RID_ASM,        0 },
3203   { "__asm__",          RID_ASM,        0 },
3204   { "__attribute",      RID_ATTRIBUTE,  0 },
3205   { "__attribute__",    RID_ATTRIBUTE,  0 },
3206   { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
3207   { "__builtin_offsetof", RID_OFFSETOF, 0 },
3208   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
3209   { "__builtin_va_arg", RID_VA_ARG,     0 },
3210   { "__complex",        RID_COMPLEX,    0 },
3211   { "__complex__",      RID_COMPLEX,    0 },
3212   { "__const",          RID_CONST,      0 },
3213   { "__const__",        RID_CONST,      0 },
3214   { "__extension__",    RID_EXTENSION,  0 },
3215   { "__func__",         RID_C99_FUNCTION_NAME, 0 },
3216   { "__imag",           RID_IMAGPART,   0 },
3217   { "__imag__",         RID_IMAGPART,   0 },
3218   { "__inline",         RID_INLINE,     0 },
3219   { "__inline__",       RID_INLINE,     0 },
3220   { "__label__",        RID_LABEL,      0 },
3221   { "__ptrbase",        RID_PTRBASE,    0 },
3222   { "__ptrbase__",      RID_PTRBASE,    0 },
3223   { "__ptrextent",      RID_PTREXTENT,  0 },
3224   { "__ptrextent__",    RID_PTREXTENT,  0 },
3225   { "__ptrvalue",       RID_PTRVALUE,   0 },
3226   { "__ptrvalue__",     RID_PTRVALUE,   0 },
3227   { "__real",           RID_REALPART,   0 },
3228   { "__real__",         RID_REALPART,   0 },
3229   { "__restrict",       RID_RESTRICT,   0 },
3230   { "__restrict__",     RID_RESTRICT,   0 },
3231   { "__signed",         RID_SIGNED,     0 },
3232   { "__signed__",       RID_SIGNED,     0 },
3233   { "__thread",         RID_THREAD,     0 },
3234   { "__typeof",         RID_TYPEOF,     0 },
3235   { "__typeof__",       RID_TYPEOF,     0 },
3236   { "__volatile",       RID_VOLATILE,   0 },
3237   { "__volatile__",     RID_VOLATILE,   0 },
3238   { "asm",              RID_ASM,        D_EXT },
3239   { "auto",             RID_AUTO,       0 },
3240   { "break",            RID_BREAK,      0 },
3241   { "case",             RID_CASE,       0 },
3242   { "char",             RID_CHAR,       0 },
3243   { "const",            RID_CONST,      0 },
3244   { "continue",         RID_CONTINUE,   0 },
3245   { "default",          RID_DEFAULT,    0 },
3246   { "do",               RID_DO,         0 },
3247   { "double",           RID_DOUBLE,     0 },
3248   { "else",             RID_ELSE,       0 },
3249   { "enum",             RID_ENUM,       0 },
3250   { "extern",           RID_EXTERN,     0 },
3251   { "float",            RID_FLOAT,      0 },
3252   { "for",              RID_FOR,        0 },
3253   { "goto",             RID_GOTO,       0 },
3254   { "if",               RID_IF,         0 },
3255   { "inline",           RID_INLINE,     D_EXT89 },
3256   { "int",              RID_INT,        0 },
3257   { "long",             RID_LONG,       0 },