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 postfix-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 infinite 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:
1559       pp_c_type_cast (pp, TREE_TYPE (e));
1560       pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1561       break;
1562
1563     default:
1564       pp_unary_expression (pp, e);
1565     }
1566 }
1567
1568 /* multiplicative-expression:
1569       cast-expression
1570       multiplicative-expression * cast-expression
1571       multiplicative-expression / cast-expression
1572       multiplicative-expression % cast-expression   */
1573
1574 static void
1575 pp_c_multiplicative_expression (c_pretty_printer *pp, tree e)
1576 {
1577   enum tree_code code = TREE_CODE (e);
1578   switch (code)
1579     {
1580     case MULT_EXPR:
1581     case TRUNC_DIV_EXPR:
1582     case TRUNC_MOD_EXPR:
1583       pp_multiplicative_expression (pp, TREE_OPERAND (e, 0));
1584       pp_c_whitespace (pp);
1585       if (code == MULT_EXPR)
1586         pp_c_star (pp);
1587       else if (code == TRUNC_DIV_EXPR)
1588         pp_slash (pp);
1589       else
1590         pp_modulo (pp);
1591       pp_c_whitespace (pp);
1592       pp_c_cast_expression (pp, TREE_OPERAND (e, 1));
1593       break;
1594
1595     default:
1596       pp_c_cast_expression (pp, e);
1597       break;
1598     }
1599 }
1600
1601 /* additive-expression:
1602       multiplicative-expression
1603       additive-expression + multiplicative-expression
1604       additive-expression - multiplicative-expression   */
1605
1606 static void
1607 pp_c_additive_expression (c_pretty_printer *pp, tree e)
1608 {
1609   enum tree_code code = TREE_CODE (e);
1610   switch (code)
1611     {
1612     case POINTER_PLUS_EXPR:
1613     case PLUS_EXPR:
1614     case MINUS_EXPR:
1615       pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
1616       pp_c_whitespace (pp);
1617       if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)
1618         pp_plus (pp);
1619       else
1620         pp_minus (pp);
1621       pp_c_whitespace (pp);
1622       pp_multiplicative_expression (pp, TREE_OPERAND (e, 1));
1623       break;
1624
1625     default:
1626       pp_multiplicative_expression (pp, e);
1627       break;
1628     }
1629 }
1630
1631 /* additive-expression:
1632       additive-expression
1633       shift-expression << additive-expression
1634       shift-expression >> additive-expression   */
1635
1636 static void
1637 pp_c_shift_expression (c_pretty_printer *pp, tree e)
1638 {
1639   enum tree_code code = TREE_CODE (e);
1640   switch (code)
1641     {
1642     case LSHIFT_EXPR:
1643     case RSHIFT_EXPR:
1644       pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
1645       pp_c_whitespace (pp);
1646       pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>");
1647       pp_c_whitespace (pp);
1648       pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
1649       break;
1650
1651     default:
1652       pp_c_additive_expression (pp, e);
1653     }
1654 }
1655
1656 /* relational-expression:
1657       shift-expression
1658       relational-expression < shift-expression
1659       relational-expression > shift-expression
1660       relational-expression <= shift-expression
1661       relational-expression >= shift-expression   */
1662
1663 static void
1664 pp_c_relational_expression (c_pretty_printer *pp, tree e)
1665 {
1666   enum tree_code code = TREE_CODE (e);
1667   switch (code)
1668     {
1669     case LT_EXPR:
1670     case GT_EXPR:
1671     case LE_EXPR:
1672     case GE_EXPR:
1673       pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
1674       pp_c_whitespace (pp);
1675       if (code == LT_EXPR)
1676         pp_less (pp);
1677       else if (code == GT_EXPR)
1678         pp_greater (pp);
1679       else if (code == LE_EXPR)
1680         pp_identifier (pp, "<=");
1681       else if (code == GE_EXPR)
1682         pp_identifier (pp, ">=");
1683       pp_c_whitespace (pp);
1684       pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
1685       break;
1686
1687     default:
1688       pp_c_shift_expression (pp, e);
1689       break;
1690     }
1691 }
1692
1693 /* equality-expression:
1694       relational-expression
1695       equality-expression == relational-expression
1696       equality-equality != relational-expression  */
1697
1698 static void
1699 pp_c_equality_expression (c_pretty_printer *pp, tree e)
1700 {
1701   enum tree_code code = TREE_CODE (e);
1702   switch (code)
1703     {
1704     case EQ_EXPR:
1705     case NE_EXPR:
1706       pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
1707       pp_c_whitespace (pp);
1708       pp_identifier (pp, code == EQ_EXPR ? "==" : "!=");
1709       pp_c_whitespace (pp);
1710       pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
1711       break;
1712
1713     default:
1714       pp_c_relational_expression (pp, e);
1715       break;
1716     }
1717 }
1718
1719 /* AND-expression:
1720       equality-expression
1721       AND-expression & equality-equality   */
1722
1723 static void
1724 pp_c_and_expression (c_pretty_printer *pp, tree e)
1725 {
1726   if (TREE_CODE (e) == BIT_AND_EXPR)
1727     {
1728       pp_c_and_expression (pp, TREE_OPERAND (e, 0));
1729       pp_c_whitespace (pp);
1730       pp_ampersand (pp);
1731       pp_c_whitespace (pp);
1732       pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
1733     }
1734   else
1735     pp_c_equality_expression (pp, e);
1736 }
1737
1738 /* exclusive-OR-expression:
1739      AND-expression
1740      exclusive-OR-expression ^ AND-expression  */
1741
1742 static void
1743 pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
1744 {
1745   if (TREE_CODE (e) == BIT_XOR_EXPR
1746       || TREE_CODE (e) == TRUTH_XOR_EXPR)
1747     {
1748       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1749       if (TREE_CODE (e) == BIT_XOR_EXPR)
1750         pp_c_maybe_whitespace (pp);
1751       else
1752         pp_c_whitespace (pp);
1753       pp_carret (pp);
1754       pp_c_whitespace (pp);
1755       pp_c_and_expression (pp, TREE_OPERAND (e, 1));
1756     }
1757   else
1758     pp_c_and_expression (pp, e);
1759 }
1760
1761 /* inclusive-OR-expression:
1762      exclusive-OR-expression
1763      inclusive-OR-expression | exclusive-OR-expression  */
1764
1765 static void
1766 pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
1767 {
1768   if (TREE_CODE (e) == BIT_IOR_EXPR)
1769     {
1770       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1771       pp_c_whitespace (pp);
1772       pp_bar (pp);
1773       pp_c_whitespace (pp);
1774       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
1775     }
1776   else
1777     pp_c_exclusive_or_expression (pp, e);
1778 }
1779
1780 /* logical-AND-expression:
1781       inclusive-OR-expression
1782       logical-AND-expression && inclusive-OR-expression  */
1783
1784 static void
1785 pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
1786 {
1787   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR
1788       || TREE_CODE (e) == TRUTH_AND_EXPR)
1789     {
1790       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
1791       pp_c_whitespace (pp);
1792       pp_identifier (pp, "&&");
1793       pp_c_whitespace (pp);
1794       pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
1795     }
1796   else
1797     pp_c_inclusive_or_expression (pp, e);
1798 }
1799
1800 /* logical-OR-expression:
1801       logical-AND-expression
1802       logical-OR-expression || logical-AND-expression  */
1803
1804 void
1805 pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
1806 {
1807   if (TREE_CODE (e) == TRUTH_ORIF_EXPR
1808       || TREE_CODE (e) == TRUTH_OR_EXPR)
1809     {
1810       pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1811       pp_c_whitespace (pp);
1812       pp_identifier (pp, "||");
1813       pp_c_whitespace (pp);
1814       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
1815     }
1816   else
1817     pp_c_logical_and_expression (pp, e);
1818 }
1819
1820 /* conditional-expression:
1821       logical-OR-expression
1822       logical-OR-expression ? expression : conditional-expression  */
1823
1824 static void
1825 pp_c_conditional_expression (c_pretty_printer *pp, tree e)
1826 {
1827   if (TREE_CODE (e) == COND_EXPR)
1828     {
1829       pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1830       pp_c_whitespace (pp);
1831       pp_question (pp);
1832       pp_c_whitespace (pp);
1833       pp_expression (pp, TREE_OPERAND (e, 1));
1834       pp_c_whitespace (pp);
1835       pp_colon (pp);
1836       pp_c_whitespace (pp);
1837       pp_c_conditional_expression (pp, TREE_OPERAND (e, 2));
1838     }
1839   else
1840     pp_c_logical_or_expression (pp, e);
1841 }
1842
1843
1844 /* assignment-expression:
1845       conditional-expression
1846       unary-expression assignment-operator  assignment-expression
1847
1848    assignment-expression: one of
1849       =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
1850
1851 static void
1852 pp_c_assignment_expression (c_pretty_printer *pp, tree e)
1853 {
1854   if (TREE_CODE (e) == MODIFY_EXPR
1855       || TREE_CODE (e) == INIT_EXPR)
1856     {
1857       pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1858       pp_c_whitespace (pp);
1859       pp_equal (pp);
1860       pp_space (pp);
1861       pp_c_expression (pp, TREE_OPERAND (e, 1));
1862     }
1863   else
1864     pp_c_conditional_expression (pp, e);
1865 }
1866
1867 /* expression:
1868        assignment-expression
1869        expression , assignment-expression
1870
1871   Implementation note:  instead of going through the usual recursion
1872   chain, I take the liberty of dispatching nodes to the appropriate
1873   functions.  This makes some redundancy, but it worths it. That also
1874   prevents a possible infinite recursion between pp_c_primary_expression ()
1875   and pp_c_expression ().  */
1876
1877 void
1878 pp_c_expression (c_pretty_printer *pp, tree e)
1879 {
1880   switch (TREE_CODE (e))
1881     {
1882     case INTEGER_CST:
1883       pp_c_integer_constant (pp, e);
1884       break;
1885
1886     case REAL_CST:
1887       pp_c_floating_constant (pp, e);
1888       break;
1889
1890     case FIXED_CST:
1891       pp_c_fixed_constant (pp, e);
1892       break;
1893
1894     case STRING_CST:
1895       pp_c_string_literal (pp, e);
1896       break;
1897
1898     case IDENTIFIER_NODE:
1899     case FUNCTION_DECL:
1900     case VAR_DECL:
1901     case CONST_DECL:
1902     case PARM_DECL:
1903     case RESULT_DECL:
1904     case FIELD_DECL:
1905     case LABEL_DECL:
1906     case ERROR_MARK:
1907       pp_primary_expression (pp, e);
1908       break;
1909
1910     case POSTINCREMENT_EXPR:
1911     case POSTDECREMENT_EXPR:
1912     case ARRAY_REF:
1913     case CALL_EXPR:
1914     case COMPONENT_REF:
1915     case COMPLEX_CST:
1916     case COMPLEX_EXPR:
1917     case VECTOR_CST:
1918     case ORDERED_EXPR:
1919     case UNORDERED_EXPR:
1920     case LTGT_EXPR:
1921     case UNEQ_EXPR:
1922     case UNLE_EXPR:
1923     case UNLT_EXPR:
1924     case UNGE_EXPR:
1925     case UNGT_EXPR:
1926     case ABS_EXPR:
1927     case CONSTRUCTOR:
1928     case COMPOUND_LITERAL_EXPR:
1929     case VA_ARG_EXPR:
1930       pp_postfix_expression (pp, e);
1931       break;
1932
1933     case CONJ_EXPR:
1934     case ADDR_EXPR:
1935     case INDIRECT_REF:
1936     case NEGATE_EXPR:
1937     case BIT_NOT_EXPR:
1938     case TRUTH_NOT_EXPR:
1939     case PREINCREMENT_EXPR:
1940     case PREDECREMENT_EXPR:
1941     case REALPART_EXPR:
1942     case IMAGPART_EXPR:
1943       pp_c_unary_expression (pp, e);
1944       break;
1945
1946     case FLOAT_EXPR:
1947     case FIX_TRUNC_EXPR:
1948     CASE_CONVERT:
1949       pp_c_cast_expression (pp, e);
1950       break;
1951
1952     case MULT_EXPR:
1953     case TRUNC_MOD_EXPR:
1954     case TRUNC_DIV_EXPR:
1955       pp_multiplicative_expression (pp, e);
1956       break;
1957
1958     case LSHIFT_EXPR:
1959     case RSHIFT_EXPR:
1960       pp_c_shift_expression (pp, e);
1961       break;
1962
1963     case LT_EXPR:
1964     case GT_EXPR:
1965     case LE_EXPR:
1966     case GE_EXPR:
1967       pp_c_relational_expression (pp, e);
1968       break;
1969
1970     case BIT_AND_EXPR:
1971       pp_c_and_expression (pp, e);
1972       break;
1973
1974     case BIT_XOR_EXPR:
1975     case TRUTH_XOR_EXPR:
1976       pp_c_exclusive_or_expression (pp, e);
1977       break;
1978
1979     case BIT_IOR_EXPR:
1980       pp_c_inclusive_or_expression (pp, e);
1981       break;
1982
1983     case TRUTH_ANDIF_EXPR:
1984     case TRUTH_AND_EXPR:
1985       pp_c_logical_and_expression (pp, e);
1986       break;
1987
1988     case TRUTH_ORIF_EXPR:
1989     case TRUTH_OR_EXPR:
1990       pp_c_logical_or_expression (pp, e);
1991       break;
1992
1993     case EQ_EXPR:
1994     case NE_EXPR:
1995       pp_c_equality_expression (pp, e);
1996       break;
1997
1998     case COND_EXPR:
1999       pp_conditional_expression (pp, e);
2000       break;
2001
2002     case POINTER_PLUS_EXPR:
2003     case PLUS_EXPR:
2004     case MINUS_EXPR:
2005       pp_c_additive_expression (pp, e);
2006       break;
2007
2008     case MODIFY_EXPR:
2009     case INIT_EXPR:
2010       pp_assignment_expression (pp, e);
2011       break;
2012
2013     case COMPOUND_EXPR:
2014       pp_c_left_paren (pp);
2015       pp_expression (pp, TREE_OPERAND (e, 0));
2016       pp_separate_with (pp, ',');
2017       pp_assignment_expression (pp, TREE_OPERAND (e, 1));
2018       pp_c_right_paren (pp);
2019       break;
2020
2021     case NON_LVALUE_EXPR:
2022     case SAVE_EXPR:
2023       pp_expression (pp, TREE_OPERAND (e, 0));
2024       break;
2025
2026     case TARGET_EXPR:
2027       pp_postfix_expression (pp, TREE_OPERAND (e, 1));
2028       break;
2029
2030     default:
2031       pp_unsupported_tree (pp, e);
2032       break;
2033     }
2034 }
2035
2036
2037 \f
2038 /* Statements.  */
2039
2040 void
2041 pp_c_statement (c_pretty_printer *pp, tree stmt)
2042 {
2043   if (stmt == NULL)
2044     return;
2045
2046   if (pp_needs_newline (pp))
2047     pp_newline_and_indent (pp, 0);
2048
2049   dump_generic_node (pp_base (pp), stmt, pp_indentation (pp), 0, true);
2050 }
2051
2052 \f
2053 /* Initialize the PRETTY-PRINTER for handling C codes.  */
2054
2055 void
2056 pp_c_pretty_printer_init (c_pretty_printer *pp)
2057 {
2058   pp->offset_list               = 0;
2059
2060   pp->declaration               = pp_c_declaration;
2061   pp->declaration_specifiers    = pp_c_declaration_specifiers;
2062   pp->declarator                = pp_c_declarator;
2063   pp->direct_declarator         = pp_c_direct_declarator;
2064   pp->type_specifier_seq        = pp_c_specifier_qualifier_list;
2065   pp->abstract_declarator       = pp_c_abstract_declarator;
2066   pp->direct_abstract_declarator = pp_c_direct_abstract_declarator;
2067   pp->ptr_operator              = pp_c_pointer;
2068   pp->parameter_list            = pp_c_parameter_type_list;
2069   pp->type_id                   = pp_c_type_id;
2070   pp->simple_type_specifier     = pp_c_type_specifier;
2071   pp->function_specifier        = pp_c_function_specifier;
2072   pp->storage_class_specifier   = pp_c_storage_class_specifier;
2073
2074   pp->statement                 = pp_c_statement;
2075
2076   pp->constant                  = pp_c_constant;
2077   pp->id_expression             = pp_c_id_expression;
2078   pp->primary_expression        = pp_c_primary_expression;
2079   pp->postfix_expression        = pp_c_postfix_expression;
2080   pp->unary_expression          = pp_c_unary_expression;
2081   pp->initializer               = pp_c_initializer;
2082   pp->multiplicative_expression = pp_c_multiplicative_expression;
2083   pp->conditional_expression    = pp_c_conditional_expression;
2084   pp->assignment_expression     = pp_c_assignment_expression;
2085   pp->expression                = pp_c_expression;
2086 }
2087
2088
2089 /* Print the tree T in full, on file FILE.  */
2090
2091 void
2092 print_c_tree (FILE *file, tree t)
2093 {
2094   static c_pretty_printer pp_rec;
2095   static bool initialized = 0;
2096   c_pretty_printer *pp = &pp_rec;
2097
2098   if (!initialized)
2099     {
2100       initialized = 1;
2101       pp_construct (pp_base (pp), NULL, 0);
2102       pp_c_pretty_printer_init (pp);
2103       pp_needs_newline (pp) = true;
2104     }
2105   pp_base (pp)->buffer->stream = file;
2106
2107   pp_statement (pp, t);
2108
2109   pp_newline (pp);
2110   pp_flush (pp);
2111 }
2112
2113 /* Print the tree T in full, on stderr.  */
2114
2115 void
2116 debug_c_tree (tree t)
2117 {
2118   print_c_tree (stderr, t);
2119   fputc ('\n', stderr);
2120 }
2121
2122 /* Output the DECL_NAME of T.  If T has no DECL_NAME, output a string made
2123    up of T's memory address.  */
2124
2125 void
2126 pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
2127 {
2128   const char *name;
2129
2130   gcc_assert (DECL_P (t));
2131
2132   if (DECL_NAME (t))
2133     name = IDENTIFIER_POINTER (DECL_NAME (t));
2134   else
2135     {
2136       static char xname[8];
2137       sprintf (xname, "<U%4x>", ((unsigned)((unsigned long)(t) & 0xffff)));
2138       name = xname;
2139     }
2140
2141   pp_c_identifier (pp, name);
2142 }