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