Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-pretty-print.c @ 55:77e2b8dfacca gcc-4.4.5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update it from 4.4.3 to 4.5.0
author ryoma <e075725@ie.u-ryukyu.ac.jp>
date Fri, 12 Feb 2010 23:39:51 +0900
parents a06113de4d67
children b7f97abdc517
comparison
equal deleted inserted replaced
52:c156f1bd5cd9 55:77e2b8dfacca
23 #include "system.h" 23 #include "system.h"
24 #include "coretypes.h" 24 #include "coretypes.h"
25 #include "tm.h" 25 #include "tm.h"
26 #include "real.h" 26 #include "real.h"
27 #include "fixed-value.h" 27 #include "fixed-value.h"
28 #include "intl.h"
28 #include "c-pretty-print.h" 29 #include "c-pretty-print.h"
29 #include "c-tree.h" 30 #include "c-tree.h"
30 #include "tree-iterator.h" 31 #include "tree-iterator.h"
31 #include "diagnostic.h" 32 #include "diagnostic.h"
33
34 /* Translate if being used for diagnostics, but not for dump files or
35 __PRETTY_FUNCTION. */
36 #define M_(msgid) (pp_translate_identifiers (pp) ? _(msgid) : (msgid))
32 37
33 /* The pretty-printer code is primarily designed to closely follow 38 /* The pretty-printer code is primarily designed to closely follow
34 (GNU) C and C++ grammars. That is to be contrasted with spaghetti 39 (GNU) C and C++ grammars. That is to be contrasted with spaghetti
35 codes we used to have in the past. Following a structured 40 codes we used to have in the past. Following a structured
36 approach (preferably the official grammars) is believed to make it 41 approach (preferably the official grammars) is believed to make it
175 /* The C programming language does not have references, but it is much 180 /* The C programming language does not have references, but it is much
176 simpler to handle those here rather than going through the same 181 simpler to handle those here rather than going through the same
177 logic in the C++ pretty-printer. */ 182 logic in the C++ pretty-printer. */
178 if (p != NULL && (*p == '*' || *p == '&')) 183 if (p != NULL && (*p == '*' || *p == '&'))
179 pp_c_whitespace (pp); 184 pp_c_whitespace (pp);
180 pp_c_identifier (pp, cv); 185 pp_c_ws_string (pp, cv);
181 } 186 }
182 187
183 /* Pretty-print T using the type-cast notation '( type-name )'. */ 188 /* Pretty-print T using the type-cast notation '( type-name )'. */
184 189
185 static void 190 static void
218 223
219 type-qualifier: 224 type-qualifier:
220 const 225 const
221 restrict -- C99 226 restrict -- C99
222 __restrict__ -- GNU C 227 __restrict__ -- GNU C
223 volatile */ 228 address-space-qualifier -- GNU C
229 volatile
230
231 address-space-qualifier:
232 identifier -- GNU C */
224 233
225 void 234 void
226 pp_c_type_qualifier_list (c_pretty_printer *pp, tree t) 235 pp_c_type_qualifier_list (c_pretty_printer *pp, tree t)
227 { 236 {
228 int qualifiers; 237 int qualifiers;
238 pp_c_cv_qualifier (pp, "const"); 247 pp_c_cv_qualifier (pp, "const");
239 if (qualifiers & TYPE_QUAL_VOLATILE) 248 if (qualifiers & TYPE_QUAL_VOLATILE)
240 pp_c_cv_qualifier (pp, "volatile"); 249 pp_c_cv_qualifier (pp, "volatile");
241 if (qualifiers & TYPE_QUAL_RESTRICT) 250 if (qualifiers & TYPE_QUAL_RESTRICT)
242 pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__"); 251 pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__");
252
253 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (t)))
254 {
255 const char *as = c_addr_space_name (TYPE_ADDR_SPACE (t));
256 pp_c_identifier (pp, as);
257 }
243 } 258 }
244 259
245 /* pointer: 260 /* pointer:
246 * type-qualifier-list(opt) 261 * type-qualifier-list(opt)
247 * type-qualifier-list(opt) pointer */ 262 * type-qualifier-list(opt) pointer */
304 { 319 {
305 const enum tree_code code = TREE_CODE (t); 320 const enum tree_code code = TREE_CODE (t);
306 switch (code) 321 switch (code)
307 { 322 {
308 case ERROR_MARK: 323 case ERROR_MARK:
309 pp_c_identifier (pp, "<type-error>"); 324 pp_c_ws_string (pp, M_("<type-error>"));
310 break; 325 break;
311 326
312 case IDENTIFIER_NODE: 327 case IDENTIFIER_NODE:
313 pp_c_tree_decl_identifier (pp, t); 328 pp_c_tree_decl_identifier (pp, t);
314 break; 329 break;
343 { 358 {
344 switch (code) 359 switch (code)
345 { 360 {
346 case INTEGER_TYPE: 361 case INTEGER_TYPE:
347 pp_string (pp, (TYPE_UNSIGNED (t) 362 pp_string (pp, (TYPE_UNSIGNED (t)
348 ? "<unnamed-unsigned:" 363 ? M_("<unnamed-unsigned:")
349 : "<unnamed-signed:")); 364 : M_("<unnamed-signed:")));
350 break; 365 break;
351 case REAL_TYPE: 366 case REAL_TYPE:
352 pp_string (pp, "<unnamed-float:"); 367 pp_string (pp, M_("<unnamed-float:"));
353 break; 368 break;
354 case FIXED_POINT_TYPE: 369 case FIXED_POINT_TYPE:
355 pp_string (pp, "<unnamed-fixed:"); 370 pp_string (pp, M_("<unnamed-fixed:"));
356 break; 371 break;
357 default: 372 default:
358 gcc_unreachable (); 373 gcc_unreachable ();
359 } 374 }
360 pp_decimal_int (pp, prec); 375 pp_decimal_int (pp, prec);
365 380
366 case TYPE_DECL: 381 case TYPE_DECL:
367 if (DECL_NAME (t)) 382 if (DECL_NAME (t))
368 pp_id_expression (pp, t); 383 pp_id_expression (pp, t);
369 else 384 else
370 pp_c_identifier (pp, "<typedef-error>"); 385 pp_c_ws_string (pp, M_("<typedef-error>"));
371 break; 386 break;
372 387
373 case UNION_TYPE: 388 case UNION_TYPE:
374 case RECORD_TYPE: 389 case RECORD_TYPE:
375 case ENUMERAL_TYPE: 390 case ENUMERAL_TYPE:
376 if (code == UNION_TYPE) 391 if (code == UNION_TYPE)
377 pp_c_identifier (pp, "union"); 392 pp_c_ws_string (pp, "union");
378 else if (code == RECORD_TYPE) 393 else if (code == RECORD_TYPE)
379 pp_c_identifier (pp, "struct"); 394 pp_c_ws_string (pp, "struct");
380 else if (code == ENUMERAL_TYPE) 395 else if (code == ENUMERAL_TYPE)
381 pp_c_identifier (pp, "enum"); 396 pp_c_ws_string (pp, "enum");
382 else 397 else
383 pp_c_identifier (pp, "<tag-error>"); 398 pp_c_ws_string (pp, M_("<tag-error>"));
384 399
385 if (TYPE_NAME (t)) 400 if (TYPE_NAME (t))
386 pp_id_expression (pp, TYPE_NAME (t)); 401 pp_id_expression (pp, TYPE_NAME (t));
387 else 402 else
388 pp_c_identifier (pp, "<anonymous>"); 403 pp_c_ws_string (pp, M_("<anonymous>"));
389 break; 404 break;
390 405
391 default: 406 default:
392 pp_unsupported_tree (pp, t); 407 pp_unsupported_tree (pp, t);
393 break; 408 break;
439 454
440 case VECTOR_TYPE: 455 case VECTOR_TYPE:
441 case COMPLEX_TYPE: 456 case COMPLEX_TYPE:
442 pp_c_specifier_qualifier_list (pp, TREE_TYPE (t)); 457 pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
443 if (code == COMPLEX_TYPE) 458 if (code == COMPLEX_TYPE)
444 pp_c_identifier (pp, flag_isoc99 ? "_Complex" : "__complex__"); 459 pp_c_ws_string (pp, flag_isoc99 ? "_Complex" : "__complex__");
445 else if (code == VECTOR_TYPE) 460 else if (code == VECTOR_TYPE)
446 pp_c_identifier (pp, "__vector__"); 461 pp_c_ws_string (pp, "__vector__");
447 break; 462 break;
448 463
449 default: 464 default:
450 pp_simple_type_specifier (pp, t); 465 pp_simple_type_specifier (pp, t);
451 break; 466 break;
469 { 484 {
470 bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract); 485 bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract);
471 tree parms = want_parm_decl ? DECL_ARGUMENTS (t) : TYPE_ARG_TYPES (t); 486 tree parms = want_parm_decl ? DECL_ARGUMENTS (t) : TYPE_ARG_TYPES (t);
472 pp_c_left_paren (pp); 487 pp_c_left_paren (pp);
473 if (parms == void_list_node) 488 if (parms == void_list_node)
474 pp_c_identifier (pp, "void"); 489 pp_c_ws_string (pp, "void");
475 else 490 else
476 { 491 {
477 bool first = true; 492 bool first = true;
478 for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms)) 493 for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
479 { 494 {
585 600
586 void 601 void
587 pp_c_storage_class_specifier (c_pretty_printer *pp, tree t) 602 pp_c_storage_class_specifier (c_pretty_printer *pp, tree t)
588 { 603 {
589 if (TREE_CODE (t) == TYPE_DECL) 604 if (TREE_CODE (t) == TYPE_DECL)
590 pp_c_identifier (pp, "typedef"); 605 pp_c_ws_string (pp, "typedef");
591 else if (DECL_P (t)) 606 else if (DECL_P (t))
592 { 607 {
593 if (DECL_REGISTER (t)) 608 if (DECL_REGISTER (t))
594 pp_c_identifier (pp, "register"); 609 pp_c_ws_string (pp, "register");
595 else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL) 610 else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
596 pp_c_identifier (pp, "static"); 611 pp_c_ws_string (pp, "static");
597 } 612 }
598 } 613 }
599 614
600 /* function-specifier: 615 /* function-specifier:
601 inline */ 616 inline */
602 617
603 void 618 void
604 pp_c_function_specifier (c_pretty_printer *pp, tree t) 619 pp_c_function_specifier (c_pretty_printer *pp, tree t)
605 { 620 {
606 if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t)) 621 if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
607 pp_c_identifier (pp, "inline"); 622 pp_c_ws_string (pp, "inline");
608 } 623 }
609 624
610 /* declaration-specifiers: 625 /* declaration-specifiers:
611 storage-class-specifier declaration-specifiers(opt) 626 storage-class-specifier declaration-specifiers(opt)
612 type-specifier declaration-specifiers(opt) 627 type-specifier declaration-specifiers(opt)
731 pp_c_attributes (c_pretty_printer *pp, tree attributes) 746 pp_c_attributes (c_pretty_printer *pp, tree attributes)
732 { 747 {
733 if (attributes == NULL_TREE) 748 if (attributes == NULL_TREE)
734 return; 749 return;
735 750
736 pp_c_identifier (pp, "__attribute__"); 751 pp_c_ws_string (pp, "__attribute__");
737 pp_c_left_paren (pp); 752 pp_c_left_paren (pp);
738 pp_c_left_paren (pp); 753 pp_c_left_paren (pp);
739 for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes)) 754 for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
740 { 755 {
741 pp_tree_identifier (pp, TREE_PURPOSE (attributes)); 756 pp_tree_identifier (pp, TREE_PURPOSE (attributes));
830 { 845 {
831 pp_character (pp, '-'); 846 pp_character (pp, '-');
832 high = ~high + !low; 847 high = ~high + !low;
833 low = -low; 848 low = -low;
834 } 849 }
835 sprintf (pp_buffer (pp)->digit_buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX, 850 sprintf (pp_buffer (pp)->digit_buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
836 (unsigned HOST_WIDE_INT) high, (unsigned HOST_WIDE_INT) low); 851 (unsigned HOST_WIDE_INT) high, (unsigned HOST_WIDE_INT) low);
837 pp_string (pp, pp_buffer (pp)->digit_buffer); 852 pp_string (pp, pp_buffer (pp)->digit_buffer);
838 } 853 }
839 if (TYPE_UNSIGNED (type)) 854 if (TYPE_UNSIGNED (type))
840 pp_character (pp, 'u'); 855 pp_character (pp, 'u');
867 pp_c_bool_constant (c_pretty_printer *pp, tree b) 882 pp_c_bool_constant (c_pretty_printer *pp, tree b)
868 { 883 {
869 if (b == boolean_false_node) 884 if (b == boolean_false_node)
870 { 885 {
871 if (c_dialect_cxx ()) 886 if (c_dialect_cxx ())
872 pp_c_identifier (pp, "false"); 887 pp_c_ws_string (pp, "false");
873 else if (flag_isoc99) 888 else if (flag_isoc99)
874 pp_c_identifier (pp, "_False"); 889 pp_c_ws_string (pp, "_False");
875 else 890 else
876 pp_unsupported_tree (pp, b); 891 pp_unsupported_tree (pp, b);
877 } 892 }
878 else if (b == boolean_true_node) 893 else if (b == boolean_true_node)
879 { 894 {
880 if (c_dialect_cxx ()) 895 if (c_dialect_cxx ())
881 pp_c_identifier (pp, "true"); 896 pp_c_ws_string (pp, "true");
882 else if (flag_isoc99) 897 else if (flag_isoc99)
883 pp_c_identifier (pp, "_True"); 898 pp_c_ws_string (pp, "_True");
884 else 899 else
885 pp_unsupported_tree (pp, b); 900 pp_unsupported_tree (pp, b);
886 } 901 }
887 else if (TREE_CODE (b) == INTEGER_CST) 902 else if (TREE_CODE (b) == INTEGER_CST)
888 pp_c_integer_constant (pp, b); 903 pp_c_integer_constant (pp, b);
1067 pp_unsupported_tree (pp, e); 1082 pp_unsupported_tree (pp, e);
1068 break; 1083 break;
1069 } 1084 }
1070 } 1085 }
1071 1086
1072 /* Pretty-print an IDENTIFIER_NODE, preceded by whitespace is necessary. */ 1087 /* Pretty-print a string such as an identifier, without changing its
1088 encoding, preceded by whitespace is necessary. */
1089
1090 void
1091 pp_c_ws_string (c_pretty_printer *pp, const char *str)
1092 {
1093 pp_c_maybe_whitespace (pp);
1094 pp_string (pp, str);
1095 pp_base (pp)->padding = pp_before;
1096 }
1097
1098 /* Pretty-print an IDENTIFIER_NODE, which may contain UTF-8 sequences
1099 that need converting to the locale encoding, preceded by whitespace
1100 is necessary. */
1073 1101
1074 void 1102 void
1075 pp_c_identifier (c_pretty_printer *pp, const char *id) 1103 pp_c_identifier (c_pretty_printer *pp, const char *id)
1076 { 1104 {
1077 pp_c_maybe_whitespace (pp); 1105 pp_c_maybe_whitespace (pp);
1103 case IDENTIFIER_NODE: 1131 case IDENTIFIER_NODE:
1104 pp_c_tree_identifier (pp, e); 1132 pp_c_tree_identifier (pp, e);
1105 break; 1133 break;
1106 1134
1107 case ERROR_MARK: 1135 case ERROR_MARK:
1108 pp_c_identifier (pp, "<erroneous-expression>"); 1136 pp_c_ws_string (pp, M_("<erroneous-expression>"));
1109 break; 1137 break;
1110 1138
1111 case RESULT_DECL: 1139 case RESULT_DECL:
1112 pp_c_identifier (pp, "<return-value>"); 1140 pp_c_ws_string (pp, M_("<return-value>"));
1113 break; 1141 break;
1114 1142
1115 case INTEGER_CST: 1143 case INTEGER_CST:
1116 case REAL_CST: 1144 case REAL_CST:
1117 case FIXED_CST: 1145 case FIXED_CST:
1118 case STRING_CST: 1146 case STRING_CST:
1119 pp_c_constant (pp, e); 1147 pp_c_constant (pp, e);
1120 break; 1148 break;
1121 1149
1122 case TARGET_EXPR: 1150 case TARGET_EXPR:
1123 pp_c_identifier (pp, "__builtin_memcpy"); 1151 pp_c_ws_string (pp, "__builtin_memcpy");
1124 pp_c_left_paren (pp); 1152 pp_c_left_paren (pp);
1125 pp_ampersand (pp); 1153 pp_ampersand (pp);
1126 pp_primary_expression (pp, TREE_OPERAND (e, 0)); 1154 pp_primary_expression (pp, TREE_OPERAND (e, 0));
1127 pp_separate_with (pp, ','); 1155 pp_separate_with (pp, ',');
1128 pp_ampersand (pp); 1156 pp_ampersand (pp);
1336 switch (code) 1364 switch (code)
1337 { 1365 {
1338 case POSTINCREMENT_EXPR: 1366 case POSTINCREMENT_EXPR:
1339 case POSTDECREMENT_EXPR: 1367 case POSTDECREMENT_EXPR:
1340 pp_postfix_expression (pp, TREE_OPERAND (e, 0)); 1368 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1341 pp_identifier (pp, code == POSTINCREMENT_EXPR ? "++" : "--"); 1369 pp_string (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
1342 break; 1370 break;
1343 1371
1344 case ARRAY_REF: 1372 case ARRAY_REF:
1345 pp_postfix_expression (pp, TREE_OPERAND (e, 0)); 1373 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1346 pp_c_left_bracket (pp); 1374 pp_c_left_bracket (pp);
1363 pp_c_right_paren (pp); 1391 pp_c_right_paren (pp);
1364 break; 1392 break;
1365 } 1393 }
1366 1394
1367 case UNORDERED_EXPR: 1395 case UNORDERED_EXPR:
1368 pp_c_identifier (pp, flag_isoc99 1396 pp_c_ws_string (pp, flag_isoc99
1369 ? "isunordered" 1397 ? "isunordered"
1370 : "__builtin_isunordered"); 1398 : "__builtin_isunordered");
1371 goto two_args_fun; 1399 goto two_args_fun;
1372 1400
1373 case ORDERED_EXPR: 1401 case ORDERED_EXPR:
1374 pp_c_identifier (pp, flag_isoc99 1402 pp_c_ws_string (pp, flag_isoc99
1375 ? "!isunordered" 1403 ? "!isunordered"
1376 : "!__builtin_isunordered"); 1404 : "!__builtin_isunordered");
1377 goto two_args_fun; 1405 goto two_args_fun;
1378 1406
1379 case UNLT_EXPR: 1407 case UNLT_EXPR:
1380 pp_c_identifier (pp, flag_isoc99 1408 pp_c_ws_string (pp, flag_isoc99
1381 ? "!isgreaterequal" 1409 ? "!isgreaterequal"
1382 : "!__builtin_isgreaterequal"); 1410 : "!__builtin_isgreaterequal");
1383 goto two_args_fun; 1411 goto two_args_fun;
1384 1412
1385 case UNLE_EXPR: 1413 case UNLE_EXPR:
1386 pp_c_identifier (pp, flag_isoc99 1414 pp_c_ws_string (pp, flag_isoc99
1387 ? "!isgreater" 1415 ? "!isgreater"
1388 : "!__builtin_isgreater"); 1416 : "!__builtin_isgreater");
1389 goto two_args_fun; 1417 goto two_args_fun;
1390 1418
1391 case UNGT_EXPR: 1419 case UNGT_EXPR:
1392 pp_c_identifier (pp, flag_isoc99 1420 pp_c_ws_string (pp, flag_isoc99
1393 ? "!islessequal" 1421 ? "!islessequal"
1394 : "!__builtin_islessequal"); 1422 : "!__builtin_islessequal");
1395 goto two_args_fun; 1423 goto two_args_fun;
1396 1424
1397 case UNGE_EXPR: 1425 case UNGE_EXPR:
1398 pp_c_identifier (pp, flag_isoc99 1426 pp_c_ws_string (pp, flag_isoc99
1399 ? "!isless" 1427 ? "!isless"
1400 : "!__builtin_isless"); 1428 : "!__builtin_isless");
1401 goto two_args_fun; 1429 goto two_args_fun;
1402 1430
1403 case UNEQ_EXPR: 1431 case UNEQ_EXPR:
1404 pp_c_identifier (pp, flag_isoc99 1432 pp_c_ws_string (pp, flag_isoc99
1405 ? "!islessgreater" 1433 ? "!islessgreater"
1406 : "!__builtin_islessgreater"); 1434 : "!__builtin_islessgreater");
1407 goto two_args_fun; 1435 goto two_args_fun;
1408 1436
1409 case LTGT_EXPR: 1437 case LTGT_EXPR:
1410 pp_c_identifier (pp, flag_isoc99 1438 pp_c_ws_string (pp, flag_isoc99
1411 ? "islessgreater" 1439 ? "islessgreater"
1412 : "__builtin_islessgreater"); 1440 : "__builtin_islessgreater");
1413 goto two_args_fun; 1441 goto two_args_fun;
1414 1442
1415 two_args_fun: 1443 two_args_fun:
1419 pp_expression (pp, TREE_OPERAND (e, 1)); 1447 pp_expression (pp, TREE_OPERAND (e, 1));
1420 pp_c_right_paren (pp); 1448 pp_c_right_paren (pp);
1421 break; 1449 break;
1422 1450
1423 case ABS_EXPR: 1451 case ABS_EXPR:
1424 pp_c_identifier (pp, "__builtin_abs"); 1452 pp_c_ws_string (pp, "__builtin_abs");
1425 pp_c_left_paren (pp); 1453 pp_c_left_paren (pp);
1426 pp_expression (pp, TREE_OPERAND (e, 0)); 1454 pp_expression (pp, TREE_OPERAND (e, 0));
1427 pp_c_right_paren (pp); 1455 pp_c_right_paren (pp);
1428 break; 1456 break;
1429 1457
1489 case CONSTRUCTOR: 1517 case CONSTRUCTOR:
1490 pp_initializer (pp, e); 1518 pp_initializer (pp, e);
1491 break; 1519 break;
1492 1520
1493 case VA_ARG_EXPR: 1521 case VA_ARG_EXPR:
1494 pp_c_identifier (pp, "__builtin_va_arg"); 1522 pp_c_ws_string (pp, "__builtin_va_arg");
1495 pp_c_left_paren (pp); 1523 pp_c_left_paren (pp);
1496 pp_assignment_expression (pp, TREE_OPERAND (e, 0)); 1524 pp_assignment_expression (pp, TREE_OPERAND (e, 0));
1497 pp_separate_with (pp, ','); 1525 pp_separate_with (pp, ',');
1498 pp_type_id (pp, TREE_TYPE (e)); 1526 pp_type_id (pp, TREE_TYPE (e));
1499 pp_c_right_paren (pp); 1527 pp_c_right_paren (pp);
1578 enum tree_code code = TREE_CODE (e); 1606 enum tree_code code = TREE_CODE (e);
1579 switch (code) 1607 switch (code)
1580 { 1608 {
1581 case PREINCREMENT_EXPR: 1609 case PREINCREMENT_EXPR:
1582 case PREDECREMENT_EXPR: 1610 case PREDECREMENT_EXPR:
1583 pp_identifier (pp, code == PREINCREMENT_EXPR ? "++" : "--"); 1611 pp_string (pp, code == PREINCREMENT_EXPR ? "++" : "--");
1584 pp_c_unary_expression (pp, TREE_OPERAND (e, 0)); 1612 pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1585 break; 1613 break;
1586 1614
1587 case ADDR_EXPR: 1615 case ADDR_EXPR:
1588 case INDIRECT_REF: 1616 case INDIRECT_REF:
1604 pp_c_cast_expression (pp, TREE_OPERAND (e, 0)); 1632 pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1605 break; 1633 break;
1606 1634
1607 case REALPART_EXPR: 1635 case REALPART_EXPR:
1608 case IMAGPART_EXPR: 1636 case IMAGPART_EXPR:
1609 pp_c_identifier (pp, code == REALPART_EXPR ? "__real__" : "__imag__"); 1637 pp_c_ws_string (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
1610 pp_c_whitespace (pp); 1638 pp_c_whitespace (pp);
1611 pp_unary_expression (pp, TREE_OPERAND (e, 0)); 1639 pp_unary_expression (pp, TREE_OPERAND (e, 0));
1612 break; 1640 break;
1613 1641
1614 default: 1642 default:
1715 { 1743 {
1716 case LSHIFT_EXPR: 1744 case LSHIFT_EXPR:
1717 case RSHIFT_EXPR: 1745 case RSHIFT_EXPR:
1718 pp_c_shift_expression (pp, TREE_OPERAND (e, 0)); 1746 pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
1719 pp_c_whitespace (pp); 1747 pp_c_whitespace (pp);
1720 pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>"); 1748 pp_string (pp, code == LSHIFT_EXPR ? "<<" : ">>");
1721 pp_c_whitespace (pp); 1749 pp_c_whitespace (pp);
1722 pp_c_additive_expression (pp, TREE_OPERAND (e, 1)); 1750 pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
1723 break; 1751 break;
1724 1752
1725 default: 1753 default:
1749 if (code == LT_EXPR) 1777 if (code == LT_EXPR)
1750 pp_less (pp); 1778 pp_less (pp);
1751 else if (code == GT_EXPR) 1779 else if (code == GT_EXPR)
1752 pp_greater (pp); 1780 pp_greater (pp);
1753 else if (code == LE_EXPR) 1781 else if (code == LE_EXPR)
1754 pp_identifier (pp, "<="); 1782 pp_string (pp, "<=");
1755 else if (code == GE_EXPR) 1783 else if (code == GE_EXPR)
1756 pp_identifier (pp, ">="); 1784 pp_string (pp, ">=");
1757 pp_c_whitespace (pp); 1785 pp_c_whitespace (pp);
1758 pp_c_shift_expression (pp, TREE_OPERAND (e, 1)); 1786 pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
1759 break; 1787 break;
1760 1788
1761 default: 1789 default:
1777 { 1805 {
1778 case EQ_EXPR: 1806 case EQ_EXPR:
1779 case NE_EXPR: 1807 case NE_EXPR:
1780 pp_c_equality_expression (pp, TREE_OPERAND (e, 0)); 1808 pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
1781 pp_c_whitespace (pp); 1809 pp_c_whitespace (pp);
1782 pp_identifier (pp, code == EQ_EXPR ? "==" : "!="); 1810 pp_string (pp, code == EQ_EXPR ? "==" : "!=");
1783 pp_c_whitespace (pp); 1811 pp_c_whitespace (pp);
1784 pp_c_relational_expression (pp, TREE_OPERAND (e, 1)); 1812 pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
1785 break; 1813 break;
1786 1814
1787 default: 1815 default:
1861 if (TREE_CODE (e) == TRUTH_ANDIF_EXPR 1889 if (TREE_CODE (e) == TRUTH_ANDIF_EXPR
1862 || TREE_CODE (e) == TRUTH_AND_EXPR) 1890 || TREE_CODE (e) == TRUTH_AND_EXPR)
1863 { 1891 {
1864 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0)); 1892 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
1865 pp_c_whitespace (pp); 1893 pp_c_whitespace (pp);
1866 pp_identifier (pp, "&&"); 1894 pp_string (pp, "&&");
1867 pp_c_whitespace (pp); 1895 pp_c_whitespace (pp);
1868 pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1)); 1896 pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
1869 } 1897 }
1870 else 1898 else
1871 pp_c_inclusive_or_expression (pp, e); 1899 pp_c_inclusive_or_expression (pp, e);
1881 if (TREE_CODE (e) == TRUTH_ORIF_EXPR 1909 if (TREE_CODE (e) == TRUTH_ORIF_EXPR
1882 || TREE_CODE (e) == TRUTH_OR_EXPR) 1910 || TREE_CODE (e) == TRUTH_OR_EXPR)
1883 { 1911 {
1884 pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0)); 1912 pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1885 pp_c_whitespace (pp); 1913 pp_c_whitespace (pp);
1886 pp_identifier (pp, "||"); 1914 pp_string (pp, "||");
1887 pp_c_whitespace (pp); 1915 pp_c_whitespace (pp);
1888 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1)); 1916 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
1889 } 1917 }
1890 else 1918 else
1891 pp_c_logical_and_expression (pp, e); 1919 pp_c_logical_and_expression (pp, e);
1923 = *= /= %= += -= >>= <<= &= ^= |= */ 1951 = *= /= %= += -= >>= <<= &= ^= |= */
1924 1952
1925 static void 1953 static void
1926 pp_c_assignment_expression (c_pretty_printer *pp, tree e) 1954 pp_c_assignment_expression (c_pretty_printer *pp, tree e)
1927 { 1955 {
1928 if (TREE_CODE (e) == MODIFY_EXPR 1956 if (TREE_CODE (e) == MODIFY_EXPR
1929 || TREE_CODE (e) == INIT_EXPR) 1957 || TREE_CODE (e) == INIT_EXPR)
1930 { 1958 {
1931 pp_c_unary_expression (pp, TREE_OPERAND (e, 0)); 1959 pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1932 pp_c_whitespace (pp); 1960 pp_c_whitespace (pp);
1933 pp_equal (pp); 1961 pp_equal (pp);
2215 if (DECL_NAME (t)) 2243 if (DECL_NAME (t))
2216 name = IDENTIFIER_POINTER (DECL_NAME (t)); 2244 name = IDENTIFIER_POINTER (DECL_NAME (t));
2217 else 2245 else
2218 { 2246 {
2219 static char xname[8]; 2247 static char xname[8];
2220 sprintf (xname, "<U%4x>", ((unsigned)((unsigned long)(t) & 0xffff))); 2248 sprintf (xname, "<U%4x>", ((unsigned)((uintptr_t)(t) & 0xffff)));
2221 name = xname; 2249 name = xname;
2222 } 2250 }
2223 2251
2224 pp_c_identifier (pp, name); 2252 pp_c_identifier (pp, name);
2225 } 2253 }