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