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     case STMT_EXPR:
 339       pp_c_left_paren (ppi);
 340       pp_statement (ppi, STMT_EXPR_STMT (e));
 341       pp_c_right_paren (ppi);
 342       break;
 343
 344     default:
 345       /*  Make sure this call won't cause any infinite loop. */
 346       pp_c_left_paren (ppi);
 347       pp_c_expression (ppi, e);
 348       pp_c_right_paren (ppi);
 349       break;
 350     }
 351 }
 352
 353 /* Print out a C initializer -- also support C compound-literals.  */
 354 void
 355 pp_c_initializer (ppi, e)
 356      c_pretty_print_info *ppi;
 357      tree e;
 358 {
 359   if (TREE_CODE (e) == CONSTRUCTOR)
 360     {
 361       enum tree_code code = TREE_CODE (TREE_TYPE (e));
 362       if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 363         {
 364           pp_left_brace (ppi);
 365           pp_c_initializer_list (ppi, e);
 366           pp_right_brace (ppi);
 367         }
 368       else
 369         pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
 370     }
 371   else
 372     pp_assignment_expression (ppi, e);
 373 }
 374
 375 static void
 376 pp_c_initializer_list (ppi, e)
 377      c_pretty_print_info *ppi;
 378      tree e;
 379 {
 380   tree type = TREE_TYPE (e);
 381   const enum tree_code code = TREE_CODE (type);
 382
 383   if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 384     {
 385       tree init = TREE_OPERAND (e, 1);
 386       for (; init != NULL_TREE; init = TREE_CHAIN (init))
 387         {
 388           if (code == RECORD_TYPE || code == UNION_TYPE)
 389             {
 390               pp_dot (ppi);
 391               pp_c_primary_expression (ppi, TREE_PURPOSE (init));
 392             }
 393           else
 394             {
 395               pp_c_left_bracket (ppi);
 396               if (TREE_PURPOSE (init))
 397                 pp_c_literal (ppi, TREE_PURPOSE (init));
 398               pp_c_right_bracket (ppi);
 399             }
 400           pp_c_whitespace (ppi);
 401           pp_equal (ppi);
 402           pp_c_whitespace (ppi);
 403           pp_initializer (ppi, TREE_VALUE (init));
 404           if (TREE_CHAIN (init))
 405             pp_separate_with (ppi, ',');
 406         }
 407     }
 408   else
 409     pp_unsupported_tree (ppi, type);
 410 }
 411
 412 void
 413 pp_c_postfix_expression (ppi, e)
 414      c_pretty_print_info *ppi;
 415      tree e;
 416 {
 417   enum tree_code code = TREE_CODE (e);
 418   switch (code)
 419     {
 420     case POSTINCREMENT_EXPR:
 421     case POSTDECREMENT_EXPR:
 422       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 423       pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
 424       break;
 425
 426     case ARROW_EXPR:
 427       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 428       pp_arrow (ppi);
 429       break;
 430
 431     case ARRAY_REF:
 432       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 433       pp_c_left_bracket (ppi);
 434       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 435       pp_c_right_bracket (ppi);
 436       break;
 437
 438     case CALL_EXPR:
 439       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 440       pp_c_left_paren (ppi);
 441       pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
 442       pp_c_right_paren (ppi);
 443       break;
 444
 445     case ABS_EXPR:
 446     case FFS_EXPR:
 447       pp_c_identifier (ppi,
 448                        code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs");
 449       pp_c_left_paren (ppi);
 450       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 451       pp_c_right_paren (ppi);
 452       break;
 453
 454     case COMPONENT_REF:
 455       {
 456         tree object = TREE_OPERAND (e, 0);
 457         if (TREE_CODE (object) == INDIRECT_REF)
 458           {
 459             pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
 460             pp_arrow (ppi);
 461           }
 462         else
 463           {
 464             pp_postfix_expression (ppi, object);
 465             pp_dot (ppi);
 466           }
 467         pp_c_expression (ppi, TREE_OPERAND (e, 1));
 468       }
 469       break;
 470
 471     case COMPLEX_CST:
 472     case VECTOR_CST:
 473     case COMPLEX_EXPR:
 474       pp_c_left_paren (ppi);
 475       pp_type_id (ppi, TREE_TYPE (e));
 476       pp_c_right_paren (ppi);
 477       pp_left_brace (ppi);
 478
 479       if (code == COMPLEX_CST)
 480         {
 481           pp_c_expression (ppi, TREE_REALPART (e));
 482           pp_separate_with (ppi, ',');
 483           pp_c_expression (ppi, TREE_IMAGPART (e));
 484         }
 485       else if (code == VECTOR_CST)
 486         pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e));
 487       else if (code == COMPLEX_EXPR)
 488         {
 489           pp_c_expression (ppi, TREE_OPERAND (e, 0));
 490           pp_separate_with (ppi, ',');
 491           pp_c_expression (ppi, TREE_OPERAND (e, 1));
 492         }
 493
 494       pp_right_brace (ppi);
 495       break;
 496
 497     case COMPOUND_LITERAL_EXPR:
 498       e = DECL_INITIAL (e);
 499       /* Fall through.  */
 500     case CONSTRUCTOR:
 501       pp_initializer (ppi, e);
 502       break;
 503
 504     case VA_ARG_EXPR:
 505       pp_c_identifier (ppi, "__builtin_va_arg");
 506       pp_c_left_paren (ppi);
 507       pp_assignment_expression (ppi, TREE_OPERAND (e, 0));
 508       pp_separate_with (ppi, ',');
 509       pp_type_id (ppi, TREE_TYPE (e));
 510       pp_c_right_paren (ppi);
 511       break;
 512
 513     default:
 514       pp_primary_expression (ppi, e);
 515       break;
 516     }
 517 }
 518
 519 /* Print out an expession-list; E is expected to be a TREE_LIST  */
 520 void
 521 pp_c_expression_list (ppi, e)
 522      c_pretty_print_info *ppi;
 523      tree e;
 524 {
 525   for (; e != NULL_TREE; e = TREE_CHAIN (e))
 526     {
 527       pp_c_assignment_expression (ppi, TREE_VALUE (e));
 528       if (TREE_CHAIN (e))
 529         pp_separate_with (ppi, ',');
 530     }
 531 }
 532
 533 static void
 534 pp_c_unary_expression (ppi, e)
 535      c_pretty_print_info *ppi;
 536      tree e;
 537 {
 538   enum tree_code code = TREE_CODE (e);
 539   switch (code)
 540     {
 541     case PREINCREMENT_EXPR:
 542     case PREDECREMENT_EXPR:
 543       pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
 544       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 545       break;
 546
 547     case ADDR_EXPR:
 548     case INDIRECT_REF:
 549     case CONVERT_EXPR:
 550     case NEGATE_EXPR:
 551     case BIT_NOT_EXPR:
 552     case TRUTH_NOT_EXPR:
 553     case CONJ_EXPR:
 554       if (code == ADDR_EXPR)
 555         pp_ampersand (ppi);
 556       else if (code == INDIRECT_REF)
 557         pp_star (ppi);
 558       else if (code == NEGATE_EXPR)
 559         pp_minus (ppi);
 560       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
 561         pp_complement (ppi);
 562       else if (code == TRUTH_NOT_EXPR)
 563         pp_exclamation (ppi);
 564       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 565       break;
 566
 567     case SIZEOF_EXPR:
 568     case ALIGNOF_EXPR:
 569       pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
 570       pp_c_whitespace (ppi);
 571       if (TYPE_P (TREE_OPERAND (e, 0)))
 572         {
 573           pp_c_left_paren (ppi);
 574           pp_type_id (ppi, TREE_OPERAND (e, 0));
 575           pp_c_right_paren (ppi);
 576         }
 577       else
 578         pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 579       break;
 580
 581     case REALPART_EXPR:
 582     case IMAGPART_EXPR:
 583       pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__");
 584       pp_c_whitespace (ppi);
 585       pp_unary_expression (ppi, TREE_OPERAND (e, 0));
 586       break;
 587
 588     default:
 589       pp_postfix_expression (ppi, e);
 590       break;
 591     }
 592 }
 593
 594 void
 595 pp_c_cast_expression (ppi, e)
 596      c_pretty_print_info *ppi;
 597      tree e;
 598 {
 599   if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
 600     {
 601       pp_c_left_paren (ppi);
 602       pp_type_id (ppi, TREE_TYPE (e));
 603       pp_c_right_paren (ppi);
 604       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 605     }
 606   else
 607     pp_unary_expression (ppi, e);
 608 }
 609
 610 static void
 611 pp_c_multiplicative_expression (ppi, e)
 612      c_pretty_print_info *ppi;
 613      tree e;
 614 {
 615   enum tree_code code = TREE_CODE (e);
 616   switch (code)
 617     {
 618     case MULT_EXPR:
 619     case TRUNC_DIV_EXPR:
 620     case TRUNC_MOD_EXPR:
 621       pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
 622       pp_c_whitespace (ppi);
 623       if (code == MULT_EXPR)
 624         pp_star (ppi);
 625       else if (code == TRUNC_DIV_EXPR)
 626         pp_slash (ppi);
 627       else
 628         pp_modulo (ppi);
 629       pp_c_whitespace (ppi);
 630       pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
 631       break;
 632
 633     default:
 634       pp_c_cast_expression (ppi, e);
 635       break;
 636     }
 637 }
 638
 639 static inline void
 640 pp_c_additive_expression (ppi, e)
 641      c_pretty_print_info *ppi;
 642      tree e;
 643 {
 644   enum tree_code code = TREE_CODE (e);
 645   switch (code)
 646     {
 647     case PLUS_EXPR:
 648     case MINUS_EXPR:
 649       pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
 650       pp_c_whitespace (ppi);
 651       if (code == PLUS_EXPR)
 652         pp_plus (ppi);
 653       else
 654         pp_minus (ppi);
 655       pp_c_whitespace (ppi);
 656       pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
 657       break;
 658
 659     default:
 660       pp_multiplicative_expression (ppi, e);
 661       break;
 662     }
 663 }
 664
 665 static inline void
 666 pp_c_shift_expression (ppi, e)
 667      c_pretty_print_info *ppi;
 668      tree e;
 669 {
 670   enum tree_code code = TREE_CODE (e);
 671   switch (code)
 672     {
 673     case LSHIFT_EXPR:
 674     case RSHIFT_EXPR:
 675       pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
 676       pp_c_whitespace (ppi);
 677       pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
 678       pp_c_whitespace (ppi);
 679       pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
 680       break;
 681
 682     default:
 683       pp_c_additive_expression (ppi, e);
 684     }
 685 }
 686
 687 static void
 688 pp_c_relational_expression (ppi, e)
 689      c_pretty_print_info *ppi;
 690      tree e;
 691 {
 692   enum tree_code code = TREE_CODE (e);
 693   switch (code)
 694     {
 695     case LT_EXPR:
 696     case GT_EXPR:
 697     case LE_EXPR:
 698     case GE_EXPR:
 699       pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
 700       pp_c_whitespace (ppi);
 701       if (code == LT_EXPR)
 702         pp_less (ppi);
 703       else if (code == GT_EXPR)
 704         pp_greater (ppi);
 705       else if (code == LE_EXPR)
 706         pp_identifier (ppi, "<=");
 707       else if (code == GE_EXPR)
 708         pp_identifier (ppi, ">=");
 709       pp_c_whitespace (ppi);
 710       pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
 711       break;
 712
 713     default:
 714       pp_c_shift_expression (ppi, e);
 715       break;
 716     }
 717 }
 718
 719 static inline void
 720 pp_c_equality_expression (ppi, e)
 721      c_pretty_print_info *ppi;
 722      tree e;
 723 {
 724   enum tree_code code = TREE_CODE (e);
 725   switch (code)
 726     {
 727     case EQ_EXPR:
 728     case NE_EXPR:
 729       pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
 730       pp_c_maybe_whitespace (ppi);
 731       pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
 732       pp_c_whitespace (ppi);
 733       pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
 734       break;
 735
 736     default:
 737       pp_c_relational_expression (ppi, e);
 738       break;
 739     }
 740 }
 741
 742 static inline void
 743 pp_c_and_expression (ppi, e)
 744      c_pretty_print_info *ppi;
 745      tree e;
 746 {
 747   if (TREE_CODE (e) == BIT_AND_EXPR)
 748     {
 749       pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
 750       pp_c_maybe_whitespace (ppi);
 751       pp_ampersand (ppi);
 752       pp_c_whitespace (ppi);
 753       pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
 754     }
 755   else
 756     pp_c_equality_expression (ppi, e);
 757 }
 758
 759 static inline void
 760 pp_c_exclusive_or_expression (ppi, e)
 761      c_pretty_print_info *ppi;
 762      tree e;
 763 {
 764   if (TREE_CODE (e) == BIT_XOR_EXPR)
 765     {
 766       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 767       pp_c_maybe_whitespace (ppi);
 768       pp_carret (ppi);
 769       pp_c_whitespace (ppi);
 770       pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
 771     }
 772   else
 773     pp_c_and_expression (ppi, e);
 774 }
 775
 776 static inline void
 777 pp_c_inclusive_or_expression (ppi, e)
 778      c_pretty_print_info *ppi;
 779      tree e;
 780 {
 781   if (TREE_CODE (e) == BIT_IOR_EXPR)
 782     {
 783       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 784       pp_c_maybe_whitespace (ppi);
 785       pp_bar (ppi);
 786       pp_c_whitespace (ppi);
 787       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 788     }
 789   else
 790     pp_c_exclusive_or_expression (ppi, e);
 791 }
 792
 793 static inline void
 794 pp_c_logical_and_expression (ppi, e)
 795      c_pretty_print_info *ppi;
 796      tree e;
 797 {
 798   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
 799     {
 800       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
 801       pp_c_maybe_whitespace (ppi);
 802       pp_identifier (ppi, "&&");
 803       pp_c_whitespace (ppi);
 804       pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 805     }
 806   else
 807     pp_c_inclusive_or_expression (ppi, e);
 808 }
 809
 810 void
 811 pp_c_logical_or_expression (ppi, e)
 812      c_pretty_print_info *ppi;
 813      tree e;
 814 {
 815   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
 816     {
 817       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 818       pp_c_maybe_whitespace (ppi);
 819       pp_identifier (ppi, "||");
 820       pp_c_whitespace (ppi);
 821       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
 822     }
 823   else
 824     pp_c_logical_and_expression (ppi, e);
 825 }
 826
 827 static void
 828 pp_c_conditional_expression (ppi, e)
 829      c_pretty_print_info *ppi;
 830      tree e;
 831 {
 832   if (TREE_CODE (e) == COND_EXPR)
 833     {
 834       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 835       pp_c_maybe_whitespace (ppi);
 836       pp_question (ppi);
 837       pp_c_whitespace (ppi);
 838       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 839       pp_c_maybe_whitespace (ppi);
 840       pp_colon (ppi);
 841       pp_c_whitespace (ppi);
 842       pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
 843     }
 844   else
 845     pp_c_logical_or_expression (ppi, e);
 846 }
 847
 848
 849 /* Pretty-print a C assignment-expression.  */
 850 static void
 851 pp_c_assignment_expression (ppi, e)
 852      c_pretty_print_info *ppi;
 853      tree e;
 854 {
 855   if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
 856     {
 857       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 858       pp_c_maybe_whitespace (ppi);
 859       pp_equal (ppi);
 860       pp_whitespace (ppi);
 861       pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
 862     }
 863   else
 864     pp_c_conditional_expression (ppi, e);
 865 }
 866
 867 /* Pretty-print an expression.  */
 868 void
 869 pp_c_expression (ppi, e)
 870      c_pretty_print_info *ppi;
 871      tree e;
 872 {
 873   switch (TREE_CODE (e))
 874     {
 875     case INTEGER_CST:
 876       pp_c_integer_literal (ppi, e);
 877       break;
 878
 879     case REAL_CST:
 880       pp_c_real_literal (ppi, e);
 881       break;
 882
 883     case STRING_CST:
 884       pp_c_string_literal (ppi, e);
 885       break;
 886
 887     case FUNCTION_DECL:
 888     case VAR_DECL:
 889     case CONST_DECL:
 890     case PARM_DECL:
 891     case RESULT_DECL:
 892     case FIELD_DECL:
 893     case LABEL_DECL:
 894     case ERROR_MARK:
 895     case TARGET_EXPR:
 896     case STMT_EXPR:
 897       pp_c_primary_expression (ppi, e);
 898       break;
 899
 900     case POSTINCREMENT_EXPR:
 901     case POSTDECREMENT_EXPR:
 902     case ARROW_EXPR:
 903     case ARRAY_REF:
 904     case CALL_EXPR:
 905     case COMPONENT_REF:
 906     case COMPLEX_CST:
 907     case VECTOR_CST:
 908     case ABS_EXPR:
 909     case FFS_EXPR:
 910     case CONSTRUCTOR:
 911     case COMPOUND_LITERAL_EXPR:
 912     case COMPLEX_EXPR:
 913     case VA_ARG_EXPR:
 914       pp_c_postfix_expression (ppi, e);
 915       break;
 916
 917     case CONJ_EXPR:
 918     case ADDR_EXPR:
 919     case INDIRECT_REF:
 920     case NEGATE_EXPR:
 921     case BIT_NOT_EXPR:
 922     case TRUTH_NOT_EXPR:
 923     case PREINCREMENT_EXPR:
 924     case PREDECREMENT_EXPR:
 925     case SIZEOF_EXPR:
 926     case ALIGNOF_EXPR:
 927     case REALPART_EXPR:
 928     case IMAGPART_EXPR:
 929       pp_c_unary_expression (ppi, e);
 930       break;
 931
 932     case CONVERT_EXPR:
 933     case FLOAT_EXPR:
 934       pp_c_cast_expression (ppi, e);
 935       break;
 936
 937     case MULT_EXPR:
 938     case TRUNC_MOD_EXPR:
 939     case TRUNC_DIV_EXPR:
 940       pp_c_multiplicative_expression (ppi, e);
 941       break;
 942
 943     case LSHIFT_EXPR:
 944     case RSHIFT_EXPR:
 945       pp_c_shift_expression (ppi, e);
 946       break;
 947
 948     case LT_EXPR:
 949     case GT_EXPR:
 950     case LE_EXPR:
 951     case GE_EXPR:
 952       pp_c_relational_expression (ppi, e);
 953       break;
 954
 955     case BIT_AND_EXPR:
 956       pp_c_and_expression (ppi, e);
 957       break;
 958
 959     case BIT_XOR_EXPR:
 960       pp_c_exclusive_or_expression (ppi, e);
 961       break;
 962
 963     case BIT_IOR_EXPR:
 964       pp_c_inclusive_or_expression (ppi, e);
 965       break;
 966
 967     case TRUTH_ANDIF_EXPR:
 968       pp_c_logical_and_expression (ppi, e);
 969       break;
 970
 971     case TRUTH_ORIF_EXPR:
 972       pp_c_logical_or_expression (ppi, e);
 973       break;
 974
 975     case COND_EXPR:
 976       pp_c_conditional_expression (ppi, e);
 977       break;
 978
 979     case MODIFY_EXPR:
 980     case INIT_EXPR:
 981       pp_c_assignment_expression (ppi, e);
 982       break;
 983
 984     case NOP_EXPR:
 985       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 986       break;
 987
 988     case COMPOUND_EXPR:
 989       pp_c_left_paren (ppi);
 990       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 991       pp_separate_with (ppi, ',');
 992       pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
 993       pp_c_right_paren (ppi);
 994       break;
 995
 996
 997     default:
 998       pp_unsupported_tree (ppi, e);
 999       break;
1000     }
1001 }
1002