gcc/c-parse.y

   1 /*WARNING: This file is automatically generated!*/
   2 /* YACC parser for C syntax and for Objective C.  -*-c-*-
   3    Copyright (C) 1987, 88, 89, 92-6, 1997 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 %expect 46
  32
  33 /* These are the 23 conflicts you should get in parse.output;
  34    the state numbers may vary if minor changes in the grammar are made.
  35
  36 State 42 contains 1 shift/reduce conflict.  (Two ways to parse ATTRIBUTE.)
  37 State 44 contains 1 shift/reduce conflict.  (Two ways to recover from error.)
  38 State 103 contains 1 shift/reduce conflict.  (Two ways to recover from error.)
  39 State 110 contains 1 shift/reduce conflict.  (Two ways to parse ATTRIBUTE.)
  40 State 111 contains 1 shift/reduce conflict.  (Two ways to recover from error.)
  41 State 115 contains 1 shift/reduce conflict.  (Two ways to recover from error.)
  42 State 132 contains 1 shift/reduce conflict.  (See comment at component_decl.)
  43 State 180 contains 1 shift/reduce conflict.  (Two ways to parse ATTRIBUTE.)
  44 State 194 contains 2 shift/reduce conflict.  (Four ways to parse this.)
  45 State 202 contains 1 shift/reduce conflict.  (Two ways to recover from error.)
  46 State 214 contains 1 shift/reduce conflict.  (Two ways to recover from error.)
  47 State 220 contains 1 shift/reduce conflict.  (Two ways to recover from error.)
  48 State 304 contains 2 shift/reduce conflicts.  (Four ways to parse this.)
  49 State 335 contains 2 shift/reduce conflicts.  (Four ways to parse this.)
  50 State 347 contains 1 shift/reduce conflict.  (Two ways to parse ATTRIBUTES.)
  51 State 352 contains 1 shift/reduce conflict.  (Two ways to parse ATTRIBUTES.)
  52 State 383 contains 2 shift/reduce conflicts.  (Four ways to parse this.)
  53 State 434 contains 2 shift/reduce conflicts.  (Four ways to parse this.)  */
  54
  55
  56 %{
  57 #include "config.h"
  58
  59 #include <stdio.h>
  60 #include <errno.h>
  61 #include <setjmp.h>
  62
  63 #include "tree.h"
  64 #include "input.h"
  65 #include "c-lex.h"
  66 #include "c-tree.h"
  67 #include "flags.h"
  68
  69 #ifdef MULTIBYTE_CHARS
  70 #include <stdlib.h>
  71 #include <locale.h>
  72 #endif
  73
  74
  75 /* Since parsers are distinct for each language, put the language string
  76    definition here.  */
  77 char *language_string = "GNU C";
  78
  79 #ifndef errno
  80 extern int errno;
  81 #endif
  82
  83 void yyerror ();
  84
  85 /* Like YYERROR but do call yyerror.  */
  86 #define YYERROR1 { yyerror ("syntax error"); YYERROR; }
  87
  88 /* Cause the `yydebug' variable to be defined.  */
  89 #define YYDEBUG 1
  90 %}
  91
  92 %start program
  93
  94 %union {long itype; tree ttype; enum tree_code code;
  95         char *filename; int lineno; int ends_in_label; }
  96
  97 /* All identifiers that are not reserved words
  98    and are not declared typedefs in the current block */
  99 %token IDENTIFIER
 100
 101 /* All identifiers that are declared typedefs in the current block.
 102    In some contexts, they are treated just like IDENTIFIER,
 103    but they can also serve as typespecs in declarations.  */
 104 %token TYPENAME
 105
 106 /* Reserved words that specify storage class.
 107    yylval contains an IDENTIFIER_NODE which indicates which one.  */
 108 %token SCSPEC
 109
 110 /* Reserved words that specify type.
 111    yylval contains an IDENTIFIER_NODE which indicates which one.  */
 112 %token TYPESPEC
 113
 114 /* Reserved words that qualify type: "const" or "volatile".
 115    yylval contains an IDENTIFIER_NODE which indicates which one.  */
 116 %token TYPE_QUAL
 117
 118 /* Character or numeric constants.
 119    yylval is the node for the constant.  */
 120 %token CONSTANT
 121
 122 /* String constants in raw form.
 123    yylval is a STRING_CST node.  */
 124 %token STRING
 125
 126 /* "...", used for functions with variable arglists.  */
 127 %token ELLIPSIS
 128
 129 /* the reserved words */
 130 /* SCO include files test "ASM", so use something else. */
 131 %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
 132 %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF
 133 %token ATTRIBUTE EXTENSION LABEL
 134 %token REALPART IMAGPART
 135
 136 /* Add precedence rules to solve dangling else s/r conflict */
 137 %nonassoc IF
 138 %nonassoc ELSE
 139
 140 /* Define the operator tokens and their precedences.
 141    The value is an integer because, if used, it is the tree code
 142    to use in the expression made from the operator.  */
 143
 144 %right <code> ASSIGN '='
 145 %right <code> '?' ':'
 146 %left <code> OROR
 147 %left <code> ANDAND
 148 %left <code> '|'
 149 %left <code> '^'
 150 %left <code> '&'
 151 %left <code> EQCOMPARE
 152 %left <code> ARITHCOMPARE
 153 %left <code> LSHIFT RSHIFT
 154 %left <code> '+' '-'
 155 %left <code> '*' '/' '%'
 156 %right <code> UNARY PLUSPLUS MINUSMINUS
 157 %left HYPERUNARY
 158 %left <code> POINTSAT '.' '(' '['
 159
 160 /* The Objective-C keywords.  These are included in C and in
 161    Objective C, so that the token codes are the same in both.  */
 162 %token INTERFACE IMPLEMENTATION END SELECTOR DEFS ENCODE
 163 %token CLASSNAME PUBLIC PRIVATE PROTECTED PROTOCOL OBJECTNAME CLASS ALIAS
 164
 165 /* Objective-C string constants in raw form.
 166    yylval is an OBJC_STRING_CST node.  */
 167 %token OBJC_STRING
 168
 169
 170 %type <code> unop
 171
 172 %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist
 173 %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING
 174 %type <ttype> typed_declspecs reserved_declspecs
 175 %type <ttype> typed_typespecs reserved_typespecquals
 176 %type <ttype> declmods typespec typespecqual_reserved
 177 %type <ttype> typed_declspecs_no_prefix_attr reserved_declspecs_no_prefix_attr
 178 %type <ttype> declmods_no_prefix_attr
 179 %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
 180 %type <ttype> initdecls notype_initdecls initdcl notype_initdcl
 181 %type <ttype> init maybeasm
 182 %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
 183 %type <ttype> maybe_attribute attributes attribute attribute_list attrib
 184 %type <ttype> any_word
 185
 186 %type <ttype> compstmt
 187
 188 %type <ttype> declarator
 189 %type <ttype> notype_declarator after_type_declarator
 190 %type <ttype> parm_declarator
 191
 192 %type <ttype> structsp component_decl_list component_decl_list2
 193 %type <ttype> component_decl components component_declarator
 194 %type <ttype> enumlist enumerator
 195 %type <ttype> typename absdcl absdcl1 type_quals
 196 %type <ttype> xexpr parms parm identifiers
 197
 198 %type <ttype> parmlist parmlist_1 parmlist_2
 199 %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
 200 %type <ttype> identifiers_or_typenames
 201
 202 %type <itype> setspecs
 203
 204 %type <ends_in_label> lineno_stmt_or_label lineno_stmt_or_labels stmt_or_label
 205
 206 %type <filename> save_filename
 207 %type <lineno> save_lineno
 208 \f
 209 \f
 210 %{
 211 /* Number of statements (loosely speaking) and compound statements
 212    seen so far.  */
 213 static int stmt_count;
 214 static int compstmt_count;
 215
 216 /* Input file and line number of the end of the body of last simple_if;
 217    used by the stmt-rule immediately after simple_if returns.  */
 218 static char *if_stmt_file;
 219 static int if_stmt_line;
 220
 221 /* List of types and structure classes of the current declaration.  */
 222 static tree current_declspecs = NULL_TREE;
 223 static tree prefix_attributes = NULL_TREE;
 224
 225 /* Stack of saved values of current_declspecs and prefix_attributes.  */
 226 static tree declspec_stack;
 227
 228 /* 1 if we explained undeclared var errors.  */
 229 static int undeclared_variable_notice;
 230
 231
 232 /* Tell yyparse how to print a token's value, if yydebug is set.  */
 233
 234 #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
 235 extern void yyprint ();
 236 %}
 237 \f
 238 %%
 239 program: /* empty */
 240                 { if (pedantic)
 241                     pedwarn ("ANSI C forbids an empty source file");
 242                   finish_file ();
 243                 }
 244         | extdefs
 245                 {
 246                   /* In case there were missing closebraces,
 247                      get us back to the global binding level.  */
 248                   while (! global_bindings_p ())
 249                     poplevel (0, 0, 0);
 250                   finish_file ();
 251                 }
 252         ;
 253
 254 /* the reason for the strange actions in this rule
 255  is so that notype_initdecls when reached via datadef
 256  can find a valid list of type and sc specs in $0. */
 257
 258 extdefs:
 259         {$<ttype>$ = NULL_TREE; } extdef
 260         | extdefs {$<ttype>$ = NULL_TREE; } extdef
 261         ;
 262
 263 extdef:
 264         fndef
 265         | datadef
 266         | ASM_KEYWORD '(' expr ')' ';'
 267                 { STRIP_NOPS ($3);
 268                   if ((TREE_CODE ($3) == ADDR_EXPR
 269                        && TREE_CODE (TREE_OPERAND ($3, 0)) == STRING_CST)
 270                       || TREE_CODE ($3) == STRING_CST)
 271                     assemble_asm ($3);
 272                   else
 273                     error ("argument of `asm' is not a constant string"); }
 274         | extension extdef
 275                 { pedantic = $<itype>1; }
 276         ;
 277
 278 datadef:
 279           setspecs notype_initdecls ';'
 280                 { if (pedantic)
 281                     error ("ANSI C forbids data definition with no type or storage class");
 282                   else if (!flag_traditional)
 283                     warning ("data definition has no type or storage class");
 284
 285                   current_declspecs = TREE_VALUE (declspec_stack);
 286                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 287                   declspec_stack = TREE_CHAIN (declspec_stack);
 288                   resume_momentary ($1); }
 289         | declmods setspecs notype_initdecls ';'
 290                 { current_declspecs = TREE_VALUE (declspec_stack);
 291                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 292                   declspec_stack = TREE_CHAIN (declspec_stack);
 293                   resume_momentary ($2); }
 294         | typed_declspecs setspecs initdecls ';'
 295                 { current_declspecs = TREE_VALUE (declspec_stack);
 296                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 297                   declspec_stack = TREE_CHAIN (declspec_stack);
 298                   resume_momentary ($2);  }
 299         | declmods ';'
 300           { pedwarn ("empty declaration"); }
 301         | typed_declspecs ';'
 302           { shadow_tag ($1); }
 303         | error ';'
 304         | error '}'
 305         | ';'
 306                 { if (pedantic)
 307                     pedwarn ("ANSI C does not allow extra `;' outside of a function"); }
 308         ;
 309 \f
 310 fndef:
 311           typed_declspecs setspecs declarator
 312                 { if (! start_function (current_declspecs, $3,
 313                                         prefix_attributes, NULL_TREE, 0))
 314                     YYERROR1;
 315                   reinit_parse_for_function (); }
 316           old_style_parm_decls
 317                 { store_parm_decls (); }
 318           compstmt_or_error
 319                 { finish_function (0);
 320                   current_declspecs = TREE_VALUE (declspec_stack);
 321                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 322                   declspec_stack = TREE_CHAIN (declspec_stack);
 323                   resume_momentary ($2); }
 324         | typed_declspecs setspecs declarator error
 325                 { current_declspecs = TREE_VALUE (declspec_stack);
 326                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 327                   declspec_stack = TREE_CHAIN (declspec_stack);
 328                   resume_momentary ($2); }
 329         | declmods setspecs notype_declarator
 330                 { if (! start_function (current_declspecs, $3,
 331                                         prefix_attributes, NULL_TREE, 0))
 332                     YYERROR1;
 333                   reinit_parse_for_function (); }
 334           old_style_parm_decls
 335                 { store_parm_decls (); }
 336           compstmt_or_error
 337                 { finish_function (0);
 338                   current_declspecs = TREE_VALUE (declspec_stack);
 339                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 340                   declspec_stack = TREE_CHAIN (declspec_stack);
 341                   resume_momentary ($2); }
 342         | declmods setspecs notype_declarator error
 343                 { current_declspecs = TREE_VALUE (declspec_stack);
 344                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 345                   declspec_stack = TREE_CHAIN (declspec_stack);
 346                   resume_momentary ($2); }
 347         | setspecs notype_declarator
 348                 { if (! start_function (NULL_TREE, $2,
 349                                         prefix_attributes, NULL_TREE, 0))
 350                     YYERROR1;
 351                   reinit_parse_for_function (); }
 352           old_style_parm_decls
 353                 { store_parm_decls (); }
 354           compstmt_or_error
 355                 { finish_function (0);
 356                   current_declspecs = TREE_VALUE (declspec_stack);
 357                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 358                   declspec_stack = TREE_CHAIN (declspec_stack);
 359                   resume_momentary ($1); }
 360         | setspecs notype_declarator error
 361                 { current_declspecs = TREE_VALUE (declspec_stack);
 362                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 363                   declspec_stack = TREE_CHAIN (declspec_stack);
 364                   resume_momentary ($1); }
 365         ;
 366
 367 identifier:
 368         IDENTIFIER
 369         | TYPENAME
 370         ;
 371
 372 unop:     '&'
 373                 { $$ = ADDR_EXPR; }
 374         | '-'
 375                 { $$ = NEGATE_EXPR; }
 376         | '+'
 377                 { $$ = CONVERT_EXPR; }
 378         | PLUSPLUS
 379                 { $$ = PREINCREMENT_EXPR; }
 380         | MINUSMINUS
 381                 { $$ = PREDECREMENT_EXPR; }
 382         | '~'
 383                 { $$ = BIT_NOT_EXPR; }
 384         | '!'
 385                 { $$ = TRUTH_NOT_EXPR; }
 386         ;
 387
 388 expr:   nonnull_exprlist
 389                 { $$ = build_compound_expr ($1); }
 390         ;
 391
 392 exprlist:
 393           /* empty */
 394                 { $$ = NULL_TREE; }
 395         | nonnull_exprlist
 396         ;
 397
 398 nonnull_exprlist:
 399         expr_no_commas
 400                 { $$ = build_tree_list (NULL_TREE, $1); }
 401         | nonnull_exprlist ',' expr_no_commas
 402                 { chainon ($1, build_tree_list (NULL_TREE, $3)); }
 403         ;
 404
 405 unary_expr:
 406         primary
 407         | '*' cast_expr   %prec UNARY
 408                 { $$ = build_indirect_ref ($2, "unary *"); }
 409         /* __extension__ turns off -pedantic for following primary.  */
 410         | extension cast_expr     %prec UNARY
 411                 { $$ = $2;
 412                   pedantic = $<itype>1; }
 413         | unop cast_expr  %prec UNARY
 414                 { $$ = build_unary_op ($1, $2, 0);
 415                   overflow_warning ($$); }
 416         /* Refer to the address of a label as a pointer.  */
 417         | ANDAND identifier
 418                 { tree label = lookup_label ($2);
 419                   if (pedantic)
 420                     pedwarn ("ANSI C forbids `&&'");
 421                   if (label == 0)
 422                     $$ = null_pointer_node;
 423                   else
 424                     {
 425                       TREE_USED (label) = 1;
 426                       $$ = build1 (ADDR_EXPR, ptr_type_node, label);
 427                       TREE_CONSTANT ($$) = 1;
 428                     }
 429                 }
 430 /* This seems to be impossible on some machines, so let's turn it off.
 431    You can use __builtin_next_arg to find the anonymous stack args.
 432         | '&' ELLIPSIS
 433                 { tree types = TYPE_ARG_TYPES (TREE_TYPE (current_function_decl));
 434                   $$ = error_mark_node;
 435                   if (TREE_VALUE (tree_last (types)) == void_type_node)
 436                     error ("`&...' used in function with fixed number of arguments");
 437                   else
 438                     {
 439                       if (pedantic)
 440                         pedwarn ("ANSI C forbids `&...'");
 441                       $$ = tree_last (DECL_ARGUMENTS (current_function_decl));
 442                       $$ = build_unary_op (ADDR_EXPR, $$, 0);
 443                     } }
 444 */
 445         | sizeof unary_expr  %prec UNARY
 446                 { skip_evaluation--;
 447                   if (TREE_CODE ($2) == COMPONENT_REF
 448                       && DECL_C_BIT_FIELD (TREE_OPERAND ($2, 1)))
 449                     error ("`sizeof' applied to a bit-field");
 450                   $$ = c_sizeof (TREE_TYPE ($2)); }
 451         | sizeof '(' typename ')'  %prec HYPERUNARY
 452                 { skip_evaluation--;
 453                   $$ = c_sizeof (groktypename ($3)); }
 454         | alignof unary_expr  %prec UNARY
 455                 { skip_evaluation--;
 456                   $$ = c_alignof_expr ($2); }
 457         | alignof '(' typename ')'  %prec HYPERUNARY
 458                 { skip_evaluation--;
 459                   $$ = c_alignof (groktypename ($3)); }
 460         | REALPART cast_expr %prec UNARY
 461                 { $$ = build_unary_op (REALPART_EXPR, $2, 0); }
 462         | IMAGPART cast_expr %prec UNARY
 463                 { $$ = build_unary_op (IMAGPART_EXPR, $2, 0); }
 464         ;
 465
 466 sizeof:
 467         SIZEOF { skip_evaluation++; }
 468         ;
 469
 470 alignof:
 471         ALIGNOF { skip_evaluation++; }
 472         ;
 473
 474 cast_expr:
 475         unary_expr
 476         | '(' typename ')' cast_expr  %prec UNARY
 477                 { tree type = groktypename ($2);
 478                   $$ = build_c_cast (type, $4); }
 479         | '(' typename ')' '{'
 480                 { start_init (NULL_TREE, NULL, 0);
 481                   $2 = groktypename ($2);
 482                   really_start_incremental_init ($2); }
 483           initlist_maybe_comma '}'  %prec UNARY
 484                 { char *name;
 485                   tree result = pop_init_level (0);
 486                   tree type = $2;
 487                   finish_init ();
 488
 489                   if (pedantic)
 490                     pedwarn ("ANSI C forbids constructor expressions");
 491                   if (TYPE_NAME (type) != 0)
 492                     {
 493                       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 494                         name = IDENTIFIER_POINTER (TYPE_NAME (type));
 495                       else
 496                         name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
 497                     }
 498                   else
 499                     name = "";
 500                   $$ = result;
 501                   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
 502                     {
 503                       int failure = complete_array_type (type, $$, 1);
 504                       if (failure)
 505                         abort ();
 506                     }
 507                 }
 508         ;
 509
 510 expr_no_commas:
 511           cast_expr
 512         | expr_no_commas '+' expr_no_commas
 513                 { $$ = parser_build_binary_op ($2, $1, $3); }
 514         | expr_no_commas '-' expr_no_commas
 515                 { $$ = parser_build_binary_op ($2, $1, $3); }
 516         | expr_no_commas '*' expr_no_commas
 517                 { $$ = parser_build_binary_op ($2, $1, $3); }
 518         | expr_no_commas '/' expr_no_commas
 519                 { $$ = parser_build_binary_op ($2, $1, $3); }
 520         | expr_no_commas '%' expr_no_commas
 521                 { $$ = parser_build_binary_op ($2, $1, $3); }
 522         | expr_no_commas LSHIFT expr_no_commas
 523                 { $$ = parser_build_binary_op ($2, $1, $3); }
 524         | expr_no_commas RSHIFT expr_no_commas
 525                 { $$ = parser_build_binary_op ($2, $1, $3); }
 526         | expr_no_commas ARITHCOMPARE expr_no_commas
 527                 { $$ = parser_build_binary_op ($2, $1, $3); }
 528         | expr_no_commas EQCOMPARE expr_no_commas
 529                 { $$ = parser_build_binary_op ($2, $1, $3); }
 530         | expr_no_commas '&' expr_no_commas
 531                 { $$ = parser_build_binary_op ($2, $1, $3); }
 532         | expr_no_commas '|' expr_no_commas
 533                 { $$ = parser_build_binary_op ($2, $1, $3); }
 534         | expr_no_commas '^' expr_no_commas
 535                 { $$ = parser_build_binary_op ($2, $1, $3); }
 536         | expr_no_commas ANDAND
 537                 { $1 = truthvalue_conversion (default_conversion ($1));
 538                   skip_evaluation += $1 == boolean_false_node; }
 539           expr_no_commas
 540                 { skip_evaluation -= $1 == boolean_false_node;
 541                   $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $4); }
 542         | expr_no_commas OROR
 543                 { $1 = truthvalue_conversion (default_conversion ($1));
 544                   skip_evaluation += $1 == boolean_true_node; }
 545           expr_no_commas
 546                 { skip_evaluation -= $1 == boolean_true_node;
 547                   $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $4); }
 548         | expr_no_commas '?'
 549                 { $1 = truthvalue_conversion (default_conversion ($1));
 550                   skip_evaluation += $1 == boolean_false_node; }
 551           expr ':'
 552                 { skip_evaluation += (($1 == boolean_true_node)
 553                                       - ($1 == boolean_false_node)); }
 554           expr_no_commas
 555                 { skip_evaluation -= $1 == boolean_true_node;
 556                   $$ = build_conditional_expr ($1, $4, $7); }
 557         | expr_no_commas '?'
 558                 { if (pedantic)
 559                     pedwarn ("ANSI C forbids omitting the middle term of a ?: expression");
 560                   /* Make sure first operand is calculated only once.  */
 561                   $<ttype>2 = save_expr ($1);
 562                   $1 = truthvalue_conversion (default_conversion ($<ttype>2));
 563                   skip_evaluation += $1 == boolean_true_node; }
 564           ':' expr_no_commas
 565                 { skip_evaluation -= $1 == boolean_true_node;
 566                   $$ = build_conditional_expr ($1, $<ttype>2, $5); }
 567         | expr_no_commas '=' expr_no_commas
 568                 { $$ = build_modify_expr ($1, NOP_EXPR, $3);
 569                   C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR); }
 570         | expr_no_commas ASSIGN expr_no_commas
 571                 { $$ = build_modify_expr ($1, $2, $3);
 572                   /* This inhibits warnings in truthvalue_conversion.  */
 573                   C_SET_EXP_ORIGINAL_CODE ($$, ERROR_MARK); }
 574         ;
 575
 576 primary:
 577         IDENTIFIER
 578                 {
 579                   $$ = lastiddecl;
 580                   if (!$$ || $$ == error_mark_node)
 581                     {
 582                       if (yychar == YYEMPTY)
 583                         yychar = YYLEX;
 584                       if (yychar == '(')
 585                         {
 586                             {
 587                               /* Ordinary implicit function declaration.  */
 588                               $$ = implicitly_declare ($1);
 589                               assemble_external ($$);
 590                               TREE_USED ($$) = 1;
 591                             }
 592                         }
 593                       else if (current_function_decl == 0)
 594                         {
 595                           error ("`%s' undeclared here (not in a function)",
 596                                  IDENTIFIER_POINTER ($1));
 597                           $$ = error_mark_node;
 598                         }
 599                       else
 600                         {
 601                             {
 602                               if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node
 603                                   || IDENTIFIER_ERROR_LOCUS ($1) != current_function_decl)
 604                                 {
 605                                   error ("`%s' undeclared (first use this function)",
 606                                          IDENTIFIER_POINTER ($1));
 607
 608                                   if (! undeclared_variable_notice)
 609                                     {
 610                                       error ("(Each undeclared identifier is reported only once");
 611                                       error ("for each function it appears in.)");
 612                                       undeclared_variable_notice = 1;
 613                                     }
 614                                 }
 615                               $$ = error_mark_node;
 616                               /* Prevent repeated error messages.  */
 617                               IDENTIFIER_GLOBAL_VALUE ($1) = error_mark_node;
 618                               IDENTIFIER_ERROR_LOCUS ($1) = current_function_decl;
 619                             }
 620                         }
 621                     }
 622                   else if (TREE_TYPE ($$) == error_mark_node)
 623                     $$ = error_mark_node;
 624                   else if (C_DECL_ANTICIPATED ($$))
 625                     {
 626                       /* The first time we see a build-in function used,
 627                          if it has not been declared.  */
 628                       C_DECL_ANTICIPATED ($$) = 0;
 629                       if (yychar == YYEMPTY)
 630                         yychar = YYLEX;
 631                       if (yychar == '(')
 632                         {
 633                           /* Omit the implicit declaration we
 634                              would ordinarily do, so we don't lose
 635                              the actual built in type.
 636                              But print a diagnostic for the mismatch.  */
 637                             if (TREE_CODE ($$) != FUNCTION_DECL)
 638                               error ("`%s' implicitly declared as function",
 639                                      IDENTIFIER_POINTER (DECL_NAME ($$)));
 640                           else if ((TYPE_MODE (TREE_TYPE (TREE_TYPE ($$)))
 641                                     != TYPE_MODE (integer_type_node))
 642                                    && (TREE_TYPE (TREE_TYPE ($$))
 643                                        != void_type_node))
 644                             pedwarn ("type mismatch in implicit declaration for built-in function `%s'",
 645                                      IDENTIFIER_POINTER (DECL_NAME ($$)));
 646                           /* If it really returns void, change that to int.  */
 647                           if (TREE_TYPE (TREE_TYPE ($$)) == void_type_node)
 648                             TREE_TYPE ($$)
 649                               = build_function_type (integer_type_node,
 650                                                      TYPE_ARG_TYPES (TREE_TYPE ($$)));
 651                         }
 652                       else
 653                         pedwarn ("built-in function `%s' used without declaration",
 654                                  IDENTIFIER_POINTER (DECL_NAME ($$)));
 655
 656                       /* Do what we would ordinarily do when a fn is used.  */
 657                       assemble_external ($$);
 658                       TREE_USED ($$) = 1;
 659                     }
 660                   else
 661                     {
 662                       assemble_external ($$);
 663                       TREE_USED ($$) = 1;
 664                     }
 665
 666                   if (TREE_CODE ($$) == CONST_DECL)
 667                     {
 668                       $$ = DECL_INITIAL ($$);
 669                       /* This is to prevent an enum whose value is 0
 670                          from being considered a null pointer constant.  */
 671                       $$ = build1 (NOP_EXPR, TREE_TYPE ($$), $$);
 672                       TREE_CONSTANT ($$) = 1;
 673                     }
 674                 }
 675         | CONSTANT
 676         | string
 677                 { $$ = combine_strings ($1); }
 678         | '(' expr ')'
 679                 { char class = TREE_CODE_CLASS (TREE_CODE ($2));
 680                   if (class == 'e' || class == '1'
 681                       || class == '2' || class == '<')
 682                     C_SET_EXP_ORIGINAL_CODE ($2, ERROR_MARK);
 683                   $$ = $2; }
 684         | '(' error ')'
 685                 { $$ = error_mark_node; }
 686         | '('
 687                 { if (current_function_decl == 0)
 688                     {
 689                       error ("braced-group within expression allowed only inside a function");
 690                       YYERROR;
 691                     }
 692                   /* We must force a BLOCK for this level
 693                      so that, if it is not expanded later,
 694                      there is a way to turn off the entire subtree of blocks
 695                      that are contained in it.  */
 696                   keep_next_level ();
 697                   push_iterator_stack ();
 698                   push_label_level ();
 699                   $<ttype>$ = expand_start_stmt_expr (); }
 700           compstmt ')'
 701                 { tree rtl_exp;
 702                   if (pedantic)
 703                     pedwarn ("ANSI C forbids braced-groups within expressions");
 704                   pop_iterator_stack ();
 705                   pop_label_level ();
 706                   rtl_exp = expand_end_stmt_expr ($<ttype>2);
 707                   /* The statements have side effects, so the group does.  */
 708                   TREE_SIDE_EFFECTS (rtl_exp) = 1;
 709
 710                   if (TREE_CODE ($3) == BLOCK)
 711                     {
 712                       /* Make a BIND_EXPR for the BLOCK already made.  */
 713                       $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp),
 714                                   NULL_TREE, rtl_exp, $3);
 715                       /* Remove the block from the tree at this point.
 716                          It gets put back at the proper place
 717                          when the BIND_EXPR is expanded.  */
 718                       delete_block ($3);
 719                     }
 720                   else
 721                     $$ = $3;
 722                 }
 723         | primary '(' exprlist ')'   %prec '.'
 724                 { $$ = build_function_call ($1, $3); }
 725         | primary '[' expr ']'   %prec '.'
 726                 { $$ = build_array_ref ($1, $3); }
 727         | primary '.' identifier
 728                 {
 729                     $$ = build_component_ref ($1, $3);
 730                 }
 731         | primary POINTSAT identifier
 732                 {
 733                   tree expr = build_indirect_ref ($1, "->");
 734
 735                     $$ = build_component_ref (expr, $3);
 736                 }
 737         | primary PLUSPLUS
 738                 { $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); }
 739         | primary MINUSMINUS
 740                 { $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); }
 741         ;
 742
 743 /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it.  */
 744 string:
 745           STRING
 746         | string STRING
 747                 { $$ = chainon ($1, $2); }
 748         ;
 749
 750
 751 old_style_parm_decls:
 752         /* empty */
 753         | datadecls
 754         | datadecls ELLIPSIS
 755                 /* ... is used here to indicate a varargs function.  */
 756                 { c_mark_varargs ();
 757                   if (pedantic)
 758                     pedwarn ("ANSI C does not permit use of `varargs.h'"); }
 759         ;
 760
 761 /* The following are analogous to lineno_decl, decls and decl
 762    except that they do not allow nested functions.
 763    They are used for old-style parm decls.  */
 764 lineno_datadecl:
 765           save_filename save_lineno datadecl
 766                 { }
 767         ;
 768
 769 datadecls:
 770         lineno_datadecl
 771         | errstmt
 772         | datadecls lineno_datadecl
 773         | lineno_datadecl errstmt
 774         ;
 775
 776 /* We don't allow prefix attributes here because they cause reduce/reduce
 777    conflicts: we can't know whether we're parsing a function decl with
 778    attribute suffix, or function defn with attribute prefix on first old
 779    style parm.  */
 780 datadecl:
 781         typed_declspecs_no_prefix_attr setspecs initdecls ';'
 782                 { current_declspecs = TREE_VALUE (declspec_stack);
 783                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 784                   declspec_stack = TREE_CHAIN (declspec_stack);
 785                   resume_momentary ($2); }
 786         | declmods_no_prefix_attr setspecs notype_initdecls ';'
 787                 { current_declspecs = TREE_VALUE (declspec_stack);
 788                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 789                   declspec_stack = TREE_CHAIN (declspec_stack);
 790                   resume_momentary ($2); }
 791         | typed_declspecs_no_prefix_attr ';'
 792                 { shadow_tag_warned ($1, 1);
 793                   pedwarn ("empty declaration"); }
 794         | declmods_no_prefix_attr ';'
 795                 { pedwarn ("empty declaration"); }
 796         ;
 797
 798 /* This combination which saves a lineno before a decl
 799    is the normal thing to use, rather than decl itself.
 800    This is to avoid shift/reduce conflicts in contexts
 801    where statement labels are allowed.  */
 802 lineno_decl:
 803           save_filename save_lineno decl
 804                 { }
 805         ;
 806
 807 decls:
 808         lineno_decl
 809         | errstmt
 810         | decls lineno_decl
 811         | lineno_decl errstmt
 812         ;
 813
 814 /* records the type and storage class specs to use for processing
 815    the declarators that follow.
 816    Maintains a stack of outer-level values of current_declspecs,
 817    for the sake of parm declarations nested in function declarators.  */
 818 setspecs: /* empty */
 819                 { $$ = suspend_momentary ();
 820                   pending_xref_error ();
 821                   declspec_stack = tree_cons (prefix_attributes,
 822                                               current_declspecs,
 823                                               declspec_stack);
 824                   split_specs_attrs ($<ttype>0,
 825                                      &current_declspecs, &prefix_attributes); }
 826         ;
 827
 828 /* ??? Yuck.  See after_type_declarator.  */
 829 setattrs: /* empty */
 830                 { prefix_attributes = chainon (prefix_attributes, $<ttype>0); }
 831         ;
 832
 833 decl:
 834         typed_declspecs setspecs initdecls ';'
 835                 { current_declspecs = TREE_VALUE (declspec_stack);
 836                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 837                   declspec_stack = TREE_CHAIN (declspec_stack);
 838                   resume_momentary ($2); }
 839         | declmods setspecs notype_initdecls ';'
 840                 { current_declspecs = TREE_VALUE (declspec_stack);
 841                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 842                   declspec_stack = TREE_CHAIN (declspec_stack);
 843                   resume_momentary ($2); }
 844         | typed_declspecs setspecs nested_function
 845                 { current_declspecs = TREE_VALUE (declspec_stack);
 846                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 847                   declspec_stack = TREE_CHAIN (declspec_stack);
 848                   resume_momentary ($2); }
 849         | declmods setspecs notype_nested_function
 850                 { current_declspecs = TREE_VALUE (declspec_stack);
 851                   prefix_attributes = TREE_PURPOSE (declspec_stack);
 852                   declspec_stack = TREE_CHAIN (declspec_stack);
 853                   resume_momentary ($2); }
 854         | typed_declspecs ';'
 855                 { shadow_tag ($1); }
 856         | declmods ';'
 857                 { pedwarn ("empty declaration"); }
 858         | extension decl
 859                 { pedantic = $<itype>1; }
 860         ;
 861
 862 /* Declspecs which contain at least one type specifier or typedef name.
 863    (Just `const' or `volatile' is not enough.)
 864    A typedef'd name following these is taken as a name to be declared.
 865    Declspecs have a non-NULL TREE_VALUE, attributes do not.  */
 866
 867 typed_declspecs:
 868           typespec reserved_declspecs
 869                 { $$ = tree_cons (NULL_TREE, $1, $2); }
 870         | declmods typespec reserved_declspecs
 871                 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
 872         ;
 873
 874 reserved_declspecs:  /* empty */
 875                 { $$ = NULL_TREE; }
 876         | reserved_declspecs typespecqual_reserved
 877                 { $$ = tree_cons (NULL_TREE, $2, $1); }
 878         | reserved_declspecs SCSPEC
 879                 { if (extra_warnings)
 880                     warning ("`%s' is not at beginning of declaration",
 881                              IDENTIFIER_POINTER ($2));
 882                   $$ = tree_cons (NULL_TREE, $2, $1); }
 883         | reserved_declspecs attributes
 884                 { $$ = tree_cons ($2, NULL_TREE, $1); }
 885         ;
 886
 887 typed_declspecs_no_prefix_attr:
 888           typespec reserved_declspecs_no_prefix_attr
 889                 { $$ = tree_cons (NULL_TREE, $1, $2); }
 890         | declmods_no_prefix_attr typespec reserved_declspecs_no_prefix_attr
 891                 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
 892         ;
 893
 894 reserved_declspecs_no_prefix_attr:
 895           /* empty */
 896                 { $$ = NULL_TREE; }
 897         | reserved_declspecs_no_prefix_attr typespecqual_reserved
 898                 { $$ = tree_cons (NULL_TREE, $2, $1); }
 899         | reserved_declspecs_no_prefix_attr SCSPEC
 900                 { if (extra_warnings)
 901                     warning ("`%s' is not at beginning of declaration",
 902                              IDENTIFIER_POINTER ($2));
 903                   $$ = tree_cons (NULL_TREE, $2, $1); }
 904         ;
 905
 906 /* List of just storage classes, type modifiers, and prefix attributes.
 907    A declaration can start with just this, but then it cannot be used
 908    to redeclare a typedef-name.
 909    Declspecs have a non-NULL TREE_VALUE, attributes do not.  */
 910
 911 declmods:
 912           declmods_no_prefix_attr
 913                 { $$ = $1; }
 914         | attributes
 915                 { $$ = tree_cons ($1, NULL_TREE, NULL_TREE); }
 916         | declmods declmods_no_prefix_attr
 917                 { $$ = chainon ($2, $1); }
 918         | declmods attributes
 919                 { $$ = tree_cons ($2, NULL_TREE, $1); }
 920         ;
 921
 922 declmods_no_prefix_attr:
 923           TYPE_QUAL
 924                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
 925                   TREE_STATIC ($$) = 1; }
 926         | SCSPEC
 927                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
 928         | declmods_no_prefix_attr TYPE_QUAL
 929                 { $$ = tree_cons (NULL_TREE, $2, $1);
 930                   TREE_STATIC ($$) = 1; }
 931         | declmods_no_prefix_attr SCSPEC
 932                 { if (extra_warnings && TREE_STATIC ($1))
 933                     warning ("`%s' is not at beginning of declaration",
 934                              IDENTIFIER_POINTER ($2));
 935                   $$ = tree_cons (NULL_TREE, $2, $1);
 936                   TREE_STATIC ($$) = TREE_STATIC ($1); }
 937         ;
 938
 939
 940 /* Used instead of declspecs where storage classes are not allowed
 941    (that is, for typenames and structure components).
 942    Don't accept a typedef-name if anything but a modifier precedes it.  */
 943
 944 typed_typespecs:
 945           typespec reserved_typespecquals
 946                 { $$ = tree_cons (NULL_TREE, $1, $2); }
 947         | nonempty_type_quals typespec reserved_typespecquals
 948                 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
 949         ;
 950
 951 reserved_typespecquals:  /* empty */
 952                 { $$ = NULL_TREE; }
 953         | reserved_typespecquals typespecqual_reserved
 954                 { $$ = tree_cons (NULL_TREE, $2, $1); }
 955         ;
 956
 957 /* A typespec (but not a type qualifier).
 958    Once we have seen one of these in a declaration,
 959    if a typedef name appears then it is being redeclared.  */
 960
 961 typespec: TYPESPEC
 962         | structsp
 963         | TYPENAME
 964                 { /* For a typedef name, record the meaning, not the name.
 965                      In case of `foo foo, bar;'.  */
 966                   $$ = lookup_name ($1); }
 967         | TYPEOF '(' expr ')'
 968                 { $$ = TREE_TYPE ($3); }
 969         | TYPEOF '(' typename ')'
 970                 { $$ = groktypename ($3); }
 971         ;
 972
 973 /* A typespec that is a reserved word, or a type qualifier.  */
 974
 975 typespecqual_reserved: TYPESPEC
 976         | TYPE_QUAL
 977         | structsp
 978         ;
 979
 980 initdecls:
 981         initdcl
 982         | initdecls ',' initdcl
 983         ;
 984
 985 notype_initdecls:
 986         notype_initdcl
 987         | notype_initdecls ',' initdcl
 988         ;
 989
 990 maybeasm:
 991           /* empty */
 992                 { $$ = NULL_TREE; }
 993         | ASM_KEYWORD '(' string ')'
 994                 { if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
 995                   $$ = $3;
 996                 }
 997         ;
 998
 999 initdcl:
1000           declarator maybeasm maybe_attribute '='
1001                 { $<ttype>$ = start_decl ($1, current_declspecs, 1,
1002                                           $3, prefix_attributes);
1003                   start_init ($<ttype>$, $2, global_bindings_p ()); }
1004           init
1005 /* Note how the declaration of the variable is in effect while its init is parsed! */
1006                 { finish_init ();
1007                   finish_decl ($<ttype>5, $6, $2); }
1008         | declarator maybeasm maybe_attribute
1009                 { tree d = start_decl ($1, current_declspecs, 0,
1010                                        $3, prefix_attributes);
1011                   finish_decl (d, NULL_TREE, $2);
1012                 }
1013         ;
1014
1015 notype_initdcl:
1016           notype_declarator maybeasm maybe_attribute '='
1017                 { $<ttype>$ = start_decl ($1, current_declspecs, 1,
1018                                           $3, prefix_attributes);
1019                   start_init ($<ttype>$, $2, global_bindings_p ()); }
1020           init
1021 /* Note how the declaration of the variable is in effect while its init is parsed! */
1022                 { finish_init ();
1023                   decl_attributes ($<ttype>5, $3, prefix_attributes);
1024                   finish_decl ($<ttype>5, $6, $2); }
1025         | notype_declarator maybeasm maybe_attribute
1026                 { tree d = start_decl ($1, current_declspecs, 0,
1027                                        $3, prefix_attributes);
1028                   finish_decl (d, NULL_TREE, $2); }
1029         ;
1030 /* the * rules are dummies to accept the Apollo extended syntax
1031    so that the header files compile. */
1032 maybe_attribute:
1033       /* empty */
1034                 { $$ = NULL_TREE; }
1035         | attributes
1036                 { $$ = $1; }
1037         ;
1038
1039 attributes:
1040       attribute
1041                 { $$ = $1; }
1042         | attributes attribute
1043                 { $$ = chainon ($1, $2); }
1044         ;
1045
1046 attribute:
1047       ATTRIBUTE '(' '(' attribute_list ')' ')'
1048                 { $$ = $4; }
1049         ;
1050
1051 attribute_list:
1052       attrib
1053                 { $$ = $1; }
1054         | attribute_list ',' attrib
1055                 { $$ = chainon ($1, $3); }
1056         ;
1057
1058 attrib:
1059     /* empty */
1060                 { $$ = NULL_TREE; }
1061         | any_word
1062                 { $$ = build_tree_list ($1, NULL_TREE); }
1063         | any_word '(' IDENTIFIER ')'
1064                 { $$ = build_tree_list ($1, build_tree_list (NULL_TREE, $3)); }
1065         | any_word '(' IDENTIFIER ',' nonnull_exprlist ')'
1066                 { $$ = build_tree_list ($1, tree_cons (NULL_TREE, $3, $5)); }
1067         | any_word '(' exprlist ')'
1068                 { $$ = build_tree_list ($1, $3); }
1069         ;
1070
1071 /* This still leaves out most reserved keywords,
1072    shouldn't we include them?  */
1073
1074 any_word:
1075           identifier
1076         | SCSPEC
1077         | TYPESPEC
1078         | TYPE_QUAL
1079         ;
1080 \f
1081 /* Initializers.  `init' is the entry point.  */
1082
1083 init:
1084         expr_no_commas
1085         | '{'
1086                 { really_start_incremental_init (NULL_TREE);
1087                   /* Note that the call to clear_momentary
1088                      is in process_init_element.  */
1089                   push_momentary (); }
1090           initlist_maybe_comma '}'
1091                 { $$ = pop_init_level (0);
1092                   if ($$ == error_mark_node
1093                       && ! (yychar == STRING || yychar == CONSTANT))
1094                     pop_momentary ();
1095                   else
1096                     pop_momentary_nofree (); }
1097
1098         | error
1099                 { $$ = error_mark_node; }
1100         ;
1101
1102 /* `initlist_maybe_comma' is the guts of an initializer in braces.  */
1103 initlist_maybe_comma:
1104           /* empty */
1105                 { if (pedantic)
1106                     pedwarn ("ANSI C forbids empty initializer braces"); }
1107         | initlist1 maybecomma
1108         ;
1109
1110 initlist1:
1111           initelt
1112         | initlist1 ',' initelt
1113         ;
1114
1115 /* `initelt' is a single element of an initializer.
1116    It may use braces.  */
1117 initelt:
1118         expr_no_commas
1119                 { process_init_element ($1); }
1120         | '{'
1121                 { push_init_level (0); }
1122           initlist_maybe_comma '}'
1123                 { process_init_element (pop_init_level (0)); }
1124         | error
1125         /* These are for labeled elements.  The syntax for an array element
1126            initializer conflicts with the syntax for an Objective-C message,
1127            so don't include these productions in the Objective-C grammar.  */
1128         | '[' expr_no_commas ELLIPSIS expr_no_commas ']' '='
1129                 { set_init_index ($2, $4); }
1130           initelt
1131         | '[' expr_no_commas ']' '='
1132                 { set_init_index ($2, NULL_TREE); }
1133           initelt
1134         | '[' expr_no_commas ']'
1135                 { set_init_index ($2, NULL_TREE); }
1136           initelt
1137         | identifier ':'
1138                 { set_init_label ($1); }
1139           initelt
1140         | '.' identifier '='
1141                 { set_init_label ($2); }
1142           initelt
1143         ;
1144 \f
1145 nested_function:
1146           declarator
1147                 { push_c_function_context ();
1148                   if (! start_function (current_declspecs, $1,
1149                                         prefix_attributes, NULL_TREE, 1))
1150                     {
1151                       pop_c_function_context ();
1152                       YYERROR1;
1153                     }
1154                   reinit_parse_for_function (); }
1155            old_style_parm_decls
1156                 { store_parm_decls (); }
1157 /* This used to use compstmt_or_error.
1158    That caused a bug with input `f(g) int g {}',
1159    where the use of YYERROR1 above caused an error
1160    which then was handled by compstmt_or_error.
1161    There followed a repeated execution of that same rule,
1162    which called YYERROR1 again, and so on.  */
1163           compstmt
1164                 { finish_function (1);
1165                   pop_c_function_context (); }
1166         ;
1167
1168 notype_nested_function:
1169           notype_declarator
1170                 { push_c_function_context ();
1171                   if (! start_function (current_declspecs, $1,
1172                                         prefix_attributes, NULL_TREE, 1))
1173                     {
1174                       pop_c_function_context ();
1175                       YYERROR1;
1176                     }
1177                   reinit_parse_for_function (); }
1178           old_style_parm_decls
1179                 { store_parm_decls (); }
1180 /* This used to use compstmt_or_error.
1181    That caused a bug with input `f(g) int g {}',
1182    where the use of YYERROR1 above caused an error
1183    which then was handled by compstmt_or_error.
1184    There followed a repeated execution of that same rule,
1185    which called YYERROR1 again, and so on.  */
1186           compstmt
1187                 { finish_function (1);
1188                   pop_c_function_context (); }
1189         ;
1190
1191 /* Any kind of declarator (thus, all declarators allowed
1192    after an explicit typespec).  */
1193
1194 declarator:
1195           after_type_declarator
1196         | notype_declarator
1197         ;
1198
1199 /* A declarator that is allowed only after an explicit typespec.  */
1200
1201 after_type_declarator:
1202           '(' after_type_declarator ')'
1203                 { $$ = $2; }
1204         | after_type_declarator '(' parmlist_or_identifiers  %prec '.'
1205                 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1206 /*      | after_type_declarator '(' error ')'  %prec '.'
1207                 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1208                   poplevel (0, 0, 0); }  */
1209         | after_type_declarator '[' expr ']'  %prec '.'
1210                 { $$ = build_nt (ARRAY_REF, $1, $3); }
1211         | after_type_declarator '[' ']'  %prec '.'
1212                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1213         | '*' type_quals after_type_declarator  %prec UNARY
1214                 { $$ = make_pointer_declarator ($2, $3); }
1215         /* ??? Yuck.  setattrs is a quick hack.  We can't use
1216            prefix_attributes because $1 only applies to this
1217            declarator.  We assume setspecs has already been done.
1218            setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1219            attributes could be recognized here or in `attributes').  */
1220         | attributes setattrs after_type_declarator
1221                 { $$ = $3; }
1222         | TYPENAME
1223         ;
1224
1225 /* Kinds of declarator that can appear in a parameter list
1226    in addition to notype_declarator.  This is like after_type_declarator
1227    but does not allow a typedef name in parentheses as an identifier
1228    (because it would conflict with a function with that typedef as arg).  */
1229
1230 parm_declarator:
1231           parm_declarator '(' parmlist_or_identifiers  %prec '.'
1232                 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1233 /*      | parm_declarator '(' error ')'  %prec '.'
1234                 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1235                   poplevel (0, 0, 0); }  */
1236         | parm_declarator '[' expr ']'  %prec '.'
1237                 { $$ = build_nt (ARRAY_REF, $1, $3); }
1238         | parm_declarator '[' ']'  %prec '.'
1239                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1240         | '*' type_quals parm_declarator  %prec UNARY
1241                 { $$ = make_pointer_declarator ($2, $3); }
1242         /* ??? Yuck.  setattrs is a quick hack.  We can't use
1243            prefix_attributes because $1 only applies to this
1244            declarator.  We assume setspecs has already been done.
1245            setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1246            attributes could be recognized here or in `attributes').  */
1247         | attributes setattrs parm_declarator
1248                 { $$ = $3; }
1249         | TYPENAME
1250         ;
1251
1252 /* A declarator allowed whether or not there has been
1253    an explicit typespec.  These cannot redeclare a typedef-name.  */
1254
1255 notype_declarator:
1256           notype_declarator '(' parmlist_or_identifiers  %prec '.'
1257                 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1258 /*      | notype_declarator '(' error ')'  %prec '.'
1259                 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1260                   poplevel (0, 0, 0); }  */
1261         | '(' notype_declarator ')'
1262                 { $$ = $2; }
1263         | '*' type_quals notype_declarator  %prec UNARY
1264                 { $$ = make_pointer_declarator ($2, $3); }
1265         | notype_declarator '[' expr ']'  %prec '.'
1266                 { $$ = build_nt (ARRAY_REF, $1, $3); }
1267         | notype_declarator '[' ']'  %prec '.'
1268                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1269         /* ??? Yuck.  setattrs is a quick hack.  We can't use
1270            prefix_attributes because $1 only applies to this
1271            declarator.  We assume setspecs has already been done.
1272            setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1273            attributes could be recognized here or in `attributes').  */
1274         | attributes setattrs notype_declarator
1275                 { $$ = $3; }
1276         | IDENTIFIER
1277         ;
1278
1279 structsp:
1280           STRUCT identifier '{'
1281                 { $$ = start_struct (RECORD_TYPE, $2);
1282                   /* Start scope of tag before parsing components.  */
1283                 }
1284           component_decl_list '}' maybe_attribute
1285                 { $$ = finish_struct ($<ttype>4, $5, $7); }
1286         | STRUCT '{' component_decl_list '}' maybe_attribute
1287                 { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
1288                                       $3, $5);
1289                 }
1290         | STRUCT identifier
1291                 { $$ = xref_tag (RECORD_TYPE, $2); }
1292         | UNION identifier '{'
1293                 { $$ = start_struct (UNION_TYPE, $2); }
1294           component_decl_list '}' maybe_attribute
1295                 { $$ = finish_struct ($<ttype>4, $5, $7); }
1296         | UNION '{' component_decl_list '}' maybe_attribute
1297                 { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
1298                                       $3, $5);
1299                 }
1300         | UNION identifier
1301                 { $$ = xref_tag (UNION_TYPE, $2); }
1302         | ENUM identifier '{'
1303                 { $<itype>3 = suspend_momentary ();
1304                   $$ = start_enum ($2); }
1305           enumlist maybecomma_warn '}' maybe_attribute
1306                 { $$ = finish_enum ($<ttype>4, nreverse ($5), $8);
1307                   resume_momentary ($<itype>3); }
1308         | ENUM '{'
1309                 { $<itype>2 = suspend_momentary ();
1310                   $$ = start_enum (NULL_TREE); }
1311           enumlist maybecomma_warn '}' maybe_attribute
1312                 { $$ = finish_enum ($<ttype>3, nreverse ($4), $7);
1313                   resume_momentary ($<itype>2); }
1314         | ENUM identifier
1315                 { $$ = xref_tag (ENUMERAL_TYPE, $2); }
1316         ;
1317
1318 maybecomma:
1319           /* empty */
1320         | ','
1321         ;
1322
1323 maybecomma_warn:
1324           /* empty */
1325         | ','
1326                 { if (pedantic) pedwarn ("comma at end of enumerator list"); }
1327         ;
1328
1329 component_decl_list:
1330           component_decl_list2
1331                 { $$ = $1; }
1332         | component_decl_list2 component_decl
1333                 { $$ = chainon ($1, $2);
1334                   pedwarn ("no semicolon at end of struct or union"); }
1335         ;
1336
1337 component_decl_list2:   /* empty */
1338                 { $$ = NULL_TREE; }
1339         | component_decl_list2 component_decl ';'
1340                 { $$ = chainon ($1, $2); }
1341         | component_decl_list2 ';'
1342                 { if (pedantic)
1343                     pedwarn ("extra semicolon in struct or union specified"); }
1344         ;
1345
1346 /* There is a shift-reduce conflict here, because `components' may
1347    start with a `typename'.  It happens that shifting (the default resolution)
1348    does the right thing, because it treats the `typename' as part of
1349    a `typed_typespecs'.
1350
1351    It is possible that this same technique would allow the distinction
1352    between `notype_initdecls' and `initdecls' to be eliminated.
1353    But I am being cautious and not trying it.  */
1354
1355 component_decl:
1356           typed_typespecs setspecs components
1357                 { $$ = $3;
1358                   current_declspecs = TREE_VALUE (declspec_stack);
1359                   prefix_attributes = TREE_PURPOSE (declspec_stack);
1360                   declspec_stack = TREE_CHAIN (declspec_stack);
1361                   resume_momentary ($2); }
1362         | typed_typespecs
1363                 { if (pedantic)
1364                     pedwarn ("ANSI C forbids member declarations with no members");
1365                   shadow_tag($1);
1366                   $$ = NULL_TREE; }
1367         | nonempty_type_quals setspecs components
1368                 { $$ = $3;
1369                   current_declspecs = TREE_VALUE (declspec_stack);
1370                   prefix_attributes = TREE_PURPOSE (declspec_stack);
1371                   declspec_stack = TREE_CHAIN (declspec_stack);
1372                   resume_momentary ($2); }
1373         | nonempty_type_quals
1374                 { if (pedantic)
1375                     pedwarn ("ANSI C forbids member declarations with no members");
1376                   shadow_tag($1);
1377                   $$ = NULL_TREE; }
1378         | error
1379                 { $$ = NULL_TREE; }
1380         | extension component_decl
1381                 { $$ = $2;
1382                   pedantic = $<itype>1; }
1383         ;
1384
1385 components:
1386           component_declarator
1387         | components ',' component_declarator
1388                 { $$ = chainon ($1, $3); }
1389         ;
1390
1391 component_declarator:
1392           save_filename save_lineno declarator maybe_attribute
1393                 { $$ = grokfield ($1, $2, $3, current_declspecs, NULL_TREE);
1394                   decl_attributes ($$, $4, prefix_attributes); }
1395         | save_filename save_lineno
1396           declarator ':' expr_no_commas maybe_attribute
1397                 { $$ = grokfield ($1, $2, $3, current_declspecs, $5);
1398                   decl_attributes ($$, $6, prefix_attributes); }
1399         | save_filename save_lineno ':' expr_no_commas maybe_attribute
1400                 { $$ = grokfield ($1, $2, NULL_TREE, current_declspecs, $4);
1401                   decl_attributes ($$, $5, prefix_attributes); }
1402         ;
1403
1404 /* We chain the enumerators in reverse order.
1405    They are put in forward order where enumlist is used.
1406    (The order used to be significant, but no longer is so.
1407    However, we still maintain the order, just to be clean.)  */
1408
1409 enumlist:
1410           enumerator
1411         | enumlist ',' enumerator
1412                 { if ($1 == error_mark_node)
1413                     $$ = $1;
1414                   else
1415                     $$ = chainon ($3, $1); }
1416         | error
1417                 { $$ = error_mark_node; }
1418         ;
1419
1420
1421 enumerator:
1422           identifier
1423                 { $$ = build_enumerator ($1, NULL_TREE); }
1424         | identifier '=' expr_no_commas
1425                 { $$ = build_enumerator ($1, $3); }
1426         ;
1427
1428 typename:
1429         typed_typespecs absdcl
1430                 { $$ = build_tree_list ($1, $2); }
1431         | nonempty_type_quals absdcl
1432                 { $$ = build_tree_list ($1, $2); }
1433         ;
1434
1435 absdcl:   /* an absolute declarator */
1436         /* empty */
1437                 { $$ = NULL_TREE; }
1438         | absdcl1
1439         ;
1440
1441 nonempty_type_quals:
1442           TYPE_QUAL
1443                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
1444         | nonempty_type_quals TYPE_QUAL
1445                 { $$ = tree_cons (NULL_TREE, $2, $1); }
1446         ;
1447
1448 type_quals:
1449           /* empty */
1450                 { $$ = NULL_TREE; }
1451         | type_quals TYPE_QUAL
1452                 { $$ = tree_cons (NULL_TREE, $2, $1); }
1453         ;
1454
1455 absdcl1:  /* a nonempty absolute declarator */
1456           '(' absdcl1 ')'
1457                 { $$ = $2; }
1458           /* `(typedef)1' is `int'.  */
1459         | '*' type_quals absdcl1  %prec UNARY
1460                 { $$ = make_pointer_declarator ($2, $3); }
1461         | '*' type_quals  %prec UNARY
1462                 { $$ = make_pointer_declarator ($2, NULL_TREE); }
1463         | absdcl1 '(' parmlist  %prec '.'
1464                 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1465         | absdcl1 '[' expr ']'  %prec '.'
1466                 { $$ = build_nt (ARRAY_REF, $1, $3); }
1467         | absdcl1 '[' ']'  %prec '.'
1468                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1469         | '(' parmlist  %prec '.'
1470                 { $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); }
1471         | '[' expr ']'  %prec '.'
1472                 { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); }
1473         | '[' ']'  %prec '.'
1474                 { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); }
1475         /* ??? It appears we have to support attributes here, however
1476            using prefix_attributes is wrong.  */
1477         ;
1478
1479 /* at least one statement, the first of which parses without error.  */
1480 /* stmts is used only after decls, so an invalid first statement
1481    is actually regarded as an invalid decl and part of the decls.  */
1482
1483 stmts:
1484         lineno_stmt_or_labels
1485                 {
1486                   if (pedantic && $1)
1487                     pedwarn ("ANSI C forbids label at end of compound statement");
1488                 }
1489         ;
1490
1491 lineno_stmt_or_labels:
1492           lineno_stmt_or_label
1493         | lineno_stmt_or_labels lineno_stmt_or_label
1494                 { $$ = $2; }
1495         | lineno_stmt_or_labels errstmt
1496                 { $$ = 0; }
1497         ;
1498
1499 xstmts:
1500         /* empty */
1501         | stmts
1502         ;
1503
1504 errstmt:  error ';'
1505         ;
1506
1507 pushlevel:  /* empty */
1508                 { emit_line_note (input_filename, lineno);
1509                   pushlevel (0);
1510                   clear_last_expr ();
1511                   push_momentary ();
1512                   expand_start_bindings (0);
1513                 }
1514         ;
1515
1516 /* Read zero or more forward-declarations for labels
1517    that nested functions can jump to.  */
1518 maybe_label_decls:
1519           /* empty */
1520         | label_decls
1521                 { if (pedantic)
1522                     pedwarn ("ANSI C forbids label declarations"); }
1523         ;
1524
1525 label_decls:
1526           label_decl
1527         | label_decls label_decl
1528         ;
1529
1530 label_decl:
1531           LABEL identifiers_or_typenames ';'
1532                 { tree link;
1533                   for (link = $2; link; link = TREE_CHAIN (link))
1534                     {
1535                       tree label = shadow_label (TREE_VALUE (link));
1536                       C_DECLARED_LABEL_FLAG (label) = 1;
1537                       declare_nonlocal_label (label);
1538                     }
1539                 }
1540         ;
1541
1542 /* This is the body of a function definition.
1543    It causes syntax errors to ignore to the next openbrace.  */
1544 compstmt_or_error:
1545           compstmt
1546                 {}
1547         | error compstmt
1548         ;
1549
1550 compstmt_start: '{' { compstmt_count++; }
1551
1552 compstmt: compstmt_start '}'
1553                 { $$ = convert (void_type_node, integer_zero_node); }
1554         | compstmt_start pushlevel maybe_label_decls decls xstmts '}'
1555                 { emit_line_note (input_filename, lineno);
1556                   expand_end_bindings (getdecls (), 1, 0);
1557                   $$ = poplevel (1, 1, 0);
1558                   if (yychar == CONSTANT || yychar == STRING)
1559                     pop_momentary_nofree ();
1560                   else
1561                     pop_momentary (); }
1562         | compstmt_start pushlevel maybe_label_decls error '}'
1563                 { emit_line_note (input_filename, lineno);
1564                   expand_end_bindings (getdecls (), kept_level_p (), 0);
1565                   $$ = poplevel (kept_level_p (), 0, 0);
1566                   if (yychar == CONSTANT || yychar == STRING)
1567                     pop_momentary_nofree ();
1568                   else
1569                     pop_momentary (); }
1570         | compstmt_start pushlevel maybe_label_decls stmts '}'
1571                 { emit_line_note (input_filename, lineno);
1572                   expand_end_bindings (getdecls (), kept_level_p (), 0);
1573                   $$ = poplevel (kept_level_p (), 0, 0);
1574                   if (yychar == CONSTANT || yychar == STRING)
1575                     pop_momentary_nofree ();
1576                   else
1577                     pop_momentary (); }
1578         ;
1579
1580 /* Value is number of statements counted as of the closeparen.  */
1581 simple_if:
1582           if_prefix lineno_labeled_stmt
1583 /* Make sure c_expand_end_cond is run once
1584    for each call to c_expand_start_cond.
1585    Otherwise a crash is likely.  */
1586         | if_prefix error
1587         ;
1588
1589 if_prefix:
1590           IF '(' expr ')'
1591                 { emit_line_note ($<filename>-1, $<lineno>0);
1592                   c_expand_start_cond (truthvalue_conversion ($3), 0,
1593                                        compstmt_count);
1594                   $<itype>$ = stmt_count;
1595                   if_stmt_file = $<filename>-1;
1596                   if_stmt_line = $<lineno>0;
1597                   position_after_white_space (); }
1598         ;
1599
1600 /* This is a subroutine of stmt.
1601    It is used twice, once for valid DO statements
1602    and once for catching errors in parsing the end test.  */
1603 do_stmt_start:
1604           DO
1605                 { stmt_count++;
1606                   compstmt_count++;
1607                   emit_line_note ($<filename>-1, $<lineno>0);
1608                   /* See comment in `while' alternative, above.  */
1609                   emit_nop ();
1610                   expand_start_loop_continue_elsewhere (1);
1611                   position_after_white_space (); }
1612           lineno_labeled_stmt WHILE
1613                 { expand_loop_continue_here (); }
1614         ;
1615
1616 save_filename:
1617                 { $$ = input_filename; }
1618         ;
1619
1620 save_lineno:
1621                 { $$ = lineno; }
1622         ;
1623
1624 lineno_labeled_stmt:
1625           save_filename save_lineno stmt
1626                 { }
1627 /*      | save_filename save_lineno error
1628                 { }
1629 */
1630         | save_filename save_lineno label lineno_labeled_stmt
1631                 { }
1632         ;
1633
1634 lineno_stmt_or_label:
1635           save_filename save_lineno stmt_or_label
1636                 { $$ = $3; }
1637         ;
1638
1639 stmt_or_label:
1640           stmt
1641                 { $$ = 0; }
1642         | label
1643                 { $$ = 1; }
1644         ;
1645
1646 /* Parse a single real statement, not including any labels.  */
1647 stmt:
1648           compstmt
1649                 { stmt_count++; }
1650         | all_iter_stmt
1651         | expr ';'
1652                 { stmt_count++;
1653                   emit_line_note ($<filename>-1, $<lineno>0);
1654 /* It appears that this should not be done--that a non-lvalue array
1655    shouldn't get an error if the value isn't used.
1656    Section 3.2.2.1 says that an array lvalue gets converted to a pointer
1657    if it appears as a top-level expression,
1658    but says nothing about non-lvalue arrays.  */
1659 #if 0
1660                   /* Call default_conversion to get an error
1661                      on referring to a register array if pedantic.  */
1662                   if (TREE_CODE (TREE_TYPE ($1)) == ARRAY_TYPE
1663                       || TREE_CODE (TREE_TYPE ($1)) == FUNCTION_TYPE)
1664                     $1 = default_conversion ($1);
1665 #endif
1666                   iterator_expand ($1);
1667                   clear_momentary (); }
1668         | simple_if ELSE
1669                 { c_expand_start_else ();
1670                   $<itype>1 = stmt_count;
1671                   position_after_white_space (); }
1672           lineno_labeled_stmt
1673                 { c_expand_end_cond ();
1674                   if (extra_warnings && stmt_count == $<itype>1)
1675                     warning ("empty body in an else-statement"); }
1676         | simple_if %prec IF
1677                 { c_expand_end_cond ();
1678                   /* This warning is here instead of in simple_if, because we
1679                      do not want a warning if an empty if is followed by an
1680                      else statement.  Increment stmt_count so we don't
1681                      give a second error if this is a nested `if'.  */
1682                   if (extra_warnings && stmt_count++ == $<itype>1)
1683                     warning_with_file_and_line (if_stmt_file, if_stmt_line,
1684                                                 "empty body in an if-statement"); }
1685 /* Make sure c_expand_end_cond is run once
1686    for each call to c_expand_start_cond.
1687    Otherwise a crash is likely.  */
1688         | simple_if ELSE error
1689                 { c_expand_end_cond (); }
1690         | WHILE
1691                 { stmt_count++;
1692                   emit_line_note ($<filename>-1, $<lineno>0);
1693                   /* The emit_nop used to come before emit_line_note,
1694                      but that made the nop seem like part of the preceding line.
1695                      And that was confusing when the preceding line was
1696                      inside of an if statement and was not really executed.
1697                      I think it ought to work to put the nop after the line number.
1698                      We will see.  --rms, July 15, 1991.  */
1699                   emit_nop (); }
1700           '(' expr ')'
1701                 { /* Don't start the loop till we have succeeded
1702                      in parsing the end test.  This is to make sure
1703                      that we end every loop we start.  */
1704                   expand_start_loop (1);
1705                   emit_line_note (input_filename, lineno);
1706                   expand_exit_loop_if_false (NULL_PTR,
1707                                              truthvalue_conversion ($4));
1708                   position_after_white_space (); }
1709           lineno_labeled_stmt
1710                 { expand_end_loop (); }
1711         | do_stmt_start
1712           '(' expr ')' ';'
1713                 { emit_line_note (input_filename, lineno);
1714                   expand_exit_loop_if_false (NULL_PTR,
1715                                              truthvalue_conversion ($3));
1716                   expand_end_loop ();
1717                   clear_momentary (); }
1718 /* This rule is needed to make sure we end every loop we start.  */
1719         | do_stmt_start error
1720                 { expand_end_loop ();
1721                   clear_momentary (); }
1722         | FOR
1723           '(' xexpr ';'
1724                 { stmt_count++;
1725                   emit_line_note ($<filename>-1, $<lineno>0);
1726                   /* See comment in `while' alternative, above.  */
1727                   emit_nop ();
1728                   if ($3) c_expand_expr_stmt ($3);
1729                   /* Next step is to call expand_start_loop_continue_elsewhere,
1730                      but wait till after we parse the entire for (...).
1731                      Otherwise, invalid input might cause us to call that
1732                      fn without calling expand_end_loop.  */
1733                 }
1734           xexpr ';'
1735                 /* Can't emit now; wait till after expand_start_loop...  */
1736                 { $<lineno>7 = lineno;
1737                   $<filename>$ = input_filename; }
1738           xexpr ')'
1739                 {
1740                   /* Start the loop.  Doing this after parsing
1741                      all the expressions ensures we will end the loop.  */
1742                   expand_start_loop_continue_elsewhere (1);
1743                   /* Emit the end-test, with a line number.  */
1744                   emit_line_note ($<filename>8, $<lineno>7);
1745                   if ($6)
1746                     expand_exit_loop_if_false (NULL_PTR,
1747                                                truthvalue_conversion ($6));
1748                   /* Don't let the tree nodes for $9 be discarded by
1749                      clear_momentary during the parsing of the next stmt.  */
1750                   push_momentary ();
1751                   $<lineno>7 = lineno;
1752                   $<filename>8 = input_filename;
1753                   position_after_white_space (); }
1754           lineno_labeled_stmt
1755                 { /* Emit the increment expression, with a line number.  */
1756                   emit_line_note ($<filename>8, $<lineno>7);
1757                   expand_loop_continue_here ();
1758                   if ($9)
1759                     c_expand_expr_stmt ($9);
1760                   if (yychar == CONSTANT || yychar == STRING)
1761                     pop_momentary_nofree ();
1762                   else
1763                     pop_momentary ();
1764                   expand_end_loop (); }
1765         | SWITCH '(' expr ')'
1766                 { stmt_count++;
1767                   emit_line_note ($<filename>-1, $<lineno>0);
1768                   c_expand_start_case ($3);
1769                   /* Don't let the tree nodes for $3 be discarded by
1770                      clear_momentary during the parsing of the next stmt.  */
1771                   push_momentary ();
1772                   position_after_white_space (); }
1773           lineno_labeled_stmt
1774                 { expand_end_case ($3);
1775                   if (yychar == CONSTANT || yychar == STRING)
1776                     pop_momentary_nofree ();
1777                   else
1778                     pop_momentary (); }
1779         | BREAK ';'
1780                 { stmt_count++;
1781                   emit_line_note ($<filename>-1, $<lineno>0);
1782                   if ( ! expand_exit_something ())
1783                     error ("break statement not within loop or switch"); }
1784         | CONTINUE ';'
1785                 { stmt_count++;
1786                   emit_line_note ($<filename>-1, $<lineno>0);
1787                   if (! expand_continue_loop (NULL_PTR))
1788                     error ("continue statement not within a loop"); }
1789         | RETURN ';'
1790                 { stmt_count++;
1791                   emit_line_note ($<filename>-1, $<lineno>0);
1792                   c_expand_return (NULL_TREE); }
1793         | RETURN expr ';'
1794                 { stmt_count++;
1795                   emit_line_note ($<filename>-1, $<lineno>0);
1796                   c_expand_return ($2); }
1797         | ASM_KEYWORD maybe_type_qual '(' expr ')' ';'
1798                 { stmt_count++;
1799                   emit_line_note ($<filename>-1, $<lineno>0);
1800                   STRIP_NOPS ($4);
1801                   if ((TREE_CODE ($4) == ADDR_EXPR
1802                        && TREE_CODE (TREE_OPERAND ($4, 0)) == STRING_CST)
1803                       || TREE_CODE ($4) == STRING_CST)
1804                     expand_asm ($4);
1805                   else
1806                     error ("argument of `asm' is not a constant string"); }
1807         /* This is the case with just output operands.  */
1808         | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ')' ';'
1809                 { stmt_count++;
1810                   emit_line_note ($<filename>-1, $<lineno>0);
1811                   c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE,
1812                                          $2 == ridpointers[(int)RID_VOLATILE],
1813                                          input_filename, lineno); }
1814         /* This is the case with input operands as well.  */
1815         | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':' asm_operands ')' ';'
1816                 { stmt_count++;
1817                   emit_line_note ($<filename>-1, $<lineno>0);
1818                   c_expand_asm_operands ($4, $6, $8, NULL_TREE,
1819                                          $2 == ridpointers[(int)RID_VOLATILE],
1820                                          input_filename, lineno); }
1821         /* This is the case with clobbered registers as well.  */
1822         | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':'
1823           asm_operands ':' asm_clobbers ')' ';'
1824                 { stmt_count++;
1825                   emit_line_note ($<filename>-1, $<lineno>0);
1826                   c_expand_asm_operands ($4, $6, $8, $10,
1827                                          $2 == ridpointers[(int)RID_VOLATILE],
1828                                          input_filename, lineno); }
1829         | GOTO identifier ';'
1830                 { tree decl;
1831                   stmt_count++;
1832                   emit_line_note ($<filename>-1, $<lineno>0);
1833                   decl = lookup_label ($2);
1834                   if (decl != 0)
1835                     {
1836                       TREE_USED (decl) = 1;
1837                       expand_goto (decl);
1838                     }
1839                 }
1840         | GOTO '*' expr ';'
1841                 { if (pedantic)
1842                     pedwarn ("ANSI C forbids `goto *expr;'");
1843                   stmt_count++;
1844                   emit_line_note ($<filename>-1, $<lineno>0);
1845                   expand_computed_goto (convert (ptr_type_node, $3)); }
1846         | ';'
1847         ;
1848
1849 all_iter_stmt:
1850           all_iter_stmt_simple
1851 /*      | all_iter_stmt_with_decl */
1852         ;
1853
1854 all_iter_stmt_simple:
1855           FOR '(' primary ')'
1856           {
1857             /* The value returned by this action is  */
1858             /*      1 if everything is OK */
1859             /*      0 in case of error or already bound iterator */
1860
1861             $<itype>$ = 0;
1862             if (TREE_CODE ($3) != VAR_DECL)
1863               error ("invalid `for (ITERATOR)' syntax");
1864             else if (! ITERATOR_P ($3))
1865               error ("`%s' is not an iterator",
1866                      IDENTIFIER_POINTER (DECL_NAME ($3)));
1867             else if (ITERATOR_BOUND_P ($3))
1868               error ("`for (%s)' inside expansion of same iterator",
1869                      IDENTIFIER_POINTER (DECL_NAME ($3)));
1870             else
1871               {
1872                 $<itype>$ = 1;
1873                 iterator_for_loop_start ($3);
1874               }
1875           }
1876           lineno_labeled_stmt
1877           {
1878             if ($<itype>5)
1879               iterator_for_loop_end ($3);
1880           }
1881
1882 /*  This really should allow any kind of declaration,
1883     for generality.  Fix it before turning it back on.
1884
1885 all_iter_stmt_with_decl:
1886           FOR '(' ITERATOR pushlevel setspecs iterator_spec ')'
1887           {
1888 */          /* The value returned by this action is  */
1889             /*      1 if everything is OK */
1890             /*      0 in case of error or already bound iterator */
1891 /*
1892             iterator_for_loop_start ($6);
1893           }
1894           lineno_labeled_stmt
1895           {
1896             iterator_for_loop_end ($6);
1897             emit_line_note (input_filename, lineno);
1898             expand_end_bindings (getdecls (), 1, 0);
1899             $<ttype>$ = poplevel (1, 1, 0);
1900             if (yychar == CONSTANT || yychar == STRING)
1901               pop_momentary_nofree ();
1902             else
1903               pop_momentary ();
1904           }
1905 */
1906
1907 /* Any kind of label, including jump labels and case labels.
1908    ANSI C accepts labels only before statements, but we allow them
1909    also at the end of a compound statement.  */
1910
1911 label:    CASE expr_no_commas ':'
1912                 { register tree value = check_case_value ($2);
1913                   register tree label
1914                     = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1915
1916                   stmt_count++;
1917
1918                   if (value != error_mark_node)
1919                     {
1920                       tree duplicate;
1921                       int success = pushcase (value, convert_and_check,
1922                                               label, &duplicate);
1923                       if (success == 1)
1924                         error ("case label not within a switch statement");
1925                       else if (success == 2)
1926                         {
1927                           error ("duplicate case value");
1928                           error_with_decl (duplicate, "this is the first entry for that value");
1929                         }
1930                       else if (success == 3)
1931                         warning ("case value out of range");
1932                       else if (success == 5)
1933                         error ("case label within scope of cleanup or variable array");
1934                     }
1935                   position_after_white_space (); }
1936         | CASE expr_no_commas ELLIPSIS expr_no_commas ':'
1937                 { register tree value1 = check_case_value ($2);
1938                   register tree value2 = check_case_value ($4);
1939                   register tree label
1940                     = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1941
1942                   if (pedantic)
1943                     pedwarn ("ANSI C forbids case ranges");
1944                   stmt_count++;
1945
1946                   if (value1 != error_mark_node && value2 != error_mark_node)
1947                     {
1948                       tree duplicate;
1949                       int success = pushcase_range (value1, value2,
1950                                                     convert_and_check, label,
1951                                                     &duplicate);
1952                       if (success == 1)
1953                         error ("case label not within a switch statement");
1954                       else if (success == 2)
1955                         {
1956                           error ("duplicate case value");
1957                           error_with_decl (duplicate, "this is the first entry for that value");
1958                         }
1959                       else if (success == 3)
1960                         warning ("case value out of range");
1961                       else if (success == 4)
1962                         warning ("empty case range");
1963                       else if (success == 5)
1964                         error ("case label within scope of cleanup or variable array");
1965                     }
1966                   position_after_white_space (); }
1967         | DEFAULT ':'
1968                 {
1969                   tree duplicate;
1970                   register tree label
1971                     = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1972                   int success = pushcase (NULL_TREE, 0, label, &duplicate);
1973                   stmt_count++;
1974                   if (success == 1)
1975                     error ("default label not within a switch statement");
1976                   else if (success == 2)
1977                     {
1978                       error ("multiple default labels in one switch");
1979                       error_with_decl (duplicate, "this is the first default label");
1980                     }
1981                   position_after_white_space (); }
1982         | identifier ':'
1983                 { tree label = define_label (input_filename, lineno, $1);
1984                   stmt_count++;
1985                   emit_nop ();
1986                   if (label)
1987                     expand_label (label);
1988                   position_after_white_space (); }
1989         ;
1990
1991 /* Either a type-qualifier or nothing.  First thing in an `asm' statement.  */
1992
1993 maybe_type_qual:
1994         /* empty */
1995                 { emit_line_note (input_filename, lineno);
1996                   $$ = NULL_TREE; }
1997         | TYPE_QUAL
1998                 { emit_line_note (input_filename, lineno); }
1999         ;
2000
2001 xexpr:
2002         /* empty */
2003                 { $$ = NULL_TREE; }
2004         | expr
2005         ;
2006
2007 /* These are the operands other than the first string and colon
2008    in  asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x))  */
2009 asm_operands: /* empty */
2010                 { $$ = NULL_TREE; }
2011         | nonnull_asm_operands
2012         ;
2013
2014 nonnull_asm_operands:
2015           asm_operand
2016         | nonnull_asm_operands ',' asm_operand
2017                 { $$ = chainon ($1, $3); }
2018         ;
2019
2020 asm_operand:
2021           STRING '(' expr ')'
2022                 { $$ = build_tree_list ($1, $3); }
2023         ;
2024
2025 asm_clobbers:
2026           string
2027                 { $$ = tree_cons (NULL_TREE, combine_strings ($1), NULL_TREE); }
2028         | asm_clobbers ',' string
2029                 { $$ = tree_cons (NULL_TREE, combine_strings ($3), $1); }
2030         ;
2031 \f
2032 /* This is what appears inside the parens in a function declarator.
2033    Its value is a list of ..._TYPE nodes.  */
2034 parmlist:
2035                 { pushlevel (0);
2036                   clear_parm_order ();
2037                   declare_parm_level (0); }
2038           parmlist_1
2039                 { $$ = $2;
2040                   parmlist_tags_warning ();
2041                   poplevel (0, 0, 0); }
2042         ;
2043
2044 parmlist_1:
2045           parmlist_2 ')'
2046         | parms ';'
2047                 { tree parm;
2048                   if (pedantic)
2049                     pedwarn ("ANSI C forbids forward parameter declarations");
2050                   /* Mark the forward decls as such.  */
2051                   for (parm = getdecls (); parm; parm = TREE_CHAIN (parm))
2052                     TREE_ASM_WRITTEN (parm) = 1;
2053                   clear_parm_order (); }
2054           parmlist_1
2055                 { $$ = $4; }
2056         | error ')'
2057                 { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
2058         ;
2059
2060 /* This is what appears inside the parens in a function declarator.
2061    Is value is represented in the format that grokdeclarator expects.  */
2062 parmlist_2:  /* empty */
2063                 { $$ = get_parm_info (0); }
2064         | ELLIPSIS
2065                 { $$ = get_parm_info (0);
2066                   /* Gcc used to allow this as an extension.  However, it does
2067                      not work for all targets, and thus has been disabled.
2068                      Also, since func (...) and func () are indistinguishable,
2069                      it caused problems with the code in expand_builtin which
2070                      tries to verify that BUILT_IN_NEXT_ARG is being used
2071                      correctly.  */
2072                   error ("ANSI C requires a named argument before `...'");
2073                 }
2074         | parms
2075                 { $$ = get_parm_info (1); }
2076         | parms ',' ELLIPSIS
2077                 { $$ = get_parm_info (0); }
2078         ;
2079
2080 parms:
2081         parm
2082                 { push_parm_decl ($1); }
2083         | parms ',' parm
2084                 { push_parm_decl ($3); }
2085         ;
2086
2087 /* A single parameter declaration or parameter type name,
2088    as found in a parmlist.  */
2089 parm:
2090           typed_declspecs setspecs parm_declarator maybe_attribute
2091                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2092                                                          $3),
2093                                         build_tree_list (prefix_attributes,
2094                                                          $4));
2095                   current_declspecs = TREE_VALUE (declspec_stack);
2096                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2097                   declspec_stack = TREE_CHAIN (declspec_stack);
2098                   resume_momentary ($2); }
2099         | typed_declspecs setspecs notype_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                   resume_momentary ($2); }
2108         | typed_declspecs setspecs absdcl maybe_attribute
2109                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2110                                                          $3),
2111                                         build_tree_list (prefix_attributes,
2112                                                          $4));
2113                   current_declspecs = TREE_VALUE (declspec_stack);
2114                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2115                   declspec_stack = TREE_CHAIN (declspec_stack);
2116                   resume_momentary ($2); }
2117         | declmods setspecs notype_declarator maybe_attribute
2118                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2119                                                          $3),
2120                                         build_tree_list (prefix_attributes,
2121                                                          $4));
2122                   current_declspecs = TREE_VALUE (declspec_stack);
2123                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2124                   declspec_stack = TREE_CHAIN (declspec_stack);
2125                   resume_momentary ($2);  }
2126
2127         | declmods setspecs absdcl maybe_attribute
2128                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2129                                                          $3),
2130                                         build_tree_list (prefix_attributes,
2131                                                          $4));
2132                   current_declspecs = TREE_VALUE (declspec_stack);
2133                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2134                   declspec_stack = TREE_CHAIN (declspec_stack);
2135                   resume_momentary ($2);  }
2136         ;
2137
2138 /* This is used in a function definition
2139    where either a parmlist or an identifier list is ok.
2140    Its value is a list of ..._TYPE nodes or a list of identifiers.  */
2141 parmlist_or_identifiers:
2142                 { pushlevel (0);
2143                   clear_parm_order ();
2144                   declare_parm_level (1); }
2145           parmlist_or_identifiers_1
2146                 { $$ = $2;
2147                   parmlist_tags_warning ();
2148                   poplevel (0, 0, 0); }
2149         ;
2150
2151 parmlist_or_identifiers_1:
2152           parmlist_1
2153         | identifiers ')'
2154                 { tree t;
2155                   for (t = $1; t; t = TREE_CHAIN (t))
2156                     if (TREE_VALUE (t) == NULL_TREE)
2157                       error ("`...' in old-style identifier list");
2158                   $$ = tree_cons (NULL_TREE, NULL_TREE, $1); }
2159         ;
2160
2161 /* A nonempty list of identifiers.  */
2162 identifiers:
2163         IDENTIFIER
2164                 { $$ = build_tree_list (NULL_TREE, $1); }
2165         | identifiers ',' IDENTIFIER
2166                 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2167         ;
2168
2169 /* A nonempty list of identifiers, including typenames.  */
2170 identifiers_or_typenames:
2171         identifier
2172                 { $$ = build_tree_list (NULL_TREE, $1); }
2173         | identifiers_or_typenames ',' identifier
2174                 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2175         ;
2176
2177 extension:
2178         EXTENSION
2179                 { $<itype>$ = pedantic;
2180                   pedantic = 0; }
2181         ;
2182 \f
2183 %%