gcc/pretty-print.c

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