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