1 /* General utility routines for GDB, the GNU debugger. 2 Copyright 1986, 1989, 1990, 1991, 1992 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 19 20 #include "defs.h" 21 #if !defined(__GO32__) 22 #include <sys/ioctl.h> 23 #include <sys/param.h> 24 #include <pwd.h> 25 #endif 26 #include <varargs.h> 27 #include <ctype.h> 28 #include <string.h> 29 30 #include "signals.h" 31 #include "gdbcmd.h" 32 #include "terminal.h" 33 #include "bfd.h" 34 #include "target.h" 35 #include "demangle.h" 36 37 /* Prototypes for local functions */ 38 39 #if !defined (NO_MALLOC_CHECK) 40 41 static void 42 malloc_botch PARAMS ((void)); 43 44 #endif /* NO_MALLOC_CHECK */ 45 46 static void 47 fatal_dump_core (); /* Can't prototype with <varargs.h> usage... */ 48 49 static void 50 prompt_for_continue PARAMS ((void)); 51 52 static void 53 set_width_command PARAMS ((char *, int, struct cmd_list_element *)); 54 55 /* If this definition isn't overridden by the header files, assume 56 that isatty and fileno exist on this system. */ 57 #ifndef ISATTY 58 #define ISATTY(FP) (isatty (fileno (FP))) 59 #endif 60 61 /* Chain of cleanup actions established with make_cleanup, 62 to be executed if an error happens. */ 63 64 static struct cleanup *cleanup_chain; 65 66 /* Nonzero means a quit has been requested. */ 67 68 int quit_flag; 69 70 /* Nonzero means quit immediately if Control-C is typed now, 71 rather than waiting until QUIT is executed. */ 72 73 int immediate_quit; 74 75 /* Nonzero means that encoded C++ names should be printed out in their 76 C++ form rather than raw. */ 77 78 int demangle = 1; 79 80 /* Nonzero means that encoded C++ names should be printed out in their 81 C++ form even in assembler language displays. If this is set, but 82 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */ 83 84 int asm_demangle = 0; 85 86 /* Nonzero means that strings with character values >0x7F should be printed 87 as octal escapes. Zero means just print the value (e.g. it's an 88 international character, and the terminal or window can cope.) */ 89 90 int sevenbit_strings = 0; 91 92 /* String to be printed before error messages, if any. */ 93 94 char *error_pre_print; 95 char *warning_pre_print = "\nwarning: "; 96 97 /* Add a new cleanup to the cleanup_chain, 98 and return the previous chain pointer 99 to be passed later to do_cleanups or discard_cleanups. 100 Args are FUNCTION to clean up with, and ARG to pass to it. */ 101 102 struct cleanup * 103 make_cleanup (function, arg) 104 void (*function) PARAMS ((PTR)); 105 PTR arg; 106 { 107 register struct cleanup *new 108 = (struct cleanup *) xmalloc (sizeof (struct cleanup)); 109 register struct cleanup *old_chain = cleanup_chain; 110 111 new->next = cleanup_chain; 112 new->function = function; 113 new->arg = arg; 114 cleanup_chain = new; 115 116 return old_chain; 117 } 118 119 /* Discard cleanups and do the actions they describe 120 until we get back to the point OLD_CHAIN in the cleanup_chain. */ 121 122 void 123 do_cleanups (old_chain) 124 register struct cleanup *old_chain; 125 { 126 register struct cleanup *ptr; 127 while ((ptr = cleanup_chain) != old_chain) 128 { 129 cleanup_chain = ptr->next; /* Do this first incase recursion */ 130 (*ptr->function) (ptr->arg); 131 free (ptr); 132 } 133 } 134 135 /* Discard cleanups, not doing the actions they describe, 136 until we get back to the point OLD_CHAIN in the cleanup_chain. */ 137 138 void 139 discard_cleanups (old_chain) 140 register struct cleanup *old_chain; 141 { 142 register struct cleanup *ptr; 143 while ((ptr = cleanup_chain) != old_chain) 144 { 145 cleanup_chain = ptr->next; 146 free ((PTR)ptr); 147 } 148 } 149 150 /* Set the cleanup_chain to 0, and return the old cleanup chain. */ 151 struct cleanup * 152 save_cleanups () 153 { 154 struct cleanup *old_chain = cleanup_chain; 155 156 cleanup_chain = 0; 157 return old_chain; 158 } 159 160 /* Restore the cleanup chain from a previously saved chain. */ 161 void 162 restore_cleanups (chain) 163 struct cleanup *chain; 164 { 165 cleanup_chain = chain; 166 } 167 168 /* This function is useful for cleanups. 169 Do 170 171 foo = xmalloc (...); 172 old_chain = make_cleanup (free_current_contents, &foo); 173 174 to arrange to free the object thus allocated. */ 175 176 void 177 free_current_contents (location) 178 char **location; 179 { 180 free (*location); 181 } 182 183 /* Provide a known function that does nothing, to use as a base for 184 for a possibly long chain of cleanups. This is useful where we 185 use the cleanup chain for handling normal cleanups as well as dealing 186 with cleanups that need to be done as a result of a call to error(). 187 In such cases, we may not be certain where the first cleanup is, unless 188 we have a do-nothing one to always use as the base. */ 189 190 /* ARGSUSED */ 191 void 192 null_cleanup (arg) 193 char **arg; 194 { 195 } 196 197 198 /* Provide a hook for modules wishing to print their own warning messages 199 to set up the terminal state in a compatible way, without them having 200 to import all the target_<...> macros. */ 201 202 void 203 warning_setup () 204 { 205 target_terminal_ours (); 206 wrap_here(""); /* Force out any buffered output */ 207 fflush (stdout); 208 } 209 210 /* Print a warning message. 211 The first argument STRING is the warning message, used as a fprintf string, 212 and the remaining args are passed as arguments to it. 213 The primary difference between warnings and errors is that a warning 214 does not force the return to command level. */ 215 216 /* VARARGS */ 217 void 218 warning (va_alist) 219 va_dcl 220 { 221 va_list args; 222 char *string; 223 224 va_start (args); 225 target_terminal_ours (); 226 wrap_here(""); /* Force out any buffered output */ 227 fflush (stdout); 228 if (warning_pre_print) 229 fprintf (stderr, warning_pre_print); 230 string = va_arg (args, char *); 231 vfprintf (stderr, string, args); 232 fprintf (stderr, "\n"); 233 va_end (args); 234 } 235 236 /* Print an error message and return to command level. 237 The first argument STRING is the error message, used as a fprintf string, 238 and the remaining args are passed as arguments to it. */ 239 240 /* VARARGS */ 241 NORETURN void 242 error (va_alist) 243 va_dcl 244 { 245 va_list args; 246 char *string; 247 248 va_start (args); 249 target_terminal_ours (); 250 wrap_here(""); /* Force out any buffered output */ 251 fflush (stdout); 252 if (error_pre_print) 253 fprintf_filtered (stderr, error_pre_print); 254 string = va_arg (args, char *); 255 vfprintf_filtered (stderr, string, args); 256 fprintf_filtered (stderr, "\n"); 257 va_end (args); 258 return_to_top_level (); 259 } 260 261 /* Print an error message and exit reporting failure. 262 This is for a error that we cannot continue from. 263 The arguments are printed a la printf. 264 265 This function cannot be declared volatile (NORETURN) in an 266 ANSI environment because exit() is not declared volatile. */ 267 268 /* VARARGS */ 269 NORETURN void 270 fatal (va_alist) 271 va_dcl 272 { 273 va_list args; 274 char *string; 275 276 va_start (args); 277 string = va_arg (args, char *); 278 fprintf (stderr, "\ngdb: "); 279 vfprintf (stderr, string, args); 280 fprintf (stderr, "\n"); 281 va_end (args); 282 exit (1); 283 } 284 285 /* Print an error message and exit, dumping core. 286 The arguments are printed a la printf (). */ 287 288 /* VARARGS */ 289 static void 290 fatal_dump_core (va_alist) 291 va_dcl 292 { 293 va_list args; 294 char *string; 295 296 va_start (args); 297 string = va_arg (args, char *); 298 /* "internal error" is always correct, since GDB should never dump 299 core, no matter what the input. */ 300 fprintf (stderr, "\ngdb internal error: "); 301 vfprintf (stderr, string, args); 302 fprintf (stderr, "\n"); 303 va_end (args); 304 305 signal (SIGQUIT, SIG_DFL); 306 kill (getpid (), SIGQUIT); 307 /* We should never get here, but just in case... */ 308 exit (1); 309 } 310 311 /* The strerror() function can return NULL for errno values that are 312 out of range. Provide a "safe" version that always returns a 313 printable string. */ 314 315 char * 316 safe_strerror (errnum) 317 int errnum; 318 { 319 char *msg; 320 static char buf[32]; 321 322 if ((msg = strerror (errnum)) == NULL) 323 { 324 sprintf (buf, "(undocumented errno %d)", errnum); 325 msg = buf; 326 } 327 return (msg); 328 } 329 330 /* The strsignal() function can return NULL for signal values that are 331 out of range. Provide a "safe" version that always returns a 332 printable string. */ 333 334 char * 335 safe_strsignal (signo) 336 int signo; 337 { 338 char *msg; 339 static char buf[32]; 340 341 if ((msg = strsignal (signo)) == NULL) 342 { 343 sprintf (buf, "(undocumented signal %d)", signo); 344 msg = buf; 345 } 346 return (msg); 347 } 348 349 350 /* Print the system error message for errno, and also mention STRING 351 as the file name for which the error was encountered. 352 Then return to command level. */ 353 354 void 355 perror_with_name (string) 356 char *string; 357 { 358 char *err; 359 char *combined; 360 361 err = safe_strerror (errno); 362 combined = (char *) alloca (strlen (err) + strlen (string) + 3); 363 strcpy (combined, string); 364 strcat (combined, ": "); 365 strcat (combined, err); 366 367 /* I understand setting these is a matter of taste. Still, some people 368 may clear errno but not know about bfd_error. Doing this here is not 369 unreasonable. */ 370 bfd_error = no_error; 371 errno = 0; 372 373 error ("%s.", combined); 374 } 375 376 /* Print the system error message for ERRCODE, and also mention STRING 377 as the file name for which the error was encountered. */ 378 379 void 380 print_sys_errmsg (string, errcode) 381 char *string; 382 int errcode; 383 { 384 char *err; 385 char *combined; 386 387 err = safe_strerror (errcode); 388 combined = (char *) alloca (strlen (err) + strlen (string) + 3); 389 strcpy (combined, string); 390 strcat (combined, ": "); 391 strcat (combined, err); 392 393 fprintf (stderr, "%s.\n", combined); 394 } 395 396 /* Control C eventually causes this to be called, at a convenient time. */ 397 398 void 399 quit () 400 { 401 target_terminal_ours (); 402 wrap_here ((char *)0); /* Force out any pending output */ 403 #if !defined(__GO32__) 404 #ifdef HAVE_TERMIO 405 ioctl (fileno (stdout), TCFLSH, 1); 406 #else /* not HAVE_TERMIO */ 407 ioctl (fileno (stdout), TIOCFLUSH, 0); 408 #endif /* not HAVE_TERMIO */ 409 #ifdef TIOCGPGRP 410 error ("Quit"); 411 #else 412 error ("Quit (expect signal %d when inferior is resumed)", SIGINT); 413 #endif /* TIOCGPGRP */ 414 #endif 415 } 416 417 /* Control C comes here */ 418 419 void 420 request_quit (signo) 421 int signo; 422 { 423 quit_flag = 1; 424 425 #ifdef USG 426 /* Restore the signal handler. */ 427 signal (signo, request_quit); 428 #endif 429 430 if (immediate_quit) 431 quit (); 432 } 433 434 435 /* Memory management stuff (malloc friends). */ 436 437 #if defined (NO_MMALLOC) 438 439 PTR 440 mmalloc (md, size) 441 PTR md; 442 long size; 443 { 444 return (malloc (size)); 445 } 446 447 PTR 448 mrealloc (md, ptr, size) 449 PTR md; 450 PTR ptr; 451 long size; 452 { 453 if (ptr == 0) /* Guard against old realloc's */ 454 return malloc (size); 455 else 456 return realloc (ptr, size); 457 } 458 459 void 460 mfree (md, ptr) 461 PTR md; 462 PTR ptr; 463 { 464 free (ptr); 465 } 466 467 #endif /* NO_MMALLOC */ 468 469 #if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK) 470 471 void 472 init_malloc (md) 473 PTR md; 474 { 475 } 476 477 #else /* have mmalloc and want corruption checking */ 478 479 static void 480 malloc_botch () 481 { 482 fatal_dump_core ("Memory corruption"); 483 } 484 485 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified 486 by MD, to detect memory corruption. Note that MD may be NULL to specify 487 the default heap that grows via sbrk. 488 489 Note that for freshly created regions, we must call mmcheck prior to any 490 mallocs in the region. Otherwise, any region which was allocated prior to 491 installing the checking hooks, which is later reallocated or freed, will 492 fail the checks! The mmcheck function only allows initial hooks to be 493 installed before the first mmalloc. However, anytime after we have called 494 mmcheck the first time to install the checking hooks, we can call it again 495 to update the function pointer to the memory corruption handler. 496 497 Returns zero on failure, non-zero on success. */ 498 499 void 500 init_malloc (md) 501 PTR md; 502 { 503 if (!mmcheck (md, malloc_botch)) 504 { 505 warning ("internal error: failed to install memory consistency checks"); 506 } 507 508 mmtrace (); 509 } 510 511 #endif /* Have mmalloc and want corruption checking */ 512 513 /* Called when a memory allocation fails, with the number of bytes of 514 memory requested in SIZE. */ 515 516 NORETURN void 517 nomem (size) 518 long size; 519 { 520 if (size > 0) 521 { 522 fatal ("virtual memory exhausted: can't allocate %ld bytes.", size); 523 } 524 else 525 { 526 fatal ("virtual memory exhausted."); 527 } 528 } 529 530 /* Like mmalloc but get error if no storage available, and protect against 531 the caller wanting to allocate zero bytes. Whether to return NULL for 532 a zero byte request, or translate the request into a request for one 533 byte of zero'd storage, is a religious issue. */ 534 535 PTR 536 xmmalloc (md, size) 537 PTR md; 538 long size; 539 { 540 register PTR val; 541 542 if (size == 0) 543 { 544 val = NULL; 545 } 546 else if ((val = mmalloc (md, size)) == NULL) 547 { 548 nomem (size); 549 } 550 return (val); 551 } 552 553 /* Like mrealloc but get error if no storage available. */ 554 555 PTR 556 xmrealloc (md, ptr, size) 557 PTR md; 558 PTR ptr; 559 long size; 560 { 561 register PTR val; 562 563 if (ptr != NULL) 564 { 565 val = mrealloc (md, ptr, size); 566 } 567 else 568 { 569 val = mmalloc (md, size); 570 } 571 if (val == NULL) 572 { 573 nomem (size); 574 } 575 return (val); 576 } 577 578 /* Like malloc but get error if no storage available, and protect against 579 the caller wanting to allocate zero bytes. */ 580 581 PTR 582 xmalloc (size) 583 long size; 584 { 585 return (xmmalloc ((void *) NULL, size)); 586 } 587 588 /* Like mrealloc but get error if no storage available. */ 589 590 PTR 591 xrealloc (ptr, size) 592 PTR ptr; 593 long size; 594 { 595 return (xmrealloc ((void *) NULL, ptr, size)); 596 } 597 598 599 /* My replacement for the read system call. 600 Used like `read' but keeps going if `read' returns too soon. */ 601 602 int 603 myread (desc, addr, len) 604 int desc; 605 char *addr; 606 int len; 607 { 608 register int val; 609 int orglen = len; 610 611 while (len > 0) 612 { 613 val = read (desc, addr, len); 614 if (val < 0) 615 return val; 616 if (val == 0) 617 return orglen - len; 618 len -= val; 619 addr += val; 620 } 621 return orglen; 622 } 623 624 /* Make a copy of the string at PTR with SIZE characters 625 (and add a null character at the end in the copy). 626 Uses malloc to get the space. Returns the address of the copy. */ 627 628 char * 629 savestring (ptr, size) 630 const char *ptr; 631 int size; 632 { 633 register char *p = (char *) xmalloc (size + 1); 634 memcpy (p, ptr, size); 635 p[size] = 0; 636 return p; 637 } 638 639 char * 640 msavestring (md, ptr, size) 641 void *md; 642 const char *ptr; 643 int size; 644 { 645 register char *p = (char *) xmmalloc (md, size + 1); 646 memcpy (p, ptr, size); 647 p[size] = 0; 648 return p; 649 } 650 651 /* The "const" is so it compiles under DGUX (which prototypes strsave 652 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it? 653 Doesn't real strsave return NULL if out of memory? */ 654 char * 655 strsave (ptr) 656 const char *ptr; 657 { 658 return savestring (ptr, strlen (ptr)); 659 } 660 661 char * 662 mstrsave (md, ptr) 663 void *md; 664 const char *ptr; 665 { 666 return (msavestring (md, ptr, strlen (ptr))); 667 } 668 669 void 670 print_spaces (n, file) 671 register int n; 672 register FILE *file; 673 { 674 while (n-- > 0) 675 fputc (' ', file); 676 } 677 678 /* Ask user a y-or-n question and return 1 iff answer is yes. 679 Takes three args which are given to printf to print the question. 680 The first, a control string, should end in "? ". 681 It should not say how to answer, because we do that. */ 682 683 /* VARARGS */ 684 int 685 query (va_alist) 686 va_dcl 687 { 688 va_list args; 689 char *ctlstr; 690 register int answer; 691 register int ans2; 692 693 /* Automatically answer "yes" if input is not from a terminal. */ 694 if (!input_from_terminal_p ()) 695 return 1; 696 697 while (1) 698 { 699 wrap_here (""); /* Flush any buffered output */ 700 fflush (stdout); 701 va_start (args); 702 ctlstr = va_arg (args, char *); 703 vfprintf_filtered (stdout, ctlstr, args); 704 va_end (args); 705 printf_filtered ("(y or n) "); 706 fflush (stdout); 707 answer = fgetc (stdin); 708 clearerr (stdin); /* in case of C-d */ 709 if (answer == EOF) /* C-d */ 710 return 1; 711 if (answer != '\n') /* Eat rest of input line, to EOF or newline */ 712 do 713 { 714 ans2 = fgetc (stdin); 715 clearerr (stdin); 716 } 717 while (ans2 != EOF && ans2 != '\n'); 718 if (answer >= 'a') 719 answer -= 040; 720 if (answer == 'Y') 721 return 1; 722 if (answer == 'N') 723 return 0; 724 printf_filtered ("Please answer y or n.\n"); 725 } 726 } 727 728 729 /* Parse a C escape sequence. STRING_PTR points to a variable 730 containing a pointer to the string to parse. That pointer 731 should point to the character after the \. That pointer 732 is updated past the characters we use. The value of the 733 escape sequence is returned. 734 735 A negative value means the sequence \ newline was seen, 736 which is supposed to be equivalent to nothing at all. 737 738 If \ is followed by a null character, we return a negative 739 value and leave the string pointer pointing at the null character. 740 741 If \ is followed by 000, we return 0 and leave the string pointer 742 after the zeros. A value of 0 does not mean end of string. */ 743 744 int 745 parse_escape (string_ptr) 746 char **string_ptr; 747 { 748 register int c = *(*string_ptr)++; 749 switch (c) 750 { 751 case 'a': 752 return 007; /* Bell (alert) char */ 753 case 'b': 754 return '\b'; 755 case 'e': /* Escape character */ 756 return 033; 757 case 'f': 758 return '\f'; 759 case 'n': 760 return '\n'; 761 case 'r': 762 return '\r'; 763 case 't': 764 return '\t'; 765 case 'v': 766 return '\v'; 767 case '\n': 768 return -2; 769 case 0: 770 (*string_ptr)--; 771 return 0; 772 case '^': 773 c = *(*string_ptr)++; 774 if (c == '\\') 775 c = parse_escape (string_ptr); 776 if (c == '?') 777 return 0177; 778 return (c & 0200) | (c & 037); 779 780 case '0': 781 case '1': 782 case '2': 783 case '3': 784 case '4': 785 case '5': 786 case '6': 787 case '7': 788 { 789 register int i = c - '0'; 790 register int count = 0; 791 while (++count < 3) 792 { 793 if ((c = *(*string_ptr)++) >= '0' && c <= '7') 794 { 795 i *= 8; 796 i += c - '0'; 797 } 798 else 799 { 800 (*string_ptr)--; 801 break; 802 } 803 } 804 return i; 805 } 806 default: 807 return c; 808 } 809 } 810 811 /* Print the character C on STREAM as part of the contents 812 of a literal string whose delimiter is QUOTER. */ 813 814 void 815 printchar (c, stream, quoter) 816 register int c; 817 FILE *stream; 818 int quoter; 819 { 820 821 c &= 0xFF; /* Avoid sign bit follies */ 822 823 if ( c < 0x20 || /* Low control chars */ 824 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */ 825 (sevenbit_strings && c >= 0x80)) { /* high order bit set */ 826 switch (c) 827 { 828 case '\n': 829 fputs_filtered ("\\n", stream); 830 break; 831 case '\b': 832 fputs_filtered ("\\b", stream); 833 break; 834 case '\t': 835 fputs_filtered ("\\t", stream); 836 break; 837 case '\f': 838 fputs_filtered ("\\f", stream); 839 break; 840 case '\r': 841 fputs_filtered ("\\r", stream); 842 break; 843 case '\033': 844 fputs_filtered ("\\e", stream); 845 break; 846 case '\007': 847 fputs_filtered ("\\a", stream); 848 break; 849 default: 850 fprintf_filtered (stream, "\\%X", (unsigned int) c); 851 break; 852 } 853 } else { 854 if (c == '\\' || c == quoter) 855 fputs_filtered ("\\", stream); 856 fprintf_filtered (stream, "%c", c); 857 } 858 } 859 860 /* Number of lines per page or UINT_MAX if paging is disabled. */ 861 static unsigned int lines_per_page; 862 /* Number of chars per line or UNIT_MAX is line folding is disabled. */ 863 static unsigned int chars_per_line; 864 /* Current count of lines printed on this page, chars on this line. */ 865 static unsigned int lines_printed, chars_printed; 866 867 /* Buffer and start column of buffered text, for doing smarter word- 868 wrapping. When someone calls wrap_here(), we start buffering output 869 that comes through fputs_filtered(). If we see a newline, we just 870 spit it out and forget about the wrap_here(). If we see another 871 wrap_here(), we spit it out and remember the newer one. If we see 872 the end of the line, we spit out a newline, the indent, and then 873 the buffered output. 874 875 wrap_column is the column number on the screen where wrap_buffer begins. 876 When wrap_column is zero, wrapping is not in effect. 877 wrap_buffer is malloc'd with chars_per_line+2 bytes. 878 When wrap_buffer[0] is null, the buffer is empty. 879 wrap_pointer points into it at the next character to fill. 880 wrap_indent is the string that should be used as indentation if the 881 wrap occurs. */ 882 883 static char *wrap_buffer, *wrap_pointer, *wrap_indent; 884 static int wrap_column; 885 886 /* ARGSUSED */ 887 static void 888 set_width_command (args, from_tty, c) 889 char *args; 890 int from_tty; 891 struct cmd_list_element *c; 892 { 893 if (!wrap_buffer) 894 { 895 wrap_buffer = (char *) xmalloc (chars_per_line + 2); 896 wrap_buffer[0] = '\0'; 897 } 898 else 899 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2); 900 wrap_pointer = wrap_buffer; /* Start it at the beginning */ 901 } 902 903 extern FILE *instream; 904 905 static void 906 instream_cleanup(stream) 907 FILE *stream; 908 { 909 instream = stream; 910 } 911 912 static void 913 prompt_for_continue () 914 { 915 if (ISATTY(stdin) && ISATTY(stdout)) 916 { 917 struct cleanup *old_chain = make_cleanup(instream_cleanup, instream); 918 char *cp; 919 920 instream = stdin; 921 immediate_quit++; 922 cp = gdb_readline ("---Type <return> to continue---"); 923 if (cp) 924 free (cp); 925 chars_printed = lines_printed = 0; 926 immediate_quit--; 927 do_cleanups(old_chain); 928 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */ 929 } 930 } 931 932 /* Reinitialize filter; ie. tell it to reset to original values. */ 933 934 void 935 reinitialize_more_filter () 936 { 937 lines_printed = 0; 938 chars_printed = 0; 939 } 940 941 /* Indicate that if the next sequence of characters overflows the line, 942 a newline should be inserted here rather than when it hits the end. 943 If INDENT is nonzero, it is a string to be printed to indent the 944 wrapped part on the next line. INDENT must remain accessible until 945 the next call to wrap_here() or until a newline is printed through 946 fputs_filtered(). 947 948 If the line is already overfull, we immediately print a newline and 949 the indentation, and disable further wrapping. 950 951 If we don't know the width of lines, but we know the page height, 952 we must not wrap words, but should still keep track of newlines 953 that were explicitly printed. 954 955 INDENT should not contain tabs, as that 956 will mess up the char count on the next line. FIXME. */ 957 958 void 959 wrap_here(indent) 960 char *indent; 961 { 962 if (wrap_buffer[0]) 963 { 964 *wrap_pointer = '\0'; 965 fputs (wrap_buffer, stdout); 966 } 967 wrap_pointer = wrap_buffer; 968 wrap_buffer[0] = '\0'; 969 if (chars_per_line == UINT_MAX) /* No line overflow checking */ 970 { 971 wrap_column = 0; 972 } 973 else if (chars_printed >= chars_per_line) 974 { 975 puts_filtered ("\n"); 976 puts_filtered (indent); 977 wrap_column = 0; 978 } 979 else 980 { 981 wrap_column = chars_printed; 982 wrap_indent = indent; 983 } 984 } 985 986 /* Like fputs but pause after every screenful, and can wrap at points 987 other than the final character of a line. 988 Unlike fputs, fputs_filtered does not return a value. 989 It is OK for LINEBUFFER to be NULL, in which case just don't print 990 anything. 991 992 Note that a longjmp to top level may occur in this routine 993 (since prompt_for_continue may do so) so this routine should not be 994 called when cleanups are not in place. */ 995 996 void 997 fputs_filtered (linebuffer, stream) 998 const char *linebuffer; 999 FILE *stream; 1000 { 1001 const char *lineptr; 1002 1003 if (linebuffer == 0) 1004 return; 1005 1006 /* Don't do any filtering if it is disabled. */ 1007 if (stream != stdout 1008 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)) 1009 { 1010 fputs (linebuffer, stream); 1011 return; 1012 } 1013 1014 /* Go through and output each character. Show line extension 1015 when this is necessary; prompt user for new page when this is 1016 necessary. */ 1017 1018 lineptr = linebuffer; 1019 while (*lineptr) 1020 { 1021 /* Possible new page. */ 1022 if (lines_printed >= lines_per_page - 1) 1023 prompt_for_continue (); 1024 1025 while (*lineptr && *lineptr != '\n') 1026 { 1027 /* Print a single line. */ 1028 if (*lineptr == '\t') 1029 { 1030 if (wrap_column) 1031 *wrap_pointer++ = '\t'; 1032 else 1033 putc ('\t', stream); 1034 /* Shifting right by 3 produces the number of tab stops 1035 we have already passed, and then adding one and 1036 shifting left 3 advances to the next tab stop. */ 1037 chars_printed = ((chars_printed >> 3) + 1) << 3; 1038 lineptr++; 1039 } 1040 else 1041 { 1042 if (wrap_column) 1043 *wrap_pointer++ = *lineptr; 1044 else 1045 putc (*lineptr, stream); 1046 chars_printed++; 1047 lineptr++; 1048 } 1049 1050 if (chars_printed >= chars_per_line) 1051 { 1052 unsigned int save_chars = chars_printed; 1053 1054 chars_printed = 0; 1055 lines_printed++; 1056 /* If we aren't actually wrapping, don't output newline -- 1057 if chars_per_line is right, we probably just overflowed 1058 anyway; if it's wrong, let us keep going. */ 1059 if (wrap_column) 1060 putc ('\n', stream); 1061 1062 /* Possible new page. */ 1063 if (lines_printed >= lines_per_page - 1) 1064 prompt_for_continue (); 1065 1066 /* Now output indentation and wrapped string */ 1067 if (wrap_column) 1068 { 1069 if (wrap_indent) 1070 fputs (wrap_indent, stream); 1071 *wrap_pointer = '\0'; /* Null-terminate saved stuff */ 1072 fputs (wrap_buffer, stream); /* and eject it */ 1073 /* FIXME, this strlen is what prevents wrap_indent from 1074 containing tabs. However, if we recurse to print it 1075 and count its chars, we risk trouble if wrap_indent is 1076 longer than (the user settable) chars_per_line. 1077 Note also that this can set chars_printed > chars_per_line 1078 if we are printing a long string. */ 1079 chars_printed = strlen (wrap_indent) 1080 + (save_chars - wrap_column); 1081 wrap_pointer = wrap_buffer; /* Reset buffer */ 1082 wrap_buffer[0] = '\0'; 1083 wrap_column = 0; /* And disable fancy wrap */ 1084 } 1085 } 1086 } 1087 1088 if (*lineptr == '\n') 1089 { 1090 chars_printed = 0; 1091 wrap_here ((char *)0); /* Spit out chars, cancel further wraps */ 1092 lines_printed++; 1093 putc ('\n', stream); 1094 lineptr++; 1095 } 1096 } 1097 } 1098 1099 1100 /* fputs_demangled is a variant of fputs_filtered that 1101 demangles g++ names.*/ 1102 1103 void 1104 fputs_demangled (linebuffer, stream, arg_mode) 1105 char *linebuffer; 1106 FILE *stream; 1107 int arg_mode; 1108 { 1109 #define SYMBOL_MAX 1024 1110 1111 #define SYMBOL_CHAR(c) (isascii(c) \ 1112 && (isalnum(c) || (c) == '_' || (c) == CPLUS_MARKER)) 1113 1114 char buf[SYMBOL_MAX+1]; 1115 # define DMSLOP 5 /* How much room to leave in buf */ 1116 char *p; 1117 1118 if (linebuffer == NULL) 1119 return; 1120 1121 /* If user wants to see raw output, no problem. */ 1122 if (!demangle) { 1123 fputs_filtered (linebuffer, stream); 1124 return; 1125 } 1126 1127 p = linebuffer; 1128 1129 while ( *p != (char) 0 ) { 1130 int i = 0; 1131 1132 /* collect non-interesting characters into buf */ 1133 while (*p != (char) 0 && !SYMBOL_CHAR(*p) && i < (int)sizeof(buf)-DMSLOP ) { 1134 buf[i++] = *p; 1135 p++; 1136 } 1137 if (i > 0) { 1138 /* output the non-interesting characters without demangling */ 1139 buf[i] = (char) 0; 1140 fputs_filtered(buf, stream); 1141 i = 0; /* reset buf */ 1142 } 1143 1144 /* and now the interesting characters */ 1145 while (i < SYMBOL_MAX 1146 && *p != (char) 0 1147 && SYMBOL_CHAR(*p) 1148 && i < (int)sizeof(buf) - DMSLOP) { 1149 buf[i++] = *p; 1150 p++; 1151 } 1152 buf[i] = (char) 0; 1153 if (i > 0) { 1154 char * result; 1155 1156 if ( (result = cplus_demangle(buf, arg_mode)) != NULL ) { 1157 fputs_filtered(result, stream); 1158 free(result); 1159 } 1160 else { 1161 fputs_filtered(buf, stream); 1162 } 1163 } 1164 } 1165 } 1166 1167 /* Print a variable number of ARGS using format FORMAT. If this 1168 information is going to put the amount written (since the last call 1169 to REINITIALIZE_MORE_FILTER or the last page break) over the page size, 1170 print out a pause message and do a gdb_readline to get the users 1171 permision to continue. 1172 1173 Unlike fprintf, this function does not return a value. 1174 1175 We implement three variants, vfprintf (takes a vararg list and stream), 1176 fprintf (takes a stream to write on), and printf (the usual). 1177 1178 Note that this routine has a restriction that the length of the 1179 final output line must be less than 255 characters *or* it must be 1180 less than twice the size of the format string. This is a very 1181 arbitrary restriction, but it is an internal restriction, so I'll 1182 put it in. This means that the %s format specifier is almost 1183 useless; unless the caller can GUARANTEE that the string is short 1184 enough, fputs_filtered should be used instead. 1185 1186 Note also that a longjmp to top level may occur in this routine 1187 (since prompt_for_continue may do so) so this routine should not be 1188 called when cleanups are not in place. */ 1189 1190 #define MIN_LINEBUF 255 1191 1192 void 1193 vfprintf_filtered (stream, format, args) 1194 FILE *stream; 1195 char *format; 1196 va_list args; 1197 { 1198 char line_buf[MIN_LINEBUF+10]; 1199 char *linebuffer = line_buf; 1200 int format_length; 1201 1202 format_length = strlen (format); 1203 1204 /* Reallocate buffer to a larger size if this is necessary. */ 1205 if (format_length * 2 > MIN_LINEBUF) 1206 { 1207 linebuffer = alloca (10 + format_length * 2); 1208 } 1209 1210 /* This won't blow up if the restrictions described above are 1211 followed. */ 1212 vsprintf (linebuffer, format, args); 1213 1214 fputs_filtered (linebuffer, stream); 1215 } 1216 1217 /* VARARGS */ 1218 void 1219 fprintf_filtered (va_alist) 1220 va_dcl 1221 { 1222 va_list args; 1223 FILE *stream; 1224 char *format; 1225 1226 va_start (args); 1227 stream = va_arg (args, FILE *); 1228 format = va_arg (args, char *); 1229 1230 /* This won't blow up if the restrictions described above are 1231 followed. */ 1232 vfprintf_filtered (stream, format, args); 1233 va_end (args); 1234 } 1235 1236 /* Like fprintf_filtered, but prints it's result indent. 1237 Called as fprintfi_filtered (spaces, format, arg1, arg2, ...); */ 1238 1239 /* VARARGS */ 1240 void 1241 fprintfi_filtered (va_alist) 1242 va_dcl 1243 { 1244 va_list args; 1245 int spaces; 1246 FILE *stream; 1247 char *format; 1248 1249 va_start (args); 1250 spaces = va_arg (args, int); 1251 stream = va_arg (args, FILE *); 1252 format = va_arg (args, char *); 1253 print_spaces_filtered (spaces, stream); 1254 1255 /* This won't blow up if the restrictions described above are 1256 followed. */ 1257 vfprintf_filtered (stream, format, args); 1258 va_end (args); 1259 } 1260 1261 /* VARARGS */ 1262 void 1263 printf_filtered (va_alist) 1264 va_dcl 1265 { 1266 va_list args; 1267 char *format; 1268 1269 va_start (args); 1270 format = va_arg (args, char *); 1271 1272 vfprintf_filtered (stdout, format, args); 1273 va_end (args); 1274 } 1275 1276 /* Like printf_filtered, but prints it's result indented. 1277 Called as printfi_filtered (spaces, format, arg1, arg2, ...); */ 1278 1279 /* VARARGS */ 1280 void 1281 printfi_filtered (va_alist) 1282 va_dcl 1283 { 1284 va_list args; 1285 int spaces; 1286 char *format; 1287 1288 va_start (args); 1289 spaces = va_arg (args, int); 1290 format = va_arg (args, char *); 1291 print_spaces_filtered (spaces, stdout); 1292 vfprintf_filtered (stdout, format, args); 1293 va_end (args); 1294 } 1295 1296 /* Easy -- but watch out! 1297 1298 This routine is *not* a replacement for puts()! puts() appends a newline. 1299 This one doesn't, and had better not! */ 1300 1301 void 1302 puts_filtered (string) 1303 char *string; 1304 { 1305 fputs_filtered (string, stdout); 1306 } 1307 1308 /* Return a pointer to N spaces and a null. The pointer is good 1309 until the next call to here. */ 1310 char * 1311 n_spaces (n) 1312 int n; 1313 { 1314 register char *t; 1315 static char *spaces; 1316 static int max_spaces; 1317 1318 if (n > max_spaces) 1319 { 1320 if (spaces) 1321 free (spaces); 1322 spaces = (char *) xmalloc (n+1); 1323 for (t = spaces+n; t != spaces;) 1324 *--t = ' '; 1325 spaces[n] = '\0'; 1326 max_spaces = n; 1327 } 1328 1329 return spaces + max_spaces - n; 1330 } 1331 1332 /* Print N spaces. */ 1333 void 1334 print_spaces_filtered (n, stream) 1335 int n; 1336 FILE *stream; 1337 { 1338 fputs_filtered (n_spaces (n), stream); 1339 } 1340 1341 /* C++ demangler stuff. */ 1342 1343 /* Make a copy of a symbol, applying C++ demangling if demangling is enabled 1344 and a demangled version exists. Note that the value returned from 1345 cplus_demangle is already allocated in malloc'd memory. */ 1346 1347 char * 1348 strdup_demangled (name) 1349 const char *name; 1350 { 1351 char *demangled = NULL; 1352 1353 if (demangle) 1354 { 1355 demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI); 1356 } 1357 return ((demangled != NULL) ? demangled : strdup (name)); 1358 } 1359 1360 1361 /* Print NAME on STREAM, demangling if necessary. */ 1362 void 1363 fprint_symbol (stream, name) 1364 FILE *stream; 1365 char *name; 1366 { 1367 char *demangled; 1368 if ((!demangle) 1369 || NULL == (demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI))) 1370 fputs_filtered (name, stream); 1371 else 1372 { 1373 fputs_filtered (demangled, stream); 1374 free (demangled); 1375 } 1376 } 1377 1378 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any 1379 differences in whitespace. Returns 0 if they match, non-zero if they 1380 don't (slightly different than strcmp()'s range of return values). 1381 1382 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO". 1383 This "feature" is useful for demangle_and_match(), which is used 1384 when searching for matching C++ function names (such as if the 1385 user types 'break FOO', where FOO is a mangled C++ function). */ 1386 1387 int 1388 strcmp_iw (string1, string2) 1389 const char *string1; 1390 const char *string2; 1391 { 1392 while ((*string1 != '\0') && (*string2 != '\0')) 1393 { 1394 while (isspace (*string1)) 1395 { 1396 string1++; 1397 } 1398 while (isspace (*string2)) 1399 { 1400 string2++; 1401 } 1402 if (*string1 != *string2) 1403 { 1404 break; 1405 } 1406 if (*string1 != '\0') 1407 { 1408 string1++; 1409 string2++; 1410 } 1411 } 1412 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0'); 1413 } 1414 1415 /* Demangle NAME and compare the result with LOOKFOR, ignoring any differences 1416 in whitespace. 1417 1418 If a match is found, returns a pointer to the demangled version of NAME 1419 in malloc'd memory, which needs to be freed by the caller after use. 1420 If a match is not found, returns NULL. 1421 1422 OPTIONS is a flags word that controls the demangling process and is just 1423 passed on to the demangler. 1424 1425 When the caller sees a non-NULL result, it knows that NAME is the mangled 1426 equivalent of LOOKFOR, and it can use either NAME, the "official demangled" 1427 version of NAME (the return value) or the "unofficial demangled" version 1428 of NAME (LOOKFOR, which it already knows). */ 1429 1430 char * 1431 demangle_and_match (name, lookfor, options) 1432 const char *name; 1433 const char *lookfor; 1434 int options; 1435 { 1436 char *demangled; 1437 1438 if ((demangled = cplus_demangle (name, options)) != NULL) 1439 { 1440 if (strcmp_iw (demangled, lookfor) != 0) 1441 { 1442 free (demangled); 1443 demangled = NULL; 1444 } 1445 } 1446 return (demangled); 1447 } 1448 1449 #ifdef TIOCGWINSZ 1450 #ifdef SIGWINCH 1451 static void 1452 sigwinch() 1453 { 1454 struct winsize win; 1455 1456 if (ioctl(0, TIOCGWINSZ, (char *)&win) < 0) { 1457 perror("TIOCGWINSZ"); 1458 return; 1459 } 1460 lines_per_page = win.ws_row; 1461 chars_per_line = win.ws_col; 1462 } 1463 1464 #ifndef SIGWINCH_HANDLER 1465 #define SIGWINCH_HANDLER sigwinch 1466 #endif 1467 1468 #endif 1469 1470 termdim() 1471 { 1472 SIGWINCH_HANDLER(); 1473 #ifdef SIGWINCH 1474 signal(SIGWINCH, SIGWINCH_HANDLER); 1475 #endif 1476 } 1477 1478 #else 1479 /* Initialize the screen height and width from termcap. */ 1480 termdim() 1481 { 1482 register int v; 1483 register char *cp; 1484 /* 2048 is large enough for all known terminals, according to the 1485 GNU termcap manual. */ 1486 char term_buffer[2048]; 1487 1488 if ((termtype = getenv ("TERM")) == 0 || tgetent(term_buffer, cp) <= 0) 1489 return; 1490 1491 v = tgetnum("li"); 1492 if (v >= 0) 1493 lines_per_page = v; 1494 else 1495 /* The number of lines per page is not mentioned 1496 in the terminal description. This probably means 1497 that paging is not useful (e.g. emacs shell window), 1498 so disable paging. */ 1499 lines_per_page = UINT_MAX; 1500 1501 v = tgetnum("co"); 1502 if (v >= 0) 1503 chars_per_line = v; 1504 } 1505 #endif 1506 1507 void 1508 _initialize_utils () 1509 { 1510 struct cmd_list_element *c; 1511 1512 c = add_set_cmd ("width", class_support, var_uinteger, 1513 (char *)&chars_per_line, 1514 "Set number of characters gdb thinks are in a line.", 1515 &setlist); 1516 add_show_from_set (c, &showlist); 1517 c->function.sfunc = set_width_command; 1518 1519 add_show_from_set 1520 (add_set_cmd ("height", class_support, 1521 var_uinteger, (char *)&lines_per_page, 1522 "Set number of lines gdb thinks are in a page.", &setlist), 1523 &showlist); 1524 1525 /* These defaults will be used if we are unable to get the correct 1526 values from termcap. */ 1527 #if defined(__GO32__) 1528 lines_per_page = ScreenRows(); 1529 chars_per_line = ScreenCols(); 1530 #else 1531 lines_per_page = 24; 1532 chars_per_line = 80; 1533 termdim(); 1534 #endif 1535 /* If the output is not a terminal, don't paginate it. */ 1536 if (!ISATTY (stdout)) 1537 lines_per_page = UINT_MAX; 1538 1539 set_width_command ((char *)NULL, 0, c); 1540 1541 add_show_from_set 1542 (add_set_cmd ("demangle", class_support, var_boolean, 1543 (char *)&demangle, 1544 "Set demangling of encoded C++ names when displaying symbols.", 1545 &setprintlist), 1546 &showprintlist); 1547 1548 add_show_from_set 1549 (add_set_cmd ("sevenbit-strings", class_support, var_boolean, 1550 (char *)&sevenbit_strings, 1551 "Set printing of 8-bit characters in strings as \\nnn.", 1552 &setprintlist), 1553 &showprintlist); 1554 1555 add_show_from_set 1556 (add_set_cmd ("asm-demangle", class_support, var_boolean, 1557 (char *)&asm_demangle, 1558 "Set demangling of C++ names in disassembly listings.", 1559 &setprintlist), 1560 &showprintlist); 1561 } 1562 1563 /* Machine specific function to handle SIGWINCH signal. */ 1564 1565 #ifdef SIGWINCH_HANDLER_BODY 1566 SIGWINCH_HANDLER_BODY 1567 #endif 1568