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 ABS_EXPR:
1255       pp_c_identifier (pp, "__builtin_abs");
1256       pp_c_left_paren (pp);
1257       pp_expression (pp, TREE_OPERAND (e, 0));
1258       pp_c_right_paren (pp);
1259       break;
1260
1261     case COMPONENT_REF:
1262       {
1263         tree object = TREE_OPERAND (e, 0);
1264         if (TREE_CODE (object) == INDIRECT_REF)
1265           {
1266             pp_postfix_expression (pp, TREE_OPERAND (object, 0));
1267             pp_c_arrow (pp);
1268           }
1269         else
1270           {
1271             pp_postfix_expression (pp, object);
1272             pp_c_dot (pp);
1273           }
1274         pp_expression (pp, TREE_OPERAND (e, 1));
1275       }
1276       break;
1277
1278     case COMPLEX_CST:
1279     case VECTOR_CST:
1280     case COMPLEX_EXPR:
1281       pp_c_compound_literal (pp, e);
1282       break;
1283
1284     case COMPOUND_LITERAL_EXPR:
1285       e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
1286       /* Fall through.  */
1287     case CONSTRUCTOR:
1288       pp_initializer (pp, e);
1289       break;
1290
1291     case VA_ARG_EXPR:
1292       pp_c_identifier (pp, "__builtin_va_arg");
1293       pp_c_left_paren (pp);
1294       pp_assignment_expression (pp, TREE_OPERAND (e, 0));
1295       pp_separate_with (pp, ',');
1296       pp_type_id (pp, TREE_TYPE (e));
1297       pp_c_right_paren (pp);
1298       break;
1299
1300     case ADDR_EXPR:
1301       if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
1302         {
1303           pp_c_id_expression (pp, TREE_OPERAND (e, 0));
1304           break;
1305         }
1306       /* else fall through.  */
1307
1308     default:
1309       pp_primary_expression (pp, e);
1310       break;
1311     }
1312 }
1313
1314 /* Print out an expression-list; E is expected to be a TREE_LIST.  */
1315
1316 void
1317 pp_c_expression_list (c_pretty_printer *pp, tree e)
1318 {
1319   for (; e != NULL_TREE; e = TREE_CHAIN (e))
1320     {
1321       pp_expression (pp, TREE_VALUE (e));
1322       if (TREE_CHAIN (e))
1323         pp_separate_with (pp, ',');
1324     }
1325 }
1326
1327 /* Print out an expression-list in parens, as in a function call.  */
1328
1329 void
1330 pp_c_call_argument_list (c_pretty_printer *pp, tree t)
1331 {
1332   pp_c_left_paren (pp);
1333   if (t && TREE_CODE (t) == TREE_LIST)
1334     pp_c_expression_list (pp, t);
1335   pp_c_right_paren (pp);
1336 }
1337
1338 /* unary-expression:
1339       postfix-expression
1340       ++ cast-expression
1341       -- cast-expression
1342       unary-operator cast-expression
1343       sizeof unary-expression
1344       sizeof ( type-id )
1345
1346   unary-operator: one of
1347       * &  + - ! ~
1348
1349    GNU extensions.
1350    unary-expression:
1351       __alignof__ unary-expression
1352       __alignof__ ( type-id )
1353       __real__ unary-expression
1354       __imag__ unary-expression  */
1355
1356 void
1357 pp_c_unary_expression (c_pretty_printer *pp, tree e)
1358 {
1359   enum tree_code code = TREE_CODE (e);
1360   switch (code)
1361     {
1362     case PREINCREMENT_EXPR:
1363     case PREDECREMENT_EXPR:
1364       pp_identifier (pp, code == PREINCREMENT_EXPR ? "++" : "--");
1365       pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1366       break;
1367
1368     case ADDR_EXPR:
1369     case INDIRECT_REF:
1370     case NEGATE_EXPR:
1371     case BIT_NOT_EXPR:
1372     case TRUTH_NOT_EXPR:
1373     case CONJ_EXPR:
1374       /* String literal are used by address.  */
1375       if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
1376         pp_ampersand (pp);
1377       else if (code == INDIRECT_REF)
1378         pp_c_star (pp);
1379       else if (code == NEGATE_EXPR)
1380         pp_minus (pp);
1381       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
1382         pp_complement (pp);
1383       else if (code == TRUTH_NOT_EXPR)
1384         pp_exclamation (pp);
1385       pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1386       break;
1387
1388     case SIZEOF_EXPR:
1389     case ALIGNOF_EXPR:
1390       pp_c_identifier (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
1391       pp_c_whitespace (pp);
1392       if (TYPE_P (TREE_OPERAND (e, 0)))
1393         pp_c_type_cast (pp, TREE_OPERAND (e, 0));
1394       else
1395         pp_unary_expression (pp, TREE_OPERAND (e, 0));
1396       break;
1397
1398     case REALPART_EXPR:
1399     case IMAGPART_EXPR:
1400       pp_c_identifier (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
1401       pp_c_whitespace (pp);
1402       pp_unary_expression (pp, TREE_OPERAND (e, 0));
1403       break;
1404
1405     default:
1406       pp_postfix_expression (pp, e);
1407       break;
1408     }
1409 }
1410
1411 /* cast-expression:
1412       unary-expression
1413       ( type-name ) cast-expression  */
1414
1415 void
1416 pp_c_cast_expression (c_pretty_printer *pp, tree e)
1417 {
1418   switch (TREE_CODE (e))
1419     {
1420     case FLOAT_EXPR:
1421     case FIX_TRUNC_EXPR:
1422     case CONVERT_EXPR:
1423       pp_c_type_cast (pp, TREE_TYPE (e));
1424       pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1425       break;
1426
1427     default:
1428       pp_unary_expression (pp, e);
1429     }
1430 }
1431
1432 /* multiplicative-expression:
1433       cast-expression
1434       multiplicative-expression * cast-expression
1435       multiplicative-expression / cast-expression
1436       multiplicative-expression % cast-expression   */
1437
1438 static void
1439 pp_c_multiplicative_expression (c_pretty_printer *pp, tree e)
1440 {
1441   enum tree_code code = TREE_CODE (e);
1442   switch (code)
1443     {
1444     case MULT_EXPR:
1445     case TRUNC_DIV_EXPR:
1446     case TRUNC_MOD_EXPR:
1447       pp_multiplicative_expression (pp, TREE_OPERAND (e, 0));
1448       pp_c_whitespace (pp);
1449       if (code == MULT_EXPR)
1450         pp_c_star (pp);
1451       else if (code == TRUNC_DIV_EXPR)
1452         pp_slash (pp);
1453       else
1454         pp_modulo (pp);
1455       pp_c_whitespace (pp);
1456       pp_c_cast_expression (pp, TREE_OPERAND (e, 1));
1457       break;
1458
1459     default:
1460       pp_c_cast_expression (pp, e);
1461       break;
1462     }
1463 }
1464
1465 /* additive-expression:
1466       multiplicative-expression
1467       additive-expression + multiplicative-expression
1468       additive-expression - multiplicative-expression   */
1469
1470 static void
1471 pp_c_additive_expression (c_pretty_printer *pp, tree e)
1472 {
1473   enum tree_code code = TREE_CODE (e);
1474   switch (code)
1475     {
1476     case PLUS_EXPR:
1477     case MINUS_EXPR:
1478       pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
1479       pp_c_whitespace (pp);
1480       if (code == PLUS_EXPR)
1481         pp_plus (pp);
1482       else
1483         pp_minus (pp);
1484       pp_c_whitespace (pp);
1485       pp_multiplicative_expression (pp, TREE_OPERAND (e, 1));
1486       break;
1487
1488     default:
1489       pp_multiplicative_expression (pp, e);
1490       break;
1491     }
1492 }
1493
1494 /* additive-expression:
1495       additive-expression
1496       shift-expression << additive-expression
1497       shift-expression >> additive-expression   */
1498
1499 static void
1500 pp_c_shift_expression (c_pretty_printer *pp, tree e)
1501 {
1502   enum tree_code code = TREE_CODE (e);
1503   switch (code)
1504     {
1505     case LSHIFT_EXPR:
1506     case RSHIFT_EXPR:
1507       pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
1508       pp_c_whitespace (pp);
1509       pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>");
1510       pp_c_whitespace (pp);
1511       pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
1512       break;
1513
1514     default:
1515       pp_c_additive_expression (pp, e);
1516     }
1517 }
1518
1519 /* relational-expression:
1520       shift-expression
1521       relational-expression < shift-expression
1522       relational-expression > shift-expression
1523       relational-expression <= shift-expression
1524       relational-expression >= shift-expression   */
1525
1526 static void
1527 pp_c_relational_expression (c_pretty_printer *pp, tree e)
1528 {
1529   enum tree_code code = TREE_CODE (e);
1530   switch (code)
1531     {
1532     case LT_EXPR:
1533     case GT_EXPR:
1534     case LE_EXPR:
1535     case GE_EXPR:
1536       pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
1537       pp_c_whitespace (pp);
1538       if (code == LT_EXPR)
1539         pp_less (pp);
1540       else if (code == GT_EXPR)
1541         pp_greater (pp);
1542       else if (code == LE_EXPR)
1543         pp_identifier (pp, "<=");
1544       else if (code == GE_EXPR)
1545         pp_identifier (pp, ">=");
1546       pp_c_whitespace (pp);
1547       pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
1548       break;
1549
1550     default:
1551       pp_c_shift_expression (pp, e);
1552       break;
1553     }
1554 }
1555
1556 /* equality-expression:
1557       relational-expression
1558       equality-expression == relational-expression
1559       equality-equality != relational-expression  */
1560
1561 static void
1562 pp_c_equality_expression (c_pretty_printer *pp, tree e)
1563 {
1564   enum tree_code code = TREE_CODE (e);
1565   switch (code)
1566     {
1567     case EQ_EXPR:
1568     case NE_EXPR:
1569       pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
1570       pp_c_whitespace (pp);
1571       pp_identifier (pp, code == EQ_EXPR ? "==" : "!=");
1572       pp_c_whitespace (pp);
1573       pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
1574       break;
1575
1576     default:
1577       pp_c_relational_expression (pp, e);
1578       break;
1579     }
1580 }
1581
1582 /* AND-expression:
1583       equality-expression
1584       AND-expression & equality-equality   */
1585
1586 static void
1587 pp_c_and_expression (c_pretty_printer *pp, tree e)
1588 {
1589   if (TREE_CODE (e) == BIT_AND_EXPR)
1590     {
1591       pp_c_and_expression (pp, TREE_OPERAND (e, 0));
1592       pp_c_whitespace (pp);
1593       pp_ampersand (pp);
1594       pp_c_whitespace (pp);
1595       pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
1596     }
1597   else
1598     pp_c_equality_expression (pp, e);
1599 }
1600
1601 /* exclusive-OR-expression:
1602      AND-expression
1603      exclusive-OR-expression ^ AND-expression  */
1604
1605 static void
1606 pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
1607 {
1608   if (TREE_CODE (e) == BIT_XOR_EXPR)
1609     {
1610       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1611       pp_c_maybe_whitespace (pp);
1612       pp_carret (pp);
1613       pp_c_whitespace (pp);
1614       pp_c_and_expression (pp, TREE_OPERAND (e, 1));
1615     }
1616   else
1617     pp_c_and_expression (pp, e);
1618 }
1619
1620 /* inclusive-OR-expression:
1621      exclusive-OR-expression
1622      inclusive-OR-expression | exclusive-OR-expression  */
1623
1624 static void
1625 pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
1626 {
1627   if (TREE_CODE (e) == BIT_IOR_EXPR)
1628     {
1629       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1630       pp_c_whitespace (pp);
1631       pp_bar (pp);
1632       pp_c_whitespace (pp);
1633       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
1634     }
1635   else
1636     pp_c_exclusive_or_expression (pp, e);
1637 }
1638
1639 /* logical-AND-expression:
1640       inclusive-OR-expression
1641       logical-AND-expression && inclusive-OR-expression  */
1642
1643 static void
1644 pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
1645 {
1646   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
1647     {
1648       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
1649       pp_c_whitespace (pp);
1650       pp_identifier (pp, "&&");
1651       pp_c_whitespace (pp);
1652       pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
1653     }
1654   else
1655     pp_c_inclusive_or_expression (pp, e);
1656 }
1657
1658 /* logical-OR-expression:
1659       logical-AND-expression
1660       logical-OR-expression || logical-AND-expression  */
1661
1662 void
1663 pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
1664 {
1665   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
1666     {
1667       pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1668       pp_c_whitespace (pp);
1669       pp_identifier (pp, "||");
1670       pp_c_whitespace (pp);
1671       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
1672     }
1673   else
1674     pp_c_logical_and_expression (pp, e);
1675 }
1676
1677 /* conditional-expression:
1678       logical-OR-expression
1679       logical-OR-expression ? expression : conditional-expression  */
1680
1681 static void
1682 pp_c_conditional_expression (c_pretty_printer *pp, tree e)
1683 {
1684   if (TREE_CODE (e) == COND_EXPR)
1685     {
1686       pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1687       pp_c_whitespace (pp);
1688       pp_question (pp);
1689       pp_c_whitespace (pp);
1690       pp_expression (pp, TREE_OPERAND (e, 1));
1691       pp_c_whitespace (pp);
1692       pp_colon (pp);
1693       pp_c_whitespace (pp);
1694       pp_c_conditional_expression (pp, TREE_OPERAND (e, 2));
1695     }
1696   else
1697     pp_c_logical_or_expression (pp, e);
1698 }
1699
1700
1701 /* assignment-expression:
1702       conditional-expression
1703       unary-expression assignment-operator  assignment-expression
1704
1705    assignment-expression: one of
1706       =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
1707
1708 static void
1709 pp_c_assignment_expression (c_pretty_printer *pp, tree e)
1710 {
1711   if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
1712     {
1713       pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1714       pp_c_whitespace (pp);
1715       pp_equal (pp);
1716       pp_space (pp);
1717       pp_c_expression (pp, TREE_OPERAND (e, 1));
1718     }
1719   else
1720     pp_c_conditional_expression (pp, e);
1721 }
1722
1723 /* expression:
1724        assignment-expression
1725        expression , assignment-expression
1726
1727   Implementation note:  instead of going through the usual recursion
1728   chain, I take the liberty of dispatching nodes to the appropriate
1729   functions.  This makes some redundancy, but it worths it. That also
1730   prevents a possible infinite recursion between pp_c_primary_expression ()
1731   and pp_c_expression ().  */
1732
1733 void
1734 pp_c_expression (c_pretty_printer *pp, tree e)
1735 {
1736   switch (TREE_CODE (e))
1737     {
1738     case INTEGER_CST:
1739       pp_c_integer_constant (pp, e);
1740       break;
1741
1742     case REAL_CST:
1743       pp_c_floating_constant (pp, e);
1744       break;
1745
1746     case STRING_CST:
1747       pp_c_string_literal (pp, e);
1748       break;
1749
1750     case IDENTIFIER_NODE:
1751     case FUNCTION_DECL:
1752     case VAR_DECL:
1753     case CONST_DECL:
1754     case PARM_DECL:
1755     case RESULT_DECL:
1756     case FIELD_DECL:
1757     case LABEL_DECL:
1758     case ERROR_MARK:
1759     case STMT_EXPR:
1760       pp_primary_expression (pp, e);
1761       break;
1762
1763     case POSTINCREMENT_EXPR:
1764     case POSTDECREMENT_EXPR:
1765     case ARROW_EXPR:
1766     case ARRAY_REF:
1767     case CALL_EXPR:
1768     case COMPONENT_REF:
1769     case COMPLEX_CST:
1770     case COMPLEX_EXPR:
1771     case VECTOR_CST:
1772     case ABS_EXPR:
1773     case CONSTRUCTOR:
1774     case COMPOUND_LITERAL_EXPR:
1775     case VA_ARG_EXPR:
1776       pp_postfix_expression (pp, e);
1777       break;
1778
1779     case CONJ_EXPR:
1780     case ADDR_EXPR:
1781     case INDIRECT_REF:
1782     case NEGATE_EXPR:
1783     case BIT_NOT_EXPR:
1784     case TRUTH_NOT_EXPR:
1785     case PREINCREMENT_EXPR:
1786     case PREDECREMENT_EXPR:
1787     case SIZEOF_EXPR:
1788     case ALIGNOF_EXPR:
1789     case REALPART_EXPR:
1790     case IMAGPART_EXPR:
1791       pp_c_unary_expression (pp, e);
1792       break;
1793
1794     case FLOAT_EXPR:
1795     case FIX_TRUNC_EXPR:
1796     case CONVERT_EXPR:
1797       pp_c_cast_expression (pp, e);
1798       break;
1799
1800     case MULT_EXPR:
1801     case TRUNC_MOD_EXPR:
1802     case TRUNC_DIV_EXPR:
1803       pp_multiplicative_expression (pp, e);
1804       break;
1805
1806     case LSHIFT_EXPR:
1807     case RSHIFT_EXPR:
1808       pp_c_shift_expression (pp, e);
1809       break;
1810
1811     case LT_EXPR:
1812     case GT_EXPR:
1813     case LE_EXPR:
1814     case GE_EXPR:
1815       pp_c_relational_expression (pp, e);
1816       break;
1817
1818     case BIT_AND_EXPR:
1819       pp_c_and_expression (pp, e);
1820       break;
1821
1822     case BIT_XOR_EXPR:
1823       pp_c_exclusive_or_expression (pp, e);
1824       break;
1825
1826     case BIT_IOR_EXPR:
1827       pp_c_inclusive_or_expression (pp, e);
1828       break;
1829
1830     case TRUTH_ANDIF_EXPR:
1831       pp_c_logical_and_expression (pp, e);
1832       break;
1833
1834     case TRUTH_ORIF_EXPR:
1835       pp_c_logical_or_expression (pp, e);
1836       break;
1837
1838     case EQ_EXPR:
1839     case NE_EXPR:
1840       pp_c_equality_expression (pp, e);
1841       break;
1842
1843     case COND_EXPR:
1844       pp_conditional_expression (pp, e);
1845       break;
1846
1847     case PLUS_EXPR:
1848     case MINUS_EXPR:
1849       pp_c_additive_expression (pp, e);
1850       break;
1851
1852     case MODIFY_EXPR:
1853     case INIT_EXPR:
1854       pp_assignment_expression (pp, e);
1855       break;
1856
1857     case COMPOUND_EXPR:
1858       pp_c_left_paren (pp);
1859       pp_expression (pp, TREE_OPERAND (e, 0));
1860       pp_separate_with (pp, ',');
1861       pp_assignment_expression (pp, TREE_OPERAND (e, 1));
1862       pp_c_right_paren (pp);
1863       break;
1864
1865     case NOP_EXPR:
1866     case NON_LVALUE_EXPR:
1867     case SAVE_EXPR:
1868     case UNSAVE_EXPR:
1869       pp_expression (pp, TREE_OPERAND (e, 0));
1870       break;
1871
1872     case TARGET_EXPR:
1873       pp_postfix_expression (pp, TREE_OPERAND (e, 1));
1874       break;
1875
1876     default:
1877       pp_unsupported_tree (pp, e);
1878       break;
1879     }
1880 }
1881
1882
1883 \f
1884 /* Statements.  */
1885
1886 /* statement:
1887       labeled-statement
1888       compound-statement
1889       expression-statement
1890       selection-statement
1891       iteration-statement
1892       jump-statement   */
1893
1894 void
1895 pp_c_statement (c_pretty_printer *pp, tree stmt)
1896 {
1897   enum tree_code code;
1898
1899   if (stmt == NULL)
1900     return;
1901
1902   if (pp_needs_newline (pp))
1903     pp_newline_and_indent (pp, 0);
1904
1905   code = TREE_CODE (stmt);
1906   switch (code)
1907     {
1908       /* expression-statement:
1909             expression(opt) ;  */
1910     case EXPR_STMT:
1911       pp_expression (pp, EXPR_STMT_EXPR (stmt));
1912       pp_c_semicolon (pp);
1913       pp_needs_newline (pp) = true;
1914       break;
1915
1916     case SWITCH_STMT:
1917       pp_c_identifier (pp, "switch");
1918       pp_space (pp);
1919       pp_c_left_paren (pp);
1920       pp_expression (pp, SWITCH_COND (stmt));
1921       pp_c_right_paren (pp);
1922       pp_indentation (pp) += 3;
1923       pp_needs_newline (pp) = true;
1924       pp_statement (pp, SWITCH_BODY (stmt));
1925       pp_newline_and_indent (pp, -3);
1926       break;
1927
1928       /* iteration-statement:
1929             while ( expression ) statement
1930             do statement while ( expression ) ;
1931             for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1932             for ( declaration expression(opt) ; expression(opt) ) statement  */
1933     case WHILE_STMT:
1934       pp_c_identifier (pp, "while");
1935       pp_space (pp);
1936       pp_c_left_paren (pp);
1937       pp_expression (pp, WHILE_COND (stmt));
1938       pp_c_right_paren (pp);
1939       pp_newline_and_indent (pp, 3);
1940       pp_statement (pp, WHILE_BODY (stmt));
1941       pp_indentation (pp) -= 3;
1942       pp_needs_newline (pp) = true;
1943       break;
1944
1945     case DO_STMT:
1946       pp_c_identifier (pp, "do");
1947       pp_newline_and_indent (pp, 3);
1948       pp_statement (pp, DO_BODY (stmt));
1949       pp_newline_and_indent (pp, -3);
1950       pp_c_identifier (pp, "while");
1951       pp_space (pp);
1952       pp_c_left_paren (pp);
1953       pp_expression (pp, DO_COND (stmt));
1954       pp_c_right_paren (pp);
1955       pp_c_semicolon (pp);
1956       pp_needs_newline (pp) = true;
1957       break;
1958
1959     case FOR_STMT:
1960       pp_c_identifier (pp, "for");
1961       pp_space (pp);
1962       pp_c_left_paren (pp);
1963       if (FOR_INIT_STMT (stmt))
1964         pp_statement (pp, FOR_INIT_STMT (stmt));
1965       else
1966         pp_c_semicolon (pp);
1967       pp_needs_newline (pp) = false;
1968       pp_c_whitespace (pp);
1969       if (FOR_COND (stmt))
1970         pp_expression (pp, FOR_COND (stmt));
1971       pp_c_semicolon (pp);
1972       pp_needs_newline (pp) = false;
1973       pp_c_whitespace (pp);
1974       if (FOR_EXPR (stmt))
1975         pp_expression (pp, FOR_EXPR (stmt));
1976       pp_c_right_paren (pp);
1977       pp_newline_and_indent (pp, 3);
1978       pp_statement (pp, FOR_BODY (stmt));
1979       pp_indentation (pp) -= 3;
1980       pp_needs_newline (pp) = true;
1981       break;
1982
1983       /* jump-statement:
1984             goto identifier;
1985             continue ;
1986             return expression(opt) ;  */
1987     case BREAK_STMT:
1988     case CONTINUE_STMT:
1989       pp_identifier (pp, code == BREAK_STMT ? "break" : "continue");
1990       pp_c_semicolon (pp);
1991       pp_needs_newline (pp) = true;
1992       break;
1993
1994     default:
1995       dump_generic_node (pp_base (pp), stmt, pp_indentation (pp), 0, true);
1996       break;
1997     }
1998 }
1999
2000 \f
2001 /* Initialize the PRETTY-PRINTER for handling C codes.  */
2002
2003 void
2004 pp_c_pretty_printer_init (c_pretty_printer *pp)
2005 {
2006   pp->offset_list               = 0;
2007
2008   pp->declaration               = pp_c_declaration;
2009   pp->declaration_specifiers    = pp_c_declaration_specifiers;
2010   pp->declarator                = pp_c_declarator;
2011   pp->direct_declarator         = pp_c_direct_declarator;
2012   pp->type_specifier_seq        = pp_c_specifier_qualifier_list;
2013   pp->abstract_declarator       = pp_c_abstract_declarator;
2014   pp->direct_abstract_declarator = pp_c_direct_abstract_declarator;
2015   pp->ptr_operator              = pp_c_pointer;
2016   pp->parameter_list            = pp_c_parameter_type_list;
2017   pp->type_id                   = pp_c_type_id;
2018   pp->simple_type_specifier     = pp_c_type_specifier;
2019   pp->function_specifier        = pp_c_function_specifier;
2020   pp->storage_class_specifier   = pp_c_storage_class_specifier;
2021
2022   pp->statement                 = pp_c_statement;
2023
2024   pp->id_expression             = pp_c_id_expression;
2025   pp->primary_expression        = pp_c_primary_expression;
2026   pp->postfix_expression        = pp_c_postfix_expression;
2027   pp->unary_expression          = pp_c_unary_expression;
2028   pp->initializer               = pp_c_initializer;
2029   pp->multiplicative_expression = pp_c_multiplicative_expression;
2030   pp->conditional_expression    = pp_c_conditional_expression;
2031   pp->assignment_expression     = pp_c_assignment_expression;
2032   pp->expression                = pp_c_expression;
2033 }
2034
2035
2036 /* Print the tree T in full, on file FILE.  */
2037
2038 void
2039 print_c_tree (FILE *file, tree t)
2040 {
2041   static c_pretty_printer pp_rec;
2042   static bool initialized = 0;
2043   c_pretty_printer *pp = &pp_rec;
2044
2045   if (!initialized)
2046     {
2047       initialized = 1;
2048       pp_construct (pp_base (pp), NULL, 0);
2049       pp_c_pretty_printer_init (pp);
2050       pp_needs_newline (pp) = true;
2051     }
2052   pp_base (pp)->buffer->stream = file;
2053
2054   pp_statement (pp, t);
2055
2056   pp_newline (pp);
2057   pp_flush (pp);
2058 }
2059
2060 /* Print the tree T in full, on stderr.  */
2061
2062 void
2063 debug_c_tree (tree t)
2064 {
2065   print_c_tree (stderr, t);
2066   fputc ('\n', stderr);
2067 }
2068
2069 /* Output the DECL_NAME of T.  If T has no DECL_NAME, output a string made
2070    up of T's memory address.  */
2071
2072 void
2073 pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
2074 {
2075   const char *name;
2076
2077   if (!DECL_P (t))
2078     abort ();
2079
2080   if (DECL_NAME (t))
2081     name = IDENTIFIER_POINTER (DECL_NAME (t));
2082   else
2083     {
2084       static char xname[8];
2085       sprintf (xname, "<U%4x>", ((unsigned)((unsigned long)(t) & 0xffff)));
2086       name = xname;
2087     }
2088
2089   pp_c_identifier (pp, name);
2090 }