2004-07-28 03:11:36 +00:00
|
|
|
|
/* Implementation of subroutines for the GNU C++ pretty-printer.
|
2007-05-19 01:19:51 +00:00
|
|
|
|
Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
|
2004-07-28 03:11:36 +00:00
|
|
|
|
Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
|
|
|
|
|
|
|
|
|
|
This file is part of GCC.
|
|
|
|
|
|
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
|
|
|
the terms of the GNU General Public License as published by the Free
|
|
|
|
|
Software Foundation; either version 2, or (at your option) any later
|
|
|
|
|
version.
|
|
|
|
|
|
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
|
for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
2007-05-19 01:19:51 +00:00
|
|
|
|
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
|
02110-1301, USA. */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
#include "system.h"
|
|
|
|
|
#include "coretypes.h"
|
|
|
|
|
#include "tm.h"
|
|
|
|
|
#include "real.h"
|
|
|
|
|
#include "cxx-pretty-print.h"
|
|
|
|
|
#include "cp-tree.h"
|
|
|
|
|
#include "toplev.h"
|
|
|
|
|
|
|
|
|
|
static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_qualified_id (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_assignment_expression (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_expression (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_type_id (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_direct_abstract_declarator (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_declarator (cxx_pretty_printer *, tree);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void pp_cxx_abstract_declarator (cxx_pretty_printer *, tree);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static void pp_cxx_statement (cxx_pretty_printer *, tree);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void pp_cxx_template_parameter (cxx_pretty_printer *, tree);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static void pp_cxx_cast_expression (cxx_pretty_printer *, tree);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c)
|
|
|
|
|
{
|
|
|
|
|
const char *p = pp_last_position_in_text (pp);
|
|
|
|
|
|
|
|
|
|
if (p != NULL && *p == c)
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_character (pp, c);
|
|
|
|
|
pp_base (pp)->padding = pp_none;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#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) \
|
|
|
|
|
pp_c_expression_list (pp_c_base (PP), T)
|
|
|
|
|
#define pp_cxx_space_for_pointer_operator(PP, T) \
|
|
|
|
|
pp_c_space_for_pointer_operator (pp_c_base (PP), T)
|
|
|
|
|
#define pp_cxx_init_declarator(PP, T) \
|
|
|
|
|
pp_c_init_declarator (pp_c_base (PP), T)
|
|
|
|
|
#define pp_cxx_call_argument_list(PP, T) \
|
|
|
|
|
pp_c_call_argument_list (pp_c_base (PP), T)
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_colon_colon (cxx_pretty_printer *pp)
|
|
|
|
|
{
|
|
|
|
|
pp_colon_colon (pp);
|
|
|
|
|
pp_base (pp)->padding = pp_none;
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
void
|
|
|
|
|
pp_cxx_begin_template_argument_list (cxx_pretty_printer *pp)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_nonconsecutive_character (pp, '<');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
pp_cxx_end_template_argument_list (cxx_pretty_printer *pp)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_nonconsecutive_character (pp, '>');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
pp_cxx_separate_with (cxx_pretty_printer *pp, int c)
|
|
|
|
|
{
|
|
|
|
|
pp_separate_with (pp, c);
|
|
|
|
|
pp_base (pp)->padding = pp_none;
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
|
|
|
|
/* Expressions. */
|
|
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
|
is_destructor_name (tree name)
|
|
|
|
|
{
|
|
|
|
|
return name == complete_dtor_identifier
|
|
|
|
|
|| name == base_dtor_identifier
|
|
|
|
|
|| name == deleting_dtor_identifier;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* conversion-function-id:
|
|
|
|
|
operator conversion-type-id
|
|
|
|
|
|
|
|
|
|
conversion-type-id:
|
|
|
|
|
type-specifier-seq conversion-declarator(opt)
|
|
|
|
|
|
|
|
|
|
conversion-declarator:
|
|
|
|
|
ptr-operator conversion-declarator(opt) */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_identifier (pp, "operator");
|
|
|
|
|
pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_cxx_begin_template_argument_list (pp);
|
|
|
|
|
pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1));
|
|
|
|
|
pp_cxx_end_template_argument_list (pp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* unqualified-id:
|
|
|
|
|
identifier
|
|
|
|
|
operator-function-id
|
|
|
|
|
conversion-function-id
|
|
|
|
|
~ class-name
|
|
|
|
|
template-id */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case RESULT_DECL:
|
|
|
|
|
pp_cxx_identifier (pp, "<return-value>");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OVERLOAD:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
t = OVL_CURRENT (t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case PARM_DECL:
|
|
|
|
|
case CONST_DECL:
|
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
case NAMESPACE_DECL:
|
|
|
|
|
case FIELD_DECL:
|
|
|
|
|
case LABEL_DECL:
|
|
|
|
|
case USING_DECL:
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
t = DECL_NAME (t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case IDENTIFIER_NODE:
|
|
|
|
|
if (t == NULL)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (pp, "<unnamed>");
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else if (IDENTIFIER_TYPENAME_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_conversion_function_id (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
if (is_destructor_name (t))
|
|
|
|
|
{
|
|
|
|
|
pp_complement (pp);
|
|
|
|
|
/* FIXME: Why is this necessary? */
|
|
|
|
|
if (TREE_TYPE (t))
|
|
|
|
|
t = constructor_name (TREE_TYPE (t));
|
|
|
|
|
}
|
|
|
|
|
pp_cxx_tree_identifier (pp, t);
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_ID_EXPR:
|
|
|
|
|
pp_cxx_template_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2005-06-03 03:28:44 +00:00
|
|
|
|
case BASELINK:
|
|
|
|
|
pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
case UNION_TYPE:
|
|
|
|
|
case ENUMERAL_TYPE:
|
|
|
|
|
pp_cxx_unqualified_id (pp, TYPE_NAME (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
|
|
|
|
if (TYPE_IDENTIFIER (t))
|
|
|
|
|
pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_canonical_template_parameter (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
|
|
|
|
pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
|
|
|
|
|
break;
|
|
|
|
|
|
2011-03-10 13:59:17 +00:00
|
|
|
|
case UNBOUND_CLASS_TEMPLATE:
|
|
|
|
|
pp_cxx_unqualified_id (pp, TYPE_NAME (t));
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* Pretty-print out the token sequence ":: template" in template codes
|
|
|
|
|
where it is needed to "inline declare" the (following) member as
|
|
|
|
|
a template. This situation arises when SCOPE of T is dependent
|
|
|
|
|
on template parameters. */
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
|
|
|
|
|
{
|
|
|
|
|
if (TREE_CODE (t) == TEMPLATE_ID_EXPR
|
|
|
|
|
&& TYPE_P (scope) && dependent_type_p (scope))
|
|
|
|
|
pp_cxx_identifier (pp, "template");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* nested-name-specifier:
|
|
|
|
|
class-or-namespace-name :: nested-name-specifier(opt)
|
|
|
|
|
class-or-namespace-name :: template nested-name-specifier */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
if (t != NULL && t != pp->enclosing_scope)
|
|
|
|
|
{
|
|
|
|
|
tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, scope);
|
|
|
|
|
pp_cxx_template_keyword_if_needed (pp, scope, t);
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
pp_cxx_colon_colon (pp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* qualified-id:
|
|
|
|
|
nested-name-specifier template(opt) unqualified-id */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* A pointer-to-member is always qualified. */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case PTRMEM_CST:
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
|
|
|
|
|
pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
|
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* In Standard C++, functions cannot possibly be used as
|
|
|
|
|
nested-name-specifiers. However, there are situations where
|
|
|
|
|
is "makes sense" to output the surrounding 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. */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case OVERLOAD:
|
|
|
|
|
t = OVL_CURRENT (t);
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
if (DECL_FUNCTION_MEMBER_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_unqualified_id
|
2007-05-19 01:19:51 +00:00
|
|
|
|
(pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
|
|
|
|
|
pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OFFSET_REF:
|
|
|
|
|
case SCOPE_REF:
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
|
|
|
|
|
if (scope != pp->enclosing_scope)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, scope);
|
|
|
|
|
pp_cxx_template_keyword_if_needed (pp, scope, t);
|
|
|
|
|
}
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_constant (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case STRING_CST:
|
|
|
|
|
{
|
|
|
|
|
const bool in_parens = PAREN_STRING_LITERAL_P (t);
|
|
|
|
|
if (in_parens)
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_c_constant (pp_c_base (pp), t);
|
|
|
|
|
if (in_parens)
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_c_constant (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* id-expression:
|
|
|
|
|
unqualified-id
|
|
|
|
|
qualified-id */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
if (TREE_CODE (t) == OVERLOAD)
|
|
|
|
|
t = OVL_CURRENT (t);
|
|
|
|
|
if (DECL_P (t) && DECL_CONTEXT (t))
|
|
|
|
|
pp_cxx_qualified_id (pp, t);
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* primary-expression:
|
|
|
|
|
literal
|
|
|
|
|
this
|
|
|
|
|
:: identifier
|
|
|
|
|
:: operator-function-id
|
|
|
|
|
:: qualifier-id
|
|
|
|
|
( expression )
|
|
|
|
|
id-expression */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case INTEGER_CST:
|
|
|
|
|
case REAL_CST:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case STRING_CST:
|
|
|
|
|
pp_cxx_constant (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BASELINK:
|
|
|
|
|
t = BASELINK_FUNCTIONS (t);
|
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case PARM_DECL:
|
|
|
|
|
case FIELD_DECL:
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
case OVERLOAD:
|
|
|
|
|
case CONST_DECL:
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
pp_cxx_id_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RESULT_DECL:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case STMT_EXPR:
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_statement (pp, STMT_EXPR_STMT (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
default:
|
|
|
|
|
pp_c_primary_expression (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* postfix-expression:
|
|
|
|
|
primary-expression
|
|
|
|
|
postfix-expression [ expression ]
|
|
|
|
|
postfix-expression ( expression-list(opt) )
|
|
|
|
|
simple-type-specifier ( expression-list(opt) )
|
|
|
|
|
typename ::(opt) nested-name-specifier identifier ( expression-list(opt) )
|
|
|
|
|
typename ::(opt) nested-name-specifier template(opt)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
template-id ( expression-list(opt) )
|
2004-07-28 03:11:36 +00:00
|
|
|
|
postfix-expression . template(opt) ::(opt) id-expression
|
|
|
|
|
postfix-expression -> template(opt) ::(opt) id-expression
|
|
|
|
|
postfix-expression . pseudo-destructor-name
|
|
|
|
|
postfix-expression -> pseudo-destructor-name
|
|
|
|
|
postfix-expression ++
|
|
|
|
|
postfix-expression --
|
|
|
|
|
dynamic_cast < type-id > ( expression )
|
|
|
|
|
static_cast < type-id > ( expression )
|
|
|
|
|
reinterpret_cast < type-id > ( expression )
|
|
|
|
|
const_cast < type-id > ( expression )
|
|
|
|
|
typeid ( expression )
|
|
|
|
|
typeif ( type-id ) */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case AGGR_INIT_EXPR:
|
|
|
|
|
case CALL_EXPR:
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tree fun = TREE_OPERAND (t, 0);
|
|
|
|
|
tree args = TREE_OPERAND (t, 1);
|
|
|
|
|
tree saved_scope = pp->enclosing_scope;
|
|
|
|
|
|
|
|
|
|
if (TREE_CODE (fun) == ADDR_EXPR)
|
|
|
|
|
fun = TREE_OPERAND (fun, 0);
|
|
|
|
|
|
|
|
|
|
/* In templates, where there is no way to tell whether a given
|
|
|
|
|
call uses an actual member function. So the parser builds
|
|
|
|
|
FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until
|
|
|
|
|
instantiation time. */
|
|
|
|
|
if (TREE_CODE (fun) != FUNCTION_DECL)
|
|
|
|
|
;
|
|
|
|
|
else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun))
|
|
|
|
|
{
|
|
|
|
|
tree object = code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t)
|
|
|
|
|
? TREE_OPERAND (t, 2)
|
|
|
|
|
: TREE_VALUE (args);
|
|
|
|
|
|
|
|
|
|
while (TREE_CODE (object) == NOP_EXPR)
|
|
|
|
|
object = TREE_OPERAND (object, 0);
|
|
|
|
|
|
|
|
|
|
if (TREE_CODE (object) == ADDR_EXPR)
|
|
|
|
|
object = TREE_OPERAND (object, 0);
|
|
|
|
|
|
|
|
|
|
if (TREE_CODE (TREE_TYPE (object)) != POINTER_TYPE)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_postfix_expression (pp, object);
|
|
|
|
|
pp_cxx_dot (pp);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_postfix_expression (pp, object);
|
|
|
|
|
pp_cxx_arrow (pp);
|
|
|
|
|
}
|
|
|
|
|
args = TREE_CHAIN (args);
|
|
|
|
|
pp->enclosing_scope = strip_pointer_operator (TREE_TYPE (object));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pp_cxx_postfix_expression (pp, fun);
|
|
|
|
|
pp->enclosing_scope = saved_scope;
|
|
|
|
|
pp_cxx_call_argument_list (pp, args);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
|
|
|
|
pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 2));
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BASELINK:
|
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case PARM_DECL:
|
|
|
|
|
case FIELD_DECL:
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
case OVERLOAD:
|
|
|
|
|
case CONST_DECL:
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
case RESULT_DECL:
|
|
|
|
|
pp_cxx_primary_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case DYNAMIC_CAST_EXPR:
|
|
|
|
|
case STATIC_CAST_EXPR:
|
|
|
|
|
case REINTERPRET_CAST_EXPR:
|
|
|
|
|
case CONST_CAST_EXPR:
|
|
|
|
|
if (code == DYNAMIC_CAST_EXPR)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (pp, "dynamic_cast");
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else if (code == STATIC_CAST_EXPR)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (pp, "static_cast");
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else if (code == REINTERPRET_CAST_EXPR)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (pp, "reinterpret_cast");
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (pp, "const_cast");
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_begin_template_argument_list (pp);
|
|
|
|
|
pp_cxx_type_id (pp, TREE_TYPE (t));
|
|
|
|
|
pp_cxx_end_template_argument_list (pp);
|
|
|
|
|
pp_left_paren (pp);
|
|
|
|
|
pp_cxx_expression (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_right_paren (pp);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EMPTY_CLASS_EXPR:
|
|
|
|
|
pp_cxx_type_id (pp, TREE_TYPE (t));
|
|
|
|
|
pp_left_paren (pp);
|
|
|
|
|
pp_right_paren (pp);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPEID_EXPR:
|
|
|
|
|
t = TREE_OPERAND (t, 0);
|
|
|
|
|
pp_cxx_identifier (pp, "typeid");
|
|
|
|
|
pp_left_paren (pp);
|
|
|
|
|
if (TYPE_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_type_id (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_expression (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_right_paren (pp);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PSEUDO_DTOR_EXPR:
|
|
|
|
|
pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_cxx_dot (pp);
|
|
|
|
|
pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1));
|
|
|
|
|
pp_cxx_colon_colon (pp);
|
|
|
|
|
pp_complement (pp);
|
|
|
|
|
pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2));
|
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case ARROW_EXPR:
|
|
|
|
|
pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_cxx_arrow (pp);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
default:
|
|
|
|
|
pp_c_postfix_expression (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* new-expression:
|
|
|
|
|
::(opt) new new-placement(opt) new-type-id new-initializer(opt)
|
|
|
|
|
::(opt) new new-placement(opt) ( type-id ) new-initializer(opt)
|
|
|
|
|
|
|
|
|
|
new-placement:
|
|
|
|
|
( expression-list )
|
|
|
|
|
|
|
|
|
|
new-type-id:
|
|
|
|
|
type-specifier-seq new-declarator(opt)
|
|
|
|
|
|
|
|
|
|
new-declarator:
|
|
|
|
|
ptr-operator new-declarator(opt)
|
|
|
|
|
direct-new-declarator
|
|
|
|
|
|
|
|
|
|
direct-new-declarator
|
|
|
|
|
[ expression ]
|
|
|
|
|
direct-new-declarator [ constant-expression ]
|
|
|
|
|
|
|
|
|
|
new-initializer:
|
|
|
|
|
( expression-list(opt) ) */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case NEW_EXPR:
|
|
|
|
|
case VEC_NEW_EXPR:
|
|
|
|
|
if (NEW_EXPR_USE_GLOBAL (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_identifier (pp, "new");
|
|
|
|
|
if (TREE_OPERAND (t, 0))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* FIXME: array-types are built with one more element. */
|
|
|
|
|
pp_cxx_type_id (pp, TREE_OPERAND (t, 1));
|
|
|
|
|
if (TREE_OPERAND (t, 2))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_left_paren (pp);
|
|
|
|
|
t = TREE_OPERAND (t, 2);
|
|
|
|
|
if (TREE_CODE (t) == TREE_LIST)
|
|
|
|
|
pp_c_expression_list (pp_c_base (pp), t);
|
|
|
|
|
else if (t == void_zero_node)
|
|
|
|
|
; /* OK, empty initializer list. */
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_expression (pp, t);
|
|
|
|
|
pp_right_paren (pp);
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* delete-expression:
|
|
|
|
|
::(opt) delete cast-expression
|
|
|
|
|
::(opt) delete [ ] cast-expression */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case DELETE_EXPR:
|
|
|
|
|
case VEC_DELETE_EXPR:
|
|
|
|
|
if (DELETE_EXPR_USE_GLOBAL (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_colon_colon (pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_identifier (pp, "delete");
|
|
|
|
|
if (code == VEC_DELETE_EXPR)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_left_bracket (pp);
|
|
|
|
|
pp_right_bracket (pp);
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 0));
|
2007-05-19 01:19:51 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* unary-expression:
|
|
|
|
|
postfix-expression
|
|
|
|
|
++ cast-expression
|
|
|
|
|
-- cast-expression
|
|
|
|
|
unary-operator cast-expression
|
|
|
|
|
sizeof unary-expression
|
|
|
|
|
sizeof ( type-id )
|
|
|
|
|
new-expression
|
|
|
|
|
delete-expression
|
|
|
|
|
|
|
|
|
|
unary-operator: one of
|
|
|
|
|
* & + - !
|
|
|
|
|
|
|
|
|
|
GNU extensions:
|
|
|
|
|
__alignof__ unary-expression
|
|
|
|
|
__alignof__ ( type-id ) */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case NEW_EXPR:
|
|
|
|
|
case VEC_NEW_EXPR:
|
|
|
|
|
pp_cxx_new_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case DELETE_EXPR:
|
|
|
|
|
case VEC_DELETE_EXPR:
|
|
|
|
|
pp_cxx_delete_expression (pp, t);
|
|
|
|
|
break;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
|
|
|
|
case SIZEOF_EXPR:
|
|
|
|
|
case ALIGNOF_EXPR:
|
|
|
|
|
pp_cxx_identifier (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
if (TYPE_P (TREE_OPERAND (t, 0)))
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pp_unary_expression (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNARY_PLUS_EXPR:
|
|
|
|
|
pp_plus (pp);
|
|
|
|
|
pp_cxx_cast_expression (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
default:
|
|
|
|
|
pp_c_unary_expression (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* cast-expression:
|
|
|
|
|
unary-expression
|
|
|
|
|
( type-id ) cast-expression */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case CAST_EXPR:
|
|
|
|
|
pp_cxx_type_id (pp, TREE_TYPE (t));
|
|
|
|
|
pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_c_cast_expression (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* pm-expression:
|
|
|
|
|
cast-expression
|
|
|
|
|
pm-expression .* cast-expression
|
|
|
|
|
pm-expression ->* cast-expression */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
/* Handle unfortunate OFFESET_REF overloading here. */
|
|
|
|
|
case OFFSET_REF:
|
|
|
|
|
if (TYPE_P (TREE_OPERAND (t, 0)))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_qualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* Else fall through. */
|
|
|
|
|
case MEMBER_REF:
|
|
|
|
|
case DOTSTAR_EXPR:
|
|
|
|
|
pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_cxx_dot (pp);
|
|
|
|
|
pp_star(pp);
|
|
|
|
|
pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_cxx_cast_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* multiplicative-expression:
|
|
|
|
|
pm-expression
|
|
|
|
|
multiplicative-expression * pm-expression
|
|
|
|
|
multiplicative-expression / pm-expression
|
|
|
|
|
multiplicative-expression % pm-expression */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
|
|
|
|
|
{
|
|
|
|
|
enum tree_code code = TREE_CODE (e);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case MULT_EXPR:
|
|
|
|
|
case TRUNC_DIV_EXPR:
|
|
|
|
|
case TRUNC_MOD_EXPR:
|
|
|
|
|
pp_cxx_multiplicative_expression (pp, TREE_OPERAND (e, 0));
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
if (code == MULT_EXPR)
|
|
|
|
|
pp_star (pp);
|
|
|
|
|
else if (code == TRUNC_DIV_EXPR)
|
|
|
|
|
pp_slash (pp);
|
|
|
|
|
else
|
|
|
|
|
pp_modulo (pp);
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_cxx_pm_expression (pp, e);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* conditional-expression:
|
|
|
|
|
logical-or-expression
|
|
|
|
|
logical-or-expression ? expression : assignment-expression */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
|
|
|
|
|
{
|
|
|
|
|
if (TREE_CODE (e) == COND_EXPR)
|
|
|
|
|
{
|
|
|
|
|
pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_question (pp);
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_expression (pp, TREE_OPERAND (e, 1));
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pp_c_logical_or_expression (pp_c_base (pp), e);
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* Pretty-print a compound assignment operator token as indicated by T. */
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
const char *op;
|
|
|
|
|
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case NOP_EXPR:
|
|
|
|
|
op = "=";
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PLUS_EXPR:
|
|
|
|
|
op = "+=";
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MINUS_EXPR:
|
|
|
|
|
op = "-=";
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TRUNC_DIV_EXPR:
|
|
|
|
|
op = "/=";
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TRUNC_MOD_EXPR:
|
|
|
|
|
op = "%=";
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
op = tree_code_name[TREE_CODE (t)];
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pp_cxx_identifier (pp, op);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* assignment-expression:
|
|
|
|
|
conditional-expression
|
|
|
|
|
logical-or-expression assignment-operator assignment-expression
|
|
|
|
|
throw-expression
|
|
|
|
|
|
|
|
|
|
throw-expression:
|
|
|
|
|
throw assignment-expression(opt)
|
|
|
|
|
|
|
|
|
|
assignment-operator: one of
|
|
|
|
|
= *= /= %= += -= >>= <<= &= ^= |= */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (e))
|
|
|
|
|
{
|
|
|
|
|
case MODIFY_EXPR:
|
|
|
|
|
case INIT_EXPR:
|
|
|
|
|
pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_equal (pp);
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case THROW_EXPR:
|
|
|
|
|
pp_cxx_identifier (pp, "throw");
|
|
|
|
|
if (TREE_OPERAND (e, 0))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MODOP_EXPR:
|
|
|
|
|
pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
|
|
|
|
|
pp_cxx_assignment_operator (pp, TREE_OPERAND (e, 1));
|
|
|
|
|
pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_cxx_conditional_expression (pp, e);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case STRING_CST:
|
|
|
|
|
case INTEGER_CST:
|
|
|
|
|
case REAL_CST:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_constant (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RESULT_DECL:
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
#if 0
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case OFFSET_REF:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
#endif
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case SCOPE_REF:
|
|
|
|
|
case PTRMEM_CST:
|
|
|
|
|
pp_cxx_qualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OVERLOAD:
|
|
|
|
|
t = OVL_CURRENT (t);
|
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case PARM_DECL:
|
|
|
|
|
case FIELD_DECL:
|
|
|
|
|
case CONST_DECL:
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
case BASELINK:
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
|
|
|
|
case STMT_EXPR:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_primary_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CALL_EXPR:
|
|
|
|
|
case DYNAMIC_CAST_EXPR:
|
|
|
|
|
case STATIC_CAST_EXPR:
|
|
|
|
|
case REINTERPRET_CAST_EXPR:
|
|
|
|
|
case CONST_CAST_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
#if 0
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case MEMBER_REF:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
#endif
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case EMPTY_CLASS_EXPR:
|
|
|
|
|
case TYPEID_EXPR:
|
|
|
|
|
case PSEUDO_DTOR_EXPR:
|
|
|
|
|
case AGGR_INIT_EXPR:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case ARROW_EXPR:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_postfix_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case NEW_EXPR:
|
|
|
|
|
case VEC_NEW_EXPR:
|
|
|
|
|
pp_cxx_new_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case DELETE_EXPR:
|
|
|
|
|
case VEC_DELETE_EXPR:
|
|
|
|
|
pp_cxx_delete_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case SIZEOF_EXPR:
|
|
|
|
|
case ALIGNOF_EXPR:
|
|
|
|
|
pp_cxx_unary_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case CAST_EXPR:
|
|
|
|
|
pp_cxx_cast_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OFFSET_REF:
|
|
|
|
|
case MEMBER_REF:
|
|
|
|
|
case DOTSTAR_EXPR:
|
|
|
|
|
pp_cxx_pm_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MULT_EXPR:
|
|
|
|
|
case TRUNC_DIV_EXPR:
|
|
|
|
|
case TRUNC_MOD_EXPR:
|
|
|
|
|
pp_cxx_multiplicative_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COND_EXPR:
|
|
|
|
|
pp_cxx_conditional_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MODIFY_EXPR:
|
|
|
|
|
case INIT_EXPR:
|
|
|
|
|
case THROW_EXPR:
|
|
|
|
|
case MODOP_EXPR:
|
|
|
|
|
pp_cxx_assignment_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case NON_DEPENDENT_EXPR:
|
|
|
|
|
case MUST_NOT_THROW_EXPR:
|
|
|
|
|
pp_cxx_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
default:
|
|
|
|
|
pp_c_expression (pp_c_base (pp), t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
break;
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Declarations. */
|
|
|
|
|
|
|
|
|
|
/* function-specifier:
|
|
|
|
|
inline
|
|
|
|
|
virtual
|
|
|
|
|
explicit */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
if (DECL_VIRTUAL_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (pp, "virtual");
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_identifier (pp, "explicit");
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_c_function_specifier (pp_c_base (pp), t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* decl-specifier-seq:
|
|
|
|
|
decl-specifier-seq(opt) decl-specifier
|
|
|
|
|
|
|
|
|
|
decl-specifier:
|
|
|
|
|
storage-class-specifier
|
|
|
|
|
type-specifier
|
|
|
|
|
function-specifier
|
|
|
|
|
friend
|
|
|
|
|
typedef */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case PARM_DECL:
|
|
|
|
|
case CONST_DECL:
|
|
|
|
|
case FIELD_DECL:
|
|
|
|
|
pp_cxx_storage_class_specifier (pp, t);
|
|
|
|
|
pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
|
|
|
|
|
break;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
pp_cxx_identifier (pp, "typedef");
|
|
|
|
|
pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
|
|
|
|
|
pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (pfm)));
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_cxx_ptr_operator (pp, t);
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
/* Constructors don't have return types. And conversion functions
|
2007-05-19 01:19:51 +00:00
|
|
|
|
do not have a type-specifier in their return types. */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_function_specifier (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (t)));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
default:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_c_declaration_specifiers (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* simple-type-specifier:
|
|
|
|
|
::(opt) nested-name-specifier(opt) type-name
|
|
|
|
|
::(opt) nested-name-specifier(opt) template(opt) template-id
|
|
|
|
|
char
|
|
|
|
|
wchar_t
|
|
|
|
|
bool
|
|
|
|
|
short
|
|
|
|
|
int
|
|
|
|
|
long
|
|
|
|
|
signed
|
|
|
|
|
unsigned
|
|
|
|
|
float
|
|
|
|
|
double
|
|
|
|
|
void */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
case UNION_TYPE:
|
|
|
|
|
case ENUMERAL_TYPE:
|
|
|
|
|
pp_cxx_qualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPENAME_TYPE:
|
|
|
|
|
pp_cxx_identifier (pp, "typename");
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
|
|
|
|
|
pp_cxx_unqualified_id (pp, TYPE_NAME (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_c_type_specifier (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* type-specifier-seq:
|
|
|
|
|
type-specifier type-specifier-seq(opt)
|
|
|
|
|
|
|
|
|
|
type-specifier:
|
|
|
|
|
simple-type-specifier
|
|
|
|
|
class-specifier
|
|
|
|
|
enum-specifier
|
|
|
|
|
elaborated-type-specifier
|
|
|
|
|
cv-qualifier */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_cv_qualifier_seq (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_simple_type_specifier (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case METHOD_TYPE:
|
|
|
|
|
pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
|
|
|
|
|
pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_c_specifier_qualifier_list (pp_c_base (pp), t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* ptr-operator:
|
|
|
|
|
* cv-qualifier-seq(opt)
|
|
|
|
|
&
|
|
|
|
|
::(opt) nested-name-specifier * cv-qualifier-seq(opt) */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
|
|
|
|
|
t = TREE_TYPE (t);
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case REFERENCE_TYPE:
|
|
|
|
|
case POINTER_TYPE:
|
|
|
|
|
if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|| TYPE_PTR_TO_MEMBER_P (TREE_TYPE (t)))
|
|
|
|
|
pp_cxx_ptr_operator (pp, TREE_TYPE (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (TREE_CODE (t) == POINTER_TYPE)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_star (pp);
|
|
|
|
|
pp_cxx_cv_qualifier_seq (pp, t);
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_ampersand (pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
|
|
|
|
|
pp_star (pp);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case OFFSET_TYPE:
|
|
|
|
|
if (TYPE_PTR_TO_MEMBER_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
|
|
|
|
|
pp_star (pp);
|
|
|
|
|
pp_cxx_cv_qualifier_seq (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* else fall through. */
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline tree
|
|
|
|
|
pp_cxx_implicit_parameter_type (tree mf)
|
|
|
|
|
{
|
|
|
|
|
return TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (mf))));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
parameter-declaration:
|
|
|
|
|
decl-specifier-seq declarator
|
|
|
|
|
decl-specifier-seq declarator = assignment-expression
|
|
|
|
|
decl-specifier-seq abstract-declarator(opt)
|
|
|
|
|
decl-specifier-seq abstract-declarator(opt) assignment-expression */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_decl_specifier_seq (pp, t);
|
|
|
|
|
if (TYPE_P (t))
|
|
|
|
|
pp_cxx_abstract_declarator (pp, t);
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_declarator (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* parameter-declaration-clause:
|
|
|
|
|
parameter-declaration-list(opt) ...(opt)
|
|
|
|
|
parameter-declaration-list , ...
|
|
|
|
|
|
|
|
|
|
parameter-declaration-list:
|
|
|
|
|
parameter-declaration
|
|
|
|
|
parameter-declaration-list , parameter-declaration */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tree types =
|
|
|
|
|
TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
const bool abstract = args == NULL
|
|
|
|
|
|| pp_c_base (pp)->flags & pp_c_flag_abstract;
|
|
|
|
|
bool first = true;
|
|
|
|
|
|
|
|
|
|
/* Skip artificial parameter for nonstatic member functions. */
|
|
|
|
|
if (TREE_CODE (t) == METHOD_TYPE)
|
|
|
|
|
types = TREE_CHAIN (types);
|
|
|
|
|
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types))
|
|
|
|
|
{
|
|
|
|
|
if (!first)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2004-07-28 03:11:36 +00:00
|
|
|
|
first = false;
|
|
|
|
|
pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args);
|
|
|
|
|
if (!abstract && pp_c_base (pp)->flags & pp_cxx_flag_default_argument)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_equal (pp);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_cxx_assignment_expression (pp, TREE_PURPOSE (types));
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* exception-specification:
|
|
|
|
|
throw ( type-id-list(opt) )
|
|
|
|
|
|
|
|
|
|
type-id-list
|
|
|
|
|
type-id
|
|
|
|
|
type-id-list , type-id */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
tree ex_spec = TYPE_RAISES_EXCEPTIONS (t);
|
|
|
|
|
|
|
|
|
|
if (!TYPE_NOTHROW_P (t) && ex_spec == NULL)
|
|
|
|
|
return;
|
|
|
|
|
pp_cxx_identifier (pp, "throw");
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_type_id (pp, TREE_VALUE (ex_spec));
|
|
|
|
|
if (TREE_CHAIN (ex_spec))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* direct-declarator:
|
|
|
|
|
declarator-id
|
|
|
|
|
direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
exception-specification(opt)
|
2004-07-28 03:11:36 +00:00
|
|
|
|
direct-declaration [ constant-expression(opt) ]
|
|
|
|
|
( declarator ) */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case PARM_DECL:
|
|
|
|
|
case CONST_DECL:
|
|
|
|
|
case FIELD_DECL:
|
|
|
|
|
if (DECL_NAME (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
|
|
|
|
|
pp_cxx_id_expression (pp, DECL_NAME (t));
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_abstract_declarator (pp, TREE_TYPE (t));
|
|
|
|
|
break;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
|
|
|
|
|
pp_cxx_id_expression (pp, t);
|
|
|
|
|
pp_cxx_parameter_declaration_clause (pp, t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_base (pp)->padding = pp_before;
|
|
|
|
|
pp_cxx_cv_qualifier_seq (pp, pp_cxx_implicit_parameter_type (t));
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
|
|
|
|
pp_cxx_exception_specification (pp, TREE_TYPE (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPENAME_TYPE:
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_c_direct_declarator (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* declarator:
|
|
|
|
|
direct-declarator
|
|
|
|
|
ptr-operator declarator */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_direct_declarator (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* ctor-initializer:
|
|
|
|
|
: mem-initializer-list
|
|
|
|
|
|
|
|
|
|
mem-initializer-list:
|
|
|
|
|
mem-initializer
|
|
|
|
|
mem-initializer , mem-initializer-list
|
|
|
|
|
|
|
|
|
|
mem-initializer:
|
|
|
|
|
mem-initializer-id ( expression-list(opt) )
|
|
|
|
|
|
|
|
|
|
mem-initializer-id:
|
|
|
|
|
::(opt) nested-name-specifier(opt) class-name
|
|
|
|
|
identifier */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
t = TREE_OPERAND (t, 0);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_colon (pp);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
for (; t; t = TREE_CHAIN (t))
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_primary_expression (pp, TREE_PURPOSE (t));
|
|
|
|
|
pp_cxx_call_argument_list (pp, TREE_VALUE (t));
|
|
|
|
|
if (TREE_CHAIN (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* function-definition:
|
|
|
|
|
decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
|
|
|
|
|
decl-specifier-seq(opt) declarator function-try-block */
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
tree saved_scope = pp->enclosing_scope;
|
|
|
|
|
pp_cxx_decl_specifier_seq (pp, t);
|
|
|
|
|
pp_cxx_declarator (pp, t);
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
pp->enclosing_scope = DECL_CONTEXT (t);
|
|
|
|
|
if (DECL_SAVED_TREE (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_statement (pp, DECL_SAVED_TREE (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
}
|
|
|
|
|
pp_flush (pp);
|
|
|
|
|
pp->enclosing_scope = saved_scope;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* abstract-declarator:
|
|
|
|
|
ptr-operator abstract-declarator(opt)
|
|
|
|
|
direct-abstract-declarator */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
if (TYPE_PTRMEM_P (t) || TYPE_PTRMEMFUNC_P (t))
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
else if (POINTER_TYPE_P (t))
|
|
|
|
|
{
|
|
|
|
|
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|| TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
|
|
|
|
|
pp_cxx_right_paren (pp);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
t = TREE_TYPE (t);
|
|
|
|
|
}
|
|
|
|
|
pp_cxx_direct_abstract_declarator (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* direct-abstract-declarator:
|
|
|
|
|
direct-abstract-declarator(opt) ( parameter-declaration-clause )
|
2007-05-19 01:19:51 +00:00
|
|
|
|
cv-qualifier-seq(opt) exception-specification(opt)
|
2004-07-28 03:11:36 +00:00
|
|
|
|
direct-abstract-declarator(opt) [ constant-expression(opt) ]
|
|
|
|
|
( abstract-declarator ) */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case REFERENCE_TYPE:
|
|
|
|
|
pp_cxx_abstract_declarator (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case METHOD_TYPE:
|
|
|
|
|
case FUNCTION_TYPE:
|
|
|
|
|
pp_cxx_parameter_declaration_clause (pp, t);
|
|
|
|
|
pp_cxx_direct_abstract_declarator (pp, TREE_TYPE (t));
|
|
|
|
|
if (TREE_CODE (t) == METHOD_TYPE)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
{
|
|
|
|
|
pp_base (pp)->padding = pp_before;
|
|
|
|
|
pp_cxx_cv_qualifier_seq
|
|
|
|
|
(pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
|
|
|
|
|
}
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_exception_specification (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPENAME_TYPE:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
|
|
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
|
|
|
|
case UNBOUND_CLASS_TEMPLATE:
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_c_direct_abstract_declarator (pp_c_base (pp), t);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
break;
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* type-id:
|
|
|
|
|
type-specifier-seq abstract-declarator(opt) */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_flags saved_flags = pp_c_base (pp)->flags;
|
|
|
|
|
pp_c_base (pp)->flags |= pp_c_flag_abstract;
|
|
|
|
|
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
case UNION_TYPE:
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
case ENUMERAL_TYPE:
|
|
|
|
|
case TYPENAME_TYPE:
|
|
|
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
|
|
|
|
case UNBOUND_CLASS_TEMPLATE:
|
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
case TYPEOF_TYPE:
|
|
|
|
|
case TEMPLATE_ID_EXPR:
|
|
|
|
|
pp_cxx_type_specifier_seq (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_c_type_id (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pp_c_base (pp)->flags = saved_flags;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* template-argument-list:
|
|
|
|
|
template-argument
|
|
|
|
|
template-argument-list, template-argument
|
|
|
|
|
|
|
|
|
|
template-argument:
|
|
|
|
|
assignment-expression
|
|
|
|
|
type-id
|
|
|
|
|
template-name */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
if (t == NULL)
|
|
|
|
|
return;
|
|
|
|
|
for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
|
|
|
|
|
{
|
|
|
|
|
tree arg = TREE_VEC_ELT (t, i);
|
|
|
|
|
if (i != 0)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
|
2007-05-19 01:19:51 +00:00
|
|
|
|
&& TYPE_P (DECL_TEMPLATE_RESULT (arg))))
|
|
|
|
|
pp_cxx_type_id (pp, arg);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_expression (pp, arg);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
t = DECL_EXPR_DECL (t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_type_specifier_seq (pp, t);
|
|
|
|
|
if (TYPE_P (t))
|
|
|
|
|
pp_cxx_abstract_declarator (pp, t);
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_declarator (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Statements. */
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_statement (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
case CTOR_INITIALIZER:
|
|
|
|
|
pp_cxx_ctor_initializer (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case USING_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "using");
|
|
|
|
|
pp_cxx_identifier (pp, "namespace");
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (DECL_CONTEXT (t))
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case USING_DECL:
|
|
|
|
|
pp_cxx_identifier (pp, "using");
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_nested_name_specifier (pp, USING_DECL_SCOPE (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_unqualified_id (pp, DECL_NAME (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EH_SPEC_BLOCK:
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* try-block:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
try compound-statement handler-seq */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case TRY_BLOCK:
|
|
|
|
|
pp_maybe_newline_and_indent (pp, 0);
|
|
|
|
|
pp_cxx_identifier (pp, "try");
|
|
|
|
|
pp_newline_and_indent (pp, 3);
|
|
|
|
|
pp_cxx_statement (pp, TRY_STMTS (t));
|
|
|
|
|
pp_newline_and_indent (pp, -3);
|
|
|
|
|
if (CLEANUP_P (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
;
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_statement (pp, TRY_HANDLERS (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/*
|
2007-05-19 01:19:51 +00:00
|
|
|
|
handler-seq:
|
|
|
|
|
handler handler-seq(opt)
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
handler:
|
|
|
|
|
catch ( exception-declaration ) compound-statement
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
exception-declaration:
|
|
|
|
|
type-specifier-seq declarator
|
|
|
|
|
type-specifier-seq abstract-declarator
|
|
|
|
|
... */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case HANDLER:
|
|
|
|
|
pp_cxx_identifier (pp, "catch");
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_exception_declaration (pp, HANDLER_PARMS (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_indentation (pp) += 3;
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
pp_cxx_statement (pp, HANDLER_BODY (t));
|
|
|
|
|
pp_indentation (pp) -= 3;
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
break;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* selection-statement:
|
|
|
|
|
if ( expression ) statement
|
|
|
|
|
if ( expression ) statement else statement */
|
|
|
|
|
case IF_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "if");
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_expression (pp, IF_COND (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_newline_and_indent (pp, 2);
|
|
|
|
|
pp_cxx_statement (pp, THEN_CLAUSE (t));
|
|
|
|
|
pp_newline_and_indent (pp, -2);
|
|
|
|
|
if (ELSE_CLAUSE (t))
|
|
|
|
|
{
|
|
|
|
|
tree else_clause = ELSE_CLAUSE (t);
|
|
|
|
|
pp_cxx_identifier (pp, "else");
|
|
|
|
|
if (TREE_CODE (else_clause) == IF_STMT)
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
else
|
|
|
|
|
pp_newline_and_indent (pp, 2);
|
|
|
|
|
pp_cxx_statement (pp, else_clause);
|
|
|
|
|
if (TREE_CODE (else_clause) != IF_STMT)
|
|
|
|
|
pp_newline_and_indent (pp, -2);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SWITCH_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "switch");
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_expression (pp, SWITCH_STMT_COND (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_indentation (pp) += 3;
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
pp_cxx_statement (pp, SWITCH_STMT_BODY (t));
|
|
|
|
|
pp_newline_and_indent (pp, -3);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* iteration-statement:
|
|
|
|
|
while ( expression ) statement
|
|
|
|
|
do statement while ( expression ) ;
|
|
|
|
|
for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
|
|
|
|
|
for ( declaration expression(opt) ; expression(opt) ) statement */
|
|
|
|
|
case WHILE_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "while");
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_expression (pp, WHILE_COND (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_newline_and_indent (pp, 3);
|
|
|
|
|
pp_cxx_statement (pp, WHILE_BODY (t));
|
|
|
|
|
pp_indentation (pp) -= 3;
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case DO_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "do");
|
|
|
|
|
pp_newline_and_indent (pp, 3);
|
|
|
|
|
pp_cxx_statement (pp, DO_BODY (t));
|
|
|
|
|
pp_newline_and_indent (pp, -3);
|
|
|
|
|
pp_cxx_identifier (pp, "while");
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_expression (pp, DO_COND (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case FOR_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "for");
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
if (FOR_INIT_STMT (t))
|
|
|
|
|
pp_cxx_statement (pp, FOR_INIT_STMT (t));
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
pp_needs_newline (pp) = false;
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
if (FOR_COND (t))
|
|
|
|
|
pp_cxx_expression (pp, FOR_COND (t));
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
pp_needs_newline (pp) = false;
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
if (FOR_EXPR (t))
|
|
|
|
|
pp_cxx_expression (pp, FOR_EXPR (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_newline_and_indent (pp, 3);
|
|
|
|
|
pp_cxx_statement (pp, FOR_BODY (t));
|
|
|
|
|
pp_indentation (pp) -= 3;
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* jump-statement:
|
|
|
|
|
goto identifier;
|
|
|
|
|
continue ;
|
|
|
|
|
return expression(opt) ; */
|
|
|
|
|
case BREAK_STMT:
|
|
|
|
|
case CONTINUE_STMT:
|
|
|
|
|
pp_identifier (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* expression-statement:
|
|
|
|
|
expression(opt) ; */
|
|
|
|
|
case EXPR_STMT:
|
|
|
|
|
pp_cxx_expression (pp, EXPR_STMT_EXPR (t));
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CLEANUP_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "try");
|
|
|
|
|
pp_newline_and_indent (pp, 2);
|
|
|
|
|
pp_cxx_statement (pp, CLEANUP_BODY (t));
|
|
|
|
|
pp_newline_and_indent (pp, -2);
|
|
|
|
|
pp_cxx_identifier (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
|
|
|
|
|
pp_newline_and_indent (pp, 2);
|
|
|
|
|
pp_cxx_statement (pp, CLEANUP_EXPR (t));
|
|
|
|
|
pp_newline_and_indent (pp, -2);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
default:
|
|
|
|
|
pp_c_statement (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* original-namespace-definition:
|
|
|
|
|
namespace identifier { namespace-body }
|
|
|
|
|
|
|
|
|
|
As an edge case, we also handle unnamed namespace definition here. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_identifier (pp, "namespace");
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (DECL_CONTEXT (t))
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
if (DECL_NAME (t))
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_cxx_left_brace (pp);
|
|
|
|
|
/* We do not print the namespace-body. */
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_cxx_right_brace (pp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* namespace-alias:
|
|
|
|
|
identifier
|
|
|
|
|
|
|
|
|
|
namespace-alias-definition:
|
|
|
|
|
namespace identifier = qualified-namespace-specifier ;
|
|
|
|
|
|
|
|
|
|
qualified-namespace-specifier:
|
|
|
|
|
::(opt) nested-name-specifier(opt) namespace-name */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_identifier (pp, "namespace");
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (DECL_CONTEXT (t))
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_equal (pp);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
|
|
|
|
|
pp_cxx_nested_name_specifier (pp,
|
|
|
|
|
DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* simple-declaration:
|
|
|
|
|
decl-specifier-seq(opt) init-declarator-list(opt) */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_decl_specifier_seq (pp, t);
|
|
|
|
|
pp_cxx_init_declarator (pp, t);
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
template-parameter-list:
|
|
|
|
|
template-parameter
|
|
|
|
|
template-parameter-list , template-parameter */
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
const int n = TREE_VEC_LENGTH (t);
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < n; ++i)
|
|
|
|
|
{
|
|
|
|
|
if (i)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* template-parameter:
|
|
|
|
|
type-parameter
|
|
|
|
|
parameter-declaration
|
|
|
|
|
|
|
|
|
|
type-parameter:
|
|
|
|
|
class identifier(opt)
|
|
|
|
|
class identifier(op) = type-id
|
|
|
|
|
typename identifier(opt)
|
|
|
|
|
typename identifier(opt) = type-id
|
|
|
|
|
template < template-parameter-list > class identifier(opt)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
template < template-parameter-list > class identifier(opt) = template-name */
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
tree parameter = TREE_VALUE (t);
|
|
|
|
|
switch (TREE_CODE (parameter))
|
|
|
|
|
{
|
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
pp_cxx_identifier (pp, "class");
|
|
|
|
|
if (DECL_NAME (parameter))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
|
2004-07-28 03:11:36 +00:00
|
|
|
|
/* FIXME: Chech if we should print also default argument. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PARM_DECL:
|
|
|
|
|
pp_cxx_parameter_declaration (pp, parameter);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Pretty-print a template parameter in the canonical form
|
|
|
|
|
"template-parameter-<level>-<position in parameter list>". */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
|
|
|
|
|
{
|
|
|
|
|
const enum tree_code code = TREE_CODE (parm);
|
|
|
|
|
|
|
|
|
|
/* Brings type template parameters to the canonical forms. */
|
|
|
|
|
if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
|
|
|
|
|
|| code == BOUND_TEMPLATE_TEMPLATE_PARM)
|
|
|
|
|
parm = TEMPLATE_TYPE_PARM_INDEX (parm);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp_cxx_begin_template_argument_list (pp);
|
|
|
|
|
pp_cxx_identifier (pp, "template-parameter-");
|
|
|
|
|
pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
|
|
|
|
|
pp_minus (pp);
|
|
|
|
|
pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
|
|
|
|
|
pp_cxx_end_template_argument_list (pp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
template-declaration:
|
|
|
|
|
export(opt) template < template-parameter-list > declaration */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
tree tmpl = most_general_template (t);
|
|
|
|
|
tree level;
|
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
|
|
pp_maybe_newline_and_indent (pp, 0);
|
|
|
|
|
for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_identifier (pp, "template");
|
|
|
|
|
pp_cxx_begin_template_argument_list (pp);
|
|
|
|
|
pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
|
|
|
|
|
pp_cxx_end_template_argument_list (pp);
|
|
|
|
|
pp_newline_and_indent (pp, 3);
|
|
|
|
|
i += 3;
|
|
|
|
|
}
|
|
|
|
|
if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
|
|
|
|
|
pp_cxx_function_definition (pp, t);
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_simple_declaration (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
declaration:
|
|
|
|
|
block-declaration
|
|
|
|
|
function-definition
|
|
|
|
|
template-declaration
|
|
|
|
|
explicit-instantiation
|
|
|
|
|
explicit-specialization
|
|
|
|
|
linkage-specification
|
|
|
|
|
namespace-definition
|
|
|
|
|
|
|
|
|
|
block-declaration:
|
|
|
|
|
simple-declaration
|
|
|
|
|
asm-definition
|
|
|
|
|
namespace-alias-definition
|
|
|
|
|
using-declaration
|
|
|
|
|
using-directive */
|
|
|
|
|
void
|
|
|
|
|
pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
if (!DECL_LANG_SPECIFIC (t))
|
|
|
|
|
pp_cxx_simple_declaration (pp, t);
|
|
|
|
|
else if (DECL_USE_TEMPLATE (t))
|
|
|
|
|
switch (DECL_USE_TEMPLATE (t))
|
|
|
|
|
{
|
|
|
|
|
case 1:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_template_declaration (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case 2:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_explicit_specialization (pp, t);
|
|
|
|
|
break;
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
|
|
|
|
case 3:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_explicit_instantiation (pp, t);
|
|
|
|
|
break;
|
2004-07-28 03:11:36 +00:00
|
|
|
|
|
|
|
|
|
default:
|
2007-05-19 01:19:51 +00:00
|
|
|
|
break;
|
2004-07-28 03:11:36 +00:00
|
|
|
|
}
|
|
|
|
|
else switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
pp_cxx_simple_declaration (pp, t);
|
|
|
|
|
break;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
if (DECL_SAVED_TREE (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_function_definition (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_simple_declaration (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case NAMESPACE_DECL:
|
|
|
|
|
if (DECL_NAMESPACE_ALIAS (t))
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_namespace_alias_definition (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
else
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp_cxx_original_namespace_definition (pp, t);
|
2004-07-28 03:11:36 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef c_pretty_print_fn pp_fun;
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
/* Initialization of a C++ pretty-printer object. */
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
void
|
|
|
|
|
pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
|
|
|
|
|
{
|
|
|
|
|
pp_c_pretty_printer_init (pp_c_base (pp));
|
|
|
|
|
pp_set_line_maximum_length (pp, 0);
|
|
|
|
|
|
|
|
|
|
pp->c_base.declaration = (pp_fun) pp_cxx_declaration;
|
|
|
|
|
pp->c_base.declaration_specifiers = (pp_fun) pp_cxx_decl_specifier_seq;
|
|
|
|
|
pp->c_base.function_specifier = (pp_fun) pp_cxx_function_specifier;
|
|
|
|
|
pp->c_base.type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
|
|
|
|
|
pp->c_base.declarator = (pp_fun) pp_cxx_declarator;
|
|
|
|
|
pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator;
|
|
|
|
|
pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
|
|
|
|
|
pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
|
|
|
|
|
pp->c_base.abstract_declarator = (pp_fun) pp_cxx_abstract_declarator;
|
|
|
|
|
pp->c_base.direct_abstract_declarator =
|
|
|
|
|
(pp_fun) pp_cxx_direct_abstract_declarator;
|
|
|
|
|
pp->c_base.simple_type_specifier = (pp_fun)pp_cxx_simple_type_specifier;
|
|
|
|
|
|
|
|
|
|
/* pp->c_base.statement = (pp_fun) pp_cxx_statement; */
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pp->c_base.constant = (pp_fun) pp_cxx_constant;
|
2004-07-28 03:11:36 +00:00
|
|
|
|
pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
|
|
|
|
|
pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression;
|
|
|
|
|
pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression;
|
|
|
|
|
pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression;
|
|
|
|
|
pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
|
|
|
|
|
pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
|
|
|
|
|
pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
|
|
|
|
|
pp->c_base.expression = (pp_fun) pp_cxx_expression;
|
|
|
|
|
pp->enclosing_scope = global_namespace;
|
|
|
|
|
}
|