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