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

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