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