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