gcc/c-pretty-print.c

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