gcc/c-pretty-print.c

   1 /* Subroutines common to both C and C++ pretty-printers.
   2    Copyright (C) 2002, 2003 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
  30 /* literal  */
  31 static void pp_c_char (c_pretty_printer, int);
  32 static void pp_c_character_literal (c_pretty_printer, tree);
  33 static void pp_c_bool_literal (c_pretty_printer, tree);
  34 static bool pp_c_enumerator (c_pretty_printer, tree);
  35 static void pp_c_integer_literal (c_pretty_printer, tree);
  36 static void pp_c_real_literal (c_pretty_printer, tree);
  37 static void pp_c_string_literal (c_pretty_printer, tree);
  38
  39 static void pp_c_primary_expression (c_pretty_printer, tree);
  40
  41 /* postfix-expression  */
  42 static void pp_c_initializer_list (c_pretty_printer, tree);
  43
  44 static void pp_c_unary_expression (c_pretty_printer, tree);
  45 static void pp_c_multiplicative_expression (c_pretty_printer, tree);
  46 static void pp_c_additive_expression (c_pretty_printer, tree);
  47 static void pp_c_shift_expression (c_pretty_printer, tree);
  48 static void pp_c_relational_expression (c_pretty_printer, tree);
  49 static void pp_c_equality_expression (c_pretty_printer, tree);
  50 static void pp_c_and_expression (c_pretty_printer, tree);
  51 static void pp_c_exclusive_or_expression (c_pretty_printer, tree);
  52 static void pp_c_inclusive_or_expression (c_pretty_printer, tree);
  53 static void pp_c_logical_and_expression (c_pretty_printer, tree);
  54 static void pp_c_conditional_expression (c_pretty_printer, tree);
  55 static void pp_c_assignment_expression (c_pretty_printer, tree);
  56
  57 /* declarations.  */
  58 static void pp_c_declaration_specifiers (c_pretty_printer, tree);
  59 static void pp_c_init_declarator (c_pretty_printer, tree);
  60 static void pp_c_declarator (c_pretty_printer, tree);
  61 static void pp_c_direct_declarator (c_pretty_printer, tree);
  62 static void pp_c_abstract_declarator (c_pretty_printer, tree);
  63 static void pp_c_specifier_qualifier_list (c_pretty_printer, tree);
  64 static void pp_c_simple_type_specifier (c_pretty_printer, tree);
  65 static void pp_c_parameter_declaration (c_pretty_printer, tree);
  66 static void pp_c_type_id (c_pretty_printer, tree);
  67 static void pp_c_storage_class_specifier (c_pretty_printer, tree);
  68 static void pp_c_function_specifier (c_pretty_printer, tree);
  69
  70 \f
  71 /* Declarations.  */
  72
  73 /* Print out CV-qualifiers.  Take care of possible extensions.  */
  74 void
  75 pp_c_cv_qualifier (c_pretty_printer ppi, int cv)
  76 {
  77   if (cv & TYPE_QUAL_CONST)
  78     pp_c_identifier (ppi, "const");
  79   if (cv & TYPE_QUAL_VOLATILE)
  80     pp_c_identifier (ppi, "volatile");
  81   if (cv & TYPE_QUAL_RESTRICT)
  82     pp_c_identifier (ppi, flag_isoc99 ? "restrict" : "__restrict__");
  83 }
  84
  85 static void
  86 pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
  87 {
  88   const enum tree_code code = TREE_CODE (t);
  89   switch (code)
  90     {
  91     case ERROR_MARK:
  92       pp_c_identifier (ppi, "<type-error>");
  93       break;
  94
  95 #if 0
  96     case UNKNOWN_TYPE:
  97       pp_c_identifier (ppi, "<unkown-type>");
  98       break;
  99 #endif
 100
 101     case IDENTIFIER_NODE:
 102       pp_c_tree_identifier (ppi, t);
 103       break;
 104
 105     case VOID_TYPE:
 106     case BOOLEAN_TYPE:
 107     case CHAR_TYPE:
 108     case INTEGER_TYPE:
 109     case REAL_TYPE:
 110       pp_c_tree_identifier (ppi, DECL_NAME (t));
 111       break;
 112
 113     case COMPLEX_TYPE:
 114     case VECTOR_TYPE:
 115       pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
 116       if (code == COMPLEX_TYPE)
 117         pp_c_identifier (ppi, flag_isoc99 ? "_Complex" : "__complex__");
 118       else if (code == VECTOR_TYPE)
 119         pp_c_identifier (ppi, "__vector__");
 120       break;
 121
 122     case TYPE_DECL:
 123       if (DECL_NAME (t))
 124         pp_c_tree_identifier (ppi, DECL_NAME (t));
 125       else
 126         pp_c_identifier (ppi, "<typedef-error>");
 127       break;
 128
 129     case UNION_TYPE:
 130     case RECORD_TYPE:
 131     case ENUMERAL_TYPE:
 132       if (code == UNION_TYPE)
 133         pp_c_identifier (ppi, "union");
 134       else if (code == RECORD_TYPE)
 135         pp_c_identifier (ppi, "struct");
 136       else if (code == ENUMERAL_TYPE)
 137         pp_c_identifier (ppi, "enum");
 138       else
 139         pp_c_identifier (ppi, "<tag-error>");
 140
 141       if (TYPE_NAME (t))
 142         pp_c_tree_identifier (ppi, TYPE_NAME (t));
 143       else
 144         pp_c_identifier (ppi, "<anonymous>");
 145       break;
 146
 147     default:
 148       pp_unsupported_tree (ppi, t);
 149     }
 150 }
 151
 152 static inline void
 153 pp_c_specifier_qualifier_list (c_pretty_printer ppi, tree t)
 154 {
 155   pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
 156   pp_c_cv_qualifier (ppi, TYPE_QUALS (t));
 157 }
 158
 159 static void
 160 pp_c_abstract_declarator (c_pretty_printer ppi, tree t)
 161 {
 162   pp_unsupported_tree (ppi, t);
 163 }
 164
 165
 166 static inline void
 167 pp_c_type_id (c_pretty_printer ppi, tree t)
 168 {
 169   pp_c_specifier_qualifier_list (ppi, t);
 170   pp_c_abstract_declarator (ppi, t);
 171 }
 172
 173 static inline void
 174 pp_c_storage_class_specifier (c_pretty_printer pp, tree t)
 175 {
 176   if (TREE_CODE (t) == TYPE_DECL)
 177     pp_c_identifier (pp, "typedef");
 178   else if (DECL_REGISTER (t))
 179     pp_c_identifier (pp, "register");
 180 }
 181
 182 static inline void
 183 pp_c_function_specifier (c_pretty_printer pp, tree t)
 184 {
 185   if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
 186     pp_c_identifier (pp, "inline");
 187 }
 188
 189 static inline void
 190 pp_c_declaration_specifiers (c_pretty_printer pp, tree t)
 191 {
 192   pp_c_storage_class_specifier (pp, t);
 193   pp_c_function_specifier (pp, t);
 194   pp_type_specifier (pp, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
 195   pp_c_cv_qualifier (pp, TYPE_QUALS (TREE_TYPE (t)));
 196 }
 197
 198 static inline void
 199 pp_c_direct_declarator (c_pretty_printer pp, tree t)
 200 {
 201   pp_unsupported_tree (pp, t);
 202 }
 203
 204 static inline void
 205 pp_c_declarator (c_pretty_printer pp, tree t)
 206 {
 207   pp_unsupported_tree (pp, t);
 208 }
 209
 210 static inline void
 211 pp_c_init_declarator (c_pretty_printer pp, tree t)
 212 {
 213   pp_declarator (pp, t);
 214   if (DECL_INITIAL (t))
 215     {
 216       pp_whitespace (pp);
 217       pp_equal (pp);
 218       pp_whitespace (pp);
 219       pp_c_initializer (pp, DECL_INITIAL (t));
 220     }
 221 }
 222
 223 void
 224 pp_c_declaration (c_pretty_printer pp, tree t)
 225 {
 226   pp_declaration_specifiers (pp, t);
 227   pp_c_init_declarator (pp, t);
 228 }
 229
 230 static void
 231 pp_c_parameter_declaration (c_pretty_printer pp, tree t)
 232 {
 233   pp_unsupported_tree (pp, t);
 234 }
 235
 236 /* Pretty-print ATTRIBUTES using GNU C extension syntax.  */
 237 void
 238 pp_c_attributes (c_pretty_printer pp, tree attributes)
 239 {
 240   if (attributes == NULL_TREE)
 241     return;
 242
 243   pp_c_identifier (pp, "__attribute__");
 244   pp_c_left_paren (pp);
 245   pp_c_left_paren (pp);
 246   for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
 247     {
 248       pp_tree_identifier (pp, TREE_PURPOSE (attributes));
 249       if (TREE_VALUE (attributes))
 250         {
 251           pp_c_left_paren (pp);
 252           pp_c_expression_list (pp, TREE_VALUE (attributes));
 253           pp_c_right_paren (pp);
 254         }
 255
 256       if (TREE_CHAIN (attributes))
 257         pp_separate_with (pp, ',');
 258     }
 259   pp_c_right_paren (pp);
 260   pp_c_right_paren (pp);
 261 }
 262
 263 \f
 264 /* Expressions.  */
 265
 266 /* Print out a c-char.  */
 267 static void
 268 pp_c_char (c_pretty_printer ppi, int c)
 269 {
 270   switch (c)
 271     {
 272     case TARGET_NEWLINE:
 273       pp_identifier (ppi, "\\n");
 274       break;
 275     case TARGET_TAB:
 276       pp_identifier (ppi, "\\t");
 277       break;
 278     case TARGET_VT:
 279       pp_identifier (ppi, "\\v");
 280       break;
 281     case TARGET_BS:
 282       pp_identifier (ppi, "\\b");
 283       break;
 284     case TARGET_CR:
 285       pp_identifier (ppi, "\\r");
 286       break;
 287     case TARGET_FF:
 288       pp_identifier (ppi, "\\f");
 289       break;
 290     case TARGET_BELL:
 291       pp_identifier (ppi, "\\a");
 292       break;
 293     case '\\':
 294       pp_identifier (ppi, "\\\\");
 295       break;
 296     case '\'':
 297       pp_identifier (ppi, "\\'");
 298       break;
 299     case '\"':
 300       pp_identifier (ppi, "\\\"");
 301       break;
 302     default:
 303       if (ISPRINT (c))
 304         pp_character (ppi, c);
 305       else
 306         pp_format_scalar (ppi, "\\%03o", (unsigned) c);
 307       break;
 308     }
 309 }
 310
 311 /* Print out a STRING literal.  */
 312 static inline void
 313 pp_c_string_literal (c_pretty_printer ppi, tree s)
 314 {
 315   const char *p = TREE_STRING_POINTER (s);
 316   int n = TREE_STRING_LENGTH (s) - 1;
 317   int i;
 318   pp_doublequote (ppi);
 319   for (i = 0; i < n; ++i)
 320     pp_c_char (ppi, p[i]);
 321   pp_doublequote (ppi);
 322 }
 323
 324 /* Print out a CHARACTER literal.  */
 325 static inline void
 326 pp_c_character_literal (c_pretty_printer ppi, tree c)
 327 {
 328   pp_quote (ppi);
 329   pp_c_char (ppi, tree_low_cst (c, 0));
 330   pp_quote (ppi);
 331 }
 332
 333 /* Print out a BOOLEAN literal.  */
 334 static inline void
 335 pp_c_bool_literal (c_pretty_printer ppi, tree b)
 336 {
 337   if (b == boolean_false_node || integer_zerop (b))
 338     {
 339       if (c_language == clk_cplusplus)
 340         pp_c_identifier (ppi, "false");
 341       else if (c_language == clk_c && flag_isoc99)
 342         pp_c_identifier (ppi, "_False");
 343       else
 344         pp_unsupported_tree (ppi, b);
 345     }
 346   else if (b == boolean_true_node)
 347     {
 348       if (c_language == clk_cplusplus)
 349         pp_c_identifier (ppi, "true");
 350       else if (c_language == clk_c && flag_isoc99)
 351         pp_c_identifier (ppi, "_True");
 352       else
 353         pp_unsupported_tree (ppi, b);
 354     }
 355   else
 356     pp_unsupported_tree (ppi, b);
 357 }
 358
 359 /* Attempt to print out an ENUMERATOR.  Return true on success.  Else return
 360    false; that means the value was obtained by a cast, in which case
 361    print out the type-id part of the cast-expression -- the casted value
 362    is then printed by pp_c_integer_literal.  */
 363 static bool
 364 pp_c_enumerator (c_pretty_printer ppi, tree e)
 365 {
 366   tree type = TREE_TYPE (e);
 367   tree value;
 368
 369   /* Find the name of this constant.  */
 370   for (value = TYPE_VALUES (type);
 371        value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
 372        value = TREE_CHAIN (value))
 373     ;
 374
 375   if (value != NULL_TREE)
 376     pp_c_tree_identifier (ppi, TREE_PURPOSE (value));
 377   else
 378     {
 379       /* Value must have been cast.  */
 380       pp_c_left_paren (ppi);
 381       pp_type_id (ppi, type);
 382       pp_c_right_paren (ppi);
 383       return false;
 384     }
 385
 386   return true;
 387 }
 388
 389 /* Print out an INTEGER constant value.  */
 390 static void
 391 pp_c_integer_literal (c_pretty_printer ppi, tree i)
 392 {
 393   tree type = TREE_TYPE (i);
 394
 395   if (type == boolean_type_node)
 396     pp_c_bool_literal (ppi, i);
 397   else if (type == char_type_node)
 398     pp_c_character_literal (ppi, i);
 399   else if (TREE_CODE (type) == ENUMERAL_TYPE
 400            && pp_c_enumerator (ppi, i))
 401     ;
 402   else
 403     {
 404       if (host_integerp (i, 0))
 405         pp_wide_integer (ppi, TREE_INT_CST_LOW (i));
 406       else
 407         {
 408           if (tree_int_cst_sgn (i) < 0)
 409             {
 410               pp_c_char (ppi, '-');
 411               i = build_int_2 (-TREE_INT_CST_LOW (i),
 412                                ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
 413               sprintf (pp_buffer (ppi)->digit_buffer,
 414                        HOST_WIDE_INT_PRINT_DOUBLE_HEX,
 415                        TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
 416               pp_identifier (ppi, pp_buffer (ppi)->digit_buffer);
 417
 418             }
 419         }
 420     }
 421 }
 422
 423 /* Print out a REAL value.  */
 424 static inline void
 425 pp_c_real_literal (c_pretty_printer ppi, tree r)
 426 {
 427   real_to_decimal (pp_buffer (ppi)->digit_buffer, &TREE_REAL_CST (r),
 428                    sizeof (pp_buffer (ppi)->digit_buffer), 0, 1);
 429   pp_identifier (ppi, pp_buffer(ppi)->digit_buffer);
 430 }
 431
 432
 433 void
 434 pp_c_literal (c_pretty_printer ppi, tree e)
 435 {
 436   switch (TREE_CODE (e))
 437     {
 438     case INTEGER_CST:
 439       pp_c_integer_literal (ppi, e);
 440       break;
 441
 442     case REAL_CST:
 443       pp_c_real_literal (ppi, e);
 444       break;
 445
 446     case STRING_CST:
 447       pp_c_string_literal (ppi, e);
 448       break;
 449
 450     default:
 451       pp_unsupported_tree (ppi, e);
 452       break;
 453     }
 454 }
 455
 456 /* Pretty-print a C primary-expression.  */
 457 static void
 458 pp_c_primary_expression (c_pretty_printer ppi, tree e)
 459 {
 460   switch (TREE_CODE (e))
 461     {
 462     case VAR_DECL:
 463     case PARM_DECL:
 464     case FIELD_DECL:
 465     case CONST_DECL:
 466     case FUNCTION_DECL:
 467     case LABEL_DECL:
 468       e = DECL_NAME (e);
 469       /* Fall through.  */
 470     case IDENTIFIER_NODE:
 471       pp_c_tree_identifier (ppi, e);
 472       break;
 473
 474     case ERROR_MARK:
 475       pp_c_identifier (ppi, "<erroneous-expression>");
 476       break;
 477
 478     case RESULT_DECL:
 479       pp_c_identifier (ppi, "<return-value>");
 480       break;
 481
 482     case INTEGER_CST:
 483     case REAL_CST:
 484     case STRING_CST:
 485       pp_c_literal (ppi, e);
 486       break;
 487
 488     case TARGET_EXPR:
 489       pp_c_left_paren (ppi);
 490       pp_c_identifier (ppi, "__builtin_memcpy");
 491       pp_c_left_paren (ppi);
 492       pp_ampersand (ppi);
 493       pp_c_primary_expression (ppi, TREE_OPERAND (e, 0));
 494       pp_separate_with (ppi, ',');
 495       pp_ampersand (ppi);
 496       pp_initializer (ppi, TREE_OPERAND (e, 1));
 497       if (TREE_OPERAND (e, 2))
 498         {
 499           pp_separate_with (ppi, ',');
 500           pp_c_expression (ppi, TREE_OPERAND (e, 2));
 501         }
 502       pp_c_right_paren (ppi);
 503
 504     case STMT_EXPR:
 505       pp_c_left_paren (ppi);
 506       pp_statement (ppi, STMT_EXPR_STMT (e));
 507       pp_c_right_paren (ppi);
 508       break;
 509
 510     default:
 511       /*  Make sure this call won't cause any infinite loop.  */
 512       pp_c_left_paren (ppi);
 513       pp_c_expression (ppi, e);
 514       pp_c_right_paren (ppi);
 515       break;
 516     }
 517 }
 518
 519 /* Print out a C initializer -- also support C compound-literals.  */
 520 void
 521 pp_c_initializer (c_pretty_printer ppi, tree e)
 522 {
 523   if (TREE_CODE (e) == CONSTRUCTOR)
 524     {
 525       enum tree_code code = TREE_CODE (TREE_TYPE (e));
 526       if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 527         {
 528           pp_left_brace (ppi);
 529           pp_c_initializer_list (ppi, e);
 530           pp_right_brace (ppi);
 531         }
 532       else
 533         pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
 534     }
 535   else
 536     pp_assignment_expression (ppi, e);
 537 }
 538
 539 static void
 540 pp_c_initializer_list (c_pretty_printer ppi, tree e)
 541 {
 542   tree type = TREE_TYPE (e);
 543   const enum tree_code code = TREE_CODE (type);
 544
 545   if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 546     {
 547       tree init = TREE_OPERAND (e, 1);
 548       for (; init != NULL_TREE; init = TREE_CHAIN (init))
 549         {
 550           if (code == RECORD_TYPE || code == UNION_TYPE)
 551             {
 552               pp_dot (ppi);
 553               pp_c_primary_expression (ppi, TREE_PURPOSE (init));
 554             }
 555           else
 556             {
 557               pp_c_left_bracket (ppi);
 558               if (TREE_PURPOSE (init))
 559                 pp_c_literal (ppi, TREE_PURPOSE (init));
 560               pp_c_right_bracket (ppi);
 561             }
 562           pp_c_whitespace (ppi);
 563           pp_equal (ppi);
 564           pp_c_whitespace (ppi);
 565           pp_initializer (ppi, TREE_VALUE (init));
 566           if (TREE_CHAIN (init))
 567             pp_separate_with (ppi, ',');
 568         }
 569     }
 570   else
 571     pp_unsupported_tree (ppi, type);
 572 }
 573
 574 void
 575 pp_c_postfix_expression (c_pretty_printer ppi, tree e)
 576 {
 577   enum tree_code code = TREE_CODE (e);
 578   switch (code)
 579     {
 580     case POSTINCREMENT_EXPR:
 581     case POSTDECREMENT_EXPR:
 582       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 583       pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
 584       break;
 585
 586     case ARROW_EXPR:
 587       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 588       pp_arrow (ppi);
 589       break;
 590
 591     case ARRAY_REF:
 592       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 593       pp_c_left_bracket (ppi);
 594       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 595       pp_c_right_bracket (ppi);
 596       break;
 597
 598     case CALL_EXPR:
 599       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 600       pp_c_left_paren (ppi);
 601       pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
 602       pp_c_right_paren (ppi);
 603       break;
 604
 605     case ABS_EXPR:
 606     case FFS_EXPR:
 607       pp_c_identifier (ppi,
 608                        code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs");
 609       pp_c_left_paren (ppi);
 610       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 611       pp_c_right_paren (ppi);
 612       break;
 613
 614     case COMPONENT_REF:
 615       {
 616         tree object = TREE_OPERAND (e, 0);
 617         if (TREE_CODE (object) == INDIRECT_REF)
 618           {
 619             pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
 620             pp_arrow (ppi);
 621           }
 622         else
 623           {
 624             pp_postfix_expression (ppi, object);
 625             pp_dot (ppi);
 626           }
 627         pp_c_expression (ppi, TREE_OPERAND (e, 1));
 628       }
 629       break;
 630
 631     case COMPLEX_CST:
 632     case VECTOR_CST:
 633     case COMPLEX_EXPR:
 634       pp_c_left_paren (ppi);
 635       pp_type_id (ppi, TREE_TYPE (e));
 636       pp_c_right_paren (ppi);
 637       pp_left_brace (ppi);
 638
 639       if (code == COMPLEX_CST)
 640         {
 641           pp_c_expression (ppi, TREE_REALPART (e));
 642           pp_separate_with (ppi, ',');
 643           pp_c_expression (ppi, TREE_IMAGPART (e));
 644         }
 645       else if (code == VECTOR_CST)
 646         pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e));
 647       else if (code == COMPLEX_EXPR)
 648         {
 649           pp_c_expression (ppi, TREE_OPERAND (e, 0));
 650           pp_separate_with (ppi, ',');
 651           pp_c_expression (ppi, TREE_OPERAND (e, 1));
 652         }
 653
 654       pp_right_brace (ppi);
 655       break;
 656
 657     case COMPOUND_LITERAL_EXPR:
 658       e = DECL_INITIAL (e);
 659       /* Fall through.  */
 660     case CONSTRUCTOR:
 661       pp_initializer (ppi, e);
 662       break;
 663
 664     case VA_ARG_EXPR:
 665       pp_c_identifier (ppi, "__builtin_va_arg");
 666       pp_c_left_paren (ppi);
 667       pp_assignment_expression (ppi, TREE_OPERAND (e, 0));
 668       pp_separate_with (ppi, ',');
 669       pp_type_id (ppi, TREE_TYPE (e));
 670       pp_c_right_paren (ppi);
 671       break;
 672
 673     default:
 674       pp_primary_expression (ppi, e);
 675       break;
 676     }
 677 }
 678
 679 /* Print out an expression-list; E is expected to be a TREE_LIST  */
 680 void
 681 pp_c_expression_list (c_pretty_printer ppi, tree e)
 682 {
 683   for (; e != NULL_TREE; e = TREE_CHAIN (e))
 684     {
 685       pp_c_assignment_expression (ppi, TREE_VALUE (e));
 686       if (TREE_CHAIN (e))
 687         pp_separate_with (ppi, ',');
 688     }
 689 }
 690
 691 static void
 692 pp_c_unary_expression (c_pretty_printer ppi, tree e)
 693 {
 694   enum tree_code code = TREE_CODE (e);
 695   switch (code)
 696     {
 697     case PREINCREMENT_EXPR:
 698     case PREDECREMENT_EXPR:
 699       pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
 700       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 701       break;
 702
 703     case ADDR_EXPR:
 704     case INDIRECT_REF:
 705     case CONVERT_EXPR:
 706     case NEGATE_EXPR:
 707     case BIT_NOT_EXPR:
 708     case TRUTH_NOT_EXPR:
 709     case CONJ_EXPR:
 710       if (code == ADDR_EXPR)
 711         pp_ampersand (ppi);
 712       else if (code == INDIRECT_REF)
 713         pp_star (ppi);
 714       else if (code == NEGATE_EXPR)
 715         pp_minus (ppi);
 716       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
 717         pp_complement (ppi);
 718       else if (code == TRUTH_NOT_EXPR)
 719         pp_exclamation (ppi);
 720       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 721       break;
 722
 723     case SIZEOF_EXPR:
 724     case ALIGNOF_EXPR:
 725       pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
 726       pp_c_whitespace (ppi);
 727       if (TYPE_P (TREE_OPERAND (e, 0)))
 728         {
 729           pp_c_left_paren (ppi);
 730           pp_type_id (ppi, TREE_OPERAND (e, 0));
 731           pp_c_right_paren (ppi);
 732         }
 733       else
 734         pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 735       break;
 736
 737     case REALPART_EXPR:
 738     case IMAGPART_EXPR:
 739       pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__");
 740       pp_c_whitespace (ppi);
 741       pp_unary_expression (ppi, TREE_OPERAND (e, 0));
 742       break;
 743
 744     default:
 745       pp_postfix_expression (ppi, e);
 746       break;
 747     }
 748 }
 749
 750 void
 751 pp_c_cast_expression (c_pretty_printer ppi, tree e)
 752 {
 753   if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
 754     {
 755       pp_c_left_paren (ppi);
 756       pp_type_id (ppi, TREE_TYPE (e));
 757       pp_c_right_paren (ppi);
 758       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 759     }
 760   else
 761     pp_unary_expression (ppi, e);
 762 }
 763
 764 static void
 765 pp_c_multiplicative_expression (c_pretty_printer ppi, tree e)
 766 {
 767   enum tree_code code = TREE_CODE (e);
 768   switch (code)
 769     {
 770     case MULT_EXPR:
 771     case TRUNC_DIV_EXPR:
 772     case TRUNC_MOD_EXPR:
 773       pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
 774       pp_c_whitespace (ppi);
 775       if (code == MULT_EXPR)
 776         pp_star (ppi);
 777       else if (code == TRUNC_DIV_EXPR)
 778         pp_slash (ppi);
 779       else
 780         pp_modulo (ppi);
 781       pp_c_whitespace (ppi);
 782       pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
 783       break;
 784
 785     default:
 786       pp_c_cast_expression (ppi, e);
 787       break;
 788     }
 789 }
 790
 791 static inline void
 792 pp_c_additive_expression (c_pretty_printer ppi, tree e)
 793 {
 794   enum tree_code code = TREE_CODE (e);
 795   switch (code)
 796     {
 797     case PLUS_EXPR:
 798     case MINUS_EXPR:
 799       pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
 800       pp_c_whitespace (ppi);
 801       if (code == PLUS_EXPR)
 802         pp_plus (ppi);
 803       else
 804         pp_minus (ppi);
 805       pp_c_whitespace (ppi);
 806       pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
 807       break;
 808
 809     default:
 810       pp_multiplicative_expression (ppi, e);
 811       break;
 812     }
 813 }
 814
 815 static inline void
 816 pp_c_shift_expression (c_pretty_printer ppi, tree e)
 817 {
 818   enum tree_code code = TREE_CODE (e);
 819   switch (code)
 820     {
 821     case LSHIFT_EXPR:
 822     case RSHIFT_EXPR:
 823       pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
 824       pp_c_whitespace (ppi);
 825       pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
 826       pp_c_whitespace (ppi);
 827       pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
 828       break;
 829
 830     default:
 831       pp_c_additive_expression (ppi, e);
 832     }
 833 }
 834
 835 static void
 836 pp_c_relational_expression (c_pretty_printer ppi, tree e)
 837 {
 838   enum tree_code code = TREE_CODE (e);
 839   switch (code)
 840     {
 841     case LT_EXPR:
 842     case GT_EXPR:
 843     case LE_EXPR:
 844     case GE_EXPR:
 845       pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
 846       pp_c_whitespace (ppi);
 847       if (code == LT_EXPR)
 848         pp_less (ppi);
 849       else if (code == GT_EXPR)
 850         pp_greater (ppi);
 851       else if (code == LE_EXPR)
 852         pp_identifier (ppi, "<=");
 853       else if (code == GE_EXPR)
 854         pp_identifier (ppi, ">=");
 855       pp_c_whitespace (ppi);
 856       pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
 857       break;
 858
 859     default:
 860       pp_c_shift_expression (ppi, e);
 861       break;
 862     }
 863 }
 864
 865 static inline void
 866 pp_c_equality_expression (c_pretty_printer ppi, tree e)
 867 {
 868   enum tree_code code = TREE_CODE (e);
 869   switch (code)
 870     {
 871     case EQ_EXPR:
 872     case NE_EXPR:
 873       pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
 874       pp_c_maybe_whitespace (ppi);
 875       pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
 876       pp_c_whitespace (ppi);
 877       pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
 878       break;
 879
 880     default:
 881       pp_c_relational_expression (ppi, e);
 882       break;
 883     }
 884 }
 885
 886 static inline void
 887 pp_c_and_expression (c_pretty_printer ppi, tree e)
 888 {
 889   if (TREE_CODE (e) == BIT_AND_EXPR)
 890     {
 891       pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
 892       pp_c_maybe_whitespace (ppi);
 893       pp_ampersand (ppi);
 894       pp_c_whitespace (ppi);
 895       pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
 896     }
 897   else
 898     pp_c_equality_expression (ppi, e);
 899 }
 900
 901 static inline void
 902 pp_c_exclusive_or_expression (c_pretty_printer ppi, tree e)
 903 {
 904   if (TREE_CODE (e) == BIT_XOR_EXPR)
 905     {
 906       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 907       pp_c_maybe_whitespace (ppi);
 908       pp_carret (ppi);
 909       pp_c_whitespace (ppi);
 910       pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
 911     }
 912   else
 913     pp_c_and_expression (ppi, e);
 914 }
 915
 916 static inline void
 917 pp_c_inclusive_or_expression (c_pretty_printer ppi, tree e)
 918 {
 919   if (TREE_CODE (e) == BIT_IOR_EXPR)
 920     {
 921       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 922       pp_c_maybe_whitespace (ppi);
 923       pp_bar (ppi);
 924       pp_c_whitespace (ppi);
 925       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 926     }
 927   else
 928     pp_c_exclusive_or_expression (ppi, e);
 929 }
 930
 931 static inline void
 932 pp_c_logical_and_expression (c_pretty_printer ppi, tree e)
 933 {
 934   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
 935     {
 936       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
 937       pp_c_maybe_whitespace (ppi);
 938       pp_identifier (ppi, "&&");
 939       pp_c_whitespace (ppi);
 940       pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 941     }
 942   else
 943     pp_c_inclusive_or_expression (ppi, e);
 944 }
 945
 946 void
 947 pp_c_logical_or_expression (c_pretty_printer ppi, tree e)
 948 {
 949   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
 950     {
 951       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 952       pp_c_maybe_whitespace (ppi);
 953       pp_identifier (ppi, "||");
 954       pp_c_whitespace (ppi);
 955       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
 956     }
 957   else
 958     pp_c_logical_and_expression (ppi, e);
 959 }
 960
 961 static void
 962 pp_c_conditional_expression (c_pretty_printer ppi, tree e)
 963 {
 964   if (TREE_CODE (e) == COND_EXPR)
 965     {
 966       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 967       pp_c_maybe_whitespace (ppi);
 968       pp_question (ppi);
 969       pp_c_whitespace (ppi);
 970       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 971       pp_c_maybe_whitespace (ppi);
 972       pp_colon (ppi);
 973       pp_c_whitespace (ppi);
 974       pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
 975     }
 976   else
 977     pp_c_logical_or_expression (ppi, e);
 978 }
 979
 980
 981 /* Pretty-print a C assignment-expression.  */
 982 static void
 983 pp_c_assignment_expression (c_pretty_printer ppi, tree e)
 984 {
 985   if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
 986     {
 987       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 988       pp_c_maybe_whitespace (ppi);
 989       pp_equal (ppi);
 990       pp_whitespace (ppi);
 991       pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
 992     }
 993   else
 994     pp_c_conditional_expression (ppi, e);
 995 }
 996
 997 /* Pretty-print an expression.  */
 998 void
 999 pp_c_expression (c_pretty_printer ppi, tree e)
1000 {
1001   switch (TREE_CODE (e))
1002     {
1003     case INTEGER_CST:
1004       pp_c_integer_literal (ppi, e);
1005       break;
1006
1007     case REAL_CST:
1008       pp_c_real_literal (ppi, e);
1009       break;
1010
1011     case STRING_CST:
1012       pp_c_string_literal (ppi, e);
1013       break;
1014
1015     case FUNCTION_DECL:
1016     case VAR_DECL:
1017     case CONST_DECL:
1018     case PARM_DECL:
1019     case RESULT_DECL:
1020     case FIELD_DECL:
1021     case LABEL_DECL:
1022     case ERROR_MARK:
1023     case TARGET_EXPR:
1024     case STMT_EXPR:
1025       pp_c_primary_expression (ppi, e);
1026       break;
1027
1028     case POSTINCREMENT_EXPR:
1029     case POSTDECREMENT_EXPR:
1030     case ARROW_EXPR:
1031     case ARRAY_REF:
1032     case CALL_EXPR:
1033     case COMPONENT_REF:
1034     case COMPLEX_CST:
1035     case VECTOR_CST:
1036     case ABS_EXPR:
1037     case FFS_EXPR:
1038     case CONSTRUCTOR:
1039     case COMPOUND_LITERAL_EXPR:
1040     case COMPLEX_EXPR:
1041     case VA_ARG_EXPR:
1042       pp_c_postfix_expression (ppi, e);
1043       break;
1044
1045     case CONJ_EXPR:
1046     case ADDR_EXPR:
1047     case INDIRECT_REF:
1048     case NEGATE_EXPR:
1049     case BIT_NOT_EXPR:
1050     case TRUTH_NOT_EXPR:
1051     case PREINCREMENT_EXPR:
1052     case PREDECREMENT_EXPR:
1053     case SIZEOF_EXPR:
1054     case ALIGNOF_EXPR:
1055     case REALPART_EXPR:
1056     case IMAGPART_EXPR:
1057       pp_c_unary_expression (ppi, e);
1058       break;
1059
1060     case CONVERT_EXPR:
1061     case FLOAT_EXPR:
1062       pp_c_cast_expression (ppi, e);
1063       break;
1064
1065     case MULT_EXPR:
1066     case TRUNC_MOD_EXPR:
1067     case TRUNC_DIV_EXPR:
1068       pp_c_multiplicative_expression (ppi, e);
1069       break;
1070
1071     case LSHIFT_EXPR:
1072     case RSHIFT_EXPR:
1073       pp_c_shift_expression (ppi, e);
1074       break;
1075
1076     case LT_EXPR:
1077     case GT_EXPR:
1078     case LE_EXPR:
1079     case GE_EXPR:
1080       pp_c_relational_expression (ppi, e);
1081       break;
1082
1083     case BIT_AND_EXPR:
1084       pp_c_and_expression (ppi, e);
1085       break;
1086
1087     case BIT_XOR_EXPR:
1088       pp_c_exclusive_or_expression (ppi, e);
1089       break;
1090
1091     case BIT_IOR_EXPR:
1092       pp_c_inclusive_or_expression (ppi, e);
1093       break;
1094
1095     case TRUTH_ANDIF_EXPR:
1096       pp_c_logical_and_expression (ppi, e);
1097       break;
1098
1099     case TRUTH_ORIF_EXPR:
1100       pp_c_logical_or_expression (ppi, e);
1101       break;
1102
1103     case COND_EXPR:
1104       pp_c_conditional_expression (ppi, e);
1105       break;
1106
1107     case MODIFY_EXPR:
1108     case INIT_EXPR:
1109       pp_c_assignment_expression (ppi, e);
1110       break;
1111
1112     case NOP_EXPR:
1113       pp_c_expression (ppi, TREE_OPERAND (e, 0));
1114       break;
1115
1116     case COMPOUND_EXPR:
1117       pp_c_left_paren (ppi);
1118       pp_c_expression (ppi, TREE_OPERAND (e, 0));
1119       pp_separate_with (ppi, ',');
1120       pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
1121       pp_c_right_paren (ppi);
1122       break;
1123
1124
1125     default:
1126       pp_unsupported_tree (ppi, e);
1127       break;
1128     }
1129 }
1130
1131 \f
1132 /* Statements.  */
1133 void
1134 pp_c_statement (c_pretty_printer ppi, tree stmt)
1135 {
1136   const enum tree_code code = TREE_CODE (stmt);
1137   switch (code)
1138     {
1139     case LABEL_STMT:
1140     case CASE_LABEL:
1141       pp_newline (ppi);
1142       if (code == LABEL_STMT)
1143         pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt)));
1144       else if (code == LABEL_STMT)
1145         {
1146           if (CASE_LOW (stmt) == NULL_TREE)
1147             pp_identifier (ppi, "default");
1148           else
1149             {
1150               pp_c_identifier (ppi, "case");
1151               pp_c_whitespace (ppi);
1152               pp_conditional_expression (ppi, CASE_LOW (stmt));
1153               if (CASE_HIGH (stmt))
1154                 {
1155                   pp_identifier (ppi, "...");
1156                   pp_conditional_expression (ppi, CASE_HIGH (stmt));
1157                 }
1158             }
1159         }
1160       pp_colon (ppi);
1161       pp_newline_and_indent (ppi, 3);
1162       break;
1163
1164     case COMPOUND_STMT:
1165       pp_left_brace (ppi);
1166       pp_newline_and_indent (ppi, 3);
1167       for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt))
1168         pp_c_statement (ppi, stmt);
1169       pp_newline_and_indent (ppi, -3);
1170       pp_right_brace (ppi);
1171       pp_newline (ppi);
1172       break;
1173
1174     case EXPR_STMT:
1175     case CLEANUP_STMT:
1176       pp_newline (ppi);
1177       pp_c_expression (ppi, code == EXPR_STMT
1178                        ? EXPR_STMT_EXPR (stmt)
1179                        : CLEANUP_EXPR (stmt));
1180       pp_semicolon (ppi);
1181       pp_newline (ppi);
1182       break;
1183
1184     case IF_STMT:
1185       pp_c_identifier (ppi, "if");
1186       pp_whitespace (ppi);
1187       pp_c_left_paren (ppi);
1188       pp_c_expression (ppi, IF_COND (stmt));
1189       pp_right_paren (ppi);
1190       pp_newline_and_indent (ppi, 3);
1191       pp_statement (ppi, THEN_CLAUSE (stmt));
1192       pp_newline_and_indent (ppi, -3);
1193       if (ELSE_CLAUSE (stmt))
1194         {
1195           tree else_clause = ELSE_CLAUSE (stmt);
1196           pp_c_identifier (ppi, "else");
1197           if (TREE_CODE (else_clause) == IF_STMT)
1198             pp_c_whitespace (ppi);
1199           else
1200             pp_newline_and_indent (ppi, 3);
1201           pp_statement (ppi, else_clause);
1202           if (TREE_CODE (else_clause) != IF_STMT)
1203             pp_newline_and_indent (ppi, -3);
1204         }
1205       break;
1206
1207     case SWITCH_STMT:
1208       pp_newline (ppi);
1209       pp_c_identifier (ppi, "switch");
1210       pp_whitespace (ppi);
1211       pp_c_left_paren (ppi);
1212       pp_c_expression (ppi, SWITCH_COND (stmt));
1213       pp_right_paren (ppi);
1214       pp_newline_and_indent (ppi, 3);
1215       pp_statement (ppi, SWITCH_BODY (stmt));
1216       pp_newline_and_indent (ppi, -3);
1217       break;
1218
1219     case WHILE_STMT:
1220       pp_c_identifier (ppi, "while");
1221       pp_whitespace (ppi);
1222       pp_c_left_paren (ppi);
1223       pp_c_expression (ppi, WHILE_COND (stmt));
1224       pp_right_paren (ppi);
1225       pp_newline_and_indent (ppi, 3);
1226       pp_statement (ppi, WHILE_BODY (stmt));
1227       pp_newline_and_indent (ppi, -3);
1228       break;
1229
1230     case DO_STMT:
1231       pp_c_identifier (ppi, "do");
1232       pp_newline_and_indent (ppi, 3);
1233       pp_statement (ppi, DO_BODY (stmt));
1234       pp_newline_and_indent (ppi, -3);
1235       pp_c_identifier (ppi, "while");
1236       pp_whitespace (ppi);
1237       pp_c_left_paren (ppi);
1238       pp_c_expression (ppi, DO_COND (stmt));
1239       pp_c_right_paren (ppi);
1240       pp_semicolon (ppi);
1241       pp_newline (ppi);
1242       break;
1243
1244     case FOR_STMT:
1245       pp_c_identifier (ppi, "for");
1246       pp_whitespace (ppi);
1247       pp_c_left_paren (ppi);
1248       pp_statement (ppi, FOR_INIT_STMT (stmt));
1249       pp_c_whitespace (ppi);
1250       if (FOR_COND (stmt))
1251         pp_c_expression (ppi, FOR_COND (stmt));
1252       pp_semicolon (ppi);
1253       pp_c_whitespace (ppi);
1254       if (FOR_EXPR (stmt))
1255         pp_c_expression (ppi, FOR_EXPR (stmt));
1256       pp_right_paren (ppi);
1257       pp_newline_and_indent (ppi, 3);
1258       pp_statement (ppi, FOR_BODY (stmt));
1259       pp_newline_and_indent (ppi, -3);
1260       break;
1261
1262     case BREAK_STMT:
1263     case CONTINUE_STMT:
1264       pp_newline (ppi);
1265       pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue");
1266       pp_semicolon (ppi);
1267       pp_newline (ppi);
1268       break;
1269
1270     case RETURN_STMT:
1271     case GOTO_STMT:
1272       {
1273         tree e = code == RETURN_STMT
1274           ? RETURN_STMT_EXPR (stmt)
1275           : GOTO_DESTINATION (stmt);
1276
1277         pp_newline (ppi);
1278         pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto");
1279         if (e)
1280           pp_c_expression (ppi, e);
1281         pp_semicolon (ppi);
1282         pp_newline (ppi);
1283       }
1284       break;
1285
1286     case SCOPE_STMT:
1287       if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt))
1288         {
1289           if (SCOPE_BEGIN_P (stmt))
1290             {
1291               pp_left_brace (ppi);
1292               pp_newline_and_indent (ppi, 3);
1293             }
1294           else if (SCOPE_END_P (stmt))
1295             {
1296               pp_right_brace (ppi);
1297               pp_newline_and_indent (ppi, -3);
1298             }
1299         }
1300       break;
1301
1302     case DECL_STMT:
1303       pp_declaration (ppi, DECL_STMT_DECL (stmt));
1304       pp_semicolon (ppi);
1305       pp_newline (ppi);
1306       break;
1307
1308     case ASM_STMT:
1309       {
1310         bool has_volatile_p = ASM_VOLATILE_P (stmt);
1311         bool is_extended = has_volatile_p || ASM_INPUTS (stmt)
1312           || ASM_OUTPUTS (stmt) || ASM_CLOBBERS (stmt);
1313         pp_c_identifier (ppi, is_extended ? "__asm__" : "asm");
1314         if (has_volatile_p)
1315           pp_c_identifier (ppi, "__volatile__");
1316         pp_whitespace (ppi);
1317         pp_c_left_paren (ppi);
1318         pp_c_string_literal (ppi, ASM_STRING (stmt));
1319         if (is_extended)
1320           {
1321             pp_whitespace (ppi);
1322             pp_separate_with (ppi, ':');
1323             if (ASM_OUTPUTS (stmt))
1324               pp_c_expression (ppi, ASM_OUTPUTS (stmt));
1325             pp_whitespace (ppi);
1326             pp_separate_with (ppi, ':');
1327             if (ASM_INPUTS (stmt))
1328               pp_c_expression (ppi, ASM_INPUTS (stmt));
1329             pp_whitespace (ppi);
1330             pp_separate_with (ppi, ':');
1331             if (ASM_CLOBBERS (stmt))
1332               pp_c_expression (ppi, ASM_CLOBBERS (stmt));
1333           }
1334         pp_right_paren (ppi);
1335         pp_newline (ppi);
1336       }
1337       break;
1338
1339     case FILE_STMT:
1340       pp_c_identifier (ppi, "__FILE__");
1341       pp_whitespace (ppi);
1342       pp_equal (ppi);
1343       pp_c_whitespace (ppi);
1344       pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt));
1345       pp_semicolon (ppi);
1346       pp_newline (ppi);
1347       break;
1348
1349     default:
1350       pp_unsupported_tree (ppi, stmt);
1351     }
1352
1353 }
1354
1355 \f
1356 /* Initialize the PRETTY-PRINTER for handling C codes.  */
1357 void
1358 pp_c_pretty_printer_init (c_pretty_printer pp)
1359 {
1360   pp->offset_list               = 0;
1361
1362   pp->declaration               = pp_c_declaration;
1363   pp->declaration_specifiers    = pp_c_declaration_specifiers;
1364   pp->type_specifier            = pp_c_simple_type_specifier;
1365   pp->declarator                = pp_c_declarator;
1366   pp->direct_declarator         = pp_c_direct_declarator;
1367   pp->parameter_declaration     = pp_c_parameter_declaration;
1368   pp->type_id                   = pp_c_type_id;
1369
1370   pp->statement                 = pp_c_statement;
1371
1372   pp->primary_expression        = pp_c_primary_expression;
1373   pp->postfix_expression        = pp_c_postfix_expression;
1374   pp->unary_expression          = pp_c_unary_expression;
1375   pp->initializer               = pp_c_initializer;
1376   pp->multiplicative_expression = pp_c_multiplicative_expression;
1377   pp->conditional_expression    = pp_c_conditional_expression;
1378   pp->assignment_expression     = pp_c_assignment_expression;
1379 }