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 #define obstack_chunk_alloc xmalloc
33 #define obstack_chunk_free free
35 /* A pointer to the formatted diagnostic message. */
36 #define pp_formatted_text_data(PP) \
37 ((const char *) obstack_base (pp_base (PP)->buffer->obstack))
39 /* Format an integer given by va_arg (ARG, type-specifier T) where
40 type-specifier is a precision modifier as indicated by PREC. F is
41 a string used to construct the appropriate format-specifier. */
42 #define pp_integer_with_precision(PP, ARG, PREC, T, F) \
47 pp_scalar (PP, "%" F, va_arg (ARG, T)); \
51 pp_scalar (PP, "%l" F, va_arg (ARG, long T)); \
55 pp_scalar (PP, "%" HOST_LONG_LONG_FORMAT F, va_arg (ARG, long long T)); \
64 /* Subroutine of pp_set_maximum_length. Set up PRETTY-PRINTER's
65 internal maximum characters per line. */
67 pp_set_real_maximum_length (pretty_printer *pp)
69 /* If we're told not to wrap lines then do the obvious thing. In case
70 we'll emit prefix only once per message, it is appropriate
71 not to increase unnecessarily the line-length cut-off. */
72 if (!pp_is_wrapping_line (pp)
73 || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_ONCE
74 || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
75 pp->maximum_length = pp_line_cutoff (pp);
78 int prefix_length = pp->prefix ? strlen (pp->prefix) : 0;
79 /* If the prefix is ridiculously too long, output at least
81 if (pp_line_cutoff (pp) - prefix_length < 32)
82 pp->maximum_length = pp_line_cutoff (pp) + 32;
84 pp->maximum_length = pp_line_cutoff (pp);
88 /* Clear PRETTY-PRINTER's output state. */
90 pp_clear_state (pretty_printer *pp)
92 pp->emitted_prefix = false;
93 pp_indentation (pp) = 0;
96 /* Flush the formatted text of PRETTY-PRINTER onto the attached stream. */
98 pp_write_text_to_stream (pretty_printer *pp)
100 const char *text = pp_formatted_text (pp);
101 fputs (text, pp->buffer->stream);
102 pp_clear_output_area (pp);
105 /* Wrap a text delimited by START and END into PRETTY-PRINTER. */
107 pp_wrap_text (pretty_printer *pp, const char *start, const char *end)
109 bool wrapping_line = pp_is_wrapping_line (pp);
113 /* Dump anything bordered by whitespaces. */
115 const char *p = start;
116 while (p != end && !ISBLANK (*p) && *p != '\n')
119 && p - start >= pp_remaining_character_count_for_line (pp))
121 pp_append_text (pp, start, p);
125 if (start != end && ISBLANK (*start))
130 if (start != end && *start == '\n')
138 /* Same as pp_wrap_text but wrap text only when in line-wrapping mode. */
140 pp_maybe_wrap_text (pretty_printer *pp, const char *start, const char *end)
142 if (pp_is_wrapping_line (pp))
143 pp_wrap_text (pp, start, end);
145 pp_append_text (pp, start, end);
148 /* Append to the output area of PRETTY-PRINTER a string specified by its
149 STARTing character and LENGTH. */
151 pp_append_r (pretty_printer *pp, const char *start, int length)
153 obstack_grow (pp->buffer->obstack, start, length);
154 pp->buffer->line_length += length;
157 /* Insert enough spaces into the output area of PRETTY-PRINTER to bring
158 the column position to the current indentation level, assuming that a
159 newline has just been written to the buffer. */
161 pp_base_indent (pretty_printer *pp)
163 int n = pp_indentation (pp);
166 for (i = 0; i < n; ++i)
170 /* The following format specifiers are recognized as being client independent:
171 %d, %i: (signed) integer in base ten.
172 %u: unsigned integer in base ten.
173 %o: unsigned integer in base eight.
174 %x: unsigned integer in base sixteen.
175 %ld, %li, %lo, %lu, %lx: long versions of the above.
176 %lld, %lli, %llo, %llu, %llx: long long versions.
177 %wd, %wi, %wo, %wu, %wx: HOST_WIDE_INT versions.
181 %m: strerror(text->err_no) - does not consume a value from args_ptr.
185 %': apostrophe (should only be used in untranslated messages;
186 translations should use appropriate punctuation directly).
187 %.*s: a substring the length of which is specified by an argument
189 %Ns: likewise, but length specified as constant in the format string.
190 Flag 'q': quote formatted text (must come immediately after '%').
192 Arguments can be used sequentially, or through %N$ resp. *N$
193 notation Nth argument after the format string. If %N$ / *N$
194 notation is used, it must be used for all arguments, except %m, %%,
195 %<, %> and %', which may not have a number, as they do not consume
196 an argument. When %M$.*N$s is used, M must be N + 1. (This may
197 also be written %M$.*s, provided N is not otherwise used.) The
198 format string must have conversion specifiers with argument numbers
199 1 up to highest argument; each argument may only be used once.
200 A format string can have at most 30 arguments. */
202 /* Formatting phases 1 and 2: render TEXT->format_spec plus
203 TEXT->args_ptr into a series of chunks in PP->buffer->args[].
204 Phase 3 is in pp_base_format_text. */
207 pp_base_format (pretty_printer *pp, text_info *text)
209 output_buffer *buffer = pp->buffer;
212 struct chunk_info *new_chunk_array;
214 unsigned int curarg = 0, chunk = 0, argno;
215 pp_wrapping_mode_t old_wrapping_mode;
216 bool any_unnumbered = false, any_numbered = false;
217 const char **formatters[PP_NL_ARGMAX];
219 /* Allocate a new chunk structure. */
220 new_chunk_array = XOBNEW (&buffer->chunk_obstack, struct chunk_info);
221 new_chunk_array->prev = buffer->cur_chunk_array;
222 buffer->cur_chunk_array = new_chunk_array;
223 args = new_chunk_array->args;
225 /* Formatting phase 1: split up TEXT->format_spec into chunks in
226 PP->buffer->args[]. Even-numbered chunks are to be output
227 verbatim, odd-numbered chunks are format specifiers.
228 %m, %%, %<, %>, and %' are replaced with the appropriate text at
231 memset (formatters, 0, sizeof formatters);
233 for (p = text->format_spec; *p; )
235 while (*p != '\0' && *p != '%')
237 obstack_1grow (&buffer->chunk_obstack, *p);
250 obstack_1grow (&buffer->chunk_obstack, '%');
255 obstack_grow (&buffer->chunk_obstack,
256 open_quote, strlen (open_quote));
262 obstack_grow (&buffer->chunk_obstack,
263 close_quote, strlen (close_quote));
269 const char *errstr = xstrerror (text->err_no);
270 obstack_grow (&buffer->chunk_obstack, errstr, strlen (errstr));
276 /* Handled in phase 2. Terminate the plain chunk here. */
277 obstack_1grow (&buffer->chunk_obstack, '\0');
278 gcc_assert (chunk < PP_NL_ARGMAX * 2);
279 args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
286 argno = strtoul (p, &end, 10) - 1;
288 gcc_assert (*p == '$');
292 gcc_assert (!any_unnumbered);
297 any_unnumbered = true;
298 gcc_assert (!any_numbered);
300 gcc_assert (argno < PP_NL_ARGMAX);
301 gcc_assert (!formatters[argno]);
302 formatters[argno] = &args[chunk];
305 obstack_1grow (&buffer->chunk_obstack, *p);
308 while (strchr ("qwl+#", p[-1]));
312 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
313 (where M == N + 1). */
318 obstack_1grow (&buffer->chunk_obstack, *p);
321 while (ISDIGIT (p[-1]));
322 gcc_assert (p[-1] == 's');
326 gcc_assert (*p == '*');
327 obstack_1grow (&buffer->chunk_obstack, '*');
333 unsigned int argno2 = strtoul (p, &end, 10) - 1;
335 gcc_assert (argno2 == argno - 1);
336 gcc_assert (!any_unnumbered);
337 gcc_assert (*p == '$');
340 formatters[argno2] = formatters[argno];
344 gcc_assert (!any_numbered);
345 formatters[argno+1] = formatters[argno];
348 gcc_assert (*p == 's');
349 obstack_1grow (&buffer->chunk_obstack, 's');
356 obstack_1grow (&buffer->chunk_obstack, '\0');
357 gcc_assert (chunk < PP_NL_ARGMAX * 2);
358 args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
361 obstack_1grow (&buffer->chunk_obstack, '\0');
362 gcc_assert (chunk < PP_NL_ARGMAX * 2);
363 args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
366 /* Set output to the argument obstack, and switch line-wrapping and
368 buffer->obstack = &buffer->chunk_obstack;
369 old_wrapping_mode = pp_set_verbatim_wrapping (pp);
371 /* Second phase. Replace each formatter with the formatted text it
374 for (argno = 0; formatters[argno]; argno++)
382 /* We do not attempt to enforce any ordering on the modifier
385 for (p = *formatters[argno];; p++)
410 /* We don't support precision beyond that of "long long". */
411 gcc_assert (precision < 2);
418 gcc_assert (!wide || precision == 0);
421 pp_string (pp, open_quote);
426 pp_character (pp, va_arg (*text->args_ptr, int));
432 pp_wide_integer (pp, va_arg (*text->args_ptr, HOST_WIDE_INT));
434 pp_integer_with_precision
435 (pp, *text->args_ptr, precision, int, "d");
440 pp_scalar (pp, "%" HOST_WIDE_INT_PRINT "o",
441 va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
443 pp_integer_with_precision
444 (pp, *text->args_ptr, precision, unsigned, "o");
448 pp_string (pp, va_arg (*text->args_ptr, const char *));
452 pp_pointer (pp, va_arg (*text->args_ptr, void *));
457 pp_scalar (pp, HOST_WIDE_INT_PRINT_UNSIGNED,
458 va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
460 pp_integer_with_precision
461 (pp, *text->args_ptr, precision, unsigned, "u");
466 pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
467 va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
469 pp_integer_with_precision
470 (pp, *text->args_ptr, precision, unsigned, "x");
478 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
479 (where M == N + 1). The format string should be verified
480 already from the first phase. */
485 n = strtoul (p, &end, 10);
487 gcc_assert (*p == 's');
491 gcc_assert (*p == '*');
493 gcc_assert (*p == 's');
494 n = va_arg (*text->args_ptr, int);
496 /* This consumes a second entry in the formatters array. */
497 gcc_assert (formatters[argno] == formatters[argno+1]);
501 s = va_arg (*text->args_ptr, const char *);
502 pp_append_text (pp, s, s + n);
510 gcc_assert (pp_format_decoder (pp));
511 ok = pp_format_decoder (pp) (pp, text, p,
512 precision, wide, plus, hash);
518 pp_string (pp, close_quote);
520 obstack_1grow (&buffer->chunk_obstack, '\0');
521 *formatters[argno] = XOBFINISH (&buffer->chunk_obstack, const char *);
524 #ifdef ENABLE_CHECKING
525 for (; argno < PP_NL_ARGMAX; argno++)
526 gcc_assert (!formatters[argno]);
529 /* Revert to normal obstack and wrapping mode. */
530 buffer->obstack = &buffer->formatted_obstack;
531 buffer->line_length = 0;
532 pp_wrapping_mode (pp) = old_wrapping_mode;
536 /* Format of a message pointed to by TEXT. */
538 pp_base_output_formatted_text (pretty_printer *pp)
541 output_buffer *buffer = pp_buffer (pp);
542 struct chunk_info *chunk_array = buffer->cur_chunk_array;
543 const char **args = chunk_array->args;
545 gcc_assert (buffer->obstack == &buffer->formatted_obstack);
546 gcc_assert (buffer->line_length == 0);
548 /* This is a third phase, first 2 phases done in pp_base_format_args.
549 Now we actually print it. */
550 for (chunk = 0; args[chunk]; chunk++)
551 pp_string (pp, args[chunk]);
553 /* Deallocate the chunk structure and everything after it (i.e. the
554 associated series of formatted strings). */
555 buffer->cur_chunk_array = chunk_array->prev;
556 obstack_free (&buffer->chunk_obstack, chunk_array);
559 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
560 settings needed by BUFFER for a verbatim formatting. */
562 pp_base_format_verbatim (pretty_printer *pp, text_info *text)
564 /* Set verbatim mode. */
565 pp_wrapping_mode_t oldmode = pp_set_verbatim_wrapping (pp);
567 /* Do the actual formatting. */
568 pp_format (pp, text);
569 pp_output_formatted_text (pp);
571 /* Restore previous settings. */
572 pp_wrapping_mode (pp) = oldmode;
575 /* Flush the content of BUFFER onto the attached stream. */
577 pp_base_flush (pretty_printer *pp)
579 pp_write_text_to_stream (pp);
581 fputc ('\n', pp->buffer->stream);
582 fflush (pp->buffer->stream);
583 pp_needs_newline (pp) = false;
586 /* Sets the number of maximum characters per line PRETTY-PRINTER can
587 output in line-wrapping mode. A LENGTH value 0 suppresses
590 pp_base_set_line_maximum_length (pretty_printer *pp, int length)
592 pp_line_cutoff (pp) = length;
593 pp_set_real_maximum_length (pp);
596 /* Clear PRETTY-PRINTER output area text info. */
598 pp_base_clear_output_area (pretty_printer *pp)
600 obstack_free (pp->buffer->obstack, obstack_base (pp->buffer->obstack));
601 pp->buffer->line_length = 0;
604 /* Set PREFIX for PRETTY-PRINTER. */
606 pp_base_set_prefix (pretty_printer *pp, const char *prefix)
609 pp_set_real_maximum_length (pp);
610 pp->emitted_prefix = false;
611 pp_indentation (pp) = 0;
614 /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string. */
616 pp_base_destroy_prefix (pretty_printer *pp)
618 if (pp->prefix != NULL)
620 free (CONST_CAST (char *, pp->prefix));
625 /* Write out PRETTY-PRINTER's prefix. */
627 pp_base_emit_prefix (pretty_printer *pp)
629 if (pp->prefix != NULL)
631 switch (pp_prefixing_rule (pp))
634 case DIAGNOSTICS_SHOW_PREFIX_NEVER:
637 case DIAGNOSTICS_SHOW_PREFIX_ONCE:
638 if (pp->emitted_prefix)
643 pp_indentation (pp) += 3;
646 case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
648 int prefix_length = strlen (pp->prefix);
649 pp_append_r (pp, pp->prefix, prefix_length);
650 pp->emitted_prefix = true;
657 /* Construct a PRETTY-PRINTER with PREFIX and of MAXIMUM_LENGTH
658 characters per line. */
660 pp_construct (pretty_printer *pp, const char *prefix, int maximum_length)
662 memset (pp, 0, sizeof (pretty_printer));
663 pp->buffer = XCNEW (output_buffer);
664 obstack_init (&pp->buffer->chunk_obstack);
665 obstack_init (&pp->buffer->formatted_obstack);
666 pp->buffer->obstack = &pp->buffer->formatted_obstack;
667 pp->buffer->stream = stderr;
668 pp_line_cutoff (pp) = maximum_length;
669 pp_prefixing_rule (pp) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
670 pp_set_prefix (pp, prefix);
671 pp_translate_identifiers (pp) = true;
674 /* Append a string delimited by START and END to the output area of
675 PRETTY-PRINTER. No line wrapping is done. However, if beginning a
676 new line then emit PRETTY-PRINTER's prefix and skip any leading
677 whitespace if appropriate. The caller must ensure that it is
680 pp_base_append_text (pretty_printer *pp, const char *start, const char *end)
682 /* Emit prefix and skip whitespace if we're starting a new line. */
683 if (pp->buffer->line_length == 0)
686 if (pp_is_wrapping_line (pp))
687 while (start != end && *start == ' ')
690 pp_append_r (pp, start, end - start);
693 /* Finishes constructing a NULL-terminated character string representing
694 the PRETTY-PRINTED text. */
696 pp_base_formatted_text (pretty_printer *pp)
698 obstack_1grow (pp->buffer->obstack, '\0');
699 return pp_formatted_text_data (pp);
702 /* Return a pointer to the last character emitted in PRETTY-PRINTER's
703 output area. A NULL pointer means no character available. */
705 pp_base_last_position_in_text (const pretty_printer *pp)
707 const char *p = NULL;
708 struct obstack *text = pp->buffer->obstack;
710 if (obstack_base (text) != obstack_next_free (text))
711 p = ((const char *) obstack_next_free (text)) - 1;
715 /* Return the amount of characters PRETTY-PRINTER can accept to
716 make a full line. Meaningful only in line-wrapping mode. */
718 pp_base_remaining_character_count_for_line (pretty_printer *pp)
720 return pp->maximum_length - pp->buffer->line_length;
724 /* Format a message into BUFFER a la printf. */
726 pp_printf (pretty_printer *pp, const char *msg, ...)
734 text.format_spec = msg;
736 pp_format (pp, &text);
737 pp_output_formatted_text (pp);
742 /* Output MESSAGE verbatim into BUFFER. */
744 pp_verbatim (pretty_printer *pp, const char *msg, ...)
752 text.format_spec = msg;
754 pp_format_verbatim (pp, &text);
760 /* Have PRETTY-PRINTER start a new line. */
762 pp_base_newline (pretty_printer *pp)
764 obstack_1grow (pp->buffer->obstack, '\n');
765 pp->buffer->line_length = 0;
768 /* Have PRETTY-PRINTER add a CHARACTER. */
770 pp_base_character (pretty_printer *pp, int c)
772 if (pp_is_wrapping_line (pp)
773 && pp_remaining_character_count_for_line (pp) <= 0)
779 obstack_1grow (pp->buffer->obstack, c);
780 ++pp->buffer->line_length;
783 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
784 be line-wrapped if in appropriate mode. */
786 pp_base_string (pretty_printer *pp, const char *str)
788 pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
791 /* Maybe print out a whitespace if needed. */
794 pp_base_maybe_space (pretty_printer *pp)
796 if (pp_base (pp)->padding != pp_none)
799 pp_base (pp)->padding = pp_none;
803 /* The string starting at P has LEN (at least 1) bytes left; if they
804 start with a valid UTF-8 sequence, return the length of that
805 sequence and set *VALUE to the value of that sequence, and
806 otherwise return 0 and set *VALUE to (unsigned int) -1. */
809 decode_utf8_char (const unsigned char *p, size_t len, unsigned int *value)
820 for (t = *p; t & 0x80; t <<= 1)
823 if (utf8_len > len || utf8_len < 2 || utf8_len > 6)
825 *value = (unsigned int) -1;
828 ch = *p & ((1 << (7 - utf8_len)) - 1);
829 for (i = 1; i < utf8_len; i++)
831 unsigned int u = p[i];
832 if ((u & 0xC0) != 0x80)
834 *value = (unsigned int) -1;
837 ch = (ch << 6) | (u & 0x3F);
839 if ( (ch <= 0x7F && utf8_len > 1)
840 || (ch <= 0x7FF && utf8_len > 2)
841 || (ch <= 0xFFFF && utf8_len > 3)
842 || (ch <= 0x1FFFFF && utf8_len > 4)
843 || (ch <= 0x3FFFFFF && utf8_len > 5)
844 || (ch >= 0xD800 && ch <= 0xDFFF))
846 *value = (unsigned int) -1;
859 /* Allocator for identifier_to_locale and corresponding function to
862 void *(*identifier_to_locale_alloc) (size_t) = xmalloc;
863 void (*identifier_to_locale_free) (void *) = free;
865 /* Given IDENT, an identifier in the internal encoding, return a
866 version of IDENT suitable for diagnostics in the locale character
867 set: either IDENT itself, or a string, allocated using
868 identifier_to_locale_alloc, converted to the locale character set
869 and using escape sequences if not representable in the locale
870 character set or containing control characters or invalid byte
871 sequences. Existing backslashes in IDENT are not doubled, so the
872 result may not uniquely specify the contents of an arbitrary byte
873 sequence identifier. */
876 identifier_to_locale (const char *ident)
878 const unsigned char *uid = (const unsigned char *) ident;
879 size_t idlen = strlen (ident);
880 bool valid_printable_utf8 = true;
881 bool all_ascii = true;
884 for (i = 0; i < idlen;)
887 size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
888 if (utf8_len == 0 || c <= 0x1F || (c >= 0x7F && c <= 0x9F))
890 valid_printable_utf8 = false;
898 /* If IDENT contains invalid UTF-8 sequences (which may occur with
899 attributes putting arbitrary byte sequences in identifiers), or
900 control characters, we use octal escape sequences for all bytes
901 outside printable ASCII. */
902 if (!valid_printable_utf8)
904 char *ret = (char *) identifier_to_locale_alloc (4 * idlen + 1);
906 for (i = 0; i < idlen; i++)
908 if (uid[i] > 0x1F && uid[i] < 0x7F)
912 sprintf (p, "\\%03o", uid[i]);
920 /* Otherwise, if it is valid printable ASCII, or printable UTF-8
921 with the locale character set being UTF-8, IDENT is used. */
922 if (all_ascii || locale_utf8)
925 /* Otherwise IDENT is converted to the locale character set if
927 #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
928 if (locale_encoding != NULL)
930 iconv_t cd = iconv_open (locale_encoding, "UTF-8");
931 bool conversion_ok = true;
933 if (cd != (iconv_t) -1)
935 size_t ret_alloc = 4 * idlen + 1;
938 /* Repeat the whole conversion process as needed with
939 larger buffers so non-reversible transformations can
940 always be detected. */
941 ICONV_CONST char *inbuf = CONST_CAST (char *, ident);
943 size_t inbytesleft = idlen;
944 size_t outbytesleft = ret_alloc - 1;
947 ret = (char *) identifier_to_locale_alloc (ret_alloc);
950 if (iconv (cd, 0, 0, 0, 0) == (size_t) -1)
952 conversion_ok = false;
956 iconv_ret = iconv (cd, &inbuf, &inbytesleft,
957 &outbuf, &outbytesleft);
958 if (iconv_ret == (size_t) -1 || inbytesleft != 0)
963 identifier_to_locale_free (ret);
969 conversion_ok = false;
973 else if (iconv_ret != 0)
975 conversion_ok = false;
978 /* Return to initial shift state. */
979 if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t) -1)
984 identifier_to_locale_free (ret);
990 conversion_ok = false;
1004 /* Otherwise, convert non-ASCII characters in IDENT to UCNs. */
1006 char *ret = (char *) identifier_to_locale_alloc (10 * idlen + 1);
1008 for (i = 0; i < idlen;)
1011 size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
1016 sprintf (p, "\\U%08x", c);