gcc/cp/cxx-pretty-print.c

   1 /* Implementation of subroutines for the GNU C++ pretty-printer.
   2    Copyright (C) 2003, 2004, 2005, 2007, 2008,
   3    2009, 2010, 2011 Free Software Foundation, Inc.
   4    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "intl.h"
  27 #include "cp-tree.h"
  28 #include "cxx-pretty-print.h"
  29 #include "tree-pretty-print.h"
  30
  31 /* Translate if being used for diagnostics, but not for dump files or
  32    __PRETTY_FUNCTION.  */
  33 #define M_(msgid) (pp_translate_identifiers (pp) ? _(msgid) : (msgid))
  34
  35 static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree);
  36 static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree);
  37 static void pp_cxx_qualified_id (cxx_pretty_printer *, tree);
  38 static void pp_cxx_assignment_expression (cxx_pretty_printer *, tree);
  39 static void pp_cxx_expression (cxx_pretty_printer *, tree);
  40 static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree);
  41 static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree);
  42 static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree);
  43 static void pp_cxx_type_id (cxx_pretty_printer *, tree);
  44 static void pp_cxx_direct_abstract_declarator (cxx_pretty_printer *, tree);
  45 static void pp_cxx_declarator (cxx_pretty_printer *, tree);
  46 static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree);
  47 static void pp_cxx_abstract_declarator (cxx_pretty_printer *, tree);
  48 static void pp_cxx_statement (cxx_pretty_printer *, tree);
  49 static void pp_cxx_template_parameter (cxx_pretty_printer *, tree);
  50 static void pp_cxx_cast_expression (cxx_pretty_printer *, tree);
  51 static void pp_cxx_typeid_expression (cxx_pretty_printer *, tree);
  52 \f
  53
  54 static inline void
  55 pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c)
  56 {
  57   const char *p = pp_last_position_in_text (pp);
  58
  59   if (p != NULL && *p == c)
  60     pp_cxx_whitespace (pp);
  61   pp_character (pp, c);
  62   pp_base (pp)->padding = pp_none;
  63 }
  64
  65 #define pp_cxx_storage_class_specifier(PP, T) \
  66    pp_c_storage_class_specifier (pp_c_base (PP), T)
  67 #define pp_cxx_expression_list(PP, T)    \
  68    pp_c_expression_list (pp_c_base (PP), T)
  69 #define pp_cxx_space_for_pointer_operator(PP, T)  \
  70    pp_c_space_for_pointer_operator (pp_c_base (PP), T)
  71 #define pp_cxx_init_declarator(PP, T)    \
  72    pp_c_init_declarator (pp_c_base (PP), T)
  73 #define pp_cxx_call_argument_list(PP, T) \
  74    pp_c_call_argument_list (pp_c_base (PP), T)
  75
  76 void
  77 pp_cxx_colon_colon (cxx_pretty_printer *pp)
  78 {
  79   pp_colon_colon (pp);
  80   pp_base (pp)->padding = pp_none;
  81 }
  82
  83 void
  84 pp_cxx_begin_template_argument_list (cxx_pretty_printer *pp)
  85 {
  86   pp_cxx_nonconsecutive_character (pp, '<');
  87 }
  88
  89 void
  90 pp_cxx_end_template_argument_list (cxx_pretty_printer *pp)
  91 {
  92   pp_cxx_nonconsecutive_character (pp, '>');
  93 }
  94
  95 void
  96 pp_cxx_separate_with (cxx_pretty_printer *pp, int c)
  97 {
  98   pp_separate_with (pp, c);
  99   pp_base (pp)->padding = pp_none;
 100 }
 101
 102 /* Expressions.  */
 103
 104 static inline bool
 105 is_destructor_name (tree name)
 106 {
 107   return name == complete_dtor_identifier
 108     || name == base_dtor_identifier
 109     || name == deleting_dtor_identifier;
 110 }
 111
 112 /* conversion-function-id:
 113       operator conversion-type-id
 114
 115    conversion-type-id:
 116       type-specifier-seq conversion-declarator(opt)
 117
 118    conversion-declarator:
 119       ptr-operator conversion-declarator(opt)  */
 120
 121 static inline void
 122 pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
 123 {
 124   pp_cxx_ws_string (pp, "operator");
 125   pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
 126 }
 127
 128 static inline void
 129 pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
 130 {
 131   pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
 132   pp_cxx_begin_template_argument_list (pp);
 133   pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1));
 134   pp_cxx_end_template_argument_list (pp);
 135 }
 136
 137 /* Prints the unqualified part of the id-expression T.
 138
 139    unqualified-id:
 140      identifier
 141      operator-function-id
 142      conversion-function-id
 143      ~ class-name
 144      template-id  */
 145
 146 static void
 147 pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
 148 {
 149   enum tree_code code = TREE_CODE (t);
 150   switch (code)
 151     {
 152     case RESULT_DECL:
 153       pp_cxx_ws_string (pp, M_("<return-value>"));
 154       break;
 155
 156     case OVERLOAD:
 157       t = OVL_CURRENT (t);
 158     case VAR_DECL:
 159     case PARM_DECL:
 160     case CONST_DECL:
 161     case TYPE_DECL:
 162     case FUNCTION_DECL:
 163     case NAMESPACE_DECL:
 164     case FIELD_DECL:
 165     case LABEL_DECL:
 166     case USING_DECL:
 167     case TEMPLATE_DECL:
 168       t = DECL_NAME (t);
 169
 170     case IDENTIFIER_NODE:
 171       if (t == NULL)
 172         pp_cxx_ws_string (pp, M_("<unnamed>"));
 173       else if (IDENTIFIER_TYPENAME_P (t))
 174         pp_cxx_conversion_function_id (pp, t);
 175       else
 176         {
 177           if (is_destructor_name (t))
 178             {
 179               pp_complement (pp);
 180               /* FIXME: Why is this necessary? */
 181               if (TREE_TYPE (t))
 182                 t = constructor_name (TREE_TYPE (t));
 183             }
 184           pp_cxx_tree_identifier (pp, t);
 185         }
 186       break;
 187
 188     case TEMPLATE_ID_EXPR:
 189       pp_cxx_template_id (pp, t);
 190       break;
 191
 192     case BASELINK:
 193       pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
 194       break;
 195
 196     case RECORD_TYPE:
 197     case UNION_TYPE:
 198     case ENUMERAL_TYPE:
 199     case TYPENAME_TYPE:
 200     case UNBOUND_CLASS_TEMPLATE:
 201       pp_cxx_unqualified_id (pp, TYPE_NAME (t));
 202       if (CLASS_TYPE_P (t) && CLASSTYPE_USE_TEMPLATE (t))
 203         {
 204           pp_cxx_begin_template_argument_list (pp);
 205           pp_cxx_template_argument_list (pp, INNERMOST_TEMPLATE_ARGS
 206                                                  (CLASSTYPE_TI_ARGS (t)));
 207           pp_cxx_end_template_argument_list (pp);
 208         }
 209       break;
 210
 211     case BIT_NOT_EXPR:
 212       pp_cxx_complement (pp);
 213       pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
 214       break;
 215
 216     case TEMPLATE_TYPE_PARM:
 217     case TEMPLATE_TEMPLATE_PARM:
 218       if (TYPE_IDENTIFIER (t))
 219         pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
 220       else
 221         pp_cxx_canonical_template_parameter (pp, t);
 222       break;
 223
 224     case TEMPLATE_PARM_INDEX:
 225       pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
 226       break;
 227
 228     case BOUND_TEMPLATE_TEMPLATE_PARM:
 229       pp_cxx_cv_qualifier_seq (pp, t);
 230       pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
 231       pp_cxx_begin_template_argument_list (pp);
 232       pp_cxx_template_argument_list (pp, TYPE_TI_ARGS (t));
 233       pp_cxx_end_template_argument_list (pp);
 234       break;
 235
 236     default:
 237       pp_unsupported_tree (pp, t);
 238       break;
 239     }
 240 }
 241
 242 /* Pretty-print out the token sequence ":: template" in template codes
 243    where it is needed to "inline declare" the (following) member as
 244    a template.  This situation arises when SCOPE of T is dependent
 245    on template parameters.  */
 246
 247 static inline void
 248 pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
 249 {
 250   if (TREE_CODE (t) == TEMPLATE_ID_EXPR
 251       && TYPE_P (scope) && dependent_type_p (scope))
 252     pp_cxx_ws_string (pp, "template");
 253 }
 254
 255 /* nested-name-specifier:
 256       class-or-namespace-name :: nested-name-specifier(opt)
 257       class-or-namespace-name :: template nested-name-specifier   */
 258
 259 static void
 260 pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
 261 {
 262   if (!SCOPE_FILE_SCOPE_P (t) && t != pp->enclosing_scope)
 263     {
 264       tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
 265       pp_cxx_nested_name_specifier (pp, scope);
 266       pp_cxx_template_keyword_if_needed (pp, scope, t);
 267       pp_cxx_unqualified_id (pp, t);
 268       pp_cxx_colon_colon (pp);
 269     }
 270 }
 271
 272 /* qualified-id:
 273       nested-name-specifier template(opt) unqualified-id  */
 274
 275 static void
 276 pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
 277 {
 278   switch (TREE_CODE (t))
 279     {
 280       /* A pointer-to-member is always qualified.  */
 281     case PTRMEM_CST:
 282       pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
 283       pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
 284       break;
 285
 286       /* In Standard C++, functions cannot possibly be used as
 287          nested-name-specifiers.  However, there are situations where
 288          is "makes sense" to output the surrounding function name for the
 289          purpose of emphasizing on the scope kind.  Just printing the
 290          function name might not be sufficient as it may be overloaded; so,
 291          we decorate the function with its signature too.
 292          FIXME:  This is probably the wrong pretty-printing for conversion
 293          functions and some function templates.  */
 294     case OVERLOAD:
 295       t = OVL_CURRENT (t);
 296     case FUNCTION_DECL:
 297       if (DECL_FUNCTION_MEMBER_P (t))
 298         pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
 299       pp_cxx_unqualified_id
 300         (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
 301       pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
 302       break;
 303
 304     case OFFSET_REF:
 305     case SCOPE_REF:
 306       pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
 307       pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
 308       break;
 309
 310     default:
 311       {
 312         tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
 313         if (scope != pp->enclosing_scope)
 314           {
 315             pp_cxx_nested_name_specifier (pp, scope);
 316             pp_cxx_template_keyword_if_needed (pp, scope, t);
 317           }
 318         pp_cxx_unqualified_id (pp, t);
 319       }
 320       break;
 321     }
 322 }
 323
 324
 325 static void
 326 pp_cxx_constant (cxx_pretty_printer *pp, tree t)
 327 {
 328   switch (TREE_CODE (t))
 329     {
 330     case STRING_CST:
 331       {
 332         const bool in_parens = PAREN_STRING_LITERAL_P (t);
 333         if (in_parens)
 334           pp_cxx_left_paren (pp);
 335         pp_c_constant (pp_c_base (pp), t);
 336         if (in_parens)
 337           pp_cxx_right_paren (pp);
 338       }
 339       break;
 340
 341     case INTEGER_CST:
 342       if (NULLPTR_TYPE_P (TREE_TYPE (t)))
 343         {
 344           pp_string (pp, "nullptr");
 345           break;
 346         }
 347       /* else fall through.  */
 348
 349     default:
 350       pp_c_constant (pp_c_base (pp), t);
 351       break;
 352     }
 353 }
 354
 355 /* id-expression:
 356       unqualified-id
 357       qualified-id   */
 358
 359 static inline void
 360 pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
 361 {
 362   if (TREE_CODE (t) == OVERLOAD)
 363     t = OVL_CURRENT (t);
 364   if (DECL_P (t) && DECL_CONTEXT (t))
 365     pp_cxx_qualified_id (pp, t);
 366   else
 367     pp_cxx_unqualified_id (pp, t);
 368 }
 369
 370 /* user-defined literal:
 371       literal ud-suffix  */
 372
 373 void
 374 pp_cxx_userdef_literal (cxx_pretty_printer *pp, tree t)
 375 {
 376   pp_cxx_constant (pp, USERDEF_LITERAL_VALUE (t));
 377   pp_cxx_id_expression (pp, USERDEF_LITERAL_SUFFIX_ID (t));
 378 }
 379
 380
 381 /* primary-expression:
 382      literal
 383      this
 384      :: identifier
 385      :: operator-function-id
 386      :: qualifier-id
 387      ( expression )
 388      id-expression
 389
 390    GNU Extensions:
 391      __builtin_va_arg ( assignment-expression , type-id )
 392      __builtin_offsetof ( type-id, offsetof-expression )
 393
 394      __has_nothrow_assign ( type-id )
 395      __has_nothrow_constructor ( type-id )
 396      __has_nothrow_copy ( type-id )
 397      __has_trivial_assign ( type-id )
 398      __has_trivial_constructor ( type-id )
 399      __has_trivial_copy ( type-id )
 400      __has_trivial_destructor ( type-id )
 401      __has_virtual_destructor ( type-id )
 402      __is_abstract ( type-id )
 403      __is_base_of ( type-id , type-id )
 404      __is_class ( type-id )
 405      __is_convertible_to ( type-id , type-id )
 406      __is_empty ( type-id )
 407      __is_enum ( type-id )
 408      __is_literal_type ( type-id )
 409      __is_pod ( type-id )
 410      __is_polymorphic ( type-id )
 411      __is_std_layout ( type-id )
 412      __is_trivial ( type-id )
 413      __is_union ( type-id )  */
 414
 415 static void
 416 pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
 417 {
 418   switch (TREE_CODE (t))
 419     {
 420     case INTEGER_CST:
 421     case REAL_CST:
 422     case COMPLEX_CST:
 423     case STRING_CST:
 424       pp_cxx_constant (pp, t);
 425       break;
 426
 427     case USERDEF_LITERAL:
 428       pp_cxx_userdef_literal (pp, t);
 429       break;
 430
 431     case BASELINK:
 432       t = BASELINK_FUNCTIONS (t);
 433     case VAR_DECL:
 434     case PARM_DECL:
 435     case FIELD_DECL:
 436     case FUNCTION_DECL:
 437     case OVERLOAD:
 438     case CONST_DECL:
 439     case TEMPLATE_DECL:
 440       pp_cxx_id_expression (pp, t);
 441       break;
 442
 443     case RESULT_DECL:
 444     case TEMPLATE_TYPE_PARM:
 445     case TEMPLATE_TEMPLATE_PARM:
 446     case TEMPLATE_PARM_INDEX:
 447       pp_cxx_unqualified_id (pp, t);
 448       break;
 449
 450     case STMT_EXPR:
 451       pp_cxx_left_paren (pp);
 452       pp_cxx_statement (pp, STMT_EXPR_STMT (t));
 453       pp_cxx_right_paren (pp);
 454       break;
 455
 456     case TRAIT_EXPR:
 457       pp_cxx_trait_expression (pp, t);
 458       break;
 459
 460     case VA_ARG_EXPR:
 461       pp_cxx_va_arg_expression (pp, t);
 462       break;
 463
 464     case OFFSETOF_EXPR:
 465       pp_cxx_offsetof_expression (pp, t);
 466       break;
 467
 468     default:
 469       pp_c_primary_expression (pp_c_base (pp), t);
 470       break;
 471     }
 472 }
 473
 474 /* postfix-expression:
 475      primary-expression
 476      postfix-expression [ expression ]
 477      postfix-expression ( expression-list(opt) )
 478      simple-type-specifier ( expression-list(opt) )
 479      typename ::(opt) nested-name-specifier identifier ( expression-list(opt) )
 480      typename ::(opt) nested-name-specifier template(opt)
 481                                        template-id ( expression-list(opt) )
 482      postfix-expression . template(opt) ::(opt) id-expression
 483      postfix-expression -> template(opt) ::(opt) id-expression
 484      postfix-expression . pseudo-destructor-name
 485      postfix-expression -> pseudo-destructor-name
 486      postfix-expression ++
 487      postfix-expression --
 488      dynamic_cast < type-id > ( expression )
 489      static_cast < type-id > ( expression )
 490      reinterpret_cast < type-id > ( expression )
 491      const_cast < type-id > ( expression )
 492      typeid ( expression )
 493      typeid ( type-id )  */
 494
 495 static void
 496 pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
 497 {
 498   enum tree_code code = TREE_CODE (t);
 499
 500   switch (code)
 501     {
 502     case AGGR_INIT_EXPR:
 503     case CALL_EXPR:
 504       {
 505         tree fun = (code == AGGR_INIT_EXPR ? AGGR_INIT_EXPR_FN (t)
 506                                            : CALL_EXPR_FN (t));
 507         tree saved_scope = pp->enclosing_scope;
 508         bool skipfirst = false;
 509         tree arg;
 510
 511         if (TREE_CODE (fun) == ADDR_EXPR)
 512           fun = TREE_OPERAND (fun, 0);
 513
 514         /* In templates, where there is no way to tell whether a given
 515            call uses an actual member function.  So the parser builds
 516            FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until
 517            instantiation time.  */
 518         if (TREE_CODE (fun) != FUNCTION_DECL)
 519           ;
 520         else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun))
 521           {
 522             tree object = (code == AGGR_INIT_EXPR
 523                            ? (AGGR_INIT_VIA_CTOR_P (t)
 524                               ? AGGR_INIT_EXPR_SLOT (t)
 525                               : AGGR_INIT_EXPR_ARG (t, 0))
 526                            : CALL_EXPR_ARG (t, 0));
 527
 528             while (TREE_CODE (object) == NOP_EXPR)
 529               object = TREE_OPERAND (object, 0);
 530
 531             if (TREE_CODE (object) == ADDR_EXPR)
 532               object = TREE_OPERAND (object, 0);
 533
 534             if (TREE_CODE (TREE_TYPE (object)) != POINTER_TYPE)
 535               {
 536                 pp_cxx_postfix_expression (pp, object);
 537                 pp_cxx_dot (pp);
 538               }
 539             else
 540               {
 541                 pp_cxx_postfix_expression (pp, object);
 542                 pp_cxx_arrow (pp);
 543               }
 544             skipfirst = true;
 545             pp->enclosing_scope = strip_pointer_operator (TREE_TYPE (object));
 546           }
 547
 548         pp_cxx_postfix_expression (pp, fun);
 549         pp->enclosing_scope = saved_scope;
 550         pp_cxx_left_paren (pp);
 551         if (code == AGGR_INIT_EXPR)
 552           {
 553             aggr_init_expr_arg_iterator iter;
 554             FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
 555               {
 556                 if (skipfirst)
 557                   skipfirst = false;
 558                 else
 559                   {
 560                     pp_cxx_expression (pp, arg);
 561                     if (more_aggr_init_expr_args_p (&iter))
 562                       pp_cxx_separate_with (pp, ',');
 563                   }
 564               }
 565           }
 566         else
 567           {
 568             call_expr_arg_iterator iter;
 569             FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
 570               {
 571                 if (skipfirst)
 572                   skipfirst = false;
 573                 else
 574                   {
 575                     pp_cxx_expression (pp, arg);
 576                     if (more_call_expr_args_p (&iter))
 577                       pp_cxx_separate_with (pp, ',');
 578                   }
 579               }
 580           }
 581         pp_cxx_right_paren (pp);
 582       }
 583       if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
 584         {
 585           pp_cxx_separate_with (pp, ',');
 586           pp_cxx_postfix_expression (pp, AGGR_INIT_EXPR_SLOT (t));
 587         }
 588       break;
 589
 590     case BASELINK:
 591     case VAR_DECL:
 592     case PARM_DECL:
 593     case FIELD_DECL:
 594     case FUNCTION_DECL:
 595     case OVERLOAD:
 596     case CONST_DECL:
 597     case TEMPLATE_DECL:
 598     case RESULT_DECL:
 599       pp_cxx_primary_expression (pp, t);
 600       break;
 601
 602     case DYNAMIC_CAST_EXPR:
 603     case STATIC_CAST_EXPR:
 604     case REINTERPRET_CAST_EXPR:
 605     case CONST_CAST_EXPR:
 606       if (code == DYNAMIC_CAST_EXPR)
 607         pp_cxx_ws_string (pp, "dynamic_cast");
 608       else if (code == STATIC_CAST_EXPR)
 609         pp_cxx_ws_string (pp, "static_cast");
 610       else if (code == REINTERPRET_CAST_EXPR)
 611         pp_cxx_ws_string (pp, "reinterpret_cast");
 612       else
 613         pp_cxx_ws_string (pp, "const_cast");
 614       pp_cxx_begin_template_argument_list (pp);
 615       pp_cxx_type_id (pp, TREE_TYPE (t));
 616       pp_cxx_end_template_argument_list (pp);
 617       pp_left_paren (pp);
 618       pp_cxx_expression (pp, TREE_OPERAND (t, 0));
 619       pp_right_paren (pp);
 620       break;
 621
 622     case EMPTY_CLASS_EXPR:
 623       pp_cxx_type_id (pp, TREE_TYPE (t));
 624       pp_left_paren (pp);
 625       pp_right_paren (pp);
 626       break;
 627
 628     case TYPEID_EXPR:
 629       pp_cxx_typeid_expression (pp, t);
 630       break;
 631
 632     case PSEUDO_DTOR_EXPR:
 633       pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
 634       pp_cxx_dot (pp);
 635       pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1));
 636       pp_cxx_colon_colon (pp);
 637       pp_complement (pp);
 638       pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2));
 639       break;
 640
 641     case ARROW_EXPR:
 642       pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
 643       pp_cxx_arrow (pp);
 644       break;
 645
 646     default:
 647       pp_c_postfix_expression (pp_c_base (pp), t);
 648       break;
 649     }
 650 }
 651
 652 /* new-expression:
 653       ::(opt) new new-placement(opt) new-type-id new-initializer(opt)
 654       ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt)
 655
 656    new-placement:
 657       ( expression-list )
 658
 659    new-type-id:
 660       type-specifier-seq new-declarator(opt)
 661
 662    new-declarator:
 663       ptr-operator new-declarator(opt)
 664       direct-new-declarator
 665
 666    direct-new-declarator
 667       [ expression ]
 668       direct-new-declarator [ constant-expression ]
 669
 670    new-initializer:
 671       ( expression-list(opt) )  */
 672
 673 static void
 674 pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
 675 {
 676   enum tree_code code = TREE_CODE (t);
 677   tree type = TREE_OPERAND (t, 1);
 678   tree init = TREE_OPERAND (t, 2);
 679   switch (code)
 680     {
 681     case NEW_EXPR:
 682     case VEC_NEW_EXPR:
 683       if (NEW_EXPR_USE_GLOBAL (t))
 684         pp_cxx_colon_colon (pp);
 685       pp_cxx_ws_string (pp, "new");
 686       if (TREE_OPERAND (t, 0))
 687         {
 688           pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
 689           pp_space (pp);
 690         }
 691       if (TREE_CODE (type) == ARRAY_REF)
 692         type = build_cplus_array_type
 693           (TREE_OPERAND (type, 0),
 694            build_index_type (fold_build2_loc (input_location,
 695                                           MINUS_EXPR, integer_type_node,
 696                                           TREE_OPERAND (type, 1),
 697                                           integer_one_node)));
 698       pp_cxx_type_id (pp, type);
 699       if (init)
 700         {
 701           pp_left_paren (pp);
 702           if (TREE_CODE (init) == TREE_LIST)
 703             pp_c_expression_list (pp_c_base (pp), init);
 704           else if (init == void_zero_node)
 705             ;                   /* OK, empty initializer list.  */
 706           else
 707             pp_cxx_expression (pp, init);
 708           pp_right_paren (pp);
 709         }
 710       break;
 711
 712     default:
 713       pp_unsupported_tree (pp, t);
 714     }
 715 }
 716
 717 /* delete-expression:
 718       ::(opt) delete cast-expression
 719       ::(opt) delete [ ] cast-expression   */
 720
 721 static void
 722 pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
 723 {
 724   enum tree_code code = TREE_CODE (t);
 725   switch (code)
 726     {
 727     case DELETE_EXPR:
 728     case VEC_DELETE_EXPR:
 729       if (DELETE_EXPR_USE_GLOBAL (t))
 730         pp_cxx_colon_colon (pp);
 731       pp_cxx_ws_string (pp, "delete");
 732       pp_space (pp);
 733       if (code == VEC_DELETE_EXPR
 734           || DELETE_EXPR_USE_VEC (t))
 735         {
 736           pp_left_bracket (pp);
 737           pp_right_bracket (pp);
 738           pp_space (pp);
 739         }
 740       pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 0));
 741       break;
 742
 743     default:
 744       pp_unsupported_tree (pp, t);
 745     }
 746 }
 747
 748 /* unary-expression:
 749       postfix-expression
 750       ++ cast-expression
 751       -- cast-expression
 752       unary-operator cast-expression
 753       sizeof unary-expression
 754       sizeof ( type-id )
 755       sizeof ... ( identifier )
 756       new-expression
 757       delete-expression
 758
 759    unary-operator: one of
 760       *   &   +   -  !
 761
 762    GNU extensions:
 763       __alignof__ unary-expression
 764       __alignof__ ( type-id )  */
 765
 766 static void
 767 pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
 768 {
 769   enum tree_code code = TREE_CODE (t);
 770   switch (code)
 771     {
 772     case NEW_EXPR:
 773     case VEC_NEW_EXPR:
 774       pp_cxx_new_expression (pp, t);
 775       break;
 776
 777     case DELETE_EXPR:
 778     case VEC_DELETE_EXPR:
 779       pp_cxx_delete_expression (pp, t);
 780       break;
 781
 782     case SIZEOF_EXPR:
 783       if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
 784         {
 785           pp_cxx_ws_string (pp, "sizeof");
 786           pp_cxx_ws_string (pp, "...");
 787           pp_cxx_whitespace (pp);
 788           pp_cxx_left_paren (pp);
 789           if (TYPE_P (TREE_OPERAND (t, 0)))
 790             pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
 791           else
 792             pp_unary_expression (pp, TREE_OPERAND (t, 0));
 793           pp_cxx_right_paren (pp);
 794           break;
 795         }
 796       /* Fall through  */
 797
 798     case ALIGNOF_EXPR:
 799       pp_cxx_ws_string (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
 800       pp_cxx_whitespace (pp);
 801       if (TYPE_P (TREE_OPERAND (t, 0)))
 802         {
 803           pp_cxx_left_paren (pp);
 804           pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
 805           pp_cxx_right_paren (pp);
 806         }
 807       else
 808         pp_unary_expression (pp, TREE_OPERAND (t, 0));
 809       break;
 810
 811     case AT_ENCODE_EXPR:
 812       pp_cxx_ws_string (pp, "@encode");
 813       pp_cxx_whitespace (pp);
 814       pp_cxx_left_paren (pp);
 815       pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
 816       pp_cxx_right_paren (pp);
 817       break;
 818
 819     case NOEXCEPT_EXPR:
 820       pp_cxx_ws_string (pp, "noexcept");
 821       pp_cxx_whitespace (pp);
 822       pp_cxx_left_paren (pp);
 823       pp_cxx_expression (pp, TREE_OPERAND (t, 0));
 824       pp_cxx_right_paren (pp);
 825       break;
 826
 827     case UNARY_PLUS_EXPR:
 828       pp_plus (pp);
 829       pp_cxx_cast_expression (pp, TREE_OPERAND (t, 0));
 830       break;
 831
 832     default:
 833       pp_c_unary_expression (pp_c_base (pp), t);
 834       break;
 835     }
 836 }
 837
 838 /* cast-expression:
 839       unary-expression
 840       ( type-id ) cast-expression  */
 841
 842 static void
 843 pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
 844 {
 845   switch (TREE_CODE (t))
 846     {
 847     case CAST_EXPR:
 848     case IMPLICIT_CONV_EXPR:
 849       pp_cxx_type_id (pp, TREE_TYPE (t));
 850       pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
 851       break;
 852
 853     default:
 854       pp_c_cast_expression (pp_c_base (pp), t);
 855       break;
 856     }
 857 }
 858
 859 /* pm-expression:
 860       cast-expression
 861       pm-expression .* cast-expression
 862       pm-expression ->* cast-expression  */
 863
 864 static void
 865 pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
 866 {
 867   switch (TREE_CODE (t))
 868     {
 869       /* Handle unfortunate OFFSET_REF overloading here.  */
 870     case OFFSET_REF:
 871       if (TYPE_P (TREE_OPERAND (t, 0)))
 872         {
 873           pp_cxx_qualified_id (pp, t);
 874           break;
 875         }
 876       /* Else fall through.  */
 877     case MEMBER_REF:
 878     case DOTSTAR_EXPR:
 879       pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
 880       if (TREE_CODE (t) == MEMBER_REF)
 881         pp_cxx_arrow (pp);
 882       else
 883         pp_cxx_dot (pp);
 884       pp_star(pp);
 885       pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
 886       break;
 887
 888
 889     default:
 890       pp_cxx_cast_expression (pp, t);
 891       break;
 892     }
 893 }
 894
 895 /* multiplicative-expression:
 896       pm-expression
 897       multiplicative-expression * pm-expression
 898       multiplicative-expression / pm-expression
 899       multiplicative-expression % pm-expression  */
 900
 901 static void
 902 pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
 903 {
 904   enum tree_code code = TREE_CODE (e);
 905   switch (code)
 906     {
 907     case MULT_EXPR:
 908     case TRUNC_DIV_EXPR:
 909     case TRUNC_MOD_EXPR:
 910       pp_cxx_multiplicative_expression (pp, TREE_OPERAND (e, 0));
 911       pp_space (pp);
 912       if (code == MULT_EXPR)
 913         pp_star (pp);
 914       else if (code == TRUNC_DIV_EXPR)
 915         pp_slash (pp);
 916       else
 917         pp_modulo (pp);
 918       pp_space (pp);
 919       pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1));
 920       break;
 921
 922     default:
 923       pp_cxx_pm_expression (pp, e);
 924       break;
 925     }
 926 }
 927
 928 /* conditional-expression:
 929       logical-or-expression
 930       logical-or-expression ?  expression  : assignment-expression  */
 931
 932 static void
 933 pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
 934 {
 935   if (TREE_CODE (e) == COND_EXPR)
 936     {
 937       pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
 938       pp_space (pp);
 939       pp_question (pp);
 940       pp_space (pp);
 941       pp_cxx_expression (pp, TREE_OPERAND (e, 1));
 942       pp_space (pp);
 943       pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
 944     }
 945   else
 946     pp_c_logical_or_expression (pp_c_base (pp), e);
 947 }
 948
 949 /* Pretty-print a compound assignment operator token as indicated by T.  */
 950
 951 static void
 952 pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
 953 {
 954   const char *op;
 955
 956   switch (TREE_CODE (t))
 957     {
 958     case NOP_EXPR:
 959       op = "=";
 960       break;
 961
 962     case PLUS_EXPR:
 963       op = "+=";
 964       break;
 965
 966     case MINUS_EXPR:
 967       op = "-=";
 968       break;
 969
 970     case TRUNC_DIV_EXPR:
 971       op = "/=";
 972       break;
 973
 974     case TRUNC_MOD_EXPR:
 975       op = "%=";
 976       break;
 977
 978     default:
 979       op = tree_code_name[TREE_CODE (t)];
 980       break;
 981     }
 982
 983   pp_cxx_ws_string (pp, op);
 984 }
 985
 986
 987 /* assignment-expression:
 988       conditional-expression
 989       logical-or-expression assignment-operator assignment-expression
 990       throw-expression
 991
 992    throw-expression:
 993        throw assignment-expression(opt)
 994
 995    assignment-operator: one of
 996       =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
 997
 998 static void
 999 pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
1000 {
1001   switch (TREE_CODE (e))
1002     {
1003     case MODIFY_EXPR:
1004     case INIT_EXPR:
1005       pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
1006       pp_space (pp);
1007       pp_equal (pp);
1008       pp_space (pp);
1009       pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1));
1010       break;
1011
1012     case THROW_EXPR:
1013       pp_cxx_ws_string (pp, "throw");
1014       if (TREE_OPERAND (e, 0))
1015         pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
1016       break;
1017
1018     case MODOP_EXPR:
1019       pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
1020       pp_cxx_assignment_operator (pp, TREE_OPERAND (e, 1));
1021       pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
1022       break;
1023
1024     default:
1025       pp_cxx_conditional_expression (pp, e);
1026       break;
1027     }
1028 }
1029
1030 static void
1031 pp_cxx_expression (cxx_pretty_printer *pp, tree t)
1032 {
1033   switch (TREE_CODE (t))
1034     {
1035     case STRING_CST:
1036     case INTEGER_CST:
1037     case REAL_CST:
1038     case COMPLEX_CST:
1039       pp_cxx_constant (pp, t);
1040       break;
1041
1042     case USERDEF_LITERAL:
1043       pp_cxx_userdef_literal (pp, t);
1044       break;
1045
1046     case RESULT_DECL:
1047       pp_cxx_unqualified_id (pp, t);
1048       break;
1049
1050 #if 0
1051     case OFFSET_REF:
1052 #endif
1053     case SCOPE_REF:
1054     case PTRMEM_CST:
1055       pp_cxx_qualified_id (pp, t);
1056       break;
1057
1058     case OVERLOAD:
1059       t = OVL_CURRENT (t);
1060     case VAR_DECL:
1061     case PARM_DECL:
1062     case FIELD_DECL:
1063     case CONST_DECL:
1064     case FUNCTION_DECL:
1065     case BASELINK:
1066     case TEMPLATE_DECL:
1067     case TEMPLATE_TYPE_PARM:
1068     case TEMPLATE_PARM_INDEX:
1069     case TEMPLATE_TEMPLATE_PARM:
1070     case STMT_EXPR:
1071       pp_cxx_primary_expression (pp, t);
1072       break;
1073
1074     case CALL_EXPR:
1075     case DYNAMIC_CAST_EXPR:
1076     case STATIC_CAST_EXPR:
1077     case REINTERPRET_CAST_EXPR:
1078     case CONST_CAST_EXPR:
1079 #if 0
1080     case MEMBER_REF:
1081 #endif
1082     case EMPTY_CLASS_EXPR:
1083     case TYPEID_EXPR:
1084     case PSEUDO_DTOR_EXPR:
1085     case AGGR_INIT_EXPR:
1086     case ARROW_EXPR:
1087       pp_cxx_postfix_expression (pp, t);
1088       break;
1089
1090     case NEW_EXPR:
1091     case VEC_NEW_EXPR:
1092       pp_cxx_new_expression (pp, t);
1093       break;
1094
1095     case DELETE_EXPR:
1096     case VEC_DELETE_EXPR:
1097       pp_cxx_delete_expression (pp, t);
1098       break;
1099
1100     case SIZEOF_EXPR:
1101     case ALIGNOF_EXPR:
1102     case NOEXCEPT_EXPR:
1103       pp_cxx_unary_expression (pp, t);
1104       break;
1105
1106     case CAST_EXPR:
1107     case IMPLICIT_CONV_EXPR:
1108       pp_cxx_cast_expression (pp, t);
1109       break;
1110
1111     case OFFSET_REF:
1112     case MEMBER_REF:
1113     case DOTSTAR_EXPR:
1114       pp_cxx_pm_expression (pp, t);
1115       break;
1116
1117     case MULT_EXPR:
1118     case TRUNC_DIV_EXPR:
1119     case TRUNC_MOD_EXPR:
1120       pp_cxx_multiplicative_expression (pp, t);
1121       break;
1122
1123     case COND_EXPR:
1124       pp_cxx_conditional_expression (pp, t);
1125       break;
1126
1127     case MODIFY_EXPR:
1128     case INIT_EXPR:
1129     case THROW_EXPR:
1130     case MODOP_EXPR:
1131       pp_cxx_assignment_expression (pp, t);
1132       break;
1133
1134     case NON_DEPENDENT_EXPR:
1135     case MUST_NOT_THROW_EXPR:
1136       pp_cxx_expression (pp, TREE_OPERAND (t, 0));
1137       break;
1138
1139     case EXPR_PACK_EXPANSION:
1140       pp_cxx_expression (pp, PACK_EXPANSION_PATTERN (t));
1141       pp_cxx_ws_string (pp, "...");
1142       break;
1143
1144     case TEMPLATE_ID_EXPR:
1145       pp_cxx_template_id (pp, t);
1146       break;
1147
1148     case NONTYPE_ARGUMENT_PACK:
1149       {
1150         tree args = ARGUMENT_PACK_ARGS (t);
1151         int i, len = TREE_VEC_LENGTH (args);
1152         for (i = 0; i < len; ++i)
1153           {
1154             if (i > 0)
1155               pp_cxx_separate_with (pp, ',');
1156             pp_cxx_expression (pp, TREE_VEC_ELT (args, i));
1157           }
1158       }
1159       break;
1160
1161     default:
1162       pp_c_expression (pp_c_base (pp), t);
1163       break;
1164     }
1165 }
1166
1167
1168 /* Declarations.  */
1169
1170 /* function-specifier:
1171       inline
1172       virtual
1173       explicit   */
1174
1175 static void
1176 pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
1177 {
1178   switch (TREE_CODE (t))
1179     {
1180     case FUNCTION_DECL:
1181       if (DECL_VIRTUAL_P (t))
1182         pp_cxx_ws_string (pp, "virtual");
1183       else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
1184         pp_cxx_ws_string (pp, "explicit");
1185       else
1186         pp_c_function_specifier (pp_c_base (pp), t);
1187
1188     default:
1189       break;
1190     }
1191 }
1192
1193 /* decl-specifier-seq:
1194       decl-specifier-seq(opt) decl-specifier
1195
1196    decl-specifier:
1197       storage-class-specifier
1198       type-specifier
1199       function-specifier
1200       friend
1201       typedef  */
1202
1203 static void
1204 pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
1205 {
1206   switch (TREE_CODE (t))
1207     {
1208     case VAR_DECL:
1209     case PARM_DECL:
1210     case CONST_DECL:
1211     case FIELD_DECL:
1212       pp_cxx_storage_class_specifier (pp, t);
1213       pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1214       break;
1215
1216     case TYPE_DECL:
1217       pp_cxx_ws_string (pp, "typedef");
1218       pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1219       break;
1220
1221     case FUNCTION_DECL:
1222       /* Constructors don't have return types.  And conversion functions
1223          do not have a type-specifier in their return types.  */
1224       if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
1225         pp_cxx_function_specifier (pp, t);
1226       else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1227         pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (t)));
1228       else
1229         default:
1230       pp_c_declaration_specifiers (pp_c_base (pp), t);
1231       break;
1232     }
1233 }
1234
1235 /* simple-type-specifier:
1236       ::(opt) nested-name-specifier(opt) type-name
1237       ::(opt) nested-name-specifier(opt) template(opt) template-id
1238       char
1239       wchar_t
1240       bool
1241       short
1242       int
1243       long
1244       signed
1245       unsigned
1246       float
1247       double
1248       void  */
1249
1250 static void
1251 pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
1252 {
1253   switch (TREE_CODE (t))
1254     {
1255     case RECORD_TYPE:
1256     case UNION_TYPE:
1257     case ENUMERAL_TYPE:
1258       pp_cxx_qualified_id (pp, t);
1259       break;
1260
1261     case TEMPLATE_TYPE_PARM:
1262     case TEMPLATE_TEMPLATE_PARM:
1263     case TEMPLATE_PARM_INDEX:
1264       pp_cxx_unqualified_id (pp, t);
1265       break;
1266
1267     case TYPENAME_TYPE:
1268       pp_cxx_ws_string (pp, "typename");
1269       pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
1270       pp_cxx_unqualified_id (pp, TYPE_NAME (t));
1271       break;
1272
1273     default:
1274       pp_c_type_specifier (pp_c_base (pp), t);
1275       break;
1276     }
1277 }
1278
1279 /* type-specifier-seq:
1280       type-specifier type-specifier-seq(opt)
1281
1282    type-specifier:
1283       simple-type-specifier
1284       class-specifier
1285       enum-specifier
1286       elaborated-type-specifier
1287       cv-qualifier   */
1288
1289 static void
1290 pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
1291 {
1292   switch (TREE_CODE (t))
1293     {
1294     case TEMPLATE_DECL:
1295     case TEMPLATE_TYPE_PARM:
1296     case TEMPLATE_TEMPLATE_PARM:
1297     case TYPE_DECL:
1298     case BOUND_TEMPLATE_TEMPLATE_PARM:
1299       pp_cxx_cv_qualifier_seq (pp, t);
1300       pp_cxx_simple_type_specifier (pp, t);
1301       break;
1302
1303     case METHOD_TYPE:
1304       pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
1305       pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1306       pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
1307       break;
1308
1309     case DECLTYPE_TYPE:
1310       pp_cxx_ws_string (pp, "decltype");
1311       pp_cxx_left_paren (pp);
1312       pp_cxx_expression (pp, DECLTYPE_TYPE_EXPR (t));
1313       pp_cxx_right_paren (pp);
1314       break;
1315
1316     case RECORD_TYPE:
1317       if (TYPE_PTRMEMFUNC_P (t))
1318         {
1319           tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
1320           pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (pfm)));
1321           pp_cxx_whitespace (pp);
1322           pp_cxx_ptr_operator (pp, t);
1323           break;
1324         }
1325       /* else fall through */
1326
1327     default:
1328       if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
1329         pp_c_specifier_qualifier_list (pp_c_base (pp), t);
1330     }
1331 }
1332
1333 /* ptr-operator:
1334       * cv-qualifier-seq(opt)
1335       &
1336       ::(opt) nested-name-specifier * cv-qualifier-seq(opt)  */
1337
1338 static void
1339 pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
1340 {
1341   if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
1342     t = TREE_TYPE (t);
1343   switch (TREE_CODE (t))
1344     {
1345     case REFERENCE_TYPE:
1346     case POINTER_TYPE:
1347       if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
1348           || TYPE_PTR_TO_MEMBER_P (TREE_TYPE (t)))
1349         pp_cxx_ptr_operator (pp, TREE_TYPE (t));
1350       pp_c_attributes_display (pp_c_base (pp),
1351                                TYPE_ATTRIBUTES (TREE_TYPE (t)));
1352       if (TREE_CODE (t) == POINTER_TYPE)
1353         {
1354           pp_star (pp);
1355           pp_cxx_cv_qualifier_seq (pp, t);
1356         }
1357       else
1358         pp_ampersand (pp);
1359       break;
1360
1361     case RECORD_TYPE:
1362       if (TYPE_PTRMEMFUNC_P (t))
1363         {
1364           pp_cxx_left_paren (pp);
1365           pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
1366           pp_star (pp);
1367           break;
1368         }
1369     case OFFSET_TYPE:
1370       if (TYPE_PTR_TO_MEMBER_P (t))
1371         {
1372           if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1373             pp_cxx_left_paren (pp);
1374           pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
1375           pp_star (pp);
1376           pp_cxx_cv_qualifier_seq (pp, t);
1377           break;
1378         }
1379       /* else fall through.  */
1380
1381     default:
1382       pp_unsupported_tree (pp, t);
1383       break;
1384     }
1385 }
1386
1387 static inline tree
1388 pp_cxx_implicit_parameter_type (tree mf)
1389 {
1390   return class_of_this_parm (TREE_TYPE (mf));
1391 }
1392
1393 /*
1394    parameter-declaration:
1395       decl-specifier-seq declarator
1396       decl-specifier-seq declarator = assignment-expression
1397       decl-specifier-seq abstract-declarator(opt)
1398       decl-specifier-seq abstract-declarator(opt) assignment-expression  */
1399
1400 static inline void
1401 pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
1402 {
1403   pp_cxx_decl_specifier_seq (pp, t);
1404   if (TYPE_P (t))
1405     pp_cxx_abstract_declarator (pp, t);
1406   else
1407     pp_cxx_declarator (pp, t);
1408 }
1409
1410 /* parameter-declaration-clause:
1411       parameter-declaration-list(opt) ...(opt)
1412       parameter-declaration-list , ...
1413
1414    parameter-declaration-list:
1415       parameter-declaration
1416       parameter-declaration-list , parameter-declaration  */
1417
1418 static void
1419 pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
1420 {
1421   tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t);
1422   tree types =
1423     TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
1424   const bool abstract = args == NULL
1425     || pp_c_base (pp)->flags & pp_c_flag_abstract;
1426   bool first = true;
1427
1428   /* Skip artificial parameter for nonstatic member functions.  */
1429   if (TREE_CODE (t) == METHOD_TYPE)
1430     types = TREE_CHAIN (types);
1431
1432   pp_cxx_left_paren (pp);
1433   for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types))
1434     {
1435       if (!first)
1436         pp_cxx_separate_with (pp, ',');
1437       first = false;
1438       pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args);
1439       if (!abstract && pp_c_base (pp)->flags & pp_cxx_flag_default_argument)
1440         {
1441           pp_cxx_whitespace (pp);
1442           pp_equal (pp);
1443           pp_cxx_whitespace (pp);
1444           pp_cxx_assignment_expression (pp, TREE_PURPOSE (types));
1445         }
1446     }
1447   pp_cxx_right_paren (pp);
1448 }
1449
1450 /* exception-specification:
1451       throw ( type-id-list(opt) )
1452
1453    type-id-list
1454       type-id
1455       type-id-list , type-id   */
1456
1457 static void
1458 pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
1459 {
1460   tree ex_spec = TYPE_RAISES_EXCEPTIONS (t);
1461   bool need_comma = false;
1462
1463   if (ex_spec == NULL)
1464     return;
1465   if (TREE_PURPOSE (ex_spec))
1466     {
1467       pp_cxx_ws_string (pp, "noexcept");
1468       pp_cxx_whitespace (pp);
1469       pp_cxx_left_paren (pp);
1470       if (DEFERRED_NOEXCEPT_SPEC_P (ex_spec))
1471         pp_cxx_ws_string (pp, "<uninstantiated>");
1472       else
1473         pp_cxx_expression (pp, TREE_PURPOSE (ex_spec));
1474       pp_cxx_right_paren (pp);
1475       return;
1476     }
1477   pp_cxx_ws_string (pp, "throw");
1478   pp_cxx_left_paren (pp);
1479   for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
1480     {
1481       tree type = TREE_VALUE (ex_spec);
1482       tree argpack = NULL_TREE;
1483       int i, len = 1;
1484
1485       if (ARGUMENT_PACK_P (type))
1486         {
1487           argpack = ARGUMENT_PACK_ARGS (type);
1488           len = TREE_VEC_LENGTH (argpack);
1489         }
1490
1491       for (i = 0; i < len; ++i)
1492         {
1493           if (argpack)
1494             type = TREE_VEC_ELT (argpack, i);
1495
1496           if (need_comma)
1497             pp_cxx_separate_with (pp, ',');
1498           else
1499             need_comma = true;
1500
1501           pp_cxx_type_id (pp, type);
1502         }
1503     }
1504   pp_cxx_right_paren (pp);
1505 }
1506
1507 /* direct-declarator:
1508       declarator-id
1509       direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
1510                                             exception-specification(opt)
1511       direct-declaration [ constant-expression(opt) ]
1512       ( declarator )  */
1513
1514 static void
1515 pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
1516 {
1517   switch (TREE_CODE (t))
1518     {
1519     case VAR_DECL:
1520     case PARM_DECL:
1521     case CONST_DECL:
1522     case FIELD_DECL:
1523       if (DECL_NAME (t))
1524         {
1525           pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1526
1527           if ((TREE_CODE (t) == PARM_DECL && FUNCTION_PARAMETER_PACK_P (t))
1528               || template_parameter_pack_p (t))
1529             /* A function parameter pack or non-type template
1530                parameter pack.  */
1531             pp_cxx_ws_string (pp, "...");
1532
1533           pp_cxx_id_expression (pp, DECL_NAME (t));
1534         }
1535       pp_cxx_abstract_declarator (pp, TREE_TYPE (t));
1536       break;
1537
1538     case FUNCTION_DECL:
1539       pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
1540       pp_cxx_id_expression (pp, t);
1541       pp_cxx_parameter_declaration_clause (pp, t);
1542
1543       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1544         {
1545           pp_base (pp)->padding = pp_before;
1546           pp_cxx_cv_qualifier_seq (pp, pp_cxx_implicit_parameter_type (t));
1547         }
1548
1549       pp_cxx_exception_specification (pp, TREE_TYPE (t));
1550       break;
1551
1552     case TYPENAME_TYPE:
1553     case TEMPLATE_DECL:
1554     case TEMPLATE_TYPE_PARM:
1555     case TEMPLATE_PARM_INDEX:
1556     case TEMPLATE_TEMPLATE_PARM:
1557       break;
1558
1559     default:
1560       pp_c_direct_declarator (pp_c_base (pp), t);
1561       break;
1562     }
1563 }
1564
1565 /* declarator:
1566    direct-declarator
1567    ptr-operator declarator  */
1568
1569 static void
1570 pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
1571 {
1572   pp_cxx_direct_declarator (pp, t);
1573 }
1574
1575 /* ctor-initializer:
1576       : mem-initializer-list
1577
1578    mem-initializer-list:
1579       mem-initializer
1580       mem-initializer , mem-initializer-list
1581
1582    mem-initializer:
1583       mem-initializer-id ( expression-list(opt) )
1584
1585    mem-initializer-id:
1586       ::(opt) nested-name-specifier(opt) class-name
1587       identifier   */
1588
1589 static void
1590 pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
1591 {
1592   t = TREE_OPERAND (t, 0);
1593   pp_cxx_whitespace (pp);
1594   pp_colon (pp);
1595   pp_cxx_whitespace (pp);
1596   for (; t; t = TREE_CHAIN (t))
1597     {
1598       tree purpose = TREE_PURPOSE (t);
1599       bool is_pack = PACK_EXPANSION_P (purpose);
1600
1601       if (is_pack)
1602         pp_cxx_primary_expression (pp, PACK_EXPANSION_PATTERN (purpose));
1603       else
1604         pp_cxx_primary_expression (pp, purpose);
1605       pp_cxx_call_argument_list (pp, TREE_VALUE (t));
1606       if (is_pack)
1607         pp_cxx_ws_string (pp, "...");
1608       if (TREE_CHAIN (t))
1609         pp_cxx_separate_with (pp, ',');
1610     }
1611 }
1612
1613 /* function-definition:
1614       decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
1615       decl-specifier-seq(opt) declarator function-try-block  */
1616
1617 static void
1618 pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
1619 {
1620   tree saved_scope = pp->enclosing_scope;
1621   pp_cxx_decl_specifier_seq (pp, t);
1622   pp_cxx_declarator (pp, t);
1623   pp_needs_newline (pp) = true;
1624   pp->enclosing_scope = DECL_CONTEXT (t);
1625   if (DECL_SAVED_TREE (t))
1626     pp_cxx_statement (pp, DECL_SAVED_TREE (t));
1627   else
1628     {
1629       pp_cxx_semicolon (pp);
1630       pp_needs_newline (pp) = true;
1631     }
1632   pp_flush (pp);
1633   pp->enclosing_scope = saved_scope;
1634 }
1635
1636 /* abstract-declarator:
1637       ptr-operator abstract-declarator(opt)
1638       direct-abstract-declarator  */
1639
1640 static void
1641 pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
1642 {
1643   if (TYPE_PTRMEM_P (t) || TYPE_PTRMEMFUNC_P (t))
1644     pp_cxx_right_paren (pp);
1645   else if (POINTER_TYPE_P (t))
1646     {
1647       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
1648           || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1649         pp_cxx_right_paren (pp);
1650       t = TREE_TYPE (t);
1651     }
1652   pp_cxx_direct_abstract_declarator (pp, t);
1653 }
1654
1655 /* direct-abstract-declarator:
1656       direct-abstract-declarator(opt) ( parameter-declaration-clause )
1657                            cv-qualifier-seq(opt) exception-specification(opt)
1658       direct-abstract-declarator(opt) [ constant-expression(opt) ]
1659       ( abstract-declarator )  */
1660
1661 static void
1662 pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
1663 {
1664   switch (TREE_CODE (t))
1665     {
1666     case REFERENCE_TYPE:
1667       pp_cxx_abstract_declarator (pp, t);
1668       break;
1669
1670     case RECORD_TYPE:
1671       if (TYPE_PTRMEMFUNC_P (t))
1672         pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t));
1673       break;
1674
1675     case METHOD_TYPE:
1676     case FUNCTION_TYPE:
1677       pp_cxx_parameter_declaration_clause (pp, t);
1678       pp_cxx_direct_abstract_declarator (pp, TREE_TYPE (t));
1679       if (TREE_CODE (t) == METHOD_TYPE)
1680         {
1681           pp_base (pp)->padding = pp_before;
1682           pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (t));
1683         }
1684       pp_cxx_exception_specification (pp, t);
1685       break;
1686
1687     case TYPENAME_TYPE:
1688     case TEMPLATE_TYPE_PARM:
1689     case TEMPLATE_TEMPLATE_PARM:
1690     case BOUND_TEMPLATE_TEMPLATE_PARM:
1691     case UNBOUND_CLASS_TEMPLATE:
1692       break;
1693
1694     default:
1695       pp_c_direct_abstract_declarator (pp_c_base (pp), t);
1696       break;
1697     }
1698 }
1699
1700 /* type-id:
1701      type-specifier-seq abstract-declarator(opt) */
1702
1703 static void
1704 pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
1705 {
1706   pp_flags saved_flags = pp_c_base (pp)->flags;
1707   pp_c_base (pp)->flags |= pp_c_flag_abstract;
1708
1709   switch (TREE_CODE (t))
1710     {
1711     case TYPE_DECL:
1712     case UNION_TYPE:
1713     case RECORD_TYPE:
1714     case ENUMERAL_TYPE:
1715     case TYPENAME_TYPE:
1716     case BOUND_TEMPLATE_TEMPLATE_PARM:
1717     case UNBOUND_CLASS_TEMPLATE:
1718     case TEMPLATE_TEMPLATE_PARM:
1719     case TEMPLATE_TYPE_PARM:
1720     case TEMPLATE_PARM_INDEX:
1721     case TEMPLATE_DECL:
1722     case TYPEOF_TYPE:
1723     case UNDERLYING_TYPE:
1724     case DECLTYPE_TYPE:
1725     case TEMPLATE_ID_EXPR:
1726       pp_cxx_type_specifier_seq (pp, t);
1727       break;
1728
1729     case TYPE_PACK_EXPANSION:
1730       pp_cxx_type_id (pp, PACK_EXPANSION_PATTERN (t));
1731       pp_cxx_ws_string (pp, "...");
1732       break;
1733
1734     default:
1735       pp_c_type_id (pp_c_base (pp), t);
1736       break;
1737     }
1738
1739   pp_c_base (pp)->flags = saved_flags;
1740 }
1741
1742 /* template-argument-list:
1743       template-argument ...(opt)
1744       template-argument-list, template-argument ...(opt)
1745
1746    template-argument:
1747       assignment-expression
1748       type-id
1749       template-name  */
1750
1751 static void
1752 pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
1753 {
1754   int i;
1755   bool need_comma = false;
1756
1757   if (t == NULL)
1758     return;
1759   for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
1760     {
1761       tree arg = TREE_VEC_ELT (t, i);
1762       tree argpack = NULL_TREE;
1763       int idx, len = 1;
1764
1765       if (ARGUMENT_PACK_P (arg))
1766         {
1767           argpack = ARGUMENT_PACK_ARGS (arg);
1768           len = TREE_VEC_LENGTH (argpack);
1769         }
1770
1771       for (idx = 0; idx < len; idx++)
1772         {
1773           if (argpack)
1774             arg = TREE_VEC_ELT (argpack, idx);
1775
1776           if (need_comma)
1777             pp_cxx_separate_with (pp, ',');
1778           else
1779             need_comma = true;
1780
1781           if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
1782                                && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
1783             pp_cxx_type_id (pp, arg);
1784           else
1785             pp_cxx_expression (pp, arg);
1786         }
1787     }
1788 }
1789
1790
1791 static void
1792 pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
1793 {
1794   t = DECL_EXPR_DECL (t);
1795   pp_cxx_type_specifier_seq (pp, t);
1796   if (TYPE_P (t))
1797     pp_cxx_abstract_declarator (pp, t);
1798   else
1799     pp_cxx_declarator (pp, t);
1800 }
1801
1802 /* Statements.  */
1803
1804 static void
1805 pp_cxx_statement (cxx_pretty_printer *pp, tree t)
1806 {
1807   switch (TREE_CODE (t))
1808     {
1809     case CTOR_INITIALIZER:
1810       pp_cxx_ctor_initializer (pp, t);
1811       break;
1812
1813     case USING_STMT:
1814       pp_cxx_ws_string (pp, "using");
1815       pp_cxx_ws_string (pp, "namespace");
1816       if (DECL_CONTEXT (t))
1817         pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1818       pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
1819       break;
1820
1821     case USING_DECL:
1822       pp_cxx_ws_string (pp, "using");
1823       pp_cxx_nested_name_specifier (pp, USING_DECL_SCOPE (t));
1824       pp_cxx_unqualified_id (pp, DECL_NAME (t));
1825       break;
1826
1827     case EH_SPEC_BLOCK:
1828       break;
1829
1830       /* try-block:
1831             try compound-statement handler-seq  */
1832     case TRY_BLOCK:
1833       pp_maybe_newline_and_indent (pp, 0);
1834       pp_cxx_ws_string (pp, "try");
1835       pp_newline_and_indent (pp, 3);
1836       pp_cxx_statement (pp, TRY_STMTS (t));
1837       pp_newline_and_indent (pp, -3);
1838       if (CLEANUP_P (t))
1839         ;
1840       else
1841         pp_cxx_statement (pp, TRY_HANDLERS (t));
1842       break;
1843
1844       /*
1845          handler-seq:
1846             handler handler-seq(opt)
1847
1848          handler:
1849          catch ( exception-declaration ) compound-statement
1850
1851          exception-declaration:
1852             type-specifier-seq declarator
1853             type-specifier-seq abstract-declarator
1854             ...   */
1855     case HANDLER:
1856       pp_cxx_ws_string (pp, "catch");
1857       pp_cxx_left_paren (pp);
1858       pp_cxx_exception_declaration (pp, HANDLER_PARMS (t));
1859       pp_cxx_right_paren (pp);
1860       pp_indentation (pp) += 3;
1861       pp_needs_newline (pp) = true;
1862       pp_cxx_statement (pp, HANDLER_BODY (t));
1863       pp_indentation (pp) -= 3;
1864       pp_needs_newline (pp) = true;
1865       break;
1866
1867       /* selection-statement:
1868             if ( expression ) statement
1869             if ( expression ) statement else statement  */
1870     case IF_STMT:
1871       pp_cxx_ws_string (pp, "if");
1872       pp_cxx_whitespace (pp);
1873       pp_cxx_left_paren (pp);
1874       pp_cxx_expression (pp, IF_COND (t));
1875       pp_cxx_right_paren (pp);
1876       pp_newline_and_indent (pp, 2);
1877       pp_cxx_statement (pp, THEN_CLAUSE (t));
1878       pp_newline_and_indent (pp, -2);
1879       if (ELSE_CLAUSE (t))
1880         {
1881           tree else_clause = ELSE_CLAUSE (t);
1882           pp_cxx_ws_string (pp, "else");
1883           if (TREE_CODE (else_clause) == IF_STMT)
1884             pp_cxx_whitespace (pp);
1885           else
1886             pp_newline_and_indent (pp, 2);
1887           pp_cxx_statement (pp, else_clause);
1888           if (TREE_CODE (else_clause) != IF_STMT)
1889             pp_newline_and_indent (pp, -2);
1890         }
1891       break;
1892
1893     case SWITCH_STMT:
1894       pp_cxx_ws_string (pp, "switch");
1895       pp_space (pp);
1896       pp_cxx_left_paren (pp);
1897       pp_cxx_expression (pp, SWITCH_STMT_COND (t));
1898       pp_cxx_right_paren (pp);
1899       pp_indentation (pp) += 3;
1900       pp_needs_newline (pp) = true;
1901       pp_cxx_statement (pp, SWITCH_STMT_BODY (t));
1902       pp_newline_and_indent (pp, -3);
1903       break;
1904
1905       /* iteration-statement:
1906             while ( expression ) statement
1907             do statement while ( expression ) ;
1908             for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1909             for ( declaration expression(opt) ; expression(opt) ) statement  */
1910     case WHILE_STMT:
1911       pp_cxx_ws_string (pp, "while");
1912       pp_space (pp);
1913       pp_cxx_left_paren (pp);
1914       pp_cxx_expression (pp, WHILE_COND (t));
1915       pp_cxx_right_paren (pp);
1916       pp_newline_and_indent (pp, 3);
1917       pp_cxx_statement (pp, WHILE_BODY (t));
1918       pp_indentation (pp) -= 3;
1919       pp_needs_newline (pp) = true;
1920       break;
1921
1922     case DO_STMT:
1923       pp_cxx_ws_string (pp, "do");
1924       pp_newline_and_indent (pp, 3);
1925       pp_cxx_statement (pp, DO_BODY (t));
1926       pp_newline_and_indent (pp, -3);
1927       pp_cxx_ws_string (pp, "while");
1928       pp_space (pp);
1929       pp_cxx_left_paren (pp);
1930       pp_cxx_expression (pp, DO_COND (t));
1931       pp_cxx_right_paren (pp);
1932       pp_cxx_semicolon (pp);
1933       pp_needs_newline (pp) = true;
1934       break;
1935
1936     case FOR_STMT:
1937       pp_cxx_ws_string (pp, "for");
1938       pp_space (pp);
1939       pp_cxx_left_paren (pp);
1940       if (FOR_INIT_STMT (t))
1941         pp_cxx_statement (pp, FOR_INIT_STMT (t));
1942       else
1943         pp_cxx_semicolon (pp);
1944       pp_needs_newline (pp) = false;
1945       pp_cxx_whitespace (pp);
1946       if (FOR_COND (t))
1947         pp_cxx_expression (pp, FOR_COND (t));
1948       pp_cxx_semicolon (pp);
1949       pp_needs_newline (pp) = false;
1950       pp_cxx_whitespace (pp);
1951       if (FOR_EXPR (t))
1952         pp_cxx_expression (pp, FOR_EXPR (t));
1953       pp_cxx_right_paren (pp);
1954       pp_newline_and_indent (pp, 3);
1955       pp_cxx_statement (pp, FOR_BODY (t));
1956       pp_indentation (pp) -= 3;
1957       pp_needs_newline (pp) = true;
1958       break;
1959
1960     case RANGE_FOR_STMT:
1961       pp_cxx_ws_string (pp, "for");
1962       pp_space (pp);
1963       pp_cxx_left_paren (pp);
1964       pp_cxx_statement (pp, RANGE_FOR_DECL (t));
1965       pp_space (pp);
1966       pp_needs_newline (pp) = false;
1967       pp_colon (pp);
1968       pp_space (pp);
1969       pp_cxx_statement (pp, RANGE_FOR_EXPR (t));
1970       pp_cxx_right_paren (pp);
1971       pp_newline_and_indent (pp, 3);
1972       pp_cxx_statement (pp, FOR_BODY (t));
1973       pp_indentation (pp) -= 3;
1974       pp_needs_newline (pp) = true;
1975       break;
1976
1977       /* jump-statement:
1978             goto identifier;
1979             continue ;
1980             return expression(opt) ;  */
1981     case BREAK_STMT:
1982     case CONTINUE_STMT:
1983       pp_string (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
1984       pp_cxx_semicolon (pp);
1985       pp_needs_newline (pp) = true;
1986       break;
1987
1988       /* expression-statement:
1989             expression(opt) ;  */
1990     case EXPR_STMT:
1991       pp_cxx_expression (pp, EXPR_STMT_EXPR (t));
1992       pp_cxx_semicolon (pp);
1993       pp_needs_newline (pp) = true;
1994       break;
1995
1996     case CLEANUP_STMT:
1997       pp_cxx_ws_string (pp, "try");
1998       pp_newline_and_indent (pp, 2);
1999       pp_cxx_statement (pp, CLEANUP_BODY (t));
2000       pp_newline_and_indent (pp, -2);
2001       pp_cxx_ws_string (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
2002       pp_newline_and_indent (pp, 2);
2003       pp_cxx_statement (pp, CLEANUP_EXPR (t));
2004       pp_newline_and_indent (pp, -2);
2005       break;
2006
2007     case STATIC_ASSERT:
2008       pp_cxx_declaration (pp, t);
2009       break;
2010
2011     default:
2012       pp_c_statement (pp_c_base (pp), t);
2013       break;
2014     }
2015 }
2016
2017 /* original-namespace-definition:
2018       namespace identifier { namespace-body }
2019
2020   As an edge case, we also handle unnamed namespace definition here.  */
2021
2022 static void
2023 pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
2024 {
2025   pp_cxx_ws_string (pp, "namespace");
2026   if (DECL_CONTEXT (t))
2027     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2028   if (DECL_NAME (t))
2029     pp_cxx_unqualified_id (pp, t);
2030   pp_cxx_whitespace (pp);
2031   pp_cxx_left_brace (pp);
2032   /* We do not print the namespace-body.  */
2033   pp_cxx_whitespace (pp);
2034   pp_cxx_right_brace (pp);
2035 }
2036
2037 /* namespace-alias:
2038       identifier
2039
2040    namespace-alias-definition:
2041       namespace identifier = qualified-namespace-specifier ;
2042
2043    qualified-namespace-specifier:
2044       ::(opt) nested-name-specifier(opt) namespace-name   */
2045
2046 static void
2047 pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
2048 {
2049   pp_cxx_ws_string (pp, "namespace");
2050   if (DECL_CONTEXT (t))
2051     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2052   pp_cxx_unqualified_id (pp, t);
2053   pp_cxx_whitespace (pp);
2054   pp_equal (pp);
2055   pp_cxx_whitespace (pp);
2056   if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
2057     pp_cxx_nested_name_specifier (pp,
2058                                   DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
2059   pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
2060   pp_cxx_semicolon (pp);
2061 }
2062
2063 /* simple-declaration:
2064       decl-specifier-seq(opt) init-declarator-list(opt)  */
2065
2066 static void
2067 pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
2068 {
2069   pp_cxx_decl_specifier_seq (pp, t);
2070   pp_cxx_init_declarator (pp, t);
2071   pp_cxx_semicolon (pp);
2072   pp_needs_newline (pp) = true;
2073 }
2074
2075 /*
2076   template-parameter-list:
2077      template-parameter
2078      template-parameter-list , template-parameter  */
2079
2080 static inline void
2081 pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
2082 {
2083   const int n = TREE_VEC_LENGTH (t);
2084   int i;
2085   for (i = 0; i < n; ++i)
2086     {
2087       if (i)
2088         pp_cxx_separate_with (pp, ',');
2089       pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
2090     }
2091 }
2092
2093 /* template-parameter:
2094       type-parameter
2095       parameter-declaration
2096
2097    type-parameter:
2098      class ...(opt) identifier(opt)
2099      class identifier(opt) = type-id
2100      typename identifier(opt)
2101      typename ...(opt) identifier(opt) = type-id
2102      template < template-parameter-list > class ...(opt) identifier(opt)
2103      template < template-parameter-list > class identifier(opt) = template-name  */
2104
2105 static void
2106 pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
2107 {
2108   tree parameter =  TREE_VALUE (t);
2109   switch (TREE_CODE (parameter))
2110     {
2111     case TYPE_DECL:
2112       pp_cxx_ws_string (pp, "class");
2113       if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2114         pp_cxx_ws_string (pp, "...");
2115       if (DECL_NAME (parameter))
2116         pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
2117       /* FIXME: Check if we should print also default argument.  */
2118       break;
2119
2120     case PARM_DECL:
2121       pp_cxx_parameter_declaration (pp, parameter);
2122       break;
2123
2124     case TEMPLATE_DECL:
2125       break;
2126
2127     default:
2128       pp_unsupported_tree (pp, t);
2129       break;
2130     }
2131 }
2132
2133 /* Pretty-print a template parameter in the canonical form
2134    "template-parameter-<level>-<position in parameter list>".  */
2135
2136 void
2137 pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
2138 {
2139   const enum tree_code code = TREE_CODE (parm);
2140
2141   /* Brings type template parameters to the canonical forms.  */
2142   if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
2143       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
2144     parm = TEMPLATE_TYPE_PARM_INDEX (parm);
2145
2146   pp_cxx_begin_template_argument_list (pp);
2147   pp_cxx_ws_string (pp, M_("template-parameter-"));
2148   pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
2149   pp_minus (pp);
2150   pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
2151   pp_cxx_end_template_argument_list (pp);
2152 }
2153
2154 /*
2155   template-declaration:
2156      export(opt) template < template-parameter-list > declaration   */
2157
2158 static void
2159 pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
2160 {
2161   tree tmpl = most_general_template (t);
2162   tree level;
2163
2164   pp_maybe_newline_and_indent (pp, 0);
2165   for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
2166     {
2167       pp_cxx_ws_string (pp, "template");
2168       pp_cxx_begin_template_argument_list (pp);
2169       pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
2170       pp_cxx_end_template_argument_list (pp);
2171       pp_newline_and_indent (pp, 3);
2172     }
2173   if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
2174     pp_cxx_function_definition (pp, t);
2175   else
2176     pp_cxx_simple_declaration (pp, t);
2177 }
2178
2179 static void
2180 pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
2181 {
2182   pp_unsupported_tree (pp, t);
2183 }
2184
2185 static void
2186 pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
2187 {
2188   pp_unsupported_tree (pp, t);
2189 }
2190
2191 /*
2192     declaration:
2193        block-declaration
2194        function-definition
2195        template-declaration
2196        explicit-instantiation
2197        explicit-specialization
2198        linkage-specification
2199        namespace-definition
2200
2201     block-declaration:
2202        simple-declaration
2203        asm-definition
2204        namespace-alias-definition
2205        using-declaration
2206        using-directive
2207        static_assert-declaration */
2208 void
2209 pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
2210 {
2211   if (TREE_CODE (t) == STATIC_ASSERT)
2212     {
2213       pp_cxx_ws_string (pp, "static_assert");
2214       pp_cxx_left_paren (pp);
2215       pp_cxx_expression (pp, STATIC_ASSERT_CONDITION (t));
2216       pp_cxx_separate_with (pp, ',');
2217       pp_cxx_expression (pp, STATIC_ASSERT_MESSAGE (t));
2218       pp_cxx_right_paren (pp);
2219     }
2220   else if (!DECL_LANG_SPECIFIC (t))
2221     pp_cxx_simple_declaration (pp, t);
2222   else if (DECL_USE_TEMPLATE (t))
2223     switch (DECL_USE_TEMPLATE (t))
2224       {
2225       case 1:
2226         pp_cxx_template_declaration (pp, t);
2227         break;
2228
2229       case 2:
2230         pp_cxx_explicit_specialization (pp, t);
2231         break;
2232
2233       case 3:
2234         pp_cxx_explicit_instantiation (pp, t);
2235         break;
2236
2237       default:
2238         break;
2239       }
2240   else switch (TREE_CODE (t))
2241     {
2242     case VAR_DECL:
2243     case TYPE_DECL:
2244       pp_cxx_simple_declaration (pp, t);
2245       break;
2246
2247     case FUNCTION_DECL:
2248       if (DECL_SAVED_TREE (t))
2249         pp_cxx_function_definition (pp, t);
2250       else
2251         pp_cxx_simple_declaration (pp, t);
2252       break;
2253
2254     case NAMESPACE_DECL:
2255       if (DECL_NAMESPACE_ALIAS (t))
2256         pp_cxx_namespace_alias_definition (pp, t);
2257       else
2258         pp_cxx_original_namespace_definition (pp, t);
2259       break;
2260
2261     default:
2262       pp_unsupported_tree (pp, t);
2263       break;
2264     }
2265 }
2266
2267 static void
2268 pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
2269 {
2270   t = TREE_OPERAND (t, 0);
2271   pp_cxx_ws_string (pp, "typeid");
2272   pp_cxx_left_paren (pp);
2273   if (TYPE_P (t))
2274     pp_cxx_type_id (pp, t);
2275   else
2276     pp_cxx_expression (pp, t);
2277   pp_cxx_right_paren (pp);
2278 }
2279
2280 void
2281 pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
2282 {
2283   pp_cxx_ws_string (pp, "va_arg");
2284   pp_cxx_left_paren (pp);
2285   pp_cxx_assignment_expression (pp, TREE_OPERAND (t, 0));
2286   pp_cxx_separate_with (pp, ',');
2287   pp_cxx_type_id (pp, TREE_TYPE (t));
2288   pp_cxx_right_paren (pp);
2289 }
2290
2291 static bool
2292 pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
2293 {
2294   switch (TREE_CODE (t))
2295     {
2296     case ARROW_EXPR:
2297       if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR
2298           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
2299         {
2300           pp_cxx_type_id (pp, TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))));
2301           pp_cxx_separate_with (pp, ',');
2302           return true;
2303         }
2304       return false;
2305     case COMPONENT_REF:
2306       if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2307         return false;
2308       if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
2309         pp_cxx_dot (pp);
2310       pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2311       return true;
2312     case ARRAY_REF:
2313       if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2314         return false;
2315       pp_left_bracket (pp);
2316       pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2317       pp_right_bracket (pp);
2318       return true;
2319     default:
2320       return false;
2321     }
2322 }
2323
2324 void
2325 pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
2326 {
2327   pp_cxx_ws_string (pp, "offsetof");
2328   pp_cxx_left_paren (pp);
2329   if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2330     pp_cxx_expression (pp, TREE_OPERAND (t, 0));
2331   pp_cxx_right_paren (pp);
2332 }
2333
2334 void
2335 pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
2336 {
2337   cp_trait_kind kind = TRAIT_EXPR_KIND (t);
2338
2339   switch (kind)
2340     {
2341     case CPTK_HAS_NOTHROW_ASSIGN:
2342       pp_cxx_ws_string (pp, "__has_nothrow_assign");
2343       break;
2344     case CPTK_HAS_TRIVIAL_ASSIGN:
2345       pp_cxx_ws_string (pp, "__has_trivial_assign");
2346       break;
2347     case CPTK_HAS_NOTHROW_CONSTRUCTOR:
2348       pp_cxx_ws_string (pp, "__has_nothrow_constructor");
2349       break;
2350     case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
2351       pp_cxx_ws_string (pp, "__has_trivial_constructor");
2352       break;
2353     case CPTK_HAS_NOTHROW_COPY:
2354       pp_cxx_ws_string (pp, "__has_nothrow_copy");
2355       break;
2356     case CPTK_HAS_TRIVIAL_COPY:
2357       pp_cxx_ws_string (pp, "__has_trivial_copy");
2358       break;
2359     case CPTK_HAS_TRIVIAL_DESTRUCTOR:
2360       pp_cxx_ws_string (pp, "__has_trivial_destructor");
2361       break;
2362     case CPTK_HAS_VIRTUAL_DESTRUCTOR:
2363       pp_cxx_ws_string (pp, "__has_virtual_destructor");
2364       break;
2365     case CPTK_IS_ABSTRACT:
2366       pp_cxx_ws_string (pp, "__is_abstract");
2367       break;
2368     case CPTK_IS_BASE_OF:
2369       pp_cxx_ws_string (pp, "__is_base_of");
2370       break;
2371     case CPTK_IS_CLASS:
2372       pp_cxx_ws_string (pp, "__is_class");
2373       break;
2374     case CPTK_IS_CONVERTIBLE_TO:
2375       pp_cxx_ws_string (pp, "__is_convertible_to");
2376       break;
2377     case CPTK_IS_EMPTY:
2378       pp_cxx_ws_string (pp, "__is_empty");
2379       break;
2380     case CPTK_IS_ENUM:
2381       pp_cxx_ws_string (pp, "__is_enum");
2382       break;
2383     case CPTK_IS_FINAL:
2384       pp_cxx_ws_string (pp, "__is_final");
2385       break;
2386     case CPTK_IS_POD:
2387       pp_cxx_ws_string (pp, "__is_pod");
2388       break;
2389     case CPTK_IS_POLYMORPHIC:
2390       pp_cxx_ws_string (pp, "__is_polymorphic");
2391       break;
2392     case CPTK_IS_STD_LAYOUT:
2393       pp_cxx_ws_string (pp, "__is_std_layout");
2394       break;
2395     case CPTK_IS_TRIVIAL:
2396       pp_cxx_ws_string (pp, "__is_trivial");
2397       break;
2398     case CPTK_IS_UNION:
2399       pp_cxx_ws_string (pp, "__is_union");
2400       break;
2401     case CPTK_IS_LITERAL_TYPE:
2402       pp_cxx_ws_string (pp, "__is_literal_type");
2403       break;
2404
2405     default:
2406       gcc_unreachable ();
2407     }
2408
2409   pp_cxx_left_paren (pp);
2410   pp_cxx_type_id (pp, TRAIT_EXPR_TYPE1 (t));
2411
2412   if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
2413     {
2414       pp_cxx_separate_with (pp, ',');
2415       pp_cxx_type_id (pp, TRAIT_EXPR_TYPE2 (t));
2416     }
2417
2418   pp_cxx_right_paren (pp);
2419 }
2420 \f
2421 typedef c_pretty_print_fn pp_fun;
2422
2423 /* Initialization of a C++ pretty-printer object.  */
2424
2425 void
2426 pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
2427 {
2428   pp_c_pretty_printer_init (pp_c_base (pp));
2429   pp_set_line_maximum_length (pp, 0);
2430
2431   pp->c_base.declaration = (pp_fun) pp_cxx_declaration;
2432   pp->c_base.declaration_specifiers = (pp_fun) pp_cxx_decl_specifier_seq;
2433   pp->c_base.function_specifier = (pp_fun) pp_cxx_function_specifier;
2434   pp->c_base.type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
2435   pp->c_base.declarator = (pp_fun) pp_cxx_declarator;
2436   pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator;
2437   pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
2438   pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
2439   pp->c_base.abstract_declarator = (pp_fun) pp_cxx_abstract_declarator;
2440   pp->c_base.direct_abstract_declarator =
2441     (pp_fun) pp_cxx_direct_abstract_declarator;
2442   pp->c_base.simple_type_specifier = (pp_fun)pp_cxx_simple_type_specifier;
2443
2444   /* pp->c_base.statement = (pp_fun) pp_cxx_statement;  */
2445
2446   pp->c_base.constant = (pp_fun) pp_cxx_constant;
2447   pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
2448   pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression;
2449   pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression;
2450   pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression;
2451   pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
2452   pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
2453   pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
2454   pp->c_base.expression = (pp_fun) pp_cxx_expression;
2455   pp->enclosing_scope = global_namespace;
2456 }