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