gcc/c-pretty-print.c

   1 /* Subroutines common to both C and C++ pretty-printers.
   2    Copyright (C) 2002, 2003 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 "coretypes.h"
  25 #include "tm.h"
  26 #include "real.h"
  27 #include "c-pretty-print.h"
  28 #include "c-tree.h"
  29
  30 /* The pretty-printer code is primarily designed to closely follow
  31    (GNU) C and C++ grammars.  That is to be contrasted with spaghetti
  32    codes we used to have in the past.  Following a structured
  33    approach (preferaably the official grammars) is believed to make it
  34    much easier o add extensions and nifty pretty-printing effects that
  35    takes expresssion or declaration contexts into account.  */
  36
  37
  38 #define pp_c_whitespace(PP)           \
  39    do {                               \
  40      pp_space (PP);                   \
  41      pp_base (PP)->padding = pp_none; \
  42    } while (0)
  43 #define pp_c_maybe_whitespace(PP)            \
  44    do {                                      \
  45      if (pp_base (PP)->padding == pp_before) \
  46        pp_c_whitespace (PP);                 \
  47    } while (0)
  48
  49 #define pp_c_left_paren(PP)           \
  50   do {                                \
  51     pp_left_paren (PP);               \
  52     pp_base (PP)->padding = pp_none;  \
  53   } while (0)
  54
  55 #define pp_c_right_paren(PP)          \
  56   do {                                \
  57     pp_right_paren (PP);              \
  58     pp_base (PP)->padding = pp_none;  \
  59   } while (0)
  60
  61 #define pp_c_left_brace(PP)           \
  62   do {                                \
  63     pp_left_brace (PP);               \
  64     pp_base (PP)->padding = pp_none;  \
  65   } while (0)
  66
  67 #define pp_c_right_brace(PP)          \
  68   do {                                \
  69     pp_right_brace (PP);              \
  70     pp_base (PP)->padding = pp_none;  \
  71   } while (0)
  72
  73 #define pp_c_left_bracket(PP)         \
  74   do {                                \
  75     pp_left_bracket (PP);             \
  76     pp_base (PP)->padding = pp_none;  \
  77   } while (0)
  78
  79 #define pp_c_right_bracket(PP)        \
  80   do {                                \
  81     pp_right_bracket (PP);            \
  82     pp_base (PP)->padding = pp_none;  \
  83   } while (0)
  84
  85 #define pp_c_arrow(PP)                \
  86   do {                                \
  87     pp_arrow (PP);                    \
  88     pp_base (PP)->padding = pp_none;  \
  89   } while (0)
  90
  91 #define pp_c_star(PP)                 \
  92   do {                                \
  93     pp_star (PP);                     \
  94     pp_base (PP)->padding = pp_none;  \
  95   } while (0)
  96
  97 #define pp_c_dot(PP)                  \
  98   do {                                \
  99     pp_dot (PP);                      \
 100     pp_base (PP)->padding = pp_none;  \
 101   } while (0)
 102
 103 #define pp_c_semicolon(PP)            \
 104   do {                                \
 105     pp_semicolon (PP);                \
 106     pp_base (PP)->padding = pp_none;  \
 107   } while (0)
 108
 109 /* literal  */
 110 static void pp_c_char (c_pretty_printer, int);
 111 static void pp_c_primary_expression (c_pretty_printer, tree);
 112
 113 /* postfix-expression  */
 114 static void pp_c_initializer_list (c_pretty_printer, tree);
 115
 116 static void pp_c_multiplicative_expression (c_pretty_printer, tree);
 117 static void pp_c_additive_expression (c_pretty_printer, tree);
 118 static void pp_c_shift_expression (c_pretty_printer, tree);
 119 static void pp_c_relational_expression (c_pretty_printer, tree);
 120 static void pp_c_equality_expression (c_pretty_printer, tree);
 121 static void pp_c_and_expression (c_pretty_printer, tree);
 122 static void pp_c_exclusive_or_expression (c_pretty_printer, tree);
 123 static void pp_c_inclusive_or_expression (c_pretty_printer, tree);
 124 static void pp_c_logical_and_expression (c_pretty_printer, tree);
 125 static void pp_c_conditional_expression (c_pretty_printer, tree);
 126 static void pp_c_assignment_expression (c_pretty_printer, tree);
 127
 128 /* declarations.  */
 129 static void pp_c_declaration_specifiers (c_pretty_printer, tree);
 130 static void pp_c_direct_abstract_declarator (c_pretty_printer, tree);
 131 static void pp_c_init_declarator (c_pretty_printer, tree);
 132 static void pp_c_simple_type_specifier (c_pretty_printer, tree);
 133 static void pp_c_parameter_declaration (c_pretty_printer, tree);
 134 static void pp_c_storage_class_specifier (c_pretty_printer, tree);
 135 static void pp_c_function_specifier (c_pretty_printer, tree);
 136
 137
 138 \f
 139 /* Declarations.  */
 140
 141 static void
 142 pp_c_cv_qualifier (c_pretty_printer pp, const char *cv)
 143 {
 144   const char *p = pp_last_position_in_text (pp);
 145   if (p != NULL && *p == '*')
 146     pp_c_whitespace (pp);
 147   pp_c_identifier (pp, cv);
 148 }
 149
 150 /* C++ cv-qualifiers are called type-qualifiers in C.  Print out the
 151    cv-qualifiers of T.  If T is a declaration then it is the cv-qualifier
 152    of its type.  Take care of possible extensions.
 153    cv-qualifier:
 154        const
 155        volatile
 156        restrict
 157        __restrict__   */
 158 void
 159 pp_c_type_qualifier_list (c_pretty_printer pp, tree t)
 160 {
 161    int qualifiers;
 162
 163   if (!TYPE_P (t))
 164     t = TREE_TYPE (t);
 165
 166   qualifiers = TYPE_QUALS (t);
 167   if (qualifiers & TYPE_QUAL_CONST)
 168     pp_c_cv_qualifier (pp, "const");
 169   if (qualifiers & TYPE_QUAL_VOLATILE)
 170     pp_c_cv_qualifier (pp, "volatile");
 171   if (qualifiers & TYPE_QUAL_RESTRICT)
 172     pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__");
 173 }
 174
 175 /* pointer:
 176       * type-qualifier-list(opt)
 177       * type-qualifier-list(opt) pointer  */
 178 static void
 179 pp_c_pointer (c_pretty_printer pp, tree t)
 180 {
 181   if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
 182     t = TREE_TYPE (t);
 183   switch (TREE_CODE (t))
 184     {
 185     case POINTER_TYPE:
 186       if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
 187         pp_c_pointer (pp, TREE_TYPE (t));
 188       pp_c_star (pp);
 189       pp_c_type_qualifier_list (pp, t);
 190       break;
 191
 192     default:
 193       pp_unsupported_tree (pp, t);
 194     }
 195 }
 196
 197 /*
 198   simple-type-specifier:
 199      void
 200      char
 201      short
 202      int
 203      long
 204      float
 205      double
 206      signed
 207      unsigned
 208      _Bool                          -- C99
 209      _Complex                       -- C99
 210      _Imaginary                     -- C99
 211      typedef-name.
 212
 213   GNU extensions.
 214   simple-type-specifier:
 215       __complex__
 216       __vector__   */
 217 static void
 218 pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
 219 {
 220   enum tree_code code;
 221
 222   if (DECL_P (t) && TREE_CODE (t) != TYPE_DECL)
 223     t = TREE_TYPE (t);
 224
 225   code = TREE_CODE (t);
 226   switch (code)
 227     {
 228     case ERROR_MARK:
 229       pp_c_identifier (ppi, "<type-error>");
 230       break;
 231
 232 #if 0
 233     case UNKNOWN_TYPE:
 234       pp_c_identifier (ppi, "<unkown-type>");
 235       break;
 236 #endif
 237
 238     case IDENTIFIER_NODE:
 239       pp_c_tree_identifier (ppi, t);
 240       break;
 241
 242     case VOID_TYPE:
 243     case BOOLEAN_TYPE:
 244     case CHAR_TYPE:
 245     case INTEGER_TYPE:
 246     case REAL_TYPE:
 247       pp_c_simple_type_specifier (ppi, TYPE_NAME (t));
 248       break;
 249
 250     case COMPLEX_TYPE:
 251     case VECTOR_TYPE:
 252       pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
 253       if (code == COMPLEX_TYPE)
 254         pp_c_identifier (ppi, flag_isoc99 ? "_Complex" : "__complex__");
 255       else if (code == VECTOR_TYPE)
 256         pp_c_identifier (ppi, "__vector__");
 257       break;
 258
 259     case TYPE_DECL:
 260       if (DECL_NAME (t))
 261         pp_id_expression (ppi, t);
 262       else
 263         pp_c_identifier (ppi, "<typedef-error>");
 264       break;
 265
 266     case UNION_TYPE:
 267     case RECORD_TYPE:
 268     case ENUMERAL_TYPE:
 269       if (code == UNION_TYPE)
 270         pp_c_identifier (ppi, "union");
 271       else if (code == RECORD_TYPE)
 272         pp_c_identifier (ppi, "struct");
 273       else if (code == ENUMERAL_TYPE)
 274         pp_c_identifier (ppi, "enum");
 275       else
 276         pp_c_identifier (ppi, "<tag-error>");
 277
 278       if (TYPE_NAME (t))
 279         pp_id_expression (ppi, TYPE_NAME (t));
 280       else
 281         pp_c_identifier (ppi, "<anonymous>");
 282       break;
 283
 284     case POINTER_TYPE:
 285     case ARRAY_TYPE:
 286     case FUNCTION_TYPE:
 287       pp_c_simple_type_specifier (ppi, TREE_TYPE (t));
 288       break;
 289
 290     default:
 291       pp_unsupported_tree (ppi, t);
 292       break;
 293     }
 294 }
 295
 296 /* specifier-qualifier-list:
 297       type-specifier specifier-qualifier-list-opt
 298       cv-qualifier specifier-qualifier-list-opt
 299
 300
 301   Implementation note:  Because of the non-linearities in array or
 302   function declarations, this routinie prints not just the
 303   specifier-qualifier-list of such entities or types of such entities,
 304   but also the 'pointer' production part of their declarators.  The
 305   remaining part is done by pp_declarator or pp_c_abstract_declarator.  */
 306 void
 307 pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t)
 308 {
 309   if (TREE_CODE (t) != POINTER_TYPE)
 310     pp_c_type_qualifier_list (pp, t);
 311   switch (TREE_CODE (t))
 312     {
 313     case POINTER_TYPE:
 314       {
 315         /* Get the types-specifier of this type.  */
 316         tree pointee = TREE_TYPE (t);
 317         while (TREE_CODE (pointee) == POINTER_TYPE)
 318           pointee = TREE_TYPE (pointee);
 319         pp_c_specifier_qualifier_list (pp, pointee);
 320         if (TREE_CODE (pointee) == ARRAY_TYPE
 321             || TREE_CODE (pointee) == FUNCTION_TYPE)
 322           {
 323             pp_c_whitespace (pp);
 324             pp_c_left_paren (pp);
 325           }
 326         pp_c_pointer (pp, t);
 327         if (TREE_CODE (pointee) != FUNCTION_TYPE
 328             && TREE_CODE (pointee) != ARRAY_TYPE)
 329           pp_c_whitespace (pp);
 330       }
 331       break;
 332
 333     case FUNCTION_TYPE:
 334     case ARRAY_TYPE:
 335       pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
 336       break;
 337
 338     case VECTOR_TYPE:
 339     case COMPLEX_TYPE:
 340       pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
 341       pp_space (pp);
 342       pp_c_simple_type_specifier (pp, t);
 343       break;
 344
 345     default:
 346       pp_c_simple_type_specifier (pp, t);
 347       break;
 348     }
 349 }
 350
 351 /* parameter-type-list:
 352       parameter-list
 353       parameter-list , ...
 354
 355    parameter-list:
 356       parameter-declaration
 357       parameter-list , parameter-declaration
 358
 359    parameter-declaration:
 360       declaration-specifiers declarator
 361       declaration-specifiers abstract-declarator(opt)   */
 362 static void
 363 pp_c_parameter_type_list (c_pretty_printer pp, tree t)
 364 {
 365   pp_c_left_paren (pp);
 366   if (t == void_list_node)
 367     pp_c_identifier (pp, "void");
 368   else
 369     {
 370       bool first = true;
 371       bool want_parm_decl = t && DECL_P (t);
 372       for ( ; t != NULL && t != void_list_node; t = TREE_CHAIN (t))
 373         {
 374           if (!first)
 375             pp_separate_with (pp, ',');
 376           first = false;
 377           pp_declaration_specifiers (pp, want_parm_decl ? t : TREE_VALUE (t));
 378           if (want_parm_decl)
 379             pp_declarator (pp, t);
 380           else
 381             pp_abstract_declarator (pp, TREE_VALUE (t));
 382         }
 383     }
 384   pp_c_right_paren (pp);
 385 }
 386
 387 /* abstract-declarator:
 388       pointer
 389       pointer(opt) direct-abstract-declarator  */
 390 static inline void
 391 pp_c_abstract_declarator (c_pretty_printer pp, tree t)
 392 {
 393   if (TREE_CODE (t) == POINTER_TYPE)
 394     {
 395       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
 396           || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
 397         pp_c_right_paren (pp);
 398       t = TREE_TYPE (t);
 399     }
 400
 401   pp_c_direct_abstract_declarator (pp, t);
 402 }
 403
 404 /* direct-abstract-declarator:
 405       ( abstract-declarator )
 406       direct-abstract-declarator(opt) [ assignment-expression(opt) ]
 407       direct-abstract-declarator(opt) [ * ]
 408       direct-abstract-declarator(opt) ( parameter-type-list(opt) )  */
 409 static void
 410 pp_c_direct_abstract_declarator (c_pretty_printer pp, tree t)
 411 {
 412   switch (TREE_CODE (t))
 413     {
 414     case POINTER_TYPE:
 415       pp_c_abstract_declarator (pp, t);
 416       break;
 417
 418     case FUNCTION_TYPE:
 419       pp_c_parameter_type_list (pp, TYPE_ARG_TYPES (t));
 420       pp_c_direct_abstract_declarator (pp, TREE_TYPE (t));
 421       break;
 422
 423     case ARRAY_TYPE:
 424       pp_c_left_bracket (pp);
 425       if (TYPE_DOMAIN (t))
 426         pp_c_expression (pp, TYPE_MAX_VALUE (TYPE_DOMAIN (t)));
 427       pp_c_right_bracket (pp);
 428       pp_c_direct_abstract_declarator (pp, TREE_TYPE (t));
 429       break;
 430
 431     case IDENTIFIER_NODE:
 432     case VOID_TYPE:
 433     case BOOLEAN_TYPE:
 434     case INTEGER_TYPE:
 435     case REAL_TYPE:
 436     case ENUMERAL_TYPE:
 437     case RECORD_TYPE:
 438     case UNION_TYPE:
 439     case VECTOR_TYPE:
 440     case COMPLEX_TYPE:
 441     case TYPE_DECL:
 442       break;
 443
 444     default:
 445       pp_unsupported_tree (pp, t);
 446       break;
 447     }
 448 }
 449
 450 void
 451 pp_c_type_id (c_pretty_printer ppi, tree t)
 452 {
 453   pp_c_specifier_qualifier_list (ppi, t);
 454   pp_abstract_declarator (ppi, t);
 455 }
 456
 457 static inline void
 458 pp_c_storage_class_specifier (c_pretty_printer pp, tree t)
 459 {
 460   if (TREE_CODE (t) == TYPE_DECL)
 461     pp_c_identifier (pp, "typedef");
 462   else if (DECL_P (t))
 463     {
 464       if (DECL_REGISTER (t))
 465         pp_c_identifier (pp, "register");
 466       else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
 467         pp_c_identifier (pp, "static");
 468     }
 469 }
 470
 471 static inline void
 472 pp_c_function_specifier (c_pretty_printer pp, tree t)
 473 {
 474   if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
 475     pp_c_identifier (pp, "inline");
 476 }
 477
 478 /* declaration-specifiers:
 479       storage-class-specifier declaration-specifiers(opt)
 480       type-specifier declaration-specifiers(opt)
 481       type-qualifier declaration-specifiers(opt)
 482       function-specifier declaration-specifiers(opt)  */
 483 static inline void
 484 pp_c_declaration_specifiers (c_pretty_printer pp, tree t)
 485 {
 486   pp_storage_class_specifier (pp, t);
 487   pp_function_specifier (pp, t);
 488   pp_c_specifier_qualifier_list (pp, DECL_P (t) ?  TREE_TYPE (t) : t);
 489 }
 490
 491 /* direct-declarator
 492       identifier
 493       ( declarator )
 494       direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
 495       direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
 496       direct-declarator [ type-qualifier-list static assignment-exression ]
 497       direct-declarator [ type-qualifier-list * ]
 498       direct-declaratpr ( parameter-type-list )
 499       direct-declarator ( identifier-list(opt) )  */
 500 void
 501 pp_c_direct_declarator (c_pretty_printer pp, tree t)
 502 {
 503   switch (TREE_CODE (t))
 504     {
 505     case VAR_DECL:
 506     case PARM_DECL:
 507     case TYPE_DECL:
 508     case FIELD_DECL:
 509     case LABEL_DECL:
 510       pp_c_tree_identifier (pp, DECL_NAME (t));
 511     case ARRAY_TYPE:
 512     case POINTER_TYPE:
 513       pp_abstract_declarator (pp, TREE_TYPE (t));
 514       break;
 515
 516     case FUNCTION_TYPE:
 517       pp_c_parameter_type_list (pp, TYPE_ARG_TYPES (t));
 518       pp_c_abstract_declarator (pp, TREE_TYPE (t));
 519       break;
 520
 521     case FUNCTION_DECL:
 522       pp_c_tree_identifier (pp, DECL_NAME (t));
 523       if (pp_c_base (pp)->flags & pp_c_flag_abstract)
 524         pp_c_abstract_declarator (pp, TREE_TYPE (t));
 525       else
 526         {
 527           pp_c_parameter_type_list (pp, DECL_ARGUMENTS (t));
 528           pp_c_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t)));
 529         }
 530       break;
 531
 532     case INTEGER_TYPE:
 533     case REAL_TYPE:
 534     case ENUMERAL_TYPE:
 535     case UNION_TYPE:
 536     case RECORD_TYPE:
 537       break;
 538
 539     default:
 540       pp_unsupported_tree (pp, t);
 541       break;
 542     }
 543 }
 544
 545
 546 /* declarator:
 547       pointer(opt)  direct-declarator   */
 548 void
 549 pp_c_declarator (c_pretty_printer pp, tree t)
 550 {
 551   switch (TREE_CODE (t))
 552     {
 553     case INTEGER_TYPE:
 554     case REAL_TYPE:
 555     case ENUMERAL_TYPE:
 556     case UNION_TYPE:
 557     case RECORD_TYPE:
 558       break;
 559
 560     case VAR_DECL:
 561     case PARM_DECL:
 562     case FIELD_DECL:
 563     case ARRAY_TYPE:
 564     case FUNCTION_TYPE:
 565     case FUNCTION_DECL:
 566     case TYPE_DECL:
 567       pp_direct_declarator (pp, t);
 568     break;
 569
 570
 571     default:
 572       pp_unsupported_tree (pp, t);
 573       break;
 574     }
 575 }
 576
 577 /* init-declarator:
 578       declarator:
 579       declarator = initializer   */
 580 static inline void
 581 pp_c_init_declarator (c_pretty_printer pp, tree t)
 582 {
 583   pp_declarator (pp, t);
 584   if (DECL_INITIAL (t))
 585     {
 586       pp_space (pp);
 587       pp_equal (pp);
 588       pp_space (pp);
 589       pp_c_initializer (pp, DECL_INITIAL (t));
 590     }
 591 }
 592
 593 /* declaration:
 594       declaration-specifiers init-declarator-list(opt) ;  */
 595
 596 void
 597 pp_c_declaration (c_pretty_printer pp, tree t)
 598 {
 599   pp_declaration_specifiers (pp, t);
 600   pp_c_init_declarator (pp, t);
 601 }
 602
 603 static void
 604 pp_c_parameter_declaration (c_pretty_printer pp, tree t)
 605 {
 606   pp_unsupported_tree (pp, t);
 607 }
 608
 609 /* Pretty-print ATTRIBUTES using GNU C extension syntax.  */
 610 void
 611 pp_c_attributes (c_pretty_printer pp, tree attributes)
 612 {
 613   if (attributes == NULL_TREE)
 614     return;
 615
 616   pp_c_identifier (pp, "__attribute__");
 617   pp_c_left_paren (pp);
 618   pp_c_left_paren (pp);
 619   for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
 620     {
 621       pp_tree_identifier (pp, TREE_PURPOSE (attributes));
 622       if (TREE_VALUE (attributes))
 623         {
 624           pp_c_left_paren (pp);
 625           pp_c_expression_list (pp, TREE_VALUE (attributes));
 626           pp_c_right_paren (pp);
 627         }
 628
 629       if (TREE_CHAIN (attributes))
 630         pp_separate_with (pp, ',');
 631     }
 632   pp_c_right_paren (pp);
 633   pp_c_right_paren (pp);
 634 }
 635
 636 /* function-definition:
 637       declaration-specifiers declarator compound-statement  */
 638 void
 639 pp_c_function_definition (c_pretty_printer pp, tree t)
 640 {
 641   pp_declaration_specifiers (pp, t);
 642   pp_declarator (pp, t);
 643   pp_needs_newline (pp) = true;
 644   pp_statement (pp, DECL_SAVED_TREE (t));
 645   pp_newline (pp);
 646   pp_flush (pp);
 647 }
 648
 649 \f
 650 /* Expressions.  */
 651
 652 /* Print out a c-char.  */
 653 static void
 654 pp_c_char (c_pretty_printer ppi, int c)
 655 {
 656   switch (c)
 657     {
 658     case TARGET_NEWLINE:
 659       pp_string (ppi, "\\n");
 660       break;
 661     case TARGET_TAB:
 662       pp_string (ppi, "\\t");
 663       break;
 664     case TARGET_VT:
 665       pp_string (ppi, "\\v");
 666       break;
 667     case TARGET_BS:
 668       pp_string (ppi, "\\b");
 669       break;
 670     case TARGET_CR:
 671       pp_string (ppi, "\\r");
 672       break;
 673     case TARGET_FF:
 674       pp_string (ppi, "\\f");
 675       break;
 676     case TARGET_BELL:
 677       pp_string (ppi, "\\a");
 678       break;
 679     case '\\':
 680       pp_string (ppi, "\\\\");
 681       break;
 682     case '\'':
 683       pp_string (ppi, "\\'");
 684       break;
 685     case '\"':
 686       pp_string (ppi, "\\\"");
 687       break;
 688     default:
 689       if (ISPRINT (c))
 690         pp_character (ppi, c);
 691       else
 692         pp_scalar (ppi, "\\%03o", (unsigned) c);
 693       break;
 694     }
 695 }
 696
 697 /* Print out a STRING literal.  */
 698 void
 699 pp_c_string_literal (c_pretty_printer ppi, tree s)
 700 {
 701   const char *p = TREE_STRING_POINTER (s);
 702   int n = TREE_STRING_LENGTH (s) - 1;
 703   int i;
 704   pp_doublequote (ppi);
 705   for (i = 0; i < n; ++i)
 706     pp_c_char (ppi, p[i]);
 707   pp_doublequote (ppi);
 708 }
 709
 710 static void
 711 pp_c_integer_constant (c_pretty_printer pp, tree i)
 712 {
 713   if (host_integerp (i, 0))
 714     pp_wide_integer (pp, TREE_INT_CST_LOW (i));
 715   else
 716     {
 717       if (tree_int_cst_sgn (i) < 0)
 718         {
 719           pp_c_char (pp, '-');
 720           i = build_int_2 (-TREE_INT_CST_LOW (i),
 721                            ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
 722         }
 723       sprintf (pp_buffer (pp)->digit_buffer,
 724                HOST_WIDE_INT_PRINT_DOUBLE_HEX,
 725                TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
 726       pp_string (pp, pp_buffer (pp)->digit_buffer);
 727     }
 728 }
 729
 730 /* Print out a CHARACTER literal.  */
 731 static inline void
 732 pp_c_character_constant (c_pretty_printer pp, tree c)
 733 {
 734   tree type = TREE_TYPE (c);
 735   if (type == wchar_type_node)
 736     pp_character (pp, 'L');
 737   pp_quote (pp);
 738   if (host_integerp (c, TREE_UNSIGNED (type)))
 739     pp_c_char (pp, tree_low_cst (c, TREE_UNSIGNED (type)));
 740   else
 741     pp_scalar (pp, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
 742   pp_quote (pp);
 743 }
 744
 745 /* Print out a BOOLEAN literal.  */
 746 static void
 747 pp_c_bool_constant (c_pretty_printer pp, tree b)
 748 {
 749   if (b == boolean_false_node)
 750     {
 751       if (c_dialect_cxx ())
 752         pp_c_identifier (pp, "false");
 753       else if (flag_isoc99)
 754         pp_c_identifier (pp, "_False");
 755       else
 756         pp_unsupported_tree (pp, b);
 757     }
 758   else if (b == boolean_true_node)
 759     {
 760       if (c_dialect_cxx ())
 761         pp_c_identifier (pp, "true");
 762       else if (flag_isoc99)
 763         pp_c_identifier (pp, "_True");
 764       else
 765         pp_unsupported_tree (pp, b);
 766     }
 767   else if (TREE_CODE (b) == INTEGER_CST)
 768     pp_c_integer_constant (pp, b);
 769   else
 770     pp_unsupported_tree (pp, b);
 771 }
 772
 773 /* Attempt to print out an ENUMERATOR.  Return true on success.  Else return
 774    false; that means the value was obtained by a cast, in which case
 775    print out the type-id part of the cast-expression -- the casted value
 776    is then printed by pp_c_integer_literal.  */
 777 static bool
 778 pp_c_enumeration_constant (c_pretty_printer ppi, tree e)
 779 {
 780   bool value_is_named = true;
 781   tree type = TREE_TYPE (e);
 782   tree value;
 783
 784   /* Find the name of this constant.  */
 785   for (value = TYPE_VALUES (type);
 786        value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
 787        value = TREE_CHAIN (value))
 788     ;
 789
 790   if (value != NULL_TREE)
 791     pp_id_expression (ppi, TREE_PURPOSE (value));
 792   else
 793     {
 794       /* Value must have been cast.  */
 795       pp_c_left_paren (ppi);
 796       pp_type_id (ppi, type);
 797       pp_c_right_paren (ppi);
 798       value_is_named = false;
 799     }
 800
 801   return value_is_named;
 802 }
 803
 804 /* Print out a REAL value.  */
 805 static inline void
 806 pp_c_floating_constant (c_pretty_printer pp, tree r)
 807 {
 808   real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
 809                    sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
 810   pp_string (pp, pp_buffer(pp)->digit_buffer);
 811 }
 812
 813 /* constant:
 814       integer-constant
 815       floating-constant
 816       enumeration-constant
 817       chatracter-constant   */
 818 void
 819 pp_c_constant (c_pretty_printer pp, tree e)
 820 {
 821   switch (TREE_CODE (e))
 822     {
 823     case INTEGER_CST:
 824       {
 825         tree type = TREE_TYPE (e);
 826         if (type == boolean_type_node)
 827           pp_c_bool_constant (pp, e);
 828         else if (type == char_type_node)
 829           pp_c_character_constant (pp, e);
 830         else if (TREE_CODE (type) == ENUMERAL_TYPE
 831                  && pp_c_enumeration_constant (pp, e))
 832           ;
 833         else
 834           pp_c_integer_constant (pp, e);
 835       }
 836       break;
 837
 838     case REAL_CST:
 839       pp_c_floating_constant (pp, e);
 840       break;
 841
 842     case STRING_CST:
 843       pp_c_string_literal (pp, e);
 844       break;
 845
 846     default:
 847       pp_unsupported_tree (pp, e);
 848       break;
 849     }
 850 }
 851
 852 void
 853 pp_c_identifier (c_pretty_printer pp, const char *id)
 854 {
 855   pp_c_maybe_whitespace (pp);
 856   pp_identifier (pp, id);
 857   pp_base (pp)->padding = pp_before;
 858 }
 859
 860 /* Pretty-print a C primary-expression.
 861    primary-expression:
 862       identifier
 863       constant
 864       string-literal
 865       ( expression )   */
 866 static void
 867 pp_c_primary_expression (c_pretty_printer ppi, tree e)
 868 {
 869   switch (TREE_CODE (e))
 870     {
 871     case VAR_DECL:
 872     case PARM_DECL:
 873     case FIELD_DECL:
 874     case CONST_DECL:
 875     case FUNCTION_DECL:
 876     case LABEL_DECL:
 877       e = DECL_NAME (e);
 878       /* Fall through.  */
 879     case IDENTIFIER_NODE:
 880       pp_c_tree_identifier (ppi, e);
 881       break;
 882
 883     case ERROR_MARK:
 884       pp_c_identifier (ppi, "<erroneous-expression>");
 885       break;
 886
 887     case RESULT_DECL:
 888       pp_c_identifier (ppi, "<return-value>");
 889       break;
 890
 891     case INTEGER_CST:
 892     case REAL_CST:
 893     case STRING_CST:
 894       pp_c_constant (ppi, e);
 895       break;
 896
 897     case TARGET_EXPR:
 898       pp_c_left_paren (ppi);
 899       pp_c_identifier (ppi, "__builtin_memcpy");
 900       pp_c_left_paren (ppi);
 901       pp_ampersand (ppi);
 902       pp_primary_expression (ppi, TREE_OPERAND (e, 0));
 903       pp_separate_with (ppi, ',');
 904       pp_ampersand (ppi);
 905       pp_initializer (ppi, TREE_OPERAND (e, 1));
 906       if (TREE_OPERAND (e, 2))
 907         {
 908           pp_separate_with (ppi, ',');
 909           pp_c_expression (ppi, TREE_OPERAND (e, 2));
 910         }
 911       pp_c_right_paren (ppi);
 912
 913     case STMT_EXPR:
 914       pp_c_left_paren (ppi);
 915       pp_statement (ppi, STMT_EXPR_STMT (e));
 916       pp_c_right_paren (ppi);
 917       break;
 918
 919     default:
 920       /* FIXME:  Make sure we won't get into an infinie loop.  */
 921       pp_c_left_paren (ppi);
 922       pp_c_expression (ppi, e);
 923       pp_c_right_paren (ppi);
 924       break;
 925     }
 926 }
 927
 928 /* Print out a C initializer -- also support C compound-literals.
 929    initializer:
 930       assignment-expression:
 931       { initializer-list }
 932       { initializer-list , }   */
 933
 934 void
 935 pp_c_initializer (c_pretty_printer ppi, tree e)
 936 {
 937   if (TREE_CODE (e) == CONSTRUCTOR)
 938     {
 939       enum tree_code code = TREE_CODE (TREE_TYPE (e));
 940       if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 941         {
 942           pp_c_left_brace (ppi);
 943           pp_c_initializer_list (ppi, e);
 944           pp_c_right_brace (ppi);
 945         }
 946       else
 947         pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
 948     }
 949   else
 950     pp_assignment_expression (ppi, e);
 951 }
 952
 953 /* initializer-list:
 954       designation(opt) initializer
 955       initializer-list , designation(opt) initializer
 956
 957    designation:
 958       designator-list =
 959
 960    designator-list:
 961       designator
 962       designator-list designator
 963
 964    designator:
 965       [ constant-expression ]
 966       identifier   */
 967 static void
 968 pp_c_initializer_list (c_pretty_printer ppi, tree e)
 969 {
 970   tree type = TREE_TYPE (e);
 971   const enum tree_code code = TREE_CODE (type);
 972
 973   if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 974     {
 975       tree init = TREE_OPERAND (e, 0);
 976       for (; init != NULL_TREE; init = TREE_CHAIN (init))
 977         {
 978           if (code == RECORD_TYPE || code == UNION_TYPE)
 979             {
 980               pp_c_dot (ppi);
 981               pp_c_primary_expression (ppi, TREE_PURPOSE (init));
 982             }
 983           else
 984             {
 985               pp_c_left_bracket (ppi);
 986               if (TREE_PURPOSE (init))
 987                 pp_c_constant (ppi, TREE_PURPOSE (init));
 988               pp_c_right_bracket (ppi);
 989             }
 990           pp_c_whitespace (ppi);
 991           pp_equal (ppi);
 992           pp_c_whitespace (ppi);
 993           pp_initializer (ppi, TREE_VALUE (init));
 994           if (TREE_CHAIN (init))
 995             pp_separate_with (ppi, ',');
 996         }
 997     }
 998   else
 999     pp_unsupported_tree (ppi, type);
1000 }
1001
1002 /*  This is a convenient function, used to bridge gap between C and C++
1003     grammars.
1004
1005     id-expression:
1006        identifier  */
1007 void
1008 pp_c_id_expression (c_pretty_printer pp, tree t)
1009 {
1010   switch (TREE_CODE (t))
1011     {
1012     case VAR_DECL:
1013     case PARM_DECL:
1014     case CONST_DECL:
1015     case TYPE_DECL:
1016     case FUNCTION_DECL:
1017     case FIELD_DECL:
1018     case LABEL_DECL:
1019       t = DECL_NAME (t);
1020     case IDENTIFIER_NODE:
1021       pp_c_tree_identifier (pp, t);
1022       break;
1023
1024     default:
1025       pp_unsupported_tree (pp, t);
1026       break;
1027     }
1028 }
1029
1030 /* postfix-expression:
1031       primary-expression
1032       postfix-expression [ expression ]
1033       postfix-expression ( argument-expression-list(opt) )
1034       postfix-expression . identifier
1035       postfix-expression -> identifier
1036       postfix-expression ++
1037       postfix-expression --
1038       ( type-name ) { initializer-list }
1039       ( type-name ) { initializer-list , }  */
1040 void
1041 pp_c_postfix_expression (c_pretty_printer ppi, tree e)
1042 {
1043   enum tree_code code = TREE_CODE (e);
1044   switch (code)
1045     {
1046     case POSTINCREMENT_EXPR:
1047     case POSTDECREMENT_EXPR:
1048       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
1049       pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
1050       break;
1051
1052     case ARROW_EXPR:
1053       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
1054       pp_c_arrow (ppi);
1055       break;
1056
1057     case ARRAY_REF:
1058       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
1059       pp_c_left_bracket (ppi);
1060       pp_c_expression (ppi, TREE_OPERAND (e, 1));
1061       pp_c_right_bracket (ppi);
1062       break;
1063
1064     case CALL_EXPR:
1065       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
1066       pp_c_left_paren (ppi);
1067       pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
1068       pp_c_right_paren (ppi);
1069       break;
1070
1071     case ABS_EXPR:
1072     case FFS_EXPR:
1073       pp_c_identifier (ppi,
1074                        code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs");
1075       pp_c_left_paren (ppi);
1076       pp_c_expression (ppi, TREE_OPERAND (e, 0));
1077       pp_c_right_paren (ppi);
1078       break;
1079
1080     case COMPONENT_REF:
1081       {
1082         tree object = TREE_OPERAND (e, 0);
1083         if (TREE_CODE (object) == INDIRECT_REF)
1084           {
1085             pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
1086             pp_c_arrow (ppi);
1087           }
1088         else
1089           {
1090             pp_postfix_expression (ppi, object);
1091             pp_c_dot (ppi);
1092           }
1093         pp_c_expression (ppi, TREE_OPERAND (e, 1));
1094       }
1095       break;
1096
1097     case COMPLEX_CST:
1098     case VECTOR_CST:
1099     case COMPLEX_EXPR:
1100       pp_c_left_paren (ppi);
1101       pp_type_id (ppi, TREE_TYPE (e));
1102       pp_c_right_paren (ppi);
1103       pp_c_left_brace (ppi);
1104
1105       if (code == COMPLEX_CST)
1106         {
1107           pp_c_expression (ppi, TREE_REALPART (e));
1108           pp_separate_with (ppi, ',');
1109           pp_c_expression (ppi, TREE_IMAGPART (e));
1110         }
1111       else if (code == VECTOR_CST)
1112         pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e));
1113       else if (code == COMPLEX_EXPR)
1114         {
1115           pp_c_expression (ppi, TREE_OPERAND (e, 0));
1116           pp_separate_with (ppi, ',');
1117           pp_c_expression (ppi, TREE_OPERAND (e, 1));
1118         }
1119
1120       pp_c_right_brace (ppi);
1121       break;
1122
1123     case COMPOUND_LITERAL_EXPR:
1124       e = DECL_INITIAL (e);
1125       /* Fall through.  */
1126     case CONSTRUCTOR:
1127       pp_initializer (ppi, e);
1128       break;
1129
1130     case VA_ARG_EXPR:
1131       pp_c_identifier (ppi, "__builtin_va_arg");
1132       pp_c_left_paren (ppi);
1133       pp_assignment_expression (ppi, TREE_OPERAND (e, 0));
1134       pp_separate_with (ppi, ',');
1135       pp_type_id (ppi, TREE_TYPE (e));
1136       pp_c_right_paren (ppi);
1137       break;
1138
1139     case ADDR_EXPR:
1140       if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
1141         {
1142           pp_c_id_expression (ppi, TREE_OPERAND (e, 0));
1143           break;
1144         }
1145       /* else fall through.   */
1146
1147     default:
1148       pp_primary_expression (ppi, e);
1149       break;
1150     }
1151 }
1152
1153 /* Print out an expression-list; E is expected to be a TREE_LIST  */
1154 void
1155 pp_c_expression_list (c_pretty_printer ppi, tree e)
1156 {
1157   for (; e != NULL_TREE; e = TREE_CHAIN (e))
1158     {
1159       pp_c_assignment_expression (ppi, TREE_VALUE (e));
1160       if (TREE_CHAIN (e))
1161         pp_separate_with (ppi, ',');
1162     }
1163 }
1164
1165 /* unary-expression:
1166       postfix-expression
1167       ++ cast-expression
1168       -- cast-expression
1169       unary-operator cast-expression
1170       sizeof unary-expression
1171       sizeof ( type-id )
1172
1173   unary-operator: one of
1174       * &  + - ! ~
1175
1176    GNU extensions.
1177    unary-expression:
1178       __alignof__ unary-expression
1179       __alignof__ ( type-id )
1180       __real__ unary-expression
1181       __imag__ unary-expression  */
1182 void
1183 pp_c_unary_expression (c_pretty_printer ppi, tree e)
1184 {
1185   enum tree_code code = TREE_CODE (e);
1186   switch (code)
1187     {
1188     case PREINCREMENT_EXPR:
1189     case PREDECREMENT_EXPR:
1190       pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
1191       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
1192       break;
1193
1194     case ADDR_EXPR:
1195     case INDIRECT_REF:
1196     case NEGATE_EXPR:
1197     case BIT_NOT_EXPR:
1198     case TRUTH_NOT_EXPR:
1199     case CONJ_EXPR:
1200       /* String literal are used by address.  */
1201       if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
1202         pp_ampersand (ppi);
1203       else if (code == INDIRECT_REF)
1204         pp_c_star (ppi);
1205       else if (code == NEGATE_EXPR)
1206         pp_minus (ppi);
1207       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
1208         pp_complement (ppi);
1209       else if (code == TRUTH_NOT_EXPR)
1210         pp_exclamation (ppi);
1211       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
1212       break;
1213
1214     case SIZEOF_EXPR:
1215     case ALIGNOF_EXPR:
1216       pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
1217       pp_c_whitespace (ppi);
1218       if (TYPE_P (TREE_OPERAND (e, 0)))
1219         {
1220           pp_c_left_paren (ppi);
1221           pp_type_id (ppi, TREE_OPERAND (e, 0));
1222           pp_c_right_paren (ppi);
1223         }
1224       else
1225         pp_unary_expression (ppi, TREE_OPERAND (e, 0));
1226       break;
1227
1228     case REALPART_EXPR:
1229     case IMAGPART_EXPR:
1230       pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__");
1231       pp_c_whitespace (ppi);
1232       pp_unary_expression (ppi, TREE_OPERAND (e, 0));
1233       break;
1234
1235     default:
1236       pp_postfix_expression (ppi, e);
1237       break;
1238     }
1239 }
1240
1241 void
1242 pp_c_cast_expression (c_pretty_printer ppi, tree e)
1243 {
1244   switch (TREE_CODE (e))
1245     {
1246     case FLOAT_EXPR:
1247     case FIX_TRUNC_EXPR:
1248     case CONVERT_EXPR:
1249       pp_c_left_paren (ppi);
1250       pp_type_id (ppi, TREE_TYPE (e));
1251       pp_c_right_paren (ppi);
1252       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
1253       break;
1254
1255     default:
1256       pp_unary_expression (ppi, e);
1257     }
1258 }
1259
1260 static void
1261 pp_c_multiplicative_expression (c_pretty_printer ppi, tree e)
1262 {
1263   enum tree_code code = TREE_CODE (e);
1264   switch (code)
1265     {
1266     case MULT_EXPR:
1267     case TRUNC_DIV_EXPR:
1268     case TRUNC_MOD_EXPR:
1269       pp_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
1270       pp_c_whitespace (ppi);
1271       if (code == MULT_EXPR)
1272         pp_c_star (ppi);
1273       else if (code == TRUNC_DIV_EXPR)
1274         pp_slash (ppi);
1275       else
1276         pp_modulo (ppi);
1277       pp_c_whitespace (ppi);
1278       pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
1279       break;
1280
1281     default:
1282       pp_c_cast_expression (ppi, e);
1283       break;
1284     }
1285 }
1286
1287 static inline void
1288 pp_c_additive_expression (c_pretty_printer ppi, tree e)
1289 {
1290   enum tree_code code = TREE_CODE (e);
1291   switch (code)
1292     {
1293     case PLUS_EXPR:
1294     case MINUS_EXPR:
1295       pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
1296       pp_c_whitespace (ppi);
1297       if (code == PLUS_EXPR)
1298         pp_plus (ppi);
1299       else
1300         pp_minus (ppi);
1301       pp_c_whitespace (ppi);
1302       pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
1303       break;
1304
1305     default:
1306       pp_multiplicative_expression (ppi, e);
1307       break;
1308     }
1309 }
1310
1311 static inline void
1312 pp_c_shift_expression (c_pretty_printer ppi, tree e)
1313 {
1314   enum tree_code code = TREE_CODE (e);
1315   switch (code)
1316     {
1317     case LSHIFT_EXPR:
1318     case RSHIFT_EXPR:
1319       pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
1320       pp_c_whitespace (ppi);
1321       pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
1322       pp_c_whitespace (ppi);
1323       pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
1324       break;
1325
1326     default:
1327       pp_c_additive_expression (ppi, e);
1328     }
1329 }
1330
1331 static void
1332 pp_c_relational_expression (c_pretty_printer ppi, tree e)
1333 {
1334   enum tree_code code = TREE_CODE (e);
1335   switch (code)
1336     {
1337     case LT_EXPR:
1338     case GT_EXPR:
1339     case LE_EXPR:
1340     case GE_EXPR:
1341       pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
1342       pp_c_whitespace (ppi);
1343       if (code == LT_EXPR)
1344         pp_less (ppi);
1345       else if (code == GT_EXPR)
1346         pp_greater (ppi);
1347       else if (code == LE_EXPR)
1348         pp_identifier (ppi, "<=");
1349       else if (code == GE_EXPR)
1350         pp_identifier (ppi, ">=");
1351       pp_c_whitespace (ppi);
1352       pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
1353       break;
1354
1355     default:
1356       pp_c_shift_expression (ppi, e);
1357       break;
1358     }
1359 }
1360
1361 static inline void
1362 pp_c_equality_expression (c_pretty_printer ppi, tree e)
1363 {
1364   enum tree_code code = TREE_CODE (e);
1365   switch (code)
1366     {
1367     case EQ_EXPR:
1368     case NE_EXPR:
1369       pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
1370       pp_c_whitespace (ppi);
1371       pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
1372       pp_c_whitespace (ppi);
1373       pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
1374       break;
1375
1376     default:
1377       pp_c_relational_expression (ppi, e);
1378       break;
1379     }
1380 }
1381
1382 static inline void
1383 pp_c_and_expression (c_pretty_printer ppi, tree e)
1384 {
1385   if (TREE_CODE (e) == BIT_AND_EXPR)
1386     {
1387       pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
1388       pp_c_whitespace (ppi);
1389       pp_ampersand (ppi);
1390       pp_c_whitespace (ppi);
1391       pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
1392     }
1393   else
1394     pp_c_equality_expression (ppi, e);
1395 }
1396
1397 static inline void
1398 pp_c_exclusive_or_expression (c_pretty_printer ppi, tree e)
1399 {
1400   if (TREE_CODE (e) == BIT_XOR_EXPR)
1401     {
1402       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
1403       pp_c_maybe_whitespace (ppi);
1404       pp_carret (ppi);
1405       pp_c_whitespace (ppi);
1406       pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
1407     }
1408   else
1409     pp_c_and_expression (ppi, e);
1410 }
1411
1412 static inline void
1413 pp_c_inclusive_or_expression (c_pretty_printer ppi, tree e)
1414 {
1415   if (TREE_CODE (e) == BIT_IOR_EXPR)
1416     {
1417       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
1418       pp_c_whitespace (ppi);
1419       pp_bar (ppi);
1420       pp_c_whitespace (ppi);
1421       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
1422     }
1423   else
1424     pp_c_exclusive_or_expression (ppi, e);
1425 }
1426
1427 static inline void
1428 pp_c_logical_and_expression (c_pretty_printer ppi, tree e)
1429 {
1430   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
1431     {
1432       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
1433       pp_c_whitespace (ppi);
1434       pp_identifier (ppi, "&&");
1435       pp_c_whitespace (ppi);
1436       pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
1437     }
1438   else
1439     pp_c_inclusive_or_expression (ppi, e);
1440 }
1441
1442 void
1443 pp_c_logical_or_expression (c_pretty_printer ppi, tree e)
1444 {
1445   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
1446     {
1447       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
1448       pp_c_whitespace (ppi);
1449       pp_identifier (ppi, "||");
1450       pp_c_whitespace (ppi);
1451       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
1452     }
1453   else
1454     pp_c_logical_and_expression (ppi, e);
1455 }
1456
1457 static void
1458 pp_c_conditional_expression (c_pretty_printer ppi, tree e)
1459 {
1460   if (TREE_CODE (e) == COND_EXPR)
1461     {
1462       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
1463       pp_c_whitespace (ppi);
1464       pp_question (ppi);
1465       pp_c_whitespace (ppi);
1466       pp_c_expression (ppi, TREE_OPERAND (e, 1));
1467       pp_c_maybe_whitespace (ppi);
1468       pp_colon (ppi);
1469       pp_c_whitespace (ppi);
1470       pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
1471     }
1472   else
1473     pp_c_logical_or_expression (ppi, e);
1474 }
1475
1476
1477 /* Pretty-print a C assignment-expression.  */
1478 static void
1479 pp_c_assignment_expression (c_pretty_printer ppi, tree e)
1480 {
1481   if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
1482     {
1483       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
1484       pp_c_maybe_whitespace (ppi);
1485       pp_equal (ppi);
1486       pp_space (ppi);
1487       pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
1488     }
1489   else
1490     pp_c_conditional_expression (ppi, e);
1491 }
1492
1493 /* Pretty-print an expression.  */
1494 void
1495 pp_c_expression (c_pretty_printer ppi, tree e)
1496 {
1497   switch (TREE_CODE (e))
1498     {
1499     case INTEGER_CST:
1500       pp_c_integer_constant (ppi, e);
1501       break;
1502
1503     case REAL_CST:
1504       pp_c_floating_constant (ppi, e);
1505       break;
1506
1507     case STRING_CST:
1508       pp_c_string_literal (ppi, e);
1509       break;
1510
1511     case FUNCTION_DECL:
1512     case VAR_DECL:
1513     case CONST_DECL:
1514     case PARM_DECL:
1515     case RESULT_DECL:
1516     case FIELD_DECL:
1517     case LABEL_DECL:
1518     case ERROR_MARK:
1519     case TARGET_EXPR:
1520     case STMT_EXPR:
1521       pp_primary_expression (ppi, e);
1522       break;
1523
1524     case POSTINCREMENT_EXPR:
1525     case POSTDECREMENT_EXPR:
1526     case ARROW_EXPR:
1527     case ARRAY_REF:
1528     case CALL_EXPR:
1529     case COMPONENT_REF:
1530     case COMPLEX_CST:
1531     case VECTOR_CST:
1532     case ABS_EXPR:
1533     case FFS_EXPR:
1534     case CONSTRUCTOR:
1535     case COMPOUND_LITERAL_EXPR:
1536     case COMPLEX_EXPR:
1537     case VA_ARG_EXPR:
1538       pp_postfix_expression (ppi, e);
1539       break;
1540
1541     case CONJ_EXPR:
1542     case ADDR_EXPR:
1543     case INDIRECT_REF:
1544     case NEGATE_EXPR:
1545     case BIT_NOT_EXPR:
1546     case TRUTH_NOT_EXPR:
1547     case PREINCREMENT_EXPR:
1548     case PREDECREMENT_EXPR:
1549     case SIZEOF_EXPR:
1550     case ALIGNOF_EXPR:
1551     case REALPART_EXPR:
1552     case IMAGPART_EXPR:
1553       pp_c_unary_expression (ppi, e);
1554       break;
1555
1556     case FLOAT_EXPR:
1557     case FIX_TRUNC_EXPR:
1558     case CONVERT_EXPR:
1559       pp_c_cast_expression (ppi, e);
1560       break;
1561
1562     case MULT_EXPR:
1563     case TRUNC_MOD_EXPR:
1564     case TRUNC_DIV_EXPR:
1565       pp_multiplicative_expression (ppi, e);
1566       break;
1567
1568     case LSHIFT_EXPR:
1569     case RSHIFT_EXPR:
1570       pp_c_shift_expression (ppi, e);
1571       break;
1572
1573     case LT_EXPR:
1574     case GT_EXPR:
1575     case LE_EXPR:
1576     case GE_EXPR:
1577       pp_c_relational_expression (ppi, e);
1578       break;
1579
1580     case BIT_AND_EXPR:
1581       pp_c_and_expression (ppi, e);
1582       break;
1583
1584     case BIT_XOR_EXPR:
1585       pp_c_exclusive_or_expression (ppi, e);
1586       break;
1587
1588     case BIT_IOR_EXPR:
1589       pp_c_inclusive_or_expression (ppi, e);
1590       break;
1591
1592     case TRUTH_ANDIF_EXPR:
1593       pp_c_logical_and_expression (ppi, e);
1594       break;
1595
1596     case TRUTH_ORIF_EXPR:
1597       pp_c_logical_or_expression (ppi, e);
1598       break;
1599
1600     case EQ_EXPR:
1601     case NE_EXPR:
1602       pp_c_equality_expression (ppi, e);
1603       break;
1604
1605     case COND_EXPR:
1606       pp_conditional_expression (ppi, e);
1607       break;
1608
1609     case PLUS_EXPR:
1610     case MINUS_EXPR:
1611       pp_c_additive_expression (ppi, e);
1612       break;
1613
1614     case MODIFY_EXPR:
1615     case INIT_EXPR:
1616       pp_assignment_expression (ppi, e);
1617       break;
1618
1619     case COMPOUND_EXPR:
1620       pp_c_left_paren (ppi);
1621       pp_c_expression (ppi, TREE_OPERAND (e, 0));
1622       pp_separate_with (ppi, ',');
1623       pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
1624       pp_c_right_paren (ppi);
1625       break;
1626
1627     case NOP_EXPR:
1628     case NON_LVALUE_EXPR:
1629     case SAVE_EXPR:
1630     case UNSAVE_EXPR:
1631       pp_c_expression (ppi, TREE_OPERAND (e, 0));
1632       break;
1633
1634     default:
1635       pp_unsupported_tree (ppi, e);
1636       break;
1637     }
1638 }
1639
1640
1641 \f
1642 /* Statements.  */
1643 void
1644 pp_c_statement (c_pretty_printer ppi, tree stmt)
1645 {
1646   enum tree_code code;
1647
1648   if (stmt == NULL)
1649     return;
1650
1651   code = TREE_CODE (stmt);
1652   switch (code)
1653     {
1654     case LABEL_STMT:
1655     case CASE_LABEL:
1656       if (pp_needs_newline (ppi))
1657         pp_newline_and_indent (ppi, -3);
1658       else
1659         pp_indentation (ppi) -= 3;
1660       if (code == LABEL_STMT)
1661         pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt)));
1662       else if (code == CASE_LABEL)
1663         {
1664           if (CASE_LOW (stmt) == NULL_TREE)
1665             pp_identifier (ppi, "default");
1666           else
1667             {
1668               pp_c_identifier (ppi, "case");
1669               pp_c_whitespace (ppi);
1670               pp_conditional_expression (ppi, CASE_LOW (stmt));
1671               if (CASE_HIGH (stmt))
1672                 {
1673                   pp_identifier (ppi, "...");
1674                   pp_conditional_expression (ppi, CASE_HIGH (stmt));
1675                 }
1676             }
1677         }
1678       pp_colon (ppi);
1679       pp_indentation (ppi) += 3;
1680       pp_needs_newline (ppi) = true;
1681       break;
1682
1683     case COMPOUND_STMT:
1684       if (pp_needs_newline (ppi))
1685         pp_newline_and_indent (ppi, 0);
1686       pp_c_left_brace (ppi);
1687       pp_newline_and_indent (ppi, 3);
1688       for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt))
1689         pp_c_statement (ppi, stmt);
1690       pp_newline_and_indent (ppi, -3);
1691       pp_c_right_brace (ppi);
1692       pp_needs_newline (ppi) = true;
1693       break;
1694
1695     case EXPR_STMT:
1696     case CLEANUP_STMT:
1697       if (pp_needs_newline (ppi))
1698         pp_newline_and_indent (ppi, 0);
1699       {
1700         tree e = code == EXPR_STMT
1701           ? EXPR_STMT_EXPR (stmt)
1702           : CLEANUP_EXPR (stmt);
1703         if (e)
1704           pp_c_expression (ppi, e);
1705       }
1706       pp_c_semicolon (ppi);
1707       pp_needs_newline (ppi) = true;
1708       break;
1709
1710     case IF_STMT:
1711       if (pp_needs_newline (ppi))
1712         pp_newline_and_indent (ppi, 0);
1713       pp_c_identifier (ppi, "if");
1714       pp_c_whitespace (ppi);
1715       pp_c_left_paren (ppi);
1716       pp_c_expression (ppi, IF_COND (stmt));
1717       pp_c_right_paren (ppi);
1718       pp_newline_and_indent (ppi, 3);
1719       pp_statement (ppi, THEN_CLAUSE (stmt));
1720       pp_newline_and_indent (ppi, -3);
1721       if (ELSE_CLAUSE (stmt))
1722         {
1723           tree else_clause = ELSE_CLAUSE (stmt);
1724           pp_c_identifier (ppi, "else");
1725           if (TREE_CODE (else_clause) == IF_STMT)
1726             pp_c_whitespace (ppi);
1727           else
1728             pp_newline_and_indent (ppi, 3);
1729           pp_statement (ppi, else_clause);
1730           if (TREE_CODE (else_clause) != IF_STMT)
1731             pp_newline_and_indent (ppi, -3);
1732         }
1733       break;
1734
1735     case SWITCH_STMT:
1736       if (pp_needs_newline (ppi))
1737         pp_newline_and_indent (ppi, 0);
1738       pp_c_identifier (ppi, "switch");
1739       pp_space (ppi);
1740       pp_c_left_paren (ppi);
1741       pp_c_expression (ppi, SWITCH_COND (stmt));
1742       pp_c_right_paren (ppi);
1743       pp_indentation (ppi) += 3;
1744       pp_needs_newline (ppi) = true;
1745       pp_statement (ppi, SWITCH_BODY (stmt));
1746       pp_newline_and_indent (ppi, -3);
1747       break;
1748
1749     case WHILE_STMT:
1750       if (pp_needs_newline (ppi))
1751         pp_newline_and_indent (ppi, 0);
1752       pp_c_identifier (ppi, "while");
1753       pp_space (ppi);
1754       pp_c_left_paren (ppi);
1755       pp_c_expression (ppi, WHILE_COND (stmt));
1756       pp_c_right_paren (ppi);
1757       pp_newline_and_indent (ppi, 3);
1758       pp_statement (ppi, WHILE_BODY (stmt));
1759       pp_indentation (ppi) -= 3;
1760       pp_needs_newline (ppi) = true;
1761       break;
1762
1763     case DO_STMT:
1764       if (pp_needs_newline (ppi))
1765         pp_newline_and_indent (ppi, 0);
1766       pp_c_identifier (ppi, "do");
1767       pp_newline_and_indent (ppi, 3);
1768       pp_statement (ppi, DO_BODY (stmt));
1769       pp_newline_and_indent (ppi, -3);
1770       pp_c_identifier (ppi, "while");
1771       pp_space (ppi);
1772       pp_c_left_paren (ppi);
1773       pp_c_expression (ppi, DO_COND (stmt));
1774       pp_c_right_paren (ppi);
1775       pp_c_semicolon (ppi);
1776       pp_needs_newline (ppi) = true;
1777       break;
1778
1779     case FOR_STMT:
1780       if (pp_needs_newline (ppi))
1781         pp_newline_and_indent (ppi, 0);
1782       pp_c_identifier (ppi, "for");
1783       pp_space (ppi);
1784       pp_c_left_paren (ppi);
1785       if (FOR_INIT_STMT (stmt))
1786         pp_statement (ppi, FOR_INIT_STMT (stmt));
1787       else
1788         pp_c_semicolon (ppi);
1789       pp_needs_newline (ppi) = false;
1790       pp_c_whitespace (ppi);
1791       if (FOR_COND (stmt))
1792         pp_c_expression (ppi, FOR_COND (stmt));
1793       pp_c_semicolon (ppi);
1794       pp_needs_newline (ppi) = false;
1795       pp_c_whitespace (ppi);
1796       if (FOR_EXPR (stmt))
1797         pp_c_expression (ppi, FOR_EXPR (stmt));
1798       pp_c_right_paren (ppi);
1799       pp_newline_and_indent (ppi, 3);
1800       pp_statement (ppi, FOR_BODY (stmt));
1801       pp_indentation (ppi) -= 3;
1802       pp_needs_newline (ppi) = true;
1803       break;
1804
1805     case BREAK_STMT:
1806     case CONTINUE_STMT:
1807       if (pp_needs_newline (ppi))
1808         pp_newline_and_indent (ppi, 0);
1809       pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue");
1810       pp_c_semicolon (ppi);
1811       pp_needs_newline (ppi) = true;
1812       break;
1813
1814     case RETURN_STMT:
1815     case GOTO_STMT:
1816       {
1817         tree e = code == RETURN_STMT
1818           ? RETURN_STMT_EXPR (stmt)
1819           : GOTO_DESTINATION (stmt);
1820         if (pp_needs_newline (ppi))
1821           pp_newline_and_indent (ppi, 0);
1822         pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto");
1823         if (e)
1824           pp_c_expression (ppi, e);
1825         pp_c_semicolon (ppi);
1826         pp_needs_newline (ppi) = true;
1827       }
1828       break;
1829
1830     case SCOPE_STMT:
1831       if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt))
1832         {
1833           int i = 0;
1834           if (pp_needs_newline (ppi))
1835             pp_newline_and_indent (ppi, 0);
1836           if (SCOPE_BEGIN_P (stmt))
1837             {
1838               pp_left_brace (ppi);
1839               i = 3;
1840             }
1841           else if (SCOPE_END_P (stmt))
1842             {
1843               pp_right_brace (ppi);
1844               i = -3;
1845             }
1846           pp_indentation (ppi) += i;
1847           pp_needs_newline (ppi) = true;
1848         }
1849       break;
1850
1851     case DECL_STMT:
1852       if (pp_needs_newline (ppi))
1853         pp_newline_and_indent (ppi, 0);
1854       pp_declaration (ppi, DECL_STMT_DECL (stmt));
1855       pp_c_semicolon (ppi);
1856       pp_needs_newline (ppi) = true;
1857       break;
1858
1859     case ASM_STMT:
1860       {
1861         bool has_volatile_p = ASM_VOLATILE_P (stmt);
1862         bool is_extended = has_volatile_p || ASM_INPUTS (stmt)
1863           || ASM_OUTPUTS (stmt) || ASM_CLOBBERS (stmt);
1864         pp_c_identifier (ppi, is_extended ? "__asm__" : "asm");
1865         if (has_volatile_p)
1866           pp_c_identifier (ppi, "__volatile__");
1867         pp_space (ppi);
1868         pp_c_left_paren (ppi);
1869         pp_c_string_literal (ppi, ASM_STRING (stmt));
1870         if (is_extended)
1871           {
1872             pp_space (ppi);
1873             pp_separate_with (ppi, ':');
1874             if (ASM_OUTPUTS (stmt))
1875               pp_c_expression (ppi, ASM_OUTPUTS (stmt));
1876             pp_space (ppi);
1877             pp_separate_with (ppi, ':');
1878             if (ASM_INPUTS (stmt))
1879               pp_c_expression (ppi, ASM_INPUTS (stmt));
1880             pp_space (ppi);
1881             pp_separate_with (ppi, ':');
1882             if (ASM_CLOBBERS (stmt))
1883               pp_c_expression (ppi, ASM_CLOBBERS (stmt));
1884           }
1885         pp_c_right_paren (ppi);
1886         pp_newline (ppi);
1887       }
1888       break;
1889
1890     case FILE_STMT:
1891       pp_c_identifier (ppi, "__FILE__");
1892       pp_space (ppi);
1893       pp_equal (ppi);
1894       pp_c_whitespace (ppi);
1895       pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt));
1896       pp_c_semicolon (ppi);
1897       pp_needs_newline (ppi) = true;
1898       break;
1899
1900     default:
1901       pp_unsupported_tree (ppi, stmt);
1902     }
1903
1904 }
1905
1906 \f
1907 /* Initialize the PRETTY-PRINTER for handling C codes.  */
1908 void
1909 pp_c_pretty_printer_init (c_pretty_printer pp)
1910 {
1911   pp->offset_list               = 0;
1912
1913   pp->declaration               = pp_c_declaration;
1914   pp->declaration_specifiers    = pp_c_declaration_specifiers;
1915   pp->declarator                = pp_c_declarator;
1916   pp->direct_declarator         = pp_c_direct_declarator;
1917   pp->type_specifier            = pp_c_simple_type_specifier;
1918   pp->abstract_declarator       = pp_c_abstract_declarator;
1919   pp->parameter_declaration     = pp_c_parameter_declaration;
1920   pp->type_id                   = pp_c_type_id;
1921   pp->function_specifier        = pp_c_function_specifier;
1922   pp->storage_class_specifier   = pp_c_storage_class_specifier;
1923
1924   pp->statement                 = pp_c_statement;
1925
1926   pp->id_expression             = pp_c_id_expression;
1927   pp->primary_expression        = pp_c_primary_expression;
1928   pp->postfix_expression        = pp_c_postfix_expression;
1929   pp->unary_expression          = pp_c_unary_expression;
1930   pp->initializer               = pp_c_initializer;
1931   pp->multiplicative_expression = pp_c_multiplicative_expression;
1932   pp->conditional_expression    = pp_c_conditional_expression;
1933   pp->assignment_expression     = pp_c_assignment_expression;
1934 }