gcc/pretty-print.c

   1 /* Various declarations for language-independent pretty-print subroutines.
   2    Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2012
   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 /* As pp_write_text_to_stream, but for GraphViz label output.
 103
 104    Flush the formatted text of pretty-printer PP onto the attached stream.
 105    Replace characters in PPF that have special meaning in a GraphViz .dot
 106    file.
 107
 108    This routine is not very fast, but it doesn't have to be as this is only
 109    be used by routines dumping intermediate representations in graph form.  */
 110
 111 void
 112 pp_write_text_as_dot_label_to_stream (pretty_printer *pp, bool for_record)
 113 {
 114   const char *text = pp_formatted_text (pp);
 115   const char *p = text;
 116   FILE *fp = pp->buffer->stream;
 117
 118   while (*p)
 119     {
 120       switch (*p)
 121         {
 122         /* Print newlines as a left-aligned newline.  */
 123         case '\n':
 124           fputs ("\\l\\\n", fp);
 125           break;
 126
 127         /* A pipe is only special for record-shape nodes.  */
 128         case '|':
 129           if (for_record)
 130             fputc ('\\', fp);
 131           fputc (*p, fp);
 132           break;
 133
 134         /* The following characters always have to be escaped
 135            for use in labels.  */
 136         case '{':
 137         case '}':
 138         case '<':
 139         case '>':
 140         case '"':
 141         case ' ':
 142           fputc ('\\', fp);
 143           /* fall through */
 144         default:
 145           fputc (*p, fp);
 146           break;
 147         }
 148       p++;
 149     }
 150
 151   pp_clear_output_area (pp);
 152 }
 153
 154 /* Wrap a text delimited by START and END into PRETTY-PRINTER.  */
 155 static void
 156 pp_wrap_text (pretty_printer *pp, const char *start, const char *end)
 157 {
 158   bool wrapping_line = pp_is_wrapping_line (pp);
 159
 160   while (start != end)
 161     {
 162       /* Dump anything bordered by whitespaces.  */
 163       {
 164         const char *p = start;
 165         while (p != end && !ISBLANK (*p) && *p != '\n')
 166           ++p;
 167         if (wrapping_line
 168             && p - start >= pp_remaining_character_count_for_line (pp))
 169           pp_newline (pp);
 170         pp_append_text (pp, start, p);
 171         start = p;
 172       }
 173
 174       if (start != end && ISBLANK (*start))
 175         {
 176           pp_space (pp);
 177           ++start;
 178         }
 179       if (start != end && *start == '\n')
 180         {
 181           pp_newline (pp);
 182           ++start;
 183         }
 184     }
 185 }
 186
 187 /* Same as pp_wrap_text but wrap text only when in line-wrapping mode.  */
 188 static inline void
 189 pp_maybe_wrap_text (pretty_printer *pp, const char *start, const char *end)
 190 {
 191   if (pp_is_wrapping_line (pp))
 192     pp_wrap_text (pp, start, end);
 193   else
 194     pp_append_text (pp, start, end);
 195 }
 196
 197 /* Append to the output area of PRETTY-PRINTER a string specified by its
 198    STARTing character and LENGTH.  */
 199 static inline void
 200 pp_append_r (pretty_printer *pp, const char *start, int length)
 201 {
 202   obstack_grow (pp->buffer->obstack, start, length);
 203   pp->buffer->line_length += length;
 204 }
 205
 206 /* Insert enough spaces into the output area of PRETTY-PRINTER to bring
 207    the column position to the current indentation level, assuming that a
 208    newline has just been written to the buffer.  */
 209 void
 210 pp_base_indent (pretty_printer *pp)
 211 {
 212   int n = pp_indentation (pp);
 213   int i;
 214
 215   for (i = 0; i < n; ++i)
 216     pp_space (pp);
 217 }
 218
 219 /* The following format specifiers are recognized as being client independent:
 220    %d, %i: (signed) integer in base ten.
 221    %u: unsigned integer in base ten.
 222    %o: unsigned integer in base eight.
 223    %x: unsigned integer in base sixteen.
 224    %ld, %li, %lo, %lu, %lx: long versions of the above.
 225    %lld, %lli, %llo, %llu, %llx: long long versions.
 226    %wd, %wi, %wo, %wu, %wx: HOST_WIDE_INT versions.
 227    %c: character.
 228    %s: string.
 229    %p: pointer.
 230    %m: strerror(text->err_no) - does not consume a value from args_ptr.
 231    %%: '%'.
 232    %<: opening quote.
 233    %>: closing quote.
 234    %': apostrophe (should only be used in untranslated messages;
 235        translations should use appropriate punctuation directly).
 236    %.*s: a substring the length of which is specified by an argument
 237          integer.
 238    %Ns: likewise, but length specified as constant in the format string.
 239    Flag 'q': quote formatted text (must come immediately after '%').
 240
 241    Arguments can be used sequentially, or through %N$ resp. *N$
 242    notation Nth argument after the format string.  If %N$ / *N$
 243    notation is used, it must be used for all arguments, except %m, %%,
 244    %<, %> and %', which may not have a number, as they do not consume
 245    an argument.  When %M$.*N$s is used, M must be N + 1.  (This may
 246    also be written %M$.*s, provided N is not otherwise used.)  The
 247    format string must have conversion specifiers with argument numbers
 248    1 up to highest argument; each argument may only be used once.
 249    A format string can have at most 30 arguments.  */
 250
 251 /* Formatting phases 1 and 2: render TEXT->format_spec plus
 252    TEXT->args_ptr into a series of chunks in PP->buffer->args[].
 253    Phase 3 is in pp_base_format_text.  */
 254
 255 void
 256 pp_base_format (pretty_printer *pp, text_info *text)
 257 {
 258   output_buffer *buffer = pp->buffer;
 259   const char *p;
 260   const char **args;
 261   struct chunk_info *new_chunk_array;
 262
 263   unsigned int curarg = 0, chunk = 0, argno;
 264   pp_wrapping_mode_t old_wrapping_mode;
 265   bool any_unnumbered = false, any_numbered = false;
 266   const char **formatters[PP_NL_ARGMAX];
 267
 268   /* Allocate a new chunk structure.  */
 269   new_chunk_array = XOBNEW (&buffer->chunk_obstack, struct chunk_info);
 270   new_chunk_array->prev = buffer->cur_chunk_array;
 271   buffer->cur_chunk_array = new_chunk_array;
 272   args = new_chunk_array->args;
 273
 274   /* Formatting phase 1: split up TEXT->format_spec into chunks in
 275      PP->buffer->args[].  Even-numbered chunks are to be output
 276      verbatim, odd-numbered chunks are format specifiers.
 277      %m, %%, %<, %>, and %' are replaced with the appropriate text at
 278      this point.  */
 279
 280   memset (formatters, 0, sizeof formatters);
 281
 282   for (p = text->format_spec; *p; )
 283     {
 284       while (*p != '\0' && *p != '%')
 285         {
 286           obstack_1grow (&buffer->chunk_obstack, *p);
 287           p++;
 288         }
 289
 290       if (*p == '\0')
 291         break;
 292
 293       switch (*++p)
 294         {
 295         case '\0':
 296           gcc_unreachable ();
 297
 298         case '%':
 299           obstack_1grow (&buffer->chunk_obstack, '%');
 300           p++;
 301           continue;
 302
 303         case '<':
 304           obstack_grow (&buffer->chunk_obstack,
 305                         open_quote, strlen (open_quote));
 306           p++;
 307           continue;
 308
 309         case '>':
 310         case '\'':
 311           obstack_grow (&buffer->chunk_obstack,
 312                         close_quote, strlen (close_quote));
 313           p++;
 314           continue;
 315
 316         case 'm':
 317           {
 318             const char *errstr = xstrerror (text->err_no);
 319             obstack_grow (&buffer->chunk_obstack, errstr, strlen (errstr));
 320           }
 321           p++;
 322           continue;
 323
 324         default:
 325           /* Handled in phase 2.  Terminate the plain chunk here.  */
 326           obstack_1grow (&buffer->chunk_obstack, '\0');
 327           gcc_assert (chunk < PP_NL_ARGMAX * 2);
 328           args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
 329           break;
 330         }
 331
 332       if (ISDIGIT (*p))
 333         {
 334           char *end;
 335           argno = strtoul (p, &end, 10) - 1;
 336           p = end;
 337           gcc_assert (*p == '$');
 338           p++;
 339
 340           any_numbered = true;
 341           gcc_assert (!any_unnumbered);
 342         }
 343       else
 344         {
 345           argno = curarg++;
 346           any_unnumbered = true;
 347           gcc_assert (!any_numbered);
 348         }
 349       gcc_assert (argno < PP_NL_ARGMAX);
 350       gcc_assert (!formatters[argno]);
 351       formatters[argno] = &args[chunk];
 352       do
 353         {
 354           obstack_1grow (&buffer->chunk_obstack, *p);
 355           p++;
 356         }
 357       while (strchr ("qwl+#", p[-1]));
 358
 359       if (p[-1] == '.')
 360         {
 361           /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
 362              (where M == N + 1).  */
 363           if (ISDIGIT (*p))
 364             {
 365               do
 366                 {
 367                   obstack_1grow (&buffer->chunk_obstack, *p);
 368                   p++;
 369                 }
 370               while (ISDIGIT (p[-1]));
 371               gcc_assert (p[-1] == 's');
 372             }
 373           else
 374             {
 375               gcc_assert (*p == '*');
 376               obstack_1grow (&buffer->chunk_obstack, '*');
 377               p++;
 378
 379               if (ISDIGIT (*p))
 380                 {
 381                   char *end;
 382                   unsigned int argno2 = strtoul (p, &end, 10) - 1;
 383                   p = end;
 384                   gcc_assert (argno2 == argno - 1);
 385                   gcc_assert (!any_unnumbered);
 386                   gcc_assert (*p == '$');
 387
 388                   p++;
 389                   formatters[argno2] = formatters[argno];
 390                 }
 391               else
 392                 {
 393                   gcc_assert (!any_numbered);
 394                   formatters[argno+1] = formatters[argno];
 395                   curarg++;
 396                 }
 397               gcc_assert (*p == 's');
 398               obstack_1grow (&buffer->chunk_obstack, 's');
 399               p++;
 400             }
 401         }
 402       if (*p == '\0')
 403         break;
 404
 405       obstack_1grow (&buffer->chunk_obstack, '\0');
 406       gcc_assert (chunk < PP_NL_ARGMAX * 2);
 407       args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
 408     }
 409
 410   obstack_1grow (&buffer->chunk_obstack, '\0');
 411   gcc_assert (chunk < PP_NL_ARGMAX * 2);
 412   args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
 413   args[chunk] = 0;
 414
 415   /* Set output to the argument obstack, and switch line-wrapping and
 416      prefixing off.  */
 417   buffer->obstack = &buffer->chunk_obstack;
 418   old_wrapping_mode = pp_set_verbatim_wrapping (pp);
 419
 420   /* Second phase.  Replace each formatter with the formatted text it
 421      corresponds to.  */
 422
 423   for (argno = 0; formatters[argno]; argno++)
 424     {
 425       int precision = 0;
 426       bool wide = false;
 427       bool plus = false;
 428       bool hash = false;
 429       bool quote = false;
 430
 431       /* We do not attempt to enforce any ordering on the modifier
 432          characters.  */
 433
 434       for (p = *formatters[argno];; p++)
 435         {
 436           switch (*p)
 437             {
 438             case 'q':
 439               gcc_assert (!quote);
 440               quote = true;
 441               continue;
 442
 443             case '+':
 444               gcc_assert (!plus);
 445               plus = true;
 446               continue;
 447
 448             case '#':
 449               gcc_assert (!hash);
 450               hash = true;
 451               continue;
 452
 453             case 'w':
 454               gcc_assert (!wide);
 455               wide = true;
 456               continue;
 457
 458             case 'l':
 459               /* We don't support precision beyond that of "long long".  */
 460               gcc_assert (precision < 2);
 461               precision++;
 462               continue;
 463             }
 464           break;
 465         }
 466
 467       gcc_assert (!wide || precision == 0);
 468
 469       if (quote)
 470         pp_string (pp, open_quote);
 471
 472       switch (*p)
 473         {
 474         case 'c':
 475           pp_character (pp, va_arg (*text->args_ptr, int));
 476           break;
 477
 478         case 'd':
 479         case 'i':
 480           if (wide)
 481             pp_wide_integer (pp, va_arg (*text->args_ptr, HOST_WIDE_INT));
 482           else
 483             pp_integer_with_precision
 484               (pp, *text->args_ptr, precision, int, "d");
 485           break;
 486
 487         case 'o':
 488           if (wide)
 489             pp_scalar (pp, "%" HOST_WIDE_INT_PRINT "o",
 490                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 491           else
 492             pp_integer_with_precision
 493               (pp, *text->args_ptr, precision, unsigned, "o");
 494           break;
 495
 496         case 's':
 497           pp_string (pp, va_arg (*text->args_ptr, const char *));
 498           break;
 499
 500         case 'p':
 501           pp_pointer (pp, va_arg (*text->args_ptr, void *));
 502           break;
 503
 504         case 'u':
 505           if (wide)
 506             pp_scalar (pp, HOST_WIDE_INT_PRINT_UNSIGNED,
 507                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 508           else
 509             pp_integer_with_precision
 510               (pp, *text->args_ptr, precision, unsigned, "u");
 511           break;
 512
 513         case 'x':
 514           if (wide)
 515             pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
 516                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 517           else
 518             pp_integer_with_precision
 519               (pp, *text->args_ptr, precision, unsigned, "x");
 520           break;
 521
 522         case '.':
 523           {
 524             int n;
 525             const char *s;
 526
 527             /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
 528                (where M == N + 1).  The format string should be verified
 529                already from the first phase.  */
 530             p++;
 531             if (ISDIGIT (*p))
 532               {
 533                 char *end;
 534                 n = strtoul (p, &end, 10);
 535                 p = end;
 536                 gcc_assert (*p == 's');
 537               }
 538             else
 539               {
 540                 gcc_assert (*p == '*');
 541                 p++;
 542                 gcc_assert (*p == 's');
 543                 n = va_arg (*text->args_ptr, int);
 544
 545                 /* This consumes a second entry in the formatters array.  */
 546                 gcc_assert (formatters[argno] == formatters[argno+1]);
 547                 argno++;
 548               }
 549
 550             s = va_arg (*text->args_ptr, const char *);
 551             pp_append_text (pp, s, s + n);
 552           }
 553           break;
 554
 555         default:
 556           {
 557             bool ok;
 558
 559             gcc_assert (pp_format_decoder (pp));
 560             ok = pp_format_decoder (pp) (pp, text, p,
 561                                          precision, wide, plus, hash);
 562             gcc_assert (ok);
 563           }
 564         }
 565
 566       if (quote)
 567         pp_string (pp, close_quote);
 568
 569       obstack_1grow (&buffer->chunk_obstack, '\0');
 570       *formatters[argno] = XOBFINISH (&buffer->chunk_obstack, const char *);
 571     }
 572
 573 #ifdef ENABLE_CHECKING
 574   for (; argno < PP_NL_ARGMAX; argno++)
 575     gcc_assert (!formatters[argno]);
 576 #endif
 577
 578   /* Revert to normal obstack and wrapping mode.  */
 579   buffer->obstack = &buffer->formatted_obstack;
 580   buffer->line_length = 0;
 581   pp_wrapping_mode (pp) = old_wrapping_mode;
 582   pp_clear_state (pp);
 583 }
 584
 585 /* Format of a message pointed to by TEXT.  */
 586 void
 587 pp_base_output_formatted_text (pretty_printer *pp)
 588 {
 589   unsigned int chunk;
 590   output_buffer *buffer = pp_buffer (pp);
 591   struct chunk_info *chunk_array = buffer->cur_chunk_array;
 592   const char **args = chunk_array->args;
 593
 594   gcc_assert (buffer->obstack == &buffer->formatted_obstack);
 595   gcc_assert (buffer->line_length == 0);
 596
 597   /* This is a third phase, first 2 phases done in pp_base_format_args.
 598      Now we actually print it.  */
 599   for (chunk = 0; args[chunk]; chunk++)
 600     pp_string (pp, args[chunk]);
 601
 602   /* Deallocate the chunk structure and everything after it (i.e. the
 603      associated series of formatted strings).  */
 604   buffer->cur_chunk_array = chunk_array->prev;
 605   obstack_free (&buffer->chunk_obstack, chunk_array);
 606 }
 607
 608 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
 609    settings needed by BUFFER for a verbatim formatting.  */
 610 void
 611 pp_base_format_verbatim (pretty_printer *pp, text_info *text)
 612 {
 613   /* Set verbatim mode.  */
 614   pp_wrapping_mode_t oldmode = pp_set_verbatim_wrapping (pp);
 615
 616   /* Do the actual formatting.  */
 617   pp_format (pp, text);
 618   pp_output_formatted_text (pp);
 619
 620   /* Restore previous settings.  */
 621   pp_wrapping_mode (pp) = oldmode;
 622 }
 623
 624 /* Flush the content of BUFFER onto the attached stream.  */
 625 void
 626 pp_base_flush (pretty_printer *pp)
 627 {
 628   pp_write_text_to_stream (pp);
 629   pp_clear_state (pp);
 630   fflush (pp->buffer->stream);
 631 }
 632
 633 /* Sets the number of maximum characters per line PRETTY-PRINTER can
 634    output in line-wrapping mode.  A LENGTH value 0 suppresses
 635    line-wrapping.  */
 636 void
 637 pp_base_set_line_maximum_length (pretty_printer *pp, int length)
 638 {
 639   pp_line_cutoff (pp) = length;
 640   pp_set_real_maximum_length (pp);
 641 }
 642
 643 /* Clear PRETTY-PRINTER output area text info.  */
 644 void
 645 pp_base_clear_output_area (pretty_printer *pp)
 646 {
 647   obstack_free (pp->buffer->obstack, obstack_base (pp->buffer->obstack));
 648   pp->buffer->line_length = 0;
 649 }
 650
 651 /* Set PREFIX for PRETTY-PRINTER.  */
 652 void
 653 pp_base_set_prefix (pretty_printer *pp, const char *prefix)
 654 {
 655   pp->prefix = prefix;
 656   pp_set_real_maximum_length (pp);
 657   pp->emitted_prefix = false;
 658   pp_indentation (pp) = 0;
 659 }
 660
 661 /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string.  */
 662 void
 663 pp_base_destroy_prefix (pretty_printer *pp)
 664 {
 665   if (pp->prefix != NULL)
 666     {
 667       free (CONST_CAST (char *, pp->prefix));
 668       pp->prefix = NULL;
 669     }
 670 }
 671
 672 /* Write out PRETTY-PRINTER's prefix.  */
 673 void
 674 pp_base_emit_prefix (pretty_printer *pp)
 675 {
 676   if (pp->prefix != NULL)
 677     {
 678       switch (pp_prefixing_rule (pp))
 679         {
 680         default:
 681         case DIAGNOSTICS_SHOW_PREFIX_NEVER:
 682           break;
 683
 684         case DIAGNOSTICS_SHOW_PREFIX_ONCE:
 685           if (pp->emitted_prefix)
 686             {
 687               pp_base_indent (pp);
 688               break;
 689             }
 690           pp_indentation (pp) += 3;
 691           /* Fall through.  */
 692
 693         case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
 694           {
 695             int prefix_length = strlen (pp->prefix);
 696             pp_append_r (pp, pp->prefix, prefix_length);
 697             pp->emitted_prefix = true;
 698           }
 699           break;
 700         }
 701     }
 702 }
 703
 704 /* Construct a PRETTY-PRINTER with PREFIX and of MAXIMUM_LENGTH
 705    characters per line.  */
 706 void
 707 pp_construct (pretty_printer *pp, const char *prefix, int maximum_length)
 708 {
 709   memset (pp, 0, sizeof (pretty_printer));
 710   pp->buffer = XCNEW (output_buffer);
 711   obstack_init (&pp->buffer->chunk_obstack);
 712   obstack_init (&pp->buffer->formatted_obstack);
 713   pp->buffer->obstack = &pp->buffer->formatted_obstack;
 714   pp->buffer->stream = stderr;
 715   pp_line_cutoff (pp) = maximum_length;
 716   pp_prefixing_rule (pp) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 717   pp_set_prefix (pp, prefix);
 718   pp_translate_identifiers (pp) = true;
 719 }
 720
 721 /* Append a string delimited by START and END to the output area of
 722    PRETTY-PRINTER.  No line wrapping is done.  However, if beginning a
 723    new line then emit PRETTY-PRINTER's prefix and skip any leading
 724    whitespace if appropriate.  The caller must ensure that it is
 725    safe to do so.  */
 726 void
 727 pp_base_append_text (pretty_printer *pp, const char *start, const char *end)
 728 {
 729   /* Emit prefix and skip whitespace if we're starting a new line.  */
 730   if (pp->buffer->line_length == 0)
 731     {
 732       pp_emit_prefix (pp);
 733       if (pp_is_wrapping_line (pp))
 734         while (start != end && *start == ' ')
 735           ++start;
 736     }
 737   pp_append_r (pp, start, end - start);
 738 }
 739
 740 /* Finishes constructing a NULL-terminated character string representing
 741    the PRETTY-PRINTED text.  */
 742 const char *
 743 pp_base_formatted_text (pretty_printer *pp)
 744 {
 745   obstack_1grow (pp->buffer->obstack, '\0');
 746   return pp_formatted_text_data (pp);
 747 }
 748
 749 /*  Return a pointer to the last character emitted in PRETTY-PRINTER's
 750     output area.  A NULL pointer means no character available.  */
 751 const char *
 752 pp_base_last_position_in_text (const pretty_printer *pp)
 753 {
 754   const char *p = NULL;
 755   struct obstack *text = pp->buffer->obstack;
 756
 757   if (obstack_base (text) != obstack_next_free (text))
 758     p = ((const char *) obstack_next_free (text)) - 1;
 759   return p;
 760 }
 761
 762 /* Return the amount of characters PRETTY-PRINTER can accept to
 763    make a full line.  Meaningful only in line-wrapping mode.  */
 764 int
 765 pp_base_remaining_character_count_for_line (pretty_printer *pp)
 766 {
 767   return pp->maximum_length - pp->buffer->line_length;
 768 }
 769
 770
 771 /* Format a message into BUFFER a la printf.  */
 772 void
 773 pp_printf (pretty_printer *pp, const char *msg, ...)
 774 {
 775   text_info text;
 776   va_list ap;
 777
 778   va_start (ap, msg);
 779   text.err_no = errno;
 780   text.args_ptr = &ap;
 781   text.format_spec = msg;
 782   text.locus = NULL;
 783   pp_format (pp, &text);
 784   pp_output_formatted_text (pp);
 785   va_end (ap);
 786 }
 787
 788
 789 /* Output MESSAGE verbatim into BUFFER.  */
 790 void
 791 pp_verbatim (pretty_printer *pp, const char *msg, ...)
 792 {
 793   text_info text;
 794   va_list ap;
 795
 796   va_start (ap, msg);
 797   text.err_no = errno;
 798   text.args_ptr = &ap;
 799   text.format_spec = msg;
 800   text.locus = NULL;
 801   pp_format_verbatim (pp, &text);
 802   va_end (ap);
 803 }
 804
 805
 806
 807 /* Have PRETTY-PRINTER start a new line.  */
 808 void
 809 pp_base_newline (pretty_printer *pp)
 810 {
 811   obstack_1grow (pp->buffer->obstack, '\n');
 812   pp_needs_newline (pp) = false;
 813   pp->buffer->line_length = 0;
 814 }
 815
 816 /* Have PRETTY-PRINTER add a CHARACTER.  */
 817 void
 818 pp_base_character (pretty_printer *pp, int c)
 819 {
 820   if (pp_is_wrapping_line (pp)
 821       && pp_remaining_character_count_for_line (pp) <= 0)
 822     {
 823       pp_newline (pp);
 824       if (ISSPACE (c))
 825         return;
 826     }
 827   obstack_1grow (pp->buffer->obstack, c);
 828   ++pp->buffer->line_length;
 829 }
 830
 831 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
 832    be line-wrapped if in appropriate mode.  */
 833 void
 834 pp_base_string (pretty_printer *pp, const char *str)
 835 {
 836   pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
 837 }
 838
 839 /* Maybe print out a whitespace if needed.  */
 840
 841 void
 842 pp_base_maybe_space (pretty_printer *pp)
 843 {
 844   if (pp_base (pp)->padding != pp_none)
 845     {
 846       pp_space (pp);
 847       pp_base (pp)->padding = pp_none;
 848     }
 849 }
 850 \f
 851 /* The string starting at P has LEN (at least 1) bytes left; if they
 852    start with a valid UTF-8 sequence, return the length of that
 853    sequence and set *VALUE to the value of that sequence, and
 854    otherwise return 0 and set *VALUE to (unsigned int) -1.  */
 855
 856 static int
 857 decode_utf8_char (const unsigned char *p, size_t len, unsigned int *value)
 858 {
 859   unsigned int t = *p;
 860
 861   if (len == 0)
 862     abort ();
 863   if (t & 0x80)
 864     {
 865       size_t utf8_len = 0;
 866       unsigned int ch;
 867       size_t i;
 868       for (t = *p; t & 0x80; t <<= 1)
 869         utf8_len++;
 870
 871       if (utf8_len > len || utf8_len < 2 || utf8_len > 6)
 872         {
 873           *value = (unsigned int) -1;
 874           return 0;
 875         }
 876       ch = *p & ((1 << (7 - utf8_len)) - 1);
 877       for (i = 1; i < utf8_len; i++)
 878         {
 879           unsigned int u = p[i];
 880           if ((u & 0xC0) != 0x80)
 881             {
 882               *value = (unsigned int) -1;
 883               return 0;
 884             }
 885           ch = (ch << 6) | (u & 0x3F);
 886         }
 887       if (   (ch <=      0x7F && utf8_len > 1)
 888           || (ch <=     0x7FF && utf8_len > 2)
 889           || (ch <=    0xFFFF && utf8_len > 3)
 890           || (ch <=  0x1FFFFF && utf8_len > 4)
 891           || (ch <= 0x3FFFFFF && utf8_len > 5)
 892           || (ch >= 0xD800 && ch <= 0xDFFF))
 893         {
 894           *value = (unsigned int) -1;
 895           return 0;
 896         }
 897       *value = ch;
 898       return utf8_len;
 899     }
 900   else
 901     {
 902       *value = t;
 903       return 1;
 904     }
 905 }
 906
 907 /* Allocator for identifier_to_locale and corresponding function to
 908    free memory.  */
 909
 910 void *(*identifier_to_locale_alloc) (size_t) = xmalloc;
 911 void (*identifier_to_locale_free) (void *) = free;
 912
 913 /* Given IDENT, an identifier in the internal encoding, return a
 914    version of IDENT suitable for diagnostics in the locale character
 915    set: either IDENT itself, or a string, allocated using
 916    identifier_to_locale_alloc, converted to the locale character set
 917    and using escape sequences if not representable in the locale
 918    character set or containing control characters or invalid byte
 919    sequences.  Existing backslashes in IDENT are not doubled, so the
 920    result may not uniquely specify the contents of an arbitrary byte
 921    sequence identifier.  */
 922
 923 const char *
 924 identifier_to_locale (const char *ident)
 925 {
 926   const unsigned char *uid = (const unsigned char *) ident;
 927   size_t idlen = strlen (ident);
 928   bool valid_printable_utf8 = true;
 929   bool all_ascii = true;
 930   size_t i;
 931
 932   for (i = 0; i < idlen;)
 933     {
 934       unsigned int c;
 935       size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
 936       if (utf8_len == 0 || c <= 0x1F || (c >= 0x7F && c <= 0x9F))
 937         {
 938           valid_printable_utf8 = false;
 939           break;
 940         }
 941       if (utf8_len > 1)
 942         all_ascii = false;
 943       i += utf8_len;
 944     }
 945
 946   /* If IDENT contains invalid UTF-8 sequences (which may occur with
 947      attributes putting arbitrary byte sequences in identifiers), or
 948      control characters, we use octal escape sequences for all bytes
 949      outside printable ASCII.  */
 950   if (!valid_printable_utf8)
 951     {
 952       char *ret = (char *) identifier_to_locale_alloc (4 * idlen + 1);
 953       char *p = ret;
 954       for (i = 0; i < idlen; i++)
 955         {
 956           if (uid[i] > 0x1F && uid[i] < 0x7F)
 957             *p++ = uid[i];
 958           else
 959             {
 960               sprintf (p, "\\%03o", uid[i]);
 961               p += 4;
 962             }
 963         }
 964       *p = 0;
 965       return ret;
 966     }
 967
 968   /* Otherwise, if it is valid printable ASCII, or printable UTF-8
 969      with the locale character set being UTF-8, IDENT is used.  */
 970   if (all_ascii || locale_utf8)
 971     return ident;
 972
 973   /* Otherwise IDENT is converted to the locale character set if
 974      possible.  */
 975 #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
 976   if (locale_encoding != NULL)
 977     {
 978       iconv_t cd = iconv_open (locale_encoding, "UTF-8");
 979       bool conversion_ok = true;
 980       char *ret = NULL;
 981       if (cd != (iconv_t) -1)
 982         {
 983           size_t ret_alloc = 4 * idlen + 1;
 984           for (;;)
 985             {
 986               /* Repeat the whole conversion process as needed with
 987                  larger buffers so non-reversible transformations can
 988                  always be detected.  */
 989               ICONV_CONST char *inbuf = CONST_CAST (char *, ident);
 990               char *outbuf;
 991               size_t inbytesleft = idlen;
 992               size_t outbytesleft = ret_alloc - 1;
 993               size_t iconv_ret;
 994
 995               ret = (char *) identifier_to_locale_alloc (ret_alloc);
 996               outbuf = ret;
 997
 998               if (iconv (cd, 0, 0, 0, 0) == (size_t) -1)
 999                 {
1000                   conversion_ok = false;
1001                   break;
1002                 }
1003
1004               iconv_ret = iconv (cd, &inbuf, &inbytesleft,
1005                                  &outbuf, &outbytesleft);
1006               if (iconv_ret == (size_t) -1 || inbytesleft != 0)
1007                 {
1008                   if (errno == E2BIG)
1009                     {
1010                       ret_alloc *= 2;
1011                       identifier_to_locale_free (ret);
1012                       ret = NULL;
1013                       continue;
1014                     }
1015                   else
1016                     {
1017                       conversion_ok = false;
1018                       break;
1019                     }
1020                 }
1021               else if (iconv_ret != 0)
1022                 {
1023                   conversion_ok = false;
1024                   break;
1025                 }
1026               /* Return to initial shift state.  */
1027               if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t) -1)
1028                 {
1029                   if (errno == E2BIG)
1030                     {
1031                       ret_alloc *= 2;
1032                       identifier_to_locale_free (ret);
1033                       ret = NULL;
1034                       continue;
1035                     }
1036                   else
1037                     {
1038                       conversion_ok = false;
1039                       break;
1040                     }
1041                 }
1042               *outbuf = 0;
1043               break;
1044             }
1045           iconv_close (cd);
1046           if (conversion_ok)
1047             return ret;
1048         }
1049     }
1050 #endif
1051
1052   /* Otherwise, convert non-ASCII characters in IDENT to UCNs.  */
1053   {
1054     char *ret = (char *) identifier_to_locale_alloc (10 * idlen + 1);
1055     char *p = ret;
1056     for (i = 0; i < idlen;)
1057       {
1058         unsigned int c;
1059         size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
1060         if (utf8_len == 1)
1061           *p++ = uid[i];
1062         else
1063           {
1064             sprintf (p, "\\U%08x", c);
1065             p += 10;
1066           }
1067         i += utf8_len;
1068       }
1069     *p = 0;
1070     return ret;
1071   }
1072 }