LCOV - code coverage report
Current view: top level - gcc/cp - cxx-pretty-print.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 882 1713 51.5 %
Date: 2020-03-28 11:57:23 Functions: 61 85 71.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Implementation of subroutines for the GNU C++ pretty-printer.
       2                 :            :    Copyright (C) 2003-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "cp-tree.h"
      25                 :            : #include "cxx-pretty-print.h"
      26                 :            : #include "tree-pretty-print.h"
      27                 :            : 
      28                 :            : static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree);
      29                 :            : static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree);
      30                 :            : static void pp_cxx_qualified_id (cxx_pretty_printer *, tree);
      31                 :            : static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree);
      32                 :            : static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree);
      33                 :            : static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree);
      34                 :            : static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree);
      35                 :            : static void pp_cxx_template_parameter (cxx_pretty_printer *, tree);
      36                 :            : static void pp_cxx_cast_expression (cxx_pretty_printer *, tree);
      37                 :            : static void pp_cxx_typeid_expression (cxx_pretty_printer *, tree);
      38                 :            : static void pp_cxx_unary_left_fold_expression (cxx_pretty_printer *, tree);
      39                 :            : static void pp_cxx_unary_right_fold_expression (cxx_pretty_printer *, tree);
      40                 :            : static void pp_cxx_binary_fold_expression (cxx_pretty_printer *, tree);
      41                 :            : static void pp_cxx_concept_definition (cxx_pretty_printer *, tree);
      42                 :            : 
      43                 :            : 
      44                 :            : static inline void
      45                 :   60407700 : pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c)
      46                 :            : {
      47                 :   60407700 :   const char *p = pp_last_position_in_text (pp);
      48                 :            : 
      49                 :   60407700 :   if (p != NULL && *p == c)
      50                 :    9942910 :     pp_cxx_whitespace (pp);
      51                 :   60407700 :   pp_character (pp, c);
      52                 :   60407700 :   pp->padding = pp_none;
      53                 :   60407700 : }
      54                 :            : 
      55                 :            : #define pp_cxx_expression_list(PP, T)    \
      56                 :            :    pp_c_expression_list (PP, T)
      57                 :            : #define pp_cxx_space_for_pointer_operator(PP, T)  \
      58                 :            :    pp_c_space_for_pointer_operator (PP, T)
      59                 :            : #define pp_cxx_init_declarator(PP, T)    \
      60                 :            :    pp_c_init_declarator (PP, T)
      61                 :            : #define pp_cxx_call_argument_list(PP, T) \
      62                 :            :    pp_c_call_argument_list (PP, T)
      63                 :            : 
      64                 :            : void
      65                 :   47311900 : pp_cxx_colon_colon (cxx_pretty_printer *pp)
      66                 :            : {
      67                 :   47311900 :   pp_colon_colon (pp);
      68                 :   47311900 :   pp->padding = pp_none;
      69                 :   47311900 : }
      70                 :            : 
      71                 :            : void
      72                 :   30203900 : pp_cxx_begin_template_argument_list (cxx_pretty_printer *pp)
      73                 :            : {
      74                 :   30203900 :   pp_cxx_nonconsecutive_character (pp, '<');
      75                 :   30203900 : }
      76                 :            : 
      77                 :            : void
      78                 :   30203900 : pp_cxx_end_template_argument_list (cxx_pretty_printer *pp)
      79                 :            : {
      80                 :   30203900 :   pp_cxx_nonconsecutive_character (pp, '>');
      81                 :   30203900 : }
      82                 :            : 
      83                 :            : void
      84                 :   20760100 : pp_cxx_separate_with (cxx_pretty_printer *pp, int c)
      85                 :            : {
      86                 :   20760100 :   pp_separate_with (pp, c);
      87                 :   20760100 :   pp->padding = pp_none;
      88                 :   20760100 : }
      89                 :            : 
      90                 :            : /* Expressions.  */
      91                 :            : 
      92                 :            : /* conversion-function-id:
      93                 :            :       operator conversion-type-id
      94                 :            : 
      95                 :            :    conversion-type-id:
      96                 :            :       type-specifier-seq conversion-declarator(opt)
      97                 :            : 
      98                 :            :    conversion-declarator:
      99                 :            :       ptr-operator conversion-declarator(opt)  */
     100                 :            : 
     101                 :            : static inline void
     102                 :          0 : pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
     103                 :            : {
     104                 :          0 :   pp_cxx_ws_string (pp, "operator");
     105                 :          0 :   pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
     106                 :          0 : }
     107                 :            : 
     108                 :            : static inline void
     109                 :        320 : pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
     110                 :            : {
     111                 :        320 :   pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
     112                 :        320 :   pp_cxx_begin_template_argument_list (pp);
     113                 :        320 :   pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1));
     114                 :        320 :   pp_cxx_end_template_argument_list (pp);
     115                 :        320 : }
     116                 :            : 
     117                 :            : /* Prints the unqualified part of the id-expression T.
     118                 :            : 
     119                 :            :    unqualified-id:
     120                 :            :      identifier
     121                 :            :      operator-function-id
     122                 :            :      conversion-function-id
     123                 :            :      ~ class-name
     124                 :            :      template-id  */
     125                 :            : 
     126                 :            : static void
     127                 :   14870900 : pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
     128                 :            : {
     129                 :   14871700 :   enum tree_code code = TREE_CODE (t);
     130                 :   14871700 :   switch (code)
     131                 :            :     {
     132                 :          0 :     case RESULT_DECL:
     133                 :          0 :       pp->translate_string ("<return-value>");
     134                 :          0 :       break;
     135                 :            : 
     136                 :            :     case OVERLOAD:
     137                 :   14554300 :       t = OVL_FIRST (t);
     138                 :            :       /* FALLTHRU */
     139                 :   14554300 :     case VAR_DECL:
     140                 :   14554300 :     case PARM_DECL:
     141                 :   14554300 :     case CONST_DECL:
     142                 :   14554300 :     case TYPE_DECL:
     143                 :   14554300 :     case FUNCTION_DECL:
     144                 :   14554300 :     case NAMESPACE_DECL:
     145                 :   14554300 :     case FIELD_DECL:
     146                 :   14554300 :     case LABEL_DECL:
     147                 :   14554300 :     case USING_DECL:
     148                 :   14554300 :     case TEMPLATE_DECL:
     149                 :   14554300 :       t = DECL_NAME (t);
     150                 :            :       /* FALLTHRU */
     151                 :            : 
     152                 :   14555300 :     case IDENTIFIER_NODE:
     153                 :   14555300 :       if (t == NULL)
     154                 :          4 :         pp->translate_string ("<unnamed>");
     155                 :   14555200 :       else if (IDENTIFIER_CONV_OP_P (t))
     156                 :          0 :         pp_cxx_conversion_function_id (pp, t);
     157                 :            :       else
     158                 :   14555200 :         pp_cxx_tree_identifier (pp, t);
     159                 :            :       break;
     160                 :            : 
     161                 :          0 :     case TEMPLATE_ID_EXPR:
     162                 :          0 :       pp_cxx_template_id (pp, t);
     163                 :          0 :       break;
     164                 :            : 
     165                 :          0 :     case BASELINK:
     166                 :          0 :       pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
     167                 :          0 :       break;
     168                 :            : 
     169                 :     315666 :     case RECORD_TYPE:
     170                 :     315666 :     case UNION_TYPE:
     171                 :     315666 :     case ENUMERAL_TYPE:
     172                 :     315666 :     case TYPENAME_TYPE:
     173                 :     315666 :     case UNBOUND_CLASS_TEMPLATE:
     174                 :     315666 :       pp_cxx_unqualified_id (pp, TYPE_NAME (t));
     175                 :     631328 :       if (tree ti = TYPE_TEMPLATE_INFO_MAYBE_ALIAS (t))
     176                 :            :         {
     177                 :        149 :           pp_cxx_begin_template_argument_list (pp);
     178                 :        149 :           tree args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (ti));
     179                 :        149 :           pp_cxx_template_argument_list (pp, args);
     180                 :        149 :           pp_cxx_end_template_argument_list (pp);
     181                 :            :         }
     182                 :            :       break;
     183                 :            : 
     184                 :          0 :     case BIT_NOT_EXPR:
     185                 :          0 :       pp_cxx_complement (pp);
     186                 :          0 :       pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
     187                 :          0 :       break;
     188                 :            : 
     189                 :        683 :     case TEMPLATE_TYPE_PARM:
     190                 :        683 :     case TEMPLATE_TEMPLATE_PARM:
     191                 :        683 :       if (template_placeholder_p (t))
     192                 :            :         {
     193                 :          0 :           t = TREE_TYPE (CLASS_PLACEHOLDER_TEMPLATE (t));
     194                 :          0 :           pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
     195                 :          0 :           pp_string (pp, "<...auto...>");
     196                 :            :         }
     197                 :        683 :       else if (TYPE_IDENTIFIER (t))
     198                 :        683 :         pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
     199                 :            :       else
     200                 :          0 :         pp_cxx_canonical_template_parameter (pp, t);
     201                 :            :       break;
     202                 :            : 
     203                 :         59 :     case TEMPLATE_PARM_INDEX:
     204                 :         59 :       pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
     205                 :         59 :       break;
     206                 :            : 
     207                 :          0 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
     208                 :          0 :       pp_cxx_cv_qualifier_seq (pp, t);
     209                 :          0 :       pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
     210                 :          0 :       pp_cxx_begin_template_argument_list (pp);
     211                 :          0 :       pp_cxx_template_argument_list (pp, TYPE_TI_ARGS (t));
     212                 :          0 :       pp_cxx_end_template_argument_list (pp);
     213                 :          0 :       break;
     214                 :            : 
     215                 :          0 :     default:
     216                 :          0 :       pp_unsupported_tree (pp, t);
     217                 :          0 :       break;
     218                 :            :     }
     219                 :   14870900 : }
     220                 :            : 
     221                 :            : /* Pretty-print out the token sequence ":: template" in template codes
     222                 :            :    where it is needed to "inline declare" the (following) member as
     223                 :            :    a template.  This situation arises when SCOPE of T is dependent
     224                 :            :    on template parameters.  */
     225                 :            : 
     226                 :            : static inline void
     227                 :     639644 : pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
     228                 :            : {
     229                 :     639644 :   if (TREE_CODE (t) == TEMPLATE_ID_EXPR
     230                 :     639644 :       && TYPE_P (scope) && dependent_type_p (scope))
     231                 :          0 :     pp_cxx_ws_string (pp, "template");
     232                 :     639644 : }
     233                 :            : 
     234                 :            : /* nested-name-specifier:
     235                 :            :       class-or-namespace-name :: nested-name-specifier(opt)
     236                 :            :       class-or-namespace-name :: template nested-name-specifier   */
     237                 :            : 
     238                 :            : static void
     239                 :     639992 : pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
     240                 :            : {
     241                 :            :   /* FIXME: When diagnosing references to concepts (especially as types?)
     242                 :            :      we end up adding too many '::' to the name. This is partially due
     243                 :            :      to the fact that pp->enclosing_namespace is null.  */
     244                 :     639992 :   if (t == global_namespace)
     245                 :            :     {
     246                 :         11 :       pp_cxx_colon_colon (pp);
     247                 :            :     }
     248                 :     639981 :   else if (!SCOPE_FILE_SCOPE_P (t) && t != pp->enclosing_scope)
     249                 :            :     {
     250                 :     323892 :       tree scope = get_containing_scope (t);
     251                 :     323892 :       pp_cxx_nested_name_specifier (pp, scope);
     252                 :     323892 :       pp_cxx_template_keyword_if_needed (pp, scope, t);
     253                 :     323892 :       pp_cxx_unqualified_id (pp, t);
     254                 :     323892 :       pp_cxx_colon_colon (pp);
     255                 :            :     }
     256                 :     639992 : }
     257                 :            : 
     258                 :            : /* qualified-id:
     259                 :            :       nested-name-specifier template(opt) unqualified-id  */
     260                 :            : 
     261                 :            : static void
     262                 :     315796 : pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
     263                 :            : {
     264                 :     315796 :   switch (TREE_CODE (t))
     265                 :            :     {
     266                 :            :       /* A pointer-to-member is always qualified.  */
     267                 :          0 :     case PTRMEM_CST:
     268                 :          0 :       pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
     269                 :          0 :       pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
     270                 :          0 :       break;
     271                 :            : 
     272                 :            :       /* In Standard C++, functions cannot possibly be used as
     273                 :            :          nested-name-specifiers.  However, there are situations where
     274                 :            :          is "makes sense" to output the surrounding function name for the
     275                 :            :          purpose of emphasizing on the scope kind.  Just printing the
     276                 :            :          function name might not be sufficient as it may be overloaded; so,
     277                 :            :          we decorate the function with its signature too.
     278                 :            :          FIXME:  This is probably the wrong pretty-printing for conversion
     279                 :            :          functions and some function templates.  */
     280                 :            :     case OVERLOAD:
     281                 :          2 :       t = OVL_FIRST (t);
     282                 :            :       /* FALLTHRU */
     283                 :          2 :     case FUNCTION_DECL:
     284                 :          4 :       if (DECL_FUNCTION_MEMBER_P (t))
     285                 :          0 :         pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
     286                 :          2 :       pp_cxx_unqualified_id
     287                 :          4 :         (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
     288                 :          2 :       pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
     289                 :          2 :       break;
     290                 :            : 
     291                 :          9 :     case OFFSET_REF:
     292                 :          9 :     case SCOPE_REF:
     293                 :          9 :       pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
     294                 :          9 :       pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
     295                 :          9 :       break;
     296                 :            : 
     297                 :     315785 :     default:
     298                 :     315785 :       {
     299                 :     315785 :         tree scope = get_containing_scope (t);
     300                 :     315785 :         if (scope != pp->enclosing_scope)
     301                 :            :           {
     302                 :     315752 :             pp_cxx_nested_name_specifier (pp, scope);
     303                 :     315752 :             pp_cxx_template_keyword_if_needed (pp, scope, t);
     304                 :            :           }
     305                 :     315785 :         pp_cxx_unqualified_id (pp, t);
     306                 :            :       }
     307                 :     315785 :       break;
     308                 :            :     }
     309                 :     315796 : }
     310                 :            : 
     311                 :            : /* Given a value e of ENUMERAL_TYPE:
     312                 :            :    Print out the first ENUMERATOR id with value e, if one is found,
     313                 :            :    (including nested names but excluding the enum name if unscoped)
     314                 :            :    else print out the value as a C-style cast (type-id)value.  */
     315                 :            : 
     316                 :            : static void
     317                 :     315591 : pp_cxx_enumeration_constant (cxx_pretty_printer *pp, tree e)
     318                 :            : {
     319                 :     315591 :   tree type = TREE_TYPE (e);
     320                 :     315591 :   tree value = NULL_TREE;
     321                 :            : 
     322                 :            :   /* Find the name of this constant.  */
     323                 :     315591 :   if ((pp->flags & pp_c_flag_gnu_v3) == 0)
     324                 :        629 :     for (value = TYPE_VALUES (type); value != NULL_TREE;
     325                 :        201 :          value = TREE_CHAIN (value))
     326                 :        428 :       if (tree_int_cst_equal (DECL_INITIAL (TREE_VALUE (value)), e))
     327                 :            :         break;
     328                 :            : 
     329                 :        227 :   if (value != NULL_TREE)
     330                 :            :     {
     331                 :        227 :       if (!ENUM_IS_SCOPED (type))
     332                 :        220 :         type = get_containing_scope (type);
     333                 :        227 :       pp_cxx_nested_name_specifier (pp, type);
     334                 :        227 :       pp->id_expression (TREE_PURPOSE (value));
     335                 :            :     }
     336                 :            :   else
     337                 :            :     {
     338                 :            :       /* Value must have been cast.  */
     339                 :     315364 :        pp_c_type_cast (pp, type);
     340                 :     315364 :        pp_c_integer_constant (pp, e);
     341                 :            :     }
     342                 :     315591 : }
     343                 :            : 
     344                 :            : 
     345                 :            : void
     346                 :    5521760 : cxx_pretty_printer::constant (tree t)
     347                 :            : {
     348                 :    5521760 :   switch (TREE_CODE (t))
     349                 :            :     {
     350                 :         96 :     case STRING_CST:
     351                 :         96 :       {
     352                 :         96 :         const bool in_parens = PAREN_STRING_LITERAL_P (t);
     353                 :         96 :         if (in_parens)
     354                 :          4 :           pp_cxx_left_paren (this);
     355                 :         96 :         c_pretty_printer::constant (t);
     356                 :         96 :         if (in_parens)
     357                 :          4 :           pp_cxx_right_paren (this);
     358                 :            :       }
     359                 :            :       break;
     360                 :            : 
     361                 :    5520930 :     case INTEGER_CST:
     362                 :    5520930 :       if (NULLPTR_TYPE_P (TREE_TYPE (t)))
     363                 :            :         {
     364                 :          0 :           pp_string (this, "nullptr");
     365                 :          0 :           break;
     366                 :            :         }
     367                 :    5520930 :       else if (TREE_CODE (TREE_TYPE (t)) == ENUMERAL_TYPE)
     368                 :            :         {
     369                 :     315591 :           pp_cxx_enumeration_constant (this, t);
     370                 :     315591 :           break;
     371                 :            :         }
     372                 :            :       /* fall through.  */
     373                 :            : 
     374                 :    5206080 :     default:
     375                 :    5206080 :       c_pretty_printer::constant (t);
     376                 :    5206080 :       break;
     377                 :            :     }
     378                 :    5521760 : }
     379                 :            : 
     380                 :            : /* id-expression:
     381                 :            :       unqualified-id
     382                 :            :       qualified-id   */
     383                 :            : 
     384                 :            : void
     385                 :   13914600 : cxx_pretty_printer::id_expression (tree t)
     386                 :            : {
     387                 :   13914600 :   if (TREE_CODE (t) == OVERLOAD)
     388                 :   13914600 :     t = OVL_FIRST (t);
     389                 :   27828900 :   if (DECL_P (t) && DECL_CONTEXT (t))
     390                 :        187 :     pp_cxx_qualified_id (this, t);
     391                 :            :   else
     392                 :   13914400 :     pp_cxx_unqualified_id (this, t);
     393                 :   13914600 : }
     394                 :            : 
     395                 :            : /* user-defined literal:
     396                 :            :       literal ud-suffix  */
     397                 :            : 
     398                 :            : void
     399                 :          0 : pp_cxx_userdef_literal (cxx_pretty_printer *pp, tree t)
     400                 :            : {
     401                 :          0 :   pp->constant (USERDEF_LITERAL_VALUE (t));
     402                 :          0 :   pp->id_expression (USERDEF_LITERAL_SUFFIX_ID (t));
     403                 :          0 : }
     404                 :            : 
     405                 :            : 
     406                 :            : /* primary-expression:
     407                 :            :      literal
     408                 :            :      this
     409                 :            :      :: identifier
     410                 :            :      :: operator-function-id
     411                 :            :      :: qualifier-id
     412                 :            :      ( expression )
     413                 :            :      id-expression   
     414                 :            : 
     415                 :            :    GNU Extensions:
     416                 :            :      __builtin_va_arg ( assignment-expression , type-id )
     417                 :            :      __builtin_offsetof ( type-id, offsetof-expression )
     418                 :            :      __builtin_addressof ( expression )
     419                 :            : 
     420                 :            :      __has_nothrow_assign ( type-id )   
     421                 :            :      __has_nothrow_constructor ( type-id )
     422                 :            :      __has_nothrow_copy ( type-id )
     423                 :            :      __has_trivial_assign ( type-id )   
     424                 :            :      __has_trivial_constructor ( type-id )
     425                 :            :      __has_trivial_copy ( type-id )
     426                 :            :      __has_unique_object_representations ( type-id )
     427                 :            :      __has_trivial_destructor ( type-id )
     428                 :            :      __has_virtual_destructor ( type-id )     
     429                 :            :      __is_abstract ( type-id )
     430                 :            :      __is_base_of ( type-id , type-id )
     431                 :            :      __is_class ( type-id )
     432                 :            :      __is_empty ( type-id )
     433                 :            :      __is_enum ( type-id )
     434                 :            :      __is_literal_type ( type-id )
     435                 :            :      __is_pod ( type-id )
     436                 :            :      __is_polymorphic ( type-id )
     437                 :            :      __is_std_layout ( type-id )
     438                 :            :      __is_trivial ( type-id )
     439                 :            :      __is_union ( type-id )  */
     440                 :            : 
     441                 :            : void
     442                 :        559 : cxx_pretty_printer::primary_expression (tree t)
     443                 :            : {
     444                 :        559 :   switch (TREE_CODE (t))
     445                 :            :     {
     446                 :         11 :     case VOID_CST:
     447                 :         11 :     case INTEGER_CST:
     448                 :         11 :     case REAL_CST:
     449                 :         11 :     case COMPLEX_CST:
     450                 :         11 :     case STRING_CST:
     451                 :         11 :       constant (t);
     452                 :         11 :       break;
     453                 :            : 
     454                 :          0 :     case USERDEF_LITERAL:
     455                 :          0 :       pp_cxx_userdef_literal (this, t);
     456                 :          0 :       break;
     457                 :            : 
     458                 :          0 :     case BASELINK:
     459                 :          0 :       t = BASELINK_FUNCTIONS (t);
     460                 :            :       /* FALLTHRU */
     461                 :        181 :     case VAR_DECL:
     462                 :        181 :     case PARM_DECL:
     463                 :        181 :     case FIELD_DECL:
     464                 :        181 :     case FUNCTION_DECL:
     465                 :        181 :     case OVERLOAD:
     466                 :        181 :     case CONST_DECL:
     467                 :        181 :     case TEMPLATE_DECL:
     468                 :        181 :       id_expression (t);
     469                 :        181 :       break;
     470                 :            : 
     471                 :         59 :     case RESULT_DECL:
     472                 :         59 :     case TEMPLATE_TYPE_PARM:
     473                 :         59 :     case TEMPLATE_TEMPLATE_PARM:
     474                 :         59 :     case TEMPLATE_PARM_INDEX:
     475                 :         59 :       pp_cxx_unqualified_id (this, t);
     476                 :         59 :       break;
     477                 :            : 
     478                 :          0 :     case STMT_EXPR:
     479                 :          0 :       pp_cxx_left_paren (this);
     480                 :          0 :       statement (STMT_EXPR_STMT (t));
     481                 :          0 :       pp_cxx_right_paren (this);
     482                 :          0 :       break;
     483                 :            : 
     484                 :         13 :     case TRAIT_EXPR:
     485                 :         13 :       pp_cxx_trait_expression (this, t);
     486                 :         13 :       break;
     487                 :            : 
     488                 :          0 :     case VA_ARG_EXPR:
     489                 :          0 :       pp_cxx_va_arg_expression (this, t);
     490                 :          0 :       break;
     491                 :            : 
     492                 :          0 :     case OFFSETOF_EXPR:
     493                 :          0 :       pp_cxx_offsetof_expression (this, t);
     494                 :          0 :       break;
     495                 :            : 
     496                 :          0 :     case ADDRESSOF_EXPR:
     497                 :          0 :       pp_cxx_addressof_expression (this, t);
     498                 :          0 :       break;
     499                 :            : 
     500                 :         15 :     case REQUIRES_EXPR:
     501                 :         15 :       pp_cxx_requires_expr (this, t);
     502                 :         15 :       break;
     503                 :            : 
     504                 :        280 :     default:
     505                 :        280 :       c_pretty_printer::primary_expression (t);
     506                 :        280 :       break;
     507                 :            :     }
     508                 :        559 : }
     509                 :            : 
     510                 :            : /* postfix-expression:
     511                 :            :      primary-expression
     512                 :            :      postfix-expression [ expression ]
     513                 :            :      postfix-expression ( expression-list(opt) )
     514                 :            :      simple-type-specifier ( expression-list(opt) )
     515                 :            :      typename ::(opt) nested-name-specifier identifier ( expression-list(opt) )
     516                 :            :      typename ::(opt) nested-name-specifier template(opt)
     517                 :            :                                        template-id ( expression-list(opt) )
     518                 :            :      postfix-expression . template(opt) ::(opt) id-expression
     519                 :            :      postfix-expression -> template(opt) ::(opt) id-expression
     520                 :            :      postfix-expression . pseudo-destructor-name
     521                 :            :      postfix-expression -> pseudo-destructor-name
     522                 :            :      postfix-expression ++
     523                 :            :      postfix-expression --
     524                 :            :      dynamic_cast < type-id > ( expression )
     525                 :            :      static_cast < type-id > ( expression )
     526                 :            :      reinterpret_cast < type-id > ( expression )
     527                 :            :      const_cast < type-id > ( expression )
     528                 :            :      typeid ( expression )
     529                 :            :      typeid ( type-id )  */
     530                 :            : 
     531                 :            : void
     532                 :        586 : cxx_pretty_printer::postfix_expression (tree t)
     533                 :            : {
     534                 :        586 :   enum tree_code code = TREE_CODE (t);
     535                 :            : 
     536                 :        586 :   switch (code)
     537                 :            :     {
     538                 :        137 :     case AGGR_INIT_EXPR:
     539                 :        137 :     case CALL_EXPR:
     540                 :        137 :       {
     541                 :        137 :         tree fun = cp_get_callee (t);
     542                 :        137 :         tree saved_scope = enclosing_scope;
     543                 :        137 :         bool skipfirst = false;
     544                 :        137 :         tree arg;
     545                 :            : 
     546                 :        137 :         if (TREE_CODE (fun) == ADDR_EXPR)
     547                 :          0 :           fun = TREE_OPERAND (fun, 0);
     548                 :            : 
     549                 :            :         /* In templates, where there is no way to tell whether a given
     550                 :            :            call uses an actual member function.  So the parser builds
     551                 :            :            FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until
     552                 :            :            instantiation time.  */
     553                 :        137 :         if (TREE_CODE (fun) != FUNCTION_DECL)
     554                 :            :           ;
     555                 :         11 :         else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun))
     556                 :            :           {
     557                 :          0 :             tree object = (code == AGGR_INIT_EXPR
     558                 :          0 :                            ? (AGGR_INIT_VIA_CTOR_P (t)
     559                 :          0 :                               ? AGGR_INIT_EXPR_SLOT (t)
     560                 :          0 :                               : AGGR_INIT_EXPR_ARG (t, 0))
     561                 :          0 :                            : CALL_EXPR_ARG (t, 0));
     562                 :            : 
     563                 :          0 :             while (TREE_CODE (object) == NOP_EXPR)
     564                 :          0 :               object = TREE_OPERAND (object, 0);
     565                 :            : 
     566                 :          0 :             if (TREE_CODE (object) == ADDR_EXPR)
     567                 :          0 :               object = TREE_OPERAND (object, 0);
     568                 :            : 
     569                 :          0 :             if (!TYPE_PTR_P (TREE_TYPE (object)))
     570                 :            :               {
     571                 :          0 :                 postfix_expression (object);
     572                 :          0 :                 pp_cxx_dot (this);
     573                 :            :               }
     574                 :            :             else
     575                 :            :               {
     576                 :          0 :                 postfix_expression (object);
     577                 :          0 :                 pp_cxx_arrow (this);
     578                 :            :               }
     579                 :          0 :             skipfirst = true;
     580                 :          0 :             enclosing_scope = strip_pointer_operator (TREE_TYPE (object));
     581                 :            :           }
     582                 :            : 
     583                 :        137 :         postfix_expression (fun);
     584                 :        137 :         enclosing_scope = saved_scope;
     585                 :        137 :         pp_cxx_left_paren (this);
     586                 :        137 :         if (code == AGGR_INIT_EXPR)
     587                 :            :           {
     588                 :          0 :             aggr_init_expr_arg_iterator iter;
     589                 :          0 :             FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
     590                 :            :               {
     591                 :          0 :                 if (skipfirst)
     592                 :            :                   skipfirst = false;
     593                 :            :                 else
     594                 :            :                   {
     595                 :          0 :                     expression (arg);
     596                 :          0 :                     if (more_aggr_init_expr_args_p (&iter))
     597                 :          0 :                       pp_cxx_separate_with (this, ',');
     598                 :            :                   }
     599                 :            :               }
     600                 :            :           }
     601                 :            :         else
     602                 :            :           {
     603                 :        137 :             call_expr_arg_iterator iter;
     604                 :        197 :             FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
     605                 :            :               {
     606                 :         60 :                 if (skipfirst)
     607                 :            :                   skipfirst = false;
     608                 :            :                 else
     609                 :            :                   {
     610                 :         60 :                     expression (arg);
     611                 :         60 :                     if (more_call_expr_args_p (&iter))
     612                 :          2 :                       pp_cxx_separate_with (this, ',');
     613                 :            :                   }
     614                 :            :               }
     615                 :            :           }
     616                 :        137 :         pp_cxx_right_paren (this);
     617                 :            :       }
     618                 :        137 :       if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
     619                 :            :         {
     620                 :          0 :           pp_cxx_separate_with (this, ',');
     621                 :          0 :           postfix_expression (AGGR_INIT_EXPR_SLOT (t));
     622                 :            :         }
     623                 :            :       break;
     624                 :            : 
     625                 :        130 :     case BASELINK:
     626                 :        130 :     case VAR_DECL:
     627                 :        130 :     case PARM_DECL:
     628                 :        130 :     case FIELD_DECL:
     629                 :        130 :     case FUNCTION_DECL:
     630                 :        130 :     case OVERLOAD:
     631                 :        130 :     case CONST_DECL:
     632                 :        130 :     case TEMPLATE_DECL:
     633                 :        130 :     case RESULT_DECL:
     634                 :        130 :       primary_expression (t);
     635                 :        130 :       break;
     636                 :            : 
     637                 :          0 :     case DYNAMIC_CAST_EXPR:
     638                 :          0 :     case STATIC_CAST_EXPR:
     639                 :          0 :     case REINTERPRET_CAST_EXPR:
     640                 :          0 :     case CONST_CAST_EXPR:
     641                 :          0 :       if (code == DYNAMIC_CAST_EXPR)
     642                 :          0 :         pp_cxx_ws_string (this, "dynamic_cast");
     643                 :          0 :       else if (code == STATIC_CAST_EXPR)
     644                 :          0 :         pp_cxx_ws_string (this, "static_cast");
     645                 :          0 :       else if (code == REINTERPRET_CAST_EXPR)
     646                 :          0 :         pp_cxx_ws_string (this, "reinterpret_cast");
     647                 :            :       else
     648                 :          0 :         pp_cxx_ws_string (this, "const_cast");
     649                 :          0 :       pp_cxx_begin_template_argument_list (this);
     650                 :          0 :       type_id (TREE_TYPE (t));
     651                 :          0 :       pp_cxx_end_template_argument_list (this);
     652                 :          0 :       pp_left_paren (this);
     653                 :          0 :       expression (TREE_OPERAND (t, 0));
     654                 :          0 :       pp_right_paren (this);
     655                 :          0 :       break;
     656                 :            : 
     657                 :          0 :     case EMPTY_CLASS_EXPR:
     658                 :          0 :       type_id (TREE_TYPE (t));
     659                 :          0 :       pp_left_paren (this);
     660                 :          0 :       pp_right_paren (this);
     661                 :          0 :       break;
     662                 :            : 
     663                 :          4 :     case TYPEID_EXPR:
     664                 :          4 :       pp_cxx_typeid_expression (this, t);
     665                 :          4 :       break;
     666                 :            : 
     667                 :          0 :     case PSEUDO_DTOR_EXPR:
     668                 :          0 :       postfix_expression (TREE_OPERAND (t, 0));
     669                 :          0 :       pp_cxx_dot (this);
     670                 :          0 :       if (TREE_OPERAND (t, 1))
     671                 :            :         {
     672                 :          0 :           pp_cxx_qualified_id (this, TREE_OPERAND (t, 1));
     673                 :          0 :           pp_cxx_colon_colon (this);
     674                 :            :         }
     675                 :          0 :       pp_complement (this);
     676                 :          0 :       pp_cxx_unqualified_id (this, TREE_OPERAND (t, 2));
     677                 :          0 :       break;
     678                 :            : 
     679                 :          0 :     case ARROW_EXPR:
     680                 :          0 :       postfix_expression (TREE_OPERAND (t, 0));
     681                 :          0 :       pp_cxx_arrow (this);
     682                 :          0 :       break;
     683                 :            : 
     684                 :        315 :     default:
     685                 :        315 :       c_pretty_printer::postfix_expression (t);
     686                 :        315 :       break;
     687                 :            :     }
     688                 :        586 : }
     689                 :            : 
     690                 :            : /* new-expression:
     691                 :            :       ::(opt) new new-placement(opt) new-type-id new-initializer(opt)
     692                 :            :       ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt)
     693                 :            : 
     694                 :            :    new-placement:
     695                 :            :       ( expression-list )
     696                 :            : 
     697                 :            :    new-type-id:
     698                 :            :       type-specifier-seq new-declarator(opt)
     699                 :            : 
     700                 :            :    new-declarator:
     701                 :            :       ptr-operator new-declarator(opt)
     702                 :            :       direct-new-declarator
     703                 :            : 
     704                 :            :    direct-new-declarator
     705                 :            :       [ expression ]
     706                 :            :       direct-new-declarator [ constant-expression ]
     707                 :            : 
     708                 :            :    new-initializer:
     709                 :            :       ( expression-list(opt) )  */
     710                 :            : 
     711                 :            : static void
     712                 :          0 : pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
     713                 :            : {
     714                 :          0 :   enum tree_code code = TREE_CODE (t);
     715                 :          0 :   tree type = TREE_OPERAND (t, 1);
     716                 :          0 :   tree init = TREE_OPERAND (t, 2);
     717                 :          0 :   switch (code)
     718                 :            :     {
     719                 :          0 :     case NEW_EXPR:
     720                 :          0 :     case VEC_NEW_EXPR:
     721                 :          0 :       if (NEW_EXPR_USE_GLOBAL (t))
     722                 :          0 :         pp_cxx_colon_colon (pp);
     723                 :          0 :       pp_cxx_ws_string (pp, "new");
     724                 :          0 :       if (TREE_OPERAND (t, 0))
     725                 :            :         {
     726                 :          0 :           pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
     727                 :          0 :           pp_space (pp);
     728                 :            :         }
     729                 :          0 :       if (TREE_CODE (type) == ARRAY_REF)
     730                 :          0 :         type = build_cplus_array_type
     731                 :          0 :           (TREE_OPERAND (type, 0),
     732                 :            :            build_index_type (fold_build2_loc (input_location,
     733                 :            :                                           MINUS_EXPR, integer_type_node,
     734                 :          0 :                                           TREE_OPERAND (type, 1),
     735                 :            :                                           integer_one_node)));
     736                 :          0 :       pp->type_id (type);
     737                 :          0 :       if (init)
     738                 :            :         {
     739                 :          0 :           pp_left_paren (pp);
     740                 :          0 :           if (TREE_CODE (init) == TREE_LIST)
     741                 :          0 :             pp_c_expression_list (pp, init);
     742                 :          0 :           else if (init == void_node)
     743                 :            :             ;                   /* OK, empty initializer list.  */
     744                 :            :           else
     745                 :          0 :             pp->expression (init);
     746                 :          0 :           pp_right_paren (pp);
     747                 :            :         }
     748                 :            :       break;
     749                 :            : 
     750                 :          0 :     default:
     751                 :          0 :       pp_unsupported_tree (pp, t);
     752                 :            :     }
     753                 :          0 : }
     754                 :            : 
     755                 :            : /* delete-expression:
     756                 :            :       ::(opt) delete cast-expression
     757                 :            :       ::(opt) delete [ ] cast-expression   */
     758                 :            : 
     759                 :            : static void
     760                 :          4 : pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
     761                 :            : {
     762                 :          4 :   enum tree_code code = TREE_CODE (t);
     763                 :          4 :   switch (code)
     764                 :            :     {
     765                 :          4 :     case DELETE_EXPR:
     766                 :          4 :     case VEC_DELETE_EXPR:
     767                 :          4 :       if (DELETE_EXPR_USE_GLOBAL (t))
     768                 :          0 :         pp_cxx_colon_colon (pp);
     769                 :          4 :       pp_cxx_ws_string (pp, "delete");
     770                 :          4 :       pp_space (pp);
     771                 :          4 :       if (code == VEC_DELETE_EXPR
     772                 :          4 :           || DELETE_EXPR_USE_VEC (t))
     773                 :            :         {
     774                 :          0 :           pp_left_bracket (pp);
     775                 :          0 :           pp_right_bracket (pp);
     776                 :          0 :           pp_space (pp);
     777                 :            :         }
     778                 :          4 :       pp_c_cast_expression (pp, TREE_OPERAND (t, 0));
     779                 :          4 :       break;
     780                 :            : 
     781                 :          0 :     default:
     782                 :          0 :       pp_unsupported_tree (pp, t);
     783                 :            :     }
     784                 :          4 : }
     785                 :            : 
     786                 :            : /* unary-expression:
     787                 :            :       postfix-expression
     788                 :            :       ++ cast-expression
     789                 :            :       -- cast-expression
     790                 :            :       unary-operator cast-expression
     791                 :            :       sizeof unary-expression
     792                 :            :       sizeof ( type-id )
     793                 :            :       sizeof ... ( identifier )
     794                 :            :       new-expression
     795                 :            :       delete-expression
     796                 :            : 
     797                 :            :    unary-operator: one of
     798                 :            :       *   &   +   -  !
     799                 :            : 
     800                 :            :    GNU extensions:
     801                 :            :       __alignof__ unary-expression
     802                 :            :       __alignof__ ( type-id )  */
     803                 :            : 
     804                 :            : void
     805                 :        340 : cxx_pretty_printer::unary_expression (tree t)
     806                 :            : {
     807                 :        340 :   enum tree_code code = TREE_CODE (t);
     808                 :        340 :   switch (code)
     809                 :            :     {
     810                 :          0 :     case NEW_EXPR:
     811                 :          0 :     case VEC_NEW_EXPR:
     812                 :          0 :       pp_cxx_new_expression (this, t);
     813                 :          0 :       break;
     814                 :            : 
     815                 :          0 :     case DELETE_EXPR:
     816                 :          0 :     case VEC_DELETE_EXPR:
     817                 :          0 :       pp_cxx_delete_expression (this, t);
     818                 :          0 :       break;
     819                 :            : 
     820                 :          6 :     case SIZEOF_EXPR:
     821                 :          6 :       if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
     822                 :            :         {
     823                 :          0 :           pp_cxx_ws_string (this, "sizeof");
     824                 :          0 :           pp_cxx_ws_string (this, "...");
     825                 :          0 :           pp_cxx_whitespace (this);
     826                 :          0 :           pp_cxx_left_paren (this);
     827                 :          0 :           if (TYPE_P (TREE_OPERAND (t, 0)))
     828                 :          0 :             type_id (TREE_OPERAND (t, 0));
     829                 :            :           else
     830                 :          0 :             unary_expression (TREE_OPERAND (t, 0));
     831                 :          0 :           pp_cxx_right_paren (this);
     832                 :          0 :           break;
     833                 :            :         }
     834                 :            :       /* Fall through  */
     835                 :            : 
     836                 :          6 :     case ALIGNOF_EXPR:
     837                 :          6 :       pp_cxx_ws_string (this, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
     838                 :          6 :       pp_cxx_whitespace (this);
     839                 :          6 :       if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
     840                 :            :         {
     841                 :          0 :           pp_cxx_left_paren (this);
     842                 :          0 :           type_id (TREE_TYPE (TREE_OPERAND (t, 0)));
     843                 :          0 :           pp_cxx_right_paren (this);
     844                 :            :         }
     845                 :          6 :       else if (TYPE_P (TREE_OPERAND (t, 0)))
     846                 :            :         {
     847                 :          6 :           pp_cxx_left_paren (this);
     848                 :          6 :           type_id (TREE_OPERAND (t, 0));
     849                 :          6 :           pp_cxx_right_paren (this);
     850                 :            :         }
     851                 :            :       else
     852                 :          0 :         unary_expression (TREE_OPERAND (t, 0));
     853                 :            :       break;
     854                 :            : 
     855                 :          0 :     case AT_ENCODE_EXPR:
     856                 :          0 :       pp_cxx_ws_string (this, "@encode");
     857                 :          0 :       pp_cxx_whitespace (this);
     858                 :          0 :       pp_cxx_left_paren (this);
     859                 :          0 :       type_id (TREE_OPERAND (t, 0));
     860                 :          0 :       pp_cxx_right_paren (this);
     861                 :          0 :       break;      
     862                 :            : 
     863                 :          0 :     case NOEXCEPT_EXPR:
     864                 :          0 :       pp_cxx_ws_string (this, "noexcept");
     865                 :          0 :       pp_cxx_whitespace (this);
     866                 :          0 :       pp_cxx_left_paren (this);
     867                 :          0 :       expression (TREE_OPERAND (t, 0));
     868                 :          0 :       pp_cxx_right_paren (this);
     869                 :          0 :       break;
     870                 :            : 
     871                 :          3 :     case UNARY_PLUS_EXPR:
     872                 :          3 :       pp_plus (this);
     873                 :          3 :       pp_cxx_cast_expression (this, TREE_OPERAND (t, 0));
     874                 :          3 :       break;
     875                 :            : 
     876                 :        331 :     default:
     877                 :        331 :       c_pretty_printer::unary_expression (t);
     878                 :        331 :       break;
     879                 :            :     }
     880                 :        340 : }
     881                 :            : 
     882                 :            : /* cast-expression:
     883                 :            :       unary-expression
     884                 :            :       ( type-id ) cast-expression  */
     885                 :            : 
     886                 :            : static void
     887                 :        176 : pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
     888                 :            : {
     889                 :        176 :   switch (TREE_CODE (t))
     890                 :            :     {
     891                 :          8 :     case CAST_EXPR:
     892                 :          8 :     case IMPLICIT_CONV_EXPR:
     893                 :          8 :       pp->type_id (TREE_TYPE (t));
     894                 :          8 :       pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
     895                 :          8 :       break;
     896                 :            : 
     897                 :        168 :     default:
     898                 :        168 :       pp_c_cast_expression (pp, t);
     899                 :        168 :       break;
     900                 :            :     }
     901                 :        176 : }
     902                 :            : 
     903                 :            : /* pm-expression:
     904                 :            :       cast-expression
     905                 :            :       pm-expression .* cast-expression
     906                 :            :       pm-expression ->* cast-expression  */
     907                 :            : 
     908                 :            : static void
     909                 :        165 : pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
     910                 :            : {
     911                 :        165 :   switch (TREE_CODE (t))
     912                 :            :     {
     913                 :            :       /* Handle unfortunate OFFSET_REF overloading here.  */
     914                 :          0 :     case OFFSET_REF:
     915                 :          0 :       if (TYPE_P (TREE_OPERAND (t, 0)))
     916                 :            :         {
     917                 :          0 :           pp_cxx_qualified_id (pp, t);
     918                 :          0 :           break;
     919                 :            :         }
     920                 :            :       /* Fall through.  */
     921                 :          8 :     case MEMBER_REF:
     922                 :          8 :     case DOTSTAR_EXPR:
     923                 :          8 :       pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
     924                 :          8 :       if (TREE_CODE (t) == MEMBER_REF)
     925                 :          4 :         pp_cxx_arrow (pp);
     926                 :            :       else
     927                 :          4 :         pp_cxx_dot (pp);
     928                 :          8 :       pp_star(pp);
     929                 :          8 :       pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
     930                 :          8 :       break;
     931                 :            : 
     932                 :            : 
     933                 :        157 :     default:
     934                 :        157 :       pp_cxx_cast_expression (pp, t);
     935                 :        157 :       break;
     936                 :            :     }
     937                 :        165 : }
     938                 :            : 
     939                 :            : /* multiplicative-expression:
     940                 :            :       pm-expression
     941                 :            :       multiplicative-expression * pm-expression
     942                 :            :       multiplicative-expression / pm-expression
     943                 :            :       multiplicative-expression % pm-expression  */
     944                 :            : 
     945                 :            : void
     946                 :        149 : cxx_pretty_printer::multiplicative_expression (tree e)
     947                 :            : {
     948                 :        149 :   enum tree_code code = TREE_CODE (e);
     949                 :        149 :   switch (code)
     950                 :            :     {
     951                 :          3 :     case MULT_EXPR:
     952                 :          3 :     case TRUNC_DIV_EXPR:
     953                 :          3 :     case TRUNC_MOD_EXPR:
     954                 :          3 :     case EXACT_DIV_EXPR:
     955                 :          3 :     case RDIV_EXPR:
     956                 :          3 :       multiplicative_expression (TREE_OPERAND (e, 0));
     957                 :          3 :       pp_space (this);
     958                 :          3 :       if (code == MULT_EXPR)
     959                 :          0 :         pp_star (this);
     960                 :          3 :       else if (code != TRUNC_MOD_EXPR)
     961                 :          3 :         pp_slash (this);
     962                 :            :       else
     963                 :          0 :         pp_modulo (this);
     964                 :          3 :       pp_space (this);
     965                 :          3 :       pp_cxx_pm_expression (this, TREE_OPERAND (e, 1));
     966                 :          3 :       break;
     967                 :            : 
     968                 :        146 :     default:
     969                 :        146 :       pp_cxx_pm_expression (this, e);
     970                 :        146 :       break;
     971                 :            :     }
     972                 :        149 : }
     973                 :            : 
     974                 :            : /* conditional-expression:
     975                 :            :       logical-or-expression
     976                 :            :       logical-or-expression ?  expression  : assignment-expression  */
     977                 :            : 
     978                 :            : void
     979                 :         14 : cxx_pretty_printer::conditional_expression (tree e)
     980                 :            : {
     981                 :         14 :   if (TREE_CODE (e) == COND_EXPR)
     982                 :            :     {
     983                 :          0 :       pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
     984                 :          0 :       pp_space (this);
     985                 :          0 :       pp_question (this);
     986                 :          0 :       pp_space (this);
     987                 :          0 :       expression (TREE_OPERAND (e, 1));
     988                 :          0 :       pp_space (this);
     989                 :          0 :       assignment_expression (TREE_OPERAND (e, 2));
     990                 :            :     }
     991                 :            :   else
     992                 :         14 :     pp_c_logical_or_expression (this, e);
     993                 :         14 : }
     994                 :            : 
     995                 :            : /* Pretty-print a compound assignment operator token as indicated by T.  */
     996                 :            : 
     997                 :            : static void
     998                 :         10 : pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
     999                 :            : {
    1000                 :         10 :   const char *op;
    1001                 :            : 
    1002                 :         10 :   switch (TREE_CODE (t))
    1003                 :            :     {
    1004                 :            :     case NOP_EXPR:
    1005                 :            :       op = "=";
    1006                 :            :       break;
    1007                 :            : 
    1008                 :          0 :     case PLUS_EXPR:
    1009                 :          0 :       op = "+=";
    1010                 :          0 :       break;
    1011                 :            : 
    1012                 :          0 :     case MINUS_EXPR:
    1013                 :          0 :       op = "-=";
    1014                 :          0 :       break;
    1015                 :            : 
    1016                 :          0 :     case TRUNC_DIV_EXPR:
    1017                 :          0 :       op = "/=";
    1018                 :          0 :       break;
    1019                 :            : 
    1020                 :          0 :     case TRUNC_MOD_EXPR:
    1021                 :          0 :       op = "%=";
    1022                 :          0 :       break;
    1023                 :            : 
    1024                 :          0 :     default:
    1025                 :          0 :       op = get_tree_code_name (TREE_CODE (t));
    1026                 :          0 :       break;
    1027                 :            :     }
    1028                 :            : 
    1029                 :         10 :   pp_cxx_ws_string (pp, op);
    1030                 :         10 : }
    1031                 :            : 
    1032                 :            : 
    1033                 :            : /* assignment-expression:
    1034                 :            :       conditional-expression
    1035                 :            :       logical-or-expression assignment-operator assignment-expression
    1036                 :            :       throw-expression
    1037                 :            : 
    1038                 :            :    throw-expression:
    1039                 :            :        throw assignment-expression(opt)
    1040                 :            : 
    1041                 :            :    assignment-operator: one of
    1042                 :            :       =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
    1043                 :            : 
    1044                 :            : void
    1045                 :         24 : cxx_pretty_printer::assignment_expression (tree e)
    1046                 :            : {
    1047                 :         24 :   switch (TREE_CODE (e))
    1048                 :            :     {
    1049                 :          0 :     case MODIFY_EXPR:
    1050                 :          0 :     case INIT_EXPR:
    1051                 :          0 :       pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
    1052                 :          0 :       pp_space (this);
    1053                 :          0 :       pp_equal (this);
    1054                 :          0 :       pp_space (this);
    1055                 :          0 :       assignment_expression (TREE_OPERAND (e, 1));
    1056                 :          0 :       break;
    1057                 :            : 
    1058                 :          0 :     case THROW_EXPR:
    1059                 :          0 :       pp_cxx_ws_string (this, "throw");
    1060                 :          0 :       if (TREE_OPERAND (e, 0))
    1061                 :          0 :         assignment_expression (TREE_OPERAND (e, 0));
    1062                 :            :       break;
    1063                 :            : 
    1064                 :         10 :     case MODOP_EXPR:
    1065                 :         10 :       pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
    1066                 :         10 :       pp_cxx_assignment_operator (this, TREE_OPERAND (e, 1));
    1067                 :         10 :       assignment_expression (TREE_OPERAND (e, 2));
    1068                 :         10 :       break;
    1069                 :            : 
    1070                 :         14 :     default:
    1071                 :         14 :       conditional_expression (e);
    1072                 :         14 :       break;
    1073                 :            :     }
    1074                 :         24 : }
    1075                 :            : 
    1076                 :            : void
    1077                 :       1161 : cxx_pretty_printer::expression (tree t)
    1078                 :            : {
    1079                 :       1161 :   switch (TREE_CODE (t))
    1080                 :            :     {
    1081                 :        118 :     case STRING_CST:
    1082                 :        118 :     case VOID_CST:
    1083                 :        118 :     case INTEGER_CST:
    1084                 :        118 :     case REAL_CST:
    1085                 :        118 :     case COMPLEX_CST:
    1086                 :        118 :       constant (t);
    1087                 :        118 :       break;
    1088                 :            : 
    1089                 :          0 :     case USERDEF_LITERAL:
    1090                 :          0 :       pp_cxx_userdef_literal (this, t);
    1091                 :          0 :       break;
    1092                 :            : 
    1093                 :          0 :     case RESULT_DECL:
    1094                 :          0 :       pp_cxx_unqualified_id (this, t);
    1095                 :          0 :       break;
    1096                 :            : 
    1097                 :            : #if 0
    1098                 :            :     case OFFSET_REF:
    1099                 :            : #endif
    1100                 :          9 :     case SCOPE_REF:
    1101                 :          9 :     case PTRMEM_CST:
    1102                 :          9 :       pp_cxx_qualified_id (this, t);
    1103                 :          9 :       break;
    1104                 :            : 
    1105                 :            :     case OVERLOAD:
    1106                 :        111 :       t = OVL_FIRST (t);
    1107                 :            :       /* FALLTHRU */
    1108                 :        111 :     case VAR_DECL:
    1109                 :        111 :     case PARM_DECL:
    1110                 :        111 :     case FIELD_DECL:
    1111                 :        111 :     case CONST_DECL:
    1112                 :        111 :     case FUNCTION_DECL:
    1113                 :        111 :     case BASELINK:
    1114                 :        111 :     case TEMPLATE_DECL:
    1115                 :        111 :     case TEMPLATE_TYPE_PARM:
    1116                 :        111 :     case TEMPLATE_PARM_INDEX:
    1117                 :        111 :     case TEMPLATE_TEMPLATE_PARM:
    1118                 :        111 :     case STMT_EXPR:
    1119                 :        111 :     case REQUIRES_EXPR:
    1120                 :        111 :       primary_expression (t);
    1121                 :        111 :       break;
    1122                 :            : 
    1123                 :        125 :     case CALL_EXPR:
    1124                 :        125 :     case DYNAMIC_CAST_EXPR:
    1125                 :        125 :     case STATIC_CAST_EXPR:
    1126                 :        125 :     case REINTERPRET_CAST_EXPR:
    1127                 :        125 :     case CONST_CAST_EXPR:
    1128                 :            : #if 0
    1129                 :            :     case MEMBER_REF:
    1130                 :            : #endif
    1131                 :        125 :     case EMPTY_CLASS_EXPR:
    1132                 :        125 :     case TYPEID_EXPR:
    1133                 :        125 :     case PSEUDO_DTOR_EXPR:
    1134                 :        125 :     case AGGR_INIT_EXPR:
    1135                 :        125 :     case ARROW_EXPR:
    1136                 :        125 :       postfix_expression (t);
    1137                 :        125 :       break;
    1138                 :            : 
    1139                 :          0 :     case NEW_EXPR:
    1140                 :          0 :     case VEC_NEW_EXPR:
    1141                 :          0 :       pp_cxx_new_expression (this, t);
    1142                 :          0 :       break;
    1143                 :            : 
    1144                 :          4 :     case DELETE_EXPR:
    1145                 :          4 :     case VEC_DELETE_EXPR:
    1146                 :          4 :       pp_cxx_delete_expression (this, t);
    1147                 :          4 :       break;
    1148                 :            : 
    1149                 :          3 :     case SIZEOF_EXPR:
    1150                 :          3 :     case ALIGNOF_EXPR:
    1151                 :          3 :     case NOEXCEPT_EXPR:
    1152                 :          3 :     case UNARY_PLUS_EXPR:
    1153                 :          3 :       unary_expression (t);
    1154                 :          3 :       break;
    1155                 :            : 
    1156                 :          8 :     case CAST_EXPR:
    1157                 :          8 :     case IMPLICIT_CONV_EXPR:
    1158                 :          8 :       pp_cxx_cast_expression (this, t);
    1159                 :          8 :       break;
    1160                 :            : 
    1161                 :          8 :     case OFFSET_REF:
    1162                 :          8 :     case MEMBER_REF:
    1163                 :          8 :     case DOTSTAR_EXPR:
    1164                 :          8 :       pp_cxx_pm_expression (this, t);
    1165                 :          8 :       break;
    1166                 :            : 
    1167                 :          3 :     case MULT_EXPR:
    1168                 :          3 :     case TRUNC_DIV_EXPR:
    1169                 :          3 :     case TRUNC_MOD_EXPR:
    1170                 :          3 :     case EXACT_DIV_EXPR:
    1171                 :          3 :     case RDIV_EXPR:
    1172                 :          3 :       multiplicative_expression (t);
    1173                 :          3 :       break;
    1174                 :            : 
    1175                 :          0 :     case COND_EXPR:
    1176                 :          0 :       conditional_expression (t);
    1177                 :          0 :       break;
    1178                 :            : 
    1179                 :         10 :     case MODIFY_EXPR:
    1180                 :         10 :     case INIT_EXPR:
    1181                 :         10 :     case THROW_EXPR:
    1182                 :         10 :     case MODOP_EXPR:
    1183                 :         10 :       assignment_expression (t);
    1184                 :         10 :       break;
    1185                 :            : 
    1186                 :          0 :     case NON_DEPENDENT_EXPR:
    1187                 :          0 :     case MUST_NOT_THROW_EXPR:
    1188                 :          0 :       expression (TREE_OPERAND (t, 0));
    1189                 :          0 :       break;
    1190                 :            : 
    1191                 :         90 :     case EXPR_PACK_EXPANSION:
    1192                 :         90 :       expression (PACK_EXPANSION_PATTERN (t));
    1193                 :         90 :       pp_cxx_ws_string (this, "...");
    1194                 :         90 :       break;
    1195                 :            : 
    1196                 :         33 :     case UNARY_LEFT_FOLD_EXPR:
    1197                 :         33 :       pp_cxx_unary_left_fold_expression (this, t);
    1198                 :         33 :       break;
    1199                 :            : 
    1200                 :          9 :     case UNARY_RIGHT_FOLD_EXPR:
    1201                 :          9 :       pp_cxx_unary_right_fold_expression (this, t);
    1202                 :          9 :     break;
    1203                 :            : 
    1204                 :          0 :     case BINARY_LEFT_FOLD_EXPR:
    1205                 :          0 :     case BINARY_RIGHT_FOLD_EXPR:
    1206                 :          0 :       pp_cxx_binary_fold_expression (this, t);
    1207                 :          0 :       break;
    1208                 :            : 
    1209                 :        320 :     case TEMPLATE_ID_EXPR:
    1210                 :        320 :       pp_cxx_template_id (this, t);
    1211                 :        320 :       break;
    1212                 :            : 
    1213                 :          2 :     case NONTYPE_ARGUMENT_PACK:
    1214                 :          2 :       {
    1215                 :          2 :         tree args = ARGUMENT_PACK_ARGS (t);
    1216                 :          2 :         int i, len = TREE_VEC_LENGTH (args);
    1217                 :          2 :         pp_cxx_left_brace (this);
    1218                 :          8 :         for (i = 0; i < len; ++i)
    1219                 :            :           {
    1220                 :          6 :             if (i > 0)
    1221                 :          4 :               pp_cxx_separate_with (this, ',');
    1222                 :          6 :             expression (TREE_VEC_ELT (args, i));
    1223                 :            :           }
    1224                 :          2 :         pp_cxx_right_brace (this);
    1225                 :            :       }
    1226                 :          2 :       break;
    1227                 :            : 
    1228                 :          3 :     case LAMBDA_EXPR:
    1229                 :          3 :       pp_cxx_ws_string (this, "<lambda>");
    1230                 :          3 :       break;
    1231                 :            : 
    1232                 :         13 :     case TRAIT_EXPR:
    1233                 :         13 :       pp_cxx_trait_expression (this, t);
    1234                 :         13 :       break;
    1235                 :            : 
    1236                 :          0 :     case ATOMIC_CONSTR:
    1237                 :          0 :     case CHECK_CONSTR:
    1238                 :          0 :     case CONJ_CONSTR:
    1239                 :          0 :     case DISJ_CONSTR:
    1240                 :          0 :       pp_cxx_constraint (this, t);
    1241                 :          0 :       break;
    1242                 :            : 
    1243                 :          0 :     case PAREN_EXPR:
    1244                 :          0 :       pp_cxx_left_paren (this);
    1245                 :          0 :       expression (TREE_OPERAND (t, 0));
    1246                 :          0 :       pp_cxx_right_paren (this);
    1247                 :          0 :       break;
    1248                 :            : 
    1249                 :        292 :     default:
    1250                 :        292 :       c_pretty_printer::expression (t);
    1251                 :        292 :       break;
    1252                 :            :     }
    1253                 :       1161 : }
    1254                 :            : 
    1255                 :            : 
    1256                 :            : /* Declarations.  */
    1257                 :            : 
    1258                 :            : /* function-specifier:
    1259                 :            :       inline
    1260                 :            :       virtual
    1261                 :            :       explicit   */
    1262                 :            : 
    1263                 :            : void
    1264                 :          3 : cxx_pretty_printer::function_specifier (tree t)
    1265                 :            : {
    1266                 :          3 :   switch (TREE_CODE (t))
    1267                 :            :     {
    1268                 :          0 :     case FUNCTION_DECL:
    1269                 :          0 :       if (DECL_VIRTUAL_P (t))
    1270                 :          0 :         pp_cxx_ws_string (this, "virtual");
    1271                 :          0 :       else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
    1272                 :          0 :         pp_cxx_ws_string (this, "explicit");
    1273                 :            :       else
    1274                 :          0 :         c_pretty_printer::function_specifier (t);
    1275                 :            : 
    1276                 :          3 :     default:
    1277                 :          3 :       break;
    1278                 :            :     }
    1279                 :          3 : }
    1280                 :            : 
    1281                 :            : /* decl-specifier-seq:
    1282                 :            :       decl-specifier-seq(opt) decl-specifier
    1283                 :            : 
    1284                 :            :    decl-specifier:
    1285                 :            :       storage-class-specifier
    1286                 :            :       type-specifier
    1287                 :            :       function-specifier
    1288                 :            :       friend
    1289                 :            :       typedef  */
    1290                 :            : 
    1291                 :            : void
    1292                 :          6 : cxx_pretty_printer::declaration_specifiers (tree t)
    1293                 :            : {
    1294                 :          6 :   switch (TREE_CODE (t))
    1295                 :            :     {
    1296                 :          3 :     case VAR_DECL:
    1297                 :          3 :     case PARM_DECL:
    1298                 :          3 :     case CONST_DECL:
    1299                 :          3 :     case FIELD_DECL:
    1300                 :          3 :       storage_class_specifier (t);
    1301                 :          3 :       declaration_specifiers (TREE_TYPE (t));
    1302                 :          3 :       break;
    1303                 :            : 
    1304                 :          0 :     case TYPE_DECL:
    1305                 :          0 :       pp_cxx_ws_string (this, "typedef");
    1306                 :          0 :       declaration_specifiers (TREE_TYPE (t));
    1307                 :          0 :       break;
    1308                 :            : 
    1309                 :          0 :     case FUNCTION_DECL:
    1310                 :            :       /* Constructors don't have return types.  And conversion functions
    1311                 :            :          do not have a type-specifier in their return types.  */
    1312                 :          0 :       if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
    1313                 :          0 :         function_specifier (t);
    1314                 :          0 :       else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
    1315                 :          0 :         declaration_specifiers (TREE_TYPE (TREE_TYPE (t)));
    1316                 :            :       else
    1317                 :          0 :         c_pretty_printer::declaration_specifiers (t);
    1318                 :            :       break;
    1319                 :          3 :     default:
    1320                 :          3 :         c_pretty_printer::declaration_specifiers (t);
    1321                 :          3 :       break;
    1322                 :            :     }
    1323                 :          6 : }
    1324                 :            : 
    1325                 :            : /* simple-type-specifier:
    1326                 :            :       ::(opt) nested-name-specifier(opt) type-name
    1327                 :            :       ::(opt) nested-name-specifier(opt) template(opt) template-id
    1328                 :            :       char
    1329                 :            :       wchar_t
    1330                 :            :       bool
    1331                 :            :       short
    1332                 :            :       int
    1333                 :            :       long
    1334                 :            :       signed
    1335                 :            :       unsigned
    1336                 :            :       float
    1337                 :            :       double
    1338                 :            :       void  */
    1339                 :            : 
    1340                 :            : void
    1341                 :   28144900 : cxx_pretty_printer::simple_type_specifier (tree t)
    1342                 :            : {
    1343                 :   28144900 :   switch (TREE_CODE (t))
    1344                 :            :     {
    1345                 :     315592 :     case RECORD_TYPE:
    1346                 :     315592 :     case UNION_TYPE:
    1347                 :     315592 :     case ENUMERAL_TYPE:
    1348                 :     315592 :       pp_cxx_qualified_id (this, t);
    1349                 :     315592 :       break;
    1350                 :            : 
    1351                 :        682 :     case TEMPLATE_TYPE_PARM:
    1352                 :        682 :     case TEMPLATE_TEMPLATE_PARM:
    1353                 :        682 :     case TEMPLATE_PARM_INDEX:
    1354                 :        682 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    1355                 :        682 :       pp_cxx_unqualified_id (this, t);
    1356                 :        682 :       if (tree c = PLACEHOLDER_TYPE_CONSTRAINTS (t))
    1357                 :          0 :         pp_cxx_constrained_type_spec (this, c);
    1358                 :            :       break;
    1359                 :            : 
    1360                 :         26 :     case TYPENAME_TYPE:
    1361                 :         26 :       pp_cxx_ws_string (this, "typename");
    1362                 :         26 :       pp_cxx_nested_name_specifier (this, TYPE_CONTEXT (t));
    1363                 :         26 :       pp_cxx_unqualified_id (this, TYPENAME_TYPE_FULLNAME (t));
    1364                 :         26 :       break;
    1365                 :            : 
    1366                 :   27828600 :     default:
    1367                 :   27828600 :       c_pretty_printer::simple_type_specifier (t);
    1368                 :   27828600 :       break;
    1369                 :            :     }
    1370                 :   28144900 : }
    1371                 :            : 
    1372                 :            : /* type-specifier-seq:
    1373                 :            :       type-specifier type-specifier-seq(opt)
    1374                 :            : 
    1375                 :            :    type-specifier:
    1376                 :            :       simple-type-specifier
    1377                 :            :       class-specifier
    1378                 :            :       enum-specifier
    1379                 :            :       elaborated-type-specifier
    1380                 :            :       cv-qualifier   */
    1381                 :            : 
    1382                 :            : static void
    1383                 :   14230100 : pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
    1384                 :            : {
    1385                 :   14230100 :   switch (TREE_CODE (t))
    1386                 :            :     {
    1387                 :        654 :     case TEMPLATE_DECL:
    1388                 :        654 :     case TEMPLATE_TYPE_PARM:
    1389                 :        654 :     case TEMPLATE_TEMPLATE_PARM:
    1390                 :        654 :     case TYPE_DECL:
    1391                 :        654 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    1392                 :        654 :       pp_cxx_cv_qualifier_seq (pp, t);
    1393                 :        654 :       pp->simple_type_specifier (t);
    1394                 :        654 :       break;
    1395                 :            : 
    1396                 :          0 :     case METHOD_TYPE:
    1397                 :          0 :       pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
    1398                 :          0 :       pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
    1399                 :          0 :       pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
    1400                 :          0 :       break;
    1401                 :            : 
    1402                 :         71 :     case DECLTYPE_TYPE:
    1403                 :         71 :       pp_cxx_ws_string (pp, "decltype");
    1404                 :         71 :       pp_cxx_left_paren (pp);
    1405                 :         71 :       pp->expression (DECLTYPE_TYPE_EXPR (t));
    1406                 :         71 :       pp_cxx_right_paren (pp);
    1407                 :         71 :       break;
    1408                 :            : 
    1409                 :        196 :     case RECORD_TYPE:
    1410                 :        196 :       if (TYPE_PTRMEMFUNC_P (t))
    1411                 :            :         {
    1412                 :          0 :           tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
    1413                 :          0 :           pp->declaration_specifiers (TREE_TYPE (TREE_TYPE (pfm)));
    1414                 :          0 :           pp_cxx_whitespace (pp);
    1415                 :          0 :           pp_cxx_ptr_operator (pp, t);
    1416                 :          0 :           break;
    1417                 :            :         }
    1418                 :            :       /* fall through */
    1419                 :            : 
    1420                 :   14229300 :     default:
    1421                 :   14229300 :       if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
    1422                 :   14229300 :         pp_c_specifier_qualifier_list (pp, t);
    1423                 :            :     }
    1424                 :   14230100 : }
    1425                 :            : 
    1426                 :            : /* ptr-operator:
    1427                 :            :       * cv-qualifier-seq(opt)
    1428                 :            :       &
    1429                 :            :       ::(opt) nested-name-specifier * cv-qualifier-seq(opt)  */
    1430                 :            : 
    1431                 :            : static void
    1432                 :          0 : pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
    1433                 :            : {
    1434                 :          0 :   if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
    1435                 :          0 :     t = TREE_TYPE (t);
    1436                 :          0 :   switch (TREE_CODE (t))
    1437                 :            :     {
    1438                 :          0 :     case REFERENCE_TYPE:
    1439                 :          0 :     case POINTER_TYPE:
    1440                 :          0 :       if (TYPE_PTR_OR_PTRMEM_P (TREE_TYPE (t)))
    1441                 :          0 :         pp_cxx_ptr_operator (pp, TREE_TYPE (t));
    1442                 :          0 :       pp_c_attributes_display (pp, TYPE_ATTRIBUTES (TREE_TYPE (t)));
    1443                 :          0 :       if (TYPE_PTR_P (t))
    1444                 :            :         {
    1445                 :          0 :           pp_star (pp);
    1446                 :          0 :           pp_cxx_cv_qualifier_seq (pp, t);
    1447                 :            :         }
    1448                 :            :       else
    1449                 :          0 :         pp_ampersand (pp);
    1450                 :            :       break;
    1451                 :            : 
    1452                 :          0 :     case RECORD_TYPE:
    1453                 :          0 :       if (TYPE_PTRMEMFUNC_P (t))
    1454                 :            :         {
    1455                 :          0 :           pp_cxx_left_paren (pp);
    1456                 :          0 :           pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
    1457                 :          0 :           pp_star (pp);
    1458                 :          0 :           break;
    1459                 :            :         }
    1460                 :            :       /* FALLTHRU */
    1461                 :          0 :     case OFFSET_TYPE:
    1462                 :          0 :       if (TYPE_PTRMEM_P (t))
    1463                 :            :         {
    1464                 :          0 :           if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
    1465                 :          0 :             pp_cxx_left_paren (pp);
    1466                 :          0 :           pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
    1467                 :          0 :           pp_star (pp);
    1468                 :          0 :           pp_cxx_cv_qualifier_seq (pp, t);
    1469                 :          0 :           break;
    1470                 :            :         }
    1471                 :            :       /* fall through.  */
    1472                 :            : 
    1473                 :          0 :     default:
    1474                 :          0 :       pp_unsupported_tree (pp, t);
    1475                 :          0 :       break;
    1476                 :            :     }
    1477                 :          0 : }
    1478                 :            : 
    1479                 :            : static inline tree
    1480                 :          0 : pp_cxx_implicit_parameter_type (tree mf)
    1481                 :            : {
    1482                 :          0 :   return class_of_this_parm (TREE_TYPE (mf));
    1483                 :            : }
    1484                 :            : 
    1485                 :            : /*
    1486                 :            :    parameter-declaration:
    1487                 :            :       decl-specifier-seq declarator
    1488                 :            :       decl-specifier-seq declarator = assignment-expression
    1489                 :            :       decl-specifier-seq abstract-declarator(opt)
    1490                 :            :       decl-specifier-seq abstract-declarator(opt) assignment-expression  */
    1491                 :            : 
    1492                 :            : static inline void
    1493                 :          3 : pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
    1494                 :            : {
    1495                 :          3 :   pp->declaration_specifiers (t);
    1496                 :          3 :   if (TYPE_P (t))
    1497                 :          0 :     pp->abstract_declarator (t);
    1498                 :            :   else
    1499                 :          3 :     pp->declarator (t);
    1500                 :          3 : }
    1501                 :            : 
    1502                 :            : /* parameter-declaration-clause:
    1503                 :            :       parameter-declaration-list(opt) ...(opt)
    1504                 :            :       parameter-declaration-list , ...
    1505                 :            : 
    1506                 :            :    parameter-declaration-list:
    1507                 :            :       parameter-declaration
    1508                 :            :       parameter-declaration-list , parameter-declaration  */
    1509                 :            : 
    1510                 :            : static void
    1511                 :          5 : pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
    1512                 :            : {
    1513                 :          5 :   tree args;
    1514                 :          5 :   tree types;
    1515                 :          5 :   bool abstract;
    1516                 :            : 
    1517                 :            :   // For a requires clause or the explicit printing of a parameter list
    1518                 :            :   // we expect T to be a chain of PARM_DECLs. Otherwise, the list of
    1519                 :            :   // args and types are taken from the function decl T.
    1520                 :          5 :   if (TREE_CODE (t) == PARM_DECL)
    1521                 :            :     {
    1522                 :            :       args = t;
    1523                 :            :       types = t;
    1524                 :            :       abstract = false;
    1525                 :            :     }
    1526                 :            :   else
    1527                 :            :     {
    1528                 :          2 :       bool type_p = TYPE_P (t);
    1529                 :          2 :       args = type_p ? NULL : FUNCTION_FIRST_USER_PARM (t);
    1530                 :          4 :       types = type_p ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
    1531                 :          2 :       abstract = args == NULL || pp->flags & pp_c_flag_abstract;
    1532                 :            :     }
    1533                 :          5 :   bool first = true;
    1534                 :            : 
    1535                 :            :   /* Skip artificial parameter for nonstatic member functions.  */
    1536                 :          5 :   if (TREE_CODE (t) == METHOD_TYPE)
    1537                 :          0 :     types = TREE_CHAIN (types);
    1538                 :            : 
    1539                 :          5 :   pp_cxx_left_paren (pp);
    1540                 :          8 :   for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types))
    1541                 :            :     {
    1542                 :          3 :       if (!first)
    1543                 :          0 :         pp_cxx_separate_with (pp, ',');
    1544                 :          3 :       first = false;
    1545                 :          3 :       pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args);
    1546                 :          3 :       if (!abstract && pp->flags & pp_cxx_flag_default_argument)
    1547                 :            :         {
    1548                 :          0 :           pp_cxx_whitespace (pp);
    1549                 :          0 :           pp_equal (pp);
    1550                 :          0 :           pp_cxx_whitespace (pp);
    1551                 :          0 :           pp->assignment_expression (TREE_PURPOSE (types));
    1552                 :            :         }
    1553                 :            :     }
    1554                 :          5 :   pp_cxx_right_paren (pp);
    1555                 :          5 : }
    1556                 :            : 
    1557                 :            : /* exception-specification:
    1558                 :            :       throw ( type-id-list(opt) )
    1559                 :            : 
    1560                 :            :    type-id-list
    1561                 :            :       type-id
    1562                 :            :       type-id-list , type-id   */
    1563                 :            : 
    1564                 :            : static void
    1565                 :          0 : pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
    1566                 :            : {
    1567                 :          0 :   tree ex_spec = TYPE_RAISES_EXCEPTIONS (t);
    1568                 :          0 :   bool need_comma = false;
    1569                 :            : 
    1570                 :          0 :   if (ex_spec == NULL)
    1571                 :            :     return;
    1572                 :          0 :   if (TREE_PURPOSE (ex_spec))
    1573                 :            :     {
    1574                 :          0 :       pp_cxx_ws_string (pp, "noexcept");
    1575                 :          0 :       pp_cxx_whitespace (pp);
    1576                 :          0 :       pp_cxx_left_paren (pp);
    1577                 :          0 :       if (DEFERRED_NOEXCEPT_SPEC_P (ex_spec))
    1578                 :          0 :         pp_cxx_ws_string (pp, "<uninstantiated>");
    1579                 :            :       else
    1580                 :          0 :         pp->expression (TREE_PURPOSE (ex_spec));
    1581                 :          0 :       pp_cxx_right_paren (pp);
    1582                 :          0 :       return;
    1583                 :            :     }
    1584                 :          0 :   pp_cxx_ws_string (pp, "throw");
    1585                 :          0 :   pp_cxx_left_paren (pp);
    1586                 :          0 :   for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
    1587                 :            :     {
    1588                 :          0 :       tree type = TREE_VALUE (ex_spec);
    1589                 :          0 :       tree argpack = NULL_TREE;
    1590                 :          0 :       int i, len = 1;
    1591                 :            : 
    1592                 :          0 :       if (ARGUMENT_PACK_P (type))
    1593                 :            :         {
    1594                 :          0 :           argpack = ARGUMENT_PACK_ARGS (type);
    1595                 :          0 :           len = TREE_VEC_LENGTH (argpack);
    1596                 :            :         }
    1597                 :            : 
    1598                 :          0 :       for (i = 0; i < len; ++i)
    1599                 :            :         {
    1600                 :          0 :           if (argpack)
    1601                 :          0 :             type = TREE_VEC_ELT (argpack, i);
    1602                 :            : 
    1603                 :          0 :           if (need_comma)
    1604                 :          0 :             pp_cxx_separate_with (pp, ',');
    1605                 :            :           else
    1606                 :            :             need_comma = true;
    1607                 :            : 
    1608                 :          0 :           pp->type_id (type);
    1609                 :            :         }
    1610                 :            :     }
    1611                 :          0 :   pp_cxx_right_paren (pp);
    1612                 :            : }
    1613                 :            : 
    1614                 :            : /* direct-declarator:
    1615                 :            :       declarator-id
    1616                 :            :       direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
    1617                 :            :                                             exception-specification(opt)
    1618                 :            :       direct-declaration [ constant-expression(opt) ]
    1619                 :            :       ( declarator )  */
    1620                 :            : 
    1621                 :            : void
    1622                 :          3 : cxx_pretty_printer::direct_declarator (tree t)
    1623                 :            : {
    1624                 :          3 :   switch (TREE_CODE (t))
    1625                 :            :     {
    1626                 :          3 :     case VAR_DECL:
    1627                 :          3 :     case PARM_DECL:
    1628                 :          3 :     case CONST_DECL:
    1629                 :          3 :     case FIELD_DECL:
    1630                 :          3 :       if (DECL_NAME (t))
    1631                 :            :         {
    1632                 :          3 :           pp_cxx_space_for_pointer_operator (this, TREE_TYPE (t));
    1633                 :            : 
    1634                 :          6 :           if ((TREE_CODE (t) == PARM_DECL && DECL_PACK_P (t))
    1635                 :          6 :               || template_parameter_pack_p (t))
    1636                 :            :             /* A function parameter pack or non-type template
    1637                 :            :                parameter pack.  */
    1638                 :          0 :             pp_cxx_ws_string (this, "...");
    1639                 :            :                       
    1640                 :          3 :           id_expression (DECL_NAME (t));
    1641                 :            :         }
    1642                 :          3 :       abstract_declarator (TREE_TYPE (t));
    1643                 :          3 :       break;
    1644                 :            : 
    1645                 :          0 :     case FUNCTION_DECL:
    1646                 :          0 :       pp_cxx_space_for_pointer_operator (this, TREE_TYPE (TREE_TYPE (t)));
    1647                 :          0 :       expression (t);
    1648                 :          0 :       pp_cxx_parameter_declaration_clause (this, t);
    1649                 :            : 
    1650                 :          0 :       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
    1651                 :            :         {
    1652                 :          0 :           padding = pp_before;
    1653                 :          0 :           pp_cxx_cv_qualifier_seq (this, pp_cxx_implicit_parameter_type (t));
    1654                 :            :         }
    1655                 :            : 
    1656                 :          0 :       pp_cxx_exception_specification (this, TREE_TYPE (t));
    1657                 :          0 :       break;
    1658                 :            : 
    1659                 :            :     case TYPENAME_TYPE:
    1660                 :            :     case TEMPLATE_DECL:
    1661                 :            :     case TEMPLATE_TYPE_PARM:
    1662                 :            :     case TEMPLATE_PARM_INDEX:
    1663                 :            :     case TEMPLATE_TEMPLATE_PARM:
    1664                 :            :       break;
    1665                 :            : 
    1666                 :          0 :     default:
    1667                 :          0 :       c_pretty_printer::direct_declarator (t);
    1668                 :          0 :       break;
    1669                 :            :     }
    1670                 :          3 : }
    1671                 :            : 
    1672                 :            : /* declarator:
    1673                 :            :    direct-declarator
    1674                 :            :    ptr-operator declarator  */
    1675                 :            : 
    1676                 :            : void
    1677                 :          3 : cxx_pretty_printer::declarator (tree t)
    1678                 :            : {
    1679                 :          3 :   direct_declarator (t);
    1680                 :            : 
    1681                 :            :   // Print a requires clause.
    1682                 :          3 :   if (flag_concepts)
    1683                 :          3 :     if (tree ci = get_constraints (t))
    1684                 :          0 :       if (tree reqs = CI_DECLARATOR_REQS (ci))
    1685                 :          0 :         pp_cxx_requires_clause (this, reqs);
    1686                 :          3 : }
    1687                 :            : 
    1688                 :            : /* ctor-initializer:
    1689                 :            :       : mem-initializer-list
    1690                 :            : 
    1691                 :            :    mem-initializer-list:
    1692                 :            :       mem-initializer
    1693                 :            :       mem-initializer , mem-initializer-list
    1694                 :            : 
    1695                 :            :    mem-initializer:
    1696                 :            :       mem-initializer-id ( expression-list(opt) )
    1697                 :            : 
    1698                 :            :    mem-initializer-id:
    1699                 :            :       ::(opt) nested-name-specifier(opt) class-name
    1700                 :            :       identifier   */
    1701                 :            : 
    1702                 :            : static void
    1703                 :          0 : pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
    1704                 :            : {
    1705                 :          0 :   t = TREE_OPERAND (t, 0);
    1706                 :          0 :   pp_cxx_whitespace (pp);
    1707                 :          0 :   pp_colon (pp);
    1708                 :          0 :   pp_cxx_whitespace (pp);
    1709                 :          0 :   for (; t; t = TREE_CHAIN (t))
    1710                 :            :     {
    1711                 :          0 :       tree purpose = TREE_PURPOSE (t);
    1712                 :          0 :       bool is_pack = PACK_EXPANSION_P (purpose);
    1713                 :            : 
    1714                 :          0 :       if (is_pack)
    1715                 :          0 :         pp->primary_expression (PACK_EXPANSION_PATTERN (purpose));
    1716                 :            :       else
    1717                 :          0 :         pp->primary_expression (purpose);
    1718                 :          0 :       pp_cxx_call_argument_list (pp, TREE_VALUE (t));
    1719                 :          0 :       if (is_pack)
    1720                 :          0 :         pp_cxx_ws_string (pp, "...");
    1721                 :          0 :       if (TREE_CHAIN (t))
    1722                 :          0 :         pp_cxx_separate_with (pp, ',');
    1723                 :            :     }
    1724                 :          0 : }
    1725                 :            : 
    1726                 :            : /* function-definition:
    1727                 :            :       decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
    1728                 :            :       decl-specifier-seq(opt) declarator function-try-block  */
    1729                 :            : 
    1730                 :            : static void
    1731                 :          0 : pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
    1732                 :            : {
    1733                 :          0 :   tree saved_scope = pp->enclosing_scope;
    1734                 :          0 :   pp->declaration_specifiers (t);
    1735                 :          0 :   pp->declarator (t);
    1736                 :          0 :   pp_needs_newline (pp) = true;
    1737                 :          0 :   pp->enclosing_scope = DECL_CONTEXT (t);
    1738                 :          0 :   if (DECL_SAVED_TREE (t))
    1739                 :          0 :     pp->statement (DECL_SAVED_TREE (t));
    1740                 :            :   else
    1741                 :          0 :     pp_cxx_semicolon (pp);
    1742                 :          0 :   pp_newline_and_flush (pp);
    1743                 :          0 :   pp->enclosing_scope = saved_scope;
    1744                 :          0 : }
    1745                 :            : 
    1746                 :            : /* abstract-declarator:
    1747                 :            :       ptr-operator abstract-declarator(opt)
    1748                 :            :       direct-abstract-declarator  */
    1749                 :            : 
    1750                 :            : void
    1751                 :        553 : cxx_pretty_printer::abstract_declarator (tree t)
    1752                 :            : {
    1753                 :        553 :   if (TYPE_PTRMEM_P (t))
    1754                 :          0 :     pp_cxx_right_paren (this);
    1755                 :        553 :   else if (INDIRECT_TYPE_P (t))
    1756                 :            :     {
    1757                 :         72 :       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
    1758                 :         72 :           || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
    1759                 :          6 :         pp_cxx_right_paren (this);
    1760                 :         72 :       t = TREE_TYPE (t);
    1761                 :            :     }
    1762                 :        553 :   direct_abstract_declarator (t);
    1763                 :        553 : }
    1764                 :            : 
    1765                 :            : /* direct-abstract-declarator:
    1766                 :            :       direct-abstract-declarator(opt) ( parameter-declaration-clause )
    1767                 :            :                            cv-qualifier-seq(opt) exception-specification(opt)
    1768                 :            :       direct-abstract-declarator(opt) [ constant-expression(opt) ]
    1769                 :            :       ( abstract-declarator )  */
    1770                 :            : 
    1771                 :            : void
    1772                 :        563 : cxx_pretty_printer::direct_abstract_declarator (tree t)
    1773                 :            : {
    1774                 :        563 :   switch (TREE_CODE (t))
    1775                 :            :     {
    1776                 :          0 :     case REFERENCE_TYPE:
    1777                 :          0 :       abstract_declarator (t);
    1778                 :          0 :       break;
    1779                 :            : 
    1780                 :         14 :     case RECORD_TYPE:
    1781                 :         14 :       if (TYPE_PTRMEMFUNC_P (t))
    1782                 :          0 :         direct_abstract_declarator (TYPE_PTRMEMFUNC_FN_TYPE (t));
    1783                 :            :       break;
    1784                 :            : 
    1785                 :          0 :     case METHOD_TYPE:
    1786                 :          0 :     case FUNCTION_TYPE:
    1787                 :          0 :       pp_cxx_parameter_declaration_clause (this, t);
    1788                 :          0 :       direct_abstract_declarator (TREE_TYPE (t));
    1789                 :          0 :       if (TREE_CODE (t) == METHOD_TYPE)
    1790                 :            :         {
    1791                 :          0 :           padding = pp_before;
    1792                 :          0 :           pp_cxx_cv_qualifier_seq (this, class_of_this_parm (t));
    1793                 :            :         }
    1794                 :          0 :       pp_cxx_exception_specification (this, t);
    1795                 :          0 :       break;
    1796                 :            : 
    1797                 :            :     case TYPENAME_TYPE:
    1798                 :            :     case TEMPLATE_TYPE_PARM:
    1799                 :            :     case TEMPLATE_TEMPLATE_PARM:
    1800                 :            :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    1801                 :            :     case UNBOUND_CLASS_TEMPLATE:
    1802                 :            :       break;
    1803                 :            : 
    1804                 :        520 :     default:
    1805                 :        520 :       c_pretty_printer::direct_abstract_declarator (t);
    1806                 :        520 :       break;
    1807                 :            :     }
    1808                 :        563 : }
    1809                 :            : 
    1810                 :            : /* type-id:
    1811                 :            :      type-specifier-seq abstract-declarator(opt) */
    1812                 :            : 
    1813                 :            : void
    1814                 :     316800 : cxx_pretty_printer::type_id (tree t)
    1815                 :            : {
    1816                 :     316800 :   pp_flags saved_flags = flags;
    1817                 :     316800 :   flags |= pp_c_flag_abstract;
    1818                 :            : 
    1819                 :     316800 :   switch (TREE_CODE (t))
    1820                 :            :     {
    1821                 :     316225 :     case TYPE_DECL:
    1822                 :     316225 :     case UNION_TYPE:
    1823                 :     316225 :     case RECORD_TYPE:
    1824                 :     316225 :     case ENUMERAL_TYPE:
    1825                 :     316225 :     case TYPENAME_TYPE:
    1826                 :     316225 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    1827                 :     316225 :     case UNBOUND_CLASS_TEMPLATE:
    1828                 :     316225 :     case TEMPLATE_TEMPLATE_PARM:
    1829                 :     316225 :     case TEMPLATE_TYPE_PARM:
    1830                 :     316225 :     case TEMPLATE_PARM_INDEX:
    1831                 :     316225 :     case TEMPLATE_DECL:
    1832                 :     316225 :     case TYPEOF_TYPE:
    1833                 :     316225 :     case UNDERLYING_TYPE:
    1834                 :     316225 :     case DECLTYPE_TYPE:
    1835                 :     316225 :     case TEMPLATE_ID_EXPR:
    1836                 :     316225 :       pp_cxx_type_specifier_seq (this, t);
    1837                 :     316225 :       break;
    1838                 :            : 
    1839                 :          6 :     case TYPE_PACK_EXPANSION:
    1840                 :         12 :       type_id (PACK_EXPANSION_PATTERN (t));
    1841                 :          6 :       pp_cxx_ws_string (this, "...");
    1842                 :          6 :       break;
    1843                 :            : 
    1844                 :         19 :     case TYPE_ARGUMENT_PACK:
    1845                 :         19 :       {
    1846                 :         38 :         tree args = ARGUMENT_PACK_ARGS (t);
    1847                 :         19 :         int len = TREE_VEC_LENGTH (args);
    1848                 :         19 :         pp_cxx_left_brace (this);
    1849                 :         65 :         for (int i = 0; i < len; ++i)
    1850                 :            :           {
    1851                 :         46 :             if (i > 0)
    1852                 :         27 :               pp_cxx_separate_with (this, ',');
    1853                 :         46 :             type_id (TREE_VEC_ELT (args, i));
    1854                 :            :           }
    1855                 :         19 :         pp_cxx_right_brace (this);
    1856                 :            :       }
    1857                 :         19 :       break;
    1858                 :            : 
    1859                 :        550 :     default:
    1860                 :        550 :       c_pretty_printer::type_id (t);
    1861                 :        550 :       break;
    1862                 :            :     }
    1863                 :            : 
    1864                 :     316800 :   flags = saved_flags;
    1865                 :     316800 : }
    1866                 :            : 
    1867                 :            : /* template-argument-list:
    1868                 :            :       template-argument ...(opt)
    1869                 :            :       template-argument-list, template-argument ...(opt)
    1870                 :            : 
    1871                 :            :    template-argument:
    1872                 :            :       assignment-expression
    1873                 :            :       type-id
    1874                 :            :       template-name  */
    1875                 :            : 
    1876                 :            : static void
    1877                 :        486 : pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
    1878                 :            : {
    1879                 :        486 :   int i;
    1880                 :        486 :   bool need_comma = false;
    1881                 :            : 
    1882                 :        486 :   if (t == NULL)
    1883                 :            :     return;
    1884                 :       1049 :   for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
    1885                 :            :     {
    1886                 :        563 :       tree arg = TREE_VEC_ELT (t, i);
    1887                 :        563 :       tree argpack = NULL_TREE;
    1888                 :        563 :       int idx, len = 1;
    1889                 :            : 
    1890                 :        563 :       if (ARGUMENT_PACK_P (arg))
    1891                 :            :         {
    1892                 :         28 :           argpack = ARGUMENT_PACK_ARGS (arg);
    1893                 :         14 :           len = TREE_VEC_LENGTH (argpack);
    1894                 :            :         }
    1895                 :            : 
    1896                 :       1130 :       for (idx = 0; idx < len; idx++)
    1897                 :            :         {
    1898                 :        567 :           if (argpack)
    1899                 :         18 :             arg = TREE_VEC_ELT (argpack, idx);
    1900                 :            : 
    1901                 :        567 :           if (need_comma)
    1902                 :         93 :             pp_cxx_separate_with (pp, ',');
    1903                 :            :           else
    1904                 :            :             need_comma = true;
    1905                 :            : 
    1906                 :        567 :           if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
    1907                 :          0 :                                && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
    1908                 :        535 :             pp->type_id (arg);
    1909                 :            :           else
    1910                 :         32 :             pp->expression (arg);
    1911                 :            :         }
    1912                 :            :     }
    1913                 :            : }
    1914                 :            : 
    1915                 :            : 
    1916                 :            : static void
    1917                 :          0 : pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
    1918                 :            : {
    1919                 :          0 :   t = DECL_EXPR_DECL (t);
    1920                 :          0 :   pp_cxx_type_specifier_seq (pp, t);
    1921                 :          0 :   if (TYPE_P (t))
    1922                 :          0 :     pp->abstract_declarator (t);
    1923                 :            :   else
    1924                 :          0 :     pp->declarator (t);
    1925                 :          0 : }
    1926                 :            : 
    1927                 :            : /* Statements.  */
    1928                 :            : 
    1929                 :            : void
    1930                 :          0 : cxx_pretty_printer::statement (tree t)
    1931                 :            : {
    1932                 :          0 :   switch (TREE_CODE (t))
    1933                 :            :     {
    1934                 :          0 :     case CTOR_INITIALIZER:
    1935                 :          0 :       pp_cxx_ctor_initializer (this, t);
    1936                 :          0 :       break;
    1937                 :            : 
    1938                 :          0 :     case USING_STMT:
    1939                 :          0 :       pp_cxx_ws_string (this, "using");
    1940                 :          0 :       pp_cxx_ws_string (this, "namespace");
    1941                 :          0 :       if (DECL_CONTEXT (t))
    1942                 :          0 :         pp_cxx_nested_name_specifier (this, DECL_CONTEXT (t));
    1943                 :          0 :       pp_cxx_qualified_id (this, USING_STMT_NAMESPACE (t));
    1944                 :          0 :       break;
    1945                 :            : 
    1946                 :          0 :     case USING_DECL:
    1947                 :          0 :       pp_cxx_ws_string (this, "using");
    1948                 :          0 :       pp_cxx_nested_name_specifier (this, USING_DECL_SCOPE (t));
    1949                 :          0 :       pp_cxx_unqualified_id (this, DECL_NAME (t));
    1950                 :          0 :       break;
    1951                 :            : 
    1952                 :            :     case EH_SPEC_BLOCK:
    1953                 :            :       break;
    1954                 :            : 
    1955                 :            :       /* try-block:
    1956                 :            :             try compound-statement handler-seq  */
    1957                 :          0 :     case TRY_BLOCK:
    1958                 :          0 :       pp_maybe_newline_and_indent (this, 0);
    1959                 :          0 :       pp_cxx_ws_string (this, "try");
    1960                 :          0 :       pp_newline_and_indent (this, 3);
    1961                 :          0 :       statement (TRY_STMTS (t));
    1962                 :          0 :       pp_newline_and_indent (this, -3);
    1963                 :          0 :       if (CLEANUP_P (t))
    1964                 :            :         ;
    1965                 :            :       else
    1966                 :          0 :         statement (TRY_HANDLERS (t));
    1967                 :            :       break;
    1968                 :            : 
    1969                 :            :       /*
    1970                 :            :          handler-seq:
    1971                 :            :             handler handler-seq(opt)
    1972                 :            : 
    1973                 :            :          handler:
    1974                 :            :          catch ( exception-declaration ) compound-statement
    1975                 :            : 
    1976                 :            :          exception-declaration:
    1977                 :            :             type-specifier-seq declarator
    1978                 :            :             type-specifier-seq abstract-declarator
    1979                 :            :             ...   */
    1980                 :          0 :     case HANDLER:
    1981                 :          0 :       pp_cxx_ws_string (this, "catch");
    1982                 :          0 :       pp_cxx_left_paren (this);
    1983                 :          0 :       pp_cxx_exception_declaration (this, HANDLER_PARMS (t));
    1984                 :          0 :       pp_cxx_right_paren (this);
    1985                 :          0 :       pp_indentation (this) += 3;
    1986                 :          0 :       pp_needs_newline (this) = true;
    1987                 :          0 :       statement (HANDLER_BODY (t));
    1988                 :          0 :       pp_indentation (this) -= 3;
    1989                 :          0 :       pp_needs_newline (this) = true;
    1990                 :          0 :       break;
    1991                 :            : 
    1992                 :            :       /* selection-statement:
    1993                 :            :             if ( expression ) statement
    1994                 :            :             if ( expression ) statement else statement  */
    1995                 :          0 :     case IF_STMT:
    1996                 :          0 :       pp_cxx_ws_string (this, "if");
    1997                 :          0 :       pp_cxx_whitespace (this);
    1998                 :          0 :       pp_cxx_left_paren (this);
    1999                 :          0 :       expression (IF_COND (t));
    2000                 :          0 :       pp_cxx_right_paren (this);
    2001                 :          0 :       pp_newline_and_indent (this, 2);
    2002                 :          0 :       statement (THEN_CLAUSE (t));
    2003                 :          0 :       pp_newline_and_indent (this, -2);
    2004                 :          0 :       if (ELSE_CLAUSE (t))
    2005                 :            :         {
    2006                 :          0 :           tree else_clause = ELSE_CLAUSE (t);
    2007                 :          0 :           pp_cxx_ws_string (this, "else");
    2008                 :          0 :           if (TREE_CODE (else_clause) == IF_STMT)
    2009                 :          0 :             pp_cxx_whitespace (this);
    2010                 :            :           else
    2011                 :          0 :             pp_newline_and_indent (this, 2);
    2012                 :          0 :           statement (else_clause);
    2013                 :          0 :           if (TREE_CODE (else_clause) != IF_STMT)
    2014                 :          0 :             pp_newline_and_indent (this, -2);
    2015                 :            :         }
    2016                 :            :       break;
    2017                 :            : 
    2018                 :          0 :     case SWITCH_STMT:
    2019                 :          0 :       pp_cxx_ws_string (this, "switch");
    2020                 :          0 :       pp_space (this);
    2021                 :          0 :       pp_cxx_left_paren (this);
    2022                 :          0 :       expression (SWITCH_STMT_COND (t));
    2023                 :          0 :       pp_cxx_right_paren (this);
    2024                 :          0 :       pp_indentation (this) += 3;
    2025                 :          0 :       pp_needs_newline (this) = true;
    2026                 :          0 :       statement (SWITCH_STMT_BODY (t));
    2027                 :          0 :       pp_newline_and_indent (this, -3);
    2028                 :          0 :       break;
    2029                 :            : 
    2030                 :            :       /* iteration-statement:
    2031                 :            :             while ( expression ) statement
    2032                 :            :             do statement while ( expression ) ;
    2033                 :            :             for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
    2034                 :            :             for ( declaration expression(opt) ; expression(opt) ) statement  */
    2035                 :          0 :     case WHILE_STMT:
    2036                 :          0 :       pp_cxx_ws_string (this, "while");
    2037                 :          0 :       pp_space (this);
    2038                 :          0 :       pp_cxx_left_paren (this);
    2039                 :          0 :       expression (WHILE_COND (t));
    2040                 :          0 :       pp_cxx_right_paren (this);
    2041                 :          0 :       pp_newline_and_indent (this, 3);
    2042                 :          0 :       statement (WHILE_BODY (t));
    2043                 :          0 :       pp_indentation (this) -= 3;
    2044                 :          0 :       pp_needs_newline (this) = true;
    2045                 :          0 :       break;
    2046                 :            : 
    2047                 :          0 :     case DO_STMT:
    2048                 :          0 :       pp_cxx_ws_string (this, "do");
    2049                 :          0 :       pp_newline_and_indent (this, 3);
    2050                 :          0 :       statement (DO_BODY (t));
    2051                 :          0 :       pp_newline_and_indent (this, -3);
    2052                 :          0 :       pp_cxx_ws_string (this, "while");
    2053                 :          0 :       pp_space (this);
    2054                 :          0 :       pp_cxx_left_paren (this);
    2055                 :          0 :       expression (DO_COND (t));
    2056                 :          0 :       pp_cxx_right_paren (this);
    2057                 :          0 :       pp_cxx_semicolon (this);
    2058                 :          0 :       pp_needs_newline (this) = true;
    2059                 :          0 :       break;
    2060                 :            : 
    2061                 :          0 :     case FOR_STMT:
    2062                 :          0 :       pp_cxx_ws_string (this, "for");
    2063                 :          0 :       pp_space (this);
    2064                 :          0 :       pp_cxx_left_paren (this);
    2065                 :          0 :       if (FOR_INIT_STMT (t))
    2066                 :          0 :         statement (FOR_INIT_STMT (t));
    2067                 :            :       else
    2068                 :          0 :         pp_cxx_semicolon (this);
    2069                 :          0 :       pp_needs_newline (this) = false;
    2070                 :          0 :       pp_cxx_whitespace (this);
    2071                 :          0 :       if (FOR_COND (t))
    2072                 :          0 :         expression (FOR_COND (t));
    2073                 :          0 :       pp_cxx_semicolon (this);
    2074                 :          0 :       pp_needs_newline (this) = false;
    2075                 :          0 :       pp_cxx_whitespace (this);
    2076                 :          0 :       if (FOR_EXPR (t))
    2077                 :          0 :         expression (FOR_EXPR (t));
    2078                 :          0 :       pp_cxx_right_paren (this);
    2079                 :          0 :       pp_newline_and_indent (this, 3);
    2080                 :          0 :       statement (FOR_BODY (t));
    2081                 :          0 :       pp_indentation (this) -= 3;
    2082                 :          0 :       pp_needs_newline (this) = true;
    2083                 :          0 :       break;
    2084                 :            : 
    2085                 :          0 :     case RANGE_FOR_STMT:
    2086                 :          0 :       pp_cxx_ws_string (this, "for");
    2087                 :          0 :       pp_space (this);
    2088                 :          0 :       pp_cxx_left_paren (this);
    2089                 :          0 :       if (RANGE_FOR_INIT_STMT (t))
    2090                 :            :         {
    2091                 :          0 :           statement (RANGE_FOR_INIT_STMT (t));
    2092                 :          0 :           pp_needs_newline (this) = false;
    2093                 :          0 :           pp_cxx_whitespace (this);
    2094                 :            :         }
    2095                 :          0 :       statement (RANGE_FOR_DECL (t));
    2096                 :          0 :       pp_space (this);
    2097                 :          0 :       pp_needs_newline (this) = false;
    2098                 :          0 :       pp_colon (this);
    2099                 :          0 :       pp_space (this);
    2100                 :          0 :       statement (RANGE_FOR_EXPR (t));
    2101                 :          0 :       pp_cxx_right_paren (this);
    2102                 :          0 :       pp_newline_and_indent (this, 3);
    2103                 :          0 :       statement (FOR_BODY (t));
    2104                 :          0 :       pp_indentation (this) -= 3;
    2105                 :          0 :       pp_needs_newline (this) = true;
    2106                 :          0 :       break;
    2107                 :            : 
    2108                 :            :       /* jump-statement:
    2109                 :            :             goto identifier;
    2110                 :            :             continue ;
    2111                 :            :             return expression(opt) ;  */
    2112                 :          0 :     case BREAK_STMT:
    2113                 :          0 :     case CONTINUE_STMT:
    2114                 :          0 :       pp_string (this, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
    2115                 :          0 :       pp_cxx_semicolon (this);
    2116                 :          0 :       pp_needs_newline (this) = true;
    2117                 :          0 :       break;
    2118                 :            : 
    2119                 :            :       /* expression-statement:
    2120                 :            :             expression(opt) ;  */
    2121                 :          0 :     case EXPR_STMT:
    2122                 :          0 :       expression (EXPR_STMT_EXPR (t));
    2123                 :          0 :       pp_cxx_semicolon (this);
    2124                 :          0 :       pp_needs_newline (this) = true;
    2125                 :          0 :       break;
    2126                 :            : 
    2127                 :          0 :     case CLEANUP_STMT:
    2128                 :          0 :       pp_cxx_ws_string (this, "try");
    2129                 :          0 :       pp_newline_and_indent (this, 2);
    2130                 :          0 :       statement (CLEANUP_BODY (t));
    2131                 :          0 :       pp_newline_and_indent (this, -2);
    2132                 :          0 :       pp_cxx_ws_string (this, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
    2133                 :          0 :       pp_newline_and_indent (this, 2);
    2134                 :          0 :       statement (CLEANUP_EXPR (t));
    2135                 :          0 :       pp_newline_and_indent (this, -2);
    2136                 :          0 :       break;
    2137                 :            : 
    2138                 :          0 :     case STATIC_ASSERT:
    2139                 :          0 :       declaration (t);
    2140                 :          0 :       break;
    2141                 :            : 
    2142                 :          0 :     case OMP_DEPOBJ:
    2143                 :          0 :       pp_cxx_ws_string (this, "#pragma omp depobj");
    2144                 :          0 :       pp_space (this);
    2145                 :          0 :       pp_cxx_left_paren (this);
    2146                 :          0 :       expression (OMP_DEPOBJ_DEPOBJ (t));
    2147                 :          0 :       pp_cxx_right_paren (this);
    2148                 :          0 :       if (OMP_DEPOBJ_CLAUSES (t) && OMP_DEPOBJ_CLAUSES (t) != error_mark_node)
    2149                 :            :         {
    2150                 :          0 :           if (TREE_CODE (OMP_DEPOBJ_CLAUSES (t)) == OMP_CLAUSE)
    2151                 :          0 :             dump_omp_clauses (this, OMP_DEPOBJ_CLAUSES (t),
    2152                 :            :                               pp_indentation (this), TDF_NONE);
    2153                 :            :           else
    2154                 :          0 :             switch (tree_to_uhwi (OMP_DEPOBJ_CLAUSES (t)))
    2155                 :            :               {
    2156                 :          0 :               case OMP_CLAUSE_DEPEND_IN:
    2157                 :          0 :                 pp_cxx_ws_string (this, " update(in)");
    2158                 :          0 :                 break;
    2159                 :          0 :               case OMP_CLAUSE_DEPEND_INOUT:
    2160                 :          0 :                 pp_cxx_ws_string (this, " update(inout)");
    2161                 :          0 :                 break;
    2162                 :          0 :               case OMP_CLAUSE_DEPEND_OUT:
    2163                 :          0 :                 pp_cxx_ws_string (this, " update(out)");
    2164                 :          0 :                 break;
    2165                 :          0 :               case OMP_CLAUSE_DEPEND_MUTEXINOUTSET:
    2166                 :          0 :                 pp_cxx_ws_string (this, " update(mutexinoutset)");
    2167                 :          0 :                 break;
    2168                 :          0 :               case OMP_CLAUSE_DEPEND_LAST:
    2169                 :          0 :                 pp_cxx_ws_string (this, " destroy");
    2170                 :          0 :                 break;
    2171                 :            :               default:
    2172                 :            :                 break;
    2173                 :            :               }
    2174                 :            :         }
    2175                 :          0 :       pp_needs_newline (this) = true;
    2176                 :          0 :       break;
    2177                 :            : 
    2178                 :          0 :     default:
    2179                 :          0 :       c_pretty_printer::statement (t);
    2180                 :          0 :       break;
    2181                 :            :     }
    2182                 :          0 : }
    2183                 :            : 
    2184                 :            : /* original-namespace-definition:
    2185                 :            :       namespace identifier { namespace-body }
    2186                 :            : 
    2187                 :            :   As an edge case, we also handle unnamed namespace definition here.  */
    2188                 :            : 
    2189                 :            : static void
    2190                 :         70 : pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
    2191                 :            : {
    2192                 :         70 :   pp_cxx_ws_string (pp, "namespace");
    2193                 :         70 :   if (DECL_CONTEXT (t))
    2194                 :         70 :     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
    2195                 :         70 :   if (DECL_NAME (t))
    2196                 :         70 :     pp_cxx_unqualified_id (pp, t);
    2197                 :         70 :   pp_cxx_whitespace (pp);
    2198                 :         70 :   pp_cxx_left_brace (pp);
    2199                 :            :   /* We do not print the namespace-body.  */
    2200                 :         70 :   pp_cxx_whitespace (pp);
    2201                 :         70 :   pp_cxx_right_brace (pp);
    2202                 :         70 : }
    2203                 :            : 
    2204                 :            : /* namespace-alias:
    2205                 :            :       identifier
    2206                 :            : 
    2207                 :            :    namespace-alias-definition:
    2208                 :            :       namespace identifier = qualified-namespace-specifier ;
    2209                 :            : 
    2210                 :            :    qualified-namespace-specifier:
    2211                 :            :       ::(opt) nested-name-specifier(opt) namespace-name   */
    2212                 :            : 
    2213                 :            : static void
    2214                 :          8 : pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
    2215                 :            : {
    2216                 :          8 :   pp_cxx_ws_string (pp, "namespace");
    2217                 :          8 :   if (DECL_CONTEXT (t))
    2218                 :          8 :     pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
    2219                 :          8 :   pp_cxx_unqualified_id (pp, t);
    2220                 :          8 :   pp_cxx_whitespace (pp);
    2221                 :          8 :   pp_equal (pp);
    2222                 :          8 :   pp_cxx_whitespace (pp);
    2223                 :          8 :   if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
    2224                 :          8 :     pp_cxx_nested_name_specifier (pp,
    2225                 :          8 :                                   DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
    2226                 :          8 :   pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
    2227                 :          8 :   pp_cxx_semicolon (pp);
    2228                 :          8 : }
    2229                 :            : 
    2230                 :            : /* simple-declaration:
    2231                 :            :       decl-specifier-seq(opt) init-declarator-list(opt)  */
    2232                 :            : 
    2233                 :            : static void
    2234                 :          0 : pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
    2235                 :            : {
    2236                 :          0 :   pp->declaration_specifiers (t);
    2237                 :          0 :   pp_cxx_init_declarator (pp, t);
    2238                 :          0 :   pp_cxx_semicolon (pp);
    2239                 :          0 :   pp_needs_newline (pp) = true;
    2240                 :          0 : }
    2241                 :            : 
    2242                 :            : /*
    2243                 :            :   template-parameter-list:
    2244                 :            :      template-parameter
    2245                 :            :      template-parameter-list , template-parameter  */
    2246                 :            : 
    2247                 :            : static inline void
    2248                 :          0 : pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
    2249                 :            : {
    2250                 :          0 :   const int n = TREE_VEC_LENGTH (t);
    2251                 :          0 :   int i;
    2252                 :          0 :   for (i = 0; i < n; ++i)
    2253                 :            :     {
    2254                 :          0 :       if (i)
    2255                 :          0 :         pp_cxx_separate_with (pp, ',');
    2256                 :          0 :       pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
    2257                 :            :     }
    2258                 :          0 : }
    2259                 :            : 
    2260                 :            : /* template-parameter:
    2261                 :            :       type-parameter
    2262                 :            :       parameter-declaration
    2263                 :            : 
    2264                 :            :    type-parameter:
    2265                 :            :      class ...(opt) identifier(opt)
    2266                 :            :      class identifier(opt) = type-id
    2267                 :            :      typename identifier(opt)
    2268                 :            :      typename ...(opt) identifier(opt) = type-id
    2269                 :            :      template < template-parameter-list > class ...(opt) identifier(opt)
    2270                 :            :      template < template-parameter-list > class identifier(opt) = template-name  */
    2271                 :            : 
    2272                 :            : static void
    2273                 :          0 : pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
    2274                 :            : {
    2275                 :          0 :   tree parameter =  TREE_VALUE (t);
    2276                 :          0 :   switch (TREE_CODE (parameter))
    2277                 :            :     {
    2278                 :          0 :     case TYPE_DECL:
    2279                 :          0 :       pp_cxx_ws_string (pp, "class");
    2280                 :          0 :       if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
    2281                 :          0 :         pp_cxx_ws_string (pp, "...");
    2282                 :          0 :       if (DECL_NAME (parameter))
    2283                 :          0 :         pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
    2284                 :            :       /* FIXME: Check if we should print also default argument.  */
    2285                 :            :       break;
    2286                 :            : 
    2287                 :          0 :     case PARM_DECL:
    2288                 :          0 :       pp_cxx_parameter_declaration (pp, parameter);
    2289                 :          0 :       break;
    2290                 :            : 
    2291                 :            :     case TEMPLATE_DECL:
    2292                 :            :       break;
    2293                 :            : 
    2294                 :          0 :     default:
    2295                 :          0 :       pp_unsupported_tree (pp, t);
    2296                 :          0 :       break;
    2297                 :            :     }
    2298                 :          0 : }
    2299                 :            : 
    2300                 :            : /* Pretty-print a template parameter in the canonical form
    2301                 :            :    "template-parameter-<level>-<position in parameter list>".  */
    2302                 :            : 
    2303                 :            : void
    2304                 :       1656 : pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
    2305                 :            : {
    2306                 :       1656 :   const enum tree_code code = TREE_CODE (parm);
    2307                 :            : 
    2308                 :            :   /* Brings type template parameters to the canonical forms.  */
    2309                 :       1656 :   if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
    2310                 :       1656 :       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
    2311                 :        918 :     parm = TEMPLATE_TYPE_PARM_INDEX (parm);
    2312                 :            : 
    2313                 :       1656 :   pp_cxx_begin_template_argument_list (pp);
    2314                 :       1656 :   pp->translate_string ("template-parameter-");
    2315                 :       1656 :   pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
    2316                 :       1656 :   pp_minus (pp);
    2317                 :       1656 :   pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
    2318                 :       1656 :   pp_cxx_end_template_argument_list (pp);
    2319                 :       1656 : }
    2320                 :            : 
    2321                 :            : /* Print a constrained-type-specifier.  */
    2322                 :            : 
    2323                 :            : void
    2324                 :         17 : pp_cxx_constrained_type_spec (cxx_pretty_printer *pp, tree c)
    2325                 :            : {
    2326                 :         17 :   pp_cxx_whitespace (pp);
    2327                 :         17 :   pp_cxx_left_bracket (pp);
    2328                 :         17 :   pp->translate_string ("requires");
    2329                 :         17 :   pp_cxx_whitespace (pp);
    2330                 :         17 :   if (c == error_mark_node)
    2331                 :            :     {
    2332                 :          0 :       pp_cxx_ws_string(pp, "<unsatisfied-type-constraint>");
    2333                 :          0 :       return;
    2334                 :            :     }
    2335                 :         17 :   tree t, a;
    2336                 :         17 :   placeholder_extract_concept_and_args (c, t, a);
    2337                 :         17 :   pp->id_expression (t);
    2338                 :         17 :   pp_cxx_begin_template_argument_list (pp);
    2339                 :         17 :   pp_cxx_ws_string (pp, "<placeholder>");
    2340                 :         17 :   pp_cxx_separate_with (pp, ',');
    2341                 :         17 :   tree args = make_tree_vec (TREE_VEC_LENGTH (a) - 1);
    2342                 :         22 :   for (int i = 0; i < TREE_VEC_LENGTH (a) - 1; ++i)
    2343                 :          5 :     TREE_VEC_ELT (args, i) = TREE_VEC_ELT (a, i + 1);
    2344                 :         17 :   pp_cxx_template_argument_list (pp, args);
    2345                 :         17 :   ggc_free (args);
    2346                 :         17 :   pp_cxx_end_template_argument_list (pp);
    2347                 :         17 :   pp_cxx_right_bracket (pp);
    2348                 :            : }
    2349                 :            : 
    2350                 :            : /*
    2351                 :            :   template-declaration:
    2352                 :            :      export(opt) template < template-parameter-list > declaration
    2353                 :            : 
    2354                 :            :   Concept extensions:
    2355                 :            : 
    2356                 :            :   template-declaration:
    2357                 :            :      export(opt) template < template-parameter-list >
    2358                 :            :        requires-clause(opt) declaration */
    2359                 :            : 
    2360                 :            : static void
    2361                 :          0 : pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
    2362                 :            : {
    2363                 :          0 :   tree tmpl = most_general_template (t);
    2364                 :          0 :   tree level;
    2365                 :            : 
    2366                 :          0 :   pp_maybe_newline_and_indent (pp, 0);
    2367                 :          0 :   for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
    2368                 :            :     {
    2369                 :          0 :       pp_cxx_ws_string (pp, "template");
    2370                 :          0 :       pp_cxx_begin_template_argument_list (pp);
    2371                 :          0 :       pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
    2372                 :          0 :       pp_cxx_end_template_argument_list (pp);
    2373                 :          0 :       pp_newline_and_indent (pp, 3);
    2374                 :            :     }
    2375                 :            : 
    2376                 :          0 :   if (flag_concepts)
    2377                 :          0 :     if (tree ci = get_constraints (t))
    2378                 :          0 :       if (tree reqs = CI_TEMPLATE_REQS (ci))
    2379                 :            :          {
    2380                 :          0 :             pp_cxx_requires_clause (pp, reqs);
    2381                 :          0 :             pp_newline_and_indent (pp, 6);
    2382                 :            :          }
    2383                 :            : 
    2384                 :          0 :   if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
    2385                 :          0 :     pp_cxx_function_definition (pp, t);
    2386                 :          0 :   else if (TREE_CODE (t) == CONCEPT_DECL)
    2387                 :          0 :     pp_cxx_concept_definition (pp, t);
    2388                 :            :   else
    2389                 :          0 :     pp_cxx_simple_declaration (pp, t);
    2390                 :          0 : }
    2391                 :            : 
    2392                 :            : static void
    2393                 :          0 : pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
    2394                 :            : {
    2395                 :          0 :   pp_unsupported_tree (pp, t);
    2396                 :          0 : }
    2397                 :            : 
    2398                 :            : static void
    2399                 :          0 : pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
    2400                 :            : {
    2401                 :          0 :   pp_unsupported_tree (pp, t);
    2402                 :          0 : }
    2403                 :            : 
    2404                 :            : static void
    2405                 :          0 : pp_cxx_concept_definition (cxx_pretty_printer *pp, tree t)
    2406                 :            : {
    2407                 :          0 :   pp_cxx_unqualified_id (pp, DECL_NAME (t));
    2408                 :          0 :   pp_cxx_whitespace (pp);
    2409                 :          0 :   pp_cxx_ws_string (pp, "=");
    2410                 :          0 :   pp_cxx_whitespace (pp);
    2411                 :          0 :   pp->expression (DECL_INITIAL (t));
    2412                 :          0 :   pp_cxx_semicolon (pp);
    2413                 :          0 : }
    2414                 :            : 
    2415                 :            : /*
    2416                 :            :     declaration:
    2417                 :            :        block-declaration
    2418                 :            :        function-definition
    2419                 :            :        template-declaration
    2420                 :            :        explicit-instantiation
    2421                 :            :        explicit-specialization
    2422                 :            :        linkage-specification
    2423                 :            :        namespace-definition
    2424                 :            : 
    2425                 :            :     block-declaration:
    2426                 :            :        simple-declaration
    2427                 :            :        asm-definition
    2428                 :            :        namespace-alias-definition
    2429                 :            :        using-declaration
    2430                 :            :        using-directive
    2431                 :            :        static_assert-declaration */
    2432                 :            : void
    2433                 :         78 : cxx_pretty_printer::declaration (tree t)
    2434                 :            : {
    2435                 :         78 :   if (TREE_CODE (t) == STATIC_ASSERT)
    2436                 :            :     {
    2437                 :          0 :       pp_cxx_ws_string (this, "static_assert");
    2438                 :          0 :       pp_cxx_left_paren (this);
    2439                 :          0 :       expression (STATIC_ASSERT_CONDITION (t));
    2440                 :          0 :       pp_cxx_separate_with (this, ',');
    2441                 :          0 :       expression (STATIC_ASSERT_MESSAGE (t));
    2442                 :          0 :       pp_cxx_right_paren (this);
    2443                 :            :     }
    2444                 :         78 :   else if (!DECL_LANG_SPECIFIC (t))
    2445                 :          0 :     pp_cxx_simple_declaration (this, t);
    2446                 :         78 :   else if (DECL_USE_TEMPLATE (t))
    2447                 :          0 :     switch (DECL_USE_TEMPLATE (t))
    2448                 :            :       {
    2449                 :          0 :       case 1:
    2450                 :          0 :         pp_cxx_template_declaration (this, t);
    2451                 :          0 :         break;
    2452                 :            : 
    2453                 :          0 :       case 2:
    2454                 :          0 :         pp_cxx_explicit_specialization (this, t);
    2455                 :          0 :         break;
    2456                 :            : 
    2457                 :          0 :       case 3:
    2458                 :          0 :         pp_cxx_explicit_instantiation (this, t);
    2459                 :          0 :         break;
    2460                 :            : 
    2461                 :            :       default:
    2462                 :            :         break;
    2463                 :            :       }
    2464                 :         78 :   else switch (TREE_CODE (t))
    2465                 :            :     {
    2466                 :          0 :     case VAR_DECL:
    2467                 :          0 :     case TYPE_DECL:
    2468                 :          0 :       pp_cxx_simple_declaration (this, t);
    2469                 :          0 :       break;
    2470                 :            : 
    2471                 :          0 :     case FUNCTION_DECL:
    2472                 :          0 :       if (DECL_SAVED_TREE (t))
    2473                 :          0 :         pp_cxx_function_definition (this, t);
    2474                 :            :       else
    2475                 :          0 :         pp_cxx_simple_declaration (this, t);
    2476                 :            :       break;
    2477                 :            : 
    2478                 :         78 :     case NAMESPACE_DECL:
    2479                 :         78 :       if (DECL_NAMESPACE_ALIAS (t))
    2480                 :          8 :         pp_cxx_namespace_alias_definition (this, t);
    2481                 :            :       else
    2482                 :         70 :         pp_cxx_original_namespace_definition (this, t);
    2483                 :            :       break;
    2484                 :            : 
    2485                 :          0 :     default:
    2486                 :          0 :       pp_unsupported_tree (this, t);
    2487                 :          0 :       break;
    2488                 :            :     }
    2489                 :         78 : }
    2490                 :            : 
    2491                 :            : static void
    2492                 :          4 : pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
    2493                 :            : {
    2494                 :          4 :   t = TREE_OPERAND (t, 0);
    2495                 :          4 :   pp_cxx_ws_string (pp, "typeid");
    2496                 :          4 :   pp_cxx_left_paren (pp);
    2497                 :          4 :   if (TYPE_P (t))
    2498                 :          4 :     pp->type_id (t);
    2499                 :            :   else
    2500                 :          0 :     pp->expression (t);
    2501                 :          4 :   pp_cxx_right_paren (pp);
    2502                 :          4 : }
    2503                 :            : 
    2504                 :            : void
    2505                 :          4 : pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
    2506                 :            : {
    2507                 :          4 :   pp_cxx_ws_string (pp, "va_arg");
    2508                 :          4 :   pp_cxx_left_paren (pp);
    2509                 :          4 :   pp->assignment_expression (TREE_OPERAND (t, 0));
    2510                 :          4 :   pp_cxx_separate_with (pp, ',');
    2511                 :          4 :   pp->type_id (TREE_TYPE (t));
    2512                 :          4 :   pp_cxx_right_paren (pp);
    2513                 :          4 : }
    2514                 :            : 
    2515                 :            : static bool
    2516                 :         60 : pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
    2517                 :            : {
    2518                 :         60 :   switch (TREE_CODE (t))
    2519                 :            :     {
    2520                 :         20 :     case ARROW_EXPR:
    2521                 :         20 :       if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR
    2522                 :         20 :           && INDIRECT_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
    2523                 :            :         {
    2524                 :         20 :           pp->type_id (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))));
    2525                 :         20 :           pp_cxx_separate_with (pp, ',');
    2526                 :         20 :           return true;
    2527                 :            :         }
    2528                 :            :       return false;
    2529                 :         32 :     case COMPONENT_REF:
    2530                 :         32 :       if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
    2531                 :            :         return false;
    2532                 :         32 :       if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
    2533                 :         12 :         pp_cxx_dot (pp);
    2534                 :         32 :       pp->expression (TREE_OPERAND (t, 1));
    2535                 :         32 :       return true;
    2536                 :          8 :     case ARRAY_REF:
    2537                 :          8 :       if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
    2538                 :            :         return false;
    2539                 :          8 :       pp_left_bracket (pp);
    2540                 :          8 :       pp->expression (TREE_OPERAND (t, 1));
    2541                 :          8 :       pp_right_bracket (pp);
    2542                 :          8 :       return true;
    2543                 :            :     default:
    2544                 :            :       return false;
    2545                 :            :     }
    2546                 :            : }
    2547                 :            : 
    2548                 :            : void
    2549                 :         20 : pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
    2550                 :            : {
    2551                 :         20 :   pp_cxx_ws_string (pp, "offsetof");
    2552                 :         20 :   pp_cxx_left_paren (pp);
    2553                 :         20 :   if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
    2554                 :          0 :     pp->expression (TREE_OPERAND (t, 0));
    2555                 :         20 :   pp_cxx_right_paren (pp);
    2556                 :         20 : }
    2557                 :            : 
    2558                 :            : void
    2559                 :          0 : pp_cxx_addressof_expression (cxx_pretty_printer *pp, tree t)
    2560                 :            : {
    2561                 :          0 :   pp_cxx_ws_string (pp, "__builtin_addressof");
    2562                 :          0 :   pp_cxx_left_paren (pp);
    2563                 :          0 :   pp->expression (TREE_OPERAND (t, 0));
    2564                 :          0 :   pp_cxx_right_paren (pp);
    2565                 :          0 : }
    2566                 :            : 
    2567                 :            : static char const*
    2568                 :         42 : get_fold_operator (tree t)
    2569                 :            : {
    2570                 :         42 :   int op = int_cst_value (FOLD_EXPR_OP (t));
    2571                 :         42 :   ovl_op_info_t *info = OVL_OP_INFO (FOLD_EXPR_MODIFY_P (t), op);
    2572                 :         42 :   return info->name;
    2573                 :            : }
    2574                 :            : 
    2575                 :            : void
    2576                 :         33 : pp_cxx_unary_left_fold_expression (cxx_pretty_printer *pp, tree t)
    2577                 :            : {
    2578                 :         33 :   char const* op = get_fold_operator (t);
    2579                 :         33 :   tree expr = PACK_EXPANSION_PATTERN (FOLD_EXPR_PACK (t));
    2580                 :         33 :   pp_cxx_left_paren (pp);
    2581                 :         33 :   pp_cxx_ws_string (pp, "...");
    2582                 :         33 :   pp_cxx_ws_string (pp, op);
    2583                 :         33 :   pp->expression (expr);
    2584                 :         33 :   pp_cxx_right_paren (pp);
    2585                 :         33 : }
    2586                 :            : 
    2587                 :            : void
    2588                 :          9 : pp_cxx_unary_right_fold_expression (cxx_pretty_printer *pp, tree t)
    2589                 :            : {
    2590                 :          9 :   char const* op = get_fold_operator (t);
    2591                 :          9 :   tree expr = PACK_EXPANSION_PATTERN (FOLD_EXPR_PACK (t));
    2592                 :          9 :   pp_cxx_left_paren (pp);
    2593                 :          9 :   pp->expression (expr);
    2594                 :          9 :   pp_space (pp);
    2595                 :          9 :   pp_cxx_ws_string (pp, op);
    2596                 :          9 :   pp_cxx_ws_string (pp, "...");
    2597                 :          9 :   pp_cxx_right_paren (pp);
    2598                 :          9 : }
    2599                 :            : 
    2600                 :            : void
    2601                 :          0 : pp_cxx_binary_fold_expression (cxx_pretty_printer *pp, tree t)
    2602                 :            : {
    2603                 :          0 :   char const* op = get_fold_operator (t);
    2604                 :          0 :   tree t1 = TREE_OPERAND (t, 1);
    2605                 :          0 :   tree t2 = TREE_OPERAND (t, 2);
    2606                 :          0 :   if (t1 == FOLD_EXPR_PACK (t))
    2607                 :          0 :     t1 = PACK_EXPANSION_PATTERN (t1);
    2608                 :            :   else
    2609                 :          0 :     t2 = PACK_EXPANSION_PATTERN (t2);
    2610                 :          0 :   pp_cxx_left_paren (pp);
    2611                 :          0 :   pp->expression (t1);
    2612                 :          0 :   pp_cxx_ws_string (pp, op);
    2613                 :          0 :   pp_cxx_ws_string (pp, "...");
    2614                 :          0 :   pp_cxx_ws_string (pp, op);
    2615                 :          0 :   pp->expression (t2);
    2616                 :          0 :   pp_cxx_right_paren (pp);
    2617                 :          0 : }
    2618                 :            : 
    2619                 :            : void
    2620                 :        101 : pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
    2621                 :            : {
    2622                 :        101 :   cp_trait_kind kind = TRAIT_EXPR_KIND (t);
    2623                 :            : 
    2624                 :        101 :   switch (kind)
    2625                 :            :     {
    2626                 :          4 :     case CPTK_HAS_NOTHROW_ASSIGN:
    2627                 :          4 :       pp_cxx_ws_string (pp, "__has_nothrow_assign");
    2628                 :          4 :       break;
    2629                 :          4 :     case CPTK_HAS_TRIVIAL_ASSIGN:
    2630                 :          4 :       pp_cxx_ws_string (pp, "__has_trivial_assign");
    2631                 :          4 :       break;
    2632                 :          4 :     case CPTK_HAS_NOTHROW_CONSTRUCTOR:
    2633                 :          4 :       pp_cxx_ws_string (pp, "__has_nothrow_constructor");
    2634                 :          4 :       break;
    2635                 :          4 :     case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
    2636                 :          4 :       pp_cxx_ws_string (pp, "__has_trivial_constructor");
    2637                 :          4 :       break;
    2638                 :          4 :     case CPTK_HAS_NOTHROW_COPY:
    2639                 :          4 :       pp_cxx_ws_string (pp, "__has_nothrow_copy");
    2640                 :          4 :       break;
    2641                 :          4 :     case CPTK_HAS_TRIVIAL_COPY:
    2642                 :          4 :       pp_cxx_ws_string (pp, "__has_trivial_copy");
    2643                 :          4 :       break;
    2644                 :          4 :     case CPTK_HAS_TRIVIAL_DESTRUCTOR:
    2645                 :          4 :       pp_cxx_ws_string (pp, "__has_trivial_destructor");
    2646                 :          4 :       break;
    2647                 :          0 :     case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS:
    2648                 :          0 :       pp_cxx_ws_string (pp, "__has_unique_object_representations");
    2649                 :          0 :       break;
    2650                 :          4 :     case CPTK_HAS_VIRTUAL_DESTRUCTOR:
    2651                 :          4 :       pp_cxx_ws_string (pp, "__has_virtual_destructor");
    2652                 :          4 :       break;
    2653                 :          4 :     case CPTK_IS_ABSTRACT:
    2654                 :          4 :       pp_cxx_ws_string (pp, "__is_abstract");
    2655                 :          4 :       break;
    2656                 :          0 :     case CPTK_IS_AGGREGATE:
    2657                 :          0 :       pp_cxx_ws_string (pp, "__is_aggregate");
    2658                 :          0 :       break;
    2659                 :          4 :     case CPTK_IS_BASE_OF:
    2660                 :          4 :       pp_cxx_ws_string (pp, "__is_base_of");
    2661                 :          4 :       break;
    2662                 :          4 :     case CPTK_IS_CLASS:
    2663                 :          4 :       pp_cxx_ws_string (pp, "__is_class");
    2664                 :          4 :       break;
    2665                 :         12 :     case CPTK_IS_EMPTY:
    2666                 :         12 :       pp_cxx_ws_string (pp, "__is_empty");
    2667                 :         12 :       break;
    2668                 :          7 :     case CPTK_IS_ENUM:
    2669                 :          7 :       pp_cxx_ws_string (pp, "__is_enum");
    2670                 :          7 :       break;
    2671                 :          0 :     case CPTK_IS_FINAL:
    2672                 :          0 :       pp_cxx_ws_string (pp, "__is_final");
    2673                 :          0 :       break;
    2674                 :          4 :     case CPTK_IS_POD:
    2675                 :          4 :       pp_cxx_ws_string (pp, "__is_pod");
    2676                 :          4 :       break;
    2677                 :          4 :     case CPTK_IS_POLYMORPHIC:
    2678                 :          4 :       pp_cxx_ws_string (pp, "__is_polymorphic");
    2679                 :          4 :       break;
    2680                 :         26 :     case CPTK_IS_SAME_AS:
    2681                 :         26 :       pp_cxx_ws_string (pp, "__is_same");
    2682                 :         26 :       break;
    2683                 :          0 :     case CPTK_IS_STD_LAYOUT:
    2684                 :          0 :       pp_cxx_ws_string (pp, "__is_std_layout");
    2685                 :          0 :       break;
    2686                 :          0 :     case CPTK_IS_TRIVIAL:
    2687                 :          0 :       pp_cxx_ws_string (pp, "__is_trivial");
    2688                 :          0 :       break;
    2689                 :          0 :     case CPTK_IS_TRIVIALLY_ASSIGNABLE:
    2690                 :          0 :       pp_cxx_ws_string (pp, "__is_trivially_assignable");
    2691                 :          0 :       break;
    2692                 :          0 :     case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE:
    2693                 :          0 :       pp_cxx_ws_string (pp, "__is_trivially_constructible");
    2694                 :          0 :       break;
    2695                 :          0 :     case CPTK_IS_TRIVIALLY_COPYABLE:
    2696                 :          0 :       pp_cxx_ws_string (pp, "__is_trivially_copyable");
    2697                 :          0 :       break;
    2698                 :          4 :     case CPTK_IS_UNION:
    2699                 :          4 :       pp_cxx_ws_string (pp, "__is_union");
    2700                 :          4 :       break;
    2701                 :          0 :     case CPTK_IS_LITERAL_TYPE:
    2702                 :          0 :       pp_cxx_ws_string (pp, "__is_literal_type");
    2703                 :          0 :       break;
    2704                 :          0 :     case CPTK_IS_ASSIGNABLE:
    2705                 :          0 :       pp_cxx_ws_string (pp, "__is_assignable");
    2706                 :          0 :       break;
    2707                 :          0 :     case CPTK_IS_CONSTRUCTIBLE:
    2708                 :          0 :       pp_cxx_ws_string (pp, "__is_constructible");
    2709                 :          0 :       break;
    2710                 :            : 
    2711                 :          0 :     default:
    2712                 :          0 :       gcc_unreachable ();
    2713                 :            :     }
    2714                 :            : 
    2715                 :        101 :   pp_cxx_left_paren (pp);
    2716                 :        101 :   pp->type_id (TRAIT_EXPR_TYPE1 (t));
    2717                 :            : 
    2718                 :        101 :   if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_SAME_AS)
    2719                 :            :     {
    2720                 :         30 :       pp_cxx_separate_with (pp, ',');
    2721                 :         30 :       pp->type_id (TRAIT_EXPR_TYPE2 (t));
    2722                 :            :     }
    2723                 :            : 
    2724                 :        101 :   pp_cxx_right_paren (pp);
    2725                 :        101 : }
    2726                 :            : 
    2727                 :            : // requires-clause:
    2728                 :            : //    'requires' logical-or-expression
    2729                 :            : void
    2730                 :        217 : pp_cxx_requires_clause (cxx_pretty_printer *pp, tree t)
    2731                 :            : {
    2732                 :        217 :   if (!t)
    2733                 :            :     return;
    2734                 :        217 :   pp->padding = pp_before;
    2735                 :        217 :   pp_cxx_ws_string (pp, "requires");
    2736                 :        217 :   pp_space (pp);
    2737                 :        217 :   pp->expression (t);
    2738                 :            : }
    2739                 :            : 
    2740                 :            : /* requirement:
    2741                 :            :      simple-requirement
    2742                 :            :      compound-requirement
    2743                 :            :      type-requirement
    2744                 :            :      nested-requirement */
    2745                 :            : static void
    2746                 :         15 : pp_cxx_requirement (cxx_pretty_printer *pp, tree t)
    2747                 :            : {
    2748                 :         15 :   switch (TREE_CODE (t))
    2749                 :            :     {
    2750                 :          4 :     case SIMPLE_REQ:
    2751                 :          4 :       pp_cxx_simple_requirement (pp, t);
    2752                 :          4 :       break;
    2753                 :            : 
    2754                 :          0 :     case TYPE_REQ:
    2755                 :          0 :       pp_cxx_type_requirement (pp, t);
    2756                 :          0 :       break;
    2757                 :            : 
    2758                 :          0 :     case COMPOUND_REQ:
    2759                 :          0 :       pp_cxx_compound_requirement (pp, t);
    2760                 :          0 :       break;
    2761                 :            : 
    2762                 :         11 :     case NESTED_REQ:
    2763                 :         11 :       pp_cxx_nested_requirement (pp, t);
    2764                 :         11 :       break;
    2765                 :            : 
    2766                 :          0 :     default:
    2767                 :          0 :       gcc_unreachable ();
    2768                 :            :     }
    2769                 :         15 : }
    2770                 :            : 
    2771                 :            : // requirement-list:
    2772                 :            : //    requirement
    2773                 :            : //    requirement-list ';' requirement[opt]
    2774                 :            : //
    2775                 :            : static void
    2776                 :         15 : pp_cxx_requirement_list (cxx_pretty_printer *pp, tree t)
    2777                 :            : {
    2778                 :         30 :   for (; t; t = TREE_CHAIN (t))
    2779                 :         15 :     pp_cxx_requirement (pp, TREE_VALUE (t));
    2780                 :         15 : }
    2781                 :            : 
    2782                 :            : // requirement-body:
    2783                 :            : //    '{' requirement-list '}'
    2784                 :            : static void
    2785                 :         15 : pp_cxx_requirement_body (cxx_pretty_printer *pp, tree t)
    2786                 :            : {
    2787                 :         15 :   pp_cxx_left_brace (pp);
    2788                 :         15 :   pp_cxx_requirement_list (pp, t);
    2789                 :         15 :   pp_cxx_right_brace (pp);
    2790                 :         15 : }
    2791                 :            : 
    2792                 :            : // requires-expression:
    2793                 :            : //    'requires' requirement-parameter-list requirement-body
    2794                 :            : void
    2795                 :         15 : pp_cxx_requires_expr (cxx_pretty_printer *pp, tree t)
    2796                 :            : {
    2797                 :         15 :   pp_string (pp, "requires");
    2798                 :         15 :   if (tree parms = TREE_OPERAND (t, 0))
    2799                 :            :     {
    2800                 :          3 :       pp_cxx_parameter_declaration_clause (pp, parms);
    2801                 :          3 :       pp_cxx_whitespace (pp);
    2802                 :            :     }
    2803                 :         15 :   pp_cxx_requirement_body (pp, TREE_OPERAND (t, 1));
    2804                 :         15 : }
    2805                 :            : 
    2806                 :            : /* simple-requirement:
    2807                 :            :      expression ';' */
    2808                 :            : void
    2809                 :          4 : pp_cxx_simple_requirement (cxx_pretty_printer *pp, tree t)
    2810                 :            : {
    2811                 :          4 :   pp->expression (TREE_OPERAND (t, 0));
    2812                 :          4 :   pp_cxx_semicolon (pp);
    2813                 :          4 : }
    2814                 :            : 
    2815                 :            : /* type-requirement:
    2816                 :            :      typename type-name ';' */
    2817                 :            : void
    2818                 :          0 : pp_cxx_type_requirement (cxx_pretty_printer *pp, tree t)
    2819                 :            : {
    2820                 :          0 :   pp->type_id (TREE_OPERAND (t, 0));
    2821                 :          0 :   pp_cxx_semicolon (pp);
    2822                 :          0 : }
    2823                 :            : 
    2824                 :            : /* compound-requirement:
    2825                 :            :      '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] */
    2826                 :            : void
    2827                 :          0 : pp_cxx_compound_requirement (cxx_pretty_printer *pp, tree t)
    2828                 :            : {
    2829                 :          0 :   pp_cxx_left_brace (pp);
    2830                 :          0 :   pp->expression (TREE_OPERAND (t, 0));
    2831                 :          0 :   pp_cxx_right_brace (pp);
    2832                 :            : 
    2833                 :          0 :   if (COMPOUND_REQ_NOEXCEPT_P (t))
    2834                 :          0 :     pp_cxx_ws_string (pp, "noexcept");
    2835                 :            : 
    2836                 :          0 :   if (tree type = TREE_OPERAND (t, 1))
    2837                 :            :     {
    2838                 :          0 :       pp_cxx_whitespace (pp);
    2839                 :          0 :       pp_cxx_ws_string (pp, "->");
    2840                 :          0 :       pp->type_id (type);
    2841                 :            :     }
    2842                 :          0 :   pp_cxx_semicolon (pp);
    2843                 :          0 : }
    2844                 :            : 
    2845                 :            : /* nested requirement:
    2846                 :            :      'requires' constraint-expression */
    2847                 :            : void
    2848                 :         11 : pp_cxx_nested_requirement (cxx_pretty_printer *pp, tree t)
    2849                 :            : {
    2850                 :         11 :   pp_cxx_ws_string (pp, "requires");
    2851                 :         11 :   pp->expression (TREE_OPERAND (t, 0));
    2852                 :         11 :   pp_cxx_semicolon (pp);
    2853                 :         11 : }
    2854                 :            : 
    2855                 :            : void
    2856                 :          0 : pp_cxx_check_constraint (cxx_pretty_printer *pp, tree t)
    2857                 :            : {
    2858                 :          0 :   tree decl = CHECK_CONSTR_CONCEPT (t);
    2859                 :          0 :   tree tmpl = DECL_TI_TEMPLATE (decl);
    2860                 :          0 :   tree args = CHECK_CONSTR_ARGS (t);
    2861                 :          0 :   tree id = build_nt (TEMPLATE_ID_EXPR, tmpl, args);
    2862                 :            : 
    2863                 :          0 :   if (TREE_CODE (decl) == CONCEPT_DECL)
    2864                 :          0 :     pp->expression (id);
    2865                 :          0 :   else if (VAR_P (decl))
    2866                 :          0 :     pp->expression (id);
    2867                 :          0 :   else if (TREE_CODE (decl) == FUNCTION_DECL)
    2868                 :            :     {
    2869                 :          0 :       tree call = build_vl_exp (CALL_EXPR, 2);
    2870                 :          0 :       TREE_OPERAND (call, 0) = integer_two_node;
    2871                 :          0 :       TREE_OPERAND (call, 1) = id;
    2872                 :          0 :       pp->expression (call);
    2873                 :            :     }
    2874                 :            :   else
    2875                 :          0 :     gcc_unreachable ();
    2876                 :          0 : }
    2877                 :            : 
    2878                 :            : /* Output the "[with ...]" clause for a parameter mapping of an atomic
    2879                 :            :    constraint.   */
    2880                 :            : 
    2881                 :            : void
    2882                 :        269 : pp_cxx_parameter_mapping (cxx_pretty_printer *pp, tree map)
    2883                 :            : {
    2884                 :        269 :   pp_cxx_whitespace (pp);
    2885                 :        269 :   pp_cxx_left_bracket (pp);
    2886                 :        269 :   pp->translate_string ("with");
    2887                 :        269 :   pp_cxx_whitespace (pp);
    2888                 :            : 
    2889                 :        579 :   for (tree p = map; p; p = TREE_CHAIN (p))
    2890                 :            :     {
    2891                 :        310 :       tree parm = TREE_VALUE (p);
    2892                 :        310 :       tree arg = TREE_PURPOSE (p);
    2893                 :            : 
    2894                 :        310 :       if (TYPE_P (parm))
    2895                 :        297 :         pp->type_id (parm);
    2896                 :            :       else
    2897                 :         13 :         pp_cxx_tree_identifier (pp, DECL_NAME (TEMPLATE_PARM_DECL (parm)));
    2898                 :            : 
    2899                 :        310 :       pp_cxx_whitespace (pp);
    2900                 :        310 :       pp_equal (pp);
    2901                 :        310 :       pp_cxx_whitespace (pp);
    2902                 :            : 
    2903                 :        311 :       if (TYPE_P (arg) || DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
    2904                 :        296 :         pp->type_id (arg);
    2905                 :            :       else
    2906                 :         14 :         pp->expression (arg);
    2907                 :            : 
    2908                 :        310 :       if (TREE_CHAIN (p) != NULL_TREE)
    2909                 :         41 :         pp_cxx_separate_with (pp, ';');
    2910                 :            :     }
    2911                 :            : 
    2912                 :        269 :   pp_cxx_right_bracket (pp);
    2913                 :        269 : }
    2914                 :            : 
    2915                 :            : void
    2916                 :         56 : pp_cxx_atomic_constraint (cxx_pretty_printer *pp, tree t)
    2917                 :            : {
    2918                 :            :   /* Emit the expression.  */
    2919                 :         56 :   pp->expression (ATOMIC_CONSTR_EXPR (t));
    2920                 :            : 
    2921                 :            :   /* Emit the parameter mapping.  */
    2922                 :         56 :   tree map = ATOMIC_CONSTR_MAP (t);
    2923                 :         56 :   if (map && map != error_mark_node)
    2924                 :         52 :     pp_cxx_parameter_mapping (pp, map);
    2925                 :         56 : }
    2926                 :            : 
    2927                 :            : void
    2928                 :          0 : pp_cxx_conjunction (cxx_pretty_printer *pp, tree t)
    2929                 :            : {
    2930                 :          0 :   pp_cxx_constraint (pp, TREE_OPERAND (t, 0));
    2931                 :          0 :   pp_string (pp, " /\\ ");
    2932                 :          0 :   pp_cxx_constraint (pp, TREE_OPERAND (t, 1));
    2933                 :          0 : }
    2934                 :            : 
    2935                 :            : void
    2936                 :          0 : pp_cxx_disjunction (cxx_pretty_printer *pp, tree t)
    2937                 :            : {
    2938                 :          0 :   pp_cxx_constraint (pp, TREE_OPERAND (t, 0));
    2939                 :          0 :   pp_string (pp, " \\/ ");
    2940                 :          0 :   pp_cxx_constraint (pp, TREE_OPERAND (t, 1));
    2941                 :          0 : }
    2942                 :            : 
    2943                 :            : void
    2944                 :         56 : pp_cxx_constraint (cxx_pretty_printer *pp, tree t)
    2945                 :            : {
    2946                 :         56 :   if (t == error_mark_node)
    2947                 :          0 :     return pp->expression (t);
    2948                 :            : 
    2949                 :         56 :   switch (TREE_CODE (t))
    2950                 :            :     {
    2951                 :         56 :     case ATOMIC_CONSTR:
    2952                 :         56 :       pp_cxx_atomic_constraint (pp, t);
    2953                 :         56 :       break;
    2954                 :            : 
    2955                 :          0 :     case CHECK_CONSTR:
    2956                 :          0 :       pp_cxx_check_constraint (pp, t);
    2957                 :          0 :       break;
    2958                 :            : 
    2959                 :          0 :     case CONJ_CONSTR:
    2960                 :          0 :       pp_cxx_conjunction (pp, t);
    2961                 :          0 :       break;
    2962                 :            : 
    2963                 :          0 :     case DISJ_CONSTR:
    2964                 :          0 :       pp_cxx_disjunction (pp, t);
    2965                 :          0 :       break;
    2966                 :            : 
    2967                 :          0 :     case EXPR_PACK_EXPANSION:
    2968                 :          0 :       pp->expression (TREE_OPERAND (t, 0));
    2969                 :          0 :       break;
    2970                 :            : 
    2971                 :          0 :     default:
    2972                 :          0 :       gcc_unreachable ();
    2973                 :            :     }
    2974                 :            : }
    2975                 :            : 
    2976                 :            : 
    2977                 :            : typedef c_pretty_print_fn pp_fun;
    2978                 :            : 
    2979                 :            : /* Initialization of a C++ pretty-printer object.  */
    2980                 :            : 
    2981                 :     156584 : cxx_pretty_printer::cxx_pretty_printer ()
    2982                 :            :   : c_pretty_printer (),
    2983                 :     156584 :     enclosing_scope (global_namespace)
    2984                 :            : {
    2985                 :     156584 :   type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
    2986                 :     156584 :   parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
    2987                 :     156584 : }
    2988                 :            : 
    2989                 :            : /* cxx_pretty_printer's implementation of pretty_printer::clone vfunc.  */
    2990                 :            : 
    2991                 :            : pretty_printer *
    2992                 :        338 : cxx_pretty_printer::clone () const
    2993                 :            : {
    2994                 :        338 :   return new cxx_pretty_printer (*this);
    2995                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.