gcc/pretty-print.c

   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>
   5
   6 This file is part of GCC.
   7
   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
  11 version.
  12
  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
  16 for more details.
  17
  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/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "intl.h"
  26 #include "pretty-print.h"
  27
  28 #if HAVE_ICONV
  29 #include <iconv.h>
  30 #endif
  31
  32 #define obstack_chunk_alloc xmalloc
  33 #define obstack_chunk_free  free
  34
  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))
  38
  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)       \
  43   do                                                         \
  44     switch (PREC)                                            \
  45       {                                                      \
  46       case 0:                                                \
  47         pp_scalar (PP, "%" F, va_arg (ARG, T));              \
  48         break;                                               \
  49                                                              \
  50       case 1:                                                \
  51         pp_scalar (PP, "%l" F, va_arg (ARG, long T));        \
  52         break;                                               \
  53                                                              \
  54       case 2:                                                \
  55         pp_scalar (PP, "%" HOST_LONG_LONG_FORMAT F, va_arg (ARG, long long T));  \
  56         break;                                               \
  57                                                              \
  58       default:                                               \
  59         break;                                               \
  60       }                                                      \
  61   while (0)
  62
  63
  64 /* Subroutine of pp_set_maximum_length.  Set up PRETTY-PRINTER's
  65    internal maximum characters per line.  */
  66 static void
  67 pp_set_real_maximum_length (pretty_printer *pp)
  68 {
  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);
  76   else
  77     {
  78       int prefix_length = pp->prefix ? strlen (pp->prefix) : 0;
  79       /* If the prefix is ridiculously too long, output at least
  80          32 characters.  */
  81       if (pp_line_cutoff (pp) - prefix_length < 32)
  82         pp->maximum_length = pp_line_cutoff (pp) + 32;
  83       else
  84         pp->maximum_length = pp_line_cutoff (pp);
  85     }
  86 }
  87
  88 /* Clear PRETTY-PRINTER's output state.  */
  89 static inline void
  90 pp_clear_state (pretty_printer *pp)
  91 {
  92   pp->emitted_prefix = false;
  93   pp_indentation (pp) = 0;
  94 }
  95
  96 /* Flush the formatted text of PRETTY-PRINTER onto the attached stream.  */
  97 void
  98 pp_write_text_to_stream (pretty_printer *pp)
  99 {
 100   const char *text = pp_formatted_text (pp);
 101   fputs (text, pp->buffer->stream);
 102   pp_clear_output_area (pp);
 103 }
 104
 105 /* Wrap a text delimited by START and END into PRETTY-PRINTER.  */
 106 static void
 107 pp_wrap_text (pretty_printer *pp, const char *start, const char *end)
 108 {
 109   bool wrapping_line = pp_is_wrapping_line (pp);
 110
 111   while (start != end)
 112     {
 113       /* Dump anything bordered by whitespaces.  */
 114       {
 115         const char *p = start;
 116         while (p != end && !ISBLANK (*p) && *p != '\n')
 117           ++p;
 118         if (wrapping_line
 119             && p - start >= pp_remaining_character_count_for_line (pp))
 120           pp_newline (pp);
 121         pp_append_text (pp, start, p);
 122         start = p;
 123       }
 124
 125       if (start != end && ISBLANK (*start))
 126         {
 127           pp_space (pp);
 128           ++start;
 129         }
 130       if (start != end && *start == '\n')
 131         {
 132           pp_newline (pp);
 133           ++start;
 134         }
 135     }
 136 }
 137
 138 /* Same as pp_wrap_text but wrap text only when in line-wrapping mode.  */
 139 static inline void
 140 pp_maybe_wrap_text (pretty_printer *pp, const char *start, const char *end)
 141 {
 142   if (pp_is_wrapping_line (pp))
 143     pp_wrap_text (pp, start, end);
 144   else
 145     pp_append_text (pp, start, end);
 146 }
 147
 148 /* Append to the output area of PRETTY-PRINTER a string specified by its
 149    STARTing character and LENGTH.  */
 150 static inline void
 151 pp_append_r (pretty_printer *pp, const char *start, int length)
 152 {
 153   obstack_grow (pp->buffer->obstack, start, length);
 154   pp->buffer->line_length += length;
 155 }
 156
 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.  */
 160 void
 161 pp_base_indent (pretty_printer *pp)
 162 {
 163   int n = pp_indentation (pp);
 164   int i;
 165
 166   for (i = 0; i < n; ++i)
 167     pp_space (pp);
 168 }
 169
 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.
 178    %c: character.
 179    %s: string.
 180    %p: pointer.
 181    %m: strerror(text->err_no) - does not consume a value from args_ptr.
 182    %%: '%'.
 183    %<: opening quote.
 184    %>: closing quote.
 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
 188          integer.
 189    %Ns: likewise, but length specified as constant in the format string.
 190    Flag 'q': quote formatted text (must come immediately after '%').
 191
 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.  */
 201
 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.  */
 205
 206 void
 207 pp_base_format (pretty_printer *pp, text_info *text)
 208 {
 209   output_buffer *buffer = pp->buffer;
 210   const char *p;
 211   const char **args;
 212   struct chunk_info *new_chunk_array;
 213
 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];
 218
 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;
 224
 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
 229      this point.  */
 230
 231   memset (formatters, 0, sizeof formatters);
 232
 233   for (p = text->format_spec; *p; )
 234     {
 235       while (*p != '\0' && *p != '%')
 236         {
 237           obstack_1grow (&buffer->chunk_obstack, *p);
 238           p++;
 239         }
 240
 241       if (*p == '\0')
 242         break;
 243
 244       switch (*++p)
 245         {
 246         case '\0':
 247           gcc_unreachable ();
 248
 249         case '%':
 250           obstack_1grow (&buffer->chunk_obstack, '%');
 251           p++;
 252           continue;
 253
 254         case '<':
 255           obstack_grow (&buffer->chunk_obstack,
 256                         open_quote, strlen (open_quote));
 257           p++;
 258           continue;
 259
 260         case '>':
 261         case '\'':
 262           obstack_grow (&buffer->chunk_obstack,
 263                         close_quote, strlen (close_quote));
 264           p++;
 265           continue;
 266
 267         case 'm':
 268           {
 269             const char *errstr = xstrerror (text->err_no);
 270             obstack_grow (&buffer->chunk_obstack, errstr, strlen (errstr));
 271           }
 272           p++;
 273           continue;
 274
 275         default:
 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 *);
 280           break;
 281         }
 282
 283       if (ISDIGIT (*p))
 284         {
 285           char *end;
 286           argno = strtoul (p, &end, 10) - 1;
 287           p = end;
 288           gcc_assert (*p == '$');
 289           p++;
 290
 291           any_numbered = true;
 292           gcc_assert (!any_unnumbered);
 293         }
 294       else
 295         {
 296           argno = curarg++;
 297           any_unnumbered = true;
 298           gcc_assert (!any_numbered);
 299         }
 300       gcc_assert (argno < PP_NL_ARGMAX);
 301       gcc_assert (!formatters[argno]);
 302       formatters[argno] = &args[chunk];
 303       do
 304         {
 305           obstack_1grow (&buffer->chunk_obstack, *p);
 306           p++;
 307         }
 308       while (strchr ("qwl+#", p[-1]));
 309
 310       if (p[-1] == '.')
 311         {
 312           /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
 313              (where M == N + 1).  */
 314           if (ISDIGIT (*p))
 315             {
 316               do
 317                 {
 318                   obstack_1grow (&buffer->chunk_obstack, *p);
 319                   p++;
 320                 }
 321               while (ISDIGIT (p[-1]));
 322               gcc_assert (p[-1] == 's');
 323             }
 324           else
 325             {
 326               gcc_assert (*p == '*');
 327               obstack_1grow (&buffer->chunk_obstack, '*');
 328               p++;
 329
 330               if (ISDIGIT (*p))
 331                 {
 332                   char *end;
 333                   unsigned int argno2 = strtoul (p, &end, 10) - 1;
 334                   p = end;
 335                   gcc_assert (argno2 == argno - 1);
 336                   gcc_assert (!any_unnumbered);
 337                   gcc_assert (*p == '$');
 338
 339                   p++;
 340                   formatters[argno2] = formatters[argno];
 341                 }
 342               else
 343                 {
 344                   gcc_assert (!any_numbered);
 345                   formatters[argno+1] = formatters[argno];
 346                   curarg++;
 347                 }
 348               gcc_assert (*p == 's');
 349               obstack_1grow (&buffer->chunk_obstack, 's');
 350               p++;
 351             }
 352         }
 353       if (*p == '\0')
 354         break;
 355
 356       obstack_1grow (&buffer->chunk_obstack, '\0');
 357       gcc_assert (chunk < PP_NL_ARGMAX * 2);
 358       args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
 359     }
 360
 361   obstack_1grow (&buffer->chunk_obstack, '\0');
 362   gcc_assert (chunk < PP_NL_ARGMAX * 2);
 363   args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
 364   args[chunk] = 0;
 365
 366   /* Set output to the argument obstack, and switch line-wrapping and
 367      prefixing off.  */
 368   buffer->obstack = &buffer->chunk_obstack;
 369   old_wrapping_mode = pp_set_verbatim_wrapping (pp);
 370
 371   /* Second phase.  Replace each formatter with the formatted text it
 372      corresponds to.  */
 373
 374   for (argno = 0; formatters[argno]; argno++)
 375     {
 376       int precision = 0;
 377       bool wide = false;
 378       bool plus = false;
 379       bool hash = false;
 380       bool quote = false;
 381
 382       /* We do not attempt to enforce any ordering on the modifier
 383          characters.  */
 384
 385       for (p = *formatters[argno];; p++)
 386         {
 387           switch (*p)
 388             {
 389             case 'q':
 390               gcc_assert (!quote);
 391               quote = true;
 392               continue;
 393
 394             case '+':
 395               gcc_assert (!plus);
 396               plus = true;
 397               continue;
 398
 399             case '#':
 400               gcc_assert (!hash);
 401               hash = true;
 402               continue;
 403
 404             case 'w':
 405               gcc_assert (!wide);
 406               wide = true;
 407               continue;
 408
 409             case 'l':
 410               /* We don't support precision beyond that of "long long".  */
 411               gcc_assert (precision < 2);
 412               precision++;
 413               continue;
 414             }
 415           break;
 416         }
 417
 418       gcc_assert (!wide || precision == 0);
 419
 420       if (quote)
 421         pp_string (pp, open_quote);
 422
 423       switch (*p)
 424         {
 425         case 'c':
 426           pp_character (pp, va_arg (*text->args_ptr, int));
 427           break;
 428
 429         case 'd':
 430         case 'i':
 431           if (wide)
 432             pp_wide_integer (pp, va_arg (*text->args_ptr, HOST_WIDE_INT));
 433           else
 434             pp_integer_with_precision
 435               (pp, *text->args_ptr, precision, int, "d");
 436           break;
 437
 438         case 'o':
 439           if (wide)
 440             pp_scalar (pp, "%" HOST_WIDE_INT_PRINT "o",
 441                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 442           else
 443             pp_integer_with_precision
 444               (pp, *text->args_ptr, precision, unsigned, "o");
 445           break;
 446
 447         case 's':
 448           pp_string (pp, va_arg (*text->args_ptr, const char *));
 449           break;
 450
 451         case 'p':
 452           pp_pointer (pp, va_arg (*text->args_ptr, void *));
 453           break;
 454
 455         case 'u':
 456           if (wide)
 457             pp_scalar (pp, HOST_WIDE_INT_PRINT_UNSIGNED,
 458                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 459           else
 460             pp_integer_with_precision
 461               (pp, *text->args_ptr, precision, unsigned, "u");
 462           break;
 463
 464         case 'x':
 465           if (wide)
 466             pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
 467                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 468           else
 469             pp_integer_with_precision
 470               (pp, *text->args_ptr, precision, unsigned, "x");
 471           break;
 472
 473         case '.':
 474           {
 475             int n;
 476             const char *s;
 477
 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.  */
 481             p++;
 482             if (ISDIGIT (*p))
 483               {
 484                 char *end;
 485                 n = strtoul (p, &end, 10);
 486                 p = end;
 487                 gcc_assert (*p == 's');
 488               }
 489             else
 490               {
 491                 gcc_assert (*p == '*');
 492                 p++;
 493                 gcc_assert (*p == 's');
 494                 n = va_arg (*text->args_ptr, int);
 495
 496                 /* This consumes a second entry in the formatters array.  */
 497                 gcc_assert (formatters[argno] == formatters[argno+1]);
 498                 argno++;
 499               }
 500
 501             s = va_arg (*text->args_ptr, const char *);
 502             pp_append_text (pp, s, s + n);
 503           }
 504           break;
 505
 506         default:
 507           {
 508             bool ok;
 509
 510             gcc_assert (pp_format_decoder (pp));
 511             ok = pp_format_decoder (pp) (pp, text, p,
 512                                          precision, wide, plus, hash);
 513             gcc_assert (ok);
 514           }
 515         }
 516
 517       if (quote)
 518         pp_string (pp, close_quote);
 519
 520       obstack_1grow (&buffer->chunk_obstack, '\0');
 521       *formatters[argno] = XOBFINISH (&buffer->chunk_obstack, const char *);
 522     }
 523
 524 #ifdef ENABLE_CHECKING
 525   for (; argno < PP_NL_ARGMAX; argno++)
 526     gcc_assert (!formatters[argno]);
 527 #endif
 528
 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;
 533   pp_clear_state (pp);
 534 }
 535
 536 /* Format of a message pointed to by TEXT.  */
 537 void
 538 pp_base_output_formatted_text (pretty_printer *pp)
 539 {
 540   unsigned int chunk;
 541   output_buffer *buffer = pp_buffer (pp);
 542   struct chunk_info *chunk_array = buffer->cur_chunk_array;
 543   const char **args = chunk_array->args;
 544
 545   gcc_assert (buffer->obstack == &buffer->formatted_obstack);
 546   gcc_assert (buffer->line_length == 0);
 547
 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]);
 552
 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);
 557 }
 558
 559 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
 560    settings needed by BUFFER for a verbatim formatting.  */
 561 void
 562 pp_base_format_verbatim (pretty_printer *pp, text_info *text)
 563 {
 564   /* Set verbatim mode.  */
 565   pp_wrapping_mode_t oldmode = pp_set_verbatim_wrapping (pp);
 566
 567   /* Do the actual formatting.  */
 568   pp_format (pp, text);
 569   pp_output_formatted_text (pp);
 570
 571   /* Restore previous settings.  */
 572   pp_wrapping_mode (pp) = oldmode;
 573 }
 574
 575 /* Flush the content of BUFFER onto the attached stream.  */
 576 void
 577 pp_base_flush (pretty_printer *pp)
 578 {
 579   pp_write_text_to_stream (pp);
 580   pp_clear_state (pp);
 581   fputc ('\n', pp->buffer->stream);
 582   fflush (pp->buffer->stream);
 583   pp_needs_newline (pp) = false;
 584 }
 585
 586 /* Sets the number of maximum characters per line PRETTY-PRINTER can
 587    output in line-wrapping mode.  A LENGTH value 0 suppresses
 588    line-wrapping.  */
 589 void
 590 pp_base_set_line_maximum_length (pretty_printer *pp, int length)
 591 {
 592   pp_line_cutoff (pp) = length;
 593   pp_set_real_maximum_length (pp);
 594 }
 595
 596 /* Clear PRETTY-PRINTER output area text info.  */
 597 void
 598 pp_base_clear_output_area (pretty_printer *pp)
 599 {
 600   obstack_free (pp->buffer->obstack, obstack_base (pp->buffer->obstack));
 601   pp->buffer->line_length = 0;
 602 }
 603
 604 /* Set PREFIX for PRETTY-PRINTER.  */
 605 void
 606 pp_base_set_prefix (pretty_printer *pp, const char *prefix)
 607 {
 608   pp->prefix = prefix;
 609   pp_set_real_maximum_length (pp);
 610   pp->emitted_prefix = false;
 611   pp_indentation (pp) = 0;
 612 }
 613
 614 /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string.  */
 615 void
 616 pp_base_destroy_prefix (pretty_printer *pp)
 617 {
 618   if (pp->prefix != NULL)
 619     {
 620       free (CONST_CAST (char *, pp->prefix));
 621       pp->prefix = NULL;
 622     }
 623 }
 624
 625 /* Write out PRETTY-PRINTER's prefix.  */
 626 void
 627 pp_base_emit_prefix (pretty_printer *pp)
 628 {
 629   if (pp->prefix != NULL)
 630     {
 631       switch (pp_prefixing_rule (pp))
 632         {
 633         default:
 634         case DIAGNOSTICS_SHOW_PREFIX_NEVER:
 635           break;
 636
 637         case DIAGNOSTICS_SHOW_PREFIX_ONCE:
 638           if (pp->emitted_prefix)
 639             {
 640               pp_base_indent (pp);
 641               break;
 642             }
 643           pp_indentation (pp) += 3;
 644           /* Fall through.  */
 645
 646         case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
 647           {
 648             int prefix_length = strlen (pp->prefix);
 649             pp_append_r (pp, pp->prefix, prefix_length);
 650             pp->emitted_prefix = true;
 651           }
 652           break;
 653         }
 654     }
 655 }
 656
 657 /* Construct a PRETTY-PRINTER with PREFIX and of MAXIMUM_LENGTH
 658    characters per line.  */
 659 void
 660 pp_construct (pretty_printer *pp, const char *prefix, int maximum_length)
 661 {
 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;
 672 }
 673
 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
 678    safe to do so.  */
 679 void
 680 pp_base_append_text (pretty_printer *pp, const char *start, const char *end)
 681 {
 682   /* Emit prefix and skip whitespace if we're starting a new line.  */
 683   if (pp->buffer->line_length == 0)
 684     {
 685       pp_emit_prefix (pp);
 686       if (pp_is_wrapping_line (pp))
 687         while (start != end && *start == ' ')
 688           ++start;
 689     }
 690   pp_append_r (pp, start, end - start);
 691 }
 692
 693 /* Finishes constructing a NULL-terminated character string representing
 694    the PRETTY-PRINTED text.  */
 695 const char *
 696 pp_base_formatted_text (pretty_printer *pp)
 697 {
 698   obstack_1grow (pp->buffer->obstack, '\0');
 699   return pp_formatted_text_data (pp);
 700 }
 701
 702 /*  Return a pointer to the last character emitted in PRETTY-PRINTER's
 703     output area.  A NULL pointer means no character available.  */
 704 const char *
 705 pp_base_last_position_in_text (const pretty_printer *pp)
 706 {
 707   const char *p = NULL;
 708   struct obstack *text = pp->buffer->obstack;
 709
 710   if (obstack_base (text) != obstack_next_free (text))
 711     p = ((const char *) obstack_next_free (text)) - 1;
 712   return p;
 713 }
 714
 715 /* Return the amount of characters PRETTY-PRINTER can accept to
 716    make a full line.  Meaningful only in line-wrapping mode.  */
 717 int
 718 pp_base_remaining_character_count_for_line (pretty_printer *pp)
 719 {
 720   return pp->maximum_length - pp->buffer->line_length;
 721 }
 722
 723
 724 /* Format a message into BUFFER a la printf.  */
 725 void
 726 pp_printf (pretty_printer *pp, const char *msg, ...)
 727 {
 728   text_info text;
 729   va_list ap;
 730
 731   va_start (ap, msg);
 732   text.err_no = errno;
 733   text.args_ptr = &ap;
 734   text.format_spec = msg;
 735   text.locus = NULL;
 736   pp_format (pp, &text);
 737   pp_output_formatted_text (pp);
 738   va_end (ap);
 739 }
 740
 741
 742 /* Output MESSAGE verbatim into BUFFER.  */
 743 void
 744 pp_verbatim (pretty_printer *pp, const char *msg, ...)
 745 {
 746   text_info text;
 747   va_list ap;
 748
 749   va_start (ap, msg);
 750   text.err_no = errno;
 751   text.args_ptr = &ap;
 752   text.format_spec = msg;
 753   text.locus = NULL;
 754   pp_format_verbatim (pp, &text);
 755   va_end (ap);
 756 }
 757
 758
 759
 760 /* Have PRETTY-PRINTER start a new line.  */
 761 void
 762 pp_base_newline (pretty_printer *pp)
 763 {
 764   obstack_1grow (pp->buffer->obstack, '\n');
 765   pp->buffer->line_length = 0;
 766 }
 767
 768 /* Have PRETTY-PRINTER add a CHARACTER.  */
 769 void
 770 pp_base_character (pretty_printer *pp, int c)
 771 {
 772   if (pp_is_wrapping_line (pp)
 773       && pp_remaining_character_count_for_line (pp) <= 0)
 774     {
 775       pp_newline (pp);
 776       if (ISSPACE (c))
 777         return;
 778     }
 779   obstack_1grow (pp->buffer->obstack, c);
 780   ++pp->buffer->line_length;
 781 }
 782
 783 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
 784    be line-wrapped if in appropriate mode.  */
 785 void
 786 pp_base_string (pretty_printer *pp, const char *str)
 787 {
 788   pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
 789 }
 790
 791 /* Maybe print out a whitespace if needed.  */
 792
 793 void
 794 pp_base_maybe_space (pretty_printer *pp)
 795 {
 796   if (pp_base (pp)->padding != pp_none)
 797     {
 798       pp_space (pp);
 799       pp_base (pp)->padding = pp_none;
 800     }
 801 }
 802 \f
 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.  */
 807
 808 static int
 809 decode_utf8_char (const unsigned char *p, size_t len, unsigned int *value)
 810 {
 811   unsigned int t = *p;
 812
 813   if (len == 0)
 814     abort ();
 815   if (t & 0x80)
 816     {
 817       size_t utf8_len = 0;
 818       unsigned int ch;
 819       size_t i;
 820       for (t = *p; t & 0x80; t <<= 1)
 821         utf8_len++;
 822
 823       if (utf8_len > len || utf8_len < 2 || utf8_len > 6)
 824         {
 825           *value = (unsigned int) -1;
 826           return 0;
 827         }
 828       ch = *p & ((1 << (7 - utf8_len)) - 1);
 829       for (i = 1; i < utf8_len; i++)
 830         {
 831           unsigned int u = p[i];
 832           if ((u & 0xC0) != 0x80)
 833             {
 834               *value = (unsigned int) -1;
 835               return 0;
 836             }
 837           ch = (ch << 6) | (u & 0x3F);
 838         }
 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))
 845         {
 846           *value = (unsigned int) -1;
 847           return 0;
 848         }
 849       *value = ch;
 850       return utf8_len;
 851     }
 852   else
 853     {
 854       *value = t;
 855       return 1;
 856     }
 857 }
 858
 859 /* Allocator for identifier_to_locale and corresponding function to
 860    free memory.  */
 861
 862 void *(*identifier_to_locale_alloc) (size_t) = xmalloc;
 863 void (*identifier_to_locale_free) (void *) = free;
 864
 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.  */
 874
 875 const char *
 876 identifier_to_locale (const char *ident)
 877 {
 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;
 882   size_t i;
 883
 884   for (i = 0; i < idlen;)
 885     {
 886       unsigned int c;
 887       size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
 888       if (utf8_len == 0 || c <= 0x1F || (c >= 0x7F && c <= 0x9F))
 889         {
 890           valid_printable_utf8 = false;
 891           break;
 892         }
 893       if (utf8_len > 1)
 894         all_ascii = false;
 895       i += utf8_len;
 896     }
 897
 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)
 903     {
 904       char *ret = (char *) identifier_to_locale_alloc (4 * idlen + 1);
 905       char *p = ret;
 906       for (i = 0; i < idlen; i++)
 907         {
 908           if (uid[i] > 0x1F && uid[i] < 0x7F)
 909             *p++ = uid[i];
 910           else
 911             {
 912               sprintf (p, "\\%03o", uid[i]);
 913               p += 4;
 914             }
 915         }
 916       *p = 0;
 917       return ret;
 918     }
 919
 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)
 923     return ident;
 924
 925   /* Otherwise IDENT is converted to the locale character set if
 926      possible.  */
 927 #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
 928   if (locale_encoding != NULL)
 929     {
 930       iconv_t cd = iconv_open (locale_encoding, "UTF-8");
 931       bool conversion_ok = true;
 932       char *ret = NULL;
 933       if (cd != (iconv_t) -1)
 934         {
 935           size_t ret_alloc = 4 * idlen + 1;
 936           for (;;)
 937             {
 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);
 942               char *outbuf;
 943               size_t inbytesleft = idlen;
 944               size_t outbytesleft = ret_alloc - 1;
 945               size_t iconv_ret;
 946
 947               ret = (char *) identifier_to_locale_alloc (ret_alloc);
 948               outbuf = ret;
 949
 950               if (iconv (cd, 0, 0, 0, 0) == (size_t) -1)
 951                 {
 952                   conversion_ok = false;
 953                   break;
 954                 }
 955
 956               iconv_ret = iconv (cd, &inbuf, &inbytesleft,
 957                                  &outbuf, &outbytesleft);
 958               if (iconv_ret == (size_t) -1 || inbytesleft != 0)
 959                 {
 960                   if (errno == E2BIG)
 961                     {
 962                       ret_alloc *= 2;
 963                       identifier_to_locale_free (ret);
 964                       ret = NULL;
 965                       continue;
 966                     }
 967                   else
 968                     {
 969                       conversion_ok = false;
 970                       break;
 971                     }
 972                 }
 973               else if (iconv_ret != 0)
 974                 {
 975                   conversion_ok = false;
 976                   break;
 977                 }
 978               /* Return to initial shift state.  */
 979               if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t) -1)
 980                 {
 981                   if (errno == E2BIG)
 982                     {
 983                       ret_alloc *= 2;
 984                       identifier_to_locale_free (ret);
 985                       ret = NULL;
 986                       continue;
 987                     }
 988                   else
 989                     {
 990                       conversion_ok = false;
 991                       break;
 992                     }
 993                 }
 994               *outbuf = 0;
 995               break;
 996             }
 997           iconv_close (cd);
 998           if (conversion_ok)
 999             return ret;
1000         }
1001     }
1002 #endif
1003
1004   /* Otherwise, convert non-ASCII characters in IDENT to UCNs.  */
1005   {
1006     char *ret = (char *) identifier_to_locale_alloc (10 * idlen + 1);
1007     char *p = ret;
1008     for (i = 0; i < idlen;)
1009       {
1010         unsigned int c;
1011         size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
1012         if (utf8_len == 1)
1013           *p++ = uid[i];
1014         else
1015           {
1016             sprintf (p, "\\U%08x", c);
1017             p += 10;
1018           }
1019         i += utf8_len;
1020       }
1021     *p = 0;
1022     return ret;
1023   }
1024 }