1 /* Various declarations for language-independent pretty-print subroutines.
2 Copyright (C) 2003-2020 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"
27 #include "diagnostic-event-id.h"
36 /* Replacement for fputs() that handles ANSI escape codes on Windows NT.
37 Contributed by: Liu Hao (lh_mouse at 126 dot com)
39 XXX: This file is compiled into libcommon.a that will be self-contained.
40 It looks like that these functions can be put nowhere else. */
43 #define WIN32_LEAN_AND_MEAN 1
46 /* Write all bytes in [s,s+n) into the specified stream.
47 Errors are ignored. */
49 write_all (HANDLE h
, const char *s
, size_t n
)
60 if (!WriteFile (h
, s
+ n
- rem
, step
, &step
, NULL
))
66 /* Find the beginning of an escape sequence.
68 1. If the sequence begins with an ESC character (0x1B) and a second
69 character X in [0x40,0x5F], returns X and stores a pointer to
70 the third character into *head.
71 2. If the sequence begins with a character X in [0x80,0x9F], returns
72 (X-0x40) and stores a pointer to the second character into *head.
73 Stores the number of ESC character(s) in *prefix_len.
74 Returns 0 if no such sequence can be found. */
76 find_esc_head (int *prefix_len
, const char **head
, const char *str
)
84 c
= (unsigned char) *r
;
90 if (escaped
&& 0x40 <= c
&& c
<= 0x5F)
97 if (0x80 <= c
&& c
<= 0x9F)
109 /* Find the terminator of an escape sequence.
110 str should be the value stored in *head by a previous successful
111 call to find_esc_head().
112 Returns 0 if no such sequence can be found. */
114 find_esc_terminator (const char **term
, const char *str
)
121 c
= (unsigned char) *r
;
127 if (0x40 <= c
&& c
<= 0x7E)
137 /* Handle a sequence of codes. Sequences that are invalid, reserved,
138 unrecognized or unimplemented are ignored silently.
139 There isn't much we can do because of lameness of Windows consoles. */
141 eat_esc_sequence (HANDLE h
, int esc_code
,
142 const char *esc_head
, const char *esc_term
)
144 /* Numbers in an escape sequence cannot be negative, because
145 a minus sign in the middle of it would have terminated it. */
148 CONSOLE_SCREEN_BUFFER_INFO sb
;
150 /* ED and EL parameters. */
153 /* SGR parameters. */
154 WORD attrib_add
, attrib_rm
;
157 switch (MAKEWORD (esc_code
, *esc_term
))
160 Move the cursor up by n1 characters. */
161 case MAKEWORD ('[', 'A'):
162 if (esc_head
== esc_term
)
166 n1
= strtol (esc_head
, &eptr
, 10);
167 if (eptr
!= esc_term
)
171 if (GetConsoleScreenBufferInfo (h
, &sb
))
173 cr
= sb
.dwCursorPosition
;
174 /* Stop at the topmost boundary. */
179 SetConsoleCursorPosition (h
, cr
);
184 Move the cursor down by n1 characters. */
185 case MAKEWORD ('[', 'B'):
186 if (esc_head
== esc_term
)
190 n1
= strtol (esc_head
, &eptr
, 10);
191 if (eptr
!= esc_term
)
195 if (GetConsoleScreenBufferInfo (h
, &sb
))
197 cr
= sb
.dwCursorPosition
;
198 /* Stop at the bottommost boundary. */
199 if (sb
.dwSize
.Y
- cr
.Y
> n1
)
203 SetConsoleCursorPosition (h
, cr
);
208 Move the cursor right by n1 characters. */
209 case MAKEWORD ('[', 'C'):
210 if (esc_head
== esc_term
)
214 n1
= strtol (esc_head
, &eptr
, 10);
215 if (eptr
!= esc_term
)
219 if (GetConsoleScreenBufferInfo (h
, &sb
))
221 cr
= sb
.dwCursorPosition
;
222 /* Stop at the rightmost boundary. */
223 if (sb
.dwSize
.X
- cr
.X
> n1
)
227 SetConsoleCursorPosition (h
, cr
);
232 Move the cursor left by n1 characters. */
233 case MAKEWORD ('[', 'D'):
234 if (esc_head
== esc_term
)
238 n1
= strtol (esc_head
, &eptr
, 10);
239 if (eptr
!= esc_term
)
243 if (GetConsoleScreenBufferInfo (h
, &sb
))
245 cr
= sb
.dwCursorPosition
;
246 /* Stop at the leftmost boundary. */
251 SetConsoleCursorPosition (h
, cr
);
256 Move the cursor to the beginning of the n1-th line downwards. */
257 case MAKEWORD ('[', 'E'):
258 if (esc_head
== esc_term
)
262 n1
= strtol (esc_head
, &eptr
, 10);
263 if (eptr
!= esc_term
)
267 if (GetConsoleScreenBufferInfo (h
, &sb
))
269 cr
= sb
.dwCursorPosition
;
271 /* Stop at the bottommost boundary. */
272 if (sb
.dwSize
.Y
- cr
.Y
> n1
)
276 SetConsoleCursorPosition (h
, cr
);
281 Move the cursor to the beginning of the n1-th line upwards. */
282 case MAKEWORD ('[', 'F'):
283 if (esc_head
== esc_term
)
287 n1
= strtol (esc_head
, &eptr
, 10);
288 if (eptr
!= esc_term
)
292 if (GetConsoleScreenBufferInfo (h
, &sb
))
294 cr
= sb
.dwCursorPosition
;
296 /* Stop at the topmost boundary. */
301 SetConsoleCursorPosition (h
, cr
);
306 Move the cursor to the (1-based) n1-th column. */
307 case MAKEWORD ('[', 'G'):
308 if (esc_head
== esc_term
)
312 n1
= strtol (esc_head
, &eptr
, 10);
313 if (eptr
!= esc_term
)
317 if (GetConsoleScreenBufferInfo (h
, &sb
))
319 cr
= sb
.dwCursorPosition
;
321 /* Stop at the leftmost or rightmost boundary. */
324 else if (n1
> sb
.dwSize
.X
)
328 SetConsoleCursorPosition (h
, cr
);
332 /* ESC [ n1 ';' n2 'H'
334 Move the cursor to the (1-based) n1-th row and
335 (also 1-based) n2-th column. */
336 case MAKEWORD ('[', 'H'):
337 case MAKEWORD ('[', 'f'):
338 if (esc_head
== esc_term
)
340 /* Both parameters are omitted and set to 1 by default. */
344 else if (!(delim
= (char *) memchr (esc_head
, ';',
345 esc_term
- esc_head
)))
347 /* Only the first parameter is given. The second one is
348 set to 1 by default. */
349 n1
= strtol (esc_head
, &eptr
, 10);
350 if (eptr
!= esc_term
)
356 /* Both parameters are given. The first one shall be
357 terminated by the semicolon. */
358 n1
= strtol (esc_head
, &eptr
, 10);
361 n2
= strtol (delim
+ 1, &eptr
, 10);
362 if (eptr
!= esc_term
)
366 if (GetConsoleScreenBufferInfo (h
, &sb
))
368 cr
= sb
.dwCursorPosition
;
371 /* The cursor position shall be relative to the view coord of
372 the console window, which is usually smaller than the actual
373 buffer. FWIW, the 'appropriate' solution will be shrinking
374 the buffer to match the size of the console window,
375 destroying scrollback in the process. */
376 n1
+= sb
.srWindow
.Top
;
377 n2
+= sb
.srWindow
.Left
;
378 /* Stop at the topmost or bottommost boundary. */
381 else if (n1
> sb
.dwSize
.Y
)
385 /* Stop at the leftmost or rightmost boundary. */
388 else if (n2
> sb
.dwSize
.X
)
392 SetConsoleCursorPosition (h
, cr
);
398 case MAKEWORD ('[', 'J'):
399 if (esc_head
== esc_term
)
400 /* This is one of the very few codes whose parameters have
401 a default value of zero. */
405 n1
= strtol (esc_head
, &eptr
, 10);
406 if (eptr
!= esc_term
)
410 if (GetConsoleScreenBufferInfo (h
, &sb
))
412 /* The cursor is not necessarily in the console window, which
413 makes the behavior of this code harder to define. */
417 /* If the cursor is in or above the window, erase from
418 it to the bottom of the window; otherwise, do nothing. */
419 cr
= sb
.dwCursorPosition
;
420 cnt
= sb
.dwSize
.X
- sb
.dwCursorPosition
.X
;
421 rows
= sb
.srWindow
.Bottom
- sb
.dwCursorPosition
.Y
;
424 /* If the cursor is in or under the window, erase from
425 it to the top of the window; otherwise, do nothing. */
427 cr
.Y
= sb
.srWindow
.Top
;
428 cnt
= sb
.dwCursorPosition
.X
+ 1;
429 rows
= sb
.dwCursorPosition
.Y
- sb
.srWindow
.Top
;
432 /* Erase the entire window. */
433 cr
.X
= sb
.srWindow
.Left
;
434 cr
.Y
= sb
.srWindow
.Top
;
436 rows
= sb
.srWindow
.Bottom
- sb
.srWindow
.Top
+ 1;
439 /* Erase the entire buffer. */
448 cnt
+= rows
* sb
.dwSize
.X
;
449 FillConsoleOutputCharacterW (h
, L
' ', cnt
, cr
, &step
);
450 FillConsoleOutputAttribute (h
, sb
.wAttributes
, cnt
, cr
, &step
);
456 case MAKEWORD ('[', 'K'):
457 if (esc_head
== esc_term
)
458 /* This is one of the very few codes whose parameters have
459 a default value of zero. */
463 n1
= strtol (esc_head
, &eptr
, 10);
464 if (eptr
!= esc_term
)
468 if (GetConsoleScreenBufferInfo (h
, &sb
))
473 /* Erase from the cursor to the end. */
474 cr
= sb
.dwCursorPosition
;
475 cnt
= sb
.dwSize
.X
- sb
.dwCursorPosition
.X
;
478 /* Erase from the cursor to the beginning. */
479 cr
= sb
.dwCursorPosition
;
481 cnt
= sb
.dwCursorPosition
.X
+ 1;
484 /* Erase the entire line. */
485 cr
= sb
.dwCursorPosition
;
490 FillConsoleOutputCharacterW (h
, L
' ', cnt
, cr
, &step
);
491 FillConsoleOutputAttribute (h
, sb
.wAttributes
, cnt
, cr
, &step
);
495 /* ESC [ n1 ';' n2 'm'
496 Set SGR parameters. Zero or more parameters will follow. */
497 case MAKEWORD ('[', 'm'):
500 if (esc_head
== esc_term
)
502 /* When no parameter is given, reset the console. */
503 attrib_add
|= (FOREGROUND_RED
| FOREGROUND_GREEN
505 attrib_rm
= -1; /* Removes everything. */
511 /* Parse a parameter. */
512 n1
= strtol (param
, &eptr
, 10);
513 if (*eptr
!= ';' && eptr
!= esc_term
)
520 attrib_add
|= (FOREGROUND_RED
| FOREGROUND_GREEN
522 attrib_rm
= -1; /* Removes everything. */
526 attrib_add
|= FOREGROUND_INTENSITY
;
530 attrib_add
|= COMMON_LVB_UNDERSCORE
;
534 /* XXX: It is not BLINKING at all! */
535 attrib_add
|= BACKGROUND_INTENSITY
;
539 attrib_add
|= COMMON_LVB_REVERSE_VIDEO
;
543 attrib_add
&= ~FOREGROUND_INTENSITY
;
544 attrib_rm
|= FOREGROUND_INTENSITY
;
548 attrib_add
&= ~COMMON_LVB_UNDERSCORE
;
549 attrib_rm
|= COMMON_LVB_UNDERSCORE
;
553 /* XXX: It is not BLINKING at all! */
554 attrib_add
&= ~BACKGROUND_INTENSITY
;
555 attrib_rm
|= BACKGROUND_INTENSITY
;
559 attrib_add
&= ~COMMON_LVB_REVERSE_VIDEO
;
560 attrib_rm
|= COMMON_LVB_REVERSE_VIDEO
;
570 /* Foreground color. */
571 attrib_add
&= ~(FOREGROUND_RED
| FOREGROUND_GREEN
575 attrib_add
|= FOREGROUND_RED
;
577 attrib_add
|= FOREGROUND_GREEN
;
579 attrib_add
|= FOREGROUND_BLUE
;
580 attrib_rm
|= (FOREGROUND_RED
| FOREGROUND_GREEN
584 /* Reserved for extended foreground color.
585 Don't know how to handle parameters remaining.
589 /* Reset foreground color. */
591 attrib_add
|= (FOREGROUND_RED
| FOREGROUND_GREEN
593 attrib_rm
|= (FOREGROUND_RED
| FOREGROUND_GREEN
604 /* Background color. */
605 attrib_add
&= ~(BACKGROUND_RED
| BACKGROUND_GREEN
609 attrib_add
|= BACKGROUND_RED
;
611 attrib_add
|= BACKGROUND_GREEN
;
613 attrib_add
|= BACKGROUND_BLUE
;
614 attrib_rm
|= (BACKGROUND_RED
| BACKGROUND_GREEN
618 /* Reserved for extended background color.
619 Don't know how to handle parameters remaining.
623 /* Reset background color. */
625 attrib_add
&= ~(BACKGROUND_RED
| BACKGROUND_GREEN
627 attrib_rm
|= (BACKGROUND_RED
| BACKGROUND_GREEN
632 /* Prepare the next parameter. */
635 while (param
!= esc_term
);
638 /* 0xFFFF removes everything. If it is not the case,
639 care must be taken to preserve old attributes. */
640 if (attrib_rm
!= 0xFFFF && GetConsoleScreenBufferInfo (h
, &sb
))
642 attrib_add
|= sb
.wAttributes
& ~attrib_rm
;
644 if (attrib_add
& COMMON_LVB_REVERSE_VIDEO
)
646 /* COMMON_LVB_REVERSE_VIDEO is only effective for DBCS.
647 * Swap foreground and background colors by hand.
649 attrib_add
= (attrib_add
& 0xFF00)
650 | ((attrib_add
& 0x00F0) >> 4)
651 | ((attrib_add
& 0x000F) << 4);
652 attrib_add
&= ~COMMON_LVB_REVERSE_VIDEO
;
654 SetConsoleTextAttribute (h
, attrib_add
);
660 mingw_ansi_fputs (const char *str
, FILE *fp
)
662 const char *read
= str
;
665 int esc_code
, prefix_len
;
666 const char *esc_head
, *esc_term
;
668 h
= (HANDLE
) _get_osfhandle (_fileno (fp
));
669 if (h
== INVALID_HANDLE_VALUE
)
672 /* Don't mess up stdio functions with Windows APIs. */
675 if (GetConsoleMode (h
, &mode
))
676 /* If it is a console, translate ANSI escape codes as needed. */
679 if ((esc_code
= find_esc_head (&prefix_len
, &esc_head
, read
)) == 0)
681 /* Write all remaining characters, then exit. */
682 write_all (h
, read
, strlen (read
));
685 if (find_esc_terminator (&esc_term
, esc_head
) == 0)
686 /* Ignore incomplete escape sequences at the moment.
687 FIXME: The escape state shall be cached for further calls
690 write_all (h
, read
, esc_head
- prefix_len
- read
);
691 eat_esc_sequence (h
, esc_code
, esc_head
, esc_term
);
695 /* If it is not a console, write everything as-is. */
696 write_all (h
, read
, strlen (read
));
701 #endif /* __MINGW32__ */
704 decode_utf8_char (const unsigned char *, size_t len
, unsigned int *);
705 static void pp_quoted_string (pretty_printer
*, const char *, size_t = -1);
707 /* Overwrite the given location/range within this text_info's rich_location.
708 For use e.g. when implementing "+" in client format decoders. */
711 text_info::set_location (unsigned int idx
, location_t loc
,
712 enum range_display_kind range_display_kind
)
714 gcc_checking_assert (m_richloc
);
715 m_richloc
->set_range (idx
, loc
, range_display_kind
);
719 text_info::get_location (unsigned int index_of_location
) const
721 gcc_checking_assert (m_richloc
);
723 if (index_of_location
== 0)
724 return m_richloc
->get_loc ();
726 return UNKNOWN_LOCATION
;
729 // Default construct an output buffer.
731 output_buffer::output_buffer ()
732 : formatted_obstack (),
734 obstack (&formatted_obstack
),
741 obstack_init (&formatted_obstack
);
742 obstack_init (&chunk_obstack
);
745 // Release resources owned by an output buffer at the end of lifetime.
747 output_buffer::~output_buffer ()
749 obstack_free (&chunk_obstack
, NULL
);
750 obstack_free (&formatted_obstack
, NULL
);
754 /* Format an integer given by va_arg (ARG, type-specifier T) where
755 type-specifier is a precision modifier as indicated by PREC. F is
756 a string used to construct the appropriate format-specifier. */
757 #define pp_integer_with_precision(PP, ARG, PREC, T, F) \
762 pp_scalar (PP, "%" F, va_arg (ARG, T)); \
766 pp_scalar (PP, "%l" F, va_arg (ARG, long T)); \
770 pp_scalar (PP, "%" HOST_LONG_LONG_FORMAT F, va_arg (ARG, long long T)); \
779 /* Subroutine of pp_set_maximum_length. Set up PRETTY-PRINTER's
780 internal maximum characters per line. */
782 pp_set_real_maximum_length (pretty_printer
*pp
)
784 /* If we're told not to wrap lines then do the obvious thing. In case
785 we'll emit prefix only once per message, it is appropriate
786 not to increase unnecessarily the line-length cut-off. */
787 if (!pp_is_wrapping_line (pp
)
788 || pp_prefixing_rule (pp
) == DIAGNOSTICS_SHOW_PREFIX_ONCE
789 || pp_prefixing_rule (pp
) == DIAGNOSTICS_SHOW_PREFIX_NEVER
)
790 pp
->maximum_length
= pp_line_cutoff (pp
);
793 int prefix_length
= pp
->prefix
? strlen (pp
->prefix
) : 0;
794 /* If the prefix is ridiculously too long, output at least
796 if (pp_line_cutoff (pp
) - prefix_length
< 32)
797 pp
->maximum_length
= pp_line_cutoff (pp
) + 32;
799 pp
->maximum_length
= pp_line_cutoff (pp
);
803 /* Clear PRETTY-PRINTER's output state. */
805 pp_clear_state (pretty_printer
*pp
)
807 pp
->emitted_prefix
= false;
808 pp_indentation (pp
) = 0;
811 /* Print X to PP in decimal. */
812 template<unsigned int N
, typename T
>
814 pp_wide_integer (pretty_printer
*pp
, const poly_int_pod
<N
, T
> &x
)
816 if (x
.is_constant ())
817 pp_wide_integer (pp
, x
.coeffs
[0]);
820 pp_left_bracket (pp
);
821 for (unsigned int i
= 0; i
< N
; ++i
)
825 pp_wide_integer (pp
, x
.coeffs
[i
]);
827 pp_right_bracket (pp
);
831 template void pp_wide_integer (pretty_printer
*, const poly_uint16_pod
&);
832 template void pp_wide_integer (pretty_printer
*, const poly_int64_pod
&);
833 template void pp_wide_integer (pretty_printer
*, const poly_uint64_pod
&);
835 /* Flush the formatted text of PRETTY-PRINTER onto the attached stream. */
837 pp_write_text_to_stream (pretty_printer
*pp
)
839 const char *text
= pp_formatted_text (pp
);
841 mingw_ansi_fputs (text
, pp_buffer (pp
)->stream
);
843 fputs (text
, pp_buffer (pp
)->stream
);
845 pp_clear_output_area (pp
);
848 /* As pp_write_text_to_stream, but for GraphViz label output.
850 Flush the formatted text of pretty-printer PP onto the attached stream.
851 Replace characters in PPF that have special meaning in a GraphViz .dot
854 This routine is not very fast, but it doesn't have to be as this is only
855 be used by routines dumping intermediate representations in graph form. */
858 pp_write_text_as_dot_label_to_stream (pretty_printer
*pp
, bool for_record
)
860 const char *text
= pp_formatted_text (pp
);
861 const char *p
= text
;
862 FILE *fp
= pp_buffer (pp
)->stream
;
869 /* Print newlines as a left-aligned newline. */
875 /* The following characters are only special for record-shape nodes. */
882 escape_char
= for_record
;
885 /* The following characters always have to be escaped
886 for use in labels. */
888 /* There is a bug in some (f.i. 2.36.0) versions of graphiz
889 ( http://www.graphviz.org/mantisbt/view.php?id=2524 ) related to
890 backslash as last char in label. Let's avoid triggering it. */
891 gcc_assert (*(p
+ 1) != '\0');
908 pp_clear_output_area (pp
);
911 /* As pp_write_text_to_stream, but for GraphViz HTML-like strings.
913 Flush the formatted text of pretty-printer PP onto the attached stream,
914 escaping these characters
916 using XML escape sequences.
918 http://www.graphviz.org/doc/info/lang.html#html states:
919 special XML escape sequences for ", &, <, and > may be necessary in
920 order to embed these characters in attribute values or raw text
921 This doesn't list "'" (which would normally be escaped in XML
922 as "'" or in HTML as "'");.
924 Experiments show that escaping "'" doesn't seem to be necessary. */
927 pp_write_text_as_html_like_dot_to_stream (pretty_printer
*pp
)
929 const char *text
= pp_formatted_text (pp
);
930 const char *p
= text
;
931 FILE *fp
= pp_buffer (pp
)->stream
;
938 fputs (""", fp
);
956 pp_clear_output_area (pp
);
959 /* Wrap a text delimited by START and END into PRETTY-PRINTER. */
961 pp_wrap_text (pretty_printer
*pp
, const char *start
, const char *end
)
963 bool wrapping_line
= pp_is_wrapping_line (pp
);
967 /* Dump anything bordered by whitespaces. */
969 const char *p
= start
;
970 while (p
!= end
&& !ISBLANK (*p
) && *p
!= '\n')
973 && p
- start
>= pp_remaining_character_count_for_line (pp
))
975 pp_append_text (pp
, start
, p
);
979 if (start
!= end
&& ISBLANK (*start
))
984 if (start
!= end
&& *start
== '\n')
992 /* Same as pp_wrap_text but wrap text only when in line-wrapping mode. */
994 pp_maybe_wrap_text (pretty_printer
*pp
, const char *start
, const char *end
)
996 if (pp_is_wrapping_line (pp
))
997 pp_wrap_text (pp
, start
, end
);
999 pp_append_text (pp
, start
, end
);
1002 /* Append to the output area of PRETTY-PRINTER a string specified by its
1003 STARTing character and LENGTH. */
1005 pp_append_r (pretty_printer
*pp
, const char *start
, int length
)
1007 output_buffer_append_r (pp_buffer (pp
), start
, length
);
1010 /* Insert enough spaces into the output area of PRETTY-PRINTER to bring
1011 the column position to the current indentation level, assuming that a
1012 newline has just been written to the buffer. */
1014 pp_indent (pretty_printer
*pp
)
1016 int n
= pp_indentation (pp
);
1019 for (i
= 0; i
< n
; ++i
)
1023 /* The following format specifiers are recognized as being client independent:
1024 %d, %i: (signed) integer in base ten.
1025 %u: unsigned integer in base ten.
1026 %o: unsigned integer in base eight.
1027 %x: unsigned integer in base sixteen.
1028 %ld, %li, %lo, %lu, %lx: long versions of the above.
1029 %lld, %lli, %llo, %llu, %llx: long long versions.
1030 %wd, %wi, %wo, %wu, %wx: HOST_WIDE_INT versions.
1034 %p: pointer (printed in a host-dependent manner).
1035 %r: if pp_show_color(pp), switch to color identified by const char *.
1036 %R: if pp_show_color(pp), reset color.
1037 %m: strerror(text->err_no) - does not consume a value from args_ptr.
1041 %': apostrophe (should only be used in untranslated messages;
1042 translations should use appropriate punctuation directly).
1043 %@: diagnostic_event_id_ptr, for which event_id->known_p () must be true.
1044 %.*s: a substring the length of which is specified by an argument
1046 %Ns: likewise, but length specified as constant in the format string.
1047 Flag 'q': quote formatted text (must come immediately after '%').
1048 %Z: Requires two arguments - array of int, and len. Prints elements
1051 Arguments can be used sequentially, or through %N$ resp. *N$
1052 notation Nth argument after the format string. If %N$ / *N$
1053 notation is used, it must be used for all arguments, except %m, %%,
1054 %<, %> and %', which may not have a number, as they do not consume
1055 an argument. When %M$.*N$s is used, M must be N + 1. (This may
1056 also be written %M$.*s, provided N is not otherwise used.) The
1057 format string must have conversion specifiers with argument numbers
1058 1 up to highest argument; each argument may only be used once.
1059 A format string can have at most 30 arguments. */
1061 /* Formatting phases 1 and 2: render TEXT->format_spec plus
1062 TEXT->args_ptr into a series of chunks in pp_buffer (PP)->args[].
1063 Phase 3 is in pp_output_formatted_text. */
1066 pp_format (pretty_printer
*pp
, text_info
*text
)
1068 output_buffer
*buffer
= pp_buffer (pp
);
1071 struct chunk_info
*new_chunk_array
;
1073 unsigned int curarg
= 0, chunk
= 0, argno
;
1074 pp_wrapping_mode_t old_wrapping_mode
;
1075 bool any_unnumbered
= false, any_numbered
= false;
1076 const char **formatters
[PP_NL_ARGMAX
];
1078 /* Allocate a new chunk structure. */
1079 new_chunk_array
= XOBNEW (&buffer
->chunk_obstack
, struct chunk_info
);
1080 new_chunk_array
->prev
= buffer
->cur_chunk_array
;
1081 buffer
->cur_chunk_array
= new_chunk_array
;
1082 args
= new_chunk_array
->args
;
1084 /* Formatting phase 1: split up TEXT->format_spec into chunks in
1085 pp_buffer (PP)->args[]. Even-numbered chunks are to be output
1086 verbatim, odd-numbered chunks are format specifiers.
1087 %m, %%, %<, %>, and %' are replaced with the appropriate text at
1090 memset (formatters
, 0, sizeof formatters
);
1092 for (p
= text
->format_spec
; *p
; )
1094 while (*p
!= '\0' && *p
!= '%')
1096 obstack_1grow (&buffer
->chunk_obstack
, *p
);
1109 obstack_1grow (&buffer
->chunk_obstack
, '%');
1115 obstack_grow (&buffer
->chunk_obstack
,
1116 open_quote
, strlen (open_quote
));
1117 const char *colorstr
1118 = colorize_start (pp_show_color (pp
), "quote");
1119 obstack_grow (&buffer
->chunk_obstack
, colorstr
, strlen (colorstr
));
1126 const char *colorstr
= colorize_stop (pp_show_color (pp
));
1127 obstack_grow (&buffer
->chunk_obstack
, colorstr
, strlen (colorstr
));
1131 obstack_grow (&buffer
->chunk_obstack
,
1132 close_quote
, strlen (close_quote
));
1138 const char *colorstr
= colorize_stop (pp_show_color (pp
));
1139 obstack_grow (&buffer
->chunk_obstack
, colorstr
,
1147 const char *errstr
= xstrerror (text
->err_no
);
1148 obstack_grow (&buffer
->chunk_obstack
, errstr
, strlen (errstr
));
1154 /* Handled in phase 2. Terminate the plain chunk here. */
1155 obstack_1grow (&buffer
->chunk_obstack
, '\0');
1156 gcc_assert (chunk
< PP_NL_ARGMAX
* 2);
1157 args
[chunk
++] = XOBFINISH (&buffer
->chunk_obstack
, const char *);
1164 argno
= strtoul (p
, &end
, 10) - 1;
1166 gcc_assert (*p
== '$');
1169 any_numbered
= true;
1170 gcc_assert (!any_unnumbered
);
1175 any_unnumbered
= true;
1176 gcc_assert (!any_numbered
);
1178 gcc_assert (argno
< PP_NL_ARGMAX
);
1179 gcc_assert (!formatters
[argno
]);
1180 formatters
[argno
] = &args
[chunk
];
1183 obstack_1grow (&buffer
->chunk_obstack
, *p
);
1186 while (strchr ("qwl+#", p
[-1]));
1190 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
1191 (where M == N + 1). */
1196 obstack_1grow (&buffer
->chunk_obstack
, *p
);
1199 while (ISDIGIT (p
[-1]));
1200 gcc_assert (p
[-1] == 's');
1204 gcc_assert (*p
== '*');
1205 obstack_1grow (&buffer
->chunk_obstack
, '*');
1211 unsigned int argno2
= strtoul (p
, &end
, 10) - 1;
1213 gcc_assert (argno2
== argno
- 1);
1214 gcc_assert (!any_unnumbered
);
1215 gcc_assert (*p
== '$');
1218 formatters
[argno2
] = formatters
[argno
];
1222 gcc_assert (!any_numbered
);
1223 formatters
[argno
+1] = formatters
[argno
];
1226 gcc_assert (*p
== 's');
1227 obstack_1grow (&buffer
->chunk_obstack
, 's');
1234 obstack_1grow (&buffer
->chunk_obstack
, '\0');
1235 gcc_assert (chunk
< PP_NL_ARGMAX
* 2);
1236 args
[chunk
++] = XOBFINISH (&buffer
->chunk_obstack
, const char *);
1239 obstack_1grow (&buffer
->chunk_obstack
, '\0');
1240 gcc_assert (chunk
< PP_NL_ARGMAX
* 2);
1241 args
[chunk
++] = XOBFINISH (&buffer
->chunk_obstack
, const char *);
1244 /* Set output to the argument obstack, and switch line-wrapping and
1246 buffer
->obstack
= &buffer
->chunk_obstack
;
1247 const int old_line_length
= buffer
->line_length
;
1248 old_wrapping_mode
= pp_set_verbatim_wrapping (pp
);
1250 /* Second phase. Replace each formatter with the formatted text it
1253 for (argno
= 0; formatters
[argno
]; argno
++)
1261 /* We do not attempt to enforce any ordering on the modifier
1264 for (p
= *formatters
[argno
];; p
++)
1269 gcc_assert (!quote
);
1289 /* We don't support precision beyond that of "long long". */
1290 gcc_assert (precision
< 2);
1297 gcc_assert (!wide
|| precision
== 0);
1300 pp_begin_quote (pp
, pp_show_color (pp
));
1305 pp_string (pp
, colorize_start (pp_show_color (pp
),
1306 va_arg (*text
->args_ptr
,
1312 /* When quoting, print alphanumeric, punctuation, and the space
1313 character unchanged, and all others in hexadecimal with the
1314 "\x" prefix. Otherwise print them all unchanged. */
1315 int chr
= va_arg (*text
->args_ptr
, int);
1316 if (ISPRINT (chr
) || !quote
)
1317 pp_character (pp
, chr
);
1320 const char str
[2] = { chr
, '\0' };
1321 pp_quoted_string (pp
, str
, 1);
1329 pp_wide_integer (pp
, va_arg (*text
->args_ptr
, HOST_WIDE_INT
));
1331 pp_integer_with_precision
1332 (pp
, *text
->args_ptr
, precision
, int, "d");
1337 pp_scalar (pp
, "%" HOST_WIDE_INT_PRINT
"o",
1338 va_arg (*text
->args_ptr
, unsigned HOST_WIDE_INT
));
1340 pp_integer_with_precision
1341 (pp
, *text
->args_ptr
, precision
, unsigned, "o");
1346 pp_quoted_string (pp
, va_arg (*text
->args_ptr
, const char *));
1348 pp_string (pp
, va_arg (*text
->args_ptr
, const char *));
1352 pp_pointer (pp
, va_arg (*text
->args_ptr
, void *));
1357 pp_scalar (pp
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1358 va_arg (*text
->args_ptr
, unsigned HOST_WIDE_INT
));
1360 pp_integer_with_precision
1361 (pp
, *text
->args_ptr
, precision
, unsigned, "u");
1365 pp_double (pp
, va_arg (*text
->args_ptr
, double));
1370 int *v
= va_arg (*text
->args_ptr
, int *);
1371 unsigned len
= va_arg (*text
->args_ptr
, unsigned);
1373 for (unsigned i
= 0; i
< len
; ++i
)
1375 pp_scalar (pp
, "%i", v
[i
]);
1387 pp_scalar (pp
, HOST_WIDE_INT_PRINT_HEX
,
1388 va_arg (*text
->args_ptr
, unsigned HOST_WIDE_INT
));
1390 pp_integer_with_precision
1391 (pp
, *text
->args_ptr
, precision
, unsigned, "x");
1399 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
1400 (where M == N + 1). The format string should be verified
1401 already from the first phase. */
1406 n
= strtoul (p
, &end
, 10);
1408 gcc_assert (*p
== 's');
1412 gcc_assert (*p
== '*');
1414 gcc_assert (*p
== 's');
1415 n
= va_arg (*text
->args_ptr
, int);
1417 /* This consumes a second entry in the formatters array. */
1418 gcc_assert (formatters
[argno
] == formatters
[argno
+1]);
1422 s
= va_arg (*text
->args_ptr
, const char *);
1424 /* Append the lesser of precision and strlen (s) characters
1425 from the array (which need not be a nul-terminated string).
1426 Negative precision is treated as if it were omitted. */
1427 size_t len
= n
< 0 ? strlen (s
) : strnlen (s
, n
);
1429 pp_append_text (pp
, s
, s
+ len
);
1435 /* diagnostic_event_id_t *. */
1436 diagnostic_event_id_ptr event_id
1437 = va_arg (*text
->args_ptr
, diagnostic_event_id_ptr
);
1438 gcc_assert (event_id
->known_p ());
1440 pp_string (pp
, colorize_start (pp_show_color (pp
), "path"));
1441 pp_character (pp
, '(');
1442 pp_decimal_int (pp
, event_id
->one_based ());
1443 pp_character (pp
, ')');
1444 pp_string (pp
, colorize_stop (pp_show_color (pp
)));
1452 /* Call the format decoder.
1453 Pass the address of "quote" so that format decoders can
1454 potentially disable printing of the closing quote
1455 (e.g. when printing "'TYPEDEF' aka 'TYPE'" in the C family
1457 gcc_assert (pp_format_decoder (pp
));
1458 ok
= pp_format_decoder (pp
) (pp
, text
, p
,
1459 precision
, wide
, plus
, hash
, "e
,
1466 pp_end_quote (pp
, pp_show_color (pp
));
1468 obstack_1grow (&buffer
->chunk_obstack
, '\0');
1469 *formatters
[argno
] = XOBFINISH (&buffer
->chunk_obstack
, const char *);
1473 for (; argno
< PP_NL_ARGMAX
; argno
++)
1474 gcc_assert (!formatters
[argno
]);
1476 /* If the client supplied a postprocessing object, call its "handle"
1478 if (pp
->m_format_postprocessor
)
1479 pp
->m_format_postprocessor
->handle (pp
);
1481 /* Revert to normal obstack and wrapping mode. */
1482 buffer
->obstack
= &buffer
->formatted_obstack
;
1483 buffer
->line_length
= old_line_length
;
1484 pp_wrapping_mode (pp
) = old_wrapping_mode
;
1485 pp_clear_state (pp
);
1488 /* Format of a message pointed to by TEXT. */
1490 pp_output_formatted_text (pretty_printer
*pp
)
1493 output_buffer
*buffer
= pp_buffer (pp
);
1494 struct chunk_info
*chunk_array
= buffer
->cur_chunk_array
;
1495 const char **args
= chunk_array
->args
;
1497 gcc_assert (buffer
->obstack
== &buffer
->formatted_obstack
);
1499 /* This is a third phase, first 2 phases done in pp_format_args.
1500 Now we actually print it. */
1501 for (chunk
= 0; args
[chunk
]; chunk
++)
1502 pp_string (pp
, args
[chunk
]);
1504 /* Deallocate the chunk structure and everything after it (i.e. the
1505 associated series of formatted strings). */
1506 buffer
->cur_chunk_array
= chunk_array
->prev
;
1507 obstack_free (&buffer
->chunk_obstack
, chunk_array
);
1510 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
1511 settings needed by BUFFER for a verbatim formatting. */
1513 pp_format_verbatim (pretty_printer
*pp
, text_info
*text
)
1515 /* Set verbatim mode. */
1516 pp_wrapping_mode_t oldmode
= pp_set_verbatim_wrapping (pp
);
1518 /* Do the actual formatting. */
1519 pp_format (pp
, text
);
1520 pp_output_formatted_text (pp
);
1522 /* Restore previous settings. */
1523 pp_wrapping_mode (pp
) = oldmode
;
1526 /* Flush the content of BUFFER onto the attached stream. This
1527 function does nothing unless pp->output_buffer->flush_p. */
1529 pp_flush (pretty_printer
*pp
)
1531 pp_clear_state (pp
);
1532 if (!pp
->buffer
->flush_p
)
1534 pp_write_text_to_stream (pp
);
1535 fflush (pp_buffer (pp
)->stream
);
1538 /* Flush the content of BUFFER onto the attached stream independently
1539 of the value of pp->output_buffer->flush_p. */
1541 pp_really_flush (pretty_printer
*pp
)
1543 pp_clear_state (pp
);
1544 pp_write_text_to_stream (pp
);
1545 fflush (pp_buffer (pp
)->stream
);
1548 /* Sets the number of maximum characters per line PRETTY-PRINTER can
1549 output in line-wrapping mode. A LENGTH value 0 suppresses
1552 pp_set_line_maximum_length (pretty_printer
*pp
, int length
)
1554 pp_line_cutoff (pp
) = length
;
1555 pp_set_real_maximum_length (pp
);
1558 /* Clear PRETTY-PRINTER output area text info. */
1560 pp_clear_output_area (pretty_printer
*pp
)
1562 obstack_free (pp_buffer (pp
)->obstack
,
1563 obstack_base (pp_buffer (pp
)->obstack
));
1564 pp_buffer (pp
)->line_length
= 0;
1567 /* Set PREFIX for PRETTY-PRINTER, taking ownership of PREFIX, which
1568 will eventually be free-ed. */
1571 pp_set_prefix (pretty_printer
*pp
, char *prefix
)
1574 pp
->prefix
= prefix
;
1575 pp_set_real_maximum_length (pp
);
1576 pp
->emitted_prefix
= false;
1577 pp_indentation (pp
) = 0;
1580 /* Take ownership of PP's prefix, setting it to NULL.
1581 This allows clients to save, overide, and then restore an existing
1582 prefix, without it being free-ed. */
1585 pp_take_prefix (pretty_printer
*pp
)
1587 char *result
= pp
->prefix
;
1592 /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string. */
1594 pp_destroy_prefix (pretty_printer
*pp
)
1596 if (pp
->prefix
!= NULL
)
1603 /* Write out PRETTY-PRINTER's prefix. */
1605 pp_emit_prefix (pretty_printer
*pp
)
1607 if (pp
->prefix
!= NULL
)
1609 switch (pp_prefixing_rule (pp
))
1612 case DIAGNOSTICS_SHOW_PREFIX_NEVER
:
1615 case DIAGNOSTICS_SHOW_PREFIX_ONCE
:
1616 if (pp
->emitted_prefix
)
1621 pp_indentation (pp
) += 3;
1624 case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
:
1626 int prefix_length
= strlen (pp
->prefix
);
1627 pp_append_r (pp
, pp
->prefix
, prefix_length
);
1628 pp
->emitted_prefix
= true;
1635 /* Construct a PRETTY-PRINTER of MAXIMUM_LENGTH characters per line. */
1637 pretty_printer::pretty_printer (int maximum_length
)
1638 : buffer (new (XCNEW (output_buffer
)) output_buffer ()),
1645 m_format_postprocessor (NULL
),
1648 translate_identifiers (true),
1652 pp_line_cutoff (this) = maximum_length
;
1653 /* By default, we emit prefixes once per message. */
1654 pp_prefixing_rule (this) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
1655 pp_set_prefix (this, NULL
);
1658 /* Copy constructor for pretty_printer. */
1660 pretty_printer::pretty_printer (const pretty_printer
&other
)
1661 : buffer (new (XCNEW (output_buffer
)) output_buffer ()),
1663 padding (other
.padding
),
1664 maximum_length (other
.maximum_length
),
1665 indent_skip (other
.indent_skip
),
1666 wrapping (other
.wrapping
),
1667 format_decoder (other
.format_decoder
),
1668 m_format_postprocessor (NULL
),
1669 emitted_prefix (other
.emitted_prefix
),
1670 need_newline (other
.need_newline
),
1671 translate_identifiers (other
.translate_identifiers
),
1672 show_color (other
.show_color
),
1673 show_urls (other
.show_urls
)
1675 pp_line_cutoff (this) = maximum_length
;
1676 /* By default, we emit prefixes once per message. */
1677 pp_prefixing_rule (this) = pp_prefixing_rule (&other
);
1678 pp_set_prefix (this, NULL
);
1680 if (other
.m_format_postprocessor
)
1681 m_format_postprocessor
= other
.m_format_postprocessor
->clone ();
1684 pretty_printer::~pretty_printer ()
1686 if (m_format_postprocessor
)
1687 delete m_format_postprocessor
;
1688 buffer
->~output_buffer ();
1693 /* Base class implementation of pretty_printer::clone vfunc. */
1696 pretty_printer::clone () const
1698 return new pretty_printer (*this);
1701 /* Append a string delimited by START and END to the output area of
1702 PRETTY-PRINTER. No line wrapping is done. However, if beginning a
1703 new line then emit PRETTY-PRINTER's prefix and skip any leading
1704 whitespace if appropriate. The caller must ensure that it is
1707 pp_append_text (pretty_printer
*pp
, const char *start
, const char *end
)
1709 /* Emit prefix and skip whitespace if we're starting a new line. */
1710 if (pp_buffer (pp
)->line_length
== 0)
1712 pp_emit_prefix (pp
);
1713 if (pp_is_wrapping_line (pp
))
1714 while (start
!= end
&& *start
== ' ')
1717 pp_append_r (pp
, start
, end
- start
);
1720 /* Finishes constructing a NULL-terminated character string representing
1721 the PRETTY-PRINTED text. */
1723 pp_formatted_text (pretty_printer
*pp
)
1725 return output_buffer_formatted_text (pp_buffer (pp
));
1728 /* Return a pointer to the last character emitted in PRETTY-PRINTER's
1729 output area. A NULL pointer means no character available. */
1731 pp_last_position_in_text (const pretty_printer
*pp
)
1733 return output_buffer_last_position_in_text (pp_buffer (pp
));
1736 /* Return the amount of characters PRETTY-PRINTER can accept to
1737 make a full line. Meaningful only in line-wrapping mode. */
1739 pp_remaining_character_count_for_line (pretty_printer
*pp
)
1741 return pp
->maximum_length
- pp_buffer (pp
)->line_length
;
1745 /* Format a message into BUFFER a la printf. */
1747 pp_printf (pretty_printer
*pp
, const char *msg
, ...)
1753 text
.err_no
= errno
;
1754 text
.args_ptr
= &ap
;
1755 text
.format_spec
= msg
;
1756 pp_format (pp
, &text
);
1757 pp_output_formatted_text (pp
);
1762 /* Output MESSAGE verbatim into BUFFER. */
1764 pp_verbatim (pretty_printer
*pp
, const char *msg
, ...)
1770 text
.err_no
= errno
;
1771 text
.args_ptr
= &ap
;
1772 text
.format_spec
= msg
;
1773 pp_format_verbatim (pp
, &text
);
1779 /* Have PRETTY-PRINTER start a new line. */
1781 pp_newline (pretty_printer
*pp
)
1783 obstack_1grow (pp_buffer (pp
)->obstack
, '\n');
1784 pp_needs_newline (pp
) = false;
1785 pp_buffer (pp
)->line_length
= 0;
1788 /* Have PRETTY-PRINTER add a CHARACTER. */
1790 pp_character (pretty_printer
*pp
, int c
)
1792 if (pp_is_wrapping_line (pp
)
1793 /* If printing UTF-8, don't wrap in the middle of a sequence. */
1794 && (((unsigned int) c
) & 0xC0) != 0x80
1795 && pp_remaining_character_count_for_line (pp
) <= 0)
1801 obstack_1grow (pp_buffer (pp
)->obstack
, c
);
1802 ++pp_buffer (pp
)->line_length
;
1805 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
1806 be line-wrapped if in appropriate mode. */
1808 pp_string (pretty_printer
*pp
, const char *str
)
1810 gcc_checking_assert (str
);
1811 pp_maybe_wrap_text (pp
, str
, str
+ strlen (str
));
1814 /* Append the leading N characters of STRING to the output area of
1815 PRETTY-PRINTER, quoting in hexadecimal non-printable characters.
1816 Setting N = -1 is as if N were set to strlen (STRING). The STRING
1817 may be line-wrapped if in appropriate mode. */
1819 pp_quoted_string (pretty_printer
*pp
, const char *str
, size_t n
/* = -1 */)
1821 gcc_checking_assert (str
);
1823 const char *last
= str
;
1826 /* Compute the length if not specified. */
1827 if (n
== (size_t) -1)
1830 for (ps
= str
; n
; ++ps
, --n
)
1835 /* Don't escape a valid UTF-8 extended char. */
1836 const unsigned char *ups
= (const unsigned char *) ps
;
1839 unsigned int extended_char
;
1840 const int valid_utf8_len
= decode_utf8_char (ups
, n
, &extended_char
);
1841 if (valid_utf8_len
> 0)
1843 ps
+= valid_utf8_len
- 1;
1844 n
-= valid_utf8_len
- 1;
1850 pp_maybe_wrap_text (pp
, last
, ps
);
1852 /* Append the hexadecimal value of the character. Allocate a buffer
1853 that's large enough for a 32-bit char plus the hex prefix. */
1855 int n
= sprintf (buf
, "\\x%02x", (unsigned char)*ps
);
1856 pp_maybe_wrap_text (pp
, buf
, buf
+ n
);
1860 pp_maybe_wrap_text (pp
, last
, ps
);
1863 /* Maybe print out a whitespace if needed. */
1866 pp_maybe_space (pretty_printer
*pp
)
1868 if (pp
->padding
!= pp_none
)
1871 pp
->padding
= pp_none
;
1875 // Add a newline to the pretty printer PP and flush formatted text.
1878 pp_newline_and_flush (pretty_printer
*pp
)
1882 pp_needs_newline (pp
) = false;
1885 // Add a newline to the pretty printer PP, followed by indentation.
1888 pp_newline_and_indent (pretty_printer
*pp
, int n
)
1890 pp_indentation (pp
) += n
;
1893 pp_needs_newline (pp
) = false;
1896 // Add separator C, followed by a single whitespace.
1899 pp_separate_with (pretty_printer
*pp
, char c
)
1901 pp_character (pp
, c
);
1905 /* Add a localized open quote, and if SHOW_COLOR is true, begin colorizing
1906 using the "quote" color. */
1909 pp_begin_quote (pretty_printer
*pp
, bool show_color
)
1911 pp_string (pp
, open_quote
);
1912 pp_string (pp
, colorize_start (show_color
, "quote"));
1915 /* If SHOW_COLOR is true, stop colorizing.
1916 Add a localized close quote. */
1919 pp_end_quote (pretty_printer
*pp
, bool show_color
)
1921 pp_string (pp
, colorize_stop (show_color
));
1922 pp_string (pp
, close_quote
);
1926 /* The string starting at P has LEN (at least 1) bytes left; if they
1927 start with a valid UTF-8 sequence, return the length of that
1928 sequence and set *VALUE to the value of that sequence, and
1929 otherwise return 0 and set *VALUE to (unsigned int) -1. */
1932 decode_utf8_char (const unsigned char *p
, size_t len
, unsigned int *value
)
1934 unsigned int t
= *p
;
1940 size_t utf8_len
= 0;
1943 for (t
= *p
; t
& 0x80; t
<<= 1)
1946 if (utf8_len
> len
|| utf8_len
< 2 || utf8_len
> 6)
1948 *value
= (unsigned int) -1;
1951 ch
= *p
& ((1 << (7 - utf8_len
)) - 1);
1952 for (i
= 1; i
< utf8_len
; i
++)
1954 unsigned int u
= p
[i
];
1955 if ((u
& 0xC0) != 0x80)
1957 *value
= (unsigned int) -1;
1960 ch
= (ch
<< 6) | (u
& 0x3F);
1962 if ( (ch
<= 0x7F && utf8_len
> 1)
1963 || (ch
<= 0x7FF && utf8_len
> 2)
1964 || (ch
<= 0xFFFF && utf8_len
> 3)
1965 || (ch
<= 0x1FFFFF && utf8_len
> 4)
1966 || (ch
<= 0x3FFFFFF && utf8_len
> 5)
1967 || (ch
>= 0xD800 && ch
<= 0xDFFF))
1969 *value
= (unsigned int) -1;
1982 /* Allocator for identifier_to_locale and corresponding function to
1985 void *(*identifier_to_locale_alloc
) (size_t) = xmalloc
;
1986 void (*identifier_to_locale_free
) (void *) = free
;
1988 /* Given IDENT, an identifier in the internal encoding, return a
1989 version of IDENT suitable for diagnostics in the locale character
1990 set: either IDENT itself, or a string, allocated using
1991 identifier_to_locale_alloc, converted to the locale character set
1992 and using escape sequences if not representable in the locale
1993 character set or containing control characters or invalid byte
1994 sequences. Existing backslashes in IDENT are not doubled, so the
1995 result may not uniquely specify the contents of an arbitrary byte
1996 sequence identifier. */
1999 identifier_to_locale (const char *ident
)
2001 const unsigned char *uid
= (const unsigned char *) ident
;
2002 size_t idlen
= strlen (ident
);
2003 bool valid_printable_utf8
= true;
2004 bool all_ascii
= true;
2007 for (i
= 0; i
< idlen
;)
2010 size_t utf8_len
= decode_utf8_char (&uid
[i
], idlen
- i
, &c
);
2011 if (utf8_len
== 0 || c
<= 0x1F || (c
>= 0x7F && c
<= 0x9F))
2013 valid_printable_utf8
= false;
2021 /* If IDENT contains invalid UTF-8 sequences (which may occur with
2022 attributes putting arbitrary byte sequences in identifiers), or
2023 control characters, we use octal escape sequences for all bytes
2024 outside printable ASCII. */
2025 if (!valid_printable_utf8
)
2027 char *ret
= (char *) identifier_to_locale_alloc (4 * idlen
+ 1);
2029 for (i
= 0; i
< idlen
; i
++)
2031 if (uid
[i
] > 0x1F && uid
[i
] < 0x7F)
2035 sprintf (p
, "\\%03o", uid
[i
]);
2043 /* Otherwise, if it is valid printable ASCII, or printable UTF-8
2044 with the locale character set being UTF-8, IDENT is used. */
2045 if (all_ascii
|| locale_utf8
)
2048 /* Otherwise IDENT is converted to the locale character set if
2050 #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
2051 if (locale_encoding
!= NULL
)
2053 iconv_t cd
= iconv_open (locale_encoding
, "UTF-8");
2054 bool conversion_ok
= true;
2056 if (cd
!= (iconv_t
) -1)
2058 size_t ret_alloc
= 4 * idlen
+ 1;
2061 /* Repeat the whole conversion process as needed with
2062 larger buffers so non-reversible transformations can
2063 always be detected. */
2064 ICONV_CONST
char *inbuf
= CONST_CAST (char *, ident
);
2066 size_t inbytesleft
= idlen
;
2067 size_t outbytesleft
= ret_alloc
- 1;
2070 ret
= (char *) identifier_to_locale_alloc (ret_alloc
);
2073 if (iconv (cd
, 0, 0, 0, 0) == (size_t) -1)
2075 conversion_ok
= false;
2079 iconv_ret
= iconv (cd
, &inbuf
, &inbytesleft
,
2080 &outbuf
, &outbytesleft
);
2081 if (iconv_ret
== (size_t) -1 || inbytesleft
!= 0)
2086 identifier_to_locale_free (ret
);
2092 conversion_ok
= false;
2096 else if (iconv_ret
!= 0)
2098 conversion_ok
= false;
2101 /* Return to initial shift state. */
2102 if (iconv (cd
, 0, 0, &outbuf
, &outbytesleft
) == (size_t) -1)
2107 identifier_to_locale_free (ret
);
2113 conversion_ok
= false;
2127 /* Otherwise, convert non-ASCII characters in IDENT to UCNs. */
2129 char *ret
= (char *) identifier_to_locale_alloc (10 * idlen
+ 1);
2131 for (i
= 0; i
< idlen
;)
2134 size_t utf8_len
= decode_utf8_char (&uid
[i
], idlen
- i
, &c
);
2139 sprintf (p
, "\\U%08x", c
);
2149 /* Support for encoding URLs.
2150 See egmontkob/Hyperlinks_in_Terminal_Emulators.md
2151 ( https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda ).
2153 > A hyperlink is opened upon encountering an OSC 8 escape sequence with
2154 > the target URI. The syntax is
2156 > OSC 8 ; params ; URI ST
2158 > A hyperlink is closed with the same escape sequence, omitting the
2159 > parameters and the URI but keeping the separators:
2163 > OSC (operating system command) is typically ESC ].
2165 Use BEL instead of ST, as that is currently rendered better in some
2166 terminal emulators that don't support OSC 8, like konsole. */
2168 /* If URL-printing is enabled, write an "open URL" escape sequence to PP
2169 for the given URL. */
2172 pp_begin_url (pretty_printer
*pp
, const char *url
)
2175 pp_printf (pp
, "\33]8;;%s\a", url
);
2178 /* If URL-printing is enabled, write a "close URL" escape sequence to PP. */
2181 pp_end_url (pretty_printer
*pp
)
2184 pp_string (pp
, "\33]8;;\a");
2189 namespace selftest
{
2191 /* Smoketest for pretty_printer. */
2194 test_basic_printing ()
2197 pp_string (&pp
, "hello");
2199 pp_string (&pp
, "world");
2201 ASSERT_STREQ ("hello world", pp_formatted_text (&pp
));
2204 /* Helper function for testing pp_format.
2205 Verify that pp_format (FMT, ...) followed by pp_output_formatted_text
2206 prints EXPECTED, assuming that pp_show_color is SHOW_COLOR. */
2209 assert_pp_format_va (const location
&loc
, const char *expected
,
2210 bool show_color
, const char *fmt
, va_list *ap
)
2214 rich_location
rich_loc (line_table
, UNKNOWN_LOCATION
);
2216 ti
.format_spec
= fmt
;
2220 ti
.m_richloc
= &rich_loc
;
2222 pp_show_color (&pp
) = show_color
;
2223 pp_format (&pp
, &ti
);
2224 pp_output_formatted_text (&pp
);
2225 ASSERT_STREQ_AT (loc
, expected
, pp_formatted_text (&pp
));
2228 /* Verify that pp_format (FMT, ...) followed by pp_output_formatted_text
2229 prints EXPECTED, with show_color disabled. */
2232 assert_pp_format (const location
&loc
, const char *expected
,
2233 const char *fmt
, ...)
2238 assert_pp_format_va (loc
, expected
, false, fmt
, &ap
);
2242 /* As above, but with colorization enabled. */
2245 assert_pp_format_colored (const location
&loc
, const char *expected
,
2246 const char *fmt
, ...)
2248 /* The tests of colorization assume the default color scheme.
2249 If GCC_COLORS is set, then the colors have potentially been
2250 overridden; skip the test. */
2251 if (getenv ("GCC_COLORS"))
2257 assert_pp_format_va (loc
, expected
, true, fmt
, &ap
);
2261 /* Helper function for calling testing pp_format,
2262 by calling assert_pp_format with various numbers of arguments.
2263 These exist mostly to avoid having to write SELFTEST_LOCATION
2264 throughout test_pp_format. */
2266 #define ASSERT_PP_FORMAT_1(EXPECTED, FMT, ARG1) \
2267 SELFTEST_BEGIN_STMT \
2268 assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
2272 #define ASSERT_PP_FORMAT_2(EXPECTED, FMT, ARG1, ARG2) \
2273 SELFTEST_BEGIN_STMT \
2274 assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
2278 #define ASSERT_PP_FORMAT_3(EXPECTED, FMT, ARG1, ARG2, ARG3) \
2279 SELFTEST_BEGIN_STMT \
2280 assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
2281 (ARG1), (ARG2), (ARG3)); \
2284 /* Verify that pp_format works, for various format codes. */
2289 /* Avoid introducing locale-specific differences in the results
2290 by hardcoding open_quote and close_quote. */
2291 auto_fix_quotes fix_quotes
;
2293 /* Verify that plain text is passed through unchanged. */
2294 assert_pp_format (SELFTEST_LOCATION
, "unformatted", "unformatted");
2296 /* Verify various individual format codes, in the order listed in the
2297 comment for pp_format above. For each code, we append a second
2298 argument with a known bit pattern (0x12345678), to ensure that we
2299 are consuming arguments correctly. */
2300 ASSERT_PP_FORMAT_2 ("-27 12345678", "%d %x", -27, 0x12345678);
2301 ASSERT_PP_FORMAT_2 ("-5 12345678", "%i %x", -5, 0x12345678);
2302 ASSERT_PP_FORMAT_2 ("10 12345678", "%u %x", 10, 0x12345678);
2303 ASSERT_PP_FORMAT_2 ("17 12345678", "%o %x", 15, 0x12345678);
2304 ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%x %x", 0xcafebabe, 0x12345678);
2305 ASSERT_PP_FORMAT_2 ("-27 12345678", "%ld %x", (long)-27, 0x12345678);
2306 ASSERT_PP_FORMAT_2 ("-5 12345678", "%li %x", (long)-5, 0x12345678);
2307 ASSERT_PP_FORMAT_2 ("10 12345678", "%lu %x", (long)10, 0x12345678);
2308 ASSERT_PP_FORMAT_2 ("17 12345678", "%lo %x", (long)15, 0x12345678);
2309 ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%lx %x", (long)0xcafebabe,
2311 ASSERT_PP_FORMAT_2 ("-27 12345678", "%lld %x", (long long)-27, 0x12345678);
2312 ASSERT_PP_FORMAT_2 ("-5 12345678", "%lli %x", (long long)-5, 0x12345678);
2313 ASSERT_PP_FORMAT_2 ("10 12345678", "%llu %x", (long long)10, 0x12345678);
2314 ASSERT_PP_FORMAT_2 ("17 12345678", "%llo %x", (long long)15, 0x12345678);
2315 ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%llx %x", (long long)0xcafebabe,
2317 ASSERT_PP_FORMAT_2 ("-27 12345678", "%wd %x", (HOST_WIDE_INT
)-27, 0x12345678);
2318 ASSERT_PP_FORMAT_2 ("-5 12345678", "%wi %x", (HOST_WIDE_INT
)-5, 0x12345678);
2319 ASSERT_PP_FORMAT_2 ("10 12345678", "%wu %x", (unsigned HOST_WIDE_INT
)10,
2321 ASSERT_PP_FORMAT_2 ("17 12345678", "%wo %x", (HOST_WIDE_INT
)15, 0x12345678);
2322 ASSERT_PP_FORMAT_2 ("0xcafebabe 12345678", "%wx %x", (HOST_WIDE_INT
)0xcafebabe,
2324 ASSERT_PP_FORMAT_2 ("1.000000 12345678", "%f %x", 1.0, 0x12345678);
2325 ASSERT_PP_FORMAT_2 ("A 12345678", "%c %x", 'A', 0x12345678);
2326 ASSERT_PP_FORMAT_2 ("hello world 12345678", "%s %x", "hello world",
2329 /* Not nul-terminated. */
2330 char arr
[5] = { '1', '2', '3', '4', '5' };
2331 ASSERT_PP_FORMAT_3 ("123 12345678", "%.*s %x", 3, arr
, 0x12345678);
2332 ASSERT_PP_FORMAT_3 ("1234 12345678", "%.*s %x", -1, "1234", 0x12345678);
2333 ASSERT_PP_FORMAT_3 ("12345 12345678", "%.*s %x", 7, "12345", 0x12345678);
2335 /* We can't test for %p; the pointer is printed in an implementation-defined
2337 ASSERT_PP_FORMAT_2 ("normal colored normal 12345678",
2338 "normal %rcolored%R normal %x",
2339 "error", 0x12345678);
2340 assert_pp_format_colored
2342 "normal \33[01;31m\33[Kcolored\33[m\33[K normal 12345678",
2343 "normal %rcolored%R normal %x", "error", 0x12345678);
2345 %m: strerror(text->err_no) - does not consume a value from args_ptr. */
2346 ASSERT_PP_FORMAT_1 ("% 12345678", "%% %x", 0x12345678);
2347 ASSERT_PP_FORMAT_1 ("` 12345678", "%< %x", 0x12345678);
2348 ASSERT_PP_FORMAT_1 ("' 12345678", "%> %x", 0x12345678);
2349 ASSERT_PP_FORMAT_1 ("' 12345678", "%' %x", 0x12345678);
2350 ASSERT_PP_FORMAT_3 ("abc 12345678", "%.*s %x", 3, "abcdef", 0x12345678);
2351 ASSERT_PP_FORMAT_2 ("abc 12345678", "%.3s %x", "abcdef", 0x12345678);
2353 /* Verify flag 'q'. */
2354 ASSERT_PP_FORMAT_2 ("`foo' 12345678", "%qs %x", "foo", 0x12345678);
2355 assert_pp_format_colored (SELFTEST_LOCATION
,
2356 "`\33[01m\33[Kfoo\33[m\33[K' 12345678", "%qs %x",
2360 diagnostic_event_id_t
first (2);
2361 diagnostic_event_id_t
second (7);
2363 ASSERT_PP_FORMAT_2 ("first `free' at (3); second `free' at (8)",
2364 "first %<free%> at %@; second %<free%> at %@",
2366 assert_pp_format_colored
2368 "first `\e[01m\e[Kfree\e[m\e[K' at \e[01;36m\e[K(3)\e[m\e[K;"
2369 " second `\e[01m\e[Kfree\e[m\e[K' at \e[01;36m\e[K(8)\e[m\e[K",
2370 "first %<free%> at %@; second %<free%> at %@",
2375 int v
[] = { 1, 2, 3 };
2376 ASSERT_PP_FORMAT_3 ("1, 2, 3 12345678", "%Z %x", v
, 3, 0x12345678);
2379 ASSERT_PP_FORMAT_3 ("0 12345678", "%Z %x", v2
, 1, 0x12345678);
2381 /* Verify that combinations work, along with unformatted text. */
2382 assert_pp_format (SELFTEST_LOCATION
,
2383 "the quick brown fox jumps over the lazy dog",
2384 "the %s %s %s jumps over the %s %s",
2385 "quick", "brown", "fox", "lazy", "dog");
2386 assert_pp_format (SELFTEST_LOCATION
, "item 3 of 7", "item %i of %i", 3, 7);
2387 assert_pp_format (SELFTEST_LOCATION
, "problem with `bar' at line 10",
2388 "problem with %qs at line %i", "bar", 10);
2391 /* A subclass of pretty_printer for use by test_prefixes_and_wrapping. */
2393 class test_pretty_printer
: public pretty_printer
2396 test_pretty_printer (enum diagnostic_prefixing_rule_t rule
,
2397 int max_line_length
)
2399 pp_set_prefix (this, xstrdup ("PREFIX: "));
2400 wrapping
.rule
= rule
;
2401 pp_set_line_maximum_length (this, max_line_length
);
2405 /* Verify that the various values of enum diagnostic_prefixing_rule_t work
2406 as expected, with and without line wrapping. */
2409 test_prefixes_and_wrapping ()
2411 /* Tests of the various prefixing rules, without wrapping.
2412 Newlines embedded in pp_string don't affect it; we have to
2413 explicitly call pp_newline. */
2415 test_pretty_printer
pp (DIAGNOSTICS_SHOW_PREFIX_ONCE
, 0);
2416 pp_string (&pp
, "the quick brown fox");
2418 pp_string (&pp
, "jumps over the lazy dog");
2420 ASSERT_STREQ (pp_formatted_text (&pp
),
2421 "PREFIX: the quick brown fox\n"
2422 " jumps over the lazy dog\n");
2425 test_pretty_printer
pp (DIAGNOSTICS_SHOW_PREFIX_NEVER
, 0);
2426 pp_string (&pp
, "the quick brown fox");
2428 pp_string (&pp
, "jumps over the lazy dog");
2430 ASSERT_STREQ (pp_formatted_text (&pp
),
2431 "the quick brown fox\n"
2432 "jumps over the lazy dog\n");
2435 test_pretty_printer
pp (DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
, 0);
2436 pp_string (&pp
, "the quick brown fox");
2438 pp_string (&pp
, "jumps over the lazy dog");
2440 ASSERT_STREQ (pp_formatted_text (&pp
),
2441 "PREFIX: the quick brown fox\n"
2442 "PREFIX: jumps over the lazy dog\n");
2445 /* Tests of the various prefixing rules, with wrapping. */
2447 test_pretty_printer
pp (DIAGNOSTICS_SHOW_PREFIX_ONCE
, 20);
2448 pp_string (&pp
, "the quick brown fox jumps over the lazy dog");
2450 pp_string (&pp
, "able was I ere I saw elba");
2452 ASSERT_STREQ (pp_formatted_text (&pp
),
2453 "PREFIX: the quick \n"
2454 " brown fox jumps \n"
2457 " able was I ere I \n"
2461 test_pretty_printer
pp (DIAGNOSTICS_SHOW_PREFIX_NEVER
, 20);
2462 pp_string (&pp
, "the quick brown fox jumps over the lazy dog");
2464 pp_string (&pp
, "able was I ere I saw elba");
2466 ASSERT_STREQ (pp_formatted_text (&pp
),
2467 "the quick brown fox \n"
2468 "jumps over the lazy \n"
2470 "able was I ere I \n"
2474 test_pretty_printer
pp (DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
, 20);
2475 pp_string (&pp
, "the quick brown fox jumps over the lazy dog");
2477 pp_string (&pp
, "able was I ere I saw elba");
2479 ASSERT_STREQ (pp_formatted_text (&pp
),
2480 "PREFIX: the quick brown fox jumps over the lazy dog\n"
2481 "PREFIX: able was I ere I saw elba\n");
2486 /* Verify that URL-printing works as expected. */
2493 pp
.show_urls
= false;
2494 pp_begin_url (&pp
, "http://example.com");
2495 pp_string (&pp
, "This is a link");
2497 ASSERT_STREQ ("This is a link",
2498 pp_formatted_text (&pp
));
2503 pp
.show_urls
= true;
2504 pp_begin_url (&pp
, "http://example.com");
2505 pp_string (&pp
, "This is a link");
2507 ASSERT_STREQ ("\33]8;;http://example.com\aThis is a link\33]8;;\a",
2508 pp_formatted_text (&pp
));
2512 /* Test multibyte awareness. */
2513 static void test_utf8 ()
2516 /* Check that pp_quoted_string leaves valid UTF-8 alone. */
2519 const char *s
= "\xf0\x9f\x98\x82";
2520 pp_quoted_string (&pp
, s
);
2521 ASSERT_STREQ (pp_formatted_text (&pp
), s
);
2524 /* Check that pp_quoted_string escapes non-UTF-8 nonprintable bytes. */
2527 pp_quoted_string (&pp
, "\xf0!\x9f\x98\x82");
2528 ASSERT_STREQ (pp_formatted_text (&pp
),
2529 "\\xf0!\\x9f\\x98\\x82");
2532 /* Check that pp_character will line-wrap at the beginning of a UTF-8
2533 sequence, but not in the middle. */
2535 pretty_printer
pp (3);
2536 const char s
[] = "---\xf0\x9f\x98\x82";
2537 for (int i
= 0; i
!= sizeof (s
) - 1; ++i
)
2538 pp_character (&pp
, s
[i
]);
2540 for (int i
= 1; i
!= sizeof (s
) - 1; ++i
)
2541 pp_character (&pp
, s
[i
]);
2542 pp_character (&pp
, '-');
2543 ASSERT_STREQ (pp_formatted_text (&pp
),
2545 "\xf0\x9f\x98\x82\n"
2546 "--\xf0\x9f\x98\x82\n"
2552 /* Run all of the selftests within this file. */
2555 pretty_print_c_tests ()
2557 test_basic_printing ();
2559 test_prefixes_and_wrapping ();
2564 } // namespace selftest
2566 #endif /* CHECKING_P */