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