gcc/pretty-print.c

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