]>
Commit | Line | Data |
---|---|---|
e4e13a01 | 1 | /* YACC parser for C syntax and for Objective C. -*-c-*- |
06c6bfb1 | 2 | Copyright (C) 1987, 88, 89, 92, 93, 1994 Free Software Foundation, Inc. |
028299c6 RS |
3 | |
4 | This file is part of GNU CC. | |
5 | ||
6 | GNU CC is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2, or (at your option) | |
9 | any later version. | |
10 | ||
11 | GNU CC is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with GNU CC; see the file COPYING. If not, write to | |
18 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | ||
20 | /* This file defines the grammar of C and that of Objective C. | |
21 | ifobjc ... end ifobjc conditionals contain code for Objective C only. | |
22 | ifc ... end ifc conditionals contain code for C only. | |
66b2ba11 | 23 | Sed commands in Makefile.in are used to convert this file into |
028299c6 RS |
24 | c-parse.y and into objc-parse.y. */ |
25 | ||
26 | /* To whomever it may concern: I have heard that such a thing was once | |
27 | written by AT&T, but I have never seen it. */ | |
28 | ||
29 | ifobjc | |
660b43c8 | 30 | %expect 22 |
028299c6 RS |
31 | end ifobjc |
32 | ifc | |
660b43c8 | 33 | %expect 10 |
028299c6 | 34 | |
660b43c8 | 35 | /* These are the 10 conflicts you should get in parse.output; |
028299c6 RS |
36 | the state numbers may vary if minor changes in the grammar are made. |
37 | ||
38 | State 41 contains 1 shift/reduce conflict. (Two ways to recover from error.) | |
660b43c8 RK |
39 | State 97 contains 1 shift/reduce conflict. (Two ways to recover from error.) |
40 | State 104 contains 1 shift/reduce conflict. (Two ways to recover from error.) | |
41 | State 108 contains 1 shift/reduce conflict. (Two ways to recover from error.) | |
42 | State 124 contains 1 shift/reduce conflict. (See comment at component_decl.) | |
43 | State 191 contains 1 shift/reduce conflict. (Two ways to recover from error.) | |
44 | State 204 contains 1 shift/reduce conflict. (Two ways to recover from error.) | |
45 | State 210 contains 1 shift/reduce conflict. (Two ways to recover from error.) | |
46 | State 449 contains 2 shift/reduce conflicts. (Four ways to parse this.) | |
028299c6 RS |
47 | */ |
48 | end ifc | |
49 | ||
50 | %{ | |
51 | #include <stdio.h> | |
52 | #include <errno.h> | |
53 | #include <setjmp.h> | |
54 | ||
55 | #include "config.h" | |
56 | #include "tree.h" | |
57 | #include "input.h" | |
58 | #include "c-lex.h" | |
59 | #include "c-tree.h" | |
60 | #include "flags.h" | |
61 | ||
62 | #ifdef MULTIBYTE_CHARS | |
63 | #include <stdlib.h> | |
64 | #include <locale.h> | |
65 | #endif | |
66 | ||
67 | ifobjc | |
df24d0da | 68 | #include "objc-act.h" |
028299c6 RS |
69 | end ifobjc |
70 | ||
867b0d7a JW |
71 | /* Since parsers are distinct for each language, put the language string |
72 | definition here. */ | |
73 | ifobjc | |
74 | char *language_string = "GNU Obj-C"; | |
75 | end ifobjc | |
76 | ifc | |
77 | char *language_string = "GNU C"; | |
78 | end ifc | |
79 | ||
028299c6 RS |
80 | #ifndef errno |
81 | extern int errno; | |
82 | #endif | |
83 | ||
84 | void yyerror (); | |
85 | ||
86 | /* Like YYERROR but do call yyerror. */ | |
87 | #define YYERROR1 { yyerror ("syntax error"); YYERROR; } | |
88 | ||
89 | /* Cause the `yydebug' variable to be defined. */ | |
90 | #define YYDEBUG 1 | |
91 | %} | |
92 | ||
93 | %start program | |
94 | ||
95 | %union {long itype; tree ttype; enum tree_code code; | |
96 | char *filename; int lineno; } | |
97 | ||
98 | /* All identifiers that are not reserved words | |
99 | and are not declared typedefs in the current block */ | |
100 | %token IDENTIFIER | |
101 | ||
102 | /* All identifiers that are declared typedefs in the current block. | |
103 | In some contexts, they are treated just like IDENTIFIER, | |
104 | but they can also serve as typespecs in declarations. */ | |
105 | %token TYPENAME | |
106 | ||
107 | /* Reserved words that specify storage class. | |
108 | yylval contains an IDENTIFIER_NODE which indicates which one. */ | |
109 | %token SCSPEC | |
110 | ||
111 | /* Reserved words that specify type. | |
112 | yylval contains an IDENTIFIER_NODE which indicates which one. */ | |
113 | %token TYPESPEC | |
114 | ||
115 | /* Reserved words that qualify type: "const" or "volatile". | |
116 | yylval contains an IDENTIFIER_NODE which indicates which one. */ | |
117 | %token TYPE_QUAL | |
118 | ||
119 | /* Character or numeric constants. | |
120 | yylval is the node for the constant. */ | |
121 | %token CONSTANT | |
122 | ||
123 | /* String constants in raw form. | |
124 | yylval is a STRING_CST node. */ | |
125 | %token STRING | |
126 | ||
127 | /* "...", used for functions with variable arglists. */ | |
128 | %token ELLIPSIS | |
129 | ||
130 | /* the reserved words */ | |
131 | /* SCO include files test "ASM", so use something else. */ | |
132 | %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT | |
133 | %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF ALIGN | |
134 | %token ATTRIBUTE EXTENSION LABEL | |
12d073e7 | 135 | %token REALPART IMAGPART |
028299c6 RS |
136 | |
137 | /* Add precedence rules to solve dangling else s/r conflict */ | |
138 | %nonassoc IF | |
139 | %nonassoc ELSE | |
140 | ||
141 | /* Define the operator tokens and their precedences. | |
142 | The value is an integer because, if used, it is the tree code | |
143 | to use in the expression made from the operator. */ | |
144 | ||
145 | %right <code> ASSIGN '=' | |
146 | %right <code> '?' ':' | |
147 | %left <code> OROR | |
148 | %left <code> ANDAND | |
149 | %left <code> '|' | |
150 | %left <code> '^' | |
151 | %left <code> '&' | |
152 | %left <code> EQCOMPARE | |
153 | %left <code> ARITHCOMPARE | |
154 | %left <code> LSHIFT RSHIFT | |
155 | %left <code> '+' '-' | |
156 | %left <code> '*' '/' '%' | |
157 | %right <code> UNARY PLUSPLUS MINUSMINUS | |
158 | %left HYPERUNARY | |
159 | %left <code> POINTSAT '.' '(' '[' | |
160 | ||
161 | /* The Objective-C keywords. These are included in C and in | |
162 | Objective C, so that the token codes are the same in both. */ | |
163 | %token INTERFACE IMPLEMENTATION END SELECTOR DEFS ENCODE | |
e31c7eec TW |
164 | %token CLASSNAME PUBLIC PRIVATE PROTECTED PROTOCOL OBJECTNAME CLASS ALIAS |
165 | ||
166 | /* Objective-C string constants in raw form. | |
167 | yylval is an OBJC_STRING_CST node. */ | |
168 | %token OBJC_STRING | |
028299c6 RS |
169 | |
170 | ||
171 | %type <code> unop | |
172 | ||
173 | %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist | |
174 | %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING | |
175 | %type <ttype> typed_declspecs reserved_declspecs | |
176 | %type <ttype> typed_typespecs reserved_typespecquals | |
177 | %type <ttype> declmods typespec typespecqual_reserved | |
178 | %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual | |
179 | %type <ttype> initdecls notype_initdecls initdcl notype_initdcl | |
42e651a6 | 180 | %type <ttype> init maybeasm |
028299c6 | 181 | %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers |
660b43c8 RK |
182 | %type <ttype> maybe_attribute attributes attribute attribute_list attrib |
183 | %type <ttype> any_word | |
028299c6 RS |
184 | |
185 | %type <ttype> compstmt | |
186 | ||
187 | %type <ttype> declarator | |
188 | %type <ttype> notype_declarator after_type_declarator | |
189 | %type <ttype> parm_declarator | |
190 | ||
191 | %type <ttype> structsp component_decl_list component_decl_list2 | |
192 | %type <ttype> component_decl components component_declarator | |
193 | %type <ttype> enumlist enumerator | |
194 | %type <ttype> typename absdcl absdcl1 type_quals | |
195 | %type <ttype> xexpr parms parm identifiers | |
196 | ||
197 | %type <ttype> parmlist parmlist_1 parmlist_2 | |
198 | %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1 | |
199 | %type <ttype> identifiers_or_typenames | |
200 | ||
201 | %type <itype> setspecs | |
202 | ||
203 | %type <filename> save_filename | |
204 | %type <lineno> save_lineno | |
205 | \f | |
206 | ifobjc | |
207 | /* the Objective-C nonterminals */ | |
208 | ||
209 | %type <ttype> ivar_decl_list ivar_decls ivar_decl ivars ivar_declarator | |
210 | %type <ttype> methoddecl unaryselector keywordselector selector | |
211 | %type <ttype> keyworddecl receiver objcmessageexpr messageargs | |
212 | %type <ttype> keywordexpr keywordarglist keywordarg | |
213 | %type <ttype> myparms myparm optparmlist reservedwords objcselectorexpr | |
214 | %type <ttype> selectorarg keywordnamelist keywordname objcencodeexpr | |
e31c7eec TW |
215 | %type <ttype> objc_string protocolrefs identifier_list objcprotocolexpr |
216 | %type <ttype> CLASSNAME OBJC_STRING OBJECTNAME | |
028299c6 RS |
217 | end ifobjc |
218 | \f | |
219 | %{ | |
220 | /* Number of statements (loosely speaking) seen so far. */ | |
221 | static int stmt_count; | |
222 | ||
223 | /* Input file and line number of the end of the body of last simple_if; | |
224 | used by the stmt-rule immediately after simple_if returns. */ | |
225 | static char *if_stmt_file; | |
226 | static int if_stmt_line; | |
227 | ||
228 | /* List of types and structure classes of the current declaration. */ | |
229 | static tree current_declspecs; | |
230 | ||
231 | /* Stack of saved values of current_declspecs. */ | |
232 | static tree declspec_stack; | |
233 | ||
234 | /* 1 if we explained undeclared var errors. */ | |
235 | static int undeclared_variable_notice; | |
236 | ||
237 | ifobjc | |
238 | /* Objective-C specific information */ | |
239 | ||
240 | tree objc_interface_context; | |
241 | tree objc_implementation_context; | |
242 | tree objc_method_context; | |
243 | tree objc_ivar_chain; | |
244 | tree objc_ivar_context; | |
245 | enum tree_code objc_inherit_code; | |
246 | int objc_receiver_context; | |
247 | int objc_public_flag; | |
248 | ||
249 | end ifobjc | |
250 | ||
251 | /* Tell yyparse how to print a token's value, if yydebug is set. */ | |
252 | ||
253 | #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL) | |
254 | extern void yyprint (); | |
255 | %} | |
256 | \f | |
257 | %% | |
258 | program: /* empty */ | |
259 | { if (pedantic) | |
260 | pedwarn ("ANSI C forbids an empty source file"); | |
261 | ifobjc | |
262 | objc_finish (); | |
263 | end ifobjc | |
264 | } | |
265 | | extdefs | |
266 | { | |
ca67f868 RS |
267 | /* In case there were missing closebraces, |
268 | get us back to the global binding level. */ | |
269 | while (! global_bindings_p ()) | |
270 | poplevel (0, 0, 0); | |
028299c6 RS |
271 | ifobjc |
272 | objc_finish (); | |
273 | end ifobjc | |
274 | } | |
275 | ; | |
276 | ||
277 | /* the reason for the strange actions in this rule | |
278 | is so that notype_initdecls when reached via datadef | |
279 | can find a valid list of type and sc specs in $0. */ | |
280 | ||
281 | extdefs: | |
282 | {$<ttype>$ = NULL_TREE; } extdef | |
283 | | extdefs {$<ttype>$ = NULL_TREE; } extdef | |
284 | ; | |
285 | ||
286 | extdef: | |
287 | fndef | |
288 | | datadef | |
289 | ifobjc | |
290 | | objcdef | |
291 | end ifobjc | |
292 | | ASM_KEYWORD '(' expr ')' ';' | |
293 | { STRIP_NOPS ($3); | |
294 | if ((TREE_CODE ($3) == ADDR_EXPR | |
295 | && TREE_CODE (TREE_OPERAND ($3, 0)) == STRING_CST) | |
296 | || TREE_CODE ($3) == STRING_CST) | |
297 | assemble_asm ($3); | |
298 | else | |
299 | error ("argument of `asm' is not a constant string"); } | |
300 | ; | |
301 | ||
302 | datadef: | |
303 | setspecs notype_initdecls ';' | |
304 | { if (pedantic) | |
305 | error ("ANSI C forbids data definition with no type or storage class"); | |
306 | else if (!flag_traditional) | |
307 | warning ("data definition has no type or storage class"); } | |
308 | | declmods setspecs notype_initdecls ';' | |
309 | {} | |
310 | | typed_declspecs setspecs initdecls ';' | |
311 | {} | |
312 | | declmods ';' | |
313 | { pedwarn ("empty declaration"); } | |
314 | | typed_declspecs ';' | |
315 | { shadow_tag ($1); } | |
316 | | error ';' | |
317 | | error '}' | |
318 | | ';' | |
319 | { if (pedantic) | |
320 | pedwarn ("ANSI C does not allow extra `;' outside of a function"); } | |
321 | ; | |
322 | \f | |
323 | fndef: | |
324 | typed_declspecs setspecs declarator | |
325 | { if (! start_function ($1, $3, 0)) | |
326 | YYERROR1; | |
327 | reinit_parse_for_function (); } | |
328 | xdecls | |
329 | { store_parm_decls (); } | |
330 | compstmt_or_error | |
331 | { finish_function (0); } | |
332 | | typed_declspecs setspecs declarator error | |
333 | { } | |
334 | | declmods setspecs notype_declarator | |
335 | { if (! start_function ($1, $3, 0)) | |
336 | YYERROR1; | |
337 | reinit_parse_for_function (); } | |
338 | xdecls | |
339 | { store_parm_decls (); } | |
340 | compstmt_or_error | |
341 | { finish_function (0); } | |
342 | | declmods setspecs notype_declarator error | |
343 | { } | |
344 | | setspecs notype_declarator | |
345 | { if (! start_function (NULL_TREE, $2, 0)) | |
346 | YYERROR1; | |
347 | reinit_parse_for_function (); } | |
348 | xdecls | |
349 | { store_parm_decls (); } | |
350 | compstmt_or_error | |
351 | { finish_function (0); } | |
352 | | setspecs notype_declarator error | |
353 | { } | |
354 | ; | |
355 | ||
356 | identifier: | |
357 | IDENTIFIER | |
358 | | TYPENAME | |
359 | ifobjc | |
e31c7eec | 360 | | OBJECTNAME |
028299c6 | 361 | | CLASSNAME |
028299c6 RS |
362 | end ifobjc |
363 | ; | |
364 | ||
365 | unop: '&' | |
366 | { $$ = ADDR_EXPR; } | |
367 | | '-' | |
368 | { $$ = NEGATE_EXPR; } | |
369 | | '+' | |
370 | { $$ = CONVERT_EXPR; } | |
371 | | PLUSPLUS | |
372 | { $$ = PREINCREMENT_EXPR; } | |
373 | | MINUSMINUS | |
374 | { $$ = PREDECREMENT_EXPR; } | |
375 | | '~' | |
376 | { $$ = BIT_NOT_EXPR; } | |
377 | | '!' | |
378 | { $$ = TRUTH_NOT_EXPR; } | |
379 | ; | |
380 | ||
381 | expr: nonnull_exprlist | |
382 | { $$ = build_compound_expr ($1); } | |
383 | ; | |
384 | ||
385 | exprlist: | |
386 | /* empty */ | |
387 | { $$ = NULL_TREE; } | |
388 | | nonnull_exprlist | |
389 | ; | |
390 | ||
391 | nonnull_exprlist: | |
392 | expr_no_commas | |
393 | { $$ = build_tree_list (NULL_TREE, $1); } | |
394 | | nonnull_exprlist ',' expr_no_commas | |
395 | { chainon ($1, build_tree_list (NULL_TREE, $3)); } | |
396 | ; | |
397 | ||
398 | unary_expr: | |
399 | primary | |
400 | | '*' cast_expr %prec UNARY | |
401 | { $$ = build_indirect_ref ($2, "unary *"); } | |
402 | /* __extension__ turns off -pedantic for following primary. */ | |
403 | | EXTENSION | |
404 | { $<itype>1 = pedantic; | |
405 | pedantic = 0; } | |
406 | cast_expr %prec UNARY | |
407 | { $$ = $3; | |
408 | pedantic = $<itype>1; } | |
409 | | unop cast_expr %prec UNARY | |
5303129f RS |
410 | { $$ = build_unary_op ($1, $2, 0); |
411 | overflow_warning ($$); } | |
028299c6 RS |
412 | /* Refer to the address of a label as a pointer. */ |
413 | | ANDAND identifier | |
414 | { tree label = lookup_label ($2); | |
e19a77e6 RS |
415 | if (label == 0) |
416 | $$ = null_pointer_node; | |
417 | else | |
418 | { | |
419 | TREE_USED (label) = 1; | |
420 | $$ = build1 (ADDR_EXPR, ptr_type_node, label); | |
421 | TREE_CONSTANT ($$) = 1; | |
422 | } | |
423 | } | |
028299c6 RS |
424 | /* This seems to be impossible on some machines, so let's turn it off. |
425 | You can use __builtin_next_arg to find the anonymous stack args. | |
426 | | '&' ELLIPSIS | |
427 | { tree types = TYPE_ARG_TYPES (TREE_TYPE (current_function_decl)); | |
428 | $$ = error_mark_node; | |
429 | if (TREE_VALUE (tree_last (types)) == void_type_node) | |
430 | error ("`&...' used in function with fixed number of arguments"); | |
431 | else | |
432 | { | |
433 | if (pedantic) | |
434 | pedwarn ("ANSI C forbids `&...'"); | |
435 | $$ = tree_last (DECL_ARGUMENTS (current_function_decl)); | |
436 | $$ = build_unary_op (ADDR_EXPR, $$, 0); | |
437 | } } | |
438 | */ | |
439 | | SIZEOF unary_expr %prec UNARY | |
440 | { if (TREE_CODE ($2) == COMPONENT_REF | |
441 | && DECL_BIT_FIELD (TREE_OPERAND ($2, 1))) | |
442 | error ("`sizeof' applied to a bit-field"); | |
443 | $$ = c_sizeof (TREE_TYPE ($2)); } | |
444 | | SIZEOF '(' typename ')' %prec HYPERUNARY | |
445 | { $$ = c_sizeof (groktypename ($3)); } | |
446 | | ALIGNOF unary_expr %prec UNARY | |
447 | { $$ = c_alignof_expr ($2); } | |
448 | | ALIGNOF '(' typename ')' %prec HYPERUNARY | |
449 | { $$ = c_alignof (groktypename ($3)); } | |
475e8534 | 450 | | REALPART cast_expr %prec UNARY |
12d073e7 | 451 | { $$ = build_unary_op (REALPART_EXPR, $2, 0); } |
475e8534 | 452 | | IMAGPART cast_expr %prec UNARY |
12d073e7 | 453 | { $$ = build_unary_op (IMAGPART_EXPR, $2, 0); } |
028299c6 RS |
454 | ; |
455 | ||
456 | cast_expr: | |
457 | unary_expr | |
458 | | '(' typename ')' cast_expr %prec UNARY | |
459 | { tree type = groktypename ($2); | |
460 | $$ = build_c_cast (type, $4); } | |
42e651a6 RS |
461 | | '(' typename ')' '{' |
462 | { start_init (NULL_TREE, NULL, 0); | |
463 | $2 = groktypename ($2); | |
464 | really_start_incremental_init ($2); } | |
465 | initlist_maybe_comma '}' %prec UNARY | |
466 | { char *name; | |
467 | tree result = pop_init_level (0); | |
468 | tree type = $2; | |
469 | finish_init (); | |
470 | ||
028299c6 RS |
471 | if (pedantic) |
472 | pedwarn ("ANSI C forbids constructor expressions"); | |
473 | if (TYPE_NAME (type) != 0) | |
474 | { | |
475 | if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) | |
476 | name = IDENTIFIER_POINTER (TYPE_NAME (type)); | |
477 | else | |
478 | name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); | |
479 | } | |
480 | else | |
481 | name = ""; | |
42e651a6 | 482 | $$ = result; |
028299c6 RS |
483 | if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0) |
484 | { | |
485 | int failure = complete_array_type (type, $$, 1); | |
486 | if (failure) | |
487 | abort (); | |
488 | } | |
489 | } | |
490 | ; | |
491 | ||
492 | expr_no_commas: | |
493 | cast_expr | |
494 | | expr_no_commas '+' expr_no_commas | |
495 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
496 | | expr_no_commas '-' expr_no_commas | |
497 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
498 | | expr_no_commas '*' expr_no_commas | |
499 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
500 | | expr_no_commas '/' expr_no_commas | |
501 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
502 | | expr_no_commas '%' expr_no_commas | |
503 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
504 | | expr_no_commas LSHIFT expr_no_commas | |
505 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
506 | | expr_no_commas RSHIFT expr_no_commas | |
507 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
508 | | expr_no_commas ARITHCOMPARE expr_no_commas | |
509 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
510 | | expr_no_commas EQCOMPARE expr_no_commas | |
511 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
512 | | expr_no_commas '&' expr_no_commas | |
513 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
514 | | expr_no_commas '|' expr_no_commas | |
515 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
516 | | expr_no_commas '^' expr_no_commas | |
517 | { $$ = parser_build_binary_op ($2, $1, $3); } | |
518 | | expr_no_commas ANDAND expr_no_commas | |
519 | { $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $3); } | |
520 | | expr_no_commas OROR expr_no_commas | |
521 | { $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $3); } | |
522 | | expr_no_commas '?' xexpr ':' expr_no_commas | |
523 | { $$ = build_conditional_expr ($1, $3, $5); } | |
524 | | expr_no_commas '=' expr_no_commas | |
525 | { $$ = build_modify_expr ($1, NOP_EXPR, $3); | |
526 | C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR); } | |
527 | | expr_no_commas ASSIGN expr_no_commas | |
528 | { $$ = build_modify_expr ($1, $2, $3); | |
6544cdba RS |
529 | /* This inhibits warnings in truthvalue_conversion. */ |
530 | C_SET_EXP_ORIGINAL_CODE ($$, ERROR_MARK); } | |
028299c6 RS |
531 | ; |
532 | ||
533 | primary: | |
534 | IDENTIFIER | |
535 | { | |
028299c6 RS |
536 | $$ = lastiddecl; |
537 | if (!$$ || $$ == error_mark_node) | |
538 | { | |
539 | if (yychar == YYEMPTY) | |
540 | yychar = YYLEX; | |
541 | if (yychar == '(') | |
542 | { | |
543 | ifobjc | |
e31c7eec TW |
544 | tree decl; |
545 | ||
028299c6 RS |
546 | if (objc_receiver_context |
547 | && ! (objc_receiver_context | |
548 | && strcmp (IDENTIFIER_POINTER ($1), "super"))) | |
549 | /* we have a message to super */ | |
550 | $$ = get_super_receiver (); | |
551 | else if (objc_method_context | |
e31c7eec TW |
552 | && (decl = is_ivar (objc_ivar_chain, $1))) |
553 | { | |
554 | if (is_private (decl)) | |
555 | $$ = error_mark_node; | |
556 | else | |
557 | $$ = build_ivar_reference ($1); | |
558 | } | |
028299c6 RS |
559 | else |
560 | end ifobjc | |
561 | { | |
562 | /* Ordinary implicit function declaration. */ | |
563 | $$ = implicitly_declare ($1); | |
564 | assemble_external ($$); | |
565 | TREE_USED ($$) = 1; | |
566 | } | |
567 | } | |
568 | else if (current_function_decl == 0) | |
569 | { | |
c47783c0 | 570 | error ("`%s' undeclared here (not in a function)", |
028299c6 RS |
571 | IDENTIFIER_POINTER ($1)); |
572 | $$ = error_mark_node; | |
573 | } | |
574 | else | |
575 | { | |
576 | ifobjc | |
e31c7eec TW |
577 | tree decl; |
578 | ||
028299c6 RS |
579 | if (objc_receiver_context |
580 | && ! strcmp (IDENTIFIER_POINTER ($1), "super")) | |
581 | /* we have a message to super */ | |
582 | $$ = get_super_receiver (); | |
583 | else if (objc_method_context | |
e31c7eec TW |
584 | && (decl = is_ivar (objc_ivar_chain, $1))) |
585 | { | |
586 | if (is_private (decl)) | |
587 | $$ = error_mark_node; | |
588 | else | |
589 | $$ = build_ivar_reference ($1); | |
590 | } | |
028299c6 RS |
591 | else |
592 | end ifobjc | |
593 | { | |
594 | if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node | |
595 | || IDENTIFIER_ERROR_LOCUS ($1) != current_function_decl) | |
596 | { | |
597 | error ("`%s' undeclared (first use this function)", | |
598 | IDENTIFIER_POINTER ($1)); | |
599 | ||
600 | if (! undeclared_variable_notice) | |
601 | { | |
602 | error ("(Each undeclared identifier is reported only once"); | |
603 | error ("for each function it appears in.)"); | |
604 | undeclared_variable_notice = 1; | |
605 | } | |
606 | } | |
607 | $$ = error_mark_node; | |
608 | /* Prevent repeated error messages. */ | |
609 | IDENTIFIER_GLOBAL_VALUE ($1) = error_mark_node; | |
610 | IDENTIFIER_ERROR_LOCUS ($1) = current_function_decl; | |
611 | } | |
612 | } | |
613 | } | |
614 | else if (TREE_TYPE ($$) == error_mark_node) | |
615 | $$ = error_mark_node; | |
616 | else if (C_DECL_ANTICIPATED ($$)) | |
617 | { | |
618 | /* The first time we see a build-in function used, | |
619 | if it has not been declared. */ | |
620 | C_DECL_ANTICIPATED ($$) = 0; | |
621 | if (yychar == YYEMPTY) | |
622 | yychar = YYLEX; | |
623 | if (yychar == '(') | |
624 | { | |
625 | /* Omit the implicit declaration we | |
626 | would ordinarily do, so we don't lose | |
627 | the actual built in type. | |
628 | But print a diagnostic for the mismatch. */ | |
629 | ifobjc | |
630 | if (objc_method_context | |
631 | && is_ivar (objc_ivar_chain, $1)) | |
632 | error ("Instance variable `%s' implicitly declared as function", | |
633 | IDENTIFIER_POINTER (DECL_NAME ($$))); | |
634 | else | |
635 | end ifobjc | |
636 | if (TREE_CODE ($$) != FUNCTION_DECL) | |
637 | error ("`%s' implicitly declared as function", | |
638 | IDENTIFIER_POINTER (DECL_NAME ($$))); | |
639 | else if ((TYPE_MODE (TREE_TYPE (TREE_TYPE ($$))) | |
640 | != TYPE_MODE (integer_type_node)) | |
641 | && (TREE_TYPE (TREE_TYPE ($$)) | |
642 | != void_type_node)) | |
643 | pedwarn ("type mismatch in implicit declaration for built-in function `%s'", | |
644 | IDENTIFIER_POINTER (DECL_NAME ($$))); | |
645 | /* If it really returns void, change that to int. */ | |
646 | if (TREE_TYPE (TREE_TYPE ($$)) == void_type_node) | |
647 | TREE_TYPE ($$) | |
648 | = build_function_type (integer_type_node, | |
649 | TYPE_ARG_TYPES (TREE_TYPE ($$))); | |
650 | } | |
651 | else | |
652 | pedwarn ("built-in function `%s' used without declaration", | |
653 | IDENTIFIER_POINTER (DECL_NAME ($$))); | |
654 | ||
655 | /* Do what we would ordinarily do when a fn is used. */ | |
656 | assemble_external ($$); | |
657 | TREE_USED ($$) = 1; | |
658 | } | |
659 | else | |
660 | { | |
661 | assemble_external ($$); | |
662 | TREE_USED ($$) = 1; | |
663 | ifobjc | |
664 | /* we have a definition - still check if iVariable */ | |
665 | ||
666 | if (!objc_receiver_context | |
667 | || (objc_receiver_context | |
668 | && strcmp (IDENTIFIER_POINTER ($1), "super"))) | |
669 | { | |
e31c7eec TW |
670 | tree decl; |
671 | ||
028299c6 | 672 | if (objc_method_context |
e31c7eec | 673 | && (decl = is_ivar (objc_ivar_chain, $1))) |
028299c6 RS |
674 | { |
675 | if (IDENTIFIER_LOCAL_VALUE ($1)) | |
676 | warning ("local declaration of `%s' hides instance variable", | |
677 | IDENTIFIER_POINTER ($1)); | |
678 | else | |
e31c7eec TW |
679 | { |
680 | if (is_private (decl)) | |
681 | $$ = error_mark_node; | |
682 | else | |
683 | $$ = build_ivar_reference ($1); | |
684 | } | |
028299c6 RS |
685 | } |
686 | } | |
687 | else /* we have a message to super */ | |
688 | $$ = get_super_receiver (); | |
689 | end ifobjc | |
690 | } | |
691 | ||
692 | if (TREE_CODE ($$) == CONST_DECL) | |
693 | { | |
694 | $$ = DECL_INITIAL ($$); | |
695 | /* This is to prevent an enum whose value is 0 | |
696 | from being considered a null pointer constant. */ | |
697 | $$ = build1 (NOP_EXPR, TREE_TYPE ($$), $$); | |
698 | TREE_CONSTANT ($$) = 1; | |
699 | } | |
700 | } | |
701 | | CONSTANT | |
702 | | string | |
703 | { $$ = combine_strings ($1); } | |
704 | | '(' expr ')' | |
705 | { char class = TREE_CODE_CLASS (TREE_CODE ($2)); | |
706 | if (class == 'e' || class == '1' | |
707 | || class == '2' || class == '<') | |
708 | C_SET_EXP_ORIGINAL_CODE ($2, ERROR_MARK); | |
709 | $$ = $2; } | |
710 | | '(' error ')' | |
711 | { $$ = error_mark_node; } | |
712 | | '(' | |
713 | { if (current_function_decl == 0) | |
714 | { | |
715 | error ("braced-group within expression allowed only inside a function"); | |
716 | YYERROR; | |
717 | } | |
718 | /* We must force a BLOCK for this level | |
719 | so that, if it is not expanded later, | |
720 | there is a way to turn off the entire subtree of blocks | |
721 | that are contained in it. */ | |
722 | keep_next_level (); | |
b490c40d | 723 | push_iterator_stack (); |
028299c6 RS |
724 | push_label_level (); |
725 | $<ttype>$ = expand_start_stmt_expr (); } | |
726 | compstmt ')' | |
727 | { tree rtl_exp; | |
728 | if (pedantic) | |
729 | pedwarn ("ANSI C forbids braced-groups within expressions"); | |
b490c40d | 730 | pop_iterator_stack (); |
028299c6 RS |
731 | pop_label_level (); |
732 | rtl_exp = expand_end_stmt_expr ($<ttype>2); | |
733 | /* The statements have side effects, so the group does. */ | |
734 | TREE_SIDE_EFFECTS (rtl_exp) = 1; | |
735 | ||
982a975e RS |
736 | if (TREE_CODE ($3) == BLOCK) |
737 | { | |
738 | /* Make a BIND_EXPR for the BLOCK already made. */ | |
739 | $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp), | |
740 | NULL_TREE, rtl_exp, $3); | |
741 | /* Remove the block from the tree at this point. | |
742 | It gets put back at the proper place | |
743 | when the BIND_EXPR is expanded. */ | |
744 | delete_block ($3); | |
745 | } | |
746 | else | |
747 | $$ = $3; | |
028299c6 RS |
748 | } |
749 | | primary '(' exprlist ')' %prec '.' | |
750 | { $$ = build_function_call ($1, $3); } | |
751 | | primary '[' expr ']' %prec '.' | |
752 | { $$ = build_array_ref ($1, $3); } | |
753 | | primary '.' identifier | |
754 | { | |
755 | ifobjc | |
756 | if (doing_objc_thang) | |
757 | { | |
758 | if (is_public ($1, $3)) | |
759 | $$ = build_component_ref ($1, $3); | |
760 | else | |
761 | $$ = error_mark_node; | |
762 | } | |
763 | else | |
764 | end ifobjc | |
765 | $$ = build_component_ref ($1, $3); | |
766 | } | |
767 | | primary POINTSAT identifier | |
768 | { | |
769 | tree expr = build_indirect_ref ($1, "->"); | |
770 | ||
771 | ifobjc | |
772 | if (doing_objc_thang) | |
773 | { | |
774 | if (is_public (expr, $3)) | |
775 | $$ = build_component_ref (expr, $3); | |
776 | else | |
777 | $$ = error_mark_node; | |
778 | } | |
779 | else | |
780 | end ifobjc | |
781 | $$ = build_component_ref (expr, $3); | |
782 | } | |
783 | | primary PLUSPLUS | |
784 | { $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); } | |
785 | | primary MINUSMINUS | |
786 | { $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); } | |
787 | ifobjc | |
788 | | objcmessageexpr | |
789 | { $$ = build_message_expr ($1); } | |
790 | | objcselectorexpr | |
791 | { $$ = build_selector_expr ($1); } | |
e31c7eec TW |
792 | | objcprotocolexpr |
793 | { $$ = build_protocol_expr ($1); } | |
028299c6 RS |
794 | | objcencodeexpr |
795 | { $$ = build_encode_expr ($1); } | |
e31c7eec TW |
796 | | objc_string |
797 | { $$ = build_objc_string_object ($1); } | |
028299c6 RS |
798 | end ifobjc |
799 | ; | |
800 | ||
801 | /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */ | |
802 | string: | |
803 | STRING | |
804 | | string STRING | |
805 | { $$ = chainon ($1, $2); } | |
806 | ; | |
807 | ||
e31c7eec TW |
808 | ifobjc |
809 | /* Produces an OBJC_STRING_CST with prehaps more OBJC_STRING_CSTs chained | |
810 | onto it. */ | |
811 | objc_string: | |
812 | OBJC_STRING | |
813 | | objc_string OBJC_STRING | |
814 | { $$ = chainon ($1, $2); } | |
815 | ; | |
816 | end ifobjc | |
817 | ||
028299c6 RS |
818 | xdecls: |
819 | /* empty */ | |
820 | | datadecls | |
821 | | datadecls ELLIPSIS | |
822 | /* ... is used here to indicate a varargs function. */ | |
823 | { c_mark_varargs (); | |
824 | if (pedantic) | |
825 | pedwarn ("ANSI C does not permit use of `varargs.h'"); } | |
826 | ; | |
827 | ||
828 | /* The following are analogous to lineno_decl, decls and decl | |
829 | except that they do not allow nested functions. | |
830 | They are used for old-style parm decls. */ | |
831 | lineno_datadecl: | |
832 | save_filename save_lineno datadecl | |
833 | { } | |
834 | ; | |
835 | ||
836 | datadecls: | |
837 | lineno_datadecl | |
838 | | errstmt | |
839 | | datadecls lineno_datadecl | |
840 | | lineno_datadecl errstmt | |
841 | ; | |
842 | ||
843 | datadecl: | |
844 | typed_declspecs setspecs initdecls ';' | |
845 | { current_declspecs = TREE_VALUE (declspec_stack); | |
846 | declspec_stack = TREE_CHAIN (declspec_stack); | |
847 | resume_momentary ($2); } | |
848 | | declmods setspecs notype_initdecls ';' | |
849 | { current_declspecs = TREE_VALUE (declspec_stack); | |
850 | declspec_stack = TREE_CHAIN (declspec_stack); | |
851 | resume_momentary ($2); } | |
852 | | typed_declspecs ';' | |
853 | { shadow_tag_warned ($1, 1); | |
854 | pedwarn ("empty declaration"); } | |
855 | | declmods ';' | |
856 | { pedwarn ("empty declaration"); } | |
857 | ; | |
858 | ||
859 | /* This combination which saves a lineno before a decl | |
860 | is the normal thing to use, rather than decl itself. | |
861 | This is to avoid shift/reduce conflicts in contexts | |
862 | where statement labels are allowed. */ | |
863 | lineno_decl: | |
864 | save_filename save_lineno decl | |
865 | { } | |
866 | ; | |
867 | ||
868 | decls: | |
869 | lineno_decl | |
870 | | errstmt | |
871 | | decls lineno_decl | |
872 | | lineno_decl errstmt | |
873 | ; | |
874 | ||
875 | /* records the type and storage class specs to use for processing | |
876 | the declarators that follow. | |
877 | Maintains a stack of outer-level values of current_declspecs, | |
878 | for the sake of parm declarations nested in function declarators. */ | |
879 | setspecs: /* empty */ | |
880 | { $$ = suspend_momentary (); | |
881 | pending_xref_error (); | |
882 | declspec_stack = tree_cons (NULL_TREE, current_declspecs, | |
883 | declspec_stack); | |
884 | current_declspecs = $<ttype>0; } | |
885 | ; | |
886 | ||
887 | decl: | |
888 | typed_declspecs setspecs initdecls ';' | |
889 | { current_declspecs = TREE_VALUE (declspec_stack); | |
890 | declspec_stack = TREE_CHAIN (declspec_stack); | |
891 | resume_momentary ($2); } | |
892 | | declmods setspecs notype_initdecls ';' | |
893 | { current_declspecs = TREE_VALUE (declspec_stack); | |
894 | declspec_stack = TREE_CHAIN (declspec_stack); | |
895 | resume_momentary ($2); } | |
896 | | typed_declspecs setspecs nested_function | |
897 | { current_declspecs = TREE_VALUE (declspec_stack); | |
898 | declspec_stack = TREE_CHAIN (declspec_stack); | |
899 | resume_momentary ($2); } | |
900 | | declmods setspecs notype_nested_function | |
901 | { current_declspecs = TREE_VALUE (declspec_stack); | |
902 | declspec_stack = TREE_CHAIN (declspec_stack); | |
903 | resume_momentary ($2); } | |
904 | | typed_declspecs ';' | |
905 | { shadow_tag ($1); } | |
906 | | declmods ';' | |
907 | { pedwarn ("empty declaration"); } | |
908 | ; | |
909 | ||
910 | /* Declspecs which contain at least one type specifier or typedef name. | |
911 | (Just `const' or `volatile' is not enough.) | |
912 | A typedef'd name following these is taken as a name to be declared. */ | |
913 | ||
914 | typed_declspecs: | |
915 | typespec reserved_declspecs | |
916 | { $$ = tree_cons (NULL_TREE, $1, $2); } | |
917 | | declmods typespec reserved_declspecs | |
918 | { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); } | |
919 | ; | |
920 | ||
921 | reserved_declspecs: /* empty */ | |
922 | { $$ = NULL_TREE; } | |
923 | | reserved_declspecs typespecqual_reserved | |
924 | { $$ = tree_cons (NULL_TREE, $2, $1); } | |
925 | | reserved_declspecs SCSPEC | |
926 | { if (extra_warnings) | |
927 | warning ("`%s' is not at beginning of declaration", | |
928 | IDENTIFIER_POINTER ($2)); | |
929 | $$ = tree_cons (NULL_TREE, $2, $1); } | |
930 | ; | |
931 | ||
932 | /* List of just storage classes and type modifiers. | |
933 | A declaration can start with just this, but then it cannot be used | |
934 | to redeclare a typedef-name. */ | |
935 | ||
936 | declmods: | |
937 | TYPE_QUAL | |
938 | { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); | |
939 | TREE_STATIC ($$) = 1; } | |
940 | | SCSPEC | |
941 | { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); } | |
942 | | declmods TYPE_QUAL | |
943 | { $$ = tree_cons (NULL_TREE, $2, $1); | |
944 | TREE_STATIC ($$) = 1; } | |
945 | | declmods SCSPEC | |
946 | { if (extra_warnings && TREE_STATIC ($1)) | |
947 | warning ("`%s' is not at beginning of declaration", | |
948 | IDENTIFIER_POINTER ($2)); | |
949 | $$ = tree_cons (NULL_TREE, $2, $1); | |
950 | TREE_STATIC ($$) = TREE_STATIC ($1); } | |
951 | ; | |
952 | ||
953 | ||
954 | /* Used instead of declspecs where storage classes are not allowed | |
955 | (that is, for typenames and structure components). | |
956 | Don't accept a typedef-name if anything but a modifier precedes it. */ | |
957 | ||
958 | typed_typespecs: | |
959 | typespec reserved_typespecquals | |
960 | { $$ = tree_cons (NULL_TREE, $1, $2); } | |
961 | | nonempty_type_quals typespec reserved_typespecquals | |
962 | { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); } | |
963 | ; | |
964 | ||
965 | reserved_typespecquals: /* empty */ | |
966 | { $$ = NULL_TREE; } | |
967 | | reserved_typespecquals typespecqual_reserved | |
968 | { $$ = tree_cons (NULL_TREE, $2, $1); } | |
969 | ; | |
970 | ||
971 | /* A typespec (but not a type qualifier). | |
972 | Once we have seen one of these in a declaration, | |
973 | if a typedef name appears then it is being redeclared. */ | |
974 | ||
975 | typespec: TYPESPEC | |
976 | | structsp | |
977 | | TYPENAME | |
978 | { /* For a typedef name, record the meaning, not the name. | |
979 | In case of `foo foo, bar;'. */ | |
980 | $$ = lookup_name ($1); } | |
981 | ifobjc | |
e31c7eec TW |
982 | | CLASSNAME protocolrefs |
983 | { $$ = get_static_reference ($1, $2); } | |
984 | | OBJECTNAME protocolrefs | |
985 | { $$ = get_object_reference ($2); } | |
028299c6 RS |
986 | end ifobjc |
987 | | TYPEOF '(' expr ')' | |
988 | { $$ = TREE_TYPE ($3); } | |
989 | | TYPEOF '(' typename ')' | |
990 | { $$ = groktypename ($3); } | |
991 | ; | |
992 | ||
993 | /* A typespec that is a reserved word, or a type qualifier. */ | |
994 | ||
995 | typespecqual_reserved: TYPESPEC | |
996 | | TYPE_QUAL | |
997 | | structsp | |
998 | ; | |
999 | ||
1000 | initdecls: | |
1001 | initdcl | |
1002 | | initdecls ',' initdcl | |
1003 | ; | |
1004 | ||
1005 | notype_initdecls: | |
1006 | notype_initdcl | |
1007 | | notype_initdecls ',' initdcl | |
1008 | ; | |
1009 | ||
1010 | maybeasm: | |
1011 | /* empty */ | |
1012 | { $$ = NULL_TREE; } | |
1013 | | ASM_KEYWORD '(' string ')' | |
1014 | { if (TREE_CHAIN ($3)) $3 = combine_strings ($3); | |
1015 | $$ = $3; | |
1016 | } | |
1017 | ; | |
1018 | ||
1019 | initdcl: | |
1020 | declarator maybeasm maybe_attribute '=' | |
42e651a6 | 1021 | { $<ttype>$ = start_decl ($1, current_declspecs, 1); |
aa2e6789 | 1022 | decl_attributes ($<ttype>$, $3); |
6126f4db | 1023 | start_init ($<ttype>$, $2, global_bindings_p ()); } |
028299c6 RS |
1024 | init |
1025 | /* Note how the declaration of the variable is in effect while its init is parsed! */ | |
42e651a6 RS |
1026 | { finish_init (); |
1027 | decl_attributes ($<ttype>5, $3); | |
6126f4db | 1028 | finish_decl ($<ttype>5, $6, $2); } |
028299c6 RS |
1029 | | declarator maybeasm maybe_attribute |
1030 | { tree d = start_decl ($1, current_declspecs, 0); | |
1031 | decl_attributes (d, $3); | |
1032 | finish_decl (d, NULL_TREE, $2); } | |
1033 | ; | |
1034 | ||
1035 | notype_initdcl: | |
1036 | notype_declarator maybeasm maybe_attribute '=' | |
42e651a6 | 1037 | { $<ttype>$ = start_decl ($1, current_declspecs, 1); |
aa2e6789 | 1038 | decl_attributes ($<ttype>$, $3); |
6126f4db | 1039 | start_init ($<ttype>$, $2, global_bindings_p ()); } |
028299c6 RS |
1040 | init |
1041 | /* Note how the declaration of the variable is in effect while its init is parsed! */ | |
42e651a6 RS |
1042 | { finish_init (); |
1043 | decl_attributes ($<ttype>5, $3); | |
6126f4db | 1044 | finish_decl ($<ttype>5, $6, $2); } |
028299c6 RS |
1045 | | notype_declarator maybeasm maybe_attribute |
1046 | { tree d = start_decl ($1, current_declspecs, 0); | |
1047 | decl_attributes (d, $3); | |
1048 | finish_decl (d, NULL_TREE, $2); } | |
1049 | ; | |
1050 | /* the * rules are dummies to accept the Apollo extended syntax | |
1051 | so that the header files compile. */ | |
1052 | maybe_attribute: | |
660b43c8 RK |
1053 | /* empty */ |
1054 | { $$ = NULL_TREE; } | |
1055 | | attributes | |
1056 | { $$ = $1; } | |
1057 | ; | |
1058 | ||
1059 | attributes: | |
1060 | attribute | |
1061 | { $$ = $1; } | |
1062 | | attributes attribute | |
1063 | { $$ = chainon ($1, $2); } | |
1064 | ; | |
1065 | ||
1066 | attribute: | |
1067 | ATTRIBUTE '(' '(' attribute_list ')' ')' | |
1068 | { $$ = $4; } | |
1069 | ; | |
1070 | ||
1071 | attribute_list: | |
1072 | attrib | |
1073 | { $$ = build_tree_list (NULL_TREE, $1); } | |
1074 | | attribute_list ',' attrib | |
1075 | { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } | |
1076 | ; | |
1077 | ||
1078 | attrib: | |
028299c6 RS |
1079 | /* empty */ |
1080 | { $$ = NULL_TREE; } | |
660b43c8 RK |
1081 | | any_word |
1082 | { $$ = $1; } | |
1083 | | any_word '(' IDENTIFIER ')' | |
1084 | { $$ = tree_cons ($1, NULL_TREE, | |
1085 | build_tree_list (NULL_TREE, $3)); } | |
1086 | | any_word '(' IDENTIFIER ',' nonnull_exprlist ')' | |
1087 | { $$ = tree_cons ($1, NULL_TREE, | |
1088 | tree_cons (NULL_TREE, $3, $5)); } | |
1089 | | any_word '(' nonnull_exprlist ')' | |
1090 | { $$ = tree_cons ($1, NULL_TREE, $3); } | |
1091 | ; | |
1092 | ||
1093 | /* This still leaves out most reserved keywords, | |
1094 | shouldn't we include them? */ | |
1095 | ||
1096 | any_word: | |
1097 | identifier | |
1098 | | SCSPEC | |
1099 | | TYPESPEC | |
1100 | | TYPE_QUAL | |
1101 | ; | |
42e651a6 RS |
1102 | \f |
1103 | /* Initializers. `init' is the entry point. */ | |
028299c6 RS |
1104 | |
1105 | init: | |
1106 | expr_no_commas | |
42e651a6 | 1107 | | '{' |
6126f4db RS |
1108 | { really_start_incremental_init (NULL_TREE); |
1109 | /* Note that the call to clear_momentary | |
1110 | is in process_init_element. */ | |
1111 | push_momentary (); } | |
42e651a6 | 1112 | initlist_maybe_comma '}' |
6126f4db | 1113 | { $$ = pop_init_level (0); |
9d4e73d6 RK |
1114 | if ($$ == error_mark_node |
1115 | && ! (yychar == STRING || yychar == CONSTANT)) | |
6126f4db RS |
1116 | pop_momentary (); |
1117 | else | |
1118 | pop_momentary_nofree (); } | |
1119 | ||
028299c6 | 1120 | | error |
e1eb754f | 1121 | { $$ = error_mark_node; } |
028299c6 RS |
1122 | ; |
1123 | ||
42e651a6 RS |
1124 | /* `initlist_maybe_comma' is the guts of an initializer in braces. */ |
1125 | initlist_maybe_comma: | |
1126 | /* empty */ | |
1127 | { if (pedantic) | |
1128 | pedwarn ("ANSI C forbids empty initializer braces"); } | |
1129 | | initlist1 maybecomma | |
1130 | ; | |
1131 | ||
1132 | initlist1: | |
1133 | initelt | |
1134 | | initlist1 ',' initelt | |
1135 | ; | |
1136 | ||
1137 | /* `initelt' is a single element of an initializer. | |
1138 | It may use braces. */ | |
1139 | initelt: | |
1140 | expr_no_commas | |
1141 | { process_init_element ($1); } | |
1142 | | '{' | |
1143 | { push_init_level (0); } | |
1144 | initlist_maybe_comma '}' | |
1145 | { process_init_element (pop_init_level (0)); } | |
1146 | | error | |
e31c7eec TW |
1147 | /* These are for labeled elements. The syntax for an array element |
1148 | initializer conflicts with the syntax for an Objective-C message, | |
1149 | so don't include these productions in the Objective-C grammer. */ | |
1150 | ifc | |
42e651a6 RS |
1151 | | '[' expr_no_commas ELLIPSIS expr_no_commas ']' '=' |
1152 | { set_init_index ($2, $4); } | |
1153 | initelt | |
1154 | | '[' expr_no_commas ']' '=' | |
1155 | { set_init_index ($2, NULL_TREE); } | |
1156 | initelt | |
a78bdb8e RK |
1157 | | '[' expr_no_commas ']' |
1158 | { set_init_index ($2, NULL_TREE); } | |
1159 | initelt | |
e31c7eec | 1160 | end ifc |
42e651a6 RS |
1161 | | identifier ':' |
1162 | { set_init_label ($1); } | |
1163 | initelt | |
1164 | | '.' identifier '=' | |
1165 | { set_init_label ($2); } | |
1166 | initelt | |
028299c6 | 1167 | ; |
42e651a6 | 1168 | \f |
028299c6 RS |
1169 | nested_function: |
1170 | declarator | |
1171 | { push_c_function_context (); | |
1172 | if (! start_function (current_declspecs, $1, 1)) | |
1173 | { | |
1174 | pop_c_function_context (); | |
1175 | YYERROR1; | |
1176 | } | |
1177 | reinit_parse_for_function (); | |
1178 | store_parm_decls (); } | |
1179 | /* This used to use compstmt_or_error. | |
1180 | That caused a bug with input `f(g) int g {}', | |
1181 | where the use of YYERROR1 above caused an error | |
1182 | which then was handled by compstmt_or_error. | |
1183 | There followed a repeated execution of that same rule, | |
1184 | which called YYERROR1 again, and so on. */ | |
1185 | compstmt | |
1186 | { finish_function (1); | |
1187 | pop_c_function_context (); } | |
1188 | ; | |
1189 | ||
1190 | notype_nested_function: | |
1191 | notype_declarator | |
1192 | { push_c_function_context (); | |
1193 | if (! start_function (current_declspecs, $1, 1)) | |
1194 | { | |
1195 | pop_c_function_context (); | |
1196 | YYERROR1; | |
1197 | } | |
1198 | reinit_parse_for_function (); | |
1199 | store_parm_decls (); } | |
1200 | /* This used to use compstmt_or_error. | |
1201 | That caused a bug with input `f(g) int g {}', | |
1202 | where the use of YYERROR1 above caused an error | |
1203 | which then was handled by compstmt_or_error. | |
1204 | There followed a repeated execution of that same rule, | |
1205 | which called YYERROR1 again, and so on. */ | |
1206 | compstmt | |
1207 | { finish_function (1); | |
1208 | pop_c_function_context (); } | |
1209 | ; | |
1210 | ||
1211 | /* Any kind of declarator (thus, all declarators allowed | |
1212 | after an explicit typespec). */ | |
1213 | ||
1214 | declarator: | |
1215 | after_type_declarator | |
1216 | | notype_declarator | |
1217 | ; | |
1218 | ||
1219 | /* A declarator that is allowed only after an explicit typespec. */ | |
1220 | ||
1221 | after_type_declarator: | |
1222 | '(' after_type_declarator ')' | |
1223 | { $$ = $2; } | |
1224 | | after_type_declarator '(' parmlist_or_identifiers %prec '.' | |
1225 | { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } | |
1226 | /* | after_type_declarator '(' error ')' %prec '.' | |
1227 | { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); | |
1228 | poplevel (0, 0, 0); } */ | |
1229 | | after_type_declarator '[' expr ']' %prec '.' | |
1230 | { $$ = build_nt (ARRAY_REF, $1, $3); } | |
1231 | | after_type_declarator '[' ']' %prec '.' | |
1232 | { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } | |
1233 | | '*' type_quals after_type_declarator %prec UNARY | |
1234 | { $$ = make_pointer_declarator ($2, $3); } | |
1235 | | TYPENAME | |
e31c7eec TW |
1236 | ifobjc |
1237 | | OBJECTNAME | |
1238 | end ifobjc | |
028299c6 RS |
1239 | ; |
1240 | ||
1241 | /* Kinds of declarator that can appear in a parameter list | |
1242 | in addition to notype_declarator. This is like after_type_declarator | |
1243 | but does not allow a typedef name in parentheses as an identifier | |
1244 | (because it would conflict with a function with that typedef as arg). */ | |
1245 | ||
1246 | parm_declarator: | |
1247 | parm_declarator '(' parmlist_or_identifiers %prec '.' | |
1248 | { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } | |
1249 | /* | parm_declarator '(' error ')' %prec '.' | |
1250 | { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); | |
1251 | poplevel (0, 0, 0); } */ | |
1252 | | parm_declarator '[' expr ']' %prec '.' | |
1253 | { $$ = build_nt (ARRAY_REF, $1, $3); } | |
1254 | | parm_declarator '[' ']' %prec '.' | |
1255 | { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } | |
1256 | | '*' type_quals parm_declarator %prec UNARY | |
1257 | { $$ = make_pointer_declarator ($2, $3); } | |
1258 | | TYPENAME | |
1259 | ; | |
1260 | ||
1261 | /* A declarator allowed whether or not there has been | |
1262 | an explicit typespec. These cannot redeclare a typedef-name. */ | |
1263 | ||
1264 | notype_declarator: | |
1265 | notype_declarator '(' parmlist_or_identifiers %prec '.' | |
1266 | { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } | |
1267 | /* | notype_declarator '(' error ')' %prec '.' | |
1268 | { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); | |
1269 | poplevel (0, 0, 0); } */ | |
1270 | | '(' notype_declarator ')' | |
1271 | { $$ = $2; } | |
1272 | | '*' type_quals notype_declarator %prec UNARY | |
1273 | { $$ = make_pointer_declarator ($2, $3); } | |
1274 | | notype_declarator '[' expr ']' %prec '.' | |
1275 | { $$ = build_nt (ARRAY_REF, $1, $3); } | |
1276 | | notype_declarator '[' ']' %prec '.' | |
1277 | { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } | |
1278 | | IDENTIFIER | |
1279 | ; | |
1280 | ||
1281 | structsp: | |
1282 | STRUCT identifier '{' | |
1283 | { $$ = start_struct (RECORD_TYPE, $2); | |
1284 | /* Start scope of tag before parsing components. */ | |
1285 | } | |
1286 | component_decl_list '}' | |
1287 | { $$ = finish_struct ($<ttype>4, $5); | |
1288 | /* Really define the structure. */ | |
1289 | } | |
1290 | | STRUCT '{' component_decl_list '}' | |
1291 | { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE), | |
1292 | $3); } | |
1293 | | STRUCT identifier | |
1294 | { $$ = xref_tag (RECORD_TYPE, $2); } | |
1295 | | UNION identifier '{' | |
1296 | { $$ = start_struct (UNION_TYPE, $2); } | |
1297 | component_decl_list '}' | |
1298 | { $$ = finish_struct ($<ttype>4, $5); } | |
1299 | | UNION '{' component_decl_list '}' | |
1300 | { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE), | |
1301 | $3); } | |
1302 | | UNION identifier | |
1303 | { $$ = xref_tag (UNION_TYPE, $2); } | |
1304 | | ENUM identifier '{' | |
1305 | { $<itype>3 = suspend_momentary (); | |
1306 | $$ = start_enum ($2); } | |
1307 | enumlist maybecomma_warn '}' | |
1308 | { $$ = finish_enum ($<ttype>4, nreverse ($5)); | |
1309 | resume_momentary ($<itype>3); } | |
1310 | | ENUM '{' | |
1311 | { $<itype>2 = suspend_momentary (); | |
1312 | $$ = start_enum (NULL_TREE); } | |
1313 | enumlist maybecomma_warn '}' | |
1314 | { $$ = finish_enum ($<ttype>3, nreverse ($4)); | |
1315 | resume_momentary ($<itype>2); } | |
1316 | | ENUM identifier | |
1317 | { $$ = xref_tag (ENUMERAL_TYPE, $2); } | |
1318 | ; | |
1319 | ||
1320 | maybecomma: | |
1321 | /* empty */ | |
1322 | | ',' | |
1323 | ; | |
1324 | ||
1325 | maybecomma_warn: | |
1326 | /* empty */ | |
1327 | | ',' | |
1328 | { if (pedantic) pedwarn ("comma at end of enumerator list"); } | |
1329 | ; | |
1330 | ||
1331 | component_decl_list: | |
1332 | component_decl_list2 | |
1333 | { $$ = $1; } | |
1334 | | component_decl_list2 component_decl | |
1335 | { $$ = chainon ($1, $2); | |
ee759b21 | 1336 | pedwarn ("no semicolon at end of struct or union"); } |
028299c6 RS |
1337 | ; |
1338 | ||
1339 | component_decl_list2: /* empty */ | |
1340 | { $$ = NULL_TREE; } | |
1341 | | component_decl_list2 component_decl ';' | |
1342 | { $$ = chainon ($1, $2); } | |
1343 | | component_decl_list2 ';' | |
1344 | { if (pedantic) | |
1345 | pedwarn ("extra semicolon in struct or union specified"); } | |
1346 | ifobjc | |
1347 | /* foo(sizeof(struct{ @defs(ClassName)})); */ | |
1348 | | DEFS '(' CLASSNAME ')' | |
e31c7eec TW |
1349 | { |
1350 | tree interface = lookup_interface ($3); | |
1351 | ||
1352 | if (interface) | |
1353 | $$ = get_class_ivars (interface); | |
1354 | else | |
1355 | { | |
1356 | error ("Cannot find interface declaration for `%s'", | |
1357 | IDENTIFIER_POINTER ($3)); | |
1358 | $$ = NULL_TREE; | |
1359 | } | |
1360 | } | |
028299c6 RS |
1361 | end ifobjc |
1362 | ; | |
1363 | ||
1364 | /* There is a shift-reduce conflict here, because `components' may | |
1365 | start with a `typename'. It happens that shifting (the default resolution) | |
1366 | does the right thing, because it treats the `typename' as part of | |
1367 | a `typed_typespecs'. | |
1368 | ||
1369 | It is possible that this same technique would allow the distinction | |
1370 | between `notype_initdecls' and `initdecls' to be eliminated. | |
1371 | But I am being cautious and not trying it. */ | |
1372 | ||
1373 | component_decl: | |
1374 | typed_typespecs setspecs components | |
1375 | { $$ = $3; | |
1376 | current_declspecs = TREE_VALUE (declspec_stack); | |
1377 | declspec_stack = TREE_CHAIN (declspec_stack); | |
1378 | resume_momentary ($2); } | |
1379 | | typed_typespecs | |
1380 | { if (pedantic) | |
1381 | pedwarn ("ANSI C forbids member declarations with no members"); | |
1382 | shadow_tag($1); | |
1383 | $$ = NULL_TREE; } | |
1384 | | nonempty_type_quals setspecs components | |
1385 | { $$ = $3; | |
1386 | current_declspecs = TREE_VALUE (declspec_stack); | |
1387 | declspec_stack = TREE_CHAIN (declspec_stack); | |
1388 | resume_momentary ($2); } | |
1389 | | nonempty_type_quals | |
1390 | { if (pedantic) | |
1391 | pedwarn ("ANSI C forbids member declarations with no members"); | |
1392 | shadow_tag($1); | |
1393 | $$ = NULL_TREE; } | |
1394 | | error | |
1395 | { $$ = NULL_TREE; } | |
1396 | ; | |
1397 | ||
1398 | components: | |
1399 | component_declarator | |
1400 | | components ',' component_declarator | |
1401 | { $$ = chainon ($1, $3); } | |
1402 | ; | |
1403 | ||
1404 | component_declarator: | |
1405 | save_filename save_lineno declarator maybe_attribute | |
1406 | { $$ = grokfield ($1, $2, $3, current_declspecs, NULL_TREE); | |
1407 | decl_attributes ($$, $4); } | |
1408 | | save_filename save_lineno | |
1409 | declarator ':' expr_no_commas maybe_attribute | |
1410 | { $$ = grokfield ($1, $2, $3, current_declspecs, $5); | |
1411 | decl_attributes ($$, $6); } | |
e8f1efb2 RS |
1412 | | save_filename save_lineno ':' expr_no_commas maybe_attribute |
1413 | { $$ = grokfield ($1, $2, NULL_TREE, current_declspecs, $4); | |
1414 | decl_attributes ($$, $5); } | |
028299c6 RS |
1415 | ; |
1416 | ||
1417 | /* We chain the enumerators in reverse order. | |
1418 | They are put in forward order where enumlist is used. | |
1419 | (The order used to be significant, but no longer is so. | |
1420 | However, we still maintain the order, just to be clean.) */ | |
1421 | ||
1422 | enumlist: | |
1423 | enumerator | |
1424 | | enumlist ',' enumerator | |
1425 | { $$ = chainon ($3, $1); } | |
adc3b521 RS |
1426 | | error |
1427 | { $$ = error_mark_node; } | |
028299c6 RS |
1428 | ; |
1429 | ||
1430 | ||
1431 | enumerator: | |
1432 | identifier | |
1433 | { $$ = build_enumerator ($1, NULL_TREE); } | |
1434 | | identifier '=' expr_no_commas | |
1435 | { $$ = build_enumerator ($1, $3); } | |
1436 | ; | |
1437 | ||
1438 | typename: | |
1439 | typed_typespecs absdcl | |
1440 | { $$ = build_tree_list ($1, $2); } | |
1441 | | nonempty_type_quals absdcl | |
1442 | { $$ = build_tree_list ($1, $2); } | |
1443 | ; | |
1444 | ||
1445 | absdcl: /* an absolute declarator */ | |
1446 | /* empty */ | |
1447 | { $$ = NULL_TREE; } | |
1448 | | absdcl1 | |
1449 | ; | |
1450 | ||
1451 | nonempty_type_quals: | |
1452 | TYPE_QUAL | |
1453 | { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); } | |
1454 | | nonempty_type_quals TYPE_QUAL | |
1455 | { $$ = tree_cons (NULL_TREE, $2, $1); } | |
1456 | ; | |
1457 | ||
1458 | type_quals: | |
1459 | /* empty */ | |
1460 | { $$ = NULL_TREE; } | |
1461 | | type_quals TYPE_QUAL | |
1462 | { $$ = tree_cons (NULL_TREE, $2, $1); } | |
1463 | ; | |
1464 | ||
1465 | absdcl1: /* a nonempty absolute declarator */ | |
1466 | '(' absdcl1 ')' | |
1467 | { $$ = $2; } | |
1468 | /* `(typedef)1' is `int'. */ | |
1469 | | '*' type_quals absdcl1 %prec UNARY | |
1470 | { $$ = make_pointer_declarator ($2, $3); } | |
1471 | | '*' type_quals %prec UNARY | |
1472 | { $$ = make_pointer_declarator ($2, NULL_TREE); } | |
1473 | | absdcl1 '(' parmlist %prec '.' | |
1474 | { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } | |
1475 | | absdcl1 '[' expr ']' %prec '.' | |
1476 | { $$ = build_nt (ARRAY_REF, $1, $3); } | |
1477 | | absdcl1 '[' ']' %prec '.' | |
1478 | { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } | |
1479 | | '(' parmlist %prec '.' | |
1480 | { $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); } | |
1481 | | '[' expr ']' %prec '.' | |
1482 | { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); } | |
1483 | | '[' ']' %prec '.' | |
1484 | { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); } | |
1485 | ; | |
1486 | ||
1487 | /* at least one statement, the first of which parses without error. */ | |
1488 | /* stmts is used only after decls, so an invalid first statement | |
1489 | is actually regarded as an invalid decl and part of the decls. */ | |
1490 | ||
1491 | stmts: | |
1492 | lineno_stmt_or_label | |
1493 | | stmts lineno_stmt_or_label | |
1494 | | stmts errstmt | |
1495 | ; | |
1496 | ||
1497 | xstmts: | |
1498 | /* empty */ | |
1499 | | stmts | |
1500 | ; | |
1501 | ||
1502 | errstmt: error ';' | |
1503 | ; | |
1504 | ||
1505 | pushlevel: /* empty */ | |
1506 | { emit_line_note (input_filename, lineno); | |
1507 | pushlevel (0); | |
1508 | clear_last_expr (); | |
1509 | push_momentary (); | |
1510 | expand_start_bindings (0); | |
1511 | ifobjc | |
1512 | if (objc_method_context) | |
1513 | add_objc_decls (); | |
1514 | end ifobjc | |
1515 | } | |
1516 | ; | |
1517 | ||
1518 | /* Read zero or more forward-declarations for labels | |
1519 | that nested functions can jump to. */ | |
1520 | maybe_label_decls: | |
1521 | /* empty */ | |
1522 | | label_decls | |
1523 | { if (pedantic) | |
1524 | pedwarn ("ANSI C forbids label declarations"); } | |
1525 | ; | |
1526 | ||
1527 | label_decls: | |
1528 | label_decl | |
1529 | | label_decls label_decl | |
1530 | ; | |
1531 | ||
1532 | label_decl: | |
1533 | LABEL identifiers_or_typenames ';' | |
1534 | { tree link; | |
1535 | for (link = $2; link; link = TREE_CHAIN (link)) | |
1536 | { | |
1537 | tree label = shadow_label (TREE_VALUE (link)); | |
1538 | C_DECLARED_LABEL_FLAG (label) = 1; | |
1539 | declare_nonlocal_label (label); | |
1540 | } | |
1541 | } | |
1542 | ; | |
1543 | ||
1544 | /* This is the body of a function definition. | |
1545 | It causes syntax errors to ignore to the next openbrace. */ | |
1546 | compstmt_or_error: | |
1547 | compstmt | |
1548 | {} | |
1549 | | error compstmt | |
1550 | ; | |
1551 | ||
1552 | compstmt: '{' '}' | |
1553 | { $$ = convert (void_type_node, integer_zero_node); } | |
1554 | | '{' pushlevel maybe_label_decls decls xstmts '}' | |
1555 | { emit_line_note (input_filename, lineno); | |
1556 | expand_end_bindings (getdecls (), 1, 0); | |
1557 | $$ = poplevel (1, 1, 0); | |
9d4e73d6 RK |
1558 | if (yychar == CONSTANT || yychar == STRING) |
1559 | pop_momentary_nofree (); | |
1560 | else | |
1561 | pop_momentary (); } | |
028299c6 RS |
1562 | | '{' pushlevel maybe_label_decls error '}' |
1563 | { emit_line_note (input_filename, lineno); | |
1564 | expand_end_bindings (getdecls (), kept_level_p (), 0); | |
1565 | $$ = poplevel (kept_level_p (), 0, 0); | |
9d4e73d6 RK |
1566 | if (yychar == CONSTANT || yychar == STRING) |
1567 | pop_momentary_nofree (); | |
1568 | else | |
1569 | pop_momentary (); } | |
028299c6 RS |
1570 | | '{' pushlevel maybe_label_decls stmts '}' |
1571 | { emit_line_note (input_filename, lineno); | |
1572 | expand_end_bindings (getdecls (), kept_level_p (), 0); | |
1573 | $$ = poplevel (kept_level_p (), 0, 0); | |
9d4e73d6 RK |
1574 | if (yychar == CONSTANT || yychar == STRING) |
1575 | pop_momentary_nofree (); | |
1576 | else | |
1577 | pop_momentary (); } | |
028299c6 RS |
1578 | ; |
1579 | ||
1580 | /* Value is number of statements counted as of the closeparen. */ | |
1581 | simple_if: | |
7f3d4b2f | 1582 | if_prefix lineno_labeled_stmt |
028299c6 RS |
1583 | /* Make sure expand_end_cond is run once |
1584 | for each call to expand_start_cond. | |
1585 | Otherwise a crash is likely. */ | |
1586 | | if_prefix error | |
1587 | ; | |
1588 | ||
1589 | if_prefix: | |
1590 | IF '(' expr ')' | |
1591 | { emit_line_note ($<filename>-1, $<lineno>0); | |
1592 | expand_start_cond (truthvalue_conversion ($3), 0); | |
7f3d4b2f | 1593 | $<itype>$ = stmt_count; |
028299c6 RS |
1594 | if_stmt_file = $<filename>-1; |
1595 | if_stmt_line = $<lineno>0; | |
1596 | position_after_white_space (); } | |
1597 | ; | |
1598 | ||
1599 | /* This is a subroutine of stmt. | |
1600 | It is used twice, once for valid DO statements | |
1601 | and once for catching errors in parsing the end test. */ | |
1602 | do_stmt_start: | |
1603 | DO | |
1604 | { stmt_count++; | |
1605 | emit_line_note ($<filename>-1, $<lineno>0); | |
1606 | /* See comment in `while' alternative, above. */ | |
1607 | emit_nop (); | |
1608 | expand_start_loop_continue_elsewhere (1); | |
1609 | position_after_white_space (); } | |
1610 | lineno_labeled_stmt WHILE | |
1611 | { expand_loop_continue_here (); } | |
1612 | ; | |
1613 | ||
1614 | save_filename: | |
1615 | { $$ = input_filename; } | |
1616 | ; | |
1617 | ||
1618 | save_lineno: | |
1619 | { $$ = lineno; } | |
1620 | ; | |
1621 | ||
1622 | lineno_labeled_stmt: | |
1623 | save_filename save_lineno stmt | |
1624 | { } | |
1625 | /* | save_filename save_lineno error | |
1626 | { } | |
1627 | */ | |
1628 | | save_filename save_lineno label lineno_labeled_stmt | |
1629 | { } | |
1630 | ; | |
1631 | ||
1632 | lineno_stmt_or_label: | |
1633 | save_filename save_lineno stmt_or_label | |
1634 | { } | |
1635 | ; | |
1636 | ||
1637 | stmt_or_label: | |
1638 | stmt | |
1639 | | label | |
1640 | { int next; | |
1641 | position_after_white_space (); | |
1642 | next = getc (finput); | |
1643 | ungetc (next, finput); | |
1644 | if (pedantic && next == '}') | |
1645 | pedwarn ("ANSI C forbids label at end of compound statement"); | |
1646 | } | |
1647 | ; | |
1648 | ||
1649 | /* Parse a single real statement, not including any labels. */ | |
1650 | stmt: | |
1651 | compstmt | |
1652 | { stmt_count++; } | |
b490c40d | 1653 | | all_iter_stmt |
028299c6 RS |
1654 | | expr ';' |
1655 | { stmt_count++; | |
1656 | emit_line_note ($<filename>-1, $<lineno>0); | |
bf0add70 RS |
1657 | /* It appears that this should not be done--that a non-lvalue array |
1658 | shouldn't get an error if the value isn't used. | |
1659 | Section 3.2.2.1 says that an array lvalue gets converted to a pointer | |
1660 | if it appears as a top-level expression, | |
1661 | but says nothing about non-lvalue arrays. */ | |
1662 | #if 0 | |
d8e29a65 RS |
1663 | /* Call default_conversion to get an error |
1664 | on referring to a register array if pedantic. */ | |
1665 | if (TREE_CODE (TREE_TYPE ($1)) == ARRAY_TYPE | |
1666 | || TREE_CODE (TREE_TYPE ($1)) == FUNCTION_TYPE) | |
1667 | $1 = default_conversion ($1); | |
bf0add70 | 1668 | #endif |
b490c40d | 1669 | iterator_expand ($1); |
028299c6 RS |
1670 | clear_momentary (); } |
1671 | | simple_if ELSE | |
1672 | { expand_start_else (); | |
1673 | $<itype>1 = stmt_count; | |
1674 | position_after_white_space (); } | |
1675 | lineno_labeled_stmt | |
1676 | { expand_end_cond (); | |
1677 | if (extra_warnings && stmt_count == $<itype>1) | |
1678 | warning ("empty body in an else-statement"); } | |
1679 | | simple_if %prec IF | |
7f3d4b2f JW |
1680 | { expand_end_cond (); |
1681 | /* This warning is here instead of in simple_if, because we | |
1682 | do not want a warning if an empty if is followed by an | |
218d0f8a RK |
1683 | else statement. Increment stmt_count so we don't |
1684 | give a second error if this is a nested `if'. */ | |
1685 | if (extra_warnings && stmt_count++ == $<itype>1) | |
7f3d4b2f JW |
1686 | warning_with_file_and_line (if_stmt_file, if_stmt_line, |
1687 | "empty body in an if-statement"); } | |
028299c6 RS |
1688 | /* Make sure expand_end_cond is run once |
1689 | for each call to expand_start_cond. | |
1690 | Otherwise a crash is likely. */ | |
1691 | | simple_if ELSE error | |
1692 | { expand_end_cond (); } | |
1693 | | WHILE | |
1694 | { stmt_count++; | |
1695 | emit_line_note ($<filename>-1, $<lineno>0); | |
1696 | /* The emit_nop used to come before emit_line_note, | |
1697 | but that made the nop seem like part of the preceding line. | |
1698 | And that was confusing when the preceding line was | |
1699 | inside of an if statement and was not really executed. | |
1700 | I think it ought to work to put the nop after the line number. | |
1701 | We will see. --rms, July 15, 1991. */ | |
1702 | emit_nop (); } | |
1703 | '(' expr ')' | |
1704 | { /* Don't start the loop till we have succeeded | |
1705 | in parsing the end test. This is to make sure | |
1706 | that we end every loop we start. */ | |
1707 | expand_start_loop (1); | |
1708 | emit_line_note (input_filename, lineno); | |
1709 | expand_exit_loop_if_false (NULL_PTR, | |
1710 | truthvalue_conversion ($4)); | |
1711 | position_after_white_space (); } | |
1712 | lineno_labeled_stmt | |
1713 | { expand_end_loop (); } | |
1714 | | do_stmt_start | |
1715 | '(' expr ')' ';' | |
1716 | { emit_line_note (input_filename, lineno); | |
1717 | expand_exit_loop_if_false (NULL_PTR, | |
1718 | truthvalue_conversion ($3)); | |
1719 | expand_end_loop (); | |
1720 | clear_momentary (); } | |
1721 | /* This rule is needed to make sure we end every loop we start. */ | |
1722 | | do_stmt_start error | |
1723 | { expand_end_loop (); | |
1724 | clear_momentary (); } | |
1725 | | FOR | |
1726 | '(' xexpr ';' | |
1727 | { stmt_count++; | |
1728 | emit_line_note ($<filename>-1, $<lineno>0); | |
1729 | /* See comment in `while' alternative, above. */ | |
1730 | emit_nop (); | |
1731 | if ($3) c_expand_expr_stmt ($3); | |
1732 | /* Next step is to call expand_start_loop_continue_elsewhere, | |
1733 | but wait till after we parse the entire for (...). | |
1734 | Otherwise, invalid input might cause us to call that | |
1735 | fn without calling expand_end_loop. */ | |
1736 | } | |
1737 | xexpr ';' | |
1738 | /* Can't emit now; wait till after expand_start_loop... */ | |
1739 | { $<lineno>7 = lineno; | |
1740 | $<filename>$ = input_filename; } | |
1741 | xexpr ')' | |
1742 | { | |
1743 | /* Start the loop. Doing this after parsing | |
1744 | all the expressions ensures we will end the loop. */ | |
1745 | expand_start_loop_continue_elsewhere (1); | |
1746 | /* Emit the end-test, with a line number. */ | |
1747 | emit_line_note ($<filename>8, $<lineno>7); | |
1748 | if ($6) | |
1749 | expand_exit_loop_if_false (NULL_PTR, | |
1750 | truthvalue_conversion ($6)); | |
1751 | /* Don't let the tree nodes for $9 be discarded by | |
1752 | clear_momentary during the parsing of the next stmt. */ | |
1753 | push_momentary (); | |
1754 | $<lineno>7 = lineno; | |
d54d8150 RS |
1755 | $<filename>8 = input_filename; |
1756 | position_after_white_space (); } | |
028299c6 RS |
1757 | lineno_labeled_stmt |
1758 | { /* Emit the increment expression, with a line number. */ | |
1759 | emit_line_note ($<filename>8, $<lineno>7); | |
1760 | expand_loop_continue_here (); | |
1761 | if ($9) | |
1762 | c_expand_expr_stmt ($9); | |
9d4e73d6 RK |
1763 | if (yychar == CONSTANT || yychar == STRING) |
1764 | pop_momentary_nofree (); | |
1765 | else | |
1766 | pop_momentary (); | |
028299c6 RS |
1767 | expand_end_loop (); } |
1768 | | SWITCH '(' expr ')' | |
1769 | { stmt_count++; | |
1770 | emit_line_note ($<filename>-1, $<lineno>0); | |
1771 | c_expand_start_case ($3); | |
1772 | /* Don't let the tree nodes for $3 be discarded by | |
1773 | clear_momentary during the parsing of the next stmt. */ | |
1774 | push_momentary (); | |
1775 | position_after_white_space (); } | |
1776 | lineno_labeled_stmt | |
1777 | { expand_end_case ($3); | |
9d4e73d6 RK |
1778 | if (yychar == CONSTANT || yychar == STRING) |
1779 | pop_momentary_nofree (); | |
1780 | else | |
1781 | pop_momentary (); } | |
028299c6 RS |
1782 | | BREAK ';' |
1783 | { stmt_count++; | |
1784 | emit_line_note ($<filename>-1, $<lineno>0); | |
1785 | if ( ! expand_exit_something ()) | |
1786 | error ("break statement not within loop or switch"); } | |
1787 | | CONTINUE ';' | |
1788 | { stmt_count++; | |
1789 | emit_line_note ($<filename>-1, $<lineno>0); | |
1790 | if (! expand_continue_loop (NULL_PTR)) | |
1791 | error ("continue statement not within a loop"); } | |
1792 | | RETURN ';' | |
1793 | { stmt_count++; | |
1794 | emit_line_note ($<filename>-1, $<lineno>0); | |
1795 | c_expand_return (NULL_TREE); } | |
1796 | | RETURN expr ';' | |
1797 | { stmt_count++; | |
1798 | emit_line_note ($<filename>-1, $<lineno>0); | |
1799 | c_expand_return ($2); } | |
1800 | | ASM_KEYWORD maybe_type_qual '(' expr ')' ';' | |
1801 | { stmt_count++; | |
1802 | emit_line_note ($<filename>-1, $<lineno>0); | |
1803 | STRIP_NOPS ($4); | |
1804 | if ((TREE_CODE ($4) == ADDR_EXPR | |
1805 | && TREE_CODE (TREE_OPERAND ($4, 0)) == STRING_CST) | |
1806 | || TREE_CODE ($4) == STRING_CST) | |
1807 | expand_asm ($4); | |
1808 | else | |
1809 | error ("argument of `asm' is not a constant string"); } | |
1810 | /* This is the case with just output operands. */ | |
1811 | | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ')' ';' | |
1812 | { stmt_count++; | |
1813 | emit_line_note ($<filename>-1, $<lineno>0); | |
1814 | c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE, | |
1815 | $2 == ridpointers[(int)RID_VOLATILE], | |
1816 | input_filename, lineno); } | |
1817 | /* This is the case with input operands as well. */ | |
1818 | | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':' asm_operands ')' ';' | |
1819 | { stmt_count++; | |
1820 | emit_line_note ($<filename>-1, $<lineno>0); | |
1821 | c_expand_asm_operands ($4, $6, $8, NULL_TREE, | |
1822 | $2 == ridpointers[(int)RID_VOLATILE], | |
1823 | input_filename, lineno); } | |
1824 | /* This is the case with clobbered registers as well. */ | |
1825 | | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':' | |
1826 | asm_operands ':' asm_clobbers ')' ';' | |
1827 | { stmt_count++; | |
1828 | emit_line_note ($<filename>-1, $<lineno>0); | |
1829 | c_expand_asm_operands ($4, $6, $8, $10, | |
1830 | $2 == ridpointers[(int)RID_VOLATILE], | |
1831 | input_filename, lineno); } | |
1832 | | GOTO identifier ';' | |
1833 | { tree decl; | |
1834 | stmt_count++; | |
1835 | emit_line_note ($<filename>-1, $<lineno>0); | |
1836 | decl = lookup_label ($2); | |
1837 | if (decl != 0) | |
1838 | { | |
1839 | TREE_USED (decl) = 1; | |
1840 | expand_goto (decl); | |
1841 | } | |
1842 | } | |
1843 | | GOTO '*' expr ';' | |
1844 | { stmt_count++; | |
1845 | emit_line_note ($<filename>-1, $<lineno>0); | |
1846 | expand_computed_goto (convert (ptr_type_node, $3)); } | |
1847 | | ';' | |
1848 | ; | |
1849 | ||
b490c40d RS |
1850 | all_iter_stmt: |
1851 | all_iter_stmt_simple | |
1852 | /* | all_iter_stmt_with_decl */ | |
1853 | ; | |
1854 | ||
1855 | all_iter_stmt_simple: | |
1856 | FOR '(' primary ')' | |
1857 | { | |
1858 | /* The value returned by this action is */ | |
1859 | /* 1 if everything is OK */ | |
1860 | /* 0 in case of error or already bound iterator */ | |
1861 | ||
1862 | $<itype>$ = 0; | |
1863 | if (TREE_CODE ($3) != VAR_DECL) | |
1864 | error ("invalid `for (ITERATOR)' syntax"); | |
4d06f1a2 | 1865 | else if (! ITERATOR_P ($3)) |
b490c40d RS |
1866 | error ("`%s' is not an iterator", |
1867 | IDENTIFIER_POINTER (DECL_NAME ($3))); | |
1868 | else if (ITERATOR_BOUND_P ($3)) | |
b29e212c | 1869 | error ("`for (%s)' inside expansion of same iterator", |
b490c40d RS |
1870 | IDENTIFIER_POINTER (DECL_NAME ($3))); |
1871 | else | |
1872 | { | |
1873 | $<itype>$ = 1; | |
1874 | iterator_for_loop_start ($3); | |
1875 | } | |
1876 | } | |
1877 | lineno_labeled_stmt | |
1878 | { | |
1879 | if ($<itype>5) | |
1880 | iterator_for_loop_end ($3); | |
1881 | } | |
1882 | ||
1883 | /* This really should allow any kind of declaration, | |
1884 | for generality. Fix it before turning it back on. | |
1885 | ||
1886 | all_iter_stmt_with_decl: | |
1887 | FOR '(' ITERATOR pushlevel setspecs iterator_spec ')' | |
1888 | { | |
1889 | */ /* The value returned by this action is */ | |
1890 | /* 1 if everything is OK */ | |
1891 | /* 0 in case of error or already bound iterator */ | |
1892 | /* | |
1893 | iterator_for_loop_start ($6); | |
1894 | } | |
1895 | lineno_labeled_stmt | |
1896 | { | |
1897 | iterator_for_loop_end ($6); | |
1898 | emit_line_note (input_filename, lineno); | |
1899 | expand_end_bindings (getdecls (), 1, 0); | |
1900 | $<ttype>$ = poplevel (1, 1, 0); | |
9d4e73d6 RK |
1901 | if (yychar == CONSTANT || yychar == STRING) |
1902 | pop_momentary_nofree (); | |
1903 | else | |
1904 | pop_momentary (); | |
b490c40d RS |
1905 | } |
1906 | */ | |
1907 | ||
028299c6 RS |
1908 | /* Any kind of label, including jump labels and case labels. |
1909 | ANSI C accepts labels only before statements, but we allow them | |
1910 | also at the end of a compound statement. */ | |
1911 | ||
b00e5f0d | 1912 | label: CASE expr_no_commas ':' |
028299c6 RS |
1913 | { register tree value = check_case_value ($2); |
1914 | register tree label | |
1915 | = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); | |
1916 | ||
1917 | stmt_count++; | |
1918 | ||
1919 | if (value != error_mark_node) | |
1920 | { | |
1921 | tree duplicate; | |
2ac3624b PE |
1922 | int success = pushcase (value, convert_and_check, |
1923 | label, &duplicate); | |
028299c6 RS |
1924 | if (success == 1) |
1925 | error ("case label not within a switch statement"); | |
1926 | else if (success == 2) | |
1927 | { | |
1928 | error ("duplicate case value"); | |
1929 | error_with_decl (duplicate, "this is the first entry for that value"); | |
1930 | } | |
1931 | else if (success == 3) | |
1932 | warning ("case value out of range"); | |
1933 | else if (success == 5) | |
1934 | error ("case label within scope of cleanup or variable array"); | |
1935 | } | |
1936 | position_after_white_space (); } | |
b00e5f0d | 1937 | | CASE expr_no_commas ELLIPSIS expr_no_commas ':' |
028299c6 RS |
1938 | { register tree value1 = check_case_value ($2); |
1939 | register tree value2 = check_case_value ($4); | |
1940 | register tree label | |
1941 | = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); | |
1942 | ||
1943 | stmt_count++; | |
1944 | ||
1945 | if (value1 != error_mark_node && value2 != error_mark_node) | |
1946 | { | |
1947 | tree duplicate; | |
2ac3624b PE |
1948 | int success = pushcase_range (value1, value2, |
1949 | convert_and_check, label, | |
028299c6 RS |
1950 | &duplicate); |
1951 | if (success == 1) | |
1952 | error ("case label not within a switch statement"); | |
1953 | else if (success == 2) | |
1954 | { | |
1955 | error ("duplicate case value"); | |
1956 | error_with_decl (duplicate, "this is the first entry for that value"); | |
1957 | } | |
1958 | else if (success == 3) | |
1959 | warning ("case value out of range"); | |
1960 | else if (success == 4) | |
1961 | warning ("empty case range"); | |
1962 | else if (success == 5) | |
1963 | error ("case label within scope of cleanup or variable array"); | |
1964 | } | |
1965 | position_after_white_space (); } | |
1966 | | DEFAULT ':' | |
1967 | { | |
1968 | tree duplicate; | |
1969 | register tree label | |
1970 | = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); | |
2ac3624b | 1971 | int success = pushcase (NULL_TREE, 0, label, &duplicate); |
028299c6 RS |
1972 | stmt_count++; |
1973 | if (success == 1) | |
1974 | error ("default label not within a switch statement"); | |
1975 | else if (success == 2) | |
1976 | { | |
1977 | error ("multiple default labels in one switch"); | |
1978 | error_with_decl (duplicate, "this is the first default label"); | |
1979 | } | |
1980 | position_after_white_space (); } | |
1981 | | identifier ':' | |
1982 | { tree label = define_label (input_filename, lineno, $1); | |
1983 | stmt_count++; | |
1984 | emit_nop (); | |
1985 | if (label) | |
1986 | expand_label (label); | |
1987 | position_after_white_space (); } | |
1988 | ; | |
1989 | ||
1990 | /* Either a type-qualifier or nothing. First thing in an `asm' statement. */ | |
1991 | ||
1992 | maybe_type_qual: | |
1993 | /* empty */ | |
5bb92565 RS |
1994 | { emit_line_note (input_filename, lineno); |
1995 | $$ = NULL_TREE; } | |
028299c6 RS |
1996 | | TYPE_QUAL |
1997 | { emit_line_note (input_filename, lineno); } | |
1998 | ; | |
1999 | ||
2000 | xexpr: | |
2001 | /* empty */ | |
2002 | { $$ = NULL_TREE; } | |
2003 | | expr | |
2004 | ; | |
2005 | ||
2006 | /* These are the operands other than the first string and colon | |
2007 | in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */ | |
2008 | asm_operands: /* empty */ | |
2009 | { $$ = NULL_TREE; } | |
2010 | | nonnull_asm_operands | |
2011 | ; | |
2012 | ||
2013 | nonnull_asm_operands: | |
2014 | asm_operand | |
2015 | | nonnull_asm_operands ',' asm_operand | |
2016 | { $$ = chainon ($1, $3); } | |
2017 | ; | |
2018 | ||
2019 | asm_operand: | |
2020 | STRING '(' expr ')' | |
2021 | { $$ = build_tree_list ($1, $3); } | |
2022 | ; | |
2023 | ||
2024 | asm_clobbers: | |
2025 | string | |
2026 | { $$ = tree_cons (NULL_TREE, combine_strings ($1), NULL_TREE); } | |
2027 | | asm_clobbers ',' string | |
2028 | { $$ = tree_cons (NULL_TREE, combine_strings ($3), $1); } | |
2029 | ; | |
2030 | \f | |
2031 | /* This is what appears inside the parens in a function declarator. | |
2032 | Its value is a list of ..._TYPE nodes. */ | |
2033 | parmlist: | |
2034 | { pushlevel (0); | |
2035 | clear_parm_order (); | |
2036 | declare_parm_level (0); } | |
2037 | parmlist_1 | |
2038 | { $$ = $2; | |
2039 | parmlist_tags_warning (); | |
2040 | poplevel (0, 0, 0); } | |
2041 | ; | |
2042 | ||
2043 | parmlist_1: | |
2044 | parmlist_2 ')' | |
2045 | | parms ';' | |
2046 | { tree parm; | |
2047 | if (pedantic) | |
2048 | pedwarn ("ANSI C forbids forward parameter declarations"); | |
2049 | /* Mark the forward decls as such. */ | |
2050 | for (parm = getdecls (); parm; parm = TREE_CHAIN (parm)) | |
2051 | TREE_ASM_WRITTEN (parm) = 1; | |
2052 | clear_parm_order (); } | |
2053 | parmlist_1 | |
2054 | { $$ = $4; } | |
2055 | | error ')' | |
2056 | { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); } | |
2057 | ; | |
2058 | ||
2059 | /* This is what appears inside the parens in a function declarator. | |
2060 | Is value is represented in the format that grokdeclarator expects. */ | |
2061 | parmlist_2: /* empty */ | |
2062 | { $$ = get_parm_info (0); } | |
2063 | | ELLIPSIS | |
2064 | { $$ = get_parm_info (0); | |
aff2a12b RK |
2065 | /* Gcc used to allow this as an extension. However, it does |
2066 | not work for all targets, and thus has been disabled. | |
2067 | Also, since func (...) and func () are indistinguishable, | |
2068 | it caused problems with the code in expand_builtin which | |
2069 | tries to verify that BUILT_IN_NEXT_ARG is being used | |
2070 | correctly. */ | |
2071 | error ("ANSI C requires a named argument before `...'"); | |
028299c6 RS |
2072 | } |
2073 | | parms | |
2074 | { $$ = get_parm_info (1); } | |
2075 | | parms ',' ELLIPSIS | |
2076 | { $$ = get_parm_info (0); } | |
2077 | ; | |
2078 | ||
2079 | parms: | |
2080 | parm | |
2081 | { push_parm_decl ($1); } | |
2082 | | parms ',' parm | |
2083 | { push_parm_decl ($3); } | |
2084 | ; | |
2085 | ||
2086 | /* A single parameter declaration or parameter type name, | |
2087 | as found in a parmlist. */ | |
2088 | parm: | |
2089 | typed_declspecs parm_declarator | |
2090 | { $$ = build_tree_list ($1, $2) ; } | |
2091 | | typed_declspecs notype_declarator | |
2092 | { $$ = build_tree_list ($1, $2) ; } | |
2093 | | typed_declspecs absdcl | |
2094 | { $$ = build_tree_list ($1, $2); } | |
2095 | | declmods notype_declarator | |
2096 | { $$ = build_tree_list ($1, $2) ; } | |
2097 | | declmods absdcl | |
2098 | { $$ = build_tree_list ($1, $2); } | |
2099 | ; | |
2100 | ||
2101 | /* This is used in a function definition | |
2102 | where either a parmlist or an identifier list is ok. | |
2103 | Its value is a list of ..._TYPE nodes or a list of identifiers. */ | |
2104 | parmlist_or_identifiers: | |
2105 | { pushlevel (0); | |
2106 | clear_parm_order (); | |
2107 | declare_parm_level (1); } | |
2108 | parmlist_or_identifiers_1 | |
2109 | { $$ = $2; | |
2110 | parmlist_tags_warning (); | |
2111 | poplevel (0, 0, 0); } | |
2112 | ; | |
2113 | ||
2114 | parmlist_or_identifiers_1: | |
2115 | parmlist_1 | |
2116 | | identifiers ')' | |
2117 | { tree t; | |
2118 | for (t = $1; t; t = TREE_CHAIN (t)) | |
2119 | if (TREE_VALUE (t) == NULL_TREE) | |
2120 | error ("`...' in old-style identifier list"); | |
2121 | $$ = tree_cons (NULL_TREE, NULL_TREE, $1); } | |
2122 | ; | |
2123 | ||
2124 | /* A nonempty list of identifiers. */ | |
2125 | identifiers: | |
2126 | IDENTIFIER | |
2127 | { $$ = build_tree_list (NULL_TREE, $1); } | |
2128 | | identifiers ',' IDENTIFIER | |
2129 | { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } | |
2130 | ; | |
2131 | ||
2132 | /* A nonempty list of identifiers, including typenames. */ | |
2133 | identifiers_or_typenames: | |
2134 | identifier | |
2135 | { $$ = build_tree_list (NULL_TREE, $1); } | |
2136 | | identifiers_or_typenames ',' identifier | |
2137 | { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } | |
2138 | ; | |
2139 | \f | |
2140 | ifobjc | |
2141 | /* Objective-C productions. */ | |
2142 | ||
2143 | objcdef: | |
2144 | classdef | |
e31c7eec TW |
2145 | | classdecl |
2146 | | aliasdecl | |
2147 | | protocoldef | |
028299c6 RS |
2148 | | methoddef |
2149 | | END | |
2150 | { | |
2151 | if (objc_implementation_context) | |
2152 | { | |
2153 | finish_class (objc_implementation_context); | |
2154 | objc_ivar_chain = NULL_TREE; | |
2155 | objc_implementation_context = NULL_TREE; | |
2156 | } | |
2157 | else | |
2158 | warning ("`@end' must appear in an implementation context"); | |
2159 | } | |
2160 | ; | |
2161 | ||
e31c7eec TW |
2162 | /* A nonempty list of identifiers. */ |
2163 | identifier_list: | |
2164 | identifier | |
2165 | { $$ = build_tree_list (NULL_TREE, $1); } | |
2166 | | identifier_list ',' identifier | |
2167 | { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } | |
2168 | ; | |
2169 | ||
2170 | classdecl: | |
2171 | CLASS identifier_list ';' | |
2172 | { | |
2173 | objc_declare_class ($2); | |
2174 | } | |
2175 | ||
2176 | aliasdecl: | |
2177 | ALIAS identifier identifier ';' | |
2178 | { | |
2179 | objc_declare_alias ($2, $3); | |
2180 | } | |
2181 | ||
028299c6 | 2182 | classdef: |
e31c7eec | 2183 | INTERFACE identifier protocolrefs '{' |
028299c6 RS |
2184 | { |
2185 | objc_interface_context = objc_ivar_context | |
e31c7eec | 2186 | = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3); |
028299c6 RS |
2187 | objc_public_flag = 0; |
2188 | } | |
2189 | ivar_decl_list '}' | |
2190 | { | |
2191 | continue_class (objc_interface_context); | |
2192 | } | |
2193 | methodprotolist | |
2194 | END | |
2195 | { | |
2196 | finish_class (objc_interface_context); | |
2197 | objc_interface_context = NULL_TREE; | |
2198 | } | |
2199 | ||
e31c7eec | 2200 | | INTERFACE identifier protocolrefs |
028299c6 RS |
2201 | { |
2202 | objc_interface_context | |
e31c7eec | 2203 | = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3); |
028299c6 RS |
2204 | continue_class (objc_interface_context); |
2205 | } | |
2206 | methodprotolist | |
2207 | END | |
2208 | { | |
2209 | finish_class (objc_interface_context); | |
2210 | objc_interface_context = NULL_TREE; | |
2211 | } | |
2212 | ||
e31c7eec | 2213 | | INTERFACE identifier ':' identifier protocolrefs '{' |
028299c6 RS |
2214 | { |
2215 | objc_interface_context = objc_ivar_context | |
e31c7eec | 2216 | = start_class (CLASS_INTERFACE_TYPE, $2, $4, $5); |
028299c6 RS |
2217 | objc_public_flag = 0; |
2218 | } | |
2219 | ivar_decl_list '}' | |
2220 | { | |
2221 | continue_class (objc_interface_context); | |
2222 | } | |
2223 | methodprotolist | |
2224 | END | |
2225 | { | |
2226 | finish_class (objc_interface_context); | |
2227 | objc_interface_context = NULL_TREE; | |
2228 | } | |
2229 | ||
e31c7eec | 2230 | | INTERFACE identifier ':' identifier protocolrefs |
028299c6 RS |
2231 | { |
2232 | objc_interface_context | |
e31c7eec | 2233 | = start_class (CLASS_INTERFACE_TYPE, $2, $4, $5); |
028299c6 RS |
2234 | continue_class (objc_interface_context); |
2235 | } | |
2236 | methodprotolist | |
2237 | END | |
2238 | { | |
2239 | finish_class (objc_interface_context); | |
2240 | objc_interface_context = NULL_TREE; | |
2241 | } | |
2242 | ||
2243 | | IMPLEMENTATION identifier '{' | |
2244 | { | |
2245 | objc_implementation_context = objc_ivar_context | |
e31c7eec | 2246 | = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE); |
028299c6 RS |
2247 | objc_public_flag = 0; |
2248 | } | |
2249 | ivar_decl_list '}' | |
2250 | { | |
2251 | objc_ivar_chain | |
2252 | = continue_class (objc_implementation_context); | |
2253 | } | |
2254 | ||
2255 | | IMPLEMENTATION identifier | |
2256 | { | |
2257 | objc_implementation_context | |
e31c7eec | 2258 | = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE); |
028299c6 RS |
2259 | objc_ivar_chain |
2260 | = continue_class (objc_implementation_context); | |
2261 | } | |
2262 | ||
2263 | | IMPLEMENTATION identifier ':' identifier '{' | |
2264 | { | |
2265 | objc_implementation_context = objc_ivar_context | |
e31c7eec | 2266 | = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE); |
028299c6 RS |
2267 | objc_public_flag = 0; |
2268 | } | |
2269 | ivar_decl_list '}' | |
2270 | { | |
2271 | objc_ivar_chain | |
2272 | = continue_class (objc_implementation_context); | |
2273 | } | |
2274 | ||
2275 | | IMPLEMENTATION identifier ':' identifier | |
2276 | { | |
2277 | objc_implementation_context | |
e31c7eec | 2278 | = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE); |
028299c6 RS |
2279 | objc_ivar_chain |
2280 | = continue_class (objc_implementation_context); | |
2281 | } | |
2282 | ||
e31c7eec | 2283 | | INTERFACE identifier '(' identifier ')' protocolrefs |
028299c6 RS |
2284 | { |
2285 | objc_interface_context | |
e31c7eec | 2286 | = start_class (CATEGORY_INTERFACE_TYPE, $2, $4, $6); |
028299c6 RS |
2287 | continue_class (objc_interface_context); |
2288 | } | |
2289 | methodprotolist | |
2290 | END | |
2291 | { | |
2292 | finish_class (objc_interface_context); | |
2293 | objc_interface_context = NULL_TREE; | |
2294 | } | |
2295 | ||
2296 | | IMPLEMENTATION identifier '(' identifier ')' | |
2297 | { | |
2298 | objc_implementation_context | |
e31c7eec | 2299 | = start_class (CATEGORY_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE); |
028299c6 RS |
2300 | objc_ivar_chain |
2301 | = continue_class (objc_implementation_context); | |
2302 | } | |
2303 | ; | |
2304 | ||
e31c7eec TW |
2305 | protocoldef: |
2306 | PROTOCOL identifier protocolrefs | |
2307 | { | |
2308 | remember_protocol_qualifiers (); | |
2309 | objc_interface_context | |
2310 | = start_protocol(PROTOCOL_INTERFACE_TYPE, $2, $3); | |
2311 | } | |
2312 | methodprotolist END | |
2313 | { | |
2314 | forget_protocol_qualifiers(); | |
2315 | finish_protocol(objc_interface_context); | |
2316 | objc_interface_context = NULL_TREE; | |
2317 | } | |
2318 | ; | |
2319 | ||
2320 | protocolrefs: | |
2321 | /* empty */ | |
2322 | { | |
2323 | $$ = NULL_TREE; | |
2324 | } | |
2325 | | ARITHCOMPARE identifier_list ARITHCOMPARE | |
2326 | { | |
2327 | if ($1 == LT_EXPR && $3 == GT_EXPR) | |
2328 | $$ = $2; | |
2329 | else | |
2330 | YYERROR1; | |
2331 | } | |
2332 | ; | |
2333 | ||
028299c6 | 2334 | ivar_decl_list: |
e31c7eec | 2335 | ivar_decl_list visibility_spec ivar_decls |
028299c6 RS |
2336 | | ivar_decls |
2337 | ; | |
2338 | ||
e31c7eec TW |
2339 | visibility_spec: |
2340 | PRIVATE { objc_public_flag = 2; } | |
2341 | | PROTECTED { objc_public_flag = 0; } | |
2342 | | PUBLIC { objc_public_flag = 1; } | |
2343 | ; | |
2344 | ||
028299c6 RS |
2345 | ivar_decls: |
2346 | /* empty */ | |
2347 | { | |
2348 | $$ = NULL_TREE; | |
2349 | } | |
2350 | | ivar_decls ivar_decl ';' | |
2351 | | ivar_decls ';' | |
2352 | { | |
2353 | if (pedantic) | |
ea3cfc81 | 2354 | pedwarn ("extra semicolon in struct or union specified"); |
028299c6 RS |
2355 | } |
2356 | ; | |
2357 | ||
2358 | ||
2359 | /* There is a shift-reduce conflict here, because `components' may | |
2360 | start with a `typename'. It happens that shifting (the default resolution) | |
2361 | does the right thing, because it treats the `typename' as part of | |
2362 | a `typed_typespecs'. | |
2363 | ||
2364 | It is possible that this same technique would allow the distinction | |
2365 | between `notype_initdecls' and `initdecls' to be eliminated. | |
2366 | But I am being cautious and not trying it. */ | |
2367 | ||
2368 | ivar_decl: | |
2369 | typed_typespecs setspecs ivars | |
2370 | { | |
2371 | $$ = $3; | |
2372 | resume_momentary ($2); | |
2373 | } | |
2374 | | nonempty_type_quals setspecs ivars | |
2375 | { | |
2376 | $$ = $3; | |
2377 | resume_momentary ($2); | |
2378 | } | |
2379 | | error | |
2380 | { $$ = NULL_TREE; } | |
2381 | ; | |
2382 | ||
2383 | ivars: | |
2384 | /* empty */ | |
2385 | { $$ = NULL_TREE; } | |
2386 | | ivar_declarator | |
2387 | | ivars ',' ivar_declarator | |
2388 | ; | |
2389 | ||
2390 | ivar_declarator: | |
2391 | declarator | |
2392 | { | |
2393 | $$ = add_instance_variable (objc_ivar_context, | |
2394 | objc_public_flag, | |
2395 | $1, current_declspecs, | |
2396 | NULL_TREE); | |
2397 | } | |
2398 | | declarator ':' expr_no_commas | |
2399 | { | |
2400 | $$ = add_instance_variable (objc_ivar_context, | |
2401 | objc_public_flag, | |
2402 | $1, current_declspecs, $3); | |
2403 | } | |
2404 | | ':' expr_no_commas | |
2405 | { | |
2406 | $$ = add_instance_variable (objc_ivar_context, | |
2407 | objc_public_flag, | |
2408 | NULL_TREE, | |
2409 | current_declspecs, $2); | |
2410 | } | |
2411 | ; | |
2412 | ||
2413 | methoddef: | |
2414 | '+' | |
2415 | { | |
e31c7eec | 2416 | remember_protocol_qualifiers (); |
028299c6 RS |
2417 | if (objc_implementation_context) |
2418 | objc_inherit_code = CLASS_METHOD_DECL; | |
2419 | else | |
2420 | fatal ("method definition not in class context"); | |
2421 | } | |
2422 | methoddecl | |
2423 | { | |
e31c7eec | 2424 | forget_protocol_qualifiers (); |
028299c6 RS |
2425 | add_class_method (objc_implementation_context, $3); |
2426 | start_method_def ($3); | |
2427 | objc_method_context = $3; | |
2428 | } | |
2429 | optarglist | |
2430 | { | |
2431 | continue_method_def (); | |
2432 | } | |
2433 | compstmt_or_error | |
2434 | { | |
2435 | finish_method_def (); | |
2436 | objc_method_context = NULL_TREE; | |
2437 | } | |
2438 | ||
2439 | | '-' | |
2440 | { | |
e31c7eec | 2441 | remember_protocol_qualifiers (); |
028299c6 RS |
2442 | if (objc_implementation_context) |
2443 | objc_inherit_code = INSTANCE_METHOD_DECL; | |
2444 | else | |
2445 | fatal ("method definition not in class context"); | |
2446 | } | |
2447 | methoddecl | |
2448 | { | |
e31c7eec | 2449 | forget_protocol_qualifiers (); |
028299c6 RS |
2450 | add_instance_method (objc_implementation_context, $3); |
2451 | start_method_def ($3); | |
2452 | objc_method_context = $3; | |
2453 | } | |
2454 | optarglist | |
2455 | { | |
2456 | continue_method_def (); | |
2457 | } | |
2458 | compstmt_or_error | |
2459 | { | |
2460 | finish_method_def (); | |
2461 | objc_method_context = NULL_TREE; | |
2462 | } | |
2463 | ; | |
2464 | ||
2465 | /* the reason for the strange actions in this rule | |
2466 | is so that notype_initdecls when reached via datadef | |
2467 | can find a valid list of type and sc specs in $0. */ | |
2468 | ||
2469 | methodprotolist: | |
2470 | /* empty */ | |
2471 | | {$<ttype>$ = NULL_TREE; } methodprotolist2 | |
2472 | ; | |
2473 | ||
2474 | methodprotolist2: /* eliminates a shift/reduce conflict */ | |
2475 | methodproto | |
2476 | | datadef | |
2477 | | methodprotolist2 methodproto | |
2478 | | methodprotolist2 {$<ttype>$ = NULL_TREE; } datadef | |
2479 | ; | |
2480 | ||
2481 | semi_or_error: | |
2482 | ';' | |
2483 | | error | |
2484 | ; | |
2485 | ||
2486 | methodproto: | |
2487 | '+' | |
2488 | { | |
2489 | objc_inherit_code = CLASS_METHOD_DECL; | |
2490 | } | |
2491 | methoddecl | |
2492 | { | |
2493 | add_class_method (objc_interface_context, $3); | |
2494 | } | |
2495 | semi_or_error | |
2496 | ||
2497 | | '-' | |
2498 | { | |
2499 | objc_inherit_code = INSTANCE_METHOD_DECL; | |
2500 | } | |
2501 | methoddecl | |
2502 | { | |
2503 | add_instance_method (objc_interface_context, $3); | |
2504 | } | |
2505 | semi_or_error | |
2506 | ; | |
2507 | ||
2508 | methoddecl: | |
2509 | '(' typename ')' unaryselector | |
2510 | { | |
2511 | $$ = build_method_decl (objc_inherit_code, $2, $4, NULL_TREE); | |
2512 | } | |
2513 | ||
2514 | | unaryselector | |
2515 | { | |
2516 | $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, NULL_TREE); | |
2517 | } | |
2518 | ||
2519 | | '(' typename ')' keywordselector optparmlist | |
2520 | { | |
2521 | $$ = build_method_decl (objc_inherit_code, $2, $4, $5); | |
2522 | } | |
2523 | ||
2524 | | keywordselector optparmlist | |
2525 | { | |
2526 | $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, $2); | |
2527 | } | |
2528 | ; | |
2529 | ||
2530 | /* "optarglist" assumes that start_method_def has already been called... | |
2531 | if it is not, the "xdecls" will not be placed in the proper scope */ | |
2532 | ||
2533 | optarglist: | |
2534 | /* empty */ | |
2535 | | ';' myxdecls | |
2536 | ; | |
2537 | ||
2538 | /* to get around the following situation: "int foo (int a) int b; {}" that | |
2539 | is synthesized when parsing "- a:a b:b; id c; id d; { ... }" */ | |
2540 | ||
2541 | myxdecls: | |
2542 | /* empty */ | |
2543 | | mydecls | |
2544 | ; | |
2545 | ||
2546 | mydecls: | |
2547 | mydecl | |
2548 | | errstmt | |
2549 | | mydecls mydecl | |
2550 | | mydecl errstmt | |
2551 | ; | |
2552 | ||
2553 | mydecl: | |
2554 | typed_declspecs setspecs myparms ';' | |
2555 | { resume_momentary ($2); } | |
2556 | | typed_declspecs ';' | |
2557 | { shadow_tag ($1); } | |
2558 | | declmods ';' | |
2559 | { pedwarn ("empty declaration"); } | |
2560 | ; | |
2561 | ||
2562 | myparms: | |
2563 | myparm | |
2564 | { push_parm_decl ($1); } | |
2565 | | myparms ',' myparm | |
2566 | { push_parm_decl ($3); } | |
2567 | ; | |
2568 | ||
2569 | /* A single parameter declaration or parameter type name, | |
2570 | as found in a parmlist. DOES NOT ALLOW AN INITIALIZER OR ASMSPEC */ | |
2571 | ||
2572 | myparm: | |
2573 | parm_declarator | |
2574 | { $$ = build_tree_list (current_declspecs, $1) ; } | |
2575 | | notype_declarator | |
2576 | { $$ = build_tree_list (current_declspecs, $1) ; } | |
2577 | | absdcl | |
2578 | { $$ = build_tree_list (current_declspecs, $1) ; } | |
2579 | ; | |
2580 | ||
2581 | optparmlist: | |
2582 | /* empty */ | |
2583 | { | |
2584 | $$ = NULL_TREE; | |
2585 | } | |
2586 | | ',' ELLIPSIS | |
2587 | { | |
2588 | /* oh what a kludge! */ | |
2589 | $$ = (tree)1; | |
2590 | } | |
2591 | | ',' | |
2592 | { | |
2593 | pushlevel (0); | |
2594 | } | |
2595 | parmlist_2 | |
2596 | { | |
2597 | /* returns a tree list node generated by get_parm_info */ | |
2598 | $$ = $3; | |
2599 | poplevel (0, 0, 0); | |
2600 | } | |
2601 | ; | |
2602 | ||
2603 | unaryselector: | |
2604 | selector | |
2605 | ; | |
2606 | ||
2607 | keywordselector: | |
2608 | keyworddecl | |
2609 | ||
2610 | | keywordselector keyworddecl | |
2611 | { | |
2612 | $$ = chainon ($1, $2); | |
2613 | } | |
2614 | ; | |
2615 | ||
2616 | selector: | |
2617 | IDENTIFIER | |
2618 | | TYPENAME | |
e31c7eec | 2619 | | OBJECTNAME |
028299c6 RS |
2620 | | reservedwords |
2621 | ; | |
2622 | ||
2623 | reservedwords: | |
2624 | ENUM { $$ = get_identifier (token_buffer); } | |
2625 | | STRUCT { $$ = get_identifier (token_buffer); } | |
2626 | | UNION { $$ = get_identifier (token_buffer); } | |
2627 | | IF { $$ = get_identifier (token_buffer); } | |
2628 | | ELSE { $$ = get_identifier (token_buffer); } | |
2629 | | WHILE { $$ = get_identifier (token_buffer); } | |
2630 | | DO { $$ = get_identifier (token_buffer); } | |
2631 | | FOR { $$ = get_identifier (token_buffer); } | |
2632 | | SWITCH { $$ = get_identifier (token_buffer); } | |
2633 | | CASE { $$ = get_identifier (token_buffer); } | |
2634 | | DEFAULT { $$ = get_identifier (token_buffer); } | |
2635 | | BREAK { $$ = get_identifier (token_buffer); } | |
2636 | | CONTINUE { $$ = get_identifier (token_buffer); } | |
2637 | | RETURN { $$ = get_identifier (token_buffer); } | |
2638 | | GOTO { $$ = get_identifier (token_buffer); } | |
2639 | | ASM_KEYWORD { $$ = get_identifier (token_buffer); } | |
2640 | | SIZEOF { $$ = get_identifier (token_buffer); } | |
2641 | | TYPEOF { $$ = get_identifier (token_buffer); } | |
2642 | | ALIGNOF { $$ = get_identifier (token_buffer); } | |
2643 | | TYPESPEC | TYPE_QUAL | |
2644 | ; | |
2645 | ||
2646 | keyworddecl: | |
2647 | selector ':' '(' typename ')' identifier | |
2648 | { | |
2649 | $$ = build_keyword_decl ($1, $4, $6); | |
2650 | } | |
2651 | ||
2652 | | selector ':' identifier | |
2653 | { | |
2654 | $$ = build_keyword_decl ($1, NULL_TREE, $3); | |
2655 | } | |
2656 | ||
2657 | | ':' '(' typename ')' identifier | |
2658 | { | |
2659 | $$ = build_keyword_decl (NULL_TREE, $3, $5); | |
2660 | } | |
2661 | ||
2662 | | ':' identifier | |
2663 | { | |
2664 | $$ = build_keyword_decl (NULL_TREE, NULL_TREE, $2); | |
2665 | } | |
2666 | ; | |
2667 | ||
2668 | messageargs: | |
2669 | selector | |
2670 | | keywordarglist | |
2671 | ; | |
2672 | ||
2673 | keywordarglist: | |
2674 | keywordarg | |
2675 | | keywordarglist keywordarg | |
2676 | { | |
2677 | $$ = chainon ($1, $2); | |
2678 | } | |
2679 | ; | |
2680 | ||
2681 | ||
2682 | keywordexpr: | |
2683 | nonnull_exprlist | |
2684 | { | |
2685 | if (TREE_CHAIN ($1) == NULL_TREE) | |
2686 | /* just return the expr., remove a level of indirection */ | |
2687 | $$ = TREE_VALUE ($1); | |
2688 | else | |
2689 | /* we have a comma expr., we will collapse later */ | |
2690 | $$ = $1; | |
2691 | } | |
2692 | ; | |
2693 | ||
2694 | keywordarg: | |
2695 | selector ':' keywordexpr | |
2696 | { | |
2697 | $$ = build_tree_list ($1, $3); | |
2698 | } | |
2699 | | ':' keywordexpr | |
2700 | { | |
2701 | $$ = build_tree_list (NULL_TREE, $2); | |
2702 | } | |
2703 | ; | |
2704 | ||
2705 | receiver: | |
2706 | expr | |
2707 | | CLASSNAME | |
2708 | { | |
2709 | $$ = get_class_reference ($1); | |
2710 | } | |
2711 | ; | |
2712 | ||
2713 | objcmessageexpr: | |
2714 | '[' | |
2715 | { objc_receiver_context = 1; } | |
2716 | receiver | |
2717 | { objc_receiver_context = 0; } | |
2718 | messageargs ']' | |
2719 | { | |
2720 | $$ = build_tree_list ($3, $5); | |
2721 | } | |
2722 | ; | |
2723 | ||
2724 | selectorarg: | |
2725 | selector | |
2726 | | keywordnamelist | |
2727 | ; | |
2728 | ||
2729 | keywordnamelist: | |
2730 | keywordname | |
2731 | | keywordnamelist keywordname | |
2732 | { | |
2733 | $$ = chainon ($1, $2); | |
2734 | } | |
2735 | ; | |
2736 | ||
2737 | keywordname: | |
2738 | selector ':' | |
2739 | { | |
2740 | $$ = build_tree_list ($1, NULL_TREE); | |
2741 | } | |
2742 | | ':' | |
2743 | { | |
2744 | $$ = build_tree_list (NULL_TREE, NULL_TREE); | |
2745 | } | |
2746 | ; | |
2747 | ||
2748 | objcselectorexpr: | |
2749 | SELECTOR '(' selectorarg ')' | |
2750 | { | |
2751 | $$ = $3; | |
2752 | } | |
2753 | ; | |
2754 | ||
e31c7eec TW |
2755 | objcprotocolexpr: |
2756 | PROTOCOL '(' identifier ')' | |
2757 | { | |
2758 | $$ = $3; | |
2759 | } | |
2760 | ; | |
2761 | ||
028299c6 RS |
2762 | /* extension to support C-structures in the archiver */ |
2763 | ||
2764 | objcencodeexpr: | |
2765 | ENCODE '(' typename ')' | |
2766 | { | |
2767 | $$ = groktypename ($3); | |
2768 | } | |
2769 | ; | |
2770 | ||
2771 | end ifobjc | |
2772 | %% |