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