gcc/c-pretty-print.c

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