| blob | d45ff5e13718874716b9adc152809242617148a8 |
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 13 /* 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; struct c_expr exprtype; 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 /* Objective-C protocol qualifiers. These acquire their magic powers
131 only in certain contexts. */
132 %token OBJC_TYPE_QUAL
134 /* Character or numeric constants.
135 yylval is the node for the constant. */
136 %token CONSTANT
138 /* String constants in raw form.
139 yylval is a STRING_CST node. */
141 %token STRING
143 /* "...", used for functions with variable arglists. */
144 %token ELLIPSIS
146 /* the reserved words */
147 /* SCO include files test "ASM", so use something else. */
148 %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
149 %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF
150 %token ATTRIBUTE EXTENSION LABEL
151 %token REALPART IMAGPART VA_ARG CHOOSE_EXPR TYPES_COMPATIBLE_P
152 %token PTR_VALUE PTR_BASE PTR_EXTENT
153 %token FUNC_NAME OFFSETOF
155 /* Add precedence rules to solve dangling else s/r conflict */
156 %nonassoc IF
157 %nonassoc ELSE
159 /* Define the operator tokens and their precedences.
160 The value is an integer because, if used, it is the tree code
161 to use in the expression made from the operator. */
163 %right <code> ASSIGN '='
164 %right <code> '?' ':'
165 %left <code> OROR
166 %left <code> ANDAND
167 %left <code> '|'
168 %left <code> '^'
169 %left <code> '&'
170 %left <code> EQCOMPARE
171 %left <code> ARITHCOMPARE
172 %left <code> LSHIFT RSHIFT
173 %left <code> '+' '-'
174 %left <code> '*' '/' '%'
175 %right <code> UNARY PLUSPLUS MINUSMINUS
176 %left HYPERUNARY
177 %left <code> POINTSAT '.' '(' '['
179 /* The Objective-C keywords. These are included in C and in
180 Objective C, so that the token codes are the same in both. */
181 %token AT_INTERFACE AT_IMPLEMENTATION AT_END AT_SELECTOR AT_DEFS AT_ENCODE
182 %token CLASSNAME AT_PUBLIC AT_PRIVATE AT_PROTECTED AT_PROTOCOL
183 %token OBJECTNAME AT_CLASS AT_ALIAS
184 %token AT_THROW AT_TRY AT_CATCH AT_FINALLY AT_SYNCHRONIZED
185 %token OBJC_STRING
187 %type <code> unop
188 %type <ttype> ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
189 %type <ttype> BREAK CONTINUE RETURN GOTO ASM_KEYWORD SIZEOF TYPEOF ALIGNOF
191 %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT STRING FUNC_NAME
192 %type <ttype> nonnull_exprlist exprlist
193 %type <exprtype> expr expr_no_commas cast_expr unary_expr primary
194 %type <ttype> declspecs_nosc_nots_nosa_noea declspecs_nosc_nots_nosa_ea
195 %type <ttype> declspecs_nosc_nots_sa_noea declspecs_nosc_nots_sa_ea
196 %type <ttype> declspecs_nosc_ts_nosa_noea declspecs_nosc_ts_nosa_ea
197 %type <ttype> declspecs_nosc_ts_sa_noea declspecs_nosc_ts_sa_ea
198 %type <ttype> declspecs_sc_nots_nosa_noea declspecs_sc_nots_nosa_ea
199 %type <ttype> declspecs_sc_nots_sa_noea declspecs_sc_nots_sa_ea
200 %type <ttype> declspecs_sc_ts_nosa_noea declspecs_sc_ts_nosa_ea
201 %type <ttype> declspecs_sc_ts_sa_noea declspecs_sc_ts_sa_ea
202 %type <ttype> declspecs_ts declspecs_nots
203 %type <ttype> declspecs_ts_nosa declspecs_nots_nosa
204 %type <ttype> declspecs_nosc_ts declspecs_nosc_nots declspecs_nosc declspecs
205 %type <ttype> maybe_type_quals_attrs typespec_nonattr typespec_attr
206 %type <ttype> typespec_reserved_nonattr typespec_reserved_attr
207 %type <ttype> typespec_nonreserved_nonattr
208 %type <ttype> offsetof_member_designator
210 %type <ttype> scspec SCSPEC STATIC TYPESPEC TYPE_QUAL maybe_volatile
211 %type <ttype> initdecls notype_initdecls initdcl notype_initdcl
212 %type <exprtype> init
213 %type <ttype> simple_asm_expr maybeasm asm_stmt asm_argument
214 %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
215 %type <ttype> maybe_attribute attributes attribute attribute_list attrib
216 %type <ttype> any_word
218 %type <ttype> compstmt compstmt_start compstmt_primary_start
219 %type <ttype> stmt label stmt_nocomp start_break start_continue
221 %type <ttype> c99_block_start c99_block_lineno_labeled_stmt
222 %type <ttype> if_statement_1 if_statement_2
223 %type <ttype> declarator
224 %type <ttype> notype_declarator after_type_declarator
225 %type <ttype> parm_declarator
226 %type <ttype> parm_declarator_starttypename parm_declarator_nostarttypename
227 %type <ttype> array_declarator
229 %type <ttype> structsp_attr structsp_nonattr
230 %type <ttype> component_decl_list component_decl_list2
231 %type <ttype> component_decl components components_notype component_declarator
232 %type <ttype> component_notype_declarator
233 %type <ttype> enumlist enumerator
234 %type <ttype> struct_head union_head enum_head
235 %type <ttype> typename absdcl absdcl1 absdcl1_ea absdcl1_noea
236 %type <ttype> direct_absdcl1 absdcl_maybe_attribute
237 %type <ttype> condition xexpr for_cond_expr for_incr_expr
238 %type <ttype> parms parm firstparm identifiers
240 %type <ttype> parmlist parmlist_1 parmlist_2
241 %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
242 %type <ttype> identifiers_or_typenames
244 %type <itype> setspecs setspecs_fp extension
246 %type <location> save_location
247 \f
248 @@ifobjc
249 /* the Objective-C nonterminals */
251 %type <ttype> ivar_decl_list ivar_decls ivar_decl ivars ivar_declarator
252 %type <ttype> methoddecl unaryselector keywordselector selector
253 %type <ttype> keyworddecl receiver objcmessageexpr messageargs
254 %type <ttype> keywordexpr keywordarglist keywordarg
255 %type <ttype> myparms myparm optparmlist reservedwords objcselectorexpr
256 %type <ttype> selectorarg keywordnamelist keywordname objcencodeexpr
257 %type <ttype> non_empty_protocolrefs protocolrefs identifier_list objcprotocolexpr
259 %type <ttype> CLASSNAME OBJECTNAME OBJC_STRING
261 %type <ttype> superclass
262 @@end_ifobjc
263 \f
264 %{
265 /* List of types and structure classes of the current declaration. */
266 static GTY(()) tree current_declspecs;
267 static GTY(()) tree prefix_attributes;
269 /* List of all the attributes applying to the identifier currently being
270 declared; includes prefix_attributes and possibly some more attributes
271 just after a comma. */
272 static GTY(()) tree all_prefix_attributes;
274 /* Stack of saved values of current_declspecs, prefix_attributes and
275 all_prefix_attributes. */
276 static GTY(()) tree declspec_stack;
278 /* INDIRECT_REF with a TREE_TYPE of the type being queried for offsetof. */
279 static tree offsetof_base;
281 /* PUSH_DECLSPEC_STACK is called from setspecs; POP_DECLSPEC_STACK
282 should be called from the productions making use of setspecs. */
283 #define PUSH_DECLSPEC_STACK \
284 do { \
285 declspec_stack = tree_cons (build_tree_list (prefix_attributes, \
286 all_prefix_attributes), \
287 current_declspecs, \
288 declspec_stack); \
289 } while (0)
291 #define POP_DECLSPEC_STACK \
292 do { \
293 current_declspecs = TREE_VALUE (declspec_stack); \
294 prefix_attributes = TREE_PURPOSE (TREE_PURPOSE (declspec_stack)); \
295 all_prefix_attributes = TREE_VALUE (TREE_PURPOSE (declspec_stack)); \
296 declspec_stack = TREE_CHAIN (declspec_stack); \
297 } while (0)
299 /* For __extension__, save/restore the warning flags which are
300 controlled by __extension__. */
301 #define SAVE_EXT_FLAGS() \
302 (pedantic \
303 | (warn_pointer_arith << 1) \
304 | (warn_traditional << 2) \
305 | (flag_iso << 3))
307 #define RESTORE_EXT_FLAGS(val) \
308 do { \
309 pedantic = val & 1; \
310 warn_pointer_arith = (val >> 1) & 1; \
311 warn_traditional = (val >> 2) & 1; \
312 flag_iso = (val >> 3) & 1; \
313 } while (0)
315 @@ifobjc
316 /* Objective-C specific parser/lexer information */
318 static enum tree_code objc_inherit_code;
319 static int objc_pq_context = 0, objc_public_flag = 0;
321 /* The following flag is needed to contextualize ObjC lexical analysis.
322 In some cases (e.g., 'int NSObject;'), it is undesirable to bind
323 an identifier to an ObjC class, even if a class with that name
324 exists. */
325 static int objc_need_raw_identifier;
326 #define OBJC_NEED_RAW_IDENTIFIER(VAL) objc_need_raw_identifier = VAL
327 @@end_ifobjc
329 @@ifc
330 #define OBJC_NEED_RAW_IDENTIFIER(VAL) /* nothing */
331 @@end_ifc
333 /* Tell yyparse how to print a token's value, if yydebug is set. */
335 #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
337 static void yyprint (FILE *, int, YYSTYPE);
338 static void yyerror (const char *);
339 static int yylexname (void);
340 static inline int _yylex (void);
341 static int yylex (void);
342 static void init_reswords (void);
344 /* Initialisation routine for this file. */
345 void
346 c_parse_init (void)
347 {
348 init_reswords ();
349 }
351 %}
352 \f
353 %%
354 program: /* empty */
355 { if (pedantic)
356 pedwarn ("ISO C forbids an empty source file");
357 }
358 | extdefs
359 ;
361 /* the reason for the strange actions in this rule
362 is so that notype_initdecls when reached via datadef
363 can find a valid list of type and sc specs in $0. */
365 extdefs:
366 {$<ttype>$ = NULL_TREE; } extdef
367 | extdefs {$<ttype>$ = NULL_TREE; ggc_collect(); } extdef
368 ;
370 extdef:
371 fndef
372 | datadef
373 | asmdef
374 | extension extdef
375 { RESTORE_EXT_FLAGS ($1); }
376 @@ifobjc
377 | objcdef
378 @@end_ifobjc
379 ;
381 datadef:
382 setspecs notype_initdecls ';'
383 { if (pedantic)
384 error ("ISO C forbids data definition with no type or storage class");
385 else
386 warning ("data definition has no type or storage class");
388 POP_DECLSPEC_STACK; }
389 | declspecs_nots setspecs notype_initdecls ';'
390 { POP_DECLSPEC_STACK; }
391 | declspecs_ts setspecs initdecls ';'
392 { POP_DECLSPEC_STACK; }
393 | declspecs ';'
394 { shadow_tag ($1); }
395 | error ';'
396 | error '}'
397 | ';'
398 { if (pedantic)
399 pedwarn ("ISO C does not allow extra `;' outside of a function"); }
400 ;
401 \f
402 fndef:
403 declspecs_ts setspecs declarator
404 { if (! start_function (current_declspecs, $3,
405 all_prefix_attributes))
406 YYERROR1;
407 }
408 old_style_parm_decls save_location
409 { DECL_SOURCE_LOCATION (current_function_decl) = $6;
410 store_parm_decls (); }
411 compstmt_or_error
412 { finish_function ();
413 POP_DECLSPEC_STACK; }
414 | declspecs_ts setspecs declarator error
415 { POP_DECLSPEC_STACK; }
416 | declspecs_nots setspecs notype_declarator
417 { if (! start_function (current_declspecs, $3,
418 all_prefix_attributes))
419 YYERROR1;
420 }
421 old_style_parm_decls save_location
422 { DECL_SOURCE_LOCATION (current_function_decl) = $6;
423 store_parm_decls (); }
424 compstmt_or_error
425 { finish_function ();
426 POP_DECLSPEC_STACK; }
427 | declspecs_nots setspecs notype_declarator error
428 { POP_DECLSPEC_STACK; }
429 | setspecs notype_declarator
430 { if (! start_function (NULL_TREE, $2,
431 all_prefix_attributes))
432 YYERROR1;
433 }
434 old_style_parm_decls save_location
435 { DECL_SOURCE_LOCATION (current_function_decl) = $5;
436 store_parm_decls (); }
437 compstmt_or_error
438 { finish_function ();
439 POP_DECLSPEC_STACK; }
440 | setspecs notype_declarator error
441 { POP_DECLSPEC_STACK; }
442 ;
444 identifier:
445 IDENTIFIER
446 | TYPENAME
447 @@ifobjc
448 | OBJECTNAME
449 | CLASSNAME
450 @@end_ifobjc
451 ;
453 unop: '&'
454 { $$ = ADDR_EXPR; }
455 | '-'
456 { $$ = NEGATE_EXPR; }
457 | '+'
458 { $$ = CONVERT_EXPR;
459 @@ifc
460 if (warn_traditional && !in_system_header)
461 warning ("traditional C rejects the unary plus operator");
462 @@end_ifc
463 }
464 | PLUSPLUS
465 { $$ = PREINCREMENT_EXPR; }
466 | MINUSMINUS
467 { $$ = PREDECREMENT_EXPR; }
468 | '~'
469 { $$ = BIT_NOT_EXPR; }
470 | '!'
471 { $$ = TRUTH_NOT_EXPR; }
472 ;
474 expr: expr_no_commas
475 | expr ',' expr_no_commas
476 { $$.value = build_compound_expr ($1.value, $3.value);
477 $$.original_code = COMPOUND_EXPR; }
478 ;
480 exprlist:
481 /* empty */
482 { $$ = NULL_TREE; }
483 | nonnull_exprlist
484 ;
486 nonnull_exprlist:
487 expr_no_commas
488 { $$ = build_tree_list (NULL_TREE, $1.value); }
489 | nonnull_exprlist ',' expr_no_commas
490 { chainon ($1, build_tree_list (NULL_TREE, $3.value)); }
491 ;
493 unary_expr:
494 primary
495 | '*' cast_expr %prec UNARY
496 { $$.value = build_indirect_ref ($2.value, "unary *");
497 $$.original_code = ERROR_MARK; }
498 /* __extension__ turns off -pedantic for following primary. */
499 | extension cast_expr %prec UNARY
500 { $$ = $2;
501 RESTORE_EXT_FLAGS ($1); }
502 | unop cast_expr %prec UNARY
503 { $$.value = build_unary_op ($1, $2.value, 0);
504 overflow_warning ($$.value);
505 $$.original_code = ERROR_MARK; }
506 /* Refer to the address of a label as a pointer. */
507 | ANDAND identifier
508 { $$.value = finish_label_address_expr ($2);
509 $$.original_code = ERROR_MARK; }
510 | sizeof unary_expr %prec UNARY
511 { skip_evaluation--;
512 if (TREE_CODE ($2.value) == COMPONENT_REF
513 && DECL_C_BIT_FIELD (TREE_OPERAND ($2.value, 1)))
514 error ("`sizeof' applied to a bit-field");
515 $$.value = c_sizeof (TREE_TYPE ($2.value));
516 $$.original_code = ERROR_MARK; }
517 | sizeof '(' typename ')' %prec HYPERUNARY
518 { skip_evaluation--;
519 $$.value = c_sizeof (groktypename ($3));
520 $$.original_code = ERROR_MARK; }
521 | alignof unary_expr %prec UNARY
522 { skip_evaluation--;
523 $$.value = c_alignof_expr ($2.value);
524 $$.original_code = ERROR_MARK; }
525 | alignof '(' typename ')' %prec HYPERUNARY
526 { skip_evaluation--;
527 $$.value = c_alignof (groktypename ($3));
528 $$.original_code = ERROR_MARK; }
529 | REALPART cast_expr %prec UNARY
530 { $$.value = build_unary_op (REALPART_EXPR, $2.value, 0);
531 $$.original_code = ERROR_MARK; }
532 | IMAGPART cast_expr %prec UNARY
533 { $$.value = build_unary_op (IMAGPART_EXPR, $2.value, 0);
534 $$.original_code = ERROR_MARK; }
535 ;
537 sizeof:
538 SIZEOF { skip_evaluation++; }
539 ;
541 alignof:
542 ALIGNOF { skip_evaluation++; }
543 ;
545 typeof:
546 TYPEOF { skip_evaluation++; }
547 ;
549 cast_expr:
550 unary_expr
551 | '(' typename ')' cast_expr %prec UNARY
552 { $$.value = c_cast_expr ($2, $4.value);
553 $$.original_code = ERROR_MARK; }
554 ;
556 expr_no_commas:
557 cast_expr
558 | expr_no_commas '+' expr_no_commas
559 { $$ = parser_build_binary_op ($2, $1, $3); }
560 | expr_no_commas '-' expr_no_commas
561 { $$ = parser_build_binary_op ($2, $1, $3); }
562 | expr_no_commas '*' expr_no_commas
563 { $$ = parser_build_binary_op ($2, $1, $3); }
564 | expr_no_commas '/' 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 LSHIFT expr_no_commas
569 { $$ = parser_build_binary_op ($2, $1, $3); }
570 | expr_no_commas RSHIFT expr_no_commas
571 { $$ = parser_build_binary_op ($2, $1, $3); }
572 | expr_no_commas ARITHCOMPARE expr_no_commas
573 { $$ = parser_build_binary_op ($2, $1, $3); }
574 | expr_no_commas EQCOMPARE expr_no_commas
575 { $$ = parser_build_binary_op ($2, $1, $3); }
576 | expr_no_commas '&' expr_no_commas
577 { $$ = parser_build_binary_op ($2, $1, $3); }
578 | expr_no_commas '|' expr_no_commas
579 { $$ = parser_build_binary_op ($2, $1, $3); }
580 | expr_no_commas '^' expr_no_commas
581 { $$ = parser_build_binary_op ($2, $1, $3); }
582 | expr_no_commas ANDAND
583 { $1.value = lang_hooks.truthvalue_conversion
584 (default_conversion ($1.value));
585 skip_evaluation += $1.value == truthvalue_false_node; }
586 expr_no_commas
587 { skip_evaluation -= $1.value == truthvalue_false_node;
588 $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $4); }
589 | expr_no_commas OROR
590 { $1.value = lang_hooks.truthvalue_conversion
591 (default_conversion ($1.value));
592 skip_evaluation += $1.value == truthvalue_true_node; }
593 expr_no_commas
594 { skip_evaluation -= $1.value == truthvalue_true_node;
595 $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $4); }
596 | expr_no_commas '?'
597 { $1.value = lang_hooks.truthvalue_conversion
598 (default_conversion ($1.value));
599 skip_evaluation += $1.value == truthvalue_false_node; }
600 expr ':'
601 { skip_evaluation += (($1.value == truthvalue_true_node)
602 - ($1.value == truthvalue_false_node)); }
603 expr_no_commas
604 { skip_evaluation -= $1.value == truthvalue_true_node;
605 $$.value = build_conditional_expr ($1.value, $4.value,
606 $7.value);
607 $$.original_code = ERROR_MARK; }
608 | expr_no_commas '?'
609 { if (pedantic)
610 pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
611 /* Make sure first operand is calculated only once. */
612 $<ttype>2 = save_expr (default_conversion ($1.value));
613 $1.value = lang_hooks.truthvalue_conversion ($<ttype>2);
614 skip_evaluation += $1.value == truthvalue_true_node; }
615 ':' expr_no_commas
616 { skip_evaluation -= $1.value == truthvalue_true_node;
617 $$.value = build_conditional_expr ($1.value, $<ttype>2,
618 $5.value);
619 $$.original_code = ERROR_MARK; }
620 | expr_no_commas '=' expr_no_commas
621 { $$.value = build_modify_expr ($1.value, NOP_EXPR, $3.value);
622 $$.original_code = MODIFY_EXPR;
623 }
624 | expr_no_commas ASSIGN expr_no_commas
625 { $$.value = build_modify_expr ($1.value, $2, $3.value);
626 TREE_NO_WARNING ($$.value) = 1;
627 $$.original_code = ERROR_MARK;
628 }
629 ;
631 primary:
632 IDENTIFIER
633 {
634 if (yychar == YYEMPTY)
635 yychar = YYLEX;
636 $$.value = build_external_ref ($1, yychar == '(');
637 $$.original_code = ERROR_MARK;
638 }
639 | CONSTANT
640 { $$.value = $1; $$.original_code = ERROR_MARK; }
641 | STRING
642 { $$.value = $1; $$.original_code = STRING_CST; }
643 | FUNC_NAME
644 { $$.value = fname_decl (C_RID_CODE ($1), $1);
645 $$.original_code = ERROR_MARK; }
646 | '(' typename ')' '{'
647 { start_init (NULL_TREE, NULL, 0);
648 $2 = groktypename ($2);
649 really_start_incremental_init ($2); }
650 initlist_maybe_comma '}' %prec UNARY
651 { struct c_expr init = pop_init_level (0);
652 tree constructor = init.value;
653 tree type = $2;
654 finish_init ();
655 maybe_warn_string_init (type, init);
657 if (pedantic && ! flag_isoc99)
658 pedwarn ("ISO C90 forbids compound literals");
659 $$.value = build_compound_literal (type, constructor);
660 $$.original_code = ERROR_MARK;
661 }
662 | '(' expr ')'
663 { $$.value = $2.value;
664 if (TREE_CODE ($$.value) == MODIFY_EXPR)
665 TREE_NO_WARNING ($$.value) = 1;
666 $$.original_code = ERROR_MARK; }
667 | '(' error ')'
668 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
669 | compstmt_primary_start compstmt_nostart ')'
670 { if (pedantic)
671 pedwarn ("ISO C forbids braced-groups within expressions");
672 $$.value = c_finish_stmt_expr ($1);
673 $$.original_code = ERROR_MARK;
674 }
675 | compstmt_primary_start error ')'
676 { c_finish_stmt_expr ($1);
677 $$.value = error_mark_node;
678 $$.original_code = ERROR_MARK;
679 }
680 | primary '(' exprlist ')' %prec '.'
681 { $$.value = build_function_call ($1.value, $3);
682 $$.original_code = ERROR_MARK; }
683 | VA_ARG '(' expr_no_commas ',' typename ')'
684 { $$.value = build_va_arg ($3.value, groktypename ($5));
685 $$.original_code = ERROR_MARK; }
687 | OFFSETOF '(' typename ','
688 { tree type = groktypename ($3);
689 if (type == error_mark_node)
690 offsetof_base = error_mark_node;
691 else
692 offsetof_base = build1 (INDIRECT_REF, type, NULL);
693 }
694 offsetof_member_designator ')'
695 { $$.value = fold_offsetof ($6);
696 $$.original_code = ERROR_MARK; }
697 | OFFSETOF '(' error ')'
698 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
699 | CHOOSE_EXPR '(' expr_no_commas ',' expr_no_commas ','
700 expr_no_commas ')'
701 {
702 tree c;
704 c = fold ($3.value);
705 STRIP_NOPS (c);
706 if (TREE_CODE (c) != INTEGER_CST)
707 error ("first argument to __builtin_choose_expr not"
708 " a constant");
709 $$ = integer_zerop (c) ? $7 : $5;
710 }
711 | CHOOSE_EXPR '(' error ')'
712 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
713 | TYPES_COMPATIBLE_P '(' typename ',' typename ')'
714 {
715 tree e1, e2;
717 e1 = TYPE_MAIN_VARIANT (groktypename ($3));
718 e2 = TYPE_MAIN_VARIANT (groktypename ($5));
720 $$.value = comptypes (e1, e2)
721 ? build_int_cst (NULL_TREE, 1)
722 : build_int_cst (NULL_TREE, 0);
723 $$.original_code = ERROR_MARK;
724 }
725 | TYPES_COMPATIBLE_P '(' error ')'
726 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
727 | primary '[' expr ']' %prec '.'
728 { $$.value = build_array_ref ($1.value, $3.value);
729 $$.original_code = ERROR_MARK; }
730 | primary '.' identifier
731 { $$.value = build_component_ref ($1.value, $3);
732 $$.original_code = ERROR_MARK; }
733 | primary POINTSAT identifier
734 {
735 tree expr = build_indirect_ref ($1.value, "->");
736 $$.value = build_component_ref (expr, $3);
737 $$.original_code = ERROR_MARK;
738 }
739 | primary PLUSPLUS
740 { $$.value = build_unary_op (POSTINCREMENT_EXPR, $1.value, 0);
741 $$.original_code = ERROR_MARK; }
742 | primary MINUSMINUS
743 { $$.value = build_unary_op (POSTDECREMENT_EXPR, $1.value, 0);
744 $$.original_code = ERROR_MARK; }
745 @@ifobjc
746 | objcmessageexpr
747 { $$.value = objc_build_message_expr ($1);
748 $$.original_code = ERROR_MARK; }
749 | objcselectorexpr
750 { $$.value = objc_build_selector_expr ($1);
751 $$.original_code = ERROR_MARK; }
752 | objcprotocolexpr
753 { $$.value = objc_build_protocol_expr ($1);
754 $$.original_code = ERROR_MARK; }
755 | objcencodeexpr
756 { $$.value = objc_build_encode_expr ($1);
757 $$.original_code = ERROR_MARK; }
758 | OBJC_STRING
759 { $$.value = objc_build_string_object ($1);
760 $$.original_code = ERROR_MARK; }
761 @@end_ifobjc
762 ;
764 /* This is the second argument to __builtin_offsetof. We must have one
765 identifier, and beyond that we want to accept sub structure and sub
766 array references. */
768 offsetof_member_designator:
769 identifier
770 { $$ = build_component_ref (offsetof_base, $1); }
771 | offsetof_member_designator '.' identifier
772 { $$ = build_component_ref ($1, $3); }
773 | offsetof_member_designator '[' expr ']'
774 { $$ = build_array_ref ($1, $3.value); }
775 ;
777 old_style_parm_decls:
778 /* empty */
779 | datadecls
780 ;
782 /* The following are analogous to lineno_decl, decls and decl
783 except that they do not allow nested functions.
784 They are used for old-style parm decls. */
785 lineno_datadecl:
786 save_location datadecl
787 { }
788 ;
790 datadecls:
791 lineno_datadecl
792 | errstmt
793 | datadecls lineno_datadecl
794 | lineno_datadecl errstmt
795 ;
797 /* We don't allow prefix attributes here because they cause reduce/reduce
798 conflicts: we can't know whether we're parsing a function decl with
799 attribute suffix, or function defn with attribute prefix on first old
800 style parm. */
801 datadecl:
802 declspecs_ts_nosa setspecs initdecls ';'
803 { POP_DECLSPEC_STACK; }
804 | declspecs_nots_nosa setspecs notype_initdecls ';'
805 { POP_DECLSPEC_STACK; }
806 | declspecs_ts_nosa ';'
807 { shadow_tag_warned ($1, 1);
808 pedwarn ("empty declaration"); }
809 | declspecs_nots_nosa ';'
810 { pedwarn ("empty declaration"); }
811 ;
813 /* This combination which saves a lineno before a decl
814 is the normal thing to use, rather than decl itself.
815 This is to avoid shift/reduce conflicts in contexts
816 where statement labels are allowed. */
817 lineno_decl:
818 save_location decl
819 { }
820 ;
822 /* records the type and storage class specs to use for processing
823 the declarators that follow.
824 Maintains a stack of outer-level values of current_declspecs,
825 for the sake of parm declarations nested in function declarators. */
826 setspecs: /* empty */
827 { pending_xref_error ();
828 PUSH_DECLSPEC_STACK;
829 split_specs_attrs ($<ttype>0,
830 ¤t_declspecs, &prefix_attributes);
831 all_prefix_attributes = prefix_attributes; }
832 ;
834 /* Possibly attributes after a comma, which should reset all_prefix_attributes
835 to prefix_attributes with these ones chained on the front. */
836 maybe_resetattrs:
837 maybe_attribute
838 { all_prefix_attributes = chainon ($1, prefix_attributes); }
839 ;
841 decl:
842 declspecs_ts setspecs initdecls ';'
843 { POP_DECLSPEC_STACK; }
844 | declspecs_nots setspecs notype_initdecls ';'
845 { POP_DECLSPEC_STACK; }
846 | declspecs_ts setspecs nested_function
847 { POP_DECLSPEC_STACK; }
848 | declspecs_nots setspecs notype_nested_function
849 { POP_DECLSPEC_STACK; }
850 | declspecs ';'
851 { shadow_tag ($1); }
852 | extension decl
853 { RESTORE_EXT_FLAGS ($1); }
854 ;
856 /* A list of declaration specifiers. These are:
858 - Storage class specifiers (scspec), which for GCC currently includes
859 function specifiers ("inline").
861 - Type specifiers (typespec_*).
863 - Type qualifiers (TYPE_QUAL).
865 - Attribute specifier lists (attributes).
867 These are stored as a TREE_LIST; the head of the list is the last
868 item in the specifier list. Each entry in the list has either a
869 TREE_PURPOSE that is an attribute specifier list, or a TREE_VALUE that
870 is a single other specifier or qualifier; and a TREE_CHAIN that is the
871 rest of the list. TREE_STATIC is set on the list if something other
872 than a storage class specifier or attribute has been seen; this is used
873 to warn for the obsolescent usage of storage class specifiers other than
874 at the start of the list. (Doing this properly would require function
875 specifiers to be handled separately from storage class specifiers.)
877 The various cases below are classified according to:
879 (a) Whether a storage class specifier is included or not; some
880 places in the grammar disallow storage class specifiers (_sc or _nosc).
882 (b) Whether a type specifier has been seen; after a type specifier,
883 a typedef name is an identifier to redeclare (_ts or _nots).
885 (c) Whether the list starts with an attribute; in certain places,
886 the grammar requires specifiers that don't start with an attribute
887 (_sa or _nosa).
889 (d) Whether the list ends with an attribute (or a specifier such that
890 any following attribute would have been parsed as part of that specifier);
891 this avoids shift-reduce conflicts in the parsing of attributes
892 (_ea or _noea).
894 TODO:
896 (i) Distinguish between function specifiers and storage class specifiers,
897 at least for the purpose of warnings about obsolescent usage.
899 (ii) Halve the number of productions here by eliminating the _sc/_nosc
900 distinction and instead checking where required that storage class
901 specifiers aren't present. */
903 /* Declspecs which contain at least one type specifier or typedef name.
904 (Just `const' or `volatile' is not enough.)
905 A typedef'd name following these is taken as a name to be declared.
906 Declspecs have a non-NULL TREE_VALUE, attributes do not. */
908 declspecs_nosc_nots_nosa_noea:
909 TYPE_QUAL
910 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
911 TREE_STATIC ($$) = 1; }
912 | declspecs_nosc_nots_nosa_noea TYPE_QUAL
913 { $$ = tree_cons (NULL_TREE, $2, $1);
914 TREE_STATIC ($$) = 1; }
915 | declspecs_nosc_nots_nosa_ea TYPE_QUAL
916 { $$ = tree_cons (NULL_TREE, $2, $1);
917 TREE_STATIC ($$) = 1; }
918 ;
920 declspecs_nosc_nots_nosa_ea:
921 declspecs_nosc_nots_nosa_noea attributes
922 { $$ = tree_cons ($2, NULL_TREE, $1);
923 TREE_STATIC ($$) = TREE_STATIC ($1); }
924 ;
926 declspecs_nosc_nots_sa_noea:
927 declspecs_nosc_nots_sa_noea TYPE_QUAL
928 { $$ = tree_cons (NULL_TREE, $2, $1);
929 TREE_STATIC ($$) = 1; }
930 | declspecs_nosc_nots_sa_ea TYPE_QUAL
931 { $$ = tree_cons (NULL_TREE, $2, $1);
932 TREE_STATIC ($$) = 1; }
933 ;
935 declspecs_nosc_nots_sa_ea:
936 attributes
937 { $$ = tree_cons ($1, NULL_TREE, NULL_TREE);
938 TREE_STATIC ($$) = 0; }
939 | declspecs_nosc_nots_sa_noea attributes
940 { $$ = tree_cons ($2, NULL_TREE, $1);
941 TREE_STATIC ($$) = TREE_STATIC ($1); }
942 ;
944 declspecs_nosc_ts_nosa_noea:
945 typespec_nonattr
946 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
947 TREE_STATIC ($$) = 1; }
948 | declspecs_nosc_ts_nosa_noea TYPE_QUAL
949 { $$ = tree_cons (NULL_TREE, $2, $1);
950 TREE_STATIC ($$) = 1; }
951 | declspecs_nosc_ts_nosa_ea TYPE_QUAL
952 { $$ = tree_cons (NULL_TREE, $2, $1);
953 TREE_STATIC ($$) = 1; }
954 | declspecs_nosc_ts_nosa_noea typespec_reserved_nonattr
955 { $$ = tree_cons (NULL_TREE, $2, $1);
956 TREE_STATIC ($$) = 1; }
957 | declspecs_nosc_ts_nosa_ea typespec_reserved_nonattr
958 { $$ = tree_cons (NULL_TREE, $2, $1);
959 TREE_STATIC ($$) = 1; }
960 | declspecs_nosc_nots_nosa_noea typespec_nonattr
961 { $$ = tree_cons (NULL_TREE, $2, $1);
962 TREE_STATIC ($$) = 1; }
963 | declspecs_nosc_nots_nosa_ea typespec_nonattr
964 { $$ = tree_cons (NULL_TREE, $2, $1);
965 TREE_STATIC ($$) = 1; }
966 ;
968 declspecs_nosc_ts_nosa_ea:
969 typespec_attr
970 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
971 TREE_STATIC ($$) = 1; }
972 | declspecs_nosc_ts_nosa_noea attributes
973 { $$ = tree_cons ($2, NULL_TREE, $1);
974 TREE_STATIC ($$) = TREE_STATIC ($1); }
975 | declspecs_nosc_ts_nosa_noea typespec_reserved_attr
976 { $$ = tree_cons (NULL_TREE, $2, $1);
977 TREE_STATIC ($$) = 1; }
978 | declspecs_nosc_ts_nosa_ea typespec_reserved_attr
979 { $$ = tree_cons (NULL_TREE, $2, $1);
980 TREE_STATIC ($$) = 1; }
981 | declspecs_nosc_nots_nosa_noea typespec_attr
982 { $$ = tree_cons (NULL_TREE, $2, $1);
983 TREE_STATIC ($$) = 1; }
984 | declspecs_nosc_nots_nosa_ea typespec_attr
985 { $$ = tree_cons (NULL_TREE, $2, $1);
986 TREE_STATIC ($$) = 1; }
987 ;
989 declspecs_nosc_ts_sa_noea:
990 declspecs_nosc_ts_sa_noea TYPE_QUAL
991 { $$ = tree_cons (NULL_TREE, $2, $1);
992 TREE_STATIC ($$) = 1; }
993 | declspecs_nosc_ts_sa_ea TYPE_QUAL
994 { $$ = tree_cons (NULL_TREE, $2, $1);
995 TREE_STATIC ($$) = 1; }
996 | declspecs_nosc_ts_sa_noea typespec_reserved_nonattr
997 { $$ = tree_cons (NULL_TREE, $2, $1);
998 TREE_STATIC ($$) = 1; }
999 | declspecs_nosc_ts_sa_ea typespec_reserved_nonattr
1000 { $$ = tree_cons (NULL_TREE, $2, $1);
1001 TREE_STATIC ($$) = 1; }
1002 | declspecs_nosc_nots_sa_noea typespec_nonattr
1003 { $$ = tree_cons (NULL_TREE, $2, $1);
1004 TREE_STATIC ($$) = 1; }
1005 | declspecs_nosc_nots_sa_ea typespec_nonattr
1006 { $$ = tree_cons (NULL_TREE, $2, $1);
1007 TREE_STATIC ($$) = 1; }
1008 ;
1010 declspecs_nosc_ts_sa_ea:
1011 declspecs_nosc_ts_sa_noea attributes
1012 { $$ = tree_cons ($2, NULL_TREE, $1);
1013 TREE_STATIC ($$) = TREE_STATIC ($1); }
1014 | declspecs_nosc_ts_sa_noea typespec_reserved_attr
1015 { $$ = tree_cons (NULL_TREE, $2, $1);
1016 TREE_STATIC ($$) = 1; }
1017 | declspecs_nosc_ts_sa_ea typespec_reserved_attr
1018 { $$ = tree_cons (NULL_TREE, $2, $1);
1019 TREE_STATIC ($$) = 1; }
1020 | declspecs_nosc_nots_sa_noea typespec_attr
1021 { $$ = tree_cons (NULL_TREE, $2, $1);
1022 TREE_STATIC ($$) = 1; }
1023 | declspecs_nosc_nots_sa_ea typespec_attr
1024 { $$ = tree_cons (NULL_TREE, $2, $1);
1025 TREE_STATIC ($$) = 1; }
1026 ;
1028 declspecs_sc_nots_nosa_noea:
1029 scspec
1030 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
1031 TREE_STATIC ($$) = 0; }
1032 | declspecs_sc_nots_nosa_noea TYPE_QUAL
1033 { $$ = tree_cons (NULL_TREE, $2, $1);
1034 TREE_STATIC ($$) = 1; }
1035 | declspecs_sc_nots_nosa_ea TYPE_QUAL
1036 { $$ = tree_cons (NULL_TREE, $2, $1);
1037 TREE_STATIC ($$) = 1; }
1038 | declspecs_nosc_nots_nosa_noea scspec
1039 { if (extra_warnings && TREE_STATIC ($1))
1040 warning ("`%s' is not at beginning of declaration",
1041 IDENTIFIER_POINTER ($2));
1042 $$ = tree_cons (NULL_TREE, $2, $1);
1043 TREE_STATIC ($$) = TREE_STATIC ($1); }
1044 | declspecs_nosc_nots_nosa_ea scspec
1045 { if (extra_warnings && TREE_STATIC ($1))
1046 warning ("`%s' is not at beginning of declaration",
1047 IDENTIFIER_POINTER ($2));
1048 $$ = tree_cons (NULL_TREE, $2, $1);
1049 TREE_STATIC ($$) = TREE_STATIC ($1); }
1050 | declspecs_sc_nots_nosa_noea scspec
1051 { if (extra_warnings && TREE_STATIC ($1))
1052 warning ("`%s' is not at beginning of declaration",
1053 IDENTIFIER_POINTER ($2));
1054 $$ = tree_cons (NULL_TREE, $2, $1);
1055 TREE_STATIC ($$) = TREE_STATIC ($1); }
1056 | declspecs_sc_nots_nosa_ea scspec
1057 { if (extra_warnings && TREE_STATIC ($1))
1058 warning ("`%s' is not at beginning of declaration",
1059 IDENTIFIER_POINTER ($2));
1060 $$ = tree_cons (NULL_TREE, $2, $1);
1061 TREE_STATIC ($$) = TREE_STATIC ($1); }
1062 ;
1064 declspecs_sc_nots_nosa_ea:
1065 declspecs_sc_nots_nosa_noea attributes
1066 { $$ = tree_cons ($2, NULL_TREE, $1);
1067 TREE_STATIC ($$) = TREE_STATIC ($1); }
1068 ;
1070 declspecs_sc_nots_sa_noea:
1071 declspecs_sc_nots_sa_noea TYPE_QUAL
1072 { $$ = tree_cons (NULL_TREE, $2, $1);
1073 TREE_STATIC ($$) = 1; }
1074 | declspecs_sc_nots_sa_ea TYPE_QUAL
1075 { $$ = tree_cons (NULL_TREE, $2, $1);
1076 TREE_STATIC ($$) = 1; }
1077 | declspecs_nosc_nots_sa_noea scspec
1078 { if (extra_warnings && TREE_STATIC ($1))
1079 warning ("`%s' is not at beginning of declaration",
1080 IDENTIFIER_POINTER ($2));
1081 $$ = tree_cons (NULL_TREE, $2, $1);
1082 TREE_STATIC ($$) = TREE_STATIC ($1); }
1083 | declspecs_nosc_nots_sa_ea scspec
1084 { if (extra_warnings && TREE_STATIC ($1))
1085 warning ("`%s' is not at beginning of declaration",
1086 IDENTIFIER_POINTER ($2));
1087 $$ = tree_cons (NULL_TREE, $2, $1);
1088 TREE_STATIC ($$) = TREE_STATIC ($1); }
1089 | declspecs_sc_nots_sa_noea scspec
1090 { if (extra_warnings && TREE_STATIC ($1))
1091 warning ("`%s' is not at beginning of declaration",
1092 IDENTIFIER_POINTER ($2));
1093 $$ = tree_cons (NULL_TREE, $2, $1);
1094 TREE_STATIC ($$) = TREE_STATIC ($1); }
1095 | declspecs_sc_nots_sa_ea scspec
1096 { if (extra_warnings && TREE_STATIC ($1))
1097 warning ("`%s' is not at beginning of declaration",
1098 IDENTIFIER_POINTER ($2));
1099 $$ = tree_cons (NULL_TREE, $2, $1);
1100 TREE_STATIC ($$) = TREE_STATIC ($1); }
1101 ;
1103 declspecs_sc_nots_sa_ea:
1104 declspecs_sc_nots_sa_noea attributes
1105 { $$ = tree_cons ($2, NULL_TREE, $1);
1106 TREE_STATIC ($$) = TREE_STATIC ($1); }
1107 ;
1109 declspecs_sc_ts_nosa_noea:
1110 declspecs_sc_ts_nosa_noea TYPE_QUAL
1111 { $$ = tree_cons (NULL_TREE, $2, $1);
1112 TREE_STATIC ($$) = 1; }
1113 | declspecs_sc_ts_nosa_ea TYPE_QUAL
1114 { $$ = tree_cons (NULL_TREE, $2, $1);
1115 TREE_STATIC ($$) = 1; }
1116 | declspecs_sc_ts_nosa_noea typespec_reserved_nonattr
1117 { $$ = tree_cons (NULL_TREE, $2, $1);
1118 TREE_STATIC ($$) = 1; }
1119 | declspecs_sc_ts_nosa_ea typespec_reserved_nonattr
1120 { $$ = tree_cons (NULL_TREE, $2, $1);
1121 TREE_STATIC ($$) = 1; }
1122 | declspecs_sc_nots_nosa_noea typespec_nonattr
1123 { $$ = tree_cons (NULL_TREE, $2, $1);
1124 TREE_STATIC ($$) = 1; }
1125 | declspecs_sc_nots_nosa_ea typespec_nonattr
1126 { $$ = tree_cons (NULL_TREE, $2, $1);
1127 TREE_STATIC ($$) = 1; }
1128 | declspecs_nosc_ts_nosa_noea scspec
1129 { if (extra_warnings && TREE_STATIC ($1))
1130 warning ("`%s' is not at beginning of declaration",
1131 IDENTIFIER_POINTER ($2));
1132 $$ = tree_cons (NULL_TREE, $2, $1);
1133 TREE_STATIC ($$) = TREE_STATIC ($1); }
1134 | declspecs_nosc_ts_nosa_ea scspec
1135 { if (extra_warnings && TREE_STATIC ($1))
1136 warning ("`%s' is not at beginning of declaration",
1137 IDENTIFIER_POINTER ($2));
1138 $$ = tree_cons (NULL_TREE, $2, $1);
1139 TREE_STATIC ($$) = TREE_STATIC ($1); }
1140 | declspecs_sc_ts_nosa_noea scspec
1141 { if (extra_warnings && TREE_STATIC ($1))
1142 warning ("`%s' is not at beginning of declaration",
1143 IDENTIFIER_POINTER ($2));
1144 $$ = tree_cons (NULL_TREE, $2, $1);
1145 TREE_STATIC ($$) = TREE_STATIC ($1); }
1146 | declspecs_sc_ts_nosa_ea scspec
1147 { if (extra_warnings && TREE_STATIC ($1))
1148 warning ("`%s' is not at beginning of declaration",
1149 IDENTIFIER_POINTER ($2));
1150 $$ = tree_cons (NULL_TREE, $2, $1);
1151 TREE_STATIC ($$) = TREE_STATIC ($1); }
1152 ;
1154 declspecs_sc_ts_nosa_ea:
1155 declspecs_sc_ts_nosa_noea attributes
1156 { $$ = tree_cons ($2, NULL_TREE, $1);
1157 TREE_STATIC ($$) = TREE_STATIC ($1); }
1158 | declspecs_sc_ts_nosa_noea typespec_reserved_attr
1159 { $$ = tree_cons (NULL_TREE, $2, $1);
1160 TREE_STATIC ($$) = 1; }
1161 | declspecs_sc_ts_nosa_ea typespec_reserved_attr
1162 { $$ = tree_cons (NULL_TREE, $2, $1);
1163 TREE_STATIC ($$) = 1; }
1164 | declspecs_sc_nots_nosa_noea typespec_attr
1165 { $$ = tree_cons (NULL_TREE, $2, $1);
1166 TREE_STATIC ($$) = 1; }
1167 | declspecs_sc_nots_nosa_ea typespec_attr
1168 { $$ = tree_cons (NULL_TREE, $2, $1);
1169 TREE_STATIC ($$) = 1; }
1170 ;
1172 declspecs_sc_ts_sa_noea:
1173 declspecs_sc_ts_sa_noea TYPE_QUAL
1174 { $$ = tree_cons (NULL_TREE, $2, $1);
1175 TREE_STATIC ($$) = 1; }
1176 | declspecs_sc_ts_sa_ea TYPE_QUAL
1177 { $$ = tree_cons (NULL_TREE, $2, $1);
1178 TREE_STATIC ($$) = 1; }
1179 | declspecs_sc_ts_sa_noea typespec_reserved_nonattr
1180 { $$ = tree_cons (NULL_TREE, $2, $1);
1181 TREE_STATIC ($$) = 1; }
1182 | declspecs_sc_ts_sa_ea typespec_reserved_nonattr
1183 { $$ = tree_cons (NULL_TREE, $2, $1);
1184 TREE_STATIC ($$) = 1; }
1185 | declspecs_sc_nots_sa_noea typespec_nonattr
1186 { $$ = tree_cons (NULL_TREE, $2, $1);
1187 TREE_STATIC ($$) = 1; }
1188 | declspecs_sc_nots_sa_ea typespec_nonattr
1189 { $$ = tree_cons (NULL_TREE, $2, $1);
1190 TREE_STATIC ($$) = 1; }
1191 | declspecs_nosc_ts_sa_noea scspec
1192 { if (extra_warnings && TREE_STATIC ($1))
1193 warning ("`%s' is not at beginning of declaration",
1194 IDENTIFIER_POINTER ($2));
1195 $$ = tree_cons (NULL_TREE, $2, $1);
1196 TREE_STATIC ($$) = TREE_STATIC ($1); }
1197 | declspecs_nosc_ts_sa_ea scspec
1198 { if (extra_warnings && TREE_STATIC ($1))
1199 warning ("`%s' is not at beginning of declaration",
1200 IDENTIFIER_POINTER ($2));
1201 $$ = tree_cons (NULL_TREE, $2, $1);
1202 TREE_STATIC ($$) = TREE_STATIC ($1); }
1203 | declspecs_sc_ts_sa_noea scspec
1204 { if (extra_warnings && TREE_STATIC ($1))
1205 warning ("`%s' is not at beginning of declaration",
1206 IDENTIFIER_POINTER ($2));
1207 $$ = tree_cons (NULL_TREE, $2, $1);
1208 TREE_STATIC ($$) = TREE_STATIC ($1); }
1209 | declspecs_sc_ts_sa_ea scspec
1210 { if (extra_warnings && TREE_STATIC ($1))
1211 warning ("`%s' is not at beginning of declaration",
1212 IDENTIFIER_POINTER ($2));
1213 $$ = tree_cons (NULL_TREE, $2, $1);
1214 TREE_STATIC ($$) = TREE_STATIC ($1); }
1215 ;
1217 declspecs_sc_ts_sa_ea:
1218 declspecs_sc_ts_sa_noea attributes
1219 { $$ = tree_cons ($2, NULL_TREE, $1);
1220 TREE_STATIC ($$) = TREE_STATIC ($1); }
1221 | declspecs_sc_ts_sa_noea typespec_reserved_attr
1222 { $$ = tree_cons (NULL_TREE, $2, $1);
1223 TREE_STATIC ($$) = 1; }
1224 | declspecs_sc_ts_sa_ea typespec_reserved_attr
1225 { $$ = tree_cons (NULL_TREE, $2, $1);
1226 TREE_STATIC ($$) = 1; }
1227 | declspecs_sc_nots_sa_noea typespec_attr
1228 { $$ = tree_cons (NULL_TREE, $2, $1);
1229 TREE_STATIC ($$) = 1; }
1230 | declspecs_sc_nots_sa_ea typespec_attr
1231 { $$ = tree_cons (NULL_TREE, $2, $1);
1232 TREE_STATIC ($$) = 1; }
1233 ;
1235 /* Particular useful classes of declspecs. */
1236 declspecs_ts:
1237 declspecs_nosc_ts_nosa_noea
1238 | declspecs_nosc_ts_nosa_ea
1239 | declspecs_nosc_ts_sa_noea
1240 | declspecs_nosc_ts_sa_ea
1241 | declspecs_sc_ts_nosa_noea
1242 | declspecs_sc_ts_nosa_ea
1243 | declspecs_sc_ts_sa_noea
1244 | declspecs_sc_ts_sa_ea
1245 ;
1247 declspecs_nots:
1248 declspecs_nosc_nots_nosa_noea
1249 | declspecs_nosc_nots_nosa_ea
1250 | declspecs_nosc_nots_sa_noea
1251 | declspecs_nosc_nots_sa_ea
1252 | declspecs_sc_nots_nosa_noea
1253 | declspecs_sc_nots_nosa_ea
1254 | declspecs_sc_nots_sa_noea
1255 | declspecs_sc_nots_sa_ea
1256 ;
1258 declspecs_ts_nosa:
1259 declspecs_nosc_ts_nosa_noea
1260 | declspecs_nosc_ts_nosa_ea
1261 | declspecs_sc_ts_nosa_noea
1262 | declspecs_sc_ts_nosa_ea
1263 ;
1265 declspecs_nots_nosa:
1266 declspecs_nosc_nots_nosa_noea
1267 | declspecs_nosc_nots_nosa_ea
1268 | declspecs_sc_nots_nosa_noea
1269 | declspecs_sc_nots_nosa_ea
1270 ;
1272 declspecs_nosc_ts:
1273 declspecs_nosc_ts_nosa_noea
1274 | declspecs_nosc_ts_nosa_ea
1275 | declspecs_nosc_ts_sa_noea
1276 | declspecs_nosc_ts_sa_ea
1277 ;
1279 declspecs_nosc_nots:
1280 declspecs_nosc_nots_nosa_noea
1281 | declspecs_nosc_nots_nosa_ea
1282 | declspecs_nosc_nots_sa_noea
1283 | declspecs_nosc_nots_sa_ea
1284 ;
1286 declspecs_nosc:
1287 declspecs_nosc_ts_nosa_noea
1288 | declspecs_nosc_ts_nosa_ea
1289 | declspecs_nosc_ts_sa_noea
1290 | declspecs_nosc_ts_sa_ea
1291 | declspecs_nosc_nots_nosa_noea
1292 | declspecs_nosc_nots_nosa_ea
1293 | declspecs_nosc_nots_sa_noea
1294 | declspecs_nosc_nots_sa_ea
1295 ;
1297 declspecs:
1298 declspecs_nosc_nots_nosa_noea
1299 | declspecs_nosc_nots_nosa_ea
1300 | declspecs_nosc_nots_sa_noea
1301 | declspecs_nosc_nots_sa_ea
1302 | declspecs_nosc_ts_nosa_noea
1303 | declspecs_nosc_ts_nosa_ea
1304 | declspecs_nosc_ts_sa_noea
1305 | declspecs_nosc_ts_sa_ea
1306 | declspecs_sc_nots_nosa_noea
1307 | declspecs_sc_nots_nosa_ea
1308 | declspecs_sc_nots_sa_noea
1309 | declspecs_sc_nots_sa_ea
1310 | declspecs_sc_ts_nosa_noea
1311 | declspecs_sc_ts_nosa_ea
1312 | declspecs_sc_ts_sa_noea
1313 | declspecs_sc_ts_sa_ea
1314 ;
1316 /* A (possibly empty) sequence of type qualifiers and attributes. */
1317 maybe_type_quals_attrs:
1318 /* empty */
1319 { $$ = NULL_TREE; }
1320 | declspecs_nosc_nots
1321 { $$ = $1; }
1322 ;
1324 /* A type specifier (but not a type qualifier).
1325 Once we have seen one of these in a declaration,
1326 if a typedef name appears then it is being redeclared.
1328 The _reserved versions start with a reserved word and may appear anywhere
1329 in the declaration specifiers; the _nonreserved versions may only
1330 appear before any other type specifiers, and after that are (if names)
1331 being redeclared.
1333 FIXME: should the _nonreserved version be restricted to names being
1334 redeclared only? The other entries there relate only the GNU extensions
1335 and Objective C, and are historically parsed thus, and don't make sense
1336 after other type specifiers, but it might be cleaner to count them as
1337 _reserved.
1339 _attr means: specifiers that either end with attributes,
1340 or are such that any following attributes would
1341 be parsed as part of the specifier.
1343 _nonattr: specifiers. */
1345 typespec_nonattr:
1346 typespec_reserved_nonattr
1347 | typespec_nonreserved_nonattr
1348 ;
1350 typespec_attr:
1351 typespec_reserved_attr
1352 ;
1354 typespec_reserved_nonattr:
1355 TYPESPEC
1356 { OBJC_NEED_RAW_IDENTIFIER (1); }
1357 | structsp_nonattr
1358 ;
1360 typespec_reserved_attr:
1361 structsp_attr
1362 ;
1364 typespec_nonreserved_nonattr:
1365 TYPENAME
1366 { /* For a typedef name, record the meaning, not the name.
1367 In case of `foo foo, bar;'. */
1368 $$ = lookup_name ($1); }
1369 @@ifobjc
1370 | CLASSNAME protocolrefs
1371 { $$ = get_static_reference ($1, $2); }
1372 | OBJECTNAME protocolrefs
1373 { $$ = get_protocol_reference ($2); }
1375 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>"
1376 - nisse@lysator.liu.se */
1377 | non_empty_protocolrefs
1378 { $$ = get_protocol_reference ($1); }
1379 @@end_ifobjc
1380 | typeof '(' expr ')'
1381 { skip_evaluation--;
1382 if (TREE_CODE ($3.value) == COMPONENT_REF
1383 && DECL_C_BIT_FIELD (TREE_OPERAND ($3.value, 1)))
1384 error ("`typeof' applied to a bit-field");
1385 $$ = TREE_TYPE ($3.value); }
1386 | typeof '(' typename ')'
1387 { skip_evaluation--; $$ = groktypename ($3); }
1388 ;
1390 /* typespec_nonreserved_attr does not exist. */
1392 initdecls:
1393 initdcl
1394 | initdecls ',' maybe_resetattrs initdcl
1395 ;
1397 notype_initdecls:
1398 notype_initdcl
1399 | notype_initdecls ',' maybe_resetattrs notype_initdcl
1400 ;
1402 initdcl:
1403 declarator maybeasm maybe_attribute '='
1404 { $<ttype>$ = start_decl ($1, current_declspecs, true,
1405 chainon ($3, all_prefix_attributes));
1406 start_init ($<ttype>$, $2, global_bindings_p ()); }
1407 init
1408 /* Note how the declaration of the variable is in effect while its init is parsed! */
1409 { finish_init ();
1410 maybe_warn_string_init (TREE_TYPE ($<ttype>5), $6);
1411 finish_decl ($<ttype>5, $6.value, $2); }
1412 | declarator maybeasm maybe_attribute
1413 { tree d = start_decl ($1, current_declspecs, false,
1414 chainon ($3, all_prefix_attributes));
1415 finish_decl (d, NULL_TREE, $2);
1416 }
1417 ;
1419 notype_initdcl:
1420 notype_declarator maybeasm maybe_attribute '='
1421 { $<ttype>$ = start_decl ($1, current_declspecs, true,
1422 chainon ($3, all_prefix_attributes));
1423 start_init ($<ttype>$, $2, global_bindings_p ()); }
1424 init
1425 /* Note how the declaration of the variable is in effect while its init is parsed! */
1426 { finish_init ();
1427 maybe_warn_string_init (TREE_TYPE ($<ttype>5), $6);
1428 finish_decl ($<ttype>5, $6.value, $2); }
1429 | notype_declarator maybeasm maybe_attribute
1430 { tree d = start_decl ($1, current_declspecs, false,
1431 chainon ($3, all_prefix_attributes));
1432 finish_decl (d, NULL_TREE, $2); }
1433 ;
1434 /* the * rules are dummies to accept the Apollo extended syntax
1435 so that the header files compile. */
1436 maybe_attribute:
1437 /* empty */
1438 { $$ = NULL_TREE; }
1439 | attributes
1440 { $$ = $1; }
1441 ;
1443 attributes:
1444 attribute
1445 { $$ = $1; }
1446 | attributes attribute
1447 { $$ = chainon ($1, $2); }
1448 ;
1450 attribute:
1451 ATTRIBUTE stop_string_translation
1452 '(' '(' attribute_list ')' ')' start_string_translation
1453 { $$ = $5; }
1454 | ATTRIBUTE error start_string_translation
1455 {}
1456 ;
1458 attribute_list:
1459 attrib
1460 { $$ = $1; }
1461 | attribute_list ',' attrib
1462 { $$ = chainon ($1, $3); }
1463 ;
1465 attrib:
1466 /* empty */
1467 { $$ = NULL_TREE; }
1468 | any_word
1469 { $$ = build_tree_list ($1, NULL_TREE); }
1470 | any_word '(' IDENTIFIER ')'
1471 { $$ = build_tree_list ($1, build_tree_list (NULL_TREE, $3)); }
1472 | any_word '(' IDENTIFIER ',' nonnull_exprlist ')'
1473 { $$ = build_tree_list ($1, tree_cons (NULL_TREE, $3, $5)); }
1474 | any_word '(' exprlist ')'
1475 { $$ = build_tree_list ($1, $3); }
1476 ;
1478 /* This still leaves out most reserved keywords,
1479 shouldn't we include them? */
1481 any_word:
1482 identifier
1483 | scspec
1484 | TYPESPEC
1485 | TYPE_QUAL
1486 ;
1488 scspec:
1489 STATIC
1490 | SCSPEC
1491 ;
1492 \f
1493 /* Initializers. `init' is the entry point. */
1495 init:
1496 expr_no_commas
1497 { $$ = $1; }
1498 | '{'
1499 { really_start_incremental_init (NULL_TREE); }
1500 initlist_maybe_comma '}'
1501 { $$ = pop_init_level (0); }
1502 | error
1503 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
1504 ;
1506 /* `initlist_maybe_comma' is the guts of an initializer in braces. */
1507 initlist_maybe_comma:
1508 /* empty */
1509 { if (pedantic)
1510 pedwarn ("ISO C forbids empty initializer braces"); }
1511 | initlist1 maybecomma
1512 ;
1514 initlist1:
1515 initelt
1516 | initlist1 ',' initelt
1517 ;
1519 /* `initelt' is a single element of an initializer.
1520 It may use braces. */
1521 initelt:
1522 designator_list '=' initval
1523 { if (pedantic && ! flag_isoc99)
1524 pedwarn ("ISO C90 forbids specifying subobject to initialize"); }
1525 | designator initval
1526 { if (pedantic)
1527 pedwarn ("obsolete use of designated initializer without `='"); }
1528 | identifier ':'
1529 { set_init_label ($1);
1530 if (pedantic)
1531 pedwarn ("obsolete use of designated initializer with `:'"); }
1532 initval
1533 {}
1534 | initval
1535 ;
1537 initval:
1538 '{'
1539 { push_init_level (0); }
1540 initlist_maybe_comma '}'
1541 { process_init_element (pop_init_level (0)); }
1542 | expr_no_commas
1543 { process_init_element ($1); }
1544 | error
1545 ;
1547 designator_list:
1548 designator
1549 | designator_list designator
1550 ;
1552 designator:
1553 '.' identifier
1554 { set_init_label ($2); }
1555 | '[' expr_no_commas ELLIPSIS expr_no_commas ']'
1556 { set_init_index ($2.value, $4.value);
1557 if (pedantic)
1558 pedwarn ("ISO C forbids specifying range of elements to initialize"); }
1559 | '[' expr_no_commas ']'
1560 { set_init_index ($2.value, NULL_TREE); }
1561 ;
1562 \f
1563 nested_function:
1564 declarator
1565 { if (pedantic)
1566 pedwarn ("ISO C forbids nested functions");
1568 push_function_context ();
1569 if (! start_function (current_declspecs, $1,
1570 all_prefix_attributes))
1571 {
1572 pop_function_context ();
1573 YYERROR1;
1574 }
1575 }
1576 old_style_parm_decls save_location
1577 { tree decl = current_function_decl;
1578 DECL_SOURCE_LOCATION (decl) = $4;
1579 store_parm_decls (); }
1580 /* This used to use compstmt_or_error. That caused a bug with
1581 input `f(g) int g {}', where the use of YYERROR1 above caused
1582 an error which then was handled by compstmt_or_error. There
1583 followed a repeated execution of that same rule, which called
1584 YYERROR1 again, and so on. */
1585 compstmt
1586 { tree decl = current_function_decl;
1587 add_stmt ($6);
1588 finish_function ();
1589 pop_function_context ();
1590 add_stmt (build_stmt (DECL_EXPR, decl)); }
1591 ;
1593 notype_nested_function:
1594 notype_declarator
1595 { if (pedantic)
1596 pedwarn ("ISO C forbids nested functions");
1598 push_function_context ();
1599 if (! start_function (current_declspecs, $1,
1600 all_prefix_attributes))
1601 {
1602 pop_function_context ();
1603 YYERROR1;
1604 }
1605 }
1606 old_style_parm_decls save_location
1607 { tree decl = current_function_decl;
1608 DECL_SOURCE_LOCATION (decl) = $4;
1609 store_parm_decls (); }
1610 /* This used to use compstmt_or_error. That caused a bug with
1611 input `f(g) int g {}', where the use of YYERROR1 above caused
1612 an error which then was handled by compstmt_or_error. There
1613 followed a repeated execution of that same rule, which called
1614 YYERROR1 again, and so on. */
1615 compstmt
1616 { tree decl = current_function_decl;
1617 add_stmt ($6);
1618 finish_function ();
1619 pop_function_context ();
1620 add_stmt (build_stmt (DECL_EXPR, decl)); }
1621 ;
1623 /* Any kind of declarator (thus, all declarators allowed
1624 after an explicit typespec). */
1626 declarator:
1627 after_type_declarator
1628 | notype_declarator
1629 ;
1631 /* A declarator that is allowed only after an explicit typespec. */
1633 after_type_declarator:
1634 '(' maybe_attribute after_type_declarator ')'
1635 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1636 | after_type_declarator '(' parmlist_or_identifiers %prec '.'
1637 { $$ = build_function_declarator ($3, $1); }
1638 | after_type_declarator array_declarator %prec '.'
1639 { $$ = set_array_declarator_inner ($2, $1, false); }
1640 | '*' maybe_type_quals_attrs after_type_declarator %prec UNARY
1641 { $$ = make_pointer_declarator ($2, $3); }
1642 | TYPENAME
1643 @@ifobjc
1644 | OBJECTNAME
1645 @@end_ifobjc
1646 ;
1648 /* Kinds of declarator that can appear in a parameter list
1649 in addition to notype_declarator. This is like after_type_declarator
1650 but does not allow a typedef name in parentheses as an identifier
1651 (because it would conflict with a function with that typedef as arg). */
1652 parm_declarator:
1653 parm_declarator_starttypename
1654 | parm_declarator_nostarttypename
1655 ;
1657 parm_declarator_starttypename:
1658 parm_declarator_starttypename '(' parmlist_or_identifiers %prec '.'
1659 { $$ = build_function_declarator ($3, $1); }
1660 | parm_declarator_starttypename array_declarator %prec '.'
1661 { $$ = set_array_declarator_inner ($2, $1, false); }
1662 | TYPENAME
1663 @@ifobjc
1664 | OBJECTNAME
1665 @@end_ifobjc
1666 ;
1668 parm_declarator_nostarttypename:
1669 parm_declarator_nostarttypename '(' parmlist_or_identifiers %prec '.'
1670 { $$ = build_function_declarator ($3, $1); }
1671 | parm_declarator_nostarttypename array_declarator %prec '.'
1672 { $$ = set_array_declarator_inner ($2, $1, false); }
1673 | '*' maybe_type_quals_attrs parm_declarator_starttypename %prec UNARY
1674 { $$ = make_pointer_declarator ($2, $3); }
1675 | '*' maybe_type_quals_attrs parm_declarator_nostarttypename %prec UNARY
1676 { $$ = make_pointer_declarator ($2, $3); }
1677 | '(' maybe_attribute parm_declarator_nostarttypename ')'
1678 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1679 ;
1681 /* A declarator allowed whether or not there has been
1682 an explicit typespec. These cannot redeclare a typedef-name. */
1684 notype_declarator:
1685 notype_declarator '(' parmlist_or_identifiers %prec '.'
1686 { $$ = build_function_declarator ($3, $1); }
1687 | '(' maybe_attribute notype_declarator ')'
1688 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1689 | '*' maybe_type_quals_attrs notype_declarator %prec UNARY
1690 { $$ = make_pointer_declarator ($2, $3); }
1691 | notype_declarator array_declarator %prec '.'
1692 { $$ = set_array_declarator_inner ($2, $1, false); }
1693 | IDENTIFIER
1694 ;
1696 struct_head:
1697 STRUCT
1698 { $$ = NULL_TREE; }
1699 | STRUCT attributes
1700 { $$ = $2; }
1701 ;
1703 union_head:
1704 UNION
1705 { $$ = NULL_TREE; }
1706 | UNION attributes
1707 { $$ = $2; }
1708 ;
1710 enum_head:
1711 ENUM
1712 { $$ = NULL_TREE; }
1713 | ENUM attributes
1714 { $$ = $2; }
1715 ;
1717 /* structsp_attr: struct/union/enum specifiers that either
1718 end with attributes, or are such that any following attributes would
1719 be parsed as part of the struct/union/enum specifier.
1721 structsp_nonattr: other struct/union/enum specifiers. */
1723 structsp_attr:
1724 struct_head identifier '{'
1725 { $$ = start_struct (RECORD_TYPE, $2);
1726 /* Start scope of tag before parsing components. */
1727 }
1728 component_decl_list '}' maybe_attribute
1729 { $$ = finish_struct ($<ttype>4, nreverse ($5),
1730 chainon ($1, $7)); }
1731 | struct_head '{' component_decl_list '}' maybe_attribute
1732 { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
1733 nreverse ($3), chainon ($1, $5));
1734 }
1735 | union_head identifier '{'
1736 { $$ = start_struct (UNION_TYPE, $2); }
1737 component_decl_list '}' maybe_attribute
1738 { $$ = finish_struct ($<ttype>4, nreverse ($5),
1739 chainon ($1, $7)); }
1740 | union_head '{' component_decl_list '}' maybe_attribute
1741 { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
1742 nreverse ($3), chainon ($1, $5));
1743 }
1744 | enum_head identifier '{'
1745 { $$ = start_enum ($2); }
1746 enumlist maybecomma_warn '}' maybe_attribute
1747 { $$ = finish_enum ($<ttype>4, nreverse ($5),
1748 chainon ($1, $8)); }
1749 | enum_head '{'
1750 { $$ = start_enum (NULL_TREE); }
1751 enumlist maybecomma_warn '}' maybe_attribute
1752 { $$ = finish_enum ($<ttype>3, nreverse ($4),
1753 chainon ($1, $7)); }
1754 ;
1756 structsp_nonattr:
1757 struct_head identifier
1758 { $$ = xref_tag (RECORD_TYPE, $2); }
1759 | union_head identifier
1760 { $$ = xref_tag (UNION_TYPE, $2); }
1761 | enum_head identifier
1762 { $$ = xref_tag (ENUMERAL_TYPE, $2);
1763 /* In ISO C, enumerated types can be referred to
1764 only if already defined. */
1765 if (pedantic && !COMPLETE_TYPE_P ($$))
1766 pedwarn ("ISO C forbids forward references to `enum' types"); }
1767 ;
1769 maybecomma:
1770 /* empty */
1771 | ','
1772 ;
1774 maybecomma_warn:
1775 /* empty */
1776 | ','
1777 { if (pedantic && ! flag_isoc99)
1778 pedwarn ("comma at end of enumerator list"); }
1779 ;
1781 /* We chain the components in reverse order. They are put in forward
1782 order in structsp_attr.
1784 Note that component_declarator returns single decls, so components
1785 and components_notype can use TREE_CHAIN directly, wheras components
1786 and components_notype return lists (of comma separated decls), so
1787 component_decl_list and component_decl_list2 must use chainon.
1789 The theory behind all this is that there will be more semicolon
1790 separated fields than comma separated fields, and so we'll be
1791 minimizing the number of node traversals required by chainon. */
1793 component_decl_list:
1794 component_decl_list2
1795 { $$ = $1; }
1796 | component_decl_list2 component_decl
1797 { $$ = chainon ($2, $1);
1798 pedwarn ("no semicolon at end of struct or union"); }
1799 ;
1801 component_decl_list2: /* empty */
1802 { $$ = NULL_TREE; }
1803 | component_decl_list2 component_decl ';'
1804 { $$ = chainon ($2, $1); }
1805 | component_decl_list2 ';'
1806 { if (pedantic)
1807 pedwarn ("extra semicolon in struct or union specified"); }
1808 @@ifobjc
1809 /* foo(sizeof(struct{ @defs(ClassName)})); */
1810 | AT_DEFS '(' CLASSNAME ')'
1811 { $$ = nreverse (objc_get_class_ivars ($3)); }
1812 @@end_ifobjc
1813 ;
1815 component_decl:
1816 declspecs_nosc_ts setspecs components
1817 { $$ = $3;
1818 POP_DECLSPEC_STACK; }
1819 | declspecs_nosc_ts setspecs
1820 {
1821 /* Support for unnamed structs or unions as members of
1822 structs or unions (which is [a] useful and [b] supports
1823 MS P-SDK). */
1824 if (pedantic)
1825 pedwarn ("ISO C doesn't support unnamed structs/unions");
1827 $$ = grokfield(NULL, current_declspecs, NULL_TREE);
1828 POP_DECLSPEC_STACK; }
1829 | declspecs_nosc_nots setspecs components_notype
1830 { $$ = $3;
1831 POP_DECLSPEC_STACK; }
1832 | declspecs_nosc_nots
1833 { if (pedantic)
1834 pedwarn ("ISO C forbids member declarations with no members");
1835 shadow_tag_warned ($1, pedantic);
1836 $$ = NULL_TREE; }
1837 | error
1838 { $$ = NULL_TREE; }
1839 | extension component_decl
1840 { $$ = $2;
1841 RESTORE_EXT_FLAGS ($1); }
1842 ;
1844 components:
1845 component_declarator
1846 | components ',' maybe_resetattrs component_declarator
1847 { TREE_CHAIN ($4) = $1; $$ = $4; }
1848 ;
1850 components_notype:
1851 component_notype_declarator
1852 | components_notype ',' maybe_resetattrs component_notype_declarator
1853 { TREE_CHAIN ($4) = $1; $$ = $4; }
1854 ;
1856 component_declarator:
1857 declarator maybe_attribute
1858 { $$ = grokfield ($1, current_declspecs, NULL_TREE);
1859 decl_attributes (&$$,
1860 chainon ($2, all_prefix_attributes), 0); }
1861 | declarator ':' expr_no_commas maybe_attribute
1862 { $$ = grokfield ($1, current_declspecs, $3.value);
1863 decl_attributes (&$$,
1864 chainon ($4, all_prefix_attributes), 0); }
1865 | ':' expr_no_commas maybe_attribute
1866 { $$ = grokfield (NULL_TREE, current_declspecs, $2.value);
1867 decl_attributes (&$$,
1868 chainon ($3, all_prefix_attributes), 0); }
1869 ;
1871 component_notype_declarator:
1872 notype_declarator maybe_attribute
1873 { $$ = grokfield ($1, current_declspecs, NULL_TREE);
1874 decl_attributes (&$$,
1875 chainon ($2, all_prefix_attributes), 0); }
1876 | notype_declarator ':' expr_no_commas maybe_attribute
1877 { $$ = grokfield ($1, current_declspecs, $3.value);
1878 decl_attributes (&$$,
1879 chainon ($4, all_prefix_attributes), 0); }
1880 | ':' expr_no_commas maybe_attribute
1881 { $$ = grokfield (NULL_TREE, current_declspecs, $2.value);
1882 decl_attributes (&$$,
1883 chainon ($3, all_prefix_attributes), 0); }
1884 ;
1886 /* We chain the enumerators in reverse order.
1887 They are put in forward order in structsp_attr. */
1889 enumlist:
1890 enumerator
1891 | enumlist ',' enumerator
1892 { if ($1 == error_mark_node)
1893 $$ = $1;
1894 else
1895 TREE_CHAIN ($3) = $1, $$ = $3; }
1896 | error
1897 { $$ = error_mark_node; }
1898 ;
1901 enumerator:
1902 identifier
1903 { $$ = build_enumerator ($1, NULL_TREE); }
1904 | identifier '=' expr_no_commas
1905 { $$ = build_enumerator ($1, $3.value); }
1906 ;
1908 typename:
1909 declspecs_nosc
1910 { pending_xref_error ();
1911 $<ttype>$ = $1; }
1912 absdcl
1913 { $$ = build_tree_list ($<ttype>2, $3); }
1914 ;
1916 absdcl: /* an absolute declarator */
1917 /* empty */
1918 { $$ = NULL_TREE; }
1919 | absdcl1
1920 ;
1922 absdcl_maybe_attribute: /* absdcl maybe_attribute, but not just attributes */
1923 /* empty */
1924 { $$ = build_c_parm (current_declspecs, all_prefix_attributes,
1925 NULL_TREE); }
1926 | absdcl1
1927 { $$ = build_c_parm (current_declspecs, all_prefix_attributes,
1928 $1); }
1929 | absdcl1_noea attributes
1930 { $$ = build_c_parm (current_declspecs,
1931 chainon ($2, all_prefix_attributes),
1932 $1); }
1933 ;
1935 absdcl1: /* a nonempty absolute declarator */
1936 absdcl1_ea
1937 | absdcl1_noea
1938 ;
1940 absdcl1_noea:
1941 direct_absdcl1
1942 | '*' maybe_type_quals_attrs absdcl1_noea
1943 { $$ = make_pointer_declarator ($2, $3); }
1944 ;
1946 absdcl1_ea:
1947 '*' maybe_type_quals_attrs
1948 { $$ = make_pointer_declarator ($2, NULL_TREE); }
1949 | '*' maybe_type_quals_attrs absdcl1_ea
1950 { $$ = make_pointer_declarator ($2, $3); }
1951 ;
1953 direct_absdcl1:
1954 '(' maybe_attribute absdcl1 ')'
1955 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1956 | direct_absdcl1 '(' parmlist
1957 { $$ = build_function_declarator ($3, $1); }
1958 | direct_absdcl1 array_declarator
1959 { $$ = set_array_declarator_inner ($2, $1, true); }
1960 | '(' parmlist
1961 { $$ = build_function_declarator ($2, NULL_TREE); }
1962 | array_declarator
1963 { $$ = set_array_declarator_inner ($1, NULL_TREE, true); }
1964 ;
1966 /* The [...] part of a declarator for an array type. */
1968 array_declarator:
1969 '[' maybe_type_quals_attrs expr_no_commas ']'
1970 { $$ = build_array_declarator ($3.value, $2, false, false); }
1971 | '[' maybe_type_quals_attrs ']'
1972 { $$ = build_array_declarator (NULL_TREE, $2, false, false); }
1973 | '[' maybe_type_quals_attrs '*' ']'
1974 { $$ = build_array_declarator (NULL_TREE, $2, false, true); }
1975 | '[' STATIC maybe_type_quals_attrs expr_no_commas ']'
1976 { $$ = build_array_declarator ($4.value, $3, true, false); }
1977 /* declspecs_nosc_nots is a synonym for type_quals_attrs. */
1978 | '[' declspecs_nosc_nots STATIC expr_no_commas ']'
1979 { $$ = build_array_declarator ($4.value, $2, true, false); }
1980 ;
1982 /* A nonempty series of declarations and statements (possibly followed by
1983 some labels) that can form the body of a compound statement.
1984 NOTE: we don't allow labels on declarations; this might seem like a
1985 natural extension, but there would be a conflict between attributes
1986 on the label and prefix attributes on the declaration. */
1988 stmts_and_decls:
1989 lineno_stmt_decl_or_labels_ending_stmt
1990 | lineno_stmt_decl_or_labels_ending_decl
1991 | lineno_stmt_decl_or_labels_ending_label
1992 {
1993 error ("label at end of compound statement");
1994 }
1995 | lineno_stmt_decl_or_labels_ending_error
1996 ;
1998 lineno_stmt_decl_or_labels_ending_stmt:
1999 lineno_stmt
2000 | lineno_stmt_decl_or_labels_ending_stmt lineno_stmt
2001 | lineno_stmt_decl_or_labels_ending_decl lineno_stmt
2002 | lineno_stmt_decl_or_labels_ending_label lineno_stmt
2003 | lineno_stmt_decl_or_labels_ending_error lineno_stmt
2004 ;
2006 lineno_stmt_decl_or_labels_ending_decl:
2007 lineno_decl
2008 | lineno_stmt_decl_or_labels_ending_stmt lineno_decl
2009 {
2010 if ((pedantic && !flag_isoc99)
2011 || warn_declaration_after_statement)
2012 pedwarn_c90 ("ISO C90 forbids mixed declarations and code");
2013 }
2014 | lineno_stmt_decl_or_labels_ending_decl lineno_decl
2015 | lineno_stmt_decl_or_labels_ending_error lineno_decl
2016 ;
2018 lineno_stmt_decl_or_labels_ending_label:
2019 lineno_label
2020 | lineno_stmt_decl_or_labels_ending_stmt lineno_label
2021 | lineno_stmt_decl_or_labels_ending_decl lineno_label
2022 | lineno_stmt_decl_or_labels_ending_label lineno_label
2023 | lineno_stmt_decl_or_labels_ending_error lineno_label
2024 ;
2026 lineno_stmt_decl_or_labels_ending_error:
2027 errstmt
2028 | lineno_stmt_decl_or_labels errstmt
2029 ;
2031 lineno_stmt_decl_or_labels:
2032 lineno_stmt_decl_or_labels_ending_stmt
2033 | lineno_stmt_decl_or_labels_ending_decl
2034 | lineno_stmt_decl_or_labels_ending_label
2035 | lineno_stmt_decl_or_labels_ending_error
2036 ;
2038 errstmt: error ';'
2039 ;
2041 /* Start and end blocks created for the new scopes of C99. */
2042 c99_block_start: /* empty */
2043 { $$ = c_begin_compound_stmt (flag_isoc99); }
2044 ;
2046 /* Read zero or more forward-declarations for labels
2047 that nested functions can jump to. */
2048 maybe_label_decls:
2049 /* empty */
2050 | label_decls
2051 { if (pedantic)
2052 pedwarn ("ISO C forbids label declarations"); }
2053 ;
2055 label_decls:
2056 label_decl
2057 | label_decls label_decl
2058 ;
2060 label_decl:
2061 LABEL identifiers_or_typenames ';'
2062 { tree link;
2063 for (link = $2; link; link = TREE_CHAIN (link))
2064 {
2065 tree label = declare_label (TREE_VALUE (link));
2066 C_DECLARED_LABEL_FLAG (label) = 1;
2067 add_stmt (build_stmt (DECL_EXPR, label));
2068 }
2069 }
2070 ;
2072 /* This is the body of a function definition.
2073 It causes syntax errors to ignore to the next openbrace. */
2074 compstmt_or_error:
2075 compstmt
2076 { add_stmt ($1); }
2077 | error compstmt
2078 ;
2080 compstmt_start: '{' { $$ = c_begin_compound_stmt (true); }
2081 ;
2083 compstmt_nostart: '}'
2084 | maybe_label_decls compstmt_contents_nonempty '}'
2085 ;
2087 compstmt_contents_nonempty:
2088 stmts_and_decls
2089 | error
2090 ;
2092 compstmt_primary_start:
2093 '(' '{'
2094 { if (current_function_decl == 0)
2095 {
2096 error ("braced-group within expression allowed "
2097 "only inside a function");
2098 YYERROR;
2099 }
2100 $$ = c_begin_stmt_expr ();
2101 }
2102 ;
2104 compstmt: compstmt_start compstmt_nostart
2105 { $$ = c_end_compound_stmt ($1, true); }
2106 ;
2108 /* The forced readahead in here is because we might be at the end of a
2109 line, and the line and file won't be bumped until yylex absorbs the
2110 first token on the next line. */
2112 save_location:
2113 { if (yychar == YYEMPTY)
2114 yychar = YYLEX;
2115 $$ = input_location; }
2116 ;
2118 lineno_labels:
2119 /* empty */
2120 | lineno_labels lineno_label
2121 ;
2123 /* A labeled statement. In C99 it also generates an implicit block. */
2124 c99_block_lineno_labeled_stmt:
2125 c99_block_start lineno_labels lineno_stmt
2126 { $$ = c_end_compound_stmt ($1, flag_isoc99); }
2127 ;
2129 lineno_stmt:
2130 save_location stmt
2131 {
2132 /* Two cases cannot and do not have line numbers associated:
2133 If stmt is degenerate, such as "2;", then stmt is an
2134 INTEGER_CST, which cannot hold line numbers. But that's
2135 ok because the statement will either be changed to a
2136 MODIFY_EXPR during gimplification of the statement expr,
2137 or discarded. If stmt was compound, but without new
2138 variables, we will have skipped the creation of a BIND
2139 and will have a bare STATEMENT_LIST. But that's ok
2140 because (recursively) all of the component statments
2141 should already have line numbers assigned. */
2142 if ($2 && EXPR_P ($2))
2143 SET_EXPR_LOCATION ($2, $1);
2144 }
2145 ;
2147 lineno_label:
2148 save_location label
2149 { if ($2) SET_EXPR_LOCATION ($2, $1); }
2150 ;
2152 condition: save_location expr
2153 { $$ = lang_hooks.truthvalue_conversion ($2.value);
2154 if (EXPR_P ($$))
2155 SET_EXPR_LOCATION ($$, $1); }
2156 ;
2158 /* Implement -Wparenthesis by special casing IF statement directly nested
2159 within IF statement. This requires some amount of duplication of the
2160 productions under c99_block_lineno_labeled_stmt in order to work out.
2161 But it's still likely more maintainable than lots of state outside the
2162 parser... */
2164 if_statement_1:
2165 c99_block_start lineno_labels if_statement
2166 { $$ = c_end_compound_stmt ($1, flag_isoc99); }
2167 ;
2169 if_statement_2:
2170 c99_block_start lineno_labels ';'
2171 { if (extra_warnings)
2172 add_stmt (build (NOP_EXPR, NULL_TREE, NULL_TREE));
2173 $$ = c_end_compound_stmt ($1, flag_isoc99); }
2174 | c99_block_lineno_labeled_stmt
2175 ;
2177 if_statement:
2178 IF c99_block_start save_location '(' condition ')'
2179 if_statement_1 ELSE if_statement_2
2180 { c_finish_if_stmt ($3, $5, $7, $9, true);
2181 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2182 | IF c99_block_start save_location '(' condition ')'
2183 if_statement_2 ELSE if_statement_2
2184 { c_finish_if_stmt ($3, $5, $7, $9, false);
2185 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2186 | IF c99_block_start save_location '(' condition ')'
2187 if_statement_1 %prec IF
2188 { c_finish_if_stmt ($3, $5, $7, NULL, true);
2189 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2190 | IF c99_block_start save_location '(' condition ')'
2191 if_statement_2 %prec IF
2192 { c_finish_if_stmt ($3, $5, $7, NULL, false);
2193 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2194 ;
2196 start_break: /* empty */
2197 { $$ = c_break_label; c_break_label = NULL; }
2198 ;
2200 start_continue: /* empty */
2201 { $$ = c_cont_label; c_cont_label = NULL; }
2202 ;
2204 while_statement:
2205 WHILE c99_block_start save_location '(' condition ')'
2206 start_break start_continue c99_block_lineno_labeled_stmt
2207 { c_finish_loop ($3, $5, NULL, $9, c_break_label,
2208 c_cont_label, true);
2209 add_stmt (c_end_compound_stmt ($2, flag_isoc99));
2210 c_break_label = $7; c_cont_label = $8; }
2211 ;
2213 do_statement:
2214 DO c99_block_start save_location start_break start_continue
2215 c99_block_lineno_labeled_stmt WHILE
2216 { $<ttype>$ = c_break_label; c_break_label = $4; }
2217 { $<ttype>$ = c_cont_label; c_cont_label = $5; }
2218 '(' condition ')' ';'
2219 { c_finish_loop ($3, $11, NULL, $6, $<ttype>8,
2220 $<ttype>9, false);
2221 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2222 ;
2224 xexpr:
2225 /* empty */
2226 { $$ = NULL_TREE; }
2227 | expr
2228 { $$ = $1.value; }
2229 ;
2231 for_init_stmt:
2232 xexpr ';'
2233 { c_finish_expr_stmt ($1); }
2234 | decl
2235 { check_for_loop_decls (); }
2236 ;
2238 for_cond_expr: save_location xexpr
2239 { if ($2)
2240 {
2241 $$ = lang_hooks.truthvalue_conversion ($2);
2242 if (EXPR_P ($$))
2243 SET_EXPR_LOCATION ($$, $1);
2244 }
2245 else
2246 $$ = NULL;
2247 }
2248 ;
2250 for_incr_expr: xexpr
2251 { $$ = c_process_expr_stmt ($1); }
2252 ;
2254 for_statement:
2255 FOR c99_block_start '(' for_init_stmt
2256 save_location for_cond_expr ';' for_incr_expr ')'
2257 start_break start_continue c99_block_lineno_labeled_stmt
2258 { c_finish_loop ($5, $6, $8, $12, c_break_label,
2259 c_cont_label, true);
2260 add_stmt (c_end_compound_stmt ($2, flag_isoc99));
2261 c_break_label = $10; c_cont_label = $11; }
2262 ;
2264 switch_statement:
2265 SWITCH c99_block_start '(' expr ')'
2266 { $<ttype>$ = c_start_case ($4.value); }
2267 start_break c99_block_lineno_labeled_stmt
2268 { c_finish_case ($8);
2269 if (c_break_label)
2270 add_stmt (build (LABEL_EXPR, void_type_node,
2271 c_break_label));
2272 c_break_label = $7;
2273 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2274 ;
2276 /* Parse a single real statement, not including any labels or compounds. */
2277 stmt_nocomp:
2278 expr ';'
2279 { $$ = c_finish_expr_stmt ($1.value); }
2280 | if_statement
2281 { $$ = NULL_TREE; }
2282 | while_statement
2283 { $$ = NULL_TREE; }
2284 | do_statement
2285 { $$ = NULL_TREE; }
2286 | for_statement
2287 { $$ = NULL_TREE; }
2288 | switch_statement
2289 { $$ = NULL_TREE; }
2290 | BREAK ';'
2291 { $$ = c_finish_bc_stmt (&c_break_label, true); }
2292 | CONTINUE ';'
2293 { $$ = c_finish_bc_stmt (&c_cont_label, false); }
2294 | RETURN ';'
2295 { $$ = c_finish_return (NULL_TREE); }
2296 | RETURN expr ';'
2297 { $$ = c_finish_return ($2.value); }
2298 | asm_stmt
2299 | GOTO identifier ';'
2300 { $$ = c_finish_goto_label ($2); }
2301 | GOTO '*' expr ';'
2302 { $$ = c_finish_goto_ptr ($3.value); }
2303 | ';'
2304 { $$ = NULL_TREE; }
2305 @@ifobjc
2306 | AT_THROW expr ';'
2307 { $$ = objc_build_throw_stmt ($2.value); }
2308 | AT_THROW ';'
2309 { $$ = objc_build_throw_stmt (NULL_TREE); }
2310 | objc_try_catch_stmt
2311 { $$ = NULL_TREE; }
2312 | AT_SYNCHRONIZED save_location '(' expr ')' compstmt
2313 { objc_build_synchronized ($2, $4.value, $6); $$ = NULL_TREE; }
2314 ;
2316 objc_catch_prefix:
2317 AT_CATCH '(' parm ')'
2318 { objc_begin_catch_clause ($3); }
2319 ;
2321 objc_catch_clause:
2322 objc_catch_prefix '{' compstmt_nostart
2323 { objc_finish_catch_clause (); }
2324 | objc_catch_prefix '{' error '}'
2325 { objc_finish_catch_clause (); }
2326 ;
2328 objc_opt_catch_list:
2329 /* empty */
2330 | objc_opt_catch_list objc_catch_clause
2331 ;
2333 objc_try_catch_clause:
2334 AT_TRY save_location compstmt
2335 { objc_begin_try_stmt ($2, $3); }
2336 objc_opt_catch_list
2337 ;
2339 objc_finally_clause:
2340 AT_FINALLY save_location compstmt
2341 { objc_build_finally_clause ($2, $3); }
2342 ;
2344 objc_try_catch_stmt:
2345 objc_try_catch_clause
2346 { objc_finish_try_stmt (); }
2347 | objc_try_catch_clause objc_finally_clause
2348 { objc_finish_try_stmt (); }
2349 @@end_ifobjc
2350 ;
2352 /* Parse a single or compound real statement, not including any labels. */
2353 stmt:
2354 compstmt
2355 { add_stmt ($1); $$ = NULL_TREE; }
2356 | stmt_nocomp
2357 ;
2359 /* Any kind of label, including jump labels and case labels.
2360 ANSI C accepts labels only before statements, but we allow them
2361 also at the end of a compound statement. */
2363 label: CASE expr_no_commas ':'
2364 { $$ = do_case ($2.value, NULL_TREE); }
2365 | CASE expr_no_commas ELLIPSIS expr_no_commas ':'
2366 { $$ = do_case ($2.value, $4.value); }
2367 | DEFAULT ':'
2368 { $$ = do_case (NULL_TREE, NULL_TREE); }
2369 | identifier save_location ':' maybe_attribute
2370 { tree label = define_label ($2, $1);
2371 if (label)
2372 {
2373 decl_attributes (&label, $4, 0);
2374 $$ = add_stmt (build_stmt (LABEL_EXPR, label));
2375 }
2376 else
2377 $$ = NULL_TREE;
2378 }
2379 ;
2381 /* Asm expressions and statements */
2383 /* simple_asm_expr is used in restricted contexts, where a full
2384 expression with inputs and outputs does not make sense. */
2385 simple_asm_expr:
2386 ASM_KEYWORD stop_string_translation
2387 '(' STRING ')' start_string_translation
2388 { $$ = $4; }
2389 ;
2391 /* maybeasm: used for assembly names for declarations */
2392 maybeasm:
2393 /* empty */
2394 { $$ = NULL_TREE; }
2395 | simple_asm_expr
2396 ;
2398 /* asmdef: asm() outside a function body. */
2399 asmdef:
2400 simple_asm_expr ';'
2401 { assemble_asm ($1); }
2402 | ASM_KEYWORD error start_string_translation ';'
2403 {}
2404 ;
2406 /* Full-blown asm statement with inputs, outputs, clobbers, and
2407 volatile tag allowed. */
2408 asm_stmt:
2409 ASM_KEYWORD maybe_volatile stop_string_translation
2410 '(' asm_argument ')' start_string_translation ';'
2411 { $$ = build_asm_stmt ($2, $5); }
2412 ;
2414 asm_argument:
2415 /* no operands */
2416 STRING
2417 { $$ = build_asm_expr ($1, 0, 0, 0, true); }
2418 /* output operands */
2419 | STRING ':' asm_operands
2420 { $$ = build_asm_expr ($1, $3, 0, 0, false); }
2421 /* output and input operands */
2422 | STRING ':' asm_operands ':' asm_operands
2423 { $$ = build_asm_expr ($1, $3, $5, 0, false); }
2424 /* output and input operands and clobbers */
2425 | STRING ':' asm_operands ':' asm_operands ':' asm_clobbers
2426 { $$ = build_asm_expr ($1, $3, $5, $7, false); }
2427 ;
2429 /* Either 'volatile' or nothing. First thing in an `asm' statement. */
2431 maybe_volatile:
2432 /* empty */
2433 { $$ = 0; }
2434 | TYPE_QUAL
2435 { if ($1 != ridpointers[RID_VOLATILE])
2436 {
2437 warning ("%E qualifier ignored on asm", $1);
2438 $$ = 0;
2439 }
2440 else
2441 $$ = $1;
2442 }
2443 ;
2445 /* These are the operands other than the first string and colon
2446 in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */
2447 asm_operands: /* empty */
2448 { $$ = NULL_TREE; }
2449 | nonnull_asm_operands
2450 ;
2452 nonnull_asm_operands:
2453 asm_operand
2454 | nonnull_asm_operands ',' asm_operand
2455 { $$ = chainon ($1, $3); }
2456 ;
2458 asm_operand:
2459 STRING start_string_translation '(' expr ')' stop_string_translation
2460 { $$ = build_tree_list (build_tree_list (NULL_TREE, $1),
2461 $4.value); }
2462 | '[' identifier ']' STRING start_string_translation
2463 '(' expr ')' stop_string_translation
2464 { $2 = build_string (IDENTIFIER_LENGTH ($2),
2465 IDENTIFIER_POINTER ($2));
2466 $$ = build_tree_list (build_tree_list ($2, $4), $7.value); }
2467 ;
2469 asm_clobbers:
2470 STRING
2471 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
2472 | asm_clobbers ',' STRING
2473 { $$ = tree_cons (NULL_TREE, $3, $1); }
2474 ;
2476 stop_string_translation:
2477 { c_lex_string_translate = 0; }
2478 ;
2480 start_string_translation:
2481 { c_lex_string_translate = 1; }
2482 ;
2484 \f
2485 /* This is what appears inside the parens in a function declarator.
2486 Its value is a list of ..._TYPE nodes. Attributes must appear here
2487 to avoid a conflict with their appearance after an open parenthesis
2488 in an abstract declarator, as in
2489 "void bar (int (__attribute__((__mode__(SI))) int foo));". */
2490 parmlist:
2491 maybe_attribute
2492 { push_scope ();
2493 declare_parm_level (); }
2494 parmlist_1
2495 { $$ = $3;
2496 pop_scope (); }
2497 ;
2499 parmlist_1:
2500 parmlist_2 ')'
2501 | parms ';'
2502 { mark_forward_parm_decls (); }
2503 maybe_attribute
2504 { /* Dummy action so attributes are in known place
2505 on parser stack. */ }
2506 parmlist_1
2507 { $$ = $6; }
2508 | error ')'
2509 { $$ = make_node (TREE_LIST); }
2510 ;
2512 /* This is what appears inside the parens in a function declarator.
2513 Is value is represented in the format that grokdeclarator expects. */
2514 parmlist_2: /* empty */
2515 { $$ = make_node (TREE_LIST); }
2516 | ELLIPSIS
2517 { $$ = make_node (TREE_LIST);
2518 /* Suppress -Wold-style-definition for this case. */
2519 TREE_CHAIN ($$) = error_mark_node;
2520 error ("ISO C requires a named argument before `...'");
2521 }
2522 | parms
2523 { $$ = get_parm_info (/*ellipsis=*/false); }
2524 | parms ',' ELLIPSIS
2525 { $$ = get_parm_info (/*ellipsis=*/true); }
2526 ;
2528 parms:
2529 firstparm
2530 { push_parm_decl ($1); }
2531 | parms ',' parm
2532 { push_parm_decl ($3); }
2533 ;
2535 /* A single parameter declaration or parameter type name,
2536 as found in a parmlist. */
2537 parm:
2538 declspecs_ts setspecs parm_declarator maybe_attribute
2539 { $$ = build_c_parm (current_declspecs,
2540 chainon ($4, all_prefix_attributes), $3);
2541 POP_DECLSPEC_STACK; }
2542 | declspecs_ts setspecs notype_declarator maybe_attribute
2543 { $$ = build_c_parm (current_declspecs,
2544 chainon ($4, all_prefix_attributes), $3);
2545 POP_DECLSPEC_STACK; }
2546 | declspecs_ts setspecs absdcl_maybe_attribute
2547 { $$ = $3;
2548 POP_DECLSPEC_STACK; }
2549 | declspecs_nots setspecs notype_declarator maybe_attribute
2550 { $$ = build_c_parm (current_declspecs,
2551 chainon ($4, all_prefix_attributes), $3);
2552 POP_DECLSPEC_STACK; }
2554 | declspecs_nots setspecs absdcl_maybe_attribute
2555 { $$ = $3;
2556 POP_DECLSPEC_STACK; }
2557 ;
2559 /* The first parm, which must suck attributes from off the top of the parser
2560 stack. */
2561 firstparm:
2562 declspecs_ts_nosa setspecs_fp parm_declarator maybe_attribute
2563 { $$ = build_c_parm (current_declspecs,
2564 chainon ($4, all_prefix_attributes), $3);
2565 POP_DECLSPEC_STACK; }
2566 | declspecs_ts_nosa setspecs_fp notype_declarator maybe_attribute
2567 { $$ = build_c_parm (current_declspecs,
2568 chainon ($4, all_prefix_attributes), $3);
2569 POP_DECLSPEC_STACK; }
2570 | declspecs_ts_nosa setspecs_fp absdcl_maybe_attribute
2571 { $$ = $3;
2572 POP_DECLSPEC_STACK; }
2573 | declspecs_nots_nosa setspecs_fp notype_declarator maybe_attribute
2574 { $$ = build_c_parm (current_declspecs,
2575 chainon ($4, all_prefix_attributes), $3);
2576 POP_DECLSPEC_STACK; }
2578 | declspecs_nots_nosa setspecs_fp absdcl_maybe_attribute
2579 { $$ = $3;
2580 POP_DECLSPEC_STACK; }
2581 ;
2583 setspecs_fp:
2584 setspecs
2585 { prefix_attributes = chainon (prefix_attributes, $<ttype>-2);
2586 all_prefix_attributes = prefix_attributes; }
2587 ;
2589 /* This is used in a function definition
2590 where either a parmlist or an identifier list is ok.
2591 Its value is a list of ..._TYPE nodes or a list of identifiers. */
2592 parmlist_or_identifiers:
2593 maybe_attribute
2594 { push_scope ();
2595 declare_parm_level (); }
2596 parmlist_or_identifiers_1
2597 { $$ = $3;
2598 pop_scope (); }
2599 ;
2601 parmlist_or_identifiers_1:
2602 parmlist_1
2603 | identifiers ')'
2604 { $$ = tree_cons (NULL_TREE, NULL_TREE, $1);
2606 /* Make sure we have a parmlist after attributes. */
2607 if ($<ttype>-1 != 0)
2608 YYERROR1;
2609 }
2610 ;
2612 /* A nonempty list of identifiers. */
2613 identifiers:
2614 IDENTIFIER
2615 { $$ = build_tree_list (NULL_TREE, $1); }
2616 | identifiers ',' IDENTIFIER
2617 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2618 ;
2620 /* A nonempty list of identifiers, including typenames. */
2621 identifiers_or_typenames:
2622 identifier
2623 { $$ = build_tree_list (NULL_TREE, $1); }
2624 | identifiers_or_typenames ',' identifier
2625 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2626 ;
2628 extension:
2629 EXTENSION
2630 { $$ = SAVE_EXT_FLAGS();
2631 pedantic = 0;
2632 warn_pointer_arith = 0;
2633 warn_traditional = 0;
2634 flag_iso = 0; }
2635 ;
2636 \f
2637 @@ifobjc
2638 /* Objective-C productions. */
2640 objcdef:
2641 classdef
2642 | classdecl
2643 | aliasdecl
2644 | protocoldef
2645 | methoddef
2646 | AT_END
2647 {
2648 if (objc_implementation_context)
2649 {
2650 finish_class (objc_implementation_context);
2651 objc_ivar_chain = NULL_TREE;
2652 objc_implementation_context = NULL_TREE;
2653 }
2654 else
2655 warning ("`@end' must appear in an implementation context");
2656 }
2657 ;
2659 /* A nonempty list of identifiers. */
2660 identifier_list:
2661 identifier
2662 { $$ = build_tree_list (NULL_TREE, $1); }
2663 | identifier_list ',' identifier
2664 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2665 ;
2667 classdecl:
2668 AT_CLASS identifier_list ';'
2669 {
2670 objc_declare_class ($2);
2671 }
2672 ;
2674 aliasdecl:
2675 AT_ALIAS identifier identifier ';'
2676 {
2677 objc_declare_alias ($2, $3);
2678 }
2679 ;
2681 superclass:
2682 ':' identifier { $$ = $2; }
2683 | /* NULL */ %prec HYPERUNARY { $$ = NULL_TREE; }
2684 ;
2686 class_ivars:
2687 '{' ivar_decl_list '}'
2688 | /* NULL */
2689 ;
2691 classdef:
2692 AT_INTERFACE identifier superclass protocolrefs
2693 {
2694 objc_interface_context = objc_ivar_context
2695 = start_class (CLASS_INTERFACE_TYPE, $2, $3, $4);
2696 objc_public_flag = 0;
2697 }
2698 class_ivars
2699 {
2700 continue_class (objc_interface_context);
2701 }
2702 methodprotolist AT_END
2703 {
2704 finish_class (objc_interface_context);
2705 objc_interface_context = NULL_TREE;
2706 }
2708 | AT_IMPLEMENTATION identifier superclass
2709 {
2710 objc_implementation_context = objc_ivar_context
2711 = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $3, NULL_TREE);
2712 objc_public_flag = 0;
2713 }
2714 class_ivars
2715 {
2716 objc_ivar_chain
2717 = continue_class (objc_implementation_context);
2718 }
2720 | AT_INTERFACE identifier '(' identifier ')' protocolrefs
2721 {
2722 objc_interface_context
2723 = start_class (CATEGORY_INTERFACE_TYPE, $2, $4, $6);
2724 continue_class (objc_interface_context);
2725 }
2726 methodprotolist AT_END
2727 {
2728 finish_class (objc_interface_context);
2729 objc_interface_context = NULL_TREE;
2730 }
2732 | AT_IMPLEMENTATION identifier '(' identifier ')'
2733 {
2734 objc_implementation_context
2735 = start_class (CATEGORY_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE);
2736 objc_ivar_chain
2737 = continue_class (objc_implementation_context);
2738 }
2739 ;
2741 protocoldef:
2742 AT_PROTOCOL identifier protocolrefs
2743 {
2744 objc_pq_context = 1;
2745 objc_interface_context
2746 = start_protocol(PROTOCOL_INTERFACE_TYPE, $2, $3);
2747 }
2748 methodprotolist AT_END
2749 {
2750 objc_pq_context = 0;
2751 finish_protocol(objc_interface_context);
2752 objc_interface_context = NULL_TREE;
2753 }
2754 /* The @protocol forward-declaration production introduces a
2755 reduce/reduce conflict on ';', which should be resolved in
2756 favor of the production 'identifier_list -> identifier'. */
2757 | AT_PROTOCOL identifier_list ';'
2758 {
2759 objc_declare_protocols ($2);
2760 }
2761 ;
2763 protocolrefs:
2764 /* empty */
2765 {
2766 $$ = NULL_TREE;
2767 }
2768 | non_empty_protocolrefs
2769 ;
2771 non_empty_protocolrefs:
2772 ARITHCOMPARE identifier_list ARITHCOMPARE
2773 {
2774 if ($1 == LT_EXPR && $3 == GT_EXPR)
2775 $$ = $2;
2776 else
2777 YYERROR1;
2778 }
2779 ;
2781 ivar_decl_list:
2782 ivar_decl_list visibility_spec ivar_decls
2783 | ivar_decls
2784 ;
2786 visibility_spec:
2787 AT_PRIVATE { objc_public_flag = 2; }
2788 | AT_PROTECTED { objc_public_flag = 0; }
2789 | AT_PUBLIC { objc_public_flag = 1; }
2790 ;
2792 ivar_decls:
2793 /* empty */
2794 {
2795 $$ = NULL_TREE;
2796 }
2797 | ivar_decls ivar_decl ';'
2798 | ivar_decls ';'
2799 {
2800 if (pedantic)
2801 pedwarn ("extra semicolon in struct or union specified");
2802 }
2803 ;
2806 /* There is a shift-reduce conflict here, because `components' may
2807 start with a `typename'. It happens that shifting (the default resolution)
2808 does the right thing, because it treats the `typename' as part of
2809 a `typed_typespecs'.
2811 It is possible that this same technique would allow the distinction
2812 between `notype_initdecls' and `initdecls' to be eliminated.
2813 But I am being cautious and not trying it. */
2815 ivar_decl:
2816 declspecs_nosc_ts setspecs ivars
2817 { $$ = $3;
2818 POP_DECLSPEC_STACK; }
2819 | declspecs_nosc_nots setspecs ivars
2820 { $$ = $3;
2821 POP_DECLSPEC_STACK; }
2822 | error
2823 { $$ = NULL_TREE; }
2824 ;
2826 ivars:
2827 /* empty */
2828 { $$ = NULL_TREE; }
2829 | ivar_declarator
2830 | ivars ',' maybe_resetattrs ivar_declarator
2831 ;
2833 ivar_declarator:
2834 declarator
2835 {
2836 $$ = add_instance_variable (objc_ivar_context,
2837 objc_public_flag,
2838 $1, current_declspecs,
2839 NULL_TREE);
2840 }
2841 | declarator ':' expr_no_commas
2842 {
2843 $$ = add_instance_variable (objc_ivar_context,
2844 objc_public_flag,
2845 $1, current_declspecs, $3.value);
2846 }
2847 | ':' expr_no_commas
2848 {
2849 $$ = add_instance_variable (objc_ivar_context,
2850 objc_public_flag,
2851 NULL_TREE,
2852 current_declspecs, $2.value);
2853 }
2854 ;
2856 methodtype:
2857 '+'
2858 { objc_inherit_code = CLASS_METHOD_DECL; }
2859 | '-'
2860 { objc_inherit_code = INSTANCE_METHOD_DECL; }
2861 ;
2863 methoddef:
2864 methodtype
2865 {
2866 objc_pq_context = 1;
2867 if (!objc_implementation_context)
2868 fatal_error ("method definition not in class context");
2869 }
2870 methoddecl
2871 {
2872 objc_pq_context = 0;
2873 objc_add_method (objc_implementation_context,
2874 $3,
2875 objc_inherit_code == CLASS_METHOD_DECL);
2876 start_method_def ($3);
2877 }
2878 optarglist
2879 {
2880 continue_method_def ();
2881 }
2882 compstmt_or_error
2883 {
2884 finish_method_def ();
2885 }
2886 ;
2888 /* the reason for the strange actions in this rule
2889 is so that notype_initdecls when reached via datadef
2890 can find a valid list of type and sc specs in $0. */
2892 methodprotolist:
2893 /* empty */
2894 | methodprotolist methodproto
2895 | methodprotolist { $<ttype>$ = NULL_TREE; } datadef
2896 ;
2898 semi_or_error:
2899 ';'
2900 | error
2901 ;
2903 methodproto:
2904 methodtype
2905 {
2906 /* Remember protocol qualifiers in prototypes. */
2907 objc_pq_context = 1;
2908 }
2909 methoddecl
2910 {
2911 /* Forget protocol qualifiers here. */
2912 objc_pq_context = 0;
2913 objc_add_method (objc_interface_context,
2914 $3,
2915 objc_inherit_code == CLASS_METHOD_DECL);
2916 }
2917 semi_or_error
2918 ;
2920 methoddecl:
2921 '(' typename ')' unaryselector
2922 {
2923 $$ = build_method_decl (objc_inherit_code, $2, $4, NULL_TREE);
2924 }
2926 | unaryselector
2927 {
2928 $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, NULL_TREE);
2929 }
2931 | '(' typename ')' keywordselector optparmlist
2932 {
2933 $$ = build_method_decl (objc_inherit_code, $2, $4, $5);
2934 }
2936 | keywordselector optparmlist
2937 {
2938 $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, $2);
2939 }
2940 ;
2942 /* "optarglist" assumes that start_method_def has already been called...
2943 if it is not, the "xdecls" will not be placed in the proper scope */
2945 optarglist:
2946 /* empty */
2947 | ';' myxdecls
2948 ;
2950 /* to get around the following situation: "int foo (int a) int b; {}" that
2951 is synthesized when parsing "- a:a b:b; id c; id d; { ... }" */
2953 myxdecls:
2954 /* empty */
2955 | mydecls
2956 ;
2958 mydecls:
2959 mydecl
2960 | errstmt
2961 | mydecls mydecl
2962 | mydecl errstmt
2963 ;
2965 mydecl:
2966 declspecs_ts setspecs myparms ';'
2967 { POP_DECLSPEC_STACK; }
2968 | declspecs_ts ';'
2969 { shadow_tag ($1); }
2970 | declspecs_nots ';'
2971 { pedwarn ("empty declaration"); }
2972 ;
2974 myparms:
2975 myparm
2976 { push_parm_decl ($1); }
2977 | myparms ',' myparm
2978 { push_parm_decl ($3); }
2979 ;
2981 /* A single parameter declaration or parameter type name,
2982 as found in a parmlist. DOES NOT ALLOW AN INITIALIZER OR ASMSPEC */
2984 myparm:
2985 parm_declarator maybe_attribute
2986 { $$ = build_tree_list (build_tree_list (current_declspecs,
2987 $1),
2988 chainon ($2, all_prefix_attributes)); }
2989 | notype_declarator maybe_attribute
2990 { $$ = build_tree_list (build_tree_list (current_declspecs,
2991 $1),
2992 chainon ($2, all_prefix_attributes)); }
2993 | absdcl_maybe_attribute
2994 { $$ = $1; }
2995 ;
2997 optparmlist:
2998 /* empty */
2999 {
3000 $$ = NULL_TREE;
3001 }
3002 | ',' ELLIPSIS
3003 {
3004 /* oh what a kludge! */
3005 $$ = objc_ellipsis_node;
3006 }
3007 | ','
3008 {
3009 push_scope ();
3010 }
3011 parmlist_2
3012 {
3013 /* returns a tree list node generated by get_parm_info */
3014 $$ = $3;
3015 pop_scope ();
3016 }
3017 ;
3019 unaryselector:
3020 selector
3021 ;
3023 keywordselector:
3024 keyworddecl
3026 | keywordselector keyworddecl
3027 {
3028 $$ = chainon ($1, $2);
3029 }
3030 ;
3032 selector:
3033 IDENTIFIER
3034 | TYPENAME
3035 | CLASSNAME
3036 | OBJECTNAME
3037 | reservedwords
3038 ;
3040 reservedwords:
3041 ENUM | STRUCT | UNION | IF | ELSE | WHILE | DO | FOR
3042 | SWITCH | CASE | DEFAULT | BREAK | CONTINUE | RETURN
3043 | GOTO | ASM_KEYWORD | SIZEOF | TYPEOF | ALIGNOF
3044 | TYPESPEC | TYPE_QUAL
3045 ;
3047 keyworddecl:
3048 selector ':' '(' typename ')' identifier
3049 {
3050 $$ = objc_build_keyword_decl ($1, $4, $6);
3051 }
3053 | selector ':' identifier
3054 {
3055 $$ = objc_build_keyword_decl ($1, NULL_TREE, $3);
3056 }
3058 | ':' '(' typename ')' identifier
3059 {
3060 $$ = objc_build_keyword_decl (NULL_TREE, $3, $5);
3061 }
3063 | ':' identifier
3064 {
3065 $$ = objc_build_keyword_decl (NULL_TREE, NULL_TREE, $2);
3066 }
3067 ;
3069 messageargs:
3070 selector
3071 | keywordarglist
3072 ;
3074 keywordarglist:
3075 keywordarg
3076 | keywordarglist keywordarg
3077 {
3078 $$ = chainon ($1, $2);
3079 }
3080 ;
3083 keywordexpr:
3084 nonnull_exprlist
3085 {
3086 if (TREE_CHAIN ($1) == NULL_TREE)
3087 /* just return the expr., remove a level of indirection */
3088 $$ = TREE_VALUE ($1);
3089 else
3090 /* we have a comma expr., we will collapse later */
3091 $$ = $1;
3092 }
3093 ;
3095 keywordarg:
3096 selector ':' keywordexpr
3097 {
3098 $$ = build_tree_list ($1, $3);
3099 }
3100 | ':' keywordexpr
3101 {
3102 $$ = build_tree_list (NULL_TREE, $2);
3103 }
3104 ;
3106 receiver:
3107 expr
3108 { $$ = $1.value; }
3109 | CLASSNAME
3110 {
3111 $$ = objc_get_class_reference ($1);
3112 }
3113 | TYPENAME
3114 {
3115 $$ = objc_get_class_reference ($1);
3116 }
3117 ;
3119 objcmessageexpr:
3120 '[' receiver messageargs ']'
3121 { $$ = build_tree_list ($2, $3); }
3122 ;
3124 selectorarg:
3125 selector
3126 | keywordnamelist
3127 ;
3129 keywordnamelist:
3130 keywordname
3131 | keywordnamelist keywordname
3132 {
3133 $$ = chainon ($1, $2);
3134 }
3135 ;
3137 keywordname:
3138 selector ':'
3139 {
3140 $$ = build_tree_list ($1, NULL_TREE);
3141 }
3142 | ':'
3143 {
3144 $$ = build_tree_list (NULL_TREE, NULL_TREE);
3145 }
3146 ;
3148 objcselectorexpr:
3149 AT_SELECTOR '(' selectorarg ')'
3150 {
3151 $$ = $3;
3152 }
3153 ;
3155 objcprotocolexpr:
3156 AT_PROTOCOL '(' identifier ')'
3157 {
3158 $$ = $3;
3159 }
3160 ;
3162 /* extension to support C-structures in the archiver */
3164 objcencodeexpr:
3165 AT_ENCODE '(' typename ')'
3166 {
3167 $$ = groktypename ($3);
3168 }
3169 ;
3171 @@end_ifobjc
3172 %%
3174 /* yylex() is a thin wrapper around c_lex(), all it does is translate
3175 cpplib.h's token codes into yacc's token codes. */
3177 static enum cpp_ttype last_token;
3179 /* The reserved keyword table. */
3180 struct resword
3181 {
3182 const char *word;
3183 ENUM_BITFIELD(rid) rid : 16;
3184 unsigned int disable : 16;
3185 };
3187 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
3188 _true_. */
3189 #define D_C89 0x01 /* not in C89 */
3190 #define D_EXT 0x02 /* GCC extension */
3191 #define D_EXT89 0x04 /* GCC extension incorporated in C99 */
3192 #define D_OBJC 0x08 /* Objective C only */
3194 static const struct resword reswords[] =
3195 {
3196 { "_Bool", RID_BOOL, 0 },
3197 { "_Complex", RID_COMPLEX, 0 },
3198 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
3199 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
3200 { "__alignof", RID_ALIGNOF, 0 },
3201 { "__alignof__", RID_ALIGNOF, 0 },
3202 { "__asm", RID_ASM, 0 },
3203 { "__asm__", RID_ASM, 0 },
3204 { "__attribute", RID_ATTRIBUTE, 0 },
3205 { "__attribute__", RID_ATTRIBUTE, 0 },
3206 { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
3207 { "__builtin_offsetof", RID_OFFSETOF, 0 },
3208 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
3209 { "__builtin_va_arg", RID_VA_ARG, 0 },
3210 { "__complex", RID_COMPLEX, 0 },
3211 { "__complex__", RID_COMPLEX, 0 },
3212 { "__const", RID_CONST, 0 },
3213 { "__const__", RID_CONST, 0 },
3214 { "__extension__", RID_EXTENSION, 0 },
3215 { "__func__", RID_C99_FUNCTION_NAME, 0 },
3216 { "__imag", RID_IMAGPART, 0 },
3217 { "__imag__", RID_IMAGPART, 0 },
3218 { "__inline", RID_INLINE, 0 },
3219 { "__inline__", RID_INLINE, 0 },
3220 { "__label__", RID_LABEL, 0 },
3221 { "__ptrbase", RID_PTRBASE, 0 },
3222 { "__ptrbase__", RID_PTRBASE, 0 },
3223 { "__ptrextent", RID_PTREXTENT, 0 },
3224 { "__ptrextent__", RID_PTREXTENT, 0 },
3225 { "__ptrvalue", RID_PTRVALUE, 0 },
3226 { "__ptrvalue__", RID_PTRVALUE, 0 },
3227 { "__real", RID_REALPART, 0 },
3228 { "__real__", RID_REALPART, 0 },
3229 { "__restrict", RID_RESTRICT, 0 },
3230 { "__restrict__", RID_RESTRICT, 0 },
3231 { "__signed", RID_SIGNED, 0 },
3232 { "__signed__", RID_SIGNED, 0 },
3233 { "__thread", RID_THREAD, 0 },
3234 { "__typeof", RID_TYPEOF, 0 },
3235 { "__typeof__", RID_TYPEOF, 0 },
3236 { "__volatile", RID_VOLATILE, 0 },
3237 { "__volatile__", RID_VOLATILE, 0 },
3238 { "asm", RID_ASM, D_EXT },
3239 { "auto", RID_AUTO, 0 },
3240 { "break", RID_BREAK, 0 },
3241 { "case", RID_CASE, 0 },
3242 { "char", RID_CHAR, 0 },
3243 { "const", RID_CONST, 0 },
3244 { "continue", RID_CONTINUE, 0 },
3245 { "default", RID_DEFAULT, 0 },
3246 { "do", RID_DO, 0 },
3247 { "double", RID_DOUBLE, 0 },
3248 { "else", RID_ELSE, 0 },
3249 { "enum", RID_ENUM, 0 },
3250 { "extern", RID_EXTERN, 0 },
3251 { "float", RID_FLOAT, 0 },
3252 { "for", RID_FOR, 0 },
3253 { "goto", RID_GOTO, 0 },
3254 { "if", RID_IF, 0 },
3255 { "inline", RID_INLINE, D_EXT89 },
3256 { "int", RID_INT, 0 },
3257 { "long", RID_LONG, 0 },
3258 { "register", RID_REGISTER, 0 },
3259 { "restrict", RID_RESTRICT, D_C89 },
3260 { "return", RID_RETURN, 0 },
3261 { "short", RID_SHORT, 0 },
3262 { "signed", RID_SIGNED, 0 },
3263 { "sizeof", RID_SIZEOF, 0 },
3264 { "static", RID_STATIC, 0 },
3265 { "struct", RID_STRUCT, 0 },
3266 { "switch", RID_SWITCH, 0 },
3267 { "typedef", RID_TYPEDEF, 0 },
3268 { "typeof", RID_TYPEOF, D_EXT },
3269 { "union", RID_UNION, 0 },
3270 { "unsigned", RID_UNSIGNED, 0 },
3271 { "void", RID_VOID, 0 },
3272 { "volatile", RID_VOLATILE, 0 },
3273 { "while", RID_WHILE, 0 },
3275 @@ifobjc
3276 { "id", RID_ID, D_OBJC },
3278 /* These objc keywords are recognized only immediately after
3279 an '@'. */
3280 { "class", RID_AT_CLASS, D_OBJC },
3281 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
3282 { "defs", RID_AT_DEFS, D_OBJC },
3283 { "encode", RID_AT_ENCODE, D_OBJC },
3284 { "end", RID_AT_END, D_OBJC },
3285 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
3286 { "interface", RID_AT_INTERFACE, D_OBJC },
3287 { "private", RID_AT_PRIVATE, D_OBJC },
3288 { "protected", RID_AT_PROTECTED, D_OBJC },
3289 { "protocol", RID_AT_PROTOCOL, D_OBJC },
3290 { "public", RID_AT_PUBLIC, D_OBJC },
3291 { "selector", RID_AT_SELECTOR, D_OBJC },
3292 { "throw", RID_AT_THROW, D_OBJC },
3293 { "try", RID_AT_TRY, D_OBJC },
3294 { "catch", RID_AT_CATCH, D_OBJC },
3295 { "finally", RID_AT_FINALLY, D_OBJC },
3296 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
3297 /* These are recognized only in protocol-qualifier context
3298 (see above) */
3299 { "bycopy", RID_BYCOPY, D_OBJC },
3300 { "byref", RID_BYREF, D_OBJC },
3301 { "in", RID_IN, D_OBJC },
3302 { "inout", RID_INOUT, D_OBJC },
3303 { "oneway", RID_ONEWAY, D_OBJC },
3304 { "out", RID_OUT, D_OBJC },
3305 @@end_ifobjc
3306 };
3307 #define N_reswords (sizeof reswords / sizeof (struct resword))
3309 /* Table mapping from RID_* constants to yacc token numbers.
3310 Unfortunately we have to have entries for all the keywords in all
3311 three languages. */
3312 static const short rid_to_yy[RID_MAX] =
3313 {
3314 /* RID_STATIC */ STATIC,
3315 /* RID_UNSIGNED */ TYPESPEC,
3316 /* RID_LONG */ TYPESPEC,
3317 /* RID_CONST */ TYPE_QUAL,
3318 /* RID_EXTERN */ SCSPEC,
3319 /* RID_REGISTER */ SCSPEC,
3320 /* RID_TYPEDEF */ SCSPEC,
3321 /* RID_SHORT */ TYPESPEC,
3322 /* RID_INLINE */ SCSPEC,
3323 /* RID_VOLATILE */ TYPE_QUAL,
3324 /* RID_SIGNED */ TYPESPEC,
3325 /* RID_AUTO */ SCSPEC,
3326 /* RID_RESTRICT */ TYPE_QUAL,
3328 /* C extensions */
3329 /* RID_COMPLEX */ TYPESPEC,
3330 /* RID_THREAD */ SCSPEC,
3332 /* C++ */
3333 /* RID_FRIEND */ 0,
3334 /* RID_VIRTUAL */ 0,
3335 /* RID_EXPLICIT */ 0,
3336 /* RID_EXPORT */ 0,
3337 /* RID_MUTABLE */ 0,
3339 /* ObjC */
3340 /* RID_IN */ TYPE_QUAL,
3341 /* RID_OUT */ TYPE_QUAL,
3342 /* RID_INOUT */ TYPE_QUAL,
3343 /* RID_BYCOPY */ TYPE_QUAL,
3344 /* RID_BYREF */ TYPE_QUAL,
3345 /* RID_ONEWAY */ TYPE_QUAL,
3347 /* C */
3348 /* RID_INT */ TYPESPEC,
3349 /* RID_CHAR */ TYPESPEC,
3350 /* RID_FLOAT */ TYPESPEC,
3351 /* RID_DOUBLE */ TYPESPEC,
3352 /* RID_VOID */ TYPESPEC,
3353 /* RID_ENUM */ ENUM,
3354 /* RID_STRUCT */ STRUCT,
3355 /* RID_UNION */ UNION,
3356 /* RID_IF */ IF,
3357 /* RID_ELSE */ ELSE,
3358 /* RID_WHILE */ WHILE,
3359 /* RID_DO */ DO,
3360 /* RID_FOR */ FOR,
3361 /* RID_SWITCH */ SWITCH,
3362 /* RID_CASE */ CASE,
3363 /* RID_DEFAULT */ DEFAULT,
3364 /* RID_BREAK */ BREAK,
3365 /* RID_CONTINUE */ CONTINUE,
3366 /* RID_RETURN */ RETURN,
3367 /* RID_GOTO */ GOTO,
3368 /* RID_SIZEOF */ SIZEOF,
3370 /* C extensions */
3371 /* RID_ASM */ ASM_KEYWORD,
3372 /* RID_TYPEOF */ TYPEOF,
3373 /* RID_ALIGNOF */ ALIGNOF,
3374 /* RID_ATTRIBUTE */ ATTRIBUTE,
3375 /* RID_VA_ARG */ VA_ARG,
3376 /* RID_EXTENSION */ EXTENSION,
3377 /* RID_IMAGPART */ IMAGPART,
3378 /* RID_REALPART */ REALPART,
3379 /* RID_LABEL */ LABEL,
3380 /* RID_PTRBASE */ PTR_BASE,
3381 /* RID_PTREXTENT */ PTR_EXTENT,
3382 /* RID_PTRVALUE */ PTR_VALUE,
3384 /* RID_CHOOSE_EXPR */ CHOOSE_EXPR,
3385 /* RID_TYPES_COMPATIBLE_P */ TYPES_COMPATIBLE_P,
3387 /* RID_FUNCTION_NAME */ FUNC_NAME,
3388 /* RID_PRETTY_FUNCTION_NAME */ FUNC_NAME,
3389 /* RID_C99_FUNCTION_NAME */ FUNC_NAME,
3391 /* C++ */
3392 /* RID_BOOL */ TYPESPEC,
3393 /* RID_WCHAR */ 0,
3394 /* RID_CLASS */ 0,
3395 /* RID_PUBLIC */ 0,
3396 /* RID_PRIVATE */ 0,
3397 /* RID_PROTECTED */ 0,
3398 /* RID_TEMPLATE */ 0,
3399 /* RID_NULL */ 0,
3400 /* RID_CATCH */ 0,
3401 /* RID_DELETE */ 0,
3402 /* RID_FALSE */ 0,
3403 /* RID_NAMESPACE */ 0,
3404 /* RID_NEW */ 0,
3405 /* RID_OFFSETOF */ OFFSETOF,
3406 /* RID_OPERATOR */ 0,
3407 /* RID_THIS */ 0,
3408 /* RID_THROW */ 0,
3409 /* RID_TRUE */ 0,
3410 /* RID_TRY */ 0,
3411 /* RID_TYPENAME */ 0,
3412 /* RID_TYPEID */ 0,
3413 /* RID_USING */ 0,
3415 /* casts */
3416 /* RID_CONSTCAST */ 0,
3417 /* RID_DYNCAST */ 0,
3418 /* RID_REINTCAST */ 0,
3419 /* RID_STATCAST */ 0,
3421 /* Objective C */
3422 /* RID_ID */ OBJECTNAME,
3423 /* RID_AT_ENCODE */ AT_ENCODE,
3424 /* RID_AT_END */ AT_END,
3425 /* RID_AT_CLASS */ AT_CLASS,
3426 /* RID_AT_ALIAS */ AT_ALIAS,
3427 /* RID_AT_DEFS */ AT_DEFS,
3428 /* RID_AT_PRIVATE */ AT_PRIVATE,
3429 /* RID_AT_PROTECTED */ AT_PROTECTED,
3430 /* RID_AT_PUBLIC */ AT_PUBLIC,
3431 /* RID_AT_PROTOCOL */ AT_PROTOCOL,
3432 /* RID_AT_SELECTOR */ AT_SELECTOR,
3433 /* RID_AT_THROW */ AT_THROW,
3434 /* RID_AT_TRY */ AT_TRY,
3435 /* RID_AT_CATCH */ AT_CATCH,
3436 /* RID_AT_FINALLY */ AT_FINALLY,
3437 /* RID_AT_SYNCHRONIZED */ AT_SYNCHRONIZED,
3438 /* RID_AT_INTERFACE */ AT_INTERFACE,
3439 /* RID_AT_IMPLEMENTATION */ AT_IMPLEMENTATION
3440 };
3442 static void
3443 init_reswords (void)
3444 {
3445 unsigned int i;
3446 tree id;
3447 int mask = (flag_isoc99 ? 0 : D_C89)
3448 | (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT|D_EXT89) : 0);
3450 if (!c_dialect_objc ())
3451 mask |= D_OBJC;
3453 ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
3454 for (i = 0; i < N_reswords; i++)
3455 {
3456 /* If a keyword is disabled, do not enter it into the table
3457 and so create a canonical spelling that isn't a keyword. */
3458 if (reswords[i].disable & mask)
3459 continue;
3461 id = get_identifier (reswords[i].word);
3462 C_RID_CODE (id) = reswords[i].rid;
3463 C_IS_RESERVED_WORD (id) = 1;
3464 ridpointers [(int) reswords[i].rid] = id;
3465 }
3466 }
3468 #define NAME(type) cpp_type2name (type)
3470 static void
3471 yyerror (const char *msgid)
3472 {
3473 c_parse_error (msgid, last_token, yylval.ttype);
3474 }
3476 static int
3477 yylexname (void)
3478 {
3479 tree decl;
3481 @@ifobjc
3482 int objc_force_identifier = objc_need_raw_identifier;
3483 OBJC_NEED_RAW_IDENTIFIER (0);
3484 @@end_ifobjc
3486 if (C_IS_RESERVED_WORD (yylval.ttype))
3487 {
3488 enum rid rid_code = C_RID_CODE (yylval.ttype);
3490 @@ifobjc
3491 /* Turn non-typedefed refs to "id" into plain identifiers; this
3492 allows constructs like "void foo(id id);" to work. */
3493 if (rid_code == RID_ID)
3494 {
3495 decl = lookup_name (yylval.ttype);
3496 if (decl == NULL_TREE || TREE_CODE (decl) != TYPE_DECL)
3497 return IDENTIFIER;
3498 }
3500 if (!OBJC_IS_AT_KEYWORD (rid_code)
3501 && (!OBJC_IS_PQ_KEYWORD (rid_code) || objc_pq_context))
3502 @@end_ifobjc
3503 {
3504 /* Return the canonical spelling for this keyword. */
3505 yylval.ttype = ridpointers[(int) rid_code];
3506 return rid_to_yy[(int) rid_code];
3507 }
3508 }
3510 decl = lookup_name (yylval.ttype);
3511 if (decl)
3512 {
3513 if (TREE_CODE (decl) == TYPE_DECL)
3514 return TYPENAME;
3515 }
3516 @@ifobjc
3517 else
3518 {
3519 tree objc_interface_decl = objc_is_class_name (yylval.ttype);
3520 /* ObjC class names are in the same namespace as variables and
3521 typedefs, and hence are shadowed by local declarations. */
3522 if (objc_interface_decl
3523 && (global_bindings_p ()
3524 || (!objc_force_identifier && !decl)))
3525 {
3526 yylval.ttype = objc_interface_decl;
3527 return CLASSNAME;
3528 }
3529 }
3530 @@end_ifobjc
3532 return IDENTIFIER;
3533 }
3535 static inline int
3536 _yylex (void)
3537 {
3538 get_next:
3539 last_token = c_lex (&yylval.ttype);
3540 switch (last_token)
3541 {
3542 case CPP_EQ: return '=';
3543 case CPP_NOT: return '!';
3544 case CPP_GREATER: yylval.code = GT_EXPR; return ARITHCOMPARE;
3545 case CPP_LESS: yylval.code = LT_EXPR; return ARITHCOMPARE;
3546 case CPP_PLUS: yylval.code = PLUS_EXPR; return '+';
3547 case CPP_MINUS: yylval.code = MINUS_EXPR; return '-';
3548 case CPP_MULT: yylval.code = MULT_EXPR; return '*';
3549 case CPP_DIV: yylval.code = TRUNC_DIV_EXPR; return '/';
3550 case CPP_MOD: yylval.code = TRUNC_MOD_EXPR; return '%';
3551 case CPP_AND: yylval.code = BIT_AND_EXPR; return '&';
3552 case CPP_OR: yylval.code = BIT_IOR_EXPR; return '|';
3553 case CPP_XOR: yylval.code = BIT_XOR_EXPR; return '^';
3554 case CPP_RSHIFT: yylval.code = RSHIFT_EXPR; return RSHIFT;
3555 case CPP_LSHIFT: yylval.code = LSHIFT_EXPR; return LSHIFT;
3557 case CPP_COMPL: return '~';
3558 case CPP_AND_AND: return ANDAND;
3559 case CPP_OR_OR: return OROR;
3560 case CPP_QUERY: return '?';
3561 case CPP_OPEN_PAREN: return '(';
3562 case CPP_EQ_EQ: yylval.code = EQ_EXPR; return EQCOMPARE;
3563 case CPP_NOT_EQ: yylval.code = NE_EXPR; return EQCOMPARE;
3564 case CPP_GREATER_EQ:yylval.code = GE_EXPR; return ARITHCOMPARE;
3565 case CPP_LESS_EQ: yylval.code = LE_EXPR; return ARITHCOMPARE;
3567 case CPP_PLUS_EQ: yylval.code = PLUS_EXPR; return ASSIGN;
3568 case CPP_MINUS_EQ: yylval.code = MINUS_EXPR; return ASSIGN;
3569 case CPP_MULT_EQ: yylval.code = MULT_EXPR; return ASSIGN;
3570 case CPP_DIV_EQ: yylval.code = TRUNC_DIV_EXPR; return ASSIGN;
3571 case CPP_MOD_EQ: yylval.code = TRUNC_MOD_EXPR; return ASSIGN;
3572 case CPP_AND_EQ: yylval.code = BIT_AND_EXPR; return ASSIGN;
3573 case CPP_OR_EQ: yylval.code = BIT_IOR_EXPR; return ASSIGN;
3574 case CPP_XOR_EQ: yylval.code = BIT_XOR_EXPR; return ASSIGN;
3575 case CPP_RSHIFT_EQ: yylval.code = RSHIFT_EXPR; return ASSIGN;
3576 case CPP_LSHIFT_EQ: yylval.code = LSHIFT_EXPR; return ASSIGN;
3578 case CPP_OPEN_SQUARE: return '[';
3579 case CPP_CLOSE_SQUARE: return ']';
3580 case CPP_OPEN_BRACE: return '{';
3581 case CPP_CLOSE_BRACE: return '}';
3582 case CPP_ELLIPSIS: return ELLIPSIS;
3584 case CPP_PLUS_PLUS: return PLUSPLUS;
3585 case CPP_MINUS_MINUS: return MINUSMINUS;
3586 case CPP_DEREF: return POINTSAT;
3587 case CPP_DOT: return '.';
3589 /* The following tokens may affect the interpretation of any
3590 identifiers following, if doing Objective-C. */
3591 case CPP_COLON: OBJC_NEED_RAW_IDENTIFIER (0); return ':';
3592 case CPP_COMMA: OBJC_NEED_RAW_IDENTIFIER (0); return ',';
3593 case CPP_CLOSE_PAREN: OBJC_NEED_RAW_IDENTIFIER (0); return ')';
3594 case CPP_SEMICOLON: OBJC_NEED_RAW_IDENTIFIER (0); return ';';
3596 case CPP_EOF:
3597 return 0;
3599 case CPP_NAME:
3600 return yylexname ();
3602 case CPP_AT_NAME:
3603 /* This only happens in Objective-C; it must be a keyword. */
3604 return rid_to_yy [(int) C_RID_CODE (yylval.ttype)];
3606 case CPP_NUMBER:
3607 case CPP_CHAR:
3608 case CPP_WCHAR:
3609 return CONSTANT;
3611 case CPP_STRING:
3612 case CPP_WSTRING:
3613 return STRING;
3615 case CPP_OBJC_STRING:
3616 return OBJC_STRING;
3618 /* These tokens are C++ specific (and will not be generated
3619 in C mode, but let's be cautious). */
3620 case CPP_SCOPE:
3621 case CPP_DEREF_STAR:
3622 case CPP_DOT_STAR:
3623 case CPP_MIN_EQ:
3624 case CPP_MAX_EQ:
3625 case CPP_MIN:
3626 case CPP_MAX:
3627 /* These tokens should not survive translation phase 4. */
3628 case CPP_HASH:
3629 case CPP_PASTE:
3630 error ("syntax error at '%s' token", NAME(last_token));
3631 goto get_next;
3633 default:
3634 abort ();
3635 }
3636 /* NOTREACHED */
3637 }
3639 static int
3640 yylex (void)
3641 {
3642 int r;
3643 timevar_push (TV_LEX);
3644 r = _yylex();
3645 timevar_pop (TV_LEX);
3646 return r;
3647 }
3649 /* Function used when yydebug is set, to print a token in more detail. */
3651 static void
3652 yyprint (FILE *file, int yychar, YYSTYPE yyl)
3653 {
3654 tree t = yyl.ttype;
3656 fprintf (file, " [%s]", NAME(last_token));
3658 switch (yychar)
3659 {
3660 case IDENTIFIER:
3661 case TYPENAME:
3662 case OBJECTNAME:
3663 case TYPESPEC:
3664 case TYPE_QUAL:
3665 case SCSPEC:
3666 case STATIC:
3667 if (IDENTIFIER_POINTER (t))
3668 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
3669 break;
3671 case CONSTANT:
3672 fprintf (file, " %s", GET_MODE_NAME (TYPE_MODE (TREE_TYPE (t))));
3673 if (TREE_CODE (t) == INTEGER_CST)
3674 {
3675 fputs (" ", file);
3676 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3677 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
3678 }
3679 break;
3680 }
3681 }
3682 \f
3683 /* This is not the ideal place to put this, but we have to get it out
3684 of c-lex.c because cp/lex.c has its own version. */
3686 /* Parse the file. */
3687 void
3688 c_parse_file (void)
3689 {
3690 yyparse ();
3692 if (malloced_yyss)
3693 {
3694 free (malloced_yyss);
3695 free (malloced_yyvs);
3696 malloced_yyss = 0;
3697 }
3698 }
3700 #include "gt-c-parse.h"