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