gcc/c-parse.in

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