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