2003-08-05 21:23:14 +02:00
|
|
|
|
/* Implementation of subroutines for the GNU C++ pretty-printer.
|
2005-02-08 15:46:52 +01:00
|
|
|
|
Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
|
2003-08-05 21:23:14 +02: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
|
|
|
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
|
|
|
02111-1307, USA. */
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
#include "system.h"
|
|
|
|
|
#include "coretypes.h"
|
|
|
|
|
#include "tm.h"
|
|
|
|
|
#include "real.h"
|
|
|
|
|
#include "cxx-pretty-print.h"
|
|
|
|
|
#include "cp-tree.h"
|
2003-08-25 21:10:50 +02:00
|
|
|
|
#include "toplev.h"
|
2003-08-10 20:17:06 +02:00
|
|
|
|
|
|
|
|
|
static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
static void pp_cxx_qualified_id (cxx_pretty_printer *, tree);
|
|
|
|
|
static void pp_cxx_assignment_expression (cxx_pretty_printer *, tree);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
static void pp_cxx_expression (cxx_pretty_printer *, tree);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
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);
|
2004-03-22 02:12:53 +01:00
|
|
|
|
static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
static void pp_cxx_abstract_declarator (cxx_pretty_printer *, tree);
|
2005-01-25 09:58:46 +01:00
|
|
|
|
static void pp_cxx_statement (cxx_pretty_printer *, tree);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
static void pp_cxx_template_parameter (cxx_pretty_printer *, tree);
|
2003-08-05 21:23:14 +02:00
|
|
|
|
|
2003-08-10 20:17:06 +02: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)
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_whitespace (pp);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_character (pp, c);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_base (pp)->padding = pp_none;
|
2003-08-10 20:17:06 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
#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)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
|
2004-05-31 17:25:51 +02:00
|
|
|
|
void
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_colon_colon (cxx_pretty_printer *pp)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_colon_colon (pp);
|
|
|
|
|
pp_base (pp)->padding = pp_none;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2004-05-31 17:25:51 +02: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;
|
|
|
|
|
}
|
2003-08-05 21:23:14 +02:00
|
|
|
|
|
2003-10-23 01:42:47 +02:00
|
|
|
|
/* Expressions. */
|
2003-08-05 21:23:14 +02:00
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
static inline bool
|
|
|
|
|
is_destructor_name (tree name)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
return name == complete_dtor_identifier
|
|
|
|
|
|| name == base_dtor_identifier
|
|
|
|
|
|| name == deleting_dtor_identifier;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
/* conversion-function-id:
|
|
|
|
|
operator conversion-type-id
|
2003-08-10 20:17:06 +02:00
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
conversion-type-id:
|
|
|
|
|
type-specifier-seq conversion-declarator(opt)
|
2003-08-10 20:17:06 +02:00
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
conversion-declarator:
|
|
|
|
|
ptr-operator conversion-declarator(opt) */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
|
2003-08-10 20:17:06 +02:00
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_identifier (pp, "operator");
|
|
|
|
|
pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
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);
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* unqualified-id:
|
|
|
|
|
identifier
|
|
|
|
|
operator-function-id
|
|
|
|
|
conversion-function-id
|
|
|
|
|
~ class-name
|
|
|
|
|
template-id */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case RESULT_DECL:
|
|
|
|
|
pp_cxx_identifier (pp, "<return-value>");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OVERLOAD:
|
|
|
|
|
t = OVL_CURRENT (t);
|
2003-08-10 20:17:06 +02: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:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case TEMPLATE_DECL:
|
2003-08-10 20:17:06 +02:00
|
|
|
|
t = DECL_NAME (t);
|
|
|
|
|
|
|
|
|
|
case IDENTIFIER_NODE:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
if (t == NULL)
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_identifier (pp, "<unnamed>");
|
2003-08-25 21:10:50 +02:00
|
|
|
|
else if (IDENTIFIER_TYPENAME_P (t))
|
|
|
|
|
pp_cxx_conversion_function_id (pp, t);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (is_destructor_name (t))
|
|
|
|
|
{
|
|
|
|
|
pp_complement (pp);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
/* FIXME: Why is this necessary? */
|
|
|
|
|
if (TREE_TYPE (t))
|
|
|
|
|
t = constructor_name (TREE_TYPE (t));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
}
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_tree_identifier (pp, t);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_ID_EXPR:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_template_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2004-07-18 14:37:57 +02:00
|
|
|
|
case BASELINK:
|
|
|
|
|
pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
case UNION_TYPE:
|
|
|
|
|
case ENUMERAL_TYPE:
|
|
|
|
|
pp_cxx_unqualified_id (pp, TYPE_NAME (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
2004-05-31 17:25:51 +02: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;
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
|
|
|
|
pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-03-22 00:55:03 +01:00
|
|
|
|
/* Pretty-print out the token sequence ":: template" in template codes
|
|
|
|
|
where it is needed to "inline declare" the (following) member as
|
2004-03-25 18:04:45 +01:00
|
|
|
|
a template. This situation arises when SCOPE of T is dependent
|
2004-03-22 00:55:03 +01:00
|
|
|
|
on template parameters. */
|
|
|
|
|
|
2003-08-25 21:10:50 +02: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 */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* qualified-id:
|
|
|
|
|
nested-name-specifier template(opt) unqualified-id */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
2004-03-22 00:55:03 +01:00
|
|
|
|
/* A pointer-to-member is always qualified. */
|
2003-08-10 20:17:06 +02:00
|
|
|
|
case PTRMEM_CST:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
|
|
|
|
|
break;
|
|
|
|
|
|
2004-03-22 00:55:03 +01:00
|
|
|
|
/* In Standard C++, functions cannot possibly be used as
|
|
|
|
|
nested-name-specifiers. However, there are situations where
|
2004-03-25 18:04:45 +01:00
|
|
|
|
is "makes sense" to output the surrounding function name for the
|
2004-03-22 00:55:03 +01:00
|
|
|
|
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. */
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case OVERLOAD:
|
|
|
|
|
t = OVL_CURRENT (t);
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
if (DECL_FUNCTION_MEMBER_P (t))
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
|
|
|
|
|
pp_cxx_unqualified_id
|
|
|
|
|
(pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
|
2004-03-22 00:55:03 +01:00
|
|
|
|
pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
|
2003-08-25 21:10:50 +02:00
|
|
|
|
break;
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
case OFFSET_REF:
|
|
|
|
|
case SCOPE_REF:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
|
|
|
|
|
if (scope != pp->enclosing_scope)
|
2003-08-10 20:17:06 +02:00
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_nested_name_specifier (pp, scope);
|
|
|
|
|
pp_cxx_template_keyword_if_needed (pp, scope, t);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
}
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* id-expression:
|
2003-10-21 04:16:17 +02:00
|
|
|
|
unqualified-id
|
2003-08-10 20:17:06 +02:00
|
|
|
|
qualified-id */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
static inline void
|
|
|
|
|
pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
if (TREE_CODE (t) == OVERLOAD)
|
|
|
|
|
t = OVL_CURRENT (t);
|
2003-10-07 09:07:07 +02:00
|
|
|
|
if (DECL_P (t) && DECL_CONTEXT (t))
|
2003-08-10 20:17:06 +02:00
|
|
|
|
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 */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-05 21:23:14 +02:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
2003-08-10 20:17:06 +02:00
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case STRING_CST:
|
|
|
|
|
case INTEGER_CST:
|
|
|
|
|
case REAL_CST:
|
|
|
|
|
pp_c_constant (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
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:
|
2004-05-31 17:25:51 +02:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
default:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_c_primary_expression (pp_c_base (pp), t);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* 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)
|
|
|
|
|
template-id ( expression-list(opt) )
|
|
|
|
|
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 ) */
|
|
|
|
|
|
2003-08-05 21:23:14 +02:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
2003-08-10 20:17:06 +02:00
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
|
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case AGGR_INIT_EXPR:
|
|
|
|
|
case CALL_EXPR:
|
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
|
|
|
|
|
{
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 2));
|
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
case DYNAMIC_CAST_EXPR:
|
|
|
|
|
case STATIC_CAST_EXPR:
|
|
|
|
|
case REINTERPRET_CAST_EXPR:
|
|
|
|
|
case CONST_CAST_EXPR:
|
|
|
|
|
if (code == DYNAMIC_CAST_EXPR)
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_identifier (pp, "dynamic_cast");
|
2003-08-10 20:17:06 +02:00
|
|
|
|
else if (code == STATIC_CAST_EXPR)
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_identifier (pp, "static_cast");
|
2003-08-10 20:17:06 +02:00
|
|
|
|
else if (code == REINTERPRET_CAST_EXPR)
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_identifier (pp, "reinterpret_cast");
|
2003-08-10 20:17:06 +02:00
|
|
|
|
else
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_identifier (pp, "const_cast");
|
2003-08-10 20:17:06 +02: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);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_expression (pp, TREE_OPERAND (t, 0));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
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);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_identifier (pp, "typeid");
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_left_paren (pp);
|
|
|
|
|
if (TYPE_P (t))
|
|
|
|
|
pp_cxx_type_id (pp, t);
|
|
|
|
|
else
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_expression (pp, t);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_right_paren (pp);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PSEUDO_DTOR_EXPR:
|
|
|
|
|
pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_dot (pp);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1));
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_colon_colon (pp);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_complement (pp);
|
|
|
|
|
pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2));
|
|
|
|
|
break;
|
|
|
|
|
|
2005-04-17 23:27:47 +02:00
|
|
|
|
case ARROW_EXPR:
|
|
|
|
|
pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
|
|
|
|
|
pp_cxx_arrow (pp);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
default:
|
|
|
|
|
pp_c_postfix_expression (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* 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) ) */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-05 21:23:14 +02:00
|
|
|
|
static void
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-10 20:17:06 +02:00
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case NEW_EXPR:
|
|
|
|
|
case VEC_NEW_EXPR:
|
|
|
|
|
if (NEW_EXPR_USE_GLOBAL (t))
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_colon_colon (pp);
|
|
|
|
|
pp_cxx_identifier (pp, "new");
|
2003-08-10 20:17:06 +02:00
|
|
|
|
if (TREE_OPERAND (t, 0))
|
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_space (pp);
|
|
|
|
|
}
|
|
|
|
|
/* FIXME: array-types are built with one more element. */
|
|
|
|
|
pp_cxx_type_id (pp, TREE_OPERAND (t, 1));
|
|
|
|
|
if (TREE_OPERAND (t, 2))
|
|
|
|
|
{
|
|
|
|
|
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
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_expression (pp, t);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_right_paren (pp);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
}
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* delete-expression:
|
|
|
|
|
::(opt) delete cast-expression
|
|
|
|
|
::(opt) delete [ ] cast-expression */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-05 21:23:14 +02:00
|
|
|
|
static void
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-10 20:17:06 +02:00
|
|
|
|
enum tree_code code = TREE_CODE (t);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case DELETE_EXPR:
|
|
|
|
|
case VEC_DELETE_EXPR:
|
|
|
|
|
if (DELETE_EXPR_USE_GLOBAL (t))
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_colon_colon (pp);
|
|
|
|
|
pp_cxx_identifier (pp, "delete");
|
2003-08-10 20:17:06 +02:00
|
|
|
|
if (code == VEC_DELETE_EXPR)
|
|
|
|
|
{
|
|
|
|
|
pp_left_bracket (pp);
|
|
|
|
|
pp_right_bracket (pp);
|
|
|
|
|
}
|
|
|
|
|
pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 0));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
}
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* 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 ) */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-05 21:23:14 +02:00
|
|
|
|
static void
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-10 20:17:06 +02:00
|
|
|
|
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;
|
|
|
|
|
|
2005-04-17 23:27:47 +02: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;
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
default:
|
|
|
|
|
pp_c_unary_expression (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
/* cast-expression:
|
|
|
|
|
unary-expression
|
|
|
|
|
( type-id ) cast-expression */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* pm-expression:
|
|
|
|
|
cast-expression
|
|
|
|
|
pm-expression .* cast-expression
|
|
|
|
|
pm-expression ->* cast-expression */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-05 21:23:14 +02:00
|
|
|
|
static void
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-10 20:17:06 +02:00
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
/* Handle unfortunate OFFESET_REF overloading here. */
|
|
|
|
|
case OFFSET_REF:
|
|
|
|
|
if (TYPE_P (TREE_OPERAND (t, 0)))
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_qualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2003-12-21 22:07:32 +01:00
|
|
|
|
/* Else fall through. */
|
2003-08-10 20:17:06 +02:00
|
|
|
|
case MEMBER_REF:
|
|
|
|
|
case DOTSTAR_EXPR:
|
|
|
|
|
pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_dot (pp);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_star(pp);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
default:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_cast_expression (pp, t);
|
2003-08-10 20:17:06 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* multiplicative-expression:
|
|
|
|
|
pm-expression
|
|
|
|
|
multiplicative-expression * pm-expression
|
|
|
|
|
multiplicative-expression / pm-expression
|
|
|
|
|
multiplicative-expression % pm-expression */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-05 21:23:14 +02:00
|
|
|
|
static void
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-10 20:17:06 +02:00
|
|
|
|
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;
|
|
|
|
|
}
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* conditional-expression:
|
|
|
|
|
logical-or-expression
|
|
|
|
|
logical-or-expression ? expression : assignment-expression */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
|
2003-08-05 21:23:14 +02:00
|
|
|
|
{
|
2003-08-10 20:17:06 +02:00
|
|
|
|
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);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_expression (pp, TREE_OPERAND (e, 1));
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pp_c_logical_or_expression (pp_c_base (pp), e);
|
|
|
|
|
}
|
|
|
|
|
|
2004-03-22 00:55:03 +01:00
|
|
|
|
/* Pretty-print a compound assignment operator token as indicated by T. */
|
|
|
|
|
|
2003-08-25 21:10:50 +02: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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
/* assignment-expression:
|
|
|
|
|
conditional-expression
|
|
|
|
|
logical-or-expression assignment-operator assignment-expression
|
2003-08-25 21:10:50 +02:00
|
|
|
|
throw-expression
|
|
|
|
|
|
|
|
|
|
throw-expression:
|
|
|
|
|
throw assignment-expression(opt)
|
2003-08-10 20:17:06 +02:00
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
assignment-operator: one of
|
2003-08-10 20:17:06 +02:00
|
|
|
|
= *= /= %= += -= >>= <<= &= ^= |= */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
static void
|
|
|
|
|
pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
|
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
switch (TREE_CODE (e))
|
2003-08-10 20:17:06 +02:00
|
|
|
|
{
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case MODIFY_EXPR:
|
|
|
|
|
case INIT_EXPR:
|
2003-08-10 20:17:06 +02:00
|
|
|
|
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));
|
2003-08-25 21:10:50 +02:00
|
|
|
|
break;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case THROW_EXPR:
|
|
|
|
|
pp_cxx_identifier (pp, "throw");
|
|
|
|
|
if (TREE_OPERAND (e, 0))
|
|
|
|
|
pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
|
|
|
|
|
break;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
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;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
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:
|
|
|
|
|
pp_c_constant (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RESULT_DECL:
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
case OFFSET_REF:
|
|
|
|
|
#endif
|
|
|
|
|
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:
|
2004-05-31 17:25:51 +02:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2003-08-25 21:10:50 +02: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:
|
|
|
|
|
#if 0
|
|
|
|
|
case MEMBER_REF:
|
|
|
|
|
#endif
|
|
|
|
|
case EMPTY_CLASS_EXPR:
|
|
|
|
|
case TYPEID_EXPR:
|
|
|
|
|
case PSEUDO_DTOR_EXPR:
|
|
|
|
|
case AGGR_INIT_EXPR:
|
2005-04-17 23:27:47 +02:00
|
|
|
|
case ARROW_EXPR:
|
2003-08-25 21:10:50 +02: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;
|
|
|
|
|
|
2005-04-17 23:27:47 +02:00
|
|
|
|
case SIZEOF_EXPR:
|
|
|
|
|
case ALIGNOF_EXPR:
|
|
|
|
|
pp_cxx_unary_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-25 21:10:50 +02: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;
|
|
|
|
|
|
2004-03-22 00:55:03 +01:00
|
|
|
|
case NON_DEPENDENT_EXPR:
|
|
|
|
|
case MUST_NOT_THROW_EXPR:
|
|
|
|
|
pp_cxx_expression (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
default:
|
|
|
|
|
pp_c_expression (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Declarations. */
|
|
|
|
|
|
|
|
|
|
/* function-specifier:
|
|
|
|
|
inline
|
|
|
|
|
virtual
|
|
|
|
|
explicit */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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))
|
|
|
|
|
pp_cxx_identifier (pp, "virtual");
|
|
|
|
|
else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
|
|
|
|
|
pp_cxx_identifier (pp, "explicit");
|
|
|
|
|
else
|
|
|
|
|
pp_c_function_specifier (pp_c_base (pp), t);
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* decl-specifier-seq:
|
|
|
|
|
decl-specifier-seq(opt) decl-specifier
|
|
|
|
|
|
|
|
|
|
decl-specifier:
|
|
|
|
|
storage-class-specifier
|
|
|
|
|
type-specifier
|
|
|
|
|
function-specifier
|
|
|
|
|
friend
|
|
|
|
|
typedef */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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;
|
|
|
|
|
|
|
|
|
|
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))
|
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
/* Constructors don't have return types. And conversion functions
|
|
|
|
|
do not have a type-specifier in their return types. */
|
|
|
|
|
if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
|
|
|
|
|
pp_cxx_function_specifier (pp, t);
|
|
|
|
|
else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
|
|
|
|
|
pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (t)));
|
|
|
|
|
else
|
|
|
|
|
default:
|
|
|
|
|
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 */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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:
|
2004-05-31 17:25:51 +02:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2003-08-25 21:10:50 +02: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
|
2003-10-21 04:16:17 +02:00
|
|
|
|
cv-qualifier */
|
2003-08-25 21:10:50 +02:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
2004-05-31 17:25:51 +02:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_cv_qualifier_seq (pp, t);
|
2003-08-25 21:10:50 +02: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)))
|
|
|
|
|
pp_c_specifier_qualifier_list (pp_c_base (pp), t);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
|
|| TYPE_PTR_TO_MEMBER_P (TREE_TYPE (t)))
|
|
|
|
|
pp_cxx_ptr_operator (pp, TREE_TYPE (t));
|
|
|
|
|
if (TREE_CODE (t) == POINTER_TYPE)
|
|
|
|
|
{
|
|
|
|
|
pp_star (pp);
|
|
|
|
|
pp_cxx_cv_qualifier_seq (pp, t);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pp_ampersand (pp);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case RECORD_TYPE:
|
|
|
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
|
|
|
|
|
pp_star (pp);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case OFFSET_TYPE:
|
|
|
|
|
if (TYPE_PTR_TO_MEMBER_P (t))
|
|
|
|
|
{
|
2004-06-27 23:36:00 +02:00
|
|
|
|
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
|
|
|
|
|
pp_cxx_left_paren (pp);
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
|
|
|
|
|
pp_star (pp);
|
|
|
|
|
pp_cxx_cv_qualifier_seq (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2003-12-13 05:28:50 +01:00
|
|
|
|
/* else fall through. */
|
2003-08-25 21:10:50 +02:00
|
|
|
|
|
|
|
|
|
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 */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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 */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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);
|
alias.c (find_base_decl): Remove unreachable case '3' block.
2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>
Zack Weinberg <zack@codesourcery.com>
* alias.c (find_base_decl): Remove unreachable case '3' block.
* expr.c (safe_from_p): Abort if passed a type.
* tree-gimple.c (recalculate_side_effects): Abort if passed
anything other than an expression.
* tree-ssa-pre.c (phi_translate): Return expr immediately if
is_gimple_min_invariant is true for it. Reorder cases for clarity.
Abort on un-handled tree classes.
(valid_in_set): Likewise.
* tree.c (tree_code_class_strings): New static data.
* tree.h (enum tree_code_class): New.
(tree_code_class_strings): Declare.
(TREE_CODE_CLASS_STRING, EXCEPTIONAL_CLASS_P, CONSTANT_CLASS_P)
(REFERENCE_CLASS_P, COMPARISON_CLASS_P, UNARY_CLASS_P, BINARY_CLASS_P)
(STATEMENT_CLASS_P, EXPRESSION_CLASS_P, IS_TYPE_OR_DECL_P): New macros.
(TYPE_P, DECL_P, IS_NON_TYPE_CODE_CLASS, IS_EXPR_CODE_CLASS)
(checking macros, EXPR_LOCATION, SET_EXPR_LOCATION, EXPR_LOCUS): Update.
* tree.def, c-common.def, objc/objc-tree.def: Use
tree_code_class enumeration constants instead of code letters.
* alias.c, builtins.c, c-common.c, c-format.c, c-lang.c, c-pragma.c
* c-typeck.c, cgraphunit.c, convert.c, dbxout.c, dwarf2out.c
* emit-rtl.c expr.c, fold-const.c, gimplify.c, lambda-code.c
* langhooks.c, langhooks.h, predict.c, print-tree.c, reload1.c, stmt.c
* tree-browser.c, tree-cfg.c, tree-chrec.c, tree-complex.c, tree-dfa.c
* tree-dump.c, tree-eh.c, tree-gimple.c, tree-inline.c, tree-nested.c
* tree-outof-ssa.c, tree-pretty-print.c, tree-sra.c, tree-ssa-ccp.c
* tree-ssa-dce.c, tree-ssa-dom.c, tree-ssa-forwprop.c, tree-ssa-live.c
* tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-operands.c
* tree-ssa-phiopt.c, tree-ssa-pre.c, tree-ssa-propagate.c
* tree-ssa.c, tree-ssanames.c, tree-tailcall.c, tree.c, varasm.c
* config/sol2-c.c, config/arm/arm.c, config/i386/winnt.c
* config/pa/pa.c, config/pa/pa.h, config/sh/sh.c, objc/objc-lang.c
Update to match.
* LANGUAGES: Add note about change.
ada:
* ada-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* ada-tree.h, decl.c, misc.c, trans.c, utils.c, utils2.c:
Update for new tree-class enumeration constants.
cp:
* cp-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* call.c, class.c, cp-gimplify.c, cp-lang.c, cxx-pretty-print.c
* mangle.c, pt.c, semantics.c, tree.c, typeck.c:
Update for new tree-class enumeration constants.
fortran:
* f95-lang.c, trans-expr.c, trans.c: Update for new tree-class
enumeration constants.
java:
* java-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* java-gimplify.c, jcf-write.c, lang.c, parse.y: Update for
new tree-class enumeration constants.
treelang:
* treetree.c: Update for new tree-class enumeration constants.
From-SVN: r87675
2004-09-17 23:55:02 +02:00
|
|
|
|
tree types =
|
|
|
|
|
TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
|
2003-08-25 21:10:50 +02: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)
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2003-08-25 21:10:50 +02: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)
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_equal (pp);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_cxx_assignment_expression (pp, TREE_PURPOSE (types));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* exception-specification:
|
|
|
|
|
throw ( type-id-list(opt) )
|
|
|
|
|
|
|
|
|
|
type-id-list
|
|
|
|
|
type-id
|
|
|
|
|
type-id-list , type-id */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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))
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2003-08-25 21:10:50 +02:00
|
|
|
|
}
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* direct-declarator:
|
|
|
|
|
declarator-id
|
|
|
|
|
direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
|
|
|
|
|
exception-specification(opt)
|
|
|
|
|
direct-declaration [ constant-expression(opt) ]
|
|
|
|
|
( declarator ) */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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))
|
|
|
|
|
{
|
|
|
|
|
pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
|
|
|
|
|
pp_cxx_id_expression (pp, DECL_NAME (t));
|
|
|
|
|
}
|
|
|
|
|
pp_cxx_abstract_declarator (pp, TREE_TYPE (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
|
|
|
|
|
{
|
|
|
|
|
pp_base (pp)->padding = pp_before;
|
|
|
|
|
pp_cxx_cv_qualifier_seq (pp, pp_cxx_implicit_parameter_type (t));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pp_cxx_exception_specification (pp, TREE_TYPE (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPENAME_TYPE:
|
|
|
|
|
case TEMPLATE_DECL:
|
|
|
|
|
case TEMPLATE_TYPE_PARM:
|
|
|
|
|
case TEMPLATE_PARM_INDEX:
|
2004-05-31 17:25:51 +02:00
|
|
|
|
case TEMPLATE_TEMPLATE_PARM:
|
2003-08-25 21:10:50 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
pp_c_direct_declarator (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* declarator:
|
|
|
|
|
direct-declarator
|
|
|
|
|
ptr-operator declarator */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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 */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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))
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2003-08-25 21:10:50 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* function-definition:
|
|
|
|
|
decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
|
|
|
|
|
decl-specifier-seq(opt) declarator function-try-block */
|
|
|
|
|
|
2005-01-25 09:58:46 +01:00
|
|
|
|
static void
|
2003-08-25 21:10:50 +02: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))
|
2004-06-17 03:24:06 +02:00
|
|
|
|
pp_cxx_statement (pp, DECL_SAVED_TREE (t));
|
2003-08-25 21:10:50 +02: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 */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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
|
|
|
|
|
|| TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
t = TREE_TYPE (t);
|
|
|
|
|
}
|
|
|
|
|
pp_cxx_direct_abstract_declarator (pp, t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* direct-abstract-declarator:
|
|
|
|
|
direct-abstract-declarator(opt) ( parameter-declaration-clause )
|
2003-10-21 04:16:17 +02:00
|
|
|
|
cv-qualifier-seq(opt) exception-specification(opt)
|
2003-08-25 21:10:50 +02:00
|
|
|
|
direct-abstract-declarator(opt) [ constant-expression(opt) ]
|
|
|
|
|
( abstract-declarator ) */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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))
|
|
|
|
|
pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t));
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
pp_base (pp)->padding = pp_before;
|
|
|
|
|
pp_cxx_cv_qualifier_seq
|
|
|
|
|
(pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
|
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* type-id:
|
|
|
|
|
type-specifier-seq abstract-declarator(opt) */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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 */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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)
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2003-08-25 21:10:50 +02:00
|
|
|
|
if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
|
alias.c (find_base_decl): Remove unreachable case '3' block.
2004-09-17 Jeffrey D. Oldham <oldham@codesourcery.com>
Zack Weinberg <zack@codesourcery.com>
* alias.c (find_base_decl): Remove unreachable case '3' block.
* expr.c (safe_from_p): Abort if passed a type.
* tree-gimple.c (recalculate_side_effects): Abort if passed
anything other than an expression.
* tree-ssa-pre.c (phi_translate): Return expr immediately if
is_gimple_min_invariant is true for it. Reorder cases for clarity.
Abort on un-handled tree classes.
(valid_in_set): Likewise.
* tree.c (tree_code_class_strings): New static data.
* tree.h (enum tree_code_class): New.
(tree_code_class_strings): Declare.
(TREE_CODE_CLASS_STRING, EXCEPTIONAL_CLASS_P, CONSTANT_CLASS_P)
(REFERENCE_CLASS_P, COMPARISON_CLASS_P, UNARY_CLASS_P, BINARY_CLASS_P)
(STATEMENT_CLASS_P, EXPRESSION_CLASS_P, IS_TYPE_OR_DECL_P): New macros.
(TYPE_P, DECL_P, IS_NON_TYPE_CODE_CLASS, IS_EXPR_CODE_CLASS)
(checking macros, EXPR_LOCATION, SET_EXPR_LOCATION, EXPR_LOCUS): Update.
* tree.def, c-common.def, objc/objc-tree.def: Use
tree_code_class enumeration constants instead of code letters.
* alias.c, builtins.c, c-common.c, c-format.c, c-lang.c, c-pragma.c
* c-typeck.c, cgraphunit.c, convert.c, dbxout.c, dwarf2out.c
* emit-rtl.c expr.c, fold-const.c, gimplify.c, lambda-code.c
* langhooks.c, langhooks.h, predict.c, print-tree.c, reload1.c, stmt.c
* tree-browser.c, tree-cfg.c, tree-chrec.c, tree-complex.c, tree-dfa.c
* tree-dump.c, tree-eh.c, tree-gimple.c, tree-inline.c, tree-nested.c
* tree-outof-ssa.c, tree-pretty-print.c, tree-sra.c, tree-ssa-ccp.c
* tree-ssa-dce.c, tree-ssa-dom.c, tree-ssa-forwprop.c, tree-ssa-live.c
* tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-operands.c
* tree-ssa-phiopt.c, tree-ssa-pre.c, tree-ssa-propagate.c
* tree-ssa.c, tree-ssanames.c, tree-tailcall.c, tree.c, varasm.c
* config/sol2-c.c, config/arm/arm.c, config/i386/winnt.c
* config/pa/pa.c, config/pa/pa.h, config/sh/sh.c, objc/objc-lang.c
Update to match.
* LANGUAGES: Add note about change.
ada:
* ada-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* ada-tree.h, decl.c, misc.c, trans.c, utils.c, utils2.c:
Update for new tree-class enumeration constants.
cp:
* cp-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* call.c, class.c, cp-gimplify.c, cp-lang.c, cxx-pretty-print.c
* mangle.c, pt.c, semantics.c, tree.c, typeck.c:
Update for new tree-class enumeration constants.
fortran:
* f95-lang.c, trans-expr.c, trans.c: Update for new tree-class
enumeration constants.
java:
* java-tree.def: Use tree_code_class enumeration constants
instead of code letters.
* java-gimplify.c, jcf-write.c, lang.c, parse.y: Update for
new tree-class enumeration constants.
treelang:
* treetree.c: Update for new tree-class enumeration constants.
From-SVN: r87675
2004-09-17 23:55:02 +02:00
|
|
|
|
&& TYPE_P (DECL_TEMPLATE_RESULT (arg))))
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_type_id (pp, arg);
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_expression (pp, arg);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
c-common.c (c_safe_from_p, [...]): Deleted.
2004-06-26 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* c-common.c (c_safe_from_p, c_walk_subtrees): Deleted.
* c-common.def (DECL_STMT): Remove.
* c-common.h (DECL_STMT_DECL): Deleted.
(COMPOUNT_LITERAL_EXPR_DECL): Use DECL_EXPR_DECL.
(c_safe_from_p, c_walk_subtrees): Deleted.
* c-decl.c, c-parse.in, c-pretty-print.c: DECL_STMT now DECL_EXPR.
* c-dump.c (c_dump_tree, case DECL_STMT): Deleted.
* c-gimplify.c (gimplify_decl_stmt): Deleted.
(gimplify_compound_literal_expr): Use DECL_EXPR_DECL
and gimplify_and_add.
(c_gimplify_expr, case DECL_EXPR): New case.
(c_gimplify_expr, case DECL_STMT): Deleted.
* c-lang.c (LANG_HOOKS_SAFE_FROM_P): Likewise.
(LANG_HOOKS_TREE_INLINING_WALK_SUBTREES): Likewise.
* expr.c (safe_from_p, case 's'): New case.
* gimplify.c (gimplify_decl_expr): New function.
(gimplify_expr, case DECL_EXPR): New case.
* tree-inline.c (walk_tree): Walk into all fields of a type and
decl only if they are in a DECL_EXPR.
(mark_local_for_remap_r): Minor code cleanup.
* tree-outof-ssa.c (discover_nonconstant_array_refs_r): Add else.
* tree.c (has_cleanups, case DECL_EXPR): New case.
* tree.def (DECL_EXPR): New code.
* tree.h (DECL_EXPR_DECL): New macro.
* objc/objc-lang.c (LANG_HOOKS_SAFE_FROM_P): Deleted.
From-SVN: r83721
2004-06-26 23:11:23 +02:00
|
|
|
|
t = DECL_EXPR_DECL (t);
|
2003-08-25 21:10:50 +02: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. */
|
|
|
|
|
|
2005-01-25 09:58:46 +01:00
|
|
|
|
static void
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp_cxx_statement (cxx_pretty_printer *pp, tree t)
|
|
|
|
|
{
|
|
|
|
|
switch (TREE_CODE (t))
|
|
|
|
|
{
|
2004-06-17 03:24:06 +02:00
|
|
|
|
case CTOR_INITIALIZER:
|
|
|
|
|
pp_cxx_ctor_initializer (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case USING_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "using");
|
|
|
|
|
pp_cxx_identifier (pp, "namespace");
|
|
|
|
|
pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case USING_DECL:
|
|
|
|
|
pp_cxx_identifier (pp, "using");
|
|
|
|
|
pp_cxx_nested_name_specifier (pp, DECL_INITIAL (t));
|
|
|
|
|
pp_cxx_unqualified_id (pp, DECL_NAME (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EH_SPEC_BLOCK:
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* try-block:
|
|
|
|
|
try compound-statement handler-seq */
|
|
|
|
|
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))
|
|
|
|
|
;
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_statement (pp, TRY_HANDLERS (t));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
handler-seq:
|
|
|
|
|
handler handler-seq(opt)
|
|
|
|
|
|
|
|
|
|
handler:
|
|
|
|
|
catch ( exception-declaration ) compound-statement
|
|
|
|
|
|
|
|
|
|
exception-declaration:
|
|
|
|
|
type-specifier-seq declarator
|
|
|
|
|
type-specifier-seq abstract-declarator
|
|
|
|
|
... */
|
|
|
|
|
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;
|
|
|
|
|
|
c-common.def (IF_STMT, [...]): Move to cp-tree.def.
* c-common.def (IF_STMT, CLEANUP_STMT): Move to cp-tree.def.
* c-common.h (IF_COND, THEN_CLAUSE, ELSE_CLAUSE, CLEANUP_BODY,
CLEANUP_EXPR, CLEANUP_DECL): Move to cp-tree.h.
(c_common_stmt_codes): Remove IF_STMT, CLEANUP_STMT.
* c-dump.c (c_dump_tree): Move IF_STMT, CLEANUP_STMT to cp_dump_tree.
* c-pretty-print.c (pp_c_statement): Similarly.
* c-gimplify.c (gimplify_cleanup_stmt, gimplify_cleanup_stmts,
gimplify_if_stmt): Move to cp-gimplify.c.
(c_genericize, c_gimplify_expr): Don't call them.
* c-semantics.c (push_cleanup): Move to cp/semantics.c.
* c-typeck.c (push_cleanup): New.
(c_begin_if_stmt, c_finish_if_cond, c_finish_then, c_finish_else,
c_finish_if_stmt): Use COND_EXPR.
* tree.h (CLEANUP_EH_ONLY): Update documentation.
cp/
* cp-tree.def (CLEANUP_STMT, IF_STMT): Move from c-common.def.
* cp-gimplify.c (gimplify_if_stmt): Move from c-gimplify.c.
(cp_gimplify_expr): Call it.
(gimplify_cleanup_stmt): Move from c-gimplify.c.
(cp_genericize): New.
* decl.c (finish_function): Call it.
* cp-tree.h (cp_stmt_codes): Add CLEANUP_STMT, IF_STMT.
(CLEANUP_BODY, CLEANUP_EXPR, CLEANUP_DECL): Move from c-common.h.
(IF_COND, THEN_CLAUSE, ELSE_CLAUSE): Likewise.
(cp_genericize): Declare.
* cxx-pretty-print.c (pp_cxx_statement): Add CLEANUP_STMT, IF_STMT.
* dump.c (cp_dump_tree): Likewise.
* semantics.c (push_cleanup): Move from c-semantics.c.
From-SVN: r83407
2004-06-20 11:18:13 +02: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;
|
|
|
|
|
|
c-common.def: Move FOR_STMT...
./ * c-common.def: Move FOR_STMT, WHILE_STMT, DO_STMT, BREAK_STMT,
CONTINUE_STMT, and SWITCH_STMT to cp/cp-tree.def.
* c-common.h (WHILE_COND, WHILE_BODY): Move to cp/cp-tree.h.
(DO_COND, DO_BODY): Likewise.
(FOR_INIT_STMT, FOR_COND, FOR_EXPR, FOR_BODY): Likewise.
(SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE): Likewise.
(c_common_stmt_codes): Remove FOR_STMT, WHILE_STMT, DO_STMT,
BREAK_STMT, CONTINUE_STMT, and SWITCH_STMT.
(build_continue_stmt, build_break_stmt): Don't declare.
(c_do_switch_warnings): Update declaration.
* c-gimplify.c (enum bc_t): Remove.
(struct c_gimplify_ctx, ctxp): Remove.
(push_context, pop_context): Remove static functions.
(c_genericize): Don't call push_context or pop_context.
(begin_bc_block, finish_bc_block): Remove static functions.
(build_bc_goto): Likewise.
(gimplify_c_loop): Likewise.
(gimplify_for_stmt, gimplify_while_stmt): Likewise.
(gimplify_do_stmt, gimplify_switch_stmt): Likewise.
(c_gimplify_expr): Remove handling of FOR_STMT, WHILE_STMT,
DO_STMT, SWITCH_STMT, CONTINUE_STMT, BREAK_STMT.
* c-common.c (c_do_switch_warnings): Rename from
c_do_switch_warnings_1.
(c_do_switch_warnings) [old version]: Remove.
(c_do_switch_expr_warnings): Remove.
* c-typeck.c (c_finish_case): Call new c_do_switch_warnings
function instead of c_do_switch_expr_warnings.
* c-dump.c (c_dump_tree): Remove handling of BREAK_STMT,
CONTINUE_STMT, DO_STMT, FOR_STMT, SWITCH_STMT, and WHILE_STMT.
* c-pretty-print.c (pp_c_statement): Likewise.
* c-semantics.c (build_break_stmt, build_continue_stmt): Remove.
cp/
* cp-tree.def: Define FOR_STMT, WHILE_STMT, DO_STMT, BREAK_STMT,
CONTINUE_STMT, SWITCH_STMT.
* cp-tree.h (cp_stmt_codes): Add FOR_STMT, WHILE_STMT, DO_STMT,
BREAK_STMT, CONTINUE_STMT, SWITCH_STMT.
(WHILE_COND, WHILE_BODY): Define.
(DO_COND, DO_BODY): Define.
(FOR_INIT_STMT, FOR_COND, FOR_EXPR, FOR_BODY): Define.
(SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE): Define.
* cp-gimplify.c (enum bc_t): Define.
(struct cp_gimplify_ctx, ctxp): Define.
(push_context, pop_context): New static functions.
(begin_bc_block, finish_bc_block): New static functions.
(build_bc_goto): New static function.
(gimplify_cp_loop, gimplify_for_stmt): New static functions.
(gimplify_while_stmt, gimplify_do_stmt): Likewise.
(gimplify_switch_stmt): Likewise.
(cp_gimplify_expr): Handle FOR_STMT, WHILE_STMT, DO_STMT,
SWITCH_STMT, CONTINUE_STMT, BREAK_STMT.
(cp_genericize): Call push_context and pop_context.
* semantics.c (finish_break_stmt): Just call build_stmt
(BREAK_STMT) rather than build_break_stmt.
(finish_continue_stmt): Corresponding change.
* decl.c (pop_switch): Update call to c_do_switch_warnings for new
parameters.
* cxx-pretty-print.c (pp_cxx_statement): Handle SWITCH_STMT,
WHILE_STMT, DO_STMT, FOR_STMT, BREAK_STMT, CONTINUE_STMT.
* dump.c (cp_dump_tree): Likewise.
From-SVN: r97885
2005-04-09 05:18:18 +02:00
|
|
|
|
case SWITCH_STMT:
|
|
|
|
|
pp_cxx_identifier (pp, "switch");
|
|
|
|
|
pp_space (pp);
|
|
|
|
|
pp_cxx_left_paren (pp);
|
|
|
|
|
pp_expression (pp, SWITCH_STMT_COND (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_indentation (pp) += 3;
|
|
|
|
|
pp_needs_newline (pp) = true;
|
|
|
|
|
pp_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_expression (pp, WHILE_COND (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_newline_and_indent (pp, 3);
|
|
|
|
|
pp_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_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_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_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_expression (pp, FOR_COND (t));
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
pp_needs_newline (pp) = false;
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
if (FOR_EXPR (t))
|
|
|
|
|
pp_expression (pp, FOR_EXPR (t));
|
|
|
|
|
pp_cxx_right_paren (pp);
|
|
|
|
|
pp_newline_and_indent (pp, 3);
|
|
|
|
|
pp_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;
|
|
|
|
|
|
c-common.def (IF_STMT, [...]): Move to cp-tree.def.
* c-common.def (IF_STMT, CLEANUP_STMT): Move to cp-tree.def.
* c-common.h (IF_COND, THEN_CLAUSE, ELSE_CLAUSE, CLEANUP_BODY,
CLEANUP_EXPR, CLEANUP_DECL): Move to cp-tree.h.
(c_common_stmt_codes): Remove IF_STMT, CLEANUP_STMT.
* c-dump.c (c_dump_tree): Move IF_STMT, CLEANUP_STMT to cp_dump_tree.
* c-pretty-print.c (pp_c_statement): Similarly.
* c-gimplify.c (gimplify_cleanup_stmt, gimplify_cleanup_stmts,
gimplify_if_stmt): Move to cp-gimplify.c.
(c_genericize, c_gimplify_expr): Don't call them.
* c-semantics.c (push_cleanup): Move to cp/semantics.c.
* c-typeck.c (push_cleanup): New.
(c_begin_if_stmt, c_finish_if_cond, c_finish_then, c_finish_else,
c_finish_if_stmt): Use COND_EXPR.
* tree.h (CLEANUP_EH_ONLY): Update documentation.
cp/
* cp-tree.def (CLEANUP_STMT, IF_STMT): Move from c-common.def.
* cp-gimplify.c (gimplify_if_stmt): Move from c-gimplify.c.
(cp_gimplify_expr): Call it.
(gimplify_cleanup_stmt): Move from c-gimplify.c.
(cp_genericize): New.
* decl.c (finish_function): Call it.
* cp-tree.h (cp_stmt_codes): Add CLEANUP_STMT, IF_STMT.
(CLEANUP_BODY, CLEANUP_EXPR, CLEANUP_DECL): Move from c-common.h.
(IF_COND, THEN_CLAUSE, ELSE_CLAUSE): Likewise.
(cp_genericize): Declare.
* cxx-pretty-print.c (pp_cxx_statement): Add CLEANUP_STMT, IF_STMT.
* dump.c (cp_dump_tree): Likewise.
* semantics.c (push_cleanup): Move from c-semantics.c.
From-SVN: r83407
2004-06-20 11:18:13 +02:00
|
|
|
|
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;
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
default:
|
|
|
|
|
pp_c_statement (pp_c_base (pp), t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-07 20:52:53 +02:00
|
|
|
|
/* 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");
|
2003-12-08 21:29:15 +01:00
|
|
|
|
if (DECL_NAME (t))
|
2003-09-07 20:52:53 +02:00
|
|
|
|
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");
|
|
|
|
|
pp_cxx_unqualified_id (pp, t);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_equal (pp);
|
|
|
|
|
pp_cxx_whitespace (pp);
|
|
|
|
|
pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
|
|
|
|
|
pp_cxx_semicolon (pp);
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
/* simple-declaration:
|
|
|
|
|
decl-specifier-seq(opt) init-declarator-list(opt) */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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)
|
2004-05-31 17:25:51 +02:00
|
|
|
|
pp_cxx_separate_with (pp, ',');
|
2003-08-25 21:10:50 +02: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)
|
|
|
|
|
template < template-parameter-list > class identifier(opt) = template-name
|
|
|
|
|
*/
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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))
|
|
|
|
|
pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
|
|
|
|
|
/* 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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-29 09:00:32 +02:00
|
|
|
|
/* 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);
|
|
|
|
|
|
2003-10-23 01:42:47 +02:00
|
|
|
|
/* Brings type template parameters to the canonical forms. */
|
2003-08-29 09:00:32 +02:00
|
|
|
|
if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
|
|
|
|
|
|| code == BOUND_TEMPLATE_TEMPLATE_PARM)
|
|
|
|
|
parm = TEMPLATE_TYPE_PARM_INDEX (parm);
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
/*
|
|
|
|
|
template-declaration:
|
|
|
|
|
export(opt) template < template-parameter-list > declaration */
|
2004-03-22 00:55:03 +01:00
|
|
|
|
|
2003-08-25 21:10:50 +02: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);
|
2003-09-07 20:52:53 +02:00
|
|
|
|
else if (DECL_USE_TEMPLATE (t))
|
2003-08-25 21:10:50 +02:00
|
|
|
|
switch (DECL_USE_TEMPLATE (t))
|
|
|
|
|
{
|
2003-09-07 20:52:53 +02:00
|
|
|
|
case 1:
|
|
|
|
|
pp_cxx_template_declaration (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
case 2:
|
|
|
|
|
pp_cxx_explicit_specialization (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
|
pp_cxx_explicit_instantiation (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else switch (TREE_CODE (t))
|
|
|
|
|
{
|
|
|
|
|
case VAR_DECL:
|
|
|
|
|
case TYPE_DECL:
|
|
|
|
|
pp_cxx_simple_declaration (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case FUNCTION_DECL:
|
|
|
|
|
if (DECL_SAVED_TREE (t))
|
|
|
|
|
pp_cxx_function_definition (pp, t);
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_simple_declaration (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-09-07 20:52:53 +02:00
|
|
|
|
case NAMESPACE_DECL:
|
|
|
|
|
if (DECL_NAMESPACE_ALIAS (t))
|
|
|
|
|
pp_cxx_namespace_alias_definition (pp, t);
|
|
|
|
|
else
|
|
|
|
|
pp_cxx_original_namespace_definition (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
|
2003-08-25 21:10:50 +02:00
|
|
|
|
default:
|
|
|
|
|
pp_unsupported_tree (pp, t);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef c_pretty_print_fn pp_fun;
|
|
|
|
|
|
2004-03-22 00:55:03 +01:00
|
|
|
|
/* Initialization of a C++ pretty-printer object. */
|
|
|
|
|
|
2003-08-25 21:10:50 +02: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);
|
2003-08-05 21:23:14 +02:00
|
|
|
|
|
|
|
|
|
pp->c_base.declaration = (pp_fun) pp_cxx_declaration;
|
2003-08-25 21:10:50 +02:00
|
|
|
|
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;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
pp->c_base.declarator = (pp_fun) pp_cxx_declarator;
|
|
|
|
|
pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator;
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
|
2003-08-25 21:10:50 +02:00
|
|
|
|
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; */
|
|
|
|
|
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
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;
|
2003-08-10 20:17:06 +02:00
|
|
|
|
pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
|
|
|
|
|
pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
|
2003-08-25 21:10:50 +02:00
|
|
|
|
pp->c_base.expression = (pp_fun) pp_cxx_expression;
|
|
|
|
|
pp->enclosing_scope = global_namespace;
|
2003-08-05 21:23:14 +02:00
|
|
|
|
}
|