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 /* Statements.  */
  75
  76 \f
  77 /* Expressions.  */
  78
  79 /* Print out a c-char.  */
  80 static void
  81 pp_c_char (ppi, c)
  82      c_pretty_print_info *ppi;
  83      int c;
  84 {
  85   switch (c)
  86     {
  87     case TARGET_NEWLINE:
  88       pp_identifier (ppi, "\\n");
  89       break;
  90     case TARGET_TAB:
  91       pp_identifier (ppi, "\\t");
  92       break;
  93     case TARGET_VT:
  94       pp_identifier (ppi, "\\v");
  95       break;
  96     case TARGET_BS:
  97       pp_identifier (ppi, "\\b");
  98       break;
  99     case TARGET_CR:
 100       pp_identifier (ppi, "\\r");
 101       break;
 102     case TARGET_FF:
 103       pp_identifier (ppi, "\\f");
 104       break;
 105     case TARGET_BELL:
 106       pp_identifier (ppi, "\\a");
 107       break;
 108     case '\\':
 109       pp_identifier (ppi, "\\\\");
 110       break;
 111     case '\'':
 112       pp_identifier (ppi, "\\'");
 113       break;
 114     case '\"':
 115       pp_identifier (ppi, "\\\"");
 116       break;
 117     default:
 118       if (ISPRINT (c))
 119         pp_character (ppi, c);
 120       else
 121         pp_format_integer (ppi, "\\%03o", (unsigned) c);
 122       break;
 123     }
 124 }
 125
 126 /* Print out a STRING literal.  */
 127 static inline void
 128 pp_c_string_literal (ppi, s)
 129      c_pretty_print_info *ppi;
 130      tree s;
 131 {
 132   const char *p = TREE_STRING_POINTER (s);
 133   int n = TREE_STRING_LENGTH (s) - 1;
 134   int i;
 135   pp_doublequote (ppi);
 136   for (i = 0; i < n; ++i)
 137     pp_c_char (ppi, p[i]);
 138   pp_doublequote (ppi);
 139 }
 140
 141 /* Print out a CHARACTER literal.  */
 142 static inline void
 143 pp_c_character_literal (ppi, c)
 144      c_pretty_print_info *ppi;
 145      tree c;
 146 {
 147   pp_quote (ppi);
 148   pp_c_char (ppi, tree_low_cst (c, 0));
 149   pp_quote (ppi);
 150 }
 151
 152 /* Print out a BOOLEAN literal.  */
 153 static inline void
 154 pp_c_bool_literal (ppi, b)
 155      c_pretty_print_info *ppi;
 156      tree b;
 157 {
 158   if (b == boolean_false_node || integer_zerop (b))
 159     {
 160       if (c_language == clk_cplusplus)
 161         pp_c_identifier (ppi, "false");
 162       else if (c_language == clk_c && flag_isoc99)
 163         pp_c_identifier (ppi, "_False");
 164       else
 165         pp_unsupported_tree (ppi, b);
 166     }
 167   else if (b == boolean_true_node)
 168     {
 169       if (c_language == clk_cplusplus)
 170         pp_c_identifier (ppi, "true");
 171       else if (c_language == clk_c && flag_isoc99)
 172         pp_c_identifier (ppi, "_True");
 173       else
 174         pp_unsupported_tree (ppi, b);
 175     }
 176   else
 177     pp_unsupported_tree (ppi, b);
 178 }
 179
 180 /* Attempt to print out an ENUMERATOR.  Return true on success.  Else return
 181    false; that means the value was obtained by a cast, in which case
 182    print out the type-id part of the cast-expression -- the casted value
 183    is then printed by pp_c_integer_literal.  */
 184 static bool
 185 pp_c_enumerator (ppi, e)
 186      c_pretty_print_info *ppi;
 187      tree e;
 188 {
 189   tree type = TREE_TYPE (e);
 190   tree value;
 191
 192   /* Find the name of this constant.  */
 193   for (value = TYPE_VALUES (type);
 194        value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
 195        value = TREE_CHAIN (value))
 196     ;
 197
 198   if (value != NULL_TREE)
 199     pp_c_tree_identifier (ppi, TREE_PURPOSE (value));
 200   else
 201     {
 202       /* Value must have been cast.  */
 203       pp_c_left_paren (ppi);
 204       pp_type_id (ppi, type);
 205       pp_c_right_paren (ppi);
 206       return false;
 207     }
 208
 209   return true;
 210 }
 211
 212 /* Print out an INTEGER constant value.  */
 213 static void
 214 pp_c_integer_literal (ppi, i)
 215      c_pretty_print_info *ppi;
 216      tree i;
 217 {
 218   tree type = TREE_TYPE (i);
 219
 220   if (type == boolean_type_node)
 221     pp_c_bool_literal (ppi, i);
 222   else if (type == char_type_node)
 223     pp_c_character_literal (ppi, i);
 224   else if (TREE_CODE (type) == ENUMERAL_TYPE
 225            && pp_c_enumerator (ppi, i))
 226     ;
 227   else
 228     {
 229       if (host_integerp (i, 0))
 230         pp_wide_integer (ppi, TREE_INT_CST_LOW (i));
 231       else
 232         {
 233           if (tree_int_cst_sgn (i) < 0)
 234             {
 235               static char format[10]; /* "%x%09999x\0" */
 236               if (!format[0])
 237                 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
 238
 239               pp_c_char (ppi, '-');
 240               i = build_int_2 (-TREE_INT_CST_LOW (i),
 241                                ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
 242               sprintf (pp_buffer (ppi)->digit_buffer, format,
 243                        TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
 244               pp_identifier (ppi, pp_buffer (ppi)->digit_buffer);
 245
 246             }
 247         }
 248     }
 249 }
 250
 251 /* Print out a REAL value. */
 252 static inline void
 253 pp_c_real_literal (ppi, r)
 254      c_pretty_print_info *ppi;
 255      tree r;
 256 {
 257   REAL_VALUE_TO_DECIMAL (TREE_REAL_CST (r), "%.16g",
 258                          pp_buffer (ppi)->digit_buffer);
 259   pp_identifier (ppi, pp_buffer(ppi)->digit_buffer);
 260 }
 261
 262
 263 void
 264 pp_c_literal (ppi, e)
 265      c_pretty_print_info *ppi;
 266      tree e;
 267 {
 268   switch (TREE_CODE (e))
 269     {
 270     case INTEGER_CST:
 271       pp_c_integer_literal (ppi, e);
 272       break;
 273
 274     case REAL_CST:
 275       pp_c_real_literal (ppi, e);
 276       break;
 277
 278     case STRING_CST:
 279       pp_c_string_literal (ppi, e);
 280       break;
 281
 282     default:
 283       pp_unsupported_tree (ppi, e);
 284       break;
 285     }
 286 }
 287
 288 /* Pretty-print a C primary-expression.  */
 289 static void
 290 pp_c_primary_expression (ppi, e)
 291      c_pretty_print_info *ppi;
 292      tree e;
 293 {
 294   switch (TREE_CODE (e))
 295     {
 296     case VAR_DECL:
 297     case PARM_DECL:
 298     case FIELD_DECL:
 299     case CONST_DECL:
 300     case FUNCTION_DECL:
 301     case LABEL_DECL:
 302       e = DECL_NAME (e);
 303       /* Fall through.  */
 304     case IDENTIFIER_NODE:
 305       pp_c_tree_identifier (ppi, e);
 306       break;
 307
 308     case ERROR_MARK:
 309       pp_c_identifier (ppi, "<erroneous-expression>");
 310       break;
 311
 312     case RESULT_DECL:
 313       pp_c_identifier (ppi, "<return-value>");
 314       break;
 315
 316     case INTEGER_CST:
 317     case REAL_CST:
 318     case STRING_CST:
 319       pp_c_literal (ppi, e);
 320       break;
 321
 322     case TARGET_EXPR:
 323       pp_c_left_paren (ppi);
 324       pp_c_identifier (ppi, "__builtin_memcpy");
 325       pp_c_left_paren (ppi);
 326       pp_ampersand (ppi);
 327       pp_c_primary_expression (ppi, TREE_OPERAND (e, 0));
 328       pp_separate_with (ppi, ',');
 329       pp_ampersand (ppi);
 330       pp_initializer (ppi, TREE_OPERAND (e, 1));
 331       if (TREE_OPERAND (e, 2))
 332         {
 333           pp_separate_with (ppi, ',');
 334           pp_c_expression (ppi, TREE_OPERAND (e, 2));
 335         }
 336       pp_c_right_paren (ppi);
 337
 338     default:
 339       /*  Make sure this call won't cause any infinite loop. */
 340       pp_c_left_paren (ppi);
 341       pp_c_expression (ppi, e);
 342       pp_c_right_paren (ppi);
 343       break;
 344     }
 345 }
 346
 347 /* Print out a C initializer -- also support C compound-literals.  */
 348 void
 349 pp_c_initializer (ppi, e)
 350      c_pretty_print_info *ppi;
 351      tree e;
 352 {
 353   if (TREE_CODE (e) == CONSTRUCTOR)
 354     {
 355       enum tree_code code = TREE_CODE (TREE_TYPE (e));
 356       if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 357         {
 358           pp_left_brace (ppi);
 359           pp_c_initializer_list (ppi, e);
 360           pp_right_brace (ppi);
 361         }
 362       else
 363         pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
 364     }
 365   else
 366     pp_assignment_expression (ppi, e);
 367 }
 368
 369 static void
 370 pp_c_initializer_list (ppi, e)
 371      c_pretty_print_info *ppi;
 372      tree e;
 373 {
 374   tree type = TREE_TYPE (e);
 375   const enum tree_code code = TREE_CODE (type);
 376
 377   if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 378     {
 379       tree init = TREE_OPERAND (e, 1);
 380       for (; init != NULL_TREE; init = TREE_CHAIN (init))
 381         {
 382           if (code == RECORD_TYPE || code == UNION_TYPE)
 383             {
 384               pp_dot (ppi);
 385               pp_c_primary_expression (ppi, TREE_PURPOSE (init));
 386             }
 387           else
 388             {
 389               pp_c_left_bracket (ppi);
 390               if (TREE_PURPOSE (init))
 391                 pp_c_literal (ppi, TREE_PURPOSE (init));
 392               pp_c_right_bracket (ppi);
 393             }
 394           pp_c_whitespace (ppi);
 395           pp_equal (ppi);
 396           pp_c_whitespace (ppi);
 397           pp_initializer (ppi, TREE_VALUE (init));
 398           if (TREE_CHAIN (init))
 399             pp_separate_with (ppi, ',');
 400         }
 401     }
 402   else
 403     pp_unsupported_tree (ppi, type);
 404 }
 405
 406 void
 407 pp_c_postfix_expression (ppi, e)
 408      c_pretty_print_info *ppi;
 409      tree e;
 410 {
 411   enum tree_code code = TREE_CODE (e);
 412   switch (code)
 413     {
 414     case POSTINCREMENT_EXPR:
 415     case POSTDECREMENT_EXPR:
 416       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 417       pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
 418       break;
 419
 420     case ARRAY_REF:
 421       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 422       pp_c_left_bracket (ppi);
 423       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 424       pp_c_right_bracket (ppi);
 425       break;
 426
 427     case CALL_EXPR:
 428       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 429       pp_c_left_paren (ppi);
 430       pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
 431       pp_c_right_paren (ppi);
 432       break;
 433
 434     case ABS_EXPR:
 435       pp_c_identifier (ppi, "abs");
 436       pp_c_left_paren (ppi);
 437       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 438       pp_c_right_paren (ppi);
 439       break;
 440
 441     case COMPONENT_REF:
 442       {
 443         tree object = TREE_OPERAND (e, 0);
 444         if (TREE_CODE (object) == INDIRECT_REF)
 445           {
 446             pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
 447             pp_arrow (ppi);
 448           }
 449         else
 450           {
 451             pp_postfix_expression (ppi, object);
 452             pp_dot (ppi);
 453           }
 454         pp_c_expression (ppi, TREE_OPERAND (e, 1));
 455       }
 456       break;
 457
 458     case COMPLEX_CST:
 459     case VECTOR_CST:
 460     case COMPLEX_EXPR:
 461       pp_c_left_paren (ppi);
 462       pp_type_id (ppi, TREE_TYPE (e));
 463       pp_c_right_paren (ppi);
 464       pp_left_brace (ppi);
 465
 466       if (code == COMPLEX_CST)
 467         {
 468           pp_c_expression (ppi, TREE_REALPART (e));
 469           pp_separate_with (ppi, ',');
 470           pp_c_expression (ppi, TREE_IMAGPART (e));
 471         }
 472       else if (code == VECTOR_CST)
 473         pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e));
 474       else if (code == COMPLEX_EXPR)
 475         {
 476           pp_c_expression (ppi, TREE_OPERAND (e, 0));
 477           pp_separate_with (ppi, ',');
 478           pp_c_expression (ppi, TREE_OPERAND (e, 1));
 479         }
 480
 481       pp_right_brace (ppi);
 482       break;
 483
 484     case CONSTRUCTOR:
 485       pp_initializer (ppi, e);
 486       break;
 487
 488     default:
 489       pp_primary_expression (ppi, e);
 490       break;
 491     }
 492 }
 493
 494 /* Print out an expession-list; E is expected to be a TREE_LIST  */
 495 void
 496 pp_c_expression_list (ppi, e)
 497      c_pretty_print_info *ppi;
 498      tree e;
 499 {
 500   for (; e != NULL_TREE; e = TREE_CHAIN (e))
 501     {
 502       pp_c_assignment_expression (ppi, TREE_VALUE (e));
 503       if (TREE_CHAIN (e))
 504         pp_separate_with (ppi, ',');
 505     }
 506 }
 507
 508 static void
 509 pp_c_unary_expression (ppi, e)
 510      c_pretty_print_info *ppi;
 511      tree e;
 512 {
 513   enum tree_code code = TREE_CODE (e);
 514   switch (code)
 515     {
 516     case PREINCREMENT_EXPR:
 517     case PREDECREMENT_EXPR:
 518       pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
 519       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 520       break;
 521
 522     case ADDR_EXPR:
 523     case INDIRECT_REF:
 524     case CONVERT_EXPR:
 525     case NEGATE_EXPR:
 526     case BIT_NOT_EXPR:
 527     case TRUTH_NOT_EXPR:
 528     case CONJ_EXPR:
 529       if (code == ADDR_EXPR)
 530         pp_ampersand (ppi);
 531       else if (code == INDIRECT_REF)
 532         pp_star (ppi);
 533       else if (code == NEGATE_EXPR)
 534         pp_minus (ppi);
 535       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
 536         pp_complement (ppi);
 537       else if (code == TRUTH_NOT_EXPR)
 538         pp_exclamation (ppi);
 539       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 540       break;
 541
 542     case SIZEOF_EXPR:
 543     case ALIGNOF_EXPR:
 544       pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
 545       pp_c_whitespace (ppi);
 546       if (TYPE_P (TREE_OPERAND (e, 0)))
 547         {
 548           pp_c_left_paren (ppi);
 549           pp_type_id (ppi, TREE_OPERAND (e, 0));
 550           pp_c_right_paren (ppi);
 551         }
 552       else
 553         pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 554       break;
 555
 556     case REALPART_EXPR:
 557     case IMAGPART_EXPR:
 558       pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__");
 559       pp_c_whitespace (ppi);
 560       pp_unary_expression (ppi, TREE_OPERAND (e, 0));
 561       break;
 562
 563     default:
 564       pp_postfix_expression (ppi, e);
 565       break;
 566     }
 567 }
 568
 569 void
 570 pp_c_cast_expression (ppi, e)
 571      c_pretty_print_info *ppi;
 572      tree e;
 573 {
 574   if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
 575     {
 576       pp_c_left_paren (ppi);
 577       pp_type_id (ppi, TREE_TYPE (e));
 578       pp_c_right_paren (ppi);
 579       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 580     }
 581   else
 582     pp_unary_expression (ppi, e);
 583 }
 584
 585 static void
 586 pp_c_multiplicative_expression (ppi, e)
 587      c_pretty_print_info *ppi;
 588      tree e;
 589 {
 590   enum tree_code code = TREE_CODE (e);
 591   switch (code)
 592     {
 593     case MULT_EXPR:
 594     case TRUNC_DIV_EXPR:
 595     case TRUNC_MOD_EXPR:
 596       pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
 597       pp_c_whitespace (ppi);
 598       if (code == MULT_EXPR)
 599         pp_star (ppi);
 600       else if (code == TRUNC_DIV_EXPR)
 601         pp_slash (ppi);
 602       else
 603         pp_modulo (ppi);
 604       pp_c_whitespace (ppi);
 605       pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
 606       break;
 607
 608     default:
 609       pp_c_cast_expression (ppi, e);
 610       break;
 611     }
 612 }
 613
 614 static inline void
 615 pp_c_additive_expression (ppi, e)
 616      c_pretty_print_info *ppi;
 617      tree e;
 618 {
 619   enum tree_code code = TREE_CODE (e);
 620   switch (code)
 621     {
 622     case PLUS_EXPR:
 623     case MINUS_EXPR:
 624       pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
 625       pp_c_whitespace (ppi);
 626       if (code == PLUS_EXPR)
 627         pp_plus (ppi);
 628       else
 629         pp_minus (ppi);
 630       pp_c_whitespace (ppi);
 631       pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
 632       break;
 633
 634     default:
 635       pp_multiplicative_expression (ppi, e);
 636       break;
 637     }
 638 }
 639
 640 static inline void
 641 pp_c_shift_expression (ppi, e)
 642      c_pretty_print_info *ppi;
 643      tree e;
 644 {
 645   enum tree_code code = TREE_CODE (e);
 646   switch (code)
 647     {
 648     case LSHIFT_EXPR:
 649     case RSHIFT_EXPR:
 650       pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
 651       pp_c_whitespace (ppi);
 652       pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
 653       pp_c_whitespace (ppi);
 654       pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
 655       break;
 656
 657     default:
 658       pp_c_additive_expression (ppi, e);
 659     }
 660 }
 661
 662 static void
 663 pp_c_relational_expression (ppi, e)
 664      c_pretty_print_info *ppi;
 665      tree e;
 666 {
 667   enum tree_code code = TREE_CODE (e);
 668   switch (code)
 669     {
 670     case LT_EXPR:
 671     case GT_EXPR:
 672     case LE_EXPR:
 673     case GE_EXPR:
 674       pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
 675       pp_c_whitespace (ppi);
 676       if (code == LT_EXPR)
 677         pp_less (ppi);
 678       else if (code == GT_EXPR)
 679         pp_greater (ppi);
 680       else if (code == LE_EXPR)
 681         pp_identifier (ppi, "<=");
 682       else if (code == GE_EXPR)
 683         pp_identifier (ppi, ">=");
 684       pp_c_whitespace (ppi);
 685       pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
 686       break;
 687
 688     default:
 689       pp_c_shift_expression (ppi, e);
 690       break;
 691     }
 692 }
 693
 694 static inline void
 695 pp_c_equality_expression (ppi, e)
 696      c_pretty_print_info *ppi;
 697      tree e;
 698 {
 699   enum tree_code code = TREE_CODE (e);
 700   switch (code)
 701     {
 702     case EQ_EXPR:
 703     case NE_EXPR:
 704       pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
 705       pp_c_maybe_whitespace (ppi);
 706       pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
 707       pp_c_whitespace (ppi);
 708       pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
 709       break;
 710
 711     default:
 712       pp_c_relational_expression (ppi, e);
 713       break;
 714     }
 715 }
 716
 717 static inline void
 718 pp_c_and_expression (ppi, e)
 719      c_pretty_print_info *ppi;
 720      tree e;
 721 {
 722   if (TREE_CODE (e) == BIT_AND_EXPR)
 723     {
 724       pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
 725       pp_c_maybe_whitespace (ppi);
 726       pp_ampersand (ppi);
 727       pp_c_whitespace (ppi);
 728       pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
 729     }
 730   else
 731     pp_c_equality_expression (ppi, e);
 732 }
 733
 734 static inline void
 735 pp_c_exclusive_or_expression (ppi, e)
 736      c_pretty_print_info *ppi;
 737      tree e;
 738 {
 739   if (TREE_CODE (e) == BIT_XOR_EXPR)
 740     {
 741       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 742       pp_c_maybe_whitespace (ppi);
 743       pp_carret (ppi);
 744       pp_c_whitespace (ppi);
 745       pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
 746     }
 747   else
 748     pp_c_and_expression (ppi, e);
 749 }
 750
 751 static inline void
 752 pp_c_inclusive_or_expression (ppi, e)
 753      c_pretty_print_info *ppi;
 754      tree e;
 755 {
 756   if (TREE_CODE (e) == BIT_IOR_EXPR)
 757     {
 758       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 759       pp_c_maybe_whitespace (ppi);
 760       pp_bar (ppi);
 761       pp_c_whitespace (ppi);
 762       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 763     }
 764   else
 765     pp_c_exclusive_or_expression (ppi, e);
 766 }
 767
 768 static inline void
 769 pp_c_logical_and_expression (ppi, e)
 770      c_pretty_print_info *ppi;
 771      tree e;
 772 {
 773   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
 774     {
 775       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
 776       pp_c_maybe_whitespace (ppi);
 777       pp_identifier (ppi, "&&");
 778       pp_c_whitespace (ppi);
 779       pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 780     }
 781   else
 782     pp_c_inclusive_or_expression (ppi, e);
 783 }
 784
 785 void
 786 pp_c_logical_or_expression (ppi, e)
 787      c_pretty_print_info *ppi;
 788      tree e;
 789 {
 790   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
 791     {
 792       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 793       pp_c_maybe_whitespace (ppi);
 794       pp_identifier (ppi, "||");
 795       pp_c_whitespace (ppi);
 796       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
 797     }
 798   else
 799     pp_c_logical_and_expression (ppi, e);
 800 }
 801
 802 static void
 803 pp_c_conditional_expression (ppi, e)
 804      c_pretty_print_info *ppi;
 805      tree e;
 806 {
 807   if (TREE_CODE (e) == COND_EXPR)
 808     {
 809       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 810       pp_c_maybe_whitespace (ppi);
 811       pp_question (ppi);
 812       pp_c_whitespace (ppi);
 813       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 814       pp_c_maybe_whitespace (ppi);
 815       pp_colon (ppi);
 816       pp_c_whitespace (ppi);
 817       pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
 818     }
 819   else
 820     pp_c_logical_or_expression (ppi, e);
 821 }
 822
 823
 824 /* Pretty-print a C assignment-expression.  */
 825 static void
 826 pp_c_assignment_expression (ppi, e)
 827      c_pretty_print_info *ppi;
 828      tree e;
 829 {
 830   if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
 831     {
 832       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 833       pp_c_maybe_whitespace (ppi);
 834       pp_equal (ppi);
 835       pp_whitespace (ppi);
 836       pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
 837     }
 838   else
 839     pp_c_conditional_expression (ppi, e);
 840 }
 841
 842 /* Pretty-print an expression.  */
 843 void
 844 pp_c_expression (ppi, e)
 845      c_pretty_print_info *ppi;
 846      tree e;
 847 {
 848   switch (TREE_CODE (e))
 849     {
 850     case INTEGER_CST:
 851       pp_c_integer_literal (ppi, e);
 852       break;
 853
 854     case REAL_CST:
 855       pp_c_real_literal (ppi, e);
 856       break;
 857
 858     case STRING_CST:
 859       pp_c_string_literal (ppi, e);
 860       break;
 861
 862     case FUNCTION_DECL:
 863     case VAR_DECL:
 864     case CONST_DECL:
 865     case PARM_DECL:
 866     case RESULT_DECL:
 867     case FIELD_DECL:
 868     case LABEL_DECL:
 869     case ERROR_MARK:
 870     case TARGET_EXPR:
 871       pp_c_primary_expression (ppi, e);
 872       break;
 873
 874     case POSTINCREMENT_EXPR:
 875     case POSTDECREMENT_EXPR:
 876     case ARRAY_REF:
 877     case CALL_EXPR:
 878     case COMPONENT_REF:
 879     case COMPLEX_CST:
 880     case VECTOR_CST:
 881     case ABS_EXPR:
 882     case CONSTRUCTOR:
 883     case COMPLEX_EXPR:
 884       pp_c_postfix_expression (ppi, e);
 885       break;
 886
 887     case CONJ_EXPR:
 888     case ADDR_EXPR:
 889     case INDIRECT_REF:
 890     case NEGATE_EXPR:
 891     case BIT_NOT_EXPR:
 892     case TRUTH_NOT_EXPR:
 893     case PREINCREMENT_EXPR:
 894     case PREDECREMENT_EXPR:
 895     case SIZEOF_EXPR:
 896     case ALIGNOF_EXPR:
 897     case REALPART_EXPR:
 898     case IMAGPART_EXPR:
 899       pp_c_unary_expression (ppi, e);
 900       break;
 901
 902     case CONVERT_EXPR:
 903     case FLOAT_EXPR:
 904       pp_c_cast_expression (ppi, e);
 905       break;
 906
 907     case MULT_EXPR:
 908     case TRUNC_MOD_EXPR:
 909     case TRUNC_DIV_EXPR:
 910       pp_c_multiplicative_expression (ppi, e);
 911       break;
 912
 913     case LSHIFT_EXPR:
 914     case RSHIFT_EXPR:
 915       pp_c_shift_expression (ppi, e);
 916       break;
 917
 918     case LT_EXPR:
 919     case GT_EXPR:
 920     case LE_EXPR:
 921     case GE_EXPR:
 922       pp_c_relational_expression (ppi, e);
 923       break;
 924
 925     case BIT_AND_EXPR:
 926       pp_c_and_expression (ppi, e);
 927       break;
 928
 929     case BIT_XOR_EXPR:
 930       pp_c_exclusive_or_expression (ppi, e);
 931       break;
 932
 933     case BIT_IOR_EXPR:
 934       pp_c_inclusive_or_expression (ppi, e);
 935       break;
 936
 937     case TRUTH_ANDIF_EXPR:
 938       pp_c_logical_and_expression (ppi, e);
 939       break;
 940
 941     case TRUTH_ORIF_EXPR:
 942       pp_c_logical_or_expression (ppi, e);
 943       break;
 944
 945     case COND_EXPR:
 946       pp_c_conditional_expression (ppi, e);
 947       break;
 948
 949     case MODIFY_EXPR:
 950     case INIT_EXPR:
 951       pp_c_assignment_expression (ppi, e);
 952       break;
 953
 954     case NOP_EXPR:
 955       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 956       break;
 957
 958     case COMPOUND_EXPR:
 959       pp_c_left_paren (ppi);
 960       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 961       pp_separate_with (ppi, ',');
 962       pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
 963       pp_c_right_paren (ppi);
 964       break;
 965
 966
 967     default:
 968       pp_unsupported_tree (ppi, e);
 969       break;
 970     }
 971 }
 972