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