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