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