gcc/pretty-print.c

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