gcc/pretty-print.c

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