| blob | e4696776c5ba6c5469c98aa2c5c5eac09434afad |
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"
53 #include "c-common.h"
55 #define YYERROR1 { yyerror ("syntax error"); YYERROR; }
57 /* Like the default stack expander, except (1) use realloc when possible,
58 (2) impose no hard maxiumum on stack size, (3) REALLY do not use alloca.
60 Irritatingly, YYSTYPE is defined after this %{ %} block, so we cannot
61 give malloced_yyvs its proper type. This is ok since all we need from
62 it is to be able to free it. */
64 static short *malloced_yyss;
65 static void *malloced_yyvs;
67 #define yyoverflow(MSG, SS, SSSIZE, VS, VSSIZE, YYSSZ) \
68 do { \
69 size_t newsize; \
70 short *newss; \
71 YYSTYPE *newvs; \
72 newsize = *(YYSSZ) *= 2; \
73 if (malloced_yyss) \
74 { \
75 newss = really_call_realloc (*(SS), newsize * sizeof (short)); \
76 newvs = really_call_realloc (*(VS), newsize * sizeof (YYSTYPE)); \
77 } \
78 else \
79 { \
80 newss = really_call_malloc (newsize * sizeof (short)); \
81 newvs = really_call_malloc (newsize * sizeof (YYSTYPE)); \
82 if (newss) \
83 memcpy (newss, *(SS), (SSSIZE)); \
84 if (newvs) \
85 memcpy (newvs, *(VS), (VSSIZE)); \
86 } \
87 if (!newss || !newvs) \
88 { \
89 yyerror (MSG); \
90 return 2; \
91 } \
92 *(SS) = newss; \
93 *(VS) = newvs; \
94 malloced_yyss = newss; \
95 malloced_yyvs = (void *) newvs; \
96 } while (0)
97 %}
99 %start program
101 %union {long itype; tree ttype; void *otype; struct c_expr exprtype;
102 struct c_arg_info *arginfotype; struct c_declarator *dtrtype;
103 struct c_type_name *typenametype; struct c_parm *parmtype;
104 struct c_declspecs *dsptype; enum tree_code code;
105 location_t location; }
107 /* All identifiers that are not reserved words
108 and are not declared typedefs in the current block */
109 %token IDENTIFIER
111 /* All identifiers that are declared typedefs in the current block.
112 In some contexts, they are treated just like IDENTIFIER,
113 but they can also serve as typespecs in declarations. */
114 %token TYPENAME
116 /* Reserved words that specify storage class.
117 yylval contains an IDENTIFIER_NODE which indicates which one. */
118 %token SCSPEC /* Storage class other than static. */
119 %token STATIC /* Static storage class. */
121 /* Reserved words that specify type.
122 yylval contains an IDENTIFIER_NODE which indicates which one. */
123 %token TYPESPEC
125 /* Reserved words that qualify type: "const", "volatile", or "restrict".
126 yylval contains an IDENTIFIER_NODE which indicates which one. */
127 %token TYPE_QUAL
129 /* Objective-C protocol qualifiers. These acquire their magic powers
130 only in certain contexts. */
131 %token OBJC_TYPE_QUAL
133 /* Character or numeric constants.
134 yylval is the node for the constant. */
135 %token CONSTANT
137 /* String constants in raw form.
138 yylval is a STRING_CST node. */
140 %token STRING
142 /* "...", used for functions with variable arglists. */
143 %token ELLIPSIS
145 /* the reserved words */
146 /* SCO include files test "ASM", so use something else. */
147 %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
148 %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF
149 %token ATTRIBUTE EXTENSION LABEL
150 %token REALPART IMAGPART VA_ARG CHOOSE_EXPR TYPES_COMPATIBLE_P
151 %token PTR_VALUE PTR_BASE PTR_EXTENT
152 %token FUNC_NAME OFFSETOF
154 /* Add precedence rules to solve dangling else s/r conflict */
155 %nonassoc IF
156 %nonassoc ELSE
158 /* Define the operator tokens and their precedences.
159 The value is an integer because, if used, it is the tree code
160 to use in the expression made from the operator. */
162 %right <code> ASSIGN '='
163 %right <code> '?' ':'
164 %left <code> OROR
165 %left <code> ANDAND
166 %left <code> '|'
167 %left <code> '^'
168 %left <code> '&'
169 %left <code> EQCOMPARE
170 %left <code> ARITHCOMPARE
171 %left <code> LSHIFT RSHIFT
172 %left <code> '+' '-'
173 %left <code> '*' '/' '%'
174 %right <code> UNARY PLUSPLUS MINUSMINUS
175 %left HYPERUNARY
176 %left <code> POINTSAT '.' '(' '['
178 /* The Objective-C keywords. These are included in C and in
179 Objective C, so that the token codes are the same in both. */
180 %token AT_INTERFACE AT_IMPLEMENTATION AT_END AT_SELECTOR AT_DEFS AT_ENCODE
181 %token CLASSNAME AT_PUBLIC AT_PRIVATE AT_PROTECTED AT_PROTOCOL
182 %token OBJECTNAME AT_CLASS AT_ALIAS
183 %token AT_THROW AT_TRY AT_CATCH AT_FINALLY AT_SYNCHRONIZED
184 %token OBJC_STRING
186 %type <code> unop
187 %type <ttype> ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
188 %type <ttype> BREAK CONTINUE RETURN GOTO ASM_KEYWORD SIZEOF TYPEOF ALIGNOF
190 %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT STRING FUNC_NAME
191 %type <ttype> nonnull_exprlist exprlist
192 %type <exprtype> expr expr_no_commas cast_expr unary_expr primary
193 %type <dsptype> declspecs_nosc_nots_nosa_noea declspecs_nosc_nots_nosa_ea
194 %type <dsptype> declspecs_nosc_nots_sa_noea declspecs_nosc_nots_sa_ea
195 %type <dsptype> declspecs_nosc_ts_nosa_noea declspecs_nosc_ts_nosa_ea
196 %type <dsptype> declspecs_nosc_ts_sa_noea declspecs_nosc_ts_sa_ea
197 %type <dsptype> declspecs_sc_nots_nosa_noea declspecs_sc_nots_nosa_ea
198 %type <dsptype> declspecs_sc_nots_sa_noea declspecs_sc_nots_sa_ea
199 %type <dsptype> declspecs_sc_ts_nosa_noea declspecs_sc_ts_nosa_ea
200 %type <dsptype> declspecs_sc_ts_sa_noea declspecs_sc_ts_sa_ea
201 %type <dsptype> declspecs_ts declspecs_nots
202 %type <dsptype> declspecs_ts_nosa declspecs_nots_nosa
203 %type <dsptype> declspecs_nosc_ts declspecs_nosc_nots declspecs_nosc declspecs
204 %type <dsptype> maybe_type_quals_attrs
205 %type <ttype> 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 <dtrtype> declarator
224 %type <dtrtype> notype_declarator after_type_declarator
225 %type <dtrtype> parm_declarator
226 %type <dtrtype> parm_declarator_starttypename parm_declarator_nostarttypename
227 %type <dtrtype> 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 <typenametype> typename
236 %type <dtrtype> absdcl absdcl1 absdcl1_ea absdcl1_noea direct_absdcl1
237 %type <parmtype> absdcl_maybe_attribute
238 %type <ttype> condition xexpr for_cond_expr for_incr_expr
239 %type <parmtype> parm firstparm
240 %type <ttype> identifiers
242 %type <arginfotype> parms parmlist parmlist_1 parmlist_2
243 %type <arginfotype> parmlist_or_identifiers parmlist_or_identifiers_1
244 %type <ttype> identifiers_or_typenames
246 %type <itype> setspecs setspecs_fp extension
248 %type <location> save_location
250 %type <otype> save_obstack_position
251 \f
252 @@ifobjc
253 /* the Objective-C nonterminals */
255 %type <ttype> methoddecl unaryselector keywordselector selector
256 %type <code> methodtype
257 %type <ttype> keyworddecl receiver objcmessageexpr messageargs
258 %type <ttype> keywordexpr keywordarglist keywordarg
259 %type <ttype> optparmlist optparms reservedwords objcselectorexpr
260 %type <ttype> selectorarg keywordnamelist keywordname objcencodeexpr
261 %type <ttype> non_empty_protocolrefs protocolrefs identifier_list objcprotocolexpr
263 %type <ttype> CLASSNAME OBJECTNAME OBJC_STRING OBJC_TYPE_QUAL
265 %type <ttype> superclass objc_quals objc_qual objc_typename
266 %type <itype> objc_try_catch_stmt optellipsis
267 @@end_ifobjc
268 \f
269 %{
270 /* Declaration specifiers of the current declaration. */
271 static struct c_declspecs *current_declspecs;
272 static GTY(()) tree prefix_attributes;
274 /* List of all the attributes applying to the identifier currently being
275 declared; includes prefix_attributes and possibly some more attributes
276 just after a comma. */
277 static GTY(()) tree all_prefix_attributes;
279 /* Structure to save declaration specifiers. */
280 struct c_declspec_stack {
281 /* Saved value of current_declspecs. */
282 struct c_declspecs *current_declspecs;
283 /* Saved value of prefix_attributes. */
284 tree prefix_attributes;
285 /* Saved value of all_prefix_attributes. */
286 tree all_prefix_attributes;
287 /* Next level of stack. */
288 struct c_declspec_stack *next;
289 };
291 /* Stack of saved values of current_declspecs, prefix_attributes and
292 all_prefix_attributes. */
293 static struct c_declspec_stack *declspec_stack;
295 /* INDIRECT_REF with a TREE_TYPE of the type being queried for offsetof. */
296 static tree offsetof_base;
298 /* PUSH_DECLSPEC_STACK is called from setspecs; POP_DECLSPEC_STACK
299 should be called from the productions making use of setspecs. */
300 #define PUSH_DECLSPEC_STACK \
301 do { \
302 struct c_declspec_stack *t = XOBNEW (&parser_obstack, \
303 struct c_declspec_stack); \
304 t->current_declspecs = current_declspecs; \
305 t->prefix_attributes = prefix_attributes; \
306 t->all_prefix_attributes = all_prefix_attributes; \
307 t->next = declspec_stack; \
308 declspec_stack = t; \
309 } while (0)
311 #define POP_DECLSPEC_STACK \
312 do { \
313 current_declspecs = declspec_stack->current_declspecs; \
314 prefix_attributes = declspec_stack->prefix_attributes; \
315 all_prefix_attributes = declspec_stack->all_prefix_attributes; \
316 declspec_stack = declspec_stack->next; \
317 } while (0)
319 /* For __extension__, save/restore the warning flags which are
320 controlled by __extension__. */
321 #define SAVE_EXT_FLAGS() \
322 (pedantic \
323 | (warn_pointer_arith << 1) \
324 | (warn_traditional << 2) \
325 | (flag_iso << 3))
327 #define RESTORE_EXT_FLAGS(val) \
328 do { \
329 pedantic = val & 1; \
330 warn_pointer_arith = (val >> 1) & 1; \
331 warn_traditional = (val >> 2) & 1; \
332 flag_iso = (val >> 3) & 1; \
333 } while (0)
335 @@ifobjc
336 /* Objective-C specific parser/lexer information */
338 static int objc_pq_context = 0;
340 /* The following flag is needed to contextualize ObjC lexical analysis.
341 In some cases (e.g., 'int NSObject;'), it is undesirable to bind
342 an identifier to an ObjC class, even if a class with that name
343 exists. */
344 static int objc_need_raw_identifier;
345 #define OBJC_NEED_RAW_IDENTIFIER(VAL) objc_need_raw_identifier = VAL
346 @@end_ifobjc
348 @@ifc
349 #define OBJC_NEED_RAW_IDENTIFIER(VAL) /* nothing */
350 @@end_ifc
352 /* Tell yyparse how to print a token's value, if yydebug is set. */
354 #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
356 static void yyprint (FILE *, int, YYSTYPE);
357 static void yyerror (const char *);
358 static int yylexname (void);
359 static inline int _yylex (void);
360 static int yylex (void);
361 static void init_reswords (void);
363 /* Initialization routine for this file. */
364 void
365 c_parse_init (void)
366 {
367 init_reswords ();
368 }
370 %}
371 \f
372 %%
373 program: /* empty */
374 { if (pedantic)
375 pedwarn ("ISO C forbids an empty source file");
376 }
377 | extdefs
378 ;
380 /* the reason for the strange actions in this rule
381 is so that notype_initdecls when reached via datadef
382 can find valid declaration specifiers in $0. */
384 extdefs:
385 save_obstack_position { $<dsptype>$ = NULL; } extdef
386 { obstack_free (&parser_obstack, $1); }
387 | extdefs save_obstack_position
388 { $<dsptype>$ = NULL; ggc_collect (); } extdef
389 { obstack_free (&parser_obstack, $2); }
390 ;
392 extdef:
393 fndef
394 | datadef
395 | asmdef
396 | extension extdef
397 { RESTORE_EXT_FLAGS ($1); }
398 @@ifobjc
399 | objcdef
400 @@end_ifobjc
401 ;
403 /* Record the current position of parser_obstack before a
404 declaration to restore it afterwards. */
405 save_obstack_position:
406 { $$ = obstack_alloc (&parser_obstack, 0); }
407 ;
409 datadef:
410 setspecs notype_initdecls ';'
411 { if (pedantic)
412 error ("ISO C forbids data definition with no type or storage class");
413 else
414 warning ("data definition has no type or storage class");
416 POP_DECLSPEC_STACK; }
417 | declspecs_nots setspecs notype_initdecls ';'
418 { POP_DECLSPEC_STACK; }
419 | declspecs_ts setspecs initdecls ';'
420 { POP_DECLSPEC_STACK; }
421 | declspecs ';'
422 { shadow_tag (finish_declspecs ($1)); }
423 | error ';'
424 | error '}'
425 | ';'
426 { if (pedantic)
427 pedwarn ("ISO C does not allow extra %<;%> outside of a function"); }
428 ;
429 \f
430 fndef:
431 declspecs_ts setspecs declarator
432 { if (!start_function (current_declspecs, $3,
433 all_prefix_attributes))
434 YYERROR1;
435 }
436 old_style_parm_decls save_location
437 { DECL_SOURCE_LOCATION (current_function_decl) = $6;
438 store_parm_decls (); }
439 compstmt_or_error
440 { finish_function ();
441 POP_DECLSPEC_STACK; }
442 | declspecs_ts setspecs declarator error
443 { POP_DECLSPEC_STACK; }
444 | declspecs_nots setspecs notype_declarator
445 { if (!start_function (current_declspecs, $3,
446 all_prefix_attributes))
447 YYERROR1;
448 }
449 old_style_parm_decls save_location
450 { DECL_SOURCE_LOCATION (current_function_decl) = $6;
451 store_parm_decls (); }
452 compstmt_or_error
453 { finish_function ();
454 POP_DECLSPEC_STACK; }
455 | declspecs_nots setspecs notype_declarator error
456 { POP_DECLSPEC_STACK; }
457 | setspecs notype_declarator
458 { if (!start_function (current_declspecs, $2,
459 all_prefix_attributes))
460 YYERROR1;
461 }
462 old_style_parm_decls save_location
463 { DECL_SOURCE_LOCATION (current_function_decl) = $5;
464 store_parm_decls (); }
465 compstmt_or_error
466 { finish_function ();
467 POP_DECLSPEC_STACK; }
468 | setspecs notype_declarator error
469 { POP_DECLSPEC_STACK; }
470 ;
472 identifier:
473 IDENTIFIER
474 | TYPENAME
475 @@ifobjc
476 | OBJECTNAME
477 | CLASSNAME
478 @@end_ifobjc
479 ;
481 unop: '&'
482 { $$ = ADDR_EXPR; }
483 | '-'
484 { $$ = NEGATE_EXPR; }
485 | '+'
486 { $$ = CONVERT_EXPR;
487 @@ifc
488 if (warn_traditional && !in_system_header)
489 warning ("traditional C rejects the unary plus operator");
490 @@end_ifc
491 }
492 | PLUSPLUS
493 { $$ = PREINCREMENT_EXPR; }
494 | MINUSMINUS
495 { $$ = PREDECREMENT_EXPR; }
496 | '~'
497 { $$ = BIT_NOT_EXPR; }
498 | '!'
499 { $$ = TRUTH_NOT_EXPR; }
500 ;
502 expr: expr_no_commas
503 | expr ',' expr_no_commas
504 { $$.value = build_compound_expr ($1.value, $3.value);
505 $$.original_code = COMPOUND_EXPR; }
506 ;
508 exprlist:
509 /* empty */
510 { $$ = NULL_TREE; }
511 | nonnull_exprlist
512 ;
514 nonnull_exprlist:
515 expr_no_commas
516 { $$ = build_tree_list (NULL_TREE, $1.value); }
517 | nonnull_exprlist ',' expr_no_commas
518 { chainon ($1, build_tree_list (NULL_TREE, $3.value)); }
519 ;
521 unary_expr:
522 primary
523 | '*' cast_expr %prec UNARY
524 { $$.value = build_indirect_ref ($2.value, "unary *");
525 $$.original_code = ERROR_MARK; }
526 /* __extension__ turns off -pedantic for following primary. */
527 | extension cast_expr %prec UNARY
528 { $$ = $2;
529 RESTORE_EXT_FLAGS ($1); }
530 | unop cast_expr %prec UNARY
531 { $$.value = build_unary_op ($1, $2.value, 0);
532 overflow_warning ($$.value);
533 $$.original_code = ERROR_MARK; }
534 /* Refer to the address of a label as a pointer. */
535 | ANDAND identifier
536 { $$.value = finish_label_address_expr ($2);
537 $$.original_code = ERROR_MARK; }
538 | sizeof unary_expr %prec UNARY
539 { skip_evaluation--;
540 in_sizeof--;
541 if (TREE_CODE ($2.value) == COMPONENT_REF
542 && DECL_C_BIT_FIELD (TREE_OPERAND ($2.value, 1)))
543 error ("%<sizeof%> applied to a bit-field");
544 $$ = c_expr_sizeof_expr ($2); }
545 | sizeof '(' typename ')' %prec HYPERUNARY
546 { skip_evaluation--;
547 in_sizeof--;
548 $$ = c_expr_sizeof_type ($3); }
549 | alignof unary_expr %prec UNARY
550 { skip_evaluation--;
551 in_alignof--;
552 $$.value = c_alignof_expr ($2.value);
553 $$.original_code = ERROR_MARK; }
554 | alignof '(' typename ')' %prec HYPERUNARY
555 { skip_evaluation--;
556 in_alignof--;
557 $$.value = c_alignof (groktypename ($3));
558 $$.original_code = ERROR_MARK; }
559 | REALPART cast_expr %prec UNARY
560 { $$.value = build_unary_op (REALPART_EXPR, $2.value, 0);
561 $$.original_code = ERROR_MARK; }
562 | IMAGPART cast_expr %prec UNARY
563 { $$.value = build_unary_op (IMAGPART_EXPR, $2.value, 0);
564 $$.original_code = ERROR_MARK; }
565 ;
567 sizeof:
568 SIZEOF { skip_evaluation++; in_sizeof++; }
569 ;
571 alignof:
572 ALIGNOF { skip_evaluation++; in_alignof++; }
573 ;
575 typeof:
576 TYPEOF { skip_evaluation++; in_typeof++; }
577 ;
579 cast_expr:
580 unary_expr
581 | '(' typename ')' cast_expr %prec UNARY
582 { $$.value = c_cast_expr ($2, $4.value);
583 $$.original_code = ERROR_MARK; }
584 ;
586 expr_no_commas:
587 cast_expr
588 | expr_no_commas '+' expr_no_commas
589 { $$ = parser_build_binary_op ($2, $1, $3); }
590 | expr_no_commas '-' expr_no_commas
591 { $$ = parser_build_binary_op ($2, $1, $3); }
592 | expr_no_commas '*' expr_no_commas
593 { $$ = parser_build_binary_op ($2, $1, $3); }
594 | expr_no_commas '/' expr_no_commas
595 { $$ = parser_build_binary_op ($2, $1, $3); }
596 | expr_no_commas '%' expr_no_commas
597 { $$ = parser_build_binary_op ($2, $1, $3); }
598 | expr_no_commas LSHIFT expr_no_commas
599 { $$ = parser_build_binary_op ($2, $1, $3); }
600 | expr_no_commas RSHIFT expr_no_commas
601 { $$ = parser_build_binary_op ($2, $1, $3); }
602 | expr_no_commas ARITHCOMPARE expr_no_commas
603 { $$ = parser_build_binary_op ($2, $1, $3); }
604 | expr_no_commas EQCOMPARE expr_no_commas
605 { $$ = parser_build_binary_op ($2, $1, $3); }
606 | expr_no_commas '&' expr_no_commas
607 { $$ = parser_build_binary_op ($2, $1, $3); }
608 | expr_no_commas '|' expr_no_commas
609 { $$ = parser_build_binary_op ($2, $1, $3); }
610 | expr_no_commas '^' expr_no_commas
611 { $$ = parser_build_binary_op ($2, $1, $3); }
612 | expr_no_commas ANDAND
613 { $1.value = lang_hooks.truthvalue_conversion
614 (default_conversion ($1.value));
615 skip_evaluation += $1.value == truthvalue_false_node; }
616 expr_no_commas
617 { skip_evaluation -= $1.value == truthvalue_false_node;
618 $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $4); }
619 | expr_no_commas OROR
620 { $1.value = lang_hooks.truthvalue_conversion
621 (default_conversion ($1.value));
622 skip_evaluation += $1.value == truthvalue_true_node; }
623 expr_no_commas
624 { skip_evaluation -= $1.value == truthvalue_true_node;
625 $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $4); }
626 | expr_no_commas '?'
627 { $1.value = lang_hooks.truthvalue_conversion
628 (default_conversion ($1.value));
629 skip_evaluation += $1.value == truthvalue_false_node; }
630 expr ':'
631 { skip_evaluation += (($1.value == truthvalue_true_node)
632 - ($1.value == truthvalue_false_node)); }
633 expr_no_commas
634 { skip_evaluation -= $1.value == truthvalue_true_node;
635 $$.value = build_conditional_expr ($1.value, $4.value,
636 $7.value);
637 $$.original_code = ERROR_MARK; }
638 | expr_no_commas '?'
639 { if (pedantic)
640 pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
641 /* Make sure first operand is calculated only once. */
642 $<ttype>2 = save_expr (default_conversion ($1.value));
643 $1.value = lang_hooks.truthvalue_conversion ($<ttype>2);
644 skip_evaluation += $1.value == truthvalue_true_node; }
645 ':' expr_no_commas
646 { skip_evaluation -= $1.value == truthvalue_true_node;
647 $$.value = build_conditional_expr ($1.value, $<ttype>2,
648 $5.value);
649 $$.original_code = ERROR_MARK; }
650 | expr_no_commas '=' expr_no_commas
651 { $$.value = build_modify_expr ($1.value, NOP_EXPR, $3.value);
652 $$.original_code = MODIFY_EXPR;
653 }
654 | expr_no_commas ASSIGN expr_no_commas
655 { $$.value = build_modify_expr ($1.value, $2, $3.value);
656 TREE_NO_WARNING ($$.value) = 1;
657 $$.original_code = ERROR_MARK;
658 }
659 ;
661 primary:
662 IDENTIFIER
663 {
664 if (yychar == YYEMPTY)
665 yychar = YYLEX;
666 $$.value = build_external_ref ($1, yychar == '(');
667 $$.original_code = ERROR_MARK;
668 }
669 | CONSTANT
670 { $$.value = $1; $$.original_code = ERROR_MARK; }
671 | STRING
672 { $$.value = $1; $$.original_code = STRING_CST; }
673 | FUNC_NAME
674 { $$.value = fname_decl (C_RID_CODE ($1), $1);
675 $$.original_code = ERROR_MARK; }
676 | '(' typename ')' '{'
677 { start_init (NULL_TREE, NULL, 0);
678 $<ttype>$ = groktypename ($2);
679 if (C_TYPE_VARIABLE_SIZE ($<ttype>$))
680 {
681 error ("compound literal has variable size");
682 $<ttype>$ = error_mark_node;
683 }
684 really_start_incremental_init ($<ttype>$); }
685 initlist_maybe_comma '}' %prec UNARY
686 { struct c_expr init = pop_init_level (0);
687 tree constructor = init.value;
688 tree type = $<ttype>5;
689 finish_init ();
690 maybe_warn_string_init (type, init);
692 if (pedantic && !flag_isoc99)
693 pedwarn ("ISO C90 forbids compound literals");
694 $$.value = build_compound_literal (type, constructor);
695 $$.original_code = ERROR_MARK;
696 }
697 | '(' expr ')'
698 { $$.value = $2.value;
699 if (TREE_CODE ($$.value) == MODIFY_EXPR)
700 TREE_NO_WARNING ($$.value) = 1;
701 $$.original_code = ERROR_MARK; }
702 | '(' error ')'
703 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
704 | compstmt_primary_start compstmt_nostart ')'
705 { if (pedantic)
706 pedwarn ("ISO C forbids braced-groups within expressions");
707 $$.value = c_finish_stmt_expr ($1);
708 $$.original_code = ERROR_MARK;
709 }
710 | compstmt_primary_start error ')'
711 { c_finish_stmt_expr ($1);
712 $$.value = error_mark_node;
713 $$.original_code = ERROR_MARK;
714 }
715 | primary '(' exprlist ')' %prec '.'
716 { $$.value = build_function_call ($1.value, $3);
717 $$.original_code = ERROR_MARK; }
718 | VA_ARG '(' expr_no_commas ',' typename ')'
719 { $$.value = build_va_arg ($3.value, groktypename ($5));
720 $$.original_code = ERROR_MARK; }
722 | OFFSETOF '(' typename ','
723 { tree type = groktypename ($3);
724 if (type == error_mark_node)
725 offsetof_base = error_mark_node;
726 else
727 offsetof_base = build1 (INDIRECT_REF, type, NULL);
728 }
729 offsetof_member_designator ')'
730 { $$.value = fold_offsetof ($6);
731 $$.original_code = ERROR_MARK; }
732 | OFFSETOF '(' error ')'
733 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
734 | CHOOSE_EXPR '(' expr_no_commas ',' expr_no_commas ','
735 expr_no_commas ')'
736 {
737 tree c;
739 c = fold ($3.value);
740 STRIP_NOPS (c);
741 if (TREE_CODE (c) != INTEGER_CST)
742 error ("first argument to __builtin_choose_expr not"
743 " a constant");
744 $$ = integer_zerop (c) ? $7 : $5;
745 }
746 | CHOOSE_EXPR '(' error ')'
747 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
748 | TYPES_COMPATIBLE_P '(' typename ',' typename ')'
749 {
750 tree e1, e2;
752 e1 = TYPE_MAIN_VARIANT (groktypename ($3));
753 e2 = TYPE_MAIN_VARIANT (groktypename ($5));
755 $$.value = comptypes (e1, e2)
756 ? build_int_cst (NULL_TREE, 1)
757 : build_int_cst (NULL_TREE, 0);
758 $$.original_code = ERROR_MARK;
759 }
760 | TYPES_COMPATIBLE_P '(' error ')'
761 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
762 | primary '[' expr ']' %prec '.'
763 { $$.value = build_array_ref ($1.value, $3.value);
764 $$.original_code = ERROR_MARK; }
765 | primary '.' identifier
766 { $$.value = build_component_ref ($1.value, $3);
767 $$.original_code = ERROR_MARK; }
768 | primary POINTSAT identifier
769 {
770 tree expr = build_indirect_ref ($1.value, "->");
771 $$.value = build_component_ref (expr, $3);
772 $$.original_code = ERROR_MARK;
773 }
774 | primary PLUSPLUS
775 { $$.value = build_unary_op (POSTINCREMENT_EXPR, $1.value, 0);
776 $$.original_code = ERROR_MARK; }
777 | primary MINUSMINUS
778 { $$.value = build_unary_op (POSTDECREMENT_EXPR, $1.value, 0);
779 $$.original_code = ERROR_MARK; }
780 @@ifobjc
781 | objcmessageexpr
782 { $$.value = objc_build_message_expr ($1);
783 $$.original_code = ERROR_MARK; }
784 | objcselectorexpr
785 { $$.value = objc_build_selector_expr ($1);
786 $$.original_code = ERROR_MARK; }
787 | objcprotocolexpr
788 { $$.value = objc_build_protocol_expr ($1);
789 $$.original_code = ERROR_MARK; }
790 | objcencodeexpr
791 { $$.value = objc_build_encode_expr ($1);
792 $$.original_code = ERROR_MARK; }
793 | OBJC_STRING
794 { $$.value = objc_build_string_object ($1);
795 $$.original_code = ERROR_MARK; }
796 @@end_ifobjc
797 ;
799 /* This is the second argument to __builtin_offsetof. We must have one
800 identifier, and beyond that we want to accept sub structure and sub
801 array references. */
803 offsetof_member_designator:
804 identifier
805 { $$ = build_component_ref (offsetof_base, $1); }
806 | offsetof_member_designator '.' identifier
807 { $$ = build_component_ref ($1, $3); }
808 | offsetof_member_designator '[' expr ']'
809 { $$ = build_array_ref ($1, $3.value); }
810 ;
812 old_style_parm_decls:
813 /* empty */
814 | datadecls
815 ;
817 /* The following are analogous to lineno_decl, decls and decl
818 except that they do not allow nested functions.
819 They are used for old-style parm decls. */
820 lineno_datadecl:
821 save_location datadecl
822 { }
823 ;
825 datadecls:
826 lineno_datadecl
827 | errstmt
828 | datadecls lineno_datadecl
829 | lineno_datadecl errstmt
830 ;
832 /* We don't allow prefix attributes here because they cause reduce/reduce
833 conflicts: we can't know whether we're parsing a function decl with
834 attribute suffix, or function defn with attribute prefix on first old
835 style parm. */
836 datadecl:
837 declspecs_ts_nosa setspecs initdecls ';'
838 { POP_DECLSPEC_STACK; }
839 | declspecs_nots_nosa setspecs notype_initdecls ';'
840 { POP_DECLSPEC_STACK; }
841 | declspecs_ts_nosa ';'
842 { shadow_tag_warned (finish_declspecs ($1), 1);
843 pedwarn ("empty declaration"); }
844 | declspecs_nots_nosa ';'
845 { pedwarn ("empty declaration"); }
846 ;
848 /* This combination which saves a lineno before a decl
849 is the normal thing to use, rather than decl itself.
850 This is to avoid shift/reduce conflicts in contexts
851 where statement labels are allowed. */
852 lineno_decl:
853 save_location decl
854 { }
855 ;
857 /* records the type and storage class specs to use for processing
858 the declarators that follow.
859 Maintains a stack of outer-level values of current_declspecs,
860 for the sake of parm declarations nested in function declarators. */
861 setspecs: /* empty */
862 { pending_xref_error ();
863 PUSH_DECLSPEC_STACK;
864 if ($<dsptype>0)
865 {
866 prefix_attributes = $<dsptype>0->attrs;
867 $<dsptype>0->attrs = NULL_TREE;
868 current_declspecs = $<dsptype>0;
869 }
870 else
871 {
872 prefix_attributes = NULL_TREE;
873 current_declspecs = build_null_declspecs ();
874 }
875 current_declspecs = finish_declspecs (current_declspecs);
876 all_prefix_attributes = prefix_attributes; }
877 ;
879 /* Possibly attributes after a comma, which should reset all_prefix_attributes
880 to prefix_attributes with these ones chained on the front. */
881 maybe_resetattrs:
882 maybe_attribute
883 { all_prefix_attributes = chainon ($1, prefix_attributes); }
884 ;
886 decl:
887 declspecs_ts setspecs initdecls ';'
888 { POP_DECLSPEC_STACK; }
889 | declspecs_nots setspecs notype_initdecls ';'
890 { POP_DECLSPEC_STACK; }
891 | declspecs_ts setspecs nested_function
892 { POP_DECLSPEC_STACK; }
893 | declspecs_nots setspecs notype_nested_function
894 { POP_DECLSPEC_STACK; }
895 | declspecs ';'
896 { shadow_tag (finish_declspecs ($1)); }
897 | extension decl
898 { RESTORE_EXT_FLAGS ($1); }
899 ;
901 /* A list of declaration specifiers. These are:
903 - Storage class specifiers (scspec), which for GCC currently includes
904 function specifiers ("inline").
906 - Type specifiers (typespec_*).
908 - Type qualifiers (TYPE_QUAL).
910 - Attribute specifier lists (attributes).
912 The various cases below are classified according to:
914 (a) Whether a storage class specifier is included or not; some
915 places in the grammar disallow storage class specifiers (_sc or _nosc).
917 (b) Whether a type specifier has been seen; after a type specifier,
918 a typedef name is an identifier to redeclare (_ts or _nots).
920 (c) Whether the list starts with an attribute; in certain places,
921 the grammar requires specifiers that don't start with an attribute
922 (_sa or _nosa).
924 (d) Whether the list ends with an attribute (or a specifier such that
925 any following attribute would have been parsed as part of that specifier);
926 this avoids shift-reduce conflicts in the parsing of attributes
927 (_ea or _noea).
929 TODO:
931 (i) Distinguish between function specifiers and storage class specifiers,
932 at least for the purpose of warnings about obsolescent usage.
934 (ii) Halve the number of productions here by eliminating the _sc/_nosc
935 distinction and instead checking where required that storage class
936 specifiers aren't present. */
938 /* Declspecs which contain at least one type specifier or typedef name.
939 (Just `const' or `volatile' is not enough.)
940 A typedef'd name following these is taken as a name to be declared. */
942 declspecs_nosc_nots_nosa_noea:
943 TYPE_QUAL
944 { $$ = declspecs_add_qual (build_null_declspecs (), $1); }
945 | declspecs_nosc_nots_nosa_noea TYPE_QUAL
946 { $$ = declspecs_add_qual ($1, $2); }
947 | declspecs_nosc_nots_nosa_ea TYPE_QUAL
948 { $$ = declspecs_add_qual ($1, $2); }
949 ;
951 declspecs_nosc_nots_nosa_ea:
952 declspecs_nosc_nots_nosa_noea attributes
953 { $$ = declspecs_add_attrs ($1, $2); }
954 ;
956 declspecs_nosc_nots_sa_noea:
957 declspecs_nosc_nots_sa_noea TYPE_QUAL
958 { $$ = declspecs_add_qual ($1, $2); }
959 | declspecs_nosc_nots_sa_ea TYPE_QUAL
960 { $$ = declspecs_add_qual ($1, $2); }
961 ;
963 declspecs_nosc_nots_sa_ea:
964 attributes
965 { $$ = declspecs_add_attrs (build_null_declspecs (), $1); }
966 | declspecs_nosc_nots_sa_noea attributes
967 { $$ = declspecs_add_attrs ($1, $2); }
968 ;
970 declspecs_nosc_ts_nosa_noea:
971 typespec_nonattr
972 { $$ = declspecs_add_type (build_null_declspecs (), $1); }
973 | declspecs_nosc_ts_nosa_noea TYPE_QUAL
974 { $$ = declspecs_add_qual ($1, $2); }
975 | declspecs_nosc_ts_nosa_ea TYPE_QUAL
976 { $$ = declspecs_add_qual ($1, $2); }
977 | declspecs_nosc_ts_nosa_noea typespec_reserved_nonattr
978 { $$ = declspecs_add_type ($1, $2); }
979 | declspecs_nosc_ts_nosa_ea typespec_reserved_nonattr
980 { $$ = declspecs_add_type ($1, $2); }
981 | declspecs_nosc_nots_nosa_noea typespec_nonattr
982 { $$ = declspecs_add_type ($1, $2); }
983 | declspecs_nosc_nots_nosa_ea typespec_nonattr
984 { $$ = declspecs_add_type ($1, $2); }
985 ;
987 declspecs_nosc_ts_nosa_ea:
988 typespec_attr
989 { $$ = declspecs_add_type (build_null_declspecs (), $1); }
990 | declspecs_nosc_ts_nosa_noea attributes
991 { $$ = declspecs_add_attrs ($1, $2); }
992 | declspecs_nosc_ts_nosa_noea typespec_reserved_attr
993 { $$ = declspecs_add_type ($1, $2); }
994 | declspecs_nosc_ts_nosa_ea typespec_reserved_attr
995 { $$ = declspecs_add_type ($1, $2); }
996 | declspecs_nosc_nots_nosa_noea typespec_attr
997 { $$ = declspecs_add_type ($1, $2); }
998 | declspecs_nosc_nots_nosa_ea typespec_attr
999 { $$ = declspecs_add_type ($1, $2); }
1000 ;
1002 declspecs_nosc_ts_sa_noea:
1003 declspecs_nosc_ts_sa_noea TYPE_QUAL
1004 { $$ = declspecs_add_qual ($1, $2); }
1005 | declspecs_nosc_ts_sa_ea TYPE_QUAL
1006 { $$ = declspecs_add_qual ($1, $2); }
1007 | declspecs_nosc_ts_sa_noea typespec_reserved_nonattr
1008 { $$ = declspecs_add_type ($1, $2); }
1009 | declspecs_nosc_ts_sa_ea typespec_reserved_nonattr
1010 { $$ = declspecs_add_type ($1, $2); }
1011 | declspecs_nosc_nots_sa_noea typespec_nonattr
1012 { $$ = declspecs_add_type ($1, $2); }
1013 | declspecs_nosc_nots_sa_ea typespec_nonattr
1014 { $$ = declspecs_add_type ($1, $2); }
1015 ;
1017 declspecs_nosc_ts_sa_ea:
1018 declspecs_nosc_ts_sa_noea attributes
1019 { $$ = declspecs_add_attrs ($1, $2); }
1020 | declspecs_nosc_ts_sa_noea typespec_reserved_attr
1021 { $$ = declspecs_add_type ($1, $2); }
1022 | declspecs_nosc_ts_sa_ea typespec_reserved_attr
1023 { $$ = declspecs_add_type ($1, $2); }
1024 | declspecs_nosc_nots_sa_noea typespec_attr
1025 { $$ = declspecs_add_type ($1, $2); }
1026 | declspecs_nosc_nots_sa_ea typespec_attr
1027 { $$ = declspecs_add_type ($1, $2); }
1028 ;
1030 declspecs_sc_nots_nosa_noea:
1031 scspec
1032 { $$ = declspecs_add_scspec (build_null_declspecs (), $1); }
1033 | declspecs_sc_nots_nosa_noea TYPE_QUAL
1034 { $$ = declspecs_add_qual ($1, $2); }
1035 | declspecs_sc_nots_nosa_ea TYPE_QUAL
1036 { $$ = declspecs_add_qual ($1, $2); }
1037 | declspecs_nosc_nots_nosa_noea scspec
1038 { $$ = declspecs_add_scspec ($1, $2); }
1039 | declspecs_nosc_nots_nosa_ea scspec
1040 { $$ = declspecs_add_scspec ($1, $2); }
1041 | declspecs_sc_nots_nosa_noea scspec
1042 { $$ = declspecs_add_scspec ($1, $2); }
1043 | declspecs_sc_nots_nosa_ea scspec
1044 { $$ = declspecs_add_scspec ($1, $2); }
1045 ;
1047 declspecs_sc_nots_nosa_ea:
1048 declspecs_sc_nots_nosa_noea attributes
1049 { $$ = declspecs_add_attrs ($1, $2); }
1050 ;
1052 declspecs_sc_nots_sa_noea:
1053 declspecs_sc_nots_sa_noea TYPE_QUAL
1054 { $$ = declspecs_add_qual ($1, $2); }
1055 | declspecs_sc_nots_sa_ea TYPE_QUAL
1056 { $$ = declspecs_add_qual ($1, $2); }
1057 | declspecs_nosc_nots_sa_noea scspec
1058 { $$ = declspecs_add_scspec ($1, $2); }
1059 | declspecs_nosc_nots_sa_ea scspec
1060 { $$ = declspecs_add_scspec ($1, $2); }
1061 | declspecs_sc_nots_sa_noea scspec
1062 { $$ = declspecs_add_scspec ($1, $2); }
1063 | declspecs_sc_nots_sa_ea scspec
1064 { $$ = declspecs_add_scspec ($1, $2); }
1065 ;
1067 declspecs_sc_nots_sa_ea:
1068 declspecs_sc_nots_sa_noea attributes
1069 { $$ = declspecs_add_attrs ($1, $2); }
1070 ;
1072 declspecs_sc_ts_nosa_noea:
1073 declspecs_sc_ts_nosa_noea TYPE_QUAL
1074 { $$ = declspecs_add_qual ($1, $2); }
1075 | declspecs_sc_ts_nosa_ea TYPE_QUAL
1076 { $$ = declspecs_add_qual ($1, $2); }
1077 | declspecs_sc_ts_nosa_noea typespec_reserved_nonattr
1078 { $$ = declspecs_add_type ($1, $2); }
1079 | declspecs_sc_ts_nosa_ea typespec_reserved_nonattr
1080 { $$ = declspecs_add_type ($1, $2); }
1081 | declspecs_sc_nots_nosa_noea typespec_nonattr
1082 { $$ = declspecs_add_type ($1, $2); }
1083 | declspecs_sc_nots_nosa_ea typespec_nonattr
1084 { $$ = declspecs_add_type ($1, $2); }
1085 | declspecs_nosc_ts_nosa_noea scspec
1086 { $$ = declspecs_add_scspec ($1, $2); }
1087 | declspecs_nosc_ts_nosa_ea scspec
1088 { $$ = declspecs_add_scspec ($1, $2); }
1089 | declspecs_sc_ts_nosa_noea scspec
1090 { $$ = declspecs_add_scspec ($1, $2); }
1091 | declspecs_sc_ts_nosa_ea scspec
1092 { $$ = declspecs_add_scspec ($1, $2); }
1093 ;
1095 declspecs_sc_ts_nosa_ea:
1096 declspecs_sc_ts_nosa_noea attributes
1097 { $$ = declspecs_add_attrs ($1, $2); }
1098 | declspecs_sc_ts_nosa_noea typespec_reserved_attr
1099 { $$ = declspecs_add_type ($1, $2); }
1100 | declspecs_sc_ts_nosa_ea typespec_reserved_attr
1101 { $$ = declspecs_add_type ($1, $2); }
1102 | declspecs_sc_nots_nosa_noea typespec_attr
1103 { $$ = declspecs_add_type ($1, $2); }
1104 | declspecs_sc_nots_nosa_ea typespec_attr
1105 { $$ = declspecs_add_type ($1, $2); }
1106 ;
1108 declspecs_sc_ts_sa_noea:
1109 declspecs_sc_ts_sa_noea TYPE_QUAL
1110 { $$ = declspecs_add_qual ($1, $2); }
1111 | declspecs_sc_ts_sa_ea TYPE_QUAL
1112 { $$ = declspecs_add_qual ($1, $2); }
1113 | declspecs_sc_ts_sa_noea typespec_reserved_nonattr
1114 { $$ = declspecs_add_type ($1, $2); }
1115 | declspecs_sc_ts_sa_ea typespec_reserved_nonattr
1116 { $$ = declspecs_add_type ($1, $2); }
1117 | declspecs_sc_nots_sa_noea typespec_nonattr
1118 { $$ = declspecs_add_type ($1, $2); }
1119 | declspecs_sc_nots_sa_ea typespec_nonattr
1120 { $$ = declspecs_add_type ($1, $2); }
1121 | declspecs_nosc_ts_sa_noea scspec
1122 { $$ = declspecs_add_scspec ($1, $2); }
1123 | declspecs_nosc_ts_sa_ea scspec
1124 { $$ = declspecs_add_scspec ($1, $2); }
1125 | declspecs_sc_ts_sa_noea scspec
1126 { $$ = declspecs_add_scspec ($1, $2); }
1127 | declspecs_sc_ts_sa_ea scspec
1128 { $$ = declspecs_add_scspec ($1, $2); }
1129 ;
1131 declspecs_sc_ts_sa_ea:
1132 declspecs_sc_ts_sa_noea attributes
1133 { $$ = declspecs_add_attrs ($1, $2); }
1134 | declspecs_sc_ts_sa_noea typespec_reserved_attr
1135 { $$ = declspecs_add_type ($1, $2); }
1136 | declspecs_sc_ts_sa_ea typespec_reserved_attr
1137 { $$ = declspecs_add_type ($1, $2); }
1138 | declspecs_sc_nots_sa_noea typespec_attr
1139 { $$ = declspecs_add_type ($1, $2); }
1140 | declspecs_sc_nots_sa_ea typespec_attr
1141 { $$ = declspecs_add_type ($1, $2); }
1142 ;
1144 /* Particular useful classes of declspecs. */
1145 declspecs_ts:
1146 declspecs_nosc_ts_nosa_noea
1147 | declspecs_nosc_ts_nosa_ea
1148 | declspecs_nosc_ts_sa_noea
1149 | declspecs_nosc_ts_sa_ea
1150 | declspecs_sc_ts_nosa_noea
1151 | declspecs_sc_ts_nosa_ea
1152 | declspecs_sc_ts_sa_noea
1153 | declspecs_sc_ts_sa_ea
1154 ;
1156 declspecs_nots:
1157 declspecs_nosc_nots_nosa_noea
1158 | declspecs_nosc_nots_nosa_ea
1159 | declspecs_nosc_nots_sa_noea
1160 | declspecs_nosc_nots_sa_ea
1161 | declspecs_sc_nots_nosa_noea
1162 | declspecs_sc_nots_nosa_ea
1163 | declspecs_sc_nots_sa_noea
1164 | declspecs_sc_nots_sa_ea
1165 ;
1167 declspecs_ts_nosa:
1168 declspecs_nosc_ts_nosa_noea
1169 | declspecs_nosc_ts_nosa_ea
1170 | declspecs_sc_ts_nosa_noea
1171 | declspecs_sc_ts_nosa_ea
1172 ;
1174 declspecs_nots_nosa:
1175 declspecs_nosc_nots_nosa_noea
1176 | declspecs_nosc_nots_nosa_ea
1177 | declspecs_sc_nots_nosa_noea
1178 | declspecs_sc_nots_nosa_ea
1179 ;
1181 declspecs_nosc_ts:
1182 declspecs_nosc_ts_nosa_noea
1183 | declspecs_nosc_ts_nosa_ea
1184 | declspecs_nosc_ts_sa_noea
1185 | declspecs_nosc_ts_sa_ea
1186 ;
1188 declspecs_nosc_nots:
1189 declspecs_nosc_nots_nosa_noea
1190 | declspecs_nosc_nots_nosa_ea
1191 | declspecs_nosc_nots_sa_noea
1192 | declspecs_nosc_nots_sa_ea
1193 ;
1195 declspecs_nosc:
1196 declspecs_nosc_ts_nosa_noea
1197 | declspecs_nosc_ts_nosa_ea
1198 | declspecs_nosc_ts_sa_noea
1199 | declspecs_nosc_ts_sa_ea
1200 | declspecs_nosc_nots_nosa_noea
1201 | declspecs_nosc_nots_nosa_ea
1202 | declspecs_nosc_nots_sa_noea
1203 | declspecs_nosc_nots_sa_ea
1204 ;
1206 declspecs:
1207 declspecs_nosc_nots_nosa_noea
1208 | declspecs_nosc_nots_nosa_ea
1209 | declspecs_nosc_nots_sa_noea
1210 | declspecs_nosc_nots_sa_ea
1211 | declspecs_nosc_ts_nosa_noea
1212 | declspecs_nosc_ts_nosa_ea
1213 | declspecs_nosc_ts_sa_noea
1214 | declspecs_nosc_ts_sa_ea
1215 | declspecs_sc_nots_nosa_noea
1216 | declspecs_sc_nots_nosa_ea
1217 | declspecs_sc_nots_sa_noea
1218 | declspecs_sc_nots_sa_ea
1219 | declspecs_sc_ts_nosa_noea
1220 | declspecs_sc_ts_nosa_ea
1221 | declspecs_sc_ts_sa_noea
1222 | declspecs_sc_ts_sa_ea
1223 ;
1225 /* A (possibly empty) sequence of type qualifiers and attributes. */
1226 maybe_type_quals_attrs:
1227 /* empty */
1228 { $$ = NULL; }
1229 | declspecs_nosc_nots
1230 { $$ = $1; }
1231 ;
1233 /* A type specifier (but not a type qualifier).
1234 Once we have seen one of these in a declaration,
1235 if a typedef name appears then it is being redeclared.
1237 The _reserved versions start with a reserved word and may appear anywhere
1238 in the declaration specifiers; the _nonreserved versions may only
1239 appear before any other type specifiers, and after that are (if names)
1240 being redeclared.
1242 FIXME: should the _nonreserved version be restricted to names being
1243 redeclared only? The other entries there relate only the GNU extensions
1244 and Objective C, and are historically parsed thus, and don't make sense
1245 after other type specifiers, but it might be cleaner to count them as
1246 _reserved.
1248 _attr means: specifiers that either end with attributes,
1249 or are such that any following attributes would
1250 be parsed as part of the specifier.
1252 _nonattr: other specifiers not ending with attributes. */
1254 typespec_nonattr:
1255 typespec_reserved_nonattr
1256 | typespec_nonreserved_nonattr
1257 ;
1259 typespec_attr:
1260 typespec_reserved_attr
1261 ;
1263 typespec_reserved_nonattr:
1264 TYPESPEC
1265 { OBJC_NEED_RAW_IDENTIFIER (1); }
1266 | structsp_nonattr
1267 ;
1269 typespec_reserved_attr:
1270 structsp_attr
1271 ;
1273 typespec_nonreserved_nonattr:
1274 TYPENAME
1275 { /* For a typedef name, record the meaning, not the name.
1276 In case of `foo foo, bar;'. */
1277 $$ = lookup_name ($1); }
1278 @@ifobjc
1279 | CLASSNAME protocolrefs
1280 { $$ = objc_get_protocol_qualified_type ($1, $2); }
1281 | OBJECTNAME protocolrefs
1282 { $$ = objc_get_protocol_qualified_type ($1, $2); }
1284 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>"
1285 - nisse@lysator.liu.se */
1286 | non_empty_protocolrefs
1287 { $$ = objc_get_protocol_qualified_type (NULL_TREE, $1); }
1288 @@end_ifobjc
1289 | typeof '(' expr ')'
1290 { skip_evaluation--;
1291 in_typeof--;
1292 if (TREE_CODE ($3.value) == COMPONENT_REF
1293 && DECL_C_BIT_FIELD (TREE_OPERAND ($3.value, 1)))
1294 error ("%<typeof%> applied to a bit-field");
1295 $$ = TREE_TYPE ($3.value);
1296 pop_maybe_used (variably_modified_type_p ($$, NULL_TREE)); }
1297 | typeof '(' typename ')'
1298 { skip_evaluation--; in_typeof--; $$ = groktypename ($3);
1299 pop_maybe_used (variably_modified_type_p ($$, NULL_TREE)); }
1300 ;
1302 /* typespec_nonreserved_attr does not exist. */
1304 initdecls:
1305 initdcl
1306 | initdecls ',' maybe_resetattrs initdcl
1307 ;
1309 notype_initdecls:
1310 notype_initdcl
1311 | notype_initdecls ',' maybe_resetattrs notype_initdcl
1312 ;
1314 initdcl:
1315 declarator maybeasm maybe_attribute '='
1316 { $<ttype>$ = start_decl ($1, current_declspecs, true,
1317 chainon ($3, all_prefix_attributes));
1318 start_init ($<ttype>$, $2, global_bindings_p ()); }
1319 init
1320 /* Note how the declaration of the variable is in effect while its init is parsed! */
1321 { finish_init ();
1322 maybe_warn_string_init (TREE_TYPE ($<ttype>5), $6);
1323 finish_decl ($<ttype>5, $6.value, $2); }
1324 | declarator maybeasm maybe_attribute
1325 { tree d = start_decl ($1, current_declspecs, false,
1326 chainon ($3, all_prefix_attributes));
1327 finish_decl (d, NULL_TREE, $2);
1328 }
1329 ;
1331 notype_initdcl:
1332 notype_declarator maybeasm maybe_attribute '='
1333 { $<ttype>$ = start_decl ($1, current_declspecs, true,
1334 chainon ($3, all_prefix_attributes));
1335 start_init ($<ttype>$, $2, global_bindings_p ()); }
1336 init
1337 /* Note how the declaration of the variable is in effect while its init is parsed! */
1338 { finish_init ();
1339 maybe_warn_string_init (TREE_TYPE ($<ttype>5), $6);
1340 finish_decl ($<ttype>5, $6.value, $2); }
1341 | notype_declarator maybeasm maybe_attribute
1342 { tree d = start_decl ($1, current_declspecs, false,
1343 chainon ($3, all_prefix_attributes));
1344 finish_decl (d, NULL_TREE, $2); }
1345 ;
1346 /* the * rules are dummies to accept the Apollo extended syntax
1347 so that the header files compile. */
1348 maybe_attribute:
1349 /* empty */
1350 { $$ = NULL_TREE; }
1351 | attributes
1352 { $$ = $1; }
1353 ;
1355 attributes:
1356 attribute
1357 { $$ = $1; }
1358 | attributes attribute
1359 { $$ = chainon ($1, $2); }
1360 ;
1362 attribute:
1363 ATTRIBUTE stop_string_translation
1364 '(' '(' attribute_list ')' ')' start_string_translation
1365 { $$ = $5; }
1366 | ATTRIBUTE error start_string_translation
1367 { $$ = NULL_TREE; }
1368 ;
1370 attribute_list:
1371 attrib
1372 { $$ = $1; }
1373 | attribute_list ',' attrib
1374 { $$ = chainon ($1, $3); }
1375 ;
1377 attrib:
1378 /* empty */
1379 { $$ = NULL_TREE; }
1380 | any_word
1381 { $$ = build_tree_list ($1, NULL_TREE); }
1382 | any_word '(' IDENTIFIER ')'
1383 { $$ = build_tree_list ($1, build_tree_list (NULL_TREE, $3)); }
1384 | any_word '(' IDENTIFIER ',' nonnull_exprlist ')'
1385 { $$ = build_tree_list ($1, tree_cons (NULL_TREE, $3, $5)); }
1386 | any_word '(' exprlist ')'
1387 { $$ = build_tree_list ($1, $3); }
1388 ;
1390 /* This still leaves out most reserved keywords,
1391 shouldn't we include them? */
1393 any_word:
1394 identifier
1395 | scspec
1396 | TYPESPEC
1397 | TYPE_QUAL
1398 ;
1400 scspec:
1401 STATIC
1402 | SCSPEC
1403 ;
1404 \f
1405 /* Initializers. `init' is the entry point. */
1407 init:
1408 expr_no_commas
1409 { $$ = $1; }
1410 | '{'
1411 { really_start_incremental_init (NULL_TREE); }
1412 initlist_maybe_comma '}'
1413 { $$ = pop_init_level (0); }
1414 | error
1415 { $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
1416 ;
1418 /* `initlist_maybe_comma' is the guts of an initializer in braces. */
1419 initlist_maybe_comma:
1420 /* empty */
1421 { if (pedantic)
1422 pedwarn ("ISO C forbids empty initializer braces"); }
1423 | initlist1 maybecomma
1424 ;
1426 initlist1:
1427 initelt
1428 | initlist1 ',' initelt
1429 ;
1431 /* `initelt' is a single element of an initializer.
1432 It may use braces. */
1433 initelt:
1434 designator_list '=' initval
1435 { if (pedantic && !flag_isoc99)
1436 pedwarn ("ISO C90 forbids specifying subobject to initialize"); }
1437 | designator initval
1438 { if (pedantic)
1439 pedwarn ("obsolete use of designated initializer without %<=%>"); }
1440 | identifier ':'
1441 { set_init_label ($1);
1442 if (pedantic)
1443 pedwarn ("obsolete use of designated initializer with %<:%>"); }
1444 initval
1445 {}
1446 | initval
1447 ;
1449 initval:
1450 '{'
1451 { push_init_level (0); }
1452 initlist_maybe_comma '}'
1453 { process_init_element (pop_init_level (0)); }
1454 | expr_no_commas
1455 { process_init_element ($1); }
1456 | error
1457 ;
1459 designator_list:
1460 designator
1461 | designator_list designator
1462 ;
1464 designator:
1465 '.' identifier
1466 { set_init_label ($2); }
1467 | '[' expr_no_commas ELLIPSIS expr_no_commas ']'
1468 { set_init_index ($2.value, $4.value);
1469 if (pedantic)
1470 pedwarn ("ISO C forbids specifying range of elements to initialize"); }
1471 | '[' expr_no_commas ']'
1472 { set_init_index ($2.value, NULL_TREE); }
1473 ;
1474 \f
1475 nested_function:
1476 declarator
1477 { if (pedantic)
1478 pedwarn ("ISO C forbids nested functions");
1480 push_function_context ();
1481 if (!start_function (current_declspecs, $1,
1482 all_prefix_attributes))
1483 {
1484 pop_function_context ();
1485 YYERROR1;
1486 }
1487 }
1488 old_style_parm_decls save_location
1489 { tree decl = current_function_decl;
1490 DECL_SOURCE_LOCATION (decl) = $4;
1491 store_parm_decls (); }
1492 /* This used to use compstmt_or_error. That caused a bug with
1493 input `f(g) int g {}', where the use of YYERROR1 above caused
1494 an error which then was handled by compstmt_or_error. There
1495 followed a repeated execution of that same rule, which called
1496 YYERROR1 again, and so on. */
1497 compstmt
1498 { tree decl = current_function_decl;
1499 add_stmt ($6);
1500 finish_function ();
1501 pop_function_context ();
1502 add_stmt (build_stmt (DECL_EXPR, decl)); }
1503 ;
1505 notype_nested_function:
1506 notype_declarator
1507 { if (pedantic)
1508 pedwarn ("ISO C forbids nested functions");
1510 push_function_context ();
1511 if (!start_function (current_declspecs, $1,
1512 all_prefix_attributes))
1513 {
1514 pop_function_context ();
1515 YYERROR1;
1516 }
1517 }
1518 old_style_parm_decls save_location
1519 { tree decl = current_function_decl;
1520 DECL_SOURCE_LOCATION (decl) = $4;
1521 store_parm_decls (); }
1522 /* This used to use compstmt_or_error. That caused a bug with
1523 input `f(g) int g {}', where the use of YYERROR1 above caused
1524 an error which then was handled by compstmt_or_error. There
1525 followed a repeated execution of that same rule, which called
1526 YYERROR1 again, and so on. */
1527 compstmt
1528 { tree decl = current_function_decl;
1529 add_stmt ($6);
1530 finish_function ();
1531 pop_function_context ();
1532 add_stmt (build_stmt (DECL_EXPR, decl)); }
1533 ;
1535 /* Any kind of declarator (thus, all declarators allowed
1536 after an explicit typespec). */
1538 declarator:
1539 after_type_declarator
1540 | notype_declarator
1541 ;
1543 /* A declarator that is allowed only after an explicit typespec. */
1545 after_type_declarator:
1546 '(' maybe_attribute after_type_declarator ')'
1547 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1548 | after_type_declarator '(' parmlist_or_identifiers %prec '.'
1549 { $$ = build_function_declarator ($3, $1); }
1550 | after_type_declarator array_declarator %prec '.'
1551 { $$ = set_array_declarator_inner ($2, $1, false); }
1552 | '*' maybe_type_quals_attrs after_type_declarator %prec UNARY
1553 { $$ = make_pointer_declarator ($2, $3); }
1554 | TYPENAME
1555 { $$ = build_id_declarator ($1); }
1556 @@ifobjc
1557 | OBJECTNAME
1558 { $$ = build_id_declarator ($1); }
1559 @@end_ifobjc
1560 ;
1562 /* Kinds of declarator that can appear in a parameter list
1563 in addition to notype_declarator. This is like after_type_declarator
1564 but does not allow a typedef name in parentheses as an identifier
1565 (because it would conflict with a function with that typedef as arg). */
1566 parm_declarator:
1567 parm_declarator_starttypename
1568 | parm_declarator_nostarttypename
1569 ;
1571 parm_declarator_starttypename:
1572 parm_declarator_starttypename '(' parmlist_or_identifiers %prec '.'
1573 { $$ = build_function_declarator ($3, $1); }
1574 | parm_declarator_starttypename array_declarator %prec '.'
1575 { $$ = set_array_declarator_inner ($2, $1, false); }
1576 | TYPENAME
1577 { $$ = build_id_declarator ($1); }
1578 @@ifobjc
1579 | OBJECTNAME
1580 { $$ = build_id_declarator ($1); }
1581 @@end_ifobjc
1582 ;
1584 parm_declarator_nostarttypename:
1585 parm_declarator_nostarttypename '(' parmlist_or_identifiers %prec '.'
1586 { $$ = build_function_declarator ($3, $1); }
1587 | parm_declarator_nostarttypename array_declarator %prec '.'
1588 { $$ = set_array_declarator_inner ($2, $1, false); }
1589 | '*' maybe_type_quals_attrs parm_declarator_starttypename %prec UNARY
1590 { $$ = make_pointer_declarator ($2, $3); }
1591 | '*' maybe_type_quals_attrs parm_declarator_nostarttypename %prec UNARY
1592 { $$ = make_pointer_declarator ($2, $3); }
1593 | '(' maybe_attribute parm_declarator_nostarttypename ')'
1594 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1595 ;
1597 /* A declarator allowed whether or not there has been
1598 an explicit typespec. These cannot redeclare a typedef-name. */
1600 notype_declarator:
1601 notype_declarator '(' parmlist_or_identifiers %prec '.'
1602 { $$ = build_function_declarator ($3, $1); }
1603 | '(' maybe_attribute notype_declarator ')'
1604 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1605 | '*' maybe_type_quals_attrs notype_declarator %prec UNARY
1606 { $$ = make_pointer_declarator ($2, $3); }
1607 | notype_declarator array_declarator %prec '.'
1608 { $$ = set_array_declarator_inner ($2, $1, false); }
1609 | IDENTIFIER
1610 { $$ = build_id_declarator ($1); }
1611 ;
1613 struct_head:
1614 STRUCT
1615 { $$ = NULL_TREE; }
1616 | STRUCT attributes
1617 { $$ = $2; }
1618 ;
1620 union_head:
1621 UNION
1622 { $$ = NULL_TREE; }
1623 | UNION attributes
1624 { $$ = $2; }
1625 ;
1627 enum_head:
1628 ENUM
1629 { $$ = NULL_TREE; }
1630 | ENUM attributes
1631 { $$ = $2; }
1632 ;
1634 /* structsp_attr: struct/union/enum specifiers that either
1635 end with attributes, or are such that any following attributes would
1636 be parsed as part of the struct/union/enum specifier.
1638 structsp_nonattr: other struct/union/enum specifiers. */
1640 structsp_attr:
1641 struct_head identifier '{'
1642 { $$ = start_struct (RECORD_TYPE, $2);
1643 /* Start scope of tag before parsing components. */
1644 }
1645 component_decl_list '}' maybe_attribute
1646 { $$ = finish_struct ($<ttype>4, nreverse ($5),
1647 chainon ($1, $7)); }
1648 | struct_head '{' component_decl_list '}' maybe_attribute
1649 { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
1650 nreverse ($3), chainon ($1, $5));
1651 }
1652 | union_head identifier '{'
1653 { $$ = start_struct (UNION_TYPE, $2); }
1654 component_decl_list '}' maybe_attribute
1655 { $$ = finish_struct ($<ttype>4, nreverse ($5),
1656 chainon ($1, $7)); }
1657 | union_head '{' component_decl_list '}' maybe_attribute
1658 { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
1659 nreverse ($3), chainon ($1, $5));
1660 }
1661 | enum_head identifier '{'
1662 { $$ = start_enum ($2); }
1663 enumlist maybecomma_warn '}' maybe_attribute
1664 { $$ = finish_enum ($<ttype>4, nreverse ($5),
1665 chainon ($1, $8)); }
1666 | enum_head '{'
1667 { $$ = start_enum (NULL_TREE); }
1668 enumlist maybecomma_warn '}' maybe_attribute
1669 { $$ = finish_enum ($<ttype>3, nreverse ($4),
1670 chainon ($1, $7)); }
1671 ;
1673 structsp_nonattr:
1674 struct_head identifier
1675 { $$ = xref_tag (RECORD_TYPE, $2); }
1676 | union_head identifier
1677 { $$ = xref_tag (UNION_TYPE, $2); }
1678 | enum_head identifier
1679 { $$ = xref_tag (ENUMERAL_TYPE, $2);
1680 /* In ISO C, enumerated types can be referred to
1681 only if already defined. */
1682 if (pedantic && !COMPLETE_TYPE_P ($$))
1683 pedwarn ("ISO C forbids forward references to %<enum%> types"); }
1684 ;
1686 maybecomma:
1687 /* empty */
1688 | ','
1689 ;
1691 maybecomma_warn:
1692 /* empty */
1693 | ','
1694 { if (pedantic && !flag_isoc99)
1695 pedwarn ("comma at end of enumerator list"); }
1696 ;
1698 /* We chain the components in reverse order. They are put in forward
1699 order in structsp_attr.
1701 Note that component_declarator returns single decls, so components
1702 and components_notype can use TREE_CHAIN directly, wheras components
1703 and components_notype return lists (of comma separated decls), so
1704 component_decl_list and component_decl_list2 must use chainon.
1706 The theory behind all this is that there will be more semicolon
1707 separated fields than comma separated fields, and so we'll be
1708 minimizing the number of node traversals required by chainon. */
1710 component_decl_list:
1711 component_decl_list2
1712 { $$ = $1; }
1713 | component_decl_list2 component_decl
1714 { $$ = chainon ($2, $1);
1715 pedwarn ("no semicolon at end of struct or union"); }
1716 ;
1718 component_decl_list2: /* empty */
1719 { $$ = NULL_TREE; }
1720 | component_decl_list2 component_decl ';'
1721 { $$ = chainon ($2, $1); }
1722 | component_decl_list2 ';'
1723 { if (pedantic)
1724 pedwarn ("extra semicolon in struct or union specified"); }
1725 @@ifobjc
1726 /* foo(sizeof(struct{ @defs(ClassName)})); */
1727 | AT_DEFS '(' CLASSNAME ')'
1728 { $$ = nreverse (objc_get_class_ivars ($3)); }
1729 @@end_ifobjc
1730 ;
1732 component_decl:
1733 declspecs_nosc_ts setspecs components
1734 { $$ = $3;
1735 POP_DECLSPEC_STACK; }
1736 | declspecs_nosc_ts setspecs
1737 {
1738 /* Support for unnamed structs or unions as members of
1739 structs or unions (which is [a] useful and [b] supports
1740 MS P-SDK). */
1741 $$ = grokfield (build_id_declarator (NULL_TREE),
1742 current_declspecs, NULL_TREE);
1743 POP_DECLSPEC_STACK; }
1744 | declspecs_nosc_nots setspecs components_notype
1745 { $$ = $3;
1746 POP_DECLSPEC_STACK; }
1747 | declspecs_nosc_nots
1748 { if (pedantic)
1749 pedwarn ("ISO C forbids member declarations with no members");
1750 shadow_tag_warned (finish_declspecs ($1), pedantic);
1751 $$ = NULL_TREE; }
1752 | error
1753 { $$ = NULL_TREE; }
1754 | extension component_decl
1755 { $$ = $2;
1756 RESTORE_EXT_FLAGS ($1); }
1757 ;
1759 components:
1760 component_declarator
1761 | components ',' maybe_resetattrs component_declarator
1762 { TREE_CHAIN ($4) = $1; $$ = $4; }
1763 ;
1765 components_notype:
1766 component_notype_declarator
1767 | components_notype ',' maybe_resetattrs component_notype_declarator
1768 { TREE_CHAIN ($4) = $1; $$ = $4; }
1769 ;
1771 component_declarator:
1772 declarator maybe_attribute
1773 { $$ = grokfield ($1, current_declspecs, NULL_TREE);
1774 decl_attributes (&$$,
1775 chainon ($2, all_prefix_attributes), 0); }
1776 | declarator ':' expr_no_commas maybe_attribute
1777 { $$ = grokfield ($1, current_declspecs, $3.value);
1778 decl_attributes (&$$,
1779 chainon ($4, all_prefix_attributes), 0); }
1780 | ':' expr_no_commas maybe_attribute
1781 { $$ = grokfield (build_id_declarator (NULL_TREE),
1782 current_declspecs, $2.value);
1783 decl_attributes (&$$,
1784 chainon ($3, all_prefix_attributes), 0); }
1785 ;
1787 component_notype_declarator:
1788 notype_declarator maybe_attribute
1789 { $$ = grokfield ($1, current_declspecs, NULL_TREE);
1790 decl_attributes (&$$,
1791 chainon ($2, all_prefix_attributes), 0); }
1792 | notype_declarator ':' expr_no_commas maybe_attribute
1793 { $$ = grokfield ($1, current_declspecs, $3.value);
1794 decl_attributes (&$$,
1795 chainon ($4, all_prefix_attributes), 0); }
1796 | ':' expr_no_commas maybe_attribute
1797 { $$ = grokfield (build_id_declarator (NULL_TREE),
1798 current_declspecs, $2.value);
1799 decl_attributes (&$$,
1800 chainon ($3, all_prefix_attributes), 0); }
1801 ;
1803 /* We chain the enumerators in reverse order.
1804 They are put in forward order in structsp_attr. */
1806 enumlist:
1807 enumerator
1808 | enumlist ',' enumerator
1809 { if ($1 == error_mark_node)
1810 $$ = $1;
1811 else
1812 TREE_CHAIN ($3) = $1, $$ = $3; }
1813 | error
1814 { $$ = error_mark_node; }
1815 ;
1818 enumerator:
1819 identifier
1820 { $$ = build_enumerator ($1, NULL_TREE); }
1821 | identifier '=' expr_no_commas
1822 { $$ = build_enumerator ($1, $3.value); }
1823 ;
1825 typename:
1826 declspecs_nosc
1827 { pending_xref_error ();
1828 $<dsptype>$ = finish_declspecs ($1); }
1829 absdcl
1830 { $$ = XOBNEW (&parser_obstack, struct c_type_name);
1831 $$->specs = $<dsptype>2;
1832 $$->declarator = $3; }
1833 ;
1835 absdcl: /* an absolute declarator */
1836 /* empty */
1837 { $$ = build_id_declarator (NULL_TREE); }
1838 | absdcl1
1839 ;
1841 absdcl_maybe_attribute: /* absdcl maybe_attribute, but not just attributes */
1842 /* empty */
1843 { $$ = build_c_parm (current_declspecs, all_prefix_attributes,
1844 build_id_declarator (NULL_TREE)); }
1845 | absdcl1
1846 { $$ = build_c_parm (current_declspecs, all_prefix_attributes,
1847 $1); }
1848 | absdcl1_noea attributes
1849 { $$ = build_c_parm (current_declspecs,
1850 chainon ($2, all_prefix_attributes),
1851 $1); }
1852 ;
1854 absdcl1: /* a nonempty absolute declarator */
1855 absdcl1_ea
1856 | absdcl1_noea
1857 ;
1859 absdcl1_noea:
1860 direct_absdcl1
1861 | '*' maybe_type_quals_attrs absdcl1_noea
1862 { $$ = make_pointer_declarator ($2, $3); }
1863 ;
1865 absdcl1_ea:
1866 '*' maybe_type_quals_attrs
1867 { $$ = make_pointer_declarator
1868 ($2, build_id_declarator (NULL_TREE)); }
1869 | '*' maybe_type_quals_attrs absdcl1_ea
1870 { $$ = make_pointer_declarator ($2, $3); }
1871 ;
1873 direct_absdcl1:
1874 '(' maybe_attribute absdcl1 ')'
1875 { $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
1876 | direct_absdcl1 '(' parmlist
1877 { $$ = build_function_declarator ($3, $1); }
1878 | direct_absdcl1 array_declarator
1879 { $$ = set_array_declarator_inner ($2, $1, true); }
1880 | '(' parmlist
1881 { $$ = build_function_declarator
1882 ($2, build_id_declarator (NULL_TREE)); }
1883 | array_declarator
1884 { $$ = set_array_declarator_inner
1885 ($1, build_id_declarator (NULL_TREE), true); }
1886 ;
1888 /* The [...] part of a declarator for an array type. */
1890 array_declarator:
1891 '[' maybe_type_quals_attrs expr_no_commas ']'
1892 { $$ = build_array_declarator ($3.value, $2, false, false); }
1893 | '[' maybe_type_quals_attrs ']'
1894 { $$ = build_array_declarator (NULL_TREE, $2, false, false); }
1895 | '[' maybe_type_quals_attrs '*' ']'
1896 { $$ = build_array_declarator (NULL_TREE, $2, false, true); }
1897 | '[' STATIC maybe_type_quals_attrs expr_no_commas ']'
1898 { $$ = build_array_declarator ($4.value, $3, true, false); }
1899 /* declspecs_nosc_nots is a synonym for type_quals_attrs. */
1900 | '[' declspecs_nosc_nots STATIC expr_no_commas ']'
1901 { $$ = build_array_declarator ($4.value, $2, true, false); }
1902 ;
1904 /* A nonempty series of declarations and statements (possibly followed by
1905 some labels) that can form the body of a compound statement.
1906 NOTE: we don't allow labels on declarations; this might seem like a
1907 natural extension, but there would be a conflict between attributes
1908 on the label and prefix attributes on the declaration. */
1910 stmts_and_decls:
1911 lineno_stmt_decl_or_labels_ending_stmt
1912 | lineno_stmt_decl_or_labels_ending_decl
1913 | lineno_stmt_decl_or_labels_ending_label
1914 {
1915 error ("label at end of compound statement");
1916 }
1917 | lineno_stmt_decl_or_labels_ending_error
1918 ;
1920 lineno_stmt_decl_or_labels_ending_stmt:
1921 lineno_stmt
1922 | lineno_stmt_decl_or_labels_ending_stmt lineno_stmt
1923 | lineno_stmt_decl_or_labels_ending_decl lineno_stmt
1924 | lineno_stmt_decl_or_labels_ending_label lineno_stmt
1925 | lineno_stmt_decl_or_labels_ending_error lineno_stmt
1926 ;
1928 lineno_stmt_decl_or_labels_ending_decl:
1929 lineno_decl
1930 | lineno_stmt_decl_or_labels_ending_stmt lineno_decl
1931 {
1932 if ((pedantic && !flag_isoc99)
1933 || warn_declaration_after_statement)
1934 pedwarn_c90 ("ISO C90 forbids mixed declarations and code");
1935 }
1936 | lineno_stmt_decl_or_labels_ending_decl lineno_decl
1937 | lineno_stmt_decl_or_labels_ending_error lineno_decl
1938 ;
1940 lineno_stmt_decl_or_labels_ending_label:
1941 lineno_label
1942 | lineno_stmt_decl_or_labels_ending_stmt lineno_label
1943 | lineno_stmt_decl_or_labels_ending_decl lineno_label
1944 | lineno_stmt_decl_or_labels_ending_label lineno_label
1945 | lineno_stmt_decl_or_labels_ending_error lineno_label
1946 ;
1948 lineno_stmt_decl_or_labels_ending_error:
1949 errstmt
1950 | lineno_stmt_decl_or_labels errstmt
1951 ;
1953 lineno_stmt_decl_or_labels:
1954 lineno_stmt_decl_or_labels_ending_stmt
1955 | lineno_stmt_decl_or_labels_ending_decl
1956 | lineno_stmt_decl_or_labels_ending_label
1957 | lineno_stmt_decl_or_labels_ending_error
1958 ;
1960 errstmt: error ';'
1961 ;
1963 /* Start and end blocks created for the new scopes of C99. */
1964 c99_block_start: /* empty */
1965 { $$ = c_begin_compound_stmt (flag_isoc99); }
1966 ;
1968 /* Read zero or more forward-declarations for labels
1969 that nested functions can jump to. */
1970 maybe_label_decls:
1971 /* empty */
1972 | label_decls
1973 { if (pedantic)
1974 pedwarn ("ISO C forbids label declarations"); }
1975 ;
1977 label_decls:
1978 label_decl
1979 | label_decls label_decl
1980 ;
1982 label_decl:
1983 LABEL identifiers_or_typenames ';'
1984 { tree link;
1985 for (link = $2; link; link = TREE_CHAIN (link))
1986 {
1987 tree label = declare_label (TREE_VALUE (link));
1988 C_DECLARED_LABEL_FLAG (label) = 1;
1989 add_stmt (build_stmt (DECL_EXPR, label));
1990 }
1991 }
1992 ;
1994 /* This is the body of a function definition.
1995 It causes syntax errors to ignore to the next openbrace. */
1996 compstmt_or_error:
1997 compstmt
1998 { add_stmt ($1); }
1999 | error compstmt
2000 ;
2002 compstmt_start: '{' { $$ = c_begin_compound_stmt (true); }
2003 ;
2005 compstmt_nostart: '}'
2006 | maybe_label_decls compstmt_contents_nonempty '}'
2007 ;
2009 compstmt_contents_nonempty:
2010 stmts_and_decls
2011 | error
2012 ;
2014 compstmt_primary_start:
2015 '(' '{'
2016 { if (current_function_decl == 0)
2017 {
2018 error ("braced-group within expression allowed "
2019 "only inside a function");
2020 YYERROR;
2021 }
2022 $$ = c_begin_stmt_expr ();
2023 }
2024 ;
2026 compstmt: compstmt_start compstmt_nostart
2027 { $$ = c_end_compound_stmt ($1, true); }
2028 ;
2030 /* The forced readahead in here is because we might be at the end of a
2031 line, and the line and file won't be bumped until yylex absorbs the
2032 first token on the next line. */
2034 save_location:
2035 { if (yychar == YYEMPTY)
2036 yychar = YYLEX;
2037 $$ = input_location; }
2038 ;
2040 lineno_labels:
2041 /* empty */
2042 | lineno_labels lineno_label
2043 ;
2045 /* A labeled statement. In C99 it also generates an implicit block. */
2046 c99_block_lineno_labeled_stmt:
2047 c99_block_start lineno_labels lineno_stmt
2048 { $$ = c_end_compound_stmt ($1, flag_isoc99); }
2049 ;
2051 lineno_stmt:
2052 save_location stmt
2053 {
2054 /* Two cases cannot and do not have line numbers associated:
2055 If stmt is degenerate, such as "2;", then stmt is an
2056 INTEGER_CST, which cannot hold line numbers. But that's
2057 ok because the statement will either be changed to a
2058 MODIFY_EXPR during gimplification of the statement expr,
2059 or discarded. If stmt was compound, but without new
2060 variables, we will have skipped the creation of a BIND
2061 and will have a bare STATEMENT_LIST. But that's ok
2062 because (recursively) all of the component statments
2063 should already have line numbers assigned. */
2064 if ($2 && EXPR_P ($2))
2065 SET_EXPR_LOCATION ($2, $1);
2066 }
2067 ;
2069 lineno_label:
2070 save_location label
2071 { if ($2) SET_EXPR_LOCATION ($2, $1); }
2072 ;
2074 condition: save_location expr
2075 { $$ = lang_hooks.truthvalue_conversion ($2.value);
2076 if (EXPR_P ($$))
2077 SET_EXPR_LOCATION ($$, $1); }
2078 ;
2080 /* Implement -Wparenthesis by special casing IF statement directly nested
2081 within IF statement. This requires some amount of duplication of the
2082 productions under c99_block_lineno_labeled_stmt in order to work out.
2083 But it's still likely more maintainable than lots of state outside the
2084 parser... */
2086 if_statement_1:
2087 c99_block_start lineno_labels if_statement
2088 { $$ = c_end_compound_stmt ($1, flag_isoc99); }
2089 ;
2091 if_statement_2:
2092 c99_block_start lineno_labels ';'
2093 { if (extra_warnings)
2094 add_stmt (build (NOP_EXPR, NULL_TREE, NULL_TREE));
2095 $$ = c_end_compound_stmt ($1, flag_isoc99); }
2096 | c99_block_lineno_labeled_stmt
2097 ;
2099 if_statement:
2100 IF c99_block_start save_location '(' condition ')'
2101 if_statement_1 ELSE if_statement_2
2102 { c_finish_if_stmt ($3, $5, $7, $9, true);
2103 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2104 | IF c99_block_start save_location '(' condition ')'
2105 if_statement_2 ELSE if_statement_2
2106 { c_finish_if_stmt ($3, $5, $7, $9, false);
2107 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2108 | IF c99_block_start save_location '(' condition ')'
2109 if_statement_1 %prec IF
2110 { c_finish_if_stmt ($3, $5, $7, NULL, true);
2111 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2112 | IF c99_block_start save_location '(' condition ')'
2113 if_statement_2 %prec IF
2114 { c_finish_if_stmt ($3, $5, $7, NULL, false);
2115 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2116 ;
2118 start_break: /* empty */
2119 { $$ = c_break_label; c_break_label = NULL; }
2120 ;
2122 start_continue: /* empty */
2123 { $$ = c_cont_label; c_cont_label = NULL; }
2124 ;
2126 while_statement:
2127 WHILE c99_block_start save_location '(' condition ')'
2128 start_break start_continue c99_block_lineno_labeled_stmt
2129 { c_finish_loop ($3, $5, NULL, $9, c_break_label,
2130 c_cont_label, true);
2131 add_stmt (c_end_compound_stmt ($2, flag_isoc99));
2132 c_break_label = $7; c_cont_label = $8; }
2133 ;
2135 do_statement:
2136 DO c99_block_start save_location start_break start_continue
2137 c99_block_lineno_labeled_stmt WHILE
2138 { $<ttype>$ = c_break_label; c_break_label = $4; }
2139 { $<ttype>$ = c_cont_label; c_cont_label = $5; }
2140 '(' condition ')' ';'
2141 { c_finish_loop ($3, $11, NULL, $6, $<ttype>8,
2142 $<ttype>9, false);
2143 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2144 ;
2146 xexpr:
2147 /* empty */
2148 { $$ = NULL_TREE; }
2149 | expr
2150 { $$ = $1.value; }
2151 ;
2153 for_init_stmt:
2154 xexpr ';'
2155 { c_finish_expr_stmt ($1); }
2156 | decl
2157 { check_for_loop_decls (); }
2158 ;
2160 for_cond_expr: save_location xexpr
2161 { if ($2)
2162 {
2163 $$ = lang_hooks.truthvalue_conversion ($2);
2164 if (EXPR_P ($$))
2165 SET_EXPR_LOCATION ($$, $1);
2166 }
2167 else
2168 $$ = NULL;
2169 }
2170 ;
2172 for_incr_expr: xexpr
2173 { $$ = c_process_expr_stmt ($1); }
2174 ;
2176 for_statement:
2177 FOR c99_block_start '(' for_init_stmt
2178 save_location for_cond_expr ';' for_incr_expr ')'
2179 start_break start_continue c99_block_lineno_labeled_stmt
2180 { c_finish_loop ($5, $6, $8, $12, c_break_label,
2181 c_cont_label, true);
2182 add_stmt (c_end_compound_stmt ($2, flag_isoc99));
2183 c_break_label = $10; c_cont_label = $11; }
2184 ;
2186 switch_statement:
2187 SWITCH c99_block_start '(' expr ')'
2188 { $<ttype>$ = c_start_case ($4.value); }
2189 start_break c99_block_lineno_labeled_stmt
2190 { c_finish_case ($8);
2191 if (c_break_label)
2192 add_stmt (build (LABEL_EXPR, void_type_node,
2193 c_break_label));
2194 c_break_label = $7;
2195 add_stmt (c_end_compound_stmt ($2, flag_isoc99)); }
2196 ;
2198 /* Parse a single real statement, not including any labels or compounds. */
2199 stmt_nocomp:
2200 expr ';'
2201 { $$ = c_finish_expr_stmt ($1.value); }
2202 | if_statement
2203 { $$ = NULL_TREE; }
2204 | while_statement
2205 { $$ = NULL_TREE; }
2206 | do_statement
2207 { $$ = NULL_TREE; }
2208 | for_statement
2209 { $$ = NULL_TREE; }
2210 | switch_statement
2211 { $$ = NULL_TREE; }
2212 | BREAK ';'
2213 { $$ = c_finish_bc_stmt (&c_break_label, true); }
2214 | CONTINUE ';'
2215 { $$ = c_finish_bc_stmt (&c_cont_label, false); }
2216 | RETURN ';'
2217 { $$ = c_finish_return (NULL_TREE); }
2218 | RETURN expr ';'
2219 { $$ = c_finish_return ($2.value); }
2220 | asm_stmt
2221 | GOTO identifier ';'
2222 { $$ = c_finish_goto_label ($2); }
2223 | GOTO '*' expr ';'
2224 { $$ = c_finish_goto_ptr ($3.value); }
2225 | ';'
2226 { $$ = NULL_TREE; }
2227 @@ifobjc
2228 | AT_THROW expr ';'
2229 { $$ = objc_build_throw_stmt ($2.value); }
2230 | AT_THROW ';'
2231 { $$ = objc_build_throw_stmt (NULL_TREE); }
2232 | objc_try_catch_stmt
2233 { $$ = NULL_TREE; }
2234 | AT_SYNCHRONIZED save_location '(' expr ')' compstmt
2235 { objc_build_synchronized ($2, $4.value, $6); $$ = NULL_TREE; }
2236 ;
2238 objc_catch_prefix:
2239 AT_CATCH '(' parm ')'
2240 { objc_begin_catch_clause (grokparm ($3)); }
2241 ;
2243 objc_catch_clause:
2244 objc_catch_prefix '{' compstmt_nostart
2245 { objc_finish_catch_clause (); }
2246 | objc_catch_prefix '{' error '}'
2247 { objc_finish_catch_clause (); }
2248 ;
2250 objc_opt_catch_list:
2251 /* empty */
2252 | objc_opt_catch_list objc_catch_clause
2253 ;
2255 objc_try_catch_clause:
2256 AT_TRY save_location compstmt
2257 { objc_begin_try_stmt ($2, $3); }
2258 objc_opt_catch_list
2259 ;
2261 objc_finally_clause:
2262 AT_FINALLY save_location compstmt
2263 { objc_build_finally_clause ($2, $3); }
2264 ;
2266 objc_try_catch_stmt:
2267 objc_try_catch_clause
2268 { objc_finish_try_stmt (); }
2269 | objc_try_catch_clause objc_finally_clause
2270 { objc_finish_try_stmt (); }
2271 @@end_ifobjc
2272 ;
2274 /* Parse a single or compound real statement, not including any labels. */
2275 stmt:
2276 compstmt
2277 { add_stmt ($1); $$ = NULL_TREE; }
2278 | stmt_nocomp
2279 ;
2281 /* Any kind of label, including jump labels and case labels.
2282 ANSI C accepts labels only before statements, but we allow them
2283 also at the end of a compound statement. */
2285 label: CASE expr_no_commas ':'
2286 { $$ = do_case ($2.value, NULL_TREE); }
2287 | CASE expr_no_commas ELLIPSIS expr_no_commas ':'
2288 { $$ = do_case ($2.value, $4.value); }
2289 | DEFAULT ':'
2290 { $$ = do_case (NULL_TREE, NULL_TREE); }
2291 | identifier save_location ':' maybe_attribute
2292 { tree label = define_label ($2, $1);
2293 if (label)
2294 {
2295 decl_attributes (&label, $4, 0);
2296 $$ = add_stmt (build_stmt (LABEL_EXPR, label));
2297 }
2298 else
2299 $$ = NULL_TREE;
2300 }
2301 ;
2303 /* Asm expressions and statements */
2305 /* simple_asm_expr is used in restricted contexts, where a full
2306 expression with inputs and outputs does not make sense. */
2307 simple_asm_expr:
2308 ASM_KEYWORD stop_string_translation
2309 '(' STRING ')' start_string_translation
2310 { $$ = $4; }
2311 ;
2313 /* maybeasm: used for assembly names for declarations */
2314 maybeasm:
2315 /* empty */
2316 { $$ = NULL_TREE; }
2317 | simple_asm_expr
2318 ;
2320 /* asmdef: asm() outside a function body. */
2321 asmdef:
2322 simple_asm_expr ';'
2323 { assemble_asm ($1); }
2324 | ASM_KEYWORD error start_string_translation ';'
2325 {}
2326 ;
2328 /* Full-blown asm statement with inputs, outputs, clobbers, and
2329 volatile tag allowed. */
2330 asm_stmt:
2331 ASM_KEYWORD maybe_volatile stop_string_translation
2332 '(' asm_argument ')' start_string_translation ';'
2333 { $$ = build_asm_stmt ($2, $5); }
2334 ;
2336 asm_argument:
2337 /* no operands */
2338 STRING
2339 { $$ = build_asm_expr ($1, 0, 0, 0, true); }
2340 /* output operands */
2341 | STRING ':' asm_operands
2342 { $$ = build_asm_expr ($1, $3, 0, 0, false); }
2343 /* output and input operands */
2344 | STRING ':' asm_operands ':' asm_operands
2345 { $$ = build_asm_expr ($1, $3, $5, 0, false); }
2346 /* output and input operands and clobbers */
2347 | STRING ':' asm_operands ':' asm_operands ':' asm_clobbers
2348 { $$ = build_asm_expr ($1, $3, $5, $7, false); }
2349 ;
2351 /* Either 'volatile' or nothing. First thing in an `asm' statement. */
2353 maybe_volatile:
2354 /* empty */
2355 { $$ = 0; }
2356 | TYPE_QUAL
2357 { if ($1 != ridpointers[RID_VOLATILE])
2358 {
2359 warning ("%E qualifier ignored on asm", $1);
2360 $$ = 0;
2361 }
2362 else
2363 $$ = $1;
2364 }
2365 ;
2367 /* These are the operands other than the first string and colon
2368 in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */
2369 asm_operands: /* empty */
2370 { $$ = NULL_TREE; }
2371 | nonnull_asm_operands
2372 ;
2374 nonnull_asm_operands:
2375 asm_operand
2376 | nonnull_asm_operands ',' asm_operand
2377 { $$ = chainon ($1, $3); }
2378 ;
2380 asm_operand:
2381 STRING start_string_translation '(' expr ')' stop_string_translation
2382 { $$ = build_tree_list (build_tree_list (NULL_TREE, $1),
2383 $4.value); }
2384 | '[' identifier ']' STRING start_string_translation
2385 '(' expr ')' stop_string_translation
2386 { $2 = build_string (IDENTIFIER_LENGTH ($2),
2387 IDENTIFIER_POINTER ($2));
2388 $$ = build_tree_list (build_tree_list ($2, $4), $7.value); }
2389 ;
2391 asm_clobbers:
2392 STRING
2393 { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
2394 | asm_clobbers ',' STRING
2395 { $$ = tree_cons (NULL_TREE, $3, $1); }
2396 ;
2398 stop_string_translation:
2399 { c_lex_string_translate = 0; }
2400 ;
2402 start_string_translation:
2403 { c_lex_string_translate = 1; }
2404 ;
2406 \f
2407 /* This is what appears inside the parens in a function declarator.
2408 Its value is a list of ..._TYPE nodes. Attributes must appear here
2409 to avoid a conflict with their appearance after an open parenthesis
2410 in an abstract declarator, as in
2411 "void bar (int (__attribute__((__mode__(SI))) int foo));". */
2412 parmlist:
2413 maybe_attribute
2414 { push_scope ();
2415 declare_parm_level (); }
2416 parmlist_1
2417 { $$ = $3;
2418 pop_scope (); }
2419 ;
2421 parmlist_1:
2422 parmlist_2 ')'
2423 | parms ';'
2424 { mark_forward_parm_decls (); }
2425 maybe_attribute
2426 { /* Dummy action so attributes are in known place
2427 on parser stack. */ }
2428 parmlist_1
2429 { $$ = $6; }
2430 | error ')'
2431 { $$ = XOBNEW (&parser_obstack, struct c_arg_info);
2432 $$->parms = 0;
2433 $$->tags = 0;
2434 $$->types = 0;
2435 $$->others = 0; }
2436 ;
2438 /* This is what appears inside the parens in a function declarator.
2439 Its value is represented in the format that grokdeclarator expects. */
2440 parmlist_2: /* empty */
2441 { $$ = XOBNEW (&parser_obstack, struct c_arg_info);
2442 $$->parms = 0;
2443 $$->tags = 0;
2444 $$->types = 0;
2445 $$->others = 0; }
2446 | ELLIPSIS
2447 { $$ = XOBNEW (&parser_obstack, struct c_arg_info);
2448 $$->parms = 0;
2449 $$->tags = 0;
2450 $$->others = 0;
2451 /* Suppress -Wold-style-definition for this case. */
2452 $$->types = error_mark_node;
2453 error ("ISO C requires a named argument before %<...%>");
2454 }
2455 | parms
2456 { $$ = get_parm_info (/*ellipsis=*/false); }
2457 | parms ',' ELLIPSIS
2458 { $$ = get_parm_info (/*ellipsis=*/true); }
2459 ;
2461 parms:
2462 firstparm
2463 { push_parm_decl ($1); }
2464 | parms ',' parm
2465 { push_parm_decl ($3); }
2466 ;
2468 /* A single parameter declaration or parameter type name,
2469 as found in a parmlist. */
2470 parm:
2471 declspecs_ts setspecs parm_declarator maybe_attribute
2472 { $$ = build_c_parm (current_declspecs,
2473 chainon ($4, all_prefix_attributes), $3);
2474 POP_DECLSPEC_STACK; }
2475 | declspecs_ts setspecs notype_declarator maybe_attribute
2476 { $$ = build_c_parm (current_declspecs,
2477 chainon ($4, all_prefix_attributes), $3);
2478 POP_DECLSPEC_STACK; }
2479 | declspecs_ts setspecs absdcl_maybe_attribute
2480 { $$ = $3;
2481 POP_DECLSPEC_STACK; }
2482 | declspecs_nots setspecs notype_declarator maybe_attribute
2483 { $$ = build_c_parm (current_declspecs,
2484 chainon ($4, all_prefix_attributes), $3);
2485 POP_DECLSPEC_STACK; }
2487 | declspecs_nots setspecs absdcl_maybe_attribute
2488 { $$ = $3;
2489 POP_DECLSPEC_STACK; }
2490 ;
2492 /* The first parm, which must suck attributes from off the top of the parser
2493 stack. */
2494 firstparm:
2495 declspecs_ts_nosa setspecs_fp parm_declarator maybe_attribute
2496 { $$ = build_c_parm (current_declspecs,
2497 chainon ($4, all_prefix_attributes), $3);
2498 POP_DECLSPEC_STACK; }
2499 | declspecs_ts_nosa setspecs_fp notype_declarator maybe_attribute
2500 { $$ = build_c_parm (current_declspecs,
2501 chainon ($4, all_prefix_attributes), $3);
2502 POP_DECLSPEC_STACK; }
2503 | declspecs_ts_nosa setspecs_fp absdcl_maybe_attribute
2504 { $$ = $3;
2505 POP_DECLSPEC_STACK; }
2506 | declspecs_nots_nosa setspecs_fp notype_declarator maybe_attribute
2507 { $$ = build_c_parm (current_declspecs,
2508 chainon ($4, all_prefix_attributes), $3);
2509 POP_DECLSPEC_STACK; }
2511 | declspecs_nots_nosa setspecs_fp absdcl_maybe_attribute
2512 { $$ = $3;
2513 POP_DECLSPEC_STACK; }
2514 ;
2516 setspecs_fp:
2517 setspecs
2518 { prefix_attributes = chainon (prefix_attributes, $<ttype>-2);
2519 all_prefix_attributes = prefix_attributes; }
2520 ;
2522 /* This is used in a function definition
2523 where either a parmlist or an identifier list is ok.
2524 Its value is a list of ..._TYPE nodes or a list of identifiers. */
2525 parmlist_or_identifiers:
2526 maybe_attribute
2527 { push_scope ();
2528 declare_parm_level (); }
2529 parmlist_or_identifiers_1
2530 { $$ = $3;
2531 pop_scope (); }
2532 ;
2534 parmlist_or_identifiers_1:
2535 parmlist_1
2536 | identifiers ')'
2537 { $$ = XOBNEW (&parser_obstack, struct c_arg_info);
2538 $$->parms = 0;
2539 $$->tags = 0;
2540 $$->types = $1;
2541 $$->others = 0;
2543 /* Make sure we have a parmlist after attributes. */
2544 if ($<ttype>-1 != 0)
2545 YYERROR1;
2546 }
2547 ;
2549 /* A nonempty list of identifiers. */
2550 identifiers:
2551 IDENTIFIER
2552 { $$ = build_tree_list (NULL_TREE, $1); }
2553 | identifiers ',' IDENTIFIER
2554 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2555 ;
2557 /* A nonempty list of identifiers, including typenames. */
2558 identifiers_or_typenames:
2559 identifier
2560 { $$ = build_tree_list (NULL_TREE, $1); }
2561 | identifiers_or_typenames ',' identifier
2562 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2563 ;
2565 extension:
2566 EXTENSION
2567 { $$ = SAVE_EXT_FLAGS ();
2568 pedantic = 0;
2569 warn_pointer_arith = 0;
2570 warn_traditional = 0;
2571 flag_iso = 0; }
2572 ;
2573 \f
2574 @@ifobjc
2575 /* Objective-C productions. */
2577 objcdef:
2578 classdef
2579 | classdecl
2580 | aliasdecl
2581 | protocoldef
2582 | methoddef
2583 | AT_END
2584 {
2585 objc_finish_implementation ();
2586 }
2587 ;
2589 /* A nonempty list of identifiers. */
2590 identifier_list:
2591 identifier
2592 { $$ = build_tree_list (NULL_TREE, $1); }
2593 | identifier_list ',' identifier
2594 { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
2595 ;
2597 classdecl:
2598 AT_CLASS identifier_list ';'
2599 {
2600 objc_declare_class ($2);
2601 }
2602 ;
2604 aliasdecl:
2605 AT_ALIAS identifier identifier ';'
2606 {
2607 objc_declare_alias ($2, $3);
2608 }
2609 ;
2611 superclass:
2612 ':' identifier { $$ = $2; }
2613 | /* NULL */ %prec HYPERUNARY { $$ = NULL_TREE; }
2614 ;
2616 class_ivars:
2617 '{' ivar_decl_list '}'
2618 | /* NULL */
2619 ;
2621 classdef:
2622 AT_INTERFACE identifier superclass protocolrefs
2623 {
2624 objc_start_class_interface ($2, $3, $4);
2625 }
2626 class_ivars
2627 {
2628 objc_continue_interface ();
2629 }
2630 methodprotolist AT_END
2631 {
2632 objc_finish_interface ();
2633 }
2635 | AT_IMPLEMENTATION identifier superclass
2636 {
2637 objc_start_class_implementation ($2, $3);
2638 }
2639 class_ivars
2640 {
2641 objc_continue_implementation ();
2642 }
2644 | AT_INTERFACE identifier '(' identifier ')' protocolrefs
2645 {
2646 objc_start_category_interface ($2, $4, $6);
2647 }
2648 methodprotolist AT_END
2649 {
2650 objc_finish_interface ();
2651 }
2653 | AT_IMPLEMENTATION identifier '(' identifier ')'
2654 {
2655 objc_start_category_implementation ($2, $4);
2656 }
2657 ;
2659 protocoldef:
2660 AT_PROTOCOL identifier protocolrefs
2661 {
2662 objc_pq_context = 1;
2663 objc_start_protocol ($2, $3);
2664 }
2665 methodprotolist AT_END
2666 {
2667 objc_pq_context = 0;
2668 objc_finish_interface ();
2669 }
2670 /* The @protocol forward-declaration production introduces a
2671 reduce/reduce conflict on ';', which should be resolved in
2672 favor of the production 'identifier_list -> identifier'. */
2673 | AT_PROTOCOL identifier_list ';'
2674 {
2675 objc_declare_protocols ($2);
2676 }
2677 ;
2679 protocolrefs:
2680 /* empty */
2681 {
2682 $$ = NULL_TREE;
2683 }
2684 | non_empty_protocolrefs
2685 ;
2687 non_empty_protocolrefs:
2688 ARITHCOMPARE identifier_list ARITHCOMPARE
2689 {
2690 if ($1 == LT_EXPR && $3 == GT_EXPR)
2691 $$ = $2;
2692 else
2693 YYERROR1;
2694 }
2695 ;
2697 ivar_decl_list:
2698 /* empty */
2699 | ivar_decl_list visibility_spec ivar_decls
2700 ;
2702 visibility_spec:
2703 /* empty */
2704 | AT_PRIVATE { objc_set_visibility (2); }
2705 | AT_PROTECTED { objc_set_visibility (0); }
2706 | AT_PUBLIC { objc_set_visibility (1); }
2707 ;
2709 ivar_decls:
2710 /* empty */
2711 | ivar_decls ivar_decl ';'
2712 | ivar_decls ';'
2713 {
2714 if (pedantic)
2715 pedwarn ("extra semicolon in struct or union specified");
2716 }
2717 ;
2719 ivar_decl:
2720 component_decl
2721 {
2722 /* Comma-separated ivars are chained together in
2723 reverse order; add them one by one. */
2724 tree ivar = nreverse ($1);
2726 for (; ivar; ivar = TREE_CHAIN (ivar))
2727 objc_add_instance_variable (copy_node (ivar));
2728 }
2729 ;
2731 opt_semi:
2732 /* NULL */
2733 | ';'
2734 {
2735 if (pedantic)
2736 pedwarn ("extra semicolon in method definition specified");
2737 }
2738 ;
2740 methodtype:
2741 '+'
2742 | '-'
2743 ;
2745 methoddef:
2746 methodtype
2747 {
2748 objc_set_method_type ($1);
2749 objc_pq_context = 1;
2750 }
2751 methoddecl opt_semi
2752 {
2753 objc_pq_context = 0;
2754 objc_start_method_definition ($3);
2755 }
2756 compstmt_or_error
2757 {
2758 objc_finish_method_definition (current_function_decl);
2759 }
2760 ;
2762 /* the reason for the strange actions in this rule
2763 is so that notype_initdecls when reached via datadef
2764 can find a valid list of type and sc specs in $0. */
2766 methodprotolist:
2767 /* empty */
2768 | methodprotolist methodproto
2769 | methodprotolist { $<ttype>$ = NULL_TREE; } datadef
2770 ;
2772 semi_or_error:
2773 ';'
2774 | error
2775 ;
2777 methodproto:
2778 methodtype
2779 {
2780 objc_set_method_type ($1);
2781 /* Remember protocol qualifiers in prototypes. */
2782 objc_pq_context = 1;
2783 }
2784 methoddecl
2785 {
2786 /* Forget protocol qualifiers here. */
2787 objc_pq_context = 0;
2788 objc_add_method_declaration ($3);
2789 }
2790 semi_or_error
2791 ;
2793 methoddecl:
2794 '(' objc_typename ')' unaryselector
2795 {
2796 $$ = objc_build_method_signature ($2, $4, NULL_TREE);
2797 }
2799 | unaryselector
2800 {
2801 $$ = objc_build_method_signature (NULL_TREE, $1, NULL_TREE);
2802 }
2804 | '(' objc_typename ')' keywordselector optparmlist
2805 {
2806 $$ = objc_build_method_signature ($2, $4, $5);
2807 }
2809 | keywordselector optparmlist
2810 {
2811 $$ = objc_build_method_signature (NULL_TREE, $1, $2);
2812 }
2813 ;
2815 /* Optional ObjC method parameters follow the C syntax, and may include '...'
2816 to denote a variable number of arguments. */
2818 optparmlist:
2819 optparms optellipsis
2820 {
2821 TREE_OVERFLOW ($$) = $2;
2822 }
2823 ;
2825 optparms:
2826 /* NULL */
2827 {
2828 $$ = make_node (TREE_LIST);
2829 }
2830 | optparms ',' parm
2831 {
2832 $$ = chainon ($1, build_tree_list (NULL_TREE,
2833 grokparm ($3)));
2834 }
2835 ;
2837 optellipsis:
2838 /* NULL */
2839 {
2840 $$ = 0;
2841 }
2842 | ',' ELLIPSIS
2843 {
2844 $$ = 1;
2845 }
2846 ;
2848 unaryselector:
2849 selector
2850 ;
2852 keywordselector:
2853 keyworddecl
2855 | keywordselector keyworddecl
2856 {
2857 $$ = chainon ($1, $2);
2858 }
2859 ;
2861 selector:
2862 IDENTIFIER
2863 | TYPENAME
2864 | CLASSNAME
2865 | OBJECTNAME
2866 | reservedwords
2867 ;
2869 reservedwords:
2870 ENUM | STRUCT | UNION | IF | ELSE | WHILE | DO | FOR
2871 | SWITCH | CASE | DEFAULT | BREAK | CONTINUE | RETURN
2872 | GOTO | ASM_KEYWORD | SIZEOF | TYPEOF | ALIGNOF
2873 | TYPESPEC | TYPE_QUAL
2874 ;
2876 objc_qual:
2877 OBJC_TYPE_QUAL
2878 ;
2880 objc_quals:
2881 objc_quals objc_qual
2882 {
2883 $$ = chainon ($1, build_tree_list (NULL_TREE, $2));
2884 }
2885 | /* NULL */
2886 {
2887 $$ = NULL_TREE;
2888 }
2889 ;
2891 objc_typename:
2892 objc_quals typename
2893 {
2894 $$ = build_tree_list ($1, groktypename ($2));
2895 }
2896 | objc_quals
2897 {
2898 $$ = build_tree_list ($1, NULL_TREE);
2899 }
2900 ;
2902 keyworddecl:
2903 selector ':' '(' objc_typename ')' identifier
2904 {
2905 $$ = objc_build_keyword_decl ($1, $4, $6);
2906 }
2908 | selector ':' identifier
2909 {
2910 $$ = objc_build_keyword_decl ($1, NULL_TREE, $3);
2911 }
2913 | ':' '(' objc_typename ')' identifier
2914 {
2915 $$ = objc_build_keyword_decl (NULL_TREE, $3, $5);
2916 }
2918 | ':' identifier
2919 {
2920 $$ = objc_build_keyword_decl (NULL_TREE, NULL_TREE, $2);
2921 }
2922 ;
2924 messageargs:
2925 selector
2926 | keywordarglist
2927 ;
2929 keywordarglist:
2930 keywordarg
2931 | keywordarglist keywordarg
2932 {
2933 $$ = chainon ($1, $2);
2934 }
2935 ;
2938 keywordexpr:
2939 nonnull_exprlist
2940 {
2941 if (TREE_CHAIN ($1) == NULL_TREE)
2942 /* just return the expr., remove a level of indirection */
2943 $$ = TREE_VALUE ($1);
2944 else
2945 /* we have a comma expr., we will collapse later */
2946 $$ = $1;
2947 }
2948 ;
2950 keywordarg:
2951 selector ':' keywordexpr
2952 {
2953 $$ = build_tree_list ($1, $3);
2954 }
2955 | ':' keywordexpr
2956 {
2957 $$ = build_tree_list (NULL_TREE, $2);
2958 }
2959 ;
2961 receiver:
2962 expr
2963 { $$ = $1.value; }
2964 | CLASSNAME
2965 {
2966 $$ = objc_get_class_reference ($1);
2967 }
2968 | TYPENAME
2969 {
2970 $$ = objc_get_class_reference ($1);
2971 }
2972 ;
2974 objcmessageexpr:
2975 '[' receiver messageargs ']'
2976 { $$ = build_tree_list ($2, $3); }
2977 ;
2979 selectorarg:
2980 selector
2981 | keywordnamelist
2982 ;
2984 keywordnamelist:
2985 keywordname
2986 | keywordnamelist keywordname
2987 {
2988 $$ = chainon ($1, $2);
2989 }
2990 ;
2992 keywordname:
2993 selector ':'
2994 {
2995 $$ = build_tree_list ($1, NULL_TREE);
2996 }
2997 | ':'
2998 {
2999 $$ = build_tree_list (NULL_TREE, NULL_TREE);
3000 }
3001 ;
3003 objcselectorexpr:
3004 AT_SELECTOR '(' selectorarg ')'
3005 {
3006 $$ = $3;
3007 }
3008 ;
3010 objcprotocolexpr:
3011 AT_PROTOCOL '(' identifier ')'
3012 {
3013 $$ = $3;
3014 }
3015 ;
3017 /* extension to support C-structures in the archiver */
3019 objcencodeexpr:
3020 AT_ENCODE '(' typename ')'
3021 {
3022 $$ = groktypename ($3);
3023 }
3024 ;
3026 @@end_ifobjc
3027 %%
3029 /* yylex() is a thin wrapper around c_lex(), all it does is translate
3030 cpplib.h's token codes into yacc's token codes. */
3032 static enum cpp_ttype last_token;
3034 /* The reserved keyword table. */
3035 struct resword
3036 {
3037 const char *word;
3038 ENUM_BITFIELD(rid) rid : 16;
3039 unsigned int disable : 16;
3040 };
3042 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
3043 _true_. */
3044 #define D_C89 0x01 /* not in C89 */
3045 #define D_EXT 0x02 /* GCC extension */
3046 #define D_EXT89 0x04 /* GCC extension incorporated in C99 */
3047 #define D_OBJC 0x08 /* Objective C only */
3049 static const struct resword reswords[] =
3050 {
3051 { "_Bool", RID_BOOL, 0 },
3052 { "_Complex", RID_COMPLEX, 0 },
3053 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
3054 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
3055 { "__alignof", RID_ALIGNOF, 0 },
3056 { "__alignof__", RID_ALIGNOF, 0 },
3057 { "__asm", RID_ASM, 0 },
3058 { "__asm__", RID_ASM, 0 },
3059 { "__attribute", RID_ATTRIBUTE, 0 },
3060 { "__attribute__", RID_ATTRIBUTE, 0 },
3061 { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
3062 { "__builtin_offsetof", RID_OFFSETOF, 0 },
3063 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
3064 { "__builtin_va_arg", RID_VA_ARG, 0 },
3065 { "__complex", RID_COMPLEX, 0 },
3066 { "__complex__", RID_COMPLEX, 0 },
3067 { "__const", RID_CONST, 0 },
3068 { "__const__", RID_CONST, 0 },
3069 { "__extension__", RID_EXTENSION, 0 },
3070 { "__func__", RID_C99_FUNCTION_NAME, 0 },
3071 { "__imag", RID_IMAGPART, 0 },
3072 { "__imag__", RID_IMAGPART, 0 },
3073 { "__inline", RID_INLINE, 0 },
3074 { "__inline__", RID_INLINE, 0 },
3075 { "__label__", RID_LABEL, 0 },
3076 { "__ptrbase", RID_PTRBASE, 0 },
3077 { "__ptrbase__", RID_PTRBASE, 0 },
3078 { "__ptrextent", RID_PTREXTENT, 0 },
3079 { "__ptrextent__", RID_PTREXTENT, 0 },
3080 { "__ptrvalue", RID_PTRVALUE, 0 },
3081 { "__ptrvalue__", RID_PTRVALUE, 0 },
3082 { "__real", RID_REALPART, 0 },
3083 { "__real__", RID_REALPART, 0 },
3084 { "__restrict", RID_RESTRICT, 0 },
3085 { "__restrict__", RID_RESTRICT, 0 },
3086 { "__signed", RID_SIGNED, 0 },
3087 { "__signed__", RID_SIGNED, 0 },
3088 { "__thread", RID_THREAD, 0 },
3089 { "__typeof", RID_TYPEOF, 0 },
3090 { "__typeof__", RID_TYPEOF, 0 },
3091 { "__volatile", RID_VOLATILE, 0 },
3092 { "__volatile__", RID_VOLATILE, 0 },
3093 { "asm", RID_ASM, D_EXT },
3094 { "auto", RID_AUTO, 0 },
3095 { "break", RID_BREAK, 0 },
3096 { "case", RID_CASE, 0 },
3097 { "char", RID_CHAR, 0 },
3098 { "const", RID_CONST, 0 },
3099 { "continue", RID_CONTINUE, 0 },
3100 { "default", RID_DEFAULT, 0 },
3101 { "do", RID_DO, 0 },
3102 { "double", RID_DOUBLE, 0 },
3103 { "else", RID_ELSE, 0 },
3104 { "enum", RID_ENUM, 0 },
3105 { "extern", RID_EXTERN, 0 },
3106 { "float", RID_FLOAT, 0 },
3107 { "for", RID_FOR, 0 },
3108 { "goto", RID_GOTO, 0 },
3109 { "if", RID_IF, 0 },
3110 { "inline", RID_INLINE, D_EXT89 },
3111 { "int", RID_INT, 0 },
3112 { "long", RID_LONG, 0 },
3113 { "register", RID_REGISTER, 0 },
3114 { "restrict", RID_RESTRICT, D_C89 },
3115 { "return", RID_RETURN, 0 },
3116 { "short", RID_SHORT, 0 },
3117 { "signed", RID_SIGNED, 0 },
3118 { "sizeof", RID_SIZEOF, 0 },
3119 { "static", RID_STATIC, 0 },
3120 { "struct", RID_STRUCT, 0 },
3121 { "switch", RID_SWITCH, 0 },
3122 { "typedef", RID_TYPEDEF, 0 },
3123 { "typeof", RID_TYPEOF, D_EXT },
3124 { "union", RID_UNION, 0 },
3125 { "unsigned", RID_UNSIGNED, 0 },
3126 { "void", RID_VOID, 0 },
3127 { "volatile", RID_VOLATILE, 0 },
3128 { "while", RID_WHILE, 0 },
3130 @@ifobjc
3131 { "id", RID_ID, D_OBJC },
3133 /* These objc keywords are recognized only immediately after
3134 an '@'. */
3135 { "class", RID_AT_CLASS, D_OBJC },
3136 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
3137 { "defs", RID_AT_DEFS, D_OBJC },
3138 { "encode", RID_AT_ENCODE, D_OBJC },
3139 { "end", RID_AT_END, D_OBJC },
3140 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
3141 { "interface", RID_AT_INTERFACE, D_OBJC },
3142 { "private", RID_AT_PRIVATE, D_OBJC },
3143 { "protected", RID_AT_PROTECTED, D_OBJC },
3144 { "protocol", RID_AT_PROTOCOL, D_OBJC },
3145 { "public", RID_AT_PUBLIC, D_OBJC },
3146 { "selector", RID_AT_SELECTOR, D_OBJC },
3147 { "throw", RID_AT_THROW, D_OBJC },
3148 { "try", RID_AT_TRY, D_OBJC },
3149 { "catch", RID_AT_CATCH, D_OBJC },
3150 { "finally", RID_AT_FINALLY, D_OBJC },
3151 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
3152 /* These are recognized only in protocol-qualifier context
3153 (see above) */
3154 { "bycopy", RID_BYCOPY, D_OBJC },
3155 { "byref", RID_BYREF, D_OBJC },
3156 { "in", RID_IN, D_OBJC },
3157 { "inout", RID_INOUT, D_OBJC },
3158 { "oneway", RID_ONEWAY, D_OBJC },
3159 { "out", RID_OUT, D_OBJC },
3160 @@end_ifobjc
3161 };
3162 #define N_reswords (sizeof reswords / sizeof (struct resword))
3164 /* Table mapping from RID_* constants to yacc token numbers.
3165 Unfortunately we have to have entries for all the keywords in all
3166 three languages. */
3167 static const short rid_to_yy[RID_MAX] =
3168 {
3169 /* RID_STATIC */ STATIC,
3170 /* RID_UNSIGNED */ TYPESPEC,
3171 /* RID_LONG */ TYPESPEC,
3172 /* RID_CONST */ TYPE_QUAL,
3173 /* RID_EXTERN */ SCSPEC,
3174 /* RID_REGISTER */ SCSPEC,
3175 /* RID_TYPEDEF */ SCSPEC,
3176 /* RID_SHORT */ TYPESPEC,
3177 /* RID_INLINE */ SCSPEC,
3178 /* RID_VOLATILE */ TYPE_QUAL,
3179 /* RID_SIGNED */ TYPESPEC,
3180 /* RID_AUTO */ SCSPEC,
3181 /* RID_RESTRICT */ TYPE_QUAL,
3183 /* C extensions */
3184 /* RID_COMPLEX */ TYPESPEC,
3185 /* RID_THREAD */ SCSPEC,
3187 /* C++ */
3188 /* RID_FRIEND */ 0,
3189 /* RID_VIRTUAL */ 0,
3190 /* RID_EXPLICIT */ 0,
3191 /* RID_EXPORT */ 0,
3192 /* RID_MUTABLE */ 0,
3194 /* ObjC */
3195 /* RID_IN */ OBJC_TYPE_QUAL,
3196 /* RID_OUT */ OBJC_TYPE_QUAL,
3197 /* RID_INOUT */ OBJC_TYPE_QUAL,
3198 /* RID_BYCOPY */ OBJC_TYPE_QUAL,
3199 /* RID_BYREF */ OBJC_TYPE_QUAL,
3200 /* RID_ONEWAY */ OBJC_TYPE_QUAL,
3202 /* C */
3203 /* RID_INT */ TYPESPEC,
3204 /* RID_CHAR */ TYPESPEC,
3205 /* RID_FLOAT */ TYPESPEC,
3206 /* RID_DOUBLE */ TYPESPEC,
3207 /* RID_VOID */ TYPESPEC,
3208 /* RID_ENUM */ ENUM,
3209 /* RID_STRUCT */ STRUCT,
3210 /* RID_UNION */ UNION,
3211 /* RID_IF */ IF,
3212 /* RID_ELSE */ ELSE,
3213 /* RID_WHILE */ WHILE,
3214 /* RID_DO */ DO,
3215 /* RID_FOR */ FOR,
3216 /* RID_SWITCH */ SWITCH,
3217 /* RID_CASE */ CASE,
3218 /* RID_DEFAULT */ DEFAULT,
3219 /* RID_BREAK */ BREAK,
3220 /* RID_CONTINUE */ CONTINUE,
3221 /* RID_RETURN */ RETURN,
3222 /* RID_GOTO */ GOTO,
3223 /* RID_SIZEOF */ SIZEOF,
3225 /* C extensions */
3226 /* RID_ASM */ ASM_KEYWORD,
3227 /* RID_TYPEOF */ TYPEOF,
3228 /* RID_ALIGNOF */ ALIGNOF,
3229 /* RID_ATTRIBUTE */ ATTRIBUTE,
3230 /* RID_VA_ARG */ VA_ARG,
3231 /* RID_EXTENSION */ EXTENSION,
3232 /* RID_IMAGPART */ IMAGPART,
3233 /* RID_REALPART */ REALPART,
3234 /* RID_LABEL */ LABEL,
3235 /* RID_PTRBASE */ PTR_BASE,
3236 /* RID_PTREXTENT */ PTR_EXTENT,
3237 /* RID_PTRVALUE */ PTR_VALUE,
3239 /* RID_CHOOSE_EXPR */ CHOOSE_EXPR,
3240 /* RID_TYPES_COMPATIBLE_P */ TYPES_COMPATIBLE_P,
3242 /* RID_FUNCTION_NAME */ FUNC_NAME,
3243 /* RID_PRETTY_FUNCTION_NAME */ FUNC_NAME,
3244 /* RID_C99_FUNCTION_NAME */ FUNC_NAME,
3246 /* C++ */
3247 /* RID_BOOL */ TYPESPEC,
3248 /* RID_WCHAR */ 0,
3249 /* RID_CLASS */ 0,
3250 /* RID_PUBLIC */ 0,
3251 /* RID_PRIVATE */ 0,
3252 /* RID_PROTECTED */ 0,
3253 /* RID_TEMPLATE */ 0,
3254 /* RID_NULL */ 0,
3255 /* RID_CATCH */ 0,
3256 /* RID_DELETE */ 0,
3257 /* RID_FALSE */ 0,
3258 /* RID_NAMESPACE */ 0,
3259 /* RID_NEW */ 0,
3260 /* RID_OFFSETOF */ OFFSETOF,
3261 /* RID_OPERATOR */ 0,
3262 /* RID_THIS */ 0,
3263 /* RID_THROW */ 0,
3264 /* RID_TRUE */ 0,
3265 /* RID_TRY */ 0,
3266 /* RID_TYPENAME */ 0,
3267 /* RID_TYPEID */ 0,
3268 /* RID_USING */ 0,
3270 /* casts */
3271 /* RID_CONSTCAST */ 0,
3272 /* RID_DYNCAST */ 0,
3273 /* RID_REINTCAST */ 0,
3274 /* RID_STATCAST */ 0,
3276 /* Objective C */
3277 /* RID_ID */ OBJECTNAME,
3278 /* RID_AT_ENCODE */ AT_ENCODE,
3279 /* RID_AT_END */ AT_END,
3280 /* RID_AT_CLASS */ AT_CLASS,
3281 /* RID_AT_ALIAS */ AT_ALIAS,
3282 /* RID_AT_DEFS */ AT_DEFS,
3283 /* RID_AT_PRIVATE */ AT_PRIVATE,
3284 /* RID_AT_PROTECTED */ AT_PROTECTED,
3285 /* RID_AT_PUBLIC */ AT_PUBLIC,
3286 /* RID_AT_PROTOCOL */ AT_PROTOCOL,
3287 /* RID_AT_SELECTOR */ AT_SELECTOR,
3288 /* RID_AT_THROW */ AT_THROW,
3289 /* RID_AT_TRY */ AT_TRY,
3290 /* RID_AT_CATCH */ AT_CATCH,
3291 /* RID_AT_FINALLY */ AT_FINALLY,
3292 /* RID_AT_SYNCHRONIZED */ AT_SYNCHRONIZED,
3293 /* RID_AT_INTERFACE */ AT_INTERFACE,
3294 /* RID_AT_IMPLEMENTATION */ AT_IMPLEMENTATION
3295 };
3297 static void
3298 init_reswords (void)
3299 {
3300 unsigned int i;
3301 tree id;
3302 int mask = (flag_isoc99 ? 0 : D_C89)
3303 | (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT|D_EXT89) : 0);
3305 if (!c_dialect_objc ())
3306 mask |= D_OBJC;
3308 ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
3309 for (i = 0; i < N_reswords; i++)
3310 {
3311 /* If a keyword is disabled, do not enter it into the table
3312 and so create a canonical spelling that isn't a keyword. */
3313 if (reswords[i].disable & mask)
3314 continue;
3316 id = get_identifier (reswords[i].word);
3317 C_RID_CODE (id) = reswords[i].rid;
3318 C_IS_RESERVED_WORD (id) = 1;
3319 ridpointers [(int) reswords[i].rid] = id;
3320 }
3321 }
3323 #define NAME(type) cpp_type2name (type)
3325 static void
3326 yyerror (const char *msgid)
3327 {
3328 c_parse_error (msgid, last_token, yylval.ttype);
3329 }
3331 static int
3332 yylexname (void)
3333 {
3334 tree decl;
3336 @@ifobjc
3337 int objc_force_identifier = objc_need_raw_identifier;
3338 OBJC_NEED_RAW_IDENTIFIER (0);
3339 @@end_ifobjc
3341 if (C_IS_RESERVED_WORD (yylval.ttype))
3342 {
3343 enum rid rid_code = C_RID_CODE (yylval.ttype);
3345 @@ifobjc
3346 /* Turn non-typedefed refs to "id" into plain identifiers; this
3347 allows constructs like "void foo(id id);" to work. */
3348 if (rid_code == RID_ID)
3349 {
3350 decl = lookup_name (yylval.ttype);
3351 if (decl == NULL_TREE || TREE_CODE (decl) != TYPE_DECL)
3352 return IDENTIFIER;
3353 }
3355 if (!OBJC_IS_AT_KEYWORD (rid_code)
3356 && (!OBJC_IS_PQ_KEYWORD (rid_code) || objc_pq_context))
3357 @@end_ifobjc
3358 {
3359 /* Return the canonical spelling for this keyword. */
3360 yylval.ttype = ridpointers[(int) rid_code];
3361 return rid_to_yy[(int) rid_code];
3362 }
3363 }
3365 decl = lookup_name (yylval.ttype);
3366 if (decl)
3367 {
3368 if (TREE_CODE (decl) == TYPE_DECL)
3369 return TYPENAME;
3370 }
3371 @@ifobjc
3372 else
3373 {
3374 tree objc_interface_decl = objc_is_class_name (yylval.ttype);
3375 /* ObjC class names are in the same namespace as variables and
3376 typedefs, and hence are shadowed by local declarations. */
3377 if (objc_interface_decl
3378 && (global_bindings_p ()
3379 || (!objc_force_identifier && !decl)))
3380 {
3381 yylval.ttype = objc_interface_decl;
3382 return CLASSNAME;
3383 }
3384 }
3385 @@end_ifobjc
3387 return IDENTIFIER;
3388 }
3390 static inline int
3391 _yylex (void)
3392 {
3393 get_next:
3394 last_token = c_lex (&yylval.ttype);
3395 switch (last_token)
3396 {
3397 case CPP_EQ: return '=';
3398 case CPP_NOT: return '!';
3399 case CPP_GREATER: yylval.code = GT_EXPR; return ARITHCOMPARE;
3400 case CPP_LESS: yylval.code = LT_EXPR; return ARITHCOMPARE;
3401 case CPP_PLUS: yylval.code = PLUS_EXPR; return '+';
3402 case CPP_MINUS: yylval.code = MINUS_EXPR; return '-';
3403 case CPP_MULT: yylval.code = MULT_EXPR; return '*';
3404 case CPP_DIV: yylval.code = TRUNC_DIV_EXPR; return '/';
3405 case CPP_MOD: yylval.code = TRUNC_MOD_EXPR; return '%';
3406 case CPP_AND: yylval.code = BIT_AND_EXPR; return '&';
3407 case CPP_OR: yylval.code = BIT_IOR_EXPR; return '|';
3408 case CPP_XOR: yylval.code = BIT_XOR_EXPR; return '^';
3409 case CPP_RSHIFT: yylval.code = RSHIFT_EXPR; return RSHIFT;
3410 case CPP_LSHIFT: yylval.code = LSHIFT_EXPR; return LSHIFT;
3412 case CPP_COMPL: return '~';
3413 case CPP_AND_AND: return ANDAND;
3414 case CPP_OR_OR: return OROR;
3415 case CPP_QUERY: return '?';
3416 case CPP_OPEN_PAREN: return '(';
3417 case CPP_EQ_EQ: yylval.code = EQ_EXPR; return EQCOMPARE;
3418 case CPP_NOT_EQ: yylval.code = NE_EXPR; return EQCOMPARE;
3419 case CPP_GREATER_EQ:yylval.code = GE_EXPR; return ARITHCOMPARE;
3420 case CPP_LESS_EQ: yylval.code = LE_EXPR; return ARITHCOMPARE;
3422 case CPP_PLUS_EQ: yylval.code = PLUS_EXPR; return ASSIGN;
3423 case CPP_MINUS_EQ: yylval.code = MINUS_EXPR; return ASSIGN;
3424 case CPP_MULT_EQ: yylval.code = MULT_EXPR; return ASSIGN;
3425 case CPP_DIV_EQ: yylval.code = TRUNC_DIV_EXPR; return ASSIGN;
3426 case CPP_MOD_EQ: yylval.code = TRUNC_MOD_EXPR; return ASSIGN;
3427 case CPP_AND_EQ: yylval.code = BIT_AND_EXPR; return ASSIGN;
3428 case CPP_OR_EQ: yylval.code = BIT_IOR_EXPR; return ASSIGN;
3429 case CPP_XOR_EQ: yylval.code = BIT_XOR_EXPR; return ASSIGN;
3430 case CPP_RSHIFT_EQ: yylval.code = RSHIFT_EXPR; return ASSIGN;
3431 case CPP_LSHIFT_EQ: yylval.code = LSHIFT_EXPR; return ASSIGN;
3433 case CPP_OPEN_SQUARE: return '[';
3434 case CPP_CLOSE_SQUARE: return ']';
3435 case CPP_OPEN_BRACE: return '{';
3436 case CPP_CLOSE_BRACE: return '}';
3437 case CPP_ELLIPSIS: return ELLIPSIS;
3439 case CPP_PLUS_PLUS: return PLUSPLUS;
3440 case CPP_MINUS_MINUS: return MINUSMINUS;
3441 case CPP_DEREF: return POINTSAT;
3442 case CPP_DOT: return '.';
3444 /* The following tokens may affect the interpretation of any
3445 identifiers following, if doing Objective-C. */
3446 case CPP_COLON: OBJC_NEED_RAW_IDENTIFIER (0); return ':';
3447 case CPP_COMMA: OBJC_NEED_RAW_IDENTIFIER (0); return ',';
3448 case CPP_CLOSE_PAREN: OBJC_NEED_RAW_IDENTIFIER (0); return ')';
3449 case CPP_SEMICOLON: OBJC_NEED_RAW_IDENTIFIER (0); return ';';
3451 case CPP_EOF:
3452 return 0;
3454 case CPP_NAME:
3455 return yylexname ();
3457 case CPP_AT_NAME:
3458 /* This only happens in Objective-C; it must be a keyword. */
3459 return rid_to_yy [(int) C_RID_CODE (yylval.ttype)];
3461 case CPP_NUMBER:
3462 case CPP_CHAR:
3463 case CPP_WCHAR:
3464 return CONSTANT;
3466 case CPP_STRING:
3467 case CPP_WSTRING:
3468 return STRING;
3470 case CPP_OBJC_STRING:
3471 return OBJC_STRING;
3473 /* These tokens are C++ specific (and will not be generated
3474 in C mode, but let's be cautious). */
3475 case CPP_SCOPE:
3476 case CPP_DEREF_STAR:
3477 case CPP_DOT_STAR:
3478 case CPP_MIN_EQ:
3479 case CPP_MAX_EQ:
3480 case CPP_MIN:
3481 case CPP_MAX:
3482 /* These tokens should not survive translation phase 4. */
3483 case CPP_HASH:
3484 case CPP_PASTE:
3485 error ("syntax error at %qs token", NAME(last_token));
3486 goto get_next;
3488 default:
3489 abort ();
3490 }
3491 /* NOTREACHED */
3492 }
3494 static int
3495 yylex (void)
3496 {
3497 int r;
3498 timevar_push (TV_LEX);
3499 r = _yylex();
3500 timevar_pop (TV_LEX);
3501 return r;
3502 }
3504 /* Function used when yydebug is set, to print a token in more detail. */
3506 static void
3507 yyprint (FILE *file, int yychar, YYSTYPE yyl)
3508 {
3509 tree t = yyl.ttype;
3511 fprintf (file, " [%s]", NAME(last_token));
3513 switch (yychar)
3514 {
3515 case IDENTIFIER:
3516 case TYPENAME:
3517 case OBJECTNAME:
3518 case TYPESPEC:
3519 case TYPE_QUAL:
3520 case SCSPEC:
3521 case STATIC:
3522 if (IDENTIFIER_POINTER (t))
3523 fprintf (file, " '%s'", IDENTIFIER_POINTER (t));
3524 break;
3526 case CONSTANT:
3527 fprintf (file, " %s", GET_MODE_NAME (TYPE_MODE (TREE_TYPE (t))));
3528 if (TREE_CODE (t) == INTEGER_CST)
3529 {
3530 fputs (" ", file);
3531 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3532 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
3533 }
3534 break;
3535 }
3536 }
3537 \f
3538 /* This is not the ideal place to put this, but we have to get it out
3539 of c-lex.c because cp/lex.c has its own version. */
3541 /* Parse the file. */
3542 void
3543 c_parse_file (void)
3544 {
3545 yyparse ();
3547 if (malloced_yyss)
3548 {
3549 free (malloced_yyss);
3550 free (malloced_yyvs);
3551 malloced_yyss = 0;
3552 }
3553 }
3555 #ifdef __XGETTEXT__
3556 /* Depending on the version of Bison used to compile this grammar,
3557 it may issue generic diagnostics spelled "syntax error" or
3558 "parse error". To prevent this from changing the translation
3559 template randomly, we list all the variants of this particular
3560 diagnostic here. Translators: there is no fine distinction
3561 between diagnostics with "syntax error" in them, and diagnostics
3562 with "parse error" in them. It's okay to give them both the same
3563 translation. */
3564 const char d1[] = N_("syntax error");
3565 const char d2[] = N_("parse error");
3566 const char d3[] = N_("syntax error; also virtual memory exhausted");
3567 const char d4[] = N_("parse error; also virtual memory exhausted");
3568 const char d5[] = N_("syntax error: cannot back up");
3569 const char d6[] = N_("parse error: cannot back up");
3570 #endif
3572 #include "gt-c-parse.h"