gcc/c-pretty-print.c

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