1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "event-top.h"
24 #include "gdbthread.h"
27 #ifdef HAVE_SYS_RESOURCE_H
28 #include <sys/resource.h>
29 #endif /* HAVE_SYS_RESOURCE_H */
32 #include "tui/tui.h" /* For tui_get_command_dimension. */
44 #include "gdb-demangle.h"
45 #include "expression.h"
49 #include "filenames.h"
51 #include "gdb_obstack.h"
57 #include "inferior.h" /* for signed_pointer_to_address */
59 #include "gdb_curses.h"
61 #include "readline/readline.h"
65 #include "gdb_usleep.h"
67 #include "gdb_regex.h"
70 extern PTR malloc (); /* ARI: PTR */
72 #if !HAVE_DECL_REALLOC
73 extern PTR realloc (); /* ARI: PTR */
79 void (*deprecated_error_begin_hook) (void);
81 /* Prototypes for local functions */
83 static void vfprintf_maybe_filtered (struct ui_file *, const char *,
84 va_list, int) ATTRIBUTE_PRINTF (2, 0);
86 static void fputs_maybe_filtered (const char *, struct ui_file *, int);
88 static void prompt_for_continue (void);
90 static void set_screen_size (void);
91 static void set_width (void);
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. */
99 static std::chrono::steady_clock::duration prompt_for_continue_wait_time;
101 /* A flag indicating whether to timestamp debugging messages. */
103 static int debug_timestamp = 0;
105 /* Nonzero if we have job control. */
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.) */
113 int sevenbit_strings = 0;
115 show_sevenbit_strings (struct ui_file *file, int from_tty,
116 struct cmd_list_element *c, const char *value)
118 fprintf_filtered (file, _("Printing of 8-bit characters "
119 "in strings as \\nnn is %s.\n"),
123 /* String to be printed before warning messages, if any. */
125 char *warning_pre_print = "\nwarning: ";
127 int pagination_enabled = 1;
129 show_pagination_enabled (struct ui_file *file, int from_tty,
130 struct cmd_list_element *c, const char *value)
132 fprintf_filtered (file, _("State of pagination is %s.\n"), value);
136 /* Cleanup utilities.
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
143 do_freeargv (void *arg)
145 freeargv ((char **) arg);
149 make_cleanup_freeargv (char **arg)
151 return make_cleanup (do_freeargv, arg);
154 /* Helper function which does the work for make_cleanup_fclose. */
157 do_fclose_cleanup (void *arg)
159 FILE *file = (FILE *) arg;
164 /* Return a new cleanup that closes FILE. */
167 make_cleanup_fclose (FILE *file)
169 return make_cleanup (do_fclose_cleanup, file);
172 /* Helper function which does the work for make_cleanup_obstack_free. */
175 do_obstack_free (void *arg)
177 struct obstack *ob = (struct obstack *) arg;
179 obstack_free (ob, NULL);
182 /* Return a new cleanup that frees OBSTACK. */
185 make_cleanup_obstack_free (struct obstack *obstack)
187 return make_cleanup (do_obstack_free, obstack);
191 do_ui_file_delete (void *arg)
193 ui_file_delete ((struct ui_file *) arg);
197 make_cleanup_ui_file_delete (struct ui_file *arg)
199 return make_cleanup (do_ui_file_delete, arg);
205 /* A simple implementation of singleton pattern. */
206 static struct ui_file *stream = NULL;
210 stream = ui_file_new ();
211 /* Delete it on gdb exit. */
212 make_final_cleanup (do_ui_file_delete, stream);
217 /* Helper function for make_cleanup_ui_out_redirect_pop. */
220 do_ui_out_redirect_pop (void *arg)
222 struct ui_out *uiout = (struct ui_out *) arg;
224 uiout->redirect (NULL);
227 /* Return a new cleanup that pops the last redirection by ui_out_redirect
228 with NULL parameter. */
231 make_cleanup_ui_out_redirect_pop (struct ui_out *uiout)
233 return make_cleanup (do_ui_out_redirect_pop, uiout);
237 do_free_section_addr_info (void *arg)
239 free_section_addr_info ((struct section_addr_info *) arg);
243 make_cleanup_free_section_addr_info (struct section_addr_info *addrs)
245 return make_cleanup (do_free_section_addr_info, addrs);
248 struct restore_integer_closure
255 restore_integer (void *p)
257 struct restore_integer_closure *closure
258 = (struct restore_integer_closure *) p;
260 *(closure->variable) = closure->value;
263 /* Remember the current value of *VARIABLE and make it restored when
264 the cleanup is run. */
267 make_cleanup_restore_integer (int *variable)
269 struct restore_integer_closure *c = XNEW (struct restore_integer_closure);
271 c->variable = variable;
272 c->value = *variable;
274 return make_cleanup_dtor (restore_integer, (void *) c, xfree);
277 /* Remember the current value of *VARIABLE and make it restored when
278 the cleanup is run. */
281 make_cleanup_restore_uinteger (unsigned int *variable)
283 return make_cleanup_restore_integer ((int *) variable);
286 /* Helper for make_cleanup_unpush_target. */
289 do_unpush_target (void *arg)
291 struct target_ops *ops = (struct target_ops *) arg;
296 /* Return a new cleanup that unpushes OPS. */
299 make_cleanup_unpush_target (struct target_ops *ops)
301 return make_cleanup (do_unpush_target, ops);
304 /* Helper for make_cleanup_value_free_to_mark. */
307 do_value_free_to_mark (void *value)
309 value_free_to_mark ((struct value *) value);
312 /* Free all values allocated since MARK was obtained by value_mark
313 (except for those released) when the cleanup is run. */
316 make_cleanup_value_free_to_mark (struct value *mark)
318 return make_cleanup (do_value_free_to_mark, mark);
321 /* Helper for make_cleanup_value_free. */
324 do_value_free (void *value)
326 value_free ((struct value *) value);
332 make_cleanup_value_free (struct value *value)
334 return make_cleanup (do_value_free, value);
337 /* Helper for make_cleanup_free_so. */
340 do_free_so (void *arg)
342 struct so_list *so = (struct so_list *) arg;
347 /* Make cleanup handler calling free_so for SO. */
350 make_cleanup_free_so (struct so_list *so)
352 return make_cleanup (do_free_so, so);
355 /* Helper for make_cleanup_restore_current_language. */
358 do_restore_current_language (void *p)
360 enum language saved_lang = (enum language) (uintptr_t) p;
362 set_language (saved_lang);
365 /* Remember the current value of CURRENT_LANGUAGE and make it restored when
366 the cleanup is run. */
369 make_cleanup_restore_current_language (void)
371 enum language saved_lang = current_language->la_language;
373 return make_cleanup (do_restore_current_language,
374 (void *) (uintptr_t) saved_lang);
377 /* Helper function for make_cleanup_clear_parser_state. */
380 do_clear_parser_state (void *ptr)
382 struct parser_state **p = (struct parser_state **) ptr;
387 /* Clean (i.e., set to NULL) the parser state variable P. */
390 make_cleanup_clear_parser_state (struct parser_state **p)
392 return make_cleanup (do_clear_parser_state, (void *) p);
395 /* This function is useful for cleanups.
399 old_chain = make_cleanup (free_current_contents, &foo);
401 to arrange to free the object thus allocated. */
404 free_current_contents (void *ptr)
406 void **location = (void **) ptr;
408 if (location == NULL)
409 internal_error (__FILE__, __LINE__,
410 _("free_current_contents: NULL pointer"));
411 if (*location != NULL)
420 /* Print a warning message. The first argument STRING is the warning
421 message, used as an fprintf format string, the second is the
422 va_list of arguments for that string. A warning is unfiltered (not
423 paginated) so that the user does not need to page through each
424 screen full of warnings when there are lots of them. */
427 vwarning (const char *string, va_list args)
429 if (deprecated_warning_hook)
430 (*deprecated_warning_hook) (string, args);
433 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
435 if (target_supports_terminal_ours ())
437 make_cleanup_restore_target_terminal ();
438 target_terminal_ours_for_output ();
440 if (filtered_printing_initialized ())
441 wrap_here (""); /* Force out any buffered output. */
442 gdb_flush (gdb_stdout);
443 if (warning_pre_print)
444 fputs_unfiltered (warning_pre_print, gdb_stderr);
445 vfprintf_unfiltered (gdb_stderr, string, args);
446 fprintf_unfiltered (gdb_stderr, "\n");
448 do_cleanups (old_chain);
452 /* Print an error message and return to command level.
453 The first argument STRING is the error message, used as a fprintf string,
454 and the remaining args are passed as arguments to it. */
457 verror (const char *string, va_list args)
459 throw_verror (GENERIC_ERROR, string, args);
463 error_stream (struct ui_file *stream)
465 std::string message = ui_file_as_string (stream);
467 error (("%s"), message.c_str ());
470 /* Emit a message and abort. */
472 static void ATTRIBUTE_NORETURN
473 abort_with_message (const char *msg)
475 if (gdb_stderr == NULL)
478 fputs_unfiltered (msg, gdb_stderr);
480 abort (); /* NOTE: GDB has only three calls to abort(). */
483 /* Dump core trying to increase the core soft limit to hard limit first. */
488 #ifdef HAVE_SETRLIMIT
489 struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY };
491 setrlimit (RLIMIT_CORE, &rlim);
492 #endif /* HAVE_SETRLIMIT */
494 abort (); /* NOTE: GDB has only three calls to abort(). */
497 /* Check whether GDB will be able to dump core using the dump_core
498 function. Returns zero if GDB cannot or should not dump core.
499 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
500 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
503 can_dump_core (enum resource_limit_kind limit_kind)
505 #ifdef HAVE_GETRLIMIT
508 /* Be quiet and assume we can dump if an error is returned. */
509 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
515 if (rlim.rlim_cur == 0)
519 if (rlim.rlim_max == 0)
522 #endif /* HAVE_GETRLIMIT */
527 /* Print a warning that we cannot dump core. */
530 warn_cant_dump_core (const char *reason)
532 fprintf_unfiltered (gdb_stderr,
533 _("%s\nUnable to dump core, use `ulimit -c"
534 " unlimited' before executing GDB next time.\n"),
538 /* Check whether GDB will be able to dump core using the dump_core
539 function, and print a warning if we cannot. */
542 can_dump_core_warn (enum resource_limit_kind limit_kind,
545 int core_dump_allowed = can_dump_core (limit_kind);
547 if (!core_dump_allowed)
548 warn_cant_dump_core (reason);
550 return core_dump_allowed;
553 /* Allow the user to configure the debugger behavior with respect to
554 what to do when an internal problem is detected. */
556 const char internal_problem_ask[] = "ask";
557 const char internal_problem_yes[] = "yes";
558 const char internal_problem_no[] = "no";
559 static const char *const internal_problem_modes[] =
561 internal_problem_ask,
562 internal_problem_yes,
567 /* Print a message reporting an internal error/warning. Ask the user
568 if they want to continue, dump core, or just exit. Return
569 something to indicate a quit. */
571 struct internal_problem
574 int user_settable_should_quit;
575 const char *should_quit;
576 int user_settable_should_dump_core;
577 const char *should_dump_core;
580 /* Report a problem, internal to GDB, to the user. Once the problem
581 has been reported, and assuming GDB didn't quit, the caller can
582 either allow execution to resume or throw an error. */
584 static void ATTRIBUTE_PRINTF (4, 0)
585 internal_vproblem (struct internal_problem *problem,
586 const char *file, int line, const char *fmt, va_list ap)
592 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
594 /* Don't allow infinite error/warning recursion. */
596 static char msg[] = "Recursive internal problem.\n";
605 abort_with_message (msg);
608 /* Newer GLIBC versions put the warn_unused_result attribute
609 on write, but this is one of those rare cases where
610 ignoring the return value is correct. Casting to (void)
611 does not fix this problem. This is the solution suggested
612 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
613 if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg))
614 abort (); /* NOTE: GDB has only three calls to abort(). */
619 /* Create a string containing the full error/warning message. Need
620 to call query with this full string, as otherwize the reason
621 (error/warning) and question become separated. Format using a
622 style similar to a compiler error message. Include extra detail
623 so that the user knows that they are living on the edge. */
627 msg = xstrvprintf (fmt, ap);
628 reason = xstrprintf ("%s:%d: %s: %s\n"
629 "A problem internal to GDB has been detected,\n"
630 "further debugging may prove unreliable.",
631 file, line, problem->name, msg);
633 make_cleanup (xfree, reason);
636 /* Fall back to abort_with_message if gdb_stderr is not set up. */
637 if (gdb_stderr == NULL)
639 fputs (reason, stderr);
640 abort_with_message ("\n");
643 /* Try to get the message out and at the start of a new line. */
644 if (target_supports_terminal_ours ())
646 make_cleanup_restore_target_terminal ();
647 target_terminal_ours_for_output ();
649 if (filtered_printing_initialized ())
652 /* Emit the message unless query will emit it below. */
653 if (problem->should_quit != internal_problem_ask
655 || !filtered_printing_initialized ())
656 fprintf_unfiltered (gdb_stderr, "%s\n", reason);
658 if (problem->should_quit == internal_problem_ask)
660 /* Default (yes/batch case) is to quit GDB. When in batch mode
661 this lessens the likelihood of GDB going into an infinite
663 if (!confirm || !filtered_printing_initialized ())
666 quit_p = query (_("%s\nQuit this debugging session? "), reason);
668 else if (problem->should_quit == internal_problem_yes)
670 else if (problem->should_quit == internal_problem_no)
673 internal_error (__FILE__, __LINE__, _("bad switch"));
675 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr);
676 if (REPORT_BUGS_TO[0])
677 fprintf_unfiltered (gdb_stderr, _(" For instructions, see:\n%s."),
679 fputs_unfiltered ("\n\n", gdb_stderr);
681 if (problem->should_dump_core == internal_problem_ask)
683 if (!can_dump_core_warn (LIMIT_MAX, reason))
685 else if (!filtered_printing_initialized ())
689 /* Default (yes/batch case) is to dump core. This leaves a GDB
690 `dropping' so that it is easier to see that something went
692 dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
695 else if (problem->should_dump_core == internal_problem_yes)
696 dump_core_p = can_dump_core_warn (LIMIT_MAX, reason);
697 else if (problem->should_dump_core == internal_problem_no)
700 internal_error (__FILE__, __LINE__, _("bad switch"));
713 #ifdef HAVE_WORKING_FORK
721 do_cleanups (cleanup);
724 static struct internal_problem internal_error_problem = {
725 "internal-error", 1, internal_problem_ask, 1, internal_problem_ask
729 internal_verror (const char *file, int line, const char *fmt, va_list ap)
731 internal_vproblem (&internal_error_problem, file, line, fmt, ap);
732 throw_quit (_("Command aborted."));
735 static struct internal_problem internal_warning_problem = {
736 "internal-warning", 1, internal_problem_ask, 1, internal_problem_ask
740 internal_vwarning (const char *file, int line, const char *fmt, va_list ap)
742 internal_vproblem (&internal_warning_problem, file, line, fmt, ap);
745 static struct internal_problem demangler_warning_problem = {
746 "demangler-warning", 1, internal_problem_ask, 0, internal_problem_no
750 demangler_vwarning (const char *file, int line, const char *fmt, va_list ap)
752 internal_vproblem (&demangler_warning_problem, file, line, fmt, ap);
756 demangler_warning (const char *file, int line, const char *string, ...)
760 va_start (ap, string);
761 demangler_vwarning (file, line, string, ap);
765 /* Dummy functions to keep add_prefix_cmd happy. */
768 set_internal_problem_cmd (char *args, int from_tty)
773 show_internal_problem_cmd (char *args, int from_tty)
777 /* When GDB reports an internal problem (error or warning) it gives
778 the user the opportunity to quit GDB and/or create a core file of
779 the current debug session. This function registers a few commands
780 that make it possible to specify that GDB should always or never
781 quit or create a core file, without asking. The commands look
784 maint set PROBLEM-NAME quit ask|yes|no
785 maint show PROBLEM-NAME quit
786 maint set PROBLEM-NAME corefile ask|yes|no
787 maint show PROBLEM-NAME corefile
789 Where PROBLEM-NAME is currently "internal-error" or
790 "internal-warning". */
793 add_internal_problem_command (struct internal_problem *problem)
795 struct cmd_list_element **set_cmd_list;
796 struct cmd_list_element **show_cmd_list;
800 set_cmd_list = XNEW (struct cmd_list_element *);
801 show_cmd_list = XNEW (struct cmd_list_element *);
802 *set_cmd_list = NULL;
803 *show_cmd_list = NULL;
805 set_doc = xstrprintf (_("Configure what GDB does when %s is detected."),
808 show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
811 add_prefix_cmd ((char*) problem->name,
812 class_maintenance, set_internal_problem_cmd, set_doc,
814 concat ("maintenance set ", problem->name, " ",
816 0/*allow-unknown*/, &maintenance_set_cmdlist);
818 add_prefix_cmd ((char*) problem->name,
819 class_maintenance, show_internal_problem_cmd, show_doc,
821 concat ("maintenance show ", problem->name, " ",
823 0/*allow-unknown*/, &maintenance_show_cmdlist);
825 if (problem->user_settable_should_quit)
827 set_doc = xstrprintf (_("Set whether GDB should quit "
828 "when an %s is detected"),
830 show_doc = xstrprintf (_("Show whether GDB will quit "
831 "when an %s is detected"),
833 add_setshow_enum_cmd ("quit", class_maintenance,
834 internal_problem_modes,
835 &problem->should_quit,
848 if (problem->user_settable_should_dump_core)
850 set_doc = xstrprintf (_("Set whether GDB should create a core "
851 "file of GDB when %s is detected"),
853 show_doc = xstrprintf (_("Show whether GDB will create a core "
854 "file of GDB when %s is detected"),
856 add_setshow_enum_cmd ("corefile", class_maintenance,
857 internal_problem_modes,
858 &problem->should_dump_core,
872 /* Return a newly allocated string, containing the PREFIX followed
873 by the system error message for errno (separated by a colon).
875 The result must be deallocated after use. */
878 perror_string (const char *prefix)
883 err = safe_strerror (errno);
884 combined = (char *) xmalloc (strlen (err) + strlen (prefix) + 3);
885 strcpy (combined, prefix);
886 strcat (combined, ": ");
887 strcat (combined, err);
892 /* Print the system error message for errno, and also mention STRING
893 as the file name for which the error was encountered. Use ERRCODE
894 for the thrown exception. Then return to command level. */
897 throw_perror_with_name (enum errors errcode, const char *string)
901 combined = perror_string (string);
902 make_cleanup (xfree, combined);
904 /* I understand setting these is a matter of taste. Still, some people
905 may clear errno but not know about bfd_error. Doing this here is not
907 bfd_set_error (bfd_error_no_error);
910 throw_error (errcode, _("%s."), combined);
913 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
916 perror_with_name (const char *string)
918 throw_perror_with_name (GENERIC_ERROR, string);
921 /* Same as perror_with_name except that it prints a warning instead
922 of throwing an error. */
925 perror_warning_with_name (const char *string)
929 combined = perror_string (string);
930 warning (_("%s"), combined);
934 /* Print the system error message for ERRCODE, and also mention STRING
935 as the file name for which the error was encountered. */
938 print_sys_errmsg (const char *string, int errcode)
943 err = safe_strerror (errcode);
944 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
945 strcpy (combined, string);
946 strcat (combined, ": ");
947 strcat (combined, err);
949 /* We want anything which was printed on stdout to come out first, before
951 gdb_flush (gdb_stdout);
952 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
955 /* Control C eventually causes this to be called, at a convenient time. */
960 struct ui *ui = current_ui;
962 if (sync_quit_force_run)
964 sync_quit_force_run = 0;
965 quit_force (NULL, 0);
969 /* No steenking SIGINT will ever be coming our way when the
970 program is resumed. Don't lie. */
974 /* If there is no terminal switching for this target, then we can't
975 possibly get screwed by the lack of job control. */
976 || !target_supports_terminal_ours ())
979 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
988 if (sync_quit_force_run)
993 if (deprecated_interactive_hook)
994 deprecated_interactive_hook ();
998 /* Called when a memory allocation fails, with the number of bytes of
999 memory requested in SIZE. */
1002 malloc_failure (long size)
1006 internal_error (__FILE__, __LINE__,
1007 _("virtual memory exhausted: can't allocate %ld bytes."),
1012 internal_error (__FILE__, __LINE__, _("virtual memory exhausted."));
1016 /* My replacement for the read system call.
1017 Used like `read' but keeps going if `read' returns too soon. */
1020 myread (int desc, char *addr, int len)
1027 val = read (desc, addr, len);
1031 return orglen - len;
1039 print_spaces (int n, struct ui_file *file)
1041 fputs_unfiltered (n_spaces (n), file);
1044 /* Print a host address. */
1047 gdb_print_host_address_1 (const void *addr, struct ui_file *stream)
1049 fprintf_filtered (stream, "%s", host_address_to_string (addr));
1055 make_hex_string (const gdb_byte *data, size_t length)
1057 char *result = (char *) xmalloc (length * 2 + 1);
1062 for (i = 0; i < length; ++i)
1063 p += xsnprintf (p, 3, "%02x", data[i]);
1070 /* A cleanup function that calls regfree. */
1073 do_regfree_cleanup (void *r)
1075 regfree ((regex_t *) r);
1078 /* Create a new cleanup that frees the compiled regular expression R. */
1081 make_regfree_cleanup (regex_t *r)
1083 return make_cleanup (do_regfree_cleanup, r);
1086 /* Return an xmalloc'd error message resulting from a regular
1087 expression compilation failure. */
1090 get_regcomp_error (int code, regex_t *rx)
1092 size_t length = regerror (code, rx, NULL, 0);
1093 char *result = (char *) xmalloc (length);
1095 regerror (code, rx, result, length);
1099 /* Compile a regexp and throw an exception on error. This returns a
1100 cleanup to free the resulting pattern on success. RX must not be
1104 compile_rx_or_error (regex_t *pattern, const char *rx, const char *message)
1108 gdb_assert (rx != NULL);
1110 code = regcomp (pattern, rx, REG_NOSUB);
1113 char *err = get_regcomp_error (code, pattern);
1115 make_cleanup (xfree, err);
1116 error (("%s: %s"), message, err);
1119 return make_regfree_cleanup (pattern);
1122 /* A cleanup that simply calls ui_unregister_input_event_handler. */
1125 ui_unregister_input_event_handler_cleanup (void *ui)
1127 ui_unregister_input_event_handler ((struct ui *) ui);
1130 /* Set up to handle input. */
1132 static struct cleanup *
1133 prepare_to_handle_input (void)
1135 struct cleanup *old_chain;
1137 old_chain = make_cleanup_restore_target_terminal ();
1138 target_terminal_ours ();
1140 ui_register_input_event_handler (current_ui);
1141 if (current_ui->prompt_state == PROMPT_BLOCKED)
1142 make_cleanup (ui_unregister_input_event_handler_cleanup, current_ui);
1144 make_cleanup_override_quit_handler (default_quit_handler);
1151 /* This function supports the query, nquery, and yquery functions.
1152 Ask user a y-or-n question and return 0 if answer is no, 1 if
1153 answer is yes, or default the answer to the specified default
1154 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1155 default answer, or '\0' for no default.
1156 CTLSTR is the control string and should end in "? ". It should
1157 not say how to answer, because we do that.
1158 ARGS are the arguments passed along with the CTLSTR argument to
1161 static int ATTRIBUTE_PRINTF (1, 0)
1162 defaulted_query (const char *ctlstr, const char defchar, va_list args)
1167 char def_answer, not_def_answer;
1168 char *y_string, *n_string, *question, *prompt;
1169 struct cleanup *old_chain;
1171 /* Set up according to which answer is the default. */
1172 if (defchar == '\0')
1176 not_def_answer = 'N';
1180 else if (defchar == 'y')
1184 not_def_answer = 'N';
1192 not_def_answer = 'Y';
1197 /* Automatically answer the default value if the user did not want
1198 prompts or the command was issued with the server prefix. */
1199 if (!confirm || server_command)
1202 /* If input isn't coming from the user directly, just say what
1203 question we're asking, and then answer the default automatically. This
1204 way, important error messages don't get lost when talking to GDB
1206 if (current_ui->instream != current_ui->stdin_stream
1207 || !input_interactive_p (current_ui))
1209 old_chain = make_cleanup_restore_target_terminal ();
1211 target_terminal_ours_for_output ();
1213 vfprintf_filtered (gdb_stdout, ctlstr, args);
1215 printf_filtered (_("(%s or %s) [answered %c; "
1216 "input not from terminal]\n"),
1217 y_string, n_string, def_answer);
1218 gdb_flush (gdb_stdout);
1220 do_cleanups (old_chain);
1224 if (deprecated_query_hook)
1228 old_chain = make_cleanup_restore_target_terminal ();
1229 res = deprecated_query_hook (ctlstr, args);
1230 do_cleanups (old_chain);
1234 /* Format the question outside of the loop, to avoid reusing args. */
1235 question = xstrvprintf (ctlstr, args);
1236 old_chain = make_cleanup (xfree, question);
1237 prompt = xstrprintf (_("%s%s(%s or %s) %s"),
1238 annotation_level > 1 ? "\n\032\032pre-query\n" : "",
1239 question, y_string, n_string,
1240 annotation_level > 1 ? "\n\032\032query\n" : "");
1241 make_cleanup (xfree, prompt);
1243 /* Used to add duration we waited for user to respond to
1244 prompt_for_continue_wait_time. */
1245 using namespace std::chrono;
1246 steady_clock::time_point prompt_started = steady_clock::now ();
1248 prepare_to_handle_input ();
1252 char *response, answer;
1254 gdb_flush (gdb_stdout);
1255 response = gdb_readline_wrapper (prompt);
1257 if (response == NULL) /* C-d */
1259 printf_filtered ("EOF [assumed %c]\n", def_answer);
1264 answer = response[0];
1269 /* Check answer. For the non-default, the user must specify
1270 the non-default explicitly. */
1271 if (answer == not_def_answer)
1273 retval = !def_value;
1276 /* Otherwise, if a default was specified, the user may either
1277 specify the required input or have it default by entering
1279 if (answer == def_answer
1280 || (defchar != '\0' && answer == '\0'))
1285 /* Invalid entries are not defaulted and require another selection. */
1286 printf_filtered (_("Please answer %s or %s.\n"),
1287 y_string, n_string);
1290 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1291 prompt_for_continue_wait_time += steady_clock::now () - prompt_started;
1293 if (annotation_level > 1)
1294 printf_filtered (("\n\032\032post-query\n"));
1295 do_cleanups (old_chain);
1300 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1301 answer is yes, or 0 if answer is defaulted.
1302 Takes three args which are given to printf to print the question.
1303 The first, a control string, should end in "? ".
1304 It should not say how to answer, because we do that. */
1307 nquery (const char *ctlstr, ...)
1312 va_start (args, ctlstr);
1313 ret = defaulted_query (ctlstr, 'n', args);
1318 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1319 answer is yes, or 1 if answer is defaulted.
1320 Takes three args which are given to printf to print the question.
1321 The first, a control string, should end in "? ".
1322 It should not say how to answer, because we do that. */
1325 yquery (const char *ctlstr, ...)
1330 va_start (args, ctlstr);
1331 ret = defaulted_query (ctlstr, 'y', args);
1336 /* Ask user a y-or-n question and return 1 iff answer is yes.
1337 Takes three args which are given to printf to print the question.
1338 The first, a control string, should end in "? ".
1339 It should not say how to answer, because we do that. */
1342 query (const char *ctlstr, ...)
1347 va_start (args, ctlstr);
1348 ret = defaulted_query (ctlstr, '\0', args);
1353 /* A helper for parse_escape that converts a host character to a
1354 target character. C is the host character. If conversion is
1355 possible, then the target character is stored in *TARGET_C and the
1356 function returns 1. Otherwise, the function returns 0. */
1359 host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c)
1361 struct obstack host_data;
1363 struct cleanup *cleanups;
1366 obstack_init (&host_data);
1367 cleanups = make_cleanup_obstack_free (&host_data);
1369 convert_between_encodings (target_charset (gdbarch), host_charset (),
1370 (gdb_byte *) &the_char, 1, 1,
1371 &host_data, translit_none);
1373 if (obstack_object_size (&host_data) == 1)
1376 *target_c = *(char *) obstack_base (&host_data);
1379 do_cleanups (cleanups);
1383 /* Parse a C escape sequence. STRING_PTR points to a variable
1384 containing a pointer to the string to parse. That pointer
1385 should point to the character after the \. That pointer
1386 is updated past the characters we use. The value of the
1387 escape sequence is returned.
1389 A negative value means the sequence \ newline was seen,
1390 which is supposed to be equivalent to nothing at all.
1392 If \ is followed by a null character, we return a negative
1393 value and leave the string pointer pointing at the null character.
1395 If \ is followed by 000, we return 0 and leave the string pointer
1396 after the zeros. A value of 0 does not mean end of string. */
1399 parse_escape (struct gdbarch *gdbarch, const char **string_ptr)
1401 int target_char = -2; /* Initialize to avoid GCC warnings. */
1402 int c = *(*string_ptr)++;
1421 int i = host_hex_value (c);
1426 if (isdigit (c) && c != '8' && c != '9')
1430 i += host_hex_value (c);
1466 if (!host_char_to_target (gdbarch, c, &target_char))
1467 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1468 " which has no equivalent\nin the `%s' character set."),
1469 c, c, target_charset (gdbarch));
1473 /* Print the character C on STREAM as part of the contents of a literal
1474 string whose delimiter is QUOTER. Note that this routine should only
1475 be called for printing things which are independent of the language
1476 of the program being debugged.
1478 printchar will normally escape backslashes and instances of QUOTER. If
1479 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1480 As a side effect, if you pass the backslash character as the QUOTER,
1481 printchar will escape backslashes as usual, but not any other quoting
1485 printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1486 void (*do_fprintf) (struct ui_file *, const char *, ...)
1487 ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
1489 c &= 0xFF; /* Avoid sign bit follies */
1491 if (c < 0x20 || /* Low control chars */
1492 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1493 (sevenbit_strings && c >= 0x80))
1494 { /* high order bit set */
1498 do_fputs ("\\n", stream);
1501 do_fputs ("\\b", stream);
1504 do_fputs ("\\t", stream);
1507 do_fputs ("\\f", stream);
1510 do_fputs ("\\r", stream);
1513 do_fputs ("\\e", stream);
1516 do_fputs ("\\a", stream);
1519 do_fprintf (stream, "\\%.3o", (unsigned int) c);
1525 if (quoter != 0 && (c == '\\' || c == quoter))
1526 do_fputs ("\\", stream);
1527 do_fprintf (stream, "%c", c);
1531 /* Print the character C on STREAM as part of the contents of a
1532 literal string whose delimiter is QUOTER. Note that these routines
1533 should only be call for printing things which are independent of
1534 the language of the program being debugged. */
1537 fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
1540 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1544 fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
1547 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1551 fputstrn_filtered (const char *str, int n, int quoter,
1552 struct ui_file *stream)
1556 for (i = 0; i < n; i++)
1557 printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
1561 fputstrn_unfiltered (const char *str, int n, int quoter,
1562 struct ui_file *stream)
1566 for (i = 0; i < n; i++)
1567 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1571 /* Number of lines per page or UINT_MAX if paging is disabled. */
1572 static unsigned int lines_per_page;
1574 show_lines_per_page (struct ui_file *file, int from_tty,
1575 struct cmd_list_element *c, const char *value)
1577 fprintf_filtered (file,
1578 _("Number of lines gdb thinks are in a page is %s.\n"),
1582 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1583 static unsigned int chars_per_line;
1585 show_chars_per_line (struct ui_file *file, int from_tty,
1586 struct cmd_list_element *c, const char *value)
1588 fprintf_filtered (file,
1589 _("Number of characters gdb thinks "
1590 "are in a line is %s.\n"),
1594 /* Current count of lines printed on this page, chars on this line. */
1595 static unsigned int lines_printed, chars_printed;
1597 /* Buffer and start column of buffered text, for doing smarter word-
1598 wrapping. When someone calls wrap_here(), we start buffering output
1599 that comes through fputs_filtered(). If we see a newline, we just
1600 spit it out and forget about the wrap_here(). If we see another
1601 wrap_here(), we spit it out and remember the newer one. If we see
1602 the end of the line, we spit out a newline, the indent, and then
1603 the buffered output. */
1605 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1606 are waiting to be output (they have already been counted in chars_printed).
1607 When wrap_buffer[0] is null, the buffer is empty. */
1608 static char *wrap_buffer;
1610 /* Pointer in wrap_buffer to the next character to fill. */
1611 static char *wrap_pointer;
1613 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1615 static const char *wrap_indent;
1617 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1618 is not in effect. */
1619 static int wrap_column;
1622 /* Initialize the number of lines per page and chars per line. */
1625 init_page_info (void)
1629 lines_per_page = UINT_MAX;
1630 chars_per_line = UINT_MAX;
1634 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
1639 #if defined(__GO32__)
1640 rows = ScreenRows ();
1641 cols = ScreenCols ();
1642 lines_per_page = rows;
1643 chars_per_line = cols;
1645 /* Make sure Readline has initialized its terminal settings. */
1646 rl_reset_terminal (NULL);
1648 /* Get the screen size from Readline. */
1649 rl_get_screen_size (&rows, &cols);
1650 lines_per_page = rows;
1651 chars_per_line = cols;
1653 /* Readline should have fetched the termcap entry for us.
1654 Only try to use tgetnum function if rl_get_screen_size
1655 did not return a useful value. */
1656 if (((rows <= 0) && (tgetnum ("li") < 0))
1657 /* Also disable paging if inside Emacs. $EMACS was used
1658 before Emacs v25.1, $INSIDE_EMACS is used since then. */
1659 || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1661 /* The number of lines per page is not mentioned in the terminal
1662 description or EMACS evironment variable is set. This probably
1663 means that paging is not useful, so disable paging. */
1664 lines_per_page = UINT_MAX;
1667 /* If the output is not a terminal, don't paginate it. */
1668 if (!ui_file_isatty (gdb_stdout))
1669 lines_per_page = UINT_MAX;
1673 /* We handle SIGWINCH ourselves. */
1674 rl_catch_sigwinch = 0;
1680 /* Return nonzero if filtered printing is initialized. */
1682 filtered_printing_initialized (void)
1684 return wrap_buffer != NULL;
1687 /* Helper for make_cleanup_restore_page_info. */
1690 do_restore_page_info_cleanup (void *arg)
1696 /* Provide cleanup for restoring the terminal size. */
1699 make_cleanup_restore_page_info (void)
1701 struct cleanup *back_to;
1703 back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
1704 make_cleanup_restore_uinteger (&lines_per_page);
1705 make_cleanup_restore_uinteger (&chars_per_line);
1710 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1711 Provide cleanup for restoring the original state. */
1714 set_batch_flag_and_make_cleanup_restore_page_info (void)
1716 struct cleanup *back_to = make_cleanup_restore_page_info ();
1718 make_cleanup_restore_integer (&batch_flag);
1725 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1728 set_screen_size (void)
1730 int rows = lines_per_page;
1731 int cols = chars_per_line;
1739 /* Update Readline's idea of the terminal size. */
1740 rl_set_screen_size (rows, cols);
1743 /* Reinitialize WRAP_BUFFER according to the current value of
1749 if (chars_per_line == 0)
1754 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1755 wrap_buffer[0] = '\0';
1758 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1759 wrap_pointer = wrap_buffer; /* Start it at the beginning. */
1763 set_width_command (char *args, int from_tty, struct cmd_list_element *c)
1770 set_height_command (char *args, int from_tty, struct cmd_list_element *c)
1778 set_screen_width_and_height (int width, int height)
1780 lines_per_page = height;
1781 chars_per_line = width;
1787 /* Wait, so the user can read what's on the screen. Prompt the user
1788 to continue by pressing RETURN. 'q' is also provided because
1789 telling users what to do in the prompt is more user-friendly than
1790 expecting them to think of Ctrl-C/SIGINT. */
1793 prompt_for_continue (void)
1796 char cont_prompt[120];
1797 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1798 /* Used to add duration we waited for user to respond to
1799 prompt_for_continue_wait_time. */
1800 using namespace std::chrono;
1801 steady_clock::time_point prompt_started = steady_clock::now ();
1803 if (annotation_level > 1)
1804 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1806 strcpy (cont_prompt,
1807 "---Type <return> to continue, or q <return> to quit---");
1808 if (annotation_level > 1)
1809 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1811 /* We must do this *before* we call gdb_readline_wrapper, else it
1812 will eventually call us -- thinking that we're trying to print
1813 beyond the end of the screen. */
1814 reinitialize_more_filter ();
1816 prepare_to_handle_input ();
1818 /* Call gdb_readline_wrapper, not readline, in order to keep an
1819 event loop running. */
1820 ignore = gdb_readline_wrapper (cont_prompt);
1821 make_cleanup (xfree, ignore);
1823 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1824 prompt_for_continue_wait_time += steady_clock::now () - prompt_started;
1826 if (annotation_level > 1)
1827 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1833 while (*p == ' ' || *p == '\t')
1836 /* Do not call quit here; there is no possibility of SIGINT. */
1837 throw_quit ("Quit");
1840 /* Now we have to do this again, so that GDB will know that it doesn't
1841 need to save the ---Type <return>--- line at the top of the screen. */
1842 reinitialize_more_filter ();
1844 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1846 do_cleanups (old_chain);
1849 /* Initialize timer to keep track of how long we waited for the user. */
1852 reset_prompt_for_continue_wait_time (void)
1854 using namespace std::chrono;
1856 prompt_for_continue_wait_time = steady_clock::duration::zero ();
1859 /* Fetch the cumulative time spent in prompt_for_continue. */
1861 std::chrono::steady_clock::duration
1862 get_prompt_for_continue_wait_time ()
1864 return prompt_for_continue_wait_time;
1867 /* Reinitialize filter; ie. tell it to reset to original values. */
1870 reinitialize_more_filter (void)
1876 /* Indicate that if the next sequence of characters overflows the line,
1877 a newline should be inserted here rather than when it hits the end.
1878 If INDENT is non-null, it is a string to be printed to indent the
1879 wrapped part on the next line. INDENT must remain accessible until
1880 the next call to wrap_here() or until a newline is printed through
1883 If the line is already overfull, we immediately print a newline and
1884 the indentation, and disable further wrapping.
1886 If we don't know the width of lines, but we know the page height,
1887 we must not wrap words, but should still keep track of newlines
1888 that were explicitly printed.
1890 INDENT should not contain tabs, as that will mess up the char count
1891 on the next line. FIXME.
1893 This routine is guaranteed to force out any output which has been
1894 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1895 used to force out output from the wrap_buffer. */
1898 wrap_here (const char *indent)
1900 /* This should have been allocated, but be paranoid anyway. */
1902 internal_error (__FILE__, __LINE__,
1903 _("failed internal consistency check"));
1907 *wrap_pointer = '\0';
1908 fputs_unfiltered (wrap_buffer, gdb_stdout);
1910 wrap_pointer = wrap_buffer;
1911 wrap_buffer[0] = '\0';
1912 if (chars_per_line == UINT_MAX) /* No line overflow checking. */
1916 else if (chars_printed >= chars_per_line)
1918 puts_filtered ("\n");
1920 puts_filtered (indent);
1925 wrap_column = chars_printed;
1929 wrap_indent = indent;
1933 /* Print input string to gdb_stdout, filtered, with wrap,
1934 arranging strings in columns of n chars. String can be
1935 right or left justified in the column. Never prints
1936 trailing spaces. String should never be longer than
1937 width. FIXME: this could be useful for the EXAMINE
1938 command, which currently doesn't tabulate very well. */
1941 puts_filtered_tabular (char *string, int width, int right)
1947 gdb_assert (chars_per_line > 0);
1948 if (chars_per_line == UINT_MAX)
1950 fputs_filtered (string, gdb_stdout);
1951 fputs_filtered ("\n", gdb_stdout);
1955 if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
1956 fputs_filtered ("\n", gdb_stdout);
1958 if (width >= chars_per_line)
1959 width = chars_per_line - 1;
1961 stringlen = strlen (string);
1963 if (chars_printed > 0)
1964 spaces = width - (chars_printed - 1) % width - 1;
1966 spaces += width - stringlen;
1968 spacebuf = (char *) alloca (spaces + 1);
1969 spacebuf[spaces] = '\0';
1971 spacebuf[spaces] = ' ';
1973 fputs_filtered (spacebuf, gdb_stdout);
1974 fputs_filtered (string, gdb_stdout);
1978 /* Ensure that whatever gets printed next, using the filtered output
1979 commands, starts at the beginning of the line. I.e. if there is
1980 any pending output for the current line, flush it and start a new
1981 line. Otherwise do nothing. */
1986 if (chars_printed > 0)
1988 puts_filtered ("\n");
1993 /* Like fputs but if FILTER is true, pause after every screenful.
1995 Regardless of FILTER can wrap at points other than the final
1996 character of a line.
1998 Unlike fputs, fputs_maybe_filtered does not return a value.
1999 It is OK for LINEBUFFER to be NULL, in which case just don't print
2002 Note that a longjmp to top level may occur in this routine (only if
2003 FILTER is true) (since prompt_for_continue may do so) so this
2004 routine should not be called when cleanups are not in place. */
2007 fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
2010 const char *lineptr;
2012 if (linebuffer == 0)
2015 /* Don't do any filtering if it is disabled. */
2016 if (stream != gdb_stdout
2017 || !pagination_enabled
2019 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
2020 || top_level_interpreter () == NULL
2021 || interp_ui_out (top_level_interpreter ())->is_mi_like_p ())
2023 fputs_unfiltered (linebuffer, stream);
2027 /* Go through and output each character. Show line extension
2028 when this is necessary; prompt user for new page when this is
2031 lineptr = linebuffer;
2034 /* Possible new page. */
2035 if (filter && (lines_printed >= lines_per_page - 1))
2036 prompt_for_continue ();
2038 while (*lineptr && *lineptr != '\n')
2040 /* Print a single line. */
2041 if (*lineptr == '\t')
2044 *wrap_pointer++ = '\t';
2046 fputc_unfiltered ('\t', stream);
2047 /* Shifting right by 3 produces the number of tab stops
2048 we have already passed, and then adding one and
2049 shifting left 3 advances to the next tab stop. */
2050 chars_printed = ((chars_printed >> 3) + 1) << 3;
2056 *wrap_pointer++ = *lineptr;
2058 fputc_unfiltered (*lineptr, stream);
2063 if (chars_printed >= chars_per_line)
2065 unsigned int save_chars = chars_printed;
2069 /* If we aren't actually wrapping, don't output newline --
2070 if chars_per_line is right, we probably just overflowed
2071 anyway; if it's wrong, let us keep going. */
2073 fputc_unfiltered ('\n', stream);
2075 /* Possible new page. */
2076 if (lines_printed >= lines_per_page - 1)
2077 prompt_for_continue ();
2079 /* Now output indentation and wrapped string. */
2082 fputs_unfiltered (wrap_indent, stream);
2083 *wrap_pointer = '\0'; /* Null-terminate saved stuff, */
2084 fputs_unfiltered (wrap_buffer, stream); /* and eject it. */
2085 /* FIXME, this strlen is what prevents wrap_indent from
2086 containing tabs. However, if we recurse to print it
2087 and count its chars, we risk trouble if wrap_indent is
2088 longer than (the user settable) chars_per_line.
2089 Note also that this can set chars_printed > chars_per_line
2090 if we are printing a long string. */
2091 chars_printed = strlen (wrap_indent)
2092 + (save_chars - wrap_column);
2093 wrap_pointer = wrap_buffer; /* Reset buffer */
2094 wrap_buffer[0] = '\0';
2095 wrap_column = 0; /* And disable fancy wrap */
2100 if (*lineptr == '\n')
2103 wrap_here ((char *) 0); /* Spit out chars, cancel
2106 fputc_unfiltered ('\n', stream);
2113 fputs_filtered (const char *linebuffer, struct ui_file *stream)
2115 fputs_maybe_filtered (linebuffer, stream, 1);
2119 putchar_unfiltered (int c)
2123 ui_file_write (gdb_stdout, &buf, 1);
2127 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2128 May return nonlocally. */
2131 putchar_filtered (int c)
2133 return fputc_filtered (c, gdb_stdout);
2137 fputc_unfiltered (int c, struct ui_file *stream)
2141 ui_file_write (stream, &buf, 1);
2146 fputc_filtered (int c, struct ui_file *stream)
2152 fputs_filtered (buf, stream);
2156 /* puts_debug is like fputs_unfiltered, except it prints special
2157 characters in printable fashion. */
2160 puts_debug (char *prefix, char *string, char *suffix)
2164 /* Print prefix and suffix after each line. */
2165 static int new_line = 1;
2166 static int return_p = 0;
2167 static char *prev_prefix = "";
2168 static char *prev_suffix = "";
2170 if (*string == '\n')
2173 /* If the prefix is changing, print the previous suffix, a new line,
2174 and the new prefix. */
2175 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2177 fputs_unfiltered (prev_suffix, gdb_stdlog);
2178 fputs_unfiltered ("\n", gdb_stdlog);
2179 fputs_unfiltered (prefix, gdb_stdlog);
2182 /* Print prefix if we printed a newline during the previous call. */
2186 fputs_unfiltered (prefix, gdb_stdlog);
2189 prev_prefix = prefix;
2190 prev_suffix = suffix;
2192 /* Output characters in a printable format. */
2193 while ((ch = *string++) != '\0')
2199 fputc_unfiltered (ch, gdb_stdlog);
2202 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2206 fputs_unfiltered ("\\\\", gdb_stdlog);
2209 fputs_unfiltered ("\\b", gdb_stdlog);
2212 fputs_unfiltered ("\\f", gdb_stdlog);
2216 fputs_unfiltered ("\\n", gdb_stdlog);
2219 fputs_unfiltered ("\\r", gdb_stdlog);
2222 fputs_unfiltered ("\\t", gdb_stdlog);
2225 fputs_unfiltered ("\\v", gdb_stdlog);
2229 return_p = ch == '\r';
2232 /* Print suffix if we printed a newline. */
2235 fputs_unfiltered (suffix, gdb_stdlog);
2236 fputs_unfiltered ("\n", gdb_stdlog);
2241 /* Print a variable number of ARGS using format FORMAT. If this
2242 information is going to put the amount written (since the last call
2243 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2244 call prompt_for_continue to get the users permision to continue.
2246 Unlike fprintf, this function does not return a value.
2248 We implement three variants, vfprintf (takes a vararg list and stream),
2249 fprintf (takes a stream to write on), and printf (the usual).
2251 Note also that a longjmp to top level may occur in this routine
2252 (since prompt_for_continue may do so) so this routine should not be
2253 called when cleanups are not in place. */
2256 vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2257 va_list args, int filter)
2260 struct cleanup *old_cleanups;
2262 linebuffer = xstrvprintf (format, args);
2263 old_cleanups = make_cleanup (xfree, linebuffer);
2264 fputs_maybe_filtered (linebuffer, stream, filter);
2265 do_cleanups (old_cleanups);
2270 vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2272 vfprintf_maybe_filtered (stream, format, args, 1);
2276 vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2279 struct cleanup *old_cleanups;
2281 linebuffer = xstrvprintf (format, args);
2282 old_cleanups = make_cleanup (xfree, linebuffer);
2283 if (debug_timestamp && stream == gdb_stdlog)
2285 using namespace std::chrono;
2288 steady_clock::time_point now = steady_clock::now ();
2289 seconds s = duration_cast<seconds> (now.time_since_epoch ());
2290 microseconds us = duration_cast<microseconds> (now.time_since_epoch () - s);
2292 len = strlen (linebuffer);
2293 need_nl = (len > 0 && linebuffer[len - 1] != '\n');
2295 std::string timestamp = string_printf ("%ld.%06ld %s%s",
2298 linebuffer, need_nl ? "\n": "");
2299 fputs_unfiltered (timestamp.c_str (), stream);
2302 fputs_unfiltered (linebuffer, stream);
2303 do_cleanups (old_cleanups);
2307 vprintf_filtered (const char *format, va_list args)
2309 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2313 vprintf_unfiltered (const char *format, va_list args)
2315 vfprintf_unfiltered (gdb_stdout, format, args);
2319 fprintf_filtered (struct ui_file *stream, const char *format, ...)
2323 va_start (args, format);
2324 vfprintf_filtered (stream, format, args);
2329 fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2333 va_start (args, format);
2334 vfprintf_unfiltered (stream, format, args);
2338 /* Like fprintf_filtered, but prints its result indented.
2339 Called as fprintfi_filtered (spaces, stream, format, ...); */
2342 fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2347 va_start (args, format);
2348 print_spaces_filtered (spaces, stream);
2350 vfprintf_filtered (stream, format, args);
2356 printf_filtered (const char *format, ...)
2360 va_start (args, format);
2361 vfprintf_filtered (gdb_stdout, format, args);
2367 printf_unfiltered (const char *format, ...)
2371 va_start (args, format);
2372 vfprintf_unfiltered (gdb_stdout, format, args);
2376 /* Like printf_filtered, but prints it's result indented.
2377 Called as printfi_filtered (spaces, format, ...); */
2380 printfi_filtered (int spaces, const char *format, ...)
2384 va_start (args, format);
2385 print_spaces_filtered (spaces, gdb_stdout);
2386 vfprintf_filtered (gdb_stdout, format, args);
2390 /* Easy -- but watch out!
2392 This routine is *not* a replacement for puts()! puts() appends a newline.
2393 This one doesn't, and had better not! */
2396 puts_filtered (const char *string)
2398 fputs_filtered (string, gdb_stdout);
2402 puts_unfiltered (const char *string)
2404 fputs_unfiltered (string, gdb_stdout);
2407 /* Return a pointer to N spaces and a null. The pointer is good
2408 until the next call to here. */
2413 static char *spaces = 0;
2414 static int max_spaces = -1;
2420 spaces = (char *) xmalloc (n + 1);
2421 for (t = spaces + n; t != spaces;)
2427 return spaces + max_spaces - n;
2430 /* Print N spaces. */
2432 print_spaces_filtered (int n, struct ui_file *stream)
2434 fputs_filtered (n_spaces (n), stream);
2437 /* C++/ObjC demangler stuff. */
2439 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2440 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2441 If the name is not mangled, or the language for the name is unknown, or
2442 demangling is off, the name is printed in its "raw" form. */
2445 fprintf_symbol_filtered (struct ui_file *stream, const char *name,
2446 enum language lang, int arg_mode)
2452 /* If user wants to see raw output, no problem. */
2455 fputs_filtered (name, stream);
2459 demangled = language_demangle (language_def (lang), name, arg_mode);
2460 fputs_filtered (demangled ? demangled : name, stream);
2461 if (demangled != NULL)
2469 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2470 differences in whitespace. Returns 0 if they match, non-zero if they
2471 don't (slightly different than strcmp()'s range of return values).
2473 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2474 This "feature" is useful when searching for matching C++ function names
2475 (such as if the user types 'break FOO', where FOO is a mangled C++
2479 strcmp_iw (const char *string1, const char *string2)
2481 while ((*string1 != '\0') && (*string2 != '\0'))
2483 while (isspace (*string1))
2487 while (isspace (*string2))
2491 if (case_sensitivity == case_sensitive_on && *string1 != *string2)
2493 if (case_sensitivity == case_sensitive_off
2494 && (tolower ((unsigned char) *string1)
2495 != tolower ((unsigned char) *string2)))
2497 if (*string1 != '\0')
2503 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2506 /* This is like strcmp except that it ignores whitespace and treats
2507 '(' as the first non-NULL character in terms of ordering. Like
2508 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2509 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2510 according to that ordering.
2512 If a list is sorted according to this function and if you want to
2513 find names in the list that match some fixed NAME according to
2514 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2515 where this function would put NAME.
2517 This function must be neutral to the CASE_SENSITIVITY setting as the user
2518 may choose it during later lookup. Therefore this function always sorts
2519 primarily case-insensitively and secondarily case-sensitively.
2521 Here are some examples of why using strcmp to sort is a bad idea:
2525 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2526 we try to do a search for "foo<char*>", strcmp will locate this
2527 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2528 will start looking at strings beginning with "goo", and will never
2529 see the correct match of "foo<char *>".
2531 Parenthesis example:
2533 In practice, this is less like to be an issue, but I'll give it a
2534 shot. Let's assume that '$' is a legitimate character to occur in
2535 symbols. (Which may well even be the case on some systems.) Then
2536 say that the partial symbol table contains "foo$" and "foo(int)".
2537 strcmp will put them in this order, since '$' < '('. Now, if the
2538 user searches for "foo", then strcmp will sort "foo" before "foo$".
2539 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2540 "foo") is false, so it won't proceed to the actual match of
2541 "foo(int)" with "foo". */
2544 strcmp_iw_ordered (const char *string1, const char *string2)
2546 const char *saved_string1 = string1, *saved_string2 = string2;
2547 enum case_sensitivity case_pass = case_sensitive_off;
2551 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2552 Provide stub characters if we are already at the end of one of the
2554 char c1 = 'X', c2 = 'X';
2556 while (*string1 != '\0' && *string2 != '\0')
2558 while (isspace (*string1))
2560 while (isspace (*string2))
2565 case case_sensitive_off:
2566 c1 = tolower ((unsigned char) *string1);
2567 c2 = tolower ((unsigned char) *string2);
2569 case case_sensitive_on:
2577 if (*string1 != '\0')
2586 /* Characters are non-equal unless they're both '\0'; we want to
2587 make sure we get the comparison right according to our
2588 comparison in the cases where one of them is '\0' or '('. */
2590 if (*string2 == '\0')
2595 if (*string2 == '\0')
2600 if (*string2 == '\0' || *string2 == '(')
2609 if (case_pass == case_sensitive_on)
2612 /* Otherwise the strings were equal in case insensitive way, make
2613 a more fine grained comparison in a case sensitive way. */
2615 case_pass = case_sensitive_on;
2616 string1 = saved_string1;
2617 string2 = saved_string2;
2621 /* A simple comparison function with opposite semantics to strcmp. */
2624 streq (const char *lhs, const char *rhs)
2626 return !strcmp (lhs, rhs);
2632 ** Answer whether string_to_compare is a full or partial match to
2633 ** template_string. The partial match must be in sequence starting
2637 subset_compare (char *string_to_compare, char *template_string)
2641 if (template_string != (char *) NULL && string_to_compare != (char *) NULL
2642 && strlen (string_to_compare) <= strlen (template_string))
2644 (startswith (template_string, string_to_compare));
2651 show_debug_timestamp (struct ui_file *file, int from_tty,
2652 struct cmd_list_element *c, const char *value)
2654 fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"),
2660 initialize_utils (void)
2662 add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
2663 Set number of characters where GDB should wrap lines of its output."), _("\
2664 Show number of characters where GDB should wrap lines of its output."), _("\
2665 This affects where GDB wraps its output to fit the screen width.\n\
2666 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2668 show_chars_per_line,
2669 &setlist, &showlist);
2671 add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
2672 Set number of lines in a page for GDB output pagination."), _("\
2673 Show number of lines in a page for GDB output pagination."), _("\
2674 This affects the number of lines after which GDB will pause\n\
2675 its output and ask you whether to continue.\n\
2676 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2678 show_lines_per_page,
2679 &setlist, &showlist);
2681 add_setshow_boolean_cmd ("pagination", class_support,
2682 &pagination_enabled, _("\
2683 Set state of GDB output pagination."), _("\
2684 Show state of GDB output pagination."), _("\
2685 When pagination is ON, GDB pauses at end of each screenful of\n\
2686 its output and asks you whether to continue.\n\
2687 Turning pagination off is an alternative to \"set height unlimited\"."),
2689 show_pagination_enabled,
2690 &setlist, &showlist);
2692 add_setshow_boolean_cmd ("sevenbit-strings", class_support,
2693 &sevenbit_strings, _("\
2694 Set printing of 8-bit characters in strings as \\nnn."), _("\
2695 Show printing of 8-bit characters in strings as \\nnn."), NULL,
2697 show_sevenbit_strings,
2698 &setprintlist, &showprintlist);
2700 add_setshow_boolean_cmd ("timestamp", class_maintenance,
2701 &debug_timestamp, _("\
2702 Set timestamping of debugging messages."), _("\
2703 Show timestamping of debugging messages."), _("\
2704 When set, debugging messages will be marked with seconds and microseconds."),
2706 show_debug_timestamp,
2707 &setdebuglist, &showdebuglist);
2711 paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
2713 /* Truncate address to the size of a target address, avoiding shifts
2714 larger or equal than the width of a CORE_ADDR. The local
2715 variable ADDR_BIT stops the compiler reporting a shift overflow
2716 when it won't occur. */
2717 /* NOTE: This assumes that the significant address information is
2718 kept in the least significant bits of ADDR - the upper bits were
2719 either zero or sign extended. Should gdbarch_address_to_pointer or
2720 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2722 int addr_bit = gdbarch_addr_bit (gdbarch);
2724 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2725 addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
2726 return hex_string (addr);
2729 /* This function is described in "defs.h". */
2732 print_core_address (struct gdbarch *gdbarch, CORE_ADDR address)
2734 int addr_bit = gdbarch_addr_bit (gdbarch);
2736 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2737 address &= ((CORE_ADDR) 1 << addr_bit) - 1;
2739 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2740 that returns the language localized string formatted to a width
2741 based on gdbarch_addr_bit. */
2743 return hex_string_custom (address, 8);
2745 return hex_string_custom (address, 16);
2748 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2751 core_addr_hash (const void *ap)
2753 const CORE_ADDR *addrp = (const CORE_ADDR *) ap;
2758 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2761 core_addr_eq (const void *ap, const void *bp)
2763 const CORE_ADDR *addr_ap = (const CORE_ADDR *) ap;
2764 const CORE_ADDR *addr_bp = (const CORE_ADDR *) bp;
2766 return *addr_ap == *addr_bp;
2769 /* Convert a string back into a CORE_ADDR. */
2771 string_to_core_addr (const char *my_string)
2775 if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
2777 /* Assume that it is in hex. */
2780 for (i = 2; my_string[i] != '\0'; i++)
2782 if (isdigit (my_string[i]))
2783 addr = (my_string[i] - '0') + (addr * 16);
2784 else if (isxdigit (my_string[i]))
2785 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
2787 error (_("invalid hex \"%s\""), my_string);
2792 /* Assume that it is in decimal. */
2795 for (i = 0; my_string[i] != '\0'; i++)
2797 if (isdigit (my_string[i]))
2798 addr = (my_string[i] - '0') + (addr * 10);
2800 error (_("invalid decimal \"%s\""), my_string);
2808 gdb_realpath (const char *filename)
2810 /* On most hosts, we rely on canonicalize_file_name to compute
2811 the FILENAME's realpath.
2813 But the situation is slightly more complex on Windows, due to some
2814 versions of GCC which were reported to generate paths where
2815 backlashes (the directory separator) were doubled. For instance:
2816 c:\\some\\double\\slashes\\dir
2818 c:\some\double\slashes\dir
2819 Those double-slashes were getting in the way when comparing paths,
2820 for instance when trying to insert a breakpoint as follow:
2821 (gdb) b c:/some/double/slashes/dir/foo.c:4
2822 No source file named c:/some/double/slashes/dir/foo.c:4.
2823 (gdb) b c:\some\double\slashes\dir\foo.c:4
2824 No source file named c:\some\double\slashes\dir\foo.c:4.
2825 To prevent this from happening, we need this function to always
2826 strip those extra backslashes. While canonicalize_file_name does
2827 perform this simplification, it only works when the path is valid.
2828 Since the simplification would be useful even if the path is not
2829 valid (one can always set a breakpoint on a file, even if the file
2830 does not exist locally), we rely instead on GetFullPathName to
2831 perform the canonicalization. */
2833 #if defined (_WIN32)
2836 DWORD len = GetFullPathName (filename, MAX_PATH, buf, NULL);
2838 /* The file system is case-insensitive but case-preserving.
2839 So it is important we do not lowercase the path. Otherwise,
2840 we might not be able to display the original casing in a given
2842 if (len > 0 && len < MAX_PATH)
2843 return xstrdup (buf);
2847 char *rp = canonicalize_file_name (filename);
2854 /* This system is a lost cause, just dup the buffer. */
2855 return xstrdup (filename);
2858 /* Return a copy of FILENAME, with its directory prefix canonicalized
2862 gdb_realpath_keepfile (const char *filename)
2864 const char *base_name = lbasename (filename);
2869 /* Extract the basename of filename, and return immediately
2870 a copy of filename if it does not contain any directory prefix. */
2871 if (base_name == filename)
2872 return xstrdup (filename);
2874 dir_name = (char *) alloca ((size_t) (base_name - filename + 2));
2875 /* Allocate enough space to store the dir_name + plus one extra
2876 character sometimes needed under Windows (see below), and
2877 then the closing \000 character. */
2878 strncpy (dir_name, filename, base_name - filename);
2879 dir_name[base_name - filename] = '\000';
2881 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2882 /* We need to be careful when filename is of the form 'd:foo', which
2883 is equivalent of d:./foo, which is totally different from d:/foo. */
2884 if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
2887 dir_name[3] = '\000';
2891 /* Canonicalize the directory prefix, and build the resulting
2892 filename. If the dirname realpath already contains an ending
2893 directory separator, avoid doubling it. */
2894 real_path = gdb_realpath (dir_name);
2895 if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
2896 result = concat (real_path, base_name, (char *) NULL);
2898 result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
2904 /* Return PATH in absolute form, performing tilde-expansion if necessary.
2905 PATH cannot be NULL or the empty string.
2906 This does not resolve symlinks however, use gdb_realpath for that.
2907 Space for the result is allocated with malloc.
2908 If the path is already absolute, it is strdup'd.
2909 If there is a problem computing the absolute path, the path is returned
2910 unchanged (still strdup'd). */
2913 gdb_abspath (const char *path)
2915 gdb_assert (path != NULL && path[0] != '\0');
2918 return tilde_expand (path);
2920 if (IS_ABSOLUTE_PATH (path))
2921 return xstrdup (path);
2923 /* Beware the // my son, the Emacs barfs, the botch that catch... */
2924 return concat (current_directory,
2925 IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
2926 ? "" : SLASH_STRING,
2927 path, (char *) NULL);
2931 align_up (ULONGEST v, int n)
2933 /* Check that N is really a power of two. */
2934 gdb_assert (n && (n & (n-1)) == 0);
2935 return (v + n - 1) & -n;
2939 align_down (ULONGEST v, int n)
2941 /* Check that N is really a power of two. */
2942 gdb_assert (n && (n & (n-1)) == 0);
2946 /* Allocation function for the libiberty hash table which uses an
2947 obstack. The obstack is passed as DATA. */
2950 hashtab_obstack_allocate (void *data, size_t size, size_t count)
2952 size_t total = size * count;
2953 void *ptr = obstack_alloc ((struct obstack *) data, total);
2955 memset (ptr, 0, total);
2959 /* Trivial deallocation function for the libiberty splay tree and hash
2960 table - don't deallocate anything. Rely on later deletion of the
2961 obstack. DATA will be the obstack, although it is not needed
2965 dummy_obstack_deallocate (void *object, void *data)
2970 /* Simple, portable version of dirname that does not modify its
2974 ldirname (const char *filename)
2976 const char *base = lbasename (filename);
2979 while (base > filename && IS_DIR_SEPARATOR (base[-1]))
2982 if (base == filename)
2985 dirname = (char *) xmalloc (base - filename + 2);
2986 memcpy (dirname, filename, base - filename);
2988 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
2989 create "d:./bar" later instead of the (different) "d:/bar". */
2990 if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
2991 && !IS_DIR_SEPARATOR (filename[0]))
2992 dirname[base++ - filename] = '.';
2994 dirname[base - filename] = '\0';
2998 /* Call libiberty's buildargv, and return the result.
2999 If buildargv fails due to out-of-memory, call nomem.
3000 Therefore, the returned value is guaranteed to be non-NULL,
3001 unless the parameter itself is NULL. */
3004 gdb_buildargv (const char *s)
3006 char **argv = buildargv (s);
3008 if (s != NULL && argv == NULL)
3014 compare_positive_ints (const void *ap, const void *bp)
3016 /* Because we know we're comparing two ints which are positive,
3017 there's no danger of overflow here. */
3018 return * (int *) ap - * (int *) bp;
3021 /* String compare function for qsort. */
3024 compare_strings (const void *arg1, const void *arg2)
3026 const char **s1 = (const char **) arg1;
3027 const char **s2 = (const char **) arg2;
3029 return strcmp (*s1, *s2);
3032 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3033 #define AMBIGUOUS_MESS2 \
3034 ".\nUse \"set gnutarget format-name\" to specify the format."
3037 gdb_bfd_errmsg (bfd_error_type error_tag, char **matching)
3043 /* Check if errmsg just need simple return. */
3044 if (error_tag != bfd_error_file_ambiguously_recognized || matching == NULL)
3045 return bfd_errmsg (error_tag);
3047 ret_len = strlen (bfd_errmsg (error_tag)) + strlen (AMBIGUOUS_MESS1)
3048 + strlen (AMBIGUOUS_MESS2);
3049 for (p = matching; *p; p++)
3050 ret_len += strlen (*p) + 1;
3051 ret = (char *) xmalloc (ret_len + 1);
3053 make_cleanup (xfree, ret);
3055 strcpy (retp, bfd_errmsg (error_tag));
3056 retp += strlen (retp);
3058 strcpy (retp, AMBIGUOUS_MESS1);
3059 retp += strlen (retp);
3061 for (p = matching; *p; p++)
3063 sprintf (retp, " %s", *p);
3064 retp += strlen (retp);
3068 strcpy (retp, AMBIGUOUS_MESS2);
3073 /* Return ARGS parsed as a valid pid, or throw an error. */
3076 parse_pid_to_attach (const char *args)
3082 error_no_arg (_("process-id to attach"));
3084 dummy = (char *) args;
3085 pid = strtoul (args, &dummy, 0);
3086 /* Some targets don't set errno on errors, grrr! */
3087 if ((pid == 0 && dummy == args) || dummy != &args[strlen (args)])
3088 error (_("Illegal process-id: %s."), args);
3093 /* Helper for make_bpstat_clear_actions_cleanup. */
3096 do_bpstat_clear_actions_cleanup (void *unused)
3098 bpstat_clear_actions ();
3101 /* Call bpstat_clear_actions for the case an exception is throw. You should
3102 discard_cleanups if no exception is caught. */
3105 make_bpstat_clear_actions_cleanup (void)
3107 return make_cleanup (do_bpstat_clear_actions_cleanup, NULL);
3110 /* Check for GCC >= 4.x according to the symtab->producer string. Return minor
3111 version (x) of 4.x in such case. If it is not GCC or it is GCC older than
3112 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
3115 producer_is_gcc_ge_4 (const char *producer)
3119 if (! producer_is_gcc (producer, &major, &minor))
3128 /* Returns nonzero if the given PRODUCER string is GCC and sets the MAJOR
3129 and MINOR versions when not NULL. Returns zero if the given PRODUCER
3130 is NULL or it isn't GCC. */
3133 producer_is_gcc (const char *producer, int *major, int *minor)
3137 if (producer != NULL && startswith (producer, "GNU "))
3146 /* Skip any identifier after "GNU " - such as "C11" or "C++".
3147 A full producer string might look like:
3149 "GNU Fortran 4.8.2 20140120 (Red Hat 4.8.2-16) -mtune=generic ..."
3150 "GNU C++14 5.0.0 20150123 (experimental)"
3152 cs = &producer[strlen ("GNU ")];
3153 while (*cs && !isspace (*cs))
3155 if (*cs && isspace (*cs))
3157 if (sscanf (cs, "%d.%d", major, minor) == 2)
3161 /* Not recognized as GCC. */
3165 /* Helper for make_cleanup_free_char_ptr_vec. */
3168 do_free_char_ptr_vec (void *arg)
3170 VEC (char_ptr) *char_ptr_vec = (VEC (char_ptr) *) arg;
3172 free_char_ptr_vec (char_ptr_vec);
3175 /* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
3176 final VEC_free for CHAR_PTR_VEC itself.
3178 You must not modify CHAR_PTR_VEC after this cleanup registration as the
3179 CHAR_PTR_VEC base address may change on its updates. Contrary to VEC_free
3180 this function does not (cannot) clear the pointer. */
3183 make_cleanup_free_char_ptr_vec (VEC (char_ptr) *char_ptr_vec)
3185 return make_cleanup (do_free_char_ptr_vec, char_ptr_vec);
3188 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3189 must come from xrealloc-compatible allocator and it may be updated. FROM
3190 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3191 located at the start or end of *STRINGP. */
3194 substitute_path_component (char **stringp, const char *from, const char *to)
3196 char *string = *stringp, *s;
3197 const size_t from_len = strlen (from);
3198 const size_t to_len = strlen (to);
3202 s = strstr (s, from);
3206 if ((s == string || IS_DIR_SEPARATOR (s[-1])
3207 || s[-1] == DIRNAME_SEPARATOR)
3208 && (s[from_len] == '\0' || IS_DIR_SEPARATOR (s[from_len])
3209 || s[from_len] == DIRNAME_SEPARATOR))
3214 = (char *) xrealloc (string, (strlen (string) + to_len + 1));
3216 /* Relocate the current S pointer. */
3217 s = s - string + string_new;
3218 string = string_new;
3220 /* Replace from by to. */
3221 memmove (&s[to_len], &s[from_len], strlen (&s[from_len]) + 1);
3222 memcpy (s, to, to_len);
3237 /* SIGALRM handler for waitpid_with_timeout. */
3240 sigalrm_handler (int signo)
3242 /* Nothing to do. */
3247 /* Wrapper to wait for child PID to die with TIMEOUT.
3248 TIMEOUT is the time to stop waiting in seconds.
3249 If TIMEOUT is zero, pass WNOHANG to waitpid.
3250 Returns PID if it was successfully waited for, otherwise -1.
3252 Timeouts are currently implemented with alarm and SIGALRM.
3253 If the host does not support them, this waits "forever".
3254 It would be odd though for a host to have waitpid and not SIGALRM. */
3257 wait_to_die_with_timeout (pid_t pid, int *status, int timeout)
3259 pid_t waitpid_result;
3261 gdb_assert (pid > 0);
3262 gdb_assert (timeout >= 0);
3267 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3268 struct sigaction sa, old_sa;
3270 sa.sa_handler = sigalrm_handler;
3271 sigemptyset (&sa.sa_mask);
3273 sigaction (SIGALRM, &sa, &old_sa);
3277 ofunc = signal (SIGALRM, sigalrm_handler);
3283 waitpid_result = waitpid (pid, status, 0);
3287 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3288 sigaction (SIGALRM, &old_sa, NULL);
3290 signal (SIGALRM, ofunc);
3295 waitpid_result = waitpid (pid, status, WNOHANG);
3297 if (waitpid_result == pid)
3303 #endif /* HAVE_WAITPID */
3305 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3306 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3308 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3309 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3312 gdb_filename_fnmatch (const char *pattern, const char *string, int flags)
3314 gdb_assert ((flags & FNM_FILE_NAME) != 0);
3316 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3317 gdb_assert ((flags & FNM_NOESCAPE) != 0);
3319 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3321 char *pattern_slash, *string_slash;
3323 /* Replace '\' by '/' in both strings. */
3325 pattern_slash = (char *) alloca (strlen (pattern) + 1);
3326 strcpy (pattern_slash, pattern);
3327 pattern = pattern_slash;
3328 for (; *pattern_slash != 0; pattern_slash++)
3329 if (IS_DIR_SEPARATOR (*pattern_slash))
3330 *pattern_slash = '/';
3332 string_slash = (char *) alloca (strlen (string) + 1);
3333 strcpy (string_slash, string);
3334 string = string_slash;
3335 for (; *string_slash != 0; string_slash++)
3336 if (IS_DIR_SEPARATOR (*string_slash))
3337 *string_slash = '/';
3339 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3341 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3342 flags |= FNM_CASEFOLD;
3343 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3345 return fnmatch (pattern, string, flags);
3348 /* Return the number of path elements in PATH.
3356 count_path_elements (const char *path)
3359 const char *p = path;
3361 if (HAS_DRIVE_SPEC (p))
3363 p = STRIP_DRIVE_SPEC (p);
3369 if (IS_DIR_SEPARATOR (*p))
3374 /* Backup one if last character is /, unless it's the only one. */
3375 if (p > path + 1 && IS_DIR_SEPARATOR (p[-1]))
3378 /* Add one for the file name, if present. */
3379 if (p > path && !IS_DIR_SEPARATOR (p[-1]))
3385 /* Remove N leading path elements from PATH.
3386 N must be non-negative.
3387 If PATH has more than N path elements then return NULL.
3388 If PATH has exactly N path elements then return "".
3389 See count_path_elements for a description of how we do the counting. */
3392 strip_leading_path_elements (const char *path, int n)
3395 const char *p = path;
3397 gdb_assert (n >= 0);
3402 if (HAS_DRIVE_SPEC (p))
3404 p = STRIP_DRIVE_SPEC (p);
3410 while (*p != '\0' && !IS_DIR_SEPARATOR (*p))
3425 /* Provide a prototype to silence -Wmissing-prototypes. */
3426 extern initialize_file_ftype _initialize_utils;
3429 _initialize_utils (void)
3431 add_internal_problem_command (&internal_error_problem);
3432 add_internal_problem_command (&internal_warning_problem);
3433 add_internal_problem_command (&demangler_warning_problem);