00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "config.h"
00023 #include "system.h"
00024 #include "real.h"
00025 #include "c-pretty-print.h"
00026 #include "c-tree.h"
00027
00028
00029 static void pp_c_char PARAMS ((c_pretty_printer, int));
00030 static void pp_c_character_literal PARAMS ((c_pretty_printer, tree));
00031 static void pp_c_bool_literal PARAMS ((c_pretty_printer, tree));
00032 static bool pp_c_enumerator PARAMS ((c_pretty_printer, tree));
00033 static void pp_c_integer_literal PARAMS ((c_pretty_printer, tree));
00034 static void pp_c_real_literal PARAMS ((c_pretty_printer, tree));
00035 static void pp_c_string_literal PARAMS ((c_pretty_printer, tree));
00036
00037 static void pp_c_primary_expression PARAMS ((c_pretty_printer, tree));
00038
00039
00040 static void pp_c_initializer_list PARAMS ((c_pretty_printer, tree));
00041
00042 static void pp_c_unary_expression PARAMS ((c_pretty_printer, tree));
00043 static void pp_c_multiplicative_expression PARAMS ((c_pretty_printer, tree));
00044 static void pp_c_additive_expression PARAMS ((c_pretty_printer, tree));
00045 static void pp_c_shift_expression PARAMS ((c_pretty_printer, tree));
00046 static void pp_c_relational_expression PARAMS ((c_pretty_printer, tree));
00047 static void pp_c_equality_expression PARAMS ((c_pretty_printer, tree));
00048 static void pp_c_and_expression PARAMS ((c_pretty_printer, tree));
00049 static void pp_c_exclusive_or_expression PARAMS ((c_pretty_printer,
00050 tree));
00051 static void pp_c_inclusive_or_expression PARAMS ((c_pretty_printer,
00052 tree));
00053 static void pp_c_logical_and_expression PARAMS ((c_pretty_printer, tree));
00054 static void pp_c_conditional_expression PARAMS ((c_pretty_printer, tree));
00055 static void pp_c_assignment_expression PARAMS ((c_pretty_printer, tree));
00056
00057
00058 static void pp_c_declaration_specifiers PARAMS ((c_pretty_printer, tree));
00059 static void pp_c_init_declarator PARAMS ((c_pretty_printer, tree));
00060 static void pp_c_declarator PARAMS ((c_pretty_printer, tree));
00061 static void pp_c_direct_declarator PARAMS ((c_pretty_printer, tree));
00062 static void pp_c_abstract_declarator PARAMS ((c_pretty_printer, tree));
00063 static void pp_c_specifier_qualifier_list PARAMS ((c_pretty_printer, tree));
00064 static void pp_c_simple_type_specifier PARAMS ((c_pretty_printer, tree));
00065 static void pp_c_parameter_declaration PARAMS ((c_pretty_printer, tree));
00066 static void pp_c_type_id PARAMS ((c_pretty_printer, tree));
00067 static void pp_c_storage_class_specifier PARAMS ((c_pretty_printer, tree));
00068 static void pp_c_function_specifier PARAMS ((c_pretty_printer, tree));
00069
00070
00071
00072
00073
00074 void
00075 pp_c_cv_qualifier (ppi, cv)
00076 c_pretty_printer ppi;
00077 int cv;
00078 {
00079 if (cv & TYPE_QUAL_CONST)
00080 pp_c_identifier (ppi, "const");
00081 if (cv & TYPE_QUAL_VOLATILE)
00082 pp_c_identifier (ppi, "volatile");
00083 if (cv & TYPE_QUAL_RESTRICT)
00084 pp_c_identifier (ppi, flag_isoc99 ? "restrict" : "__restrict__");
00085 }
00086
00087 static void
00088 pp_c_simple_type_specifier (ppi, t)
00089 c_pretty_printer ppi;
00090 tree t;
00091 {
00092 const enum tree_code code = TREE_CODE (t);
00093 switch (code)
00094 {
00095 case ERROR_MARK:
00096 pp_c_identifier (ppi, "<type-error>");
00097 break;
00098
00099 #if 0
00100 case UNKNOWN_TYPE:
00101 pp_c_identifier (ppi, "<unkown-type>");
00102 break;
00103 #endif
00104
00105 case IDENTIFIER_NODE:
00106 pp_c_tree_identifier (ppi, t);
00107 break;
00108
00109 case VOID_TYPE:
00110 case BOOLEAN_TYPE:
00111 case CHAR_TYPE:
00112 case INTEGER_TYPE:
00113 case REAL_TYPE:
00114 pp_c_tree_identifier (ppi, DECL_NAME (t));
00115 break;
00116
00117 case COMPLEX_TYPE:
00118 case VECTOR_TYPE:
00119 pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
00120 if (code == COMPLEX_TYPE)
00121 pp_c_identifier (ppi, flag_isoc99 ? "_Complex" : "__complex__");
00122 else if (code == VECTOR_TYPE)
00123 pp_c_identifier (ppi, "__vector__");
00124 break;
00125
00126 case TYPE_DECL:
00127 if (DECL_NAME (t))
00128 pp_c_tree_identifier (ppi, DECL_NAME (t));
00129 else
00130 pp_c_identifier (ppi, "<typedef-error>");
00131 break;
00132
00133 case UNION_TYPE:
00134 case RECORD_TYPE:
00135 case ENUMERAL_TYPE:
00136 if (code == UNION_TYPE)
00137 pp_c_identifier (ppi, "union");
00138 else if (code == RECORD_TYPE)
00139 pp_c_identifier (ppi, "struct");
00140 else if (code == ENUMERAL_TYPE)
00141 pp_c_identifier (ppi, "enum");
00142 else
00143 pp_c_identifier (ppi, "<tag-error>");
00144
00145 if (TYPE_NAME (t))
00146 pp_c_tree_identifier (ppi, TYPE_NAME (t));
00147 else
00148 pp_c_identifier (ppi, "<anonymous>");
00149 break;
00150
00151 default:
00152 pp_unsupported_tree (ppi, t);
00153 }
00154 }
00155
00156 static inline void
00157 pp_c_specifier_qualifier_list (ppi, t)
00158 c_pretty_printer ppi;
00159 tree t;
00160 {
00161 pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
00162 pp_c_cv_qualifier (ppi, TYPE_QUALS (t));
00163 }
00164
00165 static void
00166 pp_c_abstract_declarator (ppi, t)
00167 c_pretty_printer ppi;
00168 tree t;
00169 {
00170 pp_unsupported_tree (ppi, t);
00171 }
00172
00173
00174 static inline void
00175 pp_c_type_id (ppi, t)
00176 c_pretty_printer ppi;
00177 tree t;
00178 {
00179 pp_c_specifier_qualifier_list (ppi, t);
00180 pp_c_abstract_declarator (ppi, t);
00181 }
00182
00183 static inline void
00184 pp_c_storage_class_specifier (pp, t)
00185 c_pretty_printer pp;
00186 tree t;
00187 {
00188 if (TREE_CODE (t) == TYPE_DECL)
00189 pp_c_identifier (pp, "typedef");
00190 else if (DECL_REGISTER (t))
00191 pp_c_identifier (pp, "register");
00192 }
00193
00194 static inline void
00195 pp_c_function_specifier (pp, t)
00196 c_pretty_printer pp;
00197 tree t;
00198 {
00199 if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
00200 pp_c_identifier (pp, "inline");
00201 }
00202
00203 static inline void
00204 pp_c_declaration_specifiers (pp, t)
00205 c_pretty_printer pp;
00206 tree t;
00207 {
00208 pp_c_storage_class_specifier (pp, t);
00209 pp_c_function_specifier (pp, t);
00210 pp_type_specifier (pp, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
00211 pp_c_cv_qualifier (pp, TYPE_QUALS (TREE_TYPE (t)));
00212 }
00213
00214 static inline void
00215 pp_c_direct_declarator (pp, t)
00216 c_pretty_printer pp;
00217 tree t;
00218 {
00219 pp_unsupported_tree (pp, t);
00220 }
00221
00222 static inline void
00223 pp_c_declarator (pp, t)
00224 c_pretty_printer pp;
00225 tree t;
00226 {
00227 pp_unsupported_tree (pp, t);
00228 }
00229
00230 static inline void
00231 pp_c_init_declarator (pp, t)
00232 c_pretty_printer pp;
00233 tree t;
00234 {
00235 pp_declarator (pp, t);
00236 if (DECL_INITIAL (t))
00237 {
00238 pp_whitespace (pp);
00239 pp_equal (pp);
00240 pp_whitespace (pp);
00241 pp_c_initializer (pp, DECL_INITIAL (t));
00242 }
00243 }
00244
00245 void
00246 pp_c_declaration (pp, t)
00247 c_pretty_printer pp;
00248 tree t;
00249 {
00250 pp_declaration_specifiers (pp, t);
00251 pp_c_init_declarator (pp, t);
00252 }
00253
00254 static void
00255 pp_c_parameter_declaration (pp, t)
00256 c_pretty_printer pp;
00257 tree t;
00258 {
00259 pp_unsupported_tree (pp, t);
00260 }
00261
00262
00263 void
00264 pp_c_attributes (pp, attributes)
00265 c_pretty_printer pp;
00266 tree attributes;
00267 {
00268 if (attributes == NULL_TREE)
00269 return;
00270
00271 pp_c_identifier (pp, "__attribute__");
00272 pp_c_left_paren (pp);
00273 pp_c_left_paren (pp);
00274 for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
00275 {
00276 pp_tree_identifier (pp, TREE_PURPOSE (attributes));
00277 if (TREE_VALUE (attributes))
00278 {
00279 pp_c_left_paren (pp);
00280 pp_c_expression_list (pp, TREE_VALUE (attributes));
00281 pp_c_right_paren (pp);
00282 }
00283
00284 if (TREE_CHAIN (attributes))
00285 pp_separate_with (pp, ',');
00286 }
00287 pp_c_right_paren (pp);
00288 pp_c_right_paren (pp);
00289 }
00290
00291
00292
00293
00294
00295 static void
00296 pp_c_char (ppi, c)
00297 c_pretty_printer ppi;
00298 int c;
00299 {
00300 switch (c)
00301 {
00302 case TARGET_NEWLINE:
00303 pp_identifier (ppi, "\\n");
00304 break;
00305 case TARGET_TAB:
00306 pp_identifier (ppi, "\\t");
00307 break;
00308 case TARGET_VT:
00309 pp_identifier (ppi, "\\v");
00310 break;
00311 case TARGET_BS:
00312 pp_identifier (ppi, "\\b");
00313 break;
00314 case TARGET_CR:
00315 pp_identifier (ppi, "\\r");
00316 break;
00317 case TARGET_FF:
00318 pp_identifier (ppi, "\\f");
00319 break;
00320 case TARGET_BELL:
00321 pp_identifier (ppi, "\\a");
00322 break;
00323 case '\\':
00324 pp_identifier (ppi, "\\\\");
00325 break;
00326 case '\'':
00327 pp_identifier (ppi, "\\'");
00328 break;
00329 case '\"':
00330 pp_identifier (ppi, "\\\"");
00331 break;
00332 default:
00333 if (ISPRINT (c))
00334 pp_character (ppi, c);
00335 else
00336 pp_format_scalar (ppi, "\\%03o", (unsigned) c);
00337 break;
00338 }
00339 }
00340
00341
00342 static inline void
00343 pp_c_string_literal (ppi, s)
00344 c_pretty_printer ppi;
00345 tree s;
00346 {
00347 const char *p = TREE_STRING_POINTER (s);
00348 int n = TREE_STRING_LENGTH (s) - 1;
00349 int i;
00350 pp_doublequote (ppi);
00351 for (i = 0; i < n; ++i)
00352 pp_c_char (ppi, p[i]);
00353 pp_doublequote (ppi);
00354 }
00355
00356
00357 static inline void
00358 pp_c_character_literal (ppi, c)
00359 c_pretty_printer ppi;
00360 tree c;
00361 {
00362 pp_quote (ppi);
00363 pp_c_char (ppi, tree_low_cst (c, 0));
00364 pp_quote (ppi);
00365 }
00366
00367
00368 static inline void
00369 pp_c_bool_literal (ppi, b)
00370 c_pretty_printer ppi;
00371 tree b;
00372 {
00373 if (b == boolean_false_node || integer_zerop (b))
00374 {
00375 if (c_language == clk_cplusplus)
00376 pp_c_identifier (ppi, "false");
00377 else if (c_language == clk_c && flag_isoc99)
00378 pp_c_identifier (ppi, "_False");
00379 else
00380 pp_unsupported_tree (ppi, b);
00381 }
00382 else if (b == boolean_true_node)
00383 {
00384 if (c_language == clk_cplusplus)
00385 pp_c_identifier (ppi, "true");
00386 else if (c_language == clk_c && flag_isoc99)
00387 pp_c_identifier (ppi, "_True");
00388 else
00389 pp_unsupported_tree (ppi, b);
00390 }
00391 else
00392 pp_unsupported_tree (ppi, b);
00393 }
00394
00395
00396
00397
00398
00399 static bool
00400 pp_c_enumerator (ppi, e)
00401 c_pretty_printer ppi;
00402 tree e;
00403 {
00404 tree type = TREE_TYPE (e);
00405 tree value;
00406
00407
00408 for (value = TYPE_VALUES (type);
00409 value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
00410 value = TREE_CHAIN (value))
00411 ;
00412
00413 if (value != NULL_TREE)
00414 pp_c_tree_identifier (ppi, TREE_PURPOSE (value));
00415 else
00416 {
00417
00418 pp_c_left_paren (ppi);
00419 pp_type_id (ppi, type);
00420 pp_c_right_paren (ppi);
00421 return false;
00422 }
00423
00424 return true;
00425 }
00426
00427
00428 static void
00429 pp_c_integer_literal (ppi, i)
00430 c_pretty_printer ppi;
00431 tree i;
00432 {
00433 tree type = TREE_TYPE (i);
00434
00435 if (type == boolean_type_node)
00436 pp_c_bool_literal (ppi, i);
00437 else if (type == char_type_node)
00438 pp_c_character_literal (ppi, i);
00439 else if (TREE_CODE (type) == ENUMERAL_TYPE
00440 && pp_c_enumerator (ppi, i))
00441 ;
00442 else
00443 {
00444 if (host_integerp (i, 0))
00445 pp_wide_integer (ppi, TREE_INT_CST_LOW (i));
00446 else
00447 {
00448 if (tree_int_cst_sgn (i) < 0)
00449 {
00450 static char format[10];
00451 if (!format[0])
00452 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
00453
00454 pp_c_char (ppi, '-');
00455 i = build_int_2 (-TREE_INT_CST_LOW (i),
00456 ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
00457 sprintf (pp_buffer (ppi)->digit_buffer, format,
00458 TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
00459 pp_identifier (ppi, pp_buffer (ppi)->digit_buffer);
00460
00461 }
00462 }
00463 }
00464 }
00465
00466
00467 static inline void
00468 pp_c_real_literal (ppi, r)
00469 c_pretty_printer ppi;
00470 tree r;
00471 {
00472 real_to_decimal (pp_buffer (ppi)->digit_buffer, &TREE_REAL_CST (r),
00473 sizeof (pp_buffer (ppi)->digit_buffer), 0, 1);
00474 pp_identifier (ppi, pp_buffer(ppi)->digit_buffer);
00475 }
00476
00477
00478 void
00479 pp_c_literal (ppi, e)
00480 c_pretty_printer ppi;
00481 tree e;
00482 {
00483 switch (TREE_CODE (e))
00484 {
00485 case INTEGER_CST:
00486 pp_c_integer_literal (ppi, e);
00487 break;
00488
00489 case REAL_CST:
00490 pp_c_real_literal (ppi, e);
00491 break;
00492
00493 case STRING_CST:
00494 pp_c_string_literal (ppi, e);
00495 break;
00496
00497 default:
00498 pp_unsupported_tree (ppi, e);
00499 break;
00500 }
00501 }
00502
00503
00504 static void
00505 pp_c_primary_expression (ppi, e)
00506 c_pretty_printer ppi;
00507 tree e;
00508 {
00509 switch (TREE_CODE (e))
00510 {
00511 case VAR_DECL:
00512 case PARM_DECL:
00513 case FIELD_DECL:
00514 case CONST_DECL:
00515 case FUNCTION_DECL:
00516 case LABEL_DECL:
00517 e = DECL_NAME (e);
00518
00519 case IDENTIFIER_NODE:
00520 pp_c_tree_identifier (ppi, e);
00521 break;
00522
00523 case ERROR_MARK:
00524 pp_c_identifier (ppi, "<erroneous-expression>");
00525 break;
00526
00527 case RESULT_DECL:
00528 pp_c_identifier (ppi, "<return-value>");
00529 break;
00530
00531 case INTEGER_CST:
00532 case REAL_CST:
00533 case STRING_CST:
00534 pp_c_literal (ppi, e);
00535 break;
00536
00537 case TARGET_EXPR:
00538 pp_c_left_paren (ppi);
00539 pp_c_identifier (ppi, "__builtin_memcpy");
00540 pp_c_left_paren (ppi);
00541 pp_ampersand (ppi);
00542 pp_c_primary_expression (ppi, TREE_OPERAND (e, 0));
00543 pp_separate_with (ppi, ',');
00544 pp_ampersand (ppi);
00545 pp_initializer (ppi, TREE_OPERAND (e, 1));
00546 if (TREE_OPERAND (e, 2))
00547 {
00548 pp_separate_with (ppi, ',');
00549 pp_c_expression (ppi, TREE_OPERAND (e, 2));
00550 }
00551 pp_c_right_paren (ppi);
00552
00553 case STMT_EXPR:
00554 pp_c_left_paren (ppi);
00555 pp_statement (ppi, STMT_EXPR_STMT (e));
00556 pp_c_right_paren (ppi);
00557 break;
00558
00559 default:
00560
00561 pp_c_left_paren (ppi);
00562 pp_c_expression (ppi, e);
00563 pp_c_right_paren (ppi);
00564 break;
00565 }
00566 }
00567
00568
00569 void
00570 pp_c_initializer (ppi, e)
00571 c_pretty_printer ppi;
00572 tree e;
00573 {
00574 if (TREE_CODE (e) == CONSTRUCTOR)
00575 {
00576 enum tree_code code = TREE_CODE (TREE_TYPE (e));
00577 if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
00578 {
00579 pp_left_brace (ppi);
00580 pp_c_initializer_list (ppi, e);
00581 pp_right_brace (ppi);
00582 }
00583 else
00584 pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
00585 }
00586 else
00587 pp_assignment_expression (ppi, e);
00588 }
00589
00590 static void
00591 pp_c_initializer_list (ppi, e)
00592 c_pretty_printer ppi;
00593 tree e;
00594 {
00595 tree type = TREE_TYPE (e);
00596 const enum tree_code code = TREE_CODE (type);
00597
00598 if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
00599 {
00600 tree init = TREE_OPERAND (e, 1);
00601 for (; init != NULL_TREE; init = TREE_CHAIN (init))
00602 {
00603 if (code == RECORD_TYPE || code == UNION_TYPE)
00604 {
00605 pp_dot (ppi);
00606 pp_c_primary_expression (ppi, TREE_PURPOSE (init));
00607 }
00608 else
00609 {
00610 pp_c_left_bracket (ppi);
00611 if (TREE_PURPOSE (init))
00612 pp_c_literal (ppi, TREE_PURPOSE (init));
00613 pp_c_right_bracket (ppi);
00614 }
00615 pp_c_whitespace (ppi);
00616 pp_equal (ppi);
00617 pp_c_whitespace (ppi);
00618 pp_initializer (ppi, TREE_VALUE (init));
00619 if (TREE_CHAIN (init))
00620 pp_separate_with (ppi, ',');
00621 }
00622 }
00623 else
00624 pp_unsupported_tree (ppi, type);
00625 }
00626
00627 void
00628 pp_c_postfix_expression (ppi, e)
00629 c_pretty_printer ppi;
00630 tree e;
00631 {
00632 enum tree_code code = TREE_CODE (e);
00633 switch (code)
00634 {
00635 case POSTINCREMENT_EXPR:
00636 case POSTDECREMENT_EXPR:
00637 pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
00638 pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
00639 break;
00640
00641 case ARROW_EXPR:
00642 pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
00643 pp_arrow (ppi);
00644 break;
00645
00646 case ARRAY_REF:
00647 pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
00648 pp_c_left_bracket (ppi);
00649 pp_c_expression (ppi, TREE_OPERAND (e, 1));
00650 pp_c_right_bracket (ppi);
00651 break;
00652
00653 case CALL_EXPR:
00654 pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
00655 pp_c_left_paren (ppi);
00656 pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
00657 pp_c_right_paren (ppi);
00658 break;
00659
00660 case ABS_EXPR:
00661 case FFS_EXPR:
00662 pp_c_identifier (ppi,
00663 code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs");
00664 pp_c_left_paren (ppi);
00665 pp_c_expression (ppi, TREE_OPERAND (e, 0));
00666 pp_c_right_paren (ppi);
00667 break;
00668
00669 case COMPONENT_REF:
00670 {
00671 tree object = TREE_OPERAND (e, 0);
00672 if (TREE_CODE (object) == INDIRECT_REF)
00673 {
00674 pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
00675 pp_arrow (ppi);
00676 }
00677 else
00678 {
00679 pp_postfix_expression (ppi, object);
00680 pp_dot (ppi);
00681 }
00682 pp_c_expression (ppi, TREE_OPERAND (e, 1));
00683 }
00684 break;
00685
00686 case COMPLEX_CST:
00687 case VECTOR_CST:
00688 case COMPLEX_EXPR:
00689 pp_c_left_paren (ppi);
00690 pp_type_id (ppi, TREE_TYPE (e));
00691 pp_c_right_paren (ppi);
00692 pp_left_brace (ppi);
00693
00694 if (code == COMPLEX_CST)
00695 {
00696 pp_c_expression (ppi, TREE_REALPART (e));
00697 pp_separate_with (ppi, ',');
00698 pp_c_expression (ppi, TREE_IMAGPART (e));
00699 }
00700 else if (code == VECTOR_CST)
00701 pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e));
00702 else if (code == COMPLEX_EXPR)
00703 {
00704 pp_c_expression (ppi, TREE_OPERAND (e, 0));
00705 pp_separate_with (ppi, ',');
00706 pp_c_expression (ppi, TREE_OPERAND (e, 1));
00707 }
00708
00709 pp_right_brace (ppi);
00710 break;
00711
00712 case COMPOUND_LITERAL_EXPR:
00713 e = DECL_INITIAL (e);
00714
00715 case CONSTRUCTOR:
00716 pp_initializer (ppi, e);
00717 break;
00718
00719 #if 0
00720 case SRCLOC:
00721 pp_left_paren (ppi);
00722 pp_identifier (ppi, "__location__");
00723 pp_right_paren (ppi);
00724 pp_whitespace (ppi);
00725 pp_left_brace (ppi);
00726 pp_dot (ppi);
00727 pp_identifier (ppi, "file");
00728 pp_whitespace (ppi);
00729 pp_equal (ppi);
00730 pp_c_whitespace (ppi);
00731 pp_c_expression (ppi, SRCLOC_FILE (e));
00732 pp_separate_with (ppi, ',');
00733 pp_dot (ppi);
00734 pp_identifier (ppi, "line");
00735 pp_whitespace (ppi);
00736 pp_equal (ppi);
00737 pp_c_whitespace (ppi);
00738 pp_c_expression (ppi, SRCLOC_LINE (e));
00739 pp_right_brace (ppi);
00740 break;
00741 #endif
00742
00743 case VA_ARG_EXPR:
00744 pp_c_identifier (ppi, "__builtin_va_arg");
00745 pp_c_left_paren (ppi);
00746 pp_assignment_expression (ppi, TREE_OPERAND (e, 0));
00747 pp_separate_with (ppi, ',');
00748 pp_type_id (ppi, TREE_TYPE (e));
00749 pp_c_right_paren (ppi);
00750 break;
00751
00752 default:
00753 pp_primary_expression (ppi, e);
00754 break;
00755 }
00756 }
00757
00758
00759 void
00760 pp_c_expression_list (ppi, e)
00761 c_pretty_printer ppi;
00762 tree e;
00763 {
00764 for (; e != NULL_TREE; e = TREE_CHAIN (e))
00765 {
00766 pp_c_assignment_expression (ppi, TREE_VALUE (e));
00767 if (TREE_CHAIN (e))
00768 pp_separate_with (ppi, ',');
00769 }
00770 }
00771
00772 static void
00773 pp_c_unary_expression (ppi, e)
00774 c_pretty_printer ppi;
00775 tree e;
00776 {
00777 enum tree_code code = TREE_CODE (e);
00778 switch (code)
00779 {
00780 case PREINCREMENT_EXPR:
00781 case PREDECREMENT_EXPR:
00782 pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
00783 pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
00784 break;
00785
00786 case ADDR_EXPR:
00787 case INDIRECT_REF:
00788 case CONVERT_EXPR:
00789 case NEGATE_EXPR:
00790 case BIT_NOT_EXPR:
00791 case TRUTH_NOT_EXPR:
00792 case CONJ_EXPR:
00793 if (code == ADDR_EXPR)
00794 pp_ampersand (ppi);
00795 else if (code == INDIRECT_REF)
00796 pp_star (ppi);
00797 else if (code == NEGATE_EXPR)
00798 pp_minus (ppi);
00799 else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
00800 pp_complement (ppi);
00801 else if (code == TRUTH_NOT_EXPR)
00802 pp_exclamation (ppi);
00803 pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
00804 break;
00805
00806 case SIZEOF_EXPR:
00807 case ALIGNOF_EXPR:
00808 pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
00809 pp_c_whitespace (ppi);
00810 if (TYPE_P (TREE_OPERAND (e, 0)))
00811 {
00812 pp_c_left_paren (ppi);
00813 pp_type_id (ppi, TREE_OPERAND (e, 0));
00814 pp_c_right_paren (ppi);
00815 }
00816 else
00817 pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
00818 break;
00819
00820 case REALPART_EXPR:
00821 case IMAGPART_EXPR:
00822 pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__");
00823 pp_c_whitespace (ppi);
00824 pp_unary_expression (ppi, TREE_OPERAND (e, 0));
00825 break;
00826
00827 default:
00828 pp_postfix_expression (ppi, e);
00829 break;
00830 }
00831 }
00832
00833 void
00834 pp_c_cast_expression (ppi, e)
00835 c_pretty_printer ppi;
00836 tree e;
00837 {
00838 if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
00839 {
00840 pp_c_left_paren (ppi);
00841 pp_type_id (ppi, TREE_TYPE (e));
00842 pp_c_right_paren (ppi);
00843 pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
00844 }
00845 else
00846 pp_unary_expression (ppi, e);
00847 }
00848
00849 static void
00850 pp_c_multiplicative_expression (ppi, e)
00851 c_pretty_printer ppi;
00852 tree e;
00853 {
00854 enum tree_code code = TREE_CODE (e);
00855 switch (code)
00856 {
00857 case MULT_EXPR:
00858 case TRUNC_DIV_EXPR:
00859 case TRUNC_MOD_EXPR:
00860 pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
00861 pp_c_whitespace (ppi);
00862 if (code == MULT_EXPR)
00863 pp_star (ppi);
00864 else if (code == TRUNC_DIV_EXPR)
00865 pp_slash (ppi);
00866 else
00867 pp_modulo (ppi);
00868 pp_c_whitespace (ppi);
00869 pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
00870 break;
00871
00872 default:
00873 pp_c_cast_expression (ppi, e);
00874 break;
00875 }
00876 }
00877
00878 static inline void
00879 pp_c_additive_expression (ppi, e)
00880 c_pretty_printer ppi;
00881 tree e;
00882 {
00883 enum tree_code code = TREE_CODE (e);
00884 switch (code)
00885 {
00886 case PLUS_EXPR:
00887 case MINUS_EXPR:
00888 pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
00889 pp_c_whitespace (ppi);
00890 if (code == PLUS_EXPR)
00891 pp_plus (ppi);
00892 else
00893 pp_minus (ppi);
00894 pp_c_whitespace (ppi);
00895 pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
00896 break;
00897
00898 default:
00899 pp_multiplicative_expression (ppi, e);
00900 break;
00901 }
00902 }
00903
00904 static inline void
00905 pp_c_shift_expression (ppi, e)
00906 c_pretty_printer ppi;
00907 tree e;
00908 {
00909 enum tree_code code = TREE_CODE (e);
00910 switch (code)
00911 {
00912 case LSHIFT_EXPR:
00913 case RSHIFT_EXPR:
00914 pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
00915 pp_c_whitespace (ppi);
00916 pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
00917 pp_c_whitespace (ppi);
00918 pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
00919 break;
00920
00921 default:
00922 pp_c_additive_expression (ppi, e);
00923 }
00924 }
00925
00926 static void
00927 pp_c_relational_expression (ppi, e)
00928 c_pretty_printer ppi;
00929 tree e;
00930 {
00931 enum tree_code code = TREE_CODE (e);
00932 switch (code)
00933 {
00934 case LT_EXPR:
00935 case GT_EXPR:
00936 case LE_EXPR:
00937 case GE_EXPR:
00938 pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
00939 pp_c_whitespace (ppi);
00940 if (code == LT_EXPR)
00941 pp_less (ppi);
00942 else if (code == GT_EXPR)
00943 pp_greater (ppi);
00944 else if (code == LE_EXPR)
00945 pp_identifier (ppi, "<=");
00946 else if (code == GE_EXPR)
00947 pp_identifier (ppi, ">=");
00948 pp_c_whitespace (ppi);
00949 pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
00950 break;
00951
00952 default:
00953 pp_c_shift_expression (ppi, e);
00954 break;
00955 }
00956 }
00957
00958 static inline void
00959 pp_c_equality_expression (ppi, e)
00960 c_pretty_printer ppi;
00961 tree e;
00962 {
00963 enum tree_code code = TREE_CODE (e);
00964 switch (code)
00965 {
00966 case EQ_EXPR:
00967 case NE_EXPR:
00968 pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
00969 pp_c_maybe_whitespace (ppi);
00970 pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
00971 pp_c_whitespace (ppi);
00972 pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
00973 break;
00974
00975 default:
00976 pp_c_relational_expression (ppi, e);
00977 break;
00978 }
00979 }
00980
00981 static inline void
00982 pp_c_and_expression (ppi, e)
00983 c_pretty_printer ppi;
00984 tree e;
00985 {
00986 if (TREE_CODE (e) == BIT_AND_EXPR)
00987 {
00988 pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
00989 pp_c_maybe_whitespace (ppi);
00990 pp_ampersand (ppi);
00991 pp_c_whitespace (ppi);
00992 pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
00993 }
00994 else
00995 pp_c_equality_expression (ppi, e);
00996 }
00997
00998 static inline void
00999 pp_c_exclusive_or_expression (ppi, e)
01000 c_pretty_printer ppi;
01001 tree e;
01002 {
01003 if (TREE_CODE (e) == BIT_XOR_EXPR)
01004 {
01005 pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
01006 pp_c_maybe_whitespace (ppi);
01007 pp_carret (ppi);
01008 pp_c_whitespace (ppi);
01009 pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
01010 }
01011 else
01012 pp_c_and_expression (ppi, e);
01013 }
01014
01015 static inline void
01016 pp_c_inclusive_or_expression (ppi, e)
01017 c_pretty_printer ppi;
01018 tree e;
01019 {
01020 if (TREE_CODE (e) == BIT_IOR_EXPR)
01021 {
01022 pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
01023 pp_c_maybe_whitespace (ppi);
01024 pp_bar (ppi);
01025 pp_c_whitespace (ppi);
01026 pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
01027 }
01028 else
01029 pp_c_exclusive_or_expression (ppi, e);
01030 }
01031
01032 static inline void
01033 pp_c_logical_and_expression (ppi, e)
01034 c_pretty_printer ppi;
01035 tree e;
01036 {
01037 if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
01038 {
01039 pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
01040 pp_c_maybe_whitespace (ppi);
01041 pp_identifier (ppi, "&&");
01042 pp_c_whitespace (ppi);
01043 pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
01044 }
01045 else
01046 pp_c_inclusive_or_expression (ppi, e);
01047 }
01048
01049 void
01050 pp_c_logical_or_expression (ppi, e)
01051 c_pretty_printer ppi;
01052 tree e;
01053 {
01054 if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
01055 {
01056 pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
01057 pp_c_maybe_whitespace (ppi);
01058 pp_identifier (ppi, "||");
01059 pp_c_whitespace (ppi);
01060 pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
01061 }
01062 else
01063 pp_c_logical_and_expression (ppi, e);
01064 }
01065
01066 static void
01067 pp_c_conditional_expression (ppi, e)
01068 c_pretty_printer ppi;
01069 tree e;
01070 {
01071 if (TREE_CODE (e) == COND_EXPR)
01072 {
01073 pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
01074 pp_c_maybe_whitespace (ppi);
01075 pp_question (ppi);
01076 pp_c_whitespace (ppi);
01077 pp_c_expression (ppi, TREE_OPERAND (e, 1));
01078 pp_c_maybe_whitespace (ppi);
01079 pp_colon (ppi);
01080 pp_c_whitespace (ppi);
01081 pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
01082 }
01083 else
01084 pp_c_logical_or_expression (ppi, e);
01085 }
01086
01087
01088
01089 static void
01090 pp_c_assignment_expression (ppi, e)
01091 c_pretty_printer ppi;
01092 tree e;
01093 {
01094 if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
01095 {
01096 pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
01097 pp_c_maybe_whitespace (ppi);
01098 pp_equal (ppi);
01099 pp_whitespace (ppi);
01100 pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
01101 }
01102 else
01103 pp_c_conditional_expression (ppi, e);
01104 }
01105
01106
01107 void
01108 pp_c_expression (ppi, e)
01109 c_pretty_printer ppi;
01110 tree e;
01111 {
01112 switch (TREE_CODE (e))
01113 {
01114 case INTEGER_CST:
01115 pp_c_integer_literal (ppi, e);
01116 break;
01117
01118 case REAL_CST:
01119 pp_c_real_literal (ppi, e);
01120 break;
01121
01122 case STRING_CST:
01123 pp_c_string_literal (ppi, e);
01124 break;
01125
01126 case FUNCTION_DECL:
01127 case VAR_DECL:
01128 case CONST_DECL:
01129 case PARM_DECL:
01130 case RESULT_DECL:
01131 case FIELD_DECL:
01132 case LABEL_DECL:
01133 case ERROR_MARK:
01134 case TARGET_EXPR:
01135 case STMT_EXPR:
01136 pp_c_primary_expression (ppi, e);
01137 break;
01138
01139 case POSTINCREMENT_EXPR:
01140 case POSTDECREMENT_EXPR:
01141 case ARROW_EXPR:
01142 case ARRAY_REF:
01143 case CALL_EXPR:
01144 case COMPONENT_REF:
01145 case COMPLEX_CST:
01146 case VECTOR_CST:
01147 case ABS_EXPR:
01148 case FFS_EXPR:
01149 case CONSTRUCTOR:
01150 case COMPOUND_LITERAL_EXPR:
01151 case COMPLEX_EXPR:
01152 case VA_ARG_EXPR:
01153 pp_c_postfix_expression (ppi, e);
01154 break;
01155
01156 case CONJ_EXPR:
01157 case ADDR_EXPR:
01158 case INDIRECT_REF:
01159 case NEGATE_EXPR:
01160 case BIT_NOT_EXPR:
01161 case TRUTH_NOT_EXPR:
01162 case PREINCREMENT_EXPR:
01163 case PREDECREMENT_EXPR:
01164 case SIZEOF_EXPR:
01165 case ALIGNOF_EXPR:
01166 case REALPART_EXPR:
01167 case IMAGPART_EXPR:
01168 pp_c_unary_expression (ppi, e);
01169 break;
01170
01171 case CONVERT_EXPR:
01172 case FLOAT_EXPR:
01173 pp_c_cast_expression (ppi, e);
01174 break;
01175
01176 case MULT_EXPR:
01177 case TRUNC_MOD_EXPR:
01178 case TRUNC_DIV_EXPR:
01179 pp_c_multiplicative_expression (ppi, e);
01180 break;
01181
01182 case LSHIFT_EXPR:
01183 case RSHIFT_EXPR:
01184 pp_c_shift_expression (ppi, e);
01185 break;
01186
01187 case LT_EXPR:
01188 case GT_EXPR:
01189 case LE_EXPR:
01190 case GE_EXPR:
01191 pp_c_relational_expression (ppi, e);
01192 break;
01193
01194 case BIT_AND_EXPR:
01195 pp_c_and_expression (ppi, e);
01196 break;
01197
01198 case BIT_XOR_EXPR:
01199 pp_c_exclusive_or_expression (ppi, e);
01200 break;
01201
01202 case BIT_IOR_EXPR:
01203 pp_c_inclusive_or_expression (ppi, e);
01204 break;
01205
01206 case TRUTH_ANDIF_EXPR:
01207 pp_c_logical_and_expression (ppi, e);
01208 break;
01209
01210 case TRUTH_ORIF_EXPR:
01211 pp_c_logical_or_expression (ppi, e);
01212 break;
01213
01214 case COND_EXPR:
01215 pp_c_conditional_expression (ppi, e);
01216 break;
01217
01218 case MODIFY_EXPR:
01219 case INIT_EXPR:
01220 pp_c_assignment_expression (ppi, e);
01221 break;
01222
01223 case NOP_EXPR:
01224 pp_c_expression (ppi, TREE_OPERAND (e, 0));
01225 break;
01226
01227 case COMPOUND_EXPR:
01228 pp_c_left_paren (ppi);
01229 pp_c_expression (ppi, TREE_OPERAND (e, 0));
01230 pp_separate_with (ppi, ',');
01231 pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
01232 pp_c_right_paren (ppi);
01233 break;
01234
01235
01236 default:
01237 pp_unsupported_tree (ppi, e);
01238 break;
01239 }
01240 }
01241
01242
01243
01244 void
01245 pp_c_statement (ppi, stmt)
01246 c_pretty_printer ppi;
01247 tree stmt;
01248 {
01249 const enum tree_code code = TREE_CODE (stmt);
01250 switch (code)
01251 {
01252 case LABEL_STMT:
01253 case CASE_LABEL:
01254 pp_newline (ppi);
01255 if (code == LABEL_STMT)
01256 pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt)));
01257 else if (code == LABEL_STMT)
01258 {
01259 if (CASE_LOW (stmt) == NULL_TREE)
01260 pp_identifier (ppi, "default");
01261 else
01262 {
01263 pp_c_identifier (ppi, "case");
01264 pp_c_whitespace (ppi);
01265 pp_conditional_expression (ppi, CASE_LOW (stmt));
01266 if (CASE_HIGH (stmt))
01267 {
01268 pp_identifier (ppi, "...");
01269 pp_conditional_expression (ppi, CASE_HIGH (stmt));
01270 }
01271 }
01272 }
01273 pp_colon (ppi);
01274 pp_newline_and_indent (ppi, 3);
01275 break;
01276
01277 case COMPOUND_STMT:
01278 pp_left_brace (ppi);
01279 pp_newline_and_indent (ppi, 3);
01280 for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt))
01281 pp_c_statement (ppi, stmt);
01282 pp_newline_and_indent (ppi, -3);
01283 pp_right_brace (ppi);
01284 pp_newline (ppi);
01285 break;
01286
01287 case EXPR_STMT:
01288 case CLEANUP_STMT:
01289 pp_newline (ppi);
01290 pp_c_expression (ppi, code == EXPR_STMT
01291 ? EXPR_STMT_EXPR (stmt)
01292 : CLEANUP_EXPR (stmt));
01293 pp_semicolon (ppi);
01294 pp_newline (ppi);
01295 break;
01296
01297 case IF_STMT:
01298 pp_c_identifier (ppi, "if");
01299 pp_whitespace (ppi);
01300 pp_c_left_paren (ppi);
01301 pp_c_expression (ppi, IF_COND (stmt));
01302 pp_right_paren (ppi);
01303 pp_newline_and_indent (ppi, 3);
01304 pp_statement (ppi, THEN_CLAUSE (stmt));
01305 pp_newline_and_indent (ppi, -3);
01306 if (ELSE_CLAUSE (stmt))
01307 {
01308 tree else_clause = ELSE_CLAUSE (stmt);
01309 pp_c_identifier (ppi, "else");
01310 if (TREE_CODE (else_clause) == IF_STMT)
01311 pp_c_whitespace (ppi);
01312 else
01313 pp_newline_and_indent (ppi, 3);
01314 pp_statement (ppi, else_clause);
01315 if (TREE_CODE (else_clause) != IF_STMT)
01316 pp_newline_and_indent (ppi, -3);
01317 }
01318 break;
01319
01320 case SWITCH_STMT:
01321 pp_newline (ppi);
01322 pp_c_identifier (ppi, "switch");
01323 pp_whitespace (ppi);
01324 pp_c_left_paren (ppi);
01325 pp_c_expression (ppi, SWITCH_COND (stmt));
01326 pp_right_paren (ppi);
01327 pp_newline_and_indent (ppi, 3);
01328 pp_statement (ppi, SWITCH_BODY (stmt));
01329 pp_newline_and_indent (ppi, -3);
01330 break;
01331
01332 case WHILE_STMT:
01333 pp_c_identifier (ppi, "while");
01334 pp_whitespace (ppi);
01335 pp_c_left_paren (ppi);
01336 pp_c_expression (ppi, WHILE_COND (stmt));
01337 pp_right_paren (ppi);
01338 pp_newline_and_indent (ppi, 3);
01339 pp_statement (ppi, WHILE_BODY (stmt));
01340 pp_newline_and_indent (ppi, -3);
01341 break;
01342
01343 case DO_STMT:
01344 pp_c_identifier (ppi, "do");
01345 pp_newline_and_indent (ppi, 3);
01346 pp_statement (ppi, DO_BODY (stmt));
01347 pp_newline_and_indent (ppi, -3);
01348 pp_c_identifier (ppi, "while");
01349 pp_whitespace (ppi);
01350 pp_c_left_paren (ppi);
01351 pp_c_expression (ppi, DO_COND (stmt));
01352 pp_c_right_paren (ppi);
01353 pp_semicolon (ppi);
01354 pp_newline (ppi);
01355 break;
01356
01357 case FOR_STMT:
01358 pp_c_identifier (ppi, "for");
01359 pp_whitespace (ppi);
01360 pp_c_left_paren (ppi);
01361 pp_statement (ppi, FOR_INIT_STMT (stmt));
01362 pp_c_whitespace (ppi);
01363 if (FOR_COND (stmt))
01364 pp_c_expression (ppi, FOR_COND (stmt));
01365 pp_semicolon (ppi);
01366 pp_c_whitespace (ppi);
01367 if (FOR_EXPR (stmt))
01368 pp_c_expression (ppi, FOR_EXPR (stmt));
01369 pp_right_paren (ppi);
01370 pp_newline_and_indent (ppi, 3);
01371 pp_statement (ppi, FOR_BODY (stmt));
01372 pp_newline_and_indent (ppi, -3);
01373 break;
01374
01375 case BREAK_STMT:
01376 case CONTINUE_STMT:
01377 pp_newline (ppi);
01378 pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue");
01379 pp_semicolon (ppi);
01380 pp_newline (ppi);
01381 break;
01382
01383 case RETURN_STMT:
01384 case GOTO_STMT:
01385 {
01386 tree e = code == RETURN_STMT
01387 ? RETURN_STMT_EXPR (stmt)
01388 : GOTO_DESTINATION (stmt);
01389
01390 pp_newline (ppi);
01391 pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto");
01392 if (e)
01393 pp_c_expression (ppi, e);
01394 pp_semicolon (ppi);
01395 pp_newline (ppi);
01396 }
01397 break;
01398
01399 case SCOPE_STMT:
01400 if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt))
01401 {
01402 if (SCOPE_BEGIN_P (stmt))
01403 {
01404 pp_left_brace (ppi);
01405 pp_newline_and_indent (ppi, 3);
01406 }
01407 else if (SCOPE_END_P (stmt))
01408 {
01409 pp_right_brace (ppi);
01410 pp_newline_and_indent (ppi, -3);
01411 }
01412 }
01413 break;
01414
01415 case DECL_STMT:
01416 pp_declaration (ppi, DECL_STMT_DECL (stmt));
01417 pp_semicolon (ppi);
01418 pp_newline (ppi);
01419 break;
01420
01421 case ASM_STMT:
01422 {
01423 bool has_volatile_p = ASM_VOLATILE_P (stmt);
01424 bool is_extended = has_volatile_p || ASM_INPUTS (stmt)
01425 || ASM_OUTPUTS (stmt) || ASM_CLOBBERS (stmt);
01426 pp_c_identifier (ppi, is_extended ? "__asm__" : "asm");
01427 if (has_volatile_p)
01428 pp_c_identifier (ppi, "__volatile__");
01429 pp_whitespace (ppi);
01430 pp_c_left_paren (ppi);
01431 pp_c_string_literal (ppi, ASM_STRING (stmt));
01432 if (is_extended)
01433 {
01434 pp_whitespace (ppi);
01435 pp_separate_with (ppi, ':');
01436 if (ASM_OUTPUTS (stmt))
01437 pp_c_expression (ppi, ASM_OUTPUTS (stmt));
01438 pp_whitespace (ppi);
01439 pp_separate_with (ppi, ':');
01440 if (ASM_INPUTS (stmt))
01441 pp_c_expression (ppi, ASM_INPUTS (stmt));
01442 pp_whitespace (ppi);
01443 pp_separate_with (ppi, ':');
01444 if (ASM_CLOBBERS (stmt))
01445 pp_c_expression (ppi, ASM_CLOBBERS (stmt));
01446 }
01447 pp_right_paren (ppi);
01448 pp_newline (ppi);
01449 }
01450 break;
01451
01452 case FILE_STMT:
01453 pp_c_identifier (ppi, "__FILE__");
01454 pp_whitespace (ppi);
01455 pp_equal (ppi);
01456 pp_c_whitespace (ppi);
01457 pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt));
01458 pp_semicolon (ppi);
01459 pp_newline (ppi);
01460 break;
01461
01462 default:
01463 pp_unsupported_tree (ppi, stmt);
01464 }
01465
01466 }
01467
01468
01469
01470 void
01471 pp_c_pretty_printer_init (pp)
01472 c_pretty_printer pp;
01473 {
01474 pp->offset_list = 0;
01475
01476 pp->declaration = pp_c_declaration;
01477 pp->declaration_specifiers = pp_c_declaration_specifiers;
01478 pp->type_specifier = pp_c_simple_type_specifier;
01479 pp->declarator = pp_c_declarator;
01480 pp->direct_declarator = pp_c_direct_declarator;
01481 pp->parameter_declaration = pp_c_parameter_declaration;
01482 pp->type_id = pp_c_type_id;
01483
01484 pp->statement = pp_c_statement;
01485
01486 pp->primary_expression = pp_c_primary_expression;
01487 pp->postfix_expression = pp_c_postfix_expression;
01488 pp->unary_expression = pp_c_unary_expression;
01489 pp->initializer = pp_c_initializer;
01490 pp->multiplicative_expression = pp_c_multiplicative_expression;
01491 pp->conditional_expression = pp_c_conditional_expression;
01492 pp->assignment_expression = pp_c_assignment_expression;
01493 }
