1 /* Various declarations for language-independent pretty-print subroutines.
2 Copyright (C) 2003-2017 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
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 3, or (at your option) any later
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
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "pretty-print.h"
26 #include "diagnostic-color.h"
33 static void pp_quoted_string (pretty_printer
*, const char *, size_t = -1);
35 /* Overwrite the given location/range within this text_info's rich_location.
36 For use e.g. when implementing "+" in client format decoders. */
39 text_info::set_location (unsigned int idx
, location_t loc
, bool show_caret_p
)
41 gcc_checking_assert (m_richloc
);
42 m_richloc
->set_range (line_table
, idx
, loc
, show_caret_p
);
46 text_info::get_location (unsigned int index_of_location
) const
48 gcc_checking_assert (m_richloc
);
50 if (index_of_location
== 0)
51 return m_richloc
->get_loc ();
53 return UNKNOWN_LOCATION
;
56 // Default construct an output buffer.
58 output_buffer::output_buffer ()
59 : formatted_obstack (),
61 obstack (&formatted_obstack
),
68 obstack_init (&formatted_obstack
);
69 obstack_init (&chunk_obstack
);
72 // Release resources owned by an output buffer at the end of lifetime.
74 output_buffer::~output_buffer ()
76 obstack_free (&chunk_obstack
, NULL
);
77 obstack_free (&formatted_obstack
, NULL
);
81 /* Format an integer given by va_arg (ARG, type-specifier T) where
82 type-specifier is a precision modifier as indicated by PREC. F is
83 a string used to construct the appropriate format-specifier. */
84 #define pp_integer_with_precision(PP, ARG, PREC, T, F) \
89 pp_scalar (PP, "%" F, va_arg (ARG, T)); \
93 pp_scalar (PP, "%l" F, va_arg (ARG, long T)); \
97 pp_scalar (PP, "%" HOST_LONG_LONG_FORMAT F, va_arg (ARG, long long T)); \
106 /* Subroutine of pp_set_maximum_length. Set up PRETTY-PRINTER's
107 internal maximum characters per line. */
109 pp_set_real_maximum_length (pretty_printer
*pp
)
111 /* If we're told not to wrap lines then do the obvious thing. In case
112 we'll emit prefix only once per message, it is appropriate
113 not to increase unnecessarily the line-length cut-off. */
114 if (!pp_is_wrapping_line (pp
)
115 || pp_prefixing_rule (pp
) == DIAGNOSTICS_SHOW_PREFIX_ONCE
116 || pp_prefixing_rule (pp
) == DIAGNOSTICS_SHOW_PREFIX_NEVER
)
117 pp
->maximum_length
= pp_line_cutoff (pp
);
120 int prefix_length
= pp
->prefix
? strlen (pp
->prefix
) : 0;
121 /* If the prefix is ridiculously too long, output at least
123 if (pp_line_cutoff (pp
) - prefix_length
< 32)
124 pp
->maximum_length
= pp_line_cutoff (pp
) + 32;
126 pp
->maximum_length
= pp_line_cutoff (pp
);
130 /* Clear PRETTY-PRINTER's output state. */
132 pp_clear_state (pretty_printer
*pp
)
134 pp
->emitted_prefix
= false;
135 pp_indentation (pp
) = 0;
138 /* Flush the formatted text of PRETTY-PRINTER onto the attached stream. */
140 pp_write_text_to_stream (pretty_printer
*pp
)
142 const char *text
= pp_formatted_text (pp
);
143 fputs (text
, pp_buffer (pp
)->stream
);
144 pp_clear_output_area (pp
);
147 /* As pp_write_text_to_stream, but for GraphViz label output.
149 Flush the formatted text of pretty-printer PP onto the attached stream.
150 Replace characters in PPF that have special meaning in a GraphViz .dot
153 This routine is not very fast, but it doesn't have to be as this is only
154 be used by routines dumping intermediate representations in graph form. */
157 pp_write_text_as_dot_label_to_stream (pretty_printer
*pp
, bool for_record
)
159 const char *text
= pp_formatted_text (pp
);
160 const char *p
= text
;
161 FILE *fp
= pp_buffer (pp
)->stream
;
168 /* Print newlines as a left-aligned newline. */
174 /* The following characters are only special for record-shape nodes. */
181 escape_char
= for_record
;
184 /* The following characters always have to be escaped
185 for use in labels. */
187 /* There is a bug in some (f.i. 2.36.0) versions of graphiz
188 ( http://www.graphviz.org/mantisbt/view.php?id=2524 ) related to
189 backslash as last char in label. Let's avoid triggering it. */
190 gcc_assert (*(p
+ 1) != '\0');
207 pp_clear_output_area (pp
);
210 /* Wrap a text delimited by START and END into PRETTY-PRINTER. */
212 pp_wrap_text (pretty_printer
*pp
, const char *start
, const char *end
)
214 bool wrapping_line
= pp_is_wrapping_line (pp
);
218 /* Dump anything bordered by whitespaces. */
220 const char *p
= start
;
221 while (p
!= end
&& !ISBLANK (*p
) && *p
!= '\n')
224 && p
- start
>= pp_remaining_character_count_for_line (pp
))
226 pp_append_text (pp
, start
, p
);
230 if (start
!= end
&& ISBLANK (*start
))
235 if (start
!= end
&& *start
== '\n')
243 /* Same as pp_wrap_text but wrap text only when in line-wrapping mode. */
245 pp_maybe_wrap_text (pretty_printer
*pp
, const char *start
, const char *end
)
247 if (pp_is_wrapping_line (pp
))
248 pp_wrap_text (pp
, start
, end
);
250 pp_append_text (pp
, start
, end
);
253 /* Append to the output area of PRETTY-PRINTER a string specified by its
254 STARTing character and LENGTH. */
256 pp_append_r (pretty_printer
*pp
, const char *start
, int length
)
258 output_buffer_append_r (pp_buffer (pp
), start
, length
);
261 /* Insert enough spaces into the output area of PRETTY-PRINTER to bring
262 the column position to the current indentation level, assuming that a
263 newline has just been written to the buffer. */
265 pp_indent (pretty_printer
*pp
)
267 int n
= pp_indentation (pp
);
270 for (i
= 0; i
< n
; ++i
)
274 /* The following format specifiers are recognized as being client independent:
275 %d, %i: (signed) integer in base ten.
276 %u: unsigned integer in base ten.
277 %o: unsigned integer in base eight.
278 %x: unsigned integer in base sixteen.
279 %ld, %li, %lo, %lu, %lx: long versions of the above.
280 %lld, %lli, %llo, %llu, %llx: long long versions.
281 %wd, %wi, %wo, %wu, %wx: HOST_WIDE_INT versions.
284 %p: pointer (printed in a host-dependent manner).
285 %r: if pp_show_color(pp), switch to color identified by const char *.
286 %R: if pp_show_color(pp), reset color.
287 %m: strerror(text->err_no) - does not consume a value from args_ptr.
291 %': apostrophe (should only be used in untranslated messages;
292 translations should use appropriate punctuation directly).
293 %.*s: a substring the length of which is specified by an argument
295 %Ns: likewise, but length specified as constant in the format string.
296 Flag 'q': quote formatted text (must come immediately after '%').
297 %Z: Requires two arguments - array of int, and len. Prints elements
300 Arguments can be used sequentially, or through %N$ resp. *N$
301 notation Nth argument after the format string. If %N$ / *N$
302 notation is used, it must be used for all arguments, except %m, %%,
303 %<, %> and %', which may not have a number, as they do not consume
304 an argument. When %M$.*N$s is used, M must be N + 1. (This may
305 also be written %M$.*s, provided N is not otherwise used.) The
306 format string must have conversion specifiers with argument numbers
307 1 up to highest argument; each argument may only be used once.
308 A format string can have at most 30 arguments. */
310 /* Formatting phases 1 and 2: render TEXT->format_spec plus
311 TEXT->args_ptr into a series of chunks in pp_buffer (PP)->args[].
312 Phase 3 is in pp_output_formatted_text. */
315 pp_format (pretty_printer
*pp
, text_info
*text
)
317 output_buffer
*buffer
= pp_buffer (pp
);
320 struct chunk_info
*new_chunk_array
;
322 unsigned int curarg
= 0, chunk
= 0, argno
;
323 pp_wrapping_mode_t old_wrapping_mode
;
324 bool any_unnumbered
= false, any_numbered
= false;
325 const char **formatters
[PP_NL_ARGMAX
];
327 /* Allocate a new chunk structure. */
328 new_chunk_array
= XOBNEW (&buffer
->chunk_obstack
, struct chunk_info
);
329 new_chunk_array
->prev
= buffer
->cur_chunk_array
;
330 buffer
->cur_chunk_array
= new_chunk_array
;
331 args
= new_chunk_array
->args
;
333 /* Formatting phase 1: split up TEXT->format_spec into chunks in
334 pp_buffer (PP)->args[]. Even-numbered chunks are to be output
335 verbatim, odd-numbered chunks are format specifiers.
336 %m, %%, %<, %>, and %' are replaced with the appropriate text at
339 memset (formatters
, 0, sizeof formatters
);
341 for (p
= text
->format_spec
; *p
; )
343 while (*p
!= '\0' && *p
!= '%')
345 obstack_1grow (&buffer
->chunk_obstack
, *p
);
358 obstack_1grow (&buffer
->chunk_obstack
, '%');
364 obstack_grow (&buffer
->chunk_obstack
,
365 open_quote
, strlen (open_quote
));
367 = colorize_start (pp_show_color (pp
), "quote");
368 obstack_grow (&buffer
->chunk_obstack
, colorstr
, strlen (colorstr
));
375 const char *colorstr
= colorize_stop (pp_show_color (pp
));
376 obstack_grow (&buffer
->chunk_obstack
, colorstr
, strlen (colorstr
));
380 obstack_grow (&buffer
->chunk_obstack
,
381 close_quote
, strlen (close_quote
));
387 const char *colorstr
= colorize_stop (pp_show_color (pp
));
388 obstack_grow (&buffer
->chunk_obstack
, colorstr
,
396 const char *errstr
= xstrerror (text
->err_no
);
397 obstack_grow (&buffer
->chunk_obstack
, errstr
, strlen (errstr
));
403 /* Handled in phase 2. Terminate the plain chunk here. */
404 obstack_1grow (&buffer
->chunk_obstack
, '\0');
405 gcc_assert (chunk
< PP_NL_ARGMAX
* 2);
406 args
[chunk
++] = XOBFINISH (&buffer
->chunk_obstack
, const char *);
413 argno
= strtoul (p
, &end
, 10) - 1;
415 gcc_assert (*p
== '$');
419 gcc_assert (!any_unnumbered
);
424 any_unnumbered
= true;
425 gcc_assert (!any_numbered
);
427 gcc_assert (argno
< PP_NL_ARGMAX
);
428 gcc_assert (!formatters
[argno
]);
429 formatters
[argno
] = &args
[chunk
];
432 obstack_1grow (&buffer
->chunk_obstack
, *p
);
435 while (strchr ("qwl+#", p
[-1]));
439 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
440 (where M == N + 1). */
445 obstack_1grow (&buffer
->chunk_obstack
, *p
);
448 while (ISDIGIT (p
[-1]));
449 gcc_assert (p
[-1] == 's');
453 gcc_assert (*p
== '*');
454 obstack_1grow (&buffer
->chunk_obstack
, '*');
460 unsigned int argno2
= strtoul (p
, &end
, 10) - 1;
462 gcc_assert (argno2
== argno
- 1);
463 gcc_assert (!any_unnumbered
);
464 gcc_assert (*p
== '$');
467 formatters
[argno2
] = formatters
[argno
];
471 gcc_assert (!any_numbered
);
472 formatters
[argno
+1] = formatters
[argno
];
475 gcc_assert (*p
== 's');
476 obstack_1grow (&buffer
->chunk_obstack
, 's');
483 obstack_1grow (&buffer
->chunk_obstack
, '\0');
484 gcc_assert (chunk
< PP_NL_ARGMAX
* 2);
485 args
[chunk
++] = XOBFINISH (&buffer
->chunk_obstack
, const char *);
488 obstack_1grow (&buffer
->chunk_obstack
, '\0');
489 gcc_assert (chunk
< PP_NL_ARGMAX
* 2);
490 args
[chunk
++] = XOBFINISH (&buffer
->chunk_obstack
, const char *);
493 /* Set output to the argument obstack, and switch line-wrapping and
495 buffer
->obstack
= &buffer
->chunk_obstack
;
496 old_wrapping_mode
= pp_set_verbatim_wrapping (pp
);
498 /* Second phase. Replace each formatter with the formatted text it
501 for (argno
= 0; formatters
[argno
]; argno
++)
509 /* We do not attempt to enforce any ordering on the modifier
512 for (p
= *formatters
[argno
];; p
++)
537 /* We don't support precision beyond that of "long long". */
538 gcc_assert (precision
< 2);
545 gcc_assert (!wide
|| precision
== 0);
549 pp_string (pp
, open_quote
);
550 pp_string (pp
, colorize_start (pp_show_color (pp
), "quote"));
556 pp_string (pp
, colorize_start (pp_show_color (pp
),
557 va_arg (*text
->args_ptr
,
563 /* When quoting, print alphanumeric, punctuation, and the space
564 character unchanged, and all others in hexadecimal with the
565 "\x" prefix. Otherwise print them all unchanged. */
566 int chr
= va_arg (*text
->args_ptr
, int);
567 if (ISPRINT (chr
) || !quote
)
568 pp_character (pp
, chr
);
571 const char str
[2] = { chr
, '\0' };
572 pp_quoted_string (pp
, str
, 1);
580 pp_wide_integer (pp
, va_arg (*text
->args_ptr
, HOST_WIDE_INT
));
582 pp_integer_with_precision
583 (pp
, *text
->args_ptr
, precision
, int, "d");
588 pp_scalar (pp
, "%" HOST_WIDE_INT_PRINT
"o",
589 va_arg (*text
->args_ptr
, unsigned HOST_WIDE_INT
));
591 pp_integer_with_precision
592 (pp
, *text
->args_ptr
, precision
, unsigned, "o");
597 pp_quoted_string (pp
, va_arg (*text
->args_ptr
, const char *));
599 pp_string (pp
, va_arg (*text
->args_ptr
, const char *));
603 pp_pointer (pp
, va_arg (*text
->args_ptr
, void *));
608 pp_scalar (pp
, HOST_WIDE_INT_PRINT_UNSIGNED
,
609 va_arg (*text
->args_ptr
, unsigned HOST_WIDE_INT
));
611 pp_integer_with_precision
612 (pp
, *text
->args_ptr
, precision
, unsigned, "u");
617 int *v
= va_arg (*text
->args_ptr
, int *);
618 unsigned len
= va_arg (*text
->args_ptr
, unsigned);
620 for (unsigned i
= 0; i
< len
; ++i
)
622 pp_scalar (pp
, "%i", v
[i
]);
634 pp_scalar (pp
, HOST_WIDE_INT_PRINT_HEX
,
635 va_arg (*text
->args_ptr
, unsigned HOST_WIDE_INT
));
637 pp_integer_with_precision
638 (pp
, *text
->args_ptr
, precision
, unsigned, "x");
646 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
647 (where M == N + 1). The format string should be verified
648 already from the first phase. */
653 n
= strtoul (p
, &end
, 10);
655 gcc_assert (*p
== 's');
659 gcc_assert (*p
== '*');
661 gcc_assert (*p
== 's');
662 n
= va_arg (*text
->args_ptr
, int);
664 /* This consumes a second entry in the formatters array. */
665 gcc_assert (formatters
[argno
] == formatters
[argno
+1]);
669 s
= va_arg (*text
->args_ptr
, const char *);
671 /* Negative precision is treated as if it were omitted. */
675 /* Append the lesser of precision and strlen (s) characters. */
676 size_t len
= strlen (s
);
677 if ((unsigned) n
< len
)
680 pp_append_text (pp
, s
, s
+ len
);
688 gcc_assert (pp_format_decoder (pp
));
689 ok
= pp_format_decoder (pp
) (pp
, text
, p
,
690 precision
, wide
, plus
, hash
, quote
,
698 pp_string (pp
, colorize_stop (pp_show_color (pp
)));
699 pp_string (pp
, close_quote
);
702 obstack_1grow (&buffer
->chunk_obstack
, '\0');
703 *formatters
[argno
] = XOBFINISH (&buffer
->chunk_obstack
, const char *);
707 for (; argno
< PP_NL_ARGMAX
; argno
++)
708 gcc_assert (!formatters
[argno
]);
710 /* If the client supplied a postprocessing object, call its "handle"
712 if (pp
->m_format_postprocessor
)
713 pp
->m_format_postprocessor
->handle (pp
);
715 /* Revert to normal obstack and wrapping mode. */
716 buffer
->obstack
= &buffer
->formatted_obstack
;
717 buffer
->line_length
= 0;
718 pp_wrapping_mode (pp
) = old_wrapping_mode
;
722 /* Format of a message pointed to by TEXT. */
724 pp_output_formatted_text (pretty_printer
*pp
)
727 output_buffer
*buffer
= pp_buffer (pp
);
728 struct chunk_info
*chunk_array
= buffer
->cur_chunk_array
;
729 const char **args
= chunk_array
->args
;
731 gcc_assert (buffer
->obstack
== &buffer
->formatted_obstack
);
732 gcc_assert (buffer
->line_length
== 0);
734 /* This is a third phase, first 2 phases done in pp_format_args.
735 Now we actually print it. */
736 for (chunk
= 0; args
[chunk
]; chunk
++)
737 pp_string (pp
, args
[chunk
]);
739 /* Deallocate the chunk structure and everything after it (i.e. the
740 associated series of formatted strings). */
741 buffer
->cur_chunk_array
= chunk_array
->prev
;
742 obstack_free (&buffer
->chunk_obstack
, chunk_array
);
745 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
746 settings needed by BUFFER for a verbatim formatting. */
748 pp_format_verbatim (pretty_printer
*pp
, text_info
*text
)
750 /* Set verbatim mode. */
751 pp_wrapping_mode_t oldmode
= pp_set_verbatim_wrapping (pp
);
753 /* Do the actual formatting. */
754 pp_format (pp
, text
);
755 pp_output_formatted_text (pp
);
757 /* Restore previous settings. */
758 pp_wrapping_mode (pp
) = oldmode
;
761 /* Flush the content of BUFFER onto the attached stream. This
762 function does nothing unless pp->output_buffer->flush_p. */
764 pp_flush (pretty_printer
*pp
)
767 if (!pp
->buffer
->flush_p
)
769 pp_write_text_to_stream (pp
);
770 fflush (pp_buffer (pp
)->stream
);
773 /* Flush the content of BUFFER onto the attached stream independently
774 of the value of pp->output_buffer->flush_p. */
776 pp_really_flush (pretty_printer
*pp
)
779 pp_write_text_to_stream (pp
);
780 fflush (pp_buffer (pp
)->stream
);
783 /* Sets the number of maximum characters per line PRETTY-PRINTER can
784 output in line-wrapping mode. A LENGTH value 0 suppresses
787 pp_set_line_maximum_length (pretty_printer
*pp
, int length
)
789 pp_line_cutoff (pp
) = length
;
790 pp_set_real_maximum_length (pp
);
793 /* Clear PRETTY-PRINTER output area text info. */
795 pp_clear_output_area (pretty_printer
*pp
)
797 obstack_free (pp_buffer (pp
)->obstack
,
798 obstack_base (pp_buffer (pp
)->obstack
));
799 pp_buffer (pp
)->line_length
= 0;
802 /* Set PREFIX for PRETTY-PRINTER. */
804 pp_set_prefix (pretty_printer
*pp
, const char *prefix
)
807 pp_set_real_maximum_length (pp
);
808 pp
->emitted_prefix
= false;
809 pp_indentation (pp
) = 0;
812 /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string. */
814 pp_destroy_prefix (pretty_printer
*pp
)
816 if (pp
->prefix
!= NULL
)
818 free (CONST_CAST (char *, pp
->prefix
));
823 /* Write out PRETTY-PRINTER's prefix. */
825 pp_emit_prefix (pretty_printer
*pp
)
827 if (pp
->prefix
!= NULL
)
829 switch (pp_prefixing_rule (pp
))
832 case DIAGNOSTICS_SHOW_PREFIX_NEVER
:
835 case DIAGNOSTICS_SHOW_PREFIX_ONCE
:
836 if (pp
->emitted_prefix
)
841 pp_indentation (pp
) += 3;
844 case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
:
846 int prefix_length
= strlen (pp
->prefix
);
847 pp_append_r (pp
, pp
->prefix
, prefix_length
);
848 pp
->emitted_prefix
= true;
855 /* Construct a PRETTY-PRINTER with PREFIX and of MAXIMUM_LENGTH
856 characters per line. */
858 pretty_printer::pretty_printer (const char *p
, int l
)
859 : buffer (new (XCNEW (output_buffer
)) output_buffer ()),
866 m_format_postprocessor (NULL
),
869 translate_identifiers (true),
872 pp_line_cutoff (this) = l
;
873 /* By default, we emit prefixes once per message. */
874 pp_prefixing_rule (this) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
875 pp_set_prefix (this, p
);
878 pretty_printer::~pretty_printer ()
880 if (m_format_postprocessor
)
881 delete m_format_postprocessor
;
882 buffer
->~output_buffer ();
886 /* Append a string delimited by START and END to the output area of
887 PRETTY-PRINTER. No line wrapping is done. However, if beginning a
888 new line then emit PRETTY-PRINTER's prefix and skip any leading
889 whitespace if appropriate. The caller must ensure that it is
892 pp_append_text (pretty_printer
*pp
, const char *start
, const char *end
)
894 /* Emit prefix and skip whitespace if we're starting a new line. */
895 if (pp_buffer (pp
)->line_length
== 0)
898 if (pp_is_wrapping_line (pp
))
899 while (start
!= end
&& *start
== ' ')
902 pp_append_r (pp
, start
, end
- start
);
905 /* Finishes constructing a NULL-terminated character string representing
906 the PRETTY-PRINTED text. */
908 pp_formatted_text (pretty_printer
*pp
)
910 return output_buffer_formatted_text (pp_buffer (pp
));
913 /* Return a pointer to the last character emitted in PRETTY-PRINTER's
914 output area. A NULL pointer means no character available. */
916 pp_last_position_in_text (const pretty_printer
*pp
)
918 return output_buffer_last_position_in_text (pp_buffer (pp
));
921 /* Return the amount of characters PRETTY-PRINTER can accept to
922 make a full line. Meaningful only in line-wrapping mode. */
924 pp_remaining_character_count_for_line (pretty_printer
*pp
)
926 return pp
->maximum_length
- pp_buffer (pp
)->line_length
;
930 /* Format a message into BUFFER a la printf. */
932 pp_printf (pretty_printer
*pp
, const char *msg
, ...)
940 text
.format_spec
= msg
;
941 pp_format (pp
, &text
);
942 pp_output_formatted_text (pp
);
947 /* Output MESSAGE verbatim into BUFFER. */
949 pp_verbatim (pretty_printer
*pp
, const char *msg
, ...)
957 text
.format_spec
= msg
;
958 pp_format_verbatim (pp
, &text
);
964 /* Have PRETTY-PRINTER start a new line. */
966 pp_newline (pretty_printer
*pp
)
968 obstack_1grow (pp_buffer (pp
)->obstack
, '\n');
969 pp_needs_newline (pp
) = false;
970 pp_buffer (pp
)->line_length
= 0;
973 /* Have PRETTY-PRINTER add a CHARACTER. */
975 pp_character (pretty_printer
*pp
, int c
)
977 if (pp_is_wrapping_line (pp
)
978 && pp_remaining_character_count_for_line (pp
) <= 0)
984 obstack_1grow (pp_buffer (pp
)->obstack
, c
);
985 ++pp_buffer (pp
)->line_length
;
988 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
989 be line-wrapped if in appropriate mode. */
991 pp_string (pretty_printer
*pp
, const char *str
)
993 gcc_checking_assert (str
);
994 pp_maybe_wrap_text (pp
, str
, str
+ strlen (str
));
997 /* Append the leading N characters of STRING to the output area of
998 PRETTY-PRINTER, quoting in hexadecimal non-printable characters.
999 Setting N = -1 is as if N were set to strlen (STRING). The STRING
1000 may be line-wrapped if in appropriate mode. */
1002 pp_quoted_string (pretty_printer
*pp
, const char *str
, size_t n
/* = -1 */)
1004 gcc_checking_assert (str
);
1006 const char *last
= str
;
1009 /* Compute the length if not specified. */
1010 if (n
== (size_t) -1)
1013 for (ps
= str
; n
; ++ps
, --n
)
1019 pp_maybe_wrap_text (pp
, last
, ps
- 1);
1021 /* Append the hexadecimal value of the character. Allocate a buffer
1022 that's large enough for a 32-bit char plus the hex prefix. */
1024 int n
= sprintf (buf
, "\\x%02x", (unsigned char)*ps
);
1025 pp_maybe_wrap_text (pp
, buf
, buf
+ n
);
1029 pp_maybe_wrap_text (pp
, last
, ps
);
1032 /* Maybe print out a whitespace if needed. */
1035 pp_maybe_space (pretty_printer
*pp
)
1037 if (pp
->padding
!= pp_none
)
1040 pp
->padding
= pp_none
;
1044 // Add a newline to the pretty printer PP and flush formatted text.
1047 pp_newline_and_flush (pretty_printer
*pp
)
1051 pp_needs_newline (pp
) = false;
1054 // Add a newline to the pretty printer PP, followed by indentation.
1057 pp_newline_and_indent (pretty_printer
*pp
, int n
)
1059 pp_indentation (pp
) += n
;
1062 pp_needs_newline (pp
) = false;
1065 // Add separator C, followed by a single whitespace.
1068 pp_separate_with (pretty_printer
*pp
, char c
)
1070 pp_character (pp
, c
);
1075 /* The string starting at P has LEN (at least 1) bytes left; if they
1076 start with a valid UTF-8 sequence, return the length of that
1077 sequence and set *VALUE to the value of that sequence, and
1078 otherwise return 0 and set *VALUE to (unsigned int) -1. */
1081 decode_utf8_char (const unsigned char *p
, size_t len
, unsigned int *value
)
1083 unsigned int t
= *p
;
1089 size_t utf8_len
= 0;
1092 for (t
= *p
; t
& 0x80; t
<<= 1)
1095 if (utf8_len
> len
|| utf8_len
< 2 || utf8_len
> 6)
1097 *value
= (unsigned int) -1;
1100 ch
= *p
& ((1 << (7 - utf8_len
)) - 1);
1101 for (i
= 1; i
< utf8_len
; i
++)
1103 unsigned int u
= p
[i
];
1104 if ((u
& 0xC0) != 0x80)
1106 *value
= (unsigned int) -1;
1109 ch
= (ch
<< 6) | (u
& 0x3F);
1111 if ( (ch
<= 0x7F && utf8_len
> 1)
1112 || (ch
<= 0x7FF && utf8_len
> 2)
1113 || (ch
<= 0xFFFF && utf8_len
> 3)
1114 || (ch
<= 0x1FFFFF && utf8_len
> 4)
1115 || (ch
<= 0x3FFFFFF && utf8_len
> 5)
1116 || (ch
>= 0xD800 && ch
<= 0xDFFF))
1118 *value
= (unsigned int) -1;
1131 /* Allocator for identifier_to_locale and corresponding function to
1134 void *(*identifier_to_locale_alloc
) (size_t) = xmalloc
;
1135 void (*identifier_to_locale_free
) (void *) = free
;
1137 /* Given IDENT, an identifier in the internal encoding, return a
1138 version of IDENT suitable for diagnostics in the locale character
1139 set: either IDENT itself, or a string, allocated using
1140 identifier_to_locale_alloc, converted to the locale character set
1141 and using escape sequences if not representable in the locale
1142 character set or containing control characters or invalid byte
1143 sequences. Existing backslashes in IDENT are not doubled, so the
1144 result may not uniquely specify the contents of an arbitrary byte
1145 sequence identifier. */
1148 identifier_to_locale (const char *ident
)
1150 const unsigned char *uid
= (const unsigned char *) ident
;
1151 size_t idlen
= strlen (ident
);
1152 bool valid_printable_utf8
= true;
1153 bool all_ascii
= true;
1156 for (i
= 0; i
< idlen
;)
1159 size_t utf8_len
= decode_utf8_char (&uid
[i
], idlen
- i
, &c
);
1160 if (utf8_len
== 0 || c
<= 0x1F || (c
>= 0x7F && c
<= 0x9F))
1162 valid_printable_utf8
= false;
1170 /* If IDENT contains invalid UTF-8 sequences (which may occur with
1171 attributes putting arbitrary byte sequences in identifiers), or
1172 control characters, we use octal escape sequences for all bytes
1173 outside printable ASCII. */
1174 if (!valid_printable_utf8
)
1176 char *ret
= (char *) identifier_to_locale_alloc (4 * idlen
+ 1);
1178 for (i
= 0; i
< idlen
; i
++)
1180 if (uid
[i
] > 0x1F && uid
[i
] < 0x7F)
1184 sprintf (p
, "\\%03o", uid
[i
]);
1192 /* Otherwise, if it is valid printable ASCII, or printable UTF-8
1193 with the locale character set being UTF-8, IDENT is used. */
1194 if (all_ascii
|| locale_utf8
)
1197 /* Otherwise IDENT is converted to the locale character set if
1199 #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
1200 if (locale_encoding
!= NULL
)
1202 iconv_t cd
= iconv_open (locale_encoding
, "UTF-8");
1203 bool conversion_ok
= true;
1205 if (cd
!= (iconv_t
) -1)
1207 size_t ret_alloc
= 4 * idlen
+ 1;
1210 /* Repeat the whole conversion process as needed with
1211 larger buffers so non-reversible transformations can
1212 always be detected. */
1213 ICONV_CONST
char *inbuf
= CONST_CAST (char *, ident
);
1215 size_t inbytesleft
= idlen
;
1216 size_t outbytesleft
= ret_alloc
- 1;
1219 ret
= (char *) identifier_to_locale_alloc (ret_alloc
);
1222 if (iconv (cd
, 0, 0, 0, 0) == (size_t) -1)
1224 conversion_ok
= false;
1228 iconv_ret
= iconv (cd
, &inbuf
, &inbytesleft
,
1229 &outbuf
, &outbytesleft
);
1230 if (iconv_ret
== (size_t) -1 || inbytesleft
!= 0)
1235 identifier_to_locale_free (ret
);
1241 conversion_ok
= false;
1245 else if (iconv_ret
!= 0)
1247 conversion_ok
= false;
1250 /* Return to initial shift state. */
1251 if (iconv (cd
, 0, 0, &outbuf
, &outbytesleft
) == (size_t) -1)
1256 identifier_to_locale_free (ret
);
1262 conversion_ok
= false;
1276 /* Otherwise, convert non-ASCII characters in IDENT to UCNs. */
1278 char *ret
= (char *) identifier_to_locale_alloc (10 * idlen
+ 1);
1280 for (i
= 0; i
< idlen
;)
1283 size_t utf8_len
= decode_utf8_char (&uid
[i
], idlen
- i
, &c
);
1288 sprintf (p
, "\\U%08x", c
);
1300 namespace selftest
{
1302 /* Smoketest for pretty_printer. */
1305 test_basic_printing ()
1308 pp_string (&pp
, "hello");
1310 pp_string (&pp
, "world");
1312 ASSERT_STREQ ("hello world", pp_formatted_text (&pp
));
1315 /* Helper function for testing pp_format.
1316 Verify that pp_format (FMT, ...) followed by pp_output_formatted_text
1317 prints EXPECTED, assuming that pp_show_color is SHOW_COLOR. */
1320 assert_pp_format_va (const location
&loc
, const char *expected
,
1321 bool show_color
, const char *fmt
, va_list *ap
)
1325 rich_location
rich_loc (line_table
, UNKNOWN_LOCATION
);
1327 ti
.format_spec
= fmt
;
1331 ti
.m_richloc
= &rich_loc
;
1333 pp_show_color (&pp
) = show_color
;
1334 pp_format (&pp
, &ti
);
1335 pp_output_formatted_text (&pp
);
1336 ASSERT_STREQ_AT (loc
, expected
, pp_formatted_text (&pp
));
1339 /* Verify that pp_format (FMT, ...) followed by pp_output_formatted_text
1340 prints EXPECTED, with show_color disabled. */
1343 assert_pp_format (const location
&loc
, const char *expected
,
1344 const char *fmt
, ...)
1349 assert_pp_format_va (loc
, expected
, false, fmt
, &ap
);
1353 /* As above, but with colorization enabled. */
1356 assert_pp_format_colored (const location
&loc
, const char *expected
,
1357 const char *fmt
, ...)
1359 /* The tests of colorization assume the default color scheme.
1360 If GCC_COLORS is set, then the colors have potentially been
1361 overridden; skip the test. */
1362 if (getenv ("GCC_COLORS"))
1368 assert_pp_format_va (loc
, expected
, true, fmt
, &ap
);
1372 /* Helper function for calling testing pp_format,
1373 by calling assert_pp_format with various numbers of arguments.
1374 These exist mostly to avoid having to write SELFTEST_LOCATION
1375 throughout test_pp_format. */
1377 #define ASSERT_PP_FORMAT_1(EXPECTED, FMT, ARG1) \
1378 SELFTEST_BEGIN_STMT \
1379 assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
1383 #define ASSERT_PP_FORMAT_2(EXPECTED, FMT, ARG1, ARG2) \
1384 SELFTEST_BEGIN_STMT \
1385 assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
1389 #define ASSERT_PP_FORMAT_3(EXPECTED, FMT, ARG1, ARG2, ARG3) \
1390 SELFTEST_BEGIN_STMT \
1391 assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
1392 (ARG1), (ARG2), (ARG3)); \
1395 /* Verify that pp_format works, for various format codes. */
1400 /* Avoid introducing locale-specific differences in the results
1401 by hardcoding open_quote and close_quote. */
1402 const char *old_open_quote
= open_quote
;
1403 const char *old_close_quote
= close_quote
;
1407 /* Verify that plain text is passed through unchanged. */
1408 assert_pp_format (SELFTEST_LOCATION
, "unformatted", "unformatted");
1410 /* Verify various individual format codes, in the order listed in the
1411 comment for pp_format above. For each code, we append a second
1412 argument with a known bit pattern (0x12345678), to ensure that we
1413 are consuming arguments correctly. */
1414 ASSERT_PP_FORMAT_2 ("-27 12345678", "%d %x", -27, 0x12345678);
1415 ASSERT_PP_FORMAT_2 ("-5 12345678", "%i %x", -5, 0x12345678);
1416 ASSERT_PP_FORMAT_2 ("10 12345678", "%u %x", 10, 0x12345678);
1417 ASSERT_PP_FORMAT_2 ("17 12345678", "%o %x", 15, 0x12345678);
1418 ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%x %x", 0xcafebabe, 0x12345678);
1419 ASSERT_PP_FORMAT_2 ("-27 12345678", "%ld %x", (long)-27, 0x12345678);
1420 ASSERT_PP_FORMAT_2 ("-5 12345678", "%li %x", (long)-5, 0x12345678);
1421 ASSERT_PP_FORMAT_2 ("10 12345678", "%lu %x", (long)10, 0x12345678);
1422 ASSERT_PP_FORMAT_2 ("17 12345678", "%lo %x", (long)15, 0x12345678);
1423 ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%lx %x", (long)0xcafebabe,
1425 ASSERT_PP_FORMAT_2 ("-27 12345678", "%lld %x", (long long)-27, 0x12345678);
1426 ASSERT_PP_FORMAT_2 ("-5 12345678", "%lli %x", (long long)-5, 0x12345678);
1427 ASSERT_PP_FORMAT_2 ("10 12345678", "%llu %x", (long long)10, 0x12345678);
1428 ASSERT_PP_FORMAT_2 ("17 12345678", "%llo %x", (long long)15, 0x12345678);
1429 ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%llx %x", (long long)0xcafebabe,
1431 ASSERT_PP_FORMAT_2 ("-27 12345678", "%wd %x", (HOST_WIDE_INT
)-27, 0x12345678);
1432 ASSERT_PP_FORMAT_2 ("-5 12345678", "%wi %x", (HOST_WIDE_INT
)-5, 0x12345678);
1433 ASSERT_PP_FORMAT_2 ("10 12345678", "%wu %x", (unsigned HOST_WIDE_INT
)10,
1435 ASSERT_PP_FORMAT_2 ("17 12345678", "%wo %x", (HOST_WIDE_INT
)15, 0x12345678);
1436 ASSERT_PP_FORMAT_2 ("0xcafebabe 12345678", "%wx %x", (HOST_WIDE_INT
)0xcafebabe,
1438 ASSERT_PP_FORMAT_2 ("A 12345678", "%c %x", 'A', 0x12345678);
1439 ASSERT_PP_FORMAT_2 ("hello world 12345678", "%s %x", "hello world",
1441 /* We can't test for %p; the pointer is printed in an implementation-defined
1443 ASSERT_PP_FORMAT_2 ("normal colored normal 12345678",
1444 "normal %rcolored%R normal %x",
1445 "error", 0x12345678);
1446 assert_pp_format_colored
1448 "normal \33[01;31m\33[Kcolored\33[m\33[K normal 12345678",
1449 "normal %rcolored%R normal %x", "error", 0x12345678);
1451 %m: strerror(text->err_no) - does not consume a value from args_ptr. */
1452 ASSERT_PP_FORMAT_1 ("% 12345678", "%% %x", 0x12345678);
1453 ASSERT_PP_FORMAT_1 ("` 12345678", "%< %x", 0x12345678);
1454 ASSERT_PP_FORMAT_1 ("' 12345678", "%> %x", 0x12345678);
1455 ASSERT_PP_FORMAT_1 ("' 12345678", "%' %x", 0x12345678);
1456 ASSERT_PP_FORMAT_3 ("abc 12345678", "%.*s %x", 3, "abcdef", 0x12345678);
1457 ASSERT_PP_FORMAT_2 ("abc 12345678", "%.3s %x", "abcdef", 0x12345678);
1459 /* Verify flag 'q'. */
1460 ASSERT_PP_FORMAT_2 ("`foo' 12345678", "%qs %x", "foo", 0x12345678);
1461 assert_pp_format_colored (SELFTEST_LOCATION
,
1462 "`\33[01m\33[Kfoo\33[m\33[K' 12345678", "%qs %x",
1466 int v
[] = { 1, 2, 3 };
1467 ASSERT_PP_FORMAT_3 ("1, 2, 3 12345678", "%Z %x", v
, 3, 0x12345678);
1470 ASSERT_PP_FORMAT_3 ("0 12345678", "%Z %x", v2
, 1, 0x12345678);
1472 /* Verify that combinations work, along with unformatted text. */
1473 assert_pp_format (SELFTEST_LOCATION
,
1474 "the quick brown fox jumps over the lazy dog",
1475 "the %s %s %s jumps over the %s %s",
1476 "quick", "brown", "fox", "lazy", "dog");
1477 assert_pp_format (SELFTEST_LOCATION
, "item 3 of 7", "item %i of %i", 3, 7);
1478 assert_pp_format (SELFTEST_LOCATION
, "problem with `bar' at line 10",
1479 "problem with %qs at line %i", "bar", 10);
1481 /* Restore old values of open_quote and close_quote. */
1482 open_quote
= old_open_quote
;
1483 close_quote
= old_close_quote
;
1486 /* Run all of the selftests within this file. */
1489 pretty_print_c_tests ()
1491 test_basic_printing ();
1495 } // namespace selftest
1497 #endif /* CHECKING_P */