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