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