![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-parse.in CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-parse.in CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 ! root 1: /* YACC parser for C++ syntax and for Objective-C. ! 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: /* This file defines the grammar of C++ and that of Objective C. ! 22: %if objc ... %endif objc conditionals contain code for Objective C only. ! 23: %if cplus ... %endif cplus conditionals contain code for C++ only. ! 24: Sed commands in Makefile.in are used to convert this file into ! 25: cp-parse.y and into obcp-parse.y. */ ! 26: ! 27: ! 28: /* This grammar is based on the GNU CC grammar. */ ! 29: ! 30: /* Note: Bison automatically applies a default action of "$$ = $1" for ! 31: all derivations; this is applied before the explicit action, if one ! 32: is given. Keep this in mind when reading the actions. */ ! 33: ! 34: /* Also note: this version contains experimental exception ! 35: handling features. They could break, change, disappear, ! 36: or otherwise exhibit volatile behavior. Don't depend on ! 37: me (Michael Tiemann) to protect you from any negative impact ! 38: this may have on your professional, personal, or spiritual life. ! 39: ! 40: NEWS FLASH: This version now supports the exception handling ! 41: syntax of Stroustrup's 2nd edition, if -fansi-exceptions is given. ! 42: THIS IS WORK IN PROGRESS!!! The type of the 'throw' and the ! 43: 'catch' much match EXACTLY (no inheritance support or coercions). ! 44: Also, throw-specifications of functions don't work. ! 45: Destructors aren't called correctly. Etc, etc. --Per Bothner. ! 46: */ ! 47: ! 48: %{ ! 49: ! 50: %ifobjc ! 51: #define OBJCPLUS ! 52: %endifobjc ! 53: ! 54: #if defined(GATHER_STATISTICS) || defined(SPEW_DEBUG) ! 55: #undef YYDEBUG ! 56: #define YYDEBUG 1 ! 57: #endif ! 58: ! 59: #include "config.h" ! 60: ! 61: #include <stdio.h> ! 62: #include <errno.h> ! 63: ! 64: #include "tree.h" ! 65: #include "input.h" ! 66: #include "flags.h" ! 67: #include "cp-lex.h" ! 68: #include "cp-tree.h" ! 69: ! 70: /* Since parsers are distinct for each language, put the language string ! 71: definition here. (fnf) */ ! 72: %ifobjc ! 73: char *language_string = "GNU Objective-C++"; ! 74: %endifobjc ! 75: %ifcplus ! 76: char *language_string = "GNU C++"; ! 77: %endifcplus ! 78: ! 79: extern tree void_list_node; ! 80: extern struct obstack permanent_obstack; ! 81: ! 82: #ifndef errno ! 83: extern int errno; ! 84: #endif ! 85: ! 86: extern int end_of_file; ! 87: ! 88: void yyerror (); ! 89: ! 90: /* Like YYERROR but do call yyerror. */ ! 91: #define YYERROR1 { yyerror ("syntax error"); YYERROR; } ! 92: ! 93: static void position_after_white_space (); ! 94: ! 95: /* Contains the statement keyword (if/while/do) to include in an ! 96: error message if the user supplies an empty conditional expression. */ ! 97: static char *cond_stmt_keyword; ! 98: ! 99: %ifobjc ! 100: #include "objc-act.h" ! 101: ! 102: /* the `decl' list operators optimization is not appropriate for Objective-C */ ! 103: #define build_decl_list build_tree_list ! 104: #define decl_tree_cons tree_cons ! 105: %endifobjc ! 106: ! 107: /* Nonzero if we have an `extern "C"' acting as an extern specifier. */ ! 108: int have_extern_spec; ! 109: int used_extern_spec; ! 110: ! 111: void yyhook (); ! 112: ! 113: /* Cons up an empty parameter list. */ ! 114: #ifdef __GNUC__ ! 115: __inline ! 116: #endif ! 117: static tree ! 118: empty_parms () ! 119: { ! 120: tree parms; ! 121: ! 122: if (strict_prototype) ! 123: parms = void_list_node; ! 124: else ! 125: parms = NULL_TREE; ! 126: return parms; ! 127: } ! 128: %} ! 129: ! 130: %start program ! 131: ! 132: %union {long itype; tree ttype; char *strtype; enum tree_code code; } ! 133: ! 134: /* All identifiers that are not reserved words ! 135: and are not declared typedefs in the current block */ ! 136: %token IDENTIFIER ! 137: ! 138: /* All identifiers that are declared typedefs in the current block. ! 139: In some contexts, they are treated just like IDENTIFIER, ! 140: but they can also serve as typespecs in declarations. */ ! 141: %token TYPENAME ! 142: ! 143: /* Qualified identifiers that end in a TYPENAME. */ ! 144: %token SCOPED_TYPENAME ! 145: ! 146: /* Reserved words that specify storage class. ! 147: yylval contains an IDENTIFIER_NODE which indicates which one. */ ! 148: %token SCSPEC ! 149: ! 150: /* Reserved words that specify type. ! 151: yylval contains an IDENTIFIER_NODE which indicates which one. */ ! 152: %token TYPESPEC ! 153: ! 154: /* Reserved words that qualify type: "const" or "volatile". ! 155: yylval contains an IDENTIFIER_NODE which indicates which one. */ ! 156: %token TYPE_QUAL ! 157: ! 158: /* Character or numeric constants. ! 159: yylval is the node for the constant. */ ! 160: %token CONSTANT ! 161: ! 162: /* String constants in raw form. ! 163: yylval is a STRING_CST node. */ ! 164: %token STRING ! 165: ! 166: /* "...", used for functions with variable arglists. */ ! 167: %token ELLIPSIS ! 168: ! 169: /* the reserved words */ ! 170: /* SCO include files test "ASM", so use something else. */ ! 171: %token SIZEOF ENUM /* STRUCT UNION */ IF ELSE WHILE DO FOR SWITCH CASE DEFAULT ! 172: %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD GCC_ASM_KEYWORD TYPEOF ALIGNOF ! 173: %token HEADOF CLASSOF ! 174: %token ATTRIBUTE EXTENSION LABEL ! 175: ! 176: /* the reserved words... C++ extensions */ ! 177: %token <ttype> AGGR ! 178: %token <itype> VISSPEC ! 179: %token DELETE NEW OVERLOAD THIS OPERATOR ! 180: %token LEFT_RIGHT TEMPLATE ! 181: %token TYPEID DYNAMIC_CAST ! 182: %token <itype> SCOPE ! 183: ! 184: %ifobjc ! 185: /* the Objective-C keywords */ ! 186: %token INTERFACE IMPLEMENTATION END SELECTOR DEFS ENCODE ! 187: %token CLASSNAME PROTOCOL OBJECTNAME CLASS ALIAS ! 188: %token PRIVATE PUBLIC PROTECTED ! 189: ! 190: /* Objective-C string constants in raw form. ! 191: yylval is a OBJC_STRING_CST node. */ ! 192: %token OBJC_STRING ! 193: %endifobjc ! 194: ! 195: /* Special token created by the lexer to separate TYPENAME ! 196: from an ABSDCL. This allows us to parse `foo (*pf)()'. */ ! 197: ! 198: %token START_DECLARATOR ! 199: ! 200: /* Define the operator tokens and their precedences. ! 201: The value is an integer because, if used, it is the tree code ! 202: to use in the expression made from the operator. */ ! 203: ! 204: %left EMPTY /* used to resolve s/r with epsilon */ ! 205: ! 206: /* Add precedence rules to solve dangling else s/r conflict */ ! 207: %nonassoc IF ! 208: %nonassoc ELSE ! 209: ! 210: %left IDENTIFIER TYPENAME TYPENAME_COLON SCSPEC TYPESPEC TYPE_QUAL ENUM AGGR ! 211: ! 212: %left '{' ',' ! 213: ! 214: %right <code> ASSIGN '=' ! 215: %right <code> '?' ':' RANGE ! 216: %left <code> OROR ! 217: %left <code> ANDAND ! 218: %left <code> '|' ! 219: %left <code> '^' ! 220: %left <code> '&' ! 221: %left <code> MIN_MAX ! 222: %left <code> EQCOMPARE ! 223: %left <code> ARITHCOMPARE '<' '>' ! 224: %left <code> LSHIFT RSHIFT ! 225: %left <code> '+' '-' ! 226: %left <code> '*' '/' '%' ! 227: %right <code> UNARY PLUSPLUS MINUSMINUS ! 228: %left HYPERUNARY ! 229: %left <ttype> PAREN_STAR_PAREN LEFT_RIGHT ! 230: %left <code> POINTSAT POINTSAT_STAR '.' DOT_STAR '(' '[' ! 231: ! 232: %right SCOPE /* C++ extension */ ! 233: %nonassoc NEW DELETE RAISE RAISES RERAISE TRY EXCEPT CATCH THROW ! 234: %nonassoc ANSI_TRY ANSI_THROW ! 235: ! 236: %type <code> unop ! 237: ! 238: %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist ! 239: %type <ttype> optional_identifier paren_expr_or_null ! 240: %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING ! 241: %type <ttype> typed_declspecs reserved_declspecs ! 242: %type <ttype> typed_typespecs reserved_typespecquals ! 243: %type <ttype> declmods typespec typespecqual_reserved ! 244: %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual ! 245: %type <itype> initdecls notype_initdecls initdcl /* C++ modification */ ! 246: %type <ttype> init initlist maybeasm ! 247: %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers ! 248: %type <ttype> maybe_attribute attribute_list attrib ! 249: %type <ttype> abs_member_declarator after_type_member_declarator ! 250: ! 251: %type <ttype> compstmt except_stmts ansi_except_stmts implicitly_scoped_stmt ! 252: ! 253: %type <ttype> declarator notype_declarator after_type_declarator ! 254: ! 255: %type <ttype> structsp opt.component_decl_list component_decl_list ! 256: %type <ttype> component_decl components component_declarator ! 257: %type <ttype> enumlist enumerator ! 258: %type <ttype> typename absdcl absdcl1 type_quals abs_or_notype_decl ! 259: %type <ttype> xexpr see_typename parmlist parms parm bad_parm ! 260: %type <ttype> identifiers_or_typenames ! 261: ! 262: /* C++ extensions */ ! 263: %type <ttype> typename_scope ! 264: %token <ttype> TYPENAME_COLON TYPENAME_ELLIPSIS ! 265: %token <ttype> PTYPENAME SCOPED_TYPENAME ! 266: %token <ttype> PRE_PARSED_FUNCTION_DECL EXTERN_LANG_STRING ALL ! 267: %token <ttype> PRE_PARSED_CLASS_DECL ! 268: %type <ttype> fn.def1 /* Not really! */ ! 269: %type <ttype> fn.def2 return_id ! 270: %type <ttype> named_class_head named_class_head_sans_basetype ! 271: %type <ttype> unnamed_class_head ! 272: %type <ttype> class_head base_class_list ! 273: %type <itype> base_class_visibility_list ! 274: %type <ttype> base_class maybe_base_class_list base_class.1 ! 275: %type <ttype> after_type_declarator_no_typename ! 276: %type <ttype> maybe_raises raise_identifier raise_identifiers ansi_raise_identifier ansi_raise_identifiers ! 277: %type <ttype> component_declarator0 id_scope scoped_typename scoped_base_class ! 278: %type <ttype> forhead.1 identifier_or_opname operator_name ! 279: %type <ttype> new delete object object_star aggr ! 280: /* %type <ttype> primary_no_id */ ! 281: %type <ttype> nonmomentary_expr ! 282: %type <itype> forhead.2 initdcl0 notype_initdcl0 member_init_list ! 283: %type <itype> .scope try ansi_try ! 284: %type <ttype> template_header template_parm_list template_parm ! 285: %type <ttype> template_type template_arg_list template_arg ! 286: %type <ttype> template_instantiation template_type_name tmpl.1 tmpl.2 ! 287: %type <ttype> template_instantiate_once template_instantiate_some ! 288: %type <itype> fn_tmpl_end ! 289: /* %type <itype> try_for_typename */ ! 290: %type <ttype> condition partially_scoped_stmt xcond paren_cond_or_null ! 291: %type <strtype> .kindof_pushlevel ! 292: ! 293: /* in order to recognize aggr tags as defining and thus shadowing. */ ! 294: %token TYPENAME_DEFN IDENTIFIER_DEFN PTYPENAME_DEFN ! 295: %type <ttype> named_class_head_sans_basetype_defn ! 296: %type <ttype> identifier_defn IDENTIFIER_DEFN TYPENAME_DEFN PTYPENAME_DEFN ! 297: ! 298: %type <strtype> .pushlevel ! 299: ! 300: %ifobjc ! 301: /* the Objective-C productions */ ! 302: %type <ttype> ivar_decl_list ivar_decls ivar_decl ivars ivar_declarator ! 303: %type <ttype> methoddecl unaryselector keywordselector selector methodtype ! 304: %type <ttype> keyworddecl receiver objcmessageexpr messageargs ! 305: %type <ttype> keywordexpr keywordarglist keywordarg reservedword ! 306: %type <ttype> myparms myparm optparmlist objcselectorexpr ! 307: %type <ttype> selectorarg keywordnamelist keywordname objcencodeexpr ! 308: %type <ttype> objc_string protocolrefs identifier_list identifier_colon ! 309: %type <ttype> objcprotocolexpr CLASSNAME OBJC_STRING OBJECTNAME ! 310: %type <ttype> objc_openbracket.expr objc_closebracket ! 311: %endifobjc ! 312: ! 313: /* cp-spew.c depends on this being the last token. Define ! 314: any new tokens before this one! */ ! 315: %token END_OF_SAVED_INPUT ! 316: ! 317: %{ ! 318: /* List of types and structure classes of the current declaration. */ ! 319: static tree current_declspecs; ! 320: ! 321: /* When defining an aggregate, this is the most recent one being defined. */ ! 322: static tree current_aggr; ! 323: ! 324: %ifobjc ! 325: /* List of Objective-C specific information */ ! 326: ! 327: static tree objc_interface_context; ! 328: tree objc_implementation_context; ! 329: tree objc_method_context; ! 330: tree objc_ivar_chain; ! 331: static tree objc_ivar_context; ! 332: static enum tree_code objc_inherit_code; ! 333: int objc_receiver_context = 0; ! 334: int objc_declarator_context = 0; ! 335: int objc_msg_context = 0; ! 336: static int objc_public_flag; ! 337: ! 338: extern char *token_buffer; ! 339: ! 340: tree current_objc_implementation_context (void) ! 341: { ! 342: return objc_implementation_context; ! 343: } ! 344: %endifobjc ! 345: ! 346: /* Tell yyparse how to print a token's value, if yydebug is set. */ ! 347: ! 348: #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL) ! 349: extern void yyprint (); ! 350: extern tree combine_strings PROTO((tree)); ! 351: extern tree truthvalue_conversion PROTO((tree)); ! 352: %} ! 353: ! 354: %% ! 355: program: /* empty */ ! 356: %ifobjc ! 357: { objc_finish (); } ! 358: %endifobjc ! 359: | extdefs ! 360: { ! 361: /* In case there were missing closebraces, ! 362: get us back to the global binding level. */ ! 363: while (! global_bindings_p ()) ! 364: poplevel (0, 0, 0); ! 365: finish_file (); ! 366: %ifobjc ! 367: objc_finish (); ! 368: %endifobjc ! 369: } ! 370: ; ! 371: ! 372: /* the reason for the strange actions in this rule ! 373: is so that notype_initdecls when reached via datadef ! 374: can find a valid list of type and sc specs in $0. */ ! 375: ! 376: extdefs: ! 377: { $<ttype>$ = NULL_TREE; } extdef ! 378: {$<ttype>$ = NULL_TREE; } ! 379: | extdefs extdef ! 380: {$<ttype>$ = NULL_TREE; } ! 381: ; ! 382: ! 383: .hush_warning: ! 384: { have_extern_spec = 1; ! 385: used_extern_spec = 0; ! 386: $<ttype>$ = NULL_TREE; } ! 387: ; ! 388: .warning_ok: ! 389: { have_extern_spec = 0; } ! 390: ; ! 391: ! 392: asm_keyword: ! 393: ASM_KEYWORD { if (pedantic) ! 394: pedwarn ("ANSI C++ forbids use of `asm' keyword"); } ! 395: | GCC_ASM_KEYWORD ! 396: ; ! 397: ! 398: extdef: ! 399: fndef ! 400: { if (pending_inlines) do_pending_inlines (); } ! 401: | datadef ! 402: { if (pending_inlines) do_pending_inlines (); } ! 403: %ifobjc ! 404: | objcdef ! 405: %endifobjc ! 406: | template_def ! 407: { if (pending_inlines) do_pending_inlines (); } ! 408: | overloaddef ! 409: | asm_keyword '(' string ')' ';' ! 410: { if (TREE_CHAIN ($3)) $3 = combine_strings ($3); ! 411: assemble_asm ($3); } ! 412: | extern_lang_string '{' extdefs '}' ! 413: { pop_lang_context (); } ! 414: | extern_lang_string '{' '}' ! 415: { pop_lang_context (); } ! 416: | extern_lang_string .hush_warning fndef .warning_ok ! 417: { if (pending_inlines) do_pending_inlines (); ! 418: pop_lang_context (); } ! 419: | extern_lang_string .hush_warning datadef .warning_ok ! 420: { if (pending_inlines) do_pending_inlines (); ! 421: pop_lang_context (); } ! 422: ; ! 423: ! 424: extern_lang_string: ! 425: EXTERN_LANG_STRING ! 426: { push_lang_context ($1); } ! 427: ; ! 428: ! 429: template_header: ! 430: TEMPLATE '<' ! 431: { begin_template_parm_list (); } ! 432: template_parm_list '>' ! 433: { $$ = end_template_parm_list ($4); } ! 434: ; ! 435: ! 436: template_parm_list: ! 437: template_parm ! 438: { $$ = process_template_parm (NULL_TREE, $1); } ! 439: | template_parm_list ',' template_parm ! 440: { $$ = process_template_parm ($1, $3); } ! 441: ; ! 442: ! 443: template_parm: ! 444: /* The following rules introduce a new reduce/reduce ! 445: conflict: they are valid prefixes for a `structsp', ! 446: which means they could match a nameless parameter. ! 447: By putting them before the `parm' rule, we get ! 448: their match before considering them nameless parameter ! 449: declarations. */ ! 450: aggr identifier ! 451: { ! 452: if ($1 != class_type_node) ! 453: error ("template type parameter must use keyword `class'"); ! 454: $$ = build_tree_list ($2, NULL_TREE); ! 455: } ! 456: | aggr identifier_defn ':' base_class.1 ! 457: { ! 458: if ($1 != class_type_node) ! 459: error ("template type parameter must use keyword `class'"); ! 460: warning ("restricted template type parameters not yet implemented"); ! 461: $$ = build_tree_list ($2, $4); ! 462: } ! 463: | aggr TYPENAME_COLON base_class.1 ! 464: { ! 465: if ($1 != class_type_node) ! 466: error ("template type parameter must use keyword `class'"); ! 467: warning ("restricted template type parameters not yet implemented"); ! 468: $$ = build_tree_list ($2, $3); ! 469: } ! 470: | parm ! 471: ; ! 472: ! 473: overloaddef: ! 474: OVERLOAD ov_identifiers ';' ! 475: { warning ("use of `overload' is an anachronism"); } ! 476: ; ! 477: ! 478: ov_identifiers: IDENTIFIER ! 479: { declare_overloaded ($1); } ! 480: | ov_identifiers ',' IDENTIFIER ! 481: { declare_overloaded ($3); } ! 482: ; ! 483: ! 484: template_def: ! 485: /* Class template declarations go here; they aren't normal class ! 486: declarations, because we can't process the bodies yet. */ ! 487: template_header named_class_head_sans_basetype '{' ! 488: { yychar = '{'; goto template1; } ! 489: ';' ! 490: | template_header named_class_head_sans_basetype_defn '{' ! 491: { yychar = '{'; goto template1; } ! 492: ';' ! 493: | template_header named_class_head_sans_basetype ':' ! 494: { yychar = ':'; goto template1; } ! 495: ';' ! 496: | template_header named_class_head_sans_basetype_defn ':' ! 497: { ! 498: yychar = ':'; ! 499: template1: ! 500: if (current_aggr == exception_type_node) ! 501: error ("template type must define an aggregate or union"); ! 502: /* Maybe pedantic warning for union? ! 503: How about an enum? :-) */ ! 504: end_template_decl ($1, $2, current_aggr); ! 505: reinit_parse_for_template (yychar, $1, $2); ! 506: yychar = YYEMPTY; ! 507: } ! 508: ';' ! 509: | template_header named_class_head_sans_basetype ';' ! 510: { ! 511: end_template_decl ($1, $2, current_aggr); ! 512: /* declare $2 as template name with $1 parm list */ ! 513: } ! 514: | template_header named_class_head_sans_basetype_defn ';' ! 515: { ! 516: end_template_decl ($1, $2, current_aggr); ! 517: /* declare $2 as template name with $1 parm list */ ! 518: } ! 519: | template_header /* notype_initdcl0 ';' */ ! 520: notype_declarator maybe_raises maybeasm maybe_attribute ! 521: fn_tmpl_end ! 522: { ! 523: tree d; ! 524: int momentary; ! 525: momentary = suspend_momentary (); ! 526: d = start_decl ($<ttype>2, /*current_declspecs*/NULL_TREE, 0, $3); ! 527: cplus_decl_attributes (d, $5); ! 528: finish_decl (d, NULL_TREE, $4, 0); ! 529: end_template_decl ($1, d, 0); ! 530: if ($6 != ';') ! 531: reinit_parse_for_template ((int) $6, $1, d); ! 532: resume_momentary (momentary); ! 533: } ! 534: | template_header typed_declspecs /*initdcl0*/ ! 535: declarator maybe_raises maybeasm maybe_attribute ! 536: fn_tmpl_end ! 537: { ! 538: tree d; ! 539: int momentary; ! 540: ! 541: current_declspecs = $2; ! 542: momentary = suspend_momentary (); ! 543: d = start_decl ($<ttype>3, current_declspecs, ! 544: 0, $<ttype>4); ! 545: cplus_decl_attributes (d, $6); ! 546: finish_decl (d, NULL_TREE, $5, 0); ! 547: end_exception_decls (); ! 548: end_template_decl ($1, d, 0); ! 549: if ($7 != ';') ! 550: { ! 551: reinit_parse_for_template ((int) $7, $1, d); ! 552: yychar = YYEMPTY; ! 553: } ! 554: note_list_got_semicolon ($<ttype>2); ! 555: resume_momentary (momentary); ! 556: } ! 557: | template_header declmods declarator fn_tmpl_end ! 558: { ! 559: tree d = start_decl ($<ttype>3, $<ttype>2, 0, NULL_TREE); ! 560: finish_decl (d, NULL_TREE, NULL_TREE, 0); ! 561: end_template_decl ($1, d, 0); ! 562: if ($4 != ';') ! 563: reinit_parse_for_template ((int) $4, $1, d); ! 564: } ! 565: /* Try to recover from syntax errors in templates. */ ! 566: | template_header error '}' { end_template_decl ($1, 0, 0); } ! 567: | template_header error ';' { end_template_decl ($1, 0, 0); } ! 568: ; ! 569: ! 570: fn_tmpl_end: '{' { $$ = '{'; } ! 571: | ':' { $$ = ':'; } ! 572: | ';' { $$ = ';'; } ! 573: | '=' { $$ = '='; } ! 574: | RETURN { $$ = RETURN; } ! 575: ; ! 576: ! 577: datadef: ! 578: notype_initdecls ';' ! 579: { if (pedantic) ! 580: pedwarn ("ANSI C++ forbids data definition with no type or storage class"); ! 581: else if (! flag_traditional && ! have_extern_spec) ! 582: warning ("data definition has no type or storage class"); } ! 583: | declmods notype_initdecls ';' ! 584: {} ! 585: /* Normal case to make fast: "int i;". */ ! 586: | declmods declarator ';' ! 587: { tree d; ! 588: d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE); ! 589: finish_decl (d, NULL_TREE, NULL_TREE, 0); ! 590: } ! 591: | typed_declspecs initdecls ';' ! 592: { ! 593: end_exception_decls (); ! 594: note_list_got_semicolon ($<ttype>$); ! 595: } ! 596: /* Normal case: make this fast. */ ! 597: | typed_declspecs declarator ';' ! 598: { tree d; ! 599: d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE); ! 600: finish_decl (d, NULL_TREE, NULL_TREE, 0); ! 601: end_exception_decls (); ! 602: note_list_got_semicolon ($<ttype>$); ! 603: } ! 604: | declmods ';' ! 605: { pedwarn ("empty declaration"); } ! 606: | typed_declspecs ';' ! 607: { ! 608: tree t = $<ttype>$; ! 609: shadow_tag (t); ! 610: if (TREE_CODE (t) == TREE_LIST ! 611: && TREE_PURPOSE (t) == NULL_TREE) ! 612: { ! 613: t = TREE_VALUE (t); ! 614: if (TREE_CODE (t) == RECORD_TYPE ! 615: && TYPE_SIZE (t) ! 616: && CLASSTYPE_USE_TEMPLATE (t) == 0) ! 617: CLASSTYPE_USE_TEMPLATE (t) = 2; ! 618: else if (TREE_CODE (t) == ENUMERAL_TYPE ! 619: && !TYPE_SIZE (t)) ! 620: cp_error ("forward declaration of `%#T'", t); ! 621: } ! 622: note_list_got_semicolon ($<ttype>$); ! 623: } ! 624: | error ';' ! 625: | error '}' ! 626: | ';' ! 627: ; ! 628: ! 629: fndef: ! 630: fn.def1 base_init compstmt_or_error ! 631: { ! 632: finish_function (lineno, 1); ! 633: /* finish_function performs these three statements: ! 634: ! 635: expand_end_bindings (getdecls (), 1, 0); ! 636: poplevel (1, 1, 0); ! 637: ! 638: expand_end_bindings (0, 0, 0); ! 639: poplevel (0, 0, 1); ! 640: */ ! 641: if ($<ttype>$) process_next_inline ($<ttype>$); ! 642: } ! 643: | fn.def1 return_init base_init compstmt_or_error ! 644: { ! 645: finish_function (lineno, 1); ! 646: /* finish_function performs these three statements: ! 647: ! 648: expand_end_bindings (getdecls (), 1, 0); ! 649: poplevel (1, 1, 0); ! 650: ! 651: expand_end_bindings (0, 0, 0); ! 652: poplevel (0, 0, 1); ! 653: */ ! 654: if ($<ttype>$) process_next_inline ($<ttype>$); ! 655: } ! 656: | fn.def1 nodecls compstmt_or_error ! 657: { finish_function (lineno, 0); ! 658: if ($<ttype>$) process_next_inline ($<ttype>$); } ! 659: | fn.def1 return_init ';' nodecls compstmt_or_error ! 660: { finish_function (lineno, 0); ! 661: if ($<ttype>$) process_next_inline ($<ttype>$); } ! 662: | fn.def1 return_init nodecls compstmt_or_error ! 663: { finish_function (lineno, 0); ! 664: if ($<ttype>$) process_next_inline ($<ttype>$); } ! 665: | typed_declspecs declarator error ! 666: {} ! 667: | declmods notype_declarator error ! 668: {} ! 669: | notype_declarator error ! 670: {} ! 671: ; ! 672: ! 673: fn.def1: ! 674: typed_declspecs declarator maybe_raises ! 675: { if (! start_function ($$, $2, $3, 0)) ! 676: YYERROR1; ! 677: reinit_parse_for_function (); ! 678: $$ = NULL_TREE; } ! 679: | declmods notype_declarator maybe_raises ! 680: { if (! start_function ($$, $2, $3, 0)) ! 681: YYERROR1; ! 682: reinit_parse_for_function (); ! 683: $$ = NULL_TREE; } ! 684: | notype_declarator maybe_raises ! 685: { if (! start_function (NULL_TREE, $$, $2, 0)) ! 686: YYERROR1; ! 687: reinit_parse_for_function (); ! 688: $$ = NULL_TREE; } ! 689: | TYPENAME '(' parmlist ')' type_quals maybe_raises ! 690: { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, $3, $5), $6, 0)) ! 691: YYERROR1; ! 692: reinit_parse_for_function (); ! 693: $$ = NULL_TREE; } ! 694: | scoped_typename '(' parmlist ')' type_quals maybe_raises ! 695: { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, $3, $5), $6, 0)) ! 696: YYERROR1; ! 697: reinit_parse_for_function (); ! 698: $$ = NULL_TREE; } ! 699: | TYPENAME LEFT_RIGHT type_quals maybe_raises ! 700: { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, empty_parms (), $3), $4, 0)) ! 701: YYERROR1; ! 702: reinit_parse_for_function (); ! 703: $$ = NULL_TREE; } ! 704: | scoped_typename LEFT_RIGHT type_quals maybe_raises ! 705: { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, empty_parms (), $3), $4, 0)) ! 706: YYERROR1; ! 707: reinit_parse_for_function (); ! 708: $$ = NULL_TREE; } ! 709: | PRE_PARSED_FUNCTION_DECL ! 710: { start_function (NULL_TREE, TREE_VALUE ($$), NULL_TREE, 1); ! 711: reinit_parse_for_function (); } ! 712: ; ! 713: ! 714: /* more C++ complexity */ ! 715: fn.def2: ! 716: typed_declspecs '(' parmlist ')' type_quals maybe_raises ! 717: { ! 718: tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), $3, $5); ! 719: $$ = start_method (TREE_CHAIN ($$), decl, $6); ! 720: if (! $$) ! 721: YYERROR1; ! 722: if (yychar == YYEMPTY) ! 723: yychar = YYLEX; ! 724: reinit_parse_for_method (yychar, $$); } ! 725: | typed_declspecs LEFT_RIGHT type_quals maybe_raises ! 726: { ! 727: tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), empty_parms (), $3); ! 728: $$ = start_method (TREE_CHAIN ($$), decl, $4); ! 729: if (! $$) ! 730: YYERROR1; ! 731: if (yychar == YYEMPTY) ! 732: yychar = YYLEX; ! 733: reinit_parse_for_method (yychar, $$); } ! 734: | typed_declspecs declarator maybe_raises ! 735: { $$ = start_method ($$, $2, $3); ! 736: if (! $$) ! 737: YYERROR1; ! 738: if (yychar == YYEMPTY) ! 739: yychar = YYLEX; ! 740: reinit_parse_for_method (yychar, $$); } ! 741: | declmods '(' parmlist ')' type_quals maybe_raises ! 742: { ! 743: tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), $3, $5); ! 744: $$ = start_method (TREE_CHAIN ($$), decl, $6); ! 745: if (! $$) ! 746: YYERROR1; ! 747: if (yychar == YYEMPTY) ! 748: yychar = YYLEX; ! 749: reinit_parse_for_method (yychar, $$); } ! 750: | declmods LEFT_RIGHT type_quals maybe_raises ! 751: { ! 752: tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), empty_parms (), $3); ! 753: $$ = start_method (TREE_CHAIN ($$), decl, $4); ! 754: if (! $$) ! 755: YYERROR1; ! 756: if (yychar == YYEMPTY) ! 757: yychar = YYLEX; ! 758: reinit_parse_for_method (yychar, $$); } ! 759: | declmods declarator maybe_raises ! 760: { $$ = start_method ($$, $2, $3); ! 761: if (! $$) ! 762: YYERROR1; ! 763: if (yychar == YYEMPTY) ! 764: yychar = YYLEX; ! 765: reinit_parse_for_method (yychar, $$); } ! 766: | notype_declarator maybe_raises ! 767: { $$ = start_method (NULL_TREE, $$, $2); ! 768: if (! $$) ! 769: YYERROR1; ! 770: if (yychar == YYEMPTY) ! 771: yychar = YYLEX; ! 772: reinit_parse_for_method (yychar, $$); } ! 773: ; ! 774: ! 775: return_id: RETURN IDENTIFIER ! 776: { ! 777: if (! current_function_parms_stored) ! 778: store_parm_decls (); ! 779: $$ = $2; ! 780: } ! 781: ; ! 782: ! 783: return_init: return_id ! 784: { store_return_init ($<ttype>$, NULL_TREE); } ! 785: | return_id '=' init ! 786: { store_return_init ($<ttype>$, $3); } ! 787: | return_id '(' nonnull_exprlist ')' ! 788: { store_return_init ($<ttype>$, $3); } ! 789: | return_id LEFT_RIGHT ! 790: { store_return_init ($<ttype>$, NULL_TREE); } ! 791: ; ! 792: ! 793: base_init: ! 794: ':' .set_base_init member_init_list ! 795: { ! 796: if ($3 == 0) ! 797: error ("no base initializers given following ':'"); ! 798: setup_vtbl_ptr (); ! 799: /* Always keep the BLOCK node associated with the outermost ! 800: pair of curley braces of a function. These are needed ! 801: for correct operation of dwarfout.c. */ ! 802: keep_next_level (); ! 803: } ! 804: ; ! 805: ! 806: .set_base_init: ! 807: /* empty */ ! 808: { ! 809: if (! current_function_parms_stored) ! 810: store_parm_decls (); ! 811: ! 812: /* Flag that we are processing base and member initializers. */ ! 813: current_vtable_decl = error_mark_node; ! 814: ! 815: if (DECL_CONSTRUCTOR_P (current_function_decl)) ! 816: { ! 817: /* Make a contour for the initializer list. */ ! 818: pushlevel (0); ! 819: clear_last_expr (); ! 820: expand_start_bindings (0); ! 821: } ! 822: else if (current_class_type == NULL_TREE) ! 823: error ("base initializers not allowed for non-member functions"); ! 824: else if (! DECL_CONSTRUCTOR_P (current_function_decl)) ! 825: error ("only constructors take base initializers"); ! 826: } ! 827: ; ! 828: ! 829: member_init_list: ! 830: /* empty */ ! 831: { $$ = 0; } ! 832: | member_init ! 833: { $$ = 1; } ! 834: | member_init_list ',' member_init ! 835: | member_init_list error ! 836: ; ! 837: ! 838: member_init: '(' nonnull_exprlist ')' ! 839: { ! 840: if (current_class_name && !flag_traditional) ! 841: pedwarn ("ANSI C++ forbids old style base class initialization", ! 842: IDENTIFIER_POINTER (current_class_name)); ! 843: expand_member_init (C_C_D, NULL_TREE, $2); ! 844: } ! 845: | LEFT_RIGHT ! 846: { ! 847: if (current_class_name && !flag_traditional) ! 848: pedwarn ("ANSI C++ forbids old style base class initialization", ! 849: IDENTIFIER_POINTER (current_class_name)); ! 850: expand_member_init (C_C_D, NULL_TREE, void_type_node); ! 851: } ! 852: | identifier '(' nonnull_exprlist ')' ! 853: { ! 854: expand_member_init (C_C_D, $<ttype>$, $3); ! 855: } ! 856: | identifier LEFT_RIGHT ! 857: { expand_member_init (C_C_D, $<ttype>$, void_type_node); } ! 858: | template_type_name '(' nonnull_exprlist ')' ! 859: { expand_member_init (C_C_D, $<ttype>$, $3); } ! 860: | template_type_name LEFT_RIGHT ! 861: { expand_member_init (C_C_D, $<ttype>$, void_type_node); } ! 862: | scoped_typename '(' nonnull_exprlist ')' ! 863: { expand_member_init (C_C_D, $<ttype>$, $3); } ! 864: | scoped_typename LEFT_RIGHT ! 865: { expand_member_init (C_C_D, $<ttype>$, void_type_node); } ! 866: | id_scope identifier '(' nonnull_exprlist ')' ! 867: { ! 868: do_member_init ($<ttype>$, $2, $4); ! 869: } ! 870: | id_scope identifier LEFT_RIGHT ! 871: { ! 872: do_member_init ($<ttype>$, $2, void_type_node); ! 873: } ! 874: ; ! 875: ! 876: identifier: ! 877: IDENTIFIER ! 878: | TYPENAME ! 879: | PTYPENAME ! 880: %ifobjc ! 881: | OBJECTNAME ! 882: | CLASSNAME ! 883: %endifobjc ! 884: ; ! 885: ! 886: identifier_defn: ! 887: IDENTIFIER_DEFN ! 888: | TYPENAME_DEFN ! 889: | PTYPENAME_DEFN ! 890: ; ! 891: ! 892: identifier_or_opname: ! 893: IDENTIFIER ! 894: | TYPENAME ! 895: | PTYPENAME ! 896: %ifobjc ! 897: | OBJECTNAME ! 898: | CLASSNAME ! 899: %endifobjc ! 900: /* | '~' TYPENAME ! 901: { $$ = build_parse_node (BIT_NOT_EXPR, $2); }*/ ! 902: /* get rid of the next line, replace it with the above */ ! 903: | '~' identifier { $$ = build_parse_node (BIT_NOT_EXPR,$2);} ! 904: | operator_name ! 905: ; ! 906: ! 907: template_type: ! 908: template_type_name tmpl.1 template_instantiation ! 909: { ! 910: extern tree template_type_seen_before_scope; ! 911: ! 912: if ($3) ! 913: $$ = $3; ! 914: else if ($$ != error_mark_node) ! 915: $$ = IDENTIFIER_TYPE_VALUE ($$); ! 916: /* This is a kludge: In order to detect nested types inside ! 917: * template classes, we have to tell the lexer that it should ! 918: * try to replace a following SCOPE token with the correct ! 919: * SCOPED_TYPENAME for the nested type. This SCOPED_TYPENAME ! 920: * token will be handled in the rule "scoped_typename". ! 921: * - [email protected] */ ! 922: if (yychar == SCOPE) ! 923: { ! 924: /* We set template_type_seen_before_scope to be ! 925: an error_mark_node so we can avoid meaningless ! 926: and unhelpful syntax errors later. */ ! 927: if ($$ != error_mark_node) ! 928: template_type_seen_before_scope = TYPE_IDENTIFIER ($$); ! 929: else ! 930: template_type_seen_before_scope = error_mark_node; ! 931: yychar = YYLEX; ! 932: } ! 933: } ! 934: ; ! 935: ! 936: template_type_name: ! 937: PTYPENAME '<' template_arg_list '>' ! 938: { $$ = lookup_template_class ($$, $3, NULL_TREE); } ! 939: | TYPENAME '<' template_arg_list '>' ! 940: { $$ = lookup_template_class ($$, $3, NULL_TREE); } ! 941: ; ! 942: ! 943: tmpl.1: ! 944: /* Expansion of template may be required, unless we're followed by ! 945: a class definition. */ ! 946: '{' { yyungetc ('{', 1); $$ = 0; } ! 947: | ':' { yyungetc (':', 1); $$ = 0; } ! 948: | /* empty */ %prec EMPTY ! 949: { $$ = instantiate_class_template ($<ttype>0, 1); } ! 950: ; ! 951: ! 952: tmpl.2: ! 953: /* Always do expansion if it hasn't been done already. */ ! 954: { $$ = instantiate_class_template ($<ttype>0, 1); } ! 955: ; ! 956: ! 957: template_arg_list: ! 958: template_arg ! 959: { $$ = build_tree_list (NULL_TREE, $$); } ! 960: | template_arg_list ',' template_arg ! 961: { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); } ! 962: ; ! 963: ! 964: template_arg: ! 965: typename ! 966: { $$ = groktypename ($$); } ! 967: | expr_no_commas %prec UNARY ! 968: ; ! 969: ! 970: template_instantiate_once: ! 971: PRE_PARSED_CLASS_DECL maybe_base_class_list ! 972: { ! 973: tree t, decl, id, tmpl; ! 974: ! 975: id = TREE_VALUE ($1); ! 976: tmpl = TREE_PURPOSE (IDENTIFIER_TEMPLATE (id)); ! 977: t = xref_tag (DECL_TEMPLATE_INFO (tmpl)->aggr, id, $2); ! 978: set_current_level_tags_transparency (1); ! 979: my_friendly_assert (TREE_CODE (t) == RECORD_TYPE ! 980: || TREE_CODE (t) == UNION_TYPE, 257); ! 981: $<ttype>$ = t; ! 982: ! 983: /* Now, put a copy of the decl in global scope, to avoid ! 984: recursive expansion. */ ! 985: decl = IDENTIFIER_LOCAL_VALUE (id); ! 986: if (!decl) ! 987: decl = IDENTIFIER_CLASS_VALUE (id); ! 988: /* Now, put a copy of the decl in global scope, to avoid ! 989: recursive expansion. */ ! 990: if (decl) ! 991: { ! 992: /* Need to copy it to clear the chain pointer, ! 993: and need to get it into permanent storage. */ ! 994: my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 258); ! 995: push_obstacks (&permanent_obstack, &permanent_obstack); ! 996: decl = copy_node (decl); ! 997: if (DECL_LANG_SPECIFIC (decl)) ! 998: copy_lang_decl (decl); ! 999: pop_obstacks (); ! 1000: pushdecl_top_level (decl); ! 1001: } ! 1002: } ! 1003: left_curly opt.component_decl_list '}' ! 1004: { ! 1005: $$ = finish_struct ($<ttype>3, $5, 0); ! 1006: ! 1007: pop_obstacks (); ! 1008: end_template_instantiation ($1, $<ttype>3); ! 1009: ! 1010: /* Now go after the methods & class data. */ ! 1011: instantiate_member_templates ($1); ! 1012: ! 1013: pop_tinst_level(); ! 1014: ! 1015: CLASSTYPE_GOT_SEMICOLON ($$) = 1; ! 1016: } ! 1017: ; ! 1018: ! 1019: template_instantiation: ! 1020: /* empty */ ! 1021: { $$ = NULL_TREE; } ! 1022: | template_instantiate_once ! 1023: { $$ = $1; } ! 1024: ; ! 1025: ! 1026: template_instantiate_some: ! 1027: /* empty */ ! 1028: { $$ = NULL_TREE; /* never used from here... */} ! 1029: | template_instantiate_once template_instantiate_some ! 1030: { $$ = $1; /*???*/ } ! 1031: ; ! 1032: ! 1033: unop: '-' ! 1034: { $$ = NEGATE_EXPR; } ! 1035: | '+' ! 1036: { $$ = CONVERT_EXPR; } ! 1037: | PLUSPLUS ! 1038: { $$ = PREINCREMENT_EXPR; } ! 1039: | MINUSMINUS ! 1040: { $$ = PREDECREMENT_EXPR; } ! 1041: | '!' ! 1042: { $$ = TRUTH_NOT_EXPR; } ! 1043: ; ! 1044: ! 1045: expr: nonnull_exprlist ! 1046: { $$ = build_x_compound_expr ($$); } ! 1047: /* Ugly, but faster. */ ! 1048: | expr_no_commas ! 1049: ; ! 1050: ! 1051: paren_expr_or_null: ! 1052: LEFT_RIGHT ! 1053: { error ("ANSI C++ forbids an empty condition for `%s'", ! 1054: cond_stmt_keyword); ! 1055: $$ = integer_zero_node; } ! 1056: | '(' expr ')' ! 1057: { $$ = $2; } ! 1058: ; ! 1059: ! 1060: paren_cond_or_null: ! 1061: LEFT_RIGHT ! 1062: { error ("ANSI C++ forbids an empty condition for `%s'", ! 1063: cond_stmt_keyword); ! 1064: $$ = integer_zero_node; } ! 1065: | '(' condition ')' ! 1066: { $$ = $2; } ! 1067: ; ! 1068: ! 1069: xcond: ! 1070: /* empty */ ! 1071: { $$ = NULL_TREE; } ! 1072: | condition ! 1073: | error ! 1074: { $$ = NULL_TREE; } ! 1075: ; ! 1076: ! 1077: condition: ! 1078: typed_typespecs declarator maybe_raises maybeasm maybe_attribute '=' ! 1079: { { ! 1080: tree d; ! 1081: for (d = getdecls (); d; d = TREE_CHAIN (d)) ! 1082: if (TREE_CODE (d) == TYPE_DECL) { ! 1083: tree s = TREE_TYPE (d); ! 1084: if (TREE_CODE (s) == RECORD_TYPE) ! 1085: cp_error ("definition of class `%T' in condition", s); ! 1086: else if (TREE_CODE (s) == ENUMERAL_TYPE) ! 1087: cp_error ("definition of enum `%T' in condition", s); ! 1088: } ! 1089: } ! 1090: current_declspecs = $1; ! 1091: $<itype>6 = suspend_momentary (); ! 1092: $<ttype>$ = start_decl ($<ttype>2, current_declspecs, 1, $3); ! 1093: cplus_decl_attributes ($<ttype>$, $5); ! 1094: } ! 1095: init ! 1096: { ! 1097: finish_decl ($<ttype>7, $8, $5, 0); ! 1098: resume_momentary ($<itype>6); ! 1099: $$ = $<ttype>7; ! 1100: if (TREE_CODE (TREE_TYPE ($$)) == ARRAY_TYPE) ! 1101: cp_error ("definition of array `%#D' in condition", $$); ! 1102: } ! 1103: | expr ! 1104: ; ! 1105: ! 1106: /* Used for the blocks controlled by a condition, to add any DECLs in ! 1107: the condition to the controlled block. */ ! 1108: .kindof_pushlevel: /* empty */ ! 1109: { tree d = getdecls (); ! 1110: emit_line_note (input_filename, lineno); ! 1111: pushlevel (0); ! 1112: clear_last_expr (); ! 1113: push_momentary (); ! 1114: expand_start_bindings (0); ! 1115: if (d) pushdecl (d); ! 1116: } ! 1117: ; ! 1118: ! 1119: /* Like implicitly_scoped_stmt, but uses .kindof_pushlevel */ ! 1120: partially_scoped_stmt: ! 1121: '{' .kindof_pushlevel '}' ! 1122: { pop_implicit_try_blocks (NULL_TREE); ! 1123: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 1124: $$ = poplevel (kept_level_p (), 1, 0); ! 1125: pop_momentary (); ! 1126: finish_stmt (); } ! 1127: | '{' .kindof_pushlevel maybe_label_decls stmts '}' ! 1128: { pop_implicit_try_blocks (NULL_TREE); ! 1129: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 1130: $$ = poplevel (kept_level_p (), 1, 0); ! 1131: pop_momentary (); ! 1132: finish_stmt (); } ! 1133: | '{' .kindof_pushlevel maybe_label_decls error '}' ! 1134: { pop_implicit_try_blocks (NULL_TREE); ! 1135: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 1136: $$ = poplevel (kept_level_p (), 0, 0); ! 1137: pop_momentary (); ! 1138: finish_stmt (); } ! 1139: | .kindof_pushlevel simple_stmt ! 1140: { pop_implicit_try_blocks (NULL_TREE); ! 1141: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 1142: $$ = poplevel (kept_level_p (), 1, 0); ! 1143: pop_momentary (); } ! 1144: ; ! 1145: ! 1146: already_scoped_stmt: ! 1147: '{' '}' ! 1148: { finish_stmt (); } ! 1149: | '{' maybe_label_decls stmts '}' ! 1150: { finish_stmt (); } ! 1151: | '{' maybe_label_decls error '}' ! 1152: { finish_stmt (); } ! 1153: | simple_stmt ! 1154: ; ! 1155: ! 1156: nonnull_exprlist: ! 1157: expr_no_commas ! 1158: { $$ = build_tree_list (NULL_TREE, $$); } ! 1159: | nonnull_exprlist ',' expr_no_commas ! 1160: { chainon ($$, build_tree_list (NULL_TREE, $3)); } ! 1161: | nonnull_exprlist ',' error ! 1162: { chainon ($$, build_tree_list (NULL_TREE, error_mark_node)); } ! 1163: ; ! 1164: ! 1165: unary_expr: ! 1166: primary %prec UNARY ! 1167: { ! 1168: if (TREE_CODE ($$) == TYPE_EXPR) ! 1169: $$ = build_component_type_expr (C_C_D, $$, NULL_TREE, 1); ! 1170: } ! 1171: /* __extension__ turns off -pedantic for following primary. */ ! 1172: | EXTENSION ! 1173: { $<itype>1 = pedantic; ! 1174: pedantic = 0; } ! 1175: cast_expr %prec UNARY ! 1176: { $$ = $3; ! 1177: pedantic = $<itype>1; } ! 1178: | '*' cast_expr %prec UNARY ! 1179: { $$ = build_x_indirect_ref ($2, "unary *"); } ! 1180: | '&' cast_expr %prec UNARY ! 1181: { $$ = build_x_unary_op (ADDR_EXPR, $2); } ! 1182: | '~' cast_expr %prec UNARY ! 1183: { $$ = build_x_unary_op (BIT_NOT_EXPR, $2); } ! 1184: | unop cast_expr %prec UNARY ! 1185: { $$ = build_x_unary_op ((enum tree_code) $$, $2); ! 1186: if ($1 == NEGATE_EXPR && TREE_CODE ($2) == INTEGER_CST) ! 1187: TREE_NEGATED_INT ($$) = 1; ! 1188: overflow_warning ($$); ! 1189: } ! 1190: /* Refer to the address of a label as a pointer. */ ! 1191: | ANDAND identifier ! 1192: { tree label = lookup_label ($2); ! 1193: if (label == NULL_TREE) ! 1194: $$ = null_pointer_node; ! 1195: else ! 1196: { ! 1197: TREE_USED (label) = 1; ! 1198: $$ = build1 (ADDR_EXPR, ptr_type_node, label); ! 1199: TREE_CONSTANT ($$) = 1; ! 1200: } ! 1201: } ! 1202: | SIZEOF unary_expr %prec UNARY ! 1203: { if (TREE_CODE ($2) == COMPONENT_REF ! 1204: && DECL_BIT_FIELD (TREE_OPERAND ($2, 1))) ! 1205: error ("sizeof applied to a bit-field"); ! 1206: /* ANSI says arrays and functions are converted inside comma. ! 1207: But we can't really convert them in build_compound_expr ! 1208: because that would break commas in lvalues. ! 1209: So do the conversion here if operand was a comma. */ ! 1210: if (TREE_CODE ($2) == COMPOUND_EXPR ! 1211: && (TREE_CODE (TREE_TYPE ($2)) == ARRAY_TYPE ! 1212: || TREE_CODE (TREE_TYPE ($2)) == FUNCTION_TYPE)) ! 1213: $2 = default_conversion ($2); ! 1214: else if (TREE_CODE ($2) == TREE_LIST) ! 1215: { ! 1216: tree t = TREE_VALUE ($2); ! 1217: if (t != NULL_TREE ! 1218: && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE) ! 1219: pedwarn ("ANSI C++ forbids using sizeof() on a function"); ! 1220: } ! 1221: $$ = c_sizeof (TREE_TYPE ($2)); } ! 1222: | SIZEOF '(' typename ')' %prec HYPERUNARY ! 1223: { $$ = c_sizeof (groktypename ($3)); } ! 1224: | ALIGNOF unary_expr %prec UNARY ! 1225: { $$ = grok_alignof ($2); } ! 1226: | ALIGNOF '(' typename ')' %prec HYPERUNARY ! 1227: { $$ = c_alignof (groktypename ($3)); } ! 1228: ! 1229: | .scope new typename %prec '=' ! 1230: { $$ = build_new ($2, $3, NULL_TREE, $$ != NULL_TREE); } ! 1231: | .scope new '(' nonnull_exprlist ')' typename %prec '=' ! 1232: { $$ = build_new ($4, $6, NULL_TREE, $$ != NULL_TREE); } ! 1233: | .scope new typespec '(' nonnull_exprlist ')' ! 1234: { $$ = build_new ($2, $3, $5, $$ != NULL_TREE); } ! 1235: | .scope new typespec '(' typespec ')' ! 1236: { cp_error ("`%T' is not a valid expression", $5); ! 1237: $$ = error_mark_node; } ! 1238: | .scope new '(' nonnull_exprlist ')' typespec '(' nonnull_exprlist ')' ! 1239: { $$ = build_new ($4, $6, $8, $$ != NULL_TREE); } ! 1240: | .scope new typespec LEFT_RIGHT ! 1241: { $$ = build_new ($2, $3, NULL_TREE, $$ != NULL_TREE); } ! 1242: | .scope new '(' nonnull_exprlist ')' typespec LEFT_RIGHT ! 1243: { $$ = build_new ($4, $6, NULL_TREE, $$ != NULL_TREE); } ! 1244: | .scope new typename '=' init %prec '=' ! 1245: { $$ = build_new ($2, $3, $5, $$ != NULL_TREE); } ! 1246: | .scope new '(' nonnull_exprlist ')' typename '=' init %prec '=' ! 1247: { $$ = build_new ($4, $6, $8, $$ != NULL_TREE); } ! 1248: ! 1249: /* I am not going to add placement syntax to the below complex rules ! 1250: because Ken says the syntax is illegal. (mrs) */ ! 1251: /* I'm not sure why this is disallowed. But since it is, and it ! 1252: doesn't seem difficult to catch it, let's give a message, so ! 1253: the programmer can fix it. --Ken Raeburn */ ! 1254: | .scope new '(' typed_typespecs absdcl ')' '[' nonmomentary_expr ']' ! 1255: { ! 1256: tree absdcl, typename; ! 1257: ! 1258: illegal_new_array: ! 1259: absdcl = build_parse_node (ARRAY_REF, $5, $8); ! 1260: typename = build_decl_list ($4, absdcl); ! 1261: pedwarn ("ANSI C++ forbids array dimensions with parenthesized type"); ! 1262: $$ = build_new ($2, typename, NULL_TREE, $$ != NULL_TREE); ! 1263: } ! 1264: | .scope new '(' nonempty_type_quals absdcl ')' '[' nonmomentary_expr ']' ! 1265: { goto illegal_new_array; } ! 1266: ! 1267: | .scope new '(' typed_typespecs absdcl ')' ! 1268: { $$ = build_new ($2, build_decl_list ($4, $5), NULL_TREE, $$ != NULL_TREE); } ! 1269: | .scope new '(' nonnull_exprlist ')' '(' typed_typespecs absdcl ')' ! 1270: { $$ = build_new ($4, build_decl_list ($7, $8), NULL_TREE, $$ != NULL_TREE); } ! 1271: | .scope new '(' nonempty_type_quals absdcl ')' ! 1272: { $$ = build_new ($2, build_decl_list ($4, $5), NULL_TREE, $$ != NULL_TREE); } ! 1273: | .scope new '(' nonnull_exprlist ')' '(' nonempty_type_quals absdcl ')' ! 1274: { $$ = build_new ($4, build_decl_list ($7, $8), NULL_TREE, $$ != NULL_TREE); } ! 1275: /* Unswallow a ':' which is probably meant for ?: expression. */ ! 1276: | .scope new TYPENAME_COLON ! 1277: { yyungetc (':', 1); $$ = build_new ($2, $3, NULL_TREE, $$ != NULL_TREE); } ! 1278: | .scope new '(' nonnull_exprlist ')' TYPENAME_COLON ! 1279: { yyungetc (':', 1); $$ = build_new ($4, $6, NULL_TREE, $$ != NULL_TREE); } ! 1280: ! 1281: | delete cast_expr %prec UNARY ! 1282: { $$ = delete_sanity ($2, NULL_TREE, 0); } ! 1283: | delete '[' ']' cast_expr %prec UNARY ! 1284: { $$ = delete_sanity ($4, NULL_TREE, 1); ! 1285: if (yychar == YYEMPTY) ! 1286: yychar = YYLEX; } ! 1287: %ifcplus ! 1288: | delete '[' expr ']' cast_expr %prec UNARY ! 1289: { $$ = delete_sanity ($5, $3, 2); ! 1290: if (yychar == YYEMPTY) ! 1291: yychar = YYLEX; } ! 1292: %endifcplus ! 1293: %ifobjc ! 1294: | delete objc_openbracket.expr objc_closebracket cast_expr %prec UNARY ! 1295: { $$ = delete_sanity ($4, $2, 2); ! 1296: if (yychar == YYEMPTY) ! 1297: yychar = YYLEX; } ! 1298: %endifobjc ! 1299: ; ! 1300: ! 1301: cast_expr: ! 1302: unary_expr ! 1303: | '(' typename ')' expr_no_commas %prec UNARY ! 1304: { tree type = groktypename ($2); ! 1305: $$ = build_c_cast (type, $4); } ! 1306: | '(' typename ')' '{' initlist maybecomma '}' %prec UNARY ! 1307: { tree type = groktypename ($2); ! 1308: tree init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($5)); ! 1309: if (pedantic) ! 1310: pedwarn ("ANSI C++ forbids constructor-expressions"); ! 1311: /* Indicate that this was a GNU C constructor expression. */ ! 1312: TREE_HAS_CONSTRUCTOR (init) = 1; ! 1313: $$ = digest_init (type, init, (tree *) 0); ! 1314: if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0) ! 1315: { ! 1316: int failure = complete_array_type (type, $$, 1); ! 1317: if (failure) ! 1318: my_friendly_abort (78); ! 1319: } ! 1320: } ! 1321: | HEADOF '(' expr ')' ! 1322: { $$ = build_headof ($3); } ! 1323: | CLASSOF '(' expr ')' ! 1324: { $$ = build_classof ($3); } ! 1325: | CLASSOF '(' TYPENAME ')' ! 1326: { if (is_aggr_typedef ($3, 1)) ! 1327: { ! 1328: tree type = IDENTIFIER_TYPE_VALUE ($3); ! 1329: $$ = CLASSTYPE_DOSSIER (type); ! 1330: } ! 1331: else ! 1332: $$ = error_mark_node; ! 1333: } ! 1334: ; ! 1335: ! 1336: expr_no_commas: ! 1337: cast_expr ! 1338: | expr_no_commas '+' expr_no_commas ! 1339: { $$ = build_x_binary_op ($2, $$, $3); } ! 1340: | expr_no_commas '-' expr_no_commas ! 1341: { $$ = build_x_binary_op ($2, $$, $3); } ! 1342: | expr_no_commas '*' expr_no_commas ! 1343: { $$ = build_x_binary_op ($2, $$, $3); } ! 1344: | expr_no_commas '/' expr_no_commas ! 1345: { $$ = build_x_binary_op ($2, $$, $3); } ! 1346: | expr_no_commas '%' expr_no_commas ! 1347: { $$ = build_x_binary_op ($2, $$, $3); } ! 1348: | expr_no_commas LSHIFT expr_no_commas ! 1349: { $$ = build_x_binary_op ($2, $$, $3); } ! 1350: | expr_no_commas RSHIFT expr_no_commas ! 1351: { $$ = build_x_binary_op ($2, $$, $3); } ! 1352: | expr_no_commas ARITHCOMPARE expr_no_commas ! 1353: { $$ = build_x_binary_op ($2, $$, $3); } ! 1354: | expr_no_commas '<' expr_no_commas ! 1355: { $$ = build_x_binary_op (LT_EXPR, $$, $3); } ! 1356: | expr_no_commas '>' expr_no_commas ! 1357: { $$ = build_x_binary_op (GT_EXPR, $$, $3); } ! 1358: | expr_no_commas EQCOMPARE expr_no_commas ! 1359: { $$ = build_x_binary_op ($2, $$, $3); } ! 1360: | expr_no_commas MIN_MAX expr_no_commas ! 1361: { $$ = build_x_binary_op ($2, $$, $3); } ! 1362: | expr_no_commas '&' expr_no_commas ! 1363: { $$ = build_x_binary_op ($2, $$, $3); } ! 1364: | expr_no_commas '|' expr_no_commas ! 1365: { $$ = build_x_binary_op ($2, $$, $3); } ! 1366: | expr_no_commas '^' expr_no_commas ! 1367: { $$ = build_x_binary_op ($2, $$, $3); } ! 1368: | expr_no_commas ANDAND expr_no_commas ! 1369: { $$ = build_x_binary_op (TRUTH_ANDIF_EXPR, $$, $3); } ! 1370: | expr_no_commas OROR expr_no_commas ! 1371: { $$ = build_x_binary_op (TRUTH_ORIF_EXPR, $$, $3); } ! 1372: | expr_no_commas '?' xexpr ':' expr_no_commas ! 1373: { $$ = build_x_conditional_expr ($$, $3, $5); } ! 1374: | expr_no_commas '=' expr_no_commas ! 1375: { $$ = build_modify_expr ($$, NOP_EXPR, $3); } ! 1376: | expr_no_commas ASSIGN expr_no_commas ! 1377: { register tree rval; ! 1378: if (rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, $$, $3, ! 1379: make_node ($2))) ! 1380: $$ = rval; ! 1381: else ! 1382: $$ = build_modify_expr ($$, $2, $3); } ! 1383: | primary DOT_STAR expr_no_commas %prec UNARY ! 1384: { $$ = build_m_component_ref ($$, $3); } ! 1385: /* Handle general members. */ ! 1386: | object_star expr_no_commas %prec UNARY ! 1387: { $$ = build_x_binary_op (MEMBER_REF, $$, $2); } ! 1388: /* These extensions are not defined. The second arg to build_m_component_ref ! 1389: is old, build_m_component_ref now does an implicit ! 1390: build_indirect_ref (x, NULL_PTR) on the second argument. ! 1391: | object '&' expr_no_commas %prec UNARY ! 1392: { $$ = build_m_component_ref ($$, build_x_unary_op (ADDR_EXPR, $3)); } ! 1393: | object unop expr_no_commas %prec UNARY ! 1394: { $$ = build_m_component_ref ($$, build_x_unary_op ($2, $3)); } ! 1395: | object '(' typename ')' expr_no_commas %prec UNARY ! 1396: { tree type = groktypename ($3); ! 1397: $$ = build_m_component_ref ($$, build_c_cast (type, $5)); } ! 1398: | object primary_no_id %prec UNARY ! 1399: { $$ = build_m_component_ref ($$, $2); } ! 1400: */ ! 1401: ; ! 1402: ! 1403: primary: ! 1404: IDENTIFIER ! 1405: { $$ = do_identifier ($$); } ! 1406: | operator_name ! 1407: { ! 1408: tree op = $$; ! 1409: if (TREE_CODE (op) != IDENTIFIER_NODE) ! 1410: $$ = op; ! 1411: else ! 1412: { ! 1413: $$ = lookup_name (op, 0); ! 1414: if ($$ == NULL_TREE) ! 1415: { ! 1416: if (op != ansi_opname[ERROR_MARK]) ! 1417: error ("operator %s not defined", ! 1418: operator_name_string (op)); ! 1419: $$ = error_mark_node; ! 1420: } ! 1421: } ! 1422: } ! 1423: | CONSTANT ! 1424: | string ! 1425: { $$ = combine_strings ($$); } ! 1426: | '(' expr ')' ! 1427: { $$ = $2; } ! 1428: | '(' error ')' ! 1429: { $$ = error_mark_node; } ! 1430: | '(' ! 1431: { if (current_function_decl == 0) ! 1432: { ! 1433: error ("braced-group within expression allowed only inside a function"); ! 1434: YYERROR; ! 1435: } ! 1436: keep_next_level (); ! 1437: $<ttype>$ = expand_start_stmt_expr (); } ! 1438: compstmt ')' ! 1439: { tree rtl_exp; ! 1440: if (pedantic) ! 1441: pedwarn ("ANSI C++ forbids braced-groups within expressions"); ! 1442: rtl_exp = expand_end_stmt_expr ($<ttype>2); ! 1443: /* The statements have side effects, so the group does. */ ! 1444: TREE_SIDE_EFFECTS (rtl_exp) = 1; ! 1445: /* Make a BIND_EXPR for the BLOCK already made. */ ! 1446: $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp), ! 1447: NULL_TREE, rtl_exp, $3); ! 1448: /* Remove the block from the tree at this point. ! 1449: It gets put back at the proper place ! 1450: when the BIND_EXPR is expanded. */ ! 1451: delete_block ($3); ! 1452: } ! 1453: | primary '(' nonnull_exprlist ')' ! 1454: { /* [eichin:19911016.1902EST] */ ! 1455: $<ttype>$ = build_x_function_call ($1, $3, current_class_decl); ! 1456: /* here we instantiate_class_template as needed... */ ! 1457: do_pending_templates (); ! 1458: } template_instantiate_some { ! 1459: if (TREE_CODE ($<ttype>5) == CALL_EXPR ! 1460: && TREE_TYPE ($<ttype>5) != void_type_node) ! 1461: $$ = require_complete_type ($<ttype>5); ! 1462: else ! 1463: $$ = $<ttype>5; ! 1464: } ! 1465: | primary LEFT_RIGHT ! 1466: { ! 1467: $$ = build_x_function_call ($$, NULL_TREE, current_class_decl); ! 1468: if (TREE_CODE ($$) == CALL_EXPR ! 1469: && TREE_TYPE ($$) != void_type_node) ! 1470: $$ = require_complete_type ($$); ! 1471: } ! 1472: | primary '[' expr ']' ! 1473: { do_array: ! 1474: $$ = grok_array_decl ($$, $3); } ! 1475: | object identifier_or_opname %prec UNARY ! 1476: { $$ = build_component_ref ($$, $2, NULL_TREE, 1); } ! 1477: | object id_scope identifier_or_opname %prec UNARY ! 1478: { $$ = build_object_ref ($$, $2, $3); } ! 1479: | primary PLUSPLUS ! 1480: { /* If we get an OFFSET_REF, turn it into what it really ! 1481: means (e.g., a COMPONENT_REF). This way if we've got, ! 1482: say, a reference to a static member that's being operated ! 1483: on, we don't end up trying to find a member operator for ! 1484: the class it's in. */ ! 1485: if (TREE_CODE ($$) == OFFSET_REF) ! 1486: $$ = resolve_offset_ref ($$); ! 1487: $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); } ! 1488: | primary MINUSMINUS ! 1489: { if (TREE_CODE ($$) == OFFSET_REF) ! 1490: $$ = resolve_offset_ref ($$); ! 1491: $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); } ! 1492: /* C++ extensions */ ! 1493: | THIS ! 1494: { if (current_class_decl) ! 1495: { ! 1496: #ifdef WARNING_ABOUT_CCD ! 1497: TREE_USED (current_class_decl) = 1; ! 1498: #endif ! 1499: $$ = current_class_decl; ! 1500: } ! 1501: else if (current_function_decl ! 1502: && DECL_STATIC_FUNCTION_P (current_function_decl)) ! 1503: { ! 1504: error ("`this' is unavailable for static member functions"); ! 1505: $$ = error_mark_node; ! 1506: } ! 1507: else ! 1508: { ! 1509: if (current_function_decl) ! 1510: error ("invalid use of `this' in non-member function"); ! 1511: else ! 1512: error ("invalid use of `this' at top level"); ! 1513: $$ = error_mark_node; ! 1514: } ! 1515: } ! 1516: | TYPE_QUAL '(' nonnull_exprlist ')' ! 1517: { ! 1518: tree type; ! 1519: tree id = $$; ! 1520: ! 1521: /* This is a C cast in C++'s `functional' notation. */ ! 1522: if ($3 == error_mark_node) ! 1523: { ! 1524: $$ = error_mark_node; ! 1525: break; ! 1526: } ! 1527: #if 0 ! 1528: if ($3 == NULL_TREE) ! 1529: { ! 1530: error ("cannot cast null list to type `%s'", ! 1531: IDENTIFIER_POINTER (TYPE_NAME (id))); ! 1532: $$ = error_mark_node; ! 1533: break; ! 1534: } ! 1535: #endif ! 1536: #if 0 ! 1537: /* type is not set! (mrs) */ ! 1538: if (type == error_mark_node) ! 1539: $$ = error_mark_node; ! 1540: else ! 1541: #endif ! 1542: { ! 1543: if (id == ridpointers[(int) RID_CONST]) ! 1544: type = build_type_variant (integer_type_node, 1, 0); ! 1545: else if (id == ridpointers[(int) RID_VOLATILE]) ! 1546: type = build_type_variant (integer_type_node, 0, 1); ! 1547: #if 0 ! 1548: /* should not be able to get here (mrs) */ ! 1549: else if (id == ridpointers[(int) RID_FRIEND]) ! 1550: { ! 1551: error ("cannot cast expression to `friend' type"); ! 1552: $$ = error_mark_node; ! 1553: break; ! 1554: } ! 1555: #endif ! 1556: else my_friendly_abort (79); ! 1557: $$ = build_c_cast (type, build_compound_expr ($3)); ! 1558: } ! 1559: } ! 1560: | typespec '(' nonnull_exprlist ')' ! 1561: { $$ = build_functional_cast ($$, $3); } ! 1562: | typespec LEFT_RIGHT ! 1563: { $$ = build_functional_cast ($$, NULL_TREE); } ! 1564: /* Stroustrup RTTI */ ! 1565: | DYNAMIC_CAST '<' typename '>' '(' expr ')' ! 1566: { tree type = groktypename ($3); ! 1567: $$ = build_dynamic_cast (type, $6); } ! 1568: | TYPEID '(' expr ')' ! 1569: { $$ = build_typeid ($3); } ! 1570: | TYPEID '(' typename ')' ! 1571: { tree type = groktypename ($3); ! 1572: $$ = get_typeid (type); } ! 1573: | SCOPE typespec '(' nonnull_exprlist ')' ! 1574: { $$ = build_functional_cast ($2, $4); } ! 1575: | SCOPE typespec LEFT_RIGHT ! 1576: { $$ = build_functional_cast ($2, NULL_TREE); } ! 1577: | SCOPE IDENTIFIER ! 1578: { ! 1579: do_scoped_id: ! 1580: $$ = IDENTIFIER_GLOBAL_VALUE ($2); ! 1581: if (yychar == YYEMPTY) ! 1582: yychar = YYLEX; ! 1583: if (! $$) ! 1584: { ! 1585: if (yychar == '(' || yychar == LEFT_RIGHT) ! 1586: $$ = implicitly_declare ($2); ! 1587: else ! 1588: { ! 1589: if (IDENTIFIER_GLOBAL_VALUE ($2) != error_mark_node) ! 1590: error ("undeclared variable `%s' (first use here)", ! 1591: IDENTIFIER_POINTER ($2)); ! 1592: $$ = error_mark_node; ! 1593: /* Prevent repeated error messages. */ ! 1594: IDENTIFIER_GLOBAL_VALUE ($2) = error_mark_node; ! 1595: } ! 1596: } ! 1597: else ! 1598: { ! 1599: if (TREE_CODE ($$) == ADDR_EXPR) ! 1600: assemble_external (TREE_OPERAND ($$, 0)); ! 1601: else ! 1602: assemble_external ($$); ! 1603: TREE_USED ($$) = 1; ! 1604: } ! 1605: if (TREE_CODE ($$) == CONST_DECL) ! 1606: { ! 1607: /* XXX CHS - should we set TREE_USED of the constant? */ ! 1608: $$ = DECL_INITIAL ($$); ! 1609: /* This is to prevent an enum whose value is 0 ! 1610: from being considered a null pointer constant. */ ! 1611: $$ = build1 (NOP_EXPR, TREE_TYPE ($$), $$); ! 1612: TREE_CONSTANT ($$) = 1; ! 1613: } ! 1614: ! 1615: } ! 1616: /* p->int::~int() is valid -- 12.4 */ ! 1617: | object '~' TYPESPEC LEFT_RIGHT ! 1618: { ! 1619: if (TREE_CODE (TREE_TYPE ($1)) ! 1620: != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($3)))) ! 1621: cp_error ("`%E' is not of type `%T'", $1, $3); ! 1622: $$ = void_zero_node; ! 1623: } ! 1624: | object TYPESPEC SCOPE '~' TYPESPEC LEFT_RIGHT ! 1625: { ! 1626: if ($2 != $5) ! 1627: cp_error ("destructor specifier `%T::~%T()' must have matching names", $2, $5); ! 1628: if (TREE_CODE (TREE_TYPE ($1)) ! 1629: != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($2)))) ! 1630: cp_error ("`%E' is not of type `%T'", $1, $2); ! 1631: $$ = void_zero_node; ! 1632: } ! 1633: | SCOPE operator_name ! 1634: { ! 1635: if (TREE_CODE ($2) == IDENTIFIER_NODE) ! 1636: goto do_scoped_id; ! 1637: do_scoped_operator: ! 1638: $$ = $2; ! 1639: } ! 1640: | id_scope identifier_or_opname %prec HYPERUNARY ! 1641: { $$ = build_offset_ref ($$, $2); } ! 1642: | id_scope identifier_or_opname '(' nonnull_exprlist ')' ! 1643: { $$ = build_member_call ($$, $2, $4); } ! 1644: | id_scope identifier_or_opname LEFT_RIGHT ! 1645: { $$ = build_member_call ($$, $2, NULL_TREE); } ! 1646: | object identifier_or_opname '(' nonnull_exprlist ')' ! 1647: { ! 1648: #if 0 ! 1649: /* This is a future direction of this code, but because ! 1650: build_x_function_call cannot always undo what is done ! 1651: in build_component_ref entirely yet, we cannot do this. */ ! 1652: $$ = build_x_function_call (build_component_ref ($$, $2, NULL_TREE, 1), $4, $$); ! 1653: if (TREE_CODE ($$) == CALL_EXPR ! 1654: && TREE_TYPE ($$) != void_type_node) ! 1655: $$ = require_complete_type ($$); ! 1656: #else ! 1657: $$ = build_method_call ($$, $2, $4, NULL_TREE, ! 1658: (LOOKUP_NORMAL|LOOKUP_AGGR)); ! 1659: #endif ! 1660: } ! 1661: | object identifier_or_opname LEFT_RIGHT ! 1662: { ! 1663: #if 0 ! 1664: /* This is a future direction of this code, but because ! 1665: build_x_function_call cannot always undo what is done ! 1666: in build_component_ref entirely yet, we cannot do this. */ ! 1667: $$ = build_x_function_call (build_component_ref ($$, $2, NULL_TREE, 1), NULL_TREE, $$); ! 1668: if (TREE_CODE ($$) == CALL_EXPR ! 1669: && TREE_TYPE ($$) != void_type_node) ! 1670: $$ = require_complete_type ($$); ! 1671: #else ! 1672: $$ = build_method_call ($$, $2, NULL_TREE, NULL_TREE, ! 1673: (LOOKUP_NORMAL|LOOKUP_AGGR)); ! 1674: #endif ! 1675: } ! 1676: | object id_scope identifier_or_opname '(' nonnull_exprlist ')' ! 1677: { $$ = build_scoped_method_call ($$, $2, $3, $5); } ! 1678: | object id_scope identifier_or_opname LEFT_RIGHT ! 1679: { $$ = build_scoped_method_call ($$, $2, $3, NULL_TREE); } ! 1680: ! 1681: %ifobjc ! 1682: /* Objective-C expressions */ ! 1683: | objcmessageexpr ! 1684: { $$ = build_message_expr ($1); } ! 1685: | objcselectorexpr ! 1686: { $$ = build_selector_expr ($1); } ! 1687: | objcprotocolexpr ! 1688: { $$ = build_protocol_expr ($1); } ! 1689: | objcencodeexpr ! 1690: { $$ = build_encode_expr ($1); } ! 1691: | objc_string ! 1692: { $$ = build_objc_string_object ($1); } ! 1693: %endifobjc ! 1694: ; ! 1695: ! 1696: /* Not needed for now. ! 1697: ! 1698: primary_no_id: ! 1699: '(' expr ')' ! 1700: { $$ = $2; } ! 1701: | '(' error ')' ! 1702: { $$ = error_mark_node; } ! 1703: | '(' ! 1704: { if (current_function_decl == 0) ! 1705: { ! 1706: error ("braced-group within expression allowed only inside a function"); ! 1707: YYERROR; ! 1708: } ! 1709: $<ttype>$ = expand_start_stmt_expr (); } ! 1710: compstmt ')' ! 1711: { if (pedantic) ! 1712: pedwarn ("ANSI C++ forbids braced-groups within expressions"); ! 1713: $$ = expand_end_stmt_expr ($<ttype>2); } ! 1714: | primary_no_id '(' nonnull_exprlist ')' ! 1715: { $$ = build_x_function_call ($$, $3, current_class_decl); } ! 1716: | primary_no_id LEFT_RIGHT ! 1717: { $$ = build_x_function_call ($$, NULL_TREE, current_class_decl); } ! 1718: | primary_no_id '[' expr ']' ! 1719: { goto do_array; } ! 1720: | primary_no_id PLUSPLUS ! 1721: { $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); } ! 1722: | primary_no_id MINUSMINUS ! 1723: { $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); } ! 1724: | SCOPE IDENTIFIER ! 1725: { goto do_scoped_id; } ! 1726: | SCOPE operator_name ! 1727: { if (TREE_CODE ($2) == IDENTIFIER_NODE) ! 1728: goto do_scoped_id; ! 1729: goto do_scoped_operator; ! 1730: } ! 1731: ; ! 1732: */ ! 1733: ! 1734: new: NEW ! 1735: { $$ = NULL_TREE; } ! 1736: | NEW '{' nonnull_exprlist '}' ! 1737: { ! 1738: $$ = $3; ! 1739: pedwarn ("old style placement syntax, use () instead"); ! 1740: } ! 1741: ; ! 1742: ! 1743: .scope: ! 1744: /* empty */ ! 1745: { $$ = 0; } ! 1746: | SCOPE ! 1747: { $$ = 1; } ! 1748: ; ! 1749: ! 1750: delete: DELETE ! 1751: { $$ = NULL_TREE; } ! 1752: | SCOPE delete ! 1753: { if ($2) ! 1754: error ("extra `::' before `delete' ignored"); ! 1755: $$ = error_mark_node; ! 1756: } ! 1757: ; ! 1758: ! 1759: /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */ ! 1760: string: ! 1761: STRING ! 1762: | string STRING ! 1763: { $$ = chainon ($$, $2); } ! 1764: ; ! 1765: ! 1766: %ifobjc ! 1767: /* Produces an OBJC_STRING_CST with perhaps more OBJC_STRING_CSTs chained ! 1768: onto it. */ ! 1769: objc_string: ! 1770: OBJC_STRING ! 1771: | objc_string OBJC_STRING ! 1772: { $$ = chainon ($1, $2); } ! 1773: ; ! 1774: %endifobjc ! 1775: ! 1776: nodecls: ! 1777: /* empty */ ! 1778: { ! 1779: if (! current_function_parms_stored) ! 1780: store_parm_decls (); ! 1781: setup_vtbl_ptr (); ! 1782: /* Always keep the BLOCK node associated with the outermost ! 1783: pair of curley braces of a function. These are needed ! 1784: for correct operation of dwarfout.c. */ ! 1785: keep_next_level (); ! 1786: } ! 1787: ; ! 1788: ! 1789: object: primary '.' ! 1790: | primary POINTSAT ! 1791: { ! 1792: $$ = build_x_arrow ($$); ! 1793: } ! 1794: ; ! 1795: ! 1796: object_star: primary POINTSAT_STAR ! 1797: ; ! 1798: ! 1799: decl: ! 1800: typed_declspecs initdecls ';' ! 1801: { ! 1802: resume_momentary ($2); ! 1803: note_list_got_semicolon ($<ttype>$); ! 1804: } ! 1805: /* Normal case: make this fast. */ ! 1806: | typed_declspecs declarator ';' ! 1807: { tree d; ! 1808: int yes = suspend_momentary (); ! 1809: d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE); ! 1810: finish_decl (d, NULL_TREE, NULL_TREE, 0); ! 1811: resume_momentary (yes); ! 1812: note_list_got_semicolon ($<ttype>$); ! 1813: } ! 1814: | declmods notype_initdecls ';' ! 1815: { resume_momentary ((int) $<itype>2); } ! 1816: /* Normal case: make this fast. */ ! 1817: | declmods declarator ';' ! 1818: { tree d; ! 1819: int yes = suspend_momentary (); ! 1820: d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE); ! 1821: finish_decl (d, NULL_TREE, NULL_TREE, 0); ! 1822: resume_momentary (yes); ! 1823: } ! 1824: | typed_declspecs ';' ! 1825: { ! 1826: shadow_tag ($<ttype>$); ! 1827: note_list_got_semicolon ($<ttype>$); ! 1828: } ! 1829: | declmods ';' ! 1830: { warning ("empty declaration"); } ! 1831: ; ! 1832: ! 1833: /* Any kind of declarator (thus, all declarators allowed ! 1834: after an explicit typespec). */ ! 1835: ! 1836: declarator: ! 1837: after_type_declarator ! 1838: | notype_declarator ! 1839: | START_DECLARATOR after_type_declarator ! 1840: { $$ = $2; } ! 1841: | START_DECLARATOR notype_declarator ! 1842: { $$ = $2; } ! 1843: ; ! 1844: ! 1845: /* Declspecs which contain at least one type specifier or typedef name. ! 1846: (Just `const' or `volatile' is not enough.) ! 1847: A typedef'd name following these is taken as a name to be declared. */ ! 1848: ! 1849: typed_declspecs: ! 1850: typespec %prec HYPERUNARY ! 1851: { if ($$) $$ = list_hash_lookup_or_cons ($$); } ! 1852: | declmods typespec ! 1853: { $$ = hash_tree_chain ($2, $$); } ! 1854: | typespec reserved_declspecs %prec HYPERUNARY ! 1855: { $$ = hash_tree_chain ($$, $2); } ! 1856: | declmods typespec reserved_declspecs ! 1857: { $$ = hash_tree_chain ($2, hash_chainon ($3, $$)); } ! 1858: ; ! 1859: ! 1860: reserved_declspecs: /* empty ! 1861: { $$ = NULL_TREE; } */ ! 1862: typespecqual_reserved ! 1863: { $$ = build_decl_list (NULL_TREE, $$); } ! 1864: | SCSPEC ! 1865: { if (extra_warnings) ! 1866: warning ("`%s' is not at beginning of declaration", ! 1867: IDENTIFIER_POINTER ($$)); ! 1868: $$ = build_decl_list (NULL_TREE, $$); } ! 1869: | reserved_declspecs typespecqual_reserved ! 1870: { $$ = decl_tree_cons (NULL_TREE, $2, $$); } ! 1871: | reserved_declspecs SCSPEC ! 1872: { if (extra_warnings) ! 1873: warning ("`%s' is not at beginning of declaration", ! 1874: IDENTIFIER_POINTER ($2)); ! 1875: $$ = decl_tree_cons (NULL_TREE, $2, $$); } ! 1876: ; ! 1877: ! 1878: /* List of just storage classes and type modifiers. ! 1879: A declaration can start with just this, but then it cannot be used ! 1880: to redeclare a typedef-name. */ ! 1881: ! 1882: declmods: ! 1883: TYPE_QUAL ! 1884: { $$ = IDENTIFIER_AS_LIST ($$); ! 1885: TREE_STATIC ($$) = 1; } ! 1886: | SCSPEC ! 1887: { $$ = IDENTIFIER_AS_LIST ($$); } ! 1888: | declmods TYPE_QUAL ! 1889: { $$ = hash_tree_chain ($2, $$); ! 1890: TREE_STATIC ($$) = 1; } ! 1891: | declmods SCSPEC ! 1892: { if (extra_warnings && TREE_STATIC ($$)) ! 1893: warning ("`%s' is not at beginning of declaration", ! 1894: IDENTIFIER_POINTER ($2)); ! 1895: $$ = hash_tree_chain ($2, $$); ! 1896: TREE_STATIC ($$) = TREE_STATIC ($1); } ! 1897: ; ! 1898: ! 1899: ! 1900: /* Used instead of declspecs where storage classes are not allowed ! 1901: (that is, for typenames and structure components). ! 1902: ! 1903: C++ can takes storage classes for structure components. ! 1904: Don't accept a typedef-name if anything but a modifier precedes it. */ ! 1905: ! 1906: typed_typespecs: ! 1907: typespec %prec EMPTY ! 1908: { $$ = get_decl_list ($$); } ! 1909: | nonempty_type_quals typespec ! 1910: { $$ = decl_tree_cons (NULL_TREE, $2, $$); } ! 1911: | typespec reserved_typespecquals ! 1912: { $$ = decl_tree_cons (NULL_TREE, $$, $2); } ! 1913: | nonempty_type_quals typespec reserved_typespecquals ! 1914: { $$ = decl_tree_cons (NULL_TREE, $2, hash_chainon ($3, $$)); } ! 1915: ; ! 1916: ! 1917: reserved_typespecquals: ! 1918: typespecqual_reserved ! 1919: { $$ = get_decl_list ($$); } ! 1920: | reserved_typespecquals typespecqual_reserved ! 1921: { $$ = decl_tree_cons (NULL_TREE, $2, $$); } ! 1922: ; ! 1923: ! 1924: /* A typespec (but not a type qualifier). ! 1925: Once we have seen one of these in a declaration, ! 1926: if a typedef name appears then it is being redeclared. */ ! 1927: ! 1928: typespec: structsp ! 1929: | TYPESPEC %prec EMPTY ! 1930: | TYPENAME %prec EMPTY ! 1931: %ifobjc ! 1932: | CLASSNAME protocolrefs ! 1933: { $$ = get_static_reference ($1, $2); } ! 1934: | OBJECTNAME protocolrefs ! 1935: { $$ = get_object_reference ($2); } ! 1936: %endifobjc ! 1937: | scoped_typename ! 1938: | TYPEOF '(' expr ')' ! 1939: { $$ = TREE_TYPE ($3); ! 1940: if (pedantic) ! 1941: pedwarn ("ANSI C++ forbids `typeof'"); } ! 1942: | TYPEOF '(' typename ')' ! 1943: { $$ = groktypename ($3); ! 1944: if (pedantic) ! 1945: pedwarn ("ANSI C++ forbids `typeof'"); } ! 1946: | template_type ! 1947: ; ! 1948: ! 1949: /* A typespec that is a reserved word, or a type qualifier. */ ! 1950: ! 1951: typespecqual_reserved: TYPESPEC ! 1952: | TYPE_QUAL ! 1953: | structsp ! 1954: ; ! 1955: ! 1956: initdecls: ! 1957: initdcl0 ! 1958: | initdecls ',' initdcl ! 1959: ; ! 1960: ! 1961: notype_initdecls: ! 1962: notype_initdcl0 ! 1963: | notype_initdecls ',' initdcl ! 1964: ; ! 1965: ! 1966: maybeasm: ! 1967: /* empty */ ! 1968: { $$ = NULL_TREE; } ! 1969: | asm_keyword '(' string ')' ! 1970: { if (TREE_CHAIN ($3)) $3 = combine_strings ($3); $$ = $3; } ! 1971: ; ! 1972: ! 1973: initdcl0: ! 1974: declarator maybe_raises maybeasm maybe_attribute '=' ! 1975: { current_declspecs = $<ttype>0; ! 1976: $<itype>5 = suspend_momentary (); ! 1977: $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2); ! 1978: cplus_decl_attributes ($<ttype>$, $4); } ! 1979: init ! 1980: /* Note how the declaration of the variable is in effect while its init is parsed! */ ! 1981: { finish_decl ($<ttype>6, $7, $3, 0); ! 1982: $$ = $<itype>5; } ! 1983: | declarator maybe_raises maybeasm maybe_attribute ! 1984: { tree d; ! 1985: current_declspecs = $<ttype>0; ! 1986: $$ = suspend_momentary (); ! 1987: d = start_decl ($<ttype>1, current_declspecs, 0, $2); ! 1988: cplus_decl_attributes (d, $4); ! 1989: finish_decl (d, NULL_TREE, $3, 0); } ! 1990: ; ! 1991: ! 1992: initdcl: ! 1993: declarator maybe_raises maybeasm maybe_attribute '=' ! 1994: { $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2); ! 1995: cplus_decl_attributes ($<ttype>$, $4); } ! 1996: init ! 1997: /* Note how the declaration of the variable is in effect while its init is parsed! */ ! 1998: { finish_decl ($<ttype>6, $7, $3, 0); } ! 1999: | declarator maybe_raises maybeasm maybe_attribute ! 2000: { tree d = start_decl ($<ttype>1, current_declspecs, 0, $2); ! 2001: cplus_decl_attributes ($<ttype>$, $4); ! 2002: finish_decl (d, NULL_TREE, $3, 0); } ! 2003: ; ! 2004: ! 2005: notype_initdcl0: ! 2006: notype_declarator maybe_raises maybeasm maybe_attribute '=' ! 2007: { current_declspecs = $<ttype>0; ! 2008: $<itype>5 = suspend_momentary (); ! 2009: $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2); ! 2010: cplus_decl_attributes ($<ttype>$, $4); } ! 2011: init ! 2012: /* Note how the declaration of the variable is in effect while its init is parsed! */ ! 2013: { finish_decl ($<ttype>6, $7, $3, 0); ! 2014: $$ = $<itype>5; } ! 2015: | notype_declarator maybe_raises maybeasm maybe_attribute ! 2016: { tree d; ! 2017: current_declspecs = $<ttype>0; ! 2018: $$ = suspend_momentary (); ! 2019: d = start_decl ($<ttype>1, current_declspecs, 0, $2); ! 2020: cplus_decl_attributes (d, $4); ! 2021: finish_decl (d, NULL_TREE, $3, 0); } ! 2022: ; ! 2023: ! 2024: /* the * rules are dummies to accept the Apollo extended syntax ! 2025: so that the header files compile. */ ! 2026: maybe_attribute: ! 2027: /* empty */ ! 2028: { $$ = NULL_TREE; } ! 2029: | ATTRIBUTE '(' '(' attribute_list ')' ')' ! 2030: { $$ = $4; } ! 2031: ; ! 2032: ! 2033: attribute_list ! 2034: : attrib ! 2035: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); } ! 2036: | attribute_list ',' attrib ! 2037: { $$ = tree_cons (NULL_TREE, $3, $1); } ! 2038: ; ! 2039: ! 2040: attrib ! 2041: : IDENTIFIER ! 2042: { if (strcmp (IDENTIFIER_POINTER ($1), "packed") ! 2043: && strcmp (IDENTIFIER_POINTER ($1), "noreturn")) ! 2044: warning ("`%s' attribute directive ignored", ! 2045: IDENTIFIER_POINTER ($1)); ! 2046: $$ = $1; } ! 2047: | IDENTIFIER '(' CONSTANT ')' ! 2048: { /* if not "aligned(n)", then issue warning */ ! 2049: if (strcmp (IDENTIFIER_POINTER ($1), "aligned") != 0 ! 2050: || TREE_CODE ($3) != INTEGER_CST) ! 2051: { ! 2052: warning ("`%s' attribute directive ignored", ! 2053: IDENTIFIER_POINTER ($1)); ! 2054: $$ = $1; ! 2055: } ! 2056: else ! 2057: $$ = tree_cons ($1, $3, NULL_TREE); } ! 2058: | IDENTIFIER '(' IDENTIFIER ',' CONSTANT ',' CONSTANT ')' ! 2059: { /* if not "format(...)", then issue warning */ ! 2060: if (strcmp (IDENTIFIER_POINTER ($1), "format") != 0 ! 2061: || TREE_CODE ($5) != INTEGER_CST ! 2062: || TREE_CODE ($7) != INTEGER_CST) ! 2063: { ! 2064: warning ("`%s' attribute directive ignored", ! 2065: IDENTIFIER_POINTER ($1)); ! 2066: $$ = $1; ! 2067: } ! 2068: else ! 2069: $$ = tree_cons ($1, tree_cons ($3, tree_cons ($5, $7, NULL_TREE), NULL_TREE), NULL_TREE); } ! 2070: ; ! 2071: ! 2072: /* A nonempty list of identifiers, including typenames. */ ! 2073: identifiers_or_typenames: ! 2074: identifier ! 2075: { $$ = build_tree_list (NULL_TREE, $1); } ! 2076: | identifiers_or_typenames ',' identifier ! 2077: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } ! 2078: ; ! 2079: ! 2080: init: ! 2081: expr_no_commas %prec '=' ! 2082: | '{' '}' ! 2083: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE); ! 2084: TREE_HAS_CONSTRUCTOR ($$) = 1; ! 2085: if (pedantic) ! 2086: pedwarn ("ANSI C++ forbids empty initializer braces"); } ! 2087: | '{' initlist '}' ! 2088: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); ! 2089: TREE_HAS_CONSTRUCTOR ($$) = 1; } ! 2090: | '{' initlist ',' '}' ! 2091: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); ! 2092: TREE_HAS_CONSTRUCTOR ($$) = 1; } ! 2093: | error ! 2094: { $$ = NULL_TREE; } ! 2095: ; ! 2096: ! 2097: /* This chain is built in reverse order, ! 2098: and put in forward order where initlist is used. */ ! 2099: initlist: ! 2100: init ! 2101: { $$ = build_tree_list (NULL_TREE, $$); } ! 2102: | initlist ',' init ! 2103: { $$ = tree_cons (NULL_TREE, $3, $$); } ! 2104: %ifcplus ! 2105: /* These are for labeled elements. */ ! 2106: | '[' expr_no_commas ']' init ! 2107: { $$ = build_tree_list ($2, $4); } ! 2108: %endifcplus ! 2109: | initlist ',' CASE expr_no_commas ':' init ! 2110: { $$ = tree_cons ($4, $6, $$); } ! 2111: | identifier ':' init ! 2112: { $$ = build_tree_list ($$, $3); } ! 2113: | initlist ',' identifier ':' init ! 2114: { $$ = tree_cons ($3, $5, $$); } ! 2115: ; ! 2116: ! 2117: structsp: ! 2118: ENUM identifier '{' ! 2119: { $<itype>3 = suspend_momentary (); ! 2120: $$ = start_enum ($2); } ! 2121: enumlist maybecomma_warn '}' ! 2122: { $$ = finish_enum ($<ttype>4, $5); ! 2123: resume_momentary ((int) $<itype>3); ! 2124: check_for_missing_semicolon ($<ttype>4); } ! 2125: | ENUM identifier '{' '}' ! 2126: { $$ = finish_enum (start_enum ($2), NULL_TREE); ! 2127: check_for_missing_semicolon ($$); } ! 2128: | ENUM '{' ! 2129: { $<itype>2 = suspend_momentary (); ! 2130: $$ = start_enum (make_anon_name ()); } ! 2131: enumlist maybecomma_warn '}' ! 2132: { $$ = finish_enum ($<ttype>3, $4); ! 2133: resume_momentary ((int) $<itype>1); ! 2134: check_for_missing_semicolon ($<ttype>3); } ! 2135: | ENUM '{' '}' ! 2136: { $$ = finish_enum (start_enum (make_anon_name()), NULL_TREE); ! 2137: check_for_missing_semicolon ($$); } ! 2138: | ENUM identifier ! 2139: { $$ = xref_tag (enum_type_node, $2, NULL_TREE); } ! 2140: ! 2141: /* C++ extensions, merged with C to avoid shift/reduce conflicts */ ! 2142: | class_head left_curly opt.component_decl_list '}' ! 2143: { ! 2144: int semi; ! 2145: tree id; ! 2146: ! 2147: #if 0 ! 2148: /* Need to rework class nesting in the ! 2149: presence of nested classes, etc. */ ! 2150: shadow_tag (CLASSTYPE_AS_LIST ($$)); */ ! 2151: #endif ! 2152: if (yychar == YYEMPTY) ! 2153: yychar = YYLEX; ! 2154: semi = yychar == ';'; ! 2155: /* finish_struct nukes this anyway; if ! 2156: finish_exception does too, then it can go. */ ! 2157: if (semi) ! 2158: note_got_semicolon ($$); ! 2159: ! 2160: if (TREE_CODE ($$) == ENUMERAL_TYPE) ! 2161: /* $$ = $1 from default rule. */; ! 2162: else if (CLASSTYPE_DECLARED_EXCEPTION ($$)) ! 2163: { ! 2164: if (! semi) ! 2165: $$ = finish_exception ($$, $3); ! 2166: else ! 2167: warning ("empty exception declaration\n"); ! 2168: } ! 2169: else ! 2170: { ! 2171: $$ = finish_struct ($$, $3, semi); ! 2172: if (semi) note_got_semicolon ($$); ! 2173: } ! 2174: ! 2175: pop_obstacks (); ! 2176: ! 2177: id = TYPE_IDENTIFIER ($$); ! 2178: if (id && IDENTIFIER_TEMPLATE (id)) ! 2179: { ! 2180: tree decl; ! 2181: ! 2182: /* I don't know if the copying of this TYPE_DECL is ! 2183: * really needed. However, it's such a small per- ! 2184: * formance penalty that the extra safety is a bargain. ! 2185: * - [email protected] ! 2186: */ ! 2187: push_obstacks (&permanent_obstack, &permanent_obstack); ! 2188: decl = copy_node (lookup_name (id, 0)); ! 2189: if (DECL_LANG_SPECIFIC (decl)) ! 2190: copy_lang_decl (decl); ! 2191: pop_obstacks (); ! 2192: undo_template_name_overload (id, 0); ! 2193: pushdecl_top_level (decl); ! 2194: } ! 2195: if (! semi) ! 2196: check_for_missing_semicolon ($$); } ! 2197: | class_head %prec EMPTY ! 2198: { ! 2199: #if 0 ! 2200: /* It's no longer clear what the following error is supposed to ! 2201: accomplish. If it turns out to be needed, add a comment why. */ ! 2202: if (TYPE_BINFO_BASETYPES ($$) && !TYPE_SIZE ($$)) ! 2203: { ! 2204: error ("incomplete definition of type `%s'", ! 2205: TYPE_NAME_STRING ($$)); ! 2206: $$ = error_mark_node; ! 2207: } ! 2208: #endif ! 2209: } ! 2210: ; ! 2211: ! 2212: maybecomma: ! 2213: /* empty */ ! 2214: | ',' ! 2215: ; ! 2216: ! 2217: maybecomma_warn: ! 2218: /* empty */ ! 2219: | ',' ! 2220: { if (pedantic) pedwarn ("comma at end of enumerator list"); } ! 2221: ; ! 2222: ! 2223: aggr: AGGR ! 2224: | aggr SCSPEC ! 2225: { error ("storage class specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); } ! 2226: | aggr TYPESPEC ! 2227: { error ("type specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); } ! 2228: | aggr TYPE_QUAL ! 2229: { error ("type qualifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); } ! 2230: | aggr AGGR ! 2231: { error ("no body nor ';' separates two class, struct or union declarations"); } ! 2232: ; ! 2233: ! 2234: named_class_head_sans_basetype: ! 2235: aggr identifier ! 2236: { aggr1: current_aggr = $$; $$ = $2; } ! 2237: | aggr template_type_name %prec EMPTY ! 2238: { current_aggr = $$; $$ = $2; } ! 2239: | aggr TYPENAME_COLON ! 2240: { yyungetc (':', 1); goto aggr1; } ! 2241: | aggr template_type_name '{' ! 2242: { yyungetc ('{', 1); ! 2243: aggr2: ! 2244: current_aggr = $$; ! 2245: $$ = $2; ! 2246: overload_template_name ($$, 0); } ! 2247: | aggr template_type_name ':' ! 2248: { yyungetc (':', 1); goto aggr2; } ! 2249: ; ! 2250: ! 2251: named_class_head_sans_basetype_defn: ! 2252: aggr identifier_defn ! 2253: { current_aggr = $$; $$ = $2; } ! 2254: ; ! 2255: ! 2256: named_class_head: ! 2257: named_class_head_sans_basetype ! 2258: { ! 2259: $<ttype>$ = xref_tag (current_aggr, $1, NULL_TREE); ! 2260: } ! 2261: maybe_base_class_list %prec EMPTY ! 2262: { ! 2263: if ($3) ! 2264: $$ = xref_tag (current_aggr, $1, $3); ! 2265: else ! 2266: $$ = $<ttype>2; ! 2267: } ! 2268: | ! 2269: named_class_head_sans_basetype_defn ! 2270: { ! 2271: $<ttype>$ = xref_defn_tag (current_aggr, $1, NULL_TREE); ! 2272: } ! 2273: maybe_base_class_list %prec EMPTY ! 2274: { ! 2275: if ($3) ! 2276: $$ = xref_defn_tag (current_aggr, $1, $3); ! 2277: else ! 2278: $$ = $<ttype>2; ! 2279: } ! 2280: ; ! 2281: ! 2282: unnamed_class_head: aggr '{' ! 2283: { $$ = xref_tag ($$, make_anon_name (), NULL_TREE); ! 2284: yyungetc ('{', 1); } ! 2285: ; ! 2286: ! 2287: class_head: unnamed_class_head | named_class_head ; ! 2288: ! 2289: maybe_base_class_list: ! 2290: /* empty */ ! 2291: { $$ = NULL_TREE; } ! 2292: | ':' %prec EMPTY ! 2293: { yyungetc(':', 1); $$ = NULL_TREE; } ! 2294: | ':' base_class_list %prec EMPTY ! 2295: { $$ = $2; } ! 2296: ; ! 2297: ! 2298: base_class_list: ! 2299: base_class ! 2300: | base_class_list ',' base_class ! 2301: { $$ = chainon ($$, $3); } ! 2302: ; ! 2303: ! 2304: base_class: ! 2305: base_class.1 ! 2306: { if (! is_aggr_typedef ($$, 1)) ! 2307: $$ = NULL_TREE; ! 2308: else $$ = build_tree_list ((tree)visibility_default, $$); } ! 2309: | scoped_base_class ! 2310: { if (! is_aggr_typedef ($$, 1)) ! 2311: $$ = NULL_TREE; ! 2312: else $$ = build_tree_list ((tree)visibility_default, $$); } ! 2313: | base_class_visibility_list base_class.1 ! 2314: { if (! is_aggr_typedef ($2, 1)) ! 2315: $$ = NULL_TREE; ! 2316: else $$ = build_tree_list ((tree) $$, $2); } ! 2317: | base_class_visibility_list scoped_base_class ! 2318: { if (! is_aggr_typedef ($2, 1)) ! 2319: $$ = NULL_TREE; ! 2320: else $$ = build_tree_list ((tree) $$, $2); } ! 2321: ; ! 2322: ! 2323: scoped_base_class: ! 2324: base_class.1 SCOPED_TYPENAME ! 2325: { ! 2326: /* Kludge!!! See rule "template_type" and the code ! 2327: * dealing with "template_type_seen_before_scope" in ! 2328: * yylex(). */ ! 2329: $$ = $2; ! 2330: } ! 2331: ; ! 2332: base_class.1: ! 2333: template_type_name tmpl.2 template_instantiation ! 2334: { ! 2335: extern tree template_type_seen_before_scope; ! 2336: tree id = $3 ? TYPE_IDENTIFIER ($3) : $1; ! 2337: ! 2338: /* Check the rule template_type to get this... */ ! 2339: if (yychar == YYEMPTY) ! 2340: yychar = YYLEX; ! 2341: if (yychar == SCOPE) { ! 2342: template_type_seen_before_scope = id; ! 2343: yychar = YYLEX; ! 2344: } ! 2345: } ! 2346: | identifier ! 2347: ; ! 2348: ! 2349: base_class_visibility_list: ! 2350: VISSPEC ! 2351: | SCSPEC ! 2352: { if ($<ttype>$ != ridpointers[(int)RID_VIRTUAL]) ! 2353: sorry ("non-virtual visibility"); ! 2354: $$ = visibility_default_virtual; } ! 2355: | base_class_visibility_list VISSPEC ! 2356: { int err = 0; ! 2357: if ($2 == visibility_protected) ! 2358: { ! 2359: warning ("`protected' visibility not implemented"); ! 2360: $2 = visibility_public; ! 2361: err++; ! 2362: } ! 2363: else if ($2 == visibility_public) ! 2364: { ! 2365: if ($1 == visibility_private) ! 2366: { ! 2367: mixed: ! 2368: error ("base class cannot be public and private"); ! 2369: } ! 2370: else if ($1 == visibility_default_virtual) ! 2371: $$ = visibility_public_virtual; ! 2372: } ! 2373: else /* $2 == visibility_private */ ! 2374: { ! 2375: if ($1 == visibility_public) ! 2376: goto mixed; ! 2377: else if ($1 == visibility_default_virtual) ! 2378: $$ = visibility_private_virtual; ! 2379: } ! 2380: } ! 2381: | base_class_visibility_list SCSPEC ! 2382: { if ($2 != ridpointers[(int)RID_VIRTUAL]) ! 2383: sorry ("non-virtual visibility"); ! 2384: if ($$ == visibility_public) ! 2385: $$ = visibility_public_virtual; ! 2386: else if ($$ == visibility_private) ! 2387: $$ = visibility_private_virtual; } ! 2388: ; ! 2389: ! 2390: left_curly: '{' ! 2391: { tree t; ! 2392: push_obstacks_nochange (); ! 2393: end_temporary_allocation (); ! 2394: ! 2395: if (! IS_AGGR_TYPE ($<ttype>0)) ! 2396: { ! 2397: $<ttype>0 = make_lang_type (RECORD_TYPE); ! 2398: TYPE_NAME ($<ttype>0) = get_identifier ("erroneous type"); ! 2399: } ! 2400: if (TYPE_SIZE ($<ttype>0)) ! 2401: duplicate_tag_error ($<ttype>0); ! 2402: if (TYPE_SIZE ($<ttype>0) || TYPE_BEING_DEFINED ($<ttype>0)) ! 2403: { ! 2404: t = make_lang_type (TREE_CODE ($<ttype>0)); ! 2405: pushtag (TYPE_IDENTIFIER ($<ttype>0), t); ! 2406: $<ttype>0 = t; ! 2407: } ! 2408: pushclass ($<ttype>0, 0); ! 2409: TYPE_BEING_DEFINED ($<ttype>0) = 1; ! 2410: t = TYPE_IDENTIFIER ($<ttype>0); ! 2411: if (t && IDENTIFIER_TEMPLATE (t)) ! 2412: overload_template_name (t, 1); ! 2413: } ! 2414: ; ! 2415: ! 2416: opt.component_decl_list: ! 2417: /* empty */ ! 2418: { $$ = NULL_TREE; } ! 2419: | component_decl_list ! 2420: { $$ = build_tree_list ((tree)visibility_default, $$); } ! 2421: | opt.component_decl_list VISSPEC ':' component_decl_list ! 2422: { $$ = chainon ($$, build_tree_list ((tree) $2, $4)); } ! 2423: | opt.component_decl_list VISSPEC ':' ! 2424: %ifobjc ! 2425: | DEFS '(' CLASSNAME ')' ! 2426: { ! 2427: tree interface = lookup_interface ($3); ! 2428: if (interface) ! 2429: $$ = get_class_ivars (interface); ! 2430: else ! 2431: { ! 2432: error ("Cannot find interface declaration for `%s'", ! 2433: IDENTIFIER_POINTER ($3)); ! 2434: $$ = error_mark_node; ! 2435: } ! 2436: } ! 2437: ; ! 2438: %endifobjc ! 2439: ! 2440: /* Note: we no longer warn about the semicolon after a component_decl_list. ! 2441: ARM $9.2 says that the semicolon is optional, and therefore allowed. */ ! 2442: component_decl_list: ! 2443: component_decl ! 2444: { if ($$ == void_type_node) $$ = NULL_TREE; } ! 2445: | component_decl_list component_decl ! 2446: { /* In pushdecl, we created a reverse list of names ! 2447: in this binding level. Make sure that the chain ! 2448: of what we're trying to add isn't the item itself ! 2449: (which can happen with what pushdecl's doing). */ ! 2450: if ($2 != NULL_TREE && $2 != void_type_node) ! 2451: { ! 2452: if (TREE_CHAIN ($2) != $$) ! 2453: $$ = chainon ($$, $2); ! 2454: else ! 2455: $$ = $2; ! 2456: } ! 2457: } ! 2458: | component_decl_list ';' ! 2459: ; ! 2460: ! 2461: component_decl: ! 2462: typed_declspecs components ';' ! 2463: { do_components: ! 2464: $$ = grok_x_components ($$, $2); ! 2465: end_exception_decls (); ! 2466: } ! 2467: | typed_declspecs '(' parmlist ')' ';' ! 2468: { $$ = groktypefield ($$, $3); } ! 2469: | typed_declspecs '(' parmlist ')' '}' ! 2470: { error ("missing ';' before right brace"); ! 2471: yyungetc ('}', 0); ! 2472: $$ = groktypefield ($$, $3); } ! 2473: | typed_declspecs LEFT_RIGHT ';' ! 2474: { $$ = groktypefield ($$, empty_parms ()); } ! 2475: | typed_declspecs LEFT_RIGHT '}' ! 2476: { error ("missing ';' before right brace"); ! 2477: yyungetc ('}', 0); ! 2478: $$ = groktypefield ($$, empty_parms ()); } ! 2479: | declmods components ';' ! 2480: { goto do_components; } ! 2481: /* Normal case: make this fast. */ ! 2482: | declmods declarator ';' ! 2483: { $$ = grokfield ($<ttype>2, $<ttype>$, ! 2484: NULL_TREE, NULL_TREE, NULL_TREE); } ! 2485: | declmods components '}' ! 2486: { error ("missing ';' before right brace"); ! 2487: yyungetc ('}', 0); ! 2488: goto do_components; } ! 2489: | declmods '(' parmlist ')' ';' ! 2490: { $$ = groktypefield ($$, $3); } ! 2491: | declmods '(' parmlist ')' '}' ! 2492: { error ("missing ';' before right brace"); ! 2493: yyungetc ('}', 0); ! 2494: $$ = groktypefield ($$, $3); } ! 2495: | declmods LEFT_RIGHT ';' ! 2496: { $$ = groktypefield ($$, empty_parms ()); } ! 2497: | declmods LEFT_RIGHT '}' ! 2498: { error ("missing ';' before right brace"); ! 2499: yyungetc ('}', 0); ! 2500: $$ = groktypefield ($$, empty_parms ()); } ! 2501: | ':' expr_no_commas ';' ! 2502: { $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); } ! 2503: | ':' expr_no_commas '}' ! 2504: { error ("missing ';' before right brace"); ! 2505: yyungetc ('}', 0); ! 2506: $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); } ! 2507: | error ! 2508: { $$ = NULL_TREE; } ! 2509: ! 2510: /* C++: handle constructors, destructors and inline functions */ ! 2511: /* note that INLINE is like a TYPESPEC */ ! 2512: | fn.def2 ':' /* base_init compstmt */ ! 2513: { $$ = finish_method ($$); } ! 2514: | fn.def2 '{' /* nodecls compstmt */ ! 2515: { $$ = finish_method ($$); } ! 2516: | notype_declarator maybe_raises ';' ! 2517: { $$ = grokfield ($$, NULL_TREE, $2, NULL_TREE, NULL_TREE); } ! 2518: | notype_declarator maybe_raises '}' ! 2519: { error ("missing ';' before right brace"); ! 2520: yyungetc ('}', 0); ! 2521: $$ = grokfield ($$, NULL_TREE, $2, NULL_TREE, NULL_TREE); } ! 2522: ; ! 2523: ! 2524: components: ! 2525: /* empty: possibly anonymous */ ! 2526: { $$ = NULL_TREE; } ! 2527: | component_declarator0 ! 2528: | components ',' component_declarator ! 2529: { ! 2530: /* In this context, void_type_node encodes ! 2531: friends. They have been recorded elsewhere. */ ! 2532: if ($$ == void_type_node) ! 2533: $$ = $3; ! 2534: else ! 2535: $$ = chainon ($$, $3); ! 2536: } ! 2537: ; ! 2538: ! 2539: component_declarator0: ! 2540: declarator maybe_raises maybeasm maybe_attribute ! 2541: { current_declspecs = $<ttype>0; ! 2542: $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3); ! 2543: cplus_decl_attributes ($$, $4); } ! 2544: | declarator maybe_raises maybeasm maybe_attribute '=' init ! 2545: { current_declspecs = $<ttype>0; ! 2546: $$ = grokfield ($$, current_declspecs, $2, $6, $3); ! 2547: cplus_decl_attributes ($$, $4); } ! 2548: | IDENTIFIER ':' expr_no_commas maybe_attribute ! 2549: { current_declspecs = $<ttype>0; ! 2550: $$ = grokbitfield ($$, current_declspecs, $3); ! 2551: cplus_decl_attributes ($$, $4); } ! 2552: | TYPENAME ':' expr_no_commas maybe_attribute ! 2553: { current_declspecs = $<ttype>0; ! 2554: $$ = grokbitfield ($$, current_declspecs, $3); ! 2555: cplus_decl_attributes ($$, $4); } ! 2556: | ':' expr_no_commas maybe_attribute ! 2557: { current_declspecs = $<ttype>0; ! 2558: $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); ! 2559: cplus_decl_attributes ($$, $3); } ! 2560: ; ! 2561: ! 2562: component_declarator: ! 2563: declarator maybe_raises maybeasm maybe_attribute ! 2564: { $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3); ! 2565: cplus_decl_attributes ($$, $4); } ! 2566: | declarator maybe_raises maybeasm maybe_attribute '=' init ! 2567: { $$ = grokfield ($$, current_declspecs, $2, $6, $3); ! 2568: cplus_decl_attributes ($$, $4); } ! 2569: | IDENTIFIER ':' expr_no_commas maybe_attribute ! 2570: { $$ = grokbitfield ($$, current_declspecs, $3); ! 2571: cplus_decl_attributes ($$, $4); } ! 2572: | TYPENAME ':' expr_no_commas maybe_attribute ! 2573: { $$ = grokbitfield ($$, current_declspecs, $3); ! 2574: cplus_decl_attributes ($$, $4); } ! 2575: | ':' expr_no_commas maybe_attribute ! 2576: { $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); ! 2577: cplus_decl_attributes ($$, $3); } ! 2578: ; ! 2579: ! 2580: /* We chain the enumerators in reverse order. ! 2581: Because of the way enums are built, the order is ! 2582: insignificant. Take advantage of this fact. */ ! 2583: ! 2584: enumlist: ! 2585: enumerator ! 2586: | enumlist ',' enumerator ! 2587: { TREE_CHAIN ($3) = $$; $$ = $3; } ! 2588: ; ! 2589: ! 2590: enumerator: ! 2591: identifier ! 2592: { $$ = build_enumerator ($$, NULL_TREE); } ! 2593: | identifier '=' expr_no_commas ! 2594: { $$ = build_enumerator ($$, $3); } ! 2595: ; ! 2596: ! 2597: /* ANSI type-id (8.1) */ ! 2598: typename: ! 2599: typed_typespecs absdcl ! 2600: { $$ = build_decl_list ($$, $2); } ! 2601: | nonempty_type_quals absdcl ! 2602: { $$ = build_decl_list ($$, $2); } ! 2603: ; ! 2604: ! 2605: /* ANSI abstract-declarator (8.1) */ ! 2606: absdcl: /* an abstract declarator */ ! 2607: /* empty */ %prec EMPTY ! 2608: { $$ = NULL_TREE; } ! 2609: | absdcl1 %prec EMPTY ! 2610: | START_DECLARATOR absdcl1 %prec EMPTY ! 2611: { $$ = $2; } ! 2612: ; ! 2613: ! 2614: nonempty_type_quals: ! 2615: TYPE_QUAL ! 2616: { $$ = IDENTIFIER_AS_LIST ($$); } ! 2617: | nonempty_type_quals TYPE_QUAL ! 2618: { $$ = decl_tree_cons (NULL_TREE, $2, $$); } ! 2619: ; ! 2620: ! 2621: type_quals: ! 2622: /* empty */ ! 2623: { $$ = NULL_TREE; } ! 2624: | type_quals TYPE_QUAL ! 2625: { $$ = decl_tree_cons (NULL_TREE, $2, $$); } ! 2626: ; ! 2627: ! 2628: /* These rules must follow the rules for function declarations ! 2629: and component declarations. That way, longer rules are preferred. */ ! 2630: ! 2631: /* An expression which will not live on the momentary obstack. */ ! 2632: nonmomentary_expr: ! 2633: { $<itype>$ = suspend_momentary (); } expr ! 2634: { resume_momentary ((int) $<itype>1); $$ = $2; } ! 2635: ! 2636: %ifobjc ! 2637: /* This rule needs to be before after_type_declarator so that we resolve ! 2638: the reduce/reduce conflict in state 111 correctly. We need to resolve it ! 2639: the same way that vanilla C++ resolves the reduce/reduce conflict in state ! 2640: 105. That is we must assume that we are processing a typespec rather than ! 2641: an after_type_declarator when we see a TYPENAME and aren't sure. For the ! 2642: OBJECTNAME case this means we must read any protocolrefs, and then resume ! 2643: processing the typespec. */ ! 2644: protocolrefs: ! 2645: /* empty */ ! 2646: { ! 2647: $$ = NULL_TREE; ! 2648: } ! 2649: | '<' identifier_list '>' ! 2650: { ! 2651: $$ = $2; ! 2652: } ! 2653: ; ! 2654: %endifobjc ! 2655: ! 2656: /* A declarator that is allowed only after an explicit typespec. */ ! 2657: /* may all be followed by prec '.' */ ! 2658: after_type_declarator: ! 2659: after_type_declarator '(' nonnull_exprlist ')' type_quals %prec '.' ! 2660: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); } ! 2661: | after_type_declarator '(' parmlist ')' type_quals %prec '.' ! 2662: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); } ! 2663: | after_type_declarator LEFT_RIGHT type_quals %prec '.' ! 2664: { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); } ! 2665: | after_type_declarator '(' error ')' type_quals %prec '.' ! 2666: { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); } ! 2667: | after_type_declarator '[' nonmomentary_expr ']' ! 2668: { $$ = build_parse_node (ARRAY_REF, $$, $3); } ! 2669: | after_type_declarator '[' ']' ! 2670: { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); } ! 2671: | '(' after_type_declarator_no_typename ')' ! 2672: { $$ = $2; } ! 2673: | '(' '*' type_quals after_type_declarator ')' ! 2674: { $$ = make_pointer_declarator ($3, $4); } ! 2675: | PAREN_STAR_PAREN ! 2676: { see_typename (); } ! 2677: | after_type_member_declarator ! 2678: | '(' '&' type_quals after_type_declarator ')' ! 2679: { $$ = make_reference_declarator ($3, $4); } ! 2680: | '*' type_quals after_type_declarator %prec UNARY ! 2681: { $$ = make_pointer_declarator ($2, $3); } ! 2682: | '&' type_quals after_type_declarator %prec UNARY ! 2683: { $$ = make_reference_declarator ($2, $3); } ! 2684: | TYPENAME ! 2685: %ifobjc ! 2686: | OBJECTNAME ! 2687: %endifobjc ! 2688: ; ! 2689: ! 2690: after_type_declarator_no_typename: ! 2691: after_type_declarator_no_typename '(' nonnull_exprlist ')' type_quals %prec '.' ! 2692: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); } ! 2693: | after_type_declarator_no_typename '(' parmlist ')' type_quals %prec '.' ! 2694: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); } ! 2695: | after_type_declarator_no_typename LEFT_RIGHT type_quals %prec '.' ! 2696: { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); } ! 2697: | after_type_declarator_no_typename '(' error ')' type_quals %prec '.' ! 2698: { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); } ! 2699: | after_type_declarator_no_typename '[' nonmomentary_expr ']' ! 2700: { $$ = build_parse_node (ARRAY_REF, $$, $3); } ! 2701: | after_type_declarator_no_typename '[' ']' ! 2702: { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); } ! 2703: | '(' after_type_declarator_no_typename ')' ! 2704: { $$ = $2; } ! 2705: | PAREN_STAR_PAREN ! 2706: { see_typename (); } ! 2707: | after_type_member_declarator ! 2708: | '*' type_quals after_type_declarator %prec UNARY ! 2709: { $$ = make_pointer_declarator ($2, $3); } ! 2710: | '&' type_quals after_type_declarator %prec UNARY ! 2711: { $$ = make_reference_declarator ($2, $3); } ! 2712: ; ! 2713: ! 2714: /* A declarator allowed whether or not there has been ! 2715: an explicit typespec. These cannot redeclare a typedef-name. */ ! 2716: ! 2717: notype_declarator: ! 2718: notype_declarator '(' nonnull_exprlist ')' type_quals %prec '.' ! 2719: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); } ! 2720: | notype_declarator '(' parmlist ')' type_quals %prec '.' ! 2721: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); } ! 2722: | notype_declarator LEFT_RIGHT type_quals %prec '.' ! 2723: { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); } ! 2724: | notype_declarator '(' error ')' type_quals %prec '.' ! 2725: { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); } ! 2726: | '(' notype_declarator ')' ! 2727: { $$ = $2; } ! 2728: | '*' type_quals notype_declarator %prec UNARY ! 2729: { $$ = make_pointer_declarator ($2, $3); } ! 2730: | '&' type_quals notype_declarator %prec UNARY ! 2731: { $$ = make_reference_declarator ($2, $3); } ! 2732: | notype_declarator '[' nonmomentary_expr ']' ! 2733: { $$ = build_parse_node (ARRAY_REF, $$, $3); } ! 2734: | notype_declarator '[' ']' ! 2735: { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); } ! 2736: | IDENTIFIER ! 2737: { see_typename (); } ! 2738: ! 2739: /* C++ extensions. */ ! 2740: | operator_name ! 2741: { see_typename (); } ! 2742: ! 2743: | '~' TYPENAME ! 2744: { ! 2745: destructor_name: ! 2746: see_typename (); ! 2747: $$ = build_parse_node (BIT_NOT_EXPR, $2); ! 2748: } ! 2749: | '~' IDENTIFIER ! 2750: { goto destructor_name; } ! 2751: | '~' PTYPENAME ! 2752: { goto destructor_name; } ! 2753: | id_scope see_typename notype_declarator %prec '(' ! 2754: { see_typename (); ! 2755: if (TREE_CODE ($$) != SCOPE_REF) ! 2756: $$ = build_push_scope ($$, $3); ! 2757: else if (TREE_OPERAND ($$, 1) == NULL_TREE) ! 2758: TREE_OPERAND ($$, 1) = $3; ! 2759: else ! 2760: $$ = build_parse_node (SCOPE_REF, $$, $3); ! 2761: } ! 2762: | id_scope see_typename TYPENAME %prec '(' ! 2763: { $$ = build_push_scope ($$, $3); } ! 2764: | id_scope see_typename TYPENAME '(' nonnull_exprlist ')' type_quals %prec '.' ! 2765: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); } ! 2766: | id_scope see_typename TYPENAME '(' parmlist ')' type_quals %prec '.' ! 2767: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); } ! 2768: | id_scope see_typename TYPENAME LEFT_RIGHT type_quals %prec '.' ! 2769: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, empty_parms (), $5)); } ! 2770: | id_scope see_typename TYPENAME '(' error ')' type_quals %prec '.' ! 2771: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, NULL_TREE, NULL_TREE)); } ! 2772: /* For constructor templates. */ ! 2773: | id_scope see_typename PTYPENAME %prec '(' ! 2774: { $$ = build_push_scope ($$, $3); } ! 2775: | id_scope see_typename PTYPENAME '(' nonnull_exprlist ')' type_quals %prec '.' ! 2776: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); } ! 2777: | id_scope see_typename PTYPENAME '(' parmlist ')' type_quals %prec '.' ! 2778: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); } ! 2779: | id_scope see_typename PTYPENAME LEFT_RIGHT type_quals %prec '.' ! 2780: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, empty_parms (), $5)); } ! 2781: | id_scope see_typename PTYPENAME '(' error ')' type_quals %prec '.' ! 2782: { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, NULL_TREE, NULL_TREE)); } ! 2783: | SCOPE see_typename notype_declarator ! 2784: { $$ = build_parse_node (SCOPE_REF, NULL_TREE, $3); } ! 2785: ; ! 2786: ! 2787: id_scope: typename_scope ! 2788: { tree t; ! 2789: do_id_scope: ! 2790: ! 2791: t = resolve_scope_to_name (NULL_TREE, $$); ! 2792: if (t == NULL_TREE) ! 2793: { ! 2794: cp_error ("`%T' is not a valid scope", $$); ! 2795: $$ = error_mark_node; ! 2796: } ! 2797: else ! 2798: $$ = t; ! 2799: } ! 2800: | IDENTIFIER SCOPE ! 2801: { goto do_id_scope; } ! 2802: | template_type SCOPE /* try_for_typename %prec EMPTY */ ! 2803: { ! 2804: if ($$ == error_mark_node) ! 2805: /* leave it alone */; ! 2806: else ! 2807: { ! 2808: $$ = resolve_scope_to_name (NULL_TREE, TYPE_IDENTIFIER ($$)); ! 2809: if ($$ == NULL_TREE) ! 2810: { ! 2811: error ("undefined explicitly scoped type"); ! 2812: $$ = error_mark_node; ! 2813: } ! 2814: } ! 2815: /* if ($3) popclass (1); */ ! 2816: } ! 2817: ; ! 2818: ! 2819: typename_scope: ! 2820: TYPENAME SCOPE; ! 2821: ! 2822: scoped_typename: SCOPED_TYPENAME ! 2823: | template_type SCOPED_TYPENAME ! 2824: { ! 2825: /* Kludge!!! See rule "template_type" and the code ! 2826: * dealing with "template_type_seen_before_scope" in ! 2827: * yylex(). */ ! 2828: $$ = $2; ! 2829: } ! 2830: /* | template_type SCOPE try_for_typename TYPENAME ! 2831: { ! 2832: if ($$ == error_mark_node) ! 2833: ; ! 2834: else ! 2835: { ! 2836: $$ = build_parse_node (SCOPE_REF, ! 2837: TYPE_IDENTIFIER ($$), ! 2838: $4); ! 2839: } ! 2840: if ($3) popclass (1); ! 2841: } */ ! 2842: ; ! 2843: ! 2844: absdcl1: /* a nonempty abstract declarator */ ! 2845: '(' absdcl1 ')' ! 2846: { see_typename (); ! 2847: $$ = $2; } ! 2848: /* `(typedef)1' is `int'. */ ! 2849: | '*' type_quals absdcl1 %prec EMPTY ! 2850: { $$ = make_pointer_declarator ($2, $3); } ! 2851: | '*' type_quals %prec EMPTY ! 2852: { $$ = make_pointer_declarator ($2, NULL_TREE); } ! 2853: | PAREN_STAR_PAREN ! 2854: { see_typename (); } ! 2855: | '(' abs_member_declarator ')' ! 2856: { $$ = $2; } ! 2857: | '&' type_quals absdcl1 %prec EMPTY ! 2858: { $$ = make_reference_declarator ($2, $3); } ! 2859: | '&' type_quals %prec EMPTY ! 2860: { $$ = make_reference_declarator ($2, NULL_TREE); } ! 2861: | absdcl1 '(' parmlist ')' type_quals %prec '.' ! 2862: { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); } ! 2863: | absdcl1 LEFT_RIGHT type_quals %prec '.' ! 2864: { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); } ! 2865: | absdcl1 '[' nonmomentary_expr ']' %prec '.' ! 2866: { $$ = build_parse_node (ARRAY_REF, $$, $3); } ! 2867: | absdcl1 '[' ']' %prec '.' ! 2868: { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); } ! 2869: | '(' parmlist ')' type_quals %prec '.' ! 2870: { $$ = build_parse_node (CALL_EXPR, NULL_TREE, $2, $4); } ! 2871: | LEFT_RIGHT type_quals %prec '.' ! 2872: { $$ = build_parse_node (CALL_EXPR, NULL_TREE, empty_parms (), $2); } ! 2873: | '[' nonmomentary_expr ']' %prec '.' ! 2874: { $$ = build_parse_node (ARRAY_REF, NULL_TREE, $2); } ! 2875: | '[' ']' %prec '.' ! 2876: { $$ = build_parse_node (ARRAY_REF, NULL_TREE, NULL_TREE); } ! 2877: ; ! 2878: ! 2879: abs_member_declarator: ! 2880: id_scope see_typename '*' type_quals ! 2881: { tree t; ! 2882: t = $$; ! 2883: while (TREE_OPERAND (t, 1)) ! 2884: t = TREE_OPERAND (t, 1); ! 2885: TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, 0); ! 2886: } ! 2887: | id_scope see_typename '*' type_quals absdcl1 ! 2888: { tree t; ! 2889: t = $$; ! 2890: while (TREE_OPERAND (t, 1)) ! 2891: t = TREE_OPERAND (t, 1); ! 2892: TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, $5); ! 2893: } ! 2894: | id_scope see_typename '&' type_quals ! 2895: { tree t; ! 2896: t = $$; ! 2897: while (TREE_OPERAND (t, 1)) ! 2898: t = TREE_OPERAND (t, 1); ! 2899: TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, 0); ! 2900: } ! 2901: | id_scope see_typename '&' type_quals absdcl1 ! 2902: { tree t; ! 2903: t = $$; ! 2904: while (TREE_OPERAND (t, 1)) ! 2905: t = TREE_OPERAND (t, 1); ! 2906: TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, $5); ! 2907: } ! 2908: ; ! 2909: ! 2910: after_type_member_declarator: ! 2911: id_scope see_typename '*' type_quals after_type_declarator ! 2912: { tree t; ! 2913: t = $$; ! 2914: while (TREE_OPERAND (t, 1)) ! 2915: t = TREE_OPERAND (t, 1); ! 2916: TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, $5); ! 2917: } ! 2918: | id_scope see_typename '&' type_quals after_type_declarator ! 2919: { tree t; ! 2920: t = $$; ! 2921: while (TREE_OPERAND (t, 1)) ! 2922: t = TREE_OPERAND (t, 1); ! 2923: TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, $5); ! 2924: } ! 2925: ; ! 2926: ! 2927: /* For C++, decls and stmts can be intermixed, so we don't need to ! 2928: have a special rule that won't start parsing the stmt section ! 2929: until we have a stmt that parses without errors. */ ! 2930: ! 2931: stmts: ! 2932: stmt ! 2933: | errstmt ! 2934: | stmts stmt ! 2935: | stmts errstmt ! 2936: ; ! 2937: ! 2938: errstmt: error ';' ! 2939: ; ! 2940: ! 2941: /* build the LET_STMT node before parsing its contents, ! 2942: so that any LET_STMTs within the context can have their display pointers ! 2943: set up to point at this one. */ ! 2944: ! 2945: .pushlevel: /* empty */ ! 2946: { emit_line_note (input_filename, lineno); ! 2947: pushlevel (0); ! 2948: clear_last_expr (); ! 2949: push_momentary (); ! 2950: expand_start_bindings (0); ! 2951: %ifobjc ! 2952: if (objc_method_context) ! 2953: add_objc_decls(); ! 2954: %endifobjc ! 2955: } ! 2956: ; ! 2957: ! 2958: /* Read zero or more forward-declarations for labels ! 2959: that nested functions can jump to. */ ! 2960: maybe_label_decls: ! 2961: /* empty */ ! 2962: | label_decls ! 2963: { if (pedantic) ! 2964: pedwarn ("ANSI C++ forbids label declarations"); } ! 2965: ; ! 2966: ! 2967: label_decls: ! 2968: label_decl ! 2969: | label_decls label_decl ! 2970: ; ! 2971: ! 2972: label_decl: ! 2973: LABEL identifiers_or_typenames ';' ! 2974: { tree link; ! 2975: for (link = $2; link; link = TREE_CHAIN (link)) ! 2976: { ! 2977: tree label = shadow_label (TREE_VALUE (link)); ! 2978: C_DECLARED_LABEL_FLAG (label) = 1; ! 2979: declare_nonlocal_label (label); ! 2980: } ! 2981: } ! 2982: ; ! 2983: ! 2984: /* This is the body of a function definition. ! 2985: It causes syntax errors to ignore to the next openbrace. */ ! 2986: compstmt_or_error: ! 2987: compstmt ! 2988: {} ! 2989: | error compstmt ! 2990: ; ! 2991: ! 2992: compstmt: '{' .pushlevel '}' ! 2993: { pop_implicit_try_blocks (NULL_TREE); ! 2994: expand_end_bindings (getdecls (), kept_level_p(), 1); ! 2995: $$ = poplevel (kept_level_p (), 1, 0); ! 2996: pop_momentary (); } ! 2997: | '{' .pushlevel maybe_label_decls stmts '}' ! 2998: { pop_implicit_try_blocks (NULL_TREE); ! 2999: expand_end_bindings (getdecls (), kept_level_p(), 1); ! 3000: $$ = poplevel (kept_level_p (), 1, 0); ! 3001: pop_momentary (); } ! 3002: | '{' .pushlevel maybe_label_decls error '}' ! 3003: { pop_implicit_try_blocks (NULL_TREE); ! 3004: expand_end_bindings (getdecls (), kept_level_p(), 1); ! 3005: $$ = poplevel (kept_level_p (), 0, 0); ! 3006: pop_momentary (); } ! 3007: ; ! 3008: ! 3009: simple_if: ! 3010: IF ! 3011: { cond_stmt_keyword = "if"; } ! 3012: .pushlevel paren_cond_or_null ! 3013: { emit_line_note (input_filename, lineno); ! 3014: expand_start_cond (truthvalue_conversion ($4), 0); } ! 3015: partially_scoped_stmt ! 3016: ; ! 3017: ! 3018: implicitly_scoped_stmt: ! 3019: compstmt ! 3020: { finish_stmt (); } ! 3021: | .pushlevel simple_stmt ! 3022: { pop_implicit_try_blocks (NULL_TREE); ! 3023: expand_end_bindings (getdecls (), getdecls() != NULL_TREE, 1); ! 3024: $$ = poplevel (kept_level_p (), 1, 0); ! 3025: pop_momentary (); } ! 3026: ; ! 3027: ! 3028: stmt: ! 3029: compstmt ! 3030: { finish_stmt (); } ! 3031: | simple_stmt ! 3032: ; ! 3033: ! 3034: simple_stmt: ! 3035: decl ! 3036: { finish_stmt (); } ! 3037: | expr ';' ! 3038: { ! 3039: tree expr = $1; ! 3040: emit_line_note (input_filename, lineno); ! 3041: /* Do default conversion if safe and possibly important, ! 3042: in case within ({...}). */ ! 3043: if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE ! 3044: && lvalue_p (expr)) ! 3045: || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE) ! 3046: expr = default_conversion (expr); ! 3047: cplus_expand_expr_stmt (expr); ! 3048: clear_momentary (); ! 3049: finish_stmt (); } ! 3050: | simple_if ELSE ! 3051: { expand_start_else (); } ! 3052: partially_scoped_stmt ! 3053: { expand_end_cond (); ! 3054: pop_implicit_try_blocks (NULL_TREE); ! 3055: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 3056: poplevel (kept_level_p (), 1, 0); ! 3057: pop_momentary (); ! 3058: finish_stmt (); } ! 3059: | simple_if %prec IF ! 3060: { expand_end_cond (); ! 3061: pop_implicit_try_blocks (NULL_TREE); ! 3062: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 3063: poplevel (kept_level_p (), 1, 0); ! 3064: pop_momentary (); ! 3065: finish_stmt (); } ! 3066: | WHILE ! 3067: { emit_nop (); ! 3068: emit_line_note (input_filename, lineno); ! 3069: expand_start_loop (1); ! 3070: cond_stmt_keyword = "while"; } ! 3071: .pushlevel paren_cond_or_null ! 3072: { expand_exit_loop_if_false (0, truthvalue_conversion ($4)); } ! 3073: already_scoped_stmt ! 3074: { pop_implicit_try_blocks (NULL_TREE); ! 3075: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 3076: poplevel (kept_level_p (), 1, 0); ! 3077: pop_momentary (); ! 3078: expand_end_loop (); ! 3079: finish_stmt (); } ! 3080: | DO ! 3081: { emit_nop (); ! 3082: emit_line_note (input_filename, lineno); ! 3083: expand_start_loop_continue_elsewhere (1); } ! 3084: implicitly_scoped_stmt WHILE ! 3085: { expand_loop_continue_here (); ! 3086: cond_stmt_keyword = "do"; } ! 3087: paren_expr_or_null ';' ! 3088: { emit_line_note (input_filename, lineno); ! 3089: expand_exit_loop_if_false (0, truthvalue_conversion ($6)); ! 3090: expand_end_loop (); ! 3091: clear_momentary (); ! 3092: finish_stmt (); } ! 3093: | forhead.1 ! 3094: { emit_nop (); ! 3095: emit_line_note (input_filename, lineno); ! 3096: if ($1) cplus_expand_expr_stmt ($1); ! 3097: expand_start_loop_continue_elsewhere (1); } ! 3098: .pushlevel xcond ';' ! 3099: { emit_line_note (input_filename, lineno); ! 3100: if ($4) expand_exit_loop_if_false (0, truthvalue_conversion ($4)); } ! 3101: xexpr ')' ! 3102: /* Don't let the tree nodes for $7 be discarded ! 3103: by clear_momentary during the parsing of the next stmt. */ ! 3104: { push_momentary (); } ! 3105: already_scoped_stmt ! 3106: { emit_line_note (input_filename, lineno); ! 3107: expand_loop_continue_here (); ! 3108: if ($7) cplus_expand_expr_stmt ($7); ! 3109: pop_momentary (); ! 3110: pop_implicit_try_blocks (NULL_TREE); ! 3111: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 3112: poplevel (kept_level_p (), 1, 0); ! 3113: pop_momentary (); ! 3114: expand_end_loop (); ! 3115: finish_stmt (); } ! 3116: | forhead.2 ! 3117: { emit_nop (); ! 3118: emit_line_note (input_filename, lineno); ! 3119: expand_start_loop_continue_elsewhere (1); } ! 3120: .pushlevel xcond ';' ! 3121: { emit_line_note (input_filename, lineno); ! 3122: if ($4) expand_exit_loop_if_false (0, truthvalue_conversion ($4)); } ! 3123: xexpr ')' ! 3124: /* Don't let the tree nodes for $7 be discarded ! 3125: by clear_momentary during the parsing of the next stmt. */ ! 3126: { push_momentary (); ! 3127: $<itype>8 = lineno; } ! 3128: already_scoped_stmt ! 3129: { emit_line_note (input_filename, (int) $<itype>8); ! 3130: expand_loop_continue_here (); ! 3131: if ($7) cplus_expand_expr_stmt ($7); ! 3132: pop_momentary (); ! 3133: pop_implicit_try_blocks (NULL_TREE); ! 3134: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 3135: poplevel (kept_level_p (), 1, 0); ! 3136: pop_momentary (); ! 3137: expand_end_loop (); ! 3138: finish_stmt (); ! 3139: } ! 3140: | SWITCH .pushlevel '(' condition ')' ! 3141: { emit_line_note (input_filename, lineno); ! 3142: c_expand_start_case ($4); ! 3143: /* Don't let the tree nodes for $4 be discarded by ! 3144: clear_momentary during the parsing of the next stmt. */ ! 3145: push_momentary (); } ! 3146: partially_scoped_stmt ! 3147: { expand_end_case ($4); ! 3148: pop_momentary (); ! 3149: pop_implicit_try_blocks (NULL_TREE); ! 3150: expand_end_bindings (getdecls (), kept_level_p (), 1); ! 3151: poplevel (kept_level_p (), 1, 0); ! 3152: pop_momentary (); ! 3153: finish_stmt (); } ! 3154: | CASE expr_no_commas ':' ! 3155: { register tree value = $2; ! 3156: register tree label ! 3157: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); ! 3158: ! 3159: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. ! 3160: Strip such NOP_EXPRs. */ ! 3161: if (TREE_CODE (value) == NOP_EXPR ! 3162: && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0))) ! 3163: value = TREE_OPERAND (value, 0); ! 3164: ! 3165: if (TREE_READONLY_DECL_P (value)) ! 3166: { ! 3167: value = decl_constant_value (value); ! 3168: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. ! 3169: Strip such NOP_EXPRs. */ ! 3170: if (TREE_CODE (value) == NOP_EXPR ! 3171: && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0))) ! 3172: value = TREE_OPERAND (value, 0); ! 3173: } ! 3174: value = fold (value); ! 3175: ! 3176: if (TREE_CODE (value) != INTEGER_CST ! 3177: && value != error_mark_node) ! 3178: { ! 3179: cp_error ("case label `%E' does not reduce to an integer constant", $2); ! 3180: value = error_mark_node; ! 3181: } ! 3182: else ! 3183: /* Promote char or short to int. */ ! 3184: value = default_conversion (value); ! 3185: if (value != error_mark_node) ! 3186: { ! 3187: tree duplicate; ! 3188: int success = pushcase (value, convert_and_check, ! 3189: label, &duplicate); ! 3190: if (success == 1) ! 3191: cp_error ("case label `%E' not within a switch statement", $2); ! 3192: else if (success == 2) ! 3193: { ! 3194: cp_error ("duplicate case value `%E'", $2); ! 3195: cp_error_at ("`%E' previously used here", duplicate); ! 3196: } ! 3197: else if (success == 3) ! 3198: warning ("case value out of range"); ! 3199: else if (success == 5) ! 3200: cp_error ("case label `%E' within scope of cleanup or variable array", $2); ! 3201: } ! 3202: define_case_label (label); ! 3203: } ! 3204: stmt ! 3205: | CASE expr_no_commas RANGE expr_no_commas ':' ! 3206: { register tree value1 = $2; ! 3207: register tree value2 = $4; ! 3208: register tree label ! 3209: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); ! 3210: ! 3211: if (pedantic) ! 3212: pedwarn ("ANSI C++ forbids range expressions in switch statement"); ! 3213: ! 3214: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. ! 3215: Strip such NOP_EXPRs. */ ! 3216: if (TREE_CODE (value1) == NOP_EXPR ! 3217: && TREE_TYPE (value1) == TREE_TYPE (TREE_OPERAND (value1, 0))) ! 3218: value1 = TREE_OPERAND (value1, 0); ! 3219: ! 3220: if (TREE_READONLY_DECL_P (value1)) ! 3221: { ! 3222: value1 = decl_constant_value (value1); ! 3223: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. ! 3224: Strip such NOP_EXPRs. */ ! 3225: if (TREE_CODE (value1) == NOP_EXPR ! 3226: && TREE_TYPE (value1) == TREE_TYPE (TREE_OPERAND (value1, 0))) ! 3227: value1 = TREE_OPERAND (value1, 0); ! 3228: } ! 3229: value1 = fold (value1); ! 3230: ! 3231: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. ! 3232: Strip such NOP_EXPRs. */ ! 3233: if (TREE_CODE (value2) == NOP_EXPR ! 3234: && TREE_TYPE (value2) == TREE_TYPE (TREE_OPERAND (value2, 0))) ! 3235: value2 = TREE_OPERAND (value2, 0); ! 3236: ! 3237: if (TREE_READONLY_DECL_P (value2)) ! 3238: { ! 3239: value2 = decl_constant_value (value2); ! 3240: /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. ! 3241: Strip such NOP_EXPRs. */ ! 3242: if (TREE_CODE (value2) == NOP_EXPR ! 3243: && TREE_TYPE (value2) == TREE_TYPE (TREE_OPERAND (value2, 0))) ! 3244: value2 = TREE_OPERAND (value2, 0); ! 3245: } ! 3246: value2 = fold (value2); ! 3247: ! 3248: ! 3249: if (TREE_CODE (value1) != INTEGER_CST ! 3250: && value1 != error_mark_node) ! 3251: { ! 3252: error ("case label does not reduce to an integer constant"); ! 3253: value1 = error_mark_node; ! 3254: } ! 3255: if (TREE_CODE (value2) != INTEGER_CST ! 3256: && value2 != error_mark_node) ! 3257: { ! 3258: error ("case label does not reduce to an integer constant"); ! 3259: value2 = error_mark_node; ! 3260: } ! 3261: if (value1 != error_mark_node ! 3262: && value2 != error_mark_node) ! 3263: { ! 3264: tree duplicate; ! 3265: int success = pushcase_range (value1, value2, ! 3266: convert_and_check, label, ! 3267: &duplicate); ! 3268: if (success == 1) ! 3269: error ("case label not within a switch statement"); ! 3270: else if (success == 2) ! 3271: { ! 3272: error ("duplicate (or overlapping) case value"); ! 3273: error_with_decl (duplicate, "this is the first entry overlapping that value"); ! 3274: } ! 3275: else if (success == 3) ! 3276: warning ("case value out of range"); ! 3277: else if (success == 4) ! 3278: warning ("empty range specified"); ! 3279: else if (success == 5) ! 3280: error ("case label within scope of cleanup or variable array"); ! 3281: } ! 3282: define_case_label (label); ! 3283: } ! 3284: stmt ! 3285: | DEFAULT ':' ! 3286: { ! 3287: tree duplicate; ! 3288: register tree label ! 3289: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); ! 3290: int success = pushcase (NULL_TREE, 0, label, &duplicate); ! 3291: if (success == 1) ! 3292: error ("default label not within a switch statement"); ! 3293: else if (success == 2) ! 3294: { ! 3295: error ("multiple default labels in one switch"); ! 3296: error_with_decl (duplicate, "this is the first default label"); ! 3297: } ! 3298: define_case_label (NULL_TREE); ! 3299: } ! 3300: stmt ! 3301: | BREAK ';' ! 3302: { emit_line_note (input_filename, lineno); ! 3303: if ( ! expand_exit_something ()) ! 3304: error ("break statement not within loop or switch"); } ! 3305: | CONTINUE ';' ! 3306: { emit_line_note (input_filename, lineno); ! 3307: if (! expand_continue_loop (0)) ! 3308: error ("continue statement not within a loop"); } ! 3309: | RETURN ';' ! 3310: { emit_line_note (input_filename, lineno); ! 3311: c_expand_return (NULL_TREE); } ! 3312: | RETURN expr ';' ! 3313: { emit_line_note (input_filename, lineno); ! 3314: c_expand_return ($2); ! 3315: finish_stmt (); ! 3316: } ! 3317: | asm_keyword maybe_type_qual '(' string ')' ';' ! 3318: { if (TREE_CHAIN ($4)) $4 = combine_strings ($4); ! 3319: emit_line_note (input_filename, lineno); ! 3320: expand_asm ($4); ! 3321: finish_stmt (); ! 3322: } ! 3323: /* This is the case with just output operands. */ ! 3324: | asm_keyword maybe_type_qual '(' string ':' asm_operands ')' ';' ! 3325: { if (TREE_CHAIN ($4)) $4 = combine_strings ($4); ! 3326: emit_line_note (input_filename, lineno); ! 3327: c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE, ! 3328: $2 == ridpointers[(int)RID_VOLATILE], ! 3329: input_filename, lineno); ! 3330: finish_stmt (); ! 3331: } ! 3332: /* This is the case with input operands as well. */ ! 3333: | asm_keyword maybe_type_qual '(' string ':' asm_operands ':' asm_operands ')' ';' ! 3334: { if (TREE_CHAIN ($4)) $4 = combine_strings ($4); ! 3335: emit_line_note (input_filename, lineno); ! 3336: c_expand_asm_operands ($4, $6, $8, NULL_TREE, ! 3337: $2 == ridpointers[(int)RID_VOLATILE], ! 3338: input_filename, lineno); ! 3339: finish_stmt (); ! 3340: } ! 3341: /* This is the case with clobbered registers as well. */ ! 3342: | asm_keyword maybe_type_qual '(' string ':' asm_operands ':' ! 3343: asm_operands ':' asm_clobbers ')' ';' ! 3344: { if (TREE_CHAIN ($4)) $4 = combine_strings ($4); ! 3345: emit_line_note (input_filename, lineno); ! 3346: c_expand_asm_operands ($4, $6, $8, $10, ! 3347: $2 == ridpointers[(int)RID_VOLATILE], ! 3348: input_filename, lineno); ! 3349: finish_stmt (); ! 3350: } ! 3351: | GOTO '*' expr ';' ! 3352: { emit_line_note (input_filename, lineno); ! 3353: expand_computed_goto ($3); } ! 3354: | GOTO identifier ';' ! 3355: { tree decl; ! 3356: emit_line_note (input_filename, lineno); ! 3357: decl = lookup_label ($2); ! 3358: TREE_USED (decl) = 1; ! 3359: expand_goto (decl); } ! 3360: | label_colon stmt ! 3361: { finish_stmt (); } ! 3362: | label_colon '}' ! 3363: { error ("label must be followed by statement"); ! 3364: yyungetc ('}', 0); ! 3365: finish_stmt (); } ! 3366: | ';' ! 3367: { finish_stmt (); } ! 3368: ! 3369: /* Exception handling extensions. */ ! 3370: | ANSI_THROW ';' { cplus_expand_throw (NULL_TREE); } ! 3371: | ANSI_THROW expr ';' { cplus_expand_throw ($2); } ! 3372: | THROW raise_identifier '(' nonnull_exprlist ')' ';' ! 3373: { cplus_expand_raise ($2, $4, NULL_TREE, 0); ! 3374: finish_stmt (); } ! 3375: | THROW raise_identifier LEFT_RIGHT ';' ! 3376: { cplus_expand_raise ($2, NULL_TREE, NULL_TREE, 0); ! 3377: finish_stmt (); } ! 3378: | RAISE raise_identifier '(' nonnull_exprlist ')' ';' ! 3379: { cplus_expand_raise ($2, $4, NULL_TREE, 0); ! 3380: finish_stmt (); } ! 3381: | RAISE raise_identifier LEFT_RIGHT ';' ! 3382: { cplus_expand_raise ($2, NULL_TREE, NULL_TREE, 0); ! 3383: finish_stmt (); } ! 3384: | RAISE identifier ';' ! 3385: { cplus_expand_reraise ($2); ! 3386: finish_stmt (); } ! 3387: | try EXCEPT identifier '{' ! 3388: { ! 3389: tree decl = cplus_expand_end_try ($1); ! 3390: $<ttype>2 = current_exception_type; ! 3391: $<ttype>4 = current_exception_decl; ! 3392: $<ttype>$ = current_exception_object; ! 3393: cplus_expand_start_except ($3, decl); ! 3394: pushlevel (0); ! 3395: clear_last_expr (); ! 3396: push_momentary (); ! 3397: expand_start_bindings (0); ! 3398: } ! 3399: except_stmts '}' ! 3400: { ! 3401: tree decls = getdecls (); ! 3402: /* If there is a default exception to handle, ! 3403: handle it here. */ ! 3404: if ($6) ! 3405: { ! 3406: tree decl = build_decl (CPLUS_CATCH_DECL, NULL_TREE, 0); ! 3407: tree block; ! 3408: ! 3409: pushlevel (1); ! 3410: expand_start_bindings (0); ! 3411: expand_expr ($6, 0, 0, 0); ! 3412: expand_end_bindings (0, 1, 0); ! 3413: block = poplevel (1, 0, 0); ! 3414: ! 3415: /* This is a catch block. */ ! 3416: TREE_LANG_FLAG_2 (block) = 1; ! 3417: BLOCK_VARS (block) = decl; ! 3418: } ! 3419: ! 3420: expand_end_bindings (decls, decls != 0, 1); ! 3421: poplevel (decls != 0, 1, 0); ! 3422: pop_momentary (); ! 3423: current_exception_type = $<ttype>2; ! 3424: current_exception_decl = $<ttype>4; ! 3425: current_exception_object = $<ttype>5; ! 3426: cplus_expand_end_except ($6); ! 3427: } ! 3428: | try error ! 3429: { ! 3430: cplus_expand_end_try ($1); ! 3431: /* These are the important actions of ! 3432: `cplus_expand_end_except' which we must emulate. */ ! 3433: if (expand_escape_except ()) ! 3434: expand_end_except (); ! 3435: expand_end_bindings (0, 0, 1); ! 3436: poplevel (0, 0, 0); ! 3437: } ! 3438: | ansi_try ansi_dummy ansi_dummy ! 3439: { ! 3440: tree decl = cplus_expand_end_try ($1); ! 3441: $<ttype>2 = current_exception_type; ! 3442: $<ttype>3 = current_exception_decl; ! 3443: $<ttype>$ = current_exception_object; ! 3444: cplus_expand_start_except (NULL, decl); ! 3445: pushlevel (0); ! 3446: clear_last_expr (); ! 3447: push_momentary (); ! 3448: expand_start_bindings (0); ! 3449: } ! 3450: ansi_except_stmts ! 3451: { ! 3452: tree decls = getdecls (); ! 3453: /* If there is a default exception to handle, ! 3454: handle it here. */ ! 3455: if ($5) ! 3456: { ! 3457: tree decl = build_decl (CPLUS_CATCH_DECL, NULL_TREE, 0); ! 3458: tree block; ! 3459: ! 3460: pushlevel (1); ! 3461: expand_start_bindings (0); ! 3462: expand_expr ($5, 0, 0, 0); ! 3463: expand_end_bindings (0, 1, 0); ! 3464: block = poplevel (1, 0, 0); ! 3465: ! 3466: /* This is a catch block. */ ! 3467: TREE_LANG_FLAG_2 (block) = 1; ! 3468: BLOCK_VARS (block) = decl; ! 3469: } ! 3470: ! 3471: expand_end_bindings (decls, decls != 0, 1); ! 3472: poplevel (decls != 0, 1, 0); ! 3473: pop_momentary (); ! 3474: current_exception_type = $<ttype>2; ! 3475: current_exception_decl = $<ttype>3; ! 3476: current_exception_object = $<ttype>4; ! 3477: cplus_expand_end_except ($5); ! 3478: } ! 3479: | try RERAISE raise_identifiers /* ';' checked for at bottom. */ ! 3480: { tree name = get_identifier ("(compiler error)"); ! 3481: tree orig_ex_type = current_exception_type; ! 3482: tree orig_ex_decl = current_exception_decl; ! 3483: tree orig_ex_obj = current_exception_object; ! 3484: tree decl = cplus_expand_end_try ($1), decls; ! 3485: ! 3486: /* Start hidden EXCEPT. */ ! 3487: cplus_expand_start_except (name, decl); ! 3488: pushlevel (0); ! 3489: clear_last_expr (); ! 3490: push_momentary (); ! 3491: expand_start_bindings (0); ! 3492: ! 3493: /* This sets up the reraise. */ ! 3494: cplus_expand_reraise ($3); ! 3495: ! 3496: decls = getdecls (); ! 3497: expand_end_bindings (decls, decls != 0, 1); ! 3498: poplevel (decls != 0, 1, 0); ! 3499: pop_momentary (); ! 3500: current_exception_type = orig_ex_type; ! 3501: current_exception_decl = orig_ex_decl; ! 3502: current_exception_object = orig_ex_obj; ! 3503: /* This will reraise for us. */ ! 3504: cplus_expand_end_except (error_mark_node); ! 3505: if (yychar == YYEMPTY) ! 3506: yychar = YYLEX; ! 3507: if (yychar != ';') ! 3508: error ("missing ';' after reraise statement"); ! 3509: } ! 3510: | try %prec EMPTY ! 3511: { yyerror ("`except' missing after `try' statement"); ! 3512: /* Terminate the binding contour started by special ! 3513: code in `.pushlevel'. Automagically pops off ! 3514: the conditional we started for `try' stmt. */ ! 3515: cplus_expand_end_try ($1); ! 3516: expand_end_bindings (0, 0, 1); ! 3517: poplevel (0, 0, 0); ! 3518: pop_momentary (); ! 3519: YYERROR; } ! 3520: ; ! 3521: ! 3522: try: try_head '}' ! 3523: /* An empty try block is degenerate, but it's better to ! 3524: do extra work here than to do all the special-case work ! 3525: everywhere else. */ ! 3526: { ! 3527: $$ = 1; ! 3528: pop_implicit_try_blocks (NULL_TREE); ! 3529: } ! 3530: | try_head stmts '}' ! 3531: { ! 3532: $$ = 1; ! 3533: pop_implicit_try_blocks (NULL_TREE); ! 3534: } ! 3535: | try_head error '}' ! 3536: { ! 3537: $$ = 0; ! 3538: pop_implicit_try_blocks (NULL_TREE); ! 3539: } ! 3540: ; ! 3541: ! 3542: label_colon: ! 3543: IDENTIFIER ':' ! 3544: { tree label; ! 3545: do_label: ! 3546: label = define_label (input_filename, lineno, $1); ! 3547: if (label) ! 3548: expand_label (label); ! 3549: } ! 3550: | PTYPENAME ':' ! 3551: { goto do_label; } ! 3552: | TYPENAME_COLON ! 3553: { tree label = define_label (input_filename, lineno, $1); ! 3554: if (label) ! 3555: expand_label (label); ! 3556: } ! 3557: ; ! 3558: ! 3559: try_head: TRY '{' { cplus_expand_start_try (0); } .pushlevel ! 3560: ! 3561: ansi_try: ansi_try_head '}' ! 3562: /* An empty try block is degenerate, but it's better to ! 3563: do extra work here than to do all the special-case work ! 3564: everywhere else. */ ! 3565: { ! 3566: $$ = 1; ! 3567: pop_implicit_try_blocks (NULL_TREE); ! 3568: } ! 3569: | ansi_try_head stmts '}' ! 3570: { ! 3571: $$ = 1; ! 3572: pop_implicit_try_blocks (NULL_TREE); ! 3573: } ! 3574: | ansi_try_head error '}' ! 3575: { ! 3576: $$ = 0; ! 3577: pop_implicit_try_blocks (NULL_TREE); ! 3578: } ! 3579: ; ! 3580: ! 3581: ansi_dummy: ; /* Temporary place-holder. */ ! 3582: ansi_try_head: ANSI_TRY '{' { cplus_expand_start_try (0); } .pushlevel ! 3583: ! 3584: except_stmts: ! 3585: /* empty */ ! 3586: { $$ = NULL_TREE; } ! 3587: | except_stmts raise_identifier ! 3588: { ! 3589: tree type = lookup_exception_type (current_class_type, current_class_name, $2); ! 3590: if (type == NULL_TREE) ! 3591: { ! 3592: error ("`%s' is not an exception type", ! 3593: IDENTIFIER_POINTER (TREE_VALUE ($2))); ! 3594: current_exception_type = NULL_TREE; ! 3595: TREE_TYPE (current_exception_object) = error_mark_node; ! 3596: } ! 3597: else ! 3598: { ! 3599: current_exception_type = type; ! 3600: /* In-place union. */ ! 3601: TREE_TYPE (current_exception_object) = type; ! 3602: } ! 3603: $2 = cplus_expand_start_catch ($2); ! 3604: pushlevel (1); ! 3605: expand_start_bindings (0); ! 3606: } ! 3607: compstmt ! 3608: { ! 3609: expand_end_bindings (0, 1, 0); ! 3610: $4 = poplevel (1, 0, 0); ! 3611: ! 3612: cplus_expand_end_catch (0); ! 3613: ! 3614: /* Mark this as a catch block. */ ! 3615: TREE_LANG_FLAG_2 ($4) = 1; ! 3616: if ($2 != error_mark_node) ! 3617: { ! 3618: tree decl = build_decl (CPLUS_CATCH_DECL, DECL_NAME ($2), 0); ! 3619: DECL_RTL (decl) = DECL_RTL ($2); ! 3620: TREE_CHAIN (decl) = BLOCK_VARS ($4); ! 3621: BLOCK_VARS ($4) = decl; ! 3622: } ! 3623: } ! 3624: | except_stmts DEFAULT ! 3625: { ! 3626: if ($1) ! 3627: error ("duplicate default in exception handler"); ! 3628: current_exception_type = NULL_TREE; ! 3629: /* Takes it right out of scope. */ ! 3630: TREE_TYPE (current_exception_object) = error_mark_node; ! 3631: ! 3632: if (! expand_catch_default ()) ! 3633: compiler_error ("default catch botch"); ! 3634: ! 3635: /* The default exception is handled as the ! 3636: last in the chain of exceptions handled. */ ! 3637: do_pending_stack_adjust (); ! 3638: $1 = make_node (RTL_EXPR); ! 3639: TREE_TYPE ($1) = void_type_node; ! 3640: start_sequence_for_rtl_expr ($1); ! 3641: } ! 3642: compstmt ! 3643: { ! 3644: extern struct rtx_def *get_insns (); ! 3645: do_pending_stack_adjust (); ! 3646: if (! expand_catch (NULL_TREE)) ! 3647: compiler_error ("except nesting botch"); ! 3648: if (! expand_end_catch ()) ! 3649: compiler_error ("except nesting botch"); ! 3650: RTL_EXPR_SEQUENCE ($1) = get_insns (); ! 3651: if ($4) ! 3652: { ! 3653: /* Mark this block as the default catch block. */ ! 3654: TREE_LANG_FLAG_1 ($4) = 1; ! 3655: TREE_LANG_FLAG_2 ($4) = 1; ! 3656: } ! 3657: end_sequence (); ! 3658: } ! 3659: ; ! 3660: ! 3661: optional_identifier: ! 3662: /* empty */ ! 3663: { $$ = NULL_TREE; } ! 3664: | identifier ; ! 3665: ! 3666: ansi_except_stmts: ! 3667: /* empty */ ! 3668: { $$ = NULL_TREE; } ! 3669: | ansi_except_stmts CATCH '(' typename optional_identifier ')' ! 3670: { ! 3671: tree type = groktypename ($4); ! 3672: current_exception_type = type; ! 3673: /* In-place union. */ ! 3674: if ($5) ! 3675: { ! 3676: tree tmp; ! 3677: tmp = pushdecl (build_decl (VAR_DECL, $5, type)); ! 3678: current_exception_object = ! 3679: build1 (INDIRECT_REF, type, tmp); ! 3680: } ! 3681: $4 = ansi_expand_start_catch(type); ! 3682: pushlevel (1); ! 3683: expand_start_bindings (0); ! 3684: } ! 3685: compstmt ! 3686: { ! 3687: expand_end_bindings (0, 1, 0); ! 3688: $8 = poplevel (1, 0, 0); ! 3689: ! 3690: cplus_expand_end_catch (0); ! 3691: ! 3692: /* Mark this as a catch block. */ ! 3693: TREE_LANG_FLAG_2 ($8) = 1; ! 3694: if ($4 != error_mark_node) ! 3695: { ! 3696: tree decl = build_decl (CPLUS_CATCH_DECL, DECL_NAME ($4), 0); ! 3697: DECL_RTL (decl) = DECL_RTL ($4); ! 3698: TREE_CHAIN (decl) = BLOCK_VARS ($8); ! 3699: BLOCK_VARS ($8) = decl; ! 3700: } ! 3701: } ! 3702: ; ! 3703: ! 3704: forhead.1: ! 3705: FOR '(' ';' ! 3706: { $$ = NULL_TREE; } ! 3707: | FOR '(' expr ';' ! 3708: { $$ = $3; } ! 3709: | FOR '(' '{' '}' ! 3710: { $$ = NULL_TREE; } ! 3711: ; ! 3712: ! 3713: forhead.2: ! 3714: FOR '(' decl ! 3715: { $$ = 0; } ! 3716: | FOR '(' error ';' ! 3717: { $$ = 0; } ! 3718: | FOR '(' '{' .pushlevel stmts '}' ! 3719: { $$ = 1; } ! 3720: | FOR '(' '{' .pushlevel error '}' ! 3721: { $$ = -1; } ! 3722: ; ! 3723: ! 3724: /* Either a type-qualifier or nothing. First thing in an `asm' statement. */ ! 3725: ! 3726: maybe_type_qual: ! 3727: /* empty */ ! 3728: { emit_line_note (input_filename, lineno); ! 3729: $$ = NULL_TREE; } ! 3730: | TYPE_QUAL ! 3731: { emit_line_note (input_filename, lineno); } ! 3732: ; ! 3733: ! 3734: xexpr: ! 3735: /* empty */ ! 3736: { $$ = NULL_TREE; } ! 3737: | expr ! 3738: | error ! 3739: { $$ = NULL_TREE; } ! 3740: ; ! 3741: ! 3742: /* These are the operands other than the first string and colon ! 3743: in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */ ! 3744: asm_operands: /* empty */ ! 3745: { $$ = NULL_TREE; } ! 3746: | nonnull_asm_operands ! 3747: ; ! 3748: ! 3749: nonnull_asm_operands: ! 3750: asm_operand ! 3751: | nonnull_asm_operands ',' asm_operand ! 3752: { $$ = chainon ($$, $3); } ! 3753: ; ! 3754: ! 3755: asm_operand: ! 3756: STRING '(' expr ')' ! 3757: { $$ = build_tree_list ($$, $3); } ! 3758: ; ! 3759: ! 3760: asm_clobbers: ! 3761: STRING ! 3762: { $$ = tree_cons (NULL_TREE, $$, NULL_TREE); } ! 3763: | asm_clobbers ',' STRING ! 3764: { $$ = tree_cons (NULL_TREE, $3, $$); } ! 3765: ; ! 3766: ! 3767: /* This is what appears inside the parens in a function declarator. ! 3768: Its value is represented in the format that grokdeclarator expects. ! 3769: ! 3770: In C++, declaring a function with no parameters ! 3771: means that that function takes *no* parameters. */ ! 3772: parmlist: /* empty */ ! 3773: { ! 3774: if (strict_prototype) ! 3775: $$ = void_list_node; ! 3776: else ! 3777: $$ = NULL_TREE; ! 3778: } ! 3779: | parms ! 3780: { ! 3781: $$ = chainon ($$, void_list_node); ! 3782: TREE_PARMLIST ($$) = 1; ! 3783: } ! 3784: | parms ',' ELLIPSIS ! 3785: { ! 3786: TREE_PARMLIST ($$) = 1; ! 3787: } ! 3788: /* C++ allows an ellipsis without a separating ',' */ ! 3789: | parms ELLIPSIS ! 3790: { ! 3791: TREE_PARMLIST ($$) = 1; ! 3792: } ! 3793: | ELLIPSIS ! 3794: { ! 3795: /* ARM $8.2.5 has this as a boxed-off comment. */ ! 3796: if (pedantic) ! 3797: warning ("use of `...' without a first argument is non-portable"); ! 3798: $$ = NULL_TREE; ! 3799: } ! 3800: | TYPENAME_ELLIPSIS ! 3801: { ! 3802: TREE_PARMLIST ($$) = 1; ! 3803: } ! 3804: | parms TYPENAME_ELLIPSIS ! 3805: { ! 3806: TREE_PARMLIST ($$) = 1; ! 3807: } ! 3808: | parms ':' ! 3809: { ! 3810: /* This helps us recover from really nasty ! 3811: parse errors, for example, a missing right ! 3812: parenthesis. */ ! 3813: yyerror ("possibly missing ')'"); ! 3814: $$ = chainon ($$, void_list_node); ! 3815: TREE_PARMLIST ($$) = 1; ! 3816: yyungetc (':', 0); ! 3817: yychar = ')'; ! 3818: } ! 3819: ; ! 3820: ! 3821: /* A nonempty list of parameter declarations or type names. */ ! 3822: parms: ! 3823: parm ! 3824: { $$ = build_tree_list (NULL_TREE, $$); } ! 3825: | parm '=' init ! 3826: { $$ = build_tree_list ($3, $$); } ! 3827: | parms ',' parm ! 3828: { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); } ! 3829: | parms ',' parm '=' init ! 3830: { $$ = chainon ($$, build_tree_list ($5, $3)); } ! 3831: | parms ',' bad_parm ! 3832: { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); } ! 3833: | parms ',' bad_parm '=' init ! 3834: { $$ = chainon ($$, build_tree_list ($5, $3)); } ! 3835: ; ! 3836: ! 3837: /* A single parameter declaration or parameter type name, ! 3838: as found in a parmlist. The first four cases make up for 10% ! 3839: of the time spent parsing C++. We cannot use them because ! 3840: of `int id[]' which won't get parsed properly. */ ! 3841: parm: ! 3842: /* ! 3843: typed_declspecs dont_see_typename '*' IDENTIFIER ! 3844: { $$ = build_tree_list ($$, build_parse_node (INDIRECT_REF, $4)); ! 3845: see_typename (); } ! 3846: | typed_declspecs dont_see_typename '&' IDENTIFIER ! 3847: { $$ = build_tree_list ($$, build_parse_node (ADDR_EXPR, $4)); ! 3848: see_typename (); } ! 3849: | TYPENAME IDENTIFIER ! 3850: { $$ = build_tree_list (list_hash_lookup_or_cons ($$), $2); } ! 3851: | TYPESPEC IDENTIFIER ! 3852: { $$ = build_tree_list (list_hash_lookup_or_cons ($$), $2); } ! 3853: | */ ! 3854: typed_declspecs dont_see_typename abs_or_notype_decl ! 3855: { $$ = build_tree_list ($$, $3); ! 3856: see_typename (); } ! 3857: | declmods dont_see_typename abs_or_notype_decl ! 3858: { $$ = build_tree_list ($$, $3); ! 3859: see_typename (); } ! 3860: ; ! 3861: ! 3862: abs_or_notype_decl: absdcl ! 3863: | notype_declarator ! 3864: | START_DECLARATOR notype_declarator ! 3865: { $$ = $2; } ! 3866: ; ! 3867: ! 3868: see_typename: type_quals ! 3869: { see_typename (); } ! 3870: ; ! 3871: ! 3872: dont_see_typename: /* empty */ ! 3873: { dont_see_typename (); } ! 3874: ; ! 3875: ! 3876: /* ! 3877: try_for_typename: ! 3878: { ! 3879: if ($<ttype>-1 == error_mark_node) ! 3880: $$ = 0; ! 3881: else ! 3882: { ! 3883: $$ = 1; ! 3884: pushclass ($<ttype>-1, 1); ! 3885: } ! 3886: } ! 3887: ; ! 3888: */ ! 3889: ! 3890: bad_parm: ! 3891: abs_or_notype_decl ! 3892: { ! 3893: warning ("type specifier omitted for parameter"); ! 3894: $$ = build_tree_list (TREE_PURPOSE (TREE_VALUE ($<ttype>-1)), $$); ! 3895: } ! 3896: ; ! 3897: ! 3898: maybe_raises: ! 3899: /* empty */ ! 3900: { $$ = NULL_TREE; } ! 3901: | RAISES raise_identifiers %prec EMPTY ! 3902: { $$ = $2; } ! 3903: | ANSI_THROW '(' ansi_raise_identifiers ')' %prec EMPTY ! 3904: { $$ = $3; } ! 3905: ; ! 3906: ! 3907: raise_identifier: ! 3908: ALL ! 3909: { $$ = void_list_node; } ! 3910: | IDENTIFIER ! 3911: { $$ = build_decl_list (NULL_TREE, $$); } ! 3912: | TYPENAME ! 3913: { $$ = build_decl_list (NULL_TREE, $$); } ! 3914: | SCOPE IDENTIFIER ! 3915: { $$ = build_decl_list (void_type_node, $2); } ! 3916: | SCOPE TYPENAME ! 3917: { $$ = build_decl_list (void_type_node, $2); } ! 3918: %ifobjc ! 3919: | OBJECTNAME ! 3920: { $$ = build_decl_list (NULL_TREE, $$); } ! 3921: %endifobjc ! 3922: | id_scope IDENTIFIER ! 3923: { $$ = build_decl_list ($$, $2); } ! 3924: | scoped_typename ! 3925: ; ! 3926: ! 3927: ansi_raise_identifier: ! 3928: typename ! 3929: { $$ = build_decl_list (NULL_TREE, $$); } ! 3930: ; ! 3931: ! 3932: raise_identifiers: ! 3933: raise_identifier ! 3934: | raise_identifiers ',' raise_identifier ! 3935: { ! 3936: TREE_CHAIN ($3) = $$; ! 3937: $$ = $3; ! 3938: } ! 3939: ; ! 3940: ! 3941: ansi_raise_identifiers: ! 3942: ansi_raise_identifier ! 3943: | ansi_raise_identifiers ',' ansi_raise_identifier ! 3944: { ! 3945: TREE_CHAIN ($3) = $$; ! 3946: $$ = $3; ! 3947: } ! 3948: ; ! 3949: ! 3950: operator_name: ! 3951: OPERATOR '*' ! 3952: { $$ = ansi_opname[MULT_EXPR]; } ! 3953: | OPERATOR '/' ! 3954: { $$ = ansi_opname[TRUNC_DIV_EXPR]; } ! 3955: | OPERATOR '%' ! 3956: { $$ = ansi_opname[TRUNC_MOD_EXPR]; } ! 3957: | OPERATOR '+' ! 3958: { $$ = ansi_opname[PLUS_EXPR]; } ! 3959: | OPERATOR '-' ! 3960: { $$ = ansi_opname[MINUS_EXPR]; } ! 3961: | OPERATOR '&' ! 3962: { $$ = ansi_opname[BIT_AND_EXPR]; } ! 3963: | OPERATOR '|' ! 3964: { $$ = ansi_opname[BIT_IOR_EXPR]; } ! 3965: | OPERATOR '^' ! 3966: { $$ = ansi_opname[BIT_XOR_EXPR]; } ! 3967: | OPERATOR '~' ! 3968: { $$ = ansi_opname[BIT_NOT_EXPR]; } ! 3969: | OPERATOR ',' ! 3970: { $$ = ansi_opname[COMPOUND_EXPR]; } ! 3971: | OPERATOR ARITHCOMPARE ! 3972: { $$ = ansi_opname[$2]; } ! 3973: | OPERATOR '<' ! 3974: { $$ = ansi_opname[LT_EXPR]; } ! 3975: | OPERATOR '>' ! 3976: { $$ = ansi_opname[GT_EXPR]; } ! 3977: | OPERATOR EQCOMPARE ! 3978: { $$ = ansi_opname[$2]; } ! 3979: | OPERATOR ASSIGN ! 3980: { $$ = ansi_assopname[$2]; } ! 3981: | OPERATOR '=' ! 3982: { ! 3983: $$ = ansi_opname [MODIFY_EXPR]; ! 3984: if (current_class_type) ! 3985: { ! 3986: TYPE_HAS_ASSIGNMENT (current_class_type) = 1; ! 3987: TYPE_GETS_ASSIGNMENT (current_class_type) = 1; ! 3988: } ! 3989: } ! 3990: | OPERATOR LSHIFT ! 3991: { $$ = ansi_opname[$2]; } ! 3992: | OPERATOR RSHIFT ! 3993: { $$ = ansi_opname[$2]; } ! 3994: | OPERATOR PLUSPLUS ! 3995: { $$ = ansi_opname[POSTINCREMENT_EXPR]; } ! 3996: | OPERATOR MINUSMINUS ! 3997: { $$ = ansi_opname[PREDECREMENT_EXPR]; } ! 3998: | OPERATOR ANDAND ! 3999: { $$ = ansi_opname[TRUTH_ANDIF_EXPR]; } ! 4000: | OPERATOR OROR ! 4001: { $$ = ansi_opname[TRUTH_ORIF_EXPR]; } ! 4002: | OPERATOR '!' ! 4003: { $$ = ansi_opname[TRUTH_NOT_EXPR]; } ! 4004: | OPERATOR '?' ':' ! 4005: { $$ = ansi_opname[COND_EXPR]; } ! 4006: | OPERATOR MIN_MAX ! 4007: { $$ = ansi_opname[$2]; } ! 4008: | OPERATOR POINTSAT %prec EMPTY ! 4009: { $$ = ansi_opname[COMPONENT_REF]; ! 4010: if (current_class_type) ! 4011: { ! 4012: tree t = current_class_type; ! 4013: while (t) ! 4014: { ! 4015: TYPE_OVERLOADS_ARROW (t) = 1; ! 4016: t = TYPE_NEXT_VARIANT (t); ! 4017: } ! 4018: } ! 4019: } ! 4020: | OPERATOR POINTSAT_STAR %prec EMPTY ! 4021: { $$ = ansi_opname[MEMBER_REF]; ! 4022: if (current_class_type) ! 4023: { ! 4024: tree t = current_class_type; ! 4025: while (t) ! 4026: { ! 4027: TYPE_OVERLOADS_ARROW (t) = 1; ! 4028: t = TYPE_NEXT_VARIANT (t); ! 4029: } ! 4030: } ! 4031: } ! 4032: | OPERATOR LEFT_RIGHT ! 4033: { $$ = ansi_opname[CALL_EXPR]; ! 4034: if (current_class_type) ! 4035: { ! 4036: tree t = current_class_type; ! 4037: while (t) ! 4038: { ! 4039: TYPE_OVERLOADS_CALL_EXPR (t) = 1; ! 4040: t = TYPE_NEXT_VARIANT (t); ! 4041: } ! 4042: } ! 4043: } ! 4044: | OPERATOR '[' ']' ! 4045: { $$ = ansi_opname[ARRAY_REF]; ! 4046: if (current_class_type) ! 4047: { ! 4048: tree t = current_class_type; ! 4049: while (t) ! 4050: { ! 4051: TYPE_OVERLOADS_ARRAY_REF (t) = 1; ! 4052: t = TYPE_NEXT_VARIANT (t); ! 4053: } ! 4054: } ! 4055: } ! 4056: | OPERATOR NEW ! 4057: { ! 4058: $$ = ansi_opname[NEW_EXPR]; ! 4059: if (current_class_type) ! 4060: { ! 4061: tree t = current_class_type; ! 4062: while (t) ! 4063: { ! 4064: TREE_GETS_NEW (t) = 1; ! 4065: t = TYPE_NEXT_VARIANT (t); ! 4066: } ! 4067: } ! 4068: } ! 4069: /* ! 4070: | OPERATOR NEW '[' ']' ! 4071: { ! 4072: $$ = ansi_opname[VEC_NEW_EXPR]; ! 4073: if (current_class_type) ! 4074: { ! 4075: tree t = current_class_type; ! 4076: while (t) ! 4077: { ! 4078: TREE_GETS_VEC_NEW (t) = 1; ! 4079: t = TYPE_NEXT_VARIANT (t); ! 4080: } ! 4081: } ! 4082: } ! 4083: */ ! 4084: | OPERATOR DELETE ! 4085: { ! 4086: $$ = ansi_opname[DELETE_EXPR]; ! 4087: if (current_class_type) ! 4088: { ! 4089: tree t = current_class_type; ! 4090: while (t) ! 4091: { ! 4092: TREE_GETS_DELETE (t) = 1; ! 4093: t = TYPE_NEXT_VARIANT (t); ! 4094: } ! 4095: } ! 4096: } ! 4097: /* ! 4098: | OPERATOR DELETE '[' ']' ! 4099: { ! 4100: $$ = ansi_opname[VEC_DELETE_EXPR]; ! 4101: if (current_class_type) ! 4102: { ! 4103: tree t = current_class_type; ! 4104: while (t) ! 4105: { ! 4106: TREE_GETS_VEC_DELETE (t) = 1; ! 4107: t = TYPE_NEXT_VARIANT (t); ! 4108: } ! 4109: } ! 4110: } ! 4111: */ ! 4112: ! 4113: /* These should do `groktypename' and set up TREE_HAS_X_CONVERSION ! 4114: here, rather than doing it in class.c . */ ! 4115: | OPERATOR typed_typespecs absdcl ! 4116: { $$ = build1 (TYPE_EXPR, $2, $3); } ! 4117: | OPERATOR error ! 4118: { $$ = ansi_opname[ERROR_MARK]; } ! 4119: ; ! 4120: ! 4121: ! 4122: /* ! 4123: * Objective-C productions. ! 4124: */ ! 4125: ! 4126: /* records the type and storage class specs to use for processing ! 4127: the declarators that follow */ ! 4128: ! 4129: %ifobjc ! 4130: .setspecs: /* empty */ ! 4131: { current_declspecs = $<ttype>0; ! 4132: $<itype>$ = suspend_momentary (); } ! 4133: ; ! 4134: ! 4135: objcdef: ! 4136: classdef ! 4137: | classdecl ! 4138: | protocoldecl ! 4139: | aliasdecl ! 4140: | protocoldef ! 4141: | methoddef ! 4142: | END ! 4143: { ! 4144: if (objc_implementation_context) ! 4145: { ! 4146: finish_class(objc_implementation_context); ! 4147: objc_ivar_chain = NULL_TREE; ! 4148: objc_implementation_context = NULL_TREE; ! 4149: } ! 4150: else ! 4151: warning("`@end' must appear in an implementation context"); ! 4152: } ! 4153: ; ! 4154: ! 4155: /* A nonempty list of identifiers. */ ! 4156: identifier_list: ! 4157: identifier ! 4158: { $$ = build_tree_list (NULL_TREE, $1); } ! 4159: | identifier_list ',' identifier ! 4160: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } ! 4161: ; ! 4162: ! 4163: classdecl: ! 4164: CLASS identifier_list ';' ! 4165: { ! 4166: objc_declare_class ($2); ! 4167: } ! 4168: ! 4169: protocoldecl: ! 4170: PROTOCOL identifier_list ';' ! 4171: { ! 4172: objc_declare_protocols ($2); ! 4173: } ! 4174: ! 4175: aliasdecl: ! 4176: ALIAS identifier identifier ';' ! 4177: { ! 4178: objc_declare_alias ($2, $3); ! 4179: } ! 4180: ! 4181: /* This is necessary for living in this c++ parser */ ! 4182: identifier_colon: ! 4183: identifier ':' ! 4184: { $$ = $1 } ! 4185: | TYPENAME_COLON ! 4186: ; ! 4187: ! 4188: classdef: ! 4189: INTERFACE identifier protocolrefs '{' ! 4190: { ! 4191: objc_interface_context = objc_ivar_context ! 4192: = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3); ! 4193: objc_public_flag = 0; ! 4194: } ! 4195: ivar_decl_list '}' ! 4196: { ! 4197: continue_class (objc_interface_context); ! 4198: } ! 4199: methodprotolist ! 4200: END ! 4201: { ! 4202: finish_class (objc_interface_context); ! 4203: objc_interface_context = NULL_TREE; ! 4204: } ! 4205: ! 4206: | INTERFACE identifier protocolrefs ! 4207: { ! 4208: objc_interface_context ! 4209: = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3); ! 4210: continue_class (objc_interface_context); ! 4211: } ! 4212: methodprotolist ! 4213: END ! 4214: { ! 4215: finish_class(objc_interface_context); ! 4216: objc_interface_context = NULL_TREE; ! 4217: } ! 4218: ! 4219: | INTERFACE identifier_colon identifier protocolrefs '{' ! 4220: { ! 4221: objc_interface_context = objc_ivar_context ! 4222: = start_class (CLASS_INTERFACE_TYPE, $2, $3, $4); ! 4223: objc_public_flag = 0; ! 4224: } ! 4225: ivar_decl_list '}' ! 4226: { ! 4227: continue_class (objc_interface_context); ! 4228: } ! 4229: methodprotolist ! 4230: END ! 4231: { ! 4232: finish_class(objc_interface_context); ! 4233: objc_interface_context = NULL_TREE; ! 4234: } ! 4235: ! 4236: | INTERFACE identifier_colon identifier protocolrefs ! 4237: { ! 4238: objc_interface_context ! 4239: = start_class (CLASS_INTERFACE_TYPE, $2, $3, $4); ! 4240: continue_class (objc_interface_context); ! 4241: } ! 4242: methodprotolist ! 4243: END ! 4244: { ! 4245: finish_class (objc_interface_context); ! 4246: objc_interface_context = NULL_TREE; ! 4247: } ! 4248: ! 4249: | IMPLEMENTATION identifier '{' ! 4250: { ! 4251: objc_implementation_context = objc_ivar_context ! 4252: = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE); ! 4253: objc_public_flag = 0; ! 4254: } ! 4255: ivar_decl_list '}' ! 4256: { ! 4257: objc_ivar_chain ! 4258: = continue_class (objc_implementation_context); ! 4259: } ! 4260: ! 4261: | IMPLEMENTATION identifier ! 4262: { ! 4263: objc_implementation_context ! 4264: = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE); ! 4265: objc_ivar_chain ! 4266: = continue_class (objc_implementation_context); ! 4267: } ! 4268: ! 4269: | IMPLEMENTATION identifier_colon identifier '{' ! 4270: { ! 4271: objc_implementation_context = objc_ivar_context ! 4272: = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $3, NULL_TREE); ! 4273: objc_public_flag = 0; ! 4274: } ! 4275: ivar_decl_list '}' ! 4276: { ! 4277: objc_ivar_chain ! 4278: = continue_class (objc_implementation_context); ! 4279: } ! 4280: ! 4281: | IMPLEMENTATION identifier_colon identifier ! 4282: { ! 4283: objc_implementation_context ! 4284: = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $3, NULL_TREE); ! 4285: objc_ivar_chain ! 4286: = continue_class (objc_implementation_context); ! 4287: } ! 4288: ! 4289: | INTERFACE identifier '(' identifier ')' protocolrefs ! 4290: { ! 4291: objc_interface_context ! 4292: = start_class (CATEGORY_INTERFACE_TYPE, $2, $4, $6); ! 4293: continue_class (objc_interface_context); ! 4294: } ! 4295: methodprotolist ! 4296: END ! 4297: { ! 4298: finish_class (objc_interface_context); ! 4299: objc_interface_context = NULL_TREE; ! 4300: } ! 4301: ! 4302: | IMPLEMENTATION identifier '(' identifier ')' ! 4303: { ! 4304: objc_implementation_context ! 4305: = start_class (CATEGORY_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE); ! 4306: objc_ivar_chain ! 4307: = continue_class (objc_implementation_context); ! 4308: } ! 4309: ; ! 4310: ! 4311: protocoldef: ! 4312: PROTOCOL identifier protocolrefs ! 4313: { ! 4314: objc_interface_context = ! 4315: start_protocol(PROTOCOL_INTERFACE_TYPE, $2, $3); ! 4316: } ! 4317: methodprotolist ! 4318: END ! 4319: { ! 4320: finish_protocol(objc_interface_context); ! 4321: objc_interface_context = NULL_TREE; ! 4322: } ! 4323: ; ! 4324: ! 4325: ivar_decl_list: ! 4326: ivar_decl_list visibility_spec ivar_decls ! 4327: | ivar_decls ! 4328: ; ! 4329: ! 4330: visibility_spec: ! 4331: PUBLIC { objc_public_flag = 1; } ! 4332: | PRIVATE { objc_public_flag = 2; } ! 4333: | PROTECTED { objc_public_flag = 0; } ! 4334: ; ! 4335: ! 4336: ivar_decls: ! 4337: /* empty */ ! 4338: { ! 4339: $$ = NULL_TREE; ! 4340: } ! 4341: | ivar_decls ivar_decl ';' ! 4342: | ivar_decls ';' ! 4343: { ! 4344: if (pedantic) ! 4345: warning ("extra semicolon in struct or union specified"); ! 4346: } ! 4347: ; ! 4348: ! 4349: ivar_decl: ! 4350: typed_typespecs .setspecs ivars ! 4351: { ! 4352: $$ = $3; ! 4353: resume_momentary ($<itype>2); ! 4354: } ! 4355: | nonempty_type_quals .setspecs ivars ! 4356: { ! 4357: $$ = $3; ! 4358: resume_momentary ($<itype>2); ! 4359: } ! 4360: | error ! 4361: { $$ = NULL_TREE; } ! 4362: ; ! 4363: ! 4364: ivars: ! 4365: /* empty */ ! 4366: { $$ = NULL_TREE; } ! 4367: | ivar_declarator ! 4368: | ivars ',' ivar_declarator ! 4369: ; ! 4370: ! 4371: ivar_declarator: ! 4372: declarator ! 4373: { ! 4374: $$ = add_instance_variable(objc_ivar_context, objc_public_flag, ! 4375: $1, current_declspecs, NULL_TREE); ! 4376: } ! 4377: | declarator ':' expr_no_commas ! 4378: { ! 4379: $$ = add_instance_variable(objc_ivar_context, objc_public_flag, ! 4380: $1, current_declspecs, $3); ! 4381: } ! 4382: | ':' expr_no_commas ! 4383: { ! 4384: $$ = add_instance_variable(objc_ivar_context, objc_public_flag, ! 4385: NULL_TREE, current_declspecs, $2); ! 4386: } ! 4387: ; ! 4388: ! 4389: methoddef: ! 4390: '+' ! 4391: { ! 4392: if (objc_implementation_context) ! 4393: objc_inherit_code = CLASS_METHOD_DECL; ! 4394: else ! 4395: fatal("Illegal method definition - must be in a class context."); ! 4396: } ! 4397: methoddecl ! 4398: { ! 4399: add_class_method(objc_implementation_context,$3); ! 4400: start_method_def ($3); ! 4401: objc_method_context = $3; ! 4402: } ! 4403: optarglist ! 4404: { ! 4405: continue_method_def(); ! 4406: } ! 4407: compstmt_or_error ! 4408: { ! 4409: finish_method_def (); ! 4410: objc_method_context = NULL_TREE; ! 4411: } ! 4412: ! 4413: | '-' ! 4414: { ! 4415: if (objc_implementation_context) ! 4416: objc_inherit_code = INSTANCE_METHOD_DECL; ! 4417: else ! 4418: fatal("Illegal method definition - must be in a class context."); ! 4419: } ! 4420: methoddecl ! 4421: { ! 4422: add_instance_method(objc_implementation_context,$3); ! 4423: start_method_def ($3); ! 4424: objc_method_context = $3; ! 4425: } ! 4426: optarglist ! 4427: { ! 4428: continue_method_def(); ! 4429: } ! 4430: compstmt_or_error ! 4431: { ! 4432: finish_method_def (); ! 4433: objc_method_context = NULL_TREE; ! 4434: } ! 4435: ; ! 4436: ! 4437: /* the reason for the strange actions in this rule ! 4438: is so that notype_initdecls when reached via datadef ! 4439: can find a valid list of type and sc specs in $0. */ ! 4440: ! 4441: methodprotolist: ! 4442: /* empty */ ! 4443: | {$<ttype>$ = NULL_TREE; } methodprotolist2 ! 4444: ; ! 4445: ! 4446: methodprotolist2: /* eliminates a shift/reduce conflict */ ! 4447: methodproto ! 4448: | datadef ! 4449: | methodprotolist2 methodproto ! 4450: | methodprotolist2 {$<ttype>$ = NULL_TREE; } datadef ! 4451: ; ! 4452: ! 4453: semi_or_error: ! 4454: ';' ! 4455: | error ! 4456: ; ! 4457: ! 4458: methodproto: ! 4459: '+' ! 4460: { ! 4461: objc_inherit_code = CLASS_METHOD_DECL; ! 4462: } ! 4463: methoddecl ! 4464: { ! 4465: add_class_method(objc_interface_context,$3); ! 4466: } ! 4467: semi_or_error ! 4468: ! 4469: | '-' ! 4470: { ! 4471: objc_inherit_code = INSTANCE_METHOD_DECL; ! 4472: } ! 4473: methoddecl ! 4474: { ! 4475: add_instance_method(objc_interface_context,$3); ! 4476: } ! 4477: semi_or_error ! 4478: ; ! 4479: ! 4480: methodtype: ! 4481: '(' ! 4482: { ! 4483: remember_protocol_qualifiers(); ! 4484: } ! 4485: typename ! 4486: { ! 4487: forget_protocol_qualifiers(); ! 4488: } ! 4489: ')' ! 4490: { $$ = $3; } ! 4491: ; ! 4492: ! 4493: methoddecl: ! 4494: methodtype unaryselector ! 4495: { ! 4496: $$ = build_method_decl (objc_inherit_code, $1, $2, NULL_TREE); ! 4497: } ! 4498: ! 4499: | unaryselector ! 4500: { ! 4501: $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, NULL_TREE); ! 4502: } ! 4503: ! 4504: | methodtype keywordselector optparmlist ! 4505: { ! 4506: $$ = build_method_decl (objc_inherit_code, $1, $2, $3); ! 4507: } ! 4508: ! 4509: | keywordselector optparmlist ! 4510: { ! 4511: $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, $2); ! 4512: } ! 4513: ; ! 4514: ! 4515: ! 4516: /* "optarglist" assumes that start_method_def() has already been called... ! 4517: if it is not, the "xdecls" will not be placed in the proper scope */ ! 4518: ! 4519: optarglist: ! 4520: /* empty */ ! 4521: | ';' myxdecls ! 4522: ; ! 4523: ! 4524: /* to get around the following situation: "int foo(int a) int b; {}" that ! 4525: is synthesized when parsing "- a:a b:b; id c; id d; { ... }" */ ! 4526: ! 4527: myxdecls: ! 4528: /* empty */ ! 4529: | mydecls ! 4530: ; ! 4531: ! 4532: mydecls: ! 4533: mydecl ! 4534: | errstmt ! 4535: | mydecls mydecl ! 4536: | mydecl errstmt ! 4537: ; ! 4538: ! 4539: mydecl: ! 4540: typed_declspecs .setspecs myparms ';' ! 4541: { resume_momentary ($<itype>2); } ! 4542: | typed_declspecs ';' ! 4543: { shadow_tag ($1); } ! 4544: | declmods ';' ! 4545: { warning ("empty declaration"); } ! 4546: ; ! 4547: ! 4548: /* this must be converted to live in the g++ world...snaroff */ ! 4549: ! 4550: myparms: ! 4551: myparm ! 4552: { objcplus_push_parm_decl ($1); } ! 4553: | myparms ',' myparm ! 4554: { objcplus_push_parm_decl ($3); } ! 4555: ; ! 4556: ! 4557: /* A single parameter declaration or parameter type name, ! 4558: as found in a parmlist. DOES NOT ALLOW AN INITIALIZER OR ASMSPEC */ ! 4559: ! 4560: myparm: ! 4561: dont_see_typename notype_declarator ! 4562: { $$ = build_tree_list (current_declspecs, $2) ; } ! 4563: | notype_declarator ! 4564: { $$ = build_tree_list (current_declspecs, $1) ; } ! 4565: | absdcl ! 4566: { $$ = build_tree_list (current_declspecs, $1) ; } ! 4567: ; ! 4568: ! 4569: optparmlist: ! 4570: /* empty */ ! 4571: { ! 4572: $$ = NULL_TREE; ! 4573: } ! 4574: | ',' ELLIPSIS ! 4575: { ! 4576: /* oh what a kludge! */ ! 4577: $$ = (tree)1; ! 4578: } ! 4579: | ',' ! 4580: { ! 4581: pushlevel (0); ! 4582: } ! 4583: parmlist ! 4584: { ! 4585: /* returns a tree list node generated by `get_parm_info()' */ ! 4586: $$ = $3; ! 4587: poplevel(0,0,0); ! 4588: } ! 4589: ; ! 4590: ! 4591: unaryselector: ! 4592: selector ! 4593: ; ! 4594: ! 4595: keywordselector: ! 4596: keyworddecl ! 4597: | keywordselector keyworddecl ! 4598: { ! 4599: $$ = chainon($1, $2); ! 4600: } ! 4601: ; ! 4602: ! 4603: selector: ! 4604: IDENTIFIER ! 4605: | TYPENAME ! 4606: | OBJECTNAME ! 4607: | reservedword ! 4608: ; ! 4609: ! 4610: reservedword: ! 4611: ENUM { $$ = get_identifier("enum"); } ! 4612: | AGGR ! 4613: { ! 4614: if (yylval.ttype == class_type_node) ! 4615: $$ = get_identifier("class"); ! 4616: else if (yylval.ttype == record_type_node) ! 4617: $$ = get_identifier("struct"); ! 4618: else if (yylval.ttype == union_type_node) ! 4619: $$ = get_identifier("union"); ! 4620: else if (yylval.ttype == enum_type_node) ! 4621: $$ = get_identifier("enum"); ! 4622: else ! 4623: abort (); ! 4624: } ! 4625: | IF { $$ = get_identifier("if"); } ! 4626: | ELSE { $$ = get_identifier("else"); } ! 4627: | WHILE { $$ = get_identifier("while"); } ! 4628: | DO { $$ = get_identifier("do"); } ! 4629: | FOR { $$ = get_identifier("for"); } ! 4630: | SWITCH { $$ = get_identifier("switch"); } ! 4631: | CASE { $$ = get_identifier("case"); } ! 4632: | DEFAULT { $$ = get_identifier("default"); } ! 4633: | BREAK { $$ = get_identifier("break"); } ! 4634: | CONTINUE { $$ = get_identifier("continue"); } ! 4635: | RETURN { $$ = get_identifier("return"); } ! 4636: | GOTO { $$ = get_identifier("goto"); } ! 4637: | ASM_KEYWORD { $$ = get_identifier("asm"); } ! 4638: | SIZEOF { $$ = get_identifier("sizeof"); } ! 4639: | TYPEOF { $$ = get_identifier("typeof"); } ! 4640: | ALIGNOF { $$ = get_identifier("alignof"); } ! 4641: | NEW { $$ = get_identifier("new"); } ! 4642: | DELETE { $$ = get_identifier("delete"); } ! 4643: | OPERATOR { $$ = get_identifier("operator"); } ! 4644: | VISSPEC { ! 4645: if ($1 == visibility_private) ! 4646: $$ = get_identifier ("private"); ! 4647: else if ($1 == visibility_public) ! 4648: $$ = get_identifier ("public"); ! 4649: else if ($1 == visibility_protected) ! 4650: $$ = get_identifier ("protected"); ! 4651: else ! 4652: abort (); ! 4653: } ! 4654: | SCSPEC { $$ = yylval.ttype; } ! 4655: | TYPESPEC { $$ = yylval.ttype; } ! 4656: | OVERLOAD { $$ = get_identifier("overload"); } ! 4657: ; ! 4658: ! 4659: keyworddecl: ! 4660: selector ':' methodtype identifier ! 4661: { ! 4662: $$ = build_keyword_decl($1, $3, $4); ! 4663: } ! 4664: ! 4665: | selector ':' identifier ! 4666: { ! 4667: $$ = build_keyword_decl($1, NULL_TREE, $3); ! 4668: } ! 4669: ! 4670: | ':' methodtype identifier ! 4671: { ! 4672: $$ = build_keyword_decl(NULL_TREE, $2, $3); ! 4673: } ! 4674: ! 4675: | ':' identifier ! 4676: { ! 4677: $$ = build_keyword_decl(NULL_TREE, NULL_TREE, $2); ! 4678: } ! 4679: ; ! 4680: ! 4681: messageargs: ! 4682: selector ! 4683: | keywordarglist ! 4684: ; ! 4685: ! 4686: keywordarglist: ! 4687: keywordarg ! 4688: | keywordarglist keywordarg ! 4689: { ! 4690: $$ = chainon($1, $2); ! 4691: } ! 4692: ; ! 4693: ! 4694: ! 4695: keywordexpr: ! 4696: nonnull_exprlist ! 4697: { ! 4698: if (TREE_CHAIN($1) == NULL_TREE) ! 4699: /* just return the expr., remove a level of indirection */ ! 4700: $$ = TREE_VALUE($1); ! 4701: else ! 4702: /* we have a comma expr., we will collapse later */ ! 4703: $$ = $1; ! 4704: } ! 4705: ; ! 4706: ! 4707: keywordarg: ! 4708: selector ':' keywordexpr ! 4709: { ! 4710: $$ = build_tree_list($1, $3); ! 4711: } ! 4712: | ':' keywordexpr ! 4713: { ! 4714: $$ = build_tree_list(NULL_TREE,$2); ! 4715: } ! 4716: ; ! 4717: ! 4718: receiver: ! 4719: nonnull_exprlist ! 4720: { ! 4721: $$ = build_x_compound_expr ($1); ! 4722: } ! 4723: | CLASSNAME ! 4724: { ! 4725: $$ = get_class_reference($1); ! 4726: } ! 4727: ; ! 4728: ! 4729: objc_openbracket.expr: ! 4730: '[' ! 4731: { objc_receiver_context = 1; objc_msg_context += 1; } ! 4732: receiver ! 4733: { objc_receiver_context = 0; $$ = $3; } ! 4734: ; ! 4735: ! 4736: objc_closebracket: ! 4737: ']' ! 4738: { objc_msg_context -= 1; } ! 4739: ; ! 4740: ! 4741: objcmessageexpr: ! 4742: objc_openbracket.expr ! 4743: messageargs ! 4744: objc_closebracket ! 4745: { ! 4746: $$ = build_tree_list($1,$2); ! 4747: TREE_TYPE ($$) = NULL_TREE; ! 4748: } ! 4749: /* ! 4750: | CLASSNAME SCOPE '[' ! 4751: { objc_receiver_context = 1; } ! 4752: receiver ! 4753: { objc_receiver_context = 0; } ! 4754: messageargs ']' ! 4755: { ! 4756: $$ = build_tree_list($5,$7); ! 4757: TREE_TYPE ($$) = get_class_reference ($1); ! 4758: } ! 4759: */ ! 4760: ; ! 4761: ! 4762: selectorarg: ! 4763: selector ! 4764: | keywordnamelist ! 4765: ; ! 4766: ! 4767: keywordnamelist: ! 4768: keywordname ! 4769: | keywordnamelist keywordname ! 4770: { ! 4771: $$ = chainon ($1, $2); ! 4772: } ! 4773: ; ! 4774: ! 4775: keywordname: ! 4776: selector ':' ! 4777: { ! 4778: $$ = build_tree_list ($1, NULL_TREE); ! 4779: } ! 4780: | ':' ! 4781: { ! 4782: $$ = build_tree_list (NULL_TREE,NULL_TREE); ! 4783: } ! 4784: | SCOPE ! 4785: { ! 4786: $$ = chainon (build_tree_list (NULL_TREE,NULL_TREE), ! 4787: build_tree_list (NULL_TREE,NULL_TREE)); ! 4788: } ! 4789: ; ! 4790: ! 4791: objcselectorexpr: ! 4792: SELECTOR '(' selectorarg ')' ! 4793: { ! 4794: $$ = $3; ! 4795: } ! 4796: ; ! 4797: ! 4798: objcprotocolexpr: ! 4799: PROTOCOL '(' identifier ')' ! 4800: { ! 4801: $$ = $3; ! 4802: } ! 4803: ; ! 4804: ! 4805: /* extension to support C-structures in the archiver */ ! 4806: ! 4807: objcencodeexpr: ! 4808: ENCODE '(' typename ')' ! 4809: { ! 4810: $$ = groktypename($3); ! 4811: } ! 4812: ; ! 4813: %endifobjc ! 4814: %% ! 4815: ! 4816: ! 4817:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.