pretty-print.c (pp_base_maybe_space): New function.

	* pretty-print.c (pp_base_maybe_space): New function.
	* pretty-print.h (pp_base_maybe_space): Declare.
	(pp_maybe_space): New macro.
cp/
	* error.c (enum pad): Remove.
	(dump_qualifiers): Likewise.
	(dump_type): Replace dump_qualifiers with
	* pp_cxx_cv_qualifier_seq.
	(dump_aggr_type): Likewise.
	(dump_type_suffix): Likewise.
	(dump_simple_decl): Likewise.
	(dump_function_decl): Likewise.
	(cv_to_string): Likewise.
	(dump_type_prefix): Likewise.  Adjust return void.
	* cxx-pretty-print.c (pp_cxx_cv_qualifier_seq): Move to
	cxx_pretty_print.h.
	(pp_cxx_template_keyword_if_needed): Document.
	(pp_cxx_qualified_id): Document case FUNCTION_DECL.  Tidy.
	(pp_cxx_expression): Handle NON_DEPENDENT_EXPR and
	MUST_NOT_THROW_EXPR.
testsuite/
	* g++.dg/template/qualttp20.C: Adjust dg- regexp.

From-SVN: r79796

gcc/ChangeLog

+2004-03-21  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+	* pretty-print.c (pp_base_maybe_space): New function.
+	* pretty-print.h (pp_base_maybe_space): Declare.
+	(pp_maybe_space): New macro.
+
 2004-03-21  Ulrich Weigand  <uweigand@de.ibm.com>
 
 	* config/s390/s390.md ("addti3", "subti3"): New insns and splitters.

gcc/cp/ChangeLog

+2004-03-21  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+	* error.c (enum pad): Remove.
+	(dump_qualifiers): Likewise.
+	(dump_type): Replace dump_qualifiers with pp_cxx_cv_qualifier_seq.
+	(dump_aggr_type): Likewise.
+	(dump_type_suffix): Likewise.
+	(dump_simple_decl): Likewise.
+	(dump_function_decl): Likewise.
+	(cv_to_string): Likewise.
+	(dump_type_prefix): Likewise.  Adjust return void.  
+	* cxx-pretty-print.c (pp_cxx_cv_qualifier_seq): Move to
+	cxx_pretty_print.h.
+	(pp_cxx_template_keyword_if_needed): Document.
+	(pp_cxx_qualified_id): Document case FUNCTION_DECL.  Tidy.
+	(pp_cxx_expression): Handle NON_DEPENDENT_EXPR and
+	MUST_NOT_THROW_EXPR.  
+
 2004-03-21  Mark Mitchell  <mark@codesourcery.com>
 
 	PR c++/14616

gcc/cp/cxx-pretty-print.c

@@ -70,8 +70,6 @@ pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c)
 #define pp_cxx_identifier(PP, ID) pp_c_identifier (pp_c_base (PP), ID)
 #define pp_cxx_tree_identifier(PP, T) pp_c_tree_identifier (pp_c_base (PP), T)
 
-#define pp_cxx_cv_qualifier_seq(PP, T)   \
-   pp_c_type_qualifier_list (pp_c_base (PP), T)
 #define pp_cxx_storage_class_specifier(PP, T) \
    pp_c_storage_class_specifier (pp_c_base (PP), T)
 #define pp_cxx_expression_list(PP, T)    \
@@ -109,6 +107,7 @@ is_destructor_name (tree name)
 
    conversion-declarator:
       ptr-operator conversion-declarator(opt)  */
+
 static inline void
 pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
 {
@@ -131,6 +130,7 @@ pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
      conversion-function-id
      ~ class-name
      template-id  */
+
 static void
 pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
 {
@@ -195,6 +195,11 @@ pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
     }
 }
 
+/* Pretty-print out the token sequence ":: template" in template codes
+   where it is needed to "inline declare" the (following) member as
+   a template.  This situtation arises when SCOPE of T is dependent
+   on template parameters.  */
+
 static inline void
 pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
 {
@@ -206,6 +211,7 @@ pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
 /* nested-name-specifier:
       class-or-namespace-name :: nested-name-specifier(opt)
       class-or-namespace-name :: template nested-name-specifier   */
+
 static void
 pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
 {
@@ -221,16 +227,26 @@ pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
 
 /* qualified-id:
       nested-name-specifier template(opt) unqualified-id  */
+
 static void
 pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
 {
   switch (TREE_CODE (t))
     {
+      /* A pointer-to-member is always qualified.  */
     case PTRMEM_CST:
       pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
       pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
       break;
 
+      /* In Standard C++, functions cannot possibly be used as
+         nested-name-specifiers.  However, there are situations where
+         is "makes sense" to output the surrouding function name for the
+         purpose of emphasizing on the scope kind.  Just printing the
+         function name might not be sufficient as it may be overloaded; so,
+         we decorate the function with its signature too.
+         FIXME:  This is probably the wrong pretty-printing for conversion
+         functions and some function templates.  */
     case OVERLOAD:
       t = OVL_CURRENT (t);
     case FUNCTION_DECL:
@@ -238,6 +254,7 @@ pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
         pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
       pp_cxx_unqualified_id
         (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
+      pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
       break;
 
     case OFFSET_REF:
@@ -263,6 +280,7 @@ pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
 /* id-expression:
       unqualified-id
       qualified-id   */
+
 static inline void
 pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
 {
@@ -282,6 +300,7 @@ pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
      :: qualifier-id
      ( expression )
      id-expression   */
+
 static void
 pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
 {
@@ -482,6 +501,7 @@ pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
 
    new-initializer:
       ( expression-list(opt) )  */
+
 static void
 pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
 {
@@ -522,6 +542,7 @@ pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
 /* delete-expression:
       ::(opt) delete cast-expression
       ::(opt) delete [ ] cast-expression   */
+
 static void
 pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
 {
@@ -562,6 +583,7 @@ pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
    GNU extensions:
       __alignof__ unary-expression
       __alignof__ ( type-id )  */
+
 static void
 pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
 {
@@ -587,6 +609,7 @@ pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
 /* cast-expression:
       unary-expression
       ( type-id ) cast-expression  */
+
 static void
 pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
 {
@@ -607,6 +630,7 @@ pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
       cast-expression
       pm-expression .* cast-expression
       pm-expression ->* cast-expression  */
+
 static void
 pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
 {
@@ -640,6 +664,7 @@ pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
       multiplicative-expression * pm-expression
       multiplicative-expression / pm-expression
       multiplicative-expression % pm-expression  */
+
 static void
 pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
 {
@@ -670,6 +695,7 @@ pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
 /* conditional-expression:
       logical-or-expression
       logical-or-expression ?  expression  : assignment-expression  */
+
 static void
 pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
 {
@@ -687,6 +713,8 @@ pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
     pp_c_logical_or_expression (pp_c_base (pp), e);
 }
 
+/* Pretty-print a compound assignment operator token as indicated by T.  */
+
 static void
 pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
 {
@@ -733,6 +761,7 @@ pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
 
    assignment-operator: one of
       =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
+
 static void
 pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
 {
@@ -854,6 +883,11 @@ pp_cxx_expression (cxx_pretty_printer *pp, tree t)
       pp_cxx_assignment_expression (pp, t);
       break;
 
+    case NON_DEPENDENT_EXPR:
+    case MUST_NOT_THROW_EXPR:
+      pp_cxx_expression (pp, t);
+      break;
+
     default:
       pp_c_expression (pp_c_base (pp), t);
       break;      
@@ -867,6 +901,7 @@ pp_cxx_expression (cxx_pretty_printer *pp, tree t)
       inline
       virtual
       explicit   */
+
 static void
 pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
 {
@@ -894,6 +929,7 @@ pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
       function-specifier
       friend
       typedef  */
+
 static void
 pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
 {
@@ -950,6 +986,7 @@ pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
       float
       double
       void  */
+
 static void
 pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
 {
@@ -1075,6 +1112,7 @@ pp_cxx_implicit_parameter_type (tree mf)
       decl-specifier-seq declarator = assignment-expression
       decl-specifier-seq abstract-declarator(opt)
       decl-specifier-seq abstract-declarator(opt) assignment-expression  */
+
 static inline void
 pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
 {
@@ -1092,6 +1130,7 @@ pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
    parameter-declaration-list:
       parameter-declaration
       parameter-declaration-list , parameter-declaration  */
+
 static void
 pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
 {
@@ -1129,6 +1168,7 @@ pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
    type-id-list
       type-id
       type-id-list , type-id   */
+
 static void
 pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
 {
@@ -1153,6 +1193,7 @@ pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
                                             exception-specification(opt)
       direct-declaration [ constant-expression(opt) ]
       ( declarator )  */
+
 static void
 pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
 {
@@ -1199,6 +1240,7 @@ pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
 /* declarator:
    direct-declarator
    ptr-operator declarator  */
+
 static void
 pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
 {
@@ -1218,6 +1260,7 @@ pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
    mem-initializer-id:
       ::(opt) nested-name-specifier(opt) class-name
       identifier   */
+
 static void
 pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
 {
@@ -1270,6 +1313,7 @@ pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
 /* abstract-declarator:
       ptr-operator abstract-declarator(opt)
       direct-abstract-declarator  */
+
 static void
 pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
 {
@@ -1290,6 +1334,7 @@ pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
                            cv-qualifier-seq(opt) exception-specification(opt)
       direct-abstract-declarator(opt) [ constant-expression(opt) ]
       ( abstract-declarator )  */
+
 static void
 pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
 {
@@ -1332,6 +1377,7 @@ pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
 
 /* type-id:
      type-specifier-seq abstract-declarator(opt) */
+
 static void
 pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
 {
@@ -1374,6 +1420,7 @@ pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
       assignment-expression
       type-id
       template-name   */
+
 static void
 pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
 {
@@ -1511,6 +1558,7 @@ pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
 
 /* simple-declaration:
       decl-specifier-seq(opt) init-declarator-list(opt)  */
+
 static void
 pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
 {
@@ -1550,6 +1598,7 @@ pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
      template < template-parameter-list > class identifier(opt)
      template < template-parameter-list > class identifier(opt) = template-name
 */
+
 static void
 pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
 {
@@ -1600,6 +1649,7 @@ pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
 /*
   template-declaration:
      export(opt) template < template-parameter-list > declaration   */
+
 static void
 pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
 {
@@ -1704,6 +1754,8 @@ pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
 
 typedef c_pretty_print_fn pp_fun;
 
+/* Initialization of a C++ pretty-printer object.  */
+
 void
 pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
 {

gcc/cp/cxx-pretty-print.h

@@ -41,6 +41,9 @@ typedef struct
   tree enclosing_scope;
 } cxx_pretty_printer;
 
+#define pp_cxx_cv_qualifier_seq(PP, T)   \
+   pp_c_type_qualifier_list (pp_c_base (PP), T)
+
 void pp_cxx_pretty_printer_init (cxx_pretty_printer *);
 
 void pp_cxx_declaration (cxx_pretty_printer *, tree);

gcc/cp/error.c

@@ -32,8 +32,6 @@ Boston, MA 02111-1307, USA.  */
 #include "langhooks-def.h"
 #include "cxx-pretty-print.h"
 
-enum pad { none, before, after };
-
 #define pp_template_argument_list_start(PP) \
    pp_non_consecutive_character (PP, '<')
 #define pp_template_argument_list_end(PP)  \
@@ -72,12 +70,11 @@ static void dump_expr (tree, int);
 static void dump_unary_op (const char *, tree, int);
 static void dump_binary_op (const char *, tree, int);
 static void dump_aggr_type (tree, int);
-static enum pad dump_type_prefix (tree, int);
+static void dump_type_prefix (tree, int);
 static void dump_type_suffix (tree, int);
 static void dump_function_name (tree, int);
 static void dump_expr_list (tree, int);
 static void dump_global_iord (tree);
-static enum pad dump_qualifiers (tree, enum pad);
 static void dump_parameters (tree, int);
 static void dump_exception_spec (tree, int);
 static const char *class_key_or_enum (tree);
@@ -143,38 +140,6 @@ dump_scope (tree scope, int flags)
     }
 }
 
-/* Dump type qualifiers, providing padding as requested. Return an
-   indication of whether we dumped something.  */
-
-static enum pad
-dump_qualifiers (tree t, enum pad p)
-{
-  static const int masks[] =
-    {TYPE_QUAL_CONST, TYPE_QUAL_VOLATILE, TYPE_QUAL_RESTRICT};
-  static const char *const names[] =
-    {"const", "volatile", "__restrict"};
-  int ix;
-  int quals = TYPE_QUALS (t);
-  int do_after = p == after;
-
-  if (quals)
-    {
-      for (ix = 0; ix != 3; ix++)
-        if (masks[ix] & quals)
-          {
-            if (p == before)
-              pp_space (cxx_pp);
-            p = before;
-            pp_identifier (cxx_pp, names[ix]);
-          }
-      if (do_after)
-        pp_space (cxx_pp);
-    }
-  else
-    p = none;
-  return p;
-}
-
 /* Dump the template ARGument under control of FLAGS.  */
 
 static void
@@ -367,7 +332,7 @@ dump_type (tree t, int flags)
       break;
 
     case TEMPLATE_TYPE_PARM:
-      dump_qualifiers (t, after);
+      pp_cxx_cv_qualifier_seq (cxx_pp, t);
       if (TYPE_IDENTIFIER (t))
 	pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
       else
@@ -390,7 +355,7 @@ dump_type (tree t, int flags)
       break;
     }
     case TYPENAME_TYPE:
-      dump_qualifiers (t, after);
+      pp_cxx_cv_qualifier_seq (cxx_pp, t);
       pp_string (cxx_pp, "typename ");
       dump_typename (t, flags);
       break;
@@ -460,7 +425,7 @@ dump_aggr_type (tree t, int flags)
   int typdef = 0;
   int tmplate = 0;
 
-  dump_qualifiers (t, after);
+  pp_cxx_cv_qualifier_seq (cxx_pp, t);
 
   if (flags & TFF_CLASS_KEY_OR_ENUM)
     {
@@ -520,15 +485,12 @@ dump_aggr_type (tree t, int flags)
    deal with prefix and suffix.
 
    Arrays must also do this for DECL nodes, like int a[], and for things like
-   int *[]&.
-
-   Return indicates how you should pad an object name after this. I.e. you
-   want to pad non-*, non-& cores, but not pad * or & types.  */
+   int *[]&.  */
 
-static enum pad
+static void 
 dump_type_prefix (tree t, int flags)
 {
-  enum pad padding = before;
+  pp_base (cxx_pp)->padding = pp_none;
 
   if (TYPE_PTRMEMFUNC_P (t))
     {
@@ -543,53 +505,49 @@ dump_type_prefix (tree t, int flags)
       {
 	tree sub = TREE_TYPE (t);
 
-	padding = dump_type_prefix (sub, flags);
+	dump_type_prefix (sub, flags);
 	if (TREE_CODE (sub) == ARRAY_TYPE)
 	  {
 	    pp_space (cxx_pp);
 	    pp_left_paren (cxx_pp);
 	  }
 	pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
-	padding = dump_qualifiers (t, before);
+        pp_base (cxx_pp)->padding = pp_before;
+        pp_cxx_cv_qualifier_seq (cxx_pp, t);
       }
       break;
 
     case OFFSET_TYPE:
     offset_type:
-      padding = dump_type_prefix (TREE_TYPE (t), flags);
+      dump_type_prefix (TREE_TYPE (t), flags);
       if (TREE_CODE (t) == OFFSET_TYPE)	/* pmfs deal with this in d_t_p */
 	{
-	  if (padding != none)
-	    pp_space (cxx_pp);
+          pp_maybe_space (cxx_pp);
 	  dump_type (TYPE_OFFSET_BASETYPE (t), flags);
 	  pp_colon_colon (cxx_pp);
 	}
       pp_star (cxx_pp);
-      padding = dump_qualifiers (t, none);
+      pp_cxx_cv_qualifier_seq (cxx_pp, t);
       break;
 
       /* Can only be reached through function pointer -- this would not be
          correct if FUNCTION_DECLs used it.  */
     case FUNCTION_TYPE:
-      padding = dump_type_prefix (TREE_TYPE (t), flags);
-      if (padding != none)
-        pp_space (cxx_pp);
+      dump_type_prefix (TREE_TYPE (t), flags);
+      pp_maybe_space (cxx_pp);
       pp_left_paren (cxx_pp);
-      padding = none;
       break;
 
     case METHOD_TYPE:
-      padding = dump_type_prefix (TREE_TYPE (t), flags);
-      if (padding != none)
-        pp_space (cxx_pp);
+      dump_type_prefix (TREE_TYPE (t), flags);
+      pp_maybe_space (cxx_pp);
       pp_left_paren (cxx_pp);
-      padding = none;
       dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
       pp_colon_colon (cxx_pp);
       break;
 
     case ARRAY_TYPE:
-      padding = dump_type_prefix (TREE_TYPE (t), flags);
+      dump_type_prefix (TREE_TYPE (t), flags);
       break;
 
     case ENUMERAL_TYPE:
@@ -612,7 +570,7 @@ dump_type_prefix (tree t, int flags)
     case VECTOR_TYPE:
     case TYPEOF_TYPE:
       dump_type (t, flags);
-      padding = before;
+      pp_base (cxx_pp)->padding = pp_before;
       break;
 
     default:
@@ -622,7 +580,6 @@ dump_type_prefix (tree t, int flags)
       pp_identifier (cxx_pp, "<typeprefixerror>");
       break;
     }
-  return padding;
 }
 
 /* Dump the suffix of type T, under control of FLAGS.  This is the part
@@ -659,8 +616,8 @@ dump_type_suffix (tree t, int flags)
 	dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
 
 	if (TREE_CODE (t) == METHOD_TYPE)
-	  dump_qualifiers
-	    (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
+          pp_cxx_cv_qualifier_seq
+            (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
 	dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
 	dump_type_suffix (TREE_TYPE (t), flags);
 	break;
@@ -736,8 +693,8 @@ dump_simple_decl (tree t, tree type, int flags)
 {
   if (flags & TFF_DECL_SPECIFIERS)
     {
-      if (dump_type_prefix (type, flags) != none)
-        pp_space (cxx_pp);
+      dump_type_prefix (type, flags);
+      pp_maybe_space (cxx_pp);
     }
   if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
     dump_scope (CP_DECL_CONTEXT (t), flags);
@@ -1095,8 +1052,8 @@ dump_function_decl (tree t, int flags)
       dump_parameters (parmtypes, flags);
 
       if (TREE_CODE (fntype) == METHOD_TYPE)
-	dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
-			 before);
+        pp_cxx_cv_qualifier_seq
+          (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
 
       if (flags & TFF_EXCEPTION_SPECIFICATION)
 	dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
@@ -2116,7 +2073,8 @@ static const char *
 cv_to_string (tree p, int v)
 {
   pp_clear_output_area (cxx_pp);
-  dump_qualifiers (p, v ? before : none);
+  pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
+  pp_cxx_cv_qualifier_seq (cxx_pp, p);
   return pp_formatted_text (cxx_pp);
 }
 

gcc/pretty-print.c

@@ -545,4 +545,14 @@ pp_base_string (pretty_printer *pp, const char *str)
   pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
 }
 
+/* Maybe print out a whitespace if needed.   */
 
+void
+pp_base_maybe_space (pretty_printer *pp)
+{
+  if (pp_base (pp)->padding != pp_none)
+    {
+      pp_space (pp);
+      pp_base (pp)->padding = pp_none;
+    }
+}

gcc/pretty-print.h

@@ -205,6 +205,7 @@ struct pretty_print_info
   } while (0)
 #define pp_maybe_newline_and_indent(PP, N) \
   if (pp_needs_newline (PP)) pp_newline_and_indent (PP, N)
+#define pp_maybe_space(PP)   pp_base_maybe_space (pp_base (PP))
 #define pp_separate_with(PP, C)     \
    do {                             \
      pp_character (PP, C);          \
@@ -257,5 +258,6 @@ extern void pp_base_indent (pretty_printer *);
 extern void pp_base_newline (pretty_printer *);
 extern void pp_base_character (pretty_printer *, int);
 extern void pp_base_string (pretty_printer *, const char *);
+extern void pp_base_maybe_space (pretty_printer *);
 
 #endif /* GCC_PRETTY_PRINT_H */

gcc/testsuite/ChangeLog

+2004-03-21  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+	* g++.dg/template/qualttp20.C: Adjust dg- regexp.
+
 2004-03-21  Mark Mitchell  <mark@codesourcery.com>
 
 	PR c++/14616

gcc/testsuite/g++.dg/template/qualttp20.C

@@ -15,8 +15,8 @@ struct AS
 
 template <typename T> struct B1 : T
 {
-  typedef typename T::L __restrict__ r;// { dg-error "`__restrict' qualifiers cannot" "" }
-  typedef typename T::myT __restrict__ p;// { dg-warning "ignoring `__restrict'" "" { xfail *-*-* } }
+  typedef typename T::L __restrict__ r;// { dg-error "`__restrict__' qualifiers cannot" "" }
+  typedef typename T::myT __restrict__ p;// { dg-warning "ignoring `__restrict__'" "" { xfail *-*-* } }
 
   // The following are DR 295 dependent
   typedef typename T::myT volatile *myvolatile; // { dg-error "qualifiers" ""  }