gcc/pretty-print.c

   1 /* Various declarations for language-independent pretty-print subroutines.
   2    Copyright (C) 2003, 2004 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 2, 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 COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #undef FLOAT /* This is for hpux. They should change hpux.  */
  24 #undef FFS  /* Some systems define this in param.h.  */
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "intl.h"
  28 #include "pretty-print.h"
  29
  30 #define obstack_chunk_alloc xmalloc
  31 #define obstack_chunk_free  free
  32
  33 /* A pointer to the formatted diagnostic message.  */
  34 #define pp_formatted_text_data(PP) \
  35    ((const char *) obstack_base (&pp_base (PP)->buffer->obstack))
  36
  37 /* Format an integer given by va_arg (ARG, type-specifier T) where
  38    type-specifier is a precision modifier as indicated by PREC.  F is
  39    a string used to construct the appropriate format-specifier.  */
  40 #define pp_integer_with_precision(PP, ARG, PREC, T, F)       \
  41   do                                                         \
  42     switch (PREC)                                            \
  43       {                                                      \
  44       case 0:                                                \
  45         pp_scalar (PP, "%" F, va_arg (ARG, T));              \
  46         break;                                               \
  47                                                              \
  48       case 1:                                                \
  49         pp_scalar (PP, "%l" F, va_arg (ARG, long T));        \
  50         break;                                               \
  51                                                              \
  52       case 2:                                                \
  53         pp_scalar (PP, "%ll" F, va_arg (ARG, long long T));  \
  54         break;                                               \
  55                                                              \
  56       default:                                               \
  57         break;                                               \
  58       }                                                      \
  59   while (0)
  60
  61
  62 /* Subroutine of pp_set_maximum_length.  Set up PRETTY-PRINTER's
  63    internal maximum characters per line.  */
  64 static void
  65 pp_set_real_maximum_length (pretty_printer *pp)
  66 {
  67   /* If we're told not to wrap lines then do the obvious thing.  In case
  68      we'll emit prefix only once per message, it is appropriate
  69      not to increase unnecessarily the line-length cut-off.  */
  70   if (!pp_is_wrapping_line (pp)
  71       || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_ONCE
  72       || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
  73     pp->maximum_length = pp_line_cutoff (pp);
  74   else
  75     {
  76       int prefix_length = pp->prefix ? strlen (pp->prefix) : 0;
  77       /* If the prefix is ridiculously too long, output at least
  78          32 characters.  */
  79       if (pp_line_cutoff (pp) - prefix_length < 32)
  80         pp->maximum_length = pp_line_cutoff (pp) + 32;
  81       else
  82         pp->maximum_length = pp_line_cutoff (pp);
  83     }
  84 }
  85
  86 /* Clear PRETTY-PRINTER's output state.  */
  87 static inline void
  88 pp_clear_state (pretty_printer *pp)
  89 {
  90   pp->emitted_prefix = false;
  91   pp_indentation (pp) = 0;
  92 }
  93
  94 /* Flush the formatted text of PRETTY-PRINTER onto the attached stream.  */
  95 void
  96 pp_write_text_to_stream (pretty_printer *pp)
  97 {
  98   const char *text = pp_formatted_text (pp);
  99   fputs (text, pp->buffer->stream);
 100   pp_clear_output_area (pp);
 101 }
 102
 103 /* Wrap a text delimited by START and END into PRETTY-PRINTER.  */
 104 static void
 105 pp_wrap_text (pretty_printer *pp, const char *start, const char *end)
 106 {
 107   bool wrapping_line = pp_is_wrapping_line (pp);
 108
 109   while (start != end)
 110     {
 111       /* Dump anything bordered by whitespaces.  */
 112       {
 113         const char *p = start;
 114         while (p != end && !ISBLANK (*p) && *p != '\n')
 115           ++p;
 116         if (wrapping_line
 117             && p - start >= pp_remaining_character_count_for_line (pp))
 118           pp_newline (pp);
 119         pp_append_text (pp, start, p);
 120         start = p;
 121       }
 122
 123       if (start != end && ISBLANK (*start))
 124         {
 125           pp_space (pp);
 126           ++start;
 127         }
 128       if (start != end && *start == '\n')
 129         {
 130           pp_newline (pp);
 131           ++start;
 132         }
 133     }
 134 }
 135
 136 /* Same as pp_wrap_text but wrap text only when in line-wrapping mode.  */
 137 static inline void
 138 pp_maybe_wrap_text (pretty_printer *pp, const char *start, const char *end)
 139 {
 140   if (pp_is_wrapping_line (pp))
 141     pp_wrap_text (pp, start, end);
 142   else
 143     pp_append_text (pp, start, end);
 144 }
 145
 146 /* Append to the output area of PRETTY-PRINTER a string specified by its
 147    STARTing character and LENGTH.  */
 148 static inline void
 149 pp_append_r (pretty_printer *pp, const char *start, int length)
 150 {
 151   obstack_grow (&pp->buffer->obstack, start, length);
 152   pp->buffer->line_length += length;
 153 }
 154
 155 /* Insert enough spaces into the output area of PRETTY-PRINTER to bring
 156    the column position to the current indentation level, assuming that a
 157    newline has just been written to the buffer.  */
 158 void
 159 pp_base_indent (pretty_printer *pp)
 160 {
 161   int n = pp_indentation (pp);
 162   int i;
 163
 164   for (i = 0; i < n; ++i)
 165     pp_space (pp);
 166 }
 167
 168 /* Format a message pointed to by TEXT.  The following format specifiers are
 169    recognized as being client independent:
 170    %d, %i: (signed) integer in base ten.
 171    %u: unsigned integer in base ten.
 172    %o: unsigned integer in base eight.
 173    %x: unsigned integer in base sixteen.
 174    %ld, %li, %lo, %lu, %lx: long versions of the above.
 175    %lld, %lli, %llo, %llu, %llx: long long versions.
 176    %wd, %wi, %wo, %wu, %wx: HOST_WIDE_INT versions.
 177    %c: character.
 178    %s: string.
 179    %p: pointer.
 180    %m: strerror(text->err_no) - does not consume a value from args_ptr.
 181    %%: '%'.
 182    %<: opening quote.
 183    %>: closing quote.
 184    %': apostrophe (should only be used in untranslated messages;
 185        translations should use appropriate punctuation directly).
 186    %.*s: a substring the length of which is specified by an integer.
 187    %H: location_t.
 188    Flag 'q': quote formatted text (must come immediately after '%').  */
 189 void
 190 pp_base_format_text (pretty_printer *pp, text_info *text)
 191 {
 192   for (; *text->format_spec; ++text->format_spec)
 193     {
 194       int precision = 0;
 195       bool wide = false;
 196       bool quoted = false;
 197
 198       /* Ignore text.  */
 199       {
 200         const char *p = text->format_spec;
 201         while (*p && *p != '%')
 202           ++p;
 203         pp_wrap_text (pp, text->format_spec, p);
 204         text->format_spec = p;
 205       }
 206
 207       if (*text->format_spec == '\0')
 208         break;
 209
 210       /* We got a '%'.  Check for 'q', then parse precision modifiers,
 211          if any.  */
 212       if (*++text->format_spec == 'q')
 213         {
 214           quoted = true;
 215           ++text->format_spec;
 216         }
 217       switch (*text->format_spec)
 218         {
 219         case 'w':
 220           wide = true;
 221           ++text->format_spec;
 222           break;
 223
 224         case 'l':
 225           do
 226             ++precision;
 227           while (*++text->format_spec == 'l');
 228           break;
 229
 230         default:
 231           break;
 232         }
 233       /* We don't support precision beyond that of "long long".  */
 234       if (precision > 2)
 235         abort();
 236
 237       if (quoted)
 238         pp_string (pp, open_quote);
 239       switch (*text->format_spec)
 240         {
 241         case 'c':
 242           pp_character (pp, va_arg (*text->args_ptr, int));
 243           break;
 244
 245         case 'd':
 246         case 'i':
 247           if (wide)
 248             pp_wide_integer (pp, va_arg (*text->args_ptr, HOST_WIDE_INT));
 249           else
 250             pp_integer_with_precision
 251               (pp, *text->args_ptr, precision, int, "d");
 252           break;
 253
 254         case 'o':
 255           if (wide)
 256             pp_scalar (pp, "%" HOST_WIDE_INT_PRINT "o",
 257                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 258           else
 259             pp_integer_with_precision
 260               (pp, *text->args_ptr, precision, unsigned, "u");
 261           break;
 262
 263         case 's':
 264           pp_string (pp, va_arg (*text->args_ptr, const char *));
 265           break;
 266
 267         case 'p':
 268           pp_pointer (pp, va_arg (*text->args_ptr, void *));
 269           break;
 270
 271         case 'u':
 272           if (wide)
 273             pp_scalar (pp, HOST_WIDE_INT_PRINT_UNSIGNED,
 274                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 275           else
 276             pp_integer_with_precision
 277               (pp, *text->args_ptr, precision, unsigned, "u");
 278           break;
 279
 280         case 'x':
 281           if (wide)
 282             pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
 283                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
 284           else
 285             pp_integer_with_precision
 286               (pp, *text->args_ptr, precision, unsigned, "x");
 287           break;
 288
 289         case 'm':
 290           pp_string (pp, xstrerror (text->err_no));
 291           break;
 292
 293         case '%':
 294           pp_character (pp, '%');
 295           break;
 296
 297         case '<':
 298           pp_string (pp, open_quote);
 299           break;
 300
 301         case '>':
 302         case '\'':
 303           pp_string (pp, close_quote);
 304           break;
 305
 306         case 'H':
 307           {
 308             const location_t *locus = va_arg (*text->args_ptr, location_t *);
 309             pp_string (pp, "file '");
 310             pp_string (pp, locus->file);
 311             pp_string (pp, "', line ");
 312             pp_decimal_int (pp, locus->line);
 313           }
 314           break;
 315
 316         case '.':
 317           {
 318             int n;
 319             const char *s;
 320             /* We handle no precision specifier but '%.*s'.  */
 321             if (*++text->format_spec != '*')
 322               abort ();
 323             else if (*++text->format_spec != 's')
 324               abort ();
 325             n = va_arg (*text->args_ptr, int);
 326             s = va_arg (*text->args_ptr, const char *);
 327             pp_append_text (pp, s, s + n);
 328           }
 329           break;
 330
 331         default:
 332           if (!pp_format_decoder (pp) || !(*pp_format_decoder (pp)) (pp, text))
 333             {
 334               /* Hmmm.  The client failed to install a format translator
 335                  but called us with an unrecognized format.  Or, maybe, the
 336                  translated string just contains an invalid format, or
 337                  has formats in the wrong order.  Sorry.  */
 338               abort ();
 339             }
 340         }
 341       if (quoted)
 342         pp_string (pp, close_quote);
 343     }
 344 }
 345
 346 /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
 347    settings needed by BUFFER for a verbatim formatting.  */
 348 void
 349 pp_base_format_verbatim (pretty_printer *pp, text_info *text)
 350 {
 351   diagnostic_prefixing_rule_t rule = pp_prefixing_rule (pp);
 352   int line_cutoff = pp_line_cutoff (pp);
 353
 354   /* Set verbatim mode.  */
 355   pp->prefixing_rule = DIAGNOSTICS_SHOW_PREFIX_NEVER;
 356   pp_line_cutoff (pp) = 0;
 357   /* Do the actual formatting.  */
 358   pp_format_text (pp, text);
 359   /* Restore previous settings.  */
 360   pp_prefixing_rule (pp) = rule;
 361   pp_line_cutoff (pp) = line_cutoff;
 362 }
 363
 364 /* Flush the content of BUFFER onto the attached stream.  */
 365 void
 366 pp_base_flush (pretty_printer *pp)
 367 {
 368   pp_write_text_to_stream (pp);
 369   pp_clear_state (pp);
 370   fputc ('\n', pp->buffer->stream);
 371   fflush (pp->buffer->stream);
 372   pp_needs_newline (pp) = false;
 373 }
 374
 375 /* Sets the number of maximum characters per line PRETTY-PRINTER can
 376    output in line-wrapping mode.  A LENGTH value 0 suppresses
 377    line-wrapping.  */
 378 void
 379 pp_base_set_line_maximum_length (pretty_printer *pp, int length)
 380 {
 381   pp_line_cutoff (pp) = length;
 382   pp_set_real_maximum_length (pp);
 383 }
 384
 385 /* Clear PRETTY-PRINTER output area text info.  */
 386 void
 387 pp_base_clear_output_area (pretty_printer *pp)
 388 {
 389   obstack_free (&pp->buffer->obstack, obstack_base (&pp->buffer->obstack));
 390   pp->buffer->line_length = 0;
 391 }
 392
 393 /* Set PREFIX for PRETTY-PRINTER.  */
 394 void
 395 pp_base_set_prefix (pretty_printer *pp, const char *prefix)
 396 {
 397   pp->prefix = prefix;
 398   pp_set_real_maximum_length (pp);
 399   pp->emitted_prefix = false;
 400   pp_indentation (pp) = 0;
 401 }
 402
 403 /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string.  */
 404 void
 405 pp_base_destroy_prefix (pretty_printer *pp)
 406 {
 407   if (pp->prefix != NULL)
 408     {
 409       free ((char *) pp->prefix);
 410       pp->prefix = NULL;
 411     }
 412 }
 413
 414 /* Write out PRETTY-PRINTER's prefix.  */
 415 void
 416 pp_base_emit_prefix (pretty_printer *pp)
 417 {
 418   if (pp->prefix != NULL)
 419     {
 420       switch (pp_prefixing_rule (pp))
 421         {
 422         default:
 423         case DIAGNOSTICS_SHOW_PREFIX_NEVER:
 424           break;
 425
 426         case DIAGNOSTICS_SHOW_PREFIX_ONCE:
 427           if (pp->emitted_prefix)
 428             {
 429               pp_base_indent (pp);
 430               break;
 431             }
 432           pp_indentation (pp) += 3;
 433           /* Fall through.  */
 434
 435         case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
 436           {
 437             int prefix_length = strlen (pp->prefix);
 438             pp_append_r (pp, pp->prefix, prefix_length);
 439             pp->emitted_prefix = true;
 440           }
 441           break;
 442         }
 443     }
 444 }
 445
 446 /* Construct a PRETTY-PRINTER with PREFIX and of MAXIMUM_LENGTH
 447    characters per line.  */
 448 void
 449 pp_construct (pretty_printer *pp, const char *prefix, int maximum_length)
 450 {
 451   memset (pp, 0, sizeof (pretty_printer));
 452   pp->buffer = xcalloc (1, sizeof (output_buffer));
 453   obstack_init (&pp->buffer->obstack);
 454   pp->buffer->stream = stderr;
 455   pp_line_cutoff (pp) = maximum_length;
 456   pp_prefixing_rule (pp) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 457   pp_set_prefix (pp, prefix);
 458 }
 459
 460 /* Append a string delimited by START and END to the output area of
 461    PRETTY-PRINTER.  No line wrapping is done.  However, if beginning a
 462    new line then emit PRETTY-PRINTER's prefix and skip any leading
 463    whitespace if appropriate.  The caller must ensure that it is
 464    safe to do so.  */
 465 void
 466 pp_base_append_text (pretty_printer *pp, const char *start, const char *end)
 467 {
 468   /* Emit prefix and skip whitespace if we're starting a new line.  */
 469   if (pp->buffer->line_length == 0)
 470     {
 471       pp_emit_prefix (pp);
 472       if (pp_is_wrapping_line (pp))
 473         while (start != end && *start == ' ')
 474           ++start;
 475     }
 476   pp_append_r (pp, start, end - start);
 477 }
 478
 479 /* Finishes constructing a NULL-terminated character string representing
 480    the PRETTY-PRINTED text.  */
 481 const char *
 482 pp_base_formatted_text (pretty_printer *pp)
 483 {
 484   obstack_1grow (&pp->buffer->obstack, '\0');
 485   return pp_formatted_text_data (pp);
 486 }
 487
 488 /*  Return a pointer to the last character emitted in PRETTY-PRINTER's
 489     output area.  A NULL pointer means no character available.  */
 490 const char *
 491 pp_base_last_position_in_text (const pretty_printer *pp)
 492 {
 493   const char *p = NULL;
 494   struct obstack *text = &pp->buffer->obstack;
 495
 496   if (obstack_base (text) != obstack_next_free (text))
 497     p = ((const char *) obstack_next_free (text)) - 1;
 498   return p;
 499 }
 500
 501 /* Return the amount of characters PRETTY-PRINTER can accept to
 502    make a full line.  Meaningful only in line-wrapping mode.  */
 503 int
 504 pp_base_remaining_character_count_for_line (pretty_printer *pp)
 505 {
 506   return pp->maximum_length - pp->buffer->line_length;
 507 }
 508
 509
 510 /* Format a message into BUFFER a la printf.  */
 511 void
 512 pp_printf (pretty_printer *pp, const char *msg, ...)
 513 {
 514   text_info text;
 515   va_list ap;
 516
 517   va_start (ap, msg);
 518   text.err_no = errno;
 519   text.args_ptr = &ap;
 520   text.format_spec = msg;
 521   pp_format_text (pp, &text);
 522   va_end (ap);
 523 }
 524
 525
 526 /* Output MESSAGE verbatim into BUFFER.  */
 527 void
 528 pp_verbatim (pretty_printer *pp, const char *msg, ...)
 529 {
 530   text_info text;
 531   va_list ap;
 532
 533   va_start (ap, msg);
 534   text.err_no = errno;
 535   text.args_ptr = &ap;
 536   text.format_spec = msg;
 537   pp_format_verbatim (pp, &text);
 538   va_end (ap);
 539 }
 540
 541
 542
 543 /* Have PRETTY-PRINTER start a new line.  */
 544 void
 545 pp_base_newline (pretty_printer *pp)
 546 {
 547   obstack_1grow (&pp->buffer->obstack, '\n');
 548   pp->buffer->line_length = 0;
 549 }
 550
 551 /* Have PRETTY-PRINTER add a CHARACTER.  */
 552 void
 553 pp_base_character (pretty_printer *pp, int c)
 554 {
 555   if (pp_is_wrapping_line (pp)
 556       && pp_remaining_character_count_for_line (pp) <= 0)
 557     {
 558       pp_newline (pp);
 559       if (ISSPACE (c))
 560         return;
 561     }
 562   obstack_1grow (&pp->buffer->obstack, c);
 563   ++pp->buffer->line_length;
 564 }
 565
 566 /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
 567    be line-wrapped if in appropriate mode.  */
 568 void
 569 pp_base_string (pretty_printer *pp, const char *str)
 570 {
 571   pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0));
 572 }
 573
 574 /* Maybe print out a whitespace if needed.   */
 575
 576 void
 577 pp_base_maybe_space (pretty_printer *pp)
 578 {
 579   if (pp_base (pp)->padding != pp_none)
 580     {
 581       pp_space (pp);
 582       pp_base (pp)->padding = pp_none;
 583     }
 584 }