gcc/c-family/c-pretty-print.c

   1 /* Subroutines common to both C and C++ pretty-printers.
   2    Copyright (C) 2002-2017 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 "c-pretty-print.h"
  25 #include "diagnostic.h"
  26 #include "stor-layout.h"
  27 #include "attribs.h"
  28 #include "intl.h"
  29 #include "tree-pretty-print.h"
  30
  31 /* The pretty-printer code is primarily designed to closely follow
  32    (GNU) C and C++ grammars.  That is to be contrasted with spaghetti
  33    codes we used to have in the past.  Following a structured
  34    approach (preferably the official grammars) is believed to make it
  35    much easier to add extensions and nifty pretty-printing effects that
  36    takes expression or declaration contexts into account.  */
  37
  38
  39 #define pp_c_maybe_whitespace(PP)            \
  40    do {                                      \
  41      if ((PP)->padding == pp_before) \
  42        pp_c_whitespace (PP);                 \
  43    } while (0)
  44
  45 /* literal  */
  46 static void pp_c_char (c_pretty_printer *, int);
  47
  48 /* postfix-expression  */
  49 static void pp_c_initializer_list (c_pretty_printer *, tree);
  50 static void pp_c_brace_enclosed_initializer_list (c_pretty_printer *, tree);
  51
  52 static void pp_c_additive_expression (c_pretty_printer *, tree);
  53 static void pp_c_shift_expression (c_pretty_printer *, tree);
  54 static void pp_c_relational_expression (c_pretty_printer *, tree);
  55 static void pp_c_equality_expression (c_pretty_printer *, tree);
  56 static void pp_c_and_expression (c_pretty_printer *, tree);
  57 static void pp_c_exclusive_or_expression (c_pretty_printer *, tree);
  58 static void pp_c_inclusive_or_expression (c_pretty_printer *, tree);
  59 static void pp_c_logical_and_expression (c_pretty_printer *, tree);
  60
  61 /* declarations.  */
  62
  63 \f
  64 /* Helper functions.  */
  65
  66 void
  67 pp_c_whitespace (c_pretty_printer *pp)
  68 {
  69   pp_space (pp);
  70   pp->padding = pp_none;
  71 }
  72
  73 void
  74 pp_c_left_paren (c_pretty_printer *pp)
  75 {
  76   pp_left_paren (pp);
  77   pp->padding = pp_none;
  78 }
  79
  80 void
  81 pp_c_right_paren (c_pretty_printer *pp)
  82 {
  83   pp_right_paren (pp);
  84   pp->padding = pp_none;
  85 }
  86
  87 void
  88 pp_c_left_brace (c_pretty_printer *pp)
  89 {
  90   pp_left_brace (pp);
  91   pp->padding = pp_none;
  92 }
  93
  94 void
  95 pp_c_right_brace (c_pretty_printer *pp)
  96 {
  97   pp_right_brace (pp);
  98   pp->padding = pp_none;
  99 }
 100
 101 void
 102 pp_c_left_bracket (c_pretty_printer *pp)
 103 {
 104   pp_left_bracket (pp);
 105   pp->padding = pp_none;
 106 }
 107
 108 void
 109 pp_c_right_bracket (c_pretty_printer *pp)
 110 {
 111   pp_right_bracket (pp);
 112   pp->padding = pp_none;
 113 }
 114
 115 void
 116 pp_c_dot (c_pretty_printer *pp)
 117 {
 118   pp_dot (pp);
 119   pp->padding = pp_none;
 120 }
 121
 122 void
 123 pp_c_ampersand (c_pretty_printer *pp)
 124 {
 125   pp_ampersand (pp);
 126   pp->padding = pp_none;
 127 }
 128
 129 void
 130 pp_c_star (c_pretty_printer *pp)
 131 {
 132   pp_star (pp);
 133   pp->padding = pp_none;
 134 }
 135
 136 void
 137 pp_c_arrow (c_pretty_printer *pp)
 138 {
 139   pp_arrow (pp);
 140   pp->padding = pp_none;
 141 }
 142
 143 void
 144 pp_c_semicolon (c_pretty_printer *pp)
 145 {
 146   pp_semicolon (pp);
 147   pp->padding = pp_none;
 148 }
 149
 150 void
 151 pp_c_complement (c_pretty_printer *pp)
 152 {
 153   pp_complement (pp);
 154   pp->padding = pp_none;
 155 }
 156
 157 void
 158 pp_c_exclamation (c_pretty_printer *pp)
 159 {
 160   pp_exclamation (pp);
 161   pp->padding = pp_none;
 162 }
 163
 164 /* Print out the external representation of QUALIFIERS.  */
 165
 166 void
 167 pp_c_cv_qualifiers (c_pretty_printer *pp, int qualifiers, bool func_type)
 168 {
 169   const char *p = pp_last_position_in_text (pp);
 170
 171   if (!qualifiers)
 172     return;
 173
 174   /* The C programming language does not have references, but it is much
 175      simpler to handle those here rather than going through the same
 176      logic in the C++ pretty-printer.  */
 177   if (p != NULL && (*p == '*' || *p == '&'))
 178     pp_c_whitespace (pp);
 179
 180   if (qualifiers & TYPE_QUAL_ATOMIC)
 181     pp_c_ws_string (pp, "_Atomic");
 182   if (qualifiers & TYPE_QUAL_CONST)
 183     pp_c_ws_string (pp, func_type ? "__attribute__((const))" : "const");
 184   if (qualifiers & TYPE_QUAL_VOLATILE)
 185     pp_c_ws_string (pp, func_type ? "__attribute__((noreturn))" : "volatile");
 186   if (qualifiers & TYPE_QUAL_RESTRICT)
 187     pp_c_ws_string (pp, (flag_isoc99 && !c_dialect_cxx ()
 188                          ? "restrict" : "__restrict__"));
 189 }
 190
 191 /* Pretty-print T using the type-cast notation '( type-name )'.  */
 192
 193 static void
 194 pp_c_type_cast (c_pretty_printer *pp, tree t)
 195 {
 196   pp_c_left_paren (pp);
 197   pp->type_id (t);
 198   pp_c_right_paren (pp);
 199 }
 200
 201 /* We're about to pretty-print a pointer type as indicated by T.
 202    Output a whitespace, if needed, preparing for subsequent output.  */
 203
 204 void
 205 pp_c_space_for_pointer_operator (c_pretty_printer *pp, tree t)
 206 {
 207   if (POINTER_TYPE_P (t))
 208     {
 209       tree pointee = strip_pointer_operator (TREE_TYPE (t));
 210       if (TREE_CODE (pointee) != ARRAY_TYPE
 211           && TREE_CODE (pointee) != FUNCTION_TYPE)
 212         pp_c_whitespace (pp);
 213     }
 214 }
 215
 216 \f
 217 /* Declarations.  */
 218
 219 /* C++ cv-qualifiers are called type-qualifiers in C.  Print out the
 220    cv-qualifiers of T.  If T is a declaration then it is the cv-qualifier
 221    of its type.  Take care of possible extensions.
 222
 223    type-qualifier-list:
 224        type-qualifier
 225        type-qualifier-list type-qualifier
 226
 227    type-qualifier:
 228        const
 229        restrict                              -- C99
 230        __restrict__                          -- GNU C
 231        address-space-qualifier               -- GNU C
 232        volatile
 233        _Atomic                               -- C11
 234
 235    address-space-qualifier:
 236        identifier                            -- GNU C  */
 237
 238 void
 239 pp_c_type_qualifier_list (c_pretty_printer *pp, tree t)
 240 {
 241   int qualifiers;
 242
 243   if (!t || t == error_mark_node)
 244     return;
 245
 246   if (!TYPE_P (t))
 247     t = TREE_TYPE (t);
 248
 249   qualifiers = TYPE_QUALS (t);
 250   pp_c_cv_qualifiers (pp, qualifiers,
 251                       TREE_CODE (t) == FUNCTION_TYPE);
 252
 253   if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (t)))
 254     {
 255       const char *as = c_addr_space_name (TYPE_ADDR_SPACE (t));
 256       pp_c_identifier (pp, as);
 257     }
 258 }
 259
 260 /* pointer:
 261       * type-qualifier-list(opt)
 262       * type-qualifier-list(opt) pointer  */
 263
 264 static void
 265 pp_c_pointer (c_pretty_printer *pp, tree t)
 266 {
 267   if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
 268     t = TREE_TYPE (t);
 269   switch (TREE_CODE (t))
 270     {
 271     case POINTER_TYPE:
 272       /* It is easier to handle C++ reference types here.  */
 273     case REFERENCE_TYPE:
 274       if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
 275         pp_c_pointer (pp, TREE_TYPE (t));
 276       if (TREE_CODE (t) == POINTER_TYPE)
 277         pp_c_star (pp);
 278       else
 279         pp_c_ampersand (pp);
 280       pp_c_type_qualifier_list (pp, t);
 281       break;
 282
 283       /* ??? This node is now in GENERIC and so shouldn't be here.  But
 284          we'll fix that later.  */
 285     case DECL_EXPR:
 286       pp->declaration (DECL_EXPR_DECL (t));
 287       pp_needs_newline (pp) = true;
 288       break;
 289
 290     default:
 291       pp_unsupported_tree (pp, t);
 292     }
 293 }
 294
 295 /* simple-type-specifier:
 296      type-specifier
 297
 298    type-specifier:
 299       void
 300       char
 301       short
 302       int
 303       long
 304       float
 305       double
 306       signed
 307       unsigned
 308       _Bool                          -- C99
 309       _Complex                       -- C99
 310       _Imaginary                     -- C99
 311       struct-or-union-specifier
 312       enum-specifier
 313       typedef-name.
 314
 315   GNU extensions.
 316   simple-type-specifier:
 317       __complex__
 318       __vector__   */
 319
 320 void
 321 c_pretty_printer::simple_type_specifier (tree t)
 322 {
 323   const enum tree_code code = TREE_CODE (t);
 324   switch (code)
 325     {
 326     case ERROR_MARK:
 327       translate_string ("<type-error>");
 328       break;
 329
 330     case IDENTIFIER_NODE:
 331       pp_c_identifier (this, IDENTIFIER_POINTER (t));
 332       break;
 333
 334     case VOID_TYPE:
 335     case BOOLEAN_TYPE:
 336     case INTEGER_TYPE:
 337     case REAL_TYPE:
 338     case FIXED_POINT_TYPE:
 339       if (TYPE_NAME (t))
 340         {
 341           t = TYPE_NAME (t);
 342           simple_type_specifier (t);
 343         }
 344       else
 345         {
 346           int prec = TYPE_PRECISION (t);
 347           tree common_t;
 348           if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (t)))
 349             common_t = c_common_type_for_mode (TYPE_MODE (t),
 350                                                TYPE_SATURATING (t));
 351           else
 352             common_t = c_common_type_for_mode (TYPE_MODE (t),
 353                                                TYPE_UNSIGNED (t));
 354           if (common_t && TYPE_NAME (common_t))
 355             {
 356               simple_type_specifier (common_t);
 357               if (TYPE_PRECISION (common_t) != prec)
 358                 {
 359                   pp_colon (this);
 360                   pp_decimal_int (this, prec);
 361                 }
 362             }
 363           else
 364             {
 365               switch (code)
 366                 {
 367                 case INTEGER_TYPE:
 368                   translate_string (TYPE_UNSIGNED (t)
 369                                     ? "<unnamed-unsigned:"
 370                                     : "<unnamed-signed:");
 371                   break;
 372                 case REAL_TYPE:
 373                   translate_string ("<unnamed-float:");
 374                   break;
 375                 case FIXED_POINT_TYPE:
 376                   translate_string ("<unnamed-fixed:");
 377                   break;
 378                 default:
 379                   gcc_unreachable ();
 380                 }
 381               pp_decimal_int (this, prec);
 382               pp_greater (this);
 383             }
 384         }
 385       break;
 386
 387     case TYPE_DECL:
 388       if (DECL_NAME (t))
 389         id_expression (t);
 390       else
 391         translate_string ("<typedef-error>");
 392       break;
 393
 394     case UNION_TYPE:
 395     case RECORD_TYPE:
 396     case ENUMERAL_TYPE:
 397       if (TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
 398         /* Don't decorate the type if this is a typedef name.  */;
 399       else if (code == UNION_TYPE)
 400         pp_c_ws_string (this, "union");
 401       else if (code == RECORD_TYPE)
 402         pp_c_ws_string (this, "struct");
 403       else if (code == ENUMERAL_TYPE)
 404         pp_c_ws_string (this, "enum");
 405       else
 406         translate_string ("<tag-error>");
 407
 408       if (TYPE_NAME (t))
 409         id_expression (TYPE_NAME (t));
 410       else
 411         translate_string ("<anonymous>");
 412       break;
 413
 414     default:
 415       pp_unsupported_tree (this, t);
 416       break;
 417     }
 418 }
 419
 420 /* specifier-qualifier-list:
 421       type-specifier specifier-qualifier-list-opt
 422       type-qualifier specifier-qualifier-list-opt
 423
 424
 425   Implementation note:  Because of the non-linearities in array or
 426   function declarations, this routine prints not just the
 427   specifier-qualifier-list of such entities or types of such entities,
 428   but also the 'pointer' production part of their declarators.  The
 429   remaining part is done by declarator() or abstract_declarator().  */
 430
 431 void
 432 pp_c_specifier_qualifier_list (c_pretty_printer *pp, tree t)
 433 {
 434   const enum tree_code code = TREE_CODE (t);
 435
 436   if (!(pp->flags & pp_c_flag_gnu_v3) && code != POINTER_TYPE)
 437     pp_c_type_qualifier_list (pp, t);
 438   switch (code)
 439     {
 440     case REFERENCE_TYPE:
 441     case POINTER_TYPE:
 442       {
 443         /* Get the types-specifier of this type.  */
 444         tree pointee = strip_pointer_operator (TREE_TYPE (t));
 445         pp_c_specifier_qualifier_list (pp, pointee);
 446         if (TREE_CODE (pointee) == ARRAY_TYPE
 447             || TREE_CODE (pointee) == FUNCTION_TYPE)
 448           {
 449             pp_c_whitespace (pp);
 450             pp_c_left_paren (pp);
 451             pp_c_attributes_display (pp, TYPE_ATTRIBUTES (pointee));
 452           }
 453         else if (!c_dialect_cxx ())
 454           pp_c_whitespace (pp);
 455         pp_ptr_operator (pp, t);
 456       }
 457       break;
 458
 459     case FUNCTION_TYPE:
 460     case ARRAY_TYPE:
 461       pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
 462       break;
 463
 464     case VECTOR_TYPE:
 465     case COMPLEX_TYPE:
 466       if (code == COMPLEX_TYPE)
 467         pp_c_ws_string (pp, (flag_isoc99 && !c_dialect_cxx ()
 468                              ? "_Complex" : "__complex__"));
 469       else if (code == VECTOR_TYPE)
 470         {
 471           pp_c_ws_string (pp, "__vector");
 472           pp_c_left_paren (pp);
 473           pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (t));
 474           pp_c_right_paren (pp);
 475           pp_c_whitespace (pp);
 476         }
 477       pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
 478       break;
 479
 480     default:
 481       pp->simple_type_specifier (t);
 482       break;
 483     }
 484   if ((pp->flags & pp_c_flag_gnu_v3) && code != POINTER_TYPE)
 485     pp_c_type_qualifier_list (pp, t);
 486 }
 487
 488 /* parameter-type-list:
 489       parameter-list
 490       parameter-list , ...
 491
 492    parameter-list:
 493       parameter-declaration
 494       parameter-list , parameter-declaration
 495
 496    parameter-declaration:
 497       declaration-specifiers declarator
 498       declaration-specifiers abstract-declarator(opt)   */
 499
 500 void
 501 pp_c_parameter_type_list (c_pretty_printer *pp, tree t)
 502 {
 503   bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract);
 504   tree parms = want_parm_decl ? DECL_ARGUMENTS (t) :  TYPE_ARG_TYPES (t);
 505   pp_c_left_paren (pp);
 506   if (parms == void_list_node)
 507     pp_c_ws_string (pp, "void");
 508   else
 509     {
 510       bool first = true;
 511       for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
 512         {
 513           if (!first)
 514             pp_separate_with (pp, ',');
 515           first = false;
 516           pp->declaration_specifiers
 517             (want_parm_decl ? parms : TREE_VALUE (parms));
 518           if (want_parm_decl)
 519             pp->declarator (parms);
 520           else
 521             pp->abstract_declarator (TREE_VALUE (parms));
 522         }
 523     }
 524   pp_c_right_paren (pp);
 525 }
 526
 527 /* abstract-declarator:
 528       pointer
 529       pointer(opt) direct-abstract-declarator  */
 530
 531 void
 532 c_pretty_printer::abstract_declarator (tree t)
 533 {
 534   if (TREE_CODE (t) == POINTER_TYPE)
 535     {
 536       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
 537           || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
 538         pp_c_right_paren (this);
 539       t = TREE_TYPE (t);
 540     }
 541
 542   direct_abstract_declarator (t);
 543 }
 544
 545 /* direct-abstract-declarator:
 546       ( abstract-declarator )
 547       direct-abstract-declarator(opt) [ assignment-expression(opt) ]
 548       direct-abstract-declarator(opt) [ * ]
 549       direct-abstract-declarator(opt) ( parameter-type-list(opt) )  */
 550
 551 void
 552 c_pretty_printer::direct_abstract_declarator (tree t)
 553 {
 554   switch (TREE_CODE (t))
 555     {
 556     case POINTER_TYPE:
 557       abstract_declarator (t);
 558       break;
 559
 560     case FUNCTION_TYPE:
 561       pp_c_parameter_type_list (this, t);
 562       direct_abstract_declarator (TREE_TYPE (t));
 563       break;
 564
 565     case ARRAY_TYPE:
 566       pp_c_left_bracket (this);
 567       if (TYPE_DOMAIN (t) && TYPE_MAX_VALUE (TYPE_DOMAIN (t)))
 568         {
 569           tree maxval = TYPE_MAX_VALUE (TYPE_DOMAIN (t));
 570           tree type = TREE_TYPE (maxval);
 571
 572           if (tree_fits_shwi_p (maxval))
 573             pp_wide_integer (this, tree_to_shwi (maxval) + 1);
 574           else
 575             expression (fold_build2 (PLUS_EXPR, type, maxval,
 576                                      build_int_cst (type, 1)));
 577         }
 578       pp_c_right_bracket (this);
 579       direct_abstract_declarator (TREE_TYPE (t));
 580       break;
 581
 582     case IDENTIFIER_NODE:
 583     case VOID_TYPE:
 584     case BOOLEAN_TYPE:
 585     case INTEGER_TYPE:
 586     case REAL_TYPE:
 587     case FIXED_POINT_TYPE:
 588     case ENUMERAL_TYPE:
 589     case RECORD_TYPE:
 590     case UNION_TYPE:
 591     case VECTOR_TYPE:
 592     case COMPLEX_TYPE:
 593     case TYPE_DECL:
 594       break;
 595
 596     default:
 597       pp_unsupported_tree (this, t);
 598       break;
 599     }
 600 }
 601
 602 /* type-name:
 603       specifier-qualifier-list  abstract-declarator(opt)  */
 604
 605 void
 606 c_pretty_printer::type_id (tree t)
 607 {
 608   pp_c_specifier_qualifier_list (this, t);
 609   abstract_declarator (t);
 610 }
 611
 612 /* storage-class-specifier:
 613       typedef
 614       extern
 615       static
 616       auto
 617       register  */
 618
 619 void
 620 c_pretty_printer::storage_class_specifier (tree t)
 621 {
 622   if (TREE_CODE (t) == TYPE_DECL)
 623     pp_c_ws_string (this, "typedef");
 624   else if (DECL_P (t))
 625     {
 626       if (DECL_REGISTER (t))
 627         pp_c_ws_string (this, "register");
 628       else if (TREE_STATIC (t) && VAR_P (t))
 629         pp_c_ws_string (this, "static");
 630     }
 631 }
 632
 633 /* function-specifier:
 634       inline   */
 635
 636 void
 637 c_pretty_printer::function_specifier (tree t)
 638 {
 639   if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
 640     pp_c_ws_string (this, "inline");
 641 }
 642
 643 /* declaration-specifiers:
 644       storage-class-specifier declaration-specifiers(opt)
 645       type-specifier declaration-specifiers(opt)
 646       type-qualifier declaration-specifiers(opt)
 647       function-specifier declaration-specifiers(opt)  */
 648
 649 void
 650 c_pretty_printer::declaration_specifiers (tree t)
 651 {
 652   storage_class_specifier (t);
 653   function_specifier (t);
 654   pp_c_specifier_qualifier_list (this, DECL_P (t) ?  TREE_TYPE (t) : t);
 655 }
 656
 657 /* direct-declarator
 658       identifier
 659       ( declarator )
 660       direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
 661       direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
 662       direct-declarator [ type-qualifier-list static assignment-expression ]
 663       direct-declarator [ type-qualifier-list * ]
 664       direct-declarator ( parameter-type-list )
 665       direct-declarator ( identifier-list(opt) )  */
 666
 667 void
 668 c_pretty_printer::direct_declarator (tree t)
 669 {
 670   switch (TREE_CODE (t))
 671     {
 672     case VAR_DECL:
 673     case PARM_DECL:
 674     case TYPE_DECL:
 675     case FIELD_DECL:
 676     case LABEL_DECL:
 677       pp_c_space_for_pointer_operator (this, TREE_TYPE (t));
 678       pp_c_tree_decl_identifier (this, t);
 679       break;
 680
 681     case ARRAY_TYPE:
 682     case POINTER_TYPE:
 683       abstract_declarator (TREE_TYPE (t));
 684       break;
 685
 686     case FUNCTION_TYPE:
 687       pp_parameter_list (this, t);
 688       abstract_declarator (TREE_TYPE (t));
 689       break;
 690
 691     case FUNCTION_DECL:
 692       pp_c_space_for_pointer_operator (this, TREE_TYPE (TREE_TYPE (t)));
 693       pp_c_tree_decl_identifier (this, t);
 694       if (flags & pp_c_flag_abstract)
 695         abstract_declarator (TREE_TYPE (t));
 696       else
 697         {
 698           pp_parameter_list (this, t);
 699           abstract_declarator (TREE_TYPE (TREE_TYPE (t)));
 700         }
 701       break;
 702
 703     case INTEGER_TYPE:
 704     case REAL_TYPE:
 705     case FIXED_POINT_TYPE:
 706     case ENUMERAL_TYPE:
 707     case UNION_TYPE:
 708     case RECORD_TYPE:
 709       break;
 710
 711     default:
 712       pp_unsupported_tree (this, t);
 713       break;
 714     }
 715 }
 716
 717
 718 /* declarator:
 719       pointer(opt)  direct-declarator   */
 720
 721 void
 722 c_pretty_printer::declarator (tree t)
 723 {
 724   switch (TREE_CODE (t))
 725     {
 726     case INTEGER_TYPE:
 727     case REAL_TYPE:
 728     case FIXED_POINT_TYPE:
 729     case ENUMERAL_TYPE:
 730     case UNION_TYPE:
 731     case RECORD_TYPE:
 732       break;
 733
 734     case VAR_DECL:
 735     case PARM_DECL:
 736     case FIELD_DECL:
 737     case ARRAY_TYPE:
 738     case FUNCTION_TYPE:
 739     case FUNCTION_DECL:
 740     case TYPE_DECL:
 741       direct_declarator (t);
 742     break;
 743
 744
 745     default:
 746       pp_unsupported_tree (this, t);
 747       break;
 748     }
 749 }
 750
 751 /* declaration:
 752       declaration-specifiers init-declarator-list(opt) ;  */
 753
 754 void
 755 c_pretty_printer::declaration (tree t)
 756 {
 757   declaration_specifiers (t);
 758   pp_c_init_declarator (this, t);
 759 }
 760
 761 /* Pretty-print ATTRIBUTES using GNU C extension syntax.  */
 762
 763 void
 764 pp_c_attributes (c_pretty_printer *pp, tree attributes)
 765 {
 766   if (attributes == NULL_TREE)
 767     return;
 768
 769   pp_c_ws_string (pp, "__attribute__");
 770   pp_c_left_paren (pp);
 771   pp_c_left_paren (pp);
 772   for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
 773     {
 774       pp_tree_identifier (pp, TREE_PURPOSE (attributes));
 775       if (TREE_VALUE (attributes))
 776         pp_c_call_argument_list (pp, TREE_VALUE (attributes));
 777
 778       if (TREE_CHAIN (attributes))
 779         pp_separate_with (pp, ',');
 780     }
 781   pp_c_right_paren (pp);
 782   pp_c_right_paren (pp);
 783 }
 784
 785 /* Pretty-print ATTRIBUTES using GNU C extension syntax for attributes
 786    marked to be displayed on disgnostic.  */
 787
 788 void
 789 pp_c_attributes_display (c_pretty_printer *pp, tree a)
 790 {
 791   bool is_first = true;
 792
 793   if (a == NULL_TREE)
 794     return;
 795
 796   for (; a != NULL_TREE; a = TREE_CHAIN (a))
 797     {
 798       const struct attribute_spec *as;
 799       as = lookup_attribute_spec (TREE_PURPOSE (a));
 800       if (!as || as->affects_type_identity == false)
 801         continue;
 802       if (c_dialect_cxx ()
 803           && !strcmp ("transaction_safe", as->name))
 804         /* In C++ transaction_safe is printed at the end of the declarator.  */
 805         continue;
 806       if (is_first)
 807        {
 808          pp_c_ws_string (pp, "__attribute__");
 809          pp_c_left_paren (pp);
 810          pp_c_left_paren (pp);
 811          is_first = false;
 812        }
 813       else
 814        {
 815          pp_separate_with (pp, ',');
 816        }
 817       pp_tree_identifier (pp, TREE_PURPOSE (a));
 818       if (TREE_VALUE (a))
 819        pp_c_call_argument_list (pp, TREE_VALUE (a));
 820     }
 821
 822   if (!is_first)
 823     {
 824       pp_c_right_paren (pp);
 825       pp_c_right_paren (pp);
 826       pp_c_whitespace (pp);
 827     }
 828 }
 829
 830 /* function-definition:
 831       declaration-specifiers declarator compound-statement  */
 832
 833 void
 834 pp_c_function_definition (c_pretty_printer *pp, tree t)
 835 {
 836   pp->declaration_specifiers (t);
 837   pp->declarator (t);
 838   pp_needs_newline (pp) = true;
 839   pp->statement (DECL_SAVED_TREE (t));
 840   pp_newline_and_flush (pp);
 841 }
 842
 843 \f
 844 /* Expressions.  */
 845
 846 /* Print out a c-char.  This is called solely for characters which are
 847    in the *target* execution character set.  We ought to convert them
 848    back to the *host* execution character set before printing, but we
 849    have no way to do this at present.  A decent compromise is to print
 850    all characters as if they were in the host execution character set,
 851    and not attempt to recover any named escape characters, but render
 852    all unprintables as octal escapes.  If the host and target character
 853    sets are the same, this produces relatively readable output.  If they
 854    are not the same, strings may appear as gibberish, but that's okay
 855    (in fact, it may well be what the reader wants, e.g. if they are looking
 856    to see if conversion to the target character set happened correctly).
 857
 858    A special case: we need to prefix \, ", and ' with backslashes.  It is
 859    correct to do so for the *host*'s \, ", and ', because the rest of the
 860    file appears in the host character set.  */
 861
 862 static void
 863 pp_c_char (c_pretty_printer *pp, int c)
 864 {
 865   if (ISPRINT (c))
 866     {
 867       switch (c)
 868         {
 869         case '\\': pp_string (pp, "\\\\"); break;
 870         case '\'': pp_string (pp, "\\\'"); break;
 871         case '\"': pp_string (pp, "\\\""); break;
 872         default:   pp_character (pp, c);
 873         }
 874     }
 875   else
 876     pp_scalar (pp, "\\%03o", (unsigned) c);
 877 }
 878
 879 /* Print out a STRING literal.  */
 880
 881 void
 882 pp_c_string_literal (c_pretty_printer *pp, tree s)
 883 {
 884   const char *p = TREE_STRING_POINTER (s);
 885   int n = TREE_STRING_LENGTH (s) - 1;
 886   int i;
 887   pp_doublequote (pp);
 888   for (i = 0; i < n; ++i)
 889     pp_c_char (pp, p[i]);
 890   pp_doublequote (pp);
 891 }
 892
 893 /* Pretty-print a VOID_CST (void_node).  */
 894
 895 static void
 896 pp_c_void_constant (c_pretty_printer *pp)
 897 {
 898   pp_c_type_cast (pp, void_type_node);
 899   pp_string (pp, "0");
 900 }
 901
 902 /* Pretty-print an INTEGER literal.  */
 903
 904 static void
 905 pp_c_integer_constant (c_pretty_printer *pp, tree i)
 906 {
 907   if (tree_fits_shwi_p (i))
 908     pp_wide_integer (pp, tree_to_shwi (i));
 909   else if (tree_fits_uhwi_p (i))
 910     pp_unsigned_wide_integer (pp, tree_to_uhwi (i));
 911   else
 912     {
 913       wide_int wi = i;
 914
 915       if (wi::lt_p (i, 0, TYPE_SIGN (TREE_TYPE (i))))
 916         {
 917           pp_minus (pp);
 918           wi = -wi;
 919         }
 920       print_hex (wi, pp_buffer (pp)->digit_buffer);
 921       pp_string (pp, pp_buffer (pp)->digit_buffer);
 922     }
 923 }
 924
 925 /* Print out a CHARACTER literal.  */
 926
 927 static void
 928 pp_c_character_constant (c_pretty_printer *pp, tree c)
 929 {
 930   pp_quote (pp);
 931   pp_c_char (pp, (unsigned) TREE_INT_CST_LOW (c));
 932   pp_quote (pp);
 933 }
 934
 935 /* Print out a BOOLEAN literal.  */
 936
 937 static void
 938 pp_c_bool_constant (c_pretty_printer *pp, tree b)
 939 {
 940   if (b == boolean_false_node)
 941     {
 942       if (c_dialect_cxx ())
 943         pp_c_ws_string (pp, "false");
 944       else if (flag_isoc99)
 945         pp_c_ws_string (pp, "_False");
 946       else
 947         pp_unsupported_tree (pp, b);
 948     }
 949   else if (b == boolean_true_node)
 950     {
 951       if (c_dialect_cxx ())
 952         pp_c_ws_string (pp, "true");
 953       else if (flag_isoc99)
 954         pp_c_ws_string (pp, "_True");
 955       else
 956         pp_unsupported_tree (pp, b);
 957     }
 958   else if (TREE_CODE (b) == INTEGER_CST)
 959     pp_c_integer_constant (pp, b);
 960   else
 961     pp_unsupported_tree (pp, b);
 962 }
 963
 964 /* Attempt to print out an ENUMERATOR.  Return true on success.  Else return
 965    false; that means the value was obtained by a cast, in which case
 966    print out the type-id part of the cast-expression -- the casted value
 967    is then printed by pp_c_integer_literal.  */
 968
 969 static bool
 970 pp_c_enumeration_constant (c_pretty_printer *pp, tree e)
 971 {
 972   bool value_is_named = true;
 973   tree type = TREE_TYPE (e);
 974   tree value;
 975
 976   /* Find the name of this constant.  */
 977   for (value = TYPE_VALUES (type);
 978        value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
 979        value = TREE_CHAIN (value))
 980     ;
 981
 982   if (value != NULL_TREE)
 983     pp->id_expression (TREE_PURPOSE (value));
 984   else
 985     {
 986       /* Value must have been cast.  */
 987       pp_c_type_cast (pp, type);
 988       value_is_named = false;
 989     }
 990
 991   return value_is_named;
 992 }
 993
 994 /* Print out a REAL value as a decimal-floating-constant.  */
 995
 996 static void
 997 pp_c_floating_constant (c_pretty_printer *pp, tree r)
 998 {
 999   const struct real_format *fmt
1000     = REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (r)));
1001
1002   REAL_VALUE_TYPE floating_cst = TREE_REAL_CST (r);
1003   bool is_decimal = floating_cst.decimal;
1004
1005   /* See ISO C++ WG N1822.  Note: The fraction 643/2136 approximates
1006      log10(2) to 7 significant digits.  */
1007   int max_digits10 = 2 + (is_decimal ? fmt->p : fmt->p * 643L / 2136);
1008
1009   real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
1010                    sizeof (pp_buffer (pp)->digit_buffer),
1011                    max_digits10, 1);
1012
1013   pp_string (pp, pp_buffer(pp)->digit_buffer);
1014   if (TREE_TYPE (r) == float_type_node)
1015     pp_character (pp, 'f');
1016   else if (TREE_TYPE (r) == long_double_type_node)
1017     pp_character (pp, 'l');
1018   else if (TREE_TYPE (r) == dfloat128_type_node)
1019     pp_string (pp, "dl");
1020   else if (TREE_TYPE (r) == dfloat64_type_node)
1021     pp_string (pp, "dd");
1022   else if (TREE_TYPE (r) == dfloat32_type_node)
1023     pp_string (pp, "df");
1024   else if (TREE_TYPE (r) != double_type_node)
1025     for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1026       if (TREE_TYPE (r) == FLOATN_NX_TYPE_NODE (i))
1027         {
1028           pp_character (pp, 'f');
1029           pp_decimal_int (pp, floatn_nx_types[i].n);
1030           if (floatn_nx_types[i].extended)
1031             pp_character (pp, 'x');
1032           break;
1033         }
1034 }
1035
1036 /* Print out a FIXED value as a decimal-floating-constant.  */
1037
1038 static void
1039 pp_c_fixed_constant (c_pretty_printer *pp, tree r)
1040 {
1041   fixed_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_FIXED_CST (r),
1042                    sizeof (pp_buffer (pp)->digit_buffer));
1043   pp_string (pp, pp_buffer(pp)->digit_buffer);
1044 }
1045
1046 /* Pretty-print a compound literal expression.  GNU extensions include
1047    vector constants.  */
1048
1049 static void
1050 pp_c_compound_literal (c_pretty_printer *pp, tree e)
1051 {
1052   tree type = TREE_TYPE (e);
1053   pp_c_type_cast (pp, type);
1054
1055   switch (TREE_CODE (type))
1056     {
1057     case RECORD_TYPE:
1058     case UNION_TYPE:
1059     case ARRAY_TYPE:
1060     case VECTOR_TYPE:
1061     case COMPLEX_TYPE:
1062       pp_c_brace_enclosed_initializer_list (pp, e);
1063       break;
1064
1065     default:
1066       pp_unsupported_tree (pp, e);
1067       break;
1068     }
1069 }
1070
1071 /* Pretty-print a COMPLEX_EXPR expression.  */
1072
1073 static void
1074 pp_c_complex_expr (c_pretty_printer *pp, tree e)
1075 {
1076   /* Handle a few common special cases, otherwise fallback
1077      to printing it as compound literal.  */
1078   tree type = TREE_TYPE (e);
1079   tree realexpr = TREE_OPERAND (e, 0);
1080   tree imagexpr = TREE_OPERAND (e, 1);
1081
1082   /* Cast of an COMPLEX_TYPE expression to a different COMPLEX_TYPE.  */
1083   if (TREE_CODE (realexpr) == NOP_EXPR
1084       && TREE_CODE (imagexpr) == NOP_EXPR
1085       && TREE_TYPE (realexpr) == TREE_TYPE (type)
1086       && TREE_TYPE (imagexpr) == TREE_TYPE (type)
1087       && TREE_CODE (TREE_OPERAND (realexpr, 0)) == REALPART_EXPR
1088       && TREE_CODE (TREE_OPERAND (imagexpr, 0)) == IMAGPART_EXPR
1089       && TREE_OPERAND (TREE_OPERAND (realexpr, 0), 0)
1090          == TREE_OPERAND (TREE_OPERAND (imagexpr, 0), 0))
1091     {
1092       pp_c_type_cast (pp, type);
1093       pp->expression (TREE_OPERAND (TREE_OPERAND (realexpr, 0), 0));
1094       return;
1095     }
1096
1097   /* Cast of an scalar expression to COMPLEX_TYPE.  */
1098   if ((integer_zerop (imagexpr) || real_zerop (imagexpr))
1099       && TREE_TYPE (realexpr) == TREE_TYPE (type))
1100     {
1101       pp_c_type_cast (pp, type);
1102       if (TREE_CODE (realexpr) == NOP_EXPR)
1103         realexpr = TREE_OPERAND (realexpr, 0);
1104       pp->expression (realexpr);
1105       return;
1106     }
1107
1108   pp_c_compound_literal (pp, e);
1109 }
1110
1111 /* constant:
1112       integer-constant
1113       floating-constant
1114       fixed-point-constant
1115       enumeration-constant
1116       character-constant   */
1117
1118 void
1119 c_pretty_printer::constant (tree e)
1120 {
1121   const enum tree_code code = TREE_CODE (e);
1122
1123   switch (code)
1124     {
1125     case VOID_CST:
1126       pp_c_void_constant (this);
1127       break;
1128
1129     case INTEGER_CST:
1130       {
1131         tree type = TREE_TYPE (e);
1132         if (type == boolean_type_node)
1133           pp_c_bool_constant (this, e);
1134         else if (type == char_type_node)
1135           pp_c_character_constant (this, e);
1136         else if (TREE_CODE (type) == ENUMERAL_TYPE
1137                  && pp_c_enumeration_constant (this, e))
1138           ;
1139         else
1140           pp_c_integer_constant (this, e);
1141       }
1142       break;
1143
1144     case REAL_CST:
1145       pp_c_floating_constant (this, e);
1146       break;
1147
1148     case FIXED_CST:
1149       pp_c_fixed_constant (this, e);
1150       break;
1151
1152     case STRING_CST:
1153       pp_c_string_literal (this, e);
1154       break;
1155
1156     case COMPLEX_CST:
1157       /* Sometimes, we are confused and we think a complex literal
1158          is a constant.  Such thing is a compound literal which
1159          grammatically belongs to postfix-expr production.  */
1160       pp_c_compound_literal (this, e);
1161       break;
1162
1163     default:
1164       pp_unsupported_tree (this, e);
1165       break;
1166     }
1167 }
1168
1169 /* Pretty-print a string such as an identifier, without changing its
1170    encoding, preceded by whitespace is necessary.  */
1171
1172 void
1173 pp_c_ws_string (c_pretty_printer *pp, const char *str)
1174 {
1175   pp_c_maybe_whitespace (pp);
1176   pp_string (pp, str);
1177   pp->padding = pp_before;
1178 }
1179
1180 void
1181 c_pretty_printer::translate_string (const char *gmsgid)
1182 {
1183   if (pp_translate_identifiers (this))
1184     pp_c_ws_string (this, _(gmsgid));
1185   else
1186     pp_c_ws_string (this, gmsgid);
1187 }
1188
1189 /* Pretty-print an IDENTIFIER_NODE, which may contain UTF-8 sequences
1190    that need converting to the locale encoding, preceded by whitespace
1191    is necessary.  */
1192
1193 void
1194 pp_c_identifier (c_pretty_printer *pp, const char *id)
1195 {
1196   pp_c_maybe_whitespace (pp);
1197   pp_identifier (pp, id);
1198   pp->padding = pp_before;
1199 }
1200
1201 /* Pretty-print a C primary-expression.
1202    primary-expression:
1203       identifier
1204       constant
1205       string-literal
1206       ( expression )   */
1207
1208 void
1209 c_pretty_printer::primary_expression (tree e)
1210 {
1211   switch (TREE_CODE (e))
1212     {
1213     case VAR_DECL:
1214     case PARM_DECL:
1215     case FIELD_DECL:
1216     case CONST_DECL:
1217     case FUNCTION_DECL:
1218     case LABEL_DECL:
1219       pp_c_tree_decl_identifier (this, e);
1220       break;
1221
1222     case IDENTIFIER_NODE:
1223       pp_c_tree_identifier (this, e);
1224       break;
1225
1226     case ERROR_MARK:
1227       translate_string ("<erroneous-expression>");
1228       break;
1229
1230     case RESULT_DECL:
1231       translate_string ("<return-value>");
1232       break;
1233
1234     case VOID_CST:
1235     case INTEGER_CST:
1236     case REAL_CST:
1237     case FIXED_CST:
1238     case STRING_CST:
1239       constant (e);
1240       break;
1241
1242     case TARGET_EXPR:
1243       pp_c_ws_string (this, "__builtin_memcpy");
1244       pp_c_left_paren (this);
1245       pp_ampersand (this);
1246       primary_expression (TREE_OPERAND (e, 0));
1247       pp_separate_with (this, ',');
1248       pp_ampersand (this);
1249       initializer (TREE_OPERAND (e, 1));
1250       if (TREE_OPERAND (e, 2))
1251         {
1252           pp_separate_with (this, ',');
1253           expression (TREE_OPERAND (e, 2));
1254         }
1255       pp_c_right_paren (this);
1256       break;
1257
1258     default:
1259       /* FIXME:  Make sure we won't get into an infinite loop.  */
1260       pp_c_left_paren (this);
1261       expression (e);
1262       pp_c_right_paren (this);
1263       break;
1264     }
1265 }
1266
1267 /* Print out a C initializer -- also support C compound-literals.
1268    initializer:
1269       assignment-expression:
1270       { initializer-list }
1271       { initializer-list , }   */
1272
1273 void
1274 c_pretty_printer::initializer (tree e)
1275 {
1276   if (TREE_CODE (e) == CONSTRUCTOR)
1277     pp_c_brace_enclosed_initializer_list (this, e);
1278   else
1279     expression (e);
1280 }
1281
1282 /* init-declarator:
1283       declarator:
1284       declarator = initializer   */
1285
1286 void
1287 pp_c_init_declarator (c_pretty_printer *pp, tree t)
1288 {
1289   pp->declarator (t);
1290   /* We don't want to output function definitions here.  There are handled
1291      elsewhere (and the syntactic form is bogus anyway).  */
1292   if (TREE_CODE (t) != FUNCTION_DECL && DECL_INITIAL (t))
1293     {
1294       tree init = DECL_INITIAL (t);
1295       /* This C++ bit is handled here because it is easier to do so.
1296          In templates, the C++ parser builds a TREE_LIST for a
1297          direct-initialization; the TREE_PURPOSE is the variable to
1298          initialize and the TREE_VALUE is the initializer.  */
1299       if (TREE_CODE (init) == TREE_LIST)
1300         {
1301           pp_c_left_paren (pp);
1302           pp->expression (TREE_VALUE (init));
1303           pp_right_paren (pp);
1304         }
1305       else
1306         {
1307           pp_space (pp);
1308           pp_equal (pp);
1309           pp_space (pp);
1310           pp->initializer (init);
1311         }
1312     }
1313 }
1314
1315 /* initializer-list:
1316       designation(opt) initializer
1317       initializer-list , designation(opt) initializer
1318
1319    designation:
1320       designator-list =
1321
1322    designator-list:
1323       designator
1324       designator-list designator
1325
1326    designator:
1327       [ constant-expression ]
1328       identifier   */
1329
1330 static void
1331 pp_c_initializer_list (c_pretty_printer *pp, tree e)
1332 {
1333   tree type = TREE_TYPE (e);
1334   const enum tree_code code = TREE_CODE (type);
1335
1336   if (TREE_CODE (e) == CONSTRUCTOR)
1337     {
1338       pp_c_constructor_elts (pp, CONSTRUCTOR_ELTS (e));
1339       return;
1340     }
1341
1342   switch (code)
1343     {
1344     case RECORD_TYPE:
1345     case UNION_TYPE:
1346     case ARRAY_TYPE:
1347       {
1348         tree init = TREE_OPERAND (e, 0);
1349         for (; init != NULL_TREE; init = TREE_CHAIN (init))
1350           {
1351             if (code == RECORD_TYPE || code == UNION_TYPE)
1352               {
1353                 pp_c_dot (pp);
1354                 pp->primary_expression (TREE_PURPOSE (init));
1355               }
1356             else
1357               {
1358                 pp_c_left_bracket (pp);
1359                 if (TREE_PURPOSE (init))
1360                   pp->constant (TREE_PURPOSE (init));
1361                 pp_c_right_bracket (pp);
1362               }
1363             pp_c_whitespace (pp);
1364             pp_equal (pp);
1365             pp_c_whitespace (pp);
1366             pp->initializer (TREE_VALUE (init));
1367             if (TREE_CHAIN (init))
1368               pp_separate_with (pp, ',');
1369           }
1370       }
1371       return;
1372
1373     case VECTOR_TYPE:
1374       if (TREE_CODE (e) == VECTOR_CST)
1375         {
1376           unsigned i;
1377           for (i = 0; i < VECTOR_CST_NELTS (e); ++i)
1378             {
1379               if (i > 0)
1380                 pp_separate_with (pp, ',');
1381               pp->expression (VECTOR_CST_ELT (e, i));
1382             }
1383         }
1384       else
1385         break;
1386       return;
1387
1388     case COMPLEX_TYPE:
1389       if (TREE_CODE (e) == COMPLEX_CST || TREE_CODE (e) == COMPLEX_EXPR)
1390         {
1391           const bool cst = TREE_CODE (e) == COMPLEX_CST;
1392           pp->expression (cst ? TREE_REALPART (e) : TREE_OPERAND (e, 0));
1393           pp_separate_with (pp, ',');
1394           pp->expression (cst ? TREE_IMAGPART (e) : TREE_OPERAND (e, 1));
1395         }
1396       else
1397         break;
1398       return;
1399
1400     default:
1401       break;
1402     }
1403
1404   pp_unsupported_tree (pp, type);
1405 }
1406
1407 /* Pretty-print a brace-enclosed initializer-list.  */
1408
1409 static void
1410 pp_c_brace_enclosed_initializer_list (c_pretty_printer *pp, tree l)
1411 {
1412   pp_c_left_brace (pp);
1413   pp_c_initializer_list (pp, l);
1414   pp_c_right_brace (pp);
1415 }
1416
1417
1418 /*  This is a convenient function, used to bridge gap between C and C++
1419     grammars.
1420
1421     id-expression:
1422        identifier  */
1423
1424 void
1425 c_pretty_printer::id_expression (tree t)
1426 {
1427   switch (TREE_CODE (t))
1428     {
1429     case VAR_DECL:
1430     case PARM_DECL:
1431     case CONST_DECL:
1432     case TYPE_DECL:
1433     case FUNCTION_DECL:
1434     case FIELD_DECL:
1435     case LABEL_DECL:
1436       pp_c_tree_decl_identifier (this, t);
1437       break;
1438
1439     case IDENTIFIER_NODE:
1440       pp_c_tree_identifier (this, t);
1441       break;
1442
1443     default:
1444       pp_unsupported_tree (this, t);
1445       break;
1446     }
1447 }
1448
1449 /* postfix-expression:
1450       primary-expression
1451       postfix-expression [ expression ]
1452       postfix-expression ( argument-expression-list(opt) )
1453       postfix-expression . identifier
1454       postfix-expression -> identifier
1455       postfix-expression ++
1456       postfix-expression --
1457       ( type-name ) { initializer-list }
1458       ( type-name ) { initializer-list , }  */
1459
1460 void
1461 c_pretty_printer::postfix_expression (tree e)
1462 {
1463   enum tree_code code = TREE_CODE (e);
1464   switch (code)
1465     {
1466     case POSTINCREMENT_EXPR:
1467     case POSTDECREMENT_EXPR:
1468       postfix_expression (TREE_OPERAND (e, 0));
1469       pp_string (this, code == POSTINCREMENT_EXPR ? "++" : "--");
1470       break;
1471
1472     case ARRAY_REF:
1473       postfix_expression (TREE_OPERAND (e, 0));
1474       pp_c_left_bracket (this);
1475       expression (TREE_OPERAND (e, 1));
1476       pp_c_right_bracket (this);
1477       break;
1478
1479     case ARRAY_NOTATION_REF:
1480       postfix_expression (ARRAY_NOTATION_ARRAY (e));
1481       pp_c_left_bracket (this);
1482       expression (ARRAY_NOTATION_START (e));
1483       pp_colon (this);
1484       expression (ARRAY_NOTATION_LENGTH (e));
1485       pp_colon (this);
1486       expression (ARRAY_NOTATION_STRIDE (e));
1487       pp_c_right_bracket (this);
1488       break;
1489
1490     case CALL_EXPR:
1491       {
1492         call_expr_arg_iterator iter;
1493         tree arg;
1494         postfix_expression (CALL_EXPR_FN (e));
1495         pp_c_left_paren (this);
1496         FOR_EACH_CALL_EXPR_ARG (arg, iter, e)
1497           {
1498             expression (arg);
1499             if (more_call_expr_args_p (&iter))
1500               pp_separate_with (this, ',');
1501           }
1502         pp_c_right_paren (this);
1503         break;
1504       }
1505
1506     case UNORDERED_EXPR:
1507       pp_c_ws_string (this, flag_isoc99
1508                            ? "isunordered"
1509                            : "__builtin_isunordered");
1510       goto two_args_fun;
1511
1512     case ORDERED_EXPR:
1513       pp_c_ws_string (this, flag_isoc99
1514                            ? "!isunordered"
1515                            : "!__builtin_isunordered");
1516       goto two_args_fun;
1517
1518     case UNLT_EXPR:
1519       pp_c_ws_string (this, flag_isoc99
1520                            ? "!isgreaterequal"
1521                            : "!__builtin_isgreaterequal");
1522       goto two_args_fun;
1523
1524     case UNLE_EXPR:
1525       pp_c_ws_string (this, flag_isoc99
1526                            ? "!isgreater"
1527                            : "!__builtin_isgreater");
1528       goto two_args_fun;
1529
1530     case UNGT_EXPR:
1531       pp_c_ws_string (this, flag_isoc99
1532                            ? "!islessequal"
1533                            : "!__builtin_islessequal");
1534       goto two_args_fun;
1535
1536     case UNGE_EXPR:
1537       pp_c_ws_string (this, flag_isoc99
1538                            ? "!isless"
1539                            : "!__builtin_isless");
1540       goto two_args_fun;
1541
1542     case UNEQ_EXPR:
1543       pp_c_ws_string (this, flag_isoc99
1544                            ? "!islessgreater"
1545                            : "!__builtin_islessgreater");
1546       goto two_args_fun;
1547
1548     case LTGT_EXPR:
1549       pp_c_ws_string (this, flag_isoc99
1550                            ? "islessgreater"
1551                            : "__builtin_islessgreater");
1552       goto two_args_fun;
1553
1554     two_args_fun:
1555       pp_c_left_paren (this);
1556       expression (TREE_OPERAND (e, 0));
1557       pp_separate_with (this, ',');
1558       expression (TREE_OPERAND (e, 1));
1559       pp_c_right_paren (this);
1560       break;
1561
1562     case ABS_EXPR:
1563       pp_c_ws_string (this, "__builtin_abs");
1564       pp_c_left_paren (this);
1565       expression (TREE_OPERAND (e, 0));
1566       pp_c_right_paren (this);
1567       break;
1568
1569     case COMPONENT_REF:
1570       {
1571         tree object = TREE_OPERAND (e, 0);
1572         if (INDIRECT_REF_P (object))
1573           {
1574             postfix_expression (TREE_OPERAND (object, 0));
1575             pp_c_arrow (this);
1576           }
1577         else
1578           {
1579             postfix_expression (object);
1580             pp_c_dot (this);
1581           }
1582         expression (TREE_OPERAND (e, 1));
1583       }
1584       break;
1585
1586     case BIT_FIELD_REF:
1587       {
1588         tree type = TREE_TYPE (e);
1589
1590         type = signed_or_unsigned_type_for (TYPE_UNSIGNED (type), type);
1591         if (type
1592             && tree_int_cst_equal (TYPE_SIZE (type), TREE_OPERAND (e, 1)))
1593           {
1594             HOST_WIDE_INT bitpos = tree_to_shwi (TREE_OPERAND (e, 2));
1595             HOST_WIDE_INT size = tree_to_shwi (TYPE_SIZE (type));
1596             if ((bitpos % size) == 0)
1597               {
1598                 pp_c_left_paren (this);
1599                 pp_c_left_paren (this);
1600                 type_id (type);
1601                 pp_c_star (this);
1602                 pp_c_right_paren (this);
1603                 pp_c_ampersand (this);
1604                 expression (TREE_OPERAND (e, 0));
1605                 pp_c_right_paren (this);
1606                 pp_c_left_bracket (this);
1607                 pp_wide_integer (this, bitpos / size);
1608                 pp_c_right_bracket (this);
1609                 break;
1610               }
1611           }
1612         pp_unsupported_tree (this, e);
1613       }
1614       break;
1615
1616     case MEM_REF:
1617       expression (e);
1618       break;
1619
1620     case COMPLEX_CST:
1621     case VECTOR_CST:
1622       pp_c_compound_literal (this, e);
1623       break;
1624
1625     case COMPLEX_EXPR:
1626       pp_c_complex_expr (this, e);
1627       break;
1628
1629     case COMPOUND_LITERAL_EXPR:
1630       e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
1631       /* Fall through.  */
1632     case CONSTRUCTOR:
1633       initializer (e);
1634       break;
1635
1636     case VA_ARG_EXPR:
1637       pp_c_ws_string (this, "__builtin_va_arg");
1638       pp_c_left_paren (this);
1639       assignment_expression (TREE_OPERAND (e, 0));
1640       pp_separate_with (this, ',');
1641       type_id (TREE_TYPE (e));
1642       pp_c_right_paren (this);
1643       break;
1644
1645     case ADDR_EXPR:
1646       if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
1647         {
1648           id_expression (TREE_OPERAND (e, 0));
1649           break;
1650         }
1651       /* fall through.  */
1652
1653     default:
1654       primary_expression (e);
1655       break;
1656     }
1657 }
1658
1659 /* Print out an expression-list; E is expected to be a TREE_LIST.  */
1660
1661 void
1662 pp_c_expression_list (c_pretty_printer *pp, tree e)
1663 {
1664   for (; e != NULL_TREE; e = TREE_CHAIN (e))
1665     {
1666       pp->expression (TREE_VALUE (e));
1667       if (TREE_CHAIN (e))
1668         pp_separate_with (pp, ',');
1669     }
1670 }
1671
1672 /* Print out V, which contains the elements of a constructor.  */
1673
1674 void
1675 pp_c_constructor_elts (c_pretty_printer *pp, vec<constructor_elt, va_gc> *v)
1676 {
1677   unsigned HOST_WIDE_INT ix;
1678   tree value;
1679
1680   FOR_EACH_CONSTRUCTOR_VALUE (v, ix, value)
1681     {
1682       pp->expression (value);
1683       if (ix != vec_safe_length (v) - 1)
1684         pp_separate_with (pp, ',');
1685     }
1686 }
1687
1688 /* Print out an expression-list in parens, as if it were the argument
1689    list to a function.  */
1690
1691 void
1692 pp_c_call_argument_list (c_pretty_printer *pp, tree t)
1693 {
1694   pp_c_left_paren (pp);
1695   if (t && TREE_CODE (t) == TREE_LIST)
1696     pp_c_expression_list (pp, t);
1697   pp_c_right_paren (pp);
1698 }
1699
1700 /* unary-expression:
1701       postfix-expression
1702       ++ cast-expression
1703       -- cast-expression
1704       unary-operator cast-expression
1705       sizeof unary-expression
1706       sizeof ( type-id )
1707
1708   unary-operator: one of
1709       * &  + - ! ~
1710
1711    GNU extensions.
1712    unary-expression:
1713       __alignof__ unary-expression
1714       __alignof__ ( type-id )
1715       __real__ unary-expression
1716       __imag__ unary-expression  */
1717
1718 void
1719 c_pretty_printer::unary_expression (tree e)
1720 {
1721   enum tree_code code = TREE_CODE (e);
1722   switch (code)
1723     {
1724     case PREINCREMENT_EXPR:
1725     case PREDECREMENT_EXPR:
1726       pp_string (this, code == PREINCREMENT_EXPR ? "++" : "--");
1727       unary_expression (TREE_OPERAND (e, 0));
1728       break;
1729
1730     case ADDR_EXPR:
1731     case INDIRECT_REF:
1732     case NEGATE_EXPR:
1733     case BIT_NOT_EXPR:
1734     case TRUTH_NOT_EXPR:
1735     case CONJ_EXPR:
1736       /* String literal are used by address.  */
1737       if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
1738         pp_ampersand (this);
1739       else if (code == INDIRECT_REF)
1740         {
1741           tree type = TREE_TYPE (TREE_OPERAND (e, 0));
1742           if (type && TREE_CODE (type) == REFERENCE_TYPE)
1743             /* Reference decay is implicit, don't print anything.  */;
1744           else
1745             pp_c_star (this);
1746         }
1747       else if (code == NEGATE_EXPR)
1748         pp_minus (this);
1749       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
1750         pp_complement (this);
1751       else if (code == TRUTH_NOT_EXPR)
1752         pp_exclamation (this);
1753       pp_c_cast_expression (this, TREE_OPERAND (e, 0));
1754       break;
1755
1756     case MEM_REF:
1757       if (TREE_CODE (TREE_OPERAND (e, 0)) == ADDR_EXPR
1758           && integer_zerop (TREE_OPERAND (e, 1)))
1759         expression (TREE_OPERAND (TREE_OPERAND (e, 0), 0));
1760       else
1761         {
1762           pp_c_star (this);
1763           if (!integer_zerop (TREE_OPERAND (e, 1)))
1764             {
1765               pp_c_left_paren (this);
1766               if (!integer_onep (TYPE_SIZE_UNIT
1767                                  (TREE_TYPE (TREE_TYPE (TREE_OPERAND (e, 0))))))
1768                 pp_c_type_cast (this, ptr_type_node);
1769             }
1770           pp_c_cast_expression (this, TREE_OPERAND (e, 0));
1771           if (!integer_zerop (TREE_OPERAND (e, 1)))
1772             {
1773               pp_plus (this);
1774               pp_c_integer_constant (this,
1775                                      fold_convert (ssizetype,
1776                                                    TREE_OPERAND (e, 1)));
1777               pp_c_right_paren (this);
1778             }
1779         }
1780       break;
1781
1782     case REALPART_EXPR:
1783     case IMAGPART_EXPR:
1784       pp_c_ws_string (this, code == REALPART_EXPR ? "__real__" : "__imag__");
1785       pp_c_whitespace (this);
1786       unary_expression (TREE_OPERAND (e, 0));
1787       break;
1788
1789     default:
1790       postfix_expression (e);
1791       break;
1792     }
1793 }
1794
1795 /* cast-expression:
1796       unary-expression
1797       ( type-name ) cast-expression  */
1798
1799 void
1800 pp_c_cast_expression (c_pretty_printer *pp, tree e)
1801 {
1802   switch (TREE_CODE (e))
1803     {
1804     case FLOAT_EXPR:
1805     case FIX_TRUNC_EXPR:
1806     CASE_CONVERT:
1807     case VIEW_CONVERT_EXPR:
1808       pp_c_type_cast (pp, TREE_TYPE (e));
1809       pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1810       break;
1811
1812     default:
1813       pp->unary_expression (e);
1814     }
1815 }
1816
1817 /* multiplicative-expression:
1818       cast-expression
1819       multiplicative-expression * cast-expression
1820       multiplicative-expression / cast-expression
1821       multiplicative-expression % cast-expression   */
1822
1823 void
1824 c_pretty_printer::multiplicative_expression (tree e)
1825 {
1826   enum tree_code code = TREE_CODE (e);
1827   switch (code)
1828     {
1829     case MULT_EXPR:
1830     case TRUNC_DIV_EXPR:
1831     case TRUNC_MOD_EXPR:
1832       multiplicative_expression (TREE_OPERAND (e, 0));
1833       pp_c_whitespace (this);
1834       if (code == MULT_EXPR)
1835         pp_c_star (this);
1836       else if (code == TRUNC_DIV_EXPR)
1837         pp_slash (this);
1838       else
1839         pp_modulo (this);
1840       pp_c_whitespace (this);
1841       pp_c_cast_expression (this, TREE_OPERAND (e, 1));
1842       break;
1843
1844     default:
1845       pp_c_cast_expression (this, e);
1846       break;
1847     }
1848 }
1849
1850 /* additive-expression:
1851       multiplicative-expression
1852       additive-expression + multiplicative-expression
1853       additive-expression - multiplicative-expression   */
1854
1855 static void
1856 pp_c_additive_expression (c_pretty_printer *pp, tree e)
1857 {
1858   enum tree_code code = TREE_CODE (e);
1859   switch (code)
1860     {
1861     case POINTER_PLUS_EXPR:
1862     case PLUS_EXPR:
1863     case MINUS_EXPR:
1864       pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
1865       pp_c_whitespace (pp);
1866       if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)
1867         pp_plus (pp);
1868       else
1869         pp_minus (pp);
1870       pp_c_whitespace (pp);
1871       pp->multiplicative_expression (TREE_OPERAND (e, 1));
1872       break;
1873
1874     default:
1875       pp->multiplicative_expression (e);
1876       break;
1877     }
1878 }
1879
1880 /* additive-expression:
1881       additive-expression
1882       shift-expression << additive-expression
1883       shift-expression >> additive-expression   */
1884
1885 static void
1886 pp_c_shift_expression (c_pretty_printer *pp, tree e)
1887 {
1888   enum tree_code code = TREE_CODE (e);
1889   switch (code)
1890     {
1891     case LSHIFT_EXPR:
1892     case RSHIFT_EXPR:
1893       pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
1894       pp_c_whitespace (pp);
1895       pp_string (pp, code == LSHIFT_EXPR ? "<<" : ">>");
1896       pp_c_whitespace (pp);
1897       pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
1898       break;
1899
1900     default:
1901       pp_c_additive_expression (pp, e);
1902     }
1903 }
1904
1905 /* relational-expression:
1906       shift-expression
1907       relational-expression < shift-expression
1908       relational-expression > shift-expression
1909       relational-expression <= shift-expression
1910       relational-expression >= shift-expression   */
1911
1912 static void
1913 pp_c_relational_expression (c_pretty_printer *pp, tree e)
1914 {
1915   enum tree_code code = TREE_CODE (e);
1916   switch (code)
1917     {
1918     case LT_EXPR:
1919     case GT_EXPR:
1920     case LE_EXPR:
1921     case GE_EXPR:
1922       pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
1923       pp_c_whitespace (pp);
1924       if (code == LT_EXPR)
1925         pp_less (pp);
1926       else if (code == GT_EXPR)
1927         pp_greater (pp);
1928       else if (code == LE_EXPR)
1929         pp_less_equal (pp);
1930       else if (code == GE_EXPR)
1931         pp_greater_equal (pp);
1932       pp_c_whitespace (pp);
1933       pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
1934       break;
1935
1936     default:
1937       pp_c_shift_expression (pp, e);
1938       break;
1939     }
1940 }
1941
1942 /* equality-expression:
1943       relational-expression
1944       equality-expression == relational-expression
1945       equality-equality != relational-expression  */
1946
1947 static void
1948 pp_c_equality_expression (c_pretty_printer *pp, tree e)
1949 {
1950   enum tree_code code = TREE_CODE (e);
1951   switch (code)
1952     {
1953     case EQ_EXPR:
1954     case NE_EXPR:
1955       pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
1956       pp_c_whitespace (pp);
1957       pp_string (pp, code == EQ_EXPR ? "==" : "!=");
1958       pp_c_whitespace (pp);
1959       pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
1960       break;
1961
1962     default:
1963       pp_c_relational_expression (pp, e);
1964       break;
1965     }
1966 }
1967
1968 /* AND-expression:
1969       equality-expression
1970       AND-expression & equality-equality   */
1971
1972 static void
1973 pp_c_and_expression (c_pretty_printer *pp, tree e)
1974 {
1975   if (TREE_CODE (e) == BIT_AND_EXPR)
1976     {
1977       pp_c_and_expression (pp, TREE_OPERAND (e, 0));
1978       pp_c_whitespace (pp);
1979       pp_ampersand (pp);
1980       pp_c_whitespace (pp);
1981       pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
1982     }
1983   else
1984     pp_c_equality_expression (pp, e);
1985 }
1986
1987 /* exclusive-OR-expression:
1988      AND-expression
1989      exclusive-OR-expression ^ AND-expression  */
1990
1991 static void
1992 pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
1993 {
1994   if (TREE_CODE (e) == BIT_XOR_EXPR
1995       || TREE_CODE (e) == TRUTH_XOR_EXPR)
1996     {
1997       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1998       if (TREE_CODE (e) == BIT_XOR_EXPR)
1999         pp_c_maybe_whitespace (pp);
2000       else
2001         pp_c_whitespace (pp);
2002       pp_carret (pp);
2003       pp_c_whitespace (pp);
2004       pp_c_and_expression (pp, TREE_OPERAND (e, 1));
2005     }
2006   else
2007     pp_c_and_expression (pp, e);
2008 }
2009
2010 /* inclusive-OR-expression:
2011      exclusive-OR-expression
2012      inclusive-OR-expression | exclusive-OR-expression  */
2013
2014 static void
2015 pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
2016 {
2017   if (TREE_CODE (e) == BIT_IOR_EXPR)
2018     {
2019       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
2020       pp_c_whitespace (pp);
2021       pp_bar (pp);
2022       pp_c_whitespace (pp);
2023       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
2024     }
2025   else
2026     pp_c_exclusive_or_expression (pp, e);
2027 }
2028
2029 /* logical-AND-expression:
2030       inclusive-OR-expression
2031       logical-AND-expression && inclusive-OR-expression  */
2032
2033 static void
2034 pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
2035 {
2036   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR
2037       || TREE_CODE (e) == TRUTH_AND_EXPR)
2038     {
2039       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
2040       pp_c_whitespace (pp);
2041       pp_ampersand_ampersand (pp);
2042       pp_c_whitespace (pp);
2043       pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
2044     }
2045   else
2046     pp_c_inclusive_or_expression (pp, e);
2047 }
2048
2049 /* logical-OR-expression:
2050       logical-AND-expression
2051       logical-OR-expression || logical-AND-expression  */
2052
2053 void
2054 pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
2055 {
2056   if (TREE_CODE (e) == TRUTH_ORIF_EXPR
2057       || TREE_CODE (e) == TRUTH_OR_EXPR)
2058     {
2059       pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
2060       pp_c_whitespace (pp);
2061       pp_bar_bar (pp);
2062       pp_c_whitespace (pp);
2063       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
2064     }
2065   else
2066     pp_c_logical_and_expression (pp, e);
2067 }
2068
2069 /* conditional-expression:
2070       logical-OR-expression
2071       logical-OR-expression ? expression : conditional-expression  */
2072
2073 void
2074 c_pretty_printer::conditional_expression (tree e)
2075 {
2076   if (TREE_CODE (e) == COND_EXPR)
2077     {
2078       pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
2079       pp_c_whitespace (this);
2080       pp_question (this);
2081       pp_c_whitespace (this);
2082       expression (TREE_OPERAND (e, 1));
2083       pp_c_whitespace (this);
2084       pp_colon (this);
2085       pp_c_whitespace (this);
2086       conditional_expression (TREE_OPERAND (e, 2));
2087     }
2088   else
2089     pp_c_logical_or_expression (this, e);
2090 }
2091
2092
2093 /* assignment-expression:
2094       conditional-expression
2095       unary-expression assignment-operator  assignment-expression
2096
2097    assignment-expression: one of
2098       =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
2099
2100 void
2101 c_pretty_printer::assignment_expression (tree e)
2102 {
2103   if (TREE_CODE (e) == MODIFY_EXPR
2104       || TREE_CODE (e) == INIT_EXPR)
2105     {
2106       unary_expression (TREE_OPERAND (e, 0));
2107       pp_c_whitespace (this);
2108       pp_equal (this);
2109       pp_space (this);
2110       expression (TREE_OPERAND (e, 1));
2111     }
2112   else
2113     conditional_expression (e);
2114 }
2115
2116 /* expression:
2117        assignment-expression
2118        expression , assignment-expression
2119
2120   Implementation note:  instead of going through the usual recursion
2121   chain, I take the liberty of dispatching nodes to the appropriate
2122   functions.  This makes some redundancy, but it worths it. That also
2123   prevents a possible infinite recursion between primary_expression ()
2124   and expression ().  */
2125
2126 void
2127 c_pretty_printer::expression (tree e)
2128 {
2129   switch (TREE_CODE (e))
2130     {
2131     case VOID_CST:
2132       pp_c_void_constant (this);
2133       break;
2134
2135     case INTEGER_CST:
2136       pp_c_integer_constant (this, e);
2137       break;
2138
2139     case REAL_CST:
2140       pp_c_floating_constant (this, e);
2141       break;
2142
2143     case FIXED_CST:
2144       pp_c_fixed_constant (this, e);
2145       break;
2146
2147     case STRING_CST:
2148       pp_c_string_literal (this, e);
2149       break;
2150
2151     case IDENTIFIER_NODE:
2152     case FUNCTION_DECL:
2153     case VAR_DECL:
2154     case CONST_DECL:
2155     case PARM_DECL:
2156     case RESULT_DECL:
2157     case FIELD_DECL:
2158     case LABEL_DECL:
2159     case ERROR_MARK:
2160       primary_expression (e);
2161       break;
2162
2163     case SSA_NAME:
2164       if (SSA_NAME_VAR (e)
2165           && !DECL_ARTIFICIAL (SSA_NAME_VAR (e)))
2166         expression (SSA_NAME_VAR (e));
2167       else
2168         translate_string ("<unknown>");
2169       break;
2170
2171     case POSTINCREMENT_EXPR:
2172     case POSTDECREMENT_EXPR:
2173     case ARRAY_REF:
2174     case ARRAY_NOTATION_REF:
2175     case CALL_EXPR:
2176     case COMPONENT_REF:
2177     case BIT_FIELD_REF:
2178     case COMPLEX_CST:
2179     case COMPLEX_EXPR:
2180     case VECTOR_CST:
2181     case ORDERED_EXPR:
2182     case UNORDERED_EXPR:
2183     case LTGT_EXPR:
2184     case UNEQ_EXPR:
2185     case UNLE_EXPR:
2186     case UNLT_EXPR:
2187     case UNGE_EXPR:
2188     case UNGT_EXPR:
2189     case ABS_EXPR:
2190     case CONSTRUCTOR:
2191     case COMPOUND_LITERAL_EXPR:
2192     case VA_ARG_EXPR:
2193       postfix_expression (e);
2194       break;
2195
2196     case CONJ_EXPR:
2197     case ADDR_EXPR:
2198     case INDIRECT_REF:
2199     case MEM_REF:
2200     case NEGATE_EXPR:
2201     case BIT_NOT_EXPR:
2202     case TRUTH_NOT_EXPR:
2203     case PREINCREMENT_EXPR:
2204     case PREDECREMENT_EXPR:
2205     case REALPART_EXPR:
2206     case IMAGPART_EXPR:
2207       unary_expression (e);
2208       break;
2209
2210     case FLOAT_EXPR:
2211     case FIX_TRUNC_EXPR:
2212     CASE_CONVERT:
2213     case VIEW_CONVERT_EXPR:
2214       pp_c_cast_expression (this, e);
2215       break;
2216
2217     case MULT_EXPR:
2218     case TRUNC_MOD_EXPR:
2219     case TRUNC_DIV_EXPR:
2220       multiplicative_expression (e);
2221       break;
2222
2223     case LSHIFT_EXPR:
2224     case RSHIFT_EXPR:
2225       pp_c_shift_expression (this, e);
2226       break;
2227
2228     case LT_EXPR:
2229     case GT_EXPR:
2230     case LE_EXPR:
2231     case GE_EXPR:
2232       pp_c_relational_expression (this, e);
2233       break;
2234
2235     case BIT_AND_EXPR:
2236       pp_c_and_expression (this, e);
2237       break;
2238
2239     case BIT_XOR_EXPR:
2240     case TRUTH_XOR_EXPR:
2241       pp_c_exclusive_or_expression (this, e);
2242       break;
2243
2244     case BIT_IOR_EXPR:
2245       pp_c_inclusive_or_expression (this, e);
2246       break;
2247
2248     case TRUTH_ANDIF_EXPR:
2249     case TRUTH_AND_EXPR:
2250       pp_c_logical_and_expression (this, e);
2251       break;
2252
2253     case TRUTH_ORIF_EXPR:
2254     case TRUTH_OR_EXPR:
2255       pp_c_logical_or_expression (this, e);
2256       break;
2257
2258     case EQ_EXPR:
2259     case NE_EXPR:
2260       pp_c_equality_expression (this, e);
2261       break;
2262
2263     case COND_EXPR:
2264       conditional_expression (e);
2265       break;
2266
2267     case POINTER_PLUS_EXPR:
2268     case PLUS_EXPR:
2269     case MINUS_EXPR:
2270       pp_c_additive_expression (this, e);
2271       break;
2272
2273     case MODIFY_EXPR:
2274     case INIT_EXPR:
2275       assignment_expression (e);
2276       break;
2277
2278     case COMPOUND_EXPR:
2279       pp_c_left_paren (this);
2280       expression (TREE_OPERAND (e, 0));
2281       pp_separate_with (this, ',');
2282       assignment_expression (TREE_OPERAND (e, 1));
2283       pp_c_right_paren (this);
2284       break;
2285
2286     case NON_LVALUE_EXPR:
2287     case SAVE_EXPR:
2288       expression (TREE_OPERAND (e, 0));
2289       break;
2290
2291     case TARGET_EXPR:
2292       postfix_expression (TREE_OPERAND (e, 1));
2293       break;
2294
2295     case BIND_EXPR:
2296     case GOTO_EXPR:
2297       /* We don't yet have a way of dumping statements in a
2298          human-readable format.  */
2299       pp_string (this, "({...})");
2300       break;
2301
2302     case C_MAYBE_CONST_EXPR:
2303       expression (C_MAYBE_CONST_EXPR_EXPR (e));
2304       break;
2305
2306     default:
2307       pp_unsupported_tree (this, e);
2308       break;
2309     }
2310 }
2311
2312
2313 \f
2314 /* Statements.  */
2315
2316 void
2317 c_pretty_printer::statement (tree stmt)
2318 {
2319   if (stmt == NULL)
2320     return;
2321
2322   if (pp_needs_newline (this))
2323     pp_newline_and_indent (this, 0);
2324
2325   dump_generic_node (this, stmt, pp_indentation (this), 0, true);
2326 }
2327
2328 \f
2329 /* Initialize the PRETTY-PRINTER for handling C codes.  */
2330
2331 c_pretty_printer::c_pretty_printer ()
2332   : pretty_printer (),
2333     offset_list (),
2334     flags ()
2335 {
2336   type_specifier_seq        = pp_c_specifier_qualifier_list;
2337   ptr_operator              = pp_c_pointer;
2338   parameter_list            = pp_c_parameter_type_list;
2339 }
2340
2341
2342 /* Print the tree T in full, on file FILE.  */
2343
2344 void
2345 print_c_tree (FILE *file, tree t)
2346 {
2347   c_pretty_printer pp;
2348
2349   pp_needs_newline (&pp) = true;
2350   pp.buffer->stream = file;
2351   pp.statement (t);
2352   pp_newline_and_flush (&pp);
2353 }
2354
2355 /* Print the tree T in full, on stderr.  */
2356
2357 DEBUG_FUNCTION void
2358 debug_c_tree (tree t)
2359 {
2360   print_c_tree (stderr, t);
2361   fputc ('\n', stderr);
2362 }
2363
2364 /* Output the DECL_NAME of T.  If T has no DECL_NAME, output a string made
2365    up of T's memory address.  */
2366
2367 void
2368 pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
2369 {
2370   const char *name;
2371
2372   gcc_assert (DECL_P (t));
2373
2374   if (DECL_NAME (t))
2375     name = IDENTIFIER_POINTER (DECL_NAME (t));
2376   else
2377     {
2378       static char xname[8];
2379       sprintf (xname, "<U%4hx>", ((unsigned short) ((uintptr_t) (t)
2380                                                     & 0xffff)));
2381       name = xname;
2382     }
2383
2384   pp_c_identifier (pp, name);
2385 }