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