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