![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-parse.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cp-parse.y CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* YACC parser for C++ syntax.
2: Copyright (C) 1988, 1989 Free Software Foundation, Inc.
3: Hacked by Michael Tiemann ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: /* This grammar is based on the GNU CC grammar. */
23:
24: /* Note: Bison automatically applies a default action of "$$ = $1" for
25: all derivations; this is applied before the explicit action, if one
26: is given. Keep this in mind when reading the actions. */
27:
28: /* Also note: this version contains experimental exception
29: handling features. They could break, change, disappear,
30: or otherwise exhibit volatile behavior. Don't depend on
31: me (Michael Tiemann) to protect you from any negative impact
32: this may have on your professional, personal, or spiritual life.
33:
34: NEWS FLASH: This version now supports the exception handling
35: syntax of Stroustrup's 2nd edition, if -fansi-exceptions is given.
36: THIS IS WORK IN PROGRESS!!! The type of the 'throw' and the
37: 'catch' much match EXACTLY (no inheritance support or coercions).
38: Also, throw-specifications of functions don't work.
39: Destructors aren't called correctly. Etc, etc. --Per Bothner.
40: */
41:
42: %{
43: #ifdef GATHER_STATISTICS
44: #undef YYDEBUG
45: #define YYDEBUG 1
46: #endif
47:
48: #include "config.h"
49:
50: #include <stdio.h>
51: #include <errno.h>
52:
53: #include "tree.h"
54: #include "input.h"
55: #include "cp-lex.h"
56: #include "cp-tree.h"
57: #include "assert.h"
58:
59: extern tree void_list_node;
60:
61: #ifndef errno
62: extern int errno;
63: #endif
64:
65: extern int end_of_file;
66:
67: void yyerror ();
68:
69: /* Like YYERROR but do call yyerror. */
70: #define YYERROR1 { yyerror ("syntax error"); YYERROR; }
71:
72: static void position_after_white_space ();
73:
74: /* The elements of `ridpointers' are identifier nodes
75: for the reserved type names and storage classes.
76: It is indexed by a RID_... value. */
77:
78: tree ridpointers[(int) RID_MAX];
79: #define NORID RID_UNUSED
80:
81: /* Contains error message to give if user tries to declare
82: a variable where one does not belong. */
83: static char *stmt_decl_msg = 0;
84:
85: /* Nonzero if we have an `extern "C"' acting as an extern specifier. */
86:
87: static int have_extern_spec;
88:
89: void yyhook ();
90:
91: /* Cons up an empty parameter list. */
92: #ifdef __GNUC__
93: __inline
94: #endif
95: static tree
96: empty_parms ()
97: {
98: tree parms;
99:
100: if (strict_prototype)
101: parms = void_list_node;
102: else
103: parms = NULL_TREE;
104: return parms;
105: }
106: %}
107:
108: %start program
109:
110: %union {long itype; tree ttype; enum tree_code code; }
111:
112: /* All identifiers that are not reserved words
113: and are not declared typedefs in the current block */
114: %token IDENTIFIER
115:
116: /* All identifiers that are declared typedefs in the current block.
117: In some contexts, they are treated just like IDENTIFIER,
118: but they can also serve as typespecs in declarations. */
119: %token TYPENAME
120:
121: /* Qualified identifiers that end in a TYPENAME. */
122: %token SCOPED_TYPENAME
123:
124: /* Reserved words that specify storage class.
125: yylval contains an IDENTIFIER_NODE which indicates which one. */
126: %token SCSPEC
127:
128: /* Reserved words that specify type.
129: yylval contains an IDENTIFIER_NODE which indicates which one. */
130: %token TYPESPEC
131:
132: /* Reserved words that qualify type: "const" or "volatile".
133: yylval contains an IDENTIFIER_NODE which indicates which one. */
134: %token TYPE_QUAL
135:
136: /* Character or numeric constants.
137: yylval is the node for the constant. */
138: %token CONSTANT
139:
140: /* String constants in raw form.
141: yylval is a STRING_CST node. */
142: %token STRING
143:
144: /* "...", used for functions with variable arglists. */
145: %token ELLIPSIS
146:
147: /* the reserved words */
148: %token SIZEOF ENUM /* STRUCT UNION */ IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
149: %token BREAK CONTINUE RETURN GOTO ASM TYPEOF ALIGNOF HEADOF CLASSOF
150: %token ATTRIBUTE
151:
152: /* the reserved words... C++ extensions */
153: %token <ttype> AGGR
154: %token <itype> VISSPEC
155: %token DELETE NEW OVERLOAD THIS OPERATOR
156: %token DYNAMIC POINTSAT_LEFT_RIGHT LEFT_RIGHT TEMPLATE
157: %token <itype> SCOPE
158:
159: /* Special token created by the lexer to separate TYPENAME
160: from an ABSDCL. This allows us to parse `foo (*pf)()'. */
161:
162: %token START_DECLARATOR
163:
164: /* Define the operator tokens and their precedences.
165: The value is an integer because, if used, it is the tree code
166: to use in the expression made from the operator. */
167:
168: %left EMPTY /* used to resolve s/r with epsilon */
169:
170: /* Add precedence rules to solve dangling else s/r conflict */
171: %nonassoc IF
172: %nonassoc ELSE
173:
174: %left IDENTIFIER TYPENAME TYPENAME_COLON SCSPEC TYPESPEC TYPE_QUAL ENUM AGGR
175:
176: %left '{' ','
177:
178: %right <code> ASSIGN '='
179: %right <code> '?' ':' RANGE
180: %left <code> OROR
181: %left <code> ANDAND
182: %left <code> '|'
183: %left <code> '^'
184: %left <code> '&'
185: %left <code> MIN_MAX
186: %left <code> EQCOMPARE
187: %left <code> ARITHCOMPARE '<' '>'
188: %left <code> LSHIFT RSHIFT
189: %left <code> '+' '-'
190: %left <code> '*' '/' '%'
191: %right <code> UNARY PLUSPLUS MINUSMINUS
192: %left HYPERUNARY
193: %left <ttype> PAREN_STAR_PAREN LEFT_RIGHT
194: %left <code> POINTSAT POINTSAT_STAR '.' DOT_STAR '(' '['
195:
196: %right SCOPE /* C++ extension */
197: %nonassoc NEW DELETE RAISE RAISES RERAISE TRY EXCEPT CATCH THROW
198: %nonassoc ANSI_TRY ANSI_THROW
199: %right DYNAMIC
200:
201: %type <code> unop
202:
203: %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist
204: %type <ttype> optional_identifier
205: %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING
206: %type <ttype> typed_declspecs reserved_declspecs
207: %type <ttype> typed_typespecs reserved_typespecquals
208: %type <ttype> declmods typespec typespecqual_reserved
209: %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
210: %type <itype> initdecls notype_initdecls initdcl /* C++ modification */
211: %type <ttype> init initlist maybeasm
212: %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
213: %type <ttype> maybe_attribute attribute_list attrib
214: %type <ttype> abs_member_declarator after_type_member_declarator
215:
216: %type <ttype> compstmt except_stmts ansi_except_stmts
217:
218: %type <ttype> declarator notype_declarator after_type_declarator
219:
220: %type <ttype> structsp opt.component_decl_list component_decl_list component_decl components component_declarator
221: %type <ttype> enumlist enumerator
222: %type <ttype> typename absdcl absdcl1 type_quals abs_or_notype_decl
223: %type <ttype> xexpr see_typename parmlist parms parm bad_parm
224:
225: /* C++ extensions */
226: %type <ttype> TYPENAME_SCOPE
227: %token <ttype> TYPENAME_COLON TYPENAME_ELLIPSIS
228: %token <ttype> PTYPENAME SCOPED_TYPENAME
229: %token <ttype> PRE_PARSED_FUNCTION_DECL EXTERN_LANG_STRING ALL
230: %token <ttype> PRE_PARSED_CLASS_DECL
231: %type <ttype> fn.def1 /* Not really! */
232: %type <ttype> fn.def2 return_id
233: %type <ttype> named_class_head named_class_head_sans_basetype
234: %type <ttype> unnamed_class_head
235: %type <ttype> class_head base_class_list
236: %type <itype> base_class_visibility_list
237: %type <ttype> base_class maybe_base_class_list base_class.1
238: %type <ttype> after_type_declarator_no_typename
239: %type <ttype> maybe_raises raise_identifier raise_identifiers ansi_raise_identifier ansi_raise_identifiers
240: %type <ttype> component_declarator0 scoped_id scoped_typename
241: %type <ttype> forhead.1 identifier_or_opname operator_name
242: %type <ttype> new delete object object_star aggr
243: /* %type <ttype> primary_no_id */
244: %type <ttype> nonmomentary_expr
245: %type <itype> forhead.2 initdcl0 notype_initdcl0 wrapper member_init_list
246: %type <itype> .scope try ansi_try
247: %type <ttype> template_header template_parm_list template_parm
248: %type <ttype> template_type template_arg_list template_arg
249: %type <ttype> template_instantiation template_type_name tmpl.1 tmpl.2
250: %type <ttype> template_instantiate_once template_instantiate_some
251: %type <itype> fn_tmpl_end try_for_typename
252:
253: /* in order to recognize aggr tags as defining and thus shadowing. */
254: %token TYPENAME_DEFN IDENTIFIER_DEFN PTYPENAME_DEFN
255: %type <ttype> named_class_head_sans_basetype_defn
256: %type <ttype> identifier_defn IDENTIFIER_DEFN TYPENAME_DEFN PTYPENAME_DEFN
257:
258: /* cp-spew.c depends on this being the last token. Define
259: any new tokens before this one! */
260: %token END_OF_SAVED_INPUT
261:
262: %{
263: /* the declaration found for the last IDENTIFIER token read in.
264: yylex must look this up to detect typedefs, which get token type TYPENAME,
265: so it is left around in case the identifier is not a typedef but is
266: used in a context which makes it a reference to a variable. */
267: tree lastiddecl;
268:
269: /* Back-door communication channel to the lexer. */
270: extern int looking_for_typename;
271:
272: tree make_pointer_declarator (), make_reference_declarator ();
273:
274: void reinit_parse_for_function ();
275: void reinit_parse_for_method ();
276:
277: /* List of types and structure classes of the current declaration. */
278: tree current_declspecs;
279:
280: /* When defining an aggregate, this is the most recent one being defined. */
281: static tree current_aggr;
282:
283: int undeclared_variable_notice; /* 1 if we explained undeclared var errors. */
284:
285: int yylex ();
286:
287: #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
288: %}
289:
290: %%
291: program: /* empty */
292: | extdefs
293: { finish_file (); }
294: ;
295:
296: /* the reason for the strange actions in this rule
297: is so that notype_initdecls when reached via datadef
298: can find a valid list of type and sc specs in $0. */
299:
300: extdefs:
301: { $<ttype>$ = NULL_TREE; } extdef
302: {$<ttype>$ = NULL_TREE; }
303: | extdefs extdef
304: {$<ttype>$ = NULL_TREE; }
305: ;
306:
307: .hush_warning:
308: { have_extern_spec = 1;
309: $<ttype>$ = NULL_TREE; }
310: ;
311: .warning_ok:
312: { have_extern_spec = 0; }
313: ;
314:
315: extdef:
316: fndef
317: { if (pending_inlines) do_pending_inlines (); }
318: | datadef
319: { if (pending_inlines) do_pending_inlines (); }
320: | template_def
321: { if (pending_inlines) do_pending_inlines (); }
322: | overloaddef
323: | ASM '(' string ')' ';'
324: { if (pedantic)
325: warning ("ANSI C forbids use of `asm' keyword");
326: if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
327: assemble_asm ($3); }
328: | extern_lang_string '{' extdefs '}'
329: { pop_lang_context (); }
330: | extern_lang_string '{' '}'
331: { pop_lang_context (); }
332: | extern_lang_string .hush_warning fndef .warning_ok
333: { if (pending_inlines) do_pending_inlines ();
334: pop_lang_context (); }
335: | extern_lang_string .hush_warning datadef .warning_ok
336: { if (pending_inlines) do_pending_inlines ();
337: pop_lang_context (); }
338: ;
339:
340: extern_lang_string:
341: EXTERN_LANG_STRING
342: { push_lang_context ($1); }
343: ;
344:
345: template_header:
346: TEMPLATE '<'
347: { begin_template_parm_list (); }
348: template_parm_list '>'
349: { $$ = end_template_parm_list ($4); }
350: ;
351:
352: template_parm_list:
353: template_parm
354: { $$ = process_template_parm (0, $1); }
355: | template_parm_list ',' template_parm
356: { $$ = process_template_parm ($1, $3); }
357: ;
358:
359: template_parm:
360: /* The following rules introduce a new reduce/reduce
361: conflict: they are valid prefixes for a `structsp',
362: which means they could match a nameless parameter.
363: By putting them before the `parm' rule, we get
364: their match before considering them nameless parameter
365: declarations. */
366: aggr identifier
367: {
368: if ((enum tag_types) TREE_INT_CST_LOW ($1) != class_type)
369: error ("template type parameter must use keyword `class'");
370: $$ = build_tree_list ($2, NULL_TREE);
371: }
372: | aggr identifier_defn ':' base_class.1
373: {
374: if ((enum tag_types) TREE_INT_CST_LOW ($1) != class_type)
375: error ("template type parameter must use keyword `class'");
376: warning ("restricted template type parameters not yet implemented");
377: $$ = build_tree_list ($2, $4);
378: }
379: | aggr TYPENAME_COLON base_class.1
380: {
381: if ((enum tag_types) TREE_INT_CST_LOW ($1) != class_type)
382: error ("template type parameter must use keyword `class'");
383: warning ("restricted template type parameters not yet implemented");
384: $$ = build_tree_list ($2, $3);
385: }
386: | parm
387: ;
388:
389: overloaddef:
390: OVERLOAD ov_identifiers ';'
391:
392: ov_identifiers: IDENTIFIER
393: { declare_overloaded ($1); }
394: | ov_identifiers ',' IDENTIFIER
395: { declare_overloaded ($3); }
396: ;
397:
398: template_def:
399: /* Class template declarations go here; they aren't normal class
400: declarations, because we can't process the bodies yet. */
401: template_header named_class_head_sans_basetype '{'
402: { yychar = '{'; goto template1; }
403: ';'
404: | template_header named_class_head_sans_basetype_defn '{'
405: { yychar = '{'; goto template1; }
406: ';'
407: | template_header named_class_head_sans_basetype ':'
408: { yychar = ':'; goto template1; }
409: ';'
410: | template_header named_class_head_sans_basetype_defn ':'
411: {
412: yychar = ':';
413: template1:
414: if (current_aggr == exception_type_node)
415: error ("template type must define an aggregate or union");
416: /* Maybe pedantic warning for union?
417: How about an enum? :-) */
418: end_template_decl ($1, $2, current_aggr);
419: reinit_parse_for_template (yychar, $1, $2);
420: yychar = YYEMPTY;
421: }
422: ';'
423: | template_header named_class_head_sans_basetype ';'
424: {
425: end_template_decl ($1, $2, current_aggr);
426: /* declare $2 as template name with $1 parm list */
427: }
428: | template_header named_class_head_sans_basetype_defn ';'
429: {
430: end_template_decl ($1, $2, current_aggr);
431: /* declare $2 as template name with $1 parm list */
432: }
433: | template_header /* notype_initdcl0 ';' */
434: notype_declarator maybe_raises maybeasm maybe_attribute
435: fn_tmpl_end
436: {
437: tree d;
438: int momentary;
439: /* current_declspecs = $<ttype>0;*/
440: momentary = suspend_momentary ();
441: d = start_decl ($2, /*current_declspecs*/0, 0, $3);
442: finish_decl (d, NULL_TREE, $4);
443:
444: #if 0 /* Need to sort out destructor templates, and not give warnings
445: for them. */
446: if (pedantic)
447: error ("ANSI C forbids data definition with no type or storage class");
448: else if (! flag_traditional && ! have_extern_spec)
449: warning ("data definition has no type or storage class");
450: #endif
451: end_template_decl ($1, d, 0);
452: if ($6 != ';')
453: reinit_parse_for_template ($6, $1, d);
454: resume_momentary (momentary);
455: }
456: | template_header typed_declspecs /*initdcl0*/
457: declarator maybe_raises maybeasm maybe_attribute
458: fn_tmpl_end
459: {
460: tree d;
461: int momentary;
462:
463: current_declspecs = $2;
464: momentary = suspend_momentary ();
465: d = start_decl ($3, current_declspecs, 0, $4);
466: finish_decl (d, NULL_TREE, $5);
467: end_exception_decls ();
468: end_template_decl ($1, d, 0);
469: if ($7 != ';')
470: {
471: reinit_parse_for_template ($7, $1, d);
472: yychar = YYEMPTY;
473: }
474: note_list_got_semicolon ($<ttype>2);
475: resume_momentary (momentary);
476: }
477: | template_header declmods declarator fn_tmpl_end
478: {
479: tree d = start_decl ($3, $<ttype>2, 0, NULL_TREE);
480: finish_decl (d, NULL_TREE, NULL_TREE);
481: end_template_decl ($1, d, 0);
482: if ($4 != ';')
483: reinit_parse_for_template ($4, $1, d);
484: }
485: ;
486:
487: fn_tmpl_end: '{' { $$ = '{'; }
488: | ':' { $$ = ':'; }
489: | ';' { $$ = ';'; }
490: | '=' { $$ = '='; }
491: | RETURN { $$ = RETURN; }
492: ;
493:
494: datadef:
495: notype_initdecls ';'
496: { if (pedantic)
497: error ("ANSI C forbids data definition with no type or storage class");
498: else if (! flag_traditional && ! have_extern_spec)
499: warning ("data definition has no type or storage class"); }
500: | declmods notype_initdecls ';'
501: {}
502: /* Normal case to make fast: "int i;". */
503: | declmods declarator ';'
504: { tree d;
505: d = start_decl ($2, $<ttype>$, 0, NULL_TREE);
506: finish_decl (d, NULL_TREE, NULL_TREE);
507: }
508: | typed_declspecs initdecls ';'
509: {
510: end_exception_decls ();
511: note_list_got_semicolon ($<ttype>$);
512: }
513: /* Normal case: make this fast. */
514: | typed_declspecs declarator ';'
515: { tree d;
516: d = start_decl ($2, $<ttype>$, 0, NULL_TREE);
517: finish_decl (d, NULL_TREE, NULL_TREE);
518: end_exception_decls ();
519: note_list_got_semicolon ($<ttype>$);
520: }
521: | declmods ';'
522: { error ("empty declaration"); }
523: | typed_declspecs ';'
524: {
525: tree t = $<ttype>$;
526: shadow_tag (t);
527: if (TREE_CODE (t) == TREE_LIST
528: && TREE_PURPOSE (t) == NULL_TREE)
529: {
530: t = TREE_VALUE (t);
531: if (TREE_CODE (t) == RECORD_TYPE)
532: {
533: if (CLASSTYPE_USE_TEMPLATE (t) == 0)
534: CLASSTYPE_USE_TEMPLATE (t) = 2;
535: else if (CLASSTYPE_USE_TEMPLATE (t) == 1)
536: error ("override declaration for already-expanded template");
537: }
538: }
539: note_list_got_semicolon ($<ttype>$);
540: }
541: | error ';'
542: | error '}'
543: | ';'
544: ;
545:
546: fndef:
547: fn.def1 base_init compstmt_or_error
548: {
549: finish_function (lineno, 1);
550: /* finish_function performs these three statements:
551:
552: expand_end_bindings (getdecls (), 1, 0);
553: poplevel (1, 1, 0);
554:
555: expand_end_bindings (0, 0, 0);
556: poplevel (0, 0, 1);
557: */
558: if ($<ttype>$) process_next_inline ($<ttype>$);
559: }
560: | fn.def1 return_init base_init compstmt_or_error
561: {
562: finish_function (lineno, 1);
563: /* finish_function performs these three statements:
564:
565: expand_end_bindings (getdecls (), 1, 0);
566: poplevel (1, 1, 0);
567:
568: expand_end_bindings (0, 0, 0);
569: poplevel (0, 0, 1);
570: */
571: if ($<ttype>$) process_next_inline ($<ttype>$);
572: }
573: | fn.def1 nodecls compstmt_or_error
574: { finish_function (lineno, 0);
575: if ($<ttype>$) process_next_inline ($<ttype>$); }
576: | fn.def1 return_init ';' nodecls compstmt_or_error
577: { finish_function (lineno, 0);
578: if ($<ttype>$) process_next_inline ($<ttype>$); }
579: | fn.def1 return_init nodecls compstmt_or_error
580: { finish_function (lineno, 0);
581: if ($<ttype>$) process_next_inline ($<ttype>$); }
582: | typed_declspecs declarator error
583: {}
584: | declmods notype_declarator error
585: {}
586: | notype_declarator error
587: {}
588: ;
589:
590: fn.def1:
591: typed_declspecs declarator maybe_raises
592: { if (! start_function ($$, $2, $3, 0))
593: YYERROR1;
594: reinit_parse_for_function ();
595: $$ = NULL_TREE; }
596: | declmods notype_declarator maybe_raises
597: { if (! start_function ($$, $2, $3, 0))
598: YYERROR1;
599: reinit_parse_for_function ();
600: $$ = NULL_TREE; }
601: | notype_declarator maybe_raises
602: { if (! start_function (NULL_TREE, $$, $2, 0))
603: YYERROR1;
604: reinit_parse_for_function ();
605: $$ = NULL_TREE; }
606: | TYPENAME '(' parmlist ')' type_quals maybe_raises
607: { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, $3, $5), $6, 0))
608: YYERROR1;
609: reinit_parse_for_function ();
610: $$ = NULL_TREE; }
611: | scoped_typename '(' parmlist ')' type_quals maybe_raises
612: { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, $3, $5), $6, 0))
613: YYERROR1;
614: reinit_parse_for_function ();
615: $$ = NULL_TREE; }
616: | TYPENAME LEFT_RIGHT type_quals maybe_raises
617: { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, empty_parms (), $3), $4, 0))
618: YYERROR1;
619: reinit_parse_for_function ();
620: $$ = NULL_TREE; }
621: | scoped_typename LEFT_RIGHT type_quals maybe_raises
622: { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, empty_parms (), $3), $4, 0))
623: YYERROR1;
624: reinit_parse_for_function ();
625: $$ = NULL_TREE; }
626: | PRE_PARSED_FUNCTION_DECL
627: { start_function (NULL_TREE, TREE_VALUE ($$), NULL_TREE, 1);
628: reinit_parse_for_function (); }
629: ;
630:
631: /* more C++ complexity */
632: fn.def2:
633: typed_declspecs '(' parmlist ')' type_quals maybe_raises
634: {
635: tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), $3, $5);
636: $$ = start_method (TREE_CHAIN ($$), decl, $6);
637: if (! $$)
638: YYERROR1;
639: if (yychar == YYEMPTY)
640: yychar = YYLEX;
641: reinit_parse_for_method (yychar, $$); }
642: | typed_declspecs LEFT_RIGHT type_quals maybe_raises
643: {
644: tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), empty_parms (), $3);
645: $$ = start_method (TREE_CHAIN ($$), decl, $4);
646: if (! $$)
647: YYERROR1;
648: if (yychar == YYEMPTY)
649: yychar = YYLEX;
650: reinit_parse_for_method (yychar, $$); }
651: | typed_declspecs declarator maybe_raises
652: { $$ = start_method ($$, $2, $3);
653: if (! $$)
654: YYERROR1;
655: if (yychar == YYEMPTY)
656: yychar = YYLEX;
657: reinit_parse_for_method (yychar, $$); }
658: | declmods '(' parmlist ')' type_quals maybe_raises
659: {
660: tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), $3, $5);
661: $$ = start_method (TREE_CHAIN ($$), decl, $6);
662: if (! $$)
663: YYERROR1;
664: if (yychar == YYEMPTY)
665: yychar = YYLEX;
666: reinit_parse_for_method (yychar, $$); }
667: | declmods LEFT_RIGHT type_quals maybe_raises
668: {
669: tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), empty_parms (), $3);
670: $$ = start_method (TREE_CHAIN ($$), decl, $4);
671: if (! $$)
672: YYERROR1;
673: if (yychar == YYEMPTY)
674: yychar = YYLEX;
675: reinit_parse_for_method (yychar, $$); }
676: | declmods declarator maybe_raises
677: { $$ = start_method ($$, $2, $3);
678: if (! $$)
679: YYERROR1;
680: if (yychar == YYEMPTY)
681: yychar = YYLEX;
682: reinit_parse_for_method (yychar, $$); }
683: | notype_declarator maybe_raises
684: { $$ = start_method (NULL_TREE, $$, $2);
685: if (! $$)
686: YYERROR1;
687: if (yychar == YYEMPTY)
688: yychar = YYLEX;
689: reinit_parse_for_method (yychar, $$); }
690: ;
691:
692: return_id: RETURN IDENTIFIER
693: {
694: if (! current_function_parms_stored)
695: store_parm_decls ();
696: $$ = $2;
697: }
698: ;
699:
700: return_init: return_id
701: { store_return_init ($<ttype>$, NULL_TREE); }
702: | return_id '=' init
703: { store_return_init ($<ttype>$, $2); }
704: | return_id '(' nonnull_exprlist ')'
705: { store_return_init ($<ttype>$, $3); }
706: | return_id LEFT_RIGHT
707: { store_return_init ($<ttype>$, NULL_TREE); }
708: ;
709:
710: base_init:
711: ':' .set_base_init member_init_list
712: {
713: if ($3 == 0)
714: error ("no base initializers given following ':'");
715: setup_vtbl_ptr ();
716: }
717: ;
718:
719: .set_base_init:
720: /* empty */
721: {
722: if (! current_function_parms_stored)
723: store_parm_decls ();
724:
725: /* Flag that we are processing base and member initializers. */
726: current_vtable_decl = error_mark_node;
727:
728: if (DECL_CONSTRUCTOR_P (current_function_decl))
729: {
730: /* Make a contour for the initializer list. */
731: pushlevel (0);
732: clear_last_expr ();
733: expand_start_bindings (0);
734: }
735: else if (current_class_type == NULL_TREE)
736: error ("base initializers not allowed for non-member functions");
737: else if (! DECL_CONSTRUCTOR_P (current_function_decl))
738: error ("only constructors take base initializers");
739: }
740: ;
741:
742: member_init_list:
743: /* empty */
744: { $$ = 0; }
745: | member_init
746: { $$ = 1; }
747: | member_init_list ',' member_init
748: | member_init_list error
749: ;
750:
751: member_init: '(' nonnull_exprlist ')'
752: {
753: if (current_class_name && pedantic)
754: warning ("old style base class initialization; use `%s (...)'",
755: IDENTIFIER_POINTER (current_class_name));
756: expand_member_init (C_C_D, NULL_TREE, $2);
757: }
758: | LEFT_RIGHT
759: {
760: if (current_class_name && pedantic)
761: warning ("old style base class initialization; use `%s (...)'",
762: IDENTIFIER_POINTER (current_class_name));
763: expand_member_init (C_C_D, NULL_TREE, void_type_node);
764: }
765: | identifier '(' nonnull_exprlist ')'
766: {
767: expand_member_init (C_C_D, $<ttype>$, $3);
768: }
769: | identifier LEFT_RIGHT
770: { expand_member_init (C_C_D, $<ttype>$, void_type_node); }
771: | scoped_id identifier '(' nonnull_exprlist ')'
772: {
773: do_member_init ($<ttype>$, $2, $4);
774: }
775: | scoped_id identifier LEFT_RIGHT
776: {
777: do_member_init ($<ttype>$, $2, void_type_node);
778: }
779: ;
780:
781: identifier:
782: IDENTIFIER
783: | TYPENAME
784: | PTYPENAME
785: ;
786:
787: identifier_defn:
788: IDENTIFIER_DEFN
789: | TYPENAME_DEFN
790: | PTYPENAME_DEFN
791: ;
792:
793: identifier_or_opname:
794: IDENTIFIER
795: | TYPENAME
796: | PTYPENAME
797: /* | '~' TYPENAME
798: { $$ = build_parse_node (BIT_NOT_EXPR, $2); }*/
799: /* get rid of the next line, replace it with the above */
800: | '~' identifier { $$ = build_parse_node (BIT_NOT_EXPR,$2);}
801: | operator_name
802: | wrapper IDENTIFIER
803: { $$ = hack_wrapper ($$, NULL_TREE, $2); }
804: | wrapper TYPENAME
805: { $$ = hack_wrapper ($$, NULL_TREE, $2); }
806: | wrapper operator_name
807: { $$ = hack_wrapper ($$, NULL_TREE, $2); }
808: | wrapper scoped_id IDENTIFIER
809: { $$ = hack_wrapper ($$, $2, $3); }
810: | wrapper scoped_id operator_name
811: { $$ = hack_wrapper ($$, $2, $3); }
812: ;
813:
814: wrapper: LEFT_RIGHT
815: { $$ = 0; }
816: | '~' LEFT_RIGHT
817: { $$ = 1; }
818: | LEFT_RIGHT '?'
819: { $$ = 2; }
820: ;
821:
822: template_type:
823: template_type_name tmpl.1 template_instantiation
824: {
825: if ($3)
826: $$ = $3;
827: else if ($$ != error_mark_node)
828: $$ = IDENTIFIER_TYPE_VALUE ($$);
829: }
830: ;
831:
832: template_type_name:
833: PTYPENAME '<' template_arg_list '>'
834: { $$ = lookup_template_class ($$, $3); }
835: ;
836:
837: tmpl.1:
838: /* Expansion of template may be required, unless we're followed by
839: a class definition. */
840: '{' { yyungetc ('{', 1); $$ = 0; }
841: | ':' { yyungetc (':', 1); $$ = 0; }
842: | /* empty */ %prec EMPTY
843: { $$ = instantiate_class_template ($<ttype>0, 1); }
844: ;
845:
846: tmpl.2:
847: /* Always do expansion if it hasn't been done already. */
848: { $$ = instantiate_class_template ($<ttype>0, 1); }
849: ;
850:
851: template_arg_list:
852: template_arg
853: { $$ = build_tree_list (NULL_TREE, $$); }
854: | template_arg_list ',' template_arg
855: { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); }
856: ;
857:
858: template_arg:
859: typename
860: { $$ = groktypename ($$); }
861: | expr_no_commas %prec UNARY
862: ;
863:
864: template_instantiate_once:
865: PRE_PARSED_CLASS_DECL maybe_base_class_list
866: {
867: tree t, decl, id, tmpl;
868:
869: id = TREE_VALUE ($1);
870: tmpl = TREE_PURPOSE (IDENTIFIER_TEMPLATE (id));
871: t = xref_tag (DECL_TEMPLATE_INFO (tmpl)->aggr, id, $2);
872: set_current_level_tags_transparency (1);
873: assert (TREE_CODE (t) == RECORD_TYPE);
874: $<ttype>$ = t;
875:
876: /* Now, put a copy of the decl in global scope, to avoid
877: recursive expansion. */
878: decl = IDENTIFIER_LOCAL_VALUE (id);
879: if (!decl)
880: decl = IDENTIFIER_CLASS_VALUE (id);
881: /* Now, put a copy of the decl in global scope, to avoid
882: recursive expansion. */
883: if (decl)
884: {
885: /* Need to copy it to clear the chain pointer,
886: and need to get it into permanent storage. */
887: extern struct obstack permanent_obstack;
888: assert (TREE_CODE (decl) == TYPE_DECL);
889: push_obstacks (&permanent_obstack, &permanent_obstack);
890: decl = copy_node (decl);
891: if (DECL_LANG_SPECIFIC (decl))
892: copy_lang_decl (decl);
893: pop_obstacks ();
894: pushdecl_top_level (decl);
895: }
896: }
897: LC opt.component_decl_list '}'
898: {
899: extern void end_template_instantiation ();
900: tree id, members;
901:
902: $$ = finish_struct ($<ttype>3, $5, 0, 0);
903:
904: pop_obstacks ();
905: end_template_instantiation ($1, $<ttype>3);
906:
907: /* Now go after the methods & class data. */
908: instantiate_member_templates ($1);
909: }
910: ;
911:
912: template_instantiation:
913: /* empty */
914: { $$ = NULL_TREE; }
915: | template_instantiate_once
916: { $$ = $1; }
917: ;
918:
919: template_instantiate_some:
920: /* empty */
921: { $$ = NULL_TREE; /* never used from here... */}
922: | template_instantiate_once template_instantiate_some
923: { $$ = $1; /*???*/ }
924: ;
925:
926: unop: '-'
927: { $$ = NEGATE_EXPR; }
928: | '+'
929: { $$ = CONVERT_EXPR; }
930: | PLUSPLUS
931: { $$ = PREINCREMENT_EXPR; }
932: | MINUSMINUS
933: { $$ = PREDECREMENT_EXPR; }
934: | '!'
935: { $$ = TRUTH_NOT_EXPR; }
936: ;
937:
938: expr: nonnull_exprlist
939: { $$ = build_x_compound_expr ($$); }
940: /* Ugly, but faster. */
941: | expr_no_commas
942: ;
943:
944: nonnull_exprlist:
945: expr_no_commas
946: { $$ = build_tree_list (NULL_TREE, $$); }
947: | nonnull_exprlist ',' expr_no_commas
948: { chainon ($$, build_tree_list (NULL_TREE, $3)); }
949: | nonnull_exprlist ',' error
950: { chainon ($$, build_tree_list (NULL_TREE, error_mark_node)); }
951: ;
952:
953: unary_expr:
954: primary %prec UNARY
955: {
956: if (TREE_CODE ($$) == TYPE_EXPR)
957: $$ = build_component_type_expr (C_C_D, $$, NULL_TREE, 1);
958: }
959: | '*' cast_expr %prec UNARY
960: { $$ = build_x_indirect_ref ($2, "unary *"); }
961: | '&' cast_expr %prec UNARY
962: { $$ = build_x_unary_op (ADDR_EXPR, $2); }
963: | '~' cast_expr %prec UNARY
964: { $$ = build_x_unary_op (BIT_NOT_EXPR, $2); }
965: | unop cast_expr %prec UNARY
966: { $$ = build_x_unary_op ($$, $2);
967: if ($1 == NEGATE_EXPR && TREE_CODE ($2) == INTEGER_CST)
968: TREE_NEGATED_INT ($$) = 1;
969: }
970: | SIZEOF unary_expr %prec UNARY
971: { if (TREE_CODE ($2) == COMPONENT_REF
972: && DECL_BIT_FIELD (TREE_OPERAND ($2, 1)))
973: error ("sizeof applied to a bit-field");
974: /* ANSI says arrays and functions are converted inside comma.
975: But we can't really convert them in build_compound_expr
976: because that would break commas in lvalues.
977: So do the conversion here if operand was a comma. */
978: if (TREE_CODE ($2) == COMPOUND_EXPR
979: && (TREE_CODE (TREE_TYPE ($2)) == ARRAY_TYPE
980: || TREE_CODE (TREE_TYPE ($2)) == FUNCTION_TYPE))
981: $2 = default_conversion ($2);
982: $$ = c_sizeof (TREE_TYPE ($2)); }
983: | SIZEOF '(' typename ')' %prec HYPERUNARY
984: { $$ = c_sizeof (groktypename ($3)); }
985: | ALIGNOF unary_expr %prec UNARY
986: { if (TREE_CODE ($2) == COMPONENT_REF
987: && DECL_BIT_FIELD (TREE_OPERAND ($2, 1)))
988: error ("`__alignof' applied to a bit-field");
989: if (TREE_CODE ($2) == INDIRECT_REF)
990: {
991: tree t = TREE_OPERAND ($2, 0);
992: tree best = t;
993: int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
994: while (TREE_CODE (t) == NOP_EXPR
995: && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
996: {
997: int thisalign;
998: t = TREE_OPERAND (t, 0);
999: thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
1000: if (thisalign > bestalign)
1001: best = t, bestalign = thisalign;
1002: }
1003: $$ = c_alignof (TREE_TYPE (TREE_TYPE (best)));
1004: }
1005: else
1006: {
1007: /* ANSI says arrays and fns are converted inside comma.
1008: But we can't convert them in build_compound_expr
1009: because that would break commas in lvalues.
1010: So do the conversion here if operand was a comma. */
1011: if (TREE_CODE ($2) == COMPOUND_EXPR
1012: && (TREE_CODE (TREE_TYPE ($2)) == ARRAY_TYPE
1013: || TREE_CODE (TREE_TYPE ($2)) == FUNCTION_TYPE))
1014: $2 = default_conversion ($2);
1015: $$ = c_alignof (TREE_TYPE ($2));
1016: }
1017: }
1018: | ALIGNOF '(' typename ')' %prec HYPERUNARY
1019: { $$ = c_alignof (groktypename ($3)); }
1020:
1021: | .scope new typename %prec '='
1022: { $$ = build_new ($2, $3, NULL_TREE, $$); }
1023: | .scope new typespec '(' nonnull_exprlist ')'
1024: { $$ = build_new ($2, $3, $5, $$); }
1025: | .scope new typespec LEFT_RIGHT
1026: { $$ = build_new ($2, $3, NULL_TREE, $$); }
1027: | .scope new typename '=' init %prec '='
1028: { $$ = build_new ($2, $3, $5, $$); }
1029:
1030: /* I'm not sure why this is disallowed. But since it is, and it
1031: doesn't seem difficult to catch it, let's give a message, so
1032: the programmer can fix it. --Ken Raeburn */
1033: | .scope new '(' typed_typespecs absdcl ')' '[' nonmomentary_expr ']'
1034: {
1035: tree absdcl, typename;
1036: static int gave_warning = 0;
1037:
1038: illegal_new_array:
1039: absdcl = build_parse_node (ARRAY_REF, $5, $8);
1040: typename = build_decl_list ($4, absdcl);
1041: warning ("array dimensions with parenthesized type is disallowed in standard C++");
1042: if (!gave_warning)
1043: {
1044: gave_warning++;
1045: warning (" (per grammar in Ellis & Stroustrup [1990], chapter 17)");
1046: warning (" try rewriting, perhaps with a typedef");
1047: }
1048: $$ = build_new ($2, typename, NULL_TREE, $$);
1049: }
1050: | .scope new '(' nonempty_type_quals absdcl ')' '[' nonmomentary_expr ']'
1051: { goto illegal_new_array; }
1052:
1053: | .scope new '(' typed_typespecs absdcl ')'
1054: {
1055: $$ = build_new ($2, build_decl_list ($4, $5), NULL_TREE, $$);
1056: }
1057: | .scope new '(' nonempty_type_quals absdcl ')'
1058: { $$ = build_new ($2, build_decl_list ($4, $5), NULL_TREE, $$); }
1059: /* Unswallow a ':' which is probably meant for ?: expression. */
1060: | .scope new TYPENAME_COLON
1061: { yyungetc (':', 1);
1062: $$ = build_new ($2, $3, NULL_TREE, $$); }
1063:
1064: | delete cast_expr %prec UNARY
1065: { tree expr = stabilize_reference (convert_from_reference ($2));
1066: tree type = TREE_TYPE (expr);
1067:
1068: if (integer_zerop (expr))
1069: $$ = build1 (NOP_EXPR, void_type_node, expr);
1070: else if (TREE_CODE (type) != POINTER_TYPE)
1071: {
1072: error ("non-pointer type to `delete'");
1073: $$ = error_mark_node;
1074: break;
1075: }
1076: $$ = build_delete (type, expr, integer_three_node,
1077: LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE,
1078: TYPE_HAS_DESTRUCTOR (TREE_TYPE (type)) ? $$ : 0, 1);
1079: }
1080: | delete '[' ']' cast_expr %prec UNARY
1081: {
1082: tree exp = stabilize_reference (convert_from_reference ($4));
1083: tree elt_size = c_sizeof (TREE_TYPE (exp));
1084:
1085: if (yychar == YYEMPTY)
1086: yychar = YYLEX;
1087:
1088: $$ = build_vec_delete (exp, NULL_TREE, elt_size, NULL_TREE,
1089: integer_one_node, integer_two_node);
1090: }
1091: | delete '[' expr ']' cast_expr %prec UNARY
1092: {
1093: tree maxindex = build_binary_op (MINUS_EXPR, $3,
1094: integer_one_node);
1095: tree exp = stabilize_reference (convert_from_reference ($5));
1096: tree elt_size = c_sizeof (TREE_TYPE (exp));
1097:
1098: if (yychar == YYEMPTY)
1099: yychar = YYLEX;
1100:
1101: warning ("use of array size with vector delete is anachronistic");
1102: $$ = build_vec_delete (exp, maxindex, elt_size, NULL_TREE,
1103: integer_one_node, integer_two_node);
1104: }
1105: ;
1106:
1107: cast_expr:
1108: unary_expr
1109: | '(' typename ')' expr_no_commas %prec UNARY
1110: { tree type = groktypename ($2);
1111: $$ = build_c_cast (type, $4); }
1112: | '(' typename ')' '{' initlist maybecomma '}' %prec UNARY
1113: { tree type = groktypename ($2);
1114: tree init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($5));
1115: if (pedantic)
1116: warning ("ANSI C forbids constructor-expressions");
1117: /* Indicate that this was a GNU C constructor expression. */
1118: TREE_HAS_CONSTRUCTOR (init) = 1;
1119: $$ = digest_init (type, init, 0);
1120: if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
1121: {
1122: int failure = complete_array_type (type, $$, 1);
1123: if (failure)
1124: abort ();
1125: }
1126: }
1127: | HEADOF '(' expr ')'
1128: { $$ = build_headof ($3); }
1129: | CLASSOF '(' expr ')'
1130: { $$ = build_classof ($3); }
1131: | CLASSOF '(' TYPENAME ')'
1132: { if (is_aggr_typedef ($3, 1))
1133: {
1134: tree type = IDENTIFIER_TYPE_VALUE ($3);
1135: $$ = CLASSTYPE_DOSSIER (type);
1136: }
1137: else
1138: $$ = error_mark_node;
1139: }
1140: ;
1141:
1142: expr_no_commas:
1143: cast_expr
1144: | expr_no_commas '+' expr_no_commas
1145: { $$ = build_x_binary_op ($2, $$, $3); }
1146: | expr_no_commas '-' expr_no_commas
1147: { $$ = build_x_binary_op ($2, $$, $3); }
1148: | expr_no_commas '*' expr_no_commas
1149: { $$ = build_x_binary_op ($2, $$, $3); }
1150: | expr_no_commas '/' expr_no_commas
1151: { $$ = build_x_binary_op ($2, $$, $3); }
1152: | expr_no_commas '%' expr_no_commas
1153: { $$ = build_x_binary_op ($2, $$, $3); }
1154: | expr_no_commas LSHIFT expr_no_commas
1155: { $$ = build_x_binary_op ($2, $$, $3); }
1156: | expr_no_commas RSHIFT expr_no_commas
1157: { $$ = build_x_binary_op ($2, $$, $3); }
1158: | expr_no_commas ARITHCOMPARE expr_no_commas
1159: { $$ = build_x_binary_op ($2, $$, $3); }
1160: | expr_no_commas '<' expr_no_commas
1161: { $$ = build_x_binary_op (LT_EXPR, $$, $3); }
1162: | expr_no_commas '>' expr_no_commas
1163: { $$ = build_x_binary_op (GT_EXPR, $$, $3); }
1164: | expr_no_commas EQCOMPARE expr_no_commas
1165: { $$ = build_x_binary_op ($2, $$, $3); }
1166: | expr_no_commas MIN_MAX expr_no_commas
1167: { $$ = build_x_binary_op ($2, $$, $3); }
1168: | expr_no_commas '&' expr_no_commas
1169: { $$ = build_x_binary_op ($2, $$, $3); }
1170: | expr_no_commas '|' expr_no_commas
1171: { $$ = build_x_binary_op ($2, $$, $3); }
1172: | expr_no_commas '^' expr_no_commas
1173: { $$ = build_x_binary_op ($2, $$, $3); }
1174: | expr_no_commas ANDAND expr_no_commas
1175: { $$ = build_x_binary_op (TRUTH_ANDIF_EXPR, $$, $3); }
1176: | expr_no_commas OROR expr_no_commas
1177: { $$ = build_x_binary_op (TRUTH_ORIF_EXPR, $$, $3); }
1178: | expr_no_commas '?' xexpr ':' expr_no_commas
1179: { $$ = build_x_conditional_expr ($$, $3, $5); }
1180: | expr_no_commas '=' expr_no_commas
1181: { $$ = build_modify_expr ($$, NOP_EXPR, $3); }
1182: | expr_no_commas ASSIGN expr_no_commas
1183: { register tree rval;
1184: if (rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, $$, $3, $2))
1185: $$ = rval;
1186: else
1187: $$ = build_modify_expr ($$, $2, $3); }
1188: | primary DOT_STAR expr_no_commas %prec UNARY
1189: { $$ = build_m_component_ref ($$, build_indirect_ref ($3, 0)); }
1190: /* Handle general members. */
1191: | object_star expr_no_commas %prec UNARY
1192: { $$ = build_x_binary_op (MEMBER_REF, $$, $2); }
1193: /* These extensions are not defined.
1194: | object '&' expr_no_commas %prec UNARY
1195: { $$ = build_m_component_ref ($$, build_x_unary_op (ADDR_EXPR, $3)); }
1196: | object unop expr_no_commas %prec UNARY
1197: { $$ = build_m_component_ref ($$, build_x_unary_op ($2, $3)); }
1198: | object '(' typename ')' expr_no_commas %prec UNARY
1199: { tree type = groktypename ($3);
1200: $$ = build_m_component_ref ($$, build_c_cast (type, $5)); }
1201: | object primary_no_id %prec UNARY
1202: { $$ = build_m_component_ref ($$, $2); }
1203: */
1204: ;
1205:
1206: primary:
1207: IDENTIFIER
1208: { $$ = do_identifier ($$); }
1209: | operator_name
1210: {
1211: tree op = $$;
1212: if (TREE_CODE (op) != IDENTIFIER_NODE)
1213: $$ = op;
1214: else
1215: {
1216: $$ = lookup_name (op);
1217: if ($$ == NULL_TREE)
1218: {
1219: error ("operator %s not defined", operator_name_string (op));
1220: $$ = error_mark_node;
1221: }
1222: }
1223: }
1224: | CONSTANT
1225: | string
1226: { $$ = combine_strings ($$); }
1227: | '(' expr ')'
1228: { $$ = $2; }
1229: | '(' error ')'
1230: { $$ = error_mark_node; }
1231: | '('
1232: { if (current_function_decl == 0)
1233: {
1234: error ("braced-group within expression allowed only inside a function");
1235: YYERROR;
1236: }
1237: keep_next_level ();
1238: $<ttype>$ = expand_start_stmt_expr (); }
1239: compstmt ')'
1240: { tree rtl_exp;
1241: if (pedantic)
1242: warning ("ANSI C forbids braced-groups within expressions");
1243: rtl_exp = expand_end_stmt_expr ($<ttype>2);
1244: /* The statements have side effects, so the group does. */
1245: TREE_SIDE_EFFECTS (rtl_exp) = 1;
1246:
1247: /* Make a BIND_EXPR for the BLOCK already made. */
1248: $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp),
1249: NULL_TREE, rtl_exp, $3);
1250: }
1251: | primary '(' nonnull_exprlist ')'
1252: { /* [eichin:19911016.1902EST] */
1253: extern struct pending_template* pending_templates;
1254: $<ttype>$ = build_x_function_call ($1, $3, current_class_decl);
1255: /* here we instantiate_class_template as needed... */
1256: if (pending_templates) do_pending_templates ();
1257: } template_instantiate_some {
1258: if (TREE_CODE ($<ttype>5) == CALL_EXPR
1259: && TREE_TYPE ($<ttype>5) != void_type_node)
1260: $$ = require_complete_type ($<ttype>5);
1261: else
1262: $$ = $<ttype>5;
1263: }
1264: | primary LEFT_RIGHT
1265: {
1266: $$ = build_x_function_call ($$, NULL_TREE, current_class_decl);
1267: if (TREE_CODE ($$) == CALL_EXPR
1268: && TREE_TYPE ($$) != void_type_node)
1269: $$ = require_complete_type ($$);
1270: }
1271: | primary '[' expr ']'
1272: {
1273: do_array:
1274: {
1275: tree array_expr = $$;
1276: tree index_exp = $3;
1277: tree type = TREE_TYPE (array_expr);
1278: if (type == error_mark_node || index_exp == error_mark_node)
1279: $$ = error_mark_node;
1280: else if (type == NULL_TREE)
1281: {
1282: /* Something has gone very wrong. Assume we
1283: are mistakenly reducing an expression
1284: instead of a declaration. */
1285: error ("parser may be lost: is there a '{' missing somewhere?");
1286: $$ = NULL_TREE;
1287: }
1288: else
1289: {
1290: if (TREE_CODE (type) == OFFSET_TYPE)
1291: type = TREE_TYPE (type);
1292: if (TREE_CODE (type) == REFERENCE_TYPE)
1293: type = TREE_TYPE (type);
1294:
1295: if (TYPE_LANG_SPECIFIC (type)
1296: && TYPE_OVERLOADS_ARRAY_REF (type))
1297: $$ = build_opfncall (ARRAY_REF, LOOKUP_NORMAL, array_expr, index_exp);
1298: else if (TREE_CODE (type) == POINTER_TYPE
1299: || TREE_CODE (type) == ARRAY_TYPE)
1300: $$ = build_array_ref (array_expr, index_exp);
1301: else
1302: {
1303: type = TREE_TYPE (index_exp);
1304: if (TREE_CODE (type) == OFFSET_TYPE)
1305: type = TREE_TYPE (type);
1306: if (TREE_CODE (type) == REFERENCE_TYPE)
1307: type = TREE_TYPE (type);
1308:
1309: if (TYPE_LANG_SPECIFIC (type)
1310: && TYPE_OVERLOADS_ARRAY_REF (type))
1311: error ("array expression backwards");
1312: else if (TREE_CODE (type) == POINTER_TYPE
1313: || TREE_CODE (type) == ARRAY_TYPE)
1314: $$ = build_array_ref (index_exp, array_expr);
1315: else
1316: error("[] applied to non-pointer type");
1317: }
1318: }
1319: }
1320: }
1321: | object identifier_or_opname %prec UNARY
1322: { $$ = build_component_ref ($$, $2, NULL_TREE, 1); }
1323: | object scoped_id identifier_or_opname %prec UNARY
1324: {
1325: tree basetype = $2;
1326: if (is_aggr_typedef (basetype, 1))
1327: {
1328: basetype = IDENTIFIER_TYPE_VALUE (basetype);
1329:
1330: if ($$ == error_mark_node)
1331: ;
1332: else if (binfo_or_else (basetype, TREE_TYPE ($$)))
1333: $$ = build_component_ref (build_scoped_ref ($$, $2), $3, NULL_TREE, 1);
1334: else
1335: $$ = error_mark_node;
1336: }
1337: else $$ = error_mark_node;
1338: }
1339: | primary PLUSPLUS
1340: { $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); }
1341: | primary MINUSMINUS
1342: { $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); }
1343:
1344: /* C++ extensions */
1345: | THIS
1346: { if (current_class_decl)
1347: {
1348: #ifdef WARNING_ABOUT_CCD
1349: TREE_USED (current_class_decl) = 1;
1350: #endif
1351: $$ = current_class_decl;
1352: }
1353: else if (current_function_decl
1354: && DECL_STATIC_FUNCTION_P (current_function_decl))
1355: {
1356: error ("`this' is unavailable for static member functions");
1357: $$ = error_mark_node;
1358: }
1359: else
1360: {
1361: if (current_function_decl)
1362: error ("invalid use of `this' in non-member function");
1363: else
1364: error ("invalid use of `this' at top level");
1365: $$ = error_mark_node;
1366: }
1367: }
1368: | TYPE_QUAL '(' nonnull_exprlist ')'
1369: {
1370: tree type;
1371: tree id = $$;
1372:
1373: /* This is a C cast in C++'s `functional' notation. */
1374: if ($3 == error_mark_node)
1375: {
1376: $$ = error_mark_node;
1377: break;
1378: }
1379: #if 0
1380: if ($3 == NULL_TREE)
1381: {
1382: error ("cannot cast null list to type `%s'",
1383: IDENTIFIER_POINTER (TYPE_NAME (id)));
1384: $$ = error_mark_node;
1385: break;
1386: }
1387: #endif
1388: if (type == error_mark_node)
1389: $$ = error_mark_node;
1390: else
1391: {
1392: if (id == ridpointers[(int) RID_CONST])
1393: type = build_type_variant (integer_type_node, 1, 0);
1394: else if (id == ridpointers[(int) RID_VOLATILE])
1395: type = build_type_variant (integer_type_node, 0, 1);
1396: else if (id == ridpointers[(int) RID_FRIEND])
1397: {
1398: error ("cannot cast expression to `friend' type");
1399: $$ = error_mark_node;
1400: break;
1401: }
1402: else abort ();
1403: $$ = build_c_cast (type, build_compound_expr ($3));
1404: }
1405: }
1406: | typespec '(' nonnull_exprlist ')'
1407: { $$ = build_functional_cast ($$, $3); }
1408: | typespec LEFT_RIGHT
1409: { $$ = build_functional_cast ($$, NULL_TREE); }
1410: | SCOPE IDENTIFIER
1411: {
1412: do_scoped_id:
1413: $$ = IDENTIFIER_GLOBAL_VALUE ($2);
1414: if (yychar == YYEMPTY)
1415: yychar = YYLEX;
1416: if (! $$)
1417: {
1418: if (yychar == '(' || yychar == LEFT_RIGHT)
1419: $$ = implicitly_declare ($2);
1420: else
1421: {
1422: if (IDENTIFIER_GLOBAL_VALUE ($2) != error_mark_node)
1423: error ("undeclared variable `%s' (first use here)",
1424: IDENTIFIER_POINTER ($2));
1425: $$ = error_mark_node;
1426: /* Prevent repeated error messages. */
1427: IDENTIFIER_GLOBAL_VALUE ($2) = error_mark_node;
1428: }
1429: }
1430: else
1431: {
1432: assemble_external ($$);
1433: TREE_USED ($$) = 1;
1434: }
1435: if (TREE_CODE ($$) == CONST_DECL)
1436: $$ = DECL_INITIAL ($$);
1437: /* XXX CHS - should we set TREE_USED of the constant? */
1438: }
1439: | SCOPE operator_name
1440: {
1441: if (TREE_CODE ($2) == IDENTIFIER_NODE)
1442: goto do_scoped_id;
1443: do_scoped_operator:
1444: $$ = $2;
1445: }
1446: | scoped_id identifier_or_opname %prec HYPERUNARY
1447: { $$ = build_offset_ref ($$, $2); }
1448: | scoped_id identifier_or_opname '(' nonnull_exprlist ')'
1449: { $$ = build_member_call ($$, $2, $4); }
1450: | scoped_id identifier_or_opname LEFT_RIGHT
1451: { $$ = build_member_call ($$, $2, NULL_TREE); }
1452: | object identifier_or_opname '(' nonnull_exprlist ')'
1453: { $$ = build_method_call ($$, $2, $4, NULL_TREE,
1454: (LOOKUP_NORMAL|LOOKUP_AGGR)); }
1455: | object identifier_or_opname LEFT_RIGHT
1456: { $$ = build_method_call ($$, $2, NULL_TREE, NULL_TREE,
1457: (LOOKUP_NORMAL|LOOKUP_AGGR)); }
1458: | object scoped_id identifier_or_opname '(' nonnull_exprlist ')'
1459: { $$ = build_scoped_method_call ($$, $2, $3, $5); }
1460: | object scoped_id identifier_or_opname LEFT_RIGHT
1461: { $$ = build_scoped_method_call ($$, $2, $3, NULL_TREE); }
1462: ;
1463:
1464: /* Not needed for now.
1465:
1466: primary_no_id:
1467: '(' expr ')'
1468: { $$ = $2; }
1469: | '(' error ')'
1470: { $$ = error_mark_node; }
1471: | '('
1472: { if (current_function_decl == 0)
1473: {
1474: error ("braced-group within expression allowed only inside a function");
1475: YYERROR;
1476: }
1477: $<ttype>$ = expand_start_stmt_expr (); }
1478: compstmt ')'
1479: { if (pedantic)
1480: warning ("ANSI C forbids braced-groups within expressions");
1481: $$ = expand_end_stmt_expr ($<ttype>2); }
1482: | primary_no_id '(' nonnull_exprlist ')'
1483: { $$ = build_x_function_call ($$, $3, current_class_decl); }
1484: | primary_no_id LEFT_RIGHT
1485: { $$ = build_x_function_call ($$, NULL_TREE, current_class_decl); }
1486: | primary_no_id '[' expr ']'
1487: { goto do_array; }
1488: | primary_no_id PLUSPLUS
1489: { $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); }
1490: | primary_no_id MINUSMINUS
1491: { $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); }
1492: | SCOPE IDENTIFIER
1493: { goto do_scoped_id; }
1494: | SCOPE operator_name
1495: { if (TREE_CODE ($2) == IDENTIFIER_NODE)
1496: goto do_scoped_id;
1497: goto do_scoped_operator;
1498: }
1499: ;
1500: */
1501:
1502: new: NEW
1503: { $$ = NULL_TREE; }
1504: | NEW '{' nonnull_exprlist '}'
1505: { $$ = $3; }
1506: | NEW DYNAMIC %prec EMPTY
1507: { $$ = void_type_node; }
1508: | NEW DYNAMIC '(' string ')'
1509: { $$ = combine_strings ($4); }
1510: ;
1511:
1512: .scope:
1513: /* empty */
1514: { $$ = 0; }
1515: | SCOPE
1516: { $$ = 1; }
1517: ;
1518:
1519: delete: DELETE
1520: { $$ = NULL_TREE; }
1521: | SCOPE delete
1522: { if ($2)
1523: error ("extra `::' before `delete' ignored");
1524: $$ = error_mark_node;
1525: }
1526: ;
1527:
1528: /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */
1529: string:
1530: STRING
1531: | string STRING
1532: { $$ = chainon ($$, $2); }
1533: ;
1534:
1535: nodecls:
1536: /* empty */
1537: {
1538: if (! current_function_parms_stored)
1539: store_parm_decls ();
1540: setup_vtbl_ptr ();
1541: }
1542: ;
1543:
1544: object: primary '.'
1545: {
1546: if ($$ == error_mark_node)
1547: ;
1548: else
1549: {
1550: tree type = TREE_TYPE ($$);
1551:
1552: if (! PROMOTES_TO_AGGR_TYPE (type, REFERENCE_TYPE))
1553: {
1554: error ("object in '.' expression is not of aggregate type");
1555: $$ = error_mark_node;
1556: }
1557: }
1558: }
1559: | primary POINTSAT
1560: {
1561: $$ = build_x_arrow ($$, 0);
1562: }
1563: ;
1564:
1565: object_star: primary POINTSAT_STAR
1566: ;
1567:
1568: decl:
1569: typed_declspecs initdecls ';'
1570: {
1571: resume_momentary ($2);
1572: note_list_got_semicolon ($<ttype>$);
1573: }
1574: /* Normal case: make this fast. */
1575: | typed_declspecs declarator ';'
1576: { tree d;
1577: int yes = suspend_momentary ();
1578: d = start_decl ($2, $<ttype>$, 0, NULL_TREE);
1579: finish_decl (d, NULL_TREE, NULL_TREE);
1580: resume_momentary (yes);
1581: note_list_got_semicolon ($<ttype>$);
1582: }
1583: | declmods notype_initdecls ';'
1584: { resume_momentary ($2); }
1585: /* Normal case: make this fast. */
1586: | declmods declarator ';'
1587: { tree d;
1588: int yes = suspend_momentary ();
1589: d = start_decl ($2, $<ttype>$, 0, NULL_TREE);
1590: finish_decl (d, NULL_TREE, NULL_TREE);
1591: resume_momentary (yes);
1592: }
1593: | typed_declspecs ';'
1594: {
1595: shadow_tag ($<ttype>$);
1596: note_list_got_semicolon ($<ttype>$);
1597: }
1598: | declmods ';'
1599: { warning ("empty declaration"); }
1600: ;
1601:
1602: /* Any kind of declarator (thus, all declarators allowed
1603: after an explicit typespec). */
1604:
1605: declarator:
1606: after_type_declarator
1607: | notype_declarator
1608: | START_DECLARATOR after_type_declarator
1609: { $$ = $2; }
1610: | START_DECLARATOR notype_declarator
1611: { $$ = $2; }
1612: ;
1613:
1614: /* Declspecs which contain at least one type specifier or typedef name.
1615: (Just `const' or `volatile' is not enough.)
1616: A typedef'd name following these is taken as a name to be declared. */
1617:
1618: typed_declspecs:
1619: typespec %prec HYPERUNARY
1620: { $$ = list_hash_lookup_or_cons ($$); }
1621: | declmods typespec
1622: { $$ = hash_tree_chain ($2, $$); }
1623: | typespec reserved_declspecs %prec HYPERUNARY
1624: { $$ = hash_tree_chain ($$, $2); }
1625: | declmods typespec reserved_declspecs
1626: { $$ = hash_tree_chain ($2, hash_chainon ($3, $$)); }
1627: ;
1628:
1629: reserved_declspecs: /* empty
1630: { $$ = NULL_TREE; } */
1631: typespecqual_reserved
1632: { $$ = build_decl_list (NULL_TREE, $$); }
1633: | SCSPEC
1634: { $$ = build_decl_list (NULL_TREE, $$); }
1635: | reserved_declspecs typespecqual_reserved
1636: { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
1637: | reserved_declspecs SCSPEC
1638: { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
1639: ;
1640:
1641: /* List of just storage classes and type modifiers.
1642: A declaration can start with just this, but then it cannot be used
1643: to redeclare a typedef-name. */
1644:
1645: declmods:
1646: TYPE_QUAL
1647: { $$ = IDENTIFIER_AS_LIST ($$); }
1648: | SCSPEC
1649: { $$ = IDENTIFIER_AS_LIST ($$); }
1650: | declmods TYPE_QUAL
1651: { $$ = hash_tree_chain ($2, $$); }
1652: | declmods SCSPEC
1653: { $$ = hash_tree_chain ($2, $$); }
1654: ;
1655:
1656:
1657: /* Used instead of declspecs where storage classes are not allowed
1658: (that is, for typenames and structure components).
1659:
1660: C++ can takes storage classes for structure components.
1661: Don't accept a typedef-name if anything but a modifier precedes it. */
1662:
1663: typed_typespecs:
1664: typespec %prec EMPTY
1665: { $$ = get_decl_list ($$); }
1666: | nonempty_type_quals typespec
1667: { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
1668: | typespec reserved_typespecquals
1669: { $$ = decl_tree_cons (NULL_TREE, $$, $2); }
1670: | nonempty_type_quals typespec reserved_typespecquals
1671: { $$ = decl_tree_cons (NULL_TREE, $2, hash_chainon ($3, $$)); }
1672: ;
1673:
1674: reserved_typespecquals:
1675: typespecqual_reserved
1676: { $$ = get_decl_list ($$); }
1677: | reserved_typespecquals typespecqual_reserved
1678: { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
1679: ;
1680:
1681: /* A typespec (but not a type qualifier).
1682: Once we have seen one of these in a declaration,
1683: if a typedef name appears then it is being redeclared. */
1684:
1685: typespec: structsp
1686: | TYPESPEC %prec EMPTY
1687: | TYPENAME %prec EMPTY
1688: | scoped_typename
1689: | TYPEOF '(' expr ')'
1690: { $$ = TREE_TYPE ($3);
1691: if (pedantic)
1692: warning ("ANSI C forbids `typeof'"); }
1693: | TYPEOF '(' typename ')'
1694: { $$ = groktypename ($3);
1695: if (pedantic)
1696: warning ("ANSI C forbids `typeof'"); }
1697: | template_type
1698: ;
1699:
1700: /* A typespec that is a reserved word, or a type qualifier. */
1701:
1702: typespecqual_reserved: TYPESPEC
1703: | TYPE_QUAL
1704: | structsp
1705: ;
1706:
1707: initdecls:
1708: initdcl0
1709: | initdecls ',' initdcl
1710: ;
1711:
1712: notype_initdecls:
1713: notype_initdcl0
1714: | notype_initdecls ',' initdcl
1715: ;
1716:
1717: maybeasm:
1718: /* empty */
1719: { $$ = NULL_TREE; }
1720: | ASM '(' string ')'
1721: { if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
1722: $$ = $3;
1723: if (pedantic)
1724: warning ("ANSI C forbids use of `asm' keyword");
1725: }
1726: ;
1727:
1728: initdcl0:
1729: declarator maybe_raises maybeasm maybe_attribute '='
1730: { current_declspecs = $<ttype>0;
1731: $<itype>5 = suspend_momentary ();
1732: $<ttype>$ = start_decl ($1, current_declspecs, 1, $2); }
1733: init
1734: /* Note how the declaration of the variable is in effect while its init is parsed! */
1735: { finish_decl ($<ttype>6, $7, $3);
1736: $$ = $<itype>5; }
1737: | declarator maybe_raises maybeasm maybe_attribute
1738: { tree d;
1739: current_declspecs = $<ttype>0;
1740: $$ = suspend_momentary ();
1741: d = start_decl ($1, current_declspecs, 0, $2);
1742: finish_decl (d, NULL_TREE, $3); }
1743: ;
1744:
1745: initdcl:
1746: declarator maybe_raises maybeasm maybe_attribute '='
1747: { $<ttype>$ = start_decl ($1, current_declspecs, 1, $2); }
1748: init
1749: /* Note how the declaration of the variable is in effect while its init is parsed! */
1750: { finish_decl ($<ttype>6, $7, $3); }
1751: | declarator maybe_raises maybeasm maybe_attribute
1752: { tree d = start_decl ($$, current_declspecs, 0, $2);
1753: finish_decl (d, NULL_TREE, $3); }
1754: ;
1755:
1756: notype_initdcl0:
1757: notype_declarator maybe_raises maybeasm maybe_attribute '='
1758: { current_declspecs = $<ttype>0;
1759: $<itype>5 = suspend_momentary ();
1760: $<ttype>$ = start_decl ($1, current_declspecs, 1, $2); }
1761: init
1762: /* Note how the declaration of the variable is in effect while its init is parsed! */
1763: { finish_decl ($<ttype>6, $7, $3);
1764: $$ = $<itype>5; }
1765: | notype_declarator maybe_raises maybeasm maybe_attribute
1766: { tree d;
1767: current_declspecs = $<ttype>0;
1768: $$ = suspend_momentary ();
1769: d = start_decl ($1, current_declspecs, 0, $2);
1770: finish_decl (d, NULL_TREE, $3); }
1771: ;
1772:
1773: /* the * rules are dummies to accept the Apollo extended syntax
1774: so that the header files compile. */
1775: maybe_attribute:
1776: /* empty */
1777: { $$ = NULL_TREE; }
1778: | ATTRIBUTE '(' '(' attribute_list ')' ')'
1779: { $$ = $4; }
1780: ;
1781:
1782: attribute_list
1783: : attrib
1784: | attribute_list ',' attrib
1785: ;
1786:
1787: attrib
1788: : IDENTIFIER
1789: { warning ("`%s' attribute directive ignored",
1790: IDENTIFIER_POINTER ($$)); }
1791: | IDENTIFIER '(' CONSTANT ')'
1792: { /* if not "aligned(1)", then issue warning */
1793: if (strcmp (IDENTIFIER_POINTER ($$), "aligned") != 0
1794: || TREE_CODE ($3) != INTEGER_CST
1795: || TREE_INT_CST_LOW ($3) != 1)
1796: warning ("`%s' attribute directive ignored",
1797: IDENTIFIER_POINTER ($$)); }
1798: | IDENTIFIER '(' identifiers ')'
1799: { warning ("`%s' attribute directive ignored",
1800: IDENTIFIER_POINTER ($$)); }
1801: ;
1802:
1803: identifiers:
1804: IDENTIFIER
1805: { }
1806: | identifiers ',' IDENTIFIER
1807: { }
1808: ;
1809:
1810: init:
1811: expr_no_commas %prec '='
1812: | '{' '}'
1813: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
1814: TREE_HAS_CONSTRUCTOR ($$) = 1;
1815: if (pedantic)
1816: warning ("ANSI C forbids empty initializer braces"); }
1817: | '{' initlist '}'
1818: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2));
1819: TREE_HAS_CONSTRUCTOR ($$) = 1; }
1820: | '{' initlist ',' '}'
1821: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2));
1822: TREE_HAS_CONSTRUCTOR ($$) = 1; }
1823: | error
1824: { $$ = NULL_TREE; }
1825: ;
1826:
1827: /* This chain is built in reverse order,
1828: and put in forward order where initlist is used. */
1829: initlist:
1830: init
1831: { $$ = build_tree_list (NULL_TREE, $$); }
1832: | initlist ',' init
1833: { $$ = tree_cons (NULL_TREE, $3, $$); }
1834: /* These are for labeled elements. */
1835: | '[' expr_no_commas ']' init
1836: { $$ = build_tree_list ($2, $4); }
1837: | initlist ',' CASE expr_no_commas ':' init
1838: { $$ = tree_cons ($4, $6, $$); }
1839: | identifier ':' init
1840: { $$ = build_tree_list ($$, $3); }
1841: | initlist ',' identifier ':' init
1842: { $$ = tree_cons ($3, $5, $$); }
1843: ;
1844:
1845: structsp:
1846: ENUM identifier '{'
1847: { $<itype>3 = suspend_momentary ();
1848: $$ = start_enum ($2); }
1849: enumlist maybecomma_warn '}'
1850: { $$ = finish_enum ($<ttype>4, $5);
1851: resume_momentary ($<itype>3);
1852: check_for_missing_semicolon ($<ttype>4); }
1853: | ENUM identifier '{' '}'
1854: { $$ = finish_enum (start_enum ($2), NULL_TREE);
1855: check_for_missing_semicolon ($$); }
1856: | ENUM '{'
1857: { $<itype>2 = suspend_momentary ();
1858: $$ = start_enum (make_anon_name ()); }
1859: enumlist maybecomma_warn '}'
1860: { $$ = finish_enum ($<ttype>3, $4);
1861: resume_momentary ($<itype>1);
1862: check_for_missing_semicolon ($<ttype>3); }
1863: | ENUM '{' '}'
1864: { $$ = finish_enum (start_enum (make_anon_name()), NULL_TREE);
1865: check_for_missing_semicolon ($$); }
1866: | ENUM identifier
1867: { $$ = xref_tag (enum_type_node, $2, NULL_TREE); }
1868:
1869: /* C++ extensions, merged with C to avoid shift/reduce conflicts */
1870: | class_head LC opt.component_decl_list '}'
1871: {
1872: int semi;
1873: #if 0
1874: /* Need to rework class nesting in the
1875: presence of nested classes, etc. */
1876: shadow_tag (CLASSTYPE_AS_LIST ($$)); */
1877: #endif
1878: semi = yychar == ';';
1879: if (semi)
1880: note_got_semicolon ($$);
1881: if (TREE_CODE ($$) == ENUMERAL_TYPE)
1882: /* $$ = $1 from default rule. */;
1883: else if (CLASSTYPE_DECLARED_EXCEPTION ($$))
1884: {
1885: if (! semi)
1886: $$ = finish_exception ($$, $3);
1887: else
1888: warning ("empty exception declaration\n");
1889: }
1890: else
1891: $$ = finish_struct ($$, $3, semi, semi);
1892:
1893: pop_obstacks ();
1894: if (! semi)
1895: check_for_missing_semicolon ($$); }
1896: | class_head %prec EMPTY
1897: {
1898: #if 0
1899: /* It's no longer clear what the following error is supposed to
1900: accomplish. If it turns out to be needed, add a comment why. */
1901: if (TYPE_BINFO_BASETYPES ($$) && !TYPE_SIZE ($$))
1902: {
1903: error ("incomplete definition of type `%s'",
1904: TYPE_NAME_STRING ($$));
1905: $$ = error_mark_node;
1906: }
1907: #endif
1908: }
1909: ;
1910:
1911: maybecomma:
1912: /* empty */
1913: | ','
1914: ;
1915:
1916: maybecomma_warn:
1917: /* empty */
1918: | ','
1919: { if (pedantic) warning ("comma at end of enumerator list"); }
1920: ;
1921:
1922: aggr: AGGR
1923: | DYNAMIC AGGR
1924: { $$ = build_tree_list (NULL_TREE, $2); }
1925: | DYNAMIC '(' string ')' AGGR
1926: { $$ = build_tree_list ($3, $5); }
1927: | aggr SCSPEC
1928: { error ("storage class specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2));
1929: }
1930: | aggr TYPESPEC
1931: { error ("type specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2));
1932: }
1933: | aggr TYPE_QUAL
1934: { error ("type qualifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2));
1935: }
1936: | aggr AGGR
1937: { error ("no body nor ';' separates two class, struct or union declarations");
1938: }
1939: ;
1940:
1941: named_class_head_sans_basetype:
1942: aggr identifier
1943: { aggr1: current_aggr = $$; $$ = $2; }
1944: | aggr template_type_name %prec EMPTY
1945: { current_aggr = $$; $$ = $2; }
1946: | aggr TYPENAME_COLON
1947: { yyungetc (':', 1); goto aggr1; }
1948: | aggr template_type_name '{'
1949: { yyungetc ('{', 1);
1950: aggr2:
1951: current_aggr = $$;
1952: $$ = $2; }
1953: | aggr template_type_name ':'
1954: { yyungetc (':', 1); goto aggr2; }
1955: ;
1956:
1957: named_class_head_sans_basetype_defn:
1958: aggr identifier_defn
1959: { current_aggr = $$; $$ = $2; }
1960: ;
1961:
1962: named_class_head:
1963: named_class_head_sans_basetype
1964: {
1965: $<ttype>$ = xref_tag (current_aggr, $1, NULL_TREE);
1966: }
1967: maybe_base_class_list %prec EMPTY
1968: {
1969: if ($3)
1970: $$ = xref_tag (current_aggr, $1, $3);
1971: else
1972: $$ = $<ttype>2;
1973: }
1974: |
1975: named_class_head_sans_basetype_defn
1976: {
1977: $<ttype>$ = xref_defn_tag (current_aggr, $1, NULL_TREE);
1978: }
1979: maybe_base_class_list %prec EMPTY
1980: {
1981: if ($3)
1982: $$ = xref_defn_tag (current_aggr, $1, $3);
1983: else
1984: $$ = $<ttype>2;
1985: }
1986: ;
1987:
1988: unnamed_class_head: aggr '{'
1989: { $$ = xref_tag ($$, make_anon_name (), NULL_TREE);
1990: yyungetc ('{', 1); }
1991: ;
1992:
1993: class_head: unnamed_class_head | named_class_head ;
1994:
1995: maybe_base_class_list:
1996: /* empty */
1997: { $$ = NULL_TREE; }
1998: | ':' %prec EMPTY
1999: { yyungetc(':', 1); $$ = NULL_TREE; }
2000: | ':' base_class_list %prec EMPTY
2001: { $$ = $2; }
2002: ;
2003:
2004: base_class_list:
2005: base_class
2006: | base_class_list ',' base_class
2007: { $$ = chainon ($$, $3); }
2008: ;
2009:
2010: base_class:
2011: base_class.1
2012: { if (! is_aggr_typedef ($$, 1))
2013: $$ = NULL_TREE;
2014: else $$ = build_tree_list ((tree)visibility_default, $$); }
2015: | base_class_visibility_list base_class.1
2016: { if (! is_aggr_typedef ($2, 1))
2017: $$ = NULL_TREE;
2018: else $$ = build_tree_list ((tree) $$, $2); }
2019: ;
2020:
2021: base_class.1:
2022: template_type_name tmpl.2 template_instantiation
2023: | identifier
2024: ;
2025:
2026: base_class_visibility_list:
2027: VISSPEC
2028: {
2029: if ($$ == visibility_protected)
2030: {
2031: warning ("`protected' visibility not implemented");
2032: $$ = visibility_public;
2033: }
2034: }
2035: | SCSPEC
2036: { if ($<ttype>$ != ridpointers[(int)RID_VIRTUAL])
2037: sorry ("non-virtual visibility");
2038: $$ = visibility_default_virtual; }
2039: | base_class_visibility_list VISSPEC
2040: { int err = 0;
2041: if ($2 == visibility_protected)
2042: {
2043: warning ("`protected' visibility not implemented");
2044: $2 = visibility_public;
2045: err++;
2046: }
2047: else if ($2 == visibility_public)
2048: {
2049: if ($1 == visibility_private)
2050: {
2051: mixed:
2052: error ("base class cannot be public and private");
2053: }
2054: else if ($1 == visibility_default_virtual)
2055: $$ = visibility_public_virtual;
2056: }
2057: else /* $2 == visibility_priavte */
2058: {
2059: if ($1 == visibility_public)
2060: goto mixed;
2061: else if ($1 == visibility_default_virtual)
2062: $$ = visibility_private_virtual;
2063: }
2064: }
2065: | base_class_visibility_list SCSPEC
2066: { if ($2 != ridpointers[(int)RID_VIRTUAL])
2067: sorry ("non-virtual visibility");
2068: if ($$ == visibility_public)
2069: $$ = visibility_public_virtual;
2070: else if ($$ == visibility_private)
2071: $$ = visibility_private_virtual; }
2072: ;
2073:
2074: LC: '{'
2075: { tree t;
2076: push_obstacks_nochange ();
2077: end_temporary_allocation ();
2078:
2079: if (! IS_AGGR_TYPE ($<ttype>0))
2080: {
2081: $<ttype>0 = make_lang_type (RECORD_TYPE);
2082: TYPE_NAME ($<ttype>0) = get_identifier ("erroneous type");
2083: }
2084: if (TYPE_SIZE ($<ttype>0))
2085: duplicate_tag_error ($<ttype>0);
2086: if (TYPE_SIZE ($<ttype>0) || TYPE_BEING_DEFINED ($<ttype>0))
2087: {
2088: t = make_lang_type (TREE_CODE ($<ttype>0));
2089: pushtag (DECL_NAME (TYPE_NAME ($<ttype>0)), t);
2090: $<ttype>0 = t;
2091: }
2092: pushclass ($<ttype>0, 0);
2093: TYPE_BEING_DEFINED ($<ttype>0) = 1;
2094: t = DECL_NAME (TYPE_NAME ($<ttype>0));
2095: if (IDENTIFIER_TEMPLATE (t))
2096: overload_template_name (t, 1);
2097: }
2098: ;
2099:
2100: opt.component_decl_list:
2101: /* empty */
2102: { $$ = NULL_TREE; }
2103: | component_decl_list
2104: { $$ = build_tree_list ((tree)visibility_default, $$); }
2105: | opt.component_decl_list VISSPEC ':' component_decl_list
2106: { $$ = chainon ($$, build_tree_list ((tree) $2, $4)); }
2107: | opt.component_decl_list VISSPEC ':'
2108: ;
2109:
2110: component_decl_list:
2111: component_decl
2112: { if ($$ == void_type_node) $$ = NULL_TREE; }
2113: | component_decl_list component_decl
2114: { if ($2 != NULL_TREE && $2 != void_type_node)
2115: $$ = chainon ($$, $2); }
2116: | component_decl_list ';'
2117: { if (pedantic)
2118: warning ("extra semicolon in struct or union specified"); }
2119: ;
2120:
2121: component_decl:
2122: typed_declspecs components ';'
2123: {
2124: do_components:
2125: if ($2 == void_type_node)
2126: /* We just got some friends.
2127: They have been recorded elsewhere. */
2128: $$ = NULL_TREE;
2129: else if ($2 == NULL_TREE)
2130: {
2131: tree t = groktypename (build_decl_list ($$, NULL_TREE));
2132: if (t == NULL_TREE)
2133: {
2134: error ("error in component specification");
2135: $$ = NULL_TREE;
2136: }
2137: else if (TREE_CODE (t) == UNION_TYPE)
2138: {
2139: /* handle anonymous unions */
2140: if (CLASSTYPE_METHOD_VEC (t))
2141: sorry ("methods in anonymous unions");
2142: $$ = build_lang_field_decl (FIELD_DECL, NULL_TREE, t);
2143: }
2144: else if (TREE_CODE (t) == ENUMERAL_TYPE)
2145: $$ = grok_enum_decls (t, NULL_TREE);
2146: else if (TREE_CODE (t) == RECORD_TYPE)
2147: {
2148: if (TYPE_LANG_SPECIFIC (t)
2149: && CLASSTYPE_DECLARED_EXCEPTION (t))
2150: shadow_tag ($$);
2151: $$ = NULL_TREE;
2152: }
2153: else if (t != void_type_node)
2154: {
2155: error ("empty component declaration");
2156: $$ = NULL_TREE;
2157: }
2158: else $$ = NULL_TREE;
2159: }
2160: else
2161: {
2162: tree t = TREE_TYPE ($2);
2163: if (TREE_CODE (t) == ENUMERAL_TYPE && TREE_NONLOCAL_FLAG (t))
2164: $$ = grok_enum_decls (t, $2);
2165: else
2166: $$ = $2;
2167: }
2168: end_exception_decls ();
2169: }
2170: | typed_declspecs '(' parmlist ')' ';'
2171: { $$ = groktypefield ($$, $3); }
2172: | typed_declspecs '(' parmlist ')' '}'
2173: { error ("missing ';' before right brace");
2174: yyungetc ('}', 0);
2175: $$ = groktypefield ($$, $3); }
2176: | typed_declspecs LEFT_RIGHT ';'
2177: { $$ = groktypefield ($$, empty_parms ()); }
2178: | typed_declspecs LEFT_RIGHT '}'
2179: { error ("missing ';' before right brace");
2180: yyungetc ('}', 0);
2181: $$ = groktypefield ($$, empty_parms ()); }
2182: | declmods components ';'
2183: { goto do_components; }
2184: /* Normal case: make this fast. */
2185: | declmods declarator ';'
2186: { $$ = grokfield ($2, $$, 0, 0, 0, 0); }
2187: | declmods components '}'
2188: { error ("missing ';' before right brace");
2189: yyungetc ('}', 0);
2190: goto do_components; }
2191: | declmods '(' parmlist ')' ';'
2192: { $$ = groktypefield ($$, $3); }
2193: | declmods '(' parmlist ')' '}'
2194: { error ("missing ';' before right brace");
2195: yyungetc ('}', 0);
2196: $$ = groktypefield ($$, $3); }
2197: | declmods LEFT_RIGHT ';'
2198: { $$ = groktypefield ($$, empty_parms ()); }
2199: | declmods LEFT_RIGHT '}'
2200: { error ("missing ';' before right brace");
2201: yyungetc ('}', 0);
2202: $$ = groktypefield ($$, empty_parms ()); }
2203: | ':' expr_no_commas ';'
2204: { $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); }
2205: | ':' expr_no_commas '}'
2206: { error ("missing ';' before right brace");
2207: yyungetc ('}', 0);
2208: $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); }
2209: | error
2210: { $$ = NULL_TREE; }
2211:
2212: /* C++: handle constructors, destructors and inline functions */
2213: /* note that INLINE is like a TYPESPEC */
2214: | fn.def2 ':' /* base_init compstmt */
2215: { $$ = finish_method ($$); }
2216: | fn.def2 '{' /* nodecls compstmt */
2217: { $$ = finish_method ($$); }
2218: | notype_declarator maybe_raises ';'
2219: { $$ = grokfield ($$, NULL_TREE, $2, NULL_TREE, NULL_TREE); }
2220: | notype_declarator maybe_raises '}'
2221: { error ("missing ';' before right brace");
2222: yyungetc ('}', 0);
2223: $$ = grokfield ($$, NULL_TREE, $2, NULL_TREE, NULL_TREE); }
2224: ;
2225:
2226: components:
2227: /* empty: possibly anonymous */
2228: { $$ = NULL_TREE; }
2229: | component_declarator0
2230: | components ',' component_declarator
2231: {
2232: /* In this context, void_type_node encodes
2233: friends. They have been recorded elsewhere. */
2234: if ($$ == void_type_node)
2235: $$ = $3;
2236: else
2237: $$ = chainon ($$, $3);
2238: }
2239: ;
2240:
2241: component_declarator0:
2242: declarator maybe_raises maybeasm
2243: { current_declspecs = $<ttype>0;
2244: $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3); }
2245: | declarator maybe_raises maybeasm '=' init
2246: { current_declspecs = $<ttype>0;
2247: $$ = grokfield ($$, current_declspecs, $2, $5, $3); }
2248: | IDENTIFIER ':' expr_no_commas
2249: { current_declspecs = $<ttype>0;
2250: $$ = grokbitfield ($$, current_declspecs, $3); }
2251: | TYPENAME_COLON expr_no_commas
2252: { current_declspecs = $<ttype>0;
2253: $$ = grokbitfield ($$, current_declspecs, $2); }
2254: | ':' expr_no_commas
2255: { current_declspecs = $<ttype>0;
2256: $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); }
2257: ;
2258:
2259: component_declarator:
2260: declarator maybe_raises maybeasm
2261: { $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3); }
2262: | declarator maybe_raises maybeasm '=' init
2263: { $$ = grokfield ($$, current_declspecs, $2, $5, $3); }
2264: | IDENTIFIER ':' expr_no_commas
2265: { $$ = grokbitfield ($$, current_declspecs, $3); }
2266: | TYPENAME_COLON expr_no_commas
2267: { $$ = grokbitfield ($$, current_declspecs, $2); }
2268: | ':' expr_no_commas
2269: { $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); }
2270: ;
2271:
2272: /* We chain the enumerators in reverse order.
2273: Because of the way enums are built, the order is
2274: insignificant. Take advantage of this fact. */
2275:
2276: enumlist:
2277: enumerator
2278: | enumlist ',' enumerator
2279: { TREE_CHAIN ($3) = $$; $$ = $3; }
2280: ;
2281:
2282: enumerator:
2283: identifier
2284: { $$ = build_enumerator ($$, NULL_TREE); }
2285: | identifier '=' expr_no_commas
2286: { $$ = build_enumerator ($$, $3); }
2287: ;
2288:
2289: typename:
2290: typed_typespecs absdcl
2291: { $$ = build_decl_list ($$, $2); }
2292: | nonempty_type_quals absdcl
2293: { $$ = build_decl_list ($$, $2); }
2294: ;
2295:
2296: absdcl: /* an abstract declarator */
2297: /* empty */ %prec EMPTY
2298: { $$ = NULL_TREE; }
2299: | absdcl1 %prec EMPTY
2300: | START_DECLARATOR absdcl1 %prec EMPTY
2301: { $$ = $2; }
2302: ;
2303:
2304: nonempty_type_quals:
2305: TYPE_QUAL
2306: { $$ = IDENTIFIER_AS_LIST ($$); }
2307: | nonempty_type_quals TYPE_QUAL
2308: { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
2309: ;
2310:
2311: type_quals:
2312: /* empty */
2313: { $$ = NULL_TREE; }
2314: | type_quals TYPE_QUAL
2315: { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
2316: ;
2317:
2318: /* These rules must follow the rules for function declarations
2319: and component declarations. That way, longer rules are prefered. */
2320:
2321: /* An expression which will not live on the momentary obstack. */
2322: nonmomentary_expr:
2323: { $<itype>$ = suspend_momentary (); } expr
2324: { resume_momentary ($<itype>1); $$ = $2; }
2325:
2326: /* A declarator that is allowed only after an explicit typespec. */
2327: /* may all be followed by prec '.' */
2328: after_type_declarator:
2329: after_type_declarator '(' nonnull_exprlist ')' type_quals %prec '.'
2330: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
2331: | after_type_declarator '(' parmlist ')' type_quals %prec '.'
2332: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
2333: | after_type_declarator LEFT_RIGHT type_quals %prec '.'
2334: { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
2335: | after_type_declarator '(' error ')' type_quals %prec '.'
2336: { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); }
2337: | after_type_declarator '[' nonmomentary_expr ']'
2338: { $$ = build_parse_node (ARRAY_REF, $$, $3); }
2339: | after_type_declarator '[' ']'
2340: { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
2341: | '(' after_type_declarator_no_typename ')'
2342: { $$ = $2; }
2343: | '(' '*' type_quals after_type_declarator ')'
2344: { $$ = make_pointer_declarator ($3, $4); }
2345: | PAREN_STAR_PAREN
2346: { see_typename (); }
2347: | after_type_member_declarator
2348: | '(' '&' type_quals after_type_declarator ')'
2349: { $$ = make_reference_declarator ($3, $4); }
2350: | '*' type_quals after_type_declarator %prec UNARY
2351: { $$ = make_pointer_declarator ($2, $3); }
2352: | '&' type_quals after_type_declarator %prec UNARY
2353: { $$ = make_reference_declarator ($2, $3); }
2354: | TYPENAME
2355: ;
2356:
2357: after_type_declarator_no_typename:
2358: after_type_declarator_no_typename '(' nonnull_exprlist ')' type_quals %prec '.'
2359: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
2360: | after_type_declarator_no_typename '(' parmlist ')' type_quals %prec '.'
2361: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
2362: | after_type_declarator_no_typename LEFT_RIGHT type_quals %prec '.'
2363: { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
2364: | after_type_declarator_no_typename '(' error ')' type_quals %prec '.'
2365: { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); }
2366: | after_type_declarator_no_typename '[' nonmomentary_expr ']'
2367: { $$ = build_parse_node (ARRAY_REF, $$, $3); }
2368: | after_type_declarator_no_typename '[' ']'
2369: { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
2370: | '(' after_type_declarator_no_typename ')'
2371: { $$ = $2; }
2372: | PAREN_STAR_PAREN
2373: { see_typename (); }
2374: | after_type_member_declarator
2375: | '*' type_quals after_type_declarator %prec UNARY
2376: { $$ = make_pointer_declarator ($2, $3); }
2377: | '&' type_quals after_type_declarator %prec UNARY
2378: { $$ = make_reference_declarator ($2, $3); }
2379: ;
2380:
2381: /* A declarator allowed whether or not there has been
2382: an explicit typespec. These cannot redeclare a typedef-name. */
2383:
2384: notype_declarator:
2385: notype_declarator '(' nonnull_exprlist ')' type_quals %prec '.'
2386: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
2387: | notype_declarator '(' parmlist ')' type_quals %prec '.'
2388: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
2389: | notype_declarator LEFT_RIGHT type_quals %prec '.'
2390: { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
2391: | notype_declarator '(' error ')' type_quals %prec '.'
2392: { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); }
2393: | '(' notype_declarator ')'
2394: { $$ = $2; }
2395: | '*' type_quals notype_declarator %prec UNARY
2396: { $$ = make_pointer_declarator ($2, $3); }
2397: | '&' type_quals notype_declarator %prec UNARY
2398: { $$ = make_reference_declarator ($2, $3); }
2399: | notype_declarator '[' nonmomentary_expr ']'
2400: { $$ = build_parse_node (ARRAY_REF, $$, $3); }
2401: | notype_declarator '[' ']'
2402: { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
2403: | IDENTIFIER
2404: { see_typename (); }
2405:
2406: /* C++ extensions. */
2407: | operator_name
2408: { see_typename (); }
2409:
2410: | '~' TYPENAME
2411: {
2412: destructor_name:
2413: see_typename ();
2414: $$ = build_parse_node (BIT_NOT_EXPR, $2);
2415: }
2416: | '~' IDENTIFIER
2417: { goto destructor_name; }
2418: | '~' PTYPENAME
2419: { goto destructor_name; }
2420: | LEFT_RIGHT identifier
2421: {
2422: see_typename ();
2423: $$ = build_parse_node (WRAPPER_EXPR, $2);
2424: }
2425: | LEFT_RIGHT '?' identifier
2426: {
2427: see_typename ();
2428: $$ = build_parse_node (WRAPPER_EXPR,
2429: build_parse_node (COND_EXPR, $3, NULL_TREE, NULL_TREE));
2430: }
2431: | '~' LEFT_RIGHT identifier
2432: { see_typename ();
2433: $$ = build_parse_node (ANTI_WRAPPER_EXPR, $3); }
2434: | scoped_id see_typename notype_declarator %prec '('
2435: { see_typename ();
2436: if (TREE_CODE ($$) != SCOPE_REF)
2437: $$ = build_push_scope ($$, $3);
2438: else if (TREE_OPERAND ($$, 1) == NULL_TREE)
2439: TREE_OPERAND ($$, 1) = $3;
2440: else
2441: $$ = build_parse_node (SCOPE_REF, $$, $3);
2442: }
2443: | scoped_id see_typename TYPENAME %prec '('
2444: { $$ = build_push_scope ($$, $3); }
2445: | scoped_id see_typename TYPENAME '(' nonnull_exprlist ')' type_quals %prec '.'
2446: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); }
2447: | scoped_id see_typename TYPENAME '(' parmlist ')' type_quals %prec '.'
2448: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); }
2449: | scoped_id see_typename TYPENAME LEFT_RIGHT type_quals %prec '.'
2450: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, empty_parms (), $5)); }
2451: | scoped_id see_typename TYPENAME '(' error ')' type_quals %prec '.'
2452: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, NULL_TREE, NULL_TREE)); }
2453: /* For constructor templates. */
2454: | scoped_id see_typename PTYPENAME %prec '('
2455: { $$ = build_push_scope ($$, $3); }
2456: | scoped_id see_typename PTYPENAME '(' nonnull_exprlist ')' type_quals %prec '.'
2457: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); }
2458: | scoped_id see_typename PTYPENAME '(' parmlist ')' type_quals %prec '.'
2459: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); }
2460: | scoped_id see_typename PTYPENAME LEFT_RIGHT type_quals %prec '.'
2461: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, empty_parms (), $5)); }
2462: | scoped_id see_typename PTYPENAME '(' error ')' type_quals %prec '.'
2463: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, NULL_TREE, NULL_TREE)); }
2464: | SCOPE see_typename notype_declarator
2465: { $$ = build_parse_node (SCOPE_REF, NULL_TREE, $3); }
2466: ;
2467:
2468: scoped_id: TYPENAME_SCOPE
2469: { $$ = resolve_scope_to_name (NULL_TREE, $$); }
2470: | template_type SCOPE try_for_typename %prec EMPTY
2471: {
2472: if ($$ == error_mark_node)
2473: /* leave it alone */;
2474: else
2475: {
2476: $$ = resolve_scope_to_name (NULL_TREE, TYPE_IDENTIFIER ($$));
2477: }
2478: if ($3) popclass (1);
2479: }
2480: ;
2481:
2482: TYPENAME_SCOPE:
2483: TYPENAME SCOPE;
2484:
2485: scoped_typename: SCOPED_TYPENAME
2486: /* | template_type SCOPE try_for_typename TYPENAME
2487: {
2488: if ($$ == error_mark_node)
2489: ;
2490: else
2491: {
2492: $$ = build_parse_node (SCOPE_REF,
2493: DECL_NAME (TYPE_NAME ($$)),
2494: $4);
2495: }
2496: if ($3) popclass (1);
2497: } */
2498: ;
2499:
2500: absdcl1: /* a nonempty abstract declarator */
2501: '(' absdcl1 ')'
2502: { see_typename ();
2503: $$ = $2; }
2504: /* `(typedef)1' is `int'. */
2505: | '*' type_quals absdcl1 %prec EMPTY
2506: { $$ = make_pointer_declarator ($2, $3); }
2507: | '*' type_quals %prec EMPTY
2508: { $$ = make_pointer_declarator ($2, NULL_TREE); }
2509: | PAREN_STAR_PAREN
2510: { see_typename (); }
2511: | '(' abs_member_declarator ')'
2512: { $$ = $2; }
2513: | '&' type_quals absdcl1 %prec EMPTY
2514: { $$ = make_reference_declarator ($2, $3); }
2515: | '&' type_quals %prec EMPTY
2516: { $$ = make_reference_declarator ($2, NULL_TREE); }
2517: | absdcl1 '(' parmlist ')' type_quals %prec '.'
2518: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
2519: | absdcl1 LEFT_RIGHT type_quals %prec '.'
2520: { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
2521: | absdcl1 '[' nonmomentary_expr ']' %prec '.'
2522: { $$ = build_parse_node (ARRAY_REF, $$, $3); }
2523: | absdcl1 '[' ']' %prec '.'
2524: { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
2525: | '(' parmlist ')' type_quals %prec '.'
2526: { $$ = build_parse_node (CALL_EXPR, NULL_TREE, $2, $4); }
2527: | LEFT_RIGHT type_quals %prec '.'
2528: { $$ = build_parse_node (CALL_EXPR, NULL_TREE, empty_parms (), $2); }
2529: | '[' nonmomentary_expr ']' %prec '.'
2530: { $$ = build_parse_node (ARRAY_REF, NULL_TREE, $2); }
2531: | '[' ']' %prec '.'
2532: { $$ = build_parse_node (ARRAY_REF, NULL_TREE, NULL_TREE); }
2533: ;
2534:
2535: abs_member_declarator:
2536: scoped_id '*' type_quals
2537: { tree t;
2538: t = $$;
2539: while (TREE_OPERAND (t, 1))
2540: t = TREE_OPERAND (t, 1);
2541: TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, 0);
2542: }
2543: | scoped_id '*' type_quals absdcl1
2544: { tree t;
2545: t = $$;
2546: while (TREE_OPERAND (t, 1))
2547: t = TREE_OPERAND (t, 1);
2548: TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, $4);
2549: }
2550: | scoped_id '&' type_quals
2551: { tree t;
2552: t = $$;
2553: while (TREE_OPERAND (t, 1))
2554: t = TREE_OPERAND (t, 1);
2555: TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, 0);
2556: }
2557: | scoped_id '&' type_quals absdcl1
2558: { tree t;
2559: t = $$;
2560: while (TREE_OPERAND (t, 1))
2561: t = TREE_OPERAND (t, 1);
2562: TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, $4);
2563: }
2564: ;
2565:
2566: after_type_member_declarator:
2567: scoped_id see_typename '*' type_quals after_type_declarator
2568: { tree t;
2569: t = $$;
2570: while (TREE_OPERAND (t, 1))
2571: t = TREE_OPERAND (t, 1);
2572: TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, $5);
2573: }
2574: | scoped_id see_typename '&' type_quals after_type_declarator
2575: { tree t;
2576: t = $$;
2577: while (TREE_OPERAND (t, 1))
2578: t = TREE_OPERAND (t, 1);
2579: TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, $5);
2580: }
2581: ;
2582:
2583: /* For C++, decls and stmts can be intermixed, so we don't need to
2584: have a special rule that won't start parsing the stmt section
2585: until we have a stmt that parses without errors. */
2586:
2587: stmts:
2588: stmt
2589: | errstmt
2590: | stmts stmt
2591: | stmts errstmt
2592: ;
2593:
2594: errstmt: error ';'
2595: ;
2596:
2597: /* build the LET_STMT node before parsing its contents,
2598: so that any LET_STMTs within the context can have their display pointers
2599: set up to point at this one. */
2600:
2601: .pushlevel: /* empty */
2602: {
2603: pushlevel (0);
2604: clear_last_expr ();
2605: push_momentary ();
2606: expand_start_bindings (0);
2607: stmt_decl_msg = 0;
2608: }
2609: ;
2610:
2611: /* This is the body of a function definition.
2612: It causes syntax errors to ignore to the next openbrace. */
2613: compstmt_or_error:
2614: compstmt
2615: {}
2616: | error compstmt
2617: ;
2618:
2619: compstmt: '{' '}'
2620: { $$ = convert (void_type_node, integer_zero_node); }
2621: | '{' .pushlevel stmts '}'
2622: { pop_implicit_try_blocks (NULL_TREE);
2623: expand_end_bindings (getdecls (), kept_level_p (), 1);
2624: $$ = poplevel (kept_level_p (), 1, 0);
2625: pop_momentary (); }
2626: | '{' .pushlevel error '}'
2627: { pop_implicit_try_blocks (NULL_TREE);
2628: expand_end_bindings (getdecls (), kept_level_p (), 1);
2629: $$ = poplevel (kept_level_p (), 0, 0);
2630: pop_momentary (); }
2631: ;
2632:
2633: simple_if:
2634: IF '(' expr ')'
2635: { emit_line_note (input_filename, lineno);
2636: expand_start_cond (truthvalue_conversion ($3), 0);
2637: stmt_decl_msg = "if"; }
2638: stmt
2639: { stmt_decl_msg = 0; }
2640: ;
2641:
2642: stmt:
2643: compstmt
2644: { finish_stmt (); }
2645: | decl
2646: { if (stmt_decl_msg)
2647: error ("declaration after %s invalid", stmt_decl_msg);
2648: stmt_decl_msg = 0;
2649: finish_stmt (); }
2650: | expr ';'
2651: {
2652: tree expr = $1;
2653: emit_line_note (input_filename, lineno);
2654: /* Do default conversion if safe and possibly important,
2655: in case within ({...}). */
2656: if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
2657: && lvalue_p (expr))
2658: || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
2659: expr = default_conversion (expr);
2660: cplus_expand_expr_stmt (expr);
2661: clear_momentary ();
2662: finish_stmt (); }
2663: | simple_if ELSE
2664: { expand_start_else ();
2665: stmt_decl_msg = "else"; }
2666: stmt
2667: { expand_end_cond ();
2668: stmt_decl_msg = 0;
2669: finish_stmt (); }
2670: | simple_if %prec IF
2671: { expand_end_cond ();
2672: stmt_decl_msg = 0;
2673: finish_stmt (); }
2674: | WHILE
2675: { emit_nop ();
2676: emit_line_note (input_filename, lineno);
2677: expand_start_loop (1); }
2678: '(' expr ')'
2679: { expand_exit_loop_if_false (0, truthvalue_conversion ($4));
2680: stmt_decl_msg = "while"; }
2681: stmt
2682: {
2683: expand_end_loop ();
2684: stmt_decl_msg = 0;
2685: finish_stmt (); }
2686: | DO
2687: { emit_nop ();
2688: emit_line_note (input_filename, lineno);
2689: expand_start_loop_continue_elsewhere (1);
2690: stmt_decl_msg = "do"; }
2691: stmt WHILE
2692: { stmt_decl_msg = 0;
2693: expand_loop_continue_here (); }
2694: '(' expr ')' ';'
2695: { emit_line_note (input_filename, lineno);
2696: expand_exit_loop_if_false (0, truthvalue_conversion ($7));
2697: expand_end_loop ();
2698: clear_momentary ();
2699: finish_stmt (); }
2700: | forhead.1
2701: { emit_nop ();
2702: emit_line_note (input_filename, lineno);
2703: if ($1) cplus_expand_expr_stmt ($1);
2704: expand_start_loop_continue_elsewhere (1); }
2705: xexpr ';'
2706: { emit_line_note (input_filename, lineno);
2707: if ($3) expand_exit_loop_if_false (0, truthvalue_conversion ($3)); }
2708: xexpr ')'
2709: /* Don't let the tree nodes for $6 be discarded
2710: by clear_momentary during the parsing of the next stmt. */
2711: { push_momentary ();
2712: stmt_decl_msg = "for"; }
2713: stmt
2714: { emit_line_note (input_filename, lineno);
2715: expand_loop_continue_here ();
2716: if ($6) cplus_expand_expr_stmt ($6);
2717: pop_momentary ();
2718: expand_end_loop ();
2719: stmt_decl_msg = 0;
2720: finish_stmt (); }
2721: | forhead.2
2722: { emit_nop ();
2723: emit_line_note (input_filename, lineno);
2724: expand_start_loop_continue_elsewhere (1); }
2725: xexpr ';'
2726: { emit_line_note (input_filename, lineno);
2727: if ($3) expand_exit_loop_if_false (0, truthvalue_conversion ($3)); }
2728: xexpr ')'
2729: /* Don't let the tree nodes for $6 be discarded
2730: by clear_momentary during the parsing of the next stmt. */
2731: { push_momentary ();
2732: stmt_decl_msg = "for";
2733: $<itype>7 = lineno; }
2734: stmt
2735: { emit_line_note (input_filename, $<itype>7);
2736: expand_loop_continue_here ();
2737: if ($6) cplus_expand_expr_stmt ($6);
2738: pop_momentary ();
2739: expand_end_loop ();
2740: pop_implicit_try_blocks (NULL_TREE);
2741: if ($1)
2742: {
2743: register keep = $1 > 0;
2744: if (keep) expand_end_bindings (0, keep, 1);
2745: poplevel (keep, 1, 0);
2746: pop_momentary ();
2747: }
2748: stmt_decl_msg = 0;
2749: finish_stmt ();
2750: }
2751: | SWITCH '(' expr ')'
2752: { emit_line_note (input_filename, lineno);
2753: c_expand_start_case ($3);
2754: /* Don't let the tree nodes for $3 be discarded by
2755: clear_momentary during the parsing of the next stmt. */
2756: push_momentary ();
2757: stmt_decl_msg = "switch"; }
2758: stmt
2759: { expand_end_case ($3);
2760: pop_momentary ();
2761: stmt_decl_msg = 0;
2762: finish_stmt (); }
2763: | CASE expr ':'
2764: { register tree value = $2;
2765: register tree label
2766: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2767:
2768: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
2769: Strip such NOP_EXPRs. */
2770: if (TREE_CODE (value) == NOP_EXPR
2771: && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
2772: value = TREE_OPERAND (value, 0);
2773:
2774: if (TREE_READONLY_DECL_P (value))
2775: {
2776: value = decl_constant_value (value);
2777: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
2778: Strip such NOP_EXPRs. */
2779: if (TREE_CODE (value) == NOP_EXPR
2780: && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
2781: value = TREE_OPERAND (value, 0);
2782: }
2783: value = fold (value);
2784:
2785: if (TREE_CODE (value) != INTEGER_CST
2786: && value != error_mark_node)
2787: {
2788: error ("case label does not reduce to an integer constant");
2789: value = error_mark_node;
2790: }
2791: else
2792: /* Promote char or short to int. */
2793: value = default_conversion (value);
2794: if (value != error_mark_node)
2795: {
2796: tree duplicate;
2797: int success = pushcase (value, label, &duplicate);
2798: if (success == 1)
2799: error ("case label not within a switch statement");
2800: else if (success == 2)
2801: {
2802: error ("duplicate case value");
2803: error_with_decl (duplicate, "this is the first entry for that value");
2804: }
2805: else if (success == 3)
2806: warning ("case value out of range");
2807: else if (success == 5)
2808: error ("case label within scope of cleanup or variable array");
2809: }
2810: define_case_label (label);
2811: }
2812: stmt
2813: | CASE expr RANGE expr ':'
2814: { register tree value1 = $2;
2815: register tree value2 = $4;
2816: register tree label
2817: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2818:
2819: if (pedantic)
2820: {
2821: error ("ANSI C does not allow range expressions in switch statement");
2822: value1 = error_mark_node;
2823: value2 = error_mark_node;
2824: break;
2825: }
2826: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
2827: Strip such NOP_EXPRs. */
2828: if (TREE_CODE (value1) == NOP_EXPR
2829: && TREE_TYPE (value1) == TREE_TYPE (TREE_OPERAND (value1, 0)))
2830: value1 = TREE_OPERAND (value1, 0);
2831:
2832: if (TREE_READONLY_DECL_P (value1))
2833: {
2834: value1 = decl_constant_value (value1);
2835: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
2836: Strip such NOP_EXPRs. */
2837: if (TREE_CODE (value1) == NOP_EXPR
2838: && TREE_TYPE (value1) == TREE_TYPE (TREE_OPERAND (value1, 0)))
2839: value1 = TREE_OPERAND (value1, 0);
2840: }
2841: value1 = fold (value1);
2842:
2843: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
2844: Strip such NOP_EXPRs. */
2845: if (TREE_CODE (value2) == NOP_EXPR
2846: && TREE_TYPE (value2) == TREE_TYPE (TREE_OPERAND (value2, 0)))
2847: value2 = TREE_OPERAND (value2, 0);
2848:
2849: if (TREE_READONLY_DECL_P (value2))
2850: {
2851: value2 = decl_constant_value (value2);
2852: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
2853: Strip such NOP_EXPRs. */
2854: if (TREE_CODE (value2) == NOP_EXPR
2855: && TREE_TYPE (value2) == TREE_TYPE (TREE_OPERAND (value2, 0)))
2856: value2 = TREE_OPERAND (value2, 0);
2857: }
2858: value2 = fold (value2);
2859:
2860:
2861: if (TREE_CODE (value1) != INTEGER_CST
2862: && value1 != error_mark_node)
2863: {
2864: error ("case label does not reduce to an integer constant");
2865: value1 = error_mark_node;
2866: }
2867: if (TREE_CODE (value2) != INTEGER_CST
2868: && value2 != error_mark_node)
2869: {
2870: error ("case label does not reduce to an integer constant");
2871: value2 = error_mark_node;
2872: }
2873: if (value1 != error_mark_node
2874: && value2 != error_mark_node)
2875: {
2876: tree duplicate;
2877: int success = pushcase_range (value1, value2, label,
2878: &duplicate);
2879: if (success == 1)
2880: error ("case label not within a switch statement");
2881: else if (success == 2)
2882: {
2883: error ("duplicate (or overlapping) case value");
2884: error_with_decl (duplicate, "this is the first entry overlapping that value");
2885: }
2886: else if (success == 3)
2887: warning ("case value out of range");
2888: else if (success == 4)
2889: warning ("empty range specified");
2890: else if (success == 5)
2891: error ("case label within scope of cleanup or variable array");
2892: }
2893: define_case_label (label);
2894: }
2895: stmt
2896: | DEFAULT ':'
2897: {
2898: tree duplicate;
2899: register tree label
2900: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2901: int success = pushcase (NULL_TREE, label, &duplicate);
2902: if (success == 1)
2903: error ("default label not within a switch statement");
2904: else if (success == 2)
2905: {
2906: error ("multiple default labels in one switch");
2907: error_with_decl (duplicate, "this is the first default label");
2908: }
2909: define_case_label (NULL_TREE);
2910: }
2911: stmt
2912: | BREAK ';'
2913: { emit_line_note (input_filename, lineno);
2914: if ( ! expand_exit_something ())
2915: error ("break statement not within loop or switch"); }
2916: | CONTINUE ';'
2917: { emit_line_note (input_filename, lineno);
2918: if (! expand_continue_loop (0))
2919: error ("continue statement not within a loop"); }
2920: | RETURN ';'
2921: { emit_line_note (input_filename, lineno);
2922: c_expand_return (NULL_TREE); }
2923: | RETURN expr ';'
2924: { emit_line_note (input_filename, lineno);
2925: c_expand_return ($2);
2926: finish_stmt ();
2927: }
2928: | ASM maybe_type_qual '(' string ')' ';'
2929: { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
2930: emit_line_note (input_filename, lineno);
2931: expand_asm ($4);
2932: finish_stmt ();
2933: }
2934: /* This is the case with just output operands. */
2935: | ASM maybe_type_qual '(' string ':' asm_operands ')' ';'
2936: { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
2937: emit_line_note (input_filename, lineno);
2938: c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE,
2939: $2 == ridpointers[(int)RID_VOLATILE],
2940: input_filename, lineno);
2941: finish_stmt ();
2942: }
2943: /* This is the case with input operands as well. */
2944: | ASM maybe_type_qual '(' string ':' asm_operands ':' asm_operands ')' ';'
2945: { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
2946: emit_line_note (input_filename, lineno);
2947: c_expand_asm_operands ($4, $6, $8, NULL_TREE,
2948: $2 == ridpointers[(int)RID_VOLATILE],
2949: input_filename, lineno);
2950: finish_stmt ();
2951: }
2952: /* This is the case with clobbered registers as well. */
2953: | ASM maybe_type_qual '(' string ':' asm_operands ':'
2954: asm_operands ':' asm_clobbers ')' ';'
2955: { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
2956: emit_line_note (input_filename, lineno);
2957: c_expand_asm_operands ($4, $6, $8, $10,
2958: $2 == ridpointers[(int)RID_VOLATILE],
2959: input_filename, lineno);
2960: finish_stmt ();
2961: }
2962: | GOTO identifier ';'
2963: { tree decl;
2964: emit_line_note (input_filename, lineno);
2965: decl = lookup_label ($2);
2966: TREE_USED (decl) = 1;
2967: expand_goto (decl); }
2968: | label_colon stmt
2969: { finish_stmt (); }
2970: | label_colon '}'
2971: { error ("label must be followed by statement");
2972: yyungetc ('}', 0);
2973: finish_stmt (); }
2974: | ';'
2975: { finish_stmt (); }
2976:
2977: /* Exception handling extentions. */
2978: | ANSI_THROW ';' { cplus_expand_throw (NULL_TREE); }
2979: | ANSI_THROW expr ';' { cplus_expand_throw ($2); }
2980: | THROW raise_identifier '(' nonnull_exprlist ')' ';'
2981: { cplus_expand_raise ($2, $4, NULL_TREE, 0);
2982: finish_stmt (); }
2983: | THROW raise_identifier LEFT_RIGHT ';'
2984: { cplus_expand_raise ($2, NULL_TREE, NULL_TREE, 0);
2985: finish_stmt (); }
2986: | RAISE raise_identifier '(' nonnull_exprlist ')' ';'
2987: { cplus_expand_raise ($2, $4, NULL_TREE, 0);
2988: finish_stmt (); }
2989: | RAISE raise_identifier LEFT_RIGHT ';'
2990: { cplus_expand_raise ($2, NULL_TREE, NULL_TREE, 0);
2991: finish_stmt (); }
2992: | RAISE identifier ';'
2993: { cplus_expand_reraise ($2);
2994: finish_stmt (); }
2995: | try EXCEPT identifier '{'
2996: {
2997: tree decl = cplus_expand_end_try ($1);
2998: $<ttype>2 = current_exception_type;
2999: $<ttype>4 = current_exception_decl;
3000: $<ttype>$ = current_exception_object;
3001: cplus_expand_start_except ($3, decl);
3002: pushlevel (0);
3003: clear_last_expr ();
3004: push_momentary ();
3005: expand_start_bindings (0);
3006: stmt_decl_msg = 0;
3007: }
3008: except_stmts '}'
3009: {
3010: tree decls = getdecls ();
3011: /* If there is a default exception to handle,
3012: handle it here. */
3013: if ($6)
3014: {
3015: tree decl = build_decl (CPLUS_CATCH_DECL, NULL_TREE, 0);
3016: tree block;
3017:
3018: pushlevel (1);
3019: expand_start_bindings (0);
3020: expand_expr ($6, 0, 0, 0);
3021: expand_end_bindings (0, 1, 0);
3022: block = poplevel (1, 0, 0);
3023:
3024: /* This is a catch block. */
3025: TREE_LANG_FLAG_2 (block) = 1;
3026: BLOCK_VARS (block) = decl;
3027: }
3028:
3029: expand_end_bindings (decls, decls != 0, 1);
3030: poplevel (decls != 0, 1, 0);
3031: pop_momentary ();
3032: current_exception_type = $<ttype>2;
3033: current_exception_decl = $<ttype>4;
3034: current_exception_object = $<ttype>5;
3035: cplus_expand_end_except ($6);
3036: }
3037: | try error
3038: {
3039: cplus_expand_end_try ($1);
3040: /* These are the important actions of
3041: `cplus_expand_end_except' which we must emulate. */
3042: if (expand_escape_except ())
3043: expand_end_except ();
3044: expand_end_bindings (0, 0, 1);
3045: poplevel (0, 0, 0);
3046: }
3047: | ansi_try ansi_dummy ansi_dummy
3048: {
3049: tree decl = cplus_expand_end_try ($1);
3050: $<ttype>2 = current_exception_type;
3051: $<ttype>3 = current_exception_decl;
3052: $<ttype>$ = current_exception_object;
3053: cplus_expand_start_except (NULL, decl);
3054: pushlevel (0);
3055: clear_last_expr ();
3056: push_momentary ();
3057: expand_start_bindings (0);
3058: stmt_decl_msg = 0;
3059: }
3060: ansi_except_stmts
3061: {
3062: tree decls = getdecls ();
3063: /* If there is a default exception to handle,
3064: handle it here. */
3065: if ($5)
3066: {
3067: tree decl = build_decl (CPLUS_CATCH_DECL, NULL_TREE, 0);
3068: tree block;
3069:
3070: pushlevel (1);
3071: expand_start_bindings (0);
3072: expand_expr ($5, 0, 0, 0);
3073: expand_end_bindings (0, 1, 0);
3074: block = poplevel (1, 0, 0);
3075:
3076: /* This is a catch block. */
3077: TREE_LANG_FLAG_2 (block) = 1;
3078: BLOCK_VARS (block) = decl;
3079: }
3080:
3081: expand_end_bindings (decls, decls != 0, 1);
3082: poplevel (decls != 0, 1, 0);
3083: pop_momentary ();
3084: current_exception_type = $<ttype>2;
3085: current_exception_decl = $<ttype>3;
3086: current_exception_object = $<ttype>4;
3087: cplus_expand_end_except ($5);
3088: }
3089: | try RERAISE raise_identifiers /* ';' checked for at bottom. */
3090: { tree name = get_identifier ("(compiler error)");
3091: tree orig_ex_type = current_exception_type;
3092: tree orig_ex_decl = current_exception_decl;
3093: tree orig_ex_obj = current_exception_object;
3094: tree decl = cplus_expand_end_try ($1), decls;
3095:
3096: /* Start hidden EXCEPT. */
3097: cplus_expand_start_except (name, decl);
3098: pushlevel (0);
3099: clear_last_expr ();
3100: push_momentary ();
3101: expand_start_bindings (0);
3102: stmt_decl_msg = 0;
3103:
3104: /* This sets up the reraise. */
3105: cplus_expand_reraise ($3);
3106:
3107: decls = getdecls ();
3108: expand_end_bindings (decls, decls != 0, 1);
3109: poplevel (decls != 0, 1, 0);
3110: pop_momentary ();
3111: current_exception_type = orig_ex_type;
3112: current_exception_decl = orig_ex_decl;
3113: current_exception_object = orig_ex_obj;
3114: /* This will reraise for us. */
3115: cplus_expand_end_except (error_mark_node);
3116: if (yychar == YYEMPTY)
3117: yychar = YYLEX;
3118: if (yychar != ';')
3119: error ("missing ';' after reraise statement");
3120: }
3121: | try %prec EMPTY
3122: { yyerror ("`except' missing after `try' statement");
3123: /* Terminate the binding contour started by special
3124: code in `.pushlevel'. Automagically pops off
3125: the conditional we started for `try' stmt. */
3126: cplus_expand_end_try ($1);
3127: expand_end_bindings (0, 0, 1);
3128: poplevel (0, 0, 0);
3129: pop_momentary ();
3130: YYERROR; }
3131: ;
3132:
3133: try: try_head '}'
3134: /* An empty try block is degenerate, but it's better to
3135: do extra work here than to do all the special-case work
3136: everywhere else. */
3137: {
3138: $$ = 1;
3139: pop_implicit_try_blocks (NULL_TREE);
3140: }
3141: | try_head stmts '}'
3142: {
3143: $$ = 1;
3144: pop_implicit_try_blocks (NULL_TREE);
3145: }
3146: | try_head error '}'
3147: {
3148: $$ = 0;
3149: pop_implicit_try_blocks (NULL_TREE);
3150: }
3151: ;
3152:
3153: label_colon:
3154: IDENTIFIER ':'
3155: { tree label;
3156: do_label:
3157: label = define_label (input_filename, lineno, $1);
3158: if (label)
3159: expand_label (label);
3160: }
3161: | PTYPENAME ':'
3162: { goto do_label; }
3163: | TYPENAME_COLON
3164: { tree label = define_label (input_filename, lineno, $1);
3165: if (label)
3166: expand_label (label);
3167: }
3168: ;
3169:
3170: try_head: TRY '{' { cplus_expand_start_try (0); } .pushlevel
3171:
3172: ansi_try: ansi_try_head '}'
3173: /* An empty try block is degenerate, but it's better to
3174: do extra work here than to do all the special-case work
3175: everywhere else. */
3176: {
3177: $$ = 1;
3178: pop_implicit_try_blocks (NULL_TREE);
3179: }
3180: | ansi_try_head stmts '}'
3181: {
3182: $$ = 1;
3183: pop_implicit_try_blocks (NULL_TREE);
3184: }
3185: | ansi_try_head error '}'
3186: {
3187: $$ = 0;
3188: pop_implicit_try_blocks (NULL_TREE);
3189: }
3190: ;
3191:
3192: ansi_dummy: ; /* Temporary place-holder. */
3193: ansi_try_head: ANSI_TRY '{' { cplus_expand_start_try (0); } .pushlevel
3194:
3195: except_stmts:
3196: /* empty */
3197: { $$ = NULL_TREE; }
3198: | except_stmts raise_identifier
3199: {
3200: tree type = lookup_exception_type (current_class_type, current_class_name, $2);
3201: if (type == NULL_TREE)
3202: {
3203: error ("`%s' is not an exception type",
3204: IDENTIFIER_POINTER (TREE_VALUE ($2)));
3205: current_exception_type = NULL_TREE;
3206: TREE_TYPE (current_exception_object) = error_mark_node;
3207: }
3208: else
3209: {
3210: current_exception_type = type;
3211: /* In-place union. */
3212: TREE_TYPE (current_exception_object) = type;
3213: }
3214: $2 = cplus_expand_start_catch ($2);
3215: pushlevel (1);
3216: expand_start_bindings (0);
3217: }
3218: compstmt
3219: {
3220: expand_end_bindings (0, 1, 0);
3221: $4 = poplevel (1, 0, 0);
3222:
3223: cplus_expand_end_catch (0);
3224:
3225: /* Mark this as a catch block. */
3226: TREE_LANG_FLAG_2 ($4) = 1;
3227: if ($2 != error_mark_node)
3228: {
3229: tree decl = build_decl (CPLUS_CATCH_DECL, DECL_NAME ($2), 0);
3230: DECL_RTL (decl) = DECL_RTL ($2);
3231: TREE_CHAIN (decl) = BLOCK_VARS ($4);
3232: BLOCK_VARS ($4) = decl;
3233: }
3234: }
3235: | except_stmts DEFAULT
3236: {
3237: if ($1)
3238: error ("duplicate default in exception handler");
3239: current_exception_type = NULL_TREE;
3240: /* Takes it right out of scope. */
3241: TREE_TYPE (current_exception_object) = error_mark_node;
3242:
3243: if (! expand_catch_default ())
3244: compiler_error ("default catch botch");
3245:
3246: /* The default exception is handled as the
3247: last in the chain of exceptions handled. */
3248: do_pending_stack_adjust ();
3249: start_sequence ();
3250: $1 = make_node (RTL_EXPR);
3251: TREE_TYPE ($1) = void_type_node;
3252: }
3253: compstmt
3254: {
3255: do_pending_stack_adjust ();
3256: if (! expand_catch (NULL_TREE))
3257: compiler_error ("except nesting botch");
3258: if (! expand_end_catch ())
3259: compiler_error ("except nesting botch");
3260: RTL_EXPR_SEQUENCE ($1) = (struct rtx_def *)get_insns ();
3261: if ($4)
3262: {
3263: /* Mark this block as the default catch block. */
3264: TREE_LANG_FLAG_1 ($4) = 1;
3265: TREE_LANG_FLAG_2 ($4) = 1;
3266: }
3267: end_sequence ();
3268: }
3269: ;
3270:
3271: optional_identifier:
3272: /* empty */
3273: { $$ = NULL_TREE; }
3274: | identifier ;
3275:
3276: ansi_except_stmts:
3277: /* empty */
3278: { $$ = NULL_TREE; }
3279: | ansi_except_stmts CATCH '(' typename optional_identifier ')'
3280: {
3281: extern tree ansi_expand_start_catch ();
3282: extern tree cplus_exception_name ();
3283: tree type = groktypename ($4);
3284: current_exception_type = type;
3285: /* In-place union. */
3286: if ($5)
3287: {
3288: tree tmp;
3289: tmp = pushdecl (build_decl (VAR_DECL, $5, type));
3290: current_exception_object =
3291: build1 (INDIRECT_REF, type, tmp);
3292: }
3293: $4 = ansi_expand_start_catch(type);
3294: pushlevel (1);
3295: expand_start_bindings (0);
3296: }
3297: compstmt
3298: {
3299: expand_end_bindings (0, 1, 0);
3300: $8 = poplevel (1, 0, 0);
3301:
3302: cplus_expand_end_catch (0);
3303:
3304: /* Mark this as a catch block. */
3305: TREE_LANG_FLAG_2 ($8) = 1;
3306: if ($4 != error_mark_node)
3307: {
3308: tree decl = build_decl (CPLUS_CATCH_DECL, DECL_NAME ($4), 0);
3309: DECL_RTL (decl) = DECL_RTL ($4);
3310: TREE_CHAIN (decl) = BLOCK_VARS ($8);
3311: BLOCK_VARS ($8) = decl;
3312: }
3313: }
3314: ;
3315:
3316: forhead.1:
3317: FOR '(' ';'
3318: { $$ = NULL_TREE; }
3319: | FOR '(' expr ';'
3320: { $$ = $3; }
3321: | FOR '(' '{' '}'
3322: { $$ = NULL_TREE; }
3323: ;
3324:
3325: forhead.2:
3326: FOR '(' decl
3327: { $$ = 0; }
3328: | FOR '(' error ';'
3329: { $$ = 0; }
3330: | FOR '(' '{' .pushlevel stmts '}'
3331: { $$ = 1; }
3332: | FOR '(' '{' .pushlevel error '}'
3333: { $$ = -1; }
3334: ;
3335:
3336: /* Either a type-qualifier or nothing. First thing in an `asm' statement. */
3337:
3338: maybe_type_qual:
3339: /* empty */
3340: { if (pedantic)
3341: warning ("ANSI C forbids use of `asm' keyword");
3342: emit_line_note (input_filename, lineno); }
3343: | TYPE_QUAL
3344: { if (pedantic)
3345: warning ("ANSI C forbids use of `asm' keyword");
3346: emit_line_note (input_filename, lineno); }
3347: ;
3348:
3349: xexpr:
3350: /* empty */
3351: { $$ = NULL_TREE; }
3352: | expr
3353: | error
3354: { $$ = NULL_TREE; }
3355: ;
3356:
3357: /* These are the operands other than the first string and colon
3358: in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */
3359: asm_operands: /* empty */
3360: { $$ = NULL_TREE; }
3361: | nonnull_asm_operands
3362: ;
3363:
3364: nonnull_asm_operands:
3365: asm_operand
3366: | nonnull_asm_operands ',' asm_operand
3367: { $$ = chainon ($$, $3); }
3368: ;
3369:
3370: asm_operand:
3371: STRING '(' expr ')'
3372: { $$ = build_tree_list ($$, $3); }
3373: ;
3374:
3375: asm_clobbers:
3376: STRING
3377: { $$ = tree_cons (NULL_TREE, $$, NULL_TREE); }
3378: | asm_clobbers ',' STRING
3379: { $$ = tree_cons (NULL_TREE, $3, $$); }
3380: ;
3381:
3382: /* This is what appears inside the parens in a function declarator.
3383: Its value is represented in the format that grokdeclarator expects.
3384:
3385: In C++, declaring a function with no parameters
3386: means that that function takes *no* parameters. */
3387: parmlist: /* empty */
3388: {
3389: if (strict_prototype)
3390: $$ = void_list_node;
3391: else
3392: $$ = NULL_TREE;
3393: }
3394: | parms
3395: {
3396: $$ = chainon ($$, void_list_node);
3397: TREE_PARMLIST ($$) = 1;
3398: }
3399: | parms ',' ELLIPSIS
3400: {
3401: TREE_PARMLIST ($$) = 1;
3402: }
3403: /* C++ allows an ellipsis without a separating ',' */
3404: | parms ELLIPSIS
3405: {
3406: TREE_PARMLIST ($$) = 1;
3407: }
3408: | ELLIPSIS
3409: {
3410: $$ = NULL_TREE;
3411: }
3412: | TYPENAME_ELLIPSIS
3413: {
3414: TREE_PARMLIST ($$) = 1;
3415: }
3416: | parms TYPENAME_ELLIPSIS
3417: {
3418: TREE_PARMLIST ($$) = 1;
3419: }
3420: | parms ':'
3421: {
3422: /* This helps us recover from really nasty
3423: parse errors, for example, a missing right
3424: parenthesis. */
3425: yyerror ("possibly missing ')'");
3426: $$ = chainon ($$, void_list_node);
3427: TREE_PARMLIST ($$) = 1;
3428: yyungetc (':', 0);
3429: yychar = ')';
3430: }
3431: ;
3432:
3433: /* A nonempty list of parameter declarations or type names. */
3434: parms:
3435: parm
3436: { $$ = build_tree_list (NULL_TREE, $$); }
3437: | parm '=' init
3438: { $$ = build_tree_list ($3, $$); }
3439: | parms ',' parm
3440: { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); }
3441: | parms ',' parm '=' init
3442: { $$ = chainon ($$, build_tree_list ($5, $3)); }
3443: | parms ',' bad_parm
3444: { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); }
3445: | parms ',' bad_parm '=' init
3446: { $$ = chainon ($$, build_tree_list ($5, $3)); }
3447: ;
3448:
3449: /* A single parameter declaration or parameter type name,
3450: as found in a parmlist. The first four cases make up for 10%
3451: of the time spent parsing C++. We cannot use them because
3452: of `int id[]' which won't get parsed properly. */
3453: parm:
3454: /*
3455: typed_declspecs dont_see_typename '*' IDENTIFIER
3456: { $$ = build_tree_list ($$, build_parse_node (INDIRECT_REF, $4));
3457: see_typename (); }
3458: | typed_declspecs dont_see_typename '&' IDENTIFIER
3459: { $$ = build_tree_list ($$, build_parse_node (ADDR_EXPR, $4));
3460: see_typename (); }
3461: | TYPENAME IDENTIFIER
3462: { $$ = build_tree_list (list_hash_lookup_or_cons ($$), $2); }
3463: | TYPESPEC IDENTIFIER
3464: { $$ = build_tree_list (list_hash_lookup_or_cons ($$), $2); }
3465: | */
3466: typed_declspecs dont_see_typename abs_or_notype_decl
3467: { $$ = build_tree_list ($$, $3);
3468: see_typename (); }
3469: | declmods dont_see_typename abs_or_notype_decl
3470: { $$ = build_tree_list ($$, $3);
3471: see_typename (); }
3472: ;
3473:
3474: abs_or_notype_decl: absdcl
3475: | notype_declarator
3476: | START_DECLARATOR notype_declarator
3477: { $$ = $2; }
3478: ;
3479:
3480: see_typename: type_quals
3481: { see_typename (); }
3482: ;
3483:
3484: dont_see_typename: /* empty */
3485: { dont_see_typename (); }
3486: ;
3487:
3488: try_for_typename:
3489: {
3490: if ($<ttype>-1 == error_mark_node)
3491: $$ = 0;
3492: else
3493: {
3494: $$ = 1;
3495: pushclass ($<ttype>-1, 1);
3496: }
3497: }
3498: ;
3499:
3500: bad_parm:
3501: abs_or_notype_decl
3502: {
3503: warning ("type specifier omitted for parameter");
3504: $$ = build_tree_list (TREE_PURPOSE (TREE_VALUE ($<ttype>-1)), $$);
3505: }
3506: ;
3507:
3508: maybe_raises:
3509: /* empty */
3510: { $$ = NULL_TREE; }
3511: | RAISES raise_identifiers %prec EMPTY
3512: { $$ = $2; }
3513: | ANSI_THROW '(' ansi_raise_identifiers ')' %prec EMPTY
3514: { $$ = $3; }
3515: ;
3516:
3517: raise_identifier:
3518: ALL
3519: { $$ = void_list_node; }
3520: | IDENTIFIER
3521: { $$ = build_decl_list (NULL_TREE, $$); }
3522: | TYPENAME
3523: { $$ = build_decl_list (NULL_TREE, $$); }
3524: | SCOPE IDENTIFIER
3525: { $$ = build_decl_list (void_type_node, $2); }
3526: | SCOPE TYPENAME
3527: { $$ = build_decl_list (void_type_node, $2); }
3528: | scoped_id IDENTIFIER
3529: { $$ = build_decl_list ($$, $2); }
3530: | scoped_typename
3531: ;
3532:
3533: ansi_raise_identifier:
3534: typename
3535: { $$ = build_decl_list (NULL_TREE, $$); }
3536: ;
3537:
3538: raise_identifiers:
3539: raise_identifier
3540: | raise_identifiers ',' raise_identifier
3541: {
3542: TREE_CHAIN ($3) = $$;
3543: $$ = $3;
3544: }
3545: ;
3546:
3547: ansi_raise_identifiers:
3548: ansi_raise_identifier
3549: | ansi_raise_identifiers ',' ansi_raise_identifier
3550: {
3551: TREE_CHAIN ($3) = $$;
3552: $$ = $3;
3553: }
3554: ;
3555:
3556: operator_name:
3557: OPERATOR '*'
3558: { $$ = ansi_opname[MULT_EXPR]; }
3559: | OPERATOR '/'
3560: { $$ = ansi_opname[TRUNC_DIV_EXPR]; }
3561: | OPERATOR '%'
3562: { $$ = ansi_opname[TRUNC_MOD_EXPR]; }
3563: | OPERATOR '+'
3564: { $$ = ansi_opname[PLUS_EXPR]; }
3565: | OPERATOR '-'
3566: { $$ = ansi_opname[MINUS_EXPR]; }
3567: | OPERATOR '&'
3568: { $$ = ansi_opname[BIT_AND_EXPR]; }
3569: | OPERATOR '|'
3570: { $$ = ansi_opname[BIT_IOR_EXPR]; }
3571: | OPERATOR '^'
3572: { $$ = ansi_opname[BIT_XOR_EXPR]; }
3573: | OPERATOR '~'
3574: { $$ = ansi_opname[BIT_NOT_EXPR]; }
3575: | OPERATOR ','
3576: { $$ = ansi_opname[COMPOUND_EXPR]; }
3577: | OPERATOR ARITHCOMPARE
3578: { $$ = ansi_opname[$2]; }
3579: | OPERATOR '<'
3580: { $$ = ansi_opname[LT_EXPR]; }
3581: | OPERATOR '>'
3582: { $$ = ansi_opname[GT_EXPR]; }
3583: | OPERATOR EQCOMPARE
3584: { $$ = ansi_opname[$2]; }
3585: | OPERATOR ASSIGN
3586: { $$ = ansi_assopname[$2]; }
3587: | OPERATOR '='
3588: {
3589: $$ = ansi_opname [MODIFY_EXPR];
3590: if (current_class_type)
3591: {
3592: TYPE_HAS_ASSIGNMENT (current_class_type) = 1;
3593: TYPE_GETS_ASSIGNMENT (current_class_type) = 1;
3594: }
3595: }
3596: | OPERATOR LSHIFT
3597: { $$ = ansi_opname[$2]; }
3598: | OPERATOR RSHIFT
3599: { $$ = ansi_opname[$2]; }
3600: | OPERATOR PLUSPLUS
3601: { $$ = ansi_opname[POSTINCREMENT_EXPR]; }
3602: | OPERATOR MINUSMINUS
3603: { $$ = ansi_opname[PREDECREMENT_EXPR]; }
3604: | OPERATOR ANDAND
3605: { $$ = ansi_opname[TRUTH_ANDIF_EXPR]; }
3606: | OPERATOR OROR
3607: { $$ = ansi_opname[TRUTH_ORIF_EXPR]; }
3608: | OPERATOR '!'
3609: { $$ = ansi_opname[TRUTH_NOT_EXPR]; }
3610: | OPERATOR '?' ':'
3611: { $$ = ansi_opname[COND_EXPR]; }
3612: | OPERATOR MIN_MAX
3613: { $$ = ansi_opname[$2]; }
3614: | OPERATOR POINTSAT %prec EMPTY
3615: { $$ = ansi_opname[COMPONENT_REF];
3616: if (current_class_type)
3617: {
3618: tree t = current_class_type;
3619: while (t)
3620: {
3621: TYPE_OVERLOADS_ARROW (t) = 1;
3622: t = TYPE_NEXT_VARIANT (t);
3623: }
3624: }
3625: }
3626: | OPERATOR POINTSAT_STAR %prec EMPTY
3627: { $$ = ansi_opname[MEMBER_REF];
3628: if (current_class_type)
3629: {
3630: tree t = current_class_type;
3631: while (t)
3632: {
3633: TYPE_OVERLOADS_ARROW (t) = 1;
3634: t = TYPE_NEXT_VARIANT (t);
3635: }
3636: }
3637: }
3638: | OPERATOR POINTSAT_LEFT_RIGHT type_quals %prec '.'
3639: {
3640: if (yychar == YYEMPTY)
3641: yychar = YYLEX;
3642: if (yychar == '(' || yychar == LEFT_RIGHT)
3643: {
3644: $$ = ansi_opname[METHOD_CALL_EXPR];
3645: if (current_class_type)
3646: {
3647: tree t = current_class_type;
3648: while (t)
3649: {
3650: TYPE_OVERLOADS_METHOD_CALL_EXPR (t) = 1;
3651: t = TYPE_NEXT_VARIANT (t);
3652: }
3653: }
3654: }
3655: else
3656: {
3657: $$ = build_parse_node (CALL_EXPR, ansi_opname[COMPONENT_REF], void_list_node, $3);
3658: if (current_class_type)
3659: {
3660: tree t = current_class_type;
3661: while (t)
3662: {
3663: TYPE_OVERLOADS_ARROW (t) = 1;
3664: t = TYPE_NEXT_VARIANT (t);
3665: }
3666: }
3667: }
3668: }
3669: | OPERATOR LEFT_RIGHT
3670: { $$ = ansi_opname[CALL_EXPR];
3671: if (current_class_type)
3672: {
3673: tree t = current_class_type;
3674: while (t)
3675: {
3676: TYPE_OVERLOADS_CALL_EXPR (t) = 1;
3677: t = TYPE_NEXT_VARIANT (t);
3678: }
3679: }
3680: }
3681: | OPERATOR '[' ']'
3682: { $$ = ansi_opname[ARRAY_REF];
3683: if (current_class_type)
3684: {
3685: tree t = current_class_type;
3686: while (t)
3687: {
3688: TYPE_OVERLOADS_ARRAY_REF (t) = 1;
3689: t = TYPE_NEXT_VARIANT (t);
3690: }
3691: }
3692: }
3693: | OPERATOR NEW
3694: {
3695: $$ = ansi_opname[NEW_EXPR];
3696: if (current_class_type)
3697: {
3698: tree t = current_class_type;
3699: while (t)
3700: {
3701: TREE_GETS_NEW (t) = 1;
3702: t = TYPE_NEXT_VARIANT (t);
3703: }
3704: }
3705: }
3706: | OPERATOR DELETE
3707: {
3708: $$ = ansi_opname[DELETE_EXPR];
3709: if (current_class_type)
3710: {
3711: tree t = current_class_type;
3712: while (t)
3713: {
3714: TREE_GETS_DELETE (t) = 1;
3715: t = TYPE_NEXT_VARIANT (t);
3716: }
3717: }
3718: }
3719:
3720: /* These should do `groktypename' and set up TREE_HAS_X_CONVERSION
3721: here, rather than doing it in class.c . */
3722: | OPERATOR typed_typespecs absdcl
3723: {
3724: $$ = build1 (TYPE_EXPR, $2, $3);
3725: }
3726: | OPERATOR error
3727: { $$ = ansi_opname[ERROR_MARK]; }
3728: ;
3729:
3730: %%
3731:
3732: #if YYDEBUG != 0
3733: db_yyerror (s, yyps, yychar)
3734: char *s;
3735: short *yyps;
3736: int yychar;
3737: {
3738: FILE *yyout;
3739: char buf[1024];
3740: int st;
3741:
3742: yyerror (s);
3743: printf ("State is %d, input token number is %d.\n", *yyps, yychar);
3744:
3745: #ifdef PARSE_OUTPUT
3746: if (*yyps < 1) fatal ("Cannot start from here");
3747: else if ((yyout = fopen (PARSE_OUTPUT, "r")) == NULL)
3748: error ("cannot open file %s", PARSE_OUTPUT);
3749: else
3750: {
3751: printf ("That is to say,\n\n");
3752: while (fgets(buf, sizeof (buf)-1, yyout))
3753: {
3754: if (buf[0] != 's') continue;
3755: st = atoi (buf+6);
3756: if (st != *yyps) continue;
3757: printf ("%s", buf);
3758: while (fgets (buf, sizeof (buf)-1, yyout))
3759: {
3760: if (buf[0] == 's') break;
3761: printf ("%s", buf);
3762: }
3763: break;
3764: }
3765: printf ("With the token %s\n", yytname[YYTRANSLATE (yychar)]);
3766: fclose (yyout);
3767: }
3768: #endif
3769: }
3770: #endif
3771:
3772: void
3773: yyerror (string)
3774: char *string;
3775: {
3776: extern int end_of_file;
3777: extern char *token_buffer;
3778: extern int input_redirected ();
3779: char buf[200];
3780:
3781: strcpy (buf, string);
3782:
3783: /* We can't print string and character constants well
3784: because the token_buffer contains the result of processing escapes. */
3785: if (end_of_file)
3786: strcat (buf, input_redirected ()
3787: ? " at end of saved text"
3788: : " at end of input");
3789: else if (token_buffer[0] == 0)
3790: strcat (buf, " at null character");
3791: else if (token_buffer[0] == '"')
3792: strcat (buf, " before string constant");
3793: else if (token_buffer[0] == '\'')
3794: strcat (buf, " before character constant");
3795: else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
3796: sprintf (buf + strlen (buf), " before character 0%o",
3797: (unsigned char) token_buffer[0]);
3798: else
3799: strcat (buf, " before `%s'");
3800:
3801: error (buf, token_buffer);
3802: }
3803:
3804: static
3805: #ifdef __GNUC__
3806: __inline
3807: #endif
3808: void
3809: yyprint (file, yychar, yylval)
3810: FILE *file;
3811: int yychar;
3812: YYSTYPE yylval;
3813: {
3814: tree t;
3815: switch (yychar)
3816: {
3817: case IDENTIFIER:
3818: case TYPENAME:
3819: case TYPESPEC:
3820: case PTYPENAME:
3821: case IDENTIFIER_DEFN:
3822: case TYPENAME_DEFN:
3823: case PTYPENAME_DEFN:
3824: case TYPENAME_COLON:
3825: case TYPENAME_ELLIPSIS:
3826: case SCOPED_TYPENAME:
3827: case SCSPEC:
3828: t = yylval.ttype;
3829: print_id:
3830: assert (TREE_CODE (t) == IDENTIFIER_NODE);
3831: if (IDENTIFIER_POINTER (t))
3832: fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
3833: break;
3834: case AGGR:
3835: if (yylval.ttype == class_type_node)
3836: fprintf (file, " `class'");
3837: else if (yylval.ttype == record_type_node)
3838: fprintf (file, " `struct'");
3839: else if (yylval.ttype == union_type_node)
3840: fprintf (file, " `union'");
3841: else if (yylval.ttype == enum_type_node)
3842: fprintf (file, " `enum'");
3843: else
3844: abort ();
3845: break;
3846: case PRE_PARSED_CLASS_DECL:
3847: t = yylval.ttype;
3848: assert (TREE_CODE (t) == TREE_LIST);
3849: t = TREE_VALUE (t);
3850: goto print_id;
3851: }
3852: }
3853:
3854: static int *reduce_count;
3855: int *token_count;
3856:
3857: #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
3858: #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
3859:
3860: int *
3861: init_parse ()
3862: {
3863: #ifdef GATHER_STATISTICS
3864: reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
3865: bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
3866: reduce_count += 1;
3867: token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
3868: bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
3869: token_count += 1;
3870: #endif
3871: return token_count;
3872: }
3873:
3874: #ifdef GATHER_STATISTICS
3875: void
3876: yyhook (yyn)
3877: int yyn;
3878: {
3879: reduce_count[yyn] += 1;
3880: }
3881: #endif
3882:
3883: static int
3884: reduce_cmp (p, q)
3885: int *p, *q;
3886: {
3887: return reduce_count[*q] - reduce_count[*p];
3888: }
3889:
3890: static int
3891: token_cmp (p, q)
3892: int *p, *q;
3893: {
3894: return token_count[*q] - token_count[*p];
3895: }
3896:
3897: void
3898: print_parse_statistics ()
3899: {
3900: #if YYDEBUG != 0
3901: int i;
3902: int maxlen = REDUCE_LENGTH;
3903: unsigned *sorted;
3904:
3905: if (reduce_count[-1] == 0)
3906: return;
3907:
3908: if (TOKEN_LENGTH > REDUCE_LENGTH)
3909: maxlen = TOKEN_LENGTH;
3910: sorted = (unsigned *) alloca (sizeof (int) * maxlen);
3911:
3912: for (i = 0; i < TOKEN_LENGTH; i++)
3913: sorted[i] = i;
3914: qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
3915: for (i = 0; i < TOKEN_LENGTH; i++)
3916: {
3917: int index = sorted[i];
3918: if (token_count[index] == 0)
3919: break;
3920: if (token_count[index] < token_count[-1])
3921: break;
3922: fprintf (stderr, "token %d, `%s', count = %d\n",
3923: index, yytname[YYTRANSLATE (index)], token_count[index]);
3924: }
3925: fprintf (stderr, "\n");
3926: for (i = 0; i < REDUCE_LENGTH; i++)
3927: sorted[i] = i;
3928: qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
3929: for (i = 0; i < REDUCE_LENGTH; i++)
3930: {
3931: int index = sorted[i];
3932: if (reduce_count[index] == 0)
3933: break;
3934: if (reduce_count[index] < reduce_count[-1])
3935: break;
3936: fprintf (stderr, "rule %d, line %d, count = %d\n",
3937: index, yyrline[index], reduce_count[index]);
3938: }
3939: fprintf (stderr, "\n");
3940: #endif
3941: }
3942:
3943:
3944: /* Sets the value of the 'yydebug' varable to VALUE.
3945: This is a function so we don't have to have YYDEBUG defined
3946: in order to build the compiler. */
3947: void
3948: set_yydebug (value)
3949: int value;
3950: {
3951: #if YYDEBUG != 0
3952: yydebug = value;
3953: #else
3954: warning ("YYDEBUG not defined.");
3955: #endif
3956: }
3957:
3958: #ifdef SPEW_DEBUG
3959: const char *
3960: debug_yytranslate (value)
3961: int value;
3962: {
3963: #if YYDEBUG != 0
3964: return yytname[YYTRANSLATE (value)];
3965: #else
3966: return "YYDEBUG not defined.";
3967: #endif
3968: }
3969:
3970: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.