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