1 /* YACC parser for C syntax and for Objective C. -*-c-*-
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996,
3 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This file defines the grammar of C and that of Objective C.
23 ifobjc ... end ifobjc conditionals contain code for Objective C only.
24 ifc ... end ifc conditionals contain code for C only.
25 Sed commands in Makefile.in are used to convert this file into
26 c-parse.y and into objc-parse.y. */
28 /* To whomever it may concern: I have heard that such a thing was once
29 written by AT&T, but I have never seen it. */
55 #ifdef MULTIBYTE_CHARS
63 /* Since parsers are distinct for each language, put the language string
66 const char * const language_string = "GNU Objective-C";
69 const char * const language_string = "GNU C";
72 /* Like YYERROR but do call yyerror. */
73 #define YYERROR1 { yyerror ("syntax error"); YYERROR; }
75 /* Cause the `yydebug' variable to be defined. */
81 %union {long itype; tree ttype; enum tree_code code;
82 const char *filename; int lineno; int ends_in_label; }
84 /* All identifiers that are not reserved words
85 and are not declared typedefs in the current block */
88 /* All identifiers that are declared typedefs in the current block.
89 In some contexts, they are treated just like IDENTIFIER,
90 but they can also serve as typespecs in declarations. */
93 /* Reserved words that specify storage class.
94 yylval contains an IDENTIFIER_NODE which indicates which one. */
97 /* Reserved words that specify type.
98 yylval contains an IDENTIFIER_NODE which indicates which one. */
101 /* Reserved words that qualify type: "const", "volatile", or "restrict".
102 yylval contains an IDENTIFIER_NODE which indicates which one. */
105 /* Character or numeric constants.
106 yylval is the node for the constant. */
109 /* String constants in raw form.
110 yylval is a STRING_CST node. */
113 /* "...", used for functions with variable arglists. */
116 /* the reserved words */
117 /* SCO include files test "ASM", so use something else. */
118 %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
119 %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF
120 %token ATTRIBUTE EXTENSION LABEL
121 %token REALPART IMAGPART VA_ARG
122 %token PTR_VALUE PTR_BASE PTR_EXTENT
124 /* Add precedence rules to solve dangling else s/r conflict */
128 /* Define the operator tokens and their precedences.
129 The value is an integer because, if used, it is the tree code
130 to use in the expression made from the operator. */
132 %right <code> ASSIGN '='
133 %right <code> '?' ':'
139 %left <code> EQCOMPARE
140 %left <code> ARITHCOMPARE
141 %left <code> LSHIFT RSHIFT
143 %left <code> '*' '/' '%'
144 %right <code> UNARY PLUSPLUS MINUSMINUS
146 %left <code> POINTSAT '.' '(' '['
148 /* The Objective-C keywords. These are included in C and in
149 Objective C, so that the token codes are the same in both. */
150 %token INTERFACE IMPLEMENTATION END SELECTOR DEFS ENCODE
151 %token CLASSNAME PUBLIC PRIVATE PROTECTED PROTOCOL OBJECTNAME CLASS ALIAS
153 /* Objective-C string constants in raw form.
154 yylval is an STRING_CST node. */
159 %type <ttype> ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
160 %type <ttype> BREAK CONTINUE RETURN GOTO ASM_KEYWORD SIZEOF TYPEOF ALIGNOF
162 %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist
163 %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING
164 %type <ttype> typed_declspecs reserved_declspecs
165 %type <ttype> typed_typespecs reserved_typespecquals
166 %type <ttype> declmods typespec typespecqual_reserved
167 %type <ttype> typed_declspecs_no_prefix_attr reserved_declspecs_no_prefix_attr
168 %type <ttype> declmods_no_prefix_attr
169 %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
170 %type <ttype> initdecls notype_initdecls initdcl notype_initdcl
171 %type <ttype> init maybeasm
172 %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
173 %type <ttype> maybe_attribute attributes attribute attribute_list attrib
174 %type <ttype> any_word extension
176 %type <ttype> compstmt compstmt_start compstmt_nostart compstmt_primary_start
177 %type <ttype> do_stmt_start poplevel
179 %type <ttype> declarator
180 %type <ttype> notype_declarator after_type_declarator
181 %type <ttype> parm_declarator
183 %type <ttype> structsp component_decl_list component_decl_list2
184 %type <ttype> component_decl components component_declarator
185 %type <ttype> enumlist enumerator
186 %type <ttype> struct_head union_head enum_head
187 %type <ttype> typename absdcl absdcl1 type_quals
188 %type <ttype> xexpr parms parm identifiers
190 %type <ttype> parmlist parmlist_1 parmlist_2
191 %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
192 %type <ttype> identifiers_or_typenames
194 %type <itype> setspecs
196 %type <ends_in_label> lineno_stmt_or_label lineno_stmt_or_labels stmt_or_label
198 %type <filename> save_filename
199 %type <lineno> save_lineno
202 /* the Objective-C nonterminals */
204 %type <ttype> ivar_decl_list ivar_decls ivar_decl ivars ivar_declarator
205 %type <ttype> methoddecl unaryselector keywordselector selector
206 %type <ttype> keyworddecl receiver objcmessageexpr messageargs
207 %type <ttype> keywordexpr keywordarglist keywordarg
208 %type <ttype> myparms myparm optparmlist reservedwords objcselectorexpr
209 %type <ttype> selectorarg keywordnamelist keywordname objcencodeexpr
210 %type <ttype> objc_string non_empty_protocolrefs protocolrefs identifier_list objcprotocolexpr
212 %type <ttype> CLASSNAME OBJC_STRING OBJECTNAME
216 /* Number of statements (loosely speaking) and compound statements
218 static int stmt_count;
219 static int compstmt_count;
221 /* Input file and line number of the end of the body of last simple_if;
222 used by the stmt-rule immediately after simple_if returns. */
223 static const char *if_stmt_file;
224 static int if_stmt_line;
226 /* List of types and structure classes of the current declaration. */
227 static tree current_declspecs = NULL_TREE;
228 static tree prefix_attributes = NULL_TREE;
230 /* Stack of saved values of current_declspecs and prefix_attributes. */
231 static tree declspec_stack;
233 /* For __extension__, save/restore the warning flags which are
234 controlled by __extension__. */
235 #define SAVE_WARN_FLAGS() \
236 size_int (pedantic | (warn_pointer_arith << 1))
237 #define RESTORE_WARN_FLAGS(tval) \
239 int val = tree_low_cst (tval, 0); \
240 pedantic = val & 1; \
241 warn_pointer_arith = (val >> 1) & 1; \
245 /* Objective-C specific information */
247 tree objc_interface_context;
248 tree objc_implementation_context;
249 tree objc_method_context;
250 tree objc_ivar_chain;
251 tree objc_ivar_context;
252 enum tree_code objc_inherit_code;
253 int objc_receiver_context;
254 int objc_public_flag;
258 /* Tell yyparse how to print a token's value, if yydebug is set. */
260 #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
262 static void yyprint PARAMS ((FILE *, int, YYSTYPE));
263 static void yyerror PARAMS ((const char *));
264 static inline int _yylex PARAMS ((void));
265 static int yylex PARAMS ((void));
266 static void init_reswords PARAMS ((void));
268 /* Add GC roots for variables local to this file. */
272 ggc_add_tree_root (&declspec_stack, 1);
273 ggc_add_tree_root (¤t_declspecs, 1);
274 ggc_add_tree_root (&prefix_attributes, 1);
276 ggc_add_tree_root (&objc_interface_context, 1);
277 ggc_add_tree_root (&objc_implementation_context, 1);
278 ggc_add_tree_root (&objc_method_context, 1);
279 ggc_add_tree_root (&objc_ivar_chain, 1);
280 ggc_add_tree_root (&objc_ivar_context, 1);
289 pedwarn ("ISO C forbids an empty source file");
294 /* In case there were missing closebraces,
295 get us back to the global binding level. */
296 while (! global_bindings_p ())
302 /* the reason for the strange actions in this rule
303 is so that notype_initdecls when reached via datadef
304 can find a valid list of type and sc specs in $0. */
307 {$<ttype>$ = NULL_TREE; } extdef
308 | extdefs {$<ttype>$ = NULL_TREE; ggc_collect(); } extdef
317 | ASM_KEYWORD '(' expr ')' ';'
319 if ((TREE_CODE ($3) == ADDR_EXPR
320 && TREE_CODE (TREE_OPERAND ($3, 0)) == STRING_CST)
321 || TREE_CODE ($3) == STRING_CST)
324 error ("argument of `asm' is not a constant string"); }
326 { RESTORE_WARN_FLAGS ($1); }
330 setspecs notype_initdecls ';'
332 error ("ISO C forbids data definition with no type or storage class");
333 else if (!flag_traditional)
334 warning ("data definition has no type or storage class");
336 current_declspecs = TREE_VALUE (declspec_stack);
337 prefix_attributes = TREE_PURPOSE (declspec_stack);
338 declspec_stack = TREE_CHAIN (declspec_stack); }
339 | declmods setspecs notype_initdecls ';'
340 { current_declspecs = TREE_VALUE (declspec_stack);
341 prefix_attributes = TREE_PURPOSE (declspec_stack);
342 declspec_stack = TREE_CHAIN (declspec_stack); }
343 | typed_declspecs setspecs initdecls ';'
344 { current_declspecs = TREE_VALUE (declspec_stack);
345 prefix_attributes = TREE_PURPOSE (declspec_stack);
346 declspec_stack = TREE_CHAIN (declspec_stack); }
348 { pedwarn ("empty declaration"); }
349 | typed_declspecs ';'
355 pedwarn ("ISO C does not allow extra `;' outside of a function"); }
359 typed_declspecs setspecs declarator
360 { if (! start_function (current_declspecs, $3,
361 prefix_attributes, NULL_TREE))
365 { store_parm_decls (); }
367 { finish_function (0);
368 current_declspecs = TREE_VALUE (declspec_stack);
369 prefix_attributes = TREE_PURPOSE (declspec_stack);
370 declspec_stack = TREE_CHAIN (declspec_stack); }
371 | typed_declspecs setspecs declarator error
372 { current_declspecs = TREE_VALUE (declspec_stack);
373 prefix_attributes = TREE_PURPOSE (declspec_stack);
374 declspec_stack = TREE_CHAIN (declspec_stack); }
375 | declmods setspecs notype_declarator
376 { if (! start_function (current_declspecs, $3,
377 prefix_attributes, NULL_TREE))
381 { store_parm_decls (); }
383 { finish_function (0);
384 current_declspecs = TREE_VALUE (declspec_stack);
385 prefix_attributes = TREE_PURPOSE (declspec_stack);
386 declspec_stack = TREE_CHAIN (declspec_stack); }
387 | declmods setspecs notype_declarator error
388 { current_declspecs = TREE_VALUE (declspec_stack);
389 prefix_attributes = TREE_PURPOSE (declspec_stack);
390 declspec_stack = TREE_CHAIN (declspec_stack); }
391 | setspecs notype_declarator
392 { if (! start_function (NULL_TREE, $2,
393 prefix_attributes, NULL_TREE))
397 { store_parm_decls (); }
399 { finish_function (0);
400 current_declspecs = TREE_VALUE (declspec_stack);
401 prefix_attributes = TREE_PURPOSE (declspec_stack);
402 declspec_stack = TREE_CHAIN (declspec_stack); }
403 | setspecs notype_declarator error
404 { current_declspecs = TREE_VALUE (declspec_stack);
405 prefix_attributes = TREE_PURPOSE (declspec_stack);
406 declspec_stack = TREE_CHAIN (declspec_stack); }
421 { $$ = NEGATE_EXPR; }
425 if (warn_traditional && !in_system_header)
426 warning ("traditional C rejects the unary plus operator");
430 { $$ = PREINCREMENT_EXPR; }
432 { $$ = PREDECREMENT_EXPR; }
434 { $$ = BIT_NOT_EXPR; }
436 { $$ = TRUTH_NOT_EXPR; }
439 expr: nonnull_exprlist
440 { $$ = build_compound_expr ($1); }
451 { $$ = build_tree_list (NULL_TREE, $1); }
452 | nonnull_exprlist ',' expr_no_commas
453 { chainon ($1, build_tree_list (NULL_TREE, $3)); }
458 | '*' cast_expr %prec UNARY
459 { $$ = build_indirect_ref ($2, "unary *"); }
460 /* __extension__ turns off -pedantic for following primary. */
461 | extension cast_expr %prec UNARY
463 RESTORE_WARN_FLAGS ($1); }
464 | unop cast_expr %prec UNARY
465 { $$ = build_unary_op ($1, $2, 0);
466 overflow_warning ($$); }
467 /* Refer to the address of a label as a pointer. */
469 { tree label = lookup_label ($2);
471 pedwarn ("ISO C forbids `&&'");
473 $$ = null_pointer_node;
476 TREE_USED (label) = 1;
477 $$ = build1 (ADDR_EXPR, ptr_type_node, label);
478 TREE_CONSTANT ($$) = 1;
481 /* This seems to be impossible on some machines, so let's turn it off.
482 You can use __builtin_next_arg to find the anonymous stack args.
484 { tree types = TYPE_ARG_TYPES (TREE_TYPE (current_function_decl));
485 $$ = error_mark_node;
486 if (TREE_VALUE (tree_last (types)) == void_type_node)
487 error ("`&...' used in function with fixed number of arguments");
491 pedwarn ("ISO C forbids `&...'");
492 $$ = tree_last (DECL_ARGUMENTS (current_function_decl));
493 $$ = build_unary_op (ADDR_EXPR, $$, 0);
496 | sizeof unary_expr %prec UNARY
498 if (TREE_CODE ($2) == COMPONENT_REF
499 && DECL_C_BIT_FIELD (TREE_OPERAND ($2, 1)))
500 error ("`sizeof' applied to a bit-field");
501 $$ = c_sizeof (TREE_TYPE ($2)); }
502 | sizeof '(' typename ')' %prec HYPERUNARY
504 $$ = c_sizeof (groktypename ($3)); }
505 | alignof unary_expr %prec UNARY
507 $$ = c_alignof_expr ($2); }
508 | alignof '(' typename ')' %prec HYPERUNARY
510 $$ = c_alignof (groktypename ($3)); }
511 | REALPART cast_expr %prec UNARY
512 { $$ = build_unary_op (REALPART_EXPR, $2, 0); }
513 | IMAGPART cast_expr %prec UNARY
514 { $$ = build_unary_op (IMAGPART_EXPR, $2, 0); }
515 | VA_ARG '(' expr_no_commas ',' typename ')'
516 { $$ = build_va_arg ($3, groktypename ($5)); }
520 SIZEOF { skip_evaluation++; }
524 ALIGNOF { skip_evaluation++; }
529 | '(' typename ')' cast_expr %prec UNARY
531 int SAVED_warn_strict_prototypes = warn_strict_prototypes;
532 /* This avoids warnings about unprototyped casts on
533 integers. E.g. "#define SIG_DFL (void(*)())0". */
534 if (TREE_CODE ($4) == INTEGER_CST)
535 warn_strict_prototypes = 0;
536 type = groktypename ($2);
537 warn_strict_prototypes = SAVED_warn_strict_prototypes;
538 $$ = build_c_cast (type, $4); }
539 | '(' typename ')' '{'
540 { start_init (NULL_TREE, NULL, 0);
541 $2 = groktypename ($2);
542 really_start_incremental_init ($2); }
543 initlist_maybe_comma '}' %prec UNARY
545 tree result = pop_init_level (0);
549 if (pedantic && ! flag_isoc99)
550 pedwarn ("ISO C89 forbids constructor expressions");
551 if (TYPE_NAME (type) != 0)
553 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
554 name = IDENTIFIER_POINTER (TYPE_NAME (type));
556 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
561 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
563 int failure = complete_array_type (type, $$, 1);
572 | expr_no_commas '+' expr_no_commas
573 { $$ = parser_build_binary_op ($2, $1, $3); }
574 | expr_no_commas '-' expr_no_commas
575 { $$ = parser_build_binary_op ($2, $1, $3); }
576 | expr_no_commas '*' expr_no_commas
577 { $$ = parser_build_binary_op ($2, $1, $3); }
578 | expr_no_commas '/' expr_no_commas
579 { $$ = parser_build_binary_op ($2, $1, $3); }
580 | expr_no_commas '%' expr_no_commas
581 { $$ = parser_build_binary_op ($2, $1, $3); }
582 | expr_no_commas LSHIFT expr_no_commas
583 { $$ = parser_build_binary_op ($2, $1, $3); }
584 | expr_no_commas RSHIFT expr_no_commas
585 { $$ = parser_build_binary_op ($2, $1, $3); }
586 | expr_no_commas ARITHCOMPARE expr_no_commas
587 { $$ = parser_build_binary_op ($2, $1, $3); }
588 | expr_no_commas EQCOMPARE expr_no_commas
589 { $$ = parser_build_binary_op ($2, $1, $3); }
590 | expr_no_commas '&' expr_no_commas
591 { $$ = parser_build_binary_op ($2, $1, $3); }
592 | expr_no_commas '|' expr_no_commas
593 { $$ = parser_build_binary_op ($2, $1, $3); }
594 | expr_no_commas '^' expr_no_commas
595 { $$ = parser_build_binary_op ($2, $1, $3); }
596 | expr_no_commas ANDAND
597 { $1 = truthvalue_conversion (default_conversion ($1));
598 skip_evaluation += $1 == boolean_false_node; }
600 { skip_evaluation -= $1 == boolean_false_node;
601 $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $4); }
602 | expr_no_commas OROR
603 { $1 = truthvalue_conversion (default_conversion ($1));
604 skip_evaluation += $1 == boolean_true_node; }
606 { skip_evaluation -= $1 == boolean_true_node;
607 $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $4); }
609 { $1 = truthvalue_conversion (default_conversion ($1));
610 skip_evaluation += $1 == boolean_false_node; }
612 { skip_evaluation += (($1 == boolean_true_node)
613 - ($1 == boolean_false_node)); }
615 { skip_evaluation -= $1 == boolean_true_node;
616 $$ = build_conditional_expr ($1, $4, $7); }
619 pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
620 /* Make sure first operand is calculated only once. */
621 $<ttype>2 = save_expr ($1);
622 $1 = truthvalue_conversion (default_conversion ($<ttype>2));
623 skip_evaluation += $1 == boolean_true_node; }
625 { skip_evaluation -= $1 == boolean_true_node;
626 $$ = build_conditional_expr ($1, $<ttype>2, $5); }
627 | expr_no_commas '=' expr_no_commas
629 $$ = build_modify_expr ($1, NOP_EXPR, $3);
630 class = TREE_CODE_CLASS (TREE_CODE ($$));
631 if (class == 'e' || class == '1'
632 || class == '2' || class == '<')
633 C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR);
635 | expr_no_commas ASSIGN expr_no_commas
637 $$ = build_modify_expr ($1, $2, $3);
638 /* This inhibits warnings in truthvalue_conversion. */
639 class = TREE_CODE_CLASS (TREE_CODE ($$));
640 if (class == 'e' || class == '1'
641 || class == '2' || class == '<')
642 C_SET_EXP_ORIGINAL_CODE ($$, ERROR_MARK);
649 if (yychar == YYEMPTY)
651 $$ = build_external_ref ($1, yychar == '(');
655 { $$ = combine_strings ($1); }
657 { char class = TREE_CODE_CLASS (TREE_CODE ($2));
658 if (class == 'e' || class == '1'
659 || class == '2' || class == '<')
660 C_SET_EXP_ORIGINAL_CODE ($2, ERROR_MARK);
663 { $$ = error_mark_node; }
664 | compstmt_primary_start compstmt_nostart ')'
665 { tree saved_last_tree;
668 pedwarn ("ISO C forbids braced-groups within expressions");
671 saved_last_tree = COMPOUND_BODY ($1);
672 RECHAIN_STMTS ($1, COMPOUND_BODY ($1));
673 last_tree = saved_last_tree;
674 TREE_CHAIN (last_tree) = NULL_TREE;
676 last_expr_type = void_type_node;
677 $$ = build1 (STMT_EXPR, last_expr_type, $1);
678 TREE_SIDE_EFFECTS ($$) = 1;
680 | compstmt_primary_start error ')'
683 last_tree = COMPOUND_BODY ($1);
684 TREE_CHAIN (last_tree) = NULL_TREE;
685 $$ = error_mark_node;
687 | primary '(' exprlist ')' %prec '.'
688 { $$ = build_function_call ($1, $3); }
689 | primary '[' expr ']' %prec '.'
690 { $$ = build_array_ref ($1, $3); }
691 | primary '.' identifier
694 if (doing_objc_thang)
696 if (is_public ($1, $3))
697 $$ = build_component_ref ($1, $3);
699 $$ = error_mark_node;
703 $$ = build_component_ref ($1, $3);
705 | primary POINTSAT identifier
707 tree expr = build_indirect_ref ($1, "->");
710 if (doing_objc_thang)
712 if (is_public (expr, $3))
713 $$ = build_component_ref (expr, $3);
715 $$ = error_mark_node;
719 $$ = build_component_ref (expr, $3);
722 { $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); }
724 { $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); }
727 { $$ = build_message_expr ($1); }
729 { $$ = build_selector_expr ($1); }
731 { $$ = build_protocol_expr ($1); }
733 { $$ = build_encode_expr ($1); }
735 { $$ = build_objc_string_object ($1); }
739 /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */
745 static int last_lineno = 0;
746 static const char *last_input_filename = 0;
748 $$ = chainon ($1, $2);
750 if (warn_traditional && !in_system_header
751 && (lineno != last_lineno || !last_input_filename ||
752 strcmp (last_input_filename, input_filename)))
754 warning ("traditional C rejects string concatenation");
755 last_lineno = lineno;
756 last_input_filename = input_filename;
763 /* Produces an STRING_CST with perhaps more STRING_CSTs chained
764 onto it, which is to be read as an ObjC string object. */
767 | objc_string OBJC_STRING
768 { $$ = chainon ($1, $2); }
772 old_style_parm_decls:
776 /* ... is used here to indicate a varargs function. */
779 pedwarn ("ISO C does not permit use of `varargs.h'"); }
782 /* The following are analogous to lineno_decl, decls and decl
783 except that they do not allow nested functions.
784 They are used for old-style parm decls. */
786 save_filename save_lineno datadecl
793 | datadecls lineno_datadecl
794 | lineno_datadecl errstmt
797 /* We don't allow prefix attributes here because they cause reduce/reduce
798 conflicts: we can't know whether we're parsing a function decl with
799 attribute suffix, or function defn with attribute prefix on first old
802 typed_declspecs_no_prefix_attr setspecs initdecls ';'
803 { current_declspecs = TREE_VALUE (declspec_stack);
804 prefix_attributes = TREE_PURPOSE (declspec_stack);
805 declspec_stack = TREE_CHAIN (declspec_stack); }
806 | declmods_no_prefix_attr setspecs notype_initdecls ';'
807 { current_declspecs = TREE_VALUE (declspec_stack);
808 prefix_attributes = TREE_PURPOSE (declspec_stack);
809 declspec_stack = TREE_CHAIN (declspec_stack); }
810 | typed_declspecs_no_prefix_attr ';'
811 { shadow_tag_warned ($1, 1);
812 pedwarn ("empty declaration"); }
813 | declmods_no_prefix_attr ';'
814 { pedwarn ("empty declaration"); }
817 /* This combination which saves a lineno before a decl
818 is the normal thing to use, rather than decl itself.
819 This is to avoid shift/reduce conflicts in contexts
820 where statement labels are allowed. */
822 save_filename save_lineno decl
830 | lineno_decl errstmt
833 /* records the type and storage class specs to use for processing
834 the declarators that follow.
835 Maintains a stack of outer-level values of current_declspecs,
836 for the sake of parm declarations nested in function declarators. */
837 setspecs: /* empty */
838 { pending_xref_error ();
839 declspec_stack = tree_cons (prefix_attributes,
842 split_specs_attrs ($<ttype>0,
843 ¤t_declspecs, &prefix_attributes); }
846 /* ??? Yuck. See after_type_declarator. */
847 setattrs: /* empty */
848 { prefix_attributes = chainon (prefix_attributes, $<ttype>0); }
852 typed_declspecs setspecs initdecls ';'
853 { current_declspecs = TREE_VALUE (declspec_stack);
854 prefix_attributes = TREE_PURPOSE (declspec_stack);
855 declspec_stack = TREE_CHAIN (declspec_stack); }
856 | declmods setspecs notype_initdecls ';'
857 { current_declspecs = TREE_VALUE (declspec_stack);
858 prefix_attributes = TREE_PURPOSE (declspec_stack);
859 declspec_stack = TREE_CHAIN (declspec_stack); }
860 | typed_declspecs setspecs nested_function
861 { current_declspecs = TREE_VALUE (declspec_stack);
862 prefix_attributes = TREE_PURPOSE (declspec_stack);
863 declspec_stack = TREE_CHAIN (declspec_stack); }
864 | declmods setspecs notype_nested_function
865 { current_declspecs = TREE_VALUE (declspec_stack);
866 prefix_attributes = TREE_PURPOSE (declspec_stack);
867 declspec_stack = TREE_CHAIN (declspec_stack); }
868 | typed_declspecs ';'
871 { pedwarn ("empty declaration"); }
873 { RESTORE_WARN_FLAGS ($1); }
876 /* Declspecs which contain at least one type specifier or typedef name.
877 (Just `const' or `volatile' is not enough.)
878 A typedef'd name following these is taken as a name to be declared.
879 Declspecs have a non-NULL TREE_VALUE, attributes do not. */
882 typespec reserved_declspecs
883 { $$ = tree_cons (NULL_TREE, $1, $2); }
884 | declmods typespec reserved_declspecs
885 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
888 reserved_declspecs: /* empty */
890 | reserved_declspecs typespecqual_reserved
891 { $$ = tree_cons (NULL_TREE, $2, $1); }
892 | reserved_declspecs SCSPEC
893 { if (extra_warnings)
894 warning ("`%s' is not at beginning of declaration",
895 IDENTIFIER_POINTER ($2));
896 $$ = tree_cons (NULL_TREE, $2, $1); }
897 | reserved_declspecs attributes
898 { $$ = tree_cons ($2, NULL_TREE, $1); }
901 typed_declspecs_no_prefix_attr:
902 typespec reserved_declspecs_no_prefix_attr
903 { $$ = tree_cons (NULL_TREE, $1, $2); }
904 | declmods_no_prefix_attr typespec reserved_declspecs_no_prefix_attr
905 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
908 reserved_declspecs_no_prefix_attr:
911 | reserved_declspecs_no_prefix_attr typespecqual_reserved
912 { $$ = tree_cons (NULL_TREE, $2, $1); }
913 | reserved_declspecs_no_prefix_attr SCSPEC
914 { if (extra_warnings)
915 warning ("`%s' is not at beginning of declaration",
916 IDENTIFIER_POINTER ($2));
917 $$ = tree_cons (NULL_TREE, $2, $1); }
920 /* List of just storage classes, type modifiers, and prefix attributes.
921 A declaration can start with just this, but then it cannot be used
922 to redeclare a typedef-name.
923 Declspecs have a non-NULL TREE_VALUE, attributes do not. */
926 declmods_no_prefix_attr
929 { $$ = tree_cons ($1, NULL_TREE, NULL_TREE); }
930 | declmods declmods_no_prefix_attr
931 { $$ = chainon ($2, $1); }
932 | declmods attributes
933 { $$ = tree_cons ($2, NULL_TREE, $1); }
936 declmods_no_prefix_attr:
938 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
939 TREE_STATIC ($$) = 1; }
941 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
942 | declmods_no_prefix_attr TYPE_QUAL
943 { $$ = tree_cons (NULL_TREE, $2, $1);
944 TREE_STATIC ($$) = 1; }
945 | declmods_no_prefix_attr SCSPEC
946 { if (extra_warnings && TREE_STATIC ($1))
947 warning ("`%s' is not at beginning of declaration",
948 IDENTIFIER_POINTER ($2));
949 $$ = tree_cons (NULL_TREE, $2, $1);
950 TREE_STATIC ($$) = TREE_STATIC ($1); }
954 /* Used instead of declspecs where storage classes are not allowed
955 (that is, for typenames and structure components).
956 Don't accept a typedef-name if anything but a modifier precedes it. */
959 typespec reserved_typespecquals
960 { $$ = tree_cons (NULL_TREE, $1, $2); }
961 | nonempty_type_quals typespec reserved_typespecquals
962 { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
965 reserved_typespecquals: /* empty */
967 | reserved_typespecquals typespecqual_reserved
968 { $$ = tree_cons (NULL_TREE, $2, $1); }
971 /* A typespec (but not a type qualifier).
972 Once we have seen one of these in a declaration,
973 if a typedef name appears then it is being redeclared. */
978 { /* For a typedef name, record the meaning, not the name.
979 In case of `foo foo, bar;'. */
980 $$ = lookup_name ($1); }
982 | CLASSNAME protocolrefs
983 { $$ = get_static_reference ($1, $2); }
984 | OBJECTNAME protocolrefs
985 { $$ = get_object_reference ($2); }
987 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>"
988 - nisse@lysator.liu.se */
989 | non_empty_protocolrefs
990 { $$ = get_object_reference ($1); }
992 | TYPEOF '(' expr ')'
993 { $$ = TREE_TYPE ($3); }
994 | TYPEOF '(' typename ')'
995 { $$ = groktypename ($3); }
998 /* A typespec that is a reserved word, or a type qualifier. */
1000 typespecqual_reserved: TYPESPEC
1007 | initdecls ',' initdcl
1012 | notype_initdecls ',' initdcl
1018 | ASM_KEYWORD '(' string ')'
1019 { if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
1025 declarator maybeasm maybe_attribute '='
1026 { $<ttype>$ = start_decl ($1, current_declspecs, 1,
1027 $3, prefix_attributes);
1028 start_init ($<ttype>$, $2, global_bindings_p ()); }
1030 /* Note how the declaration of the variable is in effect while its init is parsed! */
1032 finish_decl ($<ttype>5, $6, $2); }
1033 | declarator maybeasm maybe_attribute
1034 { tree d = start_decl ($1, current_declspecs, 0,
1035 $3, prefix_attributes);
1036 finish_decl (d, NULL_TREE, $2);
1041 notype_declarator maybeasm maybe_attribute '='
1042 { $<ttype>$ = start_decl ($1, current_declspecs, 1,
1043 $3, prefix_attributes);
1044 start_init ($<ttype>$, $2, global_bindings_p ()); }
1046 /* Note how the declaration of the variable is in effect while its init is parsed! */
1048 decl_attributes ($<ttype>5, $3, prefix_attributes);
1049 finish_decl ($<ttype>5, $6, $2); }
1050 | notype_declarator maybeasm maybe_attribute
1051 { tree d = start_decl ($1, current_declspecs, 0,
1052 $3, prefix_attributes);
1053 finish_decl (d, NULL_TREE, $2); }
1055 /* the * rules are dummies to accept the Apollo extended syntax
1056 so that the header files compile. */
1067 | attributes attribute
1068 { $$ = chainon ($1, $2); }
1072 ATTRIBUTE '(' '(' attribute_list ')' ')'
1079 | attribute_list ',' attrib
1080 { $$ = chainon ($1, $3); }
1087 { $$ = build_tree_list ($1, NULL_TREE); }
1088 | any_word '(' IDENTIFIER ')'
1089 { $$ = build_tree_list ($1, build_tree_list (NULL_TREE, $3)); }
1090 | any_word '(' IDENTIFIER ',' nonnull_exprlist ')'
1091 { $$ = build_tree_list ($1, tree_cons (NULL_TREE, $3, $5)); }
1092 | any_word '(' exprlist ')'
1093 { $$ = build_tree_list ($1, $3); }
1096 /* This still leaves out most reserved keywords,
1097 shouldn't we include them? */
1106 /* Initializers. `init' is the entry point. */
1111 { really_start_incremental_init (NULL_TREE); }
1112 initlist_maybe_comma '}'
1113 { $$ = pop_init_level (0); }
1115 { $$ = error_mark_node; }
1118 /* `initlist_maybe_comma' is the guts of an initializer in braces. */
1119 initlist_maybe_comma:
1122 pedwarn ("ISO C forbids empty initializer braces"); }
1123 | initlist1 maybecomma
1128 | initlist1 ',' initelt
1131 /* `initelt' is a single element of an initializer.
1132 It may use braces. */
1134 designator_list '=' initval
1135 { if (pedantic && ! flag_isoc99)
1136 pedwarn ("ISO C89 forbids specifying subobject to initialize"); }
1137 | designator initval
1139 pedwarn ("obsolete use of designated initializer without `='"); }
1141 { set_init_label ($1);
1143 pedwarn ("obsolete use of designated initializer with `:'"); }
1150 { push_init_level (0); }
1151 initlist_maybe_comma '}'
1152 { process_init_element (pop_init_level (0)); }
1154 { process_init_element ($1); }
1160 | designator_list designator
1165 { set_init_label ($2); }
1166 /* These are for labeled elements. The syntax for an array element
1167 initializer conflicts with the syntax for an Objective-C message,
1168 so don't include these productions in the Objective-C grammar. */
1170 | '[' expr_no_commas ELLIPSIS expr_no_commas ']'
1171 { set_init_index ($2, $4);
1173 pedwarn ("ISO C forbids specifying range of elements to initialize"); }
1174 | '[' expr_no_commas ']'
1175 { set_init_index ($2, NULL_TREE); }
1182 pedwarn ("ISO C forbids nested functions");
1184 push_function_context ();
1185 if (! start_function (current_declspecs, $1,
1186 prefix_attributes, NULL_TREE))
1188 pop_function_context ();
1192 old_style_parm_decls
1193 { store_parm_decls (); }
1194 /* This used to use compstmt_or_error.
1195 That caused a bug with input `f(g) int g {}',
1196 where the use of YYERROR1 above caused an error
1197 which then was handled by compstmt_or_error.
1198 There followed a repeated execution of that same rule,
1199 which called YYERROR1 again, and so on. */
1201 { tree decl = current_function_decl;
1202 finish_function (1);
1203 pop_function_context ();
1204 add_decl_stmt (decl); }
1207 notype_nested_function:
1210 pedwarn ("ISO C forbids nested functions");
1212 push_function_context ();
1213 if (! start_function (current_declspecs, $1,
1214 prefix_attributes, NULL_TREE))
1216 pop_function_context ();
1220 old_style_parm_decls
1221 { store_parm_decls (); }
1222 /* This used to use compstmt_or_error.
1223 That caused a bug with input `f(g) int g {}',
1224 where the use of YYERROR1 above caused an error
1225 which then was handled by compstmt_or_error.
1226 There followed a repeated execution of that same rule,
1227 which called YYERROR1 again, and so on. */
1229 { tree decl = current_function_decl;
1230 finish_function (1);
1231 pop_function_context ();
1232 add_decl_stmt (decl); }
1235 /* Any kind of declarator (thus, all declarators allowed
1236 after an explicit typespec). */
1239 after_type_declarator
1243 /* A declarator that is allowed only after an explicit typespec. */
1245 after_type_declarator:
1246 '(' after_type_declarator ')'
1248 | after_type_declarator '(' parmlist_or_identifiers %prec '.'
1249 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1250 /* | after_type_declarator '(' error ')' %prec '.'
1251 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1252 poplevel (0, 0, 0); } */
1253 | after_type_declarator '[' expr ']' %prec '.'
1254 { $$ = build_nt (ARRAY_REF, $1, $3); }
1255 | after_type_declarator '[' ']' %prec '.'
1256 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1257 | '*' type_quals after_type_declarator %prec UNARY
1258 { $$ = make_pointer_declarator ($2, $3); }
1259 /* ??? Yuck. setattrs is a quick hack. We can't use
1260 prefix_attributes because $1 only applies to this
1261 declarator. We assume setspecs has already been done.
1262 setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1263 attributes could be recognized here or in `attributes'). */
1264 | attributes setattrs after_type_declarator
1272 /* Kinds of declarator that can appear in a parameter list
1273 in addition to notype_declarator. This is like after_type_declarator
1274 but does not allow a typedef name in parentheses as an identifier
1275 (because it would conflict with a function with that typedef as arg). */
1278 parm_declarator '(' parmlist_or_identifiers %prec '.'
1279 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1280 /* | parm_declarator '(' error ')' %prec '.'
1281 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1282 poplevel (0, 0, 0); } */
1284 | parm_declarator '[' '*' ']' %prec '.'
1285 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE);
1287 error ("`[*]' in parameter declaration only allowed in ISO C 99");
1290 | parm_declarator '[' expr ']' %prec '.'
1291 { $$ = build_nt (ARRAY_REF, $1, $3); }
1292 | parm_declarator '[' ']' %prec '.'
1293 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1294 | '*' type_quals parm_declarator %prec UNARY
1295 { $$ = make_pointer_declarator ($2, $3); }
1296 /* ??? Yuck. setattrs is a quick hack. We can't use
1297 prefix_attributes because $1 only applies to this
1298 declarator. We assume setspecs has already been done.
1299 setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1300 attributes could be recognized here or in `attributes'). */
1301 | attributes setattrs parm_declarator
1306 /* A declarator allowed whether or not there has been
1307 an explicit typespec. These cannot redeclare a typedef-name. */
1310 notype_declarator '(' parmlist_or_identifiers %prec '.'
1311 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1312 /* | notype_declarator '(' error ')' %prec '.'
1313 { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
1314 poplevel (0, 0, 0); } */
1315 | '(' notype_declarator ')'
1317 | '*' type_quals notype_declarator %prec UNARY
1318 { $$ = make_pointer_declarator ($2, $3); }
1320 | notype_declarator '[' '*' ']' %prec '.'
1321 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE);
1323 error ("`[*]' in parameter declaration only allowed in ISO C 99");
1326 | notype_declarator '[' expr ']' %prec '.'
1327 { $$ = build_nt (ARRAY_REF, $1, $3); }
1328 | notype_declarator '[' ']' %prec '.'
1329 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1330 /* ??? Yuck. setattrs is a quick hack. We can't use
1331 prefix_attributes because $1 only applies to this
1332 declarator. We assume setspecs has already been done.
1333 setattrs also avoids 5 reduce/reduce conflicts (otherwise multiple
1334 attributes could be recognized here or in `attributes'). */
1335 | attributes setattrs notype_declarator
1362 struct_head identifier '{'
1363 { $$ = start_struct (RECORD_TYPE, $2);
1364 /* Start scope of tag before parsing components. */
1366 component_decl_list '}' maybe_attribute
1367 { $$ = finish_struct ($<ttype>4, $5, chainon ($1, $7)); }
1368 | struct_head '{' component_decl_list '}' maybe_attribute
1369 { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
1370 $3, chainon ($1, $5));
1372 | struct_head identifier
1373 { $$ = xref_tag (RECORD_TYPE, $2); }
1374 | union_head identifier '{'
1375 { $$ = start_struct (UNION_TYPE, $2); }
1376 component_decl_list '}' maybe_attribute
1377 { $$ = finish_struct ($<ttype>4, $5, chainon ($1, $7)); }
1378 | union_head '{' component_decl_list '}' maybe_attribute
1379 { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
1380 $3, chainon ($1, $5));
1382 | union_head identifier
1383 { $$ = xref_tag (UNION_TYPE, $2); }
1384 | enum_head identifier '{'
1385 { $$ = start_enum ($2); }
1386 enumlist maybecomma_warn '}' maybe_attribute
1387 { $$ = finish_enum ($<ttype>4, nreverse ($5),
1388 chainon ($1, $8)); }
1390 { $$ = start_enum (NULL_TREE); }
1391 enumlist maybecomma_warn '}' maybe_attribute
1392 { $$ = finish_enum ($<ttype>3, nreverse ($4),
1393 chainon ($1, $7)); }
1394 | enum_head identifier
1395 { $$ = xref_tag (ENUMERAL_TYPE, $2); }
1406 { if (pedantic && ! flag_isoc99)
1407 pedwarn ("comma at end of enumerator list"); }
1410 component_decl_list:
1411 component_decl_list2
1413 | component_decl_list2 component_decl
1414 { $$ = chainon ($1, $2);
1415 pedwarn ("no semicolon at end of struct or union"); }
1418 component_decl_list2: /* empty */
1420 | component_decl_list2 component_decl ';'
1421 { $$ = chainon ($1, $2); }
1422 | component_decl_list2 ';'
1424 pedwarn ("extra semicolon in struct or union specified"); }
1426 /* foo(sizeof(struct{ @defs(ClassName)})); */
1427 | DEFS '(' CLASSNAME ')'
1429 tree interface = lookup_interface ($3);
1432 $$ = get_class_ivars (interface);
1435 error ("Cannot find interface declaration for `%s'",
1436 IDENTIFIER_POINTER ($3));
1443 /* There is a shift-reduce conflict here, because `components' may
1444 start with a `typename'. It happens that shifting (the default resolution)
1445 does the right thing, because it treats the `typename' as part of
1446 a `typed_typespecs'.
1448 It is possible that this same technique would allow the distinction
1449 between `notype_initdecls' and `initdecls' to be eliminated.
1450 But I am being cautious and not trying it. */
1453 typed_typespecs setspecs components
1455 current_declspecs = TREE_VALUE (declspec_stack);
1456 prefix_attributes = TREE_PURPOSE (declspec_stack);
1457 declspec_stack = TREE_CHAIN (declspec_stack); }
1458 | typed_typespecs setspecs save_filename save_lineno maybe_attribute
1460 /* Support for unnamed structs or unions as members of
1461 structs or unions (which is [a] useful and [b] supports
1464 pedwarn ("ISO C doesn't support unnamed structs/unions");
1466 $$ = grokfield($3, $4, NULL, current_declspecs, NULL_TREE);
1467 current_declspecs = TREE_VALUE (declspec_stack);
1468 prefix_attributes = TREE_PURPOSE (declspec_stack);
1469 declspec_stack = TREE_CHAIN (declspec_stack);
1471 | nonempty_type_quals setspecs components
1473 current_declspecs = TREE_VALUE (declspec_stack);
1474 prefix_attributes = TREE_PURPOSE (declspec_stack);
1475 declspec_stack = TREE_CHAIN (declspec_stack); }
1476 | nonempty_type_quals
1478 pedwarn ("ISO C forbids member declarations with no members");
1483 | extension component_decl
1485 RESTORE_WARN_FLAGS ($1); }
1489 component_declarator
1490 | components ',' component_declarator
1491 { $$ = chainon ($1, $3); }
1494 component_declarator:
1495 save_filename save_lineno declarator maybe_attribute
1496 { $$ = grokfield ($1, $2, $3, current_declspecs, NULL_TREE);
1497 decl_attributes ($$, $4, prefix_attributes); }
1498 | save_filename save_lineno
1499 declarator ':' expr_no_commas maybe_attribute
1500 { $$ = grokfield ($1, $2, $3, current_declspecs, $5);
1501 decl_attributes ($$, $6, prefix_attributes); }
1502 | save_filename save_lineno ':' expr_no_commas maybe_attribute
1503 { $$ = grokfield ($1, $2, NULL_TREE, current_declspecs, $4);
1504 decl_attributes ($$, $5, prefix_attributes); }
1507 /* We chain the enumerators in reverse order.
1508 They are put in forward order where enumlist is used.
1509 (The order used to be significant, but no longer is so.
1510 However, we still maintain the order, just to be clean.) */
1514 | enumlist ',' enumerator
1515 { if ($1 == error_mark_node)
1518 $$ = chainon ($3, $1); }
1520 { $$ = error_mark_node; }
1526 { $$ = build_enumerator ($1, NULL_TREE); }
1527 | identifier '=' expr_no_commas
1528 { $$ = build_enumerator ($1, $3); }
1532 typed_typespecs absdcl
1533 { $$ = build_tree_list ($1, $2); }
1534 | nonempty_type_quals absdcl
1535 { $$ = build_tree_list ($1, $2); }
1538 absdcl: /* an absolute declarator */
1544 nonempty_type_quals:
1546 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
1547 | nonempty_type_quals TYPE_QUAL
1548 { $$ = tree_cons (NULL_TREE, $2, $1); }
1554 | type_quals TYPE_QUAL
1555 { $$ = tree_cons (NULL_TREE, $2, $1); }
1558 absdcl1: /* a nonempty absolute declarator */
1561 /* `(typedef)1' is `int'. */
1562 | '*' type_quals absdcl1 %prec UNARY
1563 { $$ = make_pointer_declarator ($2, $3); }
1564 | '*' type_quals %prec UNARY
1565 { $$ = make_pointer_declarator ($2, NULL_TREE); }
1566 | absdcl1 '(' parmlist %prec '.'
1567 { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1568 | absdcl1 '[' expr ']' %prec '.'
1569 { $$ = build_nt (ARRAY_REF, $1, $3); }
1570 | absdcl1 '[' ']' %prec '.'
1571 { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1572 | '(' parmlist %prec '.'
1573 { $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); }
1574 | '[' expr ']' %prec '.'
1575 { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); }
1577 { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); }
1578 /* ??? It appears we have to support attributes here, however
1579 using prefix_attributes is wrong. */
1580 | attributes setattrs absdcl1
1584 /* at least one statement, the first of which parses without error. */
1585 /* stmts is used only after decls, so an invalid first statement
1586 is actually regarded as an invalid decl and part of the decls. */
1589 lineno_stmt_or_labels
1592 pedwarn ("ISO C forbids label at end of compound statement");
1596 lineno_stmt_or_labels:
1597 lineno_stmt_or_label
1598 | lineno_stmt_or_labels lineno_stmt_or_label
1600 | lineno_stmt_or_labels errstmt
1612 pushlevel: /* empty */
1615 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
1617 if (objc_method_context)
1623 poplevel: /* empty */
1624 { $$ = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0); }
1626 /* Read zero or more forward-declarations for labels
1627 that nested functions can jump to. */
1632 pedwarn ("ISO C forbids label declarations"); }
1637 | label_decls label_decl
1641 LABEL identifiers_or_typenames ';'
1643 for (link = $2; link; link = TREE_CHAIN (link))
1645 tree label = shadow_label (TREE_VALUE (link));
1646 C_DECLARED_LABEL_FLAG (label) = 1;
1647 add_decl_stmt (label);
1652 /* This is the body of a function definition.
1653 It causes syntax errors to ignore to the next openbrace. */
1660 compstmt_start: '{' { compstmt_count++;
1661 $$ = c_begin_compound_stmt (); }
1663 compstmt_nostart: '}'
1664 { $$ = convert (void_type_node, integer_zero_node); }
1665 | pushlevel maybe_label_decls decls xstmts '}' poplevel
1666 { $$ = poplevel (1, 1, 0);
1667 SCOPE_STMT_BLOCK (TREE_PURPOSE ($6))
1668 = SCOPE_STMT_BLOCK (TREE_VALUE ($6))
1670 | pushlevel maybe_label_decls error '}' poplevel
1671 { $$ = poplevel (kept_level_p (), 0, 0);
1672 SCOPE_STMT_BLOCK (TREE_PURPOSE ($5))
1673 = SCOPE_STMT_BLOCK (TREE_VALUE ($5))
1675 | pushlevel maybe_label_decls stmts '}' poplevel
1676 { $$ = poplevel (kept_level_p (), 0, 0);
1677 SCOPE_STMT_BLOCK (TREE_PURPOSE ($5))
1678 = SCOPE_STMT_BLOCK (TREE_VALUE ($5))
1682 compstmt_primary_start:
1684 { if (current_function_decl == 0)
1686 error ("braced-group within expression allowed only inside a function");
1689 /* We must force a BLOCK for this level
1690 so that, if it is not expanded later,
1691 there is a way to turn off the entire subtree of blocks
1692 that are contained in it. */
1694 push_label_level ();
1696 $$ = add_stmt (build_stmt (COMPOUND_STMT, last_tree));
1699 compstmt: compstmt_start compstmt_nostart
1700 { RECHAIN_STMTS ($1, COMPOUND_BODY ($1));
1704 /* Value is number of statements counted as of the closeparen. */
1706 if_prefix lineno_labeled_stmt
1707 { c_finish_then (); }
1708 /* Make sure c_expand_end_cond is run once
1709 for each call to c_expand_start_cond.
1710 Otherwise a crash is likely. */
1716 { c_expand_start_cond (truthvalue_conversion ($3),
1718 $<itype>$ = stmt_count;
1719 if_stmt_file = $<filename>-1;
1720 if_stmt_line = $<lineno>0; }
1723 /* This is a subroutine of stmt.
1724 It is used twice, once for valid DO statements
1725 and once for catching errors in parsing the end test. */
1731 = add_stmt (build_stmt (DO_STMT, NULL_TREE,
1733 /* In the event that a parse error prevents
1734 parsing the complete do-statement, set the
1735 condition now. Otherwise, we can get crashes at
1736 RTL-generation time. */
1737 DO_COND ($<ttype>$) = error_mark_node; }
1738 lineno_labeled_stmt WHILE
1740 RECHAIN_STMTS ($$, DO_BODY ($$)); }
1743 /* The forced readahead in here is because we might be at the end of a
1744 line, and the line and file won't be bumped until yylex absorbs the
1745 first token on the next line. */
1747 { if (yychar == YYEMPTY)
1749 $$ = input_filename; }
1753 { if (yychar == YYEMPTY)
1758 lineno_labeled_stmt:
1759 save_filename save_lineno stmt
1761 /* | save_filename save_lineno error
1764 | save_filename save_lineno label lineno_labeled_stmt
1768 lineno_stmt_or_label:
1769 save_filename save_lineno stmt_or_label
1780 /* Parse a single real statement, not including any labels. */
1786 c_expand_expr_stmt ($1); }
1788 { c_expand_start_else ();
1789 $<itype>1 = stmt_count; }
1792 c_expand_end_cond ();
1793 if (extra_warnings && stmt_count == $<itype>1)
1794 warning ("empty body in an else-statement"); }
1795 | simple_if %prec IF
1796 { c_expand_end_cond ();
1797 /* This warning is here instead of in simple_if, because we
1798 do not want a warning if an empty if is followed by an
1799 else statement. Increment stmt_count so we don't
1800 give a second error if this is a nested `if'. */
1801 if (extra_warnings && stmt_count++ == $<itype>1)
1802 warning_with_file_and_line (if_stmt_file, if_stmt_line,
1803 "empty body in an if-statement"); }
1804 /* Make sure c_expand_end_cond is run once
1805 for each call to c_expand_start_cond.
1806 Otherwise a crash is likely. */
1807 | simple_if ELSE error
1808 { c_expand_end_cond (); }
1812 { $4 = truthvalue_conversion ($4);
1814 = add_stmt (build_stmt (WHILE_STMT, $4, NULL_TREE)); }
1816 { RECHAIN_STMTS ($<ttype>6, WHILE_BODY ($<ttype>6)); }
1819 { DO_COND ($1) = truthvalue_conversion ($3); }
1820 | do_stmt_start error
1825 $3 = build_stmt (EXPR_STMT, $3);
1826 $<ttype>$ = build_stmt (FOR_STMT, $3, NULL_TREE,
1827 NULL_TREE, NULL_TREE);
1828 add_stmt ($<ttype>$);
1831 { FOR_COND ($<ttype>5) = $6; }
1833 { FOR_EXPR ($<ttype>5) = $9; }
1835 { RECHAIN_STMTS ($<ttype>5, FOR_BODY ($<ttype>5)); }
1836 | SWITCH '(' expr ')'
1838 $<ttype>$ = c_start_case ($3); }
1840 { c_finish_case (); }
1843 add_stmt (build_break_stmt ()); }
1846 add_stmt (build_continue_stmt ()); }
1849 c_expand_return (NULL_TREE); }
1852 c_expand_return ($2); }
1853 | ASM_KEYWORD maybe_type_qual '(' expr ')' ';'
1856 if ((TREE_CODE ($4) == ADDR_EXPR
1857 && TREE_CODE (TREE_OPERAND ($4, 0)) == STRING_CST)
1858 || TREE_CODE ($4) == STRING_CST)
1860 if (TREE_CODE ($4) == ADDR_EXPR)
1861 $4 = TREE_OPERAND ($4, 0);
1862 if (TREE_CHAIN ($4))
1863 $4 = combine_strings ($4);
1864 add_stmt (build_stmt (ASM_STMT, NULL_TREE, $4,
1865 NULL_TREE, NULL_TREE, NULL_TREE));
1868 error ("argument of `asm' is not a constant string"); }
1869 /* This is the case with just output operands. */
1870 | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ')' ';'
1872 c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE,
1873 $2 == ridpointers[(int)RID_VOLATILE],
1874 input_filename, lineno); }
1875 /* This is the case with input operands as well. */
1876 | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':' asm_operands ')' ';'
1878 c_expand_asm_operands ($4, $6, $8, NULL_TREE,
1879 $2 == ridpointers[(int)RID_VOLATILE],
1880 input_filename, lineno); }
1881 /* This is the case with clobbered registers as well. */
1882 | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':'
1883 asm_operands ':' asm_clobbers ')' ';'
1885 c_expand_asm_operands ($4, $6, $8, $10,
1886 $2 == ridpointers[(int)RID_VOLATILE],
1887 input_filename, lineno); }
1888 | GOTO identifier ';'
1891 decl = lookup_label ($2);
1894 TREE_USED (decl) = 1;
1895 add_stmt (build_stmt (GOTO_STMT, decl));
1900 pedwarn ("ISO C forbids `goto *expr;'");
1902 $3 = convert (ptr_type_node, $3);
1903 add_stmt (build_stmt (GOTO_STMT, $3)); }
1907 /* Any kind of label, including jump labels and case labels.
1908 ANSI C accepts labels only before statements, but we allow them
1909 also at the end of a compound statement. */
1911 label: CASE expr_no_commas ':'
1913 do_case ($2, NULL_TREE); }
1914 | CASE expr_no_commas ELLIPSIS expr_no_commas ':'
1919 do_case (NULL_TREE, NULL_TREE); }
1920 | identifier save_filename save_lineno ':' maybe_attribute
1921 { tree label = define_label ($2, $3, $1);
1925 decl_attributes (label, $5, NULL_TREE);
1926 add_stmt (build_stmt (LABEL_STMT, label));
1931 /* Either a type-qualifier or nothing. First thing in an `asm' statement. */
1935 { emit_line_note (input_filename, lineno);
1938 { emit_line_note (input_filename, lineno); }
1947 /* These are the operands other than the first string and colon
1948 in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */
1949 asm_operands: /* empty */
1951 | nonnull_asm_operands
1954 nonnull_asm_operands:
1956 | nonnull_asm_operands ',' asm_operand
1957 { $$ = chainon ($1, $3); }
1962 { $$ = build_tree_list ($1, $3); }
1967 { $$ = tree_cons (NULL_TREE, combine_strings ($1), NULL_TREE); }
1968 | asm_clobbers ',' string
1969 { $$ = tree_cons (NULL_TREE, combine_strings ($3), $1); }
1972 /* This is what appears inside the parens in a function declarator.
1973 Its value is a list of ..._TYPE nodes. */
1976 clear_parm_order ();
1977 declare_parm_level (0); }
1980 parmlist_tags_warning ();
1981 poplevel (0, 0, 0); }
1989 pedwarn ("ISO C forbids forward parameter declarations");
1990 /* Mark the forward decls as such. */
1991 for (parm = getdecls (); parm; parm = TREE_CHAIN (parm))
1992 TREE_ASM_WRITTEN (parm) = 1;
1993 clear_parm_order (); }
1997 { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
2000 /* This is what appears inside the parens in a function declarator.
2001 Is value is represented in the format that grokdeclarator expects. */
2002 parmlist_2: /* empty */
2003 { $$ = get_parm_info (0); }
2005 { $$ = get_parm_info (0);
2006 /* Gcc used to allow this as an extension. However, it does
2007 not work for all targets, and thus has been disabled.
2008 Also, since func (...) and func () are indistinguishable,
2009 it caused problems with the code in expand_builtin which
2010 tries to verify that BUILT_IN_NEXT_ARG is being used
2012 error ("ISO C requires a named argument before `...'");
2015 { $$ = get_parm_info (1); }
2016 | parms ',' ELLIPSIS
2017 { $$ = get_parm_info (0); }
2022 { push_parm_decl ($1); }
2024 { push_parm_decl ($3); }
2027 /* A single parameter declaration or parameter type name,
2028 as found in a parmlist. */
2030 typed_declspecs setspecs parm_declarator maybe_attribute
2031 { $$ = build_tree_list (build_tree_list (current_declspecs,
2033 build_tree_list (prefix_attributes,
2035 current_declspecs = TREE_VALUE (declspec_stack);
2036 prefix_attributes = TREE_PURPOSE (declspec_stack);
2037 declspec_stack = TREE_CHAIN (declspec_stack); }
2038 | typed_declspecs setspecs notype_declarator maybe_attribute
2039 { $$ = build_tree_list (build_tree_list (current_declspecs,
2041 build_tree_list (prefix_attributes,
2043 current_declspecs = TREE_VALUE (declspec_stack);
2044 prefix_attributes = TREE_PURPOSE (declspec_stack);
2045 declspec_stack = TREE_CHAIN (declspec_stack); }
2046 | typed_declspecs setspecs absdcl maybe_attribute
2047 { $$ = build_tree_list (build_tree_list (current_declspecs,
2049 build_tree_list (prefix_attributes,
2051 current_declspecs = TREE_VALUE (declspec_stack);
2052 prefix_attributes = TREE_PURPOSE (declspec_stack);
2053 declspec_stack = TREE_CHAIN (declspec_stack); }
2054 | declmods setspecs notype_declarator maybe_attribute
2055 { $$ = build_tree_list (build_tree_list (current_declspecs,
2057 build_tree_list (prefix_attributes,
2059 current_declspecs = TREE_VALUE (declspec_stack);
2060 prefix_attributes = TREE_PURPOSE (declspec_stack);
2061 declspec_stack = TREE_CHAIN (declspec_stack); }
2063 | declmods setspecs absdcl maybe_attribute
2064 { $$ = build_tree_list (build_tree_list (current_declspecs,
2066 build_tree_list (prefix_attributes,
2068 current_declspecs = TREE_VALUE (declspec_stack);
2069 prefix_attributes = TREE_PURPOSE (declspec_stack);
2070 declspec_stack = TREE_CHAIN (declspec_stack); }
2073 /* This is used in a function definition
2074 where either a parmlist or an identifier list is ok.
2075 Its value is a list of ..._TYPE nodes or a list of identifiers. */
2076 parmlist_or_identifiers:
2078 clear_parm_order ();
2079 declare_parm_level (1); }
2080 parmlist_or_identifiers_1
2082 parmlist_tags_warning ();
2083 poplevel (0, 0, 0); }
2086 parmlist_or_identifiers_1:
2090 for (t = $1; t; t = TREE_CHAIN (t))
2091 if (TREE_VALUE (t) == NULL_TREE)
2092 error ("`...' in old-style identifier list");
2093 $$ = tree_cons (NULL_TREE, NULL_TREE, $1); }
2096 /* A nonempty list of identifiers. */
2099 { $$ = build_tree_list (NULL_TREE, $1); }
2100 | identifiers ',' IDENTIFIER
2101 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2104 /* A nonempty list of identifiers, including typenames. */
2105 identifiers_or_typenames:
2107 { $$ = build_tree_list (NULL_TREE, $1); }
2108 | identifiers_or_typenames ',' identifier
2109 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2114 { $$ = SAVE_WARN_FLAGS();
2116 warn_pointer_arith = 0; }
2120 /* Objective-C productions. */
2130 if (objc_implementation_context)
2132 finish_class (objc_implementation_context);
2133 objc_ivar_chain = NULL_TREE;
2134 objc_implementation_context = NULL_TREE;
2137 warning ("`@end' must appear in an implementation context");
2141 /* A nonempty list of identifiers. */
2144 { $$ = build_tree_list (NULL_TREE, $1); }
2145 | identifier_list ',' identifier
2146 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2150 CLASS identifier_list ';'
2152 objc_declare_class ($2);
2156 ALIAS identifier identifier ';'
2158 objc_declare_alias ($2, $3);
2162 INTERFACE identifier protocolrefs '{'
2164 objc_interface_context = objc_ivar_context
2165 = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3);
2166 objc_public_flag = 0;
2170 continue_class (objc_interface_context);
2175 finish_class (objc_interface_context);
2176 objc_interface_context = NULL_TREE;
2179 | INTERFACE identifier protocolrefs
2181 objc_interface_context
2182 = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3);
2183 continue_class (objc_interface_context);
2188 finish_class (objc_interface_context);
2189 objc_interface_context = NULL_TREE;
2192 | INTERFACE identifier ':' identifier protocolrefs '{'
2194 objc_interface_context = objc_ivar_context
2195 = start_class (CLASS_INTERFACE_TYPE, $2, $4, $5);
2196 objc_public_flag = 0;
2200 continue_class (objc_interface_context);
2205 finish_class (objc_interface_context);
2206 objc_interface_context = NULL_TREE;
2209 | INTERFACE identifier ':' identifier protocolrefs
2211 objc_interface_context
2212 = start_class (CLASS_INTERFACE_TYPE, $2, $4, $5);
2213 continue_class (objc_interface_context);
2218 finish_class (objc_interface_context);
2219 objc_interface_context = NULL_TREE;
2222 | IMPLEMENTATION identifier '{'
2224 objc_implementation_context = objc_ivar_context
2225 = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE);
2226 objc_public_flag = 0;
2231 = continue_class (objc_implementation_context);
2234 | IMPLEMENTATION identifier
2236 objc_implementation_context
2237 = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE);
2239 = continue_class (objc_implementation_context);
2242 | IMPLEMENTATION identifier ':' identifier '{'
2244 objc_implementation_context = objc_ivar_context
2245 = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE);
2246 objc_public_flag = 0;
2251 = continue_class (objc_implementation_context);
2254 | IMPLEMENTATION identifier ':' identifier
2256 objc_implementation_context
2257 = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE);
2259 = continue_class (objc_implementation_context);
2262 | INTERFACE identifier '(' identifier ')' protocolrefs
2264 objc_interface_context
2265 = start_class (CATEGORY_INTERFACE_TYPE, $2, $4, $6);
2266 continue_class (objc_interface_context);
2271 finish_class (objc_interface_context);
2272 objc_interface_context = NULL_TREE;
2275 | IMPLEMENTATION identifier '(' identifier ')'
2277 objc_implementation_context
2278 = start_class (CATEGORY_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE);
2280 = continue_class (objc_implementation_context);
2285 PROTOCOL identifier protocolrefs
2287 remember_protocol_qualifiers ();
2288 objc_interface_context
2289 = start_protocol(PROTOCOL_INTERFACE_TYPE, $2, $3);
2293 forget_protocol_qualifiers();
2294 finish_protocol(objc_interface_context);
2295 objc_interface_context = NULL_TREE;
2304 | non_empty_protocolrefs
2307 non_empty_protocolrefs:
2308 ARITHCOMPARE identifier_list ARITHCOMPARE
2310 if ($1 == LT_EXPR && $3 == GT_EXPR)
2318 ivar_decl_list visibility_spec ivar_decls
2323 PRIVATE { objc_public_flag = 2; }
2324 | PROTECTED { objc_public_flag = 0; }
2325 | PUBLIC { objc_public_flag = 1; }
2333 | ivar_decls ivar_decl ';'
2337 pedwarn ("extra semicolon in struct or union specified");
2342 /* There is a shift-reduce conflict here, because `components' may
2343 start with a `typename'. It happens that shifting (the default resolution)
2344 does the right thing, because it treats the `typename' as part of
2345 a `typed_typespecs'.
2347 It is possible that this same technique would allow the distinction
2348 between `notype_initdecls' and `initdecls' to be eliminated.
2349 But I am being cautious and not trying it. */
2352 typed_typespecs setspecs ivars
2354 current_declspecs = TREE_VALUE (declspec_stack);
2355 prefix_attributes = TREE_PURPOSE (declspec_stack);
2356 declspec_stack = TREE_CHAIN (declspec_stack); }
2357 | nonempty_type_quals setspecs ivars
2359 current_declspecs = TREE_VALUE (declspec_stack);
2360 prefix_attributes = TREE_PURPOSE (declspec_stack);
2361 declspec_stack = TREE_CHAIN (declspec_stack); }
2370 | ivars ',' ivar_declarator
2376 $$ = add_instance_variable (objc_ivar_context,
2378 $1, current_declspecs,
2381 | declarator ':' expr_no_commas
2383 $$ = add_instance_variable (objc_ivar_context,
2385 $1, current_declspecs, $3);
2387 | ':' expr_no_commas
2389 $$ = add_instance_variable (objc_ivar_context,
2392 current_declspecs, $2);
2399 remember_protocol_qualifiers ();
2400 if (objc_implementation_context)
2401 objc_inherit_code = CLASS_METHOD_DECL;
2403 fatal ("method definition not in class context");
2407 forget_protocol_qualifiers ();
2408 add_class_method (objc_implementation_context, $3);
2409 start_method_def ($3);
2410 objc_method_context = $3;
2414 continue_method_def ();
2418 finish_method_def ();
2419 objc_method_context = NULL_TREE;
2424 remember_protocol_qualifiers ();
2425 if (objc_implementation_context)
2426 objc_inherit_code = INSTANCE_METHOD_DECL;
2428 fatal ("method definition not in class context");
2432 forget_protocol_qualifiers ();
2433 add_instance_method (objc_implementation_context, $3);
2434 start_method_def ($3);
2435 objc_method_context = $3;
2439 continue_method_def ();
2443 finish_method_def ();
2444 objc_method_context = NULL_TREE;
2448 /* the reason for the strange actions in this rule
2449 is so that notype_initdecls when reached via datadef
2450 can find a valid list of type and sc specs in $0. */
2454 | {$<ttype>$ = NULL_TREE; } methodprotolist2
2457 methodprotolist2: /* eliminates a shift/reduce conflict */
2460 | methodprotolist2 methodproto
2461 | methodprotolist2 {$<ttype>$ = NULL_TREE; } datadef
2472 /* Remember protocol qualifiers in prototypes. */
2473 remember_protocol_qualifiers ();
2474 objc_inherit_code = CLASS_METHOD_DECL;
2478 /* Forget protocol qualifiers here. */
2479 forget_protocol_qualifiers ();
2480 add_class_method (objc_interface_context, $3);
2486 /* Remember protocol qualifiers in prototypes. */
2487 remember_protocol_qualifiers ();
2488 objc_inherit_code = INSTANCE_METHOD_DECL;
2492 /* Forget protocol qualifiers here. */
2493 forget_protocol_qualifiers ();
2494 add_instance_method (objc_interface_context, $3);
2500 '(' typename ')' unaryselector
2502 $$ = build_method_decl (objc_inherit_code, $2, $4, NULL_TREE);
2507 $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, NULL_TREE);
2510 | '(' typename ')' keywordselector optparmlist
2512 $$ = build_method_decl (objc_inherit_code, $2, $4, $5);
2515 | keywordselector optparmlist
2517 $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, $2);
2521 /* "optarglist" assumes that start_method_def has already been called...
2522 if it is not, the "xdecls" will not be placed in the proper scope */
2529 /* to get around the following situation: "int foo (int a) int b; {}" that
2530 is synthesized when parsing "- a:a b:b; id c; id d; { ... }" */
2545 typed_declspecs setspecs myparms ';'
2546 { current_declspecs = TREE_VALUE (declspec_stack);
2547 prefix_attributes = TREE_PURPOSE (declspec_stack);
2548 declspec_stack = TREE_CHAIN (declspec_stack); }
2549 | typed_declspecs ';'
2550 { shadow_tag ($1); }
2552 { pedwarn ("empty declaration"); }
2557 { push_parm_decl ($1); }
2558 | myparms ',' myparm
2559 { push_parm_decl ($3); }
2562 /* A single parameter declaration or parameter type name,
2563 as found in a parmlist. DOES NOT ALLOW AN INITIALIZER OR ASMSPEC */
2566 parm_declarator maybe_attribute
2567 { $$ = build_tree_list (build_tree_list (current_declspecs,
2569 build_tree_list (prefix_attributes,
2571 | notype_declarator maybe_attribute
2572 { $$ = build_tree_list (build_tree_list (current_declspecs,
2574 build_tree_list (prefix_attributes,
2576 | absdcl maybe_attribute
2577 { $$ = build_tree_list (build_tree_list (current_declspecs,
2579 build_tree_list (prefix_attributes,
2590 /* oh what a kludge! */
2591 $$ = objc_ellipsis_node;
2599 /* returns a tree list node generated by get_parm_info */
2612 | keywordselector keyworddecl
2614 $$ = chainon ($1, $2);
2626 ENUM | STRUCT | UNION | IF | ELSE | WHILE | DO | FOR
2627 | SWITCH | CASE | DEFAULT | BREAK | CONTINUE | RETURN
2628 | GOTO | ASM_KEYWORD | SIZEOF | TYPEOF | ALIGNOF
2629 | TYPESPEC | TYPE_QUAL
2633 selector ':' '(' typename ')' identifier
2635 $$ = build_keyword_decl ($1, $4, $6);
2638 | selector ':' identifier
2640 $$ = build_keyword_decl ($1, NULL_TREE, $3);
2643 | ':' '(' typename ')' identifier
2645 $$ = build_keyword_decl (NULL_TREE, $3, $5);
2650 $$ = build_keyword_decl (NULL_TREE, NULL_TREE, $2);
2661 | keywordarglist keywordarg
2663 $$ = chainon ($1, $2);
2671 if (TREE_CHAIN ($1) == NULL_TREE)
2672 /* just return the expr., remove a level of indirection */
2673 $$ = TREE_VALUE ($1);
2675 /* we have a comma expr., we will collapse later */
2681 selector ':' keywordexpr
2683 $$ = build_tree_list ($1, $3);
2687 $$ = build_tree_list (NULL_TREE, $2);
2695 $$ = get_class_reference ($1);
2701 { objc_receiver_context = 1; }
2703 { objc_receiver_context = 0; }
2706 $$ = build_tree_list ($3, $5);
2717 | keywordnamelist keywordname
2719 $$ = chainon ($1, $2);
2726 $$ = build_tree_list ($1, NULL_TREE);
2730 $$ = build_tree_list (NULL_TREE, NULL_TREE);
2735 SELECTOR '(' selectorarg ')'
2742 PROTOCOL '(' identifier ')'
2748 /* extension to support C-structures in the archiver */
2751 ENCODE '(' typename ')'
2753 $$ = groktypename ($3);
2760 /* yylex() is a thin wrapper around c_lex(), all it does is translate
2761 cpplib.h's token codes into yacc's token codes. */
2763 static enum cpp_ttype last_token;
2765 extern cpp_reader parse_in;
2768 /* The reserved keyword table. */
2772 ENUM_BITFIELD(rid) rid : 16;
2773 unsigned int disable : 16;
2776 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
2778 #define D_TRAD 0x01 /* not in traditional C */
2779 #define D_C89 0x02 /* not in C89 */
2780 #define D_EXT 0x04 /* GCC extension */
2781 #define D_EXT89 0x08 /* GCC extension incorporated in C99 */
2782 #define D_OBJC 0x10 /* Objective C only */
2783 #define D_YES 0x20 /* always starts disabled */
2785 static const struct resword reswords[] =
2787 { "_Complex", RID_COMPLEX, 0 },
2788 { "__alignof", RID_ALIGNOF, 0 },
2789 { "__alignof__", RID_ALIGNOF, 0 },
2790 { "__asm", RID_ASM, 0 },
2791 { "__asm__", RID_ASM, 0 },
2792 { "__attribute", RID_ATTRIBUTE, 0 },
2793 { "__attribute__", RID_ATTRIBUTE, 0 },
2794 { "__bounded", RID_BOUNDED, 0 },
2795 { "__bounded__", RID_BOUNDED, 0 },
2796 { "__builtin_va_arg", RID_VA_ARG, 0 },
2797 { "__complex", RID_COMPLEX, 0 },
2798 { "__complex__", RID_COMPLEX, 0 },
2799 { "__const", RID_CONST, 0 },
2800 { "__const__", RID_CONST, 0 },
2801 { "__extension__", RID_EXTENSION, 0 },
2802 { "__imag", RID_IMAGPART, 0 },
2803 { "__imag__", RID_IMAGPART, 0 },
2804 { "__inline", RID_INLINE, 0 },
2805 { "__inline__", RID_INLINE, 0 },
2806 { "__label__", RID_LABEL, 0 },
2807 { "__ptrbase", RID_PTRBASE, 0 },
2808 { "__ptrbase__", RID_PTRBASE, 0 },
2809 { "__ptrextent", RID_PTREXTENT, 0 },
2810 { "__ptrextent__", RID_PTREXTENT, 0 },
2811 { "__ptrvalue", RID_PTRVALUE, 0 },
2812 { "__ptrvalue__", RID_PTRVALUE, 0 },
2813 { "__real", RID_REALPART, 0 },
2814 { "__real__", RID_REALPART, 0 },
2815 { "__restrict", RID_RESTRICT, 0 },
2816 { "__restrict__", RID_RESTRICT, 0 },
2817 { "__signed", RID_SIGNED, 0 },
2818 { "__signed__", RID_SIGNED, 0 },
2819 { "__typeof", RID_TYPEOF, 0 },
2820 { "__typeof__", RID_TYPEOF, 0 },
2821 { "__unbounded", RID_UNBOUNDED, 0 },
2822 { "__unbounded__", RID_UNBOUNDED, 0 },
2823 { "__volatile", RID_VOLATILE, 0 },
2824 { "__volatile__", RID_VOLATILE, 0 },
2825 { "asm", RID_ASM, D_EXT },
2826 { "auto", RID_AUTO, 0 },
2827 { "break", RID_BREAK, 0 },
2828 { "case", RID_CASE, 0 },
2829 { "char", RID_CHAR, 0 },
2830 { "const", RID_CONST, D_TRAD },
2831 { "continue", RID_CONTINUE, 0 },
2832 { "default", RID_DEFAULT, 0 },
2833 { "do", RID_DO, 0 },
2834 { "double", RID_DOUBLE, 0 },
2835 { "else", RID_ELSE, 0 },
2836 { "enum", RID_ENUM, 0 },
2837 { "extern", RID_EXTERN, 0 },
2838 { "float", RID_FLOAT, 0 },
2839 { "for", RID_FOR, 0 },
2840 { "goto", RID_GOTO, 0 },
2841 { "if", RID_IF, 0 },
2842 { "inline", RID_INLINE, D_TRAD|D_EXT89 },
2843 { "int", RID_INT, 0 },
2844 { "long", RID_LONG, 0 },
2845 { "register", RID_REGISTER, 0 },
2846 { "restrict", RID_RESTRICT, D_TRAD|D_C89 },
2847 { "return", RID_RETURN, 0 },
2848 { "short", RID_SHORT, 0 },
2849 { "signed", RID_SIGNED, D_TRAD },
2850 { "sizeof", RID_SIZEOF, 0 },
2851 { "static", RID_STATIC, 0 },
2852 { "struct", RID_STRUCT, 0 },
2853 { "switch", RID_SWITCH, 0 },
2854 { "typedef", RID_TYPEDEF, 0 },
2855 { "typeof", RID_TYPEOF, D_TRAD|D_EXT },
2856 { "union", RID_UNION, 0 },
2857 { "unsigned", RID_UNSIGNED, 0 },
2858 { "void", RID_VOID, 0 },
2859 { "volatile", RID_VOLATILE, D_TRAD },
2860 { "while", RID_WHILE, 0 },
2862 { "@class", RID_AT_CLASS, D_OBJC },
2863 { "@compatibility_alias", RID_AT_ALIAS, D_OBJC },
2864 { "@defs", RID_AT_DEFS, D_OBJC },
2865 { "@encode", RID_AT_ENCODE, D_OBJC },
2866 { "@end", RID_AT_END, D_OBJC },
2867 { "@implementation", RID_AT_IMPLEMENTATION, D_OBJC },
2868 { "@interface", RID_AT_INTERFACE, D_OBJC },
2869 { "@private", RID_AT_PRIVATE, D_OBJC },
2870 { "@protected", RID_AT_PROTECTED, D_OBJC },
2871 { "@protocol", RID_AT_PROTOCOL, D_OBJC },
2872 { "@public", RID_AT_PUBLIC, D_OBJC },
2873 { "@selector", RID_AT_SELECTOR, D_OBJC },
2874 { "id", RID_ID, D_OBJC },
2875 { "bycopy", RID_BYCOPY, D_OBJC|D_YES },
2876 { "byref", RID_BYREF, D_OBJC|D_YES },
2877 { "in", RID_IN, D_OBJC|D_YES },
2878 { "inout", RID_INOUT, D_OBJC|D_YES },
2879 { "oneway", RID_ONEWAY, D_OBJC|D_YES },
2880 { "out", RID_OUT, D_OBJC|D_YES },
2883 #define N_reswords (sizeof reswords / sizeof (struct resword))
2885 /* Table mapping from RID_* constants to yacc token numbers.
2886 Unfortunately we have to have entries for all the keywords in all
2888 static const short rid_to_yy[RID_MAX] =
2890 /* RID_STATIC */ SCSPEC,
2891 /* RID_UNSIGNED */ TYPESPEC,
2892 /* RID_LONG */ TYPESPEC,
2893 /* RID_CONST */ TYPE_QUAL,
2894 /* RID_EXTERN */ SCSPEC,
2895 /* RID_REGISTER */ SCSPEC,
2896 /* RID_TYPEDEF */ SCSPEC,
2897 /* RID_SHORT */ TYPESPEC,
2898 /* RID_INLINE */ SCSPEC,
2899 /* RID_VOLATILE */ TYPE_QUAL,
2900 /* RID_SIGNED */ TYPESPEC,
2901 /* RID_AUTO */ SCSPEC,
2902 /* RID_RESTRICT */ TYPE_QUAL,
2905 /* RID_BOUNDED */ TYPE_QUAL,
2906 /* RID_UNBOUNDED */ TYPE_QUAL,
2907 /* RID_COMPLEX */ TYPESPEC,
2911 /* RID_VIRTUAL */ 0,
2912 /* RID_EXPLICIT */ 0,
2914 /* RID_MUTABLE */ 0,
2917 /* RID_IN */ TYPE_QUAL,
2918 /* RID_OUT */ TYPE_QUAL,
2919 /* RID_INOUT */ TYPE_QUAL,
2920 /* RID_BYCOPY */ TYPE_QUAL,
2921 /* RID_BYREF */ TYPE_QUAL,
2922 /* RID_ONEWAY */ TYPE_QUAL,
2925 /* RID_INT */ TYPESPEC,
2926 /* RID_CHAR */ TYPESPEC,
2927 /* RID_FLOAT */ TYPESPEC,
2928 /* RID_DOUBLE */ TYPESPEC,
2929 /* RID_VOID */ TYPESPEC,
2930 /* RID_ENUM */ ENUM,
2931 /* RID_STRUCT */ STRUCT,
2932 /* RID_UNION */ UNION,
2934 /* RID_ELSE */ ELSE,
2935 /* RID_WHILE */ WHILE,
2938 /* RID_SWITCH */ SWITCH,
2939 /* RID_CASE */ CASE,
2940 /* RID_DEFAULT */ DEFAULT,
2941 /* RID_BREAK */ BREAK,
2942 /* RID_CONTINUE */ CONTINUE,
2943 /* RID_RETURN */ RETURN,
2944 /* RID_GOTO */ GOTO,
2945 /* RID_SIZEOF */ SIZEOF,
2948 /* RID_ASM */ ASM_KEYWORD,
2949 /* RID_TYPEOF */ TYPEOF,
2950 /* RID_ALIGNOF */ ALIGNOF,
2951 /* RID_ATTRIBUTE */ ATTRIBUTE,
2952 /* RID_VA_ARG */ VA_ARG,
2953 /* RID_EXTENSION */ EXTENSION,
2954 /* RID_IMAGPART */ IMAGPART,
2955 /* RID_REALPART */ REALPART,
2956 /* RID_LABEL */ LABEL,
2957 /* RID_PTRBASE */ PTR_BASE,
2958 /* RID_PTREXTENT */ PTR_EXTENT,
2959 /* RID_PTRVALUE */ PTR_VALUE,
2966 /* RID_PRIVATE */ 0,
2967 /* RID_PROTECTED */ 0,
2968 /* RID_TEMPLATE */ 0,
2973 /* RID_NAMESPACE */ 0,
2975 /* RID_OPERATOR */ 0,
2980 /* RID_TYPENAME */ 0,
2985 /* RID_CONSTCAST */ 0,
2986 /* RID_DYNCAST */ 0,
2987 /* RID_REINTCAST */ 0,
2988 /* RID_STATCAST */ 0,
2990 /* alternate spellings */
3004 /* RID_ID */ OBJECTNAME,
3005 /* RID_AT_ENCODE */ ENCODE,
3006 /* RID_AT_END */ END,
3007 /* RID_AT_CLASS */ CLASS,
3008 /* RID_AT_ALIAS */ ALIAS,
3009 /* RID_AT_DEFS */ DEFS,
3010 /* RID_AT_PRIVATE */ PRIVATE,
3011 /* RID_AT_PROTECTED */ PROTECTED,
3012 /* RID_AT_PUBLIC */ PUBLIC,
3013 /* RID_AT_PROTOCOL */ PROTOCOL,
3014 /* RID_AT_SELECTOR */ SELECTOR,
3015 /* RID_AT_INTERFACE */ INTERFACE,
3016 /* RID_AT_IMPLEMENTATION */ IMPLEMENTATION
3024 int mask = ((doing_objc_thang ? 0 : D_OBJC)
3025 | (flag_isoc99 ? 0 : D_C89)
3026 | (flag_traditional ? D_TRAD : 0)
3027 | (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT|D_EXT89) : 0));
3029 /* It is not necessary to register ridpointers as a GC root, because
3030 all the trees it points to are permanently interned in the
3031 get_identifier hash anyway. */
3032 ridpointers = (tree *) xcalloc ((int) RID_MAX, sizeof (tree));
3033 for (i = 0; i < N_reswords; i++)
3035 /* If a keyword is disabled, do not enter it into the table
3036 and so create a canonical spelling that isn't a keyword. */
3037 if (reswords[i].disable & mask)
3040 id = get_identifier (reswords[i].word);
3041 C_RID_CODE (id) = reswords[i].rid;
3042 ridpointers [(int) reswords[i].rid] = id;
3044 /* Objective C does tricky things with enabling and disabling
3045 keywords. So these we must not elide in the test above, but
3046 wait and not mark them reserved now. */
3047 if (! (reswords[i].disable & D_YES))
3048 C_IS_RESERVED_WORD (id) = 1;
3053 init_parse (filename)
3054 const char *filename;
3056 add_c_tree_codes ();
3058 /* Make identifier nodes long enough for the language-specific slots. */
3059 set_identifier_size (sizeof (struct lang_identifier));
3064 return init_c_lex (filename);
3071 cpp_finish (&parse_in);
3072 errorcount += parse_in.errors;
3079 #define NAME(type) cpp_type2name (type)
3084 #define TK(e, s) STRINGX(e),
3086 static const char *type2name[N_TTYPES] = { TTYPE_TABLE };
3087 #define NAME(type) type2name[type]
3094 const char *string = _(msgid);
3096 if (last_token == CPP_EOF)
3097 error ("%s at end of input", string);
3098 else if (last_token == CPP_CHAR || last_token == CPP_WCHAR)
3100 unsigned int val = TREE_INT_CST_LOW (yylval.ttype);
3101 const char *ell = (last_token == CPP_CHAR) ? "" : "L";
3102 if (val <= UCHAR_MAX && ISGRAPH (val))
3103 error ("%s before %s'%c'", string, ell, val);
3105 error ("%s before %s'\\x%x'", string, ell, val);
3107 else if (last_token == CPP_STRING
3108 || last_token == CPP_WSTRING
3109 || last_token == CPP_OSTRING)
3110 error ("%s before string constant", string);
3111 else if (last_token == CPP_NUMBER
3112 || last_token == CPP_INT
3113 || last_token == CPP_FLOAT)
3114 error ("%s before numeric constant", string);
3115 else if (last_token == CPP_NAME)
3116 error ("%s before \"%s\"", string, IDENTIFIER_POINTER (yylval.ttype));
3118 error ("%s before '%s' token", string, NAME(last_token));
3125 last_token = c_lex (&yylval.ttype);
3129 case CPP_EQ: return '=';
3130 case CPP_NOT: return '!';
3131 case CPP_GREATER: yylval.code = GT_EXPR; return ARITHCOMPARE;
3132 case CPP_LESS: yylval.code = LT_EXPR; return ARITHCOMPARE;
3133 case CPP_PLUS: yylval.code = PLUS_EXPR; return '+';
3134 case CPP_MINUS: yylval.code = MINUS_EXPR; return '-';
3135 case CPP_MULT: yylval.code = MULT_EXPR; return '*';
3136 case CPP_DIV: yylval.code = TRUNC_DIV_EXPR; return '/';
3137 case CPP_MOD: yylval.code = TRUNC_MOD_EXPR; return '%';
3138 case CPP_AND: yylval.code = BIT_AND_EXPR; return '&';
3139 case CPP_OR: yylval.code = BIT_IOR_EXPR; return '|';
3140 case CPP_XOR: yylval.code = BIT_XOR_EXPR; return '^';
3141 case CPP_RSHIFT: yylval.code = RSHIFT_EXPR; return RSHIFT;
3142 case CPP_LSHIFT: yylval.code = LSHIFT_EXPR; return LSHIFT;
3144 case CPP_COMPL: return '~';
3145 case CPP_AND_AND: return ANDAND;
3146 case CPP_OR_OR: return OROR;
3147 case CPP_QUERY: return '?';
3148 case CPP_COLON: return ':';
3149 case CPP_COMMA: return ',';
3150 case CPP_OPEN_PAREN: return '(';
3151 case CPP_CLOSE_PAREN: return ')';
3152 case CPP_EQ_EQ: yylval.code = EQ_EXPR; return EQCOMPARE;
3153 case CPP_NOT_EQ: yylval.code = NE_EXPR; return EQCOMPARE;
3154 case CPP_GREATER_EQ:yylval.code = GE_EXPR; return ARITHCOMPARE;
3155 case CPP_LESS_EQ: yylval.code = LE_EXPR; return ARITHCOMPARE;
3157 case CPP_PLUS_EQ: yylval.code = PLUS_EXPR; return ASSIGN;
3158 case CPP_MINUS_EQ: yylval.code = MINUS_EXPR; return ASSIGN;
3159 case CPP_MULT_EQ: yylval.code = MULT_EXPR; return ASSIGN;
3160 case CPP_DIV_EQ: yylval.code = TRUNC_DIV_EXPR; return ASSIGN;
3161 case CPP_MOD_EQ: yylval.code = TRUNC_MOD_EXPR; return ASSIGN;
3162 case CPP_AND_EQ: yylval.code = BIT_AND_EXPR; return ASSIGN;
3163 case CPP_OR_EQ: yylval.code = BIT_IOR_EXPR; return ASSIGN;
3164 case CPP_XOR_EQ: yylval.code = BIT_XOR_EXPR; return ASSIGN;
3165 case CPP_RSHIFT_EQ: yylval.code = RSHIFT_EXPR; return ASSIGN;
3166 case CPP_LSHIFT_EQ: yylval.code = LSHIFT_EXPR; return ASSIGN;
3168 case CPP_OPEN_SQUARE: return '[';
3169 case CPP_CLOSE_SQUARE: return ']';
3170 case CPP_OPEN_BRACE: return '{';
3171 case CPP_CLOSE_BRACE: return '}';
3172 case CPP_SEMICOLON: return ';';
3173 case CPP_ELLIPSIS: return ELLIPSIS;
3175 case CPP_PLUS_PLUS: return PLUSPLUS;
3176 case CPP_MINUS_MINUS: return MINUSMINUS;
3177 case CPP_DEREF: return POINTSAT;
3178 case CPP_DOT: return '.';
3182 cpp_pop_buffer (&parse_in);
3183 if (! CPP_BUFFER (&parse_in))
3189 if (C_IS_RESERVED_WORD (yylval.ttype))
3191 enum rid rid_code = C_RID_CODE (yylval.ttype);
3192 /* Return the canonical spelling for this keyword. */
3193 yylval.ttype = ridpointers[(int) rid_code];
3194 return rid_to_yy[(int) rid_code];
3197 if (IDENTIFIER_POINTER (yylval.ttype)[0] == '@')
3199 error ("invalid identifier `%s'", IDENTIFIER_POINTER (yylval.ttype));
3206 decl = lookup_name (yylval.ttype);
3210 if (TREE_CODE (decl) == TYPE_DECL)
3212 /* A user-invisible read-only initialized variable
3213 should be replaced by its value.
3214 We handle only strings since that's the only case used in C. */
3215 else if (TREE_CODE (decl) == VAR_DECL
3216 && DECL_IGNORED_P (decl)
3217 && TREE_READONLY (decl)
3218 && DECL_INITIAL (decl) != 0
3219 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
3221 tree stringval = DECL_INITIAL (decl);
3223 /* Copy the string value so that we won't clobber anything
3224 if we put something in the TREE_CHAIN of this one. */
3225 yylval.ttype = build_string (TREE_STRING_LENGTH (stringval),
3226 TREE_STRING_POINTER (stringval));
3230 else if (doing_objc_thang)
3232 tree objc_interface_decl = is_class_name (yylval.ttype);
3234 if (objc_interface_decl)
3236 yylval.ttype = objc_interface_decl;
3258 /* These tokens are C++ specific (and will not be generated
3259 in C mode, but let's be cautious). */
3261 case CPP_DEREF_STAR:
3267 /* These tokens should not survive translation phase 4. */
3270 error ("syntax error before '%s' token", NAME(last_token));
3284 timevar_push (TV_LEX);
3286 timevar_pop (TV_LEX);
3290 /* Sets the value of the 'yydebug' variable to VALUE.
3291 This is a function so we don't have to have YYDEBUG defined
3292 in order to build the compiler. */
3301 warning ("YYDEBUG not defined.");
3305 /* Function used when yydebug is set, to print a token in more detail. */
3308 yyprint (file, yychar, yyl)
3315 fprintf (file, " [%s]", NAME(last_token));
3325 if (IDENTIFIER_POINTER (t))
3326 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
3330 fprintf (file, " %s", GET_MODE_NAME (TYPE_MODE (TREE_TYPE (t))));
3331 if (TREE_CODE (t) == INTEGER_CST)
3333 #if HOST_BITS_PER_WIDE_INT == 64
3334 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
3337 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
3344 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
3350 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
3355 /* This is not the ideal place to put these, but we have to get them out
3356 of c-lex.c because cp/lex.c has its own versions. */
3358 /* Return something to represent absolute declarators containing a *.
3359 TARGET is the absolute declarator that the * contains.
3360 TYPE_QUALS is a list of modifiers such as const or volatile
3361 to apply to the pointer type, represented as identifiers.
3363 We return an INDIRECT_REF whose "contents" are TARGET
3364 and whose type is the modifier list. */
3367 make_pointer_declarator (type_quals, target)
3368 tree type_quals, target;
3370 return build1 (INDIRECT_REF, type_quals, target);