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