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 }
 723
 724 /* Append a string delimited by START and END to the output area of
 725    PRETTY-PRINTER.  No line wrapping is done.  However, if beginning a
 726    new line then emit PRETTY-PRINTER's prefix and skip any leading
 727    whitespace if appropriate.  The caller must ensure that it is
 728    safe to do so.  */
 729 void
 730 pp_base_append_text (pretty_printer *pp, const char *start, const char *end)
 731 {
 732   /* Emit prefix and skip whitespace if we're starting a new line.  */
 733   if (pp->buffer->line_length == 0)
 734     {
 735       pp_emit_prefix (pp);
 736       if (pp_is_wrapping_line (pp))
 737         while (start != end && *start == ' ')
 738           ++start;
 739     }
 740   pp_append_r (pp, start, end - start);
 741 }
 742
 743 /* Finishes constructing a NULL-terminated character string representing
 744    the PRETTY-PRINTED text.  */
 745 const char *
 746 pp_base_formatted_text (pretty_printer *pp)
 747 {
 748   obstack_1grow (pp->buffer->obstack, '\0');
 749   return pp_formatted_text_data (pp);
 750 }
 751
 752 /*  Return a pointer to the last character emitted in PRETTY-PRINTER's
 753     output area.  A NULL pointer means no character available.  */
 754 const char *
 755 pp_base_last_position_in_text (const pretty_printer *pp)
 756 {
 757   const char *p = NULL;
 758   struct obstack *text = pp->buffer->obstack;
 759
 760   if (obstack_base (text) != obstack_next_free (text))
 761     p = ((const char *) obstack_next_free (text)) - 1;
 762   return p;
 763 }
 764
 765 /* Return the amount of characters PRETTY-PRINTER can accept to
 766    make a full line.  Meaningful only in line-wrapping mode.  */
 767 int
 768 pp_base_remaining_character_count_for_line (pretty_printer *pp)
 769 {
 770   return pp->maximum_length - pp->buffer->line_length;
 771 }
 772
 773
 774 /* Format a message into BUFFER a la printf.  */
 775 void
 776 pp_printf (pretty_printer *pp, const char *msg, ...)
 777 {
 778   text_info text;
 779   va_list ap;
 780
 781   va_start (ap, msg);
 782   text.err_no = errno;
 783   text.args_ptr = &ap;
 784   text.format_spec = msg;
 785   text.locus = NULL;
 786   pp_format (pp, &text);
 787   pp_output_formatted_text (pp);
 788   va_end (ap);
 789 }
 790
 791
 792 /* Output MESSAGE verbatim into BUFFER.  */
 793 void
 794 pp_verbatim (pretty_printer *pp, const char *msg, ...)
 795 {
 796   text_info text;
 797   va_list ap;
 798
 799   va_start (ap, msg);
 800   text.err_no = errno;
 801   text.args_ptr = &ap;
 802   text.format_spec = msg;
 803   text.locus = NULL;
 804   pp_format_verbatim (pp, &text);
 805   va_end (ap);
 806 }
 807
 808
 809
 810 /* Have PRETTY-PRINTER start a new line.  */
 811 void
 812 pp_base_newline (pretty_printer *pp)
 813 {
 814   obstack_1grow (pp->buffer->obstack, '\n');
 815   pp->buffer->line_length = 0;
 816 }
 817
 818 /* Have PRETTY-PRINTER add a CHARACTER.  */
 819 void
 820 pp_base_character (pretty_printer *pp, int c)
 821 {
 822   if (pp_is_wrapping_line (pp)
 823       && pp_remaining_character_count_for_line (pp) <= 0)
 824     {
 825       pp_newline (pp);
 826       if (ISSPACE (c))
 827         return;
 828     }
 829   obstack_1grow (pp->buffer->obstack, c);
 830   ++pp->buffer->line_length;
 831 }
 832
 833 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
 834    be line-wrapped if in appropriate mode.  */
 835 void
 836 pp_base_string (pretty_printer *pp, const char *str)
 837 {
 838   pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
 839 }
 840
 841 /* Maybe print out a whitespace if needed.  */
 842
 843 void
 844 pp_base_maybe_space (pretty_printer *pp)
 845 {
 846   if (pp_base (pp)->padding != pp_none)
 847     {
 848       pp_space (pp);
 849       pp_base (pp)->padding = pp_none;
 850     }
 851 }
 852
 853 /* Print the identifier ID to PRETTY-PRINTER.  */
 854
 855 void
 856 pp_base_tree_identifier (pretty_printer *pp, tree id)
 857 {
 858   const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
 859   pp_append_text (pp, text, text + strlen (text));
 860 }
 861 \f
 862 /* The string starting at P has LEN (at least 1) bytes left; if they
 863    start with a valid UTF-8 sequence, return the length of that
 864    sequence and set *VALUE to the value of that sequence, and
 865    otherwise return 0 and set *VALUE to (unsigned int) -1.  */
 866
 867 static int
 868 decode_utf8_char (const unsigned char *p, size_t len, unsigned int *value)
 869 {
 870   unsigned int t = *p;
 871
 872   if (len == 0)
 873     abort ();
 874   if (t & 0x80)
 875     {
 876       size_t utf8_len = 0;
 877       unsigned int ch;
 878       size_t i;
 879       for (t = *p; t & 0x80; t <<= 1)
 880         utf8_len++;
 881
 882       if (utf8_len > len || utf8_len < 2 || utf8_len > 6)
 883         {
 884           *value = (unsigned int) -1;
 885           return 0;
 886         }
 887       ch = *p & ((1 << (7 - utf8_len)) - 1);
 888       for (i = 1; i < utf8_len; i++)
 889         {
 890           unsigned int u = p[i];
 891           if ((u & 0xC0) != 0x80)
 892             {
 893               *value = (unsigned int) -1;
 894               return 0;
 895             }
 896           ch = (ch << 6) | (u & 0x3F);
 897         }
 898       if (   (ch <=      0x7F && utf8_len > 1)
 899           || (ch <=     0x7FF && utf8_len > 2)
 900           || (ch <=    0xFFFF && utf8_len > 3)
 901           || (ch <=  0x1FFFFF && utf8_len > 4)
 902           || (ch <= 0x3FFFFFF && utf8_len > 5)
 903           || (ch >= 0xD800 && ch <= 0xDFFF))
 904         {
 905           *value = (unsigned int) -1;
 906           return 0;
 907         }
 908       *value = ch;
 909       return utf8_len;
 910     }
 911   else
 912     {
 913       *value = t;
 914       return 1;
 915     }
 916 }
 917
 918 /* Given IDENT, an identifier in the internal encoding, return a
 919    version of IDENT suitable for diagnostics in the locale character
 920    set: either IDENT itself, or a garbage-collected string converted
 921    to the locale character set and using escape sequences if not
 922    representable in the locale character set or containing control
 923    characters or invalid byte sequences.  Existing backslashes in
 924    IDENT are not doubled, so the result may not uniquely specify the
 925    contents of an arbitrary byte sequence identifier.  */
 926
 927 const char *
 928 identifier_to_locale (const char *ident)
 929 {
 930   const unsigned char *uid = (const unsigned char *) ident;
 931   size_t idlen = strlen (ident);
 932   bool valid_printable_utf8 = true;
 933   bool all_ascii = true;
 934   size_t i;
 935
 936   for (i = 0; i < idlen;)
 937     {
 938       unsigned int c;
 939       size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
 940       if (utf8_len == 0 || c <= 0x1F || (c >= 0x7F && c <= 0x9F))
 941         {
 942           valid_printable_utf8 = false;
 943           break;
 944         }
 945       if (utf8_len > 1)
 946         all_ascii = false;
 947       i += utf8_len;
 948     }
 949
 950   /* If IDENT contains invalid UTF-8 sequences (which may occur with
 951      attributes putting arbitrary byte sequences in identifiers), or
 952      control characters, we use octal escape sequences for all bytes
 953      outside printable ASCII.  */
 954   if (!valid_printable_utf8)
 955     {
 956       char *ret = GGC_NEWVEC (char, 4 * idlen + 1);
 957       char *p = ret;
 958       for (i = 0; i < idlen; i++)
 959         {
 960           if (uid[i] > 0x1F && uid[i] < 0x7F)
 961             *p++ = uid[i];
 962           else
 963             {
 964               sprintf (p, "\\%03o", uid[i]);
 965               p += 4;
 966             }
 967         }
 968       *p = 0;
 969       return ret;
 970     }
 971
 972   /* Otherwise, if it is valid printable ASCII, or printable UTF-8
 973      with the locale character set being UTF-8, IDENT is used.  */
 974   if (all_ascii || locale_utf8)
 975     return ident;
 976
 977   /* Otherwise IDENT is converted to the locale character set if
 978      possible.  */
 979 #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
 980   if (locale_encoding != NULL)
 981     {
 982       iconv_t cd = iconv_open (locale_encoding, "UTF-8");
 983       bool conversion_ok = true;
 984       char *ret = NULL;
 985       if (cd != (iconv_t) -1)
 986         {
 987           size_t ret_alloc = 4 * idlen + 1;
 988           for (;;)
 989             {
 990               /* Repeat the whole conversion process as needed with
 991                  larger buffers so non-reversible transformations can
 992                  always be detected.  */
 993               ICONV_CONST char *inbuf = CONST_CAST (char *, ident);
 994               char *outbuf;
 995               size_t inbytesleft = idlen;
 996               size_t outbytesleft = ret_alloc - 1;
 997               size_t iconv_ret;
 998
 999               ret = GGC_NEWVEC (char, ret_alloc);
1000               outbuf = ret;
1001
1002               if (iconv (cd, 0, 0, 0, 0) == (size_t) -1)
1003                 {
1004                   conversion_ok = false;
1005                   break;
1006                 }
1007
1008               iconv_ret = iconv (cd, &inbuf, &inbytesleft,
1009                                  &outbuf, &outbytesleft);
1010               if (iconv_ret == (size_t) -1 || inbytesleft != 0)
1011                 {
1012                   if (errno == E2BIG)
1013                     {
1014                       ret_alloc *= 2;
1015                       ggc_free (ret);
1016                       ret = NULL;
1017                       continue;
1018                     }
1019                   else
1020                     {
1021                       conversion_ok = false;
1022                       break;
1023                     }
1024                 }
1025               else if (iconv_ret != 0)
1026                 {
1027                   conversion_ok = false;
1028                   break;
1029                 }
1030               /* Return to initial shift state.  */
1031               if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t) -1)
1032                 {
1033                   if (errno == E2BIG)
1034                     {
1035                       ret_alloc *= 2;
1036                       ggc_free (ret);
1037                       ret = NULL;
1038                       continue;
1039                     }
1040                   else
1041                     {
1042                       conversion_ok = false;
1043                       break;
1044                     }
1045                 }
1046               *outbuf = 0;
1047               break;
1048             }
1049           iconv_close (cd);
1050           if (conversion_ok)
1051             return ret;
1052         }
1053     }
1054 #endif
1055
1056   /* Otherwise, convert non-ASCII characters in IDENT to UCNs.  */
1057   {
1058     char *ret = GGC_NEWVEC (char, 10 * idlen + 1);
1059     char *p = ret;
1060     for (i = 0; i < idlen;)
1061       {
1062         unsigned int c;
1063         size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
1064         if (utf8_len == 1)
1065           *p++ = uid[i];
1066         else
1067           {
1068             sprintf (p, "\\U%08x", c);
1069             p += 10;
1070           }
1071         i += utf8_len;
1072       }
1073     *p = 0;
1074     return ret;
1075   }
1076 }