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