gcc/c-pretty-print.c

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