mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-10 01:20:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
Gabriel Dos Reis 2004-03-21 23:55:03 +00:00 committed by Gabriel Dos Reis
parent 1c7b1b7e25
commit b9b44fb9f8
9 changed files with 126 additions and 73 deletions

6
gcc/ChangeLog

@ -1,3 +1,9 @@
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.

18
gcc/cp/ChangeLog

@ -1,3 +1,21 @@
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

56
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)
{

3
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);

96
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 *[]&.
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. */
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);
}

10
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;
}
}

2
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 */

4
gcc/testsuite/ChangeLog

@ -1,3 +1,7 @@
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

4
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" "" }