gcc/c-pretty-print.c

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