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