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 static void pp_c_unary_expression PARAMS ((c_pretty_print_info *, tree));
  39 static void pp_c_multiplicative_expression PARAMS ((c_pretty_print_info *,
  40                                                     tree));
  41 static void pp_c_additive_expression PARAMS ((c_pretty_print_info *, tree));
  42 static void pp_c_shift_expression PARAMS ((c_pretty_print_info *, tree));
  43 static void pp_c_relational_expression PARAMS ((c_pretty_print_info *, tree));
  44 static void pp_c_equality_expression PARAMS ((c_pretty_print_info *, tree));
  45 static void pp_c_and_expression PARAMS ((c_pretty_print_info *, tree));
  46 static void pp_c_exclusive_or_expression PARAMS ((c_pretty_print_info *,
  47                                                   tree));
  48 static void pp_c_inclusive_or_expression PARAMS ((c_pretty_print_info *,
  49                                                   tree));
  50 static void pp_c_logical_and_expression PARAMS ((c_pretty_print_info *, tree));
  51 static void pp_c_conditional_expression PARAMS ((c_pretty_print_info *, tree));
  52 static void pp_c_assignment_expression PARAMS ((c_pretty_print_info *, tree));
  53 \f
  54 /* Declarations.  */
  55
  56 /* Print out CV-qualifiers.  Take care of possible extension.  */
  57 void
  58 pp_c_cv_qualifier (ppi, cv)
  59      c_pretty_print_info *ppi;
  60      int cv;
  61 {
  62   if (cv & TYPE_QUAL_CONST)
  63     pp_c_identifier (ppi, "const");
  64   if (cv & TYPE_QUAL_VOLATILE)
  65     pp_c_identifier (ppi, "volatile");
  66   if (cv & TYPE_QUAL_RESTRICT)
  67     pp_c_identifier (ppi, flag_isoc99 ? "restrict" : "__restrict__");
  68 }
  69
  70 \f
  71 /* Statements.  */
  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     default:
 320       /*  Make sure this call won't cause any infinite loop. */
 321       pp_c_left_paren (ppi);
 322       pp_c_expression (ppi, e);
 323       pp_c_right_paren (ppi);
 324       break;
 325     }
 326 }
 327
 328 void
 329 pp_c_postfix_expression (ppi, e)
 330      c_pretty_print_info *ppi;
 331      tree e;
 332 {
 333   enum tree_code code = TREE_CODE (e);
 334   switch (code)
 335     {
 336     case POSTINCREMENT_EXPR:
 337     case POSTDECREMENT_EXPR:
 338       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 339       pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
 340       break;
 341
 342     case ARRAY_REF:
 343       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 344       pp_c_left_bracket (ppi);
 345       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 346       pp_c_right_bracket (ppi);
 347       break;
 348
 349     case CALL_EXPR:
 350       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 351       pp_c_left_paren (ppi);
 352       pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
 353       pp_c_right_paren (ppi);
 354       break;
 355
 356     case COMPONENT_REF:
 357       {
 358         tree object = TREE_OPERAND (e, 0);
 359         if (TREE_CODE (object) == INDIRECT_REF)
 360           {
 361             pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
 362             pp_arrow (ppi);
 363           }
 364         else
 365           {
 366             pp_postfix_expression (ppi, object);
 367             pp_dot (ppi);
 368           }
 369         pp_c_expression (ppi, TREE_OPERAND (e, 1));
 370       }
 371       break;
 372
 373     case CONSTRUCTOR:
 374     case COMPLEX_CST:
 375     case VECTOR_CST:
 376       pp_unsupported_tree (ppi, e);
 377       break;
 378
 379     default:
 380       pp_primary_expression (ppi, e);
 381       break;
 382     }
 383 }
 384
 385 /* Print out an expession-list; E is expected to be a TREE_LIST  */
 386 void
 387 pp_c_expression_list (ppi, e)
 388      c_pretty_print_info *ppi;
 389      tree e;
 390 {
 391   for (; e != NULL_TREE; e = TREE_CHAIN (e))
 392     {
 393       pp_c_assignment_expression (ppi, TREE_VALUE (e));
 394       if (TREE_CHAIN (e))
 395         pp_separate_with (ppi, ',');
 396     }
 397 }
 398
 399 static void
 400 pp_c_unary_expression (ppi, e)
 401      c_pretty_print_info *ppi;
 402      tree e;
 403 {
 404   enum tree_code code = TREE_CODE (e);
 405   switch (code)
 406     {
 407     case PREINCREMENT_EXPR:
 408     case PREDECREMENT_EXPR:
 409       pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
 410       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 411       break;
 412
 413     case ADDR_EXPR:
 414     case INDIRECT_REF:
 415     case CONVERT_EXPR:
 416     case NEGATE_EXPR:
 417     case BIT_NOT_EXPR:
 418     case TRUTH_NOT_EXPR:
 419       if (code == ADDR_EXPR)
 420         pp_ampersand (ppi);
 421       else if (code == INDIRECT_REF)
 422         pp_star (ppi);
 423       else if (code == NEGATE_EXPR)
 424         pp_minus (ppi);
 425       else if (code == BIT_NOT_EXPR)
 426         pp_complement (ppi);
 427       else if (code == TRUTH_NOT_EXPR)
 428         pp_exclamation (ppi);
 429       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 430       break;
 431
 432     case SIZEOF_EXPR:
 433     case ALIGNOF_EXPR:
 434       pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
 435       pp_c_whitespace (ppi);
 436       if (TYPE_P (TREE_OPERAND (e, 0)))
 437         {
 438           pp_c_left_paren (ppi);
 439           pp_type_id (ppi, TREE_OPERAND (e, 0));
 440           pp_c_right_paren (ppi);
 441         }
 442       else
 443         pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 444       break;
 445
 446     default:
 447       pp_postfix_expression (ppi, e);
 448       break;
 449     }
 450 }
 451
 452 void
 453 pp_c_cast_expression (ppi, e)
 454      c_pretty_print_info *ppi;
 455      tree e;
 456 {
 457   if (TREE_CODE (e) == CONVERT_EXPR)
 458     {
 459       pp_c_left_paren (ppi);
 460       pp_type_id (ppi, TREE_TYPE (e));
 461       pp_c_right_paren (ppi);
 462       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 463     }
 464   else
 465     pp_unary_expression (ppi, e);
 466 }
 467
 468 static void
 469 pp_c_multiplicative_expression (ppi, e)
 470      c_pretty_print_info *ppi;
 471      tree e;
 472 {
 473   enum tree_code code = TREE_CODE (e);
 474   switch (code)
 475     {
 476     case MULT_EXPR:
 477     case TRUNC_DIV_EXPR:
 478     case TRUNC_MOD_EXPR:
 479       pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
 480       pp_c_whitespace (ppi);
 481       if (code == MULT_EXPR)
 482         pp_star (ppi);
 483       else if (code == TRUNC_DIV_EXPR)
 484         pp_slash (ppi);
 485       else
 486         pp_modulo (ppi);
 487       pp_c_whitespace (ppi);
 488       pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
 489       break;
 490
 491     default:
 492       pp_c_cast_expression (ppi, e);
 493       break;
 494     }
 495 }
 496
 497 static inline void
 498 pp_c_additive_expression (ppi, e)
 499      c_pretty_print_info *ppi;
 500      tree e;
 501 {
 502   enum tree_code code = TREE_CODE (e);
 503   switch (code)
 504     {
 505     case PLUS_EXPR:
 506     case MINUS_EXPR:
 507       pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
 508       pp_c_whitespace (ppi);
 509       if (code == PLUS_EXPR)
 510         pp_plus (ppi);
 511       else
 512         pp_minus (ppi);
 513       pp_c_whitespace (ppi);
 514       pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
 515       break;
 516
 517     default:
 518       pp_multiplicative_expression (ppi, e);
 519       break;
 520     }
 521 }
 522
 523 static inline void
 524 pp_c_shift_expression (ppi, e)
 525      c_pretty_print_info *ppi;
 526      tree e;
 527 {
 528   enum tree_code code = TREE_CODE (e);
 529   switch (code)
 530     {
 531     case LSHIFT_EXPR:
 532     case RSHIFT_EXPR:
 533       pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
 534       pp_c_whitespace (ppi);
 535       pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
 536       pp_c_whitespace (ppi);
 537       pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
 538       break;
 539
 540     default:
 541       pp_c_additive_expression (ppi, e);
 542     }
 543 }
 544
 545 static void
 546 pp_c_relational_expression (ppi, e)
 547      c_pretty_print_info *ppi;
 548      tree e;
 549 {
 550   enum tree_code code = TREE_CODE (e);
 551   switch (code)
 552     {
 553     case LT_EXPR:
 554     case GT_EXPR:
 555     case LE_EXPR:
 556     case GE_EXPR:
 557       pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
 558       pp_c_whitespace (ppi);
 559       if (code == LT_EXPR)
 560         pp_less (ppi);
 561       else if (code == GT_EXPR)
 562         pp_greater (ppi);
 563       else if (code == LE_EXPR)
 564         pp_identifier (ppi, "<=");
 565       else if (code == GE_EXPR)
 566         pp_identifier (ppi, ">=");
 567       pp_c_whitespace (ppi);
 568       pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
 569       break;
 570
 571     default:
 572       pp_c_shift_expression (ppi, e);
 573       break;
 574     }
 575 }
 576
 577 static inline void
 578 pp_c_equality_expression (ppi, e)
 579      c_pretty_print_info *ppi;
 580      tree e;
 581 {
 582   enum tree_code code = TREE_CODE (e);
 583   switch (code)
 584     {
 585     case EQ_EXPR:
 586     case NE_EXPR:
 587       pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
 588       pp_c_maybe_whitespace (ppi);
 589       pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
 590       pp_c_whitespace (ppi);
 591       pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
 592       break;
 593
 594     default:
 595       pp_c_relational_expression (ppi, e);
 596       break;
 597     }
 598 }
 599
 600 static inline void
 601 pp_c_and_expression (ppi, e)
 602      c_pretty_print_info *ppi;
 603      tree e;
 604 {
 605   if (TREE_CODE (e) == BIT_AND_EXPR)
 606     {
 607       pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
 608       pp_c_maybe_whitespace (ppi);
 609       pp_ampersand (ppi);
 610       pp_c_whitespace (ppi);
 611       pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
 612     }
 613   else
 614     pp_c_equality_expression (ppi, e);
 615 }
 616
 617 static inline void
 618 pp_c_exclusive_or_expression (ppi, e)
 619      c_pretty_print_info *ppi;
 620      tree e;
 621 {
 622   if (TREE_CODE (e) == BIT_XOR_EXPR)
 623     {
 624       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 625       pp_c_maybe_whitespace (ppi);
 626       pp_carret (ppi);
 627       pp_c_whitespace (ppi);
 628       pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
 629     }
 630   else
 631     pp_c_and_expression (ppi, e);
 632 }
 633
 634 static inline void
 635 pp_c_inclusive_or_expression (ppi, e)
 636      c_pretty_print_info *ppi;
 637      tree e;
 638 {
 639   if (TREE_CODE (e) == BIT_IOR_EXPR)
 640     {
 641       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 642       pp_c_maybe_whitespace (ppi);
 643       pp_bar (ppi);
 644       pp_c_whitespace (ppi);
 645       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 646     }
 647   else
 648     pp_c_exclusive_or_expression (ppi, e);
 649 }
 650
 651 static inline void
 652 pp_c_logical_and_expression (ppi, e)
 653      c_pretty_print_info *ppi;
 654      tree e;
 655 {
 656   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
 657     {
 658       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
 659       pp_c_maybe_whitespace (ppi);
 660       pp_identifier (ppi, "&&");
 661       pp_c_whitespace (ppi);
 662       pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 663     }
 664   else
 665     pp_c_inclusive_or_expression (ppi, e);
 666 }
 667
 668 void
 669 pp_c_logical_or_expression (ppi, e)
 670      c_pretty_print_info *ppi;
 671      tree e;
 672 {
 673   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
 674     {
 675       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 676       pp_c_maybe_whitespace (ppi);
 677       pp_identifier (ppi, "||");
 678       pp_c_whitespace (ppi);
 679       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
 680     }
 681   else
 682     pp_c_logical_and_expression (ppi, e);
 683 }
 684
 685 static void
 686 pp_c_conditional_expression (ppi, e)
 687      c_pretty_print_info *ppi;
 688      tree e;
 689 {
 690   if (TREE_CODE (e) == COND_EXPR)
 691     {
 692       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 693       pp_c_maybe_whitespace (ppi);
 694       pp_question (ppi);
 695       pp_c_whitespace (ppi);
 696       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 697       pp_c_maybe_whitespace (ppi);
 698       pp_colon (ppi);
 699       pp_c_whitespace (ppi);
 700       pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
 701     }
 702   else
 703     pp_c_logical_or_expression (ppi, e);
 704 }
 705
 706
 707 /* Pretty-print a C assignment-expression.  */
 708 static void
 709 pp_c_assignment_expression (ppi, e)
 710      c_pretty_print_info *ppi;
 711      tree e;
 712 {
 713   if (TREE_CODE (e) == MODIFY_EXPR)
 714     {
 715       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 716       pp_c_maybe_whitespace (ppi);
 717       pp_equal (ppi);
 718       pp_whitespace (ppi);
 719       pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
 720     }
 721   else
 722     pp_c_conditional_expression (ppi, e);
 723 }
 724
 725 /* Pretty-print an expression.  */
 726 void
 727 pp_c_expression (ppi, e)
 728      c_pretty_print_info *ppi;
 729      tree e;
 730 {
 731   switch (TREE_CODE (e))
 732     {
 733     case INTEGER_CST:
 734       pp_c_integer_literal (ppi, e);
 735       break;
 736
 737     case REAL_CST:
 738       pp_c_real_literal (ppi, e);
 739       break;
 740
 741     case STRING_CST:
 742       pp_c_string_literal (ppi, e);
 743       break;
 744
 745     case FUNCTION_DECL:
 746     case VAR_DECL:
 747     case CONST_DECL:
 748     case PARM_DECL:
 749     case RESULT_DECL:
 750     case FIELD_DECL:
 751     case LABEL_DECL:
 752     case ERROR_MARK:
 753       pp_c_primary_expression (ppi, e);
 754       break;
 755
 756     case POSTINCREMENT_EXPR:
 757     case POSTDECREMENT_EXPR:
 758     case ARRAY_REF:
 759     case CALL_EXPR:
 760     case COMPONENT_REF:
 761     case CONSTRUCTOR:
 762     case COMPLEX_CST:
 763     case VECTOR_CST:
 764       pp_c_postfix_expression (ppi, e);
 765       break;
 766
 767     case CONVERT_EXPR:
 768       pp_c_cast_expression (ppi, e);
 769       break;
 770
 771     case MULT_EXPR:
 772     case TRUNC_MOD_EXPR:
 773     case TRUNC_DIV_EXPR:
 774       pp_c_multiplicative_expression (ppi, e);
 775       break;
 776
 777     case LSHIFT_EXPR:
 778     case RSHIFT_EXPR:
 779       pp_c_shift_expression (ppi, e);
 780       break;
 781
 782     case LT_EXPR:
 783     case GT_EXPR:
 784     case LE_EXPR:
 785     case GE_EXPR:
 786       pp_c_relational_expression (ppi, e);
 787       break;
 788
 789     case BIT_AND_EXPR:
 790       pp_c_and_expression (ppi, e);
 791       break;
 792
 793     case BIT_XOR_EXPR:
 794       pp_c_exclusive_or_expression (ppi, e);
 795       break;
 796
 797     case BIT_IOR_EXPR:
 798       pp_c_inclusive_or_expression (ppi, e);
 799       break;
 800
 801     case TRUTH_ANDIF_EXPR:
 802       pp_c_logical_and_expression (ppi, e);
 803       break;
 804
 805     case TRUTH_ORIF_EXPR:
 806       pp_c_logical_or_expression (ppi, e);
 807       break;
 808
 809     case COND_EXPR:
 810       pp_c_conditional_expression (ppi, e);
 811       break;
 812
 813     case MODIFY_EXPR:
 814       pp_c_assignment_expression (ppi, e);
 815       break;
 816
 817     case NOP_EXPR:
 818       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 819       break;
 820
 821     case COMPOUND_EXPR:
 822       pp_c_left_paren (ppi);
 823       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 824       pp_separate_with (ppi, ',');
 825       pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
 826       pp_c_right_paren (ppi);
 827       break;
 828
 829
 830     default:
 831       pp_unsupported_tree (ppi, e);
 832       break;
 833     }
 834 }
 835