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   pp_format (pp, &text);
 857   pp_output_formatted_text (pp);
 858   va_end (ap);
 859 }
 860
 861
 862 /* Output MESSAGE verbatim into BUFFER.  */
 863 void
 864 pp_verbatim (pretty_printer *pp, const char *msg, ...)
 865 {
 866   text_info text;
 867   va_list ap;
 868
 869   va_start (ap, msg);
 870   text.err_no = errno;
 871   text.args_ptr = &ap;
 872   text.format_spec = msg;
 873   pp_format_verbatim (pp, &text);
 874   va_end (ap);
 875 }
 876
 877
 878
 879 /* Have PRETTY-PRINTER start a new line.  */
 880 void
 881 pp_newline (pretty_printer *pp)
 882 {
 883   obstack_1grow (pp_buffer (pp)->obstack, '\n');
 884   pp_needs_newline (pp) = false;
 885   pp_buffer (pp)->line_length = 0;
 886 }
 887
 888 /* Have PRETTY-PRINTER add a CHARACTER.  */
 889 void
 890 pp_character (pretty_printer *pp, int c)
 891 {
 892   if (pp_is_wrapping_line (pp)
 893       && pp_remaining_character_count_for_line (pp) <= 0)
 894     {
 895       pp_newline (pp);
 896       if (ISSPACE (c))
 897         return;
 898     }
 899   obstack_1grow (pp_buffer (pp)->obstack, c);
 900   ++pp_buffer (pp)->line_length;
 901 }
 902
 903 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
 904    be line-wrapped if in appropriate mode.  */
 905 void
 906 pp_string (pretty_printer *pp, const char *str)
 907 {
 908   pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
 909 }
 910
 911 /* Maybe print out a whitespace if needed.  */
 912
 913 void
 914 pp_maybe_space (pretty_printer *pp)
 915 {
 916   if (pp->padding != pp_none)
 917     {
 918       pp_space (pp);
 919       pp->padding = pp_none;
 920     }
 921 }
 922
 923 // Add a newline to the pretty printer PP and flush formatted text.
 924
 925 void
 926 pp_newline_and_flush (pretty_printer *pp)
 927 {
 928   pp_newline (pp);
 929   pp_flush (pp);
 930   pp_needs_newline (pp) = false;
 931 }
 932
 933 // Add a newline to the pretty printer PP, followed by indentation.
 934
 935 void
 936 pp_newline_and_indent (pretty_printer *pp, int n)
 937 {
 938   pp_indentation (pp) += n;
 939   pp_newline (pp);
 940   pp_indent (pp);
 941   pp_needs_newline (pp) = false;
 942 }
 943
 944 // Add separator C, followed by a single whitespace.
 945
 946 void
 947 pp_separate_with (pretty_printer *pp, char c)
 948 {
 949   pp_character (pp, c);
 950   pp_space (pp);
 951 }
 952
 953 \f
 954 /* The string starting at P has LEN (at least 1) bytes left; if they
 955    start with a valid UTF-8 sequence, return the length of that
 956    sequence and set *VALUE to the value of that sequence, and
 957    otherwise return 0 and set *VALUE to (unsigned int) -1.  */
 958
 959 static int
 960 decode_utf8_char (const unsigned char *p, size_t len, unsigned int *value)
 961 {
 962   unsigned int t = *p;
 963
 964   if (len == 0)
 965     abort ();
 966   if (t & 0x80)
 967     {
 968       size_t utf8_len = 0;
 969       unsigned int ch;
 970       size_t i;
 971       for (t = *p; t & 0x80; t <<= 1)
 972         utf8_len++;
 973
 974       if (utf8_len > len || utf8_len < 2 || utf8_len > 6)
 975         {
 976           *value = (unsigned int) -1;
 977           return 0;
 978         }
 979       ch = *p & ((1 << (7 - utf8_len)) - 1);
 980       for (i = 1; i < utf8_len; i++)
 981         {
 982           unsigned int u = p[i];
 983           if ((u & 0xC0) != 0x80)
 984             {
 985               *value = (unsigned int) -1;
 986               return 0;
 987             }
 988           ch = (ch << 6) | (u & 0x3F);
 989         }
 990       if (   (ch <=      0x7F && utf8_len > 1)
 991           || (ch <=     0x7FF && utf8_len > 2)
 992           || (ch <=    0xFFFF && utf8_len > 3)
 993           || (ch <=  0x1FFFFF && utf8_len > 4)
 994           || (ch <= 0x3FFFFFF && utf8_len > 5)
 995           || (ch >= 0xD800 && ch <= 0xDFFF))
 996         {
 997           *value = (unsigned int) -1;
 998           return 0;
 999         }
1000       *value = ch;
1001       return utf8_len;
1002     }
1003   else
1004     {
1005       *value = t;
1006       return 1;
1007     }
1008 }
1009
1010 /* Allocator for identifier_to_locale and corresponding function to
1011    free memory.  */
1012
1013 void *(*identifier_to_locale_alloc) (size_t) = xmalloc;
1014 void (*identifier_to_locale_free) (void *) = free;
1015
1016 /* Given IDENT, an identifier in the internal encoding, return a
1017    version of IDENT suitable for diagnostics in the locale character
1018    set: either IDENT itself, or a string, allocated using
1019    identifier_to_locale_alloc, converted to the locale character set
1020    and using escape sequences if not representable in the locale
1021    character set or containing control characters or invalid byte
1022    sequences.  Existing backslashes in IDENT are not doubled, so the
1023    result may not uniquely specify the contents of an arbitrary byte
1024    sequence identifier.  */
1025
1026 const char *
1027 identifier_to_locale (const char *ident)
1028 {
1029   const unsigned char *uid = (const unsigned char *) ident;
1030   size_t idlen = strlen (ident);
1031   bool valid_printable_utf8 = true;
1032   bool all_ascii = true;
1033   size_t i;
1034
1035   for (i = 0; i < idlen;)
1036     {
1037       unsigned int c;
1038       size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
1039       if (utf8_len == 0 || c <= 0x1F || (c >= 0x7F && c <= 0x9F))
1040         {
1041           valid_printable_utf8 = false;
1042           break;
1043         }
1044       if (utf8_len > 1)
1045         all_ascii = false;
1046       i += utf8_len;
1047     }
1048
1049   /* If IDENT contains invalid UTF-8 sequences (which may occur with
1050      attributes putting arbitrary byte sequences in identifiers), or
1051      control characters, we use octal escape sequences for all bytes
1052      outside printable ASCII.  */
1053   if (!valid_printable_utf8)
1054     {
1055       char *ret = (char *) identifier_to_locale_alloc (4 * idlen + 1);
1056       char *p = ret;
1057       for (i = 0; i < idlen; i++)
1058         {
1059           if (uid[i] > 0x1F && uid[i] < 0x7F)
1060             *p++ = uid[i];
1061           else
1062             {
1063               sprintf (p, "\\%03o", uid[i]);
1064               p += 4;
1065             }
1066         }
1067       *p = 0;
1068       return ret;
1069     }
1070
1071   /* Otherwise, if it is valid printable ASCII, or printable UTF-8
1072      with the locale character set being UTF-8, IDENT is used.  */
1073   if (all_ascii || locale_utf8)
1074     return ident;
1075
1076   /* Otherwise IDENT is converted to the locale character set if
1077      possible.  */
1078 #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
1079   if (locale_encoding != NULL)
1080     {
1081       iconv_t cd = iconv_open (locale_encoding, "UTF-8");
1082       bool conversion_ok = true;
1083       char *ret = NULL;
1084       if (cd != (iconv_t) -1)
1085         {
1086           size_t ret_alloc = 4 * idlen + 1;
1087           for (;;)
1088             {
1089               /* Repeat the whole conversion process as needed with
1090                  larger buffers so non-reversible transformations can
1091                  always be detected.  */
1092               ICONV_CONST char *inbuf = CONST_CAST (char *, ident);
1093               char *outbuf;
1094               size_t inbytesleft = idlen;
1095               size_t outbytesleft = ret_alloc - 1;
1096               size_t iconv_ret;
1097
1098               ret = (char *) identifier_to_locale_alloc (ret_alloc);
1099               outbuf = ret;
1100
1101               if (iconv (cd, 0, 0, 0, 0) == (size_t) -1)
1102                 {
1103                   conversion_ok = false;
1104                   break;
1105                 }
1106
1107               iconv_ret = iconv (cd, &inbuf, &inbytesleft,
1108                                  &outbuf, &outbytesleft);
1109               if (iconv_ret == (size_t) -1 || inbytesleft != 0)
1110                 {
1111                   if (errno == E2BIG)
1112                     {
1113                       ret_alloc *= 2;
1114                       identifier_to_locale_free (ret);
1115                       ret = NULL;
1116                       continue;
1117                     }
1118                   else
1119                     {
1120                       conversion_ok = false;
1121                       break;
1122                     }
1123                 }
1124               else if (iconv_ret != 0)
1125                 {
1126                   conversion_ok = false;
1127                   break;
1128                 }
1129               /* Return to initial shift state.  */
1130               if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t) -1)
1131                 {
1132                   if (errno == E2BIG)
1133                     {
1134                       ret_alloc *= 2;
1135                       identifier_to_locale_free (ret);
1136                       ret = NULL;
1137                       continue;
1138                     }
1139                   else
1140                     {
1141                       conversion_ok = false;
1142                       break;
1143                     }
1144                 }
1145               *outbuf = 0;
1146               break;
1147             }
1148           iconv_close (cd);
1149           if (conversion_ok)
1150             return ret;
1151         }
1152     }
1153 #endif
1154
1155   /* Otherwise, convert non-ASCII characters in IDENT to UCNs.  */
1156   {
1157     char *ret = (char *) identifier_to_locale_alloc (10 * idlen + 1);
1158     char *p = ret;
1159     for (i = 0; i < idlen;)
1160       {
1161         unsigned int c;
1162         size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
1163         if (utf8_len == 1)
1164           *p++ = uid[i];
1165         else
1166           {
1167             sprintf (p, "\\U%08x", c);
1168             p += 10;
1169           }
1170         i += utf8_len;
1171       }
1172     *p = 0;
1173     return ret;
1174   }
1175 }