gcc/pretty-print.c

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