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