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   if (CHECKING_P)
 629     for (; argno < PP_NL_ARGMAX; argno++)
 630       gcc_assert (!formatters[argno]);
 631
 632   /* Revert to normal obstack and wrapping mode.  */
 633   buffer->obstack = &buffer->formatted_obstack;
 634   buffer->line_length = 0;
 635   pp_wrapping_mode (pp) = old_wrapping_mode;
 636   pp_clear_state (pp);
 637 }
 638
 639 /* Format of a message pointed to by TEXT.  */
 640 void
 641 pp_output_formatted_text (pretty_printer *pp)
 642 {
 643   unsigned int chunk;
 644   output_buffer *buffer = pp_buffer (pp);
 645   struct chunk_info *chunk_array = buffer->cur_chunk_array;
 646   const char **args = chunk_array->args;
 647
 648   gcc_assert (buffer->obstack == &buffer->formatted_obstack);
 649   gcc_assert (buffer->line_length == 0);
 650
 651   /* This is a third phase, first 2 phases done in pp_format_args.
 652      Now we actually print it.  */
 653   for (chunk = 0; args[chunk]; chunk++)
 654     pp_string (pp, args[chunk]);
 655
 656   /* Deallocate the chunk structure and everything after it (i.e. the
 657      associated series of formatted strings).  */
 658   buffer->cur_chunk_array = chunk_array->prev;
 659   obstack_free (&buffer->chunk_obstack, chunk_array);
 660 }
 661
 662 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
 663    settings needed by BUFFER for a verbatim formatting.  */
 664 void
 665 pp_format_verbatim (pretty_printer *pp, text_info *text)
 666 {
 667   /* Set verbatim mode.  */
 668   pp_wrapping_mode_t oldmode = pp_set_verbatim_wrapping (pp);
 669
 670   /* Do the actual formatting.  */
 671   pp_format (pp, text);
 672   pp_output_formatted_text (pp);
 673
 674   /* Restore previous settings.  */
 675   pp_wrapping_mode (pp) = oldmode;
 676 }
 677
 678 /* Flush the content of BUFFER onto the attached stream.  This
 679    function does nothing unless pp->output_buffer->flush_p.  */
 680 void
 681 pp_flush (pretty_printer *pp)
 682 {
 683   pp_clear_state (pp);
 684   if (!pp->buffer->flush_p)
 685     return;
 686   pp_write_text_to_stream (pp);
 687   fflush (pp_buffer (pp)->stream);
 688 }
 689
 690 /* Flush the content of BUFFER onto the attached stream independently
 691    of the value of pp->output_buffer->flush_p.  */
 692 void
 693 pp_really_flush (pretty_printer *pp)
 694 {
 695   pp_clear_state (pp);
 696   pp_write_text_to_stream (pp);
 697   fflush (pp_buffer (pp)->stream);
 698 }
 699
 700 /* Sets the number of maximum characters per line PRETTY-PRINTER can
 701    output in line-wrapping mode.  A LENGTH value 0 suppresses
 702    line-wrapping.  */
 703 void
 704 pp_set_line_maximum_length (pretty_printer *pp, int length)
 705 {
 706   pp_line_cutoff (pp) = length;
 707   pp_set_real_maximum_length (pp);
 708 }
 709
 710 /* Clear PRETTY-PRINTER output area text info.  */
 711 void
 712 pp_clear_output_area (pretty_printer *pp)
 713 {
 714   obstack_free (pp_buffer (pp)->obstack,
 715                 obstack_base (pp_buffer (pp)->obstack));
 716   pp_buffer (pp)->line_length = 0;
 717 }
 718
 719 /* Set PREFIX for PRETTY-PRINTER.  */
 720 void
 721 pp_set_prefix (pretty_printer *pp, const char *prefix)
 722 {
 723   pp->prefix = prefix;
 724   pp_set_real_maximum_length (pp);
 725   pp->emitted_prefix = false;
 726   pp_indentation (pp) = 0;
 727 }
 728
 729 /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string.  */
 730 void
 731 pp_destroy_prefix (pretty_printer *pp)
 732 {
 733   if (pp->prefix != NULL)
 734     {
 735       free (CONST_CAST (char *, pp->prefix));
 736       pp->prefix = NULL;
 737     }
 738 }
 739
 740 /* Write out PRETTY-PRINTER's prefix.  */
 741 void
 742 pp_emit_prefix (pretty_printer *pp)
 743 {
 744   if (pp->prefix != NULL)
 745     {
 746       switch (pp_prefixing_rule (pp))
 747         {
 748         default:
 749         case DIAGNOSTICS_SHOW_PREFIX_NEVER:
 750           break;
 751
 752         case DIAGNOSTICS_SHOW_PREFIX_ONCE:
 753           if (pp->emitted_prefix)
 754             {
 755               pp_indent (pp);
 756               break;
 757             }
 758           pp_indentation (pp) += 3;
 759           /* Fall through.  */
 760
 761         case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
 762           {
 763             int prefix_length = strlen (pp->prefix);
 764             pp_append_r (pp, pp->prefix, prefix_length);
 765             pp->emitted_prefix = true;
 766           }
 767           break;
 768         }
 769     }
 770 }
 771
 772 /* Construct a PRETTY-PRINTER with PREFIX and of MAXIMUM_LENGTH
 773    characters per line.  */
 774
 775 pretty_printer::pretty_printer (const char *p, int l)
 776   : buffer (new (XCNEW (output_buffer)) output_buffer ()),
 777     prefix (),
 778     padding (pp_none),
 779     maximum_length (),
 780     indent_skip (),
 781     wrapping (),
 782     format_decoder (),
 783     emitted_prefix (),
 784     need_newline (),
 785     translate_identifiers (true),
 786     show_color ()
 787 {
 788   pp_line_cutoff (this) = l;
 789   /* By default, we emit prefixes once per message.  */
 790   pp_prefixing_rule (this) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 791   pp_set_prefix (this, p);
 792 }
 793
 794 pretty_printer::~pretty_printer ()
 795 {
 796   buffer->~output_buffer ();
 797   XDELETE (buffer);
 798 }
 799
 800 /* Append a string delimited by START and END to the output area of
 801    PRETTY-PRINTER.  No line wrapping is done.  However, if beginning a
 802    new line then emit PRETTY-PRINTER's prefix and skip any leading
 803    whitespace if appropriate.  The caller must ensure that it is
 804    safe to do so.  */
 805 void
 806 pp_append_text (pretty_printer *pp, const char *start, const char *end)
 807 {
 808   /* Emit prefix and skip whitespace if we're starting a new line.  */
 809   if (pp_buffer (pp)->line_length == 0)
 810     {
 811       pp_emit_prefix (pp);
 812       if (pp_is_wrapping_line (pp))
 813         while (start != end && *start == ' ')
 814           ++start;
 815     }
 816   pp_append_r (pp, start, end - start);
 817 }
 818
 819 /* Finishes constructing a NULL-terminated character string representing
 820    the PRETTY-PRINTED text.  */
 821 const char *
 822 pp_formatted_text (pretty_printer *pp)
 823 {
 824   return output_buffer_formatted_text (pp_buffer (pp));
 825 }
 826
 827 /*  Return a pointer to the last character emitted in PRETTY-PRINTER's
 828     output area.  A NULL pointer means no character available.  */
 829 const char *
 830 pp_last_position_in_text (const pretty_printer *pp)
 831 {
 832   return output_buffer_last_position_in_text (pp_buffer (pp));
 833 }
 834
 835 /* Return the amount of characters PRETTY-PRINTER can accept to
 836    make a full line.  Meaningful only in line-wrapping mode.  */
 837 int
 838 pp_remaining_character_count_for_line (pretty_printer *pp)
 839 {
 840   return pp->maximum_length - pp_buffer (pp)->line_length;
 841 }
 842
 843
 844 /* Format a message into BUFFER a la printf.  */
 845 void
 846 pp_printf (pretty_printer *pp, const char *msg, ...)
 847 {
 848   text_info text;
 849   va_list ap;
 850
 851   va_start (ap, msg);
 852   text.err_no = errno;
 853   text.args_ptr = &ap;
 854   text.format_spec = msg;
 855   pp_format (pp, &text);
 856   pp_output_formatted_text (pp);
 857   va_end (ap);
 858 }
 859
 860
 861 /* Output MESSAGE verbatim into BUFFER.  */
 862 void
 863 pp_verbatim (pretty_printer *pp, const char *msg, ...)
 864 {
 865   text_info text;
 866   va_list ap;
 867
 868   va_start (ap, msg);
 869   text.err_no = errno;
 870   text.args_ptr = &ap;
 871   text.format_spec = msg;
 872   pp_format_verbatim (pp, &text);
 873   va_end (ap);
 874 }
 875
 876
 877
 878 /* Have PRETTY-PRINTER start a new line.  */
 879 void
 880 pp_newline (pretty_printer *pp)
 881 {
 882   obstack_1grow (pp_buffer (pp)->obstack, '\n');
 883   pp_needs_newline (pp) = false;
 884   pp_buffer (pp)->line_length = 0;
 885 }
 886
 887 /* Have PRETTY-PRINTER add a CHARACTER.  */
 888 void
 889 pp_character (pretty_printer *pp, int c)
 890 {
 891   if (pp_is_wrapping_line (pp)
 892       && pp_remaining_character_count_for_line (pp) <= 0)
 893     {
 894       pp_newline (pp);
 895       if (ISSPACE (c))
 896         return;
 897     }
 898   obstack_1grow (pp_buffer (pp)->obstack, c);
 899   ++pp_buffer (pp)->line_length;
 900 }
 901
 902 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
 903    be line-wrapped if in appropriate mode.  */
 904 void
 905 pp_string (pretty_printer *pp, const char *str)
 906 {
 907   gcc_checking_assert (str);
 908   pp_maybe_wrap_text (pp, str, str + strlen (str));
 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 }