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