+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.
+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
#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) \
conversion-declarator:
ptr-operator conversion-declarator(opt) */
+
static inline void
pp_cxx_conversion_function_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)
{
}
}
+/* 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)
{
/* 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)
{
/* 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:
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:
/* id-expression:
unqualified-id
qualified-id */
+
static inline void
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)
{
new-initializer:
( expression-list(opt) ) */
+
static void
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)
{
GNU extensions:
__alignof__ unary-expression
__alignof__ ( type-id ) */
+
static void
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)
{
cast-expression
pm-expression .* cast-expression
pm-expression ->* cast-expression */
+
static void
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)
{
/* conditional-expression:
logical-or-expression
logical-or-expression ? expression : assignment-expression */
+
static void
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)
{
assignment-operator: one of
= *= /= %= += -= >>= <<= &= ^= |= */
+
static void
pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
{
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;
inline
virtual
explicit */
+
static void
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)
{
float
double
void */
+
static void
pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
{
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)
{
parameter-declaration-list:
parameter-declaration
parameter-declaration-list , parameter-declaration */
+
static void
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)
{
exception-specification(opt)
direct-declaration [ constant-expression(opt) ]
( declarator ) */
+
static void
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)
{
mem-initializer-id:
::(opt) nested-name-specifier(opt) class-name
identifier */
+
static void
pp_cxx_ctor_initializer (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)
{
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)
{
/* type-id:
type-specifier-seq abstract-declarator(opt) */
+
static void
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)
{
/* simple-declaration:
decl-specifier-seq(opt) init-declarator-list(opt) */
+
static void
pp_cxx_simple_declaration (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)
{
/*
template-declaration:
export(opt) template < template-parameter-list > declaration */
+
static void
pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
{
\f
typedef c_pretty_print_fn pp_fun;
+/* Initialization of a C++ pretty-printer object. */
+
void
pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
{
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);
#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) \
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);
}
}
-/* 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
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
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;
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)
{
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))
{
{
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:
case VECTOR_TYPE:
case TYPEOF_TYPE:
dump_type (t, flags);
- padding = before;
+ pp_base (cxx_pp)->padding = pp_before;
break;
default:
pp_identifier (cxx_pp, "<typeprefixerror>");
break;
}
- return padding;
}
/* Dump the suffix of type T, under control of FLAGS. This is the part
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;
{
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);
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);
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);
}
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;
+ }
+}
} 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); \
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 */
+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
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" "" }
projects / platform / upstream / linaro-gcc.git / commitdiff