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