* decl.c (grokfndecl): Remove dead code.
[official-gcc.git] / gcc / c-parse.in
blob6811b45b98ef46f68b541c71b5c26f718bb829af
1 /* YACC parser for C syntax and for Objective C.  -*-c-*-
2    Copyright (C) 1987, 88, 89, 92-98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING.  If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.  */
21 /* This file defines the grammar of C and that of Objective C.
22    ifobjc ... end ifobjc  conditionals contain code for Objective C only.
23    ifc ... end ifc  conditionals contain code for C only.
24    Sed commands in Makefile.in are used to convert this file into
25    c-parse.y and into objc-parse.y.  */
27 /* To whomever it may concern: I have heard that such a thing was once
28    written by AT&T, but I have never seen it.  */
30 ifobjc
31 %expect 74
32 end ifobjc
33 ifc
34 %expect 53
35 end ifc
38 #include "config.h"
39 #include "system.h"
40 #include <setjmp.h>
41 #include "tree.h"
42 #include "input.h"
43 #include "c-lex.h"
44 #include "c-tree.h"
45 #include "flags.h"
46 #include "output.h"
47 #include "toplev.h"
48 #include "ggc.h"
49   
50 #ifdef MULTIBYTE_CHARS
51 #include <locale.h>
52 #endif
54 ifobjc
55 #include "objc-act.h"
56 end ifobjc
58 /* Since parsers are distinct for each language, put the language string
59    definition here.  */
60 ifobjc
61 const char * const language_string = "GNU Obj-C";
62 end ifobjc
63 ifc
64 const char * const language_string = "GNU C";
65 end ifc
67 /* Like YYERROR but do call yyerror.  */
68 #define YYERROR1 { yyerror ("syntax error"); YYERROR; }
70 /* Cause the `yydebug' variable to be defined.  */
71 #define YYDEBUG 1
74 %start program
76 %union {long itype; tree ttype; enum tree_code code;
77         char *filename; int lineno; int ends_in_label; }
79 /* All identifiers that are not reserved words
80    and are not declared typedefs in the current block */
81 %token IDENTIFIER
83 /* All identifiers that are declared typedefs in the current block.
84    In some contexts, they are treated just like IDENTIFIER,
85    but they can also serve as typespecs in declarations.  */
86 %token TYPENAME
88 /* Reserved words that specify storage class.
89    yylval contains an IDENTIFIER_NODE which indicates which one.  */
90 %token SCSPEC
92 /* Reserved words that specify type.
93    yylval contains an IDENTIFIER_NODE which indicates which one.  */
94 %token TYPESPEC
96 /* Reserved words that qualify type: "const", "volatile", or "restrict".
97    yylval contains an IDENTIFIER_NODE which indicates which one.  */
98 %token TYPE_QUAL
100 /* Character or numeric constants.
101    yylval is the node for the constant.  */
102 %token CONSTANT
104 /* String constants in raw form.
105    yylval is a STRING_CST node.  */
106 %token STRING
108 /* "...", used for functions with variable arglists.  */
109 %token ELLIPSIS
111 /* the reserved words */
112 /* SCO include files test "ASM", so use something else. */
113 %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
114 %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF
115 %token ATTRIBUTE EXTENSION LABEL
116 %token REALPART IMAGPART VA_ARG
118 /* Used in c-lex.c for parsing pragmas.  */
119 %token END_OF_LINE
121 /* Add precedence rules to solve dangling else s/r conflict */
122 %nonassoc IF
123 %nonassoc ELSE
125 /* Define the operator tokens and their precedences.
126    The value is an integer because, if used, it is the tree code
127    to use in the expression made from the operator.  */
129 %right <code> ASSIGN '='
130 %right <code> '?' ':'
131 %left <code> OROR
132 %left <code> ANDAND
133 %left <code> '|'
134 %left <code> '^'
135 %left <code> '&'
136 %left <code> EQCOMPARE
137 %left <code> ARITHCOMPARE
138 %left <code> LSHIFT RSHIFT
139 %left <code> '+' '-'
140 %left <code> '*' '/' '%'
141 %right <code> UNARY PLUSPLUS MINUSMINUS
142 %left HYPERUNARY
143 %left <code> POINTSAT '.' '(' '['
145 /* The Objective-C keywords.  These are included in C and in
146    Objective C, so that the token codes are the same in both.  */
147 %token INTERFACE IMPLEMENTATION END SELECTOR DEFS ENCODE
148 %token CLASSNAME PUBLIC PRIVATE PROTECTED PROTOCOL OBJECTNAME CLASS ALIAS
150 /* Objective-C string constants in raw form.
151    yylval is an OBJC_STRING_CST node.  */
152 %token OBJC_STRING
155 %type <code> unop
157 %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist
158 %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING
159 %type <ttype> typed_declspecs reserved_declspecs
160 %type <ttype> typed_typespecs reserved_typespecquals
161 %type <ttype> declmods typespec typespecqual_reserved
162 %type <ttype> typed_declspecs_no_prefix_attr reserved_declspecs_no_prefix_attr
163 %type <ttype> declmods_no_prefix_attr
164 %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
165 %type <ttype> initdecls notype_initdecls initdcl notype_initdcl
166 %type <ttype> init maybeasm
167 %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
168 %type <ttype> maybe_attribute attributes attribute attribute_list attrib
169 %type <ttype> any_word
171 %type <ttype> compstmt compstmt_nostart compstmt_primary_start
173 %type <ttype> declarator
174 %type <ttype> notype_declarator after_type_declarator
175 %type <ttype> parm_declarator
177 %type <ttype> structsp component_decl_list component_decl_list2
178 %type <ttype> component_decl components component_declarator
179 %type <ttype> enumlist enumerator
180 %type <ttype> struct_head union_head enum_head
181 %type <ttype> typename absdcl absdcl1 type_quals
182 %type <ttype> xexpr parms parm identifiers
184 %type <ttype> parmlist parmlist_1 parmlist_2
185 %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
186 %type <ttype> identifiers_or_typenames
188 %type <itype> extension
190 %type <itype> setspecs
192 %type <ends_in_label> lineno_stmt_or_label lineno_stmt_or_labels stmt_or_label
194 %type <filename> save_filename
195 %type <lineno> save_lineno
197 ifobjc
198 /* the Objective-C nonterminals */
200 %type <ttype> ivar_decl_list ivar_decls ivar_decl ivars ivar_declarator
201 %type <ttype> methoddecl unaryselector keywordselector selector
202 %type <ttype> keyworddecl receiver objcmessageexpr messageargs
203 %type <ttype> keywordexpr keywordarglist keywordarg
204 %type <ttype> myparms myparm optparmlist reservedwords objcselectorexpr
205 %type <ttype> selectorarg keywordnamelist keywordname objcencodeexpr
206 %type <ttype> objc_string non_empty_protocolrefs protocolrefs identifier_list objcprotocolexpr
208 %type <ttype> CLASSNAME OBJC_STRING OBJECTNAME
209 end ifobjc
212 /* Number of statements (loosely speaking) and compound statements 
213    seen so far.  */
214 static int stmt_count;
215 static int compstmt_count;
216   
217 /* Input file and line number of the end of the body of last simple_if;
218    used by the stmt-rule immediately after simple_if returns.  */
219 static char *if_stmt_file;
220 static int if_stmt_line;
222 /* List of types and structure classes of the current declaration.  */
223 static tree current_declspecs = NULL_TREE;
224 static tree prefix_attributes = NULL_TREE;
226 /* Stack of saved values of current_declspecs and prefix_attributes.  */
227 static tree declspec_stack;
229 /* 1 if we explained undeclared var errors.  */
230 static int undeclared_variable_notice;
232 /* For __extension__, save/restore the warning flags which are
233    controlled by __extension__.  */
234 #define SAVE_WARN_FLAGS() (pedantic | (warn_pointer_arith << 1))
235 #define RESTORE_WARN_FLAGS(val) \
236   do {                                     \
237     pedantic = val & 1;                    \
238     warn_pointer_arith = (val >> 1) & 1;   \
239   } while (0)
241 ifobjc
242 /* Objective-C specific information */
244 tree objc_interface_context;
245 tree objc_implementation_context;
246 tree objc_method_context;
247 tree objc_ivar_chain;
248 tree objc_ivar_context;
249 enum tree_code objc_inherit_code;
250 int objc_receiver_context;
251 int objc_public_flag;
253 end ifobjc
255 /* Tell yyparse how to print a token's value, if yydebug is set.  */
257 #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
258 extern void yyprint                     PROTO ((FILE *, int, YYSTYPE));
260 /* Add GC roots for variables local to this file.  */
261 void
262 c_parse_init ()
264   ggc_add_tree_root (&declspec_stack, 1);
265   ggc_add_tree_root (&current_declspecs, 1);
266   ggc_add_tree_root (&prefix_attributes, 1);
272 program: /* empty */
273                 { if (pedantic)
274                     pedwarn ("ANSI C forbids an empty source file");
275                   finish_file ();
276                 }
277         | extdefs
278                 {
279                   /* In case there were missing closebraces,
280                      get us back to the global binding level.  */
281                   while (! global_bindings_p ())
282                     poplevel (0, 0, 0);
283                   finish_file ();
284                 }
285         ;
287 /* the reason for the strange actions in this rule
288  is so that notype_initdecls when reached via datadef
289  can find a valid list of type and sc specs in $0. */
291 extdefs:
292         {$<ttype>$ = NULL_TREE; } extdef
293         | extdefs {$<ttype>$ = NULL_TREE; } extdef
294         ;
296 extdef:
297         fndef
298         | datadef
299 ifobjc
300         | objcdef
301 end ifobjc
302         | ASM_KEYWORD '(' expr ')' ';'
303                 { STRIP_NOPS ($3);
304                   if ((TREE_CODE ($3) == ADDR_EXPR
305                        && TREE_CODE (TREE_OPERAND ($3, 0)) == STRING_CST)
306                       || TREE_CODE ($3) == STRING_CST)
307                     assemble_asm ($3);
308                   else
309                     error ("argument of `asm' is not a constant string"); }
310         | extension extdef
311                 { RESTORE_WARN_FLAGS ($1); }
312         ;
314 datadef:
315           setspecs notype_initdecls ';'
316                 { if (pedantic)
317                     error ("ANSI C forbids data definition with no type or storage class");
318                   else if (!flag_traditional)
319                     warning ("data definition has no type or storage class"); 
321                   current_declspecs = TREE_VALUE (declspec_stack);
322                   prefix_attributes = TREE_PURPOSE (declspec_stack);
323                   declspec_stack = TREE_CHAIN (declspec_stack);
324                   resume_momentary ($1); }
325         | declmods setspecs notype_initdecls ';'
326                 { current_declspecs = TREE_VALUE (declspec_stack);
327                   prefix_attributes = TREE_PURPOSE (declspec_stack);
328                   declspec_stack = TREE_CHAIN (declspec_stack);
329                   resume_momentary ($2); }
330         | typed_declspecs setspecs initdecls ';'
331                 { current_declspecs = TREE_VALUE (declspec_stack);
332                   prefix_attributes = TREE_PURPOSE (declspec_stack);
333                   declspec_stack = TREE_CHAIN (declspec_stack);
334                   resume_momentary ($2);  }
335         | declmods ';'
336           { pedwarn ("empty declaration"); }
337         | typed_declspecs ';'
338           { shadow_tag ($1); }
339         | error ';'
340         | error '}'
341         | ';'
342                 { if (pedantic)
343                     pedwarn ("ANSI C does not allow extra `;' outside of a function"); }
344         ;
346 fndef:
347           typed_declspecs setspecs declarator
348                 { if (! start_function (current_declspecs, $3,
349                                         prefix_attributes, NULL_TREE, 0))
350                     YYERROR1;
351                   reinit_parse_for_function (); }
352           old_style_parm_decls
353                 { store_parm_decls (); }
354           compstmt_or_error
355                 { finish_function (0); 
356                   current_declspecs = TREE_VALUE (declspec_stack);
357                   prefix_attributes = TREE_PURPOSE (declspec_stack);
358                   declspec_stack = TREE_CHAIN (declspec_stack);
359                   resume_momentary ($2); }
360         | typed_declspecs setspecs declarator error
361                 { current_declspecs = TREE_VALUE (declspec_stack);
362                   prefix_attributes = TREE_PURPOSE (declspec_stack);
363                   declspec_stack = TREE_CHAIN (declspec_stack);
364                   resume_momentary ($2); }
365         | declmods setspecs notype_declarator
366                 { if (! start_function (current_declspecs, $3,
367                                         prefix_attributes, NULL_TREE, 0))
368                     YYERROR1;
369                   reinit_parse_for_function (); }
370           old_style_parm_decls
371                 { store_parm_decls (); }
372           compstmt_or_error
373                 { finish_function (0); 
374                   current_declspecs = TREE_VALUE (declspec_stack);
375                   prefix_attributes = TREE_PURPOSE (declspec_stack);
376                   declspec_stack = TREE_CHAIN (declspec_stack);
377                   resume_momentary ($2); }
378         | declmods setspecs notype_declarator error
379                 { current_declspecs = TREE_VALUE (declspec_stack);
380                   prefix_attributes = TREE_PURPOSE (declspec_stack);
381                   declspec_stack = TREE_CHAIN (declspec_stack);
382                   resume_momentary ($2); }
383         | setspecs notype_declarator
384                 { if (! start_function (NULL_TREE, $2,
385                                         prefix_attributes, NULL_TREE, 0))
386                     YYERROR1;
387                   reinit_parse_for_function (); }
388           old_style_parm_decls
389                 { store_parm_decls (); }
390           compstmt_or_error
391                 { finish_function (0); 
392                   current_declspecs = TREE_VALUE (declspec_stack);
393                   prefix_attributes = TREE_PURPOSE (declspec_stack);
394                   declspec_stack = TREE_CHAIN (declspec_stack);
395                   resume_momentary ($1); }
396         | setspecs notype_declarator error
397                 { current_declspecs = TREE_VALUE (declspec_stack);
398                   prefix_attributes = TREE_PURPOSE (declspec_stack);
399                   declspec_stack = TREE_CHAIN (declspec_stack);
400                   resume_momentary ($1); }
401         ;
403 identifier:
404         IDENTIFIER
405         | TYPENAME
406 ifobjc
407         | OBJECTNAME
408         | CLASSNAME
409 end ifobjc
410         ;
412 unop:     '&'
413                 { $$ = ADDR_EXPR; }
414         | '-'
415                 { $$ = NEGATE_EXPR; }
416         | '+'
417                 { $$ = CONVERT_EXPR; }
418         | PLUSPLUS
419                 { $$ = PREINCREMENT_EXPR; }
420         | MINUSMINUS
421                 { $$ = PREDECREMENT_EXPR; }
422         | '~'
423                 { $$ = BIT_NOT_EXPR; }
424         | '!'
425                 { $$ = TRUTH_NOT_EXPR; }
426         ;
428 expr:   nonnull_exprlist
429                 { $$ = build_compound_expr ($1); }
430         ;
432 exprlist:
433           /* empty */
434                 { $$ = NULL_TREE; }
435         | nonnull_exprlist
436         ;
438 nonnull_exprlist:
439         expr_no_commas
440                 { $$ = build_tree_list (NULL_TREE, $1); }
441         | nonnull_exprlist ',' expr_no_commas
442                 { chainon ($1, build_tree_list (NULL_TREE, $3)); }
443         ;
445 unary_expr:
446         primary
447         | '*' cast_expr   %prec UNARY
448                 { $$ = build_indirect_ref ($2, "unary *"); }
449         /* __extension__ turns off -pedantic for following primary.  */
450         | extension cast_expr     %prec UNARY
451                 { $$ = $2;
452                   RESTORE_WARN_FLAGS ($1); }
453         | unop cast_expr  %prec UNARY
454                 { $$ = build_unary_op ($1, $2, 0);
455                   overflow_warning ($$); }
456         /* Refer to the address of a label as a pointer.  */
457         | ANDAND identifier
458                 { tree label = lookup_label ($2);
459                   if (pedantic)
460                     pedwarn ("ANSI C forbids `&&'");
461                   if (label == 0)
462                     $$ = null_pointer_node;
463                   else
464                     {
465                       TREE_USED (label) = 1;
466                       $$ = build1 (ADDR_EXPR, ptr_type_node, label);
467                       TREE_CONSTANT ($$) = 1;
468                     }
469                 }
470 /* This seems to be impossible on some machines, so let's turn it off.
471    You can use __builtin_next_arg to find the anonymous stack args.
472         | '&' ELLIPSIS
473                 { tree types = TYPE_ARG_TYPES (TREE_TYPE (current_function_decl));
474                   $$ = error_mark_node;
475                   if (TREE_VALUE (tree_last (types)) == void_type_node)
476                     error ("`&...' used in function with fixed number of arguments");
477                   else
478                     {
479                       if (pedantic)
480                         pedwarn ("ANSI C forbids `&...'");
481                       $$ = tree_last (DECL_ARGUMENTS (current_function_decl));
482                       $$ = build_unary_op (ADDR_EXPR, $$, 0);
483                     } }
485         | sizeof unary_expr  %prec UNARY
486                 { skip_evaluation--;
487                   if (TREE_CODE ($2) == COMPONENT_REF
488                       && DECL_C_BIT_FIELD (TREE_OPERAND ($2, 1)))
489                     error ("`sizeof' applied to a bit-field");
490                   $$ = c_sizeof (TREE_TYPE ($2)); }
491         | sizeof '(' typename ')'  %prec HYPERUNARY
492                 { skip_evaluation--;
493                   $$ = c_sizeof (groktypename ($3)); }
494         | alignof unary_expr  %prec UNARY
495                 { skip_evaluation--;
496                   $$ = c_alignof_expr ($2); }
497         | alignof '(' typename ')'  %prec HYPERUNARY
498                 { skip_evaluation--;
499                   $$ = c_alignof (groktypename ($3)); }
500         | REALPART cast_expr %prec UNARY
501                 { $$ = build_unary_op (REALPART_EXPR, $2, 0); }
502         | IMAGPART cast_expr %prec UNARY
503                 { $$ = build_unary_op (IMAGPART_EXPR, $2, 0); }
504         | VA_ARG '(' expr_no_commas ',' typename ')'
505                 { $$ = build_va_arg ($3, groktypename ($5)); }
506         ;
508 sizeof:
509         SIZEOF { skip_evaluation++; }
510         ;
512 alignof:
513         ALIGNOF { skip_evaluation++; }
514         ;
516 cast_expr:
517         unary_expr
518         | '(' typename ')' cast_expr  %prec UNARY
519                 { tree type = groktypename ($2);
520                   $$ = build_c_cast (type, $4); }
521         | '(' typename ')' '{' 
522                 { start_init (NULL_TREE, NULL, 0);
523                   $2 = groktypename ($2);
524                   really_start_incremental_init ($2); }
525           initlist_maybe_comma '}'  %prec UNARY
526                 { const char *name;
527                   tree result = pop_init_level (0);
528                   tree type = $2;
529                   finish_init ();
531                   if (pedantic && ! flag_isoc9x)
532                     pedwarn ("ANSI C forbids constructor expressions");
533                   if (TYPE_NAME (type) != 0)
534                     {
535                       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
536                         name = IDENTIFIER_POINTER (TYPE_NAME (type));
537                       else
538                         name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
539                     }
540                   else
541                     name = "";
542                   $$ = result;
543                   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
544                     {
545                       int failure = complete_array_type (type, $$, 1);
546                       if (failure)
547                         abort ();
548                     }
549                 }
550         ;
552 expr_no_commas:
553           cast_expr
554         | expr_no_commas '+' expr_no_commas
555                 { $$ = parser_build_binary_op ($2, $1, $3); }
556         | expr_no_commas '-' expr_no_commas
557                 { $$ = parser_build_binary_op ($2, $1, $3); }
558         | expr_no_commas '*' expr_no_commas
559                 { $$ = parser_build_binary_op ($2, $1, $3); }
560         | expr_no_commas '/' expr_no_commas
561                 { $$ = parser_build_binary_op ($2, $1, $3); }
562         | expr_no_commas '%' expr_no_commas
563                 { $$ = parser_build_binary_op ($2, $1, $3); }
564         | expr_no_commas LSHIFT expr_no_commas
565                 { $$ = parser_build_binary_op ($2, $1, $3); }
566         | expr_no_commas RSHIFT expr_no_commas
567                 { $$ = parser_build_binary_op ($2, $1, $3); }
568         | expr_no_commas ARITHCOMPARE expr_no_commas
569                 { $$ = parser_build_binary_op ($2, $1, $3); }
570         | expr_no_commas EQCOMPARE expr_no_commas
571                 { $$ = parser_build_binary_op ($2, $1, $3); }
572         | expr_no_commas '&' expr_no_commas
573                 { $$ = parser_build_binary_op ($2, $1, $3); }
574         | expr_no_commas '|' expr_no_commas
575                 { $$ = parser_build_binary_op ($2, $1, $3); }
576         | expr_no_commas '^' expr_no_commas
577                 { $$ = parser_build_binary_op ($2, $1, $3); }
578         | expr_no_commas ANDAND
579                 { $1 = truthvalue_conversion (default_conversion ($1));
580                   skip_evaluation += $1 == boolean_false_node; }
581           expr_no_commas
582                 { skip_evaluation -= $1 == boolean_false_node;
583                   $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $4); }
584         | expr_no_commas OROR
585                 { $1 = truthvalue_conversion (default_conversion ($1));
586                   skip_evaluation += $1 == boolean_true_node; }
587           expr_no_commas
588                 { skip_evaluation -= $1 == boolean_true_node;
589                   $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $4); }
590         | expr_no_commas '?'
591                 { $1 = truthvalue_conversion (default_conversion ($1));
592                   skip_evaluation += $1 == boolean_false_node; }
593           expr ':'
594                 { skip_evaluation += (($1 == boolean_true_node)
595                                       - ($1 == boolean_false_node)); }
596           expr_no_commas
597                 { skip_evaluation -= $1 == boolean_true_node;
598                   $$ = build_conditional_expr ($1, $4, $7); }
599         | expr_no_commas '?'
600                 { if (pedantic)
601                     pedwarn ("ANSI C forbids omitting the middle term of a ?: expression");
602                   /* Make sure first operand is calculated only once.  */
603                   $<ttype>2 = save_expr ($1);
604                   $1 = truthvalue_conversion (default_conversion ($<ttype>2));
605                   skip_evaluation += $1 == boolean_true_node; }
606           ':' expr_no_commas
607                 { skip_evaluation -= $1 == boolean_true_node;
608                   $$ = build_conditional_expr ($1, $<ttype>2, $5); }
609         | expr_no_commas '=' expr_no_commas
610                 { char class;
611                   $$ = build_modify_expr ($1, NOP_EXPR, $3);
612                   class = TREE_CODE_CLASS (TREE_CODE ($$));
613                   if (class == 'e' || class == '1'
614                       || class == '2' || class == '<')
615                     C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR);
616                 }
617         | expr_no_commas ASSIGN expr_no_commas
618                 { char class;
619                   $$ = build_modify_expr ($1, $2, $3);
620                   /* This inhibits warnings in truthvalue_conversion.  */
621                   class = TREE_CODE_CLASS (TREE_CODE ($$));
622                   if (class == 'e' || class == '1'
623                       || class == '2' || class == '<')
624                     C_SET_EXP_ORIGINAL_CODE ($$, ERROR_MARK);
625                 }
626         ;
628 primary:
629         IDENTIFIER
630                 {
631                   $$ = lastiddecl;
632                   if (!$$ || $$ == error_mark_node)
633                     {
634                       if (yychar == YYEMPTY)
635                         yychar = YYLEX;
636                       if (yychar == '(')
637                         {
638 ifobjc
639                           tree decl;
641                           if (objc_receiver_context
642                               && ! (objc_receiver_context
643                                     && strcmp (IDENTIFIER_POINTER ($1), "super")))
644                             /* we have a message to super */
645                             $$ = get_super_receiver ();
646                           else if (objc_method_context
647                                    && (decl = is_ivar (objc_ivar_chain, $1)))
648                             {
649                               if (is_private (decl))
650                                 $$ = error_mark_node;
651                               else
652                                 $$ = build_ivar_reference ($1);
653                             }
654                           else
655 end ifobjc
656                             {
657                               /* Ordinary implicit function declaration.  */
658                               $$ = implicitly_declare ($1);
659                               assemble_external ($$);
660                               TREE_USED ($$) = 1;
661                             }
662                         }
663                       else if (current_function_decl == 0)
664                         {
665                           error ("`%s' undeclared here (not in a function)",
666                                  IDENTIFIER_POINTER ($1));
667                           $$ = error_mark_node;
668                         }
669                       else
670                         {
671 ifobjc
672                           tree decl;
674                           if (objc_receiver_context
675                               && ! strcmp (IDENTIFIER_POINTER ($1), "super"))
676                             /* we have a message to super */
677                             $$ = get_super_receiver ();
678                           else if (objc_method_context
679                                    && (decl = is_ivar (objc_ivar_chain, $1)))
680                             {
681                               if (is_private (decl))
682                                 $$ = error_mark_node;
683                               else
684                                 $$ = build_ivar_reference ($1);
685                             }
686                           else
687 end ifobjc
688                             {
689                               if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node
690                                   || IDENTIFIER_ERROR_LOCUS ($1) != current_function_decl)
691                                 {
692                                   error ("`%s' undeclared (first use in this function)",
693                                          IDENTIFIER_POINTER ($1));
695                                   if (! undeclared_variable_notice)
696                                     {
697                                       error ("(Each undeclared identifier is reported only once");
698                                       error ("for each function it appears in.)");
699                                       undeclared_variable_notice = 1;
700                                     }
701                                 }
702                               $$ = error_mark_node;
703                               /* Prevent repeated error messages.  */
704                               IDENTIFIER_GLOBAL_VALUE ($1) = error_mark_node;
705                               IDENTIFIER_ERROR_LOCUS ($1) = current_function_decl;
706                             }
707                         }
708                     }
709                   else if (TREE_TYPE ($$) == error_mark_node)
710                     $$ = error_mark_node;
711                   else if (C_DECL_ANTICIPATED ($$))
712                     {
713                       /* The first time we see a build-in function used,
714                          if it has not been declared.  */
715                       C_DECL_ANTICIPATED ($$) = 0;
716                       if (yychar == YYEMPTY)
717                         yychar = YYLEX;
718                       if (yychar == '(')
719                         {
720                           /* Omit the implicit declaration we
721                              would ordinarily do, so we don't lose
722                              the actual built in type.
723                              But print a diagnostic for the mismatch.  */
724 ifobjc
725                           if (objc_method_context
726                               && is_ivar (objc_ivar_chain, $1))
727                             error ("Instance variable `%s' implicitly declared as function",
728                                    IDENTIFIER_POINTER (DECL_NAME ($$)));
729                           else
730 end ifobjc
731                             if (TREE_CODE ($$) != FUNCTION_DECL)
732                               error ("`%s' implicitly declared as function",
733                                      IDENTIFIER_POINTER (DECL_NAME ($$)));
734                           else if ((TYPE_MODE (TREE_TYPE (TREE_TYPE ($$)))
735                                     != TYPE_MODE (integer_type_node))
736                                    && (TREE_TYPE (TREE_TYPE ($$))
737                                        != void_type_node))
738                             pedwarn ("type mismatch in implicit declaration for built-in function `%s'",
739                                      IDENTIFIER_POINTER (DECL_NAME ($$)));
740                           /* If it really returns void, change that to int.  */
741                           if (TREE_TYPE (TREE_TYPE ($$)) == void_type_node)
742                             TREE_TYPE ($$)
743                               = build_function_type (integer_type_node,
744                                                      TYPE_ARG_TYPES (TREE_TYPE ($$)));
745                         }
746                       else
747                         pedwarn ("built-in function `%s' used without declaration",
748                                  IDENTIFIER_POINTER (DECL_NAME ($$)));
750                       /* Do what we would ordinarily do when a fn is used.  */
751                       assemble_external ($$);
752                       TREE_USED ($$) = 1;
753                     }
754                   else
755                     {
756                       assemble_external ($$);
757                       TREE_USED ($$) = 1;
758 ifobjc
759                       /* we have a definition - still check if iVariable */
761                       if (!objc_receiver_context
762                           || (objc_receiver_context
763                               && strcmp (IDENTIFIER_POINTER ($1), "super")))
764                         {
765                           tree decl;
767                           if (objc_method_context
768                               && (decl = is_ivar (objc_ivar_chain, $1)))
769                             {
770                               if (IDENTIFIER_LOCAL_VALUE ($1))
771                                 warning ("local declaration of `%s' hides instance variable",
772                                          IDENTIFIER_POINTER ($1));
773                               else
774                                 {
775                                   if (is_private (decl))
776                                     $$ = error_mark_node;
777                                   else
778                                     $$ = build_ivar_reference ($1);
779                                 }
780                             }
781                         }
782                       else /* we have a message to super */
783                         $$ = get_super_receiver ();
784 end ifobjc
785                     }
787                   if (TREE_CODE ($$) == CONST_DECL)
788                     {
789                       $$ = DECL_INITIAL ($$);
790                       /* This is to prevent an enum whose value is 0
791                          from being considered a null pointer constant.  */
792                       $$ = build1 (NOP_EXPR, TREE_TYPE ($$), $$);
793                       TREE_CONSTANT ($$) = 1;
794                     }
795                 }
796         | CONSTANT
797         | string
798                 { $$ = combine_strings ($1); }
799         | '(' expr ')'
800                 { char class = TREE_CODE_CLASS (TREE_CODE ($2));
801                   if (class == 'e' || class == '1'
802                       || class == '2' || class == '<')
803                     C_SET_EXP_ORIGINAL_CODE ($2, ERROR_MARK);
804                   $$ = $2; }
805         | '(' error ')'
806                 { $$ = error_mark_node; }
807         | compstmt_primary_start compstmt_nostart ')'
808                 { tree rtl_exp;
809                   if (pedantic)
810                     pedwarn ("ANSI C forbids braced-groups within expressions");
811                   pop_iterator_stack ();
812                   pop_label_level ();
813                   rtl_exp = expand_end_stmt_expr ($1);
814                   /* The statements have side effects, so the group does.  */
815                   TREE_SIDE_EFFECTS (rtl_exp) = 1;
817                   if (TREE_CODE ($2) == BLOCK)
818                     {
819                       /* Make a BIND_EXPR for the BLOCK already made.  */
820                       $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp),
821                                   NULL_TREE, rtl_exp, $2);
822                       /* Remove the block from the tree at this point.
823                          It gets put back at the proper place
824                          when the BIND_EXPR is expanded.  */
825                       delete_block ($2);
826                     }
827                   else
828                     $$ = $2;
829                 }
830         | compstmt_primary_start error ')'
831                 {
832                   /* Make sure we call expand_end_stmt_expr.  Otherwise
833                      we are likely to lose sequences and crash later.  */
834                   pop_iterator_stack ();
835                   pop_label_level ();
836                   expand_end_stmt_expr ($1);
837                   $$ = error_mark_node;
838                 }
839         | primary '(' exprlist ')'   %prec '.'
840                 { $$ = build_function_call ($1, $3); }
841         | primary '[' expr ']'   %prec '.'
842                 { $$ = build_array_ref ($1, $3); }
843         | primary '.' identifier
844                 {
845 ifobjc
846                   if (doing_objc_thang)
847                     {
848                       if (is_public ($1, $3))
849                         $$ = build_component_ref ($1, $3);
850                       else
851                         $$ = error_mark_node;
852                     }
853                   else
854 end ifobjc
855                     $$ = build_component_ref ($1, $3);
856                 }
857         | primary POINTSAT identifier
858                 {
859                   tree expr = build_indirect_ref ($1, "->");
861 ifobjc
862                   if (doing_objc_thang)
863                     {
864                       if (is_public (expr, $3))
865                         $$ = build_component_ref (expr, $3);
866                       else
867                         $$ = error_mark_node;
868                     }
869                   else
870 end ifobjc
871                     $$ = build_component_ref (expr, $3);
872                 }
873         | primary PLUSPLUS
874                 { $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); }
875         | primary MINUSMINUS
876                 { $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); }
877 ifobjc
878         | objcmessageexpr
879                 { $$ = build_message_expr ($1); }
880         | objcselectorexpr
881                 { $$ = build_selector_expr ($1); }
882         | objcprotocolexpr
883                 { $$ = build_protocol_expr ($1); }
884         | objcencodeexpr
885                 { $$ = build_encode_expr ($1); }
886         | objc_string
887                 { $$ = build_objc_string_object ($1); }
888 end ifobjc
889         ;
891 /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it.  */
892 string:
893           STRING
894         | string STRING
895                 { $$ = chainon ($1, $2); }
896         ;
898 ifobjc
899 /* Produces an OBJC_STRING_CST with perhaps more OBJC_STRING_CSTs chained
900    onto it.  */
901 objc_string:
902           OBJC_STRING
903         | objc_string OBJC_STRING
904                 { $$ = chainon ($1, $2); }
905         ;
906 end ifobjc
908 old_style_parm_decls:
909         /* empty */
910         | datadecls
911         | datadecls ELLIPSIS
912                 /* ... is used here to indicate a varargs function.  */
913                 { c_mark_varargs ();
914                   if (pedantic)
915                     pedwarn ("ANSI C does not permit use of `varargs.h'"); }
916         ;
918 /* The following are analogous to lineno_decl, decls and decl
919    except that they do not allow nested functions.
920    They are used for old-style parm decls.  */
921 lineno_datadecl:
922           save_filename save_lineno datadecl
923                 { }
924         ;
926 datadecls:
927         lineno_datadecl
928         | errstmt
929         | datadecls lineno_datadecl
930         | lineno_datadecl errstmt
931         ;
933 /* We don't allow prefix attributes here because they cause reduce/reduce
934    conflicts: we can't know whether we're parsing a function decl with
935    attribute suffix, or function defn with attribute prefix on first old
936    style parm.  */
937 datadecl:
938         typed_declspecs_no_prefix_attr setspecs initdecls ';'
939                 { current_declspecs = TREE_VALUE (declspec_stack);
940                   prefix_attributes = TREE_PURPOSE (declspec_stack);
941                   declspec_stack = TREE_CHAIN (declspec_stack);
942                   resume_momentary ($2); }
943         | declmods_no_prefix_attr setspecs notype_initdecls ';'
944                 { current_declspecs = TREE_VALUE (declspec_stack);      
945                   prefix_attributes = TREE_PURPOSE (declspec_stack);
946                   declspec_stack = TREE_CHAIN (declspec_stack);
947                   resume_momentary ($2); }
948         | typed_declspecs_no_prefix_attr ';'
949                 { shadow_tag_warned ($1, 1);
950                   pedwarn ("empty declaration"); }
951         | declmods_no_prefix_attr ';'
952                 { pedwarn ("empty declaration"); }
953         ;
955 /* This combination which saves a lineno before a decl
956    is the normal thing to use, rather than decl itself.
957    This is to avoid shift/reduce conflicts in contexts
958    where statement labels are allowed.  */
959 lineno_decl:
960           save_filename save_lineno decl
961                 { }
962         ;
964 decls:
965         lineno_decl
966         | errstmt
967         | decls lineno_decl
968         | lineno_decl errstmt
969         ;
971 /* records the type and storage class specs to use for processing
972    the declarators that follow.
973    Maintains a stack of outer-level values of current_declspecs,
974    for the sake of parm declarations nested in function declarators.  */
975 setspecs: /* empty */
976                 { $$ = suspend_momentary ();
977                   pending_xref_error ();
978                   declspec_stack = tree_cons (prefix_attributes,
979                                               current_declspecs,
980                                               declspec_stack);
981                   split_specs_attrs ($<ttype>0,
982                                      &current_declspecs, &prefix_attributes); }
983         ;
985 /* ??? Yuck.  See after_type_declarator.  */
986 setattrs: /* empty */
987                 { prefix_attributes = chainon (prefix_attributes, $<ttype>0); }
988         ;
990 decl:
991         typed_declspecs setspecs initdecls ';'
992                 { current_declspecs = TREE_VALUE (declspec_stack);
993                   prefix_attributes = TREE_PURPOSE (declspec_stack);
994                   declspec_stack = TREE_CHAIN (declspec_stack);
995                   resume_momentary ($2); }
996         | declmods setspecs notype_initdecls ';'
997                 { current_declspecs = TREE_VALUE (declspec_stack);
998                   prefix_attributes = TREE_PURPOSE (declspec_stack);
999                   declspec_stack = TREE_CHAIN (declspec_stack);
1000                   resume_momentary ($2); }
1001         | typed_declspecs setspecs nested_function
1002                 { current_declspecs = TREE_VALUE (declspec_stack);
1003                   prefix_attributes = TREE_PURPOSE (declspec_stack);
1004                   declspec_stack = TREE_CHAIN (declspec_stack);
1005                   resume_momentary ($2); }
1006         | declmods setspecs notype_nested_function
1007                 { current_declspecs = TREE_VALUE (declspec_stack);
1008                   prefix_attributes = TREE_PURPOSE (declspec_stack);
1009                   declspec_stack = TREE_CHAIN (declspec_stack);
1010                   resume_momentary ($2); }
1011         | typed_declspecs ';'
1012                 { shadow_tag ($1); }
1013         | declmods ';'
1014                 { pedwarn ("empty declaration"); }
1015         | extension decl
1016                 { RESTORE_WARN_FLAGS ($1); }
1017         ;
1019 /* Declspecs which contain at least one type specifier or typedef name.
1020    (Just `const' or `volatile' is not enough.)
1021    A typedef'd name following these is taken as a name to be declared.
1022    Declspecs have a non-NULL TREE_VALUE, attributes do not.  */
1024 typed_declspecs:
1025           typespec reserved_declspecs
1026                 { $$ = tree_cons (NULL_TREE, $1, $2); }
1027         | declmods typespec reserved_declspecs
1028                 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
1029         ;
1031 reserved_declspecs:  /* empty */
1032                 { $$ = NULL_TREE; }
1033         | reserved_declspecs typespecqual_reserved
1034                 { $$ = tree_cons (NULL_TREE, $2, $1); }
1035         | reserved_declspecs SCSPEC
1036                 { if (extra_warnings)
1037                     warning ("`%s' is not at beginning of declaration",
1038                              IDENTIFIER_POINTER ($2));
1039                   $$ = tree_cons (NULL_TREE, $2, $1); }
1040         | reserved_declspecs attributes
1041                 { $$ = tree_cons ($2, NULL_TREE, $1); }
1042         ;
1044 typed_declspecs_no_prefix_attr:
1045           typespec reserved_declspecs_no_prefix_attr
1046                 { $$ = tree_cons (NULL_TREE, $1, $2); }
1047         | declmods_no_prefix_attr typespec reserved_declspecs_no_prefix_attr
1048                 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
1049         ;
1051 reserved_declspecs_no_prefix_attr:
1052           /* empty */
1053                 { $$ = NULL_TREE; }
1054         | reserved_declspecs_no_prefix_attr typespecqual_reserved
1055                 { $$ = tree_cons (NULL_TREE, $2, $1); }
1056         | reserved_declspecs_no_prefix_attr SCSPEC
1057                 { if (extra_warnings)
1058                     warning ("`%s' is not at beginning of declaration",
1059                              IDENTIFIER_POINTER ($2));
1060                   $$ = tree_cons (NULL_TREE, $2, $1); }
1061         ;
1063 /* List of just storage classes, type modifiers, and prefix attributes.
1064    A declaration can start with just this, but then it cannot be used
1065    to redeclare a typedef-name.
1066    Declspecs have a non-NULL TREE_VALUE, attributes do not.  */
1068 declmods:
1069           declmods_no_prefix_attr
1070                 { $$ = $1; }
1071         | attributes
1072                 { $$ = tree_cons ($1, NULL_TREE, NULL_TREE); }
1073         | declmods declmods_no_prefix_attr
1074                 { $$ = chainon ($2, $1); }
1075         | declmods attributes
1076                 { $$ = tree_cons ($2, NULL_TREE, $1); }
1077         ;
1079 declmods_no_prefix_attr:
1080           TYPE_QUAL
1081                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
1082                   TREE_STATIC ($$) = 1; }
1083         | SCSPEC
1084                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
1085         | declmods_no_prefix_attr TYPE_QUAL
1086                 { $$ = tree_cons (NULL_TREE, $2, $1);
1087                   TREE_STATIC ($$) = 1; }
1088         | declmods_no_prefix_attr SCSPEC
1089                 { if (extra_warnings && TREE_STATIC ($1))
1090                     warning ("`%s' is not at beginning of declaration",
1091                              IDENTIFIER_POINTER ($2));
1092                   $$ = tree_cons (NULL_TREE, $2, $1);
1093                   TREE_STATIC ($$) = TREE_STATIC ($1); }
1094         ;
1097 /* Used instead of declspecs where storage classes are not allowed
1098    (that is, for typenames and structure components).
1099    Don't accept a typedef-name if anything but a modifier precedes it.  */
1101 typed_typespecs:
1102           typespec reserved_typespecquals
1103                 { $$ = tree_cons (NULL_TREE, $1, $2); }
1104         | nonempty_type_quals typespec reserved_typespecquals
1105                 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
1106         ;
1108 reserved_typespecquals:  /* empty */
1109                 { $$ = NULL_TREE; }
1110         | reserved_typespecquals typespecqual_reserved
1111                 { $$ = tree_cons (NULL_TREE, $2, $1); }
1112         ;
1114 /* A typespec (but not a type qualifier).
1115    Once we have seen one of these in a declaration,
1116    if a typedef name appears then it is being redeclared.  */
1118 typespec: TYPESPEC
1119         | structsp
1120         | TYPENAME
1121                 { /* For a typedef name, record the meaning, not the name.
1122                      In case of `foo foo, bar;'.  */
1123                   $$ = lookup_name ($1); }
1124 ifobjc
1125         | CLASSNAME protocolrefs
1126                 { $$ = get_static_reference ($1, $2); }
1127         | OBJECTNAME protocolrefs
1128                 { $$ = get_object_reference ($2); }
1130 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>"
1131    - nisse@lysator.liu.se */
1132         | non_empty_protocolrefs
1133                 { $$ = get_object_reference ($1); }
1134 end ifobjc
1135         | TYPEOF '(' expr ')'
1136                 { $$ = TREE_TYPE ($3); }
1137         | TYPEOF '(' typename ')'
1138                 { $$ = groktypename ($3); }
1139         ;
1141 /* A typespec that is a reserved word, or a type qualifier.  */
1143 typespecqual_reserved: TYPESPEC
1144         | TYPE_QUAL
1145         | structsp
1146         ;
1148 initdecls:
1149         initdcl
1150         | initdecls ',' initdcl
1151         ;
1153 notype_initdecls:
1154         notype_initdcl
1155         | notype_initdecls ',' initdcl
1156         ;
1158 maybeasm:
1159           /* empty */
1160                 { $$ = NULL_TREE; }
1161         | ASM_KEYWORD '(' string ')'
1162                 { if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
1163                   $$ = $3;
1164                 }
1165         ;
1167 initdcl:
1168           declarator maybeasm maybe_attribute '='
1169                 { $<ttype>$ = start_decl ($1, current_declspecs, 1,
1170                                           $3, prefix_attributes);
1171                   start_init ($<ttype>$, $2, global_bindings_p ()); }
1172           init
1173 /* Note how the declaration of the variable is in effect while its init is parsed! */
1174                 { finish_init ();
1175                   finish_decl ($<ttype>5, $6, $2); }
1176         | declarator maybeasm maybe_attribute
1177                 { tree d = start_decl ($1, current_declspecs, 0,
1178                                        $3, prefix_attributes);
1179                   finish_decl (d, NULL_TREE, $2); 
1180                 }
1181         ;
1183 notype_initdcl:
1184           notype_declarator maybeasm maybe_attribute '='
1185                 { $<ttype>$ = start_decl ($1, current_declspecs, 1,
1186                                           $3, prefix_attributes);
1187                   start_init ($<ttype>$, $2, global_bindings_p ()); }
1188           init
1189 /* Note how the declaration of the variable is in effect while its init is parsed! */
1190                 { finish_init ();
1191                   decl_attributes ($<ttype>5, $3, prefix_attributes);
1192                   finish_decl ($<ttype>5, $6, $2); }
1193         | notype_declarator maybeasm maybe_attribute
1194                 { tree d = start_decl ($1, current_declspecs, 0,
1195                                        $3, prefix_attributes);
1196                   finish_decl (d, NULL_TREE, $2); }
1197         ;
1198 /* the * rules are dummies to accept the Apollo extended syntax
1199    so that the header files compile. */
1200 maybe_attribute:
1201       /* empty */
1202                 { $$ = NULL_TREE; }
1203         | attributes
1204                 { $$ = $1; }
1205         ;
1207 attributes:
1208       attribute
1209                 { $$ = $1; }
1210         | attributes attribute
1211                 { $$ = chainon ($1, $2); }
1212         ;
1214 attribute:
1215       ATTRIBUTE '(' '(' attribute_list ')' ')'
1216                 { $$ = $4; }
1217         ;
1219 attribute_list:
1220       attrib
1221                 { $$ = $1; }
1222         | attribute_list ',' attrib
1223                 { $$ = chainon ($1, $3); }
1224         ;
1226 attrib:
1227     /* empty */
1228                 { $$ = NULL_TREE; }
1229         | any_word
1230                 { $$ = build_tree_list ($1, NULL_TREE); }
1231         | any_word '(' IDENTIFIER ')'
1232                 { $$ = build_tree_list ($1, build_tree_list (NULL_TREE, $3)); }
1233         | any_word '(' IDENTIFIER ',' nonnull_exprlist ')'
1234                 { $$ = build_tree_list ($1, tree_cons (NULL_TREE, $3, $5)); }
1235         | any_word '(' exprlist ')'
1236                 { $$ = build_tree_list ($1, $3); }
1237         ;
1239 /* This still leaves out most reserved keywords,
1240    shouldn't we include them?  */
1242 any_word:
1243           identifier
1244         | SCSPEC
1245         | TYPESPEC
1246         | TYPE_QUAL
1247         ;
1249 /* Initializers.  `init' is the entry point.  */
1251 init:
1252         expr_no_commas
1253         | '{'
1254                 { really_start_incremental_init (NULL_TREE);
1255                   /* Note that the call to clear_momentary
1256                      is in process_init_element.  */
1257                   push_momentary (); }
1258           initlist_maybe_comma '}'
1259                 { $$ = pop_init_level (0);
1260                   if ($$ == error_mark_node
1261                       && ! (yychar == STRING || yychar == CONSTANT))
1262                     pop_momentary ();
1263                   else
1264                     pop_momentary_nofree (); }
1266         | error
1267                 { $$ = error_mark_node; }
1268         ;
1270 /* `initlist_maybe_comma' is the guts of an initializer in braces.  */
1271 initlist_maybe_comma:
1272           /* empty */
1273                 { if (pedantic)
1274                     pedwarn ("ANSI C forbids empty initializer braces"); }
1275         | initlist1 maybecomma
1276         ;
1278 initlist1:
1279           initelt
1280         | initlist1 ',' initelt
1281         ;
1283 /* `initelt' is a single element of an initializer.
1284    It may use braces.  */
1285 initelt:
1286           designator_list '=' initval
1287         | designator initval
1288         | identifier ':'
1289                 { set_init_label ($1); }
1290           initval
1291         | initval
1292         ;
1294 initval:
1295           '{'
1296                 { push_init_level (0); }
1297           initlist_maybe_comma '}'
1298                 { process_init_element (pop_init_level (0)); }
1299         | expr_no_commas
1300                 { process_init_element ($1); }
1301         | error
1302         ;
1304 designator_list:
1305           designator
1306         | designator_list designator
1307         ;
1309 designator:
1310           '.' identifier
1311                 { set_init_label ($2); }
1312         /* These are for labeled elements.  The syntax for an array element
1313            initializer conflicts with the syntax for an Objective-C message,
1314            so don't include these productions in the Objective-C grammar.  */
1316         | '[' expr_no_commas ELLIPSIS expr_no_commas ']'
1317                 { set_init_index ($2, $4); }
1318         | '[' expr_no_commas ']'
1319                 { set_init_index ($2, NULL_TREE); }
1320 end ifc
1321         ;
1323 nested_function:
1324           declarator
1325                 { if (pedantic)
1326                     pedwarn ("ANSI C forbids nested functions");
1328                   push_function_context ();
1329                   if (! start_function (current_declspecs, $1,
1330                                         prefix_attributes, NULL_TREE, 1))
1331                     {
1332                       pop_function_context ();
1333                       YYERROR1;
1334                     }
1335                   reinit_parse_for_function (); }
1336            old_style_parm_decls
1337                 { store_parm_decls (); }
1338 /* This used to use compstmt_or_error.
1339    That caused a bug with input `f(g) int g {}',
1340    where the use of YYERROR1 above caused an error
1341    which then was handled by compstmt_or_error.
1342    There followed a repeated execution of that same rule,
1343    which called YYERROR1 again, and so on.  */
1344           compstmt
1345                 { finish_function (1);
1346                   pop_function_context (); }
1347         ;
1349 notype_nested_function:
1350           notype_declarator
1351                 { if (pedantic)
1352                     pedwarn ("ANSI C forbids nested functions");
1354                   push_function_context ();
1355                   if (! start_function (current_declspecs, $1,
1356                                         prefix_attributes, NULL_TREE, 1))
1357                     {
1358                       pop_function_context ();
1359                       YYERROR1;
1360                     }
1361                   reinit_parse_for_function (); }
1362           old_style_parm_decls
1363                 { store_parm_decls (); }
1364 /* This used to use compstmt_or_error.
1365    That caused a bug with input `f(g) int g {}',
1366    where the use of YYERROR1 above caused an error
1367    which then was handled by compstmt_or_error.
1368    There followed a repeated execution of that same rule,
1369    which called YYERROR1 again, and so on.  */
1370           compstmt
1371                 { finish_function (1);
1372                   pop_function_context (); }
1373         ;
1375 /* Any kind of declarator (thus, all declarators allowed
1376    after an explicit typespec).  */
1378 declarator:
1379           after_type_declarator
1380         | notype_declarator
1381         ;
1383 /* A declarator that is allowed only after an explicit typespec.  */
1385 after_type_declarator:
1386           '(' after_type_declarator ')'
1387                 { $$ = $2; }
1388         | after_type_declarator '(' parmlist_or_identifiers  %prec '.'
1389                 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1390 /*      | after_type_declarator '(' error ')'  %prec '.'
1391                 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1392                   poplevel (0, 0, 0); }  */
1393         | after_type_declarator '[' expr ']'  %prec '.'
1394                 { $$ = build_nt (ARRAY_REF, $1, $3); }
1395         | after_type_declarator '[' ']'  %prec '.'
1396                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1397         | '*' type_quals after_type_declarator  %prec UNARY
1398                 { $$ = make_pointer_declarator ($2, $3); }
1399         /* ??? Yuck.  setattrs is a quick hack.  We can't use
1400            prefix_attributes because $1 only applies to this
1401            declarator.  We assume setspecs has already been done.
1402            setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1403            attributes could be recognized here or in `attributes').  */
1404         | attributes setattrs after_type_declarator
1405                 { $$ = $3; }
1406         | TYPENAME
1407 ifobjc
1408         | OBJECTNAME
1409 end ifobjc
1410         ;
1412 /* Kinds of declarator that can appear in a parameter list
1413    in addition to notype_declarator.  This is like after_type_declarator
1414    but does not allow a typedef name in parentheses as an identifier
1415    (because it would conflict with a function with that typedef as arg).  */
1417 parm_declarator:
1418           parm_declarator '(' parmlist_or_identifiers  %prec '.'
1419                 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1420 /*      | parm_declarator '(' error ')'  %prec '.'
1421                 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1422                   poplevel (0, 0, 0); }  */
1424         | parm_declarator '[' '*' ']'  %prec '.'
1425                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE);
1426                   if (! flag_isoc9x)
1427                     error ("`[*]' in parameter declaration only allowed in ISO C 9x");
1428                 }
1429 end ifc
1430         | parm_declarator '[' expr ']'  %prec '.'
1431                 { $$ = build_nt (ARRAY_REF, $1, $3); }
1432         | parm_declarator '[' ']'  %prec '.'
1433                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1434         | '*' type_quals parm_declarator  %prec UNARY
1435                 { $$ = make_pointer_declarator ($2, $3); }
1436         /* ??? Yuck.  setattrs is a quick hack.  We can't use
1437            prefix_attributes because $1 only applies to this
1438            declarator.  We assume setspecs has already been done.
1439            setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1440            attributes could be recognized here or in `attributes').  */
1441         | attributes setattrs parm_declarator
1442                 { $$ = $3; }
1443         | TYPENAME
1444         ;
1446 /* A declarator allowed whether or not there has been
1447    an explicit typespec.  These cannot redeclare a typedef-name.  */
1449 notype_declarator:
1450           notype_declarator '(' parmlist_or_identifiers  %prec '.'
1451                 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1452 /*      | notype_declarator '(' error ')'  %prec '.'
1453                 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1454                   poplevel (0, 0, 0); }  */
1455         | '(' notype_declarator ')'
1456                 { $$ = $2; }
1457         | '*' type_quals notype_declarator  %prec UNARY
1458                 { $$ = make_pointer_declarator ($2, $3); }
1460         | notype_declarator '[' '*' ']'  %prec '.'
1461                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE);
1462                   if (! flag_isoc9x)
1463                     error ("`[*]' in parameter declaration only allowed in ISO C 9x");
1464                 }
1465 end ifc
1466         | notype_declarator '[' expr ']'  %prec '.'
1467                 { $$ = build_nt (ARRAY_REF, $1, $3); }
1468         | notype_declarator '[' ']'  %prec '.'
1469                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1470         /* ??? Yuck.  setattrs is a quick hack.  We can't use
1471            prefix_attributes because $1 only applies to this
1472            declarator.  We assume setspecs has already been done.
1473            setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1474            attributes could be recognized here or in `attributes').  */
1475         | attributes setattrs notype_declarator
1476                 { $$ = $3; }
1477         | IDENTIFIER
1478         ;
1480 struct_head:
1481           STRUCT
1482                 { $$ = NULL_TREE; }
1483         | STRUCT attributes
1484                 { $$ = $2; }
1485         ;
1487 union_head:
1488           UNION
1489                 { $$ = NULL_TREE; }
1490         | UNION attributes
1491                 { $$ = $2; }
1492         ;
1494 enum_head:
1495           ENUM
1496                 { $$ = NULL_TREE; }
1497         | ENUM attributes
1498                 { $$ = $2; }
1499         ;
1501 structsp:
1502           struct_head identifier '{'
1503                 { $$ = start_struct (RECORD_TYPE, $2);
1504                   /* Start scope of tag before parsing components.  */
1505                 }
1506           component_decl_list '}' maybe_attribute 
1507                 { $$ = finish_struct ($<ttype>4, $5, chainon ($1, $7)); }
1508         | struct_head '{' component_decl_list '}' maybe_attribute
1509                 { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
1510                                       $3, chainon ($1, $5));
1511                 }
1512         | struct_head identifier
1513                 { $$ = xref_tag (RECORD_TYPE, $2); }
1514         | union_head identifier '{'
1515                 { $$ = start_struct (UNION_TYPE, $2); }
1516           component_decl_list '}' maybe_attribute
1517                 { $$ = finish_struct ($<ttype>4, $5, chainon ($1, $7)); }
1518         | union_head '{' component_decl_list '}' maybe_attribute
1519                 { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
1520                                       $3, chainon ($1, $5));
1521                 }
1522         | union_head identifier
1523                 { $$ = xref_tag (UNION_TYPE, $2); }
1524         | enum_head identifier '{'
1525                 { $<itype>3 = suspend_momentary ();
1526                   $$ = start_enum ($2); }
1527           enumlist maybecomma_warn '}' maybe_attribute
1528                 { $$= finish_enum ($<ttype>4, nreverse ($5), chainon ($1, $8));
1529                   resume_momentary ($<itype>3); }
1530         | enum_head '{'
1531                 { $<itype>2 = suspend_momentary ();
1532                   $$ = start_enum (NULL_TREE); }
1533           enumlist maybecomma_warn '}' maybe_attribute
1534                 { $$= finish_enum ($<ttype>3, nreverse ($4), chainon ($1, $7));
1535                   resume_momentary ($<itype>2); }
1536         | enum_head identifier
1537                 { $$ = xref_tag (ENUMERAL_TYPE, $2); }
1538         ;
1540 maybecomma:
1541           /* empty */
1542         | ','
1543         ;
1545 maybecomma_warn:
1546           /* empty */
1547         | ','
1548                 { if (pedantic && ! flag_isoc9x)
1549                     pedwarn ("comma at end of enumerator list"); }
1550         ;
1552 component_decl_list:
1553           component_decl_list2
1554                 { $$ = $1; }
1555         | component_decl_list2 component_decl
1556                 { $$ = chainon ($1, $2);
1557                   pedwarn ("no semicolon at end of struct or union"); }
1558         ;
1560 component_decl_list2:   /* empty */
1561                 { $$ = NULL_TREE; }
1562         | component_decl_list2 component_decl ';'
1563                 { $$ = chainon ($1, $2); }
1564         | component_decl_list2 ';'
1565                 { if (pedantic)
1566                     pedwarn ("extra semicolon in struct or union specified"); }
1567 ifobjc
1568         /* foo(sizeof(struct{ @defs(ClassName)})); */
1569         | DEFS '(' CLASSNAME ')'
1570                 {
1571                   tree interface = lookup_interface ($3);
1573                   if (interface)
1574                     $$ = get_class_ivars (interface);
1575                   else
1576                     {
1577                       error ("Cannot find interface declaration for `%s'",
1578                              IDENTIFIER_POINTER ($3));
1579                       $$ = NULL_TREE;
1580                     }
1581                 }
1582 end ifobjc
1583         ;
1585 /* There is a shift-reduce conflict here, because `components' may
1586    start with a `typename'.  It happens that shifting (the default resolution)
1587    does the right thing, because it treats the `typename' as part of
1588    a `typed_typespecs'.
1590    It is possible that this same technique would allow the distinction
1591    between `notype_initdecls' and `initdecls' to be eliminated.
1592    But I am being cautious and not trying it.  */
1594 component_decl:
1595           typed_typespecs setspecs components
1596                 { $$ = $3;
1597                   current_declspecs = TREE_VALUE (declspec_stack);
1598                   prefix_attributes = TREE_PURPOSE (declspec_stack);
1599                   declspec_stack = TREE_CHAIN (declspec_stack);
1600                   resume_momentary ($2); }
1601         | typed_typespecs setspecs save_filename save_lineno maybe_attribute
1602                 {
1603                   /* Support for unnamed structs or unions as members of 
1604                      structs or unions (which is [a] useful and [b] supports 
1605                      MS P-SDK).  */
1606                   if (pedantic)
1607                     pedwarn ("ANSI C doesn't support unnamed structs/unions");
1609                   $$ = grokfield($3, $4, NULL, current_declspecs, NULL_TREE);
1610                   current_declspecs = TREE_VALUE (declspec_stack);
1611                   prefix_attributes = TREE_PURPOSE (declspec_stack);
1612                   declspec_stack = TREE_CHAIN (declspec_stack);
1613                   resume_momentary ($2);
1614                 }
1615     | nonempty_type_quals setspecs components
1616                 { $$ = $3;
1617                   current_declspecs = TREE_VALUE (declspec_stack);
1618                   prefix_attributes = TREE_PURPOSE (declspec_stack);
1619                   declspec_stack = TREE_CHAIN (declspec_stack);
1620                   resume_momentary ($2); }
1621         | nonempty_type_quals
1622                 { if (pedantic)
1623                     pedwarn ("ANSI C forbids member declarations with no members");
1624                   shadow_tag($1);
1625                   $$ = NULL_TREE; }
1626         | error
1627                 { $$ = NULL_TREE; }
1628         | extension component_decl
1629                 { $$ = $2;
1630                   RESTORE_WARN_FLAGS ($1); }
1631         ;
1633 components:
1634           component_declarator
1635         | components ',' component_declarator
1636                 { $$ = chainon ($1, $3); }
1637         ;
1639 component_declarator:
1640           save_filename save_lineno declarator maybe_attribute
1641                 { $$ = grokfield ($1, $2, $3, current_declspecs, NULL_TREE);
1642                   decl_attributes ($$, $4, prefix_attributes); }
1643         | save_filename save_lineno
1644           declarator ':' expr_no_commas maybe_attribute
1645                 { $$ = grokfield ($1, $2, $3, current_declspecs, $5);
1646                   decl_attributes ($$, $6, prefix_attributes); }
1647         | save_filename save_lineno ':' expr_no_commas maybe_attribute
1648                 { $$ = grokfield ($1, $2, NULL_TREE, current_declspecs, $4);
1649                   decl_attributes ($$, $5, prefix_attributes); }
1650         ;
1652 /* We chain the enumerators in reverse order.
1653    They are put in forward order where enumlist is used.
1654    (The order used to be significant, but no longer is so.
1655    However, we still maintain the order, just to be clean.)  */
1657 enumlist:
1658           enumerator
1659         | enumlist ',' enumerator
1660                 { if ($1 == error_mark_node)
1661                     $$ = $1;
1662                   else
1663                     $$ = chainon ($3, $1); }
1664         | error
1665                 { $$ = error_mark_node; }
1666         ;
1669 enumerator:
1670           identifier
1671                 { $$ = build_enumerator ($1, NULL_TREE); }
1672         | identifier '=' expr_no_commas
1673                 { $$ = build_enumerator ($1, $3); }
1674         ;
1676 typename:
1677         typed_typespecs absdcl
1678                 { $$ = build_tree_list ($1, $2); }
1679         | nonempty_type_quals absdcl
1680                 { $$ = build_tree_list ($1, $2); }
1681         ;
1683 absdcl:   /* an absolute declarator */
1684         /* empty */
1685                 { $$ = NULL_TREE; }
1686         | absdcl1
1687         ;
1689 nonempty_type_quals:
1690           TYPE_QUAL
1691                 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
1692         | nonempty_type_quals TYPE_QUAL
1693                 { $$ = tree_cons (NULL_TREE, $2, $1); }
1694         ;
1696 type_quals:
1697           /* empty */
1698                 { $$ = NULL_TREE; }
1699         | type_quals TYPE_QUAL
1700                 { $$ = tree_cons (NULL_TREE, $2, $1); }
1701         ;
1703 absdcl1:  /* a nonempty absolute declarator */
1704           '(' absdcl1 ')'
1705                 { $$ = $2; }
1706           /* `(typedef)1' is `int'.  */
1707         | '*' type_quals absdcl1  %prec UNARY
1708                 { $$ = make_pointer_declarator ($2, $3); }
1709         | '*' type_quals  %prec UNARY
1710                 { $$ = make_pointer_declarator ($2, NULL_TREE); }
1711         | absdcl1 '(' parmlist  %prec '.'
1712                 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1713         | absdcl1 '[' expr ']'  %prec '.'
1714                 { $$ = build_nt (ARRAY_REF, $1, $3); }
1715         | absdcl1 '[' ']'  %prec '.'
1716                 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1717         | '(' parmlist  %prec '.'
1718                 { $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); }
1719         | '[' expr ']'  %prec '.'
1720                 { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); }
1721         | '[' ']'  %prec '.'
1722                 { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); }
1723         /* ??? It appears we have to support attributes here, however
1724            using prefix_attributes is wrong.  */
1725         | attributes setattrs absdcl1
1726                 { $$ = $3; }
1727         ;
1729 /* at least one statement, the first of which parses without error.  */
1730 /* stmts is used only after decls, so an invalid first statement
1731    is actually regarded as an invalid decl and part of the decls.  */
1733 stmts:
1734         lineno_stmt_or_labels
1735                 {
1736                   if (pedantic && $1)
1737                     pedwarn ("ANSI C forbids label at end of compound statement");
1738                 }
1739         ;
1741 lineno_stmt_or_labels:
1742           lineno_stmt_or_label
1743         | lineno_stmt_or_labels lineno_stmt_or_label
1744                 { $$ = $2; }
1745         | lineno_stmt_or_labels errstmt
1746                 { $$ = 0; }
1747         ;
1749 xstmts:
1750         /* empty */
1751         | stmts
1752         ;
1754 errstmt:  error ';'
1755         ;
1757 pushlevel:  /* empty */
1758                 { emit_line_note (input_filename, lineno);
1759                   pushlevel (0);
1760                   clear_last_expr ();
1761                   push_momentary ();
1762                   expand_start_bindings (0);
1763 ifobjc
1764                   if (objc_method_context)
1765                     add_objc_decls ();
1766 end ifobjc
1767                 }
1768         ;
1770 /* Read zero or more forward-declarations for labels
1771    that nested functions can jump to.  */
1772 maybe_label_decls:
1773           /* empty */
1774         | label_decls
1775                 { if (pedantic)
1776                     pedwarn ("ANSI C forbids label declarations"); }
1777         ;
1779 label_decls:
1780           label_decl
1781         | label_decls label_decl
1782         ;
1784 label_decl:
1785           LABEL identifiers_or_typenames ';'
1786                 { tree link;
1787                   for (link = $2; link; link = TREE_CHAIN (link))
1788                     {
1789                       tree label = shadow_label (TREE_VALUE (link));
1790                       C_DECLARED_LABEL_FLAG (label) = 1;
1791                       declare_nonlocal_label (label);
1792                     }
1793                 }
1794         ;
1796 /* This is the body of a function definition.
1797    It causes syntax errors to ignore to the next openbrace.  */
1798 compstmt_or_error:
1799           compstmt
1800                 {}
1801         | error compstmt
1802         ;
1804 compstmt_start: '{' { compstmt_count++; }
1806 compstmt_nostart: '}'
1807                 { $$ = convert (void_type_node, integer_zero_node); }
1808         | pushlevel maybe_label_decls decls xstmts '}'
1809                 { emit_line_note (input_filename, lineno);
1810                   expand_end_bindings (getdecls (), 1, 0);
1811                   $$ = poplevel (1, 1, 0);
1812                   if (yychar == CONSTANT || yychar == STRING)
1813                     pop_momentary_nofree ();
1814                   else
1815                     pop_momentary (); }
1816         | pushlevel maybe_label_decls error '}'
1817                 { emit_line_note (input_filename, lineno);
1818                   expand_end_bindings (getdecls (), kept_level_p (), 0);
1819                   $$ = poplevel (kept_level_p (), 0, 0);
1820                   if (yychar == CONSTANT || yychar == STRING)
1821                     pop_momentary_nofree ();
1822                   else
1823                     pop_momentary (); }
1824         | pushlevel maybe_label_decls stmts '}'
1825                 { emit_line_note (input_filename, lineno);
1826                   expand_end_bindings (getdecls (), kept_level_p (), 0);
1827                   $$ = poplevel (kept_level_p (), 0, 0);
1828                   if (yychar == CONSTANT || yychar == STRING)
1829                     pop_momentary_nofree ();
1830                   else
1831                     pop_momentary (); }
1832         ;
1834 compstmt_primary_start:
1835         '(' '{'
1836                 { if (current_function_decl == 0)
1837                     {
1838                       error ("braced-group within expression allowed only inside a function");
1839                       YYERROR;
1840                     }
1841                   /* We must force a BLOCK for this level
1842                      so that, if it is not expanded later,
1843                      there is a way to turn off the entire subtree of blocks
1844                      that are contained in it.  */
1845                   keep_next_level ();
1846                   push_iterator_stack ();
1847                   push_label_level ();
1848                   $$ = expand_start_stmt_expr ();
1849                   compstmt_count++;
1850                 }
1852 compstmt: compstmt_start compstmt_nostart
1853                 { $$ = $2; }
1854         ;
1856 /* Value is number of statements counted as of the closeparen.  */
1857 simple_if:
1858           if_prefix lineno_labeled_stmt
1859 /* Make sure c_expand_end_cond is run once
1860    for each call to c_expand_start_cond.
1861    Otherwise a crash is likely.  */
1862         | if_prefix error
1863         ;
1865 if_prefix:
1866           IF '(' expr ')'
1867                 { emit_line_note ($<filename>-1, $<lineno>0);
1868                   c_expand_start_cond (truthvalue_conversion ($3), 0, 
1869                                        compstmt_count);
1870                   $<itype>$ = stmt_count;
1871                   if_stmt_file = $<filename>-1;
1872                   if_stmt_line = $<lineno>0;
1873                   position_after_white_space (); }
1874         ;
1876 /* This is a subroutine of stmt.
1877    It is used twice, once for valid DO statements
1878    and once for catching errors in parsing the end test.  */
1879 do_stmt_start:
1880           DO
1881                 { stmt_count++;
1882                   compstmt_count++;
1883                   emit_line_note ($<filename>-1, $<lineno>0);
1884                   /* See comment in `while' alternative, above.  */
1885                   emit_nop ();
1886                   expand_start_loop_continue_elsewhere (1);
1887                   position_after_white_space (); }
1888           lineno_labeled_stmt WHILE
1889                 { expand_loop_continue_here (); }
1890         ;
1892 save_filename:
1893                 { $$ = input_filename; }
1894         ;
1896 save_lineno:
1897                 { $$ = lineno; }
1898         ;
1900 lineno_labeled_stmt:
1901           save_filename save_lineno stmt
1902                 { }
1903 /*      | save_filename save_lineno error
1904                 { }
1906         | save_filename save_lineno label lineno_labeled_stmt
1907                 { }
1908         ;
1910 lineno_stmt_or_label:
1911           save_filename save_lineno stmt_or_label
1912                 { $$ = $3; }
1913         ;
1915 stmt_or_label:
1916           stmt
1917                 { $$ = 0; }
1918         | label
1919                 { $$ = 1; }
1920         ;
1922 /* Parse a single real statement, not including any labels.  */
1923 stmt:
1924           compstmt
1925                 { stmt_count++; }
1926         | all_iter_stmt 
1927         | expr ';'
1928                 { stmt_count++;
1929                   emit_line_note ($<filename>-1, $<lineno>0);
1930 /* It appears that this should not be done--that a non-lvalue array
1931    shouldn't get an error if the value isn't used.
1932    Section 3.2.2.1 says that an array lvalue gets converted to a pointer
1933    if it appears as a top-level expression,
1934    but says nothing about non-lvalue arrays.  */
1935 #if 0
1936                   /* Call default_conversion to get an error
1937                      on referring to a register array if pedantic.  */
1938                   if (TREE_CODE (TREE_TYPE ($1)) == ARRAY_TYPE
1939                       || TREE_CODE (TREE_TYPE ($1)) == FUNCTION_TYPE)
1940                     $1 = default_conversion ($1);
1941 #endif
1942                   iterator_expand ($1);
1943                   clear_momentary (); }
1944         | simple_if ELSE
1945                 { c_expand_start_else ();
1946                   $<itype>1 = stmt_count;
1947                   position_after_white_space (); }
1948           lineno_labeled_stmt
1949                 { c_expand_end_cond ();
1950                   if (extra_warnings && stmt_count == $<itype>1)
1951                     warning ("empty body in an else-statement"); }
1952         | simple_if %prec IF
1953                 { c_expand_end_cond ();
1954                   /* This warning is here instead of in simple_if, because we
1955                      do not want a warning if an empty if is followed by an
1956                      else statement.  Increment stmt_count so we don't
1957                      give a second error if this is a nested `if'.  */
1958                   if (extra_warnings && stmt_count++ == $<itype>1)
1959                     warning_with_file_and_line (if_stmt_file, if_stmt_line,
1960                                                 "empty body in an if-statement"); }
1961 /* Make sure c_expand_end_cond is run once
1962    for each call to c_expand_start_cond.
1963    Otherwise a crash is likely.  */
1964         | simple_if ELSE error
1965                 { c_expand_end_cond (); }
1966         | WHILE
1967                 { stmt_count++;
1968                   emit_line_note ($<filename>-1, $<lineno>0);
1969                   /* The emit_nop used to come before emit_line_note,
1970                      but that made the nop seem like part of the preceding line.
1971                      And that was confusing when the preceding line was
1972                      inside of an if statement and was not really executed.
1973                      I think it ought to work to put the nop after the line number.
1974                      We will see.  --rms, July 15, 1991.  */
1975                   emit_nop (); }
1976           '(' expr ')'
1977                 { /* Don't start the loop till we have succeeded
1978                      in parsing the end test.  This is to make sure
1979                      that we end every loop we start.  */
1980                   expand_start_loop (1);
1981                   emit_line_note (input_filename, lineno);
1982                   expand_exit_loop_if_false (NULL_PTR,
1983                                              truthvalue_conversion ($4));
1984                   position_after_white_space (); }
1985           lineno_labeled_stmt
1986                 { expand_end_loop (); }
1987         | do_stmt_start
1988           '(' expr ')' ';'
1989                 { emit_line_note (input_filename, lineno);
1990                   expand_exit_loop_if_false (NULL_PTR,
1991                                              truthvalue_conversion ($3));
1992                   expand_end_loop ();
1993                   clear_momentary (); }
1994 /* This rule is needed to make sure we end every loop we start.  */
1995         | do_stmt_start error
1996                 { expand_end_loop ();
1997                   clear_momentary (); }
1998         | FOR
1999           '(' xexpr ';'
2000                 { stmt_count++;
2001                   emit_line_note ($<filename>-1, $<lineno>0);
2002                   /* See comment in `while' alternative, above.  */
2003                   emit_nop ();
2004                   if ($3) c_expand_expr_stmt ($3);
2005                   /* Next step is to call expand_start_loop_continue_elsewhere,
2006                      but wait till after we parse the entire for (...).
2007                      Otherwise, invalid input might cause us to call that
2008                      fn without calling expand_end_loop.  */
2009                 }
2010           xexpr ';'
2011                 /* Can't emit now; wait till after expand_start_loop...  */
2012                 { $<lineno>7 = lineno;
2013                   $<filename>$ = input_filename; }
2014           xexpr ')'
2015                 { 
2016                   /* Start the loop.  Doing this after parsing
2017                      all the expressions ensures we will end the loop.  */
2018                   expand_start_loop_continue_elsewhere (1);
2019                   /* Emit the end-test, with a line number.  */
2020                   emit_line_note ($<filename>8, $<lineno>7);
2021                   if ($6)
2022                     expand_exit_loop_if_false (NULL_PTR,
2023                                                truthvalue_conversion ($6));
2024                   /* Don't let the tree nodes for $9 be discarded by
2025                      clear_momentary during the parsing of the next stmt.  */
2026                   push_momentary ();
2027                   $<lineno>7 = lineno;
2028                   $<filename>8 = input_filename;
2029                   position_after_white_space (); }
2030           lineno_labeled_stmt
2031                 { /* Emit the increment expression, with a line number.  */
2032                   emit_line_note ($<filename>8, $<lineno>7);
2033                   expand_loop_continue_here ();
2034                   if ($9)
2035                     c_expand_expr_stmt ($9);
2036                   if (yychar == CONSTANT || yychar == STRING)
2037                     pop_momentary_nofree ();
2038                   else
2039                     pop_momentary ();
2040                   expand_end_loop (); }
2041         | SWITCH '(' expr ')'
2042                 { stmt_count++;
2043                   emit_line_note ($<filename>-1, $<lineno>0);
2044                   c_expand_start_case ($3);
2045                   /* Don't let the tree nodes for $3 be discarded by
2046                      clear_momentary during the parsing of the next stmt.  */
2047                   push_momentary ();
2048                   position_after_white_space (); }
2049           lineno_labeled_stmt
2050                 { expand_end_case ($3);
2051                   if (yychar == CONSTANT || yychar == STRING)
2052                     pop_momentary_nofree ();
2053                   else
2054                     pop_momentary (); }
2055         | BREAK ';'
2056                 { stmt_count++;
2057                   emit_line_note ($<filename>-1, $<lineno>0);
2058                   if ( ! expand_exit_something ())
2059                     error ("break statement not within loop or switch"); }
2060         | CONTINUE ';'
2061                 { stmt_count++;
2062                   emit_line_note ($<filename>-1, $<lineno>0);
2063                   if (! expand_continue_loop (NULL_PTR))
2064                     error ("continue statement not within a loop"); }
2065         | RETURN ';'
2066                 { stmt_count++;
2067                   emit_line_note ($<filename>-1, $<lineno>0);
2068                   c_expand_return (NULL_TREE); }
2069         | RETURN expr ';'
2070                 { stmt_count++;
2071                   emit_line_note ($<filename>-1, $<lineno>0);
2072                   c_expand_return ($2); }
2073         | ASM_KEYWORD maybe_type_qual '(' expr ')' ';'
2074                 { stmt_count++;
2075                   emit_line_note ($<filename>-1, $<lineno>0);
2076                   STRIP_NOPS ($4);
2077                   if ((TREE_CODE ($4) == ADDR_EXPR
2078                        && TREE_CODE (TREE_OPERAND ($4, 0)) == STRING_CST)
2079                       || TREE_CODE ($4) == STRING_CST)
2080                     expand_asm ($4);
2081                   else
2082                     error ("argument of `asm' is not a constant string"); }
2083         /* This is the case with just output operands.  */
2084         | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ')' ';'
2085                 { stmt_count++;
2086                   emit_line_note ($<filename>-1, $<lineno>0);
2087                   c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE,
2088                                          $2 == ridpointers[(int)RID_VOLATILE],
2089                                          input_filename, lineno); }
2090         /* This is the case with input operands as well.  */
2091         | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':' asm_operands ')' ';'
2092                 { stmt_count++;
2093                   emit_line_note ($<filename>-1, $<lineno>0);
2094                   c_expand_asm_operands ($4, $6, $8, NULL_TREE,
2095                                          $2 == ridpointers[(int)RID_VOLATILE],
2096                                          input_filename, lineno); }
2097         /* This is the case with clobbered registers as well.  */
2098         | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':'
2099           asm_operands ':' asm_clobbers ')' ';'
2100                 { stmt_count++;
2101                   emit_line_note ($<filename>-1, $<lineno>0);
2102                   c_expand_asm_operands ($4, $6, $8, $10,
2103                                          $2 == ridpointers[(int)RID_VOLATILE],
2104                                          input_filename, lineno); }
2105         | GOTO identifier ';'
2106                 { tree decl;
2107                   stmt_count++;
2108                   emit_line_note ($<filename>-1, $<lineno>0);
2109                   decl = lookup_label ($2);
2110                   if (decl != 0)
2111                     {
2112                       TREE_USED (decl) = 1;
2113                       expand_goto (decl);
2114                     }
2115                 }
2116         | GOTO '*' expr ';'
2117                 { if (pedantic)
2118                     pedwarn ("ANSI C forbids `goto *expr;'");
2119                   stmt_count++;
2120                   emit_line_note ($<filename>-1, $<lineno>0);
2121                   expand_computed_goto (convert (ptr_type_node, $3)); }
2122         | ';'
2123         ;
2125 all_iter_stmt:
2126           all_iter_stmt_simple
2127 /*      | all_iter_stmt_with_decl */
2128         ;
2130 all_iter_stmt_simple:
2131           FOR '(' primary ')' 
2132           {
2133             /* The value returned by this action is  */
2134             /*      1 if everything is OK */ 
2135             /*      0 in case of error or already bound iterator */
2137             $<itype>$ = 0;
2138             if (TREE_CODE ($3) != VAR_DECL)
2139               error ("invalid `for (ITERATOR)' syntax");
2140             else if (! ITERATOR_P ($3))
2141               error ("`%s' is not an iterator",
2142                      IDENTIFIER_POINTER (DECL_NAME ($3)));
2143             else if (ITERATOR_BOUND_P ($3))
2144               error ("`for (%s)' inside expansion of same iterator",
2145                      IDENTIFIER_POINTER (DECL_NAME ($3)));
2146             else
2147               {
2148                 $<itype>$ = 1;
2149                 iterator_for_loop_start ($3);
2150               }
2151           }
2152           lineno_labeled_stmt
2153           {
2154             if ($<itype>5)
2155               iterator_for_loop_end ($3);
2156           }
2158 /*  This really should allow any kind of declaration,
2159     for generality.  Fix it before turning it back on.
2161 all_iter_stmt_with_decl:
2162           FOR '(' ITERATOR pushlevel setspecs iterator_spec ')' 
2163           {
2164 */          /* The value returned by this action is  */
2165             /*      1 if everything is OK */ 
2166             /*      0 in case of error or already bound iterator */
2168             iterator_for_loop_start ($6);
2169           }
2170           lineno_labeled_stmt
2171           {
2172             iterator_for_loop_end ($6);
2173             emit_line_note (input_filename, lineno);
2174             expand_end_bindings (getdecls (), 1, 0);
2175             $<ttype>$ = poplevel (1, 1, 0);
2176             if (yychar == CONSTANT || yychar == STRING)
2177               pop_momentary_nofree ();
2178             else
2179               pop_momentary ();     
2180           }
2183 /* Any kind of label, including jump labels and case labels.
2184    ANSI C accepts labels only before statements, but we allow them
2185    also at the end of a compound statement.  */
2187 label:    CASE expr_no_commas ':'
2188                 { register tree value = check_case_value ($2);
2189                   register tree label
2190                     = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2192                   stmt_count++;
2194                   if (value != error_mark_node)
2195                     {
2196                       tree duplicate;
2197                       int success;
2199                       if (pedantic && ! INTEGRAL_TYPE_P (TREE_TYPE (value)))
2200                         pedwarn ("label must have integral type in ANSI C");
2202                       success = pushcase (value, convert_and_check,
2203                                           label, &duplicate);
2205                       if (success == 1)
2206                         error ("case label not within a switch statement");
2207                       else if (success == 2)
2208                         {
2209                           error ("duplicate case value");
2210                           error_with_decl (duplicate, "this is the first entry for that value");
2211                         }
2212                       else if (success == 3)
2213                         warning ("case value out of range");
2214                       else if (success == 5)
2215                         error ("case label within scope of cleanup or variable array");
2216                     }
2217                   position_after_white_space (); }
2218         | CASE expr_no_commas ELLIPSIS expr_no_commas ':'
2219                 { register tree value1 = check_case_value ($2);
2220                   register tree value2 = check_case_value ($4);
2221                   register tree label
2222                     = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2224                   if (pedantic)
2225                     pedwarn ("ANSI C forbids case ranges");
2226                   stmt_count++;
2228                   if (value1 != error_mark_node && value2 != error_mark_node)
2229                     {
2230                       tree duplicate;
2231                       int success = pushcase_range (value1, value2,
2232                                                     convert_and_check, label,
2233                                                     &duplicate);
2234                       if (success == 1)
2235                         error ("case label not within a switch statement");
2236                       else if (success == 2)
2237                         {
2238                           error ("duplicate case value");
2239                           error_with_decl (duplicate, "this is the first entry for that value");
2240                         }
2241                       else if (success == 3)
2242                         warning ("case value out of range");
2243                       else if (success == 4)
2244                         warning ("empty case range");
2245                       else if (success == 5)
2246                         error ("case label within scope of cleanup or variable array");
2247                     }
2248                   position_after_white_space (); }
2249         | DEFAULT ':'
2250                 {
2251                   tree duplicate;
2252                   register tree label
2253                     = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2254                   int success = pushcase (NULL_TREE, 0, label, &duplicate);
2255                   stmt_count++;
2256                   if (success == 1)
2257                     error ("default label not within a switch statement");
2258                   else if (success == 2)
2259                     {
2260                       error ("multiple default labels in one switch");
2261                       error_with_decl (duplicate, "this is the first default label");
2262                     }
2263                   position_after_white_space (); }
2264         | identifier ':' maybe_attribute
2265                 { tree label = define_label (input_filename, lineno, $1);
2266                   stmt_count++;
2267                   emit_nop ();
2268                   if (label)
2269                     {
2270                       expand_label (label);
2271                       decl_attributes (label, $3, NULL_TREE);
2272                     }
2273                   position_after_white_space (); }
2274         ;
2276 /* Either a type-qualifier or nothing.  First thing in an `asm' statement.  */
2278 maybe_type_qual:
2279         /* empty */
2280                 { emit_line_note (input_filename, lineno);
2281                   $$ = NULL_TREE; }
2282         | TYPE_QUAL
2283                 { emit_line_note (input_filename, lineno); }
2284         ;
2286 xexpr:
2287         /* empty */
2288                 { $$ = NULL_TREE; }
2289         | expr
2290         ;
2292 /* These are the operands other than the first string and colon
2293    in  asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x))  */
2294 asm_operands: /* empty */
2295                 { $$ = NULL_TREE; }
2296         | nonnull_asm_operands
2297         ;
2299 nonnull_asm_operands:
2300           asm_operand
2301         | nonnull_asm_operands ',' asm_operand
2302                 { $$ = chainon ($1, $3); }
2303         ;
2305 asm_operand:
2306           STRING '(' expr ')'
2307                 { $$ = build_tree_list ($1, $3); }
2308         ;
2310 asm_clobbers:
2311           string
2312                 { $$ = tree_cons (NULL_TREE, combine_strings ($1), NULL_TREE); }
2313         | asm_clobbers ',' string
2314                 { $$ = tree_cons (NULL_TREE, combine_strings ($3), $1); }
2315         ;
2317 /* This is what appears inside the parens in a function declarator.
2318    Its value is a list of ..._TYPE nodes.  */
2319 parmlist:
2320                 { pushlevel (0);
2321                   clear_parm_order ();
2322                   declare_parm_level (0); }
2323           parmlist_1
2324                 { $$ = $2;
2325                   parmlist_tags_warning ();
2326                   poplevel (0, 0, 0); }
2327         ;
2329 parmlist_1:
2330           parmlist_2 ')'
2331         | parms ';'
2332                 { tree parm;
2333                   if (pedantic)
2334                     pedwarn ("ANSI C forbids forward parameter declarations");
2335                   /* Mark the forward decls as such.  */
2336                   for (parm = getdecls (); parm; parm = TREE_CHAIN (parm))
2337                     TREE_ASM_WRITTEN (parm) = 1;
2338                   clear_parm_order (); }
2339           parmlist_1
2340                 { $$ = $4; }
2341         | error ')'
2342                 { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
2343         ;
2345 /* This is what appears inside the parens in a function declarator.
2346    Is value is represented in the format that grokdeclarator expects.  */
2347 parmlist_2:  /* empty */
2348                 { $$ = get_parm_info (0); }
2349         | ELLIPSIS
2350                 { $$ = get_parm_info (0);
2351                   /* Gcc used to allow this as an extension.  However, it does
2352                      not work for all targets, and thus has been disabled.
2353                      Also, since func (...) and func () are indistinguishable,
2354                      it caused problems with the code in expand_builtin which
2355                      tries to verify that BUILT_IN_NEXT_ARG is being used
2356                      correctly.  */
2357                   error ("ANSI C requires a named argument before `...'");
2358                 }
2359         | parms
2360                 { $$ = get_parm_info (1); }
2361         | parms ',' ELLIPSIS
2362                 { $$ = get_parm_info (0); }
2363         ;
2365 parms:
2366         parm
2367                 { push_parm_decl ($1); }
2368         | parms ',' parm
2369                 { push_parm_decl ($3); }
2370         ;
2372 /* A single parameter declaration or parameter type name,
2373    as found in a parmlist.  */
2374 parm:
2375           typed_declspecs setspecs parm_declarator maybe_attribute
2376                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2377                                                          $3),
2378                                         build_tree_list (prefix_attributes,
2379                                                          $4));
2380                   current_declspecs = TREE_VALUE (declspec_stack);
2381                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2382                   declspec_stack = TREE_CHAIN (declspec_stack);
2383                   resume_momentary ($2); }
2384         | typed_declspecs setspecs notype_declarator maybe_attribute
2385                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2386                                                          $3),
2387                                         build_tree_list (prefix_attributes,
2388                                                          $4)); 
2389                   current_declspecs = TREE_VALUE (declspec_stack);
2390                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2391                   declspec_stack = TREE_CHAIN (declspec_stack);
2392                   resume_momentary ($2); }
2393         | typed_declspecs setspecs absdcl maybe_attribute
2394                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2395                                                          $3),
2396                                         build_tree_list (prefix_attributes,
2397                                                          $4));
2398                   current_declspecs = TREE_VALUE (declspec_stack);
2399                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2400                   declspec_stack = TREE_CHAIN (declspec_stack);
2401                   resume_momentary ($2); }
2402         | declmods setspecs notype_declarator maybe_attribute
2403                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2404                                                          $3),
2405                                         build_tree_list (prefix_attributes,
2406                                                          $4));
2407                   current_declspecs = TREE_VALUE (declspec_stack);
2408                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2409                   declspec_stack = TREE_CHAIN (declspec_stack);
2410                   resume_momentary ($2);  }
2412         | declmods setspecs absdcl maybe_attribute
2413                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2414                                                          $3),
2415                                         build_tree_list (prefix_attributes,
2416                                                          $4));
2417                   current_declspecs = TREE_VALUE (declspec_stack);
2418                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2419                   declspec_stack = TREE_CHAIN (declspec_stack);
2420                   resume_momentary ($2);  }
2421         ;
2423 /* This is used in a function definition
2424    where either a parmlist or an identifier list is ok.
2425    Its value is a list of ..._TYPE nodes or a list of identifiers.  */
2426 parmlist_or_identifiers:
2427                 { pushlevel (0);
2428                   clear_parm_order ();
2429                   declare_parm_level (1); }
2430           parmlist_or_identifiers_1
2431                 { $$ = $2;
2432                   parmlist_tags_warning ();
2433                   poplevel (0, 0, 0); }
2434         ;
2436 parmlist_or_identifiers_1:
2437           parmlist_1
2438         | identifiers ')'
2439                 { tree t;
2440                   for (t = $1; t; t = TREE_CHAIN (t))
2441                     if (TREE_VALUE (t) == NULL_TREE)
2442                       error ("`...' in old-style identifier list");
2443                   $$ = tree_cons (NULL_TREE, NULL_TREE, $1); }
2444         ;
2446 /* A nonempty list of identifiers.  */
2447 identifiers:
2448         IDENTIFIER
2449                 { $$ = build_tree_list (NULL_TREE, $1); }
2450         | identifiers ',' IDENTIFIER
2451                 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2452         ;
2454 /* A nonempty list of identifiers, including typenames.  */
2455 identifiers_or_typenames:
2456         identifier
2457                 { $$ = build_tree_list (NULL_TREE, $1); }
2458         | identifiers_or_typenames ',' identifier
2459                 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2460         ;
2462 extension:
2463         EXTENSION
2464                 { $$ = SAVE_WARN_FLAGS();
2465                   pedantic = 0;
2466                   warn_pointer_arith = 0; }
2467         ;
2469 ifobjc
2470 /* Objective-C productions.  */
2472 objcdef:
2473           classdef
2474         | classdecl
2475         | aliasdecl
2476         | protocoldef
2477         | methoddef
2478         | END
2479                 {
2480                   if (objc_implementation_context)
2481                     {
2482                       finish_class (objc_implementation_context);
2483                       objc_ivar_chain = NULL_TREE;
2484                       objc_implementation_context = NULL_TREE;
2485                     }
2486                   else
2487                     warning ("`@end' must appear in an implementation context");
2488                 }
2489         ;
2491 /* A nonempty list of identifiers.  */
2492 identifier_list:
2493         identifier
2494                 { $$ = build_tree_list (NULL_TREE, $1); }
2495         | identifier_list ',' identifier
2496                 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2497         ;
2499 classdecl:
2500           CLASS identifier_list ';'
2501                 {
2502                   objc_declare_class ($2);
2503                 }
2505 aliasdecl:
2506           ALIAS identifier identifier ';'
2507                 {
2508                   objc_declare_alias ($2, $3);
2509                 }
2511 classdef:
2512           INTERFACE identifier protocolrefs '{'
2513                 {
2514                   objc_interface_context = objc_ivar_context
2515                     = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3);
2516                   objc_public_flag = 0;
2517                 }
2518           ivar_decl_list '}'
2519                 {
2520                   continue_class (objc_interface_context);
2521                 }
2522           methodprotolist
2523           END
2524                 {
2525                   finish_class (objc_interface_context);
2526                   objc_interface_context = NULL_TREE;
2527                 }
2529         | INTERFACE identifier protocolrefs
2530                 {
2531                   objc_interface_context
2532                     = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3);
2533                   continue_class (objc_interface_context);
2534                 }
2535           methodprotolist
2536           END
2537                 {
2538                   finish_class (objc_interface_context);
2539                   objc_interface_context = NULL_TREE;
2540                 }
2542         | INTERFACE identifier ':' identifier protocolrefs '{'
2543                 {
2544                   objc_interface_context = objc_ivar_context
2545                     = start_class (CLASS_INTERFACE_TYPE, $2, $4, $5);
2546                   objc_public_flag = 0;
2547                 }
2548           ivar_decl_list '}'
2549                 {
2550                   continue_class (objc_interface_context);
2551                 }
2552           methodprotolist
2553           END
2554                 {
2555                   finish_class (objc_interface_context);
2556                   objc_interface_context = NULL_TREE;
2557                 }
2559         | INTERFACE identifier ':' identifier protocolrefs
2560                 {
2561                   objc_interface_context
2562                     = start_class (CLASS_INTERFACE_TYPE, $2, $4, $5);
2563                   continue_class (objc_interface_context);
2564                 }
2565           methodprotolist
2566           END
2567                 {
2568                   finish_class (objc_interface_context);
2569                   objc_interface_context = NULL_TREE;
2570                 }
2572         | IMPLEMENTATION identifier '{'
2573                 {
2574                   objc_implementation_context = objc_ivar_context
2575                     = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE);
2576                   objc_public_flag = 0;
2577                 }
2578           ivar_decl_list '}'
2579                 {
2580                   objc_ivar_chain
2581                     = continue_class (objc_implementation_context);
2582                 }
2584         | IMPLEMENTATION identifier
2585                 {
2586                   objc_implementation_context
2587                     = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE);
2588                   objc_ivar_chain
2589                     = continue_class (objc_implementation_context);
2590                 }
2592         | IMPLEMENTATION identifier ':' identifier '{'
2593                 {
2594                   objc_implementation_context = objc_ivar_context
2595                     = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE);
2596                   objc_public_flag = 0;
2597                 }
2598           ivar_decl_list '}'
2599                 {
2600                   objc_ivar_chain
2601                     = continue_class (objc_implementation_context);
2602                 }
2604         | IMPLEMENTATION identifier ':' identifier
2605                 {
2606                   objc_implementation_context
2607                     = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE);
2608                   objc_ivar_chain
2609                     = continue_class (objc_implementation_context);
2610                 }
2612         | INTERFACE identifier '(' identifier ')' protocolrefs
2613                 {
2614                   objc_interface_context
2615                     = start_class (CATEGORY_INTERFACE_TYPE, $2, $4, $6);
2616                   continue_class (objc_interface_context);
2617                 }
2618           methodprotolist
2619           END
2620                 {
2621                   finish_class (objc_interface_context);
2622                   objc_interface_context = NULL_TREE;
2623                 }
2625         | IMPLEMENTATION identifier '(' identifier ')'
2626                 {
2627                   objc_implementation_context
2628                     = start_class (CATEGORY_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE);
2629                   objc_ivar_chain
2630                     = continue_class (objc_implementation_context);
2631                 }
2632         ;
2634 protocoldef:
2635           PROTOCOL identifier protocolrefs
2636                 {
2637                   remember_protocol_qualifiers ();
2638                   objc_interface_context
2639                     = start_protocol(PROTOCOL_INTERFACE_TYPE, $2, $3);
2640                 }
2641           methodprotolist END
2642                 {
2643                   forget_protocol_qualifiers();
2644                   finish_protocol(objc_interface_context);
2645                   objc_interface_context = NULL_TREE;
2646                 }
2647         ;
2649 protocolrefs:
2650           /* empty */
2651                 {
2652                   $$ = NULL_TREE;
2653                 }
2654         | non_empty_protocolrefs
2655         ;
2657 non_empty_protocolrefs:
2658           ARITHCOMPARE identifier_list ARITHCOMPARE
2659                 {
2660                   if ($1 == LT_EXPR && $3 == GT_EXPR)
2661                     $$ = $2;
2662                   else
2663                     YYERROR1;
2664                 }
2665         ;
2667 ivar_decl_list:
2668           ivar_decl_list visibility_spec ivar_decls
2669         | ivar_decls
2670         ;
2672 visibility_spec:
2673           PRIVATE { objc_public_flag = 2; }
2674         | PROTECTED { objc_public_flag = 0; }
2675         | PUBLIC { objc_public_flag = 1; }
2676         ;
2678 ivar_decls:
2679           /* empty */
2680                 {
2681                   $$ = NULL_TREE;
2682                 }
2683         | ivar_decls ivar_decl ';'
2684         | ivar_decls ';'
2685                 {
2686                   if (pedantic)
2687                     pedwarn ("extra semicolon in struct or union specified");
2688                 }
2689         ;
2692 /* There is a shift-reduce conflict here, because `components' may
2693    start with a `typename'.  It happens that shifting (the default resolution)
2694    does the right thing, because it treats the `typename' as part of
2695    a `typed_typespecs'.
2697    It is possible that this same technique would allow the distinction
2698    between `notype_initdecls' and `initdecls' to be eliminated.
2699    But I am being cautious and not trying it.  */
2701 ivar_decl:
2702         typed_typespecs setspecs ivars
2703                 { $$ = $3;
2704                   current_declspecs = TREE_VALUE (declspec_stack);
2705                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2706                   declspec_stack = TREE_CHAIN (declspec_stack);
2707                   resume_momentary ($2); }
2708         | nonempty_type_quals setspecs ivars
2709                 { $$ = $3;
2710                   current_declspecs = TREE_VALUE (declspec_stack);
2711                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2712                   declspec_stack = TREE_CHAIN (declspec_stack);
2713                   resume_momentary ($2); }
2714         | error
2715                 { $$ = NULL_TREE; }
2716         ;
2718 ivars:
2719           /* empty */
2720                 { $$ = NULL_TREE; }
2721         | ivar_declarator
2722         | ivars ',' ivar_declarator
2723         ;
2725 ivar_declarator:
2726           declarator
2727                 {
2728                   $$ = add_instance_variable (objc_ivar_context,
2729                                               objc_public_flag,
2730                                               $1, current_declspecs,
2731                                               NULL_TREE);
2732                 }
2733         | declarator ':' expr_no_commas
2734                 {
2735                   $$ = add_instance_variable (objc_ivar_context,
2736                                               objc_public_flag,
2737                                               $1, current_declspecs, $3);
2738                 }
2739         | ':' expr_no_commas
2740                 {
2741                   $$ = add_instance_variable (objc_ivar_context,
2742                                               objc_public_flag,
2743                                               NULL_TREE,
2744                                               current_declspecs, $2);
2745                 }
2746         ;
2748 methoddef:
2749           '+'
2750                 {
2751                   remember_protocol_qualifiers ();
2752                   if (objc_implementation_context)
2753                     objc_inherit_code = CLASS_METHOD_DECL;
2754                   else
2755                     fatal ("method definition not in class context");
2756                 }
2757           methoddecl
2758                 {
2759                   forget_protocol_qualifiers ();
2760                   add_class_method (objc_implementation_context, $3);
2761                   start_method_def ($3);
2762                   objc_method_context = $3;
2763                 }
2764           optarglist
2765                 {
2766                   continue_method_def ();
2767                 }
2768           compstmt_or_error
2769                 {
2770                   finish_method_def ();
2771                   objc_method_context = NULL_TREE;
2772                 }
2774         | '-'
2775                 {
2776                   remember_protocol_qualifiers ();
2777                   if (objc_implementation_context)
2778                     objc_inherit_code = INSTANCE_METHOD_DECL;
2779                   else
2780                     fatal ("method definition not in class context");
2781                 }
2782           methoddecl
2783                 {
2784                   forget_protocol_qualifiers ();
2785                   add_instance_method (objc_implementation_context, $3);
2786                   start_method_def ($3);
2787                   objc_method_context = $3;
2788                 }
2789           optarglist
2790                 {
2791                   continue_method_def ();
2792                 }
2793           compstmt_or_error
2794                 {
2795                   finish_method_def ();
2796                   objc_method_context = NULL_TREE;
2797                 }
2798         ;
2800 /* the reason for the strange actions in this rule
2801  is so that notype_initdecls when reached via datadef
2802  can find a valid list of type and sc specs in $0. */
2804 methodprotolist:
2805           /* empty  */
2806         | {$<ttype>$ = NULL_TREE; } methodprotolist2
2807         ;
2809 methodprotolist2:                /* eliminates a shift/reduce conflict */
2810            methodproto
2811         |  datadef
2812         | methodprotolist2 methodproto
2813         | methodprotolist2 {$<ttype>$ = NULL_TREE; } datadef
2814         ;
2816 semi_or_error:
2817           ';'
2818         | error
2819         ;
2821 methodproto:
2822           '+'
2823                 {
2824                   /* Remember protocol qualifiers in prototypes.  */
2825                   remember_protocol_qualifiers ();
2826                   objc_inherit_code = CLASS_METHOD_DECL;
2827                 }
2828           methoddecl
2829                 {
2830                   /* Forget protocol qualifiers here.  */
2831                   forget_protocol_qualifiers ();
2832                   add_class_method (objc_interface_context, $3);
2833                 }
2834           semi_or_error
2836         | '-'
2837                 {
2838                   /* Remember protocol qualifiers in prototypes.  */
2839                   remember_protocol_qualifiers ();
2840                   objc_inherit_code = INSTANCE_METHOD_DECL;
2841                 }
2842           methoddecl
2843                 {
2844                   /* Forget protocol qualifiers here.  */
2845                   forget_protocol_qualifiers ();
2846                   add_instance_method (objc_interface_context, $3);
2847                 }
2848           semi_or_error
2849         ;
2851 methoddecl:
2852           '(' typename ')' unaryselector
2853                 {
2854                   $$ = build_method_decl (objc_inherit_code, $2, $4, NULL_TREE);
2855                 }
2857         | unaryselector
2858                 {
2859                   $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, NULL_TREE);
2860                 }
2862         | '(' typename ')' keywordselector optparmlist
2863                 {
2864                   $$ = build_method_decl (objc_inherit_code, $2, $4, $5);
2865                 }
2867         | keywordselector optparmlist
2868                 {
2869                   $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, $2);
2870                 }
2871         ;
2873 /* "optarglist" assumes that start_method_def has already been called...
2874    if it is not, the "xdecls" will not be placed in the proper scope */
2876 optarglist:
2877           /* empty */
2878         | ';' myxdecls
2879         ;
2881 /* to get around the following situation: "int foo (int a) int b; {}" that
2882    is synthesized when parsing "- a:a b:b; id c; id d; { ... }" */
2884 myxdecls:
2885           /* empty */
2886         | mydecls
2887         ;
2889 mydecls:
2890         mydecl
2891         | errstmt
2892         | mydecls mydecl
2893         | mydecl errstmt
2894         ;
2896 mydecl:
2897         typed_declspecs setspecs myparms ';'
2898                 { current_declspecs = TREE_VALUE (declspec_stack);
2899                   prefix_attributes = TREE_PURPOSE (declspec_stack);
2900                   declspec_stack = TREE_CHAIN (declspec_stack);
2901                   resume_momentary ($2); }
2902         | typed_declspecs ';'
2903                 { shadow_tag ($1); }
2904         | declmods ';'
2905                 { pedwarn ("empty declaration"); }
2906         ;
2908 myparms:
2909         myparm
2910                 { push_parm_decl ($1); }
2911         | myparms ',' myparm
2912                 { push_parm_decl ($3); }
2913         ;
2915 /* A single parameter declaration or parameter type name,
2916    as found in a parmlist. DOES NOT ALLOW AN INITIALIZER OR ASMSPEC */
2918 myparm:
2919           parm_declarator maybe_attribute
2920                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2921                                                          $1),
2922                                         build_tree_list (prefix_attributes,
2923                                                          $2)); }
2924         | notype_declarator maybe_attribute
2925                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2926                                                          $1),
2927                                         build_tree_list (prefix_attributes,
2928                                                          $2)); }
2929         | absdcl maybe_attribute
2930                 { $$ = build_tree_list (build_tree_list (current_declspecs,
2931                                                          $1),
2932                                         build_tree_list (prefix_attributes,
2933                                                          $2)); }
2934         ;
2936 optparmlist:
2937           /* empty */
2938                 {
2939                   $$ = NULL_TREE;
2940                 }
2941         | ',' ELLIPSIS
2942                 {
2943                   /* oh what a kludge! */
2944                   $$ = (tree)1;
2945                 }
2946         | ','
2947                 {
2948                   pushlevel (0);
2949                 }
2950           parmlist_2
2951                 {
2952                   /* returns a tree list node generated by get_parm_info */
2953                   $$ = $3;
2954                   poplevel (0, 0, 0);
2955                 }
2956         ;
2958 unaryselector:
2959           selector
2960         ;
2962 keywordselector:
2963           keyworddecl
2965         | keywordselector keyworddecl
2966                 {
2967                   $$ = chainon ($1, $2);
2968                 }
2969         ;
2971 selector:
2972           IDENTIFIER
2973         | TYPENAME
2974         | OBJECTNAME
2975         | reservedwords
2976         ;
2978 reservedwords:
2979           ENUM { $$ = get_identifier (token_buffer); }
2980         | STRUCT { $$ = get_identifier (token_buffer); }
2981         | UNION { $$ = get_identifier (token_buffer); }
2982         | IF { $$ = get_identifier (token_buffer); }
2983         | ELSE { $$ = get_identifier (token_buffer); }
2984         | WHILE { $$ = get_identifier (token_buffer); }
2985         | DO { $$ = get_identifier (token_buffer); }
2986         | FOR { $$ = get_identifier (token_buffer); }
2987         | SWITCH { $$ = get_identifier (token_buffer); }
2988         | CASE { $$ = get_identifier (token_buffer); }
2989         | DEFAULT { $$ = get_identifier (token_buffer); }
2990         | BREAK { $$ = get_identifier (token_buffer); }
2991         | CONTINUE { $$ = get_identifier (token_buffer); }
2992         | RETURN  { $$ = get_identifier (token_buffer); }
2993         | GOTO { $$ = get_identifier (token_buffer); }
2994         | ASM_KEYWORD { $$ = get_identifier (token_buffer); }
2995         | SIZEOF { $$ = get_identifier (token_buffer); }
2996         | TYPEOF { $$ = get_identifier (token_buffer); }
2997         | ALIGNOF { $$ = get_identifier (token_buffer); }
2998         | TYPESPEC | TYPE_QUAL
2999         ;
3001 keyworddecl:
3002           selector ':' '(' typename ')' identifier
3003                 {
3004                   $$ = build_keyword_decl ($1, $4, $6);
3005                 }
3007         | selector ':' identifier
3008                 {
3009                   $$ = build_keyword_decl ($1, NULL_TREE, $3);
3010                 }
3012         | ':' '(' typename ')' identifier
3013                 {
3014                   $$ = build_keyword_decl (NULL_TREE, $3, $5);
3015                 }
3017         | ':' identifier
3018                 {
3019                   $$ = build_keyword_decl (NULL_TREE, NULL_TREE, $2);
3020                 }
3021         ;
3023 messageargs:
3024           selector
3025         | keywordarglist
3026         ;
3028 keywordarglist:
3029           keywordarg
3030         | keywordarglist keywordarg
3031                 {
3032                   $$ = chainon ($1, $2);
3033                 }
3034         ;
3037 keywordexpr:
3038           nonnull_exprlist
3039                 {
3040                   if (TREE_CHAIN ($1) == NULL_TREE)
3041                     /* just return the expr., remove a level of indirection */
3042                     $$ = TREE_VALUE ($1);
3043                   else
3044                     /* we have a comma expr., we will collapse later */
3045                     $$ = $1;
3046                 }
3047         ;
3049 keywordarg:
3050           selector ':' keywordexpr
3051                 {
3052                   $$ = build_tree_list ($1, $3);
3053                 }
3054         | ':' keywordexpr
3055                 {
3056                   $$ = build_tree_list (NULL_TREE, $2);
3057                 }
3058         ;
3060 receiver:
3061           expr
3062         | CLASSNAME
3063                 {
3064                   $$ = get_class_reference ($1);
3065                 }
3066         ;
3068 objcmessageexpr:
3069           '['
3070                 { objc_receiver_context = 1; }
3071           receiver
3072                 { objc_receiver_context = 0; }
3073           messageargs ']'
3074                 {
3075                   $$ = build_tree_list ($3, $5);
3076                 }
3077         ;
3079 selectorarg:
3080           selector
3081         | keywordnamelist
3082         ;
3084 keywordnamelist:
3085           keywordname
3086         | keywordnamelist keywordname
3087                 {
3088                   $$ = chainon ($1, $2);
3089                 }
3090         ;
3092 keywordname:
3093           selector ':'
3094                 {
3095                   $$ = build_tree_list ($1, NULL_TREE);
3096                 }
3097         | ':'
3098                 {
3099                   $$ = build_tree_list (NULL_TREE, NULL_TREE);
3100                 }
3101         ;
3103 objcselectorexpr:
3104           SELECTOR '(' selectorarg ')'
3105                 {
3106                   $$ = $3;
3107                 }
3108         ;
3110 objcprotocolexpr:
3111           PROTOCOL '(' identifier ')'
3112                 {
3113                   $$ = $3;
3114                 }
3115         ;
3117 /* extension to support C-structures in the archiver */
3119 objcencodeexpr:
3120           ENCODE '(' typename ')'
3121                 {
3122                   $$ = groktypename ($3);
3123                 }
3124         ;
3126 end ifobjc