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

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