1/* Various declarations for language-independent pretty-print subroutines. 2 Copyright (C) 2003, 2004, 2005 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 2, 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 COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, 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#include "tree.h" 30 31#define obstack_chunk_alloc xmalloc 32#define obstack_chunk_free free 33 34/* A pointer to the formatted diagnostic message. */ 35#define pp_formatted_text_data(PP) \ 36 ((const char *) obstack_base (pp_base (PP)->buffer->obstack)) 37 38/* Format an integer given by va_arg (ARG, type-specifier T) where 39 type-specifier is a precision modifier as indicated by PREC. F is 40 a string used to construct the appropriate format-specifier. */ 41#define pp_integer_with_precision(PP, ARG, PREC, T, F) \ 42 do \ 43 switch (PREC) \ 44 { \ 45 case 0: \ 46 pp_scalar (PP, "%" F, va_arg (ARG, T)); \ 47 break; \ 48 \ 49 case 1: \ 50 pp_scalar (PP, "%l" F, va_arg (ARG, long T)); \ 51 break; \ 52 \ 53 case 2: \ 54 pp_scalar (PP, "%ll" F, va_arg (ARG, long long T)); \ 55 break; \ 56 \ 57 default: \ 58 break; \ 59 } \ 60 while (0) 61 62 63/* Subroutine of pp_set_maximum_length. Set up PRETTY-PRINTER's 64 internal maximum characters per line. */ 65static void 66pp_set_real_maximum_length (pretty_printer *pp) 67{ 68 /* If we're told not to wrap lines then do the obvious thing. In case 69 we'll emit prefix only once per message, it is appropriate 70 not to increase unnecessarily the line-length cut-off. */ 71 if (!pp_is_wrapping_line (pp) 72 || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_ONCE 73 || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_NEVER) 74 pp->maximum_length = pp_line_cutoff (pp); 75 else 76 { 77 int prefix_length = pp->prefix ? strlen (pp->prefix) : 0; 78 /* If the prefix is ridiculously too long, output at least 79 32 characters. */ 80 if (pp_line_cutoff (pp) - prefix_length < 32) 81 pp->maximum_length = pp_line_cutoff (pp) + 32; 82 else 83 pp->maximum_length = pp_line_cutoff (pp); 84 } 85} 86 87/* Clear PRETTY-PRINTER's output state. */ 88static inline void 89pp_clear_state (pretty_printer *pp) 90{ 91 pp->emitted_prefix = false; 92 pp_indentation (pp) = 0; 93} 94 95/* Flush the formatted text of PRETTY-PRINTER onto the attached stream. */ 96void 97pp_write_text_to_stream (pretty_printer *pp) 98{ 99 const char *text = pp_formatted_text (pp); 100 fputs (text, pp->buffer->stream); 101 pp_clear_output_area (pp); 102} 103 104/* Wrap a text delimited by START and END into PRETTY-PRINTER. */ 105static void 106pp_wrap_text (pretty_printer *pp, const char *start, const char *end) 107{ 108 bool wrapping_line = pp_is_wrapping_line (pp); 109 110 while (start != end) 111 { 112 /* Dump anything bordered by whitespaces. */ 113 { 114 const char *p = start; 115 while (p != end && !ISBLANK (*p) && *p != '\n') 116 ++p; 117 if (wrapping_line 118 && p - start >= pp_remaining_character_count_for_line (pp)) 119 pp_newline (pp); 120 pp_append_text (pp, start, p); 121 start = p; 122 } 123 124 if (start != end && ISBLANK (*start)) 125 { 126 pp_space (pp); 127 ++start; 128 } 129 if (start != end && *start == '\n') 130 { 131 pp_newline (pp); 132 ++start; 133 } 134 } 135} 136 137/* Same as pp_wrap_text but wrap text only when in line-wrapping mode. */ 138static inline void 139pp_maybe_wrap_text (pretty_printer *pp, const char *start, const char *end) 140{ 141 if (pp_is_wrapping_line (pp)) 142 pp_wrap_text (pp, start, end); 143 else 144 pp_append_text (pp, start, end); 145} 146 147/* Append to the output area of PRETTY-PRINTER a string specified by its 148 STARTing character and LENGTH. */ 149static inline void 150pp_append_r (pretty_printer *pp, const char *start, int length) 151{ 152 obstack_grow (pp->buffer->obstack, start, length); 153 pp->buffer->line_length += length; 154} 155 156/* Insert enough spaces into the output area of PRETTY-PRINTER to bring 157 the column position to the current indentation level, assuming that a 158 newline has just been written to the buffer. */ 159void 160pp_base_indent (pretty_printer *pp) 161{ 162 int n = pp_indentation (pp); 163 int i; 164 165 for (i = 0; i < n; ++i) 166 pp_space (pp); 167} 168 169/* The following format specifiers are 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 argument 187 integer. 188 %Ns: likewise, but length specified as constant in the format string. 189 %H: location_t. 190 %J: a decl tree, from which DECL_SOURCE_LOCATION will be recorded. 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 207void 208pp_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 'H': 475 { 476 location_t *locus = va_arg (*text->args_ptr, location_t *); 477 gcc_assert (text->locus != NULL); 478 *text->locus = *locus; 479 } 480 break; 481 482 case 'J': 483 { 484 tree t = va_arg (*text->args_ptr, tree); 485 gcc_assert (text->locus != NULL); 486 *text->locus = DECL_SOURCE_LOCATION (t); 487 } 488 break; 489 490 case '.': 491 { 492 int n; 493 const char *s; 494 495 /* We handle '%.Ns' and '%.*s' or '%M$.*N$s' 496 (where M == N + 1). The format string should be verified 497 already from the first phase. */ 498 p++; 499 if (ISDIGIT (*p)) 500 { 501 char *end; 502 n = strtoul (p, &end, 10); 503 p = end; 504 gcc_assert (*p == 's'); 505 } 506 else 507 { 508 gcc_assert (*p == '*'); 509 p++; 510 gcc_assert (*p == 's'); 511 n = va_arg (*text->args_ptr, int); 512 513 /* This consumes a second entry in the formatters array. */ 514 gcc_assert (formatters[argno] == formatters[argno+1]); 515 argno++; 516 } 517 518 s = va_arg (*text->args_ptr, const char *); 519 pp_append_text (pp, s, s + n); 520 } 521 break; 522 523 default: 524 { 525 bool ok; 526 527 gcc_assert (pp_format_decoder (pp)); 528 ok = pp_format_decoder (pp) (pp, text, p, 529 precision, wide, plus, hash); 530 gcc_assert (ok); 531 } 532 } 533 534 if (quote) 535 pp_string (pp, close_quote); 536 537 obstack_1grow (&buffer->chunk_obstack, '\0'); 538 *formatters[argno] = XOBFINISH (&buffer->chunk_obstack, const char *); 539 } 540 541#ifdef ENABLE_CHECKING 542 for (; argno < PP_NL_ARGMAX; argno++) 543 gcc_assert (!formatters[argno]); 544#endif 545 546 /* Revert to normal obstack and wrapping mode. */ 547 buffer->obstack = &buffer->formatted_obstack; 548 buffer->line_length = 0; 549 pp_wrapping_mode (pp) = old_wrapping_mode; 550 pp_clear_state (pp); 551} 552 553/* Format of a message pointed to by TEXT. */ 554void 555pp_base_output_formatted_text (pretty_printer *pp) 556{ 557 unsigned int chunk; 558 output_buffer *buffer = pp_buffer (pp); 559 struct chunk_info *chunk_array = buffer->cur_chunk_array; 560 const char **args = chunk_array->args; 561 562 gcc_assert (buffer->obstack == &buffer->formatted_obstack); 563 gcc_assert (buffer->line_length == 0); 564 565 /* This is a third phase, first 2 phases done in pp_base_format_args. 566 Now we actually print it. */ 567 for (chunk = 0; args[chunk]; chunk++) 568 pp_string (pp, args[chunk]); 569 570 /* Deallocate the chunk structure and everything after it (i.e. the 571 associated series of formatted strings). */ 572 buffer->cur_chunk_array = chunk_array->prev; 573 obstack_free (&buffer->chunk_obstack, chunk_array); 574} 575 576/* Helper subroutine of output_verbatim and verbatim. Do the appropriate 577 settings needed by BUFFER for a verbatim formatting. */ 578void 579pp_base_format_verbatim (pretty_printer *pp, text_info *text) 580{ 581 /* Set verbatim mode. */ 582 pp_wrapping_mode_t oldmode = pp_set_verbatim_wrapping (pp); 583 584 /* Do the actual formatting. */ 585 pp_format (pp, text); 586 pp_output_formatted_text (pp); 587 588 /* Restore previous settings. */ 589 pp_wrapping_mode (pp) = oldmode; 590} 591 592/* Flush the content of BUFFER onto the attached stream. */ 593void 594pp_base_flush (pretty_printer *pp) 595{ 596 pp_write_text_to_stream (pp); 597 pp_clear_state (pp); 598 fputc ('\n', pp->buffer->stream); 599 fflush (pp->buffer->stream); 600 pp_needs_newline (pp) = false; 601} 602 603/* Sets the number of maximum characters per line PRETTY-PRINTER can 604 output in line-wrapping mode. A LENGTH value 0 suppresses 605 line-wrapping. */ 606void 607pp_base_set_line_maximum_length (pretty_printer *pp, int length) 608{ 609 pp_line_cutoff (pp) = length; 610 pp_set_real_maximum_length (pp); 611} 612 613/* Clear PRETTY-PRINTER output area text info. */ 614void 615pp_base_clear_output_area (pretty_printer *pp) 616{ 617 obstack_free (pp->buffer->obstack, obstack_base (pp->buffer->obstack)); 618 pp->buffer->line_length = 0; 619} 620 621/* Set PREFIX for PRETTY-PRINTER. */ 622void 623pp_base_set_prefix (pretty_printer *pp, const char *prefix) 624{ 625 pp->prefix = prefix; 626 pp_set_real_maximum_length (pp); 627 pp->emitted_prefix = false; 628 pp_indentation (pp) = 0; 629} 630 631/* Free PRETTY-PRINTER's prefix, a previously malloc()'d string. */ 632void 633pp_base_destroy_prefix (pretty_printer *pp) 634{ 635 if (pp->prefix != NULL) 636 { 637 free ((char *) pp->prefix); 638 pp->prefix = NULL; 639 } 640} 641 642/* Write out PRETTY-PRINTER's prefix. */ 643void 644pp_base_emit_prefix (pretty_printer *pp) 645{ 646 if (pp->prefix != NULL) 647 { 648 switch (pp_prefixing_rule (pp)) 649 { 650 default: 651 case DIAGNOSTICS_SHOW_PREFIX_NEVER: 652 break; 653 654 case DIAGNOSTICS_SHOW_PREFIX_ONCE: 655 if (pp->emitted_prefix) 656 { 657 pp_base_indent (pp); 658 break; 659 } 660 pp_indentation (pp) += 3; 661 /* Fall through. */ 662 663 case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE: 664 { 665 int prefix_length = strlen (pp->prefix); 666 pp_append_r (pp, pp->prefix, prefix_length); 667 pp->emitted_prefix = true; 668 } 669 break; 670 } 671 } 672} 673 674/* Construct a PRETTY-PRINTER with PREFIX and of MAXIMUM_LENGTH 675 characters per line. */ 676void 677pp_construct (pretty_printer *pp, const char *prefix, int maximum_length) 678{ 679 memset (pp, 0, sizeof (pretty_printer)); 680 pp->buffer = XCNEW (output_buffer); 681 obstack_init (&pp->buffer->chunk_obstack); 682 obstack_init (&pp->buffer->formatted_obstack); 683 pp->buffer->obstack = &pp->buffer->formatted_obstack; 684 pp->buffer->stream = stderr; 685 pp_line_cutoff (pp) = maximum_length; 686 pp_prefixing_rule (pp) = DIAGNOSTICS_SHOW_PREFIX_ONCE; 687 pp_set_prefix (pp, prefix); 688} 689 690/* Append a string delimited by START and END to the output area of 691 PRETTY-PRINTER. No line wrapping is done. However, if beginning a 692 new line then emit PRETTY-PRINTER's prefix and skip any leading 693 whitespace if appropriate. The caller must ensure that it is 694 safe to do so. */ 695void 696pp_base_append_text (pretty_printer *pp, const char *start, const char *end) 697{ 698 /* Emit prefix and skip whitespace if we're starting a new line. */ 699 if (pp->buffer->line_length == 0) 700 { 701 pp_emit_prefix (pp); 702 if (pp_is_wrapping_line (pp)) 703 while (start != end && *start == ' ') 704 ++start; 705 } 706 pp_append_r (pp, start, end - start); 707} 708 709/* Finishes constructing a NULL-terminated character string representing 710 the PRETTY-PRINTED text. */ 711const char * 712pp_base_formatted_text (pretty_printer *pp) 713{ 714 obstack_1grow (pp->buffer->obstack, '\0'); 715 return pp_formatted_text_data (pp); 716} 717 718/* Return a pointer to the last character emitted in PRETTY-PRINTER's 719 output area. A NULL pointer means no character available. */ 720const char * 721pp_base_last_position_in_text (const pretty_printer *pp) 722{ 723 const char *p = NULL; 724 struct obstack *text = pp->buffer->obstack; 725 726 if (obstack_base (text) != obstack_next_free (text)) 727 p = ((const char *) obstack_next_free (text)) - 1; 728 return p; 729} 730 731/* Return the amount of characters PRETTY-PRINTER can accept to 732 make a full line. Meaningful only in line-wrapping mode. */ 733int 734pp_base_remaining_character_count_for_line (pretty_printer *pp) 735{ 736 return pp->maximum_length - pp->buffer->line_length; 737} 738 739 740/* Format a message into BUFFER a la printf. */ 741void 742pp_printf (pretty_printer *pp, const char *msg, ...) 743{ 744 text_info text; 745 va_list ap; 746 747 va_start (ap, msg); 748 text.err_no = errno; 749 text.args_ptr = ≈ 750 text.format_spec = msg; 751 text.locus = NULL; 752 pp_format (pp, &text); 753 pp_output_formatted_text (pp); 754 va_end (ap); 755} 756 757 758/* Output MESSAGE verbatim into BUFFER. */ 759void 760pp_verbatim (pretty_printer *pp, const char *msg, ...) 761{ 762 text_info text; 763 va_list ap; 764 765 va_start (ap, msg); 766 text.err_no = errno; 767 text.args_ptr = ≈ 768 text.format_spec = msg; 769 text.locus = NULL; 770 pp_format_verbatim (pp, &text); 771 va_end (ap); 772} 773 774 775 776/* Have PRETTY-PRINTER start a new line. */ 777void 778pp_base_newline (pretty_printer *pp) 779{ 780 obstack_1grow (pp->buffer->obstack, '\n'); 781 pp->buffer->line_length = 0; 782} 783 784/* Have PRETTY-PRINTER add a CHARACTER. */ 785void 786pp_base_character (pretty_printer *pp, int c) 787{ 788 if (pp_is_wrapping_line (pp) 789 && pp_remaining_character_count_for_line (pp) <= 0) 790 { 791 pp_newline (pp); 792 if (ISSPACE (c)) 793 return; 794 } 795 obstack_1grow (pp->buffer->obstack, c); 796 ++pp->buffer->line_length; 797} 798 799/* Append a STRING to the output area of PRETTY-PRINTER; the STRING may 800 be line-wrapped if in appropriate mode. */ 801void 802pp_base_string (pretty_printer *pp, const char *str) 803{ 804 pp_maybe_wrap_text (pp, str, str + (str ? strlen (str) : 0)); 805} 806 807/* Maybe print out a whitespace if needed. */ 808 809void 810pp_base_maybe_space (pretty_printer *pp) 811{ 812 if (pp_base (pp)->padding != pp_none) 813 { 814 pp_space (pp); 815 pp_base (pp)->padding = pp_none; 816 } 817} 818