OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [cp/] [cxx-pretty-print.c] - Blame information for rev 750

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.