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