1 /* General utility routines for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 5 2009 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "gdb_assert.h" 24 #include <ctype.h> 25 #include "gdb_string.h" 26 #include "event-top.h" 27 #include "exceptions.h" 28 #include "gdbthread.h" 29 30 #ifdef TUI 31 #include "tui/tui.h" /* For tui_get_command_dimension. */ 32 #endif 33 34 #ifdef __GO32__ 35 #include <pc.h> 36 #endif 37 38 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */ 39 #ifdef reg 40 #undef reg 41 #endif 42 43 #include <signal.h> 44 #include "gdbcmd.h" 45 #include "serial.h" 46 #include "bfd.h" 47 #include "target.h" 48 #include "demangle.h" 49 #include "expression.h" 50 #include "language.h" 51 #include "charset.h" 52 #include "annotate.h" 53 #include "filenames.h" 54 #include "symfile.h" 55 #include "gdb_obstack.h" 56 #include "gdbcore.h" 57 #include "top.h" 58 59 #include "inferior.h" /* for signed_pointer_to_address */ 60 61 #include <sys/param.h> /* For MAXPATHLEN */ 62 63 #include "gdb_curses.h" 64 65 #include "readline/readline.h" 66 67 #include <sys/time.h> 68 #include <time.h> 69 70 #include "gdb_usleep.h" 71 72 #if !HAVE_DECL_MALLOC 73 extern PTR malloc (); /* ARI: PTR */ 74 #endif 75 #if !HAVE_DECL_REALLOC 76 extern PTR realloc (); /* ARI: PTR */ 77 #endif 78 #if !HAVE_DECL_FREE 79 extern void free (); 80 #endif 81 82 /* readline defines this. */ 83 #undef savestring 84 85 void (*deprecated_error_begin_hook) (void); 86 87 /* Prototypes for local functions */ 88 89 static void vfprintf_maybe_filtered (struct ui_file *, const char *, 90 va_list, int) ATTR_FORMAT (printf, 2, 0); 91 92 static void fputs_maybe_filtered (const char *, struct ui_file *, int); 93 94 static void do_my_cleanups (struct cleanup **, struct cleanup *); 95 96 static void prompt_for_continue (void); 97 98 static void set_screen_size (void); 99 static void set_width (void); 100 101 /* A flag indicating whether to timestamp debugging messages. */ 102 103 static int debug_timestamp = 0; 104 105 /* Chain of cleanup actions established with make_cleanup, 106 to be executed if an error happens. */ 107 108 static struct cleanup *cleanup_chain; /* cleaned up after a failed command */ 109 static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */ 110 111 /* Nonzero if we have job control. */ 112 113 int job_control; 114 115 /* Nonzero means a quit has been requested. */ 116 117 int quit_flag; 118 119 /* Nonzero means quit immediately if Control-C is typed now, rather 120 than waiting until QUIT is executed. Be careful in setting this; 121 code which executes with immediate_quit set has to be very careful 122 about being able to deal with being interrupted at any time. It is 123 almost always better to use QUIT; the only exception I can think of 124 is being able to quit out of a system call (using EINTR loses if 125 the SIGINT happens between the previous QUIT and the system call). 126 To immediately quit in the case in which a SIGINT happens between 127 the previous QUIT and setting immediate_quit (desirable anytime we 128 expect to block), call QUIT after setting immediate_quit. */ 129 130 int immediate_quit; 131 132 /* Nonzero means that encoded C++/ObjC names should be printed out in their 133 C++/ObjC form rather than raw. */ 134 135 int demangle = 1; 136 static void 137 show_demangle (struct ui_file *file, int from_tty, 138 struct cmd_list_element *c, const char *value) 139 { 140 fprintf_filtered (file, _("\ 141 Demangling of encoded C++/ObjC names when displaying symbols is %s.\n"), 142 value); 143 } 144 145 /* Nonzero means that encoded C++/ObjC names should be printed out in their 146 C++/ObjC form even in assembler language displays. If this is set, but 147 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */ 148 149 int asm_demangle = 0; 150 static void 151 show_asm_demangle (struct ui_file *file, int from_tty, 152 struct cmd_list_element *c, const char *value) 153 { 154 fprintf_filtered (file, _("\ 155 Demangling of C++/ObjC names in disassembly listings is %s.\n"), 156 value); 157 } 158 159 /* Nonzero means that strings with character values >0x7F should be printed 160 as octal escapes. Zero means just print the value (e.g. it's an 161 international character, and the terminal or window can cope.) */ 162 163 int sevenbit_strings = 0; 164 static void 165 show_sevenbit_strings (struct ui_file *file, int from_tty, 166 struct cmd_list_element *c, const char *value) 167 { 168 fprintf_filtered (file, _("\ 169 Printing of 8-bit characters in strings as \\nnn is %s.\n"), 170 value); 171 } 172 173 /* String to be printed before error messages, if any. */ 174 175 char *error_pre_print; 176 177 /* String to be printed before quit messages, if any. */ 178 179 char *quit_pre_print; 180 181 /* String to be printed before warning messages, if any. */ 182 183 char *warning_pre_print = "\nwarning: "; 184 185 int pagination_enabled = 1; 186 static void 187 show_pagination_enabled (struct ui_file *file, int from_tty, 188 struct cmd_list_element *c, const char *value) 189 { 190 fprintf_filtered (file, _("State of pagination is %s.\n"), value); 191 } 192 193 194 195 /* Add a new cleanup to the cleanup_chain, 196 and return the previous chain pointer 197 to be passed later to do_cleanups or discard_cleanups. 198 Args are FUNCTION to clean up with, and ARG to pass to it. */ 199 200 struct cleanup * 201 make_cleanup (make_cleanup_ftype *function, void *arg) 202 { 203 return make_my_cleanup (&cleanup_chain, function, arg); 204 } 205 206 struct cleanup * 207 make_cleanup_dtor (make_cleanup_ftype *function, void *arg, 208 void (*dtor) (void *)) 209 { 210 return make_my_cleanup2 (&cleanup_chain, 211 function, arg, dtor); 212 } 213 214 struct cleanup * 215 make_final_cleanup (make_cleanup_ftype *function, void *arg) 216 { 217 return make_my_cleanup (&final_cleanup_chain, function, arg); 218 } 219 220 static void 221 do_freeargv (void *arg) 222 { 223 freeargv ((char **) arg); 224 } 225 226 struct cleanup * 227 make_cleanup_freeargv (char **arg) 228 { 229 return make_my_cleanup (&cleanup_chain, do_freeargv, arg); 230 } 231 232 static void 233 do_bfd_close_cleanup (void *arg) 234 { 235 bfd_close (arg); 236 } 237 238 struct cleanup * 239 make_cleanup_bfd_close (bfd *abfd) 240 { 241 return make_cleanup (do_bfd_close_cleanup, abfd); 242 } 243 244 static void 245 do_close_cleanup (void *arg) 246 { 247 int *fd = arg; 248 close (*fd); 249 } 250 251 struct cleanup * 252 make_cleanup_close (int fd) 253 { 254 int *saved_fd = xmalloc (sizeof (fd)); 255 *saved_fd = fd; 256 return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree); 257 } 258 259 /* Helper function which does the work for make_cleanup_fclose. */ 260 261 static void 262 do_fclose_cleanup (void *arg) 263 { 264 FILE *file = arg; 265 fclose (arg); 266 } 267 268 /* Return a new cleanup that closes FILE. */ 269 270 struct cleanup * 271 make_cleanup_fclose (FILE *file) 272 { 273 return make_cleanup (do_fclose_cleanup, file); 274 } 275 276 /* Helper function which does the work for make_cleanup_obstack_free. */ 277 278 static void 279 do_obstack_free (void *arg) 280 { 281 struct obstack *ob = arg; 282 obstack_free (ob, NULL); 283 } 284 285 /* Return a new cleanup that frees OBSTACK. */ 286 287 struct cleanup * 288 make_cleanup_obstack_free (struct obstack *obstack) 289 { 290 return make_cleanup (do_obstack_free, obstack); 291 } 292 293 static void 294 do_ui_file_delete (void *arg) 295 { 296 ui_file_delete (arg); 297 } 298 299 struct cleanup * 300 make_cleanup_ui_file_delete (struct ui_file *arg) 301 { 302 return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg); 303 } 304 305 static void 306 do_free_section_addr_info (void *arg) 307 { 308 free_section_addr_info (arg); 309 } 310 311 struct cleanup * 312 make_cleanup_free_section_addr_info (struct section_addr_info *addrs) 313 { 314 return make_my_cleanup (&cleanup_chain, do_free_section_addr_info, addrs); 315 } 316 317 struct restore_integer_closure 318 { 319 int *variable; 320 int value; 321 }; 322 323 static void 324 restore_integer (void *p) 325 { 326 struct restore_integer_closure *closure = p; 327 *(closure->variable) = closure->value; 328 } 329 330 /* Remember the current value of *VARIABLE and make it restored when the cleanup 331 is run. */ 332 struct cleanup * 333 make_cleanup_restore_integer (int *variable) 334 { 335 struct restore_integer_closure *c = 336 xmalloc (sizeof (struct restore_integer_closure)); 337 c->variable = variable; 338 c->value = *variable; 339 340 return make_my_cleanup2 (&cleanup_chain, restore_integer, (void *)c, 341 xfree); 342 } 343 344 struct cleanup * 345 make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function, 346 void *arg, void (*free_arg) (void *)) 347 { 348 struct cleanup *new 349 = (struct cleanup *) xmalloc (sizeof (struct cleanup)); 350 struct cleanup *old_chain = *pmy_chain; 351 352 new->next = *pmy_chain; 353 new->function = function; 354 new->free_arg = free_arg; 355 new->arg = arg; 356 *pmy_chain = new; 357 358 return old_chain; 359 } 360 361 struct cleanup * 362 make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function, 363 void *arg) 364 { 365 return make_my_cleanup2 (pmy_chain, function, arg, NULL); 366 } 367 368 /* Discard cleanups and do the actions they describe 369 until we get back to the point OLD_CHAIN in the cleanup_chain. */ 370 371 void 372 do_cleanups (struct cleanup *old_chain) 373 { 374 do_my_cleanups (&cleanup_chain, old_chain); 375 } 376 377 void 378 do_final_cleanups (struct cleanup *old_chain) 379 { 380 do_my_cleanups (&final_cleanup_chain, old_chain); 381 } 382 383 static void 384 do_my_cleanups (struct cleanup **pmy_chain, 385 struct cleanup *old_chain) 386 { 387 struct cleanup *ptr; 388 while ((ptr = *pmy_chain) != old_chain) 389 { 390 *pmy_chain = ptr->next; /* Do this first incase recursion */ 391 (*ptr->function) (ptr->arg); 392 if (ptr->free_arg) 393 (*ptr->free_arg) (ptr->arg); 394 xfree (ptr); 395 } 396 } 397 398 /* Discard cleanups, not doing the actions they describe, 399 until we get back to the point OLD_CHAIN in the cleanup_chain. */ 400 401 void 402 discard_cleanups (struct cleanup *old_chain) 403 { 404 discard_my_cleanups (&cleanup_chain, old_chain); 405 } 406 407 void 408 discard_final_cleanups (struct cleanup *old_chain) 409 { 410 discard_my_cleanups (&final_cleanup_chain, old_chain); 411 } 412 413 void 414 discard_my_cleanups (struct cleanup **pmy_chain, 415 struct cleanup *old_chain) 416 { 417 struct cleanup *ptr; 418 while ((ptr = *pmy_chain) != old_chain) 419 { 420 *pmy_chain = ptr->next; 421 if (ptr->free_arg) 422 (*ptr->free_arg) (ptr->arg); 423 xfree (ptr); 424 } 425 } 426 427 /* Set the cleanup_chain to 0, and return the old cleanup chain. */ 428 struct cleanup * 429 save_cleanups (void) 430 { 431 return save_my_cleanups (&cleanup_chain); 432 } 433 434 struct cleanup * 435 save_final_cleanups (void) 436 { 437 return save_my_cleanups (&final_cleanup_chain); 438 } 439 440 struct cleanup * 441 save_my_cleanups (struct cleanup **pmy_chain) 442 { 443 struct cleanup *old_chain = *pmy_chain; 444 445 *pmy_chain = 0; 446 return old_chain; 447 } 448 449 /* Restore the cleanup chain from a previously saved chain. */ 450 void 451 restore_cleanups (struct cleanup *chain) 452 { 453 restore_my_cleanups (&cleanup_chain, chain); 454 } 455 456 void 457 restore_final_cleanups (struct cleanup *chain) 458 { 459 restore_my_cleanups (&final_cleanup_chain, chain); 460 } 461 462 void 463 restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain) 464 { 465 *pmy_chain = chain; 466 } 467 468 /* This function is useful for cleanups. 469 Do 470 471 foo = xmalloc (...); 472 old_chain = make_cleanup (free_current_contents, &foo); 473 474 to arrange to free the object thus allocated. */ 475 476 void 477 free_current_contents (void *ptr) 478 { 479 void **location = ptr; 480 if (location == NULL) 481 internal_error (__FILE__, __LINE__, 482 _("free_current_contents: NULL pointer")); 483 if (*location != NULL) 484 { 485 xfree (*location); 486 *location = NULL; 487 } 488 } 489 490 /* Provide a known function that does nothing, to use as a base for 491 for a possibly long chain of cleanups. This is useful where we 492 use the cleanup chain for handling normal cleanups as well as dealing 493 with cleanups that need to be done as a result of a call to error(). 494 In such cases, we may not be certain where the first cleanup is, unless 495 we have a do-nothing one to always use as the base. */ 496 497 void 498 null_cleanup (void *arg) 499 { 500 } 501 502 /* Continuations are implemented as cleanups internally. Inherit from 503 cleanups. */ 504 struct continuation 505 { 506 struct cleanup base; 507 }; 508 509 /* Add a continuation to the continuation list of THREAD. The new 510 continuation will be added at the front. */ 511 void 512 add_continuation (struct thread_info *thread, 513 void (*continuation_hook) (void *), void *args, 514 void (*continuation_free_args) (void *)) 515 { 516 struct cleanup *as_cleanup = &thread->continuations->base; 517 make_cleanup_ftype *continuation_hook_fn = continuation_hook; 518 519 make_my_cleanup2 (&as_cleanup, 520 continuation_hook_fn, 521 args, 522 continuation_free_args); 523 524 thread->continuations = (struct continuation *) as_cleanup; 525 } 526 527 /* Add a continuation to the continuation list of INFERIOR. The new 528 continuation will be added at the front. */ 529 530 void 531 add_inferior_continuation (void (*continuation_hook) (void *), void *args, 532 void (*continuation_free_args) (void *)) 533 { 534 struct inferior *inf = current_inferior (); 535 struct cleanup *as_cleanup = &inf->continuations->base; 536 make_cleanup_ftype *continuation_hook_fn = continuation_hook; 537 538 make_my_cleanup2 (&as_cleanup, 539 continuation_hook_fn, 540 args, 541 continuation_free_args); 542 543 inf->continuations = (struct continuation *) as_cleanup; 544 } 545 546 /* Do all continuations of the current inferior. */ 547 548 void 549 do_all_inferior_continuations (void) 550 { 551 struct cleanup *old_chain; 552 struct cleanup *as_cleanup; 553 struct inferior *inf = current_inferior (); 554 555 if (inf->continuations == NULL) 556 return; 557 558 /* Copy the list header into another pointer, and set the global 559 list header to null, so that the global list can change as a side 560 effect of invoking the continuations and the processing of the 561 preexisting continuations will not be affected. */ 562 563 as_cleanup = &inf->continuations->base; 564 inf->continuations = NULL; 565 566 /* Work now on the list we have set aside. */ 567 do_my_cleanups (&as_cleanup, NULL); 568 } 569 570 /* Get rid of all the inferior-wide continuations of INF. */ 571 572 void 573 discard_all_inferior_continuations (struct inferior *inf) 574 { 575 struct cleanup *continuation_ptr = &inf->continuations->base; 576 discard_my_cleanups (&continuation_ptr, NULL); 577 inf->continuations = NULL; 578 } 579 580 static void 581 restore_thread_cleanup (void *arg) 582 { 583 ptid_t *ptid_p = arg; 584 switch_to_thread (*ptid_p); 585 } 586 587 /* Walk down the continuation list of PTID, and execute all the 588 continuations. There is a problem though. In some cases new 589 continuations may be added while we are in the middle of this loop. 590 If this happens they will be added in the front, and done before we 591 have a chance of exhausting those that were already there. We need 592 to then save the beginning of the list in a pointer and do the 593 continuations from there on, instead of using the global beginning 594 of list as our iteration pointer. */ 595 static void 596 do_all_continuations_ptid (ptid_t ptid, 597 struct continuation **continuations_p) 598 { 599 struct cleanup *old_chain; 600 ptid_t current_thread; 601 struct cleanup *as_cleanup; 602 603 if (*continuations_p == NULL) 604 return; 605 606 current_thread = inferior_ptid; 607 608 /* Restore selected thread on exit. Don't try to restore the frame 609 as well, because: 610 611 - When running continuations, the selected frame is always #0. 612 613 - The continuations may trigger symbol file loads, which may 614 change the frame layout (frame ids change), which would trigger 615 a warning if we used make_cleanup_restore_current_thread. */ 616 617 old_chain = make_cleanup (restore_thread_cleanup, ¤t_thread); 618 619 /* Let the continuation see this thread as selected. */ 620 switch_to_thread (ptid); 621 622 /* Copy the list header into another pointer, and set the global 623 list header to null, so that the global list can change as a side 624 effect of invoking the continuations and the processing of the 625 preexisting continuations will not be affected. */ 626 627 as_cleanup = &(*continuations_p)->base; 628 *continuations_p = NULL; 629 630 /* Work now on the list we have set aside. */ 631 do_my_cleanups (&as_cleanup, NULL); 632 633 do_cleanups (old_chain); 634 } 635 636 /* Callback for iterate over threads. */ 637 static int 638 do_all_continuations_thread_callback (struct thread_info *thread, void *data) 639 { 640 do_all_continuations_ptid (thread->ptid, &thread->continuations); 641 return 0; 642 } 643 644 /* Do all continuations of thread THREAD. */ 645 void 646 do_all_continuations_thread (struct thread_info *thread) 647 { 648 do_all_continuations_thread_callback (thread, NULL); 649 } 650 651 /* Do all continuations of all threads. */ 652 void 653 do_all_continuations (void) 654 { 655 iterate_over_threads (do_all_continuations_thread_callback, NULL); 656 } 657 658 /* Callback for iterate over threads. */ 659 static int 660 discard_all_continuations_thread_callback (struct thread_info *thread, 661 void *data) 662 { 663 struct cleanup *continuation_ptr = &thread->continuations->base; 664 discard_my_cleanups (&continuation_ptr, NULL); 665 thread->continuations = NULL; 666 return 0; 667 } 668 669 /* Get rid of all the continuations of THREAD. */ 670 void 671 discard_all_continuations_thread (struct thread_info *thread) 672 { 673 discard_all_continuations_thread_callback (thread, NULL); 674 } 675 676 /* Get rid of all the continuations of all threads. */ 677 void 678 discard_all_continuations (void) 679 { 680 iterate_over_threads (discard_all_continuations_thread_callback, NULL); 681 } 682 683 684 /* Add a continuation to the intermediate continuation list of THREAD. 685 The new continuation will be added at the front. */ 686 void 687 add_intermediate_continuation (struct thread_info *thread, 688 void (*continuation_hook) 689 (void *), void *args, 690 void (*continuation_free_args) (void *)) 691 { 692 struct cleanup *as_cleanup = &thread->intermediate_continuations->base; 693 make_cleanup_ftype *continuation_hook_fn = continuation_hook; 694 695 make_my_cleanup2 (&as_cleanup, 696 continuation_hook_fn, 697 args, 698 continuation_free_args); 699 700 thread->intermediate_continuations = (struct continuation *) as_cleanup; 701 } 702 703 /* Walk down the cmd_continuation list, and execute all the 704 continuations. There is a problem though. In some cases new 705 continuations may be added while we are in the middle of this 706 loop. If this happens they will be added in the front, and done 707 before we have a chance of exhausting those that were already 708 there. We need to then save the beginning of the list in a pointer 709 and do the continuations from there on, instead of using the 710 global beginning of list as our iteration pointer.*/ 711 static int 712 do_all_intermediate_continuations_thread_callback (struct thread_info *thread, 713 void *data) 714 { 715 do_all_continuations_ptid (thread->ptid, 716 &thread->intermediate_continuations); 717 return 0; 718 } 719 720 /* Do all intermediate continuations of thread THREAD. */ 721 void 722 do_all_intermediate_continuations_thread (struct thread_info *thread) 723 { 724 do_all_intermediate_continuations_thread_callback (thread, NULL); 725 } 726 727 /* Do all intermediate continuations of all threads. */ 728 void 729 do_all_intermediate_continuations (void) 730 { 731 iterate_over_threads (do_all_intermediate_continuations_thread_callback, NULL); 732 } 733 734 /* Callback for iterate over threads. */ 735 static int 736 discard_all_intermediate_continuations_thread_callback (struct thread_info *thread, 737 void *data) 738 { 739 struct cleanup *continuation_ptr = &thread->intermediate_continuations->base; 740 discard_my_cleanups (&continuation_ptr, NULL); 741 thread->intermediate_continuations = NULL; 742 return 0; 743 } 744 745 /* Get rid of all the intermediate continuations of THREAD. */ 746 void 747 discard_all_intermediate_continuations_thread (struct thread_info *thread) 748 { 749 discard_all_intermediate_continuations_thread_callback (thread, NULL); 750 } 751 752 /* Get rid of all the intermediate continuations of all threads. */ 753 void 754 discard_all_intermediate_continuations (void) 755 { 756 iterate_over_threads (discard_all_intermediate_continuations_thread_callback, NULL); 757 } 758 759 760 761 /* Print a warning message. The first argument STRING is the warning 762 message, used as an fprintf format string, the second is the 763 va_list of arguments for that string. A warning is unfiltered (not 764 paginated) so that the user does not need to page through each 765 screen full of warnings when there are lots of them. */ 766 767 void 768 vwarning (const char *string, va_list args) 769 { 770 if (deprecated_warning_hook) 771 (*deprecated_warning_hook) (string, args); 772 else 773 { 774 target_terminal_ours (); 775 wrap_here (""); /* Force out any buffered output */ 776 gdb_flush (gdb_stdout); 777 if (warning_pre_print) 778 fputs_unfiltered (warning_pre_print, gdb_stderr); 779 vfprintf_unfiltered (gdb_stderr, string, args); 780 fprintf_unfiltered (gdb_stderr, "\n"); 781 va_end (args); 782 } 783 } 784 785 /* Print a warning message. 786 The first argument STRING is the warning message, used as a fprintf string, 787 and the remaining args are passed as arguments to it. 788 The primary difference between warnings and errors is that a warning 789 does not force the return to command level. */ 790 791 void 792 warning (const char *string, ...) 793 { 794 va_list args; 795 va_start (args, string); 796 vwarning (string, args); 797 va_end (args); 798 } 799 800 /* Print an error message and return to command level. 801 The first argument STRING is the error message, used as a fprintf string, 802 and the remaining args are passed as arguments to it. */ 803 804 NORETURN void 805 verror (const char *string, va_list args) 806 { 807 throw_verror (GENERIC_ERROR, string, args); 808 } 809 810 NORETURN void 811 error (const char *string, ...) 812 { 813 va_list args; 814 va_start (args, string); 815 throw_verror (GENERIC_ERROR, string, args); 816 va_end (args); 817 } 818 819 /* Print an error message and quit. 820 The first argument STRING is the error message, used as a fprintf string, 821 and the remaining args are passed as arguments to it. */ 822 823 NORETURN void 824 vfatal (const char *string, va_list args) 825 { 826 throw_vfatal (string, args); 827 } 828 829 NORETURN void 830 fatal (const char *string, ...) 831 { 832 va_list args; 833 va_start (args, string); 834 throw_vfatal (string, args); 835 va_end (args); 836 } 837 838 NORETURN void 839 error_stream (struct ui_file *stream) 840 { 841 char *message = ui_file_xstrdup (stream, NULL); 842 make_cleanup (xfree, message); 843 error (("%s"), message); 844 } 845 846 /* Allow the user to configure the debugger behavior with respect to 847 what to do when an internal problem is detected. */ 848 849 const char internal_problem_ask[] = "ask"; 850 const char internal_problem_yes[] = "yes"; 851 const char internal_problem_no[] = "no"; 852 static const char *internal_problem_modes[] = 853 { 854 internal_problem_ask, 855 internal_problem_yes, 856 internal_problem_no, 857 NULL 858 }; 859 static const char *internal_problem_mode = internal_problem_ask; 860 861 /* Print a message reporting an internal error/warning. Ask the user 862 if they want to continue, dump core, or just exit. Return 863 something to indicate a quit. */ 864 865 struct internal_problem 866 { 867 const char *name; 868 const char *should_quit; 869 const char *should_dump_core; 870 }; 871 872 /* Report a problem, internal to GDB, to the user. Once the problem 873 has been reported, and assuming GDB didn't quit, the caller can 874 either allow execution to resume or throw an error. */ 875 876 static void ATTR_FORMAT (printf, 4, 0) 877 internal_vproblem (struct internal_problem *problem, 878 const char *file, int line, const char *fmt, va_list ap) 879 { 880 static int dejavu; 881 int quit_p; 882 int dump_core_p; 883 char *reason; 884 885 /* Don't allow infinite error/warning recursion. */ 886 { 887 static char msg[] = "Recursive internal problem.\n"; 888 switch (dejavu) 889 { 890 case 0: 891 dejavu = 1; 892 break; 893 case 1: 894 dejavu = 2; 895 fputs_unfiltered (msg, gdb_stderr); 896 abort (); /* NOTE: GDB has only four calls to abort(). */ 897 default: 898 dejavu = 3; 899 /* Newer GLIBC versions put the warn_unused_result attribute 900 on write, but this is one of those rare cases where 901 ignoring the return value is correct. Casting to (void) 902 does not fix this problem. This is the solution suggested 903 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */ 904 if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg)) 905 abort (); /* NOTE: GDB has only four calls to abort(). */ 906 exit (1); 907 } 908 } 909 910 /* Try to get the message out and at the start of a new line. */ 911 target_terminal_ours (); 912 begin_line (); 913 914 /* Create a string containing the full error/warning message. Need 915 to call query with this full string, as otherwize the reason 916 (error/warning) and question become separated. Format using a 917 style similar to a compiler error message. Include extra detail 918 so that the user knows that they are living on the edge. */ 919 { 920 char *msg; 921 msg = xstrvprintf (fmt, ap); 922 reason = xstrprintf ("\ 923 %s:%d: %s: %s\n\ 924 A problem internal to GDB has been detected,\n\ 925 further debugging may prove unreliable.", file, line, problem->name, msg); 926 xfree (msg); 927 make_cleanup (xfree, reason); 928 } 929 930 if (problem->should_quit == internal_problem_ask) 931 { 932 /* Default (yes/batch case) is to quit GDB. When in batch mode 933 this lessens the likelihood of GDB going into an infinite 934 loop. */ 935 if (caution == 0) 936 { 937 /* Emit the message and quit. */ 938 fputs_unfiltered (reason, gdb_stderr); 939 fputs_unfiltered ("\n", gdb_stderr); 940 quit_p = 1; 941 } 942 else 943 quit_p = query (_("%s\nQuit this debugging session? "), reason); 944 } 945 else if (problem->should_quit == internal_problem_yes) 946 quit_p = 1; 947 else if (problem->should_quit == internal_problem_no) 948 quit_p = 0; 949 else 950 internal_error (__FILE__, __LINE__, _("bad switch")); 951 952 if (problem->should_dump_core == internal_problem_ask) 953 { 954 /* Default (yes/batch case) is to dump core. This leaves a GDB 955 `dropping' so that it is easier to see that something went 956 wrong in GDB. */ 957 dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason); 958 } 959 else if (problem->should_dump_core == internal_problem_yes) 960 dump_core_p = 1; 961 else if (problem->should_dump_core == internal_problem_no) 962 dump_core_p = 0; 963 else 964 internal_error (__FILE__, __LINE__, _("bad switch")); 965 966 if (quit_p) 967 { 968 if (dump_core_p) 969 abort (); /* NOTE: GDB has only four calls to abort(). */ 970 else 971 exit (1); 972 } 973 else 974 { 975 if (dump_core_p) 976 { 977 #ifdef HAVE_WORKING_FORK 978 if (fork () == 0) 979 abort (); /* NOTE: GDB has only four calls to abort(). */ 980 #endif 981 } 982 } 983 984 dejavu = 0; 985 } 986 987 static struct internal_problem internal_error_problem = { 988 "internal-error", internal_problem_ask, internal_problem_ask 989 }; 990 991 NORETURN void 992 internal_verror (const char *file, int line, const char *fmt, va_list ap) 993 { 994 internal_vproblem (&internal_error_problem, file, line, fmt, ap); 995 deprecated_throw_reason (RETURN_ERROR); 996 } 997 998 NORETURN void 999 internal_error (const char *file, int line, const char *string, ...) 1000 { 1001 va_list ap; 1002 va_start (ap, string); 1003 internal_verror (file, line, string, ap); 1004 va_end (ap); 1005 } 1006 1007 static struct internal_problem internal_warning_problem = { 1008 "internal-warning", internal_problem_ask, internal_problem_ask 1009 }; 1010 1011 void 1012 internal_vwarning (const char *file, int line, const char *fmt, va_list ap) 1013 { 1014 internal_vproblem (&internal_warning_problem, file, line, fmt, ap); 1015 } 1016 1017 void 1018 internal_warning (const char *file, int line, const char *string, ...) 1019 { 1020 va_list ap; 1021 va_start (ap, string); 1022 internal_vwarning (file, line, string, ap); 1023 va_end (ap); 1024 } 1025 1026 /* Dummy functions to keep add_prefix_cmd happy. */ 1027 1028 static void 1029 set_internal_problem_cmd (char *args, int from_tty) 1030 { 1031 } 1032 1033 static void 1034 show_internal_problem_cmd (char *args, int from_tty) 1035 { 1036 } 1037 1038 /* When GDB reports an internal problem (error or warning) it gives 1039 the user the opportunity to quit GDB and/or create a core file of 1040 the current debug session. This function registers a few commands 1041 that make it possible to specify that GDB should always or never 1042 quit or create a core file, without asking. The commands look 1043 like: 1044 1045 maint set PROBLEM-NAME quit ask|yes|no 1046 maint show PROBLEM-NAME quit 1047 maint set PROBLEM-NAME corefile ask|yes|no 1048 maint show PROBLEM-NAME corefile 1049 1050 Where PROBLEM-NAME is currently "internal-error" or 1051 "internal-warning". */ 1052 1053 static void 1054 add_internal_problem_command (struct internal_problem *problem) 1055 { 1056 struct cmd_list_element **set_cmd_list; 1057 struct cmd_list_element **show_cmd_list; 1058 char *set_doc; 1059 char *show_doc; 1060 1061 set_cmd_list = xmalloc (sizeof (*set_cmd_list)); 1062 show_cmd_list = xmalloc (sizeof (*set_cmd_list)); 1063 *set_cmd_list = NULL; 1064 *show_cmd_list = NULL; 1065 1066 set_doc = xstrprintf (_("Configure what GDB does when %s is detected."), 1067 problem->name); 1068 1069 show_doc = xstrprintf (_("Show what GDB does when %s is detected."), 1070 problem->name); 1071 1072 add_prefix_cmd ((char*) problem->name, 1073 class_maintenance, set_internal_problem_cmd, set_doc, 1074 set_cmd_list, 1075 concat ("maintenance set ", problem->name, " ", NULL), 1076 0/*allow-unknown*/, &maintenance_set_cmdlist); 1077 1078 add_prefix_cmd ((char*) problem->name, 1079 class_maintenance, show_internal_problem_cmd, show_doc, 1080 show_cmd_list, 1081 concat ("maintenance show ", problem->name, " ", NULL), 1082 0/*allow-unknown*/, &maintenance_show_cmdlist); 1083 1084 set_doc = xstrprintf (_("\ 1085 Set whether GDB should quit when an %s is detected"), 1086 problem->name); 1087 show_doc = xstrprintf (_("\ 1088 Show whether GDB will quit when an %s is detected"), 1089 problem->name); 1090 add_setshow_enum_cmd ("quit", class_maintenance, 1091 internal_problem_modes, 1092 &problem->should_quit, 1093 set_doc, 1094 show_doc, 1095 NULL, /* help_doc */ 1096 NULL, /* setfunc */ 1097 NULL, /* showfunc */ 1098 set_cmd_list, 1099 show_cmd_list); 1100 1101 xfree (set_doc); 1102 xfree (show_doc); 1103 1104 set_doc = xstrprintf (_("\ 1105 Set whether GDB should create a core file of GDB when %s is detected"), 1106 problem->name); 1107 show_doc = xstrprintf (_("\ 1108 Show whether GDB will create a core file of GDB when %s is detected"), 1109 problem->name); 1110 add_setshow_enum_cmd ("corefile", class_maintenance, 1111 internal_problem_modes, 1112 &problem->should_dump_core, 1113 set_doc, 1114 show_doc, 1115 NULL, /* help_doc */ 1116 NULL, /* setfunc */ 1117 NULL, /* showfunc */ 1118 set_cmd_list, 1119 show_cmd_list); 1120 1121 xfree (set_doc); 1122 xfree (show_doc); 1123 } 1124 1125 /* Print the system error message for errno, and also mention STRING 1126 as the file name for which the error was encountered. 1127 Then return to command level. */ 1128 1129 NORETURN void 1130 perror_with_name (const char *string) 1131 { 1132 char *err; 1133 char *combined; 1134 1135 err = safe_strerror (errno); 1136 combined = (char *) alloca (strlen (err) + strlen (string) + 3); 1137 strcpy (combined, string); 1138 strcat (combined, ": "); 1139 strcat (combined, err); 1140 1141 /* I understand setting these is a matter of taste. Still, some people 1142 may clear errno but not know about bfd_error. Doing this here is not 1143 unreasonable. */ 1144 bfd_set_error (bfd_error_no_error); 1145 errno = 0; 1146 1147 error (_("%s."), combined); 1148 } 1149 1150 /* Print the system error message for ERRCODE, and also mention STRING 1151 as the file name for which the error was encountered. */ 1152 1153 void 1154 print_sys_errmsg (const char *string, int errcode) 1155 { 1156 char *err; 1157 char *combined; 1158 1159 err = safe_strerror (errcode); 1160 combined = (char *) alloca (strlen (err) + strlen (string) + 3); 1161 strcpy (combined, string); 1162 strcat (combined, ": "); 1163 strcat (combined, err); 1164 1165 /* We want anything which was printed on stdout to come out first, before 1166 this message. */ 1167 gdb_flush (gdb_stdout); 1168 fprintf_unfiltered (gdb_stderr, "%s.\n", combined); 1169 } 1170 1171 /* Control C eventually causes this to be called, at a convenient time. */ 1172 1173 void 1174 quit (void) 1175 { 1176 #ifdef __MSDOS__ 1177 /* No steenking SIGINT will ever be coming our way when the 1178 program is resumed. Don't lie. */ 1179 fatal ("Quit"); 1180 #else 1181 if (job_control 1182 /* If there is no terminal switching for this target, then we can't 1183 possibly get screwed by the lack of job control. */ 1184 || current_target.to_terminal_ours == NULL) 1185 fatal ("Quit"); 1186 else 1187 fatal ("Quit (expect signal SIGINT when the program is resumed)"); 1188 #endif 1189 } 1190 1191 1192 /* Called when a memory allocation fails, with the number of bytes of 1193 memory requested in SIZE. */ 1194 1195 NORETURN void 1196 nomem (long size) 1197 { 1198 if (size > 0) 1199 { 1200 internal_error (__FILE__, __LINE__, 1201 _("virtual memory exhausted: can't allocate %ld bytes."), 1202 size); 1203 } 1204 else 1205 { 1206 internal_error (__FILE__, __LINE__, _("virtual memory exhausted.")); 1207 } 1208 } 1209 1210 /* The xmalloc() (libiberty.h) family of memory management routines. 1211 1212 These are like the ISO-C malloc() family except that they implement 1213 consistent semantics and guard against typical memory management 1214 problems. */ 1215 1216 /* NOTE: These are declared using PTR to ensure consistency with 1217 "libiberty.h". xfree() is GDB local. */ 1218 1219 PTR /* ARI: PTR */ 1220 xmalloc (size_t size) 1221 { 1222 void *val; 1223 1224 /* See libiberty/xmalloc.c. This function need's to match that's 1225 semantics. It never returns NULL. */ 1226 if (size == 0) 1227 size = 1; 1228 1229 val = malloc (size); /* ARI: malloc */ 1230 if (val == NULL) 1231 nomem (size); 1232 1233 return (val); 1234 } 1235 1236 void * 1237 xzalloc (size_t size) 1238 { 1239 return xcalloc (1, size); 1240 } 1241 1242 PTR /* ARI: PTR */ 1243 xrealloc (PTR ptr, size_t size) /* ARI: PTR */ 1244 { 1245 void *val; 1246 1247 /* See libiberty/xmalloc.c. This function need's to match that's 1248 semantics. It never returns NULL. */ 1249 if (size == 0) 1250 size = 1; 1251 1252 if (ptr != NULL) 1253 val = realloc (ptr, size); /* ARI: realloc */ 1254 else 1255 val = malloc (size); /* ARI: malloc */ 1256 if (val == NULL) 1257 nomem (size); 1258 1259 return (val); 1260 } 1261 1262 PTR /* ARI: PTR */ 1263 xcalloc (size_t number, size_t size) 1264 { 1265 void *mem; 1266 1267 /* See libiberty/xmalloc.c. This function need's to match that's 1268 semantics. It never returns NULL. */ 1269 if (number == 0 || size == 0) 1270 { 1271 number = 1; 1272 size = 1; 1273 } 1274 1275 mem = calloc (number, size); /* ARI: xcalloc */ 1276 if (mem == NULL) 1277 nomem (number * size); 1278 1279 return mem; 1280 } 1281 1282 void 1283 xfree (void *ptr) 1284 { 1285 if (ptr != NULL) 1286 free (ptr); /* ARI: free */ 1287 } 1288 1289 1290 /* Like asprintf/vasprintf but get an internal_error if the call 1291 fails. */ 1292 1293 char * 1294 xstrprintf (const char *format, ...) 1295 { 1296 char *ret; 1297 va_list args; 1298 va_start (args, format); 1299 ret = xstrvprintf (format, args); 1300 va_end (args); 1301 return ret; 1302 } 1303 1304 void 1305 xasprintf (char **ret, const char *format, ...) 1306 { 1307 va_list args; 1308 va_start (args, format); 1309 (*ret) = xstrvprintf (format, args); 1310 va_end (args); 1311 } 1312 1313 void 1314 xvasprintf (char **ret, const char *format, va_list ap) 1315 { 1316 (*ret) = xstrvprintf (format, ap); 1317 } 1318 1319 char * 1320 xstrvprintf (const char *format, va_list ap) 1321 { 1322 char *ret = NULL; 1323 int status = vasprintf (&ret, format, ap); 1324 /* NULL is returned when there was a memory allocation problem, or 1325 any other error (for instance, a bad format string). A negative 1326 status (the printed length) with a non-NULL buffer should never 1327 happen, but just to be sure. */ 1328 if (ret == NULL || status < 0) 1329 internal_error (__FILE__, __LINE__, _("vasprintf call failed")); 1330 return ret; 1331 } 1332 1333 int 1334 xsnprintf (char *str, size_t size, const char *format, ...) 1335 { 1336 va_list args; 1337 int ret; 1338 1339 va_start (args, format); 1340 ret = vsnprintf (str, size, format, args); 1341 gdb_assert (ret < size); 1342 va_end (args); 1343 1344 return ret; 1345 } 1346 1347 /* My replacement for the read system call. 1348 Used like `read' but keeps going if `read' returns too soon. */ 1349 1350 int 1351 myread (int desc, char *addr, int len) 1352 { 1353 int val; 1354 int orglen = len; 1355 1356 while (len > 0) 1357 { 1358 val = read (desc, addr, len); 1359 if (val < 0) 1360 return val; 1361 if (val == 0) 1362 return orglen - len; 1363 len -= val; 1364 addr += val; 1365 } 1366 return orglen; 1367 } 1368 1369 /* Make a copy of the string at PTR with SIZE characters 1370 (and add a null character at the end in the copy). 1371 Uses malloc to get the space. Returns the address of the copy. */ 1372 1373 char * 1374 savestring (const char *ptr, size_t size) 1375 { 1376 char *p = (char *) xmalloc (size + 1); 1377 memcpy (p, ptr, size); 1378 p[size] = 0; 1379 return p; 1380 } 1381 1382 void 1383 print_spaces (int n, struct ui_file *file) 1384 { 1385 fputs_unfiltered (n_spaces (n), file); 1386 } 1387 1388 /* Print a host address. */ 1389 1390 void 1391 gdb_print_host_address (const void *addr, struct ui_file *stream) 1392 { 1393 fprintf_filtered (stream, "%s", host_address_to_string (addr)); 1394 } 1395 1396 1397 /* This function supports the query, nquery, and yquery functions. 1398 Ask user a y-or-n question and return 0 if answer is no, 1 if 1399 answer is yes, or default the answer to the specified default 1400 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a 1401 default answer, or '\0' for no default. 1402 CTLSTR is the control string and should end in "? ". It should 1403 not say how to answer, because we do that. 1404 ARGS are the arguments passed along with the CTLSTR argument to 1405 printf. */ 1406 1407 static int ATTR_FORMAT (printf, 1, 0) 1408 defaulted_query (const char *ctlstr, const char defchar, va_list args) 1409 { 1410 int answer; 1411 int ans2; 1412 int retval; 1413 int def_value; 1414 char def_answer, not_def_answer; 1415 char *y_string, *n_string, *question; 1416 1417 /* Set up according to which answer is the default. */ 1418 if (defchar == '\0') 1419 { 1420 def_value = 1; 1421 def_answer = 'Y'; 1422 not_def_answer = 'N'; 1423 y_string = "y"; 1424 n_string = "n"; 1425 } 1426 else if (defchar == 'y') 1427 { 1428 def_value = 1; 1429 def_answer = 'Y'; 1430 not_def_answer = 'N'; 1431 y_string = "[y]"; 1432 n_string = "n"; 1433 } 1434 else 1435 { 1436 def_value = 0; 1437 def_answer = 'N'; 1438 not_def_answer = 'Y'; 1439 y_string = "y"; 1440 n_string = "[n]"; 1441 } 1442 1443 /* Automatically answer the default value if the user did not want 1444 prompts or the command was issued with the server prefix. */ 1445 if (! caution || server_command) 1446 return def_value; 1447 1448 /* If input isn't coming from the user directly, just say what 1449 question we're asking, and then answer the default automatically. This 1450 way, important error messages don't get lost when talking to GDB 1451 over a pipe. */ 1452 if (! input_from_terminal_p ()) 1453 { 1454 wrap_here (""); 1455 vfprintf_filtered (gdb_stdout, ctlstr, args); 1456 1457 printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"), 1458 y_string, n_string, def_answer); 1459 gdb_flush (gdb_stdout); 1460 1461 return def_value; 1462 } 1463 1464 if (deprecated_query_hook) 1465 { 1466 return deprecated_query_hook (ctlstr, args); 1467 } 1468 1469 /* Format the question outside of the loop, to avoid reusing args. */ 1470 question = xstrvprintf (ctlstr, args); 1471 1472 while (1) 1473 { 1474 wrap_here (""); /* Flush any buffered output */ 1475 gdb_flush (gdb_stdout); 1476 1477 if (annotation_level > 1) 1478 printf_filtered (("\n\032\032pre-query\n")); 1479 1480 fputs_filtered (question, gdb_stdout); 1481 printf_filtered (_("(%s or %s) "), y_string, n_string); 1482 1483 if (annotation_level > 1) 1484 printf_filtered (("\n\032\032query\n")); 1485 1486 wrap_here (""); 1487 gdb_flush (gdb_stdout); 1488 1489 answer = fgetc (stdin); 1490 1491 /* We expect fgetc to block until a character is read. But 1492 this may not be the case if the terminal was opened with 1493 the NONBLOCK flag. In that case, if there is nothing to 1494 read on stdin, fgetc returns EOF, but also sets the error 1495 condition flag on stdin and errno to EAGAIN. With a true 1496 EOF, stdin's error condition flag is not set. 1497 1498 A situation where this behavior was observed is a pseudo 1499 terminal on AIX. */ 1500 while (answer == EOF && ferror (stdin) && errno == EAGAIN) 1501 { 1502 /* Not a real EOF. Wait a little while and try again until 1503 we read something. */ 1504 clearerr (stdin); 1505 gdb_usleep (10000); 1506 answer = fgetc (stdin); 1507 } 1508 1509 clearerr (stdin); /* in case of C-d */ 1510 if (answer == EOF) /* C-d */ 1511 { 1512 printf_filtered ("EOF [assumed %c]\n", def_answer); 1513 retval = def_value; 1514 break; 1515 } 1516 /* Eat rest of input line, to EOF or newline */ 1517 if (answer != '\n') 1518 do 1519 { 1520 ans2 = fgetc (stdin); 1521 clearerr (stdin); 1522 } 1523 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r'); 1524 1525 if (answer >= 'a') 1526 answer -= 040; 1527 /* Check answer. For the non-default, the user must specify 1528 the non-default explicitly. */ 1529 if (answer == not_def_answer) 1530 { 1531 retval = !def_value; 1532 break; 1533 } 1534 /* Otherwise, if a default was specified, the user may either 1535 specify the required input or have it default by entering 1536 nothing. */ 1537 if (answer == def_answer 1538 || (defchar != '\0' && 1539 (answer == '\n' || answer == '\r' || answer == EOF))) 1540 { 1541 retval = def_value; 1542 break; 1543 } 1544 /* Invalid entries are not defaulted and require another selection. */ 1545 printf_filtered (_("Please answer %s or %s.\n"), 1546 y_string, n_string); 1547 } 1548 1549 xfree (question); 1550 if (annotation_level > 1) 1551 printf_filtered (("\n\032\032post-query\n")); 1552 return retval; 1553 } 1554 1555 1556 /* Ask user a y-or-n question and return 0 if answer is no, 1 if 1557 answer is yes, or 0 if answer is defaulted. 1558 Takes three args which are given to printf to print the question. 1559 The first, a control string, should end in "? ". 1560 It should not say how to answer, because we do that. */ 1561 1562 int 1563 nquery (const char *ctlstr, ...) 1564 { 1565 va_list args; 1566 1567 va_start (args, ctlstr); 1568 return defaulted_query (ctlstr, 'n', args); 1569 va_end (args); 1570 } 1571 1572 /* Ask user a y-or-n question and return 0 if answer is no, 1 if 1573 answer is yes, or 1 if answer is defaulted. 1574 Takes three args which are given to printf to print the question. 1575 The first, a control string, should end in "? ". 1576 It should not say how to answer, because we do that. */ 1577 1578 int 1579 yquery (const char *ctlstr, ...) 1580 { 1581 va_list args; 1582 1583 va_start (args, ctlstr); 1584 return defaulted_query (ctlstr, 'y', args); 1585 va_end (args); 1586 } 1587 1588 /* Ask user a y-or-n question and return 1 iff answer is yes. 1589 Takes three args which are given to printf to print the question. 1590 The first, a control string, should end in "? ". 1591 It should not say how to answer, because we do that. */ 1592 1593 int 1594 query (const char *ctlstr, ...) 1595 { 1596 va_list args; 1597 1598 va_start (args, ctlstr); 1599 return defaulted_query (ctlstr, '\0', args); 1600 va_end (args); 1601 } 1602 1603 /* A helper for parse_escape that converts a host character to a 1604 target character. C is the host character. If conversion is 1605 possible, then the target character is stored in *TARGET_C and the 1606 function returns 1. Otherwise, the function returns 0. */ 1607 1608 static int 1609 host_char_to_target (int c, int *target_c) 1610 { 1611 struct obstack host_data; 1612 char the_char = c; 1613 struct cleanup *cleanups; 1614 int result = 0; 1615 1616 obstack_init (&host_data); 1617 cleanups = make_cleanup_obstack_free (&host_data); 1618 1619 convert_between_encodings (target_charset (), host_charset (), 1620 &the_char, 1, 1, &host_data, translit_none); 1621 1622 if (obstack_object_size (&host_data) == 1) 1623 { 1624 result = 1; 1625 *target_c = *(char *) obstack_base (&host_data); 1626 } 1627 1628 do_cleanups (cleanups); 1629 return result; 1630 } 1631 1632 /* Parse a C escape sequence. STRING_PTR points to a variable 1633 containing a pointer to the string to parse. That pointer 1634 should point to the character after the \. That pointer 1635 is updated past the characters we use. The value of the 1636 escape sequence is returned. 1637 1638 A negative value means the sequence \ newline was seen, 1639 which is supposed to be equivalent to nothing at all. 1640 1641 If \ is followed by a null character, we return a negative 1642 value and leave the string pointer pointing at the null character. 1643 1644 If \ is followed by 000, we return 0 and leave the string pointer 1645 after the zeros. A value of 0 does not mean end of string. */ 1646 1647 int 1648 parse_escape (char **string_ptr) 1649 { 1650 int target_char = -2; /* initialize to avoid GCC warnings */ 1651 int c = *(*string_ptr)++; 1652 switch (c) 1653 { 1654 case '\n': 1655 return -2; 1656 case 0: 1657 (*string_ptr)--; 1658 return 0; 1659 1660 case '0': 1661 case '1': 1662 case '2': 1663 case '3': 1664 case '4': 1665 case '5': 1666 case '6': 1667 case '7': 1668 { 1669 int i = host_hex_value (c); 1670 int count = 0; 1671 while (++count < 3) 1672 { 1673 c = (**string_ptr); 1674 if (isdigit (c) && c != '8' && c != '9') 1675 { 1676 (*string_ptr)++; 1677 i *= 8; 1678 i += host_hex_value (c); 1679 } 1680 else 1681 { 1682 break; 1683 } 1684 } 1685 return i; 1686 } 1687 1688 case 'a': 1689 c = '\a'; 1690 break; 1691 case 'b': 1692 c = '\b'; 1693 break; 1694 case 'f': 1695 c = '\f'; 1696 break; 1697 case 'n': 1698 c = '\n'; 1699 break; 1700 case 'r': 1701 c = '\r'; 1702 break; 1703 case 't': 1704 c = '\t'; 1705 break; 1706 case 'v': 1707 c = '\v'; 1708 break; 1709 1710 default: 1711 break; 1712 } 1713 1714 if (!host_char_to_target (c, &target_char)) 1715 error 1716 ("The escape sequence `\%c' is equivalent to plain `%c', which" 1717 " has no equivalent\n" "in the `%s' character set.", c, c, 1718 target_charset ()); 1719 return target_char; 1720 } 1721 1722 /* Print the character C on STREAM as part of the contents of a literal 1723 string whose delimiter is QUOTER. Note that this routine should only 1724 be call for printing things which are independent of the language 1725 of the program being debugged. */ 1726 1727 static void 1728 printchar (int c, void (*do_fputs) (const char *, struct ui_file *), 1729 void (*do_fprintf) (struct ui_file *, const char *, ...) 1730 ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter) 1731 { 1732 1733 c &= 0xFF; /* Avoid sign bit follies */ 1734 1735 if (c < 0x20 || /* Low control chars */ 1736 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */ 1737 (sevenbit_strings && c >= 0x80)) 1738 { /* high order bit set */ 1739 switch (c) 1740 { 1741 case '\n': 1742 do_fputs ("\\n", stream); 1743 break; 1744 case '\b': 1745 do_fputs ("\\b", stream); 1746 break; 1747 case '\t': 1748 do_fputs ("\\t", stream); 1749 break; 1750 case '\f': 1751 do_fputs ("\\f", stream); 1752 break; 1753 case '\r': 1754 do_fputs ("\\r", stream); 1755 break; 1756 case '\033': 1757 do_fputs ("\\e", stream); 1758 break; 1759 case '\007': 1760 do_fputs ("\\a", stream); 1761 break; 1762 default: 1763 do_fprintf (stream, "\\%.3o", (unsigned int) c); 1764 break; 1765 } 1766 } 1767 else 1768 { 1769 if (c == '\\' || c == quoter) 1770 do_fputs ("\\", stream); 1771 do_fprintf (stream, "%c", c); 1772 } 1773 } 1774 1775 /* Print the character C on STREAM as part of the contents of a 1776 literal string whose delimiter is QUOTER. Note that these routines 1777 should only be call for printing things which are independent of 1778 the language of the program being debugged. */ 1779 1780 void 1781 fputstr_filtered (const char *str, int quoter, struct ui_file *stream) 1782 { 1783 while (*str) 1784 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter); 1785 } 1786 1787 void 1788 fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream) 1789 { 1790 while (*str) 1791 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter); 1792 } 1793 1794 void 1795 fputstrn_filtered (const char *str, int n, int quoter, 1796 struct ui_file *stream) 1797 { 1798 int i; 1799 for (i = 0; i < n; i++) 1800 printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter); 1801 } 1802 1803 void 1804 fputstrn_unfiltered (const char *str, int n, int quoter, 1805 struct ui_file *stream) 1806 { 1807 int i; 1808 for (i = 0; i < n; i++) 1809 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter); 1810 } 1811 1812 1813 /* Number of lines per page or UINT_MAX if paging is disabled. */ 1814 static unsigned int lines_per_page; 1815 static void 1816 show_lines_per_page (struct ui_file *file, int from_tty, 1817 struct cmd_list_element *c, const char *value) 1818 { 1819 fprintf_filtered (file, _("\ 1820 Number of lines gdb thinks are in a page is %s.\n"), 1821 value); 1822 } 1823 1824 /* Number of chars per line or UINT_MAX if line folding is disabled. */ 1825 static unsigned int chars_per_line; 1826 static void 1827 show_chars_per_line (struct ui_file *file, int from_tty, 1828 struct cmd_list_element *c, const char *value) 1829 { 1830 fprintf_filtered (file, _("\ 1831 Number of characters gdb thinks are in a line is %s.\n"), 1832 value); 1833 } 1834 1835 /* Current count of lines printed on this page, chars on this line. */ 1836 static unsigned int lines_printed, chars_printed; 1837 1838 /* Buffer and start column of buffered text, for doing smarter word- 1839 wrapping. When someone calls wrap_here(), we start buffering output 1840 that comes through fputs_filtered(). If we see a newline, we just 1841 spit it out and forget about the wrap_here(). If we see another 1842 wrap_here(), we spit it out and remember the newer one. If we see 1843 the end of the line, we spit out a newline, the indent, and then 1844 the buffered output. */ 1845 1846 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which 1847 are waiting to be output (they have already been counted in chars_printed). 1848 When wrap_buffer[0] is null, the buffer is empty. */ 1849 static char *wrap_buffer; 1850 1851 /* Pointer in wrap_buffer to the next character to fill. */ 1852 static char *wrap_pointer; 1853 1854 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column 1855 is non-zero. */ 1856 static char *wrap_indent; 1857 1858 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping 1859 is not in effect. */ 1860 static int wrap_column; 1861 1862 1863 /* Inialize the number of lines per page and chars per line. */ 1864 1865 void 1866 init_page_info (void) 1867 { 1868 #if defined(TUI) 1869 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page)) 1870 #endif 1871 { 1872 int rows, cols; 1873 1874 #if defined(__GO32__) 1875 rows = ScreenRows (); 1876 cols = ScreenCols (); 1877 lines_per_page = rows; 1878 chars_per_line = cols; 1879 #else 1880 /* Make sure Readline has initialized its terminal settings. */ 1881 rl_reset_terminal (NULL); 1882 1883 /* Get the screen size from Readline. */ 1884 rl_get_screen_size (&rows, &cols); 1885 lines_per_page = rows; 1886 chars_per_line = cols; 1887 1888 /* Readline should have fetched the termcap entry for us. */ 1889 if (tgetnum ("li") < 0 || getenv ("EMACS")) 1890 { 1891 /* The number of lines per page is not mentioned in the 1892 terminal description. This probably means that paging is 1893 not useful (e.g. emacs shell window), so disable paging. */ 1894 lines_per_page = UINT_MAX; 1895 } 1896 1897 /* FIXME: Get rid of this junk. */ 1898 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER) 1899 SIGWINCH_HANDLER (SIGWINCH); 1900 #endif 1901 1902 /* If the output is not a terminal, don't paginate it. */ 1903 if (!ui_file_isatty (gdb_stdout)) 1904 lines_per_page = UINT_MAX; 1905 #endif 1906 } 1907 1908 set_screen_size (); 1909 set_width (); 1910 } 1911 1912 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */ 1913 1914 static void 1915 set_screen_size (void) 1916 { 1917 int rows = lines_per_page; 1918 int cols = chars_per_line; 1919 1920 if (rows <= 0) 1921 rows = INT_MAX; 1922 1923 if (cols <= 0) 1924 cols = INT_MAX; 1925 1926 /* Update Readline's idea of the terminal size. */ 1927 rl_set_screen_size (rows, cols); 1928 } 1929 1930 /* Reinitialize WRAP_BUFFER according to the current value of 1931 CHARS_PER_LINE. */ 1932 1933 static void 1934 set_width (void) 1935 { 1936 if (chars_per_line == 0) 1937 init_page_info (); 1938 1939 if (!wrap_buffer) 1940 { 1941 wrap_buffer = (char *) xmalloc (chars_per_line + 2); 1942 wrap_buffer[0] = '\0'; 1943 } 1944 else 1945 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2); 1946 wrap_pointer = wrap_buffer; /* Start it at the beginning. */ 1947 } 1948 1949 static void 1950 set_width_command (char *args, int from_tty, struct cmd_list_element *c) 1951 { 1952 set_screen_size (); 1953 set_width (); 1954 } 1955 1956 static void 1957 set_height_command (char *args, int from_tty, struct cmd_list_element *c) 1958 { 1959 set_screen_size (); 1960 } 1961 1962 /* Wait, so the user can read what's on the screen. Prompt the user 1963 to continue by pressing RETURN. */ 1964 1965 static void 1966 prompt_for_continue (void) 1967 { 1968 char *ignore; 1969 char cont_prompt[120]; 1970 1971 if (annotation_level > 1) 1972 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n")); 1973 1974 strcpy (cont_prompt, 1975 "---Type <return> to continue, or q <return> to quit---"); 1976 if (annotation_level > 1) 1977 strcat (cont_prompt, "\n\032\032prompt-for-continue\n"); 1978 1979 /* We must do this *before* we call gdb_readline, else it will eventually 1980 call us -- thinking that we're trying to print beyond the end of the 1981 screen. */ 1982 reinitialize_more_filter (); 1983 1984 immediate_quit++; 1985 /* On a real operating system, the user can quit with SIGINT. 1986 But not on GO32. 1987 1988 'q' is provided on all systems so users don't have to change habits 1989 from system to system, and because telling them what to do in 1990 the prompt is more user-friendly than expecting them to think of 1991 SIGINT. */ 1992 /* Call readline, not gdb_readline, because GO32 readline handles control-C 1993 whereas control-C to gdb_readline will cause the user to get dumped 1994 out to DOS. */ 1995 ignore = gdb_readline_wrapper (cont_prompt); 1996 1997 if (annotation_level > 1) 1998 printf_unfiltered (("\n\032\032post-prompt-for-continue\n")); 1999 2000 if (ignore) 2001 { 2002 char *p = ignore; 2003 while (*p == ' ' || *p == '\t') 2004 ++p; 2005 if (p[0] == 'q') 2006 async_request_quit (0); 2007 xfree (ignore); 2008 } 2009 immediate_quit--; 2010 2011 /* Now we have to do this again, so that GDB will know that it doesn't 2012 need to save the ---Type <return>--- line at the top of the screen. */ 2013 reinitialize_more_filter (); 2014 2015 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */ 2016 } 2017 2018 /* Reinitialize filter; ie. tell it to reset to original values. */ 2019 2020 void 2021 reinitialize_more_filter (void) 2022 { 2023 lines_printed = 0; 2024 chars_printed = 0; 2025 } 2026 2027 /* Indicate that if the next sequence of characters overflows the line, 2028 a newline should be inserted here rather than when it hits the end. 2029 If INDENT is non-null, it is a string to be printed to indent the 2030 wrapped part on the next line. INDENT must remain accessible until 2031 the next call to wrap_here() or until a newline is printed through 2032 fputs_filtered(). 2033 2034 If the line is already overfull, we immediately print a newline and 2035 the indentation, and disable further wrapping. 2036 2037 If we don't know the width of lines, but we know the page height, 2038 we must not wrap words, but should still keep track of newlines 2039 that were explicitly printed. 2040 2041 INDENT should not contain tabs, as that will mess up the char count 2042 on the next line. FIXME. 2043 2044 This routine is guaranteed to force out any output which has been 2045 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be 2046 used to force out output from the wrap_buffer. */ 2047 2048 void 2049 wrap_here (char *indent) 2050 { 2051 /* This should have been allocated, but be paranoid anyway. */ 2052 if (!wrap_buffer) 2053 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); 2054 2055 if (wrap_buffer[0]) 2056 { 2057 *wrap_pointer = '\0'; 2058 fputs_unfiltered (wrap_buffer, gdb_stdout); 2059 } 2060 wrap_pointer = wrap_buffer; 2061 wrap_buffer[0] = '\0'; 2062 if (chars_per_line == UINT_MAX) /* No line overflow checking */ 2063 { 2064 wrap_column = 0; 2065 } 2066 else if (chars_printed >= chars_per_line) 2067 { 2068 puts_filtered ("\n"); 2069 if (indent != NULL) 2070 puts_filtered (indent); 2071 wrap_column = 0; 2072 } 2073 else 2074 { 2075 wrap_column = chars_printed; 2076 if (indent == NULL) 2077 wrap_indent = ""; 2078 else 2079 wrap_indent = indent; 2080 } 2081 } 2082 2083 /* Print input string to gdb_stdout, filtered, with wrap, 2084 arranging strings in columns of n chars. String can be 2085 right or left justified in the column. Never prints 2086 trailing spaces. String should never be longer than 2087 width. FIXME: this could be useful for the EXAMINE 2088 command, which currently doesn't tabulate very well */ 2089 2090 void 2091 puts_filtered_tabular (char *string, int width, int right) 2092 { 2093 int spaces = 0; 2094 int stringlen; 2095 char *spacebuf; 2096 2097 gdb_assert (chars_per_line > 0); 2098 if (chars_per_line == UINT_MAX) 2099 { 2100 fputs_filtered (string, gdb_stdout); 2101 fputs_filtered ("\n", gdb_stdout); 2102 return; 2103 } 2104 2105 if (((chars_printed - 1) / width + 2) * width >= chars_per_line) 2106 fputs_filtered ("\n", gdb_stdout); 2107 2108 if (width >= chars_per_line) 2109 width = chars_per_line - 1; 2110 2111 stringlen = strlen (string); 2112 2113 if (chars_printed > 0) 2114 spaces = width - (chars_printed - 1) % width - 1; 2115 if (right) 2116 spaces += width - stringlen; 2117 2118 spacebuf = alloca (spaces + 1); 2119 spacebuf[spaces] = '\0'; 2120 while (spaces--) 2121 spacebuf[spaces] = ' '; 2122 2123 fputs_filtered (spacebuf, gdb_stdout); 2124 fputs_filtered (string, gdb_stdout); 2125 } 2126 2127 2128 /* Ensure that whatever gets printed next, using the filtered output 2129 commands, starts at the beginning of the line. I.E. if there is 2130 any pending output for the current line, flush it and start a new 2131 line. Otherwise do nothing. */ 2132 2133 void 2134 begin_line (void) 2135 { 2136 if (chars_printed > 0) 2137 { 2138 puts_filtered ("\n"); 2139 } 2140 } 2141 2142 2143 /* Like fputs but if FILTER is true, pause after every screenful. 2144 2145 Regardless of FILTER can wrap at points other than the final 2146 character of a line. 2147 2148 Unlike fputs, fputs_maybe_filtered does not return a value. 2149 It is OK for LINEBUFFER to be NULL, in which case just don't print 2150 anything. 2151 2152 Note that a longjmp to top level may occur in this routine (only if 2153 FILTER is true) (since prompt_for_continue may do so) so this 2154 routine should not be called when cleanups are not in place. */ 2155 2156 static void 2157 fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream, 2158 int filter) 2159 { 2160 const char *lineptr; 2161 2162 if (linebuffer == 0) 2163 return; 2164 2165 /* Don't do any filtering if it is disabled. */ 2166 if ((stream != gdb_stdout) || !pagination_enabled 2167 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)) 2168 { 2169 fputs_unfiltered (linebuffer, stream); 2170 return; 2171 } 2172 2173 /* Go through and output each character. Show line extension 2174 when this is necessary; prompt user for new page when this is 2175 necessary. */ 2176 2177 lineptr = linebuffer; 2178 while (*lineptr) 2179 { 2180 /* Possible new page. */ 2181 if (filter && (lines_printed >= lines_per_page - 1)) 2182 prompt_for_continue (); 2183 2184 while (*lineptr && *lineptr != '\n') 2185 { 2186 /* Print a single line. */ 2187 if (*lineptr == '\t') 2188 { 2189 if (wrap_column) 2190 *wrap_pointer++ = '\t'; 2191 else 2192 fputc_unfiltered ('\t', stream); 2193 /* Shifting right by 3 produces the number of tab stops 2194 we have already passed, and then adding one and 2195 shifting left 3 advances to the next tab stop. */ 2196 chars_printed = ((chars_printed >> 3) + 1) << 3; 2197 lineptr++; 2198 } 2199 else 2200 { 2201 if (wrap_column) 2202 *wrap_pointer++ = *lineptr; 2203 else 2204 fputc_unfiltered (*lineptr, stream); 2205 chars_printed++; 2206 lineptr++; 2207 } 2208 2209 if (chars_printed >= chars_per_line) 2210 { 2211 unsigned int save_chars = chars_printed; 2212 2213 chars_printed = 0; 2214 lines_printed++; 2215 /* If we aren't actually wrapping, don't output newline -- 2216 if chars_per_line is right, we probably just overflowed 2217 anyway; if it's wrong, let us keep going. */ 2218 if (wrap_column) 2219 fputc_unfiltered ('\n', stream); 2220 2221 /* Possible new page. */ 2222 if (lines_printed >= lines_per_page - 1) 2223 prompt_for_continue (); 2224 2225 /* Now output indentation and wrapped string */ 2226 if (wrap_column) 2227 { 2228 fputs_unfiltered (wrap_indent, stream); 2229 *wrap_pointer = '\0'; /* Null-terminate saved stuff */ 2230 fputs_unfiltered (wrap_buffer, stream); /* and eject it */ 2231 /* FIXME, this strlen is what prevents wrap_indent from 2232 containing tabs. However, if we recurse to print it 2233 and count its chars, we risk trouble if wrap_indent is 2234 longer than (the user settable) chars_per_line. 2235 Note also that this can set chars_printed > chars_per_line 2236 if we are printing a long string. */ 2237 chars_printed = strlen (wrap_indent) 2238 + (save_chars - wrap_column); 2239 wrap_pointer = wrap_buffer; /* Reset buffer */ 2240 wrap_buffer[0] = '\0'; 2241 wrap_column = 0; /* And disable fancy wrap */ 2242 } 2243 } 2244 } 2245 2246 if (*lineptr == '\n') 2247 { 2248 chars_printed = 0; 2249 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */ 2250 lines_printed++; 2251 fputc_unfiltered ('\n', stream); 2252 lineptr++; 2253 } 2254 } 2255 } 2256 2257 void 2258 fputs_filtered (const char *linebuffer, struct ui_file *stream) 2259 { 2260 fputs_maybe_filtered (linebuffer, stream, 1); 2261 } 2262 2263 int 2264 putchar_unfiltered (int c) 2265 { 2266 char buf = c; 2267 ui_file_write (gdb_stdout, &buf, 1); 2268 return c; 2269 } 2270 2271 /* Write character C to gdb_stdout using GDB's paging mechanism and return C. 2272 May return nonlocally. */ 2273 2274 int 2275 putchar_filtered (int c) 2276 { 2277 return fputc_filtered (c, gdb_stdout); 2278 } 2279 2280 int 2281 fputc_unfiltered (int c, struct ui_file *stream) 2282 { 2283 char buf = c; 2284 ui_file_write (stream, &buf, 1); 2285 return c; 2286 } 2287 2288 int 2289 fputc_filtered (int c, struct ui_file *stream) 2290 { 2291 char buf[2]; 2292 2293 buf[0] = c; 2294 buf[1] = 0; 2295 fputs_filtered (buf, stream); 2296 return c; 2297 } 2298 2299 /* puts_debug is like fputs_unfiltered, except it prints special 2300 characters in printable fashion. */ 2301 2302 void 2303 puts_debug (char *prefix, char *string, char *suffix) 2304 { 2305 int ch; 2306 2307 /* Print prefix and suffix after each line. */ 2308 static int new_line = 1; 2309 static int return_p = 0; 2310 static char *prev_prefix = ""; 2311 static char *prev_suffix = ""; 2312 2313 if (*string == '\n') 2314 return_p = 0; 2315 2316 /* If the prefix is changing, print the previous suffix, a new line, 2317 and the new prefix. */ 2318 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line) 2319 { 2320 fputs_unfiltered (prev_suffix, gdb_stdlog); 2321 fputs_unfiltered ("\n", gdb_stdlog); 2322 fputs_unfiltered (prefix, gdb_stdlog); 2323 } 2324 2325 /* Print prefix if we printed a newline during the previous call. */ 2326 if (new_line) 2327 { 2328 new_line = 0; 2329 fputs_unfiltered (prefix, gdb_stdlog); 2330 } 2331 2332 prev_prefix = prefix; 2333 prev_suffix = suffix; 2334 2335 /* Output characters in a printable format. */ 2336 while ((ch = *string++) != '\0') 2337 { 2338 switch (ch) 2339 { 2340 default: 2341 if (isprint (ch)) 2342 fputc_unfiltered (ch, gdb_stdlog); 2343 2344 else 2345 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff); 2346 break; 2347 2348 case '\\': 2349 fputs_unfiltered ("\\\\", gdb_stdlog); 2350 break; 2351 case '\b': 2352 fputs_unfiltered ("\\b", gdb_stdlog); 2353 break; 2354 case '\f': 2355 fputs_unfiltered ("\\f", gdb_stdlog); 2356 break; 2357 case '\n': 2358 new_line = 1; 2359 fputs_unfiltered ("\\n", gdb_stdlog); 2360 break; 2361 case '\r': 2362 fputs_unfiltered ("\\r", gdb_stdlog); 2363 break; 2364 case '\t': 2365 fputs_unfiltered ("\\t", gdb_stdlog); 2366 break; 2367 case '\v': 2368 fputs_unfiltered ("\\v", gdb_stdlog); 2369 break; 2370 } 2371 2372 return_p = ch == '\r'; 2373 } 2374 2375 /* Print suffix if we printed a newline. */ 2376 if (new_line) 2377 { 2378 fputs_unfiltered (suffix, gdb_stdlog); 2379 fputs_unfiltered ("\n", gdb_stdlog); 2380 } 2381 } 2382 2383 2384 /* Print a variable number of ARGS using format FORMAT. If this 2385 information is going to put the amount written (since the last call 2386 to REINITIALIZE_MORE_FILTER or the last page break) over the page size, 2387 call prompt_for_continue to get the users permision to continue. 2388 2389 Unlike fprintf, this function does not return a value. 2390 2391 We implement three variants, vfprintf (takes a vararg list and stream), 2392 fprintf (takes a stream to write on), and printf (the usual). 2393 2394 Note also that a longjmp to top level may occur in this routine 2395 (since prompt_for_continue may do so) so this routine should not be 2396 called when cleanups are not in place. */ 2397 2398 static void 2399 vfprintf_maybe_filtered (struct ui_file *stream, const char *format, 2400 va_list args, int filter) 2401 { 2402 char *linebuffer; 2403 struct cleanup *old_cleanups; 2404 2405 linebuffer = xstrvprintf (format, args); 2406 old_cleanups = make_cleanup (xfree, linebuffer); 2407 fputs_maybe_filtered (linebuffer, stream, filter); 2408 do_cleanups (old_cleanups); 2409 } 2410 2411 2412 void 2413 vfprintf_filtered (struct ui_file *stream, const char *format, va_list args) 2414 { 2415 vfprintf_maybe_filtered (stream, format, args, 1); 2416 } 2417 2418 void 2419 vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args) 2420 { 2421 char *linebuffer; 2422 struct cleanup *old_cleanups; 2423 2424 linebuffer = xstrvprintf (format, args); 2425 old_cleanups = make_cleanup (xfree, linebuffer); 2426 if (debug_timestamp && stream == gdb_stdlog) 2427 { 2428 struct timeval tm; 2429 char *timestamp; 2430 int len, need_nl; 2431 2432 gettimeofday (&tm, NULL); 2433 2434 len = strlen (linebuffer); 2435 need_nl = (len > 0 && linebuffer[len - 1] != '\n'); 2436 2437 timestamp = xstrprintf ("%ld:%ld %s%s", 2438 (long) tm.tv_sec, (long) tm.tv_usec, 2439 linebuffer, 2440 need_nl ? "\n": ""); 2441 make_cleanup (xfree, timestamp); 2442 fputs_unfiltered (timestamp, stream); 2443 } 2444 else 2445 fputs_unfiltered (linebuffer, stream); 2446 do_cleanups (old_cleanups); 2447 } 2448 2449 void 2450 vprintf_filtered (const char *format, va_list args) 2451 { 2452 vfprintf_maybe_filtered (gdb_stdout, format, args, 1); 2453 } 2454 2455 void 2456 vprintf_unfiltered (const char *format, va_list args) 2457 { 2458 vfprintf_unfiltered (gdb_stdout, format, args); 2459 } 2460 2461 void 2462 fprintf_filtered (struct ui_file *stream, const char *format, ...) 2463 { 2464 va_list args; 2465 va_start (args, format); 2466 vfprintf_filtered (stream, format, args); 2467 va_end (args); 2468 } 2469 2470 void 2471 fprintf_unfiltered (struct ui_file *stream, const char *format, ...) 2472 { 2473 va_list args; 2474 va_start (args, format); 2475 vfprintf_unfiltered (stream, format, args); 2476 va_end (args); 2477 } 2478 2479 /* Like fprintf_filtered, but prints its result indented. 2480 Called as fprintfi_filtered (spaces, stream, format, ...); */ 2481 2482 void 2483 fprintfi_filtered (int spaces, struct ui_file *stream, const char *format, 2484 ...) 2485 { 2486 va_list args; 2487 va_start (args, format); 2488 print_spaces_filtered (spaces, stream); 2489 2490 vfprintf_filtered (stream, format, args); 2491 va_end (args); 2492 } 2493 2494 2495 void 2496 printf_filtered (const char *format, ...) 2497 { 2498 va_list args; 2499 va_start (args, format); 2500 vfprintf_filtered (gdb_stdout, format, args); 2501 va_end (args); 2502 } 2503 2504 2505 void 2506 printf_unfiltered (const char *format, ...) 2507 { 2508 va_list args; 2509 va_start (args, format); 2510 vfprintf_unfiltered (gdb_stdout, format, args); 2511 va_end (args); 2512 } 2513 2514 /* Like printf_filtered, but prints it's result indented. 2515 Called as printfi_filtered (spaces, format, ...); */ 2516 2517 void 2518 printfi_filtered (int spaces, const char *format, ...) 2519 { 2520 va_list args; 2521 va_start (args, format); 2522 print_spaces_filtered (spaces, gdb_stdout); 2523 vfprintf_filtered (gdb_stdout, format, args); 2524 va_end (args); 2525 } 2526 2527 /* Easy -- but watch out! 2528 2529 This routine is *not* a replacement for puts()! puts() appends a newline. 2530 This one doesn't, and had better not! */ 2531 2532 void 2533 puts_filtered (const char *string) 2534 { 2535 fputs_filtered (string, gdb_stdout); 2536 } 2537 2538 void 2539 puts_unfiltered (const char *string) 2540 { 2541 fputs_unfiltered (string, gdb_stdout); 2542 } 2543 2544 /* Return a pointer to N spaces and a null. The pointer is good 2545 until the next call to here. */ 2546 char * 2547 n_spaces (int n) 2548 { 2549 char *t; 2550 static char *spaces = 0; 2551 static int max_spaces = -1; 2552 2553 if (n > max_spaces) 2554 { 2555 if (spaces) 2556 xfree (spaces); 2557 spaces = (char *) xmalloc (n + 1); 2558 for (t = spaces + n; t != spaces;) 2559 *--t = ' '; 2560 spaces[n] = '\0'; 2561 max_spaces = n; 2562 } 2563 2564 return spaces + max_spaces - n; 2565 } 2566 2567 /* Print N spaces. */ 2568 void 2569 print_spaces_filtered (int n, struct ui_file *stream) 2570 { 2571 fputs_filtered (n_spaces (n), stream); 2572 } 2573 2574 /* C++/ObjC demangler stuff. */ 2575 2576 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language 2577 LANG, using demangling args ARG_MODE, and print it filtered to STREAM. 2578 If the name is not mangled, or the language for the name is unknown, or 2579 demangling is off, the name is printed in its "raw" form. */ 2580 2581 void 2582 fprintf_symbol_filtered (struct ui_file *stream, char *name, 2583 enum language lang, int arg_mode) 2584 { 2585 char *demangled; 2586 2587 if (name != NULL) 2588 { 2589 /* If user wants to see raw output, no problem. */ 2590 if (!demangle) 2591 { 2592 fputs_filtered (name, stream); 2593 } 2594 else 2595 { 2596 demangled = language_demangle (language_def (lang), name, arg_mode); 2597 fputs_filtered (demangled ? demangled : name, stream); 2598 if (demangled != NULL) 2599 { 2600 xfree (demangled); 2601 } 2602 } 2603 } 2604 } 2605 2606 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any 2607 differences in whitespace. Returns 0 if they match, non-zero if they 2608 don't (slightly different than strcmp()'s range of return values). 2609 2610 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO". 2611 This "feature" is useful when searching for matching C++ function names 2612 (such as if the user types 'break FOO', where FOO is a mangled C++ 2613 function). */ 2614 2615 int 2616 strcmp_iw (const char *string1, const char *string2) 2617 { 2618 while ((*string1 != '\0') && (*string2 != '\0')) 2619 { 2620 while (isspace (*string1)) 2621 { 2622 string1++; 2623 } 2624 while (isspace (*string2)) 2625 { 2626 string2++; 2627 } 2628 if (*string1 != *string2) 2629 { 2630 break; 2631 } 2632 if (*string1 != '\0') 2633 { 2634 string1++; 2635 string2++; 2636 } 2637 } 2638 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0'); 2639 } 2640 2641 /* This is like strcmp except that it ignores whitespace and treats 2642 '(' as the first non-NULL character in terms of ordering. Like 2643 strcmp (and unlike strcmp_iw), it returns negative if STRING1 < 2644 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2 2645 according to that ordering. 2646 2647 If a list is sorted according to this function and if you want to 2648 find names in the list that match some fixed NAME according to 2649 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right 2650 where this function would put NAME. 2651 2652 Here are some examples of why using strcmp to sort is a bad idea: 2653 2654 Whitespace example: 2655 2656 Say your partial symtab contains: "foo<char *>", "goo". Then, if 2657 we try to do a search for "foo<char*>", strcmp will locate this 2658 after "foo<char *>" and before "goo". Then lookup_partial_symbol 2659 will start looking at strings beginning with "goo", and will never 2660 see the correct match of "foo<char *>". 2661 2662 Parenthesis example: 2663 2664 In practice, this is less like to be an issue, but I'll give it a 2665 shot. Let's assume that '$' is a legitimate character to occur in 2666 symbols. (Which may well even be the case on some systems.) Then 2667 say that the partial symbol table contains "foo$" and "foo(int)". 2668 strcmp will put them in this order, since '$' < '('. Now, if the 2669 user searches for "foo", then strcmp will sort "foo" before "foo$". 2670 Then lookup_partial_symbol will notice that strcmp_iw("foo$", 2671 "foo") is false, so it won't proceed to the actual match of 2672 "foo(int)" with "foo". */ 2673 2674 int 2675 strcmp_iw_ordered (const char *string1, const char *string2) 2676 { 2677 while ((*string1 != '\0') && (*string2 != '\0')) 2678 { 2679 while (isspace (*string1)) 2680 { 2681 string1++; 2682 } 2683 while (isspace (*string2)) 2684 { 2685 string2++; 2686 } 2687 if (*string1 != *string2) 2688 { 2689 break; 2690 } 2691 if (*string1 != '\0') 2692 { 2693 string1++; 2694 string2++; 2695 } 2696 } 2697 2698 switch (*string1) 2699 { 2700 /* Characters are non-equal unless they're both '\0'; we want to 2701 make sure we get the comparison right according to our 2702 comparison in the cases where one of them is '\0' or '('. */ 2703 case '\0': 2704 if (*string2 == '\0') 2705 return 0; 2706 else 2707 return -1; 2708 case '(': 2709 if (*string2 == '\0') 2710 return 1; 2711 else 2712 return -1; 2713 default: 2714 if (*string2 == '(') 2715 return 1; 2716 else 2717 return *string1 - *string2; 2718 } 2719 } 2720 2721 /* A simple comparison function with opposite semantics to strcmp. */ 2722 2723 int 2724 streq (const char *lhs, const char *rhs) 2725 { 2726 return !strcmp (lhs, rhs); 2727 } 2728 2729 2730 /* 2731 ** subset_compare() 2732 ** Answer whether string_to_compare is a full or partial match to 2733 ** template_string. The partial match must be in sequence starting 2734 ** at index 0. 2735 */ 2736 int 2737 subset_compare (char *string_to_compare, char *template_string) 2738 { 2739 int match; 2740 if (template_string != (char *) NULL && string_to_compare != (char *) NULL 2741 && strlen (string_to_compare) <= strlen (template_string)) 2742 match = 2743 (strncmp 2744 (template_string, string_to_compare, strlen (string_to_compare)) == 0); 2745 else 2746 match = 0; 2747 return match; 2748 } 2749 2750 static void 2751 pagination_on_command (char *arg, int from_tty) 2752 { 2753 pagination_enabled = 1; 2754 } 2755 2756 static void 2757 pagination_off_command (char *arg, int from_tty) 2758 { 2759 pagination_enabled = 0; 2760 } 2761 2762 static void 2763 show_debug_timestamp (struct ui_file *file, int from_tty, 2764 struct cmd_list_element *c, const char *value) 2765 { 2766 fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"), value); 2767 } 2768 2769 2770 void 2771 initialize_utils (void) 2772 { 2773 struct cmd_list_element *c; 2774 2775 add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\ 2776 Set number of characters gdb thinks are in a line."), _("\ 2777 Show number of characters gdb thinks are in a line."), NULL, 2778 set_width_command, 2779 show_chars_per_line, 2780 &setlist, &showlist); 2781 2782 add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\ 2783 Set number of lines gdb thinks are in a page."), _("\ 2784 Show number of lines gdb thinks are in a page."), NULL, 2785 set_height_command, 2786 show_lines_per_page, 2787 &setlist, &showlist); 2788 2789 init_page_info (); 2790 2791 add_setshow_boolean_cmd ("demangle", class_support, &demangle, _("\ 2792 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\ 2793 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL, 2794 NULL, 2795 show_demangle, 2796 &setprintlist, &showprintlist); 2797 2798 add_setshow_boolean_cmd ("pagination", class_support, 2799 &pagination_enabled, _("\ 2800 Set state of pagination."), _("\ 2801 Show state of pagination."), NULL, 2802 NULL, 2803 show_pagination_enabled, 2804 &setlist, &showlist); 2805 2806 if (xdb_commands) 2807 { 2808 add_com ("am", class_support, pagination_on_command, 2809 _("Enable pagination")); 2810 add_com ("sm", class_support, pagination_off_command, 2811 _("Disable pagination")); 2812 } 2813 2814 add_setshow_boolean_cmd ("sevenbit-strings", class_support, 2815 &sevenbit_strings, _("\ 2816 Set printing of 8-bit characters in strings as \\nnn."), _("\ 2817 Show printing of 8-bit characters in strings as \\nnn."), NULL, 2818 NULL, 2819 show_sevenbit_strings, 2820 &setprintlist, &showprintlist); 2821 2822 add_setshow_boolean_cmd ("asm-demangle", class_support, &asm_demangle, _("\ 2823 Set demangling of C++/ObjC names in disassembly listings."), _("\ 2824 Show demangling of C++/ObjC names in disassembly listings."), NULL, 2825 NULL, 2826 show_asm_demangle, 2827 &setprintlist, &showprintlist); 2828 2829 add_setshow_boolean_cmd ("timestamp", class_maintenance, 2830 &debug_timestamp, _("\ 2831 Set timestamping of debugging messages."), _("\ 2832 Show timestamping of debugging messages."), _("\ 2833 When set, debugging messages will be marked with seconds and microseconds."), 2834 NULL, 2835 show_debug_timestamp, 2836 &setdebuglist, &showdebuglist); 2837 } 2838 2839 /* Machine specific function to handle SIGWINCH signal. */ 2840 2841 #ifdef SIGWINCH_HANDLER_BODY 2842 SIGWINCH_HANDLER_BODY 2843 #endif 2844 /* print routines to handle variable size regs, etc. */ 2845 /* temporary storage using circular buffer */ 2846 #define NUMCELLS 16 2847 #define CELLSIZE 50 2848 static char * 2849 get_cell (void) 2850 { 2851 static char buf[NUMCELLS][CELLSIZE]; 2852 static int cell = 0; 2853 if (++cell >= NUMCELLS) 2854 cell = 0; 2855 return buf[cell]; 2856 } 2857 2858 const char * 2859 paddress (struct gdbarch *gdbarch, CORE_ADDR addr) 2860 { 2861 /* Truncate address to the size of a target address, avoiding shifts 2862 larger or equal than the width of a CORE_ADDR. The local 2863 variable ADDR_BIT stops the compiler reporting a shift overflow 2864 when it won't occur. */ 2865 /* NOTE: This assumes that the significant address information is 2866 kept in the least significant bits of ADDR - the upper bits were 2867 either zero or sign extended. Should gdbarch_address_to_pointer or 2868 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */ 2869 2870 int addr_bit = gdbarch_addr_bit (gdbarch); 2871 2872 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)) 2873 addr &= ((CORE_ADDR) 1 << addr_bit) - 1; 2874 return hex_string (addr); 2875 } 2876 2877 static char * 2878 decimal2str (char *sign, ULONGEST addr, int width) 2879 { 2880 /* Steal code from valprint.c:print_decimal(). Should this worry 2881 about the real size of addr as the above does? */ 2882 unsigned long temp[3]; 2883 char *str = get_cell (); 2884 2885 int i = 0; 2886 do 2887 { 2888 temp[i] = addr % (1000 * 1000 * 1000); 2889 addr /= (1000 * 1000 * 1000); 2890 i++; 2891 width -= 9; 2892 } 2893 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0]))); 2894 2895 width += 9; 2896 if (width < 0) 2897 width = 0; 2898 2899 switch (i) 2900 { 2901 case 1: 2902 xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]); 2903 break; 2904 case 2: 2905 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width, 2906 temp[1], temp[0]); 2907 break; 2908 case 3: 2909 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width, 2910 temp[2], temp[1], temp[0]); 2911 break; 2912 default: 2913 internal_error (__FILE__, __LINE__, 2914 _("failed internal consistency check")); 2915 } 2916 2917 return str; 2918 } 2919 2920 static char * 2921 octal2str (ULONGEST addr, int width) 2922 { 2923 unsigned long temp[3]; 2924 char *str = get_cell (); 2925 2926 int i = 0; 2927 do 2928 { 2929 temp[i] = addr % (0100000 * 0100000); 2930 addr /= (0100000 * 0100000); 2931 i++; 2932 width -= 10; 2933 } 2934 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0]))); 2935 2936 width += 10; 2937 if (width < 0) 2938 width = 0; 2939 2940 switch (i) 2941 { 2942 case 1: 2943 if (temp[0] == 0) 2944 xsnprintf (str, CELLSIZE, "%*o", width, 0); 2945 else 2946 xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]); 2947 break; 2948 case 2: 2949 xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]); 2950 break; 2951 case 3: 2952 xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width, 2953 temp[2], temp[1], temp[0]); 2954 break; 2955 default: 2956 internal_error (__FILE__, __LINE__, 2957 _("failed internal consistency check")); 2958 } 2959 2960 return str; 2961 } 2962 2963 char * 2964 pulongest (ULONGEST u) 2965 { 2966 return decimal2str ("", u, 0); 2967 } 2968 2969 char * 2970 plongest (LONGEST l) 2971 { 2972 if (l < 0) 2973 return decimal2str ("-", -l, 0); 2974 else 2975 return decimal2str ("", l, 0); 2976 } 2977 2978 /* Eliminate warning from compiler on 32-bit systems. */ 2979 static int thirty_two = 32; 2980 2981 char * 2982 phex (ULONGEST l, int sizeof_l) 2983 { 2984 char *str; 2985 2986 switch (sizeof_l) 2987 { 2988 case 8: 2989 str = get_cell (); 2990 xsnprintf (str, CELLSIZE, "%08lx%08lx", 2991 (unsigned long) (l >> thirty_two), 2992 (unsigned long) (l & 0xffffffff)); 2993 break; 2994 case 4: 2995 str = get_cell (); 2996 xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l); 2997 break; 2998 case 2: 2999 str = get_cell (); 3000 xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff)); 3001 break; 3002 default: 3003 str = phex (l, sizeof (l)); 3004 break; 3005 } 3006 3007 return str; 3008 } 3009 3010 char * 3011 phex_nz (ULONGEST l, int sizeof_l) 3012 { 3013 char *str; 3014 3015 switch (sizeof_l) 3016 { 3017 case 8: 3018 { 3019 unsigned long high = (unsigned long) (l >> thirty_two); 3020 str = get_cell (); 3021 if (high == 0) 3022 xsnprintf (str, CELLSIZE, "%lx", 3023 (unsigned long) (l & 0xffffffff)); 3024 else 3025 xsnprintf (str, CELLSIZE, "%lx%08lx", high, 3026 (unsigned long) (l & 0xffffffff)); 3027 break; 3028 } 3029 case 4: 3030 str = get_cell (); 3031 xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l); 3032 break; 3033 case 2: 3034 str = get_cell (); 3035 xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff)); 3036 break; 3037 default: 3038 str = phex_nz (l, sizeof (l)); 3039 break; 3040 } 3041 3042 return str; 3043 } 3044 3045 /* Converts a LONGEST to a C-format hexadecimal literal and stores it 3046 in a static string. Returns a pointer to this string. */ 3047 char * 3048 hex_string (LONGEST num) 3049 { 3050 char *result = get_cell (); 3051 xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num))); 3052 return result; 3053 } 3054 3055 /* Converts a LONGEST number to a C-format hexadecimal literal and 3056 stores it in a static string. Returns a pointer to this string 3057 that is valid until the next call. The number is padded on the 3058 left with 0s to at least WIDTH characters. */ 3059 char * 3060 hex_string_custom (LONGEST num, int width) 3061 { 3062 char *result = get_cell (); 3063 char *result_end = result + CELLSIZE - 1; 3064 const char *hex = phex_nz (num, sizeof (num)); 3065 int hex_len = strlen (hex); 3066 3067 if (hex_len > width) 3068 width = hex_len; 3069 if (width + 2 >= CELLSIZE) 3070 internal_error (__FILE__, __LINE__, 3071 _("hex_string_custom: insufficient space to store result")); 3072 3073 strcpy (result_end - width - 2, "0x"); 3074 memset (result_end - width, '0', width); 3075 strcpy (result_end - hex_len, hex); 3076 return result_end - width - 2; 3077 } 3078 3079 /* Convert VAL to a numeral in the given radix. For 3080 * radix 10, IS_SIGNED may be true, indicating a signed quantity; 3081 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied, 3082 * it is the minimum width (0-padded if needed). USE_C_FORMAT means 3083 * to use C format in all cases. If it is false, then 'x' 3084 * and 'o' formats do not include a prefix (0x or leading 0). */ 3085 3086 char * 3087 int_string (LONGEST val, int radix, int is_signed, int width, 3088 int use_c_format) 3089 { 3090 switch (radix) 3091 { 3092 case 16: 3093 { 3094 char *result; 3095 if (width == 0) 3096 result = hex_string (val); 3097 else 3098 result = hex_string_custom (val, width); 3099 if (! use_c_format) 3100 result += 2; 3101 return result; 3102 } 3103 case 10: 3104 { 3105 if (is_signed && val < 0) 3106 return decimal2str ("-", -val, width); 3107 else 3108 return decimal2str ("", val, width); 3109 } 3110 case 8: 3111 { 3112 char *result = octal2str (val, width); 3113 if (use_c_format || val == 0) 3114 return result; 3115 else 3116 return result + 1; 3117 } 3118 default: 3119 internal_error (__FILE__, __LINE__, 3120 _("failed internal consistency check")); 3121 } 3122 } 3123 3124 /* Convert a CORE_ADDR into a string. */ 3125 const char * 3126 core_addr_to_string (const CORE_ADDR addr) 3127 { 3128 char *str = get_cell (); 3129 strcpy (str, "0x"); 3130 strcat (str, phex (addr, sizeof (addr))); 3131 return str; 3132 } 3133 3134 const char * 3135 core_addr_to_string_nz (const CORE_ADDR addr) 3136 { 3137 char *str = get_cell (); 3138 strcpy (str, "0x"); 3139 strcat (str, phex_nz (addr, sizeof (addr))); 3140 return str; 3141 } 3142 3143 /* Convert a string back into a CORE_ADDR. */ 3144 CORE_ADDR 3145 string_to_core_addr (const char *my_string) 3146 { 3147 CORE_ADDR addr = 0; 3148 3149 if (my_string[0] == '0' && tolower (my_string[1]) == 'x') 3150 { 3151 /* Assume that it is in hex. */ 3152 int i; 3153 for (i = 2; my_string[i] != '\0'; i++) 3154 { 3155 if (isdigit (my_string[i])) 3156 addr = (my_string[i] - '0') + (addr * 16); 3157 else if (isxdigit (my_string[i])) 3158 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16); 3159 else 3160 error (_("invalid hex \"%s\""), my_string); 3161 } 3162 } 3163 else 3164 { 3165 /* Assume that it is in decimal. */ 3166 int i; 3167 for (i = 0; my_string[i] != '\0'; i++) 3168 { 3169 if (isdigit (my_string[i])) 3170 addr = (my_string[i] - '0') + (addr * 10); 3171 else 3172 error (_("invalid decimal \"%s\""), my_string); 3173 } 3174 } 3175 3176 return addr; 3177 } 3178 3179 const char * 3180 host_address_to_string (const void *addr) 3181 { 3182 char *str = get_cell (); 3183 3184 xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr))); 3185 return str; 3186 } 3187 3188 char * 3189 gdb_realpath (const char *filename) 3190 { 3191 /* Method 1: The system has a compile time upper bound on a filename 3192 path. Use that and realpath() to canonicalize the name. This is 3193 the most common case. Note that, if there isn't a compile time 3194 upper bound, you want to avoid realpath() at all costs. */ 3195 #if defined(HAVE_REALPATH) 3196 { 3197 # if defined (PATH_MAX) 3198 char buf[PATH_MAX]; 3199 # define USE_REALPATH 3200 # elif defined (MAXPATHLEN) 3201 char buf[MAXPATHLEN]; 3202 # define USE_REALPATH 3203 # endif 3204 # if defined (USE_REALPATH) 3205 const char *rp = realpath (filename, buf); 3206 if (rp == NULL) 3207 rp = filename; 3208 return xstrdup (rp); 3209 # endif 3210 } 3211 #endif /* HAVE_REALPATH */ 3212 3213 /* Method 2: The host system (i.e., GNU) has the function 3214 canonicalize_file_name() which malloc's a chunk of memory and 3215 returns that, use that. */ 3216 #if defined(HAVE_CANONICALIZE_FILE_NAME) 3217 { 3218 char *rp = canonicalize_file_name (filename); 3219 if (rp == NULL) 3220 return xstrdup (filename); 3221 else 3222 return rp; 3223 } 3224 #endif 3225 3226 /* FIXME: cagney/2002-11-13: 3227 3228 Method 2a: Use realpath() with a NULL buffer. Some systems, due 3229 to the problems described in in method 3, have modified their 3230 realpath() implementation so that it will allocate a buffer when 3231 NULL is passed in. Before this can be used, though, some sort of 3232 configure time test would need to be added. Otherwize the code 3233 will likely core dump. */ 3234 3235 /* Method 3: Now we're getting desperate! The system doesn't have a 3236 compile time buffer size and no alternative function. Query the 3237 OS, using pathconf(), for the buffer limit. Care is needed 3238 though, some systems do not limit PATH_MAX (return -1 for 3239 pathconf()) making it impossible to pass a correctly sized buffer 3240 to realpath() (it could always overflow). On those systems, we 3241 skip this. */ 3242 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA) 3243 { 3244 /* Find out the max path size. */ 3245 long path_max = pathconf ("/", _PC_PATH_MAX); 3246 if (path_max > 0) 3247 { 3248 /* PATH_MAX is bounded. */ 3249 char *buf = alloca (path_max); 3250 char *rp = realpath (filename, buf); 3251 return xstrdup (rp ? rp : filename); 3252 } 3253 } 3254 #endif 3255 3256 /* This system is a lost cause, just dup the buffer. */ 3257 return xstrdup (filename); 3258 } 3259 3260 /* Return a copy of FILENAME, with its directory prefix canonicalized 3261 by gdb_realpath. */ 3262 3263 char * 3264 xfullpath (const char *filename) 3265 { 3266 const char *base_name = lbasename (filename); 3267 char *dir_name; 3268 char *real_path; 3269 char *result; 3270 3271 /* Extract the basename of filename, and return immediately 3272 a copy of filename if it does not contain any directory prefix. */ 3273 if (base_name == filename) 3274 return xstrdup (filename); 3275 3276 dir_name = alloca ((size_t) (base_name - filename + 2)); 3277 /* Allocate enough space to store the dir_name + plus one extra 3278 character sometimes needed under Windows (see below), and 3279 then the closing \000 character */ 3280 strncpy (dir_name, filename, base_name - filename); 3281 dir_name[base_name - filename] = '\000'; 3282 3283 #ifdef HAVE_DOS_BASED_FILE_SYSTEM 3284 /* We need to be careful when filename is of the form 'd:foo', which 3285 is equivalent of d:./foo, which is totally different from d:/foo. */ 3286 if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':') 3287 { 3288 dir_name[2] = '.'; 3289 dir_name[3] = '\000'; 3290 } 3291 #endif 3292 3293 /* Canonicalize the directory prefix, and build the resulting 3294 filename. If the dirname realpath already contains an ending 3295 directory separator, avoid doubling it. */ 3296 real_path = gdb_realpath (dir_name); 3297 if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1])) 3298 result = concat (real_path, base_name, (char *)NULL); 3299 else 3300 result = concat (real_path, SLASH_STRING, base_name, (char *)NULL); 3301 3302 xfree (real_path); 3303 return result; 3304 } 3305 3306 3307 /* This is the 32-bit CRC function used by the GNU separate debug 3308 facility. An executable may contain a section named 3309 .gnu_debuglink, which holds the name of a separate executable file 3310 containing its debug info, and a checksum of that file's contents, 3311 computed using this function. */ 3312 unsigned long 3313 gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len) 3314 { 3315 static const unsigned int crc32_table[256] = { 3316 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 3317 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 3318 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 3319 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 3320 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 3321 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 3322 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 3323 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 3324 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 3325 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 3326 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 3327 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 3328 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 3329 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 3330 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 3331 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 3332 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 3333 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 3334 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 3335 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 3336 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 3337 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 3338 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 3339 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 3340 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 3341 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 3342 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 3343 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 3344 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 3345 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 3346 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 3347 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 3348 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 3349 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 3350 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 3351 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 3352 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 3353 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 3354 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 3355 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 3356 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 3357 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 3358 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 3359 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 3360 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 3361 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 3362 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 3363 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 3364 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 3365 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 3366 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 3367 0x2d02ef8d 3368 }; 3369 unsigned char *end; 3370 3371 crc = ~crc & 0xffffffff; 3372 for (end = buf + len; buf < end; ++buf) 3373 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); 3374 return ~crc & 0xffffffff;; 3375 } 3376 3377 ULONGEST 3378 align_up (ULONGEST v, int n) 3379 { 3380 /* Check that N is really a power of two. */ 3381 gdb_assert (n && (n & (n-1)) == 0); 3382 return (v + n - 1) & -n; 3383 } 3384 3385 ULONGEST 3386 align_down (ULONGEST v, int n) 3387 { 3388 /* Check that N is really a power of two. */ 3389 gdb_assert (n && (n & (n-1)) == 0); 3390 return (v & -n); 3391 } 3392 3393 /* Allocation function for the libiberty hash table which uses an 3394 obstack. The obstack is passed as DATA. */ 3395 3396 void * 3397 hashtab_obstack_allocate (void *data, size_t size, size_t count) 3398 { 3399 unsigned int total = size * count; 3400 void *ptr = obstack_alloc ((struct obstack *) data, total); 3401 memset (ptr, 0, total); 3402 return ptr; 3403 } 3404 3405 /* Trivial deallocation function for the libiberty splay tree and hash 3406 table - don't deallocate anything. Rely on later deletion of the 3407 obstack. DATA will be the obstack, although it is not needed 3408 here. */ 3409 3410 void 3411 dummy_obstack_deallocate (void *object, void *data) 3412 { 3413 return; 3414 } 3415 3416 /* The bit offset of the highest byte in a ULONGEST, for overflow 3417 checking. */ 3418 3419 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT) 3420 3421 /* True (non-zero) iff DIGIT is a valid digit in radix BASE, 3422 where 2 <= BASE <= 36. */ 3423 3424 static int 3425 is_digit_in_base (unsigned char digit, int base) 3426 { 3427 if (!isalnum (digit)) 3428 return 0; 3429 if (base <= 10) 3430 return (isdigit (digit) && digit < base + '0'); 3431 else 3432 return (isdigit (digit) || tolower (digit) < base - 10 + 'a'); 3433 } 3434 3435 static int 3436 digit_to_int (unsigned char c) 3437 { 3438 if (isdigit (c)) 3439 return c - '0'; 3440 else 3441 return tolower (c) - 'a' + 10; 3442 } 3443 3444 /* As for strtoul, but for ULONGEST results. */ 3445 3446 ULONGEST 3447 strtoulst (const char *num, const char **trailer, int base) 3448 { 3449 unsigned int high_part; 3450 ULONGEST result; 3451 int minus = 0; 3452 int i = 0; 3453 3454 /* Skip leading whitespace. */ 3455 while (isspace (num[i])) 3456 i++; 3457 3458 /* Handle prefixes. */ 3459 if (num[i] == '+') 3460 i++; 3461 else if (num[i] == '-') 3462 { 3463 minus = 1; 3464 i++; 3465 } 3466 3467 if (base == 0 || base == 16) 3468 { 3469 if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X')) 3470 { 3471 i += 2; 3472 if (base == 0) 3473 base = 16; 3474 } 3475 } 3476 3477 if (base == 0 && num[i] == '0') 3478 base = 8; 3479 3480 if (base == 0) 3481 base = 10; 3482 3483 if (base < 2 || base > 36) 3484 { 3485 errno = EINVAL; 3486 return 0; 3487 } 3488 3489 result = high_part = 0; 3490 for (; is_digit_in_base (num[i], base); i += 1) 3491 { 3492 result = result * base + digit_to_int (num[i]); 3493 high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN); 3494 result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1; 3495 if (high_part > 0xff) 3496 { 3497 errno = ERANGE; 3498 result = ~ (ULONGEST) 0; 3499 high_part = 0; 3500 minus = 0; 3501 break; 3502 } 3503 } 3504 3505 if (trailer != NULL) 3506 *trailer = &num[i]; 3507 3508 result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN); 3509 if (minus) 3510 return -result; 3511 else 3512 return result; 3513 } 3514 3515 /* Simple, portable version of dirname that does not modify its 3516 argument. */ 3517 3518 char * 3519 ldirname (const char *filename) 3520 { 3521 const char *base = lbasename (filename); 3522 char *dirname; 3523 3524 while (base > filename && IS_DIR_SEPARATOR (base[-1])) 3525 --base; 3526 3527 if (base == filename) 3528 return NULL; 3529 3530 dirname = xmalloc (base - filename + 2); 3531 memcpy (dirname, filename, base - filename); 3532 3533 /* On DOS based file systems, convert "d:foo" to "d:.", so that we 3534 create "d:./bar" later instead of the (different) "d:/bar". */ 3535 if (base - filename == 2 && IS_ABSOLUTE_PATH (base) 3536 && !IS_DIR_SEPARATOR (filename[0])) 3537 dirname[base++ - filename] = '.'; 3538 3539 dirname[base - filename] = '\0'; 3540 return dirname; 3541 } 3542 3543 /* Call libiberty's buildargv, and return the result. 3544 If buildargv fails due to out-of-memory, call nomem. 3545 Therefore, the returned value is guaranteed to be non-NULL, 3546 unless the parameter itself is NULL. */ 3547 3548 char ** 3549 gdb_buildargv (const char *s) 3550 { 3551 char **argv = buildargv (s); 3552 if (s != NULL && argv == NULL) 3553 nomem (0); 3554 return argv; 3555 } 3556 3557 /* Provide a prototype to silence -Wmissing-prototypes. */ 3558 extern initialize_file_ftype _initialize_utils; 3559 3560 void 3561 _initialize_utils (void) 3562 { 3563 add_internal_problem_command (&internal_error_problem); 3564 add_internal_problem_command (&internal_warning_problem); 3565 } 3566