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