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