1 /* Various declarations for language-independent pretty-print subroutines.
2 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
26 #include "pretty-print.h"
32 /* A pointer to the formatted diagnostic message. */
33 #define pp_formatted_text_data(PP) \
34 ((const char *) obstack_base (pp_base (PP)->buffer->obstack))
36 /* Format an integer given by va_arg (ARG, type-specifier T) where
37 type-specifier is a precision modifier as indicated by PREC. F is
38 a string used to construct the appropriate format-specifier. */
39 #define pp_integer_with_precision(PP, ARG, PREC, T, F) \
44 pp_scalar (PP, "%" F, va_arg (ARG, T)); \
48 pp_scalar (PP, "%l" F, va_arg (ARG, long T)); \
52 pp_scalar (PP, "%" HOST_LONG_LONG_FORMAT F, va_arg (ARG, long long T)); \
61 /* Subroutine of pp_set_maximum_length. Set up PRETTY-PRINTER's
62 internal maximum characters per line. */
64 pp_set_real_maximum_length (pretty_printer *pp)
66 /* If we're told not to wrap lines then do the obvious thing. In case
67 we'll emit prefix only once per message, it is appropriate
68 not to increase unnecessarily the line-length cut-off. */
69 if (!pp_is_wrapping_line (pp)
70 || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_ONCE
71 || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
72 pp->maximum_length = pp_line_cutoff (pp);
75 int prefix_length = pp->prefix ? strlen (pp->prefix) : 0;
76 /* If the prefix is ridiculously too long, output at least
78 if (pp_line_cutoff (pp) - prefix_length < 32)
79 pp->maximum_length = pp_line_cutoff (pp) + 32;
81 pp->maximum_length = pp_line_cutoff (pp);
85 /* Clear PRETTY-PRINTER's output state. */
87 pp_clear_state (pretty_printer *pp)
89 pp->emitted_prefix = false;
90 pp_indentation (pp) = 0;
93 /* Flush the formatted text of PRETTY-PRINTER onto the attached stream. */
95 pp_write_text_to_stream (pretty_printer *pp)
97 const char *text = pp_formatted_text (pp);
98 fputs (text, pp->buffer->stream);
99 pp_clear_output_area (pp);
102 /* Wrap a text delimited by START and END into PRETTY-PRINTER. */
104 pp_wrap_text (pretty_printer *pp, const char *start, const char *end)
106 bool wrapping_line = pp_is_wrapping_line (pp);
110 /* Dump anything bordered by whitespaces. */
112 const char *p = start;
113 while (p != end && !ISBLANK (*p) && *p != '\n')
116 && p - start >= pp_remaining_character_count_for_line (pp))
118 pp_append_text (pp, start, p);
122 if (start != end && ISBLANK (*start))
127 if (start != end && *start == '\n')
135 /* Same as pp_wrap_text but wrap text only when in line-wrapping mode. */
137 pp_maybe_wrap_text (pretty_printer *pp, const char *start, const char *end)
139 if (pp_is_wrapping_line (pp))
140 pp_wrap_text (pp, start, end);
142 pp_append_text (pp, start, end);
145 /* Append to the output area of PRETTY-PRINTER a string specified by its
146 STARTing character and LENGTH. */
148 pp_append_r (pretty_printer *pp, const char *start, int length)
150 obstack_grow (pp->buffer->obstack, start, length);
151 pp->buffer->line_length += length;
154 /* Insert enough spaces into the output area of PRETTY-PRINTER to bring
155 the column position to the current indentation level, assuming that a
156 newline has just been written to the buffer. */
158 pp_base_indent (pretty_printer *pp)
160 int n = pp_indentation (pp);
163 for (i = 0; i < n; ++i)
167 /* The following format specifiers are recognized as being client independent:
168 %d, %i: (signed) integer in base ten.
169 %u: unsigned integer in base ten.
170 %o: unsigned integer in base eight.
171 %x: unsigned integer in base sixteen.
172 %ld, %li, %lo, %lu, %lx: long versions of the above.
173 %lld, %lli, %llo, %llu, %llx: long long versions.
174 %wd, %wi, %wo, %wu, %wx: HOST_WIDE_INT versions.
178 %m: strerror(text->err_no) - does not consume a value from args_ptr.
182 %': apostrophe (should only be used in untranslated messages;
183 translations should use appropriate punctuation directly).
184 %.*s: a substring the length of which is specified by an argument
186 %Ns: likewise, but length specified as constant in the format string.
187 Flag 'q': quote formatted text (must come immediately after '%').
189 Arguments can be used sequentially, or through %N$ resp. *N$
190 notation Nth argument after the format string. If %N$ / *N$
191 notation is used, it must be used for all arguments, except %m, %%,
192 %<, %> and %', which may not have a number, as they do not consume
193 an argument. When %M$.*N$s is used, M must be N + 1. (This may
194 also be written %M$.*s, provided N is not otherwise used.) The
195 format string must have conversion specifiers with argument numbers
196 1 up to highest argument; each argument may only be used once.
197 A format string can have at most 30 arguments. */
199 /* Formatting phases 1 and 2: render TEXT->format_spec plus
200 TEXT->args_ptr into a series of chunks in PP->buffer->args[].
201 Phase 3 is in pp_base_format_text. */
204 pp_base_format (pretty_printer *pp, text_info *text)
206 output_buffer *buffer = pp->buffer;
209 struct chunk_info *new_chunk_array;
211 unsigned int curarg = 0, chunk = 0, argno;
212 pp_wrapping_mode_t old_wrapping_mode;
213 bool any_unnumbered = false, any_numbered = false;
214 const char **formatters[PP_NL_ARGMAX];
216 /* Allocate a new chunk structure. */
217 new_chunk_array = XOBNEW (&buffer->chunk_obstack, struct chunk_info);
218 new_chunk_array->prev = buffer->cur_chunk_array;
219 buffer->cur_chunk_array = new_chunk_array;
220 args = new_chunk_array->args;
222 /* Formatting phase 1: split up TEXT->format_spec into chunks in
223 PP->buffer->args[]. Even-numbered chunks are to be output
224 verbatim, odd-numbered chunks are format specifiers.
225 %m, %%, %<, %>, and %' are replaced with the appropriate text at
228 memset (formatters, 0, sizeof formatters);
230 for (p = text->format_spec; *p; )
232 while (*p != '\0' && *p != '%')
234 obstack_1grow (&buffer->chunk_obstack, *p);
247 obstack_1grow (&buffer->chunk_obstack, '%');
252 obstack_grow (&buffer->chunk_obstack,
253 open_quote, strlen (open_quote));
259 obstack_grow (&buffer->chunk_obstack,
260 close_quote, strlen (close_quote));
266 const char *errstr = xstrerror (text->err_no);
267 obstack_grow (&buffer->chunk_obstack, errstr, strlen (errstr));
273 /* Handled in phase 2. Terminate the plain chunk here. */
274 obstack_1grow (&buffer->chunk_obstack, '\0');
275 gcc_assert (chunk < PP_NL_ARGMAX * 2);
276 args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
283 argno = strtoul (p, &end, 10) - 1;
285 gcc_assert (*p == '$');
289 gcc_assert (!any_unnumbered);
294 any_unnumbered = true;
295 gcc_assert (!any_numbered);
297 gcc_assert (argno < PP_NL_ARGMAX);
298 gcc_assert (!formatters[argno]);
299 formatters[argno] = &args[chunk];
302 obstack_1grow (&buffer->chunk_obstack, *p);
305 while (strchr ("qwl+#", p[-1]));
309 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
310 (where M == N + 1). */
315 obstack_1grow (&buffer->chunk_obstack, *p);
318 while (ISDIGIT (p[-1]));
319 gcc_assert (p[-1] == 's');
323 gcc_assert (*p == '*');
324 obstack_1grow (&buffer->chunk_obstack, '*');
330 unsigned int argno2 = strtoul (p, &end, 10) - 1;
332 gcc_assert (argno2 == argno - 1);
333 gcc_assert (!any_unnumbered);
334 gcc_assert (*p == '$');
337 formatters[argno2] = formatters[argno];
341 gcc_assert (!any_numbered);
342 formatters[argno+1] = formatters[argno];
345 gcc_assert (*p == 's');
346 obstack_1grow (&buffer->chunk_obstack, 's');
353 obstack_1grow (&buffer->chunk_obstack, '\0');
354 gcc_assert (chunk < PP_NL_ARGMAX * 2);
355 args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
358 obstack_1grow (&buffer->chunk_obstack, '\0');
359 gcc_assert (chunk < PP_NL_ARGMAX * 2);
360 args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
363 /* Set output to the argument obstack, and switch line-wrapping and
365 buffer->obstack = &buffer->chunk_obstack;
366 old_wrapping_mode = pp_set_verbatim_wrapping (pp);
368 /* Second phase. Replace each formatter with the formatted text it
371 for (argno = 0; formatters[argno]; argno++)
379 /* We do not attempt to enforce any ordering on the modifier
382 for (p = *formatters[argno];; p++)
407 /* We don't support precision beyond that of "long long". */
408 gcc_assert (precision < 2);
415 gcc_assert (!wide || precision == 0);
418 pp_string (pp, open_quote);
423 pp_character (pp, va_arg (*text->args_ptr, int));
429 pp_wide_integer (pp, va_arg (*text->args_ptr, HOST_WIDE_INT));
431 pp_integer_with_precision
432 (pp, *text->args_ptr, precision, int, "d");
437 pp_scalar (pp, "%" HOST_WIDE_INT_PRINT "o",
438 va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
440 pp_integer_with_precision
441 (pp, *text->args_ptr, precision, unsigned, "o");
445 pp_string (pp, va_arg (*text->args_ptr, const char *));
449 pp_pointer (pp, va_arg (*text->args_ptr, void *));
454 pp_scalar (pp, HOST_WIDE_INT_PRINT_UNSIGNED,
455 va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
457 pp_integer_with_precision
458 (pp, *text->args_ptr, precision, unsigned, "u");
463 pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
464 va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
466 pp_integer_with_precision
467 (pp, *text->args_ptr, precision, unsigned, "x");
475 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
476 (where M == N + 1). The format string should be verified
477 already from the first phase. */
482 n = strtoul (p, &end, 10);
484 gcc_assert (*p == 's');
488 gcc_assert (*p == '*');
490 gcc_assert (*p == 's');
491 n = va_arg (*text->args_ptr, int);
493 /* This consumes a second entry in the formatters array. */
494 gcc_assert (formatters[argno] == formatters[argno+1]);
498 s = va_arg (*text->args_ptr, const char *);
499 pp_append_text (pp, s, s + n);
507 gcc_assert (pp_format_decoder (pp));
508 ok = pp_format_decoder (pp) (pp, text, p,
509 precision, wide, plus, hash);
515 pp_string (pp, close_quote);
517 obstack_1grow (&buffer->chunk_obstack, '\0');
518 *formatters[argno] = XOBFINISH (&buffer->chunk_obstack, const char *);
521 #ifdef ENABLE_CHECKING
522 for (; argno < PP_NL_ARGMAX; argno++)
523 gcc_assert (!formatters[argno]);
526 /* Revert to normal obstack and wrapping mode. */
527 buffer->obstack = &buffer->formatted_obstack;
528 buffer->line_length = 0;
529 pp_wrapping_mode (pp) = old_wrapping_mode;
533 /* Format of a message pointed to by TEXT. */
535 pp_base_output_formatted_text (pretty_printer *pp)
538 output_buffer *buffer = pp_buffer (pp);
539 struct chunk_info *chunk_array = buffer->cur_chunk_array;
540 const char **args = chunk_array->args;
542 gcc_assert (buffer->obstack == &buffer->formatted_obstack);
543 gcc_assert (buffer->line_length == 0);
545 /* This is a third phase, first 2 phases done in pp_base_format_args.
546 Now we actually print it. */
547 for (chunk = 0; args[chunk]; chunk++)
548 pp_string (pp, args[chunk]);
550 /* Deallocate the chunk structure and everything after it (i.e. the
551 associated series of formatted strings). */
552 buffer->cur_chunk_array = chunk_array->prev;
553 obstack_free (&buffer->chunk_obstack, chunk_array);
556 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
557 settings needed by BUFFER for a verbatim formatting. */
559 pp_base_format_verbatim (pretty_printer *pp, text_info *text)
561 /* Set verbatim mode. */
562 pp_wrapping_mode_t oldmode = pp_set_verbatim_wrapping (pp);
564 /* Do the actual formatting. */
565 pp_format (pp, text);
566 pp_output_formatted_text (pp);
568 /* Restore previous settings. */
569 pp_wrapping_mode (pp) = oldmode;
572 /* Flush the content of BUFFER onto the attached stream. */
574 pp_base_flush (pretty_printer *pp)
576 pp_write_text_to_stream (pp);
578 fputc ('\n', pp->buffer->stream);
579 fflush (pp->buffer->stream);
580 pp_needs_newline (pp) = false;
583 /* Sets the number of maximum characters per line PRETTY-PRINTER can
584 output in line-wrapping mode. A LENGTH value 0 suppresses
587 pp_base_set_line_maximum_length (pretty_printer *pp, int length)
589 pp_line_cutoff (pp) = length;
590 pp_set_real_maximum_length (pp);
593 /* Clear PRETTY-PRINTER output area text info. */
595 pp_base_clear_output_area (pretty_printer *pp)
597 obstack_free (pp->buffer->obstack, obstack_base (pp->buffer->obstack));
598 pp->buffer->line_length = 0;
601 /* Set PREFIX for PRETTY-PRINTER. */
603 pp_base_set_prefix (pretty_printer *pp, const char *prefix)
606 pp_set_real_maximum_length (pp);
607 pp->emitted_prefix = false;
608 pp_indentation (pp) = 0;
611 /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string. */
613 pp_base_destroy_prefix (pretty_printer *pp)
615 if (pp->prefix != NULL)
617 free (CONST_CAST (char *, pp->prefix));
622 /* Write out PRETTY-PRINTER's prefix. */
624 pp_base_emit_prefix (pretty_printer *pp)
626 if (pp->prefix != NULL)
628 switch (pp_prefixing_rule (pp))
631 case DIAGNOSTICS_SHOW_PREFIX_NEVER:
634 case DIAGNOSTICS_SHOW_PREFIX_ONCE:
635 if (pp->emitted_prefix)
640 pp_indentation (pp) += 3;
643 case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
645 int prefix_length = strlen (pp->prefix);
646 pp_append_r (pp, pp->prefix, prefix_length);
647 pp->emitted_prefix = true;
654 /* Construct a PRETTY-PRINTER with PREFIX and of MAXIMUM_LENGTH
655 characters per line. */
657 pp_construct (pretty_printer *pp, const char *prefix, int maximum_length)
659 memset (pp, 0, sizeof (pretty_printer));
660 pp->buffer = XCNEW (output_buffer);
661 obstack_init (&pp->buffer->chunk_obstack);
662 obstack_init (&pp->buffer->formatted_obstack);
663 pp->buffer->obstack = &pp->buffer->formatted_obstack;
664 pp->buffer->stream = stderr;
665 pp_line_cutoff (pp) = maximum_length;
666 pp_prefixing_rule (pp) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
667 pp_set_prefix (pp, prefix);
668 pp_translate_identifiers (pp) = true;
671 /* Append a string delimited by START and END to the output area of
672 PRETTY-PRINTER. No line wrapping is done. However, if beginning a
673 new line then emit PRETTY-PRINTER's prefix and skip any leading
674 whitespace if appropriate. The caller must ensure that it is
677 pp_base_append_text (pretty_printer *pp, const char *start, const char *end)
679 /* Emit prefix and skip whitespace if we're starting a new line. */
680 if (pp->buffer->line_length == 0)
683 if (pp_is_wrapping_line (pp))
684 while (start != end && *start == ' ')
687 pp_append_r (pp, start, end - start);
690 /* Finishes constructing a NULL-terminated character string representing
691 the PRETTY-PRINTED text. */
693 pp_base_formatted_text (pretty_printer *pp)
695 obstack_1grow (pp->buffer->obstack, '\0');
696 return pp_formatted_text_data (pp);
699 /* Return a pointer to the last character emitted in PRETTY-PRINTER's
700 output area. A NULL pointer means no character available. */
702 pp_base_last_position_in_text (const pretty_printer *pp)
704 const char *p = NULL;
705 struct obstack *text = pp->buffer->obstack;
707 if (obstack_base (text) != obstack_next_free (text))
708 p = ((const char *) obstack_next_free (text)) - 1;
712 /* Return the amount of characters PRETTY-PRINTER can accept to
713 make a full line. Meaningful only in line-wrapping mode. */
715 pp_base_remaining_character_count_for_line (pretty_printer *pp)
717 return pp->maximum_length - pp->buffer->line_length;
721 /* Format a message into BUFFER a la printf. */
723 pp_printf (pretty_printer *pp, const char *msg, ...)
731 text.format_spec = msg;
733 pp_format (pp, &text);
734 pp_output_formatted_text (pp);
739 /* Output MESSAGE verbatim into BUFFER. */
741 pp_verbatim (pretty_printer *pp, const char *msg, ...)
749 text.format_spec = msg;
751 pp_format_verbatim (pp, &text);
757 /* Have PRETTY-PRINTER start a new line. */
759 pp_base_newline (pretty_printer *pp)
761 obstack_1grow (pp->buffer->obstack, '\n');
762 pp_needs_newline (pp) = false;
763 pp->buffer->line_length = 0;
766 /* Have PRETTY-PRINTER add a CHARACTER. */
768 pp_base_character (pretty_printer *pp, int c)
770 if (pp_is_wrapping_line (pp)
771 && pp_remaining_character_count_for_line (pp) <= 0)
777 obstack_1grow (pp->buffer->obstack, c);
778 ++pp->buffer->line_length;
781 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
782 be line-wrapped if in appropriate mode. */
784 pp_base_string (pretty_printer *pp, const char *str)
786 pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
789 /* Maybe print out a whitespace if needed. */
792 pp_base_maybe_space (pretty_printer *pp)
794 if (pp_base (pp)->padding != pp_none)
797 pp_base (pp)->padding = pp_none;
801 /* The string starting at P has LEN (at least 1) bytes left; if they
802 start with a valid UTF-8 sequence, return the length of that
803 sequence and set *VALUE to the value of that sequence, and
804 otherwise return 0 and set *VALUE to (unsigned int) -1. */
807 decode_utf8_char (const unsigned char *p, size_t len, unsigned int *value)
818 for (t = *p; t & 0x80; t <<= 1)
821 if (utf8_len > len || utf8_len < 2 || utf8_len > 6)
823 *value = (unsigned int) -1;
826 ch = *p & ((1 << (7 - utf8_len)) - 1);
827 for (i = 1; i < utf8_len; i++)
829 unsigned int u = p[i];
830 if ((u & 0xC0) != 0x80)
832 *value = (unsigned int) -1;
835 ch = (ch << 6) | (u & 0x3F);
837 if ( (ch <= 0x7F && utf8_len > 1)
838 || (ch <= 0x7FF && utf8_len > 2)
839 || (ch <= 0xFFFF && utf8_len > 3)
840 || (ch <= 0x1FFFFF && utf8_len > 4)
841 || (ch <= 0x3FFFFFF && utf8_len > 5)
842 || (ch >= 0xD800 && ch <= 0xDFFF))
844 *value = (unsigned int) -1;
857 /* Allocator for identifier_to_locale and corresponding function to
860 void *(*identifier_to_locale_alloc) (size_t) = xmalloc;
861 void (*identifier_to_locale_free) (void *) = free;
863 /* Given IDENT, an identifier in the internal encoding, return a
864 version of IDENT suitable for diagnostics in the locale character
865 set: either IDENT itself, or a string, allocated using
866 identifier_to_locale_alloc, converted to the locale character set
867 and using escape sequences if not representable in the locale
868 character set or containing control characters or invalid byte
869 sequences. Existing backslashes in IDENT are not doubled, so the
870 result may not uniquely specify the contents of an arbitrary byte
871 sequence identifier. */
874 identifier_to_locale (const char *ident)
876 const unsigned char *uid = (const unsigned char *) ident;
877 size_t idlen = strlen (ident);
878 bool valid_printable_utf8 = true;
879 bool all_ascii = true;
882 for (i = 0; i < idlen;)
885 size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
886 if (utf8_len == 0 || c <= 0x1F || (c >= 0x7F && c <= 0x9F))
888 valid_printable_utf8 = false;
896 /* If IDENT contains invalid UTF-8 sequences (which may occur with
897 attributes putting arbitrary byte sequences in identifiers), or
898 control characters, we use octal escape sequences for all bytes
899 outside printable ASCII. */
900 if (!valid_printable_utf8)
902 char *ret = (char *) identifier_to_locale_alloc (4 * idlen + 1);
904 for (i = 0; i < idlen; i++)
906 if (uid[i] > 0x1F && uid[i] < 0x7F)
910 sprintf (p, "\\%03o", uid[i]);
918 /* Otherwise, if it is valid printable ASCII, or printable UTF-8
919 with the locale character set being UTF-8, IDENT is used. */
920 if (all_ascii || locale_utf8)
923 /* Otherwise IDENT is converted to the locale character set if
925 #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
926 if (locale_encoding != NULL)
928 iconv_t cd = iconv_open (locale_encoding, "UTF-8");
929 bool conversion_ok = true;
931 if (cd != (iconv_t) -1)
933 size_t ret_alloc = 4 * idlen + 1;
936 /* Repeat the whole conversion process as needed with
937 larger buffers so non-reversible transformations can
938 always be detected. */
939 ICONV_CONST char *inbuf = CONST_CAST (char *, ident);
941 size_t inbytesleft = idlen;
942 size_t outbytesleft = ret_alloc - 1;
945 ret = (char *) identifier_to_locale_alloc (ret_alloc);
948 if (iconv (cd, 0, 0, 0, 0) == (size_t) -1)
950 conversion_ok = false;
954 iconv_ret = iconv (cd, &inbuf, &inbytesleft,
955 &outbuf, &outbytesleft);
956 if (iconv_ret == (size_t) -1 || inbytesleft != 0)
961 identifier_to_locale_free (ret);
967 conversion_ok = false;
971 else if (iconv_ret != 0)
973 conversion_ok = false;
976 /* Return to initial shift state. */
977 if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t) -1)
982 identifier_to_locale_free (ret);
988 conversion_ok = false;
1002 /* Otherwise, convert non-ASCII characters in IDENT to UCNs. */
1004 char *ret = (char *) identifier_to_locale_alloc (10 * idlen + 1);
1006 for (i = 0; i < idlen;)
1009 size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
1014 sprintf (p, "\\U%08x", c);