gcc/c-parse.in

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