gcc/c-pretty-print.c

   1 /* Subroutines common to both C and C++ pretty-printers.
   2    Copyright (C) 2002 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 "real.h"
  25 #include "c-pretty-print.h"
  26
  27 /* literal  */
  28 static void pp_c_char              PARAMS ((c_pretty_print_info *, int));
  29 static void pp_c_character_literal PARAMS ((c_pretty_print_info *, tree));
  30 static void pp_c_bool_literal      PARAMS ((c_pretty_print_info *, tree));
  31 static bool pp_c_enumerator        PARAMS ((c_pretty_print_info *, tree));
  32 static void pp_c_integer_literal   PARAMS ((c_pretty_print_info *, tree));
  33 static void pp_c_real_literal      PARAMS ((c_pretty_print_info *, tree));
  34 static void pp_c_string_literal    PARAMS ((c_pretty_print_info *, tree));
  35
  36 static void pp_c_primary_expression PARAMS ((c_pretty_print_info *, tree));
  37
  38 /* postfix-expression  */
  39 static void pp_c_initializer_list PARAMS ((c_pretty_print_info *, tree));
  40
  41 static void pp_c_unary_expression PARAMS ((c_pretty_print_info *, tree));
  42 static void pp_c_multiplicative_expression PARAMS ((c_pretty_print_info *,
  43                                                     tree));
  44 static void pp_c_additive_expression PARAMS ((c_pretty_print_info *, tree));
  45 static void pp_c_shift_expression PARAMS ((c_pretty_print_info *, tree));
  46 static void pp_c_relational_expression PARAMS ((c_pretty_print_info *, tree));
  47 static void pp_c_equality_expression PARAMS ((c_pretty_print_info *, tree));
  48 static void pp_c_and_expression PARAMS ((c_pretty_print_info *, tree));
  49 static void pp_c_exclusive_or_expression PARAMS ((c_pretty_print_info *,
  50                                                   tree));
  51 static void pp_c_inclusive_or_expression PARAMS ((c_pretty_print_info *,
  52                                                   tree));
  53 static void pp_c_logical_and_expression PARAMS ((c_pretty_print_info *, tree));
  54 static void pp_c_conditional_expression PARAMS ((c_pretty_print_info *, tree));
  55 static void pp_c_assignment_expression PARAMS ((c_pretty_print_info *, tree));
  56
  57 /* declarations.  */
  58 static void pp_c_specifier_qualifier_list PARAMS ((c_pretty_print_info *, tree));
  59 static void pp_c_type_specifier PARAMS ((c_pretty_print_info *, tree));
  60 static void pp_c_abstract_declarator PARAMS ((c_pretty_print_info *, tree));
  61 static void pp_c_type_id PARAMS ((c_pretty_print_info *, tree));
  62
  63 \f
  64 /* Declarations.  */
  65
  66 /* Print out CV-qualifiers.  Take care of possible extension.  */
  67 void
  68 pp_c_cv_qualifier (ppi, cv)
  69      c_pretty_print_info *ppi;
  70      int cv;
  71 {
  72   if (cv & TYPE_QUAL_CONST)
  73     pp_c_identifier (ppi, "const");
  74   if (cv & TYPE_QUAL_VOLATILE)
  75     pp_c_identifier (ppi, "volatile");
  76   if (cv & TYPE_QUAL_RESTRICT)
  77     pp_c_identifier (ppi, flag_isoc99 ? "restrict" : "__restrict__");
  78 }
  79
  80 static void
  81 pp_c_type_specifier (ppi, t)
  82      c_pretty_print_info *ppi;
  83      tree t;
  84 {
  85   const enum tree_code code = TREE_CODE (t);
  86   switch (code)
  87     {
  88     case ERROR_MARK:
  89       pp_c_identifier (ppi, "<erroneous-type>");
  90       break;
  91
  92 #if 0
  93     case UNKNOWN_TYPE:
  94       pp_c_identifier (ppi, "<unkown-type>");
  95       break;
  96 #endif
  97
  98     case IDENTIFIER_NODE:
  99       pp_c_tree_identifier (ppi, t);
 100       break;
 101
 102 #if 0
 103     case INTEGER_TYPE:
 104       if (TREE_UNSIGNED (t))
 105         pp_c_identifier (ppi, "unsigned");
 106       /* fall through.  */
 107     case VOID_TYPE:
 108     case BOOLEAN_TYPE:
 109     case REAL_TYPE:
 110       if (TYPE_NAME (t) && TYPE_IDENTIFIER (t))
 111         pp_c_tree_identifier (t, TYPE_IDENTIFIER (t));
 112       else
 113         pp_c_identifier (ppi, "<anonymous-type>");
 114       break;
 115 #endif
 116
 117     case COMPLEX_TYPE:
 118     case VECTOR_TYPE:
 119       pp_c_type_specifier (ppi, TREE_TYPE (t));
 120       if (code == COMPLEX_TYPE)
 121         pp_c_identifier (ppi, flag_isoc99 ? "_Complex" : "__complex__");
 122       else if (code == VECTOR_TYPE)
 123         pp_c_identifier (ppi, "__vector__");
 124       break;
 125
 126     case TYPE_DECL:
 127       pp_c_tree_identifier (ppi, DECL_NAME (t));
 128       break;
 129
 130     case UNION_TYPE:
 131     case RECORD_TYPE:
 132     case ENUMERAL_TYPE:
 133       if (code == UNION_TYPE)
 134         pp_c_identifier (ppi, "union");
 135       else if (code == RECORD_TYPE)
 136         pp_c_identifier (ppi, "struct");
 137       else if (code == ENUMERAL_TYPE)
 138         pp_c_identifier (ppi, "enum");
 139
 140       if (TYPE_NAME (t))
 141         pp_c_tree_identifier (ppi, TYPE_NAME (t));
 142       else
 143         pp_c_identifier (ppi, "<anonymous>");
 144       break;
 145
 146     case POINTER_TYPE:
 147     case ARRAY_TYPE:
 148       {
 149       }
 150       break;
 151
 152     default:
 153       pp_unsupported_tree (ppi, t);
 154     }
 155 }
 156
 157 static inline void
 158 pp_c_specifier_qualifier_list (ppi, t)
 159      c_pretty_print_info *ppi;
 160      tree t;
 161 {
 162   pp_c_type_specifier (ppi, t);
 163   pp_c_cv_qualifier (ppi, TYPE_QUALS (t));
 164 }
 165
 166 static void
 167 pp_c_abstract_declarator (ppi, t)
 168      c_pretty_print_info *ppi;
 169      tree t;
 170 {
 171   pp_unsupported_tree (ppi, t);
 172 }
 173
 174
 175 static inline void
 176 pp_c_type_id (ppi, t)
 177      c_pretty_print_info *ppi;
 178      tree t;
 179 {
 180   pp_c_specifier_qualifier_list (ppi, t);
 181   pp_c_abstract_declarator (ppi, t);
 182 }
 183
 184 \f
 185 /* Expressions.  */
 186
 187 /* Print out a c-char.  */
 188 static void
 189 pp_c_char (ppi, c)
 190      c_pretty_print_info *ppi;
 191      int c;
 192 {
 193   switch (c)
 194     {
 195     case TARGET_NEWLINE:
 196       pp_identifier (ppi, "\\n");
 197       break;
 198     case TARGET_TAB:
 199       pp_identifier (ppi, "\\t");
 200       break;
 201     case TARGET_VT:
 202       pp_identifier (ppi, "\\v");
 203       break;
 204     case TARGET_BS:
 205       pp_identifier (ppi, "\\b");
 206       break;
 207     case TARGET_CR:
 208       pp_identifier (ppi, "\\r");
 209       break;
 210     case TARGET_FF:
 211       pp_identifier (ppi, "\\f");
 212       break;
 213     case TARGET_BELL:
 214       pp_identifier (ppi, "\\a");
 215       break;
 216     case '\\':
 217       pp_identifier (ppi, "\\\\");
 218       break;
 219     case '\'':
 220       pp_identifier (ppi, "\\'");
 221       break;
 222     case '\"':
 223       pp_identifier (ppi, "\\\"");
 224       break;
 225     default:
 226       if (ISPRINT (c))
 227         pp_character (ppi, c);
 228       else
 229         pp_format_scalar (ppi, "\\%03o", (unsigned) c);
 230       break;
 231     }
 232 }
 233
 234 /* Print out a STRING literal.  */
 235 static inline void
 236 pp_c_string_literal (ppi, s)
 237      c_pretty_print_info *ppi;
 238      tree s;
 239 {
 240   const char *p = TREE_STRING_POINTER (s);
 241   int n = TREE_STRING_LENGTH (s) - 1;
 242   int i;
 243   pp_doublequote (ppi);
 244   for (i = 0; i < n; ++i)
 245     pp_c_char (ppi, p[i]);
 246   pp_doublequote (ppi);
 247 }
 248
 249 /* Print out a CHARACTER literal.  */
 250 static inline void
 251 pp_c_character_literal (ppi, c)
 252      c_pretty_print_info *ppi;
 253      tree c;
 254 {
 255   pp_quote (ppi);
 256   pp_c_char (ppi, tree_low_cst (c, 0));
 257   pp_quote (ppi);
 258 }
 259
 260 /* Print out a BOOLEAN literal.  */
 261 static inline void
 262 pp_c_bool_literal (ppi, b)
 263      c_pretty_print_info *ppi;
 264      tree b;
 265 {
 266   if (b == boolean_false_node || integer_zerop (b))
 267     {
 268       if (c_language == clk_cplusplus)
 269         pp_c_identifier (ppi, "false");
 270       else if (c_language == clk_c && flag_isoc99)
 271         pp_c_identifier (ppi, "_False");
 272       else
 273         pp_unsupported_tree (ppi, b);
 274     }
 275   else if (b == boolean_true_node)
 276     {
 277       if (c_language == clk_cplusplus)
 278         pp_c_identifier (ppi, "true");
 279       else if (c_language == clk_c && flag_isoc99)
 280         pp_c_identifier (ppi, "_True");
 281       else
 282         pp_unsupported_tree (ppi, b);
 283     }
 284   else
 285     pp_unsupported_tree (ppi, b);
 286 }
 287
 288 /* Attempt to print out an ENUMERATOR.  Return true on success.  Else return
 289    false; that means the value was obtained by a cast, in which case
 290    print out the type-id part of the cast-expression -- the casted value
 291    is then printed by pp_c_integer_literal.  */
 292 static bool
 293 pp_c_enumerator (ppi, e)
 294      c_pretty_print_info *ppi;
 295      tree e;
 296 {
 297   tree type = TREE_TYPE (e);
 298   tree value;
 299
 300   /* Find the name of this constant.  */
 301   for (value = TYPE_VALUES (type);
 302        value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
 303        value = TREE_CHAIN (value))
 304     ;
 305
 306   if (value != NULL_TREE)
 307     pp_c_tree_identifier (ppi, TREE_PURPOSE (value));
 308   else
 309     {
 310       /* Value must have been cast.  */
 311       pp_c_left_paren (ppi);
 312       pp_type_id (ppi, type);
 313       pp_c_right_paren (ppi);
 314       return false;
 315     }
 316
 317   return true;
 318 }
 319
 320 /* Print out an INTEGER constant value.  */
 321 static void
 322 pp_c_integer_literal (ppi, i)
 323      c_pretty_print_info *ppi;
 324      tree i;
 325 {
 326   tree type = TREE_TYPE (i);
 327
 328   if (type == boolean_type_node)
 329     pp_c_bool_literal (ppi, i);
 330   else if (type == char_type_node)
 331     pp_c_character_literal (ppi, i);
 332   else if (TREE_CODE (type) == ENUMERAL_TYPE
 333            && pp_c_enumerator (ppi, i))
 334     ;
 335   else
 336     {
 337       if (host_integerp (i, 0))
 338         pp_wide_integer (ppi, TREE_INT_CST_LOW (i));
 339       else
 340         {
 341           if (tree_int_cst_sgn (i) < 0)
 342             {
 343               static char format[10]; /* "%x%09999x\0" */
 344               if (!format[0])
 345                 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
 346
 347               pp_c_char (ppi, '-');
 348               i = build_int_2 (-TREE_INT_CST_LOW (i),
 349                                ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
 350               sprintf (pp_buffer (ppi)->digit_buffer, format,
 351                        TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
 352               pp_identifier (ppi, pp_buffer (ppi)->digit_buffer);
 353
 354             }
 355         }
 356     }
 357 }
 358
 359 /* Print out a REAL value. */
 360 static inline void
 361 pp_c_real_literal (ppi, r)
 362      c_pretty_print_info *ppi;
 363      tree r;
 364 {
 365   REAL_VALUE_TO_DECIMAL (TREE_REAL_CST (r), "%.16g",
 366                          pp_buffer (ppi)->digit_buffer);
 367   pp_identifier (ppi, pp_buffer(ppi)->digit_buffer);
 368 }
 369
 370
 371 void
 372 pp_c_literal (ppi, e)
 373      c_pretty_print_info *ppi;
 374      tree e;
 375 {
 376   switch (TREE_CODE (e))
 377     {
 378     case INTEGER_CST:
 379       pp_c_integer_literal (ppi, e);
 380       break;
 381
 382     case REAL_CST:
 383       pp_c_real_literal (ppi, e);
 384       break;
 385
 386     case STRING_CST:
 387       pp_c_string_literal (ppi, e);
 388       break;
 389
 390     default:
 391       pp_unsupported_tree (ppi, e);
 392       break;
 393     }
 394 }
 395
 396 /* Pretty-print a C primary-expression.  */
 397 static void
 398 pp_c_primary_expression (ppi, e)
 399      c_pretty_print_info *ppi;
 400      tree e;
 401 {
 402   switch (TREE_CODE (e))
 403     {
 404     case VAR_DECL:
 405     case PARM_DECL:
 406     case FIELD_DECL:
 407     case CONST_DECL:
 408     case FUNCTION_DECL:
 409     case LABEL_DECL:
 410       e = DECL_NAME (e);
 411       /* Fall through.  */
 412     case IDENTIFIER_NODE:
 413       pp_c_tree_identifier (ppi, e);
 414       break;
 415
 416     case ERROR_MARK:
 417       pp_c_identifier (ppi, "<erroneous-expression>");
 418       break;
 419
 420     case RESULT_DECL:
 421       pp_c_identifier (ppi, "<return-value>");
 422       break;
 423
 424     case INTEGER_CST:
 425     case REAL_CST:
 426     case STRING_CST:
 427       pp_c_literal (ppi, e);
 428       break;
 429
 430     case TARGET_EXPR:
 431       pp_c_left_paren (ppi);
 432       pp_c_identifier (ppi, "__builtin_memcpy");
 433       pp_c_left_paren (ppi);
 434       pp_ampersand (ppi);
 435       pp_c_primary_expression (ppi, TREE_OPERAND (e, 0));
 436       pp_separate_with (ppi, ',');
 437       pp_ampersand (ppi);
 438       pp_initializer (ppi, TREE_OPERAND (e, 1));
 439       if (TREE_OPERAND (e, 2))
 440         {
 441           pp_separate_with (ppi, ',');
 442           pp_c_expression (ppi, TREE_OPERAND (e, 2));
 443         }
 444       pp_c_right_paren (ppi);
 445
 446     case STMT_EXPR:
 447       pp_c_left_paren (ppi);
 448       pp_statement (ppi, STMT_EXPR_STMT (e));
 449       pp_c_right_paren (ppi);
 450       break;
 451
 452     default:
 453       /*  Make sure this call won't cause any infinite loop. */
 454       pp_c_left_paren (ppi);
 455       pp_c_expression (ppi, e);
 456       pp_c_right_paren (ppi);
 457       break;
 458     }
 459 }
 460
 461 /* Print out a C initializer -- also support C compound-literals.  */
 462 void
 463 pp_c_initializer (ppi, e)
 464      c_pretty_print_info *ppi;
 465      tree e;
 466 {
 467   if (TREE_CODE (e) == CONSTRUCTOR)
 468     {
 469       enum tree_code code = TREE_CODE (TREE_TYPE (e));
 470       if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 471         {
 472           pp_left_brace (ppi);
 473           pp_c_initializer_list (ppi, e);
 474           pp_right_brace (ppi);
 475         }
 476       else
 477         pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
 478     }
 479   else
 480     pp_assignment_expression (ppi, e);
 481 }
 482
 483 static void
 484 pp_c_initializer_list (ppi, e)
 485      c_pretty_print_info *ppi;
 486      tree e;
 487 {
 488   tree type = TREE_TYPE (e);
 489   const enum tree_code code = TREE_CODE (type);
 490
 491   if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
 492     {
 493       tree init = TREE_OPERAND (e, 1);
 494       for (; init != NULL_TREE; init = TREE_CHAIN (init))
 495         {
 496           if (code == RECORD_TYPE || code == UNION_TYPE)
 497             {
 498               pp_dot (ppi);
 499               pp_c_primary_expression (ppi, TREE_PURPOSE (init));
 500             }
 501           else
 502             {
 503               pp_c_left_bracket (ppi);
 504               if (TREE_PURPOSE (init))
 505                 pp_c_literal (ppi, TREE_PURPOSE (init));
 506               pp_c_right_bracket (ppi);
 507             }
 508           pp_c_whitespace (ppi);
 509           pp_equal (ppi);
 510           pp_c_whitespace (ppi);
 511           pp_initializer (ppi, TREE_VALUE (init));
 512           if (TREE_CHAIN (init))
 513             pp_separate_with (ppi, ',');
 514         }
 515     }
 516   else
 517     pp_unsupported_tree (ppi, type);
 518 }
 519
 520 void
 521 pp_c_postfix_expression (ppi, e)
 522      c_pretty_print_info *ppi;
 523      tree e;
 524 {
 525   enum tree_code code = TREE_CODE (e);
 526   switch (code)
 527     {
 528     case POSTINCREMENT_EXPR:
 529     case POSTDECREMENT_EXPR:
 530       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 531       pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
 532       break;
 533
 534     case ARROW_EXPR:
 535       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 536       pp_arrow (ppi);
 537       break;
 538
 539     case ARRAY_REF:
 540       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 541       pp_c_left_bracket (ppi);
 542       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 543       pp_c_right_bracket (ppi);
 544       break;
 545
 546     case CALL_EXPR:
 547       pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
 548       pp_c_left_paren (ppi);
 549       pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
 550       pp_c_right_paren (ppi);
 551       break;
 552
 553     case ABS_EXPR:
 554     case FFS_EXPR:
 555       pp_c_identifier (ppi,
 556                        code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs");
 557       pp_c_left_paren (ppi);
 558       pp_c_expression (ppi, TREE_OPERAND (e, 0));
 559       pp_c_right_paren (ppi);
 560       break;
 561
 562     case COMPONENT_REF:
 563       {
 564         tree object = TREE_OPERAND (e, 0);
 565         if (TREE_CODE (object) == INDIRECT_REF)
 566           {
 567             pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
 568             pp_arrow (ppi);
 569           }
 570         else
 571           {
 572             pp_postfix_expression (ppi, object);
 573             pp_dot (ppi);
 574           }
 575         pp_c_expression (ppi, TREE_OPERAND (e, 1));
 576       }
 577       break;
 578
 579     case COMPLEX_CST:
 580     case VECTOR_CST:
 581     case COMPLEX_EXPR:
 582       pp_c_left_paren (ppi);
 583       pp_type_id (ppi, TREE_TYPE (e));
 584       pp_c_right_paren (ppi);
 585       pp_left_brace (ppi);
 586
 587       if (code == COMPLEX_CST)
 588         {
 589           pp_c_expression (ppi, TREE_REALPART (e));
 590           pp_separate_with (ppi, ',');
 591           pp_c_expression (ppi, TREE_IMAGPART (e));
 592         }
 593       else if (code == VECTOR_CST)
 594         pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e));
 595       else if (code == COMPLEX_EXPR)
 596         {
 597           pp_c_expression (ppi, TREE_OPERAND (e, 0));
 598           pp_separate_with (ppi, ',');
 599           pp_c_expression (ppi, TREE_OPERAND (e, 1));
 600         }
 601
 602       pp_right_brace (ppi);
 603       break;
 604
 605     case COMPOUND_LITERAL_EXPR:
 606       e = DECL_INITIAL (e);
 607       /* Fall through.  */
 608     case CONSTRUCTOR:
 609       pp_initializer (ppi, e);
 610       break;
 611
 612 #if 0
 613     case SRCLOC:
 614       pp_left_paren (ppi);
 615       pp_identifier (ppi, "__location__");
 616       pp_right_paren (ppi);
 617       pp_whitespace (ppi);
 618       pp_left_brace (ppi);
 619       pp_dot (ppi);
 620       pp_identifier (ppi, "file");
 621       pp_whitespace (ppi);
 622       pp_equal (ppi);
 623       pp_c_whitespace (ppi);
 624       pp_c_expression (ppi, SRCLOC_FILE (e));
 625       pp_separate_with (ppi, ',');
 626       pp_dot (ppi);
 627       pp_identifier (ppi, "line");
 628       pp_whitespace (ppi);
 629       pp_equal (ppi);
 630       pp_c_whitespace (ppi);
 631       pp_c_expression (ppi, SRCLOC_LINE (e));
 632       pp_right_brace (ppi);
 633       break;
 634 #endif
 635
 636     case VA_ARG_EXPR:
 637       pp_c_identifier (ppi, "__builtin_va_arg");
 638       pp_c_left_paren (ppi);
 639       pp_assignment_expression (ppi, TREE_OPERAND (e, 0));
 640       pp_separate_with (ppi, ',');
 641       pp_type_id (ppi, TREE_TYPE (e));
 642       pp_c_right_paren (ppi);
 643       break;
 644
 645     default:
 646       pp_primary_expression (ppi, e);
 647       break;
 648     }
 649 }
 650
 651 /* Print out an expression-list; E is expected to be a TREE_LIST  */
 652 void
 653 pp_c_expression_list (ppi, e)
 654      c_pretty_print_info *ppi;
 655      tree e;
 656 {
 657   for (; e != NULL_TREE; e = TREE_CHAIN (e))
 658     {
 659       pp_c_assignment_expression (ppi, TREE_VALUE (e));
 660       if (TREE_CHAIN (e))
 661         pp_separate_with (ppi, ',');
 662     }
 663 }
 664
 665 static void
 666 pp_c_unary_expression (ppi, e)
 667      c_pretty_print_info *ppi;
 668      tree e;
 669 {
 670   enum tree_code code = TREE_CODE (e);
 671   switch (code)
 672     {
 673     case PREINCREMENT_EXPR:
 674     case PREDECREMENT_EXPR:
 675       pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
 676       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 677       break;
 678
 679     case ADDR_EXPR:
 680     case INDIRECT_REF:
 681     case CONVERT_EXPR:
 682     case NEGATE_EXPR:
 683     case BIT_NOT_EXPR:
 684     case TRUTH_NOT_EXPR:
 685     case CONJ_EXPR:
 686       if (code == ADDR_EXPR)
 687         pp_ampersand (ppi);
 688       else if (code == INDIRECT_REF)
 689         pp_star (ppi);
 690       else if (code == NEGATE_EXPR)
 691         pp_minus (ppi);
 692       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
 693         pp_complement (ppi);
 694       else if (code == TRUTH_NOT_EXPR)
 695         pp_exclamation (ppi);
 696       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 697       break;
 698
 699     case SIZEOF_EXPR:
 700     case ALIGNOF_EXPR:
 701       pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
 702       pp_c_whitespace (ppi);
 703       if (TYPE_P (TREE_OPERAND (e, 0)))
 704         {
 705           pp_c_left_paren (ppi);
 706           pp_type_id (ppi, TREE_OPERAND (e, 0));
 707           pp_c_right_paren (ppi);
 708         }
 709       else
 710         pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 711       break;
 712
 713     case REALPART_EXPR:
 714     case IMAGPART_EXPR:
 715       pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__");
 716       pp_c_whitespace (ppi);
 717       pp_unary_expression (ppi, TREE_OPERAND (e, 0));
 718       break;
 719
 720     default:
 721       pp_postfix_expression (ppi, e);
 722       break;
 723     }
 724 }
 725
 726 void
 727 pp_c_cast_expression (ppi, e)
 728      c_pretty_print_info *ppi;
 729      tree e;
 730 {
 731   if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
 732     {
 733       pp_c_left_paren (ppi);
 734       pp_type_id (ppi, TREE_TYPE (e));
 735       pp_c_right_paren (ppi);
 736       pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
 737     }
 738   else
 739     pp_unary_expression (ppi, e);
 740 }
 741
 742 static void
 743 pp_c_multiplicative_expression (ppi, e)
 744      c_pretty_print_info *ppi;
 745      tree e;
 746 {
 747   enum tree_code code = TREE_CODE (e);
 748   switch (code)
 749     {
 750     case MULT_EXPR:
 751     case TRUNC_DIV_EXPR:
 752     case TRUNC_MOD_EXPR:
 753       pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
 754       pp_c_whitespace (ppi);
 755       if (code == MULT_EXPR)
 756         pp_star (ppi);
 757       else if (code == TRUNC_DIV_EXPR)
 758         pp_slash (ppi);
 759       else
 760         pp_modulo (ppi);
 761       pp_c_whitespace (ppi);
 762       pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
 763       break;
 764
 765     default:
 766       pp_c_cast_expression (ppi, e);
 767       break;
 768     }
 769 }
 770
 771 static inline void
 772 pp_c_additive_expression (ppi, e)
 773      c_pretty_print_info *ppi;
 774      tree e;
 775 {
 776   enum tree_code code = TREE_CODE (e);
 777   switch (code)
 778     {
 779     case PLUS_EXPR:
 780     case MINUS_EXPR:
 781       pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
 782       pp_c_whitespace (ppi);
 783       if (code == PLUS_EXPR)
 784         pp_plus (ppi);
 785       else
 786         pp_minus (ppi);
 787       pp_c_whitespace (ppi);
 788       pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
 789       break;
 790
 791     default:
 792       pp_multiplicative_expression (ppi, e);
 793       break;
 794     }
 795 }
 796
 797 static inline void
 798 pp_c_shift_expression (ppi, e)
 799      c_pretty_print_info *ppi;
 800      tree e;
 801 {
 802   enum tree_code code = TREE_CODE (e);
 803   switch (code)
 804     {
 805     case LSHIFT_EXPR:
 806     case RSHIFT_EXPR:
 807       pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
 808       pp_c_whitespace (ppi);
 809       pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
 810       pp_c_whitespace (ppi);
 811       pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
 812       break;
 813
 814     default:
 815       pp_c_additive_expression (ppi, e);
 816     }
 817 }
 818
 819 static void
 820 pp_c_relational_expression (ppi, e)
 821      c_pretty_print_info *ppi;
 822      tree e;
 823 {
 824   enum tree_code code = TREE_CODE (e);
 825   switch (code)
 826     {
 827     case LT_EXPR:
 828     case GT_EXPR:
 829     case LE_EXPR:
 830     case GE_EXPR:
 831       pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
 832       pp_c_whitespace (ppi);
 833       if (code == LT_EXPR)
 834         pp_less (ppi);
 835       else if (code == GT_EXPR)
 836         pp_greater (ppi);
 837       else if (code == LE_EXPR)
 838         pp_identifier (ppi, "<=");
 839       else if (code == GE_EXPR)
 840         pp_identifier (ppi, ">=");
 841       pp_c_whitespace (ppi);
 842       pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
 843       break;
 844
 845     default:
 846       pp_c_shift_expression (ppi, e);
 847       break;
 848     }
 849 }
 850
 851 static inline void
 852 pp_c_equality_expression (ppi, e)
 853      c_pretty_print_info *ppi;
 854      tree e;
 855 {
 856   enum tree_code code = TREE_CODE (e);
 857   switch (code)
 858     {
 859     case EQ_EXPR:
 860     case NE_EXPR:
 861       pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
 862       pp_c_maybe_whitespace (ppi);
 863       pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
 864       pp_c_whitespace (ppi);
 865       pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
 866       break;
 867
 868     default:
 869       pp_c_relational_expression (ppi, e);
 870       break;
 871     }
 872 }
 873
 874 static inline void
 875 pp_c_and_expression (ppi, e)
 876      c_pretty_print_info *ppi;
 877      tree e;
 878 {
 879   if (TREE_CODE (e) == BIT_AND_EXPR)
 880     {
 881       pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
 882       pp_c_maybe_whitespace (ppi);
 883       pp_ampersand (ppi);
 884       pp_c_whitespace (ppi);
 885       pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
 886     }
 887   else
 888     pp_c_equality_expression (ppi, e);
 889 }
 890
 891 static inline void
 892 pp_c_exclusive_or_expression (ppi, e)
 893      c_pretty_print_info *ppi;
 894      tree e;
 895 {
 896   if (TREE_CODE (e) == BIT_XOR_EXPR)
 897     {
 898       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 899       pp_c_maybe_whitespace (ppi);
 900       pp_carret (ppi);
 901       pp_c_whitespace (ppi);
 902       pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
 903     }
 904   else
 905     pp_c_and_expression (ppi, e);
 906 }
 907
 908 static inline void
 909 pp_c_inclusive_or_expression (ppi, e)
 910      c_pretty_print_info *ppi;
 911      tree e;
 912 {
 913   if (TREE_CODE (e) == BIT_IOR_EXPR)
 914     {
 915       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
 916       pp_c_maybe_whitespace (ppi);
 917       pp_bar (ppi);
 918       pp_c_whitespace (ppi);
 919       pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 920     }
 921   else
 922     pp_c_exclusive_or_expression (ppi, e);
 923 }
 924
 925 static inline void
 926 pp_c_logical_and_expression (ppi, e)
 927      c_pretty_print_info *ppi;
 928      tree e;
 929 {
 930   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
 931     {
 932       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
 933       pp_c_maybe_whitespace (ppi);
 934       pp_identifier (ppi, "&&");
 935       pp_c_whitespace (ppi);
 936       pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
 937     }
 938   else
 939     pp_c_inclusive_or_expression (ppi, e);
 940 }
 941
 942 void
 943 pp_c_logical_or_expression (ppi, e)
 944      c_pretty_print_info *ppi;
 945      tree e;
 946 {
 947   if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
 948     {
 949       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 950       pp_c_maybe_whitespace (ppi);
 951       pp_identifier (ppi, "||");
 952       pp_c_whitespace (ppi);
 953       pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
 954     }
 955   else
 956     pp_c_logical_and_expression (ppi, e);
 957 }
 958
 959 static void
 960 pp_c_conditional_expression (ppi, e)
 961      c_pretty_print_info *ppi;
 962      tree e;
 963 {
 964   if (TREE_CODE (e) == COND_EXPR)
 965     {
 966       pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
 967       pp_c_maybe_whitespace (ppi);
 968       pp_question (ppi);
 969       pp_c_whitespace (ppi);
 970       pp_c_expression (ppi, TREE_OPERAND (e, 1));
 971       pp_c_maybe_whitespace (ppi);
 972       pp_colon (ppi);
 973       pp_c_whitespace (ppi);
 974       pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
 975     }
 976   else
 977     pp_c_logical_or_expression (ppi, e);
 978 }
 979
 980
 981 /* Pretty-print a C assignment-expression.  */
 982 static void
 983 pp_c_assignment_expression (ppi, e)
 984      c_pretty_print_info *ppi;
 985      tree e;
 986 {
 987   if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
 988     {
 989       pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
 990       pp_c_maybe_whitespace (ppi);
 991       pp_equal (ppi);
 992       pp_whitespace (ppi);
 993       pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
 994     }
 995   else
 996     pp_c_conditional_expression (ppi, e);
 997 }
 998
 999 /* Pretty-print an expression.  */
1000 void
1001 pp_c_expression (ppi, e)
1002      c_pretty_print_info *ppi;
1003      tree e;
1004 {
1005   switch (TREE_CODE (e))
1006     {
1007     case INTEGER_CST:
1008       pp_c_integer_literal (ppi, e);
1009       break;
1010
1011     case REAL_CST:
1012       pp_c_real_literal (ppi, e);
1013       break;
1014
1015     case STRING_CST:
1016       pp_c_string_literal (ppi, e);
1017       break;
1018
1019     case FUNCTION_DECL:
1020     case VAR_DECL:
1021     case CONST_DECL:
1022     case PARM_DECL:
1023     case RESULT_DECL:
1024     case FIELD_DECL:
1025     case LABEL_DECL:
1026     case ERROR_MARK:
1027     case TARGET_EXPR:
1028     case STMT_EXPR:
1029       pp_c_primary_expression (ppi, e);
1030       break;
1031
1032     case POSTINCREMENT_EXPR:
1033     case POSTDECREMENT_EXPR:
1034     case ARROW_EXPR:
1035     case ARRAY_REF:
1036     case CALL_EXPR:
1037     case COMPONENT_REF:
1038     case COMPLEX_CST:
1039     case VECTOR_CST:
1040     case ABS_EXPR:
1041     case FFS_EXPR:
1042     case CONSTRUCTOR:
1043     case COMPOUND_LITERAL_EXPR:
1044     case COMPLEX_EXPR:
1045     case VA_ARG_EXPR:
1046       pp_c_postfix_expression (ppi, e);
1047       break;
1048
1049     case CONJ_EXPR:
1050     case ADDR_EXPR:
1051     case INDIRECT_REF:
1052     case NEGATE_EXPR:
1053     case BIT_NOT_EXPR:
1054     case TRUTH_NOT_EXPR:
1055     case PREINCREMENT_EXPR:
1056     case PREDECREMENT_EXPR:
1057     case SIZEOF_EXPR:
1058     case ALIGNOF_EXPR:
1059     case REALPART_EXPR:
1060     case IMAGPART_EXPR:
1061       pp_c_unary_expression (ppi, e);
1062       break;
1063
1064     case CONVERT_EXPR:
1065     case FLOAT_EXPR:
1066       pp_c_cast_expression (ppi, e);
1067       break;
1068
1069     case MULT_EXPR:
1070     case TRUNC_MOD_EXPR:
1071     case TRUNC_DIV_EXPR:
1072       pp_c_multiplicative_expression (ppi, e);
1073       break;
1074
1075     case LSHIFT_EXPR:
1076     case RSHIFT_EXPR:
1077       pp_c_shift_expression (ppi, e);
1078       break;
1079
1080     case LT_EXPR:
1081     case GT_EXPR:
1082     case LE_EXPR:
1083     case GE_EXPR:
1084       pp_c_relational_expression (ppi, e);
1085       break;
1086
1087     case BIT_AND_EXPR:
1088       pp_c_and_expression (ppi, e);
1089       break;
1090
1091     case BIT_XOR_EXPR:
1092       pp_c_exclusive_or_expression (ppi, e);
1093       break;
1094
1095     case BIT_IOR_EXPR:
1096       pp_c_inclusive_or_expression (ppi, e);
1097       break;
1098
1099     case TRUTH_ANDIF_EXPR:
1100       pp_c_logical_and_expression (ppi, e);
1101       break;
1102
1103     case TRUTH_ORIF_EXPR:
1104       pp_c_logical_or_expression (ppi, e);
1105       break;
1106
1107     case COND_EXPR:
1108       pp_c_conditional_expression (ppi, e);
1109       break;
1110
1111     case MODIFY_EXPR:
1112     case INIT_EXPR:
1113       pp_c_assignment_expression (ppi, e);
1114       break;
1115
1116     case NOP_EXPR:
1117       pp_c_expression (ppi, TREE_OPERAND (e, 0));
1118       break;
1119
1120     case COMPOUND_EXPR:
1121       pp_c_left_paren (ppi);
1122       pp_c_expression (ppi, TREE_OPERAND (e, 0));
1123       pp_separate_with (ppi, ',');
1124       pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
1125       pp_c_right_paren (ppi);
1126       break;
1127
1128
1129     default:
1130       pp_unsupported_tree (ppi, e);
1131       break;
1132     }
1133 }
1134
1135 \f
1136 /* Statements.  */
1137 void
1138 pp_c_statement (ppi, stmt)
1139      c_pretty_print_info *ppi;
1140      tree stmt;
1141 {
1142   const enum tree_code code = TREE_CODE (stmt);
1143   switch (code)
1144     {
1145     case LABEL_STMT:
1146     case CASE_LABEL:
1147       pp_newline (ppi);
1148       if (code == LABEL_STMT)
1149         pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt)));
1150       else if (code == LABEL_STMT)
1151         {
1152           if (CASE_LOW (stmt) == NULL_TREE)
1153             pp_identifier (ppi, "default");
1154           else
1155             {
1156               pp_c_identifier (ppi, "case");
1157               pp_c_whitespace (ppi);
1158               pp_conditional_expression (ppi, CASE_LOW (stmt));
1159               if (CASE_HIGH (stmt))
1160                 {
1161                   pp_identifier (ppi, "...");
1162                   pp_conditional_expression (ppi, CASE_HIGH (stmt));
1163                 }
1164             }
1165         }
1166       pp_colon (ppi);
1167       pp_newline_and_indent (ppi, 3);
1168       break;
1169
1170     case COMPOUND_STMT:
1171       pp_left_brace (ppi);
1172       pp_newline_and_indent (ppi, 3);
1173       for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt))
1174         pp_c_statement (ppi, stmt);
1175       pp_newline_and_indent (ppi, -3);
1176       pp_right_brace (ppi);
1177       pp_newline (ppi);
1178       break;
1179
1180     case EXPR_STMT:
1181     case CLEANUP_STMT:
1182       pp_newline (ppi);
1183       pp_c_expression (ppi, code == EXPR_STMT
1184                        ? EXPR_STMT_EXPR (stmt)
1185                        : CLEANUP_EXPR (stmt));
1186       pp_semicolon (ppi);
1187       pp_newline (ppi);
1188       break;
1189
1190     case IF_STMT:
1191       pp_c_identifier (ppi, "if");
1192       pp_whitespace (ppi);
1193       pp_c_left_paren (ppi);
1194       pp_c_expression (ppi, IF_COND (stmt));
1195       pp_right_paren (ppi);
1196       pp_newline_and_indent (ppi, 3);
1197       pp_statement (ppi, THEN_CLAUSE (stmt));
1198       pp_newline_and_indent (ppi, -3);
1199       if (ELSE_CLAUSE (stmt))
1200         {
1201           tree else_clause = ELSE_CLAUSE (stmt);
1202           pp_c_identifier (ppi, "else");
1203           if (TREE_CODE (else_clause) == IF_STMT)
1204             pp_c_whitespace (ppi);
1205           else
1206             pp_newline_and_indent (ppi, 3);
1207           pp_statement (ppi, else_clause);
1208           if (TREE_CODE (else_clause) != IF_STMT)
1209             pp_newline_and_indent (ppi, -3);
1210         }
1211       break;
1212
1213     case SWITCH_STMT:
1214       pp_newline (ppi);
1215       pp_c_identifier (ppi, "switch");
1216       pp_whitespace (ppi);
1217       pp_c_left_paren (ppi);
1218       pp_c_expression (ppi, SWITCH_COND (stmt));
1219       pp_right_paren (ppi);
1220       pp_newline_and_indent (ppi, 3);
1221       pp_statement (ppi, SWITCH_BODY (stmt));
1222       pp_newline_and_indent (ppi, -3);
1223       break;
1224
1225     case WHILE_STMT:
1226       pp_c_identifier (ppi, "while");
1227       pp_whitespace (ppi);
1228       pp_c_left_paren (ppi);
1229       pp_c_expression (ppi, WHILE_COND (stmt));
1230       pp_right_paren (ppi);
1231       pp_newline_and_indent (ppi, 3);
1232       pp_statement (ppi, WHILE_BODY (stmt));
1233       pp_newline_and_indent (ppi, -3);
1234       break;
1235
1236     case DO_STMT:
1237       pp_c_identifier (ppi, "do");
1238       pp_newline_and_indent (ppi, 3);
1239       pp_statement (ppi, DO_BODY (stmt));
1240       pp_newline_and_indent (ppi, -3);
1241       pp_c_identifier (ppi, "while");
1242       pp_whitespace (ppi);
1243       pp_c_left_paren (ppi);
1244       pp_c_expression (ppi, DO_COND (stmt));
1245       pp_c_right_paren (ppi);
1246       pp_semicolon (ppi);
1247       pp_newline (ppi);
1248       break;
1249
1250     case FOR_STMT:
1251       pp_c_identifier (ppi, "for");
1252       pp_whitespace (ppi);
1253       pp_c_left_paren (ppi);
1254       pp_statement (ppi, FOR_INIT_STMT (stmt));
1255       pp_c_whitespace (ppi);
1256       if (FOR_COND (stmt))
1257         pp_c_expression (ppi, FOR_COND (stmt));
1258       pp_semicolon (ppi);
1259       pp_c_whitespace (ppi);
1260       if (FOR_EXPR (stmt))
1261         pp_c_expression (ppi, FOR_EXPR (stmt));
1262       pp_right_paren (ppi);
1263       pp_newline_and_indent (ppi, 3);
1264       pp_statement (ppi, FOR_BODY (stmt));
1265       pp_newline_and_indent (ppi, -3);
1266       break;
1267
1268     case BREAK_STMT:
1269     case CONTINUE_STMT:
1270       pp_newline (ppi);
1271       pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue");
1272       pp_semicolon (ppi);
1273       pp_newline (ppi);
1274       break;
1275
1276     case RETURN_STMT:
1277     case GOTO_STMT:
1278       {
1279         tree e = code == RETURN_STMT
1280           ? RETURN_EXPR (stmt)
1281           : GOTO_DESTINATION (stmt);
1282
1283         pp_newline (ppi);
1284         pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto");
1285         if (e)
1286           pp_c_expression (ppi, e);
1287         pp_semicolon (ppi);
1288         pp_newline (ppi);
1289       }
1290       break;
1291
1292     case SCOPE_STMT:
1293       if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt))
1294         {
1295           if (SCOPE_BEGIN_P (stmt))
1296             {
1297               pp_left_brace (ppi);
1298               pp_newline_and_indent (ppi, 3);
1299             }
1300           else if (SCOPE_END_P (stmt))
1301             {
1302               pp_right_brace (ppi);
1303               pp_newline_and_indent (ppi, -3);
1304             }
1305         }
1306       break;
1307
1308     case DECL_STMT:
1309       pp_declaration (ppi, DECL_STMT_DECL (stmt));
1310       pp_semicolon (ppi);
1311       pp_newline (ppi);
1312       break;
1313
1314     case ASM_STMT:
1315       {
1316         bool has_volatile_p = ASM_VOLATILE_P (stmt);
1317         bool is_extended = has_volatile_p || ASM_INPUTS (stmt)
1318           || ASM_OUTPUTS (stmt) || ASM_CLOBBERS (stmt);
1319         pp_c_identifier (ppi, is_extended ? "__asm__" : "asm");
1320         if (has_volatile_p)
1321           pp_c_identifier (ppi, "__volatile__");
1322         pp_whitespace (ppi);
1323         pp_c_left_paren (ppi);
1324         pp_c_string_literal (ppi, ASM_STRING (stmt));
1325         if (is_extended)
1326           {
1327             pp_whitespace (ppi);
1328             pp_separate_with (ppi, ':');
1329             if (ASM_OUTPUTS (stmt))
1330               pp_c_expression (ppi, ASM_OUTPUTS (stmt));
1331             pp_whitespace (ppi);
1332             pp_separate_with (ppi, ':');
1333             if (ASM_INPUTS (stmt))
1334               pp_c_expression (ppi, ASM_INPUTS (stmt));
1335             pp_whitespace (ppi);
1336             pp_separate_with (ppi, ':');
1337             if (ASM_CLOBBERS (stmt))
1338               pp_c_expression (ppi, ASM_CLOBBERS (stmt));
1339           }
1340         pp_right_paren (ppi);
1341         pp_newline (ppi);
1342       }
1343       break;
1344
1345     case FILE_STMT:
1346       pp_c_identifier (ppi, "__FILE__");
1347       pp_whitespace (ppi);
1348       pp_equal (ppi);
1349       pp_c_whitespace (ppi);
1350       pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt));
1351       pp_semicolon (ppi);
1352       pp_newline (ppi);
1353       break;
1354
1355     default:
1356       pp_unsupported_tree (ppi, stmt);
1357     }
1358
1359 }
1360