cp-tree.h (type_as_string_real): New function.

Fri Apr 17 21:25:00 1998  Mark Mitchell  <mmitchell@usa.net>
	* cp-tree.h (type_as_string_real): New function.
	* pt.c (mangle_class_name_for_template): Use it.
	* error.c (dump_aggr_type): Change prototype.
	(dump_type_prefix): Likewise.
	(dump_type_suffix): Likewise.
	(dump_type_real): Convert from dump_type.  If desired, the
	"canonica" name of a typedef, i.e., the name of the underlying
	type, can be printed.
	(dump_type): Call dump_type_real.

From-SVN: r19273

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index d15bc1acf0eddda9ec4acde8fa65147f6062d079..3d8f991a4e9256c202f488a941304d231de6c73f 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,15 @@
+Fri Apr 17 21:25:00 1998  Mark Mitchell  <mmitchell@usa.net>
+
+       * cp-tree.h (type_as_string_real): New function.
+       * pt.c (mangle_class_name_for_template): Use it.
+       * error.c (dump_aggr_type): Change prototype.
+       (dump_type_prefix): Likewise.
+       (dump_type_suffix): Likewise.
+       (dump_type_real): Convert from dump_type.  If desired, the
+       "canonica" name of a typedef, i.e., the name of the underlying
+       type, can be printed.
+       (dump_type): Call dump_type_real.
+
 Fri Apr 17 14:30:45 1998  Jason Merrill  <jason@yorick.cygnus.com>
 
        * decl2.c (lang_decode_option): -fnew-abi implies -fvtable-thunks.

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index dd2e087c153ab5d1c6eb7fe517b03e8830b40193..e2f68aa816f5ae991402dd3d5f76e0719bacc56b 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -2272,6 +2272,7 @@ extern void cp_sprintf                            ();
 extern void init_error                         PROTO((void));
 extern char *fndecl_as_string                  PROTO((tree, int));
 extern char *type_as_string                    PROTO((tree, int));
+extern char *type_as_string_real               PROTO((tree, int, int));
 extern char *args_as_string                    PROTO((tree, int));
 extern char *decl_as_string                    PROTO((tree, int));
 extern char *expr_as_string                    PROTO((tree, int));

diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 7e9b06cad8b6ca6f68f55cd9c53f1ea3cf697048..a9e9661490ca3f633da9df9a7712743af759803c 100644 (file)
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -88,14 +88,15 @@ static char *scratch_firstobj;
 enum pad { none, before, after };
 
 static void dump_type PROTO((tree, int));
+static void dump_type_real PROTO((tree, int, int));
 static void dump_decl PROTO((tree, int));
 static void dump_function_decl PROTO((tree, int));
 static void dump_expr PROTO((tree, int));
 static void dump_unary_op PROTO((char *, tree, int));
 static void dump_binary_op PROTO((char *, tree));
-static void dump_aggr_type PROTO((tree, int));
-static void dump_type_prefix PROTO((tree, int));
-static void dump_type_suffix PROTO((tree, int));
+static void dump_aggr_type PROTO((tree, int, int));
+static void dump_type_prefix PROTO((tree, int, int));
+static void dump_type_suffix PROTO((tree, int, int));
 static void dump_function_name PROTO((tree));
 static void dump_expr_list PROTO((tree));
 static void dump_global_iord PROTO((tree));
@@ -136,7 +137,7 @@ static char digit_buffer[128];
 /* Dump into the obstack a human-readable equivalent of TYPE.  */
 
 static void
-dump_type (t, v)
+dump_type_real (t, v, canonical_name)
      tree t;
      int v;                    /* verbose? */
 {
@@ -160,7 +161,7 @@ dump_type (t, v)
       /* i.e. function taking no arguments */
       if (t != void_list_node)
        {
-         dump_type (TREE_VALUE (t), v);
+         dump_type_real (TREE_VALUE (t), v, canonical_name);
          /* Can this happen other than for default arguments? */
          if (TREE_PURPOSE (t) && v)
            {
@@ -172,7 +173,7 @@ dump_type (t, v)
              if (TREE_CHAIN (t) != void_list_node)
                {
                  OB_PUTC2 (',', ' ');
-                 dump_type (TREE_CHAIN (t), v);
+                 dump_type_real (TREE_CHAIN (t), v, canonical_name);
                }
            }
          else OB_PUTS (" ...");
@@ -184,7 +185,7 @@ dump_type (t, v)
       break;
 
     case TREE_VEC:
-      dump_type (BINFO_TYPE (t), v);
+      dump_type_real (BINFO_TYPE (t), v, canonical_name);
       break;
 
     case RECORD_TYPE:
@@ -195,14 +196,14 @@ dump_type (t, v)
        {
          if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
            dump_readonly_or_volatile (t, after);
-         dump_type (SIGNATURE_TYPE (t), v);
+         dump_type_real (SIGNATURE_TYPE (t), v, canonical_name);
          if (IS_SIGNATURE_POINTER (t))
            OB_PUTC ('*');
          else
            OB_PUTC ('&');
        }
       else
-       dump_aggr_type (t, v);
+       dump_aggr_type (t, v, canonical_name);
       break;
 
     case TYPE_DECL:
@@ -212,7 +213,7 @@ dump_type (t, v)
 
     case COMPLEX_TYPE:
       OB_PUTS ("complex ");
-      dump_type (TREE_TYPE (t), v);
+      dump_type_real (TREE_TYPE (t), v, canonical_name);
       break;
 
     case INTEGER_TYPE:
@@ -226,7 +227,7 @@ dump_type (t, v)
     case VOID_TYPE:
     case BOOLEAN_TYPE:
       dump_readonly_or_volatile (t, after);
-      OB_PUTID (TYPE_IDENTIFIER (t));
+      OB_PUTID (TYPE_IDENTIFIER (canonical_name ? TYPE_MAIN_VARIANT (t) : t));
       break;
 
     case TEMPLATE_TEMPLATE_PARM:
@@ -249,7 +250,7 @@ dump_type (t, v)
              tree arg = TREE_VEC_ELT (args, i);
              if (TREE_CODE_CLASS (TREE_CODE (arg)) == 't'
                  || TREE_CODE (arg) == TEMPLATE_DECL)
-               dump_type (arg, 0);
+               dump_type_real (arg, 0, canonical_name);
              else
                dump_expr (arg, 0);
              if (i < TREE_VEC_LENGTH (args)-1)
@@ -276,13 +277,13 @@ dump_type (t, v)
     offset_type:
     case FUNCTION_TYPE:
     case METHOD_TYPE:
-      dump_type_prefix (t, v);
-      dump_type_suffix (t, v);
+      dump_type_prefix (t, v, canonical_name);
+      dump_type_suffix (t, v, canonical_name);
       break;
 
     case TYPENAME_TYPE:
       OB_PUTS ("typename ");
-      dump_type (TYPE_CONTEXT (t), 0);
+      dump_type_real (TYPE_CONTEXT (t), 0, canonical_name);
       OB_PUTS ("::");
       OB_PUTID (TYPE_IDENTIFIER (t));
       break;
@@ -309,12 +310,21 @@ aggr_variety (t)
     return "struct";
 }
 
+static void
+dump_type (t, v)
+     tree t;
+     int v;                    /* verbose? */
+{
+  dump_type_real (t, v, 0);
+}
+
 /* Print out a class declaration, in the form `class foo'.  */
 
 static void
-dump_aggr_type (t, v)
+dump_aggr_type (t, v, canonical_name)
      tree t;
      int v;                    /* verbose? */
+     int canonical_name;
 {
   tree name;
   char *variety = aggr_variety (t);
@@ -327,7 +337,7 @@ dump_aggr_type (t, v)
       OB_PUTC (' ');
     }
   
-  name = TYPE_NAME (t);
+  name = TYPE_NAME (canonical_name ? TYPE_MAIN_VARIANT (t) : t);
 
   if (name && DECL_CONTEXT (name))
     {
@@ -366,9 +376,10 @@ dump_aggr_type (t, v)
    int *[]&.  */
 
 static void
-dump_type_prefix (t, v)
+dump_type_prefix (t, v, canonical_name)
      tree t;
      int v;                    /* verbosity */
+     int canonical_name;
 {
   if (TYPE_PTRMEMFUNC_P (t))
     {
@@ -382,7 +393,7 @@ dump_type_prefix (t, v)
       {
        tree sub = TREE_TYPE (t);
        
-       dump_type_prefix (sub, v);
+       dump_type_prefix (sub, v, canonical_name);
        /* A tree for a member pointer looks like pointer to offset,
           so let the OFFSET_TYPE case handle it.  */
        if (TREE_CODE (sub) != OFFSET_TYPE)
@@ -416,7 +427,7 @@ dump_type_prefix (t, v)
     case REFERENCE_TYPE:
       {
        tree sub = TREE_TYPE (t);
-       dump_type_prefix (sub, v);
+       dump_type_prefix (sub, v, canonical_name);
 
        switch (TREE_CODE (sub))
          {
@@ -440,11 +451,11 @@ dump_type_prefix (t, v)
 
     case OFFSET_TYPE:
     offset_type:
-      dump_type_prefix (TREE_TYPE (t), v);
+      dump_type_prefix (TREE_TYPE (t), v, canonical_name);
       if (TREE_CODE (t) == OFFSET_TYPE)        /* pmfs deal with this in d_t_p */
        {
          OB_PUTC (' ');
-         dump_type (TYPE_OFFSET_BASETYPE (t), 0);
+         dump_type_real (TYPE_OFFSET_BASETYPE (t), 0, canonical_name);
          OB_PUTC2 (':', ':');
        }
       OB_PUTC ('*');
@@ -454,19 +465,19 @@ dump_type_prefix (t, v)
       /* Can only be reached through function pointer -- this would not be
          correct if FUNCTION_DECLs used it.  */
     case FUNCTION_TYPE:
-      dump_type_prefix (TREE_TYPE (t), v);
+      dump_type_prefix (TREE_TYPE (t), v, canonical_name);
       OB_PUTC2 (' ', '(');
       break;
 
     case METHOD_TYPE:
-      dump_type_prefix (TREE_TYPE (t), v);
+      dump_type_prefix (TREE_TYPE (t), v, canonical_name);
       OB_PUTC2 (' ', '(');
-      dump_aggr_type (TYPE_METHOD_BASETYPE (t), 0);
+      dump_aggr_type (TYPE_METHOD_BASETYPE (t), 0, canonical_name);
       OB_PUTC2 (':', ':');
       break;
 
     case ARRAY_TYPE:
-      dump_type_prefix (TREE_TYPE (t), v);
+      dump_type_prefix (TREE_TYPE (t), v, canonical_name);
       break;
 
     case ENUMERAL_TYPE:
@@ -486,7 +497,7 @@ dump_type_prefix (t, v)
     case VOID_TYPE:
     case TYPENAME_TYPE:
     case COMPLEX_TYPE:
-      dump_type (t, v);
+      dump_type_real (t, v, canonical_name);
       break;
       
     default:
@@ -496,9 +507,10 @@ dump_type_prefix (t, v)
 }
 
 static void
-dump_type_suffix (t, v)
+dump_type_suffix (t, v, canonical_name)
      tree t;
      int v;                    /* verbose? */
+     int canonical_name;
 {
   if (TYPE_PTRMEMFUNC_P (t))
     t = TYPE_PTRMEMFUNC_FN_TYPE (t);
@@ -510,7 +522,7 @@ dump_type_suffix (t, v)
     case OFFSET_TYPE:
       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
        OB_PUTC (')');
-      dump_type_suffix (TREE_TYPE (t), v);
+      dump_type_suffix (TREE_TYPE (t), v, canonical_name);
       break;
 
       /* Can only be reached through function pointer */
@@ -531,7 +543,7 @@ dump_type_suffix (t, v)
        if (TREE_CODE (t) == METHOD_TYPE)
          dump_readonly_or_volatile
            (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
-       dump_type_suffix (TREE_TYPE (t), v);
+       dump_type_suffix (TREE_TYPE (t), v, canonical_name);
        break;
       }
 
@@ -549,7 +561,7 @@ dump_type_suffix (t, v)
                              integer_one_node, 1)), 0);
        }
       OB_PUTC (']');
-      dump_type_suffix (TREE_TYPE (t), v);
+      dump_type_suffix (TREE_TYPE (t), v, canonical_name);
       break;
       
     case ENUMERAL_TYPE:
@@ -676,7 +688,7 @@ dump_decl (t, v)
     general:
       if (v > 0)
        {
-         dump_type_prefix (TREE_TYPE (t), v);
+         dump_type_prefix (TREE_TYPE (t), v, 0);
          OB_PUTC (' ');
          dump_readonly_or_volatile (t, after);
        }
@@ -692,7 +704,7 @@ dump_decl (t, v)
       else
        OB_PUTS ("{anon}");
       if (v > 0)
-       dump_type_suffix (TREE_TYPE (t), v);
+       dump_type_suffix (TREE_TYPE (t), v, 0);
       break;
 
     case NAMESPACE_DECL:
@@ -922,7 +934,7 @@ dump_function_decl (t, v)
          && ! DECL_CONSTRUCTOR_P (t)
          && ! DESTRUCTOR_NAME_P (name))
        {
-         dump_type_prefix (TREE_TYPE (fntype), 1);
+         dump_type_prefix (TREE_TYPE (fntype), 1, 0);
          OB_PUTC (' ');
        }
     }
@@ -953,7 +965,7 @@ dump_function_decl (t, v)
   OB_PUTC (')');
 
   if (v && ! IDENTIFIER_TYPENAME_P (name))
-    dump_type_suffix (TREE_TYPE (fntype), 1);
+    dump_type_suffix (TREE_TYPE (fntype), 1, 0);
 
   if (TREE_CODE (fntype) == METHOD_TYPE)
     {
@@ -1653,22 +1665,34 @@ fndecl_as_string (fndecl, print_ret_type_p)
 
 /* Same, but handle a _TYPE.
    Called from convert_to_reference, mangle_class_name_for_template,
-   build_unary_op, and GNU_xref_decl.  */
+   build_unary_op, and GNU_xref_decl.  If CANONICAL_NAME is non-zero,
+   when describing a typedef, we use the name of the type described,
+   rather than the name of the typedef.  */
 
 char *
-type_as_string (typ, v)
+type_as_string_real (typ, v, canonical_name)
      tree typ;
      int v;
+     int canonical_name;
 {
   OB_INIT ();
 
-  dump_type (typ, v);
+  dump_type_real (typ, v, canonical_name);
 
   OB_FINISH ();
 
   return (char *)obstack_base (&scratch_obstack);
 }
 
+
+char *
+type_as_string (typ, v)
+     tree typ;
+     int v;
+{
+  return type_as_string_real (typ, v, 0);
+}
+
 char *
 expr_as_string (decl, v)
      tree decl;

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 7a8365c3856fdcfc6971e750f065304cfe8a2aba..8de724a9026015a9428cb7d85f0864e4c8bcd00a 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -2559,13 +2559,7 @@ mangle_class_name_for_template (name, parms, arglist, ctx)
       if (TREE_CODE (ctx) == FUNCTION_DECL)
        s = fndecl_as_string (ctx, 0);
       else if (TREE_CODE_CLASS (TREE_CODE (ctx)) == 't')
-       {
-         /* We can't use a typedef type name here.  */
-         ctx = build_type_variant (TYPE_MAIN_VARIANT (ctx),
-                                   TYPE_READONLY (ctx),
-                                   TYPE_VOLATILE (ctx));
-         s = type_as_string (ctx, 0);
-       }
+       s = type_as_string_real (ctx, 0, 1);
       else
        my_friendly_abort (0);
       cat (s);
@@ -2583,15 +2577,9 @@ mangle_class_name_for_template (name, parms, arglist, ctx)
       if (i)
        ccat (',');
 
-      /* We can't use a typedef type name here.  */
-      if (TREE_CODE_CLASS (TREE_CODE (arg)) == 't')
-       arg = build_type_variant (TYPE_MAIN_VARIANT (arg),
-                                 TYPE_READONLY (arg),
-                                 TYPE_VOLATILE (arg));
-
       if (TREE_CODE (parm) == TYPE_DECL)
        {
-         cat (type_as_string (arg, 0));
+         cat (type_as_string_real (arg, 0, 1));
          continue;
        }
       else if (TREE_CODE (parm) == TEMPLATE_DECL)
@@ -2602,7 +2590,7 @@ mangle_class_name_for_template (name, parms, arglist, ctx)
            cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
          else
            /* Output the parameter declaration */
-           cat (type_as_string (arg, 0));
+           cat (type_as_string_real (arg, 0, 1));
          continue;
        }
       else