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