![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-method.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cp-method.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Handle the hair of processing (but not expanding) inline functions. 1.1.1.2 ! root 2: Also manage function and variable name overloading. 1.1 root 3: Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. 4: Contributed by Michael Tiemann ([email protected]) 5: 6: This file is part of GNU CC. 7: 8: GNU CC is free software; you can redistribute it and/or modify 9: it under the terms of the GNU General Public License as published by 10: the Free Software Foundation; either version 2, or (at your option) 11: any later version. 12: 13: GNU CC is distributed in the hope that it will be useful, 14: but WITHOUT ANY WARRANTY; without even the implied warranty of 15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16: GNU General Public License for more details. 17: 18: You should have received a copy of the GNU General Public License 19: along with GNU CC; see the file COPYING. If not, write to 20: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 21: 22: 23: #ifndef PARM_CAN_BE_ARRAY_TYPE 24: #define PARM_CAN_BE_ARRAY_TYPE 1 25: #endif 26: 27: /* Handle method declarations. */ 28: #include <stdio.h> 29: #include <string.h> 30: #include "config.h" 31: #include "tree.h" 32: #include "cp-tree.h" 33: #include "cp-class.h" 34: #include "assert.h" 35: #include "obstack.h" 36: 37: #define obstack_chunk_alloc xmalloc 38: #define obstack_chunk_free free 39: 40: extern int xmalloc (); 41: extern void free (); 42: 43: /* TREE_LIST of the current inline functions that need to be 44: processed. */ 45: struct pending_inline *pending_inlines; 46: 47: /* Obstack where we build text strings for overloading, etc. */ 48: static struct obstack scratch_obstack; 49: static char *scratch_firstobj; 50: 51: # define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0) 52: # define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C))) 53: # define OB_PUTC2(C1,C2) \ 54: (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2))) 55: # define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1)) 56: # define OB_PUTID(ID) \ 57: (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \ 58: IDENTIFIER_LENGTH (ID))) 59: # define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S))) 60: # define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0')) 61: 62: /* Counter to help build parameter names in case they were omitted. */ 63: static int dummy_name; 64: static int in_parmlist; 65: 66: /* This points to a safe place to resume processing in case an expression 67: generates an error while we're trying to format it. */ 68: static int scratch_error_offset; 69: 70: static void dump_type (), dump_decl (); 71: static void dump_init (), dump_unary_op (), dump_binary_op (); 72: 73: tree wrapper_name, wrapper_pred_name, anti_wrapper_name; 74: 75: #ifdef NO_AUTO_OVERLOAD 76: int is_overloaded (); 77: #endif 78: 79: void 80: init_method () 81: { 82: char buf[sizeof (ANTI_WRAPPER_NAME_FORMAT) + 8]; 83: sprintf (buf, WRAPPER_NAME_FORMAT, ""); 84: wrapper_name = get_identifier (buf); 85: sprintf (buf, WRAPPER_PRED_NAME_FORMAT, ""); 86: wrapper_pred_name = get_identifier (buf); 87: sprintf (buf, ANTI_WRAPPER_NAME_FORMAT, ""); 88: anti_wrapper_name = get_identifier (buf); 89: gcc_obstack_init (&scratch_obstack); 90: scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0); 91: } 92: 93: /* Return a pointer to the end of the new text in INLINE_BUFFER. 94: We cannot use `fatal' or `error' in here because that 95: might cause an infinite loop. */ 96: static char * 97: new_text_len (s) 98: char *s; 99: { 100: while (*s++) ; 101: return s - 1; 102: } 103: 104: tree 105: make_anon_parm_name () 106: { 107: char buf[32]; 108: 109: sprintf (buf, ANON_PARMNAME_FORMAT, dummy_name++); 110: return get_identifier (buf); 111: } 112: 113: void 114: clear_anon_parm_name () 115: { 116: /* recycle these names. */ 117: dummy_name = 0; 118: } 119: 120: static void 121: dump_readonly_or_volatile (t) 122: tree t; 123: { 124: if (TYPE_READONLY (t)) 125: OB_PUTS ("const "); 126: if (TYPE_VOLATILE (t)) 127: OB_PUTS ("volatile "); 128: } 129: 130: static void 131: dump_aggr_type (t) 132: tree t; 133: { 134: tree name; 135: char *aggr_string; 136: char *context_string = 0; 137: 138: if (TYPE_READONLY (t)) 139: OB_PUTS ("const "); 140: if (TYPE_VOLATILE (t)) 141: OB_PUTS ("volatile "); 142: if (TREE_CODE (t) == ENUMERAL_TYPE) 143: aggr_string = "enum"; 144: else if (TREE_CODE (t) == UNION_TYPE) 145: aggr_string = "union"; 146: else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t)) 147: aggr_string = "class"; 148: else 149: aggr_string = "struct"; 150: 151: name = TYPE_NAME (t); 152: 153: if (TREE_CODE (name) == TYPE_DECL) 154: { 1.1.1.2 ! root 155: #if 0 /* not yet, should get fixed properly later */ ! 156: if (DECL_CONTEXT (name)) ! 157: context_string = TYPE_NAME_STRING (DECL_CONTEXT (name)); ! 158: #else 1.1 root 159: if (DECL_LANG_SPECIFIC (name) && DECL_CLASS_CONTEXT (name)) 160: context_string = TYPE_NAME_STRING (DECL_CLASS_CONTEXT (name)); 1.1.1.2 ! root 161: #endif 1.1 root 162: name = DECL_NAME (name); 163: } 164: 165: obstack_grow (&scratch_obstack, aggr_string, strlen (aggr_string)); 166: OB_PUTC (' '); 167: if (context_string) 168: { 1.1.1.2 ! root 169: obstack_grow (&scratch_obstack, context_string, strlen (context_string)); 1.1 root 170: OB_PUTC2 (':', ':'); 171: } 172: OB_PUTID (name); 173: } 174: 175: /* This must be large enough to hold any anonymous parm name. */ 176: static char anon_buffer[sizeof (ANON_PARMNAME_FORMAT) + 20]; 177: /* This must be large enough to hold any printed integer or floatingpoint value. */ 178: static char digit_buffer[128]; 179: 180: static void 181: dump_type_prefix (t, p) 182: tree t; 183: int *p; 184: { 185: int old_p = 0; 186: int print_struct = 1; 187: tree name; 188: 189: if (t == NULL_TREE) 190: return; 191: 192: switch (TREE_CODE (t)) 193: { 194: case ERROR_MARK: 195: sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++); 196: OB_PUTCP (anon_buffer); 197: break; 198: 199: case UNKNOWN_TYPE: 200: OB_PUTS ("<unknown type>"); 201: return; 202: 203: case TREE_LIST: 204: dump_type (TREE_VALUE (t), &old_p); 205: if (TREE_CHAIN (t)) 206: { 207: if (TREE_CHAIN (t) != void_list_node) 208: { 209: OB_PUTC (','); 210: dump_type (TREE_CHAIN (t), &old_p); 211: } 212: } 213: else OB_PUTS ("..."); 214: return; 215: 216: case POINTER_TYPE: 217: *p += 1; 218: dump_type_prefix (TREE_TYPE (t), p); 219: while (*p) 220: { 221: OB_PUTC ('*'); 222: *p -= 1; 223: } 224: if (TYPE_READONLY (t)) 225: OB_PUTS ("const "); 226: if (TYPE_VOLATILE (t)) 227: OB_PUTS ("volatile "); 228: return; 229: 230: case OFFSET_TYPE: 231: { 232: tree type = TREE_TYPE (t); 233: if (TREE_CODE (type) == FUNCTION_TYPE) 234: { 235: type = TREE_TYPE (type); 236: if (in_parmlist) 237: OB_PUTS ("auto "); 238: } 239: 240: dump_type_prefix (type, &old_p); 241: 242: OB_PUTC ('('); 243: dump_type (TYPE_OFFSET_BASETYPE (t), &old_p); 244: OB_PUTC2 (':', ':'); 245: while (*p) 246: { 247: OB_PUTC ('*'); 248: *p -= 1; 249: } 250: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 251: dump_readonly_or_volatile (t); 252: return; 253: } 254: 255: case METHOD_TYPE: 256: { 257: tree type = TREE_TYPE (t); 258: if (in_parmlist) 259: OB_PUTS ("auto "); 260: 261: dump_type_prefix (type, &old_p); 262: 263: OB_PUTC ('('); 264: dump_type (TYPE_METHOD_BASETYPE (t), &old_p); 265: OB_PUTC2 (':', ':'); 266: while (*p) 267: { 268: OB_PUTC ('*'); 269: *p -= 1; 270: } 271: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 272: dump_readonly_or_volatile (t); 273: return; 274: } 275: 276: case REFERENCE_TYPE: 277: dump_type_prefix (TREE_TYPE (t), p); 278: OB_PUTC ('&'); 279: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 280: dump_readonly_or_volatile (t); 281: return; 282: 283: case ARRAY_TYPE: 284: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 285: dump_readonly_or_volatile (t); 286: dump_type_prefix (TREE_TYPE (t), p); 287: return; 288: 289: case FUNCTION_TYPE: 290: if (in_parmlist) 291: OB_PUTS ("auto "); 292: dump_type_prefix (TREE_TYPE (t), &old_p); 293: OB_PUTC ('('); 294: while (*p) 295: { 296: OB_PUTC ('*'); 297: *p -= 1; 298: } 299: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 300: dump_readonly_or_volatile (t); 301: return; 302: 303: case IDENTIFIER_NODE: 304: OB_PUTID (t); 305: OB_PUTC (' '); 306: break; 307: 308: case RECORD_TYPE: 309: case UNION_TYPE: 310: case ENUMERAL_TYPE: 311: dump_aggr_type (t); 312: break; 313: 314: case TYPE_DECL: 315: if (TYPE_READONLY (t)) 316: OB_PUTS ("const "); 317: if (TYPE_VOLATILE (t)) 318: OB_PUTS ("volatile "); 319: OB_PUTID (DECL_NAME (t)); 320: OB_PUTC (' '); 321: break; 322: 323: case INTEGER_TYPE: 324: #if 0 325: /* Normally, `unsigned' is part of the deal. Not so if it comes 326: with `const' or `volatile'. */ 327: if (TYPE_MAIN_VARIANT (t) == unsigned_type (TYPE_MAIN_VARIANT (t)) 328: && (TYPE_READONLY (t) || TYPE_VOLATILE (t))) 329: OB_PUTS ("unsigned "); 330: #endif 331: /* fall through. */ 332: case REAL_TYPE: 333: case VOID_TYPE: 334: if (TYPE_READONLY (t)) 335: OB_PUTS ("const "); 336: if (TYPE_VOLATILE (t)) 337: OB_PUTS ("volatile "); 338: OB_PUTID (DECL_NAME (TYPE_NAME (t))); 339: OB_PUTC (' '); 340: break; 341: 342: default: 343: abort (); 344: } 345: } 346: 347: static void 348: dump_type_suffix (t, p) 349: tree t; 350: int *p; 351: { 352: int old_p = 0; 353: 354: if (t == NULL_TREE) 355: return; 356: 357: switch (TREE_CODE (t)) 358: { 359: case ERROR_MARK: 360: sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++); 361: OB_PUTCP (anon_buffer); 362: break; 363: 364: case UNKNOWN_TYPE: 365: return; 366: 367: case POINTER_TYPE: 368: dump_type_suffix (TREE_TYPE (t), p); 369: return; 370: 371: case OFFSET_TYPE: 372: { 373: tree type = TREE_TYPE (t); 374: 375: OB_PUTC (')'); 376: if (TREE_CODE (type) == FUNCTION_TYPE) 377: { 378: #if 0 379: tree next_arg = TREE_CHAIN (TYPE_ARG_TYPES (type)); 380: OB_PUTC ('('); 381: if (next_arg) 382: { 383: if (next_arg != void_list_node) 384: { 385: in_parmlist++; 386: dump_type (next_arg, &old_p); 387: in_parmlist--; 388: } 389: } 390: else OB_PUTS ("..."); 391: OB_PUTC (')'); 392: dump_type_suffix (TREE_TYPE (type), p); 393: #else 394: abort (); 395: #endif 396: } 397: return; 398: } 399: 400: case METHOD_TYPE: 401: { 402: tree next_arg; 403: OB_PUTC (')'); 404: next_arg = TREE_CHAIN (TYPE_ARG_TYPES (t)); 405: OB_PUTC ('('); 406: if (next_arg) 407: { 408: if (next_arg != void_list_node) 409: { 410: in_parmlist++; 411: dump_type (next_arg, &old_p); 412: in_parmlist--; 413: } 414: } 415: else OB_PUTS ("..."); 416: OB_PUTC (')'); 417: dump_readonly_or_volatile (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t)))); 418: dump_type_suffix (TREE_TYPE (t), p); 419: return; 420: } 421: 422: case REFERENCE_TYPE: 423: dump_type_suffix (TREE_TYPE (t), p); 424: return; 425: 426: case ARRAY_TYPE: 427: dump_type_suffix (TREE_TYPE (t), p); 428: OB_PUTC2 ('[', ']'); 429: return; 430: 431: case FUNCTION_TYPE: 432: OB_PUTC2 (')', '('); 433: if (TYPE_ARG_TYPES (t) && TYPE_ARG_TYPES (t) != void_list_node) 434: { 435: in_parmlist++; 436: dump_type (TYPE_ARG_TYPES (t), &old_p); 437: in_parmlist--; 438: } 439: OB_PUTC (')'); 440: dump_type_suffix (TREE_TYPE (t), p); 441: return; 442: 443: case IDENTIFIER_NODE: 444: case RECORD_TYPE: 445: case UNION_TYPE: 446: case ENUMERAL_TYPE: 447: case TYPE_DECL: 448: case INTEGER_TYPE: 449: case REAL_TYPE: 450: case VOID_TYPE: 451: return; 452: 453: default: 454: abort (); 455: } 456: } 457: 458: static void 459: dump_type (t, p) 460: tree t; 461: int *p; 462: { 463: int old_p = 0; 464: int print_struct = 1; 465: 466: if (t == NULL_TREE) 467: return; 468: 469: switch (TREE_CODE (t)) 470: { 471: case ERROR_MARK: 472: sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++); 473: OB_PUTCP (anon_buffer); 474: break; 475: 476: case UNKNOWN_TYPE: 477: OB_PUTS ("<unknown type>"); 478: return; 479: 480: case TREE_LIST: 481: dump_type (TREE_VALUE (t), &old_p); 482: if (TREE_CHAIN (t)) 483: { 484: if (TREE_CHAIN (t) != void_list_node) 485: { 486: OB_PUTC (','); 487: dump_type (TREE_CHAIN (t), &old_p); 488: } 489: } 490: else OB_PUTS ("..."); 491: return; 492: 493: case POINTER_TYPE: 494: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 495: dump_readonly_or_volatile (t); 496: *p += 1; 497: dump_type (TREE_TYPE (t), p); 498: while (*p) 499: { 500: OB_PUTC ('*'); 501: *p -= 1; 502: } 503: return; 504: 505: case REFERENCE_TYPE: 506: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 507: dump_readonly_or_volatile (t); 508: dump_type (TREE_TYPE (t), p); 509: OB_PUTC ('&'); 510: return; 511: 512: case ARRAY_TYPE: 513: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 514: dump_readonly_or_volatile (t); 515: dump_type (TREE_TYPE (t), p); 516: OB_PUTC2 ('[', ']'); 517: return; 518: 519: case OFFSET_TYPE: 520: case METHOD_TYPE: 521: case FUNCTION_TYPE: 522: dump_type_prefix (t, p); 523: dump_type_suffix (t, p); 524: return; 525: 526: case IDENTIFIER_NODE: 527: OB_PUTID (t); 528: OB_PUTC (' '); 529: break; 530: 531: case RECORD_TYPE: 532: case UNION_TYPE: 533: case ENUMERAL_TYPE: 534: dump_aggr_type (t); 535: break; 536: 537: case TYPE_DECL: 538: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 539: dump_readonly_or_volatile (t); 540: OB_PUTID (DECL_NAME (t)); 541: OB_PUTC (' '); 542: break; 543: 544: case INTEGER_TYPE: 545: /* Normally, `unsigned' is part of the deal. Not so if it comes 546: with `const' or `volatile'. */ 547: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 548: dump_readonly_or_volatile (t); 549: #if 0 550: if (TYPE_MAIN_VARIANT (t) == unsigned_type (TYPE_MAIN_VARIANT (t)) 551: && (TYPE_READONLY (t) | TYPE_VOLATILE (t))) 552: OB_PUTS ("unsigned "); 553: #endif 554: OB_PUTID (DECL_NAME (TYPE_NAME (t))); 555: OB_PUTC (' '); 556: break; 557: 558: case REAL_TYPE: 559: case VOID_TYPE: 560: if (TYPE_READONLY (t) | TYPE_VOLATILE (t)) 561: dump_readonly_or_volatile (t); 562: OB_PUTID (DECL_NAME (TYPE_NAME (t))); 563: OB_PUTC (' '); 564: break; 565: 566: case TEMPLATE_TYPE_PARM: 567: OB_PUTS ("<template type parm "); 568: OB_PUTID (DECL_NAME (TYPE_NAME (t))); 569: OB_PUTC ('>'); 570: break; 571: 572: case UNINSTANTIATED_P_TYPE: 573: OB_PUTID (DECL_NAME (UPT_TEMPLATE (t))); 574: OB_PUTS ("<...>"); 575: break; 576: 577: default: 578: abort (); 579: } 580: } 581: 582: static void 583: dump_decl (t) 584: tree t; 585: { 586: int p = 0; 587: 588: if (t == NULL_TREE) 589: return; 590: 591: switch (TREE_CODE (t)) 592: { 593: case ERROR_MARK: 594: OB_PUTS (" /* decl error */ "); 595: break; 596: 597: case PARM_DECL: 598: dump_type_prefix (TREE_TYPE (t), &p); 599: if (DECL_NAME (t)) 600: dump_decl (DECL_NAME (t)); 601: else 602: { 603: sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++); 604: OB_PUTCP (anon_buffer); 605: break; 606: } 607: dump_type_suffix (TREE_TYPE (t), &p); 608: return; 609: 610: case CALL_EXPR: 611: dump_decl (TREE_OPERAND (t, 0)); 612: OB_PUTC ('('); 613: in_parmlist++; 614: dump_decl (TREE_OPERAND (t, 1)); 615: in_parmlist--; 616: t = tree_last (TYPE_ARG_TYPES (TREE_TYPE (t))); 617: if (!t || t != void_list_node) 618: OB_PUTS ("..."); 619: OB_PUTC (')'); 620: return; 621: 622: case ARRAY_REF: 623: dump_decl (TREE_OPERAND (t, 0)); 624: OB_PUTC ('['); 625: dump_decl (TREE_OPERAND (t, 1)); 626: OB_PUTC (']'); 627: return; 628: 629: case TYPE_DECL: 630: OB_PUTID (DECL_NAME (t)); 631: OB_PUTC (' '); 632: break; 633: 634: case TYPE_EXPR: 635: abort (); 636: break; 637: 638: case IDENTIFIER_NODE: 1.1.1.2 ! root 639: if (t == ansi_opname[(int) TYPE_EXPR]) 1.1 root 640: { 641: OB_PUTS ("operator "); 642: /* Not exactly IDENTIFIER_TYPE_VALUE. */ 643: dump_type (TREE_TYPE (t), &p); 644: return; 645: } 646: else if (IDENTIFIER_OPNAME_P (t)) 647: { 648: char *name_string = operator_name_string (t); 649: OB_PUTS ("operator "); 650: OB_PUTCP (name_string); 651: OB_PUTC (' '); 652: } 653: else 654: { 655: OB_PUTID (t); 656: OB_PUTC (' '); 657: } 658: break; 659: 660: case BIT_NOT_EXPR: 661: OB_PUTC2 ('~', ' '); 662: dump_decl (TREE_OPERAND (t, 0)); 663: return; 664: 665: case SCOPE_REF: 666: OB_PUTID (TREE_OPERAND (t, 0)); 667: OB_PUTC2 (':', ':'); 668: dump_decl (TREE_OPERAND (t, 1)); 669: return; 670: 671: case INDIRECT_REF: 672: OB_PUTC ('*'); 673: dump_decl (TREE_OPERAND (t, 0)); 674: return; 675: 676: case ADDR_EXPR: 677: OB_PUTC ('&'); 678: dump_decl (TREE_OPERAND (t, 0)); 679: return; 680: 681: default: 682: abort (); 683: } 684: } 685: 686: static void 687: dump_init_list (l) 688: tree l; 689: { 690: while (l) 691: { 692: dump_init (TREE_VALUE (l)); 693: if (TREE_CHAIN (l)) 694: OB_PUTC (','); 695: l = TREE_CHAIN (l); 696: } 697: } 698: 699: static void 700: dump_init (t) 701: tree t; 702: { 703: int dummy; 704: 705: switch (TREE_CODE (t)) 706: { 707: case VAR_DECL: 708: case PARM_DECL: 709: OB_PUTC (' '); 710: OB_PUTID (DECL_NAME (t)); 711: OB_PUTC (' '); 712: break; 713: 714: case FUNCTION_DECL: 715: { 716: tree name = DECL_ASSEMBLER_NAME (t); 717: 718: if (DESTRUCTOR_NAME_P (name)) 719: { 720: OB_PUTC2 (' ', '~'); 721: OB_PUTID (DECL_NAME (t)); 722: } 723: else if (IDENTIFIER_TYPENAME_P (name)) 724: { 725: dummy = 0; 726: OB_PUTS ("operator "); 727: dump_type (TREE_TYPE (name), &dummy); 728: } 729: else if (IDENTIFIER_OPNAME_P (name)) 730: { 731: char *name_string = operator_name_string (name); 732: OB_PUTS ("operator "); 733: OB_PUTCP (name_string); 734: OB_PUTC (' '); 735: } 736: #if 0 737: else if (WRAPPER_NAME_P (name)) 738: sprintf (inline_bufp, " ()%s", IDENTIFIER_POINTER (DECL_NAME (t))); 739: else if (WRAPPER_PRED_NAME_P (name)) 740: sprintf (inline_bufp, " ()?%s", IDENTIFIER_POINTER (DECL_NAME (t))); 741: else if (ANTI_WRAPPER_NAME_P (name)) 742: sprintf (inline_bufp, " ~()%s", IDENTIFIER_POINTER (DECL_NAME (t))); 743: #endif 744: else 745: { 746: OB_PUTC (' '); 747: OB_PUTID (DECL_NAME (t)); 748: } 749: OB_PUTC (' '); 750: } 751: break; 752: 753: case CONST_DECL: 754: dummy = 0; 755: OB_PUTC2 ('(', '('); 756: dump_type (TREE_TYPE (t), &dummy); 757: OB_PUTC (')'); 758: dump_init (DECL_INITIAL (t)); 759: OB_PUTC (')'); 760: return; 761: 762: case INTEGER_CST: 763: sprintf (digit_buffer, " %d ", TREE_INT_CST_LOW (t)); 764: OB_PUTCP (digit_buffer); 765: break; 766: 767: case REAL_CST: 768: sprintf (digit_buffer, " %g ", TREE_REAL_CST (t)); 769: OB_PUTCP (digit_buffer); 770: break; 771: 772: case STRING_CST: 773: { 774: char *p = TREE_STRING_POINTER (t); 775: int len = TREE_STRING_LENGTH (t) - 1; 776: int i; 777: 778: OB_PUTC ('\"'); 779: for (i = 0; i < len; i++) 780: { 781: register char c = p[i]; 782: if (c == '\"' || c == '\\') 783: OB_PUTC ('\\'); 784: if (c >= ' ' && c < 0177) 785: OB_PUTC (c); 786: else 787: { 788: sprintf (digit_buffer, "\\%03o", c); 789: OB_PUTCP (digit_buffer); 790: } 791: } 792: OB_PUTC ('\"'); 793: } 794: return; 795: 796: case COMPOUND_EXPR: 797: dump_binary_op (",", t, 1); 798: break; 799: 800: case COND_EXPR: 801: OB_PUTC ('('); 802: dump_init (TREE_OPERAND (t, 0)); 803: OB_PUTS (" ? "); 804: dump_init (TREE_OPERAND (t, 1)); 805: OB_PUTS (" : "); 806: dump_init (TREE_OPERAND (t, 2)); 807: OB_PUTC (')'); 808: return; 809: 810: case SAVE_EXPR: 811: if (TREE_HAS_CONSTRUCTOR (t)) 812: { 813: dummy = 0; 814: OB_PUTS ("new "); 815: dump_type (TREE_TYPE (TREE_TYPE (t)), &dummy); 816: PARM_DECL_EXPR (t) = 1; 817: } 818: else 819: { 820: sorry ("operand of SAVE_EXPR not understood"); 821: scratch_obstack.next_free 822: = obstack_base (&scratch_obstack) + scratch_error_offset; 823: } 824: return; 825: 826: case NEW_EXPR: 827: OB_PUTID (DECL_NAME (TYPE_NAME (TREE_TYPE (t)))); 828: OB_PUTC ('('); 829: dump_init_list (TREE_CHAIN (TREE_OPERAND (t, 1))); 830: OB_PUTC (')'); 831: return; 832: 833: case CALL_EXPR: 834: OB_PUTC ('('); 835: dump_init (TREE_OPERAND (t, 0)); 836: dump_init_list (TREE_OPERAND (t, 1)); 837: OB_PUTC (')'); 838: return; 839: 840: case WITH_CLEANUP_EXPR: 841: /* Note that this only works for G++ cleanups. If somebody 842: builds a general cleanup, there's no way to represent it. */ 843: dump_init (TREE_OPERAND (t, 0)); 844: return; 845: 846: case TARGET_EXPR: 847: /* Note that this only works for G++ target exprs. If somebody 848: builds a general TARGET_EXPR, there's no way to represent that 849: it initializes anything other that the parameter slot for the 850: default argument. */ 851: dump_init (TREE_OPERAND (t, 1)); 852: return; 853: 854: case MODIFY_EXPR: 855: case PLUS_EXPR: 856: case MINUS_EXPR: 857: case MULT_EXPR: 858: case TRUNC_DIV_EXPR: 859: case TRUNC_MOD_EXPR: 860: case MIN_EXPR: 861: case MAX_EXPR: 862: case LSHIFT_EXPR: 863: case RSHIFT_EXPR: 864: case BIT_IOR_EXPR: 865: case BIT_XOR_EXPR: 866: case BIT_AND_EXPR: 867: case BIT_ANDTC_EXPR: 868: case TRUTH_ANDIF_EXPR: 869: case TRUTH_ORIF_EXPR: 870: case LT_EXPR: 871: case LE_EXPR: 872: case GT_EXPR: 873: case GE_EXPR: 874: case EQ_EXPR: 875: case NE_EXPR: 876: dump_binary_op (opname_tab[(int) TREE_CODE (t)], t, 877: strlen (opname_tab[(int) TREE_CODE (t)])); 878: return; 879: 880: case CEIL_DIV_EXPR: 881: case FLOOR_DIV_EXPR: 882: case ROUND_DIV_EXPR: 883: dump_binary_op ("/", t, 1); 884: return; 885: 886: case CEIL_MOD_EXPR: 887: case FLOOR_MOD_EXPR: 888: case ROUND_MOD_EXPR: 889: dump_binary_op ("%", t, 1); 890: return; 891: 892: case COMPONENT_REF: 893: dump_binary_op (".", t, 1); 894: return; 895: 896: case CONVERT_EXPR: 897: dump_unary_op ("+", t, 1); 898: return; 899: 900: case ADDR_EXPR: 901: if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL 902: || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST) 903: dump_init (TREE_OPERAND (t, 0)); 904: else 905: dump_unary_op ("&", t, 1); 906: return; 907: 908: case INDIRECT_REF: 1.1.1.2 ! root 909: if (TREE_HAS_CONSTRUCTOR (t)) ! 910: { ! 911: t = TREE_OPERAND (t, 0); ! 912: assert (TREE_CODE (t) == CALL_EXPR); ! 913: dump_init (TREE_OPERAND (t, 0)); ! 914: OB_PUTC ('('); ! 915: dump_init_list (TREE_CHAIN (TREE_OPERAND (t, 1))); ! 916: OB_PUTC (')'); ! 917: } ! 918: else ! 919: dump_unary_op ("*", t, 1); 1.1 root 920: return; 921: 922: case NEGATE_EXPR: 923: case BIT_NOT_EXPR: 924: case TRUTH_NOT_EXPR: 925: case PREDECREMENT_EXPR: 926: case PREINCREMENT_EXPR: 927: dump_unary_op (opname_tab [(int)TREE_CODE (t)], t, 928: strlen (opname_tab[(int) TREE_CODE (t)])); 929: return; 930: 931: case POSTDECREMENT_EXPR: 932: case POSTINCREMENT_EXPR: 933: OB_PUTC ('('); 934: dump_init (TREE_OPERAND (t, 0)); 935: OB_PUTCP (opname_tab[(int)TREE_CODE (t)]); 936: OB_PUTC (')'); 937: return; 938: 939: case NOP_EXPR: 940: dummy = 0; 941: OB_PUTC2 ('(', '('); 942: dump_type (TREE_TYPE (t), &dummy); 943: OB_PUTC (')'); 944: dump_init (TREE_OPERAND (t, 0)); 945: OB_PUTC (')'); 946: return; 947: 948: case CONSTRUCTOR: 949: OB_PUTC ('{'); 950: dump_init_list (CONSTRUCTOR_ELTS (t)); 951: OB_PUTC ('}'); 952: return; 953: 954: /* This list is incomplete, but should suffice for now. 955: It is very important that `sorry' does not call 956: `report_error_function'. That could cause an infinite loop. */ 957: default: 958: sorry ("`%s' not supported for default parameters", 959: tree_code_name[(int) TREE_CODE (t)]); 960: 961: /* fall through to ERROR_MARK... */ 962: case ERROR_MARK: 963: scratch_obstack.next_free 964: = obstack_base (&scratch_obstack) + scratch_error_offset; 965: return; 966: } 967: } 968: 969: static void 970: dump_binary_op (opstring, t, len) 971: char *opstring; 972: tree t; 973: int len; 974: { 975: OB_PUTC ('('); 976: dump_init (TREE_OPERAND (t, 0)); 977: OB_PUTC (' '); 978: OB_PUTCP (opstring); 979: OB_PUTC (' '); 980: dump_init (TREE_OPERAND (t, 1)); 981: OB_PUTC (')'); 982: } 983: 984: static void 985: dump_unary_op (opstring, t, len) 986: char *opstring; 987: tree t; 988: int len; 989: { 990: OB_PUTC ('('); 991: OB_PUTC (' '); 992: OB_PUTCP (opstring); 993: OB_PUTC (' '); 994: dump_init (TREE_OPERAND (t, 0)); 995: OB_PUTC (')'); 996: } 997: 998: /* Pretty printing for announce_function. CNAME is the TYPE_DECL for 999: the class that FNDECL belongs to, if we could not figure that out 1000: from FNDECL itself. FNDECL is the declaration of the function we 1001: are interested in seeing. PRINT_RET_TYPE_P is non-zero if we 1002: should print the type that this function returns. */ 1003: 1004: char * 1005: fndecl_as_string (cname, fndecl, print_ret_type_p) 1006: tree cname, fndecl; 1007: int print_ret_type_p; 1008: { 1009: tree name = DECL_ASSEMBLER_NAME (fndecl); 1010: tree fntype = TREE_TYPE (fndecl); 1011: tree parmtypes = TYPE_ARG_TYPES (fntype); 1012: int p = 0; 1013: int spaces = 0; 1014: 1015: OB_INIT (); 1016: 1017: if (DECL_CLASS_CONTEXT (fndecl)) 1018: cname = TYPE_NAME (DECL_CLASS_CONTEXT (fndecl)); 1019: 1020: if (print_ret_type_p && ! IDENTIFIER_TYPENAME_P (name)) 1021: { 1022: dump_type_prefix (TREE_TYPE (fntype), &p); 1023: OB_PUTC (' '); 1024: } 1025: if (DECL_STATIC_FUNCTION_P (fndecl)) 1026: OB_PUTS ("static "); 1027: 1028: if (cname) 1029: { 1030: dump_type (cname, &p); 1031: *((char *) obstack_next_free (&scratch_obstack) - 1) = ':'; 1032: OB_PUTC (':'); 1033: if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes) 1034: parmtypes = TREE_CHAIN (parmtypes); 1035: if (DECL_CONSTRUCTOR_FOR_VBASE_P (fndecl)) 1036: /* Skip past "in_charge" identifier. */ 1037: parmtypes = TREE_CHAIN (parmtypes); 1038: } 1039: 1040: if (DESTRUCTOR_NAME_P (name)) 1041: { 1042: OB_PUTC ('~'); 1043: parmtypes = TREE_CHAIN (parmtypes); 1044: dump_decl (DECL_NAME (fndecl)); 1045: } 1046: else if (IDENTIFIER_TYPENAME_P (name)) 1047: { 1048: /* This cannot use the hack that the operator's return 1049: type is stashed off of its name because it may be 1050: used for error reporting. In the case of conflicting 1051: declarations, both will have the same name, yet 1052: the types will be different, hence the TREE_TYPE field 1053: of the first name will be clobbered by the second. */ 1054: OB_PUTS ("operator "); 1055: dump_type (TREE_TYPE (TREE_TYPE (fndecl)), &p); 1056: } 1057: else if (IDENTIFIER_OPNAME_P (name)) 1058: { 1059: char *name_string = operator_name_string (name); 1060: OB_PUTS ("operator "); 1061: OB_PUTCP (name_string); 1062: OB_PUTC (' '); 1063: } 1064: else if (DECL_CONSTRUCTOR_P (fndecl)) 1065: { 1066: #ifdef SOS 1067: if (TYPE_DYNAMIC (IDENTIFIER_TYPE_VALUE (cname))) 1068: { 1069: OB_PUTS ("dynamic "); 1070: parmtypes = TREE_CHAIN (parmtypes); 1071: } 1072: #endif 1073: dump_decl (DECL_NAME (fndecl)); 1074: } 1075: else 1076: { 1077: #if 0 1078: if (WRAPPER_NAME_P (name)) 1079: OB_PUTC2 ('(', ')'); 1080: if (WRAPPER_PRED_NAME_P (name)) 1081: OB_PUTS ("()?"); 1082: else if (ANTI_WRAPPER_NAME_P (name)) 1083: OB_PUTS ("~()"); 1084: #endif 1085: dump_decl (DECL_NAME (fndecl)); 1086: } 1087: 1088: OB_PUTC ('('); 1089: if (parmtypes) 1090: { 1091: in_parmlist++; 1092: if (parmtypes != void_list_node) 1093: spaces = 2; 1094: while (parmtypes && parmtypes != void_list_node) 1095: { 1096: char *last_space; 1097: dump_type (TREE_VALUE (parmtypes), &p); 1098: last_space = (char *)obstack_next_free (&scratch_obstack); 1099: while (last_space[-1] == ' ') 1100: last_space--; 1101: scratch_obstack.next_free = last_space; 1102: if (TREE_PURPOSE (parmtypes)) 1103: { 1104: scratch_error_offset = obstack_object_size (&scratch_obstack); 1105: OB_PUTS (" (= "); 1106: dump_init (TREE_PURPOSE (parmtypes)); 1107: OB_PUTC (')'); 1108: } 1109: OB_PUTC2 (',', ' '); 1110: parmtypes = TREE_CHAIN (parmtypes); 1111: } 1112: in_parmlist--; 1113: } 1114: 1115: if (parmtypes) 1116: { 1117: if (spaces) 1118: scratch_obstack.next_free = obstack_next_free (&scratch_obstack)-spaces; 1119: } 1120: else 1121: OB_PUTS ("..."); 1122: 1123: OB_PUTC (')'); 1124: 1125: if (print_ret_type_p && ! IDENTIFIER_TYPENAME_P (name)) 1126: dump_type_suffix (TREE_TYPE (fntype), &p); 1127: 1128: if (TREE_CODE (fntype) == METHOD_TYPE) 1129: dump_readonly_or_volatile (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)))); 1130: 1131: OB_FINISH (); 1132: 1133: return (char *)obstack_base (&scratch_obstack); 1134: } 1135: 1136: /* Same, but handtype a _TYPE. */ 1137: char * 1138: type_as_string (buf, typ) 1139: char *buf; 1140: tree typ; 1141: { 1142: int p = 0; 1143: int spaces = 0; 1144: 1145: OB_INIT (); 1146: 1147: dump_type(typ,&p); 1148: 1149: OB_FINISH (); 1150: 1151: return (char *)obstack_base (&scratch_obstack); 1152: } 1153: 1.1.1.2 ! root 1154: /* Move inline function definitions out of structure so that they 1.1 root 1155: can be processed normally. CNAME is the name of the class 1156: we are working from, METHOD_LIST is the list of method lists 1157: of the structure. We delete friend methods here, after 1158: saving away their inline function definitions (if any). */ 1159: 1160: void 1161: do_inline_function_hair (type, friend_list) 1162: tree type, friend_list; 1163: { 1164: tree cname = TYPE_IDENTIFIER (type); 1165: tree method = TYPE_METHODS (type); 1166: 1167: if (method && TREE_CODE (method) == TREE_VEC) 1168: { 1169: if (TREE_VEC_ELT (method, 0)) 1170: method = TREE_VEC_ELT (method, 0); 1171: else 1172: method = TREE_VEC_ELT (method, 1); 1173: } 1174: 1175: while (method) 1176: { 1177: /* Do inline member functions. */ 1178: struct pending_inline *info = DECL_PENDING_INLINE_INFO (method); 1179: if (info) 1180: { 1181: tree args; 1182: 1183: assert (info->fndecl == method); 1184: args = DECL_ARGUMENTS (method); 1185: while (args) 1186: { 1187: DECL_CONTEXT (args) = method; 1188: args = TREE_CHAIN (args); 1189: } 1190: 1191: /* Allow this decl to be seen in global scope */ 1192: IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (method)) = method; 1193: } 1194: method = TREE_CHAIN (method); 1195: } 1196: while (friend_list) 1197: { 1198: tree fndecl = TREE_VALUE (friend_list); 1199: struct pending_inline *info = DECL_PENDING_INLINE_INFO (fndecl); 1200: if (info) 1201: { 1202: tree args; 1203: 1204: assert (info->fndecl == fndecl); 1205: args = DECL_ARGUMENTS (fndecl); 1206: while (args) 1207: { 1208: DECL_CONTEXT (args) = fndecl; 1209: args = TREE_CHAIN (args); 1210: } 1211: 1212: /* Allow this decl to be seen in global scope */ 1213: IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (fndecl)) = fndecl; 1214: } 1215: 1216: friend_list = TREE_CHAIN (friend_list); 1217: } 1218: } 1219: 1220: /* Report a argument type mismatch between the best declared function 1221: we could find and the current argument list that we have. */ 1222: void 1223: report_type_mismatch (cp, parmtypes, name_kind, err_name) 1224: struct candidate *cp; 1225: tree parmtypes; 1226: char *name_kind, *err_name; 1227: { 1228: int i = cp->u.bad_arg; 1229: tree ttf, tta; 1230: char *tmp_firstobj; 1231: 1232: switch (i) 1233: { 1234: case -4: 1235: assert (TREE_CODE (cp->function) == TEMPLATE_DECL); 1236: error ("type unification failed for function template `%s'", err_name); 1237: return; 1238: 1239: case -3: 1240: if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes)))) 1241: error ("call to const %s `%s' with non-const object", name_kind, err_name); 1242: else 1243: error ("call to non-const %s `%s' with const object", name_kind, err_name); 1244: return; 1245: case -2: 1246: error ("too few arguments for %s `%s'", name_kind, err_name); 1247: return; 1248: case -1: 1249: error ("too many arguments for %s `%s'", name_kind, err_name); 1250: return; 1251: case 0: 1252: if (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE) 1253: { 1254: /* Happens when we have an ambiguous base class. */ 1255: assert (get_binfo (DECL_CLASS_CONTEXT (cp->function), 1256: TREE_TYPE (TREE_TYPE (TREE_VALUE (parmtypes))), 1) == error_mark_node); 1257: return; 1258: } 1259: } 1260: 1261: ttf = TYPE_ARG_TYPES (TREE_TYPE (cp->function)); 1262: tta = parmtypes; 1263: 1264: while (i-- > 0) 1265: { 1266: ttf = TREE_CHAIN (ttf); 1267: tta = TREE_CHAIN (tta); 1268: } 1269: 1270: OB_INIT (); 1271: OB_PUTS ("bad argument "); 1272: sprintf (digit_buffer, "%d", 1273: cp->u.bad_arg - (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)); 1274: OB_PUTCP (digit_buffer); 1275: OB_PUTS (" for function `"); 1276: 1277: tmp_firstobj = scratch_firstobj; 1278: scratch_firstobj = 0; 1279: fndecl_as_string (0, cp->function, 0); 1280: scratch_firstobj = tmp_firstobj; 1281: 1282: /* We know that the last char written is next_free-1. */ 1283: ((char *) obstack_next_free (&scratch_obstack))[-1] = '\''; 1284: OB_PUTS (" (type was "); 1285: 1286: /* Reset `i' so that type printing routines do the right thing. */ 1287: if (tta) 1288: { 1289: enum tree_code code = TREE_CODE (TREE_TYPE (TREE_VALUE (tta))); 1290: if (code == ERROR_MARK) 1.1.1.2 ! root 1291: OB_PUTS ("(failed type instantiation)"); 1.1 root 1292: else 1293: { 1294: i = (code == FUNCTION_TYPE || code == METHOD_TYPE); 1295: dump_type (TREE_TYPE (TREE_VALUE (tta)), &i); 1296: } 1297: } 1298: else OB_PUTS ("void"); 1299: OB_PUTC (')'); 1300: OB_FINISH (); 1301: 1302: tmp_firstobj = (char *)alloca (obstack_object_size (&scratch_obstack)); 1303: bcopy (obstack_base (&scratch_obstack), tmp_firstobj, 1304: obstack_object_size (&scratch_obstack)); 1305: error (tmp_firstobj); 1306: } 1307: 1308: /* Here is where overload code starts. */ 1309: 1310: /* Array of types seen so far in top-level call to `build_overload_name'. 1311: Allocated and deallocated by caller. */ 1312: static tree *typevec; 1313: 1314: /* Number of types interned by `build_overload_name' so far. */ 1315: static int maxtype; 1316: 1.1.1.2 ! root 1317: /* Number of occurrences of last type seen. */ 1.1 root 1318: static int nrepeats; 1319: 1320: /* Nonzero if we should not try folding parameter types. */ 1321: static int nofold; 1322: 1323: #define ALLOCATE_TYPEVEC(PARMTYPES) \ 1324: do { maxtype = 0, nrepeats = 0; \ 1325: typevec = (tree *)alloca (list_length (PARMTYPES) * sizeof (tree)); } while (0) 1326: 1327: #define DEALLOCATE_TYPEVEC(PARMTYPES) \ 1328: do { tree t = (PARMTYPES); \ 1329: while (t) { TREE_USED (TREE_VALUE (t)) = 0; t = TREE_CHAIN (t); } \ 1330: } while (0) 1331: 1332: /* Code to concatenate an asciified integer to a string, 1333: and return the end of the string. */ 1334: static 1335: #ifdef __GNUC__ 1336: __inline 1337: #endif 1338: char * 1339: icat (i) 1340: int i; 1341: { 1342: if (i < 0) 1343: { 1344: OB_PUTC ('m'); 1345: i = -i; 1346: } 1347: if (i < 10) 1348: OB_PUTC ('0' + i); 1349: else 1350: { 1351: icat (i / 10); 1352: OB_PUTC ('0' + (i % 10)); 1353: } 1354: } 1355: 1356: static 1357: #ifdef __GNUC__ 1358: __inline 1359: #endif 1360: void 1361: flush_repeats (type) 1362: tree type; 1363: { 1364: int tindex = 0; 1365: char *rval; 1366: 1367: while (typevec[tindex] != type) 1368: tindex++; 1369: 1370: if (nrepeats > 1) 1371: { 1372: OB_PUTC ('N'); 1373: icat (nrepeats); 1374: if (nrepeats > 9) 1375: OB_PUTC ('_'); 1376: } 1377: else 1378: OB_PUTC ('T'); 1379: nrepeats = 0; 1380: icat (tindex); 1381: if (tindex > 9) 1382: OB_PUTC ('_'); 1383: } 1384: 1385: static void build_overload_identifier (); 1386: 1387: static void 1388: build_overload_nested_name (context) 1389: tree context; 1390: { 1391: tree name = DECL_ASSEMBLER_NAME (context); 1392: if (DECL_CONTEXT (context)) 1393: { 1394: context = DECL_CONTEXT (context); 1395: if (TREE_CODE_CLASS (TREE_CODE (context)) == 't') 1396: context = TYPE_NAME (context); 1397: build_overload_nested_name (context); 1398: } 1399: build_overload_identifier (name); 1400: } 1401: 1402: static void 1403: build_overload_value (type, value) 1404: tree type, value; 1405: { 1406: char buf[40]; 1407: while (TREE_CODE (value) == NON_LVALUE_EXPR) 1408: value = TREE_OPERAND (value, 0); 1409: assert (TREE_CODE (type) == PARM_DECL); 1410: type = TREE_TYPE (type); 1411: switch (TREE_CODE (type)) 1412: { 1413: case INTEGER_TYPE: 1414: case ENUMERAL_TYPE: 1415: { 1416: assert (TREE_CODE (value) == INTEGER_CST); 1417: if (TYPE_MODE (value) == DImode) 1418: { 1419: if (tree_int_cst_lt (value, integer_zero_node)) 1420: { 1421: OB_PUTC ('m'); 1422: value = build_int_2 (~ TREE_INT_CST_LOW (value), 1423: - TREE_INT_CST_HIGH (value)); 1424: } 1425: if (TREE_INT_CST_HIGH (value) != (TREE_INT_CST_LOW (value) >> 31)) 1426: { 1427: /* need to print a DImode value in decimal */ 1428: sorry ("conversion of long long as PT parameter"); 1429: } 1430: /* else fall through to print in smaller mode */ 1431: } 1432: /* SImode or smaller */ 1433: icat (TREE_INT_CST_LOW (value)); 1434: return; 1435: } 1436: #ifndef REAL_IS_NOT_DOUBLE 1437: case REAL_TYPE: 1438: { 1439: REAL_VALUE_TYPE val; 1440: char *bufp = digit_buffer; 1441: 1442: assert (TREE_CODE (value) == REAL_CST); 1443: val = TREE_REAL_CST (value); 1444: if (val < 0) 1445: { 1446: val = -val; 1447: *bufp++ = 'm'; 1448: } 1449: sprintf (bufp, "%e", val); 1450: bufp = strchr (bufp, 'e'); 1451: if (!bufp) 1452: strcat (buf, "e0"); 1453: else 1454: { 1455: char *p; 1456: bufp++; 1457: if (*bufp == '-') 1458: { 1459: *bufp++ = 'm'; 1460: } 1461: p = bufp; 1462: if (*p == '+') 1463: p++; 1464: while (*p == '0') 1465: p++; 1466: if (*p == 0) 1467: { 1468: *bufp++ = '0'; 1469: *bufp = 0; 1470: } 1471: else if (p != bufp) 1472: { 1473: while (*p) 1474: *bufp++ = *p++; 1475: *bufp = 0; 1476: } 1477: } 1478: OB_PUTCP (buf); 1479: return; 1480: } 1481: #endif 1482: case POINTER_TYPE: 1483: value = TREE_OPERAND (value, 0); 1484: if (TREE_CODE (value) == VAR_DECL) 1485: { 1486: assert (DECL_NAME (value) != 0); 1487: build_overload_identifier (DECL_NAME (value)); 1488: return; 1489: } 1490: else 1491: { 1492: debug_tree (type); 1493: debug_tree (value); 1494: abort (); 1495: } 1496: default: 1497: sorry ("conversion of %s as PT parameter", 1498: tree_code_name [(int) TREE_CODE (type)]); 1499: abort (); 1500: } 1501: } 1502: 1503: static void 1504: build_overload_identifier (name) 1505: tree name; 1506: { 1507: if (IDENTIFIER_TEMPLATE (name)) 1508: { 1509: tree template, parmlist, arglist, tname; 1510: int i, nparms; 1511: template = IDENTIFIER_TEMPLATE (name); 1512: arglist = TREE_VALUE (template); 1513: template = TREE_PURPOSE (template); 1514: tname = DECL_NAME (template); 1515: parmlist = DECL_ARGUMENTS (template); 1516: nparms = TREE_VEC_LENGTH (parmlist); 1517: OB_PUTC ('t'); 1518: icat (IDENTIFIER_LENGTH (tname)); 1519: OB_PUTID (tname); 1520: icat (nparms); 1521: for (i = 0; i < nparms; i++) 1522: { 1523: tree parm = TREE_VEC_ELT (parmlist, i); 1524: tree arg = TREE_VEC_ELT (arglist, i); 1525: if (TREE_CODE (parm) == IDENTIFIER_NODE) 1526: { 1527: /* This parameter is a type. */ 1528: OB_PUTC ('Z'); 1529: build_overload_name (arg, 0, 0); 1530: } 1531: else 1532: { 1533: /* It's a PARM_DECL. */ 1534: build_overload_name (TREE_TYPE (parm), 0, 0); 1535: build_overload_value (parm, arg); 1536: } 1537: } 1538: } 1539: else 1540: { 1541: icat (IDENTIFIER_LENGTH (name)); 1542: OB_PUTID (name); 1543: } 1544: } 1545: 1546: /* Given a list of parameters in PARMTYPES, create an unambiguous 1547: overload string. Should distinguish any type that C (or C++) can 1548: distinguish. I.e., pointers to functions are treated correctly. 1549: 1550: Caller must deal with whether a final `e' goes on the end or not. 1551: 1552: Any default conversions must take place before this function 1553: is called. 1554: 1555: BEGIN and END control initialization and finalization of the 1556: obstack where we build the string. */ 1557: 1558: char * 1559: build_overload_name (parmtypes, begin, end) 1560: tree parmtypes; 1561: int begin, end; 1562: { 1563: int just_one; 1564: tree parmtype; 1565: 1566: if (begin) OB_INIT (); 1567: 1568: if (just_one = (TREE_CODE (parmtypes) != TREE_LIST)) 1569: { 1570: parmtype = parmtypes; 1571: goto only_one; 1572: } 1573: 1574: while (parmtypes) 1575: { 1576: parmtype = TREE_VALUE (parmtypes); 1577: 1578: only_one: 1579: 1580: if (! nofold) 1581: { 1582: if (! just_one) 1583: /* Every argument gets counted. */ 1584: typevec[maxtype++] = parmtype; 1585: 1586: if (TREE_USED (parmtype)) 1587: { 1588: if (! just_one && parmtype == typevec[maxtype-2]) 1589: nrepeats++; 1590: else 1591: { 1592: if (nrepeats) 1593: flush_repeats (parmtype); 1594: if (! just_one && TREE_CHAIN (parmtypes) 1595: && parmtype == TREE_VALUE (TREE_CHAIN (parmtypes))) 1596: nrepeats++; 1597: else 1598: { 1599: int tindex = 0; 1600: 1601: while (typevec[tindex] != parmtype) 1602: tindex++; 1603: OB_PUTC ('T'); 1604: icat (tindex); 1605: if (tindex > 9) 1606: OB_PUTC ('_'); 1607: } 1608: } 1609: goto next; 1610: } 1611: if (nrepeats) 1612: flush_repeats (typevec[maxtype-2]); 1613: if (! just_one 1614: /* Only cache types which take more than one character. */ 1615: && (parmtype != TYPE_MAIN_VARIANT (parmtype) 1616: || (TREE_CODE (parmtype) != INTEGER_TYPE 1617: && TREE_CODE (parmtype) != REAL_TYPE))) 1618: TREE_USED (parmtype) = 1; 1619: } 1620: 1621: if (TREE_READONLY (parmtype)) 1622: OB_PUTC ('C'); 1623: if (TREE_CODE (parmtype) == INTEGER_TYPE 1624: && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype))) 1625: OB_PUTC ('U'); 1626: if (TYPE_VOLATILE (parmtype)) 1627: OB_PUTC ('V'); 1628: 1629: switch (TREE_CODE (parmtype)) 1630: { 1631: case OFFSET_TYPE: 1632: OB_PUTC ('O'); 1633: build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0); 1634: OB_PUTC ('_'); 1635: build_overload_name (TREE_TYPE (parmtype), 0, 0); 1636: break; 1637: 1638: case REFERENCE_TYPE: 1639: OB_PUTC ('R'); 1640: goto more; 1641: 1642: case ARRAY_TYPE: 1643: #if PARM_CAN_BE_ARRAY_TYPE 1644: { 1645: tree length; 1646: 1647: OB_PUTC ('A'); 1.1.1.2 ! root 1648: if (TYPE_DOMAIN (parmtype) == NULL_TREE) ! 1649: { ! 1650: error ("parameter type with unspecified array bounds invalid"); ! 1651: icat (1); ! 1652: } ! 1653: else ! 1654: { ! 1655: length = array_type_nelts (parmtype); ! 1656: if (TREE_CODE (length) == INTEGER_CST) ! 1657: icat (TREE_INT_CST_LOW (length) + 1); ! 1658: } 1.1 root 1659: OB_PUTC ('_'); 1660: goto more; 1661: } 1662: #else 1663: OB_PUTC ('P'); 1664: goto more; 1665: #endif 1666: 1667: case POINTER_TYPE: 1668: OB_PUTC ('P'); 1669: more: 1670: build_overload_name (TREE_TYPE (parmtype), 0, 0); 1671: break; 1672: 1673: case FUNCTION_TYPE: 1674: case METHOD_TYPE: 1675: { 1676: tree firstarg = TYPE_ARG_TYPES (parmtype); 1677: /* Otherwise have to implement reentrant typevecs, 1678: unmark and remark types, etc. */ 1679: int old_nofold = nofold; 1680: nofold = 1; 1681: 1682: if (nrepeats) 1683: flush_repeats (typevec[maxtype-1]); 1684: 1685: /* @@ It may be possible to pass a function type in 1686: which is not preceded by a 'P'. */ 1687: if (TREE_CODE (parmtype) == FUNCTION_TYPE) 1688: { 1689: OB_PUTC ('F'); 1690: if (firstarg == NULL_TREE) 1691: OB_PUTC ('e'); 1692: else if (firstarg == void_list_node) 1693: OB_PUTC ('v'); 1694: else 1695: build_overload_name (firstarg, 0, 0); 1696: } 1697: else 1698: { 1699: int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg))); 1700: int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg))); 1701: OB_PUTC ('M'); 1702: firstarg = TREE_CHAIN (firstarg); 1703: 1704: build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0); 1705: if (constp) 1706: OB_PUTC ('C'); 1707: if (volatilep) 1708: OB_PUTC ('V'); 1709: 1.1.1.2 ! root 1710: /* For cfront 2.0 compatibility. */ 1.1 root 1711: OB_PUTC ('F'); 1712: 1713: if (firstarg == NULL_TREE) 1714: OB_PUTC ('e'); 1715: else if (firstarg == void_list_node) 1716: OB_PUTC ('v'); 1717: else 1718: build_overload_name (firstarg, 0, 0); 1719: } 1720: 1721: /* Separate args from return type. */ 1722: OB_PUTC ('_'); 1723: build_overload_name (TREE_TYPE (parmtype), 0, 0); 1724: nofold = old_nofold; 1725: break; 1726: } 1727: 1728: case INTEGER_TYPE: 1729: parmtype = TYPE_MAIN_VARIANT (parmtype); 1730: switch (TYPE_MODE (parmtype)) 1731: { 1732: case TImode: 1733: if (parmtype == long_integer_type_node 1734: || parmtype == long_unsigned_type_node) 1735: OB_PUTC ('l'); 1736: else 1737: OB_PUTC ('q'); 1738: break; 1739: case DImode: 1740: if (parmtype == long_integer_type_node 1741: || parmtype == long_unsigned_type_node) 1742: OB_PUTC ('l'); 1743: else if (parmtype == integer_type_node 1744: || parmtype == unsigned_type_node) 1745: OB_PUTC ('i'); 1746: else if (parmtype == short_integer_type_node 1747: || parmtype == short_unsigned_type_node) 1748: OB_PUTC ('s'); 1749: else 1750: OB_PUTC ('x'); 1751: break; 1752: case SImode: 1753: if (parmtype == long_integer_type_node 1754: || parmtype == long_unsigned_type_node) 1755: OB_PUTC ('l'); 1756: else if (parmtype == short_integer_type_node 1757: || parmtype == short_unsigned_type_node) 1758: OB_PUTC ('s'); 1759: else 1760: OB_PUTC ('i'); 1761: break; 1762: case HImode: 1763: if (parmtype == integer_type_node 1764: || parmtype == unsigned_type_node) 1765: OB_PUTC ('i'); 1766: else 1767: OB_PUTC ('s'); 1768: break; 1769: case QImode: 1770: OB_PUTC ('c'); 1771: break; 1772: default: 1773: abort (); 1774: } 1775: break; 1776: 1777: case REAL_TYPE: 1778: parmtype = TYPE_MAIN_VARIANT (parmtype); 1779: if (parmtype == long_double_type_node) 1780: OB_PUTC ('r'); 1781: else if (parmtype == double_type_node) 1782: OB_PUTC ('d'); 1783: else if (parmtype == float_type_node) 1784: OB_PUTC ('f'); 1785: else abort (); 1786: break; 1787: 1788: case VOID_TYPE: 1789: if (! just_one) 1790: { 1791: #if 0 1792: extern tree void_list_node; 1793: 1794: /* See if anybody is wasting memory. */ 1795: assert (parmtypes == void_list_node); 1796: #endif 1797: /* This is the end of a parameter list. */ 1798: if (end) OB_FINISH (); 1799: return (char *)obstack_base (&scratch_obstack); 1800: } 1801: OB_PUTC ('v'); 1802: break; 1803: 1804: case ERROR_MARK: /* not right, but nothing is anyway */ 1805: break; 1806: 1807: /* have to do these */ 1808: case UNION_TYPE: 1809: case RECORD_TYPE: 1810: if (! just_one) 1811: /* Make this type signature look incompatible 1812: with AT&T. */ 1813: OB_PUTC ('G'); 1814: goto common; 1815: case ENUMERAL_TYPE: 1816: common: 1817: { 1818: tree name = TYPE_NAME (parmtype); 1819: int i = 1; 1820: 1821: if (TREE_CODE (name) == TYPE_DECL) 1822: { 1823: tree context = name; 1824: while (DECL_CONTEXT (context)) 1825: { 1826: i += 1; 1827: context = DECL_CONTEXT (context); 1828: if (TREE_CODE_CLASS (TREE_CODE (context)) == 't') 1829: context = TYPE_NAME (context); 1830: } 1831: name = DECL_NAME (name); 1832: } 1833: assert (TREE_CODE (name) == IDENTIFIER_NODE); 1834: if (i > 1) 1835: { 1836: OB_PUTC ('Q'); 1837: icat (i); 1838: build_overload_nested_name (TYPE_NAME (parmtype)); 1839: } 1840: else 1841: build_overload_identifier (name); 1842: break; 1843: } 1844: 1845: case UNKNOWN_TYPE: 1846: /* This will take some work. */ 1847: OB_PUTC ('?'); 1848: break; 1849: 1850: case TEMPLATE_TYPE_PARM: 1851: case TEMPLATE_CONST_PARM: 1852: case UNINSTANTIATED_P_TYPE: 1853: /* We don't ever want this output, but it's inconvenient not to 1854: be able to build the string. This should cause assembler 1855: errors we'll notice. */ 1856: { 1857: static int n; 1858: sprintf (digit_buffer, " *%d", n++); 1859: OB_PUTCP (digit_buffer); 1860: } 1861: break; 1862: 1863: default: 1864: abort (); 1865: } 1866: 1867: next: 1868: if (just_one) break; 1869: parmtypes = TREE_CHAIN (parmtypes); 1870: } 1871: if (! just_one) 1872: { 1873: if (nrepeats) 1874: flush_repeats (typevec[maxtype-1]); 1875: 1876: /* To get here, parms must end with `...'. */ 1877: OB_PUTC ('e'); 1878: } 1879: 1880: if (end) OB_FINISH (); 1881: return (char *)obstack_base (&scratch_obstack); 1882: } 1883: 1884: /* Generate an identifier that encodes the (ANSI) exception TYPE. */ 1885: 1886: /* This should be part of `ansi_opname', or at least be defined by the std. */ 1887: #define EXCEPTION_NAME_PREFIX "__ex" 1888: #define EXCEPTION_NAME_LENGTH 4 1889: 1890: tree 1891: cplus_exception_name (type) 1892: tree type; 1893: { 1894: OB_INIT (); 1895: OB_PUTS (EXCEPTION_NAME_PREFIX); 1896: return get_identifier (build_overload_name (type, 0, 1)); 1897: } 1898: 1899: /* Change the name of a function definition so that it may be 1900: overloaded. NAME is the name of the function to overload, 1901: PARMS is the parameter list (which determines what name the 1902: final function obtains). 1903: 1904: FOR_METHOD is 1 if this overload is being performed 1905: for a method, rather than a function type. It is 2 if 1906: this overload is being performed for a constructor. */ 1907: tree 1.1.1.2 ! root 1908: build_decl_overload (dname, parms, for_method) ! 1909: tree dname; 1.1 root 1910: tree parms; 1911: int for_method; 1912: { 1.1.1.2 ! root 1913: char *name = IDENTIFIER_POINTER (dname); ! 1914: ! 1915: if (dname == ansi_opname[(int) NEW_EXPR] ! 1916: && parms != NULL_TREE ! 1917: && TREE_CODE (parms) == TREE_LIST ! 1918: && TREE_VALUE (parms) == sizetype ! 1919: && TREE_CHAIN (parms) == void_list_node) ! 1920: return get_identifier ("__builtin_new"); ! 1921: else if (dname == ansi_opname[(int) DELETE_EXPR] ! 1922: && parms != NULL_TREE ! 1923: && TREE_CODE (parms) == TREE_LIST ! 1924: && TREE_VALUE (parms) == ptr_type_node ! 1925: && TREE_CHAIN (parms) == void_list_node) ! 1926: return get_identifier ("__builtin_delete"); ! 1927: 1.1 root 1928: OB_INIT (); 1929: if (for_method != 2) 1930: OB_PUTCP (name); 1931: /* Otherwise, we can divine that this is a constructor, 1932: and figure out its name without any extra encoding. */ 1933: 1934: OB_PUTC2 ('_', '_'); 1935: if (for_method) 1936: { 1937: #if 0 1938: /* We can get away without doing this. */ 1939: OB_PUTC ('M'); 1940: #endif 1941: parms = temp_tree_cons (NULL_TREE, TREE_TYPE (TREE_VALUE (parms)), TREE_CHAIN (parms)); 1942: } 1943: else 1944: OB_PUTC ('F'); 1945: 1946: if (parms == NULL_TREE) 1947: OB_PUTC2 ('e', '\0'); 1948: else if (parms == void_list_node) 1949: OB_PUTC2 ('v', '\0'); 1950: else 1951: { 1952: ALLOCATE_TYPEVEC (parms); 1953: nofold = 0; 1954: if (for_method) 1955: { 1956: build_overload_name (TREE_VALUE (parms), 0, 0); 1957: 1958: typevec[maxtype++] = TREE_VALUE (parms); 1959: TREE_USED (TREE_VALUE (parms)) = 1; 1960: 1961: if (TREE_CHAIN (parms)) 1962: build_overload_name (TREE_CHAIN (parms), 0, 1); 1963: else 1964: OB_PUTC2 ('e', '\0'); 1965: } 1966: else 1967: build_overload_name (parms, 0, 1); 1968: DEALLOCATE_TYPEVEC (parms); 1969: } 1970: return get_identifier (obstack_base (&scratch_obstack)); 1971: } 1972: 1973: /* Build an overload name for the type expression TYPE. */ 1974: tree 1975: build_typename_overload (type) 1976: tree type; 1977: { 1978: OB_INIT (); 1.1.1.2 ! root 1979: OB_PUTID (ansi_opname[(int) TYPE_EXPR]); 1.1 root 1980: 1981: #if 0 1982: /* We can get away without doing this--it really gets 1983: overloaded later. */ 1984: OB_PUTC2 ('_', '_'); 1985: OB_PUTC ('M'); 1986: #endif 1987: nofold = 1; 1988: build_overload_name (type, 0, 1); 1989: return get_identifier (obstack_base (&scratch_obstack)); 1990: } 1991: 1992: #define T_DESC_FORMAT "TD$" 1993: #define I_DESC_FORMAT "ID$" 1994: #define M_DESC_FORMAT "MD$" 1995: 1996: /* Build an overload name for the type expression TYPE. */ 1997: tree 1998: build_t_desc_overload (type) 1999: tree type; 2000: { 2001: int i = sizeof (T_DESC_FORMAT) - 1; 2002: 2003: OB_INIT (); 2004: OB_PUTS (T_DESC_FORMAT); 2005: nofold = 1; 2006: 2007: #if 0 2008: /* Use a different format if the type isn't defined yet. */ 2009: if (TYPE_SIZE (type) == NULL_TREE) 2010: { 2011: char *p; 2012: int changed; 2013: 2014: for (p = tname; *p; p++) 2015: if (isupper (*p)) 2016: { 2017: changed = 1; 2018: *p = tolower (*p); 2019: } 1.1.1.2 ! root 2020: /* If there's no change, we have an inappropriate T_DESC_FORMAT. */ 1.1 root 2021: assert (changed != 0); 2022: } 2023: #endif 2024: 2025: build_overload_name (type, 0, 1); 2026: return get_identifier (obstack_base (&scratch_obstack)); 2027: } 2028: 2029: /* Top-level interface to explicit overload requests. Allow NAME 2030: to be overloaded. Error if NAME is already declared for the current 1.1.1.2 ! root 2031: scope. Warning if function is redundantly overloaded. */ 1.1 root 2032: 2033: void 2034: declare_overloaded (name) 2035: tree name; 2036: { 2037: #ifdef NO_AUTO_OVERLOAD 2038: if (is_overloaded (name)) 2039: warning ("function `%s' already declared overloaded", 2040: IDENTIFIER_POINTER (name)); 2041: else if (IDENTIFIER_GLOBAL_VALUE (name)) 2042: error ("overloading function `%s' that is already defined", 2043: IDENTIFIER_POINTER (name)); 2044: else 2045: { 2046: TREE_OVERLOADED (name) = 1; 2047: IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE); 2048: TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node; 2049: } 2050: #else 2051: if (current_lang_name == lang_name_cplusplus) 2052: { 2053: if (0) 2054: warning ("functions are implicitly overloaded in C++"); 2055: } 2056: else if (current_lang_name == lang_name_c) 2057: error ("overloading function `%s' cannot be done in C language context"); 2058: else 2059: abort (); 2060: #endif 2061: } 2062: 2063: #ifdef NO_AUTO_OVERLOAD 2064: /* Check to see if NAME is overloaded. For first approximation, 2065: check to see if its TREE_OVERLOADED is set. This is used on 2066: IDENTIFIER nodes. */ 2067: int 2068: is_overloaded (name) 2069: tree name; 2070: { 2071: /* @@ */ 2072: return (TREE_OVERLOADED (name) 2073: && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0) 2074: && ! IDENTIFIER_LOCAL_VALUE (name)); 2075: } 2076: #endif 2077: 2078: /* Given a tree_code CODE, and some arguments (at least one), 2079: attempt to use an overloaded operator on the arguments. 2080: 2081: For unary operators, only the first argument need be checked. 2082: For binary operators, both arguments may need to be checked. 2083: 2084: Member functions can convert class references to class pointers, 2085: for one-level deep indirection. More than that is not supported. 2086: Operators [](), ()(), and ->() must be member functions. 2087: 2088: We call function call building calls with nonzero complain if 2089: they are our only hope. This is true when we see a vanilla operator 2090: applied to something of aggregate type. If this fails, we are free to 2091: return `error_mark_node', because we will have reported the error. 2092: 2093: Operators NEW and DELETE overload in funny ways: operator new takes 2094: a single `size' parameter, and operator delete takes a pointer to the 2095: storage being deleted. When overloading these operators, success is 2096: assumed. If there is a failure, report an error message and return 2097: `error_mark_node'. */ 2098: 2099: /* NOSTRICT */ 2100: tree 2101: build_opfncall (code, flags, xarg1, xarg2, arg3) 2102: enum tree_code code; 2103: tree xarg1, xarg2; 2104: tree arg3; 2105: { 2106: tree rval = 0; 2107: tree arg1, arg2; 2108: tree type1, type2, fnname; 2109: tree fields1 = 0, parms = 0; 2110: tree global_fn; 2111: int try_second; 2112: int binary_is_unary; 2113: 2114: if (xarg1 == error_mark_node) 2115: return error_mark_node; 2116: 2117: if (code == COND_EXPR) 2118: { 2119: if (TREE_CODE (xarg2) == ERROR_MARK 2120: || TREE_CODE (arg3) == ERROR_MARK) 2121: return error_mark_node; 2122: } 2123: if (code == COMPONENT_REF) 2124: if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE) 2125: return rval; 2126: 2127: /* First, see if we can work with the first argument */ 2128: type1 = TREE_TYPE (xarg1); 2129: 2130: /* Some tree codes have length > 1, but we really only want to 2131: overload them if their first argument has a user defined type. */ 2132: switch (code) 2133: { 2134: case PREINCREMENT_EXPR: 2135: code = POSTINCREMENT_EXPR; 2136: binary_is_unary = 1; 2137: try_second = 0; 2138: break; 2139: 2140: case POSTDECREMENT_EXPR: 2141: code = PREDECREMENT_EXPR; 2142: binary_is_unary = 1; 2143: try_second = 0; 2144: break; 2145: 2146: case PREDECREMENT_EXPR: 2147: case POSTINCREMENT_EXPR: 2148: case COMPONENT_REF: 2149: binary_is_unary = 1; 2150: try_second = 0; 2151: break; 2152: 2153: /* ARRAY_REFs and CALL_EXPRs must overload successfully. 2154: If they do not, return error_mark_node instead of NULL_TREE. */ 2155: case ARRAY_REF: 2156: if (xarg2 == error_mark_node) 2157: return error_mark_node; 2158: case CALL_EXPR: 2159: rval = error_mark_node; 2160: binary_is_unary = 0; 2161: try_second = 0; 2162: break; 2163: 2164: case NEW_EXPR: 2165: { 2166: /* For operators `new' (`delete'), only check visibility 2167: if we are in a constructor (destructor), and we are 2168: allocating for that constructor's (destructor's) type. */ 2169: 1.1.1.2 ! root 2170: fnname = ansi_opname[(int) NEW_EXPR]; 1.1 root 2171: if (flags & LOOKUP_GLOBAL) 2172: return build_overload_call (fnname, tree_cons (NULL_TREE, xarg2, arg3), 2173: flags & LOOKUP_COMPLAIN, 0); 2174: 2175: if (current_function_decl == NULL_TREE 2176: || !DECL_CONSTRUCTOR_P (current_function_decl) 2177: || current_class_type != TYPE_MAIN_VARIANT (type1)) 2178: flags = LOOKUP_COMPLAIN; 2179: rval = build_method_call (build1 (NOP_EXPR, xarg1, error_mark_node), 2180: fnname, tree_cons (NULL_TREE, xarg2, arg3), 2181: NULL_TREE, flags); 2182: if (rval == error_mark_node) 2183: /* User might declare fancy operator new, but invoke it 2184: like standard one. */ 2185: return rval; 2186: 2187: TREE_TYPE (rval) = xarg1; 2188: TREE_CALLS_NEW (rval) = 1; 2189: return rval; 2190: } 2191: break; 2192: 2193: case DELETE_EXPR: 2194: { 2195: /* See comment above. */ 2196: 1.1.1.2 ! root 2197: fnname = ansi_opname[(int) DELETE_EXPR]; 1.1 root 2198: if (flags & LOOKUP_GLOBAL) 2199: return build_overload_call (fnname, build_tree_list (NULL_TREE, xarg1), 2200: flags & LOOKUP_COMPLAIN, 0); 2201: 2202: if (current_function_decl == NULL_TREE 2203: || !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (current_function_decl)) 2204: || current_class_type != TYPE_MAIN_VARIANT (type1)) 2205: flags = LOOKUP_COMPLAIN; 2206: rval = build_method_call (build1 (NOP_EXPR, TREE_TYPE (xarg1), error_mark_node), 2207: fnname, build_tree_list (NULL_TREE, xarg1), 2208: NULL_TREE, flags); 2209: /* This happens when the user mis-declares `operator delete'. 2210: Should now be impossible. */ 2211: assert (rval != error_mark_node); 2212: TREE_TYPE (rval) = void_type_node; 2213: return rval; 2214: } 2215: break; 2216: 2217: default: 2218: binary_is_unary = 0; 2219: try_second = tree_code_length [(int) code] == 2; 2220: if (try_second && xarg2 == error_mark_node) 2221: return error_mark_node; 2222: break; 2223: } 2224: 2225: if (try_second && xarg2 == error_mark_node) 2226: return error_mark_node; 2227: 2228: /* What ever it was, we do not know how to deal with it. */ 2229: if (type1 == NULL_TREE) 2230: return rval; 2231: 2232: if (TREE_CODE (type1) == OFFSET_TYPE) 2233: type1 = TREE_TYPE (type1); 2234: 2235: if (TREE_CODE (type1) == REFERENCE_TYPE) 2236: { 2237: arg1 = convert_from_reference (xarg1); 2238: type1 = TREE_TYPE (arg1); 2239: } 2240: else 2241: { 2242: arg1 = xarg1; 2243: } 2244: 2245: if (!IS_AGGR_TYPE (type1)) 2246: { 2247: /* Try to fail. First, fail if unary */ 2248: if (! try_second) 2249: return rval; 2250: /* Second, see if second argument is non-aggregate. */ 2251: type2 = TREE_TYPE (xarg2); 2252: if (TREE_CODE (type2) == OFFSET_TYPE) 2253: type2 = TREE_TYPE (type2); 2254: if (TREE_CODE (type2) == REFERENCE_TYPE) 2255: { 2256: arg2 = convert_from_reference (xarg2); 2257: type2 = TREE_TYPE (arg2); 2258: } 2259: else 2260: { 2261: arg2 = xarg2; 2262: } 2263: 2264: if (!IS_AGGR_TYPE (type2)) 2265: return rval; 2266: try_second = 0; 2267: } 2268: 2269: if (try_second) 2270: { 2271: /* First arg may succeed; see whether second should. */ 2272: type2 = TREE_TYPE (xarg2); 2273: if (TREE_CODE (type2) == OFFSET_TYPE) 2274: type2 = TREE_TYPE (type2); 2275: if (TREE_CODE (type2) == REFERENCE_TYPE) 2276: { 2277: arg2 = convert_from_reference (xarg2); 2278: type2 = TREE_TYPE (arg2); 2279: } 2280: else 2281: { 2282: arg2 = xarg2; 2283: } 2284: 2285: if (! IS_AGGR_TYPE (type2)) 2286: try_second = 0; 2287: } 2288: 2289: if (type1 == unknown_type_node 2290: || (try_second && TREE_TYPE (xarg2) == unknown_type_node)) 2291: { 2292: /* This will not be implemented in the forseeable future. */ 2293: return rval; 2294: } 2295: 2296: if (code == MODIFY_EXPR) 2297: fnname = ansi_assopname[(int)arg3]; 2298: else 1.1.1.2 ! root 2299: fnname = ansi_opname[(int) code]; 1.1 root 2300: 2301: global_fn = IDENTIFIER_GLOBAL_VALUE (fnname); 2302: 2303: /* This is the last point where we will accept failure. This 2304: may be too eager if we wish an overloaded operator not to match, 2305: but would rather a normal operator be called on a type-converted 2306: argument. */ 2307: 2308: if (IS_AGGR_TYPE (type1)) 2309: fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0); 2310: 2311: if (fields1 == NULL_TREE && global_fn == NULL_TREE) 2312: return rval; 2313: 2314: /* If RVAL winds up being `error_mark_node', we will return 2315: that... There is no way that normal semantics of these 2316: operators will succeed. */ 2317: 1.1.1.2 ! root 2318: /* This argument may be an uncommitted OFFSET_REF. This is 1.1 root 2319: the case for example when dealing with static class members 2320: which are referenced from their class name rather than 2321: from a class instance. */ 2322: if (TREE_CODE (xarg1) == OFFSET_REF 2323: && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL) 2324: xarg1 = TREE_OPERAND (xarg1, 1); 2325: if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF 2326: && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL) 2327: xarg2 = TREE_OPERAND (xarg2, 1); 2328: 2329: if (global_fn) 2330: flags |= LOOKUP_GLOBAL; 2331: 2332: if (code == CALL_EXPR) 2333: { 2334: /* This can only be a member function. */ 2335: return build_method_call (xarg1, fnname, xarg2, 2336: NULL_TREE, LOOKUP_NORMAL); 2337: } 2338: else if (tree_code_length[(int) code] == 1 || binary_is_unary) 2339: { 2340: parms = NULL_TREE; 2341: rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags); 2342: } 2343: else if (code == COND_EXPR) 2344: { 2345: parms = tree_cons (0, xarg2, build_tree_list (0, arg3)); 2346: rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags); 2347: } 2348: else if (code == METHOD_CALL_EXPR) 2349: { 2350: /* must be a member function. */ 2351: parms = tree_cons (NULL_TREE, xarg2, arg3); 2352: return build_method_call (xarg1, fnname, parms, NULL_TREE, LOOKUP_NORMAL); 2353: } 2354: else if (fields1) 2355: { 2356: parms = build_tree_list (NULL_TREE, xarg2); 2357: rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags); 2358: } 2359: else 2360: { 2361: parms = tree_cons (NULL_TREE, xarg1, 2362: build_tree_list (NULL_TREE, xarg2)); 2363: rval = build_overload_call (fnname, parms, flags & LOOKUP_COMPLAIN, 0); 2364: } 2365: 2366: /* If we did not win, do not lose yet, since type conversion may work. */ 2367: if (TREE_CODE (rval) == ERROR_MARK) 2368: { 2369: if (flags & LOOKUP_COMPLAIN) 2370: return rval; 2371: return 0; 2372: } 2373: 2374: return rval; 2375: } 2376: 2377: /* This function takes an identifier, ID, and attempts to figure out what 2378: it means. There are a number of possible scenarios, presented in increasing 2379: order of hair: 2380: 2381: 1) not in a class's scope 2382: 2) in class's scope, member name of the class's method 2383: 3) in class's scope, but not a member name of the class 2384: 4) in class's scope, member name of a class's variable 2385: 2386: NAME is $1 from the bison rule. It is an IDENTIFIER_NODE. 2387: VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1) 2388: yychar is the pending input character (suitably encoded :-). 2389: 2390: As a last ditch, try to look up the name as a label and return that 2391: address. 2392: 2393: Values which are declared as being of REFERENCE_TYPE are 2394: automatically dereferenced here (as a hack to make the 2395: compiler faster). */ 2396: 2397: tree 2398: hack_identifier (value, name, yychar) 2399: tree value, name; 2400: { 2401: tree type; 2402: 2403: if (TREE_CODE (value) == ERROR_MARK) 2404: { 2405: if (current_class_name) 2406: { 2407: tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 0); 2408: if (fields) 2409: { 2410: tree fndecl; 2411: 2412: fndecl = TREE_VALUE (fields); 2413: assert (TREE_CODE (fndecl) == FUNCTION_DECL); 2414: if (DECL_CHAIN (fndecl) == NULL_TREE) 2415: { 2416: warning ("methods cannot be converted to function pointers"); 2417: return fndecl; 2418: } 2419: else 2420: { 2421: error ("ambiguous request for method pointer `%s'", 2422: IDENTIFIER_POINTER (name)); 2423: return error_mark_node; 2424: } 2425: } 2426: } 2427: if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name)) 2428: { 2429: return IDENTIFIER_LABEL_VALUE (name); 2430: } 2431: return error_mark_node; 2432: } 2433: 2434: type = TREE_TYPE (value); 2435: if (TREE_CODE (value) == FIELD_DECL) 2436: { 2437: if (current_class_decl == NULL_TREE) 2438: { 2439: error ("request for member `%s' in static member function", 2440: IDENTIFIER_POINTER (DECL_NAME (value))); 2441: return error_mark_node; 2442: } 2443: TREE_USED (current_class_decl) = 1; 2444: if (yychar == '(') 2445: if (! ((TYPE_LANG_SPECIFIC (type) 2446: && TYPE_OVERLOADS_CALL_EXPR (type)) 2447: || (TREE_CODE (type) == REFERENCE_TYPE 2448: && TYPE_LANG_SPECIFIC (TREE_TYPE (type)) 2449: && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (type)))) 2450: && TREE_CODE (type) != FUNCTION_TYPE 2451: && TREE_CODE (type) != METHOD_TYPE 2452: && (TREE_CODE (type) != POINTER_TYPE 2453: || (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE 2454: && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE))) 2455: { 2456: error ("component `%s' is not a method", 2457: IDENTIFIER_POINTER (name)); 2458: return error_mark_node; 2459: } 2460: /* Mark so that if we are in a constructor, and then find that 2461: this field was initialized by a base initializer, 2462: we can emit an error message. */ 2463: TREE_USED (value) = 1; 2464: return build_component_ref (C_C_D, name, 0, 1); 2465: } 2466: 2467: if (TREE_CODE (value) == TREE_LIST) 2468: { 2469: tree t = value; 2470: while (t && TREE_CODE (t) == TREE_LIST) 2471: { 2472: assemble_external (TREE_VALUE (t)); 2473: TREE_USED (t) = 1; 2474: t = TREE_CHAIN (t); 2475: } 2476: } 2477: else 2478: { 2479: assemble_external (value); 2480: TREE_USED (value) = 1; 2481: } 2482: 2483: if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && TREE_NONLOCAL (value)) 2484: { 2485: if (DECL_CLASS_CONTEXT (value) != current_class_type) 2486: { 2487: tree path; 2488: enum visibility_type visibility; 2489: 2490: get_base_distance (DECL_CLASS_CONTEXT (value), 2491: current_class_type, 0, &path); 2492: visibility = compute_visibility (path, value); 2493: if (visibility != visibility_public) 2494: { 2495: if (TREE_CODE (value) == VAR_DECL) 2496: error ("static member `%s' is from private base class", 2497: IDENTIFIER_POINTER (name)); 2498: else 2499: error ("enum `%s' is from private base class", 2500: IDENTIFIER_POINTER (name)); 2501: return error_mark_node; 2502: } 2503: } 2504: if (TREE_CODE (value) == VAR_DECL && ! TREE_USED (value)) 2505: { 1.1.1.2 ! root 2506: assemble_external (value); 1.1 root 2507: TREE_USED (value) = 1; 2508: } 2509: return value; 2510: } 2511: if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value)) 2512: { 2513: if (type == 0) 2514: { 2515: error ("request for member `%s' is ambiguous in multiple inheritance lattice", 2516: IDENTIFIER_POINTER (name)); 2517: return error_mark_node; 2518: } 2519: 2520: return value; 2521: } 2522: 2523: if (TREE_CODE (type) == REFERENCE_TYPE) 2524: { 2525: assert (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == PARM_DECL); 2526: if (DECL_REFERENCE_SLOT (value)) 2527: return DECL_REFERENCE_SLOT (value); 2528: } 2529: return value; 2530: } 2531: 2532: /* NONWRAPPER is nonzero if this call is not to be wrapped. 2533: TYPE is the type that the wrapper belongs to (in case 2534: it should be non-virtual). 2535: DECL is the function will will be (not be) wrapped. */ 2536: tree 2537: hack_wrapper (nonwrapper, type, decl) 2538: int nonwrapper; 2539: tree type, decl; 2540: { 2541: if (type == NULL_TREE || is_aggr_typedef (type, 1)) 2542: { 2543: if (type) 2544: type = TREE_TYPE (type); 2545: 2546: switch (nonwrapper) 2547: { 2548: case 0: 2549: return build_nt (WRAPPER_EXPR, type, decl); 2550: case 1: 2551: return build_nt (ANTI_WRAPPER_EXPR, type, decl); 2552: case 2: 2553: return build_nt (WRAPPER_EXPR, type, 2554: build_nt (COND_EXPR, decl, NULL_TREE, NULL_TREE)); 2555: default: 2556: assert (0 <= nonwrapper && nonwrapper <= 2); 2557: } 2558: } 2559: return error_mark_node; 2560: } 2561: 2562: /* Given an object OF, and a type conversion operator COMPONENT 2563: build a call to the conversion operator, if a call is requested, 2564: or return the address (as a pointer to member function) if one is not. 2565: 2566: OF can be a TYPE_DECL or any kind of datum that would normally 2567: be passed to `build_component_ref'. It may also be NULL_TREE, 2568: in which case `current_class_type' and `current_class_decl' 2569: provide default values. 2570: 2571: BASETYPE_PATH, if non-null, is the path of basetypes 2572: to go through before we get the the instance of interest. 2573: 2574: PROTECT says whether we apply C++ scoping rules or not. */ 2575: tree 2576: build_component_type_expr (of, component, basetype_path, protect) 2577: tree of, component, basetype_path; 2578: int protect; 2579: { 2580: tree cname = NULL_TREE; 2581: tree tmp, last; 2582: tree name; 2583: int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN; 2584: 2585: assert (IS_AGGR_TYPE (TREE_TYPE (of))); 2586: assert (TREE_CODE (component) == TYPE_EXPR); 2587: 2588: tmp = TREE_OPERAND (component, 0); 2589: last = NULL_TREE; 2590: 2591: while (tmp) 2592: { 2593: switch (TREE_CODE (tmp)) 2594: { 2595: case CALL_EXPR: 2596: if (last) 2597: TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0); 2598: else 2599: TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0); 2600: if (TREE_OPERAND (tmp, 0) 2601: && TREE_OPERAND (tmp, 0) != void_list_node) 2602: { 2603: error ("operator <typename> requires empty parameter list"); 2604: TREE_OPERAND (tmp, 0) = NULL_TREE; 2605: } 2606: last = groktypename (build_tree_list (TREE_TYPE (component), 2607: TREE_OPERAND (component, 0))); 2608: name = build_typename_overload (last); 2609: TREE_TYPE (name) = last; 2610: 2611: if (of && TREE_CODE (of) != TYPE_DECL) 2612: return build_method_call (of, name, NULL_TREE, NULL_TREE, flags); 2613: else if (of) 2614: { 2615: tree this_this; 2616: 2617: if (current_class_decl == NULL_TREE) 2618: { 2619: error ("object required for `operator <typename>' call"); 2620: return error_mark_node; 2621: } 2622: 2623: this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl); 2624: return build_method_call (this_this, name, NULL_TREE, 2625: NULL_TREE, flags | LOOKUP_NONVIRTUAL); 2626: } 2627: else if (current_class_decl) 2628: return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags); 2629: 2630: error ("object required for `operator <typename>' call"); 2631: return error_mark_node; 2632: 2633: case INDIRECT_REF: 2634: case ADDR_EXPR: 2635: case ARRAY_REF: 2636: break; 2637: 2638: case SCOPE_REF: 2639: assert (cname == 0); 2640: cname = TREE_OPERAND (tmp, 0); 2641: tmp = TREE_OPERAND (tmp, 1); 2642: break; 2643: 2644: default: 2645: abort (); 2646: } 2647: last = tmp; 2648: tmp = TREE_OPERAND (tmp, 0); 2649: } 2650: 2651: last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0))); 2652: name = build_typename_overload (last); 2653: TREE_TYPE (name) = last; 2654: if (of && TREE_CODE (of) == TYPE_DECL) 2655: { 2656: if (cname == NULL_TREE) 2657: { 2658: cname = DECL_NAME (of); 2659: of = NULL_TREE; 2660: } 2661: else assert (cname == DECL_NAME (of)); 2662: } 2663: 2664: if (of) 2665: { 2666: tree this_this; 2667: 2668: if (current_class_decl == NULL_TREE) 2669: { 2670: error ("object required for `operator <typename>' call"); 2671: return error_mark_node; 2672: } 2673: 2674: this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl); 2675: return build_component_ref (this_this, name, 0, protect); 2676: } 2677: else if (cname) 2678: return build_offset_ref (cname, name); 2679: else if (current_class_name) 2680: return build_offset_ref (current_class_name, name); 2681: 2682: error ("object required for `operator <typename>' member reference"); 2683: return error_mark_node; 2684: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.