1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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"
68 #include "job-control.h"
69 #include "common/selftest.h"
70 #include "common/gdb_optional.h"
71 #include "cp-support.h"
73 #include "common/pathstuff.h"
76 extern PTR
malloc (); /* ARI: PTR */
78 #if !HAVE_DECL_REALLOC
79 extern PTR
realloc (); /* ARI: PTR */
85 void (*deprecated_error_begin_hook
) (void);
87 /* Prototypes for local functions */
89 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
90 va_list, int) ATTRIBUTE_PRINTF (2, 0);
92 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
94 static void prompt_for_continue (void);
96 static void set_screen_size (void);
97 static void set_width (void);
99 /* Time spent in prompt_for_continue in the currently executing command
100 waiting for user to respond.
101 Initialized in make_command_stats_cleanup.
102 Modified in prompt_for_continue and defaulted_query.
103 Used in report_command_stats. */
105 static std::chrono::steady_clock::duration prompt_for_continue_wait_time
;
107 /* A flag indicating whether to timestamp debugging messages. */
109 static int debug_timestamp
= 0;
111 /* Nonzero means that strings with character values >0x7F should be printed
112 as octal escapes. Zero means just print the value (e.g. it's an
113 international character, and the terminal or window can cope.) */
115 int sevenbit_strings
= 0;
117 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
118 struct cmd_list_element
*c
, const char *value
)
120 fprintf_filtered (file
, _("Printing of 8-bit characters "
121 "in strings as \\nnn is %s.\n"),
125 /* String to be printed before warning messages, if any. */
127 const char *warning_pre_print
= "\nwarning: ";
129 int pagination_enabled
= 1;
131 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
132 struct cmd_list_element
*c
, const char *value
)
134 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
138 /* Cleanup utilities.
140 These are not defined in cleanups.c (nor declared in cleanups.h)
141 because while they use the "cleanup API" they are not part of the
144 /* Helper for make_cleanup_value_free_to_mark. */
147 do_value_free_to_mark (void *value
)
149 value_free_to_mark ((struct value
*) value
);
152 /* Free all values allocated since MARK was obtained by value_mark
153 (except for those released) when the cleanup is run. */
156 make_cleanup_value_free_to_mark (struct value
*mark
)
158 return make_cleanup (do_value_free_to_mark
, mark
);
161 /* This function is useful for cleanups.
165 old_chain = make_cleanup (free_current_contents, &foo);
167 to arrange to free the object thus allocated. */
170 free_current_contents (void *ptr
)
172 void **location
= (void **) ptr
;
174 if (location
== NULL
)
175 internal_error (__FILE__
, __LINE__
,
176 _("free_current_contents: NULL pointer"));
177 if (*location
!= NULL
)
186 /* Print a warning message. The first argument STRING is the warning
187 message, used as an fprintf format string, the second is the
188 va_list of arguments for that string. A warning is unfiltered (not
189 paginated) so that the user does not need to page through each
190 screen full of warnings when there are lots of them. */
193 vwarning (const char *string
, va_list args
)
195 if (deprecated_warning_hook
)
196 (*deprecated_warning_hook
) (string
, args
);
199 gdb::optional
<target_terminal::scoped_restore_terminal_state
> term_state
;
200 if (target_supports_terminal_ours ())
202 term_state
.emplace ();
203 target_terminal::ours_for_output ();
205 if (filtered_printing_initialized ())
206 wrap_here (""); /* Force out any buffered output. */
207 gdb_flush (gdb_stdout
);
208 if (warning_pre_print
)
209 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
210 vfprintf_unfiltered (gdb_stderr
, string
, args
);
211 fprintf_unfiltered (gdb_stderr
, "\n");
215 /* Print an error message and return to command level.
216 The first argument STRING is the error message, used as a fprintf string,
217 and the remaining args are passed as arguments to it. */
220 verror (const char *string
, va_list args
)
222 throw_verror (GENERIC_ERROR
, string
, args
);
226 error_stream (const string_file
&stream
)
228 error (("%s"), stream
.c_str ());
231 /* Emit a message and abort. */
233 static void ATTRIBUTE_NORETURN
234 abort_with_message (const char *msg
)
236 if (current_ui
== NULL
)
239 fputs_unfiltered (msg
, gdb_stderr
);
241 abort (); /* NOTE: GDB has only three calls to abort(). */
244 /* Dump core trying to increase the core soft limit to hard limit first. */
249 #ifdef HAVE_SETRLIMIT
250 struct rlimit rlim
= { RLIM_INFINITY
, RLIM_INFINITY
};
252 setrlimit (RLIMIT_CORE
, &rlim
);
253 #endif /* HAVE_SETRLIMIT */
255 abort (); /* NOTE: GDB has only three calls to abort(). */
258 /* Check whether GDB will be able to dump core using the dump_core
259 function. Returns zero if GDB cannot or should not dump core.
260 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
261 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
264 can_dump_core (enum resource_limit_kind limit_kind
)
266 #ifdef HAVE_GETRLIMIT
269 /* Be quiet and assume we can dump if an error is returned. */
270 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
276 if (rlim
.rlim_cur
== 0)
280 if (rlim
.rlim_max
== 0)
283 #endif /* HAVE_GETRLIMIT */
288 /* Print a warning that we cannot dump core. */
291 warn_cant_dump_core (const char *reason
)
293 fprintf_unfiltered (gdb_stderr
,
294 _("%s\nUnable to dump core, use `ulimit -c"
295 " unlimited' before executing GDB next time.\n"),
299 /* Check whether GDB will be able to dump core using the dump_core
300 function, and print a warning if we cannot. */
303 can_dump_core_warn (enum resource_limit_kind limit_kind
,
306 int core_dump_allowed
= can_dump_core (limit_kind
);
308 if (!core_dump_allowed
)
309 warn_cant_dump_core (reason
);
311 return core_dump_allowed
;
314 /* Allow the user to configure the debugger behavior with respect to
315 what to do when an internal problem is detected. */
317 const char internal_problem_ask
[] = "ask";
318 const char internal_problem_yes
[] = "yes";
319 const char internal_problem_no
[] = "no";
320 static const char *const internal_problem_modes
[] =
322 internal_problem_ask
,
323 internal_problem_yes
,
328 /* Print a message reporting an internal error/warning. Ask the user
329 if they want to continue, dump core, or just exit. Return
330 something to indicate a quit. */
332 struct internal_problem
335 int user_settable_should_quit
;
336 const char *should_quit
;
337 int user_settable_should_dump_core
;
338 const char *should_dump_core
;
341 /* Report a problem, internal to GDB, to the user. Once the problem
342 has been reported, and assuming GDB didn't quit, the caller can
343 either allow execution to resume or throw an error. */
345 static void ATTRIBUTE_PRINTF (4, 0)
346 internal_vproblem (struct internal_problem
*problem
,
347 const char *file
, int line
, const char *fmt
, va_list ap
)
354 /* Don't allow infinite error/warning recursion. */
356 static char msg
[] = "Recursive internal problem.\n";
365 abort_with_message (msg
);
368 /* Newer GLIBC versions put the warn_unused_result attribute
369 on write, but this is one of those rare cases where
370 ignoring the return value is correct. Casting to (void)
371 does not fix this problem. This is the solution suggested
372 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
373 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
374 abort (); /* NOTE: GDB has only three calls to abort(). */
379 /* Create a string containing the full error/warning message. Need
380 to call query with this full string, as otherwize the reason
381 (error/warning) and question become separated. Format using a
382 style similar to a compiler error message. Include extra detail
383 so that the user knows that they are living on the edge. */
385 std::string msg
= string_vprintf (fmt
, ap
);
386 reason
= string_printf ("%s:%d: %s: %s\n"
387 "A problem internal to GDB has been detected,\n"
388 "further debugging may prove unreliable.",
389 file
, line
, problem
->name
, msg
.c_str ());
392 /* Fall back to abort_with_message if gdb_stderr is not set up. */
393 if (current_ui
== NULL
)
395 fputs (reason
.c_str (), stderr
);
396 abort_with_message ("\n");
399 /* Try to get the message out and at the start of a new line. */
400 gdb::optional
<target_terminal::scoped_restore_terminal_state
> term_state
;
401 if (target_supports_terminal_ours ())
403 term_state
.emplace ();
404 target_terminal::ours_for_output ();
406 if (filtered_printing_initialized ())
409 /* Emit the message unless query will emit it below. */
410 if (problem
->should_quit
!= internal_problem_ask
412 || !filtered_printing_initialized ())
413 fprintf_unfiltered (gdb_stderr
, "%s\n", reason
.c_str ());
415 if (problem
->should_quit
== internal_problem_ask
)
417 /* Default (yes/batch case) is to quit GDB. When in batch mode
418 this lessens the likelihood of GDB going into an infinite
420 if (!confirm
|| !filtered_printing_initialized ())
423 quit_p
= query (_("%s\nQuit this debugging session? "),
426 else if (problem
->should_quit
== internal_problem_yes
)
428 else if (problem
->should_quit
== internal_problem_no
)
431 internal_error (__FILE__
, __LINE__
, _("bad switch"));
433 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr
);
434 if (REPORT_BUGS_TO
[0])
435 fprintf_unfiltered (gdb_stderr
, _(" For instructions, see:\n%s."),
437 fputs_unfiltered ("\n\n", gdb_stderr
);
439 if (problem
->should_dump_core
== internal_problem_ask
)
441 if (!can_dump_core_warn (LIMIT_MAX
, reason
.c_str ()))
443 else if (!filtered_printing_initialized ())
447 /* Default (yes/batch case) is to dump core. This leaves a GDB
448 `dropping' so that it is easier to see that something went
450 dump_core_p
= query (_("%s\nCreate a core file of GDB? "),
454 else if (problem
->should_dump_core
== internal_problem_yes
)
455 dump_core_p
= can_dump_core_warn (LIMIT_MAX
, reason
.c_str ());
456 else if (problem
->should_dump_core
== internal_problem_no
)
459 internal_error (__FILE__
, __LINE__
, _("bad switch"));
472 #ifdef HAVE_WORKING_FORK
482 static struct internal_problem internal_error_problem
= {
483 "internal-error", 1, internal_problem_ask
, 1, internal_problem_ask
487 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
489 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
490 throw_quit (_("Command aborted."));
493 static struct internal_problem internal_warning_problem
= {
494 "internal-warning", 1, internal_problem_ask
, 1, internal_problem_ask
498 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
500 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
503 static struct internal_problem demangler_warning_problem
= {
504 "demangler-warning", 1, internal_problem_ask
, 0, internal_problem_no
508 demangler_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
510 internal_vproblem (&demangler_warning_problem
, file
, line
, fmt
, ap
);
514 demangler_warning (const char *file
, int line
, const char *string
, ...)
518 va_start (ap
, string
);
519 demangler_vwarning (file
, line
, string
, ap
);
523 /* Dummy functions to keep add_prefix_cmd happy. */
526 set_internal_problem_cmd (const char *args
, int from_tty
)
531 show_internal_problem_cmd (const char *args
, int from_tty
)
535 /* When GDB reports an internal problem (error or warning) it gives
536 the user the opportunity to quit GDB and/or create a core file of
537 the current debug session. This function registers a few commands
538 that make it possible to specify that GDB should always or never
539 quit or create a core file, without asking. The commands look
542 maint set PROBLEM-NAME quit ask|yes|no
543 maint show PROBLEM-NAME quit
544 maint set PROBLEM-NAME corefile ask|yes|no
545 maint show PROBLEM-NAME corefile
547 Where PROBLEM-NAME is currently "internal-error" or
548 "internal-warning". */
551 add_internal_problem_command (struct internal_problem
*problem
)
553 struct cmd_list_element
**set_cmd_list
;
554 struct cmd_list_element
**show_cmd_list
;
558 set_cmd_list
= XNEW (struct cmd_list_element
*);
559 show_cmd_list
= XNEW (struct cmd_list_element
*);
560 *set_cmd_list
= NULL
;
561 *show_cmd_list
= NULL
;
563 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
566 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
569 add_prefix_cmd (problem
->name
,
570 class_maintenance
, set_internal_problem_cmd
, set_doc
,
572 concat ("maintenance set ", problem
->name
, " ",
574 0/*allow-unknown*/, &maintenance_set_cmdlist
);
576 add_prefix_cmd (problem
->name
,
577 class_maintenance
, show_internal_problem_cmd
, show_doc
,
579 concat ("maintenance show ", problem
->name
, " ",
581 0/*allow-unknown*/, &maintenance_show_cmdlist
);
583 if (problem
->user_settable_should_quit
)
585 set_doc
= xstrprintf (_("Set whether GDB should quit "
586 "when an %s is detected"),
588 show_doc
= xstrprintf (_("Show whether GDB will quit "
589 "when an %s is detected"),
591 add_setshow_enum_cmd ("quit", class_maintenance
,
592 internal_problem_modes
,
593 &problem
->should_quit
,
606 if (problem
->user_settable_should_dump_core
)
608 set_doc
= xstrprintf (_("Set whether GDB should create a core "
609 "file of GDB when %s is detected"),
611 show_doc
= xstrprintf (_("Show whether GDB will create a core "
612 "file of GDB when %s is detected"),
614 add_setshow_enum_cmd ("corefile", class_maintenance
,
615 internal_problem_modes
,
616 &problem
->should_dump_core
,
630 /* Return a newly allocated string, containing the PREFIX followed
631 by the system error message for errno (separated by a colon). */
634 perror_string (const char *prefix
)
638 err
= safe_strerror (errno
);
639 return std::string (prefix
) + ": " + err
;
642 /* Print the system error message for errno, and also mention STRING
643 as the file name for which the error was encountered. Use ERRCODE
644 for the thrown exception. Then return to command level. */
647 throw_perror_with_name (enum errors errcode
, const char *string
)
649 std::string combined
= perror_string (string
);
651 /* I understand setting these is a matter of taste. Still, some people
652 may clear errno but not know about bfd_error. Doing this here is not
654 bfd_set_error (bfd_error_no_error
);
657 throw_error (errcode
, _("%s."), combined
.c_str ());
660 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
663 perror_with_name (const char *string
)
665 throw_perror_with_name (GENERIC_ERROR
, string
);
668 /* Same as perror_with_name except that it prints a warning instead
669 of throwing an error. */
672 perror_warning_with_name (const char *string
)
674 std::string combined
= perror_string (string
);
675 warning (_("%s"), combined
.c_str ());
678 /* Print the system error message for ERRCODE, and also mention STRING
679 as the file name for which the error was encountered. */
682 print_sys_errmsg (const char *string
, int errcode
)
687 err
= safe_strerror (errcode
);
688 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
689 strcpy (combined
, string
);
690 strcat (combined
, ": ");
691 strcat (combined
, err
);
693 /* We want anything which was printed on stdout to come out first, before
695 gdb_flush (gdb_stdout
);
696 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
699 /* Control C eventually causes this to be called, at a convenient time. */
704 if (sync_quit_force_run
)
706 sync_quit_force_run
= 0;
707 quit_force (NULL
, 0);
711 /* No steenking SIGINT will ever be coming our way when the
712 program is resumed. Don't lie. */
716 /* If there is no terminal switching for this target, then we can't
717 possibly get screwed by the lack of job control. */
718 || !target_supports_terminal_ours ())
721 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
730 if (sync_quit_force_run
)
735 if (deprecated_interactive_hook
)
736 deprecated_interactive_hook ();
740 /* Called when a memory allocation fails, with the number of bytes of
741 memory requested in SIZE. */
744 malloc_failure (long size
)
748 internal_error (__FILE__
, __LINE__
,
749 _("virtual memory exhausted: can't allocate %ld bytes."),
754 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
758 /* My replacement for the read system call.
759 Used like `read' but keeps going if `read' returns too soon. */
762 myread (int desc
, char *addr
, int len
)
769 val
= read (desc
, addr
, len
);
781 print_spaces (int n
, struct ui_file
*file
)
783 fputs_unfiltered (n_spaces (n
), file
);
786 /* Print a host address. */
789 gdb_print_host_address_1 (const void *addr
, struct ui_file
*stream
)
791 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
797 make_hex_string (const gdb_byte
*data
, size_t length
)
799 char *result
= (char *) xmalloc (length
* 2 + 1);
804 for (i
= 0; i
< length
; ++i
)
805 p
+= xsnprintf (p
, 3, "%02x", data
[i
]);
812 /* An RAII class that sets up to handle input and then tears down
813 during destruction. */
815 class scoped_input_handler
819 scoped_input_handler ()
820 : m_quit_handler (&quit_handler
, default_quit_handler
),
823 target_terminal::ours ();
824 ui_register_input_event_handler (current_ui
);
825 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
829 ~scoped_input_handler ()
832 ui_unregister_input_event_handler (m_ui
);
835 DISABLE_COPY_AND_ASSIGN (scoped_input_handler
);
839 /* Save and restore the terminal state. */
840 target_terminal::scoped_restore_terminal_state m_term_state
;
842 /* Save and restore the quit handler. */
843 scoped_restore_tmpl
<quit_handler_ftype
*> m_quit_handler
;
845 /* The saved UI, if non-NULL. */
851 /* This function supports the query, nquery, and yquery functions.
852 Ask user a y-or-n question and return 0 if answer is no, 1 if
853 answer is yes, or default the answer to the specified default
854 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
855 default answer, or '\0' for no default.
856 CTLSTR is the control string and should end in "? ". It should
857 not say how to answer, because we do that.
858 ARGS are the arguments passed along with the CTLSTR argument to
861 static int ATTRIBUTE_PRINTF (1, 0)
862 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
866 char def_answer
, not_def_answer
;
867 const char *y_string
, *n_string
;
869 /* Set up according to which answer is the default. */
874 not_def_answer
= 'N';
878 else if (defchar
== 'y')
882 not_def_answer
= 'N';
890 not_def_answer
= 'Y';
895 /* Automatically answer the default value if the user did not want
896 prompts or the command was issued with the server prefix. */
897 if (!confirm
|| server_command
)
900 /* If input isn't coming from the user directly, just say what
901 question we're asking, and then answer the default automatically. This
902 way, important error messages don't get lost when talking to GDB
904 if (current_ui
->instream
!= current_ui
->stdin_stream
905 || !input_interactive_p (current_ui
)
906 /* Restrict queries to the main UI. */
907 || current_ui
!= main_ui
)
909 target_terminal::scoped_restore_terminal_state term_state
;
910 target_terminal::ours_for_output ();
912 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
914 printf_filtered (_("(%s or %s) [answered %c; "
915 "input not from terminal]\n"),
916 y_string
, n_string
, def_answer
);
917 gdb_flush (gdb_stdout
);
922 if (deprecated_query_hook
)
924 target_terminal::scoped_restore_terminal_state term_state
;
925 return deprecated_query_hook (ctlstr
, args
);
928 /* Format the question outside of the loop, to avoid reusing args. */
929 std::string question
= string_vprintf (ctlstr
, args
);
931 = string_printf (_("%s%s(%s or %s) %s"),
932 annotation_level
> 1 ? "\n\032\032pre-query\n" : "",
933 question
.c_str (), y_string
, n_string
,
934 annotation_level
> 1 ? "\n\032\032query\n" : "");
936 /* Used to add duration we waited for user to respond to
937 prompt_for_continue_wait_time. */
938 using namespace std::chrono
;
939 steady_clock::time_point prompt_started
= steady_clock::now ();
941 scoped_input_handler prepare_input
;
945 char *response
, answer
;
947 gdb_flush (gdb_stdout
);
948 response
= gdb_readline_wrapper (prompt
.c_str ());
950 if (response
== NULL
) /* C-d */
952 printf_filtered ("EOF [assumed %c]\n", def_answer
);
957 answer
= response
[0];
962 /* Check answer. For the non-default, the user must specify
963 the non-default explicitly. */
964 if (answer
== not_def_answer
)
969 /* Otherwise, if a default was specified, the user may either
970 specify the required input or have it default by entering
972 if (answer
== def_answer
973 || (defchar
!= '\0' && answer
== '\0'))
978 /* Invalid entries are not defaulted and require another selection. */
979 printf_filtered (_("Please answer %s or %s.\n"),
983 /* Add time spend in this routine to prompt_for_continue_wait_time. */
984 prompt_for_continue_wait_time
+= steady_clock::now () - prompt_started
;
986 if (annotation_level
> 1)
987 printf_filtered (("\n\032\032post-query\n"));
992 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
993 answer is yes, or 0 if answer is defaulted.
994 Takes three args which are given to printf to print the question.
995 The first, a control string, should end in "? ".
996 It should not say how to answer, because we do that. */
999 nquery (const char *ctlstr
, ...)
1004 va_start (args
, ctlstr
);
1005 ret
= defaulted_query (ctlstr
, 'n', args
);
1010 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1011 answer is yes, or 1 if answer is defaulted.
1012 Takes three args which are given to printf to print the question.
1013 The first, a control string, should end in "? ".
1014 It should not say how to answer, because we do that. */
1017 yquery (const char *ctlstr
, ...)
1022 va_start (args
, ctlstr
);
1023 ret
= defaulted_query (ctlstr
, 'y', args
);
1028 /* Ask user a y-or-n question and return 1 iff answer is yes.
1029 Takes three args which are given to printf to print the question.
1030 The first, a control string, should end in "? ".
1031 It should not say how to answer, because we do that. */
1034 query (const char *ctlstr
, ...)
1039 va_start (args
, ctlstr
);
1040 ret
= defaulted_query (ctlstr
, '\0', args
);
1045 /* A helper for parse_escape that converts a host character to a
1046 target character. C is the host character. If conversion is
1047 possible, then the target character is stored in *TARGET_C and the
1048 function returns 1. Otherwise, the function returns 0. */
1051 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1056 auto_obstack host_data
;
1058 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1059 (gdb_byte
*) &the_char
, 1, 1,
1060 &host_data
, translit_none
);
1062 if (obstack_object_size (&host_data
) == 1)
1065 *target_c
= *(char *) obstack_base (&host_data
);
1071 /* Parse a C escape sequence. STRING_PTR points to a variable
1072 containing a pointer to the string to parse. That pointer
1073 should point to the character after the \. That pointer
1074 is updated past the characters we use. The value of the
1075 escape sequence is returned.
1077 A negative value means the sequence \ newline was seen,
1078 which is supposed to be equivalent to nothing at all.
1080 If \ is followed by a null character, we return a negative
1081 value and leave the string pointer pointing at the null character.
1083 If \ is followed by 000, we return 0 and leave the string pointer
1084 after the zeros. A value of 0 does not mean end of string. */
1087 parse_escape (struct gdbarch
*gdbarch
, const char **string_ptr
)
1089 int target_char
= -2; /* Initialize to avoid GCC warnings. */
1090 int c
= *(*string_ptr
)++;
1109 int i
= host_hex_value (c
);
1114 if (isdigit (c
) && c
!= '8' && c
!= '9')
1118 i
+= host_hex_value (c
);
1154 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1155 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1156 " which has no equivalent\nin the `%s' character set."),
1157 c
, c
, target_charset (gdbarch
));
1161 /* Print the character C on STREAM as part of the contents of a literal
1162 string whose delimiter is QUOTER. Note that this routine should only
1163 be called for printing things which are independent of the language
1164 of the program being debugged.
1166 printchar will normally escape backslashes and instances of QUOTER. If
1167 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1168 As a side effect, if you pass the backslash character as the QUOTER,
1169 printchar will escape backslashes as usual, but not any other quoting
1173 printchar (int c
, do_fputc_ftype do_fputc
, ui_file
*stream
, int quoter
)
1175 c
&= 0xFF; /* Avoid sign bit follies */
1177 if (c
< 0x20 || /* Low control chars */
1178 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1179 (sevenbit_strings
&& c
>= 0x80))
1180 { /* high order bit set */
1181 do_fputc ('\\', stream
);
1186 do_fputc ('n', stream
);
1189 do_fputc ('b', stream
);
1192 do_fputc ('t', stream
);
1195 do_fputc ('f', stream
);
1198 do_fputc ('r', stream
);
1201 do_fputc ('e', stream
);
1204 do_fputc ('a', stream
);
1208 do_fputc ('0' + ((c
>> 6) & 0x7), stream
);
1209 do_fputc ('0' + ((c
>> 3) & 0x7), stream
);
1210 do_fputc ('0' + ((c
>> 0) & 0x7), stream
);
1217 if (quoter
!= 0 && (c
== '\\' || c
== quoter
))
1218 do_fputc ('\\', stream
);
1219 do_fputc (c
, stream
);
1223 /* Print the character C on STREAM as part of the contents of a
1224 literal string whose delimiter is QUOTER. Note that these routines
1225 should only be call for printing things which are independent of
1226 the language of the program being debugged. */
1229 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1232 printchar (*str
++, fputc_filtered
, stream
, quoter
);
1236 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1239 printchar (*str
++, fputc_unfiltered
, stream
, quoter
);
1243 fputstrn_filtered (const char *str
, int n
, int quoter
,
1244 struct ui_file
*stream
)
1246 for (int i
= 0; i
< n
; i
++)
1247 printchar (str
[i
], fputc_filtered
, stream
, quoter
);
1251 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1252 do_fputc_ftype do_fputc
, struct ui_file
*stream
)
1254 for (int i
= 0; i
< n
; i
++)
1255 printchar (str
[i
], do_fputc
, stream
, quoter
);
1259 /* Number of lines per page or UINT_MAX if paging is disabled. */
1260 static unsigned int lines_per_page
;
1262 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1263 struct cmd_list_element
*c
, const char *value
)
1265 fprintf_filtered (file
,
1266 _("Number of lines gdb thinks are in a page is %s.\n"),
1270 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1271 static unsigned int chars_per_line
;
1273 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1274 struct cmd_list_element
*c
, const char *value
)
1276 fprintf_filtered (file
,
1277 _("Number of characters gdb thinks "
1278 "are in a line is %s.\n"),
1282 /* Current count of lines printed on this page, chars on this line. */
1283 static unsigned int lines_printed
, chars_printed
;
1285 /* Buffer and start column of buffered text, for doing smarter word-
1286 wrapping. When someone calls wrap_here(), we start buffering output
1287 that comes through fputs_filtered(). If we see a newline, we just
1288 spit it out and forget about the wrap_here(). If we see another
1289 wrap_here(), we spit it out and remember the newer one. If we see
1290 the end of the line, we spit out a newline, the indent, and then
1291 the buffered output. */
1293 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1294 are waiting to be output (they have already been counted in chars_printed).
1295 When wrap_buffer[0] is null, the buffer is empty. */
1296 static char *wrap_buffer
;
1298 /* Pointer in wrap_buffer to the next character to fill. */
1299 static char *wrap_pointer
;
1301 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1303 static const char *wrap_indent
;
1305 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1306 is not in effect. */
1307 static int wrap_column
;
1310 /* Initialize the number of lines per page and chars per line. */
1313 init_page_info (void)
1317 lines_per_page
= UINT_MAX
;
1318 chars_per_line
= UINT_MAX
;
1322 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1327 #if defined(__GO32__)
1328 rows
= ScreenRows ();
1329 cols
= ScreenCols ();
1330 lines_per_page
= rows
;
1331 chars_per_line
= cols
;
1333 /* Make sure Readline has initialized its terminal settings. */
1334 rl_reset_terminal (NULL
);
1336 /* Get the screen size from Readline. */
1337 rl_get_screen_size (&rows
, &cols
);
1338 lines_per_page
= rows
;
1339 chars_per_line
= cols
;
1341 /* Readline should have fetched the termcap entry for us.
1342 Only try to use tgetnum function if rl_get_screen_size
1343 did not return a useful value. */
1344 if (((rows
<= 0) && (tgetnum ((char *) "li") < 0))
1345 /* Also disable paging if inside Emacs. $EMACS was used
1346 before Emacs v25.1, $INSIDE_EMACS is used since then. */
1347 || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1349 /* The number of lines per page is not mentioned in the terminal
1350 description or EMACS evironment variable is set. This probably
1351 means that paging is not useful, so disable paging. */
1352 lines_per_page
= UINT_MAX
;
1355 /* If the output is not a terminal, don't paginate it. */
1356 if (!ui_file_isatty (gdb_stdout
))
1357 lines_per_page
= UINT_MAX
;
1361 /* We handle SIGWINCH ourselves. */
1362 rl_catch_sigwinch
= 0;
1368 /* Return nonzero if filtered printing is initialized. */
1370 filtered_printing_initialized (void)
1372 return wrap_buffer
!= NULL
;
1375 set_batch_flag_and_restore_page_info::set_batch_flag_and_restore_page_info ()
1376 : m_save_lines_per_page (lines_per_page
),
1377 m_save_chars_per_line (chars_per_line
),
1378 m_save_batch_flag (batch_flag
)
1384 set_batch_flag_and_restore_page_info::~set_batch_flag_and_restore_page_info ()
1386 batch_flag
= m_save_batch_flag
;
1387 chars_per_line
= m_save_chars_per_line
;
1388 lines_per_page
= m_save_lines_per_page
;
1394 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1397 set_screen_size (void)
1399 int rows
= lines_per_page
;
1400 int cols
= chars_per_line
;
1408 /* Update Readline's idea of the terminal size. */
1409 rl_set_screen_size (rows
, cols
);
1412 /* Reinitialize WRAP_BUFFER according to the current value of
1418 if (chars_per_line
== 0)
1423 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1424 wrap_buffer
[0] = '\0';
1427 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1428 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1432 set_width_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1439 set_height_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1447 set_screen_width_and_height (int width
, int height
)
1449 lines_per_page
= height
;
1450 chars_per_line
= width
;
1456 /* Wait, so the user can read what's on the screen. Prompt the user
1457 to continue by pressing RETURN. 'q' is also provided because
1458 telling users what to do in the prompt is more user-friendly than
1459 expecting them to think of Ctrl-C/SIGINT. */
1462 prompt_for_continue (void)
1464 char cont_prompt
[120];
1465 /* Used to add duration we waited for user to respond to
1466 prompt_for_continue_wait_time. */
1467 using namespace std::chrono
;
1468 steady_clock::time_point prompt_started
= steady_clock::now ();
1470 if (annotation_level
> 1)
1471 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1473 strcpy (cont_prompt
,
1474 "---Type <return> to continue, or q <return> to quit---");
1475 if (annotation_level
> 1)
1476 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1478 /* We must do this *before* we call gdb_readline_wrapper, else it
1479 will eventually call us -- thinking that we're trying to print
1480 beyond the end of the screen. */
1481 reinitialize_more_filter ();
1483 scoped_input_handler prepare_input
;
1485 /* Call gdb_readline_wrapper, not readline, in order to keep an
1486 event loop running. */
1487 gdb::unique_xmalloc_ptr
<char> ignore (gdb_readline_wrapper (cont_prompt
));
1489 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1490 prompt_for_continue_wait_time
+= steady_clock::now () - prompt_started
;
1492 if (annotation_level
> 1)
1493 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1497 char *p
= ignore
.get ();
1499 while (*p
== ' ' || *p
== '\t')
1502 /* Do not call quit here; there is no possibility of SIGINT. */
1503 throw_quit ("Quit");
1506 /* Now we have to do this again, so that GDB will know that it doesn't
1507 need to save the ---Type <return>--- line at the top of the screen. */
1508 reinitialize_more_filter ();
1510 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1513 /* Initialize timer to keep track of how long we waited for the user. */
1516 reset_prompt_for_continue_wait_time (void)
1518 using namespace std::chrono
;
1520 prompt_for_continue_wait_time
= steady_clock::duration::zero ();
1523 /* Fetch the cumulative time spent in prompt_for_continue. */
1525 std::chrono::steady_clock::duration
1526 get_prompt_for_continue_wait_time ()
1528 return prompt_for_continue_wait_time
;
1531 /* Reinitialize filter; ie. tell it to reset to original values. */
1534 reinitialize_more_filter (void)
1540 /* Indicate that if the next sequence of characters overflows the line,
1541 a newline should be inserted here rather than when it hits the end.
1542 If INDENT is non-null, it is a string to be printed to indent the
1543 wrapped part on the next line. INDENT must remain accessible until
1544 the next call to wrap_here() or until a newline is printed through
1547 If the line is already overfull, we immediately print a newline and
1548 the indentation, and disable further wrapping.
1550 If we don't know the width of lines, but we know the page height,
1551 we must not wrap words, but should still keep track of newlines
1552 that were explicitly printed.
1554 INDENT should not contain tabs, as that will mess up the char count
1555 on the next line. FIXME.
1557 This routine is guaranteed to force out any output which has been
1558 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1559 used to force out output from the wrap_buffer. */
1562 wrap_here (const char *indent
)
1564 /* This should have been allocated, but be paranoid anyway. */
1566 internal_error (__FILE__
, __LINE__
,
1567 _("failed internal consistency check"));
1571 *wrap_pointer
= '\0';
1572 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1574 wrap_pointer
= wrap_buffer
;
1575 wrap_buffer
[0] = '\0';
1576 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
1580 else if (chars_printed
>= chars_per_line
)
1582 puts_filtered ("\n");
1584 puts_filtered (indent
);
1589 wrap_column
= chars_printed
;
1593 wrap_indent
= indent
;
1597 /* Print input string to gdb_stdout, filtered, with wrap,
1598 arranging strings in columns of n chars. String can be
1599 right or left justified in the column. Never prints
1600 trailing spaces. String should never be longer than
1601 width. FIXME: this could be useful for the EXAMINE
1602 command, which currently doesn't tabulate very well. */
1605 puts_filtered_tabular (char *string
, int width
, int right
)
1611 gdb_assert (chars_per_line
> 0);
1612 if (chars_per_line
== UINT_MAX
)
1614 fputs_filtered (string
, gdb_stdout
);
1615 fputs_filtered ("\n", gdb_stdout
);
1619 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1620 fputs_filtered ("\n", gdb_stdout
);
1622 if (width
>= chars_per_line
)
1623 width
= chars_per_line
- 1;
1625 stringlen
= strlen (string
);
1627 if (chars_printed
> 0)
1628 spaces
= width
- (chars_printed
- 1) % width
- 1;
1630 spaces
+= width
- stringlen
;
1632 spacebuf
= (char *) alloca (spaces
+ 1);
1633 spacebuf
[spaces
] = '\0';
1635 spacebuf
[spaces
] = ' ';
1637 fputs_filtered (spacebuf
, gdb_stdout
);
1638 fputs_filtered (string
, gdb_stdout
);
1642 /* Ensure that whatever gets printed next, using the filtered output
1643 commands, starts at the beginning of the line. I.e. if there is
1644 any pending output for the current line, flush it and start a new
1645 line. Otherwise do nothing. */
1650 if (chars_printed
> 0)
1652 puts_filtered ("\n");
1657 /* Like fputs but if FILTER is true, pause after every screenful.
1659 Regardless of FILTER can wrap at points other than the final
1660 character of a line.
1662 Unlike fputs, fputs_maybe_filtered does not return a value.
1663 It is OK for LINEBUFFER to be NULL, in which case just don't print
1666 Note that a longjmp to top level may occur in this routine (only if
1667 FILTER is true) (since prompt_for_continue may do so) so this
1668 routine should not be called when cleanups are not in place. */
1671 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1674 const char *lineptr
;
1676 if (linebuffer
== 0)
1679 /* Don't do any filtering if it is disabled. */
1680 if (stream
!= gdb_stdout
1681 || !pagination_enabled
1683 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
1684 || top_level_interpreter () == NULL
1685 || interp_ui_out (top_level_interpreter ())->is_mi_like_p ())
1687 fputs_unfiltered (linebuffer
, stream
);
1691 /* Go through and output each character. Show line extension
1692 when this is necessary; prompt user for new page when this is
1695 lineptr
= linebuffer
;
1698 /* Possible new page. */
1699 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1700 prompt_for_continue ();
1702 while (*lineptr
&& *lineptr
!= '\n')
1704 /* Print a single line. */
1705 if (*lineptr
== '\t')
1708 *wrap_pointer
++ = '\t';
1710 fputc_unfiltered ('\t', stream
);
1711 /* Shifting right by 3 produces the number of tab stops
1712 we have already passed, and then adding one and
1713 shifting left 3 advances to the next tab stop. */
1714 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1720 *wrap_pointer
++ = *lineptr
;
1722 fputc_unfiltered (*lineptr
, stream
);
1727 if (chars_printed
>= chars_per_line
)
1729 unsigned int save_chars
= chars_printed
;
1733 /* If we aren't actually wrapping, don't output newline --
1734 if chars_per_line is right, we probably just overflowed
1735 anyway; if it's wrong, let us keep going. */
1737 fputc_unfiltered ('\n', stream
);
1739 /* Possible new page. */
1740 if (lines_printed
>= lines_per_page
- 1)
1741 prompt_for_continue ();
1743 /* Now output indentation and wrapped string. */
1746 fputs_unfiltered (wrap_indent
, stream
);
1747 *wrap_pointer
= '\0'; /* Null-terminate saved stuff, */
1748 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it. */
1749 /* FIXME, this strlen is what prevents wrap_indent from
1750 containing tabs. However, if we recurse to print it
1751 and count its chars, we risk trouble if wrap_indent is
1752 longer than (the user settable) chars_per_line.
1753 Note also that this can set chars_printed > chars_per_line
1754 if we are printing a long string. */
1755 chars_printed
= strlen (wrap_indent
)
1756 + (save_chars
- wrap_column
);
1757 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1758 wrap_buffer
[0] = '\0';
1759 wrap_column
= 0; /* And disable fancy wrap */
1764 if (*lineptr
== '\n')
1767 wrap_here ((char *) 0); /* Spit out chars, cancel
1770 fputc_unfiltered ('\n', stream
);
1777 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1779 fputs_maybe_filtered (linebuffer
, stream
, 1);
1783 putchar_unfiltered (int c
)
1787 ui_file_write (gdb_stdout
, &buf
, 1);
1791 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1792 May return nonlocally. */
1795 putchar_filtered (int c
)
1797 return fputc_filtered (c
, gdb_stdout
);
1801 fputc_unfiltered (int c
, struct ui_file
*stream
)
1805 ui_file_write (stream
, &buf
, 1);
1810 fputc_filtered (int c
, struct ui_file
*stream
)
1816 fputs_filtered (buf
, stream
);
1820 /* puts_debug is like fputs_unfiltered, except it prints special
1821 characters in printable fashion. */
1824 puts_debug (char *prefix
, char *string
, char *suffix
)
1828 /* Print prefix and suffix after each line. */
1829 static int new_line
= 1;
1830 static int return_p
= 0;
1831 static const char *prev_prefix
= "";
1832 static const char *prev_suffix
= "";
1834 if (*string
== '\n')
1837 /* If the prefix is changing, print the previous suffix, a new line,
1838 and the new prefix. */
1839 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
1841 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
1842 fputs_unfiltered ("\n", gdb_stdlog
);
1843 fputs_unfiltered (prefix
, gdb_stdlog
);
1846 /* Print prefix if we printed a newline during the previous call. */
1850 fputs_unfiltered (prefix
, gdb_stdlog
);
1853 prev_prefix
= prefix
;
1854 prev_suffix
= suffix
;
1856 /* Output characters in a printable format. */
1857 while ((ch
= *string
++) != '\0')
1863 fputc_unfiltered (ch
, gdb_stdlog
);
1866 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
1870 fputs_unfiltered ("\\\\", gdb_stdlog
);
1873 fputs_unfiltered ("\\b", gdb_stdlog
);
1876 fputs_unfiltered ("\\f", gdb_stdlog
);
1880 fputs_unfiltered ("\\n", gdb_stdlog
);
1883 fputs_unfiltered ("\\r", gdb_stdlog
);
1886 fputs_unfiltered ("\\t", gdb_stdlog
);
1889 fputs_unfiltered ("\\v", gdb_stdlog
);
1893 return_p
= ch
== '\r';
1896 /* Print suffix if we printed a newline. */
1899 fputs_unfiltered (suffix
, gdb_stdlog
);
1900 fputs_unfiltered ("\n", gdb_stdlog
);
1905 /* Print a variable number of ARGS using format FORMAT. If this
1906 information is going to put the amount written (since the last call
1907 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1908 call prompt_for_continue to get the users permision to continue.
1910 Unlike fprintf, this function does not return a value.
1912 We implement three variants, vfprintf (takes a vararg list and stream),
1913 fprintf (takes a stream to write on), and printf (the usual).
1915 Note also that a longjmp to top level may occur in this routine
1916 (since prompt_for_continue may do so) so this routine should not be
1917 called when cleanups are not in place. */
1920 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
1921 va_list args
, int filter
)
1923 std::string linebuffer
= string_vprintf (format
, args
);
1924 fputs_maybe_filtered (linebuffer
.c_str (), stream
, filter
);
1929 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
1931 vfprintf_maybe_filtered (stream
, format
, args
, 1);
1935 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
1937 std::string linebuffer
= string_vprintf (format
, args
);
1938 if (debug_timestamp
&& stream
== gdb_stdlog
)
1940 using namespace std::chrono
;
1943 steady_clock::time_point now
= steady_clock::now ();
1944 seconds s
= duration_cast
<seconds
> (now
.time_since_epoch ());
1945 microseconds us
= duration_cast
<microseconds
> (now
.time_since_epoch () - s
);
1947 len
= linebuffer
.size ();
1948 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
1950 std::string timestamp
= string_printf ("%ld.%06ld %s%s",
1953 linebuffer
.c_str (),
1954 need_nl
? "\n": "");
1955 fputs_unfiltered (timestamp
.c_str (), stream
);
1958 fputs_unfiltered (linebuffer
.c_str (), stream
);
1962 vprintf_filtered (const char *format
, va_list args
)
1964 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
1968 vprintf_unfiltered (const char *format
, va_list args
)
1970 vfprintf_unfiltered (gdb_stdout
, format
, args
);
1974 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
1978 va_start (args
, format
);
1979 vfprintf_filtered (stream
, format
, args
);
1984 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
1988 va_start (args
, format
);
1989 vfprintf_unfiltered (stream
, format
, args
);
1993 /* Like fprintf_filtered, but prints its result indented.
1994 Called as fprintfi_filtered (spaces, stream, format, ...); */
1997 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2002 va_start (args
, format
);
2003 print_spaces_filtered (spaces
, stream
);
2005 vfprintf_filtered (stream
, format
, args
);
2011 printf_filtered (const char *format
, ...)
2015 va_start (args
, format
);
2016 vfprintf_filtered (gdb_stdout
, format
, args
);
2022 printf_unfiltered (const char *format
, ...)
2026 va_start (args
, format
);
2027 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2031 /* Like printf_filtered, but prints it's result indented.
2032 Called as printfi_filtered (spaces, format, ...); */
2035 printfi_filtered (int spaces
, const char *format
, ...)
2039 va_start (args
, format
);
2040 print_spaces_filtered (spaces
, gdb_stdout
);
2041 vfprintf_filtered (gdb_stdout
, format
, args
);
2045 /* Easy -- but watch out!
2047 This routine is *not* a replacement for puts()! puts() appends a newline.
2048 This one doesn't, and had better not! */
2051 puts_filtered (const char *string
)
2053 fputs_filtered (string
, gdb_stdout
);
2057 puts_unfiltered (const char *string
)
2059 fputs_unfiltered (string
, gdb_stdout
);
2062 /* Return a pointer to N spaces and a null. The pointer is good
2063 until the next call to here. */
2068 static char *spaces
= 0;
2069 static int max_spaces
= -1;
2075 spaces
= (char *) xmalloc (n
+ 1);
2076 for (t
= spaces
+ n
; t
!= spaces
;)
2082 return spaces
+ max_spaces
- n
;
2085 /* Print N spaces. */
2087 print_spaces_filtered (int n
, struct ui_file
*stream
)
2089 fputs_filtered (n_spaces (n
), stream
);
2092 /* C++/ObjC demangler stuff. */
2094 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2095 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2096 If the name is not mangled, or the language for the name is unknown, or
2097 demangling is off, the name is printed in its "raw" form. */
2100 fprintf_symbol_filtered (struct ui_file
*stream
, const char *name
,
2101 enum language lang
, int arg_mode
)
2107 /* If user wants to see raw output, no problem. */
2110 fputs_filtered (name
, stream
);
2114 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2115 fputs_filtered (demangled
? demangled
: name
, stream
);
2116 if (demangled
!= NULL
)
2124 /* True if CH is a character that can be part of a symbol name. I.e.,
2125 either a number, a letter, or a '_'. */
2128 valid_identifier_name_char (int ch
)
2130 return (isalnum (ch
) || ch
== '_');
2133 /* Skip to end of token, or to END, whatever comes first. Input is
2134 assumed to be a C++ operator name. */
2137 cp_skip_operator_token (const char *token
, const char *end
)
2139 const char *p
= token
;
2140 while (p
!= end
&& !isspace (*p
) && *p
!= '(')
2142 if (valid_identifier_name_char (*p
))
2144 while (p
!= end
&& valid_identifier_name_char (*p
))
2150 /* Note, ordered such that among ops that share a prefix,
2151 longer comes first. This is so that the loop below can
2152 bail on first match. */
2153 static const char *ops
[] =
2159 "-=", "--", "->", "-",
2168 "<<=", "<=", "<<", "<",
2169 ">>=", ">=", ">>", ">",
2173 for (const char *op
: ops
)
2175 size_t oplen
= strlen (op
);
2176 size_t lencmp
= std::min
<size_t> (oplen
, end
- p
);
2178 if (strncmp (p
, op
, lencmp
) == 0)
2181 /* Some unidentified character. Return it. */
2189 /* Advance STRING1/STRING2 past whitespace. */
2192 skip_ws (const char *&string1
, const char *&string2
, const char *end_str2
)
2194 while (isspace (*string1
))
2196 while (string2
< end_str2
&& isspace (*string2
))
2200 /* True if STRING points at the start of a C++ operator name. START
2201 is the start of the string that STRING points to, hence when
2202 reading backwards, we must not read any character before START. */
2205 cp_is_operator (const char *string
, const char *start
)
2207 return ((string
== start
2208 || !valid_identifier_name_char (string
[-1]))
2209 && strncmp (string
, CP_OPERATOR_STR
, CP_OPERATOR_LEN
) == 0
2210 && !valid_identifier_name_char (string
[CP_OPERATOR_LEN
]));
2213 /* If *NAME points at an ABI tag, skip it and return true. Otherwise
2214 leave *NAME unmodified and return false. (see GCC's abi_tag
2215 attribute), such names are demangled as e.g.,
2216 "function[abi:cxx11]()". */
2219 skip_abi_tag (const char **name
)
2221 const char *p
= *name
;
2223 if (startswith (p
, "[abi:"))
2227 while (valid_identifier_name_char (*p
))
2243 strncmp_iw_with_mode (const char *string1
, const char *string2
,
2244 size_t string2_len
, strncmp_iw_mode mode
,
2245 enum language language
,
2246 completion_match_for_lcd
*match_for_lcd
)
2248 const char *string1_start
= string1
;
2249 const char *end_str2
= string2
+ string2_len
;
2250 bool skip_spaces
= true;
2251 bool have_colon_op
= (language
== language_cplus
2252 || language
== language_rust
2253 || language
== language_fortran
);
2258 || ((isspace (*string1
) && !valid_identifier_name_char (*string2
))
2259 || (isspace (*string2
) && !valid_identifier_name_char (*string1
))))
2261 skip_ws (string1
, string2
, end_str2
);
2262 skip_spaces
= false;
2265 /* Skip [abi:cxx11] tags in the symbol name if the lookup name
2266 doesn't include them. E.g.:
2268 string1: function[abi:cxx1](int)
2271 string1: function[abi:cxx1](int)
2272 string2: function(int)
2274 string1: Struct[abi:cxx1]::function()
2275 string2: Struct::function()
2277 string1: function(Struct[abi:cxx1], int)
2278 string2: function(Struct, int)
2280 if (string2
== end_str2
2281 || (*string2
!= '[' && !valid_identifier_name_char (*string2
)))
2283 const char *abi_start
= string1
;
2285 /* There can be more than one tag. */
2286 while (*string1
== '[' && skip_abi_tag (&string1
))
2289 if (match_for_lcd
!= NULL
&& abi_start
!= string1
)
2290 match_for_lcd
->mark_ignored_range (abi_start
, string1
);
2292 while (isspace (*string1
))
2296 if (*string1
== '\0' || string2
== end_str2
)
2299 /* Handle the :: operator. */
2300 if (have_colon_op
&& string1
[0] == ':' && string1
[1] == ':')
2302 if (*string2
!= ':')
2308 if (string2
== end_str2
)
2311 if (*string2
!= ':')
2317 while (isspace (*string1
))
2319 while (string2
< end_str2
&& isspace (*string2
))
2324 /* Handle C++ user-defined operators. */
2325 else if (language
== language_cplus
2328 if (cp_is_operator (string1
, string1_start
))
2330 /* An operator name in STRING1. Check STRING2. */
2332 = std::min
<size_t> (CP_OPERATOR_LEN
, end_str2
- string2
);
2333 if (strncmp (string1
, string2
, cmplen
) != 0)
2339 if (string2
!= end_str2
)
2341 /* Check for "operatorX" in STRING2. */
2342 if (valid_identifier_name_char (*string2
))
2345 skip_ws (string1
, string2
, end_str2
);
2348 /* Handle operator(). */
2349 if (*string1
== '(')
2351 if (string2
== end_str2
)
2353 if (mode
== strncmp_iw_mode::NORMAL
)
2357 /* Don't break for the regular return at the
2358 bottom, because "operator" should not
2359 match "operator()", since this open
2360 parentheses is not the parameter list
2362 return *string1
!= '\0';
2366 if (*string1
!= *string2
)
2375 skip_ws (string1
, string2
, end_str2
);
2377 /* Skip to end of token, or to END, whatever comes
2379 const char *end_str1
= string1
+ strlen (string1
);
2380 const char *p1
= cp_skip_operator_token (string1
, end_str1
);
2381 const char *p2
= cp_skip_operator_token (string2
, end_str2
);
2383 cmplen
= std::min (p1
- string1
, p2
- string2
);
2386 if (strncmp (string1
, string2
, cmplen
) != 0)
2391 if (p1
- string1
!= p2
- string2
)
2393 if (strncmp (string1
, string2
, cmplen
) != 0)
2400 if (*string1
== '\0' || string2
== end_str2
)
2402 if (*string1
== '(' || *string2
== '(')
2410 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
2412 if (case_sensitivity
== case_sensitive_off
2413 && (tolower ((unsigned char) *string1
)
2414 != tolower ((unsigned char) *string2
)))
2417 /* If we see any non-whitespace, non-identifier-name character
2418 (any of "()<>*&" etc.), then skip spaces the next time
2420 if (!isspace (*string1
) && !valid_identifier_name_char (*string1
))
2427 if (string2
== end_str2
)
2429 if (mode
== strncmp_iw_mode::NORMAL
)
2431 /* Strip abi tag markers from the matched symbol name.
2432 Usually the ABI marker will be found on function name
2433 (automatically added because the function returns an
2434 object marked with an ABI tag). However, it's also
2435 possible to see a marker in one of the function
2436 parameters, for example.
2438 string2 (lookup name):
2441 function(some_struct[abi:cxx11], int)
2443 and for completion LCD computation we want to say that
2445 function(some_struct, int)
2447 if (match_for_lcd
!= NULL
)
2449 while ((string1
= strstr (string1
, "[abi:")) != NULL
)
2451 const char *abi_start
= string1
;
2453 /* There can be more than one tag. */
2454 while (skip_abi_tag (&string1
) && *string1
== '[')
2457 if (abi_start
!= string1
)
2458 match_for_lcd
->mark_ignored_range (abi_start
, string1
);
2465 return (*string1
!= '\0' && *string1
!= '(');
2474 strncmp_iw (const char *string1
, const char *string2
, size_t string2_len
)
2476 return strncmp_iw_with_mode (string1
, string2
, string2_len
,
2477 strncmp_iw_mode::NORMAL
, language_minimal
);
2483 strcmp_iw (const char *string1
, const char *string2
)
2485 return strncmp_iw_with_mode (string1
, string2
, strlen (string2
),
2486 strncmp_iw_mode::MATCH_PARAMS
, language_minimal
);
2489 /* This is like strcmp except that it ignores whitespace and treats
2490 '(' as the first non-NULL character in terms of ordering. Like
2491 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2492 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2493 according to that ordering.
2495 If a list is sorted according to this function and if you want to
2496 find names in the list that match some fixed NAME according to
2497 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2498 where this function would put NAME.
2500 This function must be neutral to the CASE_SENSITIVITY setting as the user
2501 may choose it during later lookup. Therefore this function always sorts
2502 primarily case-insensitively and secondarily case-sensitively.
2504 Here are some examples of why using strcmp to sort is a bad idea:
2508 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2509 we try to do a search for "foo<char*>", strcmp will locate this
2510 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2511 will start looking at strings beginning with "goo", and will never
2512 see the correct match of "foo<char *>".
2514 Parenthesis example:
2516 In practice, this is less like to be an issue, but I'll give it a
2517 shot. Let's assume that '$' is a legitimate character to occur in
2518 symbols. (Which may well even be the case on some systems.) Then
2519 say that the partial symbol table contains "foo$" and "foo(int)".
2520 strcmp will put them in this order, since '$' < '('. Now, if the
2521 user searches for "foo", then strcmp will sort "foo" before "foo$".
2522 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2523 "foo") is false, so it won't proceed to the actual match of
2524 "foo(int)" with "foo". */
2527 strcmp_iw_ordered (const char *string1
, const char *string2
)
2529 const char *saved_string1
= string1
, *saved_string2
= string2
;
2530 enum case_sensitivity case_pass
= case_sensitive_off
;
2534 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2535 Provide stub characters if we are already at the end of one of the
2537 char c1
= 'X', c2
= 'X';
2539 while (*string1
!= '\0' && *string2
!= '\0')
2541 while (isspace (*string1
))
2543 while (isspace (*string2
))
2548 case case_sensitive_off
:
2549 c1
= tolower ((unsigned char) *string1
);
2550 c2
= tolower ((unsigned char) *string2
);
2552 case case_sensitive_on
:
2560 if (*string1
!= '\0')
2569 /* Characters are non-equal unless they're both '\0'; we want to
2570 make sure we get the comparison right according to our
2571 comparison in the cases where one of them is '\0' or '('. */
2573 if (*string2
== '\0')
2578 if (*string2
== '\0')
2583 if (*string2
== '\0' || *string2
== '(')
2592 if (case_pass
== case_sensitive_on
)
2595 /* Otherwise the strings were equal in case insensitive way, make
2596 a more fine grained comparison in a case sensitive way. */
2598 case_pass
= case_sensitive_on
;
2599 string1
= saved_string1
;
2600 string2
= saved_string2
;
2607 streq (const char *lhs
, const char *rhs
)
2609 return !strcmp (lhs
, rhs
);
2615 streq_hash (const void *lhs
, const void *rhs
)
2617 return streq ((const char *) lhs
, (const char *) rhs
);
2624 ** Answer whether string_to_compare is a full or partial match to
2625 ** template_string. The partial match must be in sequence starting
2629 subset_compare (const char *string_to_compare
, const char *template_string
)
2633 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2634 && strlen (string_to_compare
) <= strlen (template_string
))
2636 (startswith (template_string
, string_to_compare
));
2643 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2644 struct cmd_list_element
*c
, const char *value
)
2646 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
2652 initialize_utils (void)
2654 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2655 Set number of characters where GDB should wrap lines of its output."), _("\
2656 Show number of characters where GDB should wrap lines of its output."), _("\
2657 This affects where GDB wraps its output to fit the screen width.\n\
2658 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2660 show_chars_per_line
,
2661 &setlist
, &showlist
);
2663 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2664 Set number of lines in a page for GDB output pagination."), _("\
2665 Show number of lines in a page for GDB output pagination."), _("\
2666 This affects the number of lines after which GDB will pause\n\
2667 its output and ask you whether to continue.\n\
2668 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2670 show_lines_per_page
,
2671 &setlist
, &showlist
);
2673 add_setshow_boolean_cmd ("pagination", class_support
,
2674 &pagination_enabled
, _("\
2675 Set state of GDB output pagination."), _("\
2676 Show state of GDB output pagination."), _("\
2677 When pagination is ON, GDB pauses at end of each screenful of\n\
2678 its output and asks you whether to continue.\n\
2679 Turning pagination off is an alternative to \"set height unlimited\"."),
2681 show_pagination_enabled
,
2682 &setlist
, &showlist
);
2684 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2685 &sevenbit_strings
, _("\
2686 Set printing of 8-bit characters in strings as \\nnn."), _("\
2687 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2689 show_sevenbit_strings
,
2690 &setprintlist
, &showprintlist
);
2692 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2693 &debug_timestamp
, _("\
2694 Set timestamping of debugging messages."), _("\
2695 Show timestamping of debugging messages."), _("\
2696 When set, debugging messages will be marked with seconds and microseconds."),
2698 show_debug_timestamp
,
2699 &setdebuglist
, &showdebuglist
);
2705 address_significant (gdbarch
*gdbarch
, CORE_ADDR addr
)
2707 /* Truncate address to the significant bits of a target address,
2708 avoiding shifts larger or equal than the width of a CORE_ADDR.
2709 The local variable ADDR_BIT stops the compiler reporting a shift
2710 overflow when it won't occur. */
2711 int addr_bit
= gdbarch_significant_addr_bit (gdbarch
);
2713 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2714 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2720 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2722 /* Truncate address to the size of a target address, avoiding shifts
2723 larger or equal than the width of a CORE_ADDR. The local
2724 variable ADDR_BIT stops the compiler reporting a shift overflow
2725 when it won't occur. */
2726 /* NOTE: This assumes that the significant address information is
2727 kept in the least significant bits of ADDR - the upper bits were
2728 either zero or sign extended. Should gdbarch_address_to_pointer or
2729 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2731 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2733 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2734 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2735 return hex_string (addr
);
2738 /* This function is described in "defs.h". */
2741 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2743 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2745 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2746 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2748 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2749 that returns the language localized string formatted to a width
2750 based on gdbarch_addr_bit. */
2752 return hex_string_custom (address
, 8);
2754 return hex_string_custom (address
, 16);
2757 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2760 core_addr_hash (const void *ap
)
2762 const CORE_ADDR
*addrp
= (const CORE_ADDR
*) ap
;
2767 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2770 core_addr_eq (const void *ap
, const void *bp
)
2772 const CORE_ADDR
*addr_ap
= (const CORE_ADDR
*) ap
;
2773 const CORE_ADDR
*addr_bp
= (const CORE_ADDR
*) bp
;
2775 return *addr_ap
== *addr_bp
;
2778 /* Convert a string back into a CORE_ADDR. */
2780 string_to_core_addr (const char *my_string
)
2784 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2786 /* Assume that it is in hex. */
2789 for (i
= 2; my_string
[i
] != '\0'; i
++)
2791 if (isdigit (my_string
[i
]))
2792 addr
= (my_string
[i
] - '0') + (addr
* 16);
2793 else if (isxdigit (my_string
[i
]))
2794 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2796 error (_("invalid hex \"%s\""), my_string
);
2801 /* Assume that it is in decimal. */
2804 for (i
= 0; my_string
[i
] != '\0'; i
++)
2806 if (isdigit (my_string
[i
]))
2807 addr
= (my_string
[i
] - '0') + (addr
* 10);
2809 error (_("invalid decimal \"%s\""), my_string
);
2819 gdb_realpath_check_trailer (const char *input
, const char *trailer
)
2821 gdb::unique_xmalloc_ptr
<char> result
= gdb_realpath (input
);
2823 size_t len
= strlen (result
.get ());
2824 size_t trail_len
= strlen (trailer
);
2826 SELF_CHECK (len
>= trail_len
2827 && strcmp (result
.get () + len
- trail_len
, trailer
) == 0);
2831 gdb_realpath_tests ()
2833 /* A file which contains a directory prefix. */
2834 gdb_realpath_check_trailer ("./xfullpath.exp", "/xfullpath.exp");
2835 /* A file which contains a directory prefix. */
2836 gdb_realpath_check_trailer ("../../defs.h", "/defs.h");
2837 /* A one-character filename. */
2838 gdb_realpath_check_trailer ("./a", "/a");
2839 /* A file in the root directory. */
2840 gdb_realpath_check_trailer ("/root_file_which_should_exist",
2841 "/root_file_which_should_exist");
2842 /* A file which does not have a directory prefix. */
2843 gdb_realpath_check_trailer ("xfullpath.exp", "xfullpath.exp");
2844 /* A one-char filename without any directory prefix. */
2845 gdb_realpath_check_trailer ("a", "a");
2846 /* An empty filename. */
2847 gdb_realpath_check_trailer ("", "");
2850 #endif /* GDB_SELF_TEST */
2853 align_up (ULONGEST v
, int n
)
2855 /* Check that N is really a power of two. */
2856 gdb_assert (n
&& (n
& (n
-1)) == 0);
2857 return (v
+ n
- 1) & -n
;
2861 align_down (ULONGEST v
, int n
)
2863 /* Check that N is really a power of two. */
2864 gdb_assert (n
&& (n
& (n
-1)) == 0);
2868 /* Allocation function for the libiberty hash table which uses an
2869 obstack. The obstack is passed as DATA. */
2872 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
2874 size_t total
= size
* count
;
2875 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
2877 memset (ptr
, 0, total
);
2881 /* Trivial deallocation function for the libiberty splay tree and hash
2882 table - don't deallocate anything. Rely on later deletion of the
2883 obstack. DATA will be the obstack, although it is not needed
2887 dummy_obstack_deallocate (void *object
, void *data
)
2892 /* Simple, portable version of dirname that does not modify its
2896 ldirname (const char *filename
)
2898 std::string dirname
;
2899 const char *base
= lbasename (filename
);
2901 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
2904 if (base
== filename
)
2907 dirname
= std::string (filename
, base
- filename
);
2909 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
2910 create "d:./bar" later instead of the (different) "d:/bar". */
2911 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
2912 && !IS_DIR_SEPARATOR (filename
[0]))
2913 dirname
[base
++ - filename
] = '.';
2921 gdb_argv::reset (const char *s
)
2923 char **argv
= buildargv (s
);
2925 if (s
!= NULL
&& argv
== NULL
)
2933 compare_positive_ints (const void *ap
, const void *bp
)
2935 /* Because we know we're comparing two ints which are positive,
2936 there's no danger of overflow here. */
2937 return * (int *) ap
- * (int *) bp
;
2940 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
2941 #define AMBIGUOUS_MESS2 \
2942 ".\nUse \"set gnutarget format-name\" to specify the format."
2945 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
2951 /* Check if errmsg just need simple return. */
2952 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
2953 return bfd_errmsg (error_tag
);
2955 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
2956 + strlen (AMBIGUOUS_MESS2
);
2957 for (p
= matching
; *p
; p
++)
2958 ret_len
+= strlen (*p
) + 1;
2959 ret
= (char *) xmalloc (ret_len
+ 1);
2961 make_cleanup (xfree
, ret
);
2963 strcpy (retp
, bfd_errmsg (error_tag
));
2964 retp
+= strlen (retp
);
2966 strcpy (retp
, AMBIGUOUS_MESS1
);
2967 retp
+= strlen (retp
);
2969 for (p
= matching
; *p
; p
++)
2971 sprintf (retp
, " %s", *p
);
2972 retp
+= strlen (retp
);
2976 strcpy (retp
, AMBIGUOUS_MESS2
);
2981 /* Return ARGS parsed as a valid pid, or throw an error. */
2984 parse_pid_to_attach (const char *args
)
2990 error_no_arg (_("process-id to attach"));
2992 dummy
= (char *) args
;
2993 pid
= strtoul (args
, &dummy
, 0);
2994 /* Some targets don't set errno on errors, grrr! */
2995 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
2996 error (_("Illegal process-id: %s."), args
);
3001 /* Helper for make_bpstat_clear_actions_cleanup. */
3004 do_bpstat_clear_actions_cleanup (void *unused
)
3006 bpstat_clear_actions ();
3009 /* Call bpstat_clear_actions for the case an exception is throw. You should
3010 discard_cleanups if no exception is caught. */
3013 make_bpstat_clear_actions_cleanup (void)
3015 return make_cleanup (do_bpstat_clear_actions_cleanup
, NULL
);
3018 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3019 must come from xrealloc-compatible allocator and it may be updated. FROM
3020 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3021 located at the start or end of *STRINGP. */
3024 substitute_path_component (char **stringp
, const char *from
, const char *to
)
3026 char *string
= *stringp
, *s
;
3027 const size_t from_len
= strlen (from
);
3028 const size_t to_len
= strlen (to
);
3032 s
= strstr (s
, from
);
3036 if ((s
== string
|| IS_DIR_SEPARATOR (s
[-1])
3037 || s
[-1] == DIRNAME_SEPARATOR
)
3038 && (s
[from_len
] == '\0' || IS_DIR_SEPARATOR (s
[from_len
])
3039 || s
[from_len
] == DIRNAME_SEPARATOR
))
3044 = (char *) xrealloc (string
, (strlen (string
) + to_len
+ 1));
3046 /* Relocate the current S pointer. */
3047 s
= s
- string
+ string_new
;
3048 string
= string_new
;
3050 /* Replace from by to. */
3051 memmove (&s
[to_len
], &s
[from_len
], strlen (&s
[from_len
]) + 1);
3052 memcpy (s
, to
, to_len
);
3067 /* SIGALRM handler for waitpid_with_timeout. */
3070 sigalrm_handler (int signo
)
3072 /* Nothing to do. */
3077 /* Wrapper to wait for child PID to die with TIMEOUT.
3078 TIMEOUT is the time to stop waiting in seconds.
3079 If TIMEOUT is zero, pass WNOHANG to waitpid.
3080 Returns PID if it was successfully waited for, otherwise -1.
3082 Timeouts are currently implemented with alarm and SIGALRM.
3083 If the host does not support them, this waits "forever".
3084 It would be odd though for a host to have waitpid and not SIGALRM. */
3087 wait_to_die_with_timeout (pid_t pid
, int *status
, int timeout
)
3089 pid_t waitpid_result
;
3091 gdb_assert (pid
> 0);
3092 gdb_assert (timeout
>= 0);
3097 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3098 struct sigaction sa
, old_sa
;
3100 sa
.sa_handler
= sigalrm_handler
;
3101 sigemptyset (&sa
.sa_mask
);
3103 sigaction (SIGALRM
, &sa
, &old_sa
);
3107 ofunc
= signal (SIGALRM
, sigalrm_handler
);
3113 waitpid_result
= waitpid (pid
, status
, 0);
3117 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3118 sigaction (SIGALRM
, &old_sa
, NULL
);
3120 signal (SIGALRM
, ofunc
);
3125 waitpid_result
= waitpid (pid
, status
, WNOHANG
);
3127 if (waitpid_result
== pid
)
3133 #endif /* HAVE_WAITPID */
3135 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3136 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3138 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3139 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3142 gdb_filename_fnmatch (const char *pattern
, const char *string
, int flags
)
3144 gdb_assert ((flags
& FNM_FILE_NAME
) != 0);
3146 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3147 gdb_assert ((flags
& FNM_NOESCAPE
) != 0);
3149 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3151 char *pattern_slash
, *string_slash
;
3153 /* Replace '\' by '/' in both strings. */
3155 pattern_slash
= (char *) alloca (strlen (pattern
) + 1);
3156 strcpy (pattern_slash
, pattern
);
3157 pattern
= pattern_slash
;
3158 for (; *pattern_slash
!= 0; pattern_slash
++)
3159 if (IS_DIR_SEPARATOR (*pattern_slash
))
3160 *pattern_slash
= '/';
3162 string_slash
= (char *) alloca (strlen (string
) + 1);
3163 strcpy (string_slash
, string
);
3164 string
= string_slash
;
3165 for (; *string_slash
!= 0; string_slash
++)
3166 if (IS_DIR_SEPARATOR (*string_slash
))
3167 *string_slash
= '/';
3169 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3171 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3172 flags
|= FNM_CASEFOLD
;
3173 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3175 return fnmatch (pattern
, string
, flags
);
3178 /* Return the number of path elements in PATH.
3186 count_path_elements (const char *path
)
3189 const char *p
= path
;
3191 if (HAS_DRIVE_SPEC (p
))
3193 p
= STRIP_DRIVE_SPEC (p
);
3199 if (IS_DIR_SEPARATOR (*p
))
3204 /* Backup one if last character is /, unless it's the only one. */
3205 if (p
> path
+ 1 && IS_DIR_SEPARATOR (p
[-1]))
3208 /* Add one for the file name, if present. */
3209 if (p
> path
&& !IS_DIR_SEPARATOR (p
[-1]))
3215 /* Remove N leading path elements from PATH.
3216 N must be non-negative.
3217 If PATH has more than N path elements then return NULL.
3218 If PATH has exactly N path elements then return "".
3219 See count_path_elements for a description of how we do the counting. */
3222 strip_leading_path_elements (const char *path
, int n
)
3225 const char *p
= path
;
3227 gdb_assert (n
>= 0);
3232 if (HAS_DRIVE_SPEC (p
))
3234 p
= STRIP_DRIVE_SPEC (p
);
3240 while (*p
!= '\0' && !IS_DIR_SEPARATOR (*p
))
3256 _initialize_utils (void)
3258 add_internal_problem_command (&internal_error_problem
);
3259 add_internal_problem_command (&internal_warning_problem
);
3260 add_internal_problem_command (&demangler_warning_problem
);
3263 selftests::register_test ("gdb_realpath", gdb_realpath_tests
);