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     case BOUND_TEMPLATE_TEMPLATE_PARM:
1265       pp_cxx_unqualified_id (pp, t);
1266       break;
1267
1268     case TYPENAME_TYPE:
1269       pp_cxx_ws_string (pp, "typename");
1270       pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
1271       pp_cxx_unqualified_id (pp, TYPE_NAME (t));
1272       break;
1273
1274     default:
1275       pp_c_type_specifier (pp_c_base (pp), t);
1276       break;
1277     }
1278 }
1279
1280 /* type-specifier-seq:
1281       type-specifier type-specifier-seq(opt)
1282
1283    type-specifier:
1284       simple-type-specifier
1285       class-specifier
1286       enum-specifier
1287       elaborated-type-specifier
1288       cv-qualifier   */
1289
1290 static void
1291 pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
1292 {
1293   switch (TREE_CODE (t))
1294     {
1295     case TEMPLATE_DECL:
1296     case TEMPLATE_TYPE_PARM:
1297     case TEMPLATE_TEMPLATE_PARM:
1298     case TYPE_DECL:
1299     case BOUND_TEMPLATE_TEMPLATE_PARM:
1300       pp_cxx_cv_qualifier_seq (pp, t);
1301       pp_cxx_simple_type_specifier (pp, t);
1302       break;
1303
1304     case METHOD_TYPE:
1305       pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
1306       pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1307       pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
1308       break;
1309
1310     case DECLTYPE_TYPE:
1311       pp_cxx_ws_string (pp, "decltype");
1312       pp_cxx_left_paren (pp);
1313       pp_cxx_expression (pp, DECLTYPE_TYPE_EXPR (t));
1314       pp_cxx_right_paren (pp);
1315       break;
1316
1317     case RECORD_TYPE:
1318       if (TYPE_PTRMEMFUNC_P (t))
1319         {
1320           tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
1321           pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (pfm)));
1322           pp_cxx_whitespace (pp);
1323           pp_cxx_ptr_operator (pp, t);
1324           break;
1325         }
1326       /* else fall through */
1327
1328     default:
1329       if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
1330         pp_c_specifier_qualifier_list (pp_c_base (pp), t);
1331     }
1332 }
1333
1334 /* ptr-operator:
1335       * cv-qualifier-seq(opt)
1336       &
1337       ::(opt) nested-name-specifier * cv-qualifier-seq(opt)  */
1338
1339 static void
1340 pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
1341 {
1342   if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
1343     t = TREE_TYPE (t);
1344   switch (TREE_CODE (t))
1345     {
1346     case REFERENCE_TYPE:
1347     case POINTER_TYPE:
1348       if (TYPE_PTR_OR_PTRMEM_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_PTRMEM_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     pp_cxx_semicolon (pp);
1629   pp_newline_and_flush (pp);
1630   pp->enclosing_scope = saved_scope;
1631 }
1632
1633 /* abstract-declarator:
1634       ptr-operator abstract-declarator(opt)
1635       direct-abstract-declarator  */
1636
1637 static void
1638 pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
1639 {
1640   if (TYPE_PTRMEM_P (t))
1641     pp_cxx_right_paren (pp);
1642   else if (POINTER_TYPE_P (t))
1643     {
1644       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
1645           || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1646         pp_cxx_right_paren (pp);
1647       t = TREE_TYPE (t);
1648     }
1649   pp_cxx_direct_abstract_declarator (pp, t);
1650 }
1651
1652 /* direct-abstract-declarator:
1653       direct-abstract-declarator(opt) ( parameter-declaration-clause )
1654                            cv-qualifier-seq(opt) exception-specification(opt)
1655       direct-abstract-declarator(opt) [ constant-expression(opt) ]
1656       ( abstract-declarator )  */
1657
1658 static void
1659 pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
1660 {
1661   switch (TREE_CODE (t))
1662     {
1663     case REFERENCE_TYPE:
1664       pp_cxx_abstract_declarator (pp, t);
1665       break;
1666
1667     case RECORD_TYPE:
1668       if (TYPE_PTRMEMFUNC_P (t))
1669         pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t));
1670       break;
1671
1672     case METHOD_TYPE:
1673     case FUNCTION_TYPE:
1674       pp_cxx_parameter_declaration_clause (pp, t);
1675       pp_cxx_direct_abstract_declarator (pp, TREE_TYPE (t));
1676       if (TREE_CODE (t) == METHOD_TYPE)
1677         {
1678           pp_base (pp)->padding = pp_before;
1679           pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (t));
1680         }
1681       pp_cxx_exception_specification (pp, t);
1682       break;
1683
1684     case TYPENAME_TYPE:
1685     case TEMPLATE_TYPE_PARM:
1686     case TEMPLATE_TEMPLATE_PARM:
1687     case BOUND_TEMPLATE_TEMPLATE_PARM:
1688     case UNBOUND_CLASS_TEMPLATE:
1689       break;
1690
1691     default:
1692       pp_c_direct_abstract_declarator (pp_c_base (pp), t);
1693       break;
1694     }
1695 }
1696
1697 /* type-id:
1698      type-specifier-seq abstract-declarator(opt) */
1699
1700 static void
1701 pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
1702 {
1703   pp_flags saved_flags = pp_c_base (pp)->flags;
1704   pp_c_base (pp)->flags |= pp_c_flag_abstract;
1705
1706   switch (TREE_CODE (t))
1707     {
1708     case TYPE_DECL:
1709     case UNION_TYPE:
1710     case RECORD_TYPE:
1711     case ENUMERAL_TYPE:
1712     case TYPENAME_TYPE:
1713     case BOUND_TEMPLATE_TEMPLATE_PARM:
1714     case UNBOUND_CLASS_TEMPLATE:
1715     case TEMPLATE_TEMPLATE_PARM:
1716     case TEMPLATE_TYPE_PARM:
1717     case TEMPLATE_PARM_INDEX:
1718     case TEMPLATE_DECL:
1719     case TYPEOF_TYPE:
1720     case UNDERLYING_TYPE:
1721     case DECLTYPE_TYPE:
1722     case TEMPLATE_ID_EXPR:
1723       pp_cxx_type_specifier_seq (pp, t);
1724       break;
1725
1726     case TYPE_PACK_EXPANSION:
1727       pp_cxx_type_id (pp, PACK_EXPANSION_PATTERN (t));
1728       pp_cxx_ws_string (pp, "...");
1729       break;
1730
1731     default:
1732       pp_c_type_id (pp_c_base (pp), t);
1733       break;
1734     }
1735
1736   pp_c_base (pp)->flags = saved_flags;
1737 }
1738
1739 /* template-argument-list:
1740       template-argument ...(opt)
1741       template-argument-list, template-argument ...(opt)
1742
1743    template-argument:
1744       assignment-expression
1745       type-id
1746       template-name  */
1747
1748 static void
1749 pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
1750 {
1751   int i;
1752   bool need_comma = false;
1753
1754   if (t == NULL)
1755     return;
1756   for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
1757     {
1758       tree arg = TREE_VEC_ELT (t, i);
1759       tree argpack = NULL_TREE;
1760       int idx, len = 1;
1761
1762       if (ARGUMENT_PACK_P (arg))
1763         {
1764           argpack = ARGUMENT_PACK_ARGS (arg);
1765           len = TREE_VEC_LENGTH (argpack);
1766         }
1767
1768       for (idx = 0; idx < len; idx++)
1769         {
1770           if (argpack)
1771             arg = TREE_VEC_ELT (argpack, idx);
1772
1773           if (need_comma)
1774             pp_cxx_separate_with (pp, ',');
1775           else
1776             need_comma = true;
1777
1778           if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
1779                                && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
1780             pp_cxx_type_id (pp, arg);
1781           else
1782             pp_cxx_expression (pp, arg);
1783         }
1784     }
1785 }
1786
1787
1788 static void
1789 pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
1790 {
1791   t = DECL_EXPR_DECL (t);
1792   pp_cxx_type_specifier_seq (pp, t);
1793   if (TYPE_P (t))
1794     pp_cxx_abstract_declarator (pp, t);
1795   else
1796     pp_cxx_declarator (pp, t);
1797 }
1798
1799 /* Statements.  */
1800
1801 static void
1802 pp_cxx_statement (cxx_pretty_printer *pp, tree t)
1803 {
1804   switch (TREE_CODE (t))
1805     {
1806     case CTOR_INITIALIZER:
1807       pp_cxx_ctor_initializer (pp, t);
1808       break;
1809
1810     case USING_STMT:
1811       pp_cxx_ws_string (pp, "using");
1812       pp_cxx_ws_string (pp, "namespace");
1813       if (DECL_CONTEXT (t))
1814         pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1815       pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
1816       break;
1817
1818     case USING_DECL:
1819       pp_cxx_ws_string (pp, "using");
1820       pp_cxx_nested_name_specifier (pp, USING_DECL_SCOPE (t));
1821       pp_cxx_unqualified_id (pp, DECL_NAME (t));
1822       break;
1823
1824     case EH_SPEC_BLOCK:
1825       break;
1826
1827       /* try-block:
1828             try compound-statement handler-seq  */
1829     case TRY_BLOCK:
1830       pp_maybe_newline_and_indent (pp, 0);
1831       pp_cxx_ws_string (pp, "try");
1832       pp_newline_and_indent (pp, 3);
1833       pp_cxx_statement (pp, TRY_STMTS (t));
1834       pp_newline_and_indent (pp, -3);
1835       if (CLEANUP_P (t))
1836         ;
1837       else
1838         pp_cxx_statement (pp, TRY_HANDLERS (t));
1839       break;
1840
1841       /*
1842          handler-seq:
1843             handler handler-seq(opt)
1844
1845          handler:
1846          catch ( exception-declaration ) compound-statement
1847
1848          exception-declaration:
1849             type-specifier-seq declarator
1850             type-specifier-seq abstract-declarator
1851             ...   */
1852     case HANDLER:
1853       pp_cxx_ws_string (pp, "catch");
1854       pp_cxx_left_paren (pp);
1855       pp_cxx_exception_declaration (pp, HANDLER_PARMS (t));
1856       pp_cxx_right_paren (pp);
1857       pp_indentation (pp) += 3;
1858       pp_needs_newline (pp) = true;
1859       pp_cxx_statement (pp, HANDLER_BODY (t));
1860       pp_indentation (pp) -= 3;
1861       pp_needs_newline (pp) = true;
1862       break;
1863
1864       /* selection-statement:
1865             if ( expression ) statement
1866             if ( expression ) statement else statement  */
1867     case IF_STMT:
1868       pp_cxx_ws_string (pp, "if");
1869       pp_cxx_whitespace (pp);
1870       pp_cxx_left_paren (pp);
1871       pp_cxx_expression (pp, IF_COND (t));
1872       pp_cxx_right_paren (pp);
1873       pp_newline_and_indent (pp, 2);
1874       pp_cxx_statement (pp, THEN_CLAUSE (t));
1875       pp_newline_and_indent (pp, -2);
1876       if (ELSE_CLAUSE (t))
1877         {
1878           tree else_clause = ELSE_CLAUSE (t);
1879           pp_cxx_ws_string (pp, "else");
1880           if (TREE_CODE (else_clause) == IF_STMT)
1881             pp_cxx_whitespace (pp);
1882           else
1883             pp_newline_and_indent (pp, 2);
1884           pp_cxx_statement (pp, else_clause);
1885           if (TREE_CODE (else_clause) != IF_STMT)
1886             pp_newline_and_indent (pp, -2);
1887         }
1888       break;
1889
1890     case SWITCH_STMT:
1891       pp_cxx_ws_string (pp, "switch");
1892       pp_space (pp);
1893       pp_cxx_left_paren (pp);
1894       pp_cxx_expression (pp, SWITCH_STMT_COND (t));
1895       pp_cxx_right_paren (pp);
1896       pp_indentation (pp) += 3;
1897       pp_needs_newline (pp) = true;
1898       pp_cxx_statement (pp, SWITCH_STMT_BODY (t));
1899       pp_newline_and_indent (pp, -3);
1900       break;
1901
1902       /* iteration-statement:
1903             while ( expression ) statement
1904             do statement while ( expression ) ;
1905             for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1906             for ( declaration expression(opt) ; expression(opt) ) statement  */
1907     case WHILE_STMT:
1908       pp_cxx_ws_string (pp, "while");
1909       pp_space (pp);
1910       pp_cxx_left_paren (pp);
1911       pp_cxx_expression (pp, WHILE_COND (t));
1912       pp_cxx_right_paren (pp);
1913       pp_newline_and_indent (pp, 3);
1914       pp_cxx_statement (pp, WHILE_BODY (t));
1915       pp_indentation (pp) -= 3;
1916       pp_needs_newline (pp) = true;
1917       break;
1918
1919     case DO_STMT:
1920       pp_cxx_ws_string (pp, "do");
1921       pp_newline_and_indent (pp, 3);
1922       pp_cxx_statement (pp, DO_BODY (t));
1923       pp_newline_and_indent (pp, -3);
1924       pp_cxx_ws_string (pp, "while");
1925       pp_space (pp);
1926       pp_cxx_left_paren (pp);
1927       pp_cxx_expression (pp, DO_COND (t));
1928       pp_cxx_right_paren (pp);
1929       pp_cxx_semicolon (pp);
1930       pp_needs_newline (pp) = true;
1931       break;
1932
1933     case FOR_STMT:
1934       pp_cxx_ws_string (pp, "for");
1935       pp_space (pp);
1936       pp_cxx_left_paren (pp);
1937       if (FOR_INIT_STMT (t))
1938         pp_cxx_statement (pp, FOR_INIT_STMT (t));
1939       else
1940         pp_cxx_semicolon (pp);
1941       pp_needs_newline (pp) = false;
1942       pp_cxx_whitespace (pp);
1943       if (FOR_COND (t))
1944         pp_cxx_expression (pp, FOR_COND (t));
1945       pp_cxx_semicolon (pp);
1946       pp_needs_newline (pp) = false;
1947       pp_cxx_whitespace (pp);
1948       if (FOR_EXPR (t))
1949         pp_cxx_expression (pp, FOR_EXPR (t));
1950       pp_cxx_right_paren (pp);
1951       pp_newline_and_indent (pp, 3);
1952       pp_cxx_statement (pp, FOR_BODY (t));
1953       pp_indentation (pp) -= 3;
1954       pp_needs_newline (pp) = true;
1955       break;
1956
1957     case RANGE_FOR_STMT:
1958       pp_cxx_ws_string (pp, "for");
1959       pp_space (pp);
1960       pp_cxx_left_paren (pp);
1961       pp_cxx_statement (pp, RANGE_FOR_DECL (t));
1962       pp_space (pp);
1963       pp_needs_newline (pp) = false;
1964       pp_colon (pp);
1965       pp_space (pp);
1966       pp_cxx_statement (pp, RANGE_FOR_EXPR (t));
1967       pp_cxx_right_paren (pp);
1968       pp_newline_and_indent (pp, 3);
1969       pp_cxx_statement (pp, FOR_BODY (t));
1970       pp_indentation (pp) -= 3;
1971       pp_needs_newline (pp) = true;
1972       break;
1973
1974       /* jump-statement:
1975             goto identifier;
1976             continue ;
1977             return expression(opt) ;  */
1978     case BREAK_STMT:
1979     case CONTINUE_STMT:
1980       pp_string (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
1981       pp_cxx_semicolon (pp);
1982       pp_needs_newline (pp) = true;
1983       break;
1984
1985       /* expression-statement:
1986             expression(opt) ;  */
1987     case EXPR_STMT:
1988       pp_cxx_expression (pp, EXPR_STMT_EXPR (t));
1989       pp_cxx_semicolon (pp);
1990       pp_needs_newline (pp) = true;
1991       break;
1992
1993     case CLEANUP_STMT:
1994       pp_cxx_ws_string (pp, "try");
1995       pp_newline_and_indent (pp, 2);
1996       pp_cxx_statement (pp, CLEANUP_BODY (t));
1997       pp_newline_and_indent (pp, -2);
1998       pp_cxx_ws_string (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
1999       pp_newline_and_indent (pp, 2);
2000       pp_cxx_statement (pp, CLEANUP_EXPR (t));
2001       pp_newline_and_indent (pp, -2);
2002       break;
2003
2004     case STATIC_ASSERT:
2005       pp_cxx_declaration (pp, t);
2006       break;
2007
2008     default:
2009       pp_c_statement (pp_c_base (pp), t);
2010       break;
2011     }
2012 }
2013
2014 /* original-namespace-definition:
2015       namespace identifier { namespace-body }
2016
2017   As an edge case, we also handle unnamed namespace definition here.  */
2018
2019 static void
2020 pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
2021 {
2022   pp_cxx_ws_string (pp, "namespace");
2023   if (DECL_CONTEXT (t))
2024     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2025   if (DECL_NAME (t))
2026     pp_cxx_unqualified_id (pp, t);
2027   pp_cxx_whitespace (pp);
2028   pp_cxx_left_brace (pp);
2029   /* We do not print the namespace-body.  */
2030   pp_cxx_whitespace (pp);
2031   pp_cxx_right_brace (pp);
2032 }
2033
2034 /* namespace-alias:
2035       identifier
2036
2037    namespace-alias-definition:
2038       namespace identifier = qualified-namespace-specifier ;
2039
2040    qualified-namespace-specifier:
2041       ::(opt) nested-name-specifier(opt) namespace-name   */
2042
2043 static void
2044 pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
2045 {
2046   pp_cxx_ws_string (pp, "namespace");
2047   if (DECL_CONTEXT (t))
2048     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2049   pp_cxx_unqualified_id (pp, t);
2050   pp_cxx_whitespace (pp);
2051   pp_equal (pp);
2052   pp_cxx_whitespace (pp);
2053   if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
2054     pp_cxx_nested_name_specifier (pp,
2055                                   DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
2056   pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
2057   pp_cxx_semicolon (pp);
2058 }
2059
2060 /* simple-declaration:
2061       decl-specifier-seq(opt) init-declarator-list(opt)  */
2062
2063 static void
2064 pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
2065 {
2066   pp_cxx_decl_specifier_seq (pp, t);
2067   pp_cxx_init_declarator (pp, t);
2068   pp_cxx_semicolon (pp);
2069   pp_needs_newline (pp) = true;
2070 }
2071
2072 /*
2073   template-parameter-list:
2074      template-parameter
2075      template-parameter-list , template-parameter  */
2076
2077 static inline void
2078 pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
2079 {
2080   const int n = TREE_VEC_LENGTH (t);
2081   int i;
2082   for (i = 0; i < n; ++i)
2083     {
2084       if (i)
2085         pp_cxx_separate_with (pp, ',');
2086       pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
2087     }
2088 }
2089
2090 /* template-parameter:
2091       type-parameter
2092       parameter-declaration
2093
2094    type-parameter:
2095      class ...(opt) identifier(opt)
2096      class identifier(opt) = type-id
2097      typename identifier(opt)
2098      typename ...(opt) identifier(opt) = type-id
2099      template < template-parameter-list > class ...(opt) identifier(opt)
2100      template < template-parameter-list > class identifier(opt) = template-name  */
2101
2102 static void
2103 pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
2104 {
2105   tree parameter =  TREE_VALUE (t);
2106   switch (TREE_CODE (parameter))
2107     {
2108     case TYPE_DECL:
2109       pp_cxx_ws_string (pp, "class");
2110       if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2111         pp_cxx_ws_string (pp, "...");
2112       if (DECL_NAME (parameter))
2113         pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
2114       /* FIXME: Check if we should print also default argument.  */
2115       break;
2116
2117     case PARM_DECL:
2118       pp_cxx_parameter_declaration (pp, parameter);
2119       break;
2120
2121     case TEMPLATE_DECL:
2122       break;
2123
2124     default:
2125       pp_unsupported_tree (pp, t);
2126       break;
2127     }
2128 }
2129
2130 /* Pretty-print a template parameter in the canonical form
2131    "template-parameter-<level>-<position in parameter list>".  */
2132
2133 void
2134 pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
2135 {
2136   const enum tree_code code = TREE_CODE (parm);
2137
2138   /* Brings type template parameters to the canonical forms.  */
2139   if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
2140       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
2141     parm = TEMPLATE_TYPE_PARM_INDEX (parm);
2142
2143   pp_cxx_begin_template_argument_list (pp);
2144   pp_cxx_ws_string (pp, M_("template-parameter-"));
2145   pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
2146   pp_minus (pp);
2147   pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
2148   pp_cxx_end_template_argument_list (pp);
2149 }
2150
2151 /*
2152   template-declaration:
2153      export(opt) template < template-parameter-list > declaration   */
2154
2155 static void
2156 pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
2157 {
2158   tree tmpl = most_general_template (t);
2159   tree level;
2160
2161   pp_maybe_newline_and_indent (pp, 0);
2162   for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
2163     {
2164       pp_cxx_ws_string (pp, "template");
2165       pp_cxx_begin_template_argument_list (pp);
2166       pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
2167       pp_cxx_end_template_argument_list (pp);
2168       pp_newline_and_indent (pp, 3);
2169     }
2170   if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
2171     pp_cxx_function_definition (pp, t);
2172   else
2173     pp_cxx_simple_declaration (pp, t);
2174 }
2175
2176 static void
2177 pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
2178 {
2179   pp_unsupported_tree (pp, t);
2180 }
2181
2182 static void
2183 pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
2184 {
2185   pp_unsupported_tree (pp, t);
2186 }
2187
2188 /*
2189     declaration:
2190        block-declaration
2191        function-definition
2192        template-declaration
2193        explicit-instantiation
2194        explicit-specialization
2195        linkage-specification
2196        namespace-definition
2197
2198     block-declaration:
2199        simple-declaration
2200        asm-definition
2201        namespace-alias-definition
2202        using-declaration
2203        using-directive
2204        static_assert-declaration */
2205 void
2206 pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
2207 {
2208   if (TREE_CODE (t) == STATIC_ASSERT)
2209     {
2210       pp_cxx_ws_string (pp, "static_assert");
2211       pp_cxx_left_paren (pp);
2212       pp_cxx_expression (pp, STATIC_ASSERT_CONDITION (t));
2213       pp_cxx_separate_with (pp, ',');
2214       pp_cxx_expression (pp, STATIC_ASSERT_MESSAGE (t));
2215       pp_cxx_right_paren (pp);
2216     }
2217   else if (!DECL_LANG_SPECIFIC (t))
2218     pp_cxx_simple_declaration (pp, t);
2219   else if (DECL_USE_TEMPLATE (t))
2220     switch (DECL_USE_TEMPLATE (t))
2221       {
2222       case 1:
2223         pp_cxx_template_declaration (pp, t);
2224         break;
2225
2226       case 2:
2227         pp_cxx_explicit_specialization (pp, t);
2228         break;
2229
2230       case 3:
2231         pp_cxx_explicit_instantiation (pp, t);
2232         break;
2233
2234       default:
2235         break;
2236       }
2237   else switch (TREE_CODE (t))
2238     {
2239     case VAR_DECL:
2240     case TYPE_DECL:
2241       pp_cxx_simple_declaration (pp, t);
2242       break;
2243
2244     case FUNCTION_DECL:
2245       if (DECL_SAVED_TREE (t))
2246         pp_cxx_function_definition (pp, t);
2247       else
2248         pp_cxx_simple_declaration (pp, t);
2249       break;
2250
2251     case NAMESPACE_DECL:
2252       if (DECL_NAMESPACE_ALIAS (t))
2253         pp_cxx_namespace_alias_definition (pp, t);
2254       else
2255         pp_cxx_original_namespace_definition (pp, t);
2256       break;
2257
2258     default:
2259       pp_unsupported_tree (pp, t);
2260       break;
2261     }
2262 }
2263
2264 static void
2265 pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
2266 {
2267   t = TREE_OPERAND (t, 0);
2268   pp_cxx_ws_string (pp, "typeid");
2269   pp_cxx_left_paren (pp);
2270   if (TYPE_P (t))
2271     pp_cxx_type_id (pp, t);
2272   else
2273     pp_cxx_expression (pp, t);
2274   pp_cxx_right_paren (pp);
2275 }
2276
2277 void
2278 pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
2279 {
2280   pp_cxx_ws_string (pp, "va_arg");
2281   pp_cxx_left_paren (pp);
2282   pp_cxx_assignment_expression (pp, TREE_OPERAND (t, 0));
2283   pp_cxx_separate_with (pp, ',');
2284   pp_cxx_type_id (pp, TREE_TYPE (t));
2285   pp_cxx_right_paren (pp);
2286 }
2287
2288 static bool
2289 pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
2290 {
2291   switch (TREE_CODE (t))
2292     {
2293     case ARROW_EXPR:
2294       if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR
2295           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
2296         {
2297           pp_cxx_type_id (pp, TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))));
2298           pp_cxx_separate_with (pp, ',');
2299           return true;
2300         }
2301       return false;
2302     case COMPONENT_REF:
2303       if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2304         return false;
2305       if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
2306         pp_cxx_dot (pp);
2307       pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2308       return true;
2309     case ARRAY_REF:
2310       if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2311         return false;
2312       pp_left_bracket (pp);
2313       pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2314       pp_right_bracket (pp);
2315       return true;
2316     default:
2317       return false;
2318     }
2319 }
2320
2321 void
2322 pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
2323 {
2324   pp_cxx_ws_string (pp, "offsetof");
2325   pp_cxx_left_paren (pp);
2326   if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2327     pp_cxx_expression (pp, TREE_OPERAND (t, 0));
2328   pp_cxx_right_paren (pp);
2329 }
2330
2331 void
2332 pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
2333 {
2334   cp_trait_kind kind = TRAIT_EXPR_KIND (t);
2335
2336   switch (kind)
2337     {
2338     case CPTK_HAS_NOTHROW_ASSIGN:
2339       pp_cxx_ws_string (pp, "__has_nothrow_assign");
2340       break;
2341     case CPTK_HAS_TRIVIAL_ASSIGN:
2342       pp_cxx_ws_string (pp, "__has_trivial_assign");
2343       break;
2344     case CPTK_HAS_NOTHROW_CONSTRUCTOR:
2345       pp_cxx_ws_string (pp, "__has_nothrow_constructor");
2346       break;
2347     case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
2348       pp_cxx_ws_string (pp, "__has_trivial_constructor");
2349       break;
2350     case CPTK_HAS_NOTHROW_COPY:
2351       pp_cxx_ws_string (pp, "__has_nothrow_copy");
2352       break;
2353     case CPTK_HAS_TRIVIAL_COPY:
2354       pp_cxx_ws_string (pp, "__has_trivial_copy");
2355       break;
2356     case CPTK_HAS_TRIVIAL_DESTRUCTOR:
2357       pp_cxx_ws_string (pp, "__has_trivial_destructor");
2358       break;
2359     case CPTK_HAS_VIRTUAL_DESTRUCTOR:
2360       pp_cxx_ws_string (pp, "__has_virtual_destructor");
2361       break;
2362     case CPTK_IS_ABSTRACT:
2363       pp_cxx_ws_string (pp, "__is_abstract");
2364       break;
2365     case CPTK_IS_BASE_OF:
2366       pp_cxx_ws_string (pp, "__is_base_of");
2367       break;
2368     case CPTK_IS_CLASS:
2369       pp_cxx_ws_string (pp, "__is_class");
2370       break;
2371     case CPTK_IS_CONVERTIBLE_TO:
2372       pp_cxx_ws_string (pp, "__is_convertible_to");
2373       break;
2374     case CPTK_IS_EMPTY:
2375       pp_cxx_ws_string (pp, "__is_empty");
2376       break;
2377     case CPTK_IS_ENUM:
2378       pp_cxx_ws_string (pp, "__is_enum");
2379       break;
2380     case CPTK_IS_FINAL:
2381       pp_cxx_ws_string (pp, "__is_final");
2382       break;
2383     case CPTK_IS_POD:
2384       pp_cxx_ws_string (pp, "__is_pod");
2385       break;
2386     case CPTK_IS_POLYMORPHIC:
2387       pp_cxx_ws_string (pp, "__is_polymorphic");
2388       break;
2389     case CPTK_IS_STD_LAYOUT:
2390       pp_cxx_ws_string (pp, "__is_std_layout");
2391       break;
2392     case CPTK_IS_TRIVIAL:
2393       pp_cxx_ws_string (pp, "__is_trivial");
2394       break;
2395     case CPTK_IS_UNION:
2396       pp_cxx_ws_string (pp, "__is_union");
2397       break;
2398     case CPTK_IS_LITERAL_TYPE:
2399       pp_cxx_ws_string (pp, "__is_literal_type");
2400       break;
2401
2402     default:
2403       gcc_unreachable ();
2404     }
2405
2406   pp_cxx_left_paren (pp);
2407   pp_cxx_type_id (pp, TRAIT_EXPR_TYPE1 (t));
2408
2409   if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
2410     {
2411       pp_cxx_separate_with (pp, ',');
2412       pp_cxx_type_id (pp, TRAIT_EXPR_TYPE2 (t));
2413     }
2414
2415   pp_cxx_right_paren (pp);
2416 }
2417 \f
2418 typedef c_pretty_print_fn pp_fun;
2419
2420 /* Initialization of a C++ pretty-printer object.  */
2421
2422 void
2423 pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
2424 {
2425   pp_c_pretty_printer_init (pp_c_base (pp));
2426   pp_set_line_maximum_length (pp, 0);
2427
2428   pp->c_base.declaration = (pp_fun) pp_cxx_declaration;
2429   pp->c_base.declaration_specifiers = (pp_fun) pp_cxx_decl_specifier_seq;
2430   pp->c_base.function_specifier = (pp_fun) pp_cxx_function_specifier;
2431   pp->c_base.type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
2432   pp->c_base.declarator = (pp_fun) pp_cxx_declarator;
2433   pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator;
2434   pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
2435   pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
2436   pp->c_base.abstract_declarator = (pp_fun) pp_cxx_abstract_declarator;
2437   pp->c_base.direct_abstract_declarator =
2438     (pp_fun) pp_cxx_direct_abstract_declarator;
2439   pp->c_base.simple_type_specifier = (pp_fun)pp_cxx_simple_type_specifier;
2440
2441   /* pp->c_base.statement = (pp_fun) pp_cxx_statement;  */
2442
2443   pp->c_base.constant = (pp_fun) pp_cxx_constant;
2444   pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
2445   pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression;
2446   pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression;
2447   pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression;
2448   pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
2449   pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
2450   pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
2451   pp->c_base.expression = (pp_fun) pp_cxx_expression;
2452   pp->enclosing_scope = global_namespace;
2453 }