gcc/c-pretty-print.c

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