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