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