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