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

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