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