OSDN Git Service

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