![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-error.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-error.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* Call-backs for C++ error reporting. ! 2: This code is non-reentrant. ! 3: Copyright (C) 1993 Free Software Foundation, Inc. ! 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: #include "config.h" ! 22: #include "tree.h" ! 23: #include "cp-tree.h" ! 24: #include "obstack.h" ! 25: #include <ctype.h> ! 26: ! 27: typedef char* cp_printer (); ! 28: ! 29: #define C code_as_string ! 30: #define D decl_as_string ! 31: #define E expr_as_string ! 32: #define L language_as_string ! 33: #define T type_as_string ! 34: ! 35: #define _ (cp_printer *) 0 ! 36: cp_printer * cp_printers[256] = ! 37: { ! 38: /*0 1 2 3 4 5 6 7 8 9 A B C D E F */ ! 39: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x00 */ ! 40: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x10 */ ! 41: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x20 */ ! 42: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x30 */ ! 43: _, _, _, C, D, E, _, _, _, _, _, _, L, _, _, _, /* 0x40 */ ! 44: _, _, _, _, T, _, _, _, _, _, _, _, _, _, _, _, /* 0x50 */ ! 45: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x60 */ ! 46: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x70 */ ! 47: }; ! 48: #undef C ! 49: #undef D ! 50: #undef E ! 51: #undef L ! 52: #undef T ! 53: #undef _ ! 54: ! 55: #define obstack_chunk_alloc xmalloc ! 56: #define obstack_chunk_free free ! 57: ! 58: /* Obstack where we build text strings for overloading, etc. */ ! 59: static struct obstack scratch_obstack; ! 60: static char *scratch_firstobj; ! 61: ! 62: # define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0) ! 63: # define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C))) ! 64: # define OB_PUTC2(C1,C2) \ ! 65: (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2))) ! 66: # define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1)) ! 67: # define OB_PUTID(ID) \ ! 68: (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \ ! 69: IDENTIFIER_LENGTH (ID))) ! 70: # define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S))) ! 71: # define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0')) ! 72: # define OB_PUTI(CST) do { sprintf (digit_buffer, "%d", (CST)); \ ! 73: OB_PUTCP (digit_buffer); } while (0) ! 74: ! 75: # define NEXT_CODE(t) (TREE_CODE (TREE_TYPE (t))) ! 76: ! 77: static void dump_type (), dump_decl (), dump_function_decl (); ! 78: static void dump_expr (), dump_unary_op (), dump_binary_op (); ! 79: static void dump_aggr_type (), dump_type_prefix (), dump_type_suffix (); ! 80: static void dump_function_name (); ! 81: ! 82: void ! 83: init_error () ! 84: { ! 85: gcc_obstack_init (&scratch_obstack); ! 86: scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0); ! 87: } ! 88: ! 89: /* Counter to help build parameter names in case they were omitted. */ ! 90: static int dummy_name; ! 91: ! 92: enum pad { none, before, after }; ! 93: ! 94: static void ! 95: dump_readonly_or_volatile (t, p) ! 96: tree t; ! 97: enum pad p; ! 98: { ! 99: if (TYPE_READONLY (t) || TYPE_VOLATILE (t)) ! 100: { ! 101: if (p == before) OB_PUTC (' '); ! 102: if (TYPE_READONLY (t)) ! 103: OB_PUTS ("const"); ! 104: if (TYPE_VOLATILE (t)) ! 105: OB_PUTS ("volatile"); ! 106: if (p == after) OB_PUTC (' '); ! 107: } ! 108: } ! 109: ! 110: /* This must be large enough to hold any printed integer or floating-point ! 111: value. */ ! 112: static char digit_buffer[128]; ! 113: ! 114: /* Dump into the obstack a human-readable equivalent of TYPE. */ ! 115: static void ! 116: dump_type (t, v) ! 117: tree t; ! 118: int v; /* verbose? */ ! 119: { ! 120: if (t == NULL_TREE) ! 121: return; ! 122: ! 123: if (TYPE_PTRMEMFUNC_P (t)) ! 124: goto offset_type; ! 125: ! 126: switch (TREE_CODE (t)) ! 127: { ! 128: case ERROR_MARK: ! 129: OB_PUTS ("<error>"); ! 130: break; ! 131: ! 132: case UNKNOWN_TYPE: ! 133: OB_PUTS ("<unknown type>"); ! 134: break; ! 135: ! 136: case TREE_LIST: ! 137: /* i.e. function taking no arguments */ ! 138: if (t != void_list_node) ! 139: { ! 140: dump_type (TREE_VALUE (t), v); ! 141: /* Can this happen other than for default arguments? */ ! 142: if (TREE_PURPOSE (t) && v) ! 143: { ! 144: OB_PUTS (" = "); ! 145: dump_expr (TREE_PURPOSE (t)); ! 146: } ! 147: if (TREE_CHAIN (t)) ! 148: { ! 149: if (TREE_CHAIN (t) != void_list_node) ! 150: { ! 151: OB_PUTC2 (',', ' '); ! 152: dump_type (TREE_CHAIN (t), v); ! 153: } ! 154: } ! 155: else OB_PUTS (" ..."); ! 156: } ! 157: break; ! 158: ! 159: case IDENTIFIER_NODE: ! 160: OB_PUTID (t); ! 161: break; ! 162: ! 163: case TREE_VEC: ! 164: dump_type (BINFO_TYPE (t), v); ! 165: break; ! 166: ! 167: case RECORD_TYPE: ! 168: case UNION_TYPE: ! 169: case ENUMERAL_TYPE: ! 170: dump_aggr_type (t, v); ! 171: break; ! 172: ! 173: case TYPE_DECL: ! 174: dump_readonly_or_volatile (t, after); ! 175: OB_PUTID (DECL_NAME (t)); ! 176: break; ! 177: ! 178: case INTEGER_TYPE: ! 179: if (!TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && TREE_UNSIGNED (t)) ! 180: OB_PUTS ("unsigned "); ! 181: else if (TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && !TREE_UNSIGNED (t)) ! 182: OB_PUTS ("signed "); ! 183: ! 184: /* fall through. */ ! 185: case REAL_TYPE: ! 186: case VOID_TYPE: ! 187: dump_readonly_or_volatile (t, after); ! 188: OB_PUTID (TYPE_IDENTIFIER (t)); ! 189: break; ! 190: ! 191: case TEMPLATE_TYPE_PARM: ! 192: OB_PUTS ("<template type parm "); ! 193: OB_PUTID (TYPE_IDENTIFIER (t)); ! 194: OB_PUTC ('>'); ! 195: break; ! 196: ! 197: case UNINSTANTIATED_P_TYPE: ! 198: OB_PUTID (DECL_NAME (UPT_TEMPLATE (t))); ! 199: OB_PUTS ("<...>"); ! 200: break; ! 201: ! 202: /* This is not always necessary for pointers and such, but doing this ! 203: reduces code size. */ ! 204: case ARRAY_TYPE: ! 205: case POINTER_TYPE: ! 206: case REFERENCE_TYPE: ! 207: case OFFSET_TYPE: ! 208: offset_type: ! 209: case FUNCTION_TYPE: ! 210: case METHOD_TYPE: ! 211: dump_type_prefix (t, v); ! 212: dump_type_suffix (t, v); ! 213: break; ! 214: ! 215: default: ! 216: my_friendly_abort (68); ! 217: ! 218: } ! 219: } ! 220: ! 221: /* Print out a class declaration, in the form `class foo'. */ ! 222: static void ! 223: dump_aggr_type (t, v) ! 224: tree t; ! 225: int v; /* verbose? */ ! 226: { ! 227: tree name; ! 228: char *variety; ! 229: ! 230: if (TREE_CODE (t) == ENUMERAL_TYPE) ! 231: variety = "enum"; ! 232: else if (TREE_CODE (t) == UNION_TYPE) ! 233: variety = "union"; ! 234: else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t)) ! 235: variety = "class"; ! 236: else ! 237: variety = "struct"; ! 238: ! 239: dump_readonly_or_volatile (t, after); ! 240: ! 241: if (v) ! 242: { ! 243: OB_PUTCP (variety); ! 244: OB_PUTC (' '); ! 245: } ! 246: ! 247: name = TYPE_NAME (t); ! 248: ! 249: if (DECL_CONTEXT (name)) ! 250: { ! 251: /* FUNCTION_DECL or RECORD_TYPE */ ! 252: dump_decl (DECL_CONTEXT (name), 0); ! 253: OB_PUTC2 (':', ':'); ! 254: } ! 255: ! 256: /* kludge around wierd behavior on g++.brendan/line1.C */ ! 257: if (TREE_CODE (name) != IDENTIFIER_NODE) ! 258: name = DECL_NAME (name); ! 259: ! 260: if (ANON_AGGRNAME_P (name)) ! 261: { ! 262: OB_PUTS ("<anonymous"); ! 263: if (!v) ! 264: { ! 265: OB_PUTC (' '); ! 266: OB_PUTCP (variety); ! 267: } ! 268: OB_PUTC ('>'); ! 269: } ! 270: else ! 271: OB_PUTID (name); ! 272: } ! 273: ! 274: /* Dump into the obstack the initial part of the output for a given type. ! 275: This is necessary when dealing with things like functions returning ! 276: functions. Examples: ! 277: ! 278: return type of `int (* fee ())()': pointer -> function -> int. Both ! 279: pointer (and reference and offset) and function (and member) types must ! 280: deal with prefix and suffix. ! 281: ! 282: Arrays must also do this for DECL nodes, like int a[], and for things like ! 283: int *[]&. */ ! 284: ! 285: static void ! 286: dump_type_prefix (t, v) ! 287: tree t; ! 288: int v; /* verbosity */ ! 289: { ! 290: if (TYPE_PTRMEMFUNC_P (t)) ! 291: { ! 292: t = TYPE_PTRMEMFUNC_FN_TYPE (t); ! 293: goto offset_type; ! 294: } ! 295: ! 296: switch (TREE_CODE (t)) ! 297: { ! 298: case POINTER_TYPE: ! 299: { ! 300: tree sub = TREE_TYPE (t); ! 301: ! 302: dump_type_prefix (sub, v); ! 303: /* A tree for a member pointer looks like pointer to offset, ! 304: so let the OFFSET_TYPE case handle it. */ ! 305: if (TREE_CODE (sub) != OFFSET_TYPE) ! 306: { ! 307: switch (TREE_CODE (sub)) ! 308: { ! 309: /* We don't want int ( *)() */ ! 310: case FUNCTION_TYPE: ! 311: case METHOD_TYPE: ! 312: break; ! 313: ! 314: case POINTER_TYPE: ! 315: /* We don't want "char * *" */ ! 316: if (! (TYPE_READONLY (sub) || TYPE_VOLATILE (sub))) ! 317: break; ! 318: /* But we do want "char *const *" */ ! 319: ! 320: default: ! 321: OB_PUTC (' '); ! 322: } ! 323: OB_PUTC ('*'); ! 324: dump_readonly_or_volatile (t, none); ! 325: } ! 326: } ! 327: break; ! 328: ! 329: case REFERENCE_TYPE: ! 330: { ! 331: tree sub = TREE_TYPE (t); ! 332: dump_type_prefix (sub, v); ! 333: ! 334: switch (TREE_CODE (sub)) ! 335: { ! 336: case POINTER_TYPE: ! 337: /* We don't want "char * &" */ ! 338: if (! (TYPE_READONLY (sub) || TYPE_VOLATILE (sub))) ! 339: break; ! 340: /* But we do want "char *const &" */ ! 341: ! 342: default: ! 343: OB_PUTC (' '); ! 344: } ! 345: } ! 346: OB_PUTC ('&'); ! 347: dump_readonly_or_volatile (t, none); ! 348: break; ! 349: ! 350: case OFFSET_TYPE: ! 351: offset_type: ! 352: dump_type_prefix (TREE_TYPE (t), v); ! 353: if (NEXT_CODE (t) != FUNCTION_TYPE && NEXT_CODE (t) != METHOD_TYPE) ! 354: OB_PUTC (' '); ! 355: if (TREE_CODE (t) == OFFSET_TYPE) ! 356: dump_type (TYPE_OFFSET_BASETYPE (t), 0); ! 357: else /* pointer to member function */ ! 358: dump_type (TYPE_METHOD_BASETYPE (TREE_TYPE (t)), 0); ! 359: OB_PUTC2 (':', ':'); ! 360: OB_PUTC ('*'); ! 361: dump_readonly_or_volatile (t, none); ! 362: break; ! 363: ! 364: /* Can only be reached through function pointer -- this would not be ! 365: correct if FUNCTION_DECLs used it. */ ! 366: case FUNCTION_TYPE: ! 367: case METHOD_TYPE: ! 368: dump_type_prefix (TREE_TYPE (t), v); ! 369: OB_PUTC2 (' ', '('); ! 370: break; ! 371: ! 372: case ARRAY_TYPE: ! 373: dump_type_prefix (TREE_TYPE (t), v); ! 374: break; ! 375: ! 376: case ENUMERAL_TYPE: ! 377: case ERROR_MARK: ! 378: case IDENTIFIER_NODE: ! 379: case INTEGER_TYPE: ! 380: case REAL_TYPE: ! 381: case RECORD_TYPE: ! 382: case TEMPLATE_TYPE_PARM: ! 383: case TREE_LIST: ! 384: case TYPE_DECL: ! 385: case TREE_VEC: ! 386: case UNINSTANTIATED_P_TYPE: ! 387: case UNION_TYPE: ! 388: case UNKNOWN_TYPE: ! 389: case VOID_TYPE: ! 390: dump_type (t, v); ! 391: break; ! 392: ! 393: default: ! 394: my_friendly_abort (65); ! 395: } ! 396: } ! 397: ! 398: static void ! 399: dump_type_suffix (t, v) ! 400: tree t; ! 401: int v; /* verbose? */ ! 402: { ! 403: if (TYPE_PTRMEMFUNC_P (t)) ! 404: t = TYPE_PTRMEMFUNC_FN_TYPE (t); ! 405: ! 406: switch (TREE_CODE (t)) ! 407: { ! 408: case POINTER_TYPE: ! 409: case REFERENCE_TYPE: ! 410: case OFFSET_TYPE: ! 411: dump_type_suffix (TREE_TYPE (t), v); ! 412: break; ! 413: ! 414: /* Can only be reached through function pointer */ ! 415: case FUNCTION_TYPE: ! 416: case METHOD_TYPE: ! 417: { ! 418: tree arg; ! 419: OB_PUTC2 (')', '('); ! 420: arg = TYPE_ARG_TYPES (t); ! 421: if (TREE_CODE (t) == METHOD_TYPE) ! 422: arg = TREE_CHAIN (arg); ! 423: ! 424: if (arg) ! 425: dump_type (arg, v); ! 426: else ! 427: OB_PUTS ("..."); ! 428: OB_PUTC (')'); ! 429: if (TREE_CODE (t) == METHOD_TYPE) ! 430: dump_readonly_or_volatile ! 431: (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before); ! 432: dump_type_suffix (TREE_TYPE (t), v); ! 433: break; ! 434: } ! 435: ! 436: case ARRAY_TYPE: ! 437: OB_PUTC ('['); ! 438: if (TYPE_DOMAIN (t)) ! 439: OB_PUTI (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) + 1); ! 440: OB_PUTC (']'); ! 441: dump_type_suffix (TREE_TYPE (t), v); ! 442: break; ! 443: ! 444: case ENUMERAL_TYPE: ! 445: case ERROR_MARK: ! 446: case IDENTIFIER_NODE: ! 447: case INTEGER_TYPE: ! 448: case REAL_TYPE: ! 449: case RECORD_TYPE: ! 450: case TEMPLATE_TYPE_PARM: ! 451: case TREE_LIST: ! 452: case TYPE_DECL: ! 453: case TREE_VEC: ! 454: case UNINSTANTIATED_P_TYPE: ! 455: case UNION_TYPE: ! 456: case UNKNOWN_TYPE: ! 457: case VOID_TYPE: ! 458: break; ! 459: ! 460: default: ! 461: my_friendly_abort (67); ! 462: } ! 463: } ! 464: ! 465: /* Return a function declaration which corresponds to the IDENTIFIER_NODE ! 466: argument. */ ! 467: tree ! 468: ident_fndecl (t) ! 469: tree t; ! 470: { ! 471: tree n = IDENTIFIER_GLOBAL_VALUE (t); ! 472: ! 473: if (TREE_CODE (n) == FUNCTION_DECL) ! 474: return n; ! 475: else if (TREE_CODE (n) == TREE_LIST ! 476: && TREE_CODE (TREE_VALUE (n)) == FUNCTION_DECL) ! 477: return TREE_VALUE (n); ! 478: else ! 479: my_friendly_abort (66); ! 480: } ! 481: ! 482: #ifndef NO_DOLLAR_IN_LABEL ! 483: # define GLOBAL_THING "_GLOBAL_$" ! 484: #else ! 485: # ifndef NO_DOT_IN_LABEL ! 486: # define GLOBAL_THING "_GLOBAL_." ! 487: # else ! 488: # define GLOBAL_THING "_GLOBAL__" ! 489: # endif ! 490: #endif ! 491: ! 492: #define GLOBAL_IORD_P(NODE) \ ! 493: !strncmp(IDENTIFIER_POINTER(NODE),GLOBAL_THING,sizeof(GLOBAL_THING)-1) ! 494: ! 495: void ! 496: dump_global_iord (t) ! 497: tree t; ! 498: { ! 499: char *name = IDENTIFIER_POINTER (t); ! 500: ! 501: OB_PUTS ("(static "); ! 502: if (name [sizeof (GLOBAL_THING) - 1] == 'I') ! 503: OB_PUTS ("initializers"); ! 504: else if (name [sizeof (GLOBAL_THING) - 1] == 'D') ! 505: OB_PUTS ("destructors"); ! 506: else ! 507: my_friendly_abort (352); ! 508: ! 509: OB_PUTS (" for "); ! 510: OB_PUTCP (input_filename); ! 511: OB_PUTC (')'); ! 512: } ! 513: ! 514: static void ! 515: dump_decl (t, v) ! 516: tree t; ! 517: int v; /* verbosity */ ! 518: { ! 519: if (t == NULL_TREE) ! 520: return; ! 521: ! 522: switch (TREE_CODE (t)) ! 523: { ! 524: case ERROR_MARK: ! 525: OB_PUTS (" /* decl error */ "); ! 526: break; ! 527: ! 528: case VAR_DECL: ! 529: if (VTABLE_NAME_P (DECL_NAME (t))) ! 530: { ! 531: OB_PUTS ("vtable for "); ! 532: dump_type (DECL_CONTEXT (t), v); ! 533: break; ! 534: } ! 535: /* else fall through */ ! 536: case FIELD_DECL: ! 537: case PARM_DECL: ! 538: if (v) ! 539: { ! 540: dump_type_prefix (TREE_TYPE (t), v); ! 541: OB_PUTC(' '); ! 542: } ! 543: /* DECL_CLASS_CONTEXT isn't being set in some cases. Hmm... */ ! 544: if (TREE_CODE (t) == FIELD_DECL ! 545: || (TREE_CODE (t) == VAR_DECL && DECL_CONTEXT (t) ! 546: && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't')) ! 547: { ! 548: dump_type (DECL_CONTEXT (t), 0); ! 549: OB_PUTC2(':', ':'); ! 550: } ! 551: if (DECL_NAME (t)) ! 552: dump_decl (DECL_NAME (t), v); ! 553: else ! 554: OB_PUTS ("<anon>"); ! 555: if (v) dump_type_suffix (TREE_TYPE (t), v); ! 556: break; ! 557: ! 558: case ARRAY_REF: ! 559: dump_decl (TREE_OPERAND (t, 0), v); ! 560: OB_PUTC ('['); ! 561: dump_decl (TREE_OPERAND (t, 1), v); ! 562: OB_PUTC (']'); ! 563: break; ! 564: ! 565: /* So that we can do dump_decl in dump_aggr_type and have it work for ! 566: both class and function scope. */ ! 567: case RECORD_TYPE: ! 568: case UNION_TYPE: ! 569: case ENUMERAL_TYPE: ! 570: dump_type (t, v); ! 571: break; ! 572: ! 573: case TYPE_DECL: ! 574: dump_type (TREE_TYPE (t), v); ! 575: break; ! 576: ! 577: case TYPE_EXPR: ! 578: my_friendly_abort (69); ! 579: break; ! 580: ! 581: /* These special cases are duplicated here so that other functions ! 582: can feed identifiers to cp_error and get them demangled properly. */ ! 583: case IDENTIFIER_NODE: ! 584: if (DESTRUCTOR_NAME_P (t)) ! 585: { ! 586: OB_PUTC ('~'); ! 587: dump_decl (DECL_NAME (ident_fndecl (t)), 0); ! 588: } ! 589: else if (IDENTIFIER_TYPENAME_P (t)) ! 590: { ! 591: OB_PUTS ("operator "); ! 592: /* Not exactly IDENTIFIER_TYPE_VALUE. */ ! 593: dump_type (TREE_TYPE (t), 0); ! 594: break; ! 595: } ! 596: else if (IDENTIFIER_OPNAME_P (t)) ! 597: { ! 598: char *name_string = operator_name_string (t); ! 599: OB_PUTS ("operator "); ! 600: OB_PUTCP (name_string); ! 601: } ! 602: else ! 603: OB_PUTID (t); ! 604: break; ! 605: ! 606: case FUNCTION_DECL: ! 607: if (GLOBAL_IORD_P (DECL_ASSEMBLER_NAME (t))) ! 608: dump_global_iord (DECL_ASSEMBLER_NAME (t)); ! 609: else ! 610: dump_function_decl (t, v); ! 611: break; ! 612: ! 613: case TEMPLATE_DECL: ! 614: switch (NEXT_CODE (t)) ! 615: { ! 616: case METHOD_TYPE: ! 617: case FUNCTION_TYPE: ! 618: dump_function_decl (t, v); ! 619: break; ! 620: ! 621: default: ! 622: my_friendly_abort (353); ! 623: } ! 624: break; ! 625: ! 626: case LABEL_DECL: ! 627: OB_PUTID (DECL_NAME (t)); ! 628: break; ! 629: ! 630: case CONST_DECL: ! 631: if (NEXT_CODE (t) == ENUMERAL_TYPE) ! 632: { ! 633: if (DECL_CONTEXT (t)) ! 634: { ! 635: dump_decl (DECL_CONTEXT (t), 0); ! 636: OB_PUTC2 (':', ':'); ! 637: } ! 638: OB_PUTID (DECL_NAME (t)); ! 639: } ! 640: else ! 641: dump_expr (DECL_INITIAL (t), 0); ! 642: break; ! 643: ! 644: default: ! 645: my_friendly_abort (70); ! 646: } ! 647: } ! 648: ! 649: /* Pretty printing for announce_function. T is the declaration of the ! 650: function we are interested in seeing. V is non-zero if we should print ! 651: the type that this function returns. */ ! 652: ! 653: static void ! 654: dump_function_decl (t, v) ! 655: tree t; ! 656: int v; ! 657: { ! 658: tree name = DECL_ASSEMBLER_NAME (t); ! 659: tree fntype = TREE_TYPE (t); ! 660: tree parmtypes = TYPE_ARG_TYPES (fntype); ! 661: tree cname = NULL_TREE; ! 662: int spaces = 0; ! 663: ! 664: if (DECL_CLASS_CONTEXT (t)) ! 665: cname = DECL_CLASS_CONTEXT (t); ! 666: /* this is for partially instantiated template methods */ ! 667: else if (TREE_CODE (fntype) == METHOD_TYPE) ! 668: cname = TREE_TYPE (TREE_VALUE (parmtypes)); ! 669: ! 670: if (v) ! 671: { ! 672: if (DECL_STATIC_FUNCTION_P (t)) ! 673: OB_PUTS ("static "); ! 674: ! 675: if (! IDENTIFIER_TYPENAME_P (name)) ! 676: { ! 677: dump_type_prefix (TREE_TYPE (fntype), 1); ! 678: OB_PUTC (' '); ! 679: } ! 680: } ! 681: ! 682: if (cname) ! 683: { ! 684: dump_type (cname, 0); ! 685: OB_PUTC2 (':', ':'); ! 686: if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes) ! 687: parmtypes = TREE_CHAIN (parmtypes); ! 688: if (DECL_CONSTRUCTOR_FOR_VBASE_P (t)) ! 689: /* Skip past "in_charge" identifier. */ ! 690: parmtypes = TREE_CHAIN (parmtypes); ! 691: } ! 692: ! 693: if (DESTRUCTOR_NAME_P (name)) ! 694: parmtypes = TREE_CHAIN (parmtypes); ! 695: ! 696: dump_function_name (t); ! 697: ! 698: OB_PUTC ('('); ! 699: ! 700: if (parmtypes) ! 701: dump_type (parmtypes, v); ! 702: else ! 703: OB_PUTS ("..."); ! 704: ! 705: OB_PUTC (')'); ! 706: ! 707: if (v && ! IDENTIFIER_TYPENAME_P (name)) ! 708: dump_type_suffix (TREE_TYPE (fntype), 1); ! 709: ! 710: if (TREE_CODE (fntype) == METHOD_TYPE) ! 711: dump_readonly_or_volatile ! 712: (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))), before); ! 713: } ! 714: ! 715: /* Handle the function name for a FUNCTION_DECL node, grokking operators ! 716: and destructors properly. */ ! 717: static void ! 718: dump_function_name (t) ! 719: tree t; ! 720: { ! 721: tree name = DECL_NAME (t); ! 722: ! 723: /* There ought to be a better way to find out whether or not something is ! 724: a destructor. */ ! 725: if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (t))) ! 726: { ! 727: OB_PUTC ('~'); ! 728: dump_decl (name, 0); ! 729: } ! 730: else if (IDENTIFIER_TYPENAME_P (name)) ! 731: { ! 732: /* This cannot use the hack that the operator's return ! 733: type is stashed off of its name because it may be ! 734: used for error reporting. In the case of conflicting ! 735: declarations, both will have the same name, yet ! 736: the types will be different, hence the TREE_TYPE field ! 737: of the first name will be clobbered by the second. */ ! 738: OB_PUTS ("operator "); ! 739: dump_type (TREE_TYPE (TREE_TYPE (t)), 0); ! 740: } ! 741: else if (IDENTIFIER_OPNAME_P (name)) ! 742: { ! 743: char *name_string = operator_name_string (name); ! 744: OB_PUTS ("operator "); ! 745: OB_PUTCP (name_string); ! 746: } ! 747: else ! 748: dump_decl (name, 0); ! 749: } ! 750: ! 751: static void ! 752: dump_char (c) ! 753: char c; ! 754: { ! 755: switch (c) ! 756: { ! 757: case '\n': ! 758: OB_PUTS ("\\n"); ! 759: break; ! 760: case '\t': ! 761: OB_PUTS ("\\t"); ! 762: break; ! 763: case '\v': ! 764: OB_PUTS ("\\v"); ! 765: break; ! 766: case '\b': ! 767: OB_PUTS ("\\b"); ! 768: break; ! 769: case '\r': ! 770: OB_PUTS ("\\r"); ! 771: break; ! 772: case '\f': ! 773: OB_PUTS ("\\f"); ! 774: break; ! 775: case '\a': ! 776: OB_PUTS ("\\a"); ! 777: break; ! 778: case '\\': ! 779: OB_PUTS ("\\\\"); ! 780: break; ! 781: case '\'': ! 782: OB_PUTS ("\\'"); ! 783: break; ! 784: case '\"': ! 785: OB_PUTS ("\\\""); ! 786: break; ! 787: default: ! 788: if (isprint (c)) ! 789: OB_PUTC (c); ! 790: else ! 791: { ! 792: sprintf (digit_buffer, "\\%03o", (int) c); ! 793: OB_PUTCP (digit_buffer); ! 794: } ! 795: } ! 796: } ! 797: ! 798: /* Print out a list of initializers (subr of dump_expr) */ ! 799: static void ! 800: dump_expr_list (l) ! 801: tree l; ! 802: { ! 803: while (l) ! 804: { ! 805: dump_expr (TREE_VALUE (l), 0); ! 806: if (TREE_CHAIN (l)) ! 807: OB_PUTC2 (',', ' '); ! 808: l = TREE_CHAIN (l); ! 809: } ! 810: } ! 811: ! 812: /* Print out an expression */ ! 813: static void ! 814: dump_expr (t, nop) ! 815: tree t; ! 816: int nop; /* suppress parens */ ! 817: { ! 818: switch (TREE_CODE (t)) ! 819: { ! 820: case VAR_DECL: ! 821: case PARM_DECL: ! 822: case FIELD_DECL: ! 823: case CONST_DECL: ! 824: case FUNCTION_DECL: ! 825: dump_decl (t, 0); ! 826: break; ! 827: ! 828: case INTEGER_CST: ! 829: { ! 830: tree type = TREE_TYPE (t); ! 831: my_friendly_assert (type != 0, 81); ! 832: ! 833: /* If it's an enum, output its tag, rather than its value. */ ! 834: if (TREE_CODE (type) == ENUMERAL_TYPE) ! 835: { ! 836: char *p = enum_name_string (t, type); ! 837: OB_PUTCP (p); ! 838: } ! 839: else if (type == char_type_node ! 840: || type == signed_char_type_node ! 841: || type == unsigned_char_type_node) ! 842: { ! 843: OB_PUTC ('\''); ! 844: dump_char (TREE_INT_CST_LOW (t)); ! 845: OB_PUTC ('\''); ! 846: } ! 847: else if (TREE_INT_CST_HIGH (t) ! 848: != (TREE_INT_CST_LOW (t) >> (HOST_BITS_PER_WIDE_INT - 1))) ! 849: { ! 850: tree val = t; ! 851: if (TREE_INT_CST_HIGH (val) < 0) ! 852: { ! 853: OB_PUTC ('-'); ! 854: val = build_int_2 (~TREE_INT_CST_LOW (val), ! 855: -TREE_INT_CST_HIGH (val)); ! 856: } ! 857: /* Would "%x%0*x" or "%x%*0x" get zero-padding on all ! 858: systems? */ ! 859: { ! 860: static char format[10]; /* "%x%09999x\0" */ ! 861: if (!format[0]) ! 862: sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4); ! 863: sprintf (digit_buffer, format, TREE_INT_CST_HIGH (val), ! 864: TREE_INT_CST_LOW (val)); ! 865: OB_PUTCP (digit_buffer); ! 866: } ! 867: } ! 868: else ! 869: OB_PUTI (TREE_INT_CST_LOW (t)); ! 870: } ! 871: break; ! 872: ! 873: case REAL_CST: ! 874: #ifndef REAL_IS_NOT_DOUBLE ! 875: sprintf (digit_buffer, "%g", TREE_REAL_CST (t)); ! 876: #else ! 877: { ! 878: int i; ! 879: char *p = (char *) &TREE_REAL_CST (t); ! 880: sprintf (digit_buffer, "0x"); ! 881: for (i = 0; i < sizeof TREE_REAL_CST (t); i++) ! 882: sprintf (digit_buffer + 2 + 2*i, "%02x", *p++); ! 883: } ! 884: #endif ! 885: OB_PUTCP (digit_buffer); ! 886: break; ! 887: ! 888: case STRING_CST: ! 889: { ! 890: char *p = TREE_STRING_POINTER (t); ! 891: int len = TREE_STRING_LENGTH (t) - 1; ! 892: int i; ! 893: ! 894: OB_PUTC ('\"'); ! 895: for (i = 0; i < len; i++) ! 896: dump_char (p[i]); ! 897: OB_PUTC ('\"'); ! 898: } ! 899: break; ! 900: ! 901: case COMPOUND_EXPR: ! 902: dump_binary_op (",", t); ! 903: break; ! 904: ! 905: case COND_EXPR: ! 906: OB_PUTC ('('); ! 907: dump_expr (TREE_OPERAND (t, 0), 0); ! 908: OB_PUTS (" ? "); ! 909: dump_expr (TREE_OPERAND (t, 1), 0); ! 910: OB_PUTS (" : "); ! 911: dump_expr (TREE_OPERAND (t, 2), 0); ! 912: OB_PUTC (')'); ! 913: break; ! 914: ! 915: case SAVE_EXPR: ! 916: if (TREE_HAS_CONSTRUCTOR (t)) ! 917: { ! 918: OB_PUTS ("new "); ! 919: dump_type (TREE_TYPE (TREE_TYPE (t)), 0); ! 920: PARM_DECL_EXPR (t) = 1; ! 921: } ! 922: else ! 923: { ! 924: sorry ("operand of SAVE_EXPR not understood"); ! 925: goto error; ! 926: } ! 927: break; ! 928: ! 929: case NEW_EXPR: ! 930: OB_PUTID (TYPE_IDENTIFIER (TREE_TYPE (t))); ! 931: OB_PUTC ('('); ! 932: dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1))); ! 933: OB_PUTC (')'); ! 934: break; ! 935: ! 936: case CALL_EXPR: ! 937: dump_expr (TREE_OPERAND (t, 0), 0); ! 938: OB_PUTC2 (' ', '('); ! 939: dump_expr_list (TREE_OPERAND (t, 1)); ! 940: OB_PUTC (')'); ! 941: break; ! 942: ! 943: case WITH_CLEANUP_EXPR: ! 944: /* Note that this only works for G++ cleanups. If somebody ! 945: builds a general cleanup, there's no way to represent it. */ ! 946: dump_expr (TREE_OPERAND (t, 0), 0); ! 947: break; ! 948: ! 949: case TARGET_EXPR: ! 950: /* Note that this only works for G++ target exprs. If somebody ! 951: builds a general TARGET_EXPR, there's no way to represent that ! 952: it initializes anything other that the parameter slot for the ! 953: default argument. Note we may have cleared out the first ! 954: operand in expand_expr, so don't go killing ourselves. */ ! 955: if (TREE_OPERAND (t, 1)) ! 956: dump_expr (TREE_OPERAND (t, 1), 0); ! 957: break; ! 958: ! 959: case MODIFY_EXPR: ! 960: case PLUS_EXPR: ! 961: case MINUS_EXPR: ! 962: case MULT_EXPR: ! 963: case TRUNC_DIV_EXPR: ! 964: case TRUNC_MOD_EXPR: ! 965: case MIN_EXPR: ! 966: case MAX_EXPR: ! 967: case LSHIFT_EXPR: ! 968: case RSHIFT_EXPR: ! 969: case BIT_IOR_EXPR: ! 970: case BIT_XOR_EXPR: ! 971: case BIT_AND_EXPR: ! 972: case BIT_ANDTC_EXPR: ! 973: case TRUTH_ANDIF_EXPR: ! 974: case TRUTH_ORIF_EXPR: ! 975: case LT_EXPR: ! 976: case LE_EXPR: ! 977: case GT_EXPR: ! 978: case GE_EXPR: ! 979: case EQ_EXPR: ! 980: case NE_EXPR: ! 981: dump_binary_op (opname_tab[(int) TREE_CODE (t)], t); ! 982: break; ! 983: ! 984: case CEIL_DIV_EXPR: ! 985: case FLOOR_DIV_EXPR: ! 986: case ROUND_DIV_EXPR: ! 987: dump_binary_op ("/", t); ! 988: break; ! 989: ! 990: case CEIL_MOD_EXPR: ! 991: case FLOOR_MOD_EXPR: ! 992: case ROUND_MOD_EXPR: ! 993: dump_binary_op ("%", t); ! 994: break; ! 995: ! 996: case COMPONENT_REF: ! 997: dump_binary_op (".", t); ! 998: break; ! 999: ! 1000: case CONVERT_EXPR: ! 1001: dump_unary_op ("+", t, nop); ! 1002: break; ! 1003: ! 1004: case ADDR_EXPR: ! 1005: if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL ! 1006: || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST) ! 1007: dump_expr (TREE_OPERAND (t, 0), 0); ! 1008: else ! 1009: dump_unary_op ("&", t, nop); ! 1010: break; ! 1011: ! 1012: case INDIRECT_REF: ! 1013: if (TREE_HAS_CONSTRUCTOR (t)) ! 1014: { ! 1015: t = TREE_OPERAND (t, 0); ! 1016: my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237); ! 1017: dump_expr (TREE_OPERAND (t, 0), 0); ! 1018: OB_PUTC ('('); ! 1019: dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1))); ! 1020: OB_PUTC (')'); ! 1021: } ! 1022: else ! 1023: dump_unary_op ("*", t, nop); ! 1024: break; ! 1025: ! 1026: case NEGATE_EXPR: ! 1027: case BIT_NOT_EXPR: ! 1028: case TRUTH_NOT_EXPR: ! 1029: case PREDECREMENT_EXPR: ! 1030: case PREINCREMENT_EXPR: ! 1031: dump_unary_op (opname_tab [(int)TREE_CODE (t)], t, nop); ! 1032: break; ! 1033: ! 1034: case POSTDECREMENT_EXPR: ! 1035: case POSTINCREMENT_EXPR: ! 1036: OB_PUTC ('('); ! 1037: dump_expr (TREE_OPERAND (t, 0), 0); ! 1038: OB_PUTCP (opname_tab[(int)TREE_CODE (t)]); ! 1039: OB_PUTC (')'); ! 1040: break; ! 1041: ! 1042: case NON_LVALUE_EXPR: ! 1043: /* FIXME: This is a KLUDGE workaround for a parsing problem. There ! 1044: should be another level of INDIRECT_REF so that I don't have to do ! 1045: this. */ ! 1046: if (NEXT_CODE (t) == POINTER_TYPE) ! 1047: { ! 1048: tree next = TREE_TYPE (TREE_TYPE (t)); ! 1049: ! 1050: while (TREE_CODE (next) == POINTER_TYPE) ! 1051: next = TREE_TYPE (next); ! 1052: ! 1053: if (TREE_CODE (next) == FUNCTION_TYPE) ! 1054: { ! 1055: if (!nop) OB_PUTC ('('); ! 1056: OB_PUTC ('*'); ! 1057: dump_expr (TREE_OPERAND (t, 0), 1); ! 1058: if (!nop) OB_PUTC (')'); ! 1059: break; ! 1060: } ! 1061: /* else FALLTHRU */ ! 1062: } ! 1063: dump_expr (TREE_OPERAND (t, 0), 0); ! 1064: break; ! 1065: ! 1066: case NOP_EXPR: ! 1067: dump_expr (TREE_OPERAND (t, 0), nop); ! 1068: break; ! 1069: ! 1070: case CONSTRUCTOR: ! 1071: OB_PUTC ('{'); ! 1072: dump_expr_list (CONSTRUCTOR_ELTS (t), 0); ! 1073: OB_PUTC ('}'); ! 1074: break; ! 1075: ! 1076: /* This list is incomplete, but should suffice for now. ! 1077: It is very important that `sorry' does not call ! 1078: `report_error_function'. That could cause an infinite loop. */ ! 1079: default: ! 1080: sorry ("`%s' not supported by dump_expr", ! 1081: tree_code_name[(int) TREE_CODE (t)]); ! 1082: ! 1083: /* fall through to ERROR_MARK... */ ! 1084: case ERROR_MARK: ! 1085: error: ! 1086: OB_PUTCP ("/* error */"); ! 1087: break; ! 1088: } ! 1089: } ! 1090: ! 1091: static void ! 1092: dump_binary_op (opstring, t) ! 1093: char *opstring; ! 1094: tree t; ! 1095: { ! 1096: OB_PUTC ('('); ! 1097: dump_expr (TREE_OPERAND (t, 0), 1); ! 1098: OB_PUTC (' '); ! 1099: OB_PUTCP (opstring); ! 1100: OB_PUTC (' '); ! 1101: dump_expr (TREE_OPERAND (t, 1), 1); ! 1102: OB_PUTC (')'); ! 1103: } ! 1104: ! 1105: static void ! 1106: dump_unary_op (opstring, t, nop) ! 1107: char *opstring; ! 1108: tree t; ! 1109: int nop; ! 1110: { ! 1111: if (!nop) OB_PUTC ('('); ! 1112: OB_PUTCP (opstring); ! 1113: dump_expr (TREE_OPERAND (t, 0), 1); ! 1114: if (!nop) OB_PUTC (')'); ! 1115: } ! 1116: ! 1117: char * ! 1118: fndecl_as_string (cname, fndecl, print_ret_type_p) ! 1119: tree cname, fndecl; ! 1120: int print_ret_type_p; ! 1121: { ! 1122: return decl_as_string (fndecl, print_ret_type_p); ! 1123: } ! 1124: ! 1125: /* Same, but handtype a _TYPE. ! 1126: Called from convert_to_reference, mangle_class_name_for_template, ! 1127: build_unary_op, and GNU_xref_decl. */ ! 1128: char * ! 1129: type_as_string (typ, v) ! 1130: tree typ; ! 1131: int v; ! 1132: { ! 1133: OB_INIT (); ! 1134: ! 1135: dump_type (typ, v); ! 1136: ! 1137: OB_FINISH (); ! 1138: ! 1139: return (char *)obstack_base (&scratch_obstack); ! 1140: } ! 1141: ! 1142: char * ! 1143: expr_as_string (decl, v) ! 1144: tree decl; ! 1145: int v; ! 1146: { ! 1147: OB_INIT (); ! 1148: ! 1149: dump_expr (decl, 1); ! 1150: ! 1151: OB_FINISH (); ! 1152: ! 1153: return (char *)obstack_base (&scratch_obstack); ! 1154: } ! 1155: ! 1156: /* A cross between type_as_string and fndecl_as_string. ! 1157: Only called from substitute_nice_name. */ ! 1158: char * ! 1159: decl_as_string (decl, v) ! 1160: tree decl; ! 1161: int v; ! 1162: { ! 1163: OB_INIT (); ! 1164: ! 1165: dump_decl (decl, v); ! 1166: ! 1167: OB_FINISH (); ! 1168: ! 1169: return (char *)obstack_base (&scratch_obstack); ! 1170: } ! 1171: ! 1172: char * ! 1173: cp_file_of (t) ! 1174: tree t; ! 1175: { ! 1176: if (TREE_CODE (t) == PARM_DECL) ! 1177: return DECL_SOURCE_FILE (DECL_CONTEXT (t)); ! 1178: else ! 1179: return DECL_SOURCE_FILE (t); ! 1180: } ! 1181: ! 1182: int ! 1183: cp_line_of (t) ! 1184: tree t; ! 1185: { ! 1186: if (TREE_CODE (t) == PARM_DECL) ! 1187: return DECL_SOURCE_LINE (DECL_CONTEXT (t)); ! 1188: else ! 1189: return DECL_SOURCE_LINE (t); ! 1190: } ! 1191: ! 1192: char * ! 1193: code_as_string (c, v) ! 1194: enum tree_code c; ! 1195: int v; ! 1196: { ! 1197: return tree_code_name [c]; ! 1198: } ! 1199: ! 1200: char * ! 1201: language_as_string (c, v) ! 1202: enum languages c; ! 1203: int v; ! 1204: { ! 1205: switch (c) ! 1206: { ! 1207: case lang_c: ! 1208: return "C"; ! 1209: ! 1210: case lang_cplusplus: ! 1211: return "C++"; ! 1212: ! 1213: default: ! 1214: my_friendly_abort (355); ! 1215: } ! 1216: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.