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