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 /* This function is useful for cleanups.
148 old_chain = make_cleanup (free_current_contents, &foo);
150 to arrange to free the object thus allocated. */
153 free_current_contents (void *ptr
)
155 void **location
= (void **) ptr
;
157 if (location
== NULL
)
158 internal_error (__FILE__
, __LINE__
,
159 _("free_current_contents: NULL pointer"));
160 if (*location
!= NULL
)
169 /* Print a warning message. The first argument STRING is the warning
170 message, used as an fprintf format string, the second is the
171 va_list of arguments for that string. A warning is unfiltered (not
172 paginated) so that the user does not need to page through each
173 screen full of warnings when there are lots of them. */
176 vwarning (const char *string
, va_list args
)
178 if (deprecated_warning_hook
)
179 (*deprecated_warning_hook
) (string
, args
);
182 gdb::optional
<target_terminal::scoped_restore_terminal_state
> term_state
;
183 if (target_supports_terminal_ours ())
185 term_state
.emplace ();
186 target_terminal::ours_for_output ();
188 if (filtered_printing_initialized ())
189 wrap_here (""); /* Force out any buffered output. */
190 gdb_flush (gdb_stdout
);
191 if (warning_pre_print
)
192 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
193 vfprintf_unfiltered (gdb_stderr
, string
, args
);
194 fprintf_unfiltered (gdb_stderr
, "\n");
198 /* Print an error message and return to command level.
199 The first argument STRING is the error message, used as a fprintf string,
200 and the remaining args are passed as arguments to it. */
203 verror (const char *string
, va_list args
)
205 throw_verror (GENERIC_ERROR
, string
, args
);
209 error_stream (const string_file
&stream
)
211 error (("%s"), stream
.c_str ());
214 /* Emit a message and abort. */
216 static void ATTRIBUTE_NORETURN
217 abort_with_message (const char *msg
)
219 if (current_ui
== NULL
)
222 fputs_unfiltered (msg
, gdb_stderr
);
224 abort (); /* NOTE: GDB has only three calls to abort(). */
227 /* Dump core trying to increase the core soft limit to hard limit first. */
232 #ifdef HAVE_SETRLIMIT
233 struct rlimit rlim
= { RLIM_INFINITY
, RLIM_INFINITY
};
235 setrlimit (RLIMIT_CORE
, &rlim
);
236 #endif /* HAVE_SETRLIMIT */
238 abort (); /* NOTE: GDB has only three calls to abort(). */
241 /* Check whether GDB will be able to dump core using the dump_core
242 function. Returns zero if GDB cannot or should not dump core.
243 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
244 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
247 can_dump_core (enum resource_limit_kind limit_kind
)
249 #ifdef HAVE_GETRLIMIT
252 /* Be quiet and assume we can dump if an error is returned. */
253 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
259 if (rlim
.rlim_cur
== 0)
264 if (rlim
.rlim_max
== 0)
267 #endif /* HAVE_GETRLIMIT */
272 /* Print a warning that we cannot dump core. */
275 warn_cant_dump_core (const char *reason
)
277 fprintf_unfiltered (gdb_stderr
,
278 _("%s\nUnable to dump core, use `ulimit -c"
279 " unlimited' before executing GDB next time.\n"),
283 /* Check whether GDB will be able to dump core using the dump_core
284 function, and print a warning if we cannot. */
287 can_dump_core_warn (enum resource_limit_kind limit_kind
,
290 int core_dump_allowed
= can_dump_core (limit_kind
);
292 if (!core_dump_allowed
)
293 warn_cant_dump_core (reason
);
295 return core_dump_allowed
;
298 /* Allow the user to configure the debugger behavior with respect to
299 what to do when an internal problem is detected. */
301 const char internal_problem_ask
[] = "ask";
302 const char internal_problem_yes
[] = "yes";
303 const char internal_problem_no
[] = "no";
304 static const char *const internal_problem_modes
[] =
306 internal_problem_ask
,
307 internal_problem_yes
,
312 /* Print a message reporting an internal error/warning. Ask the user
313 if they want to continue, dump core, or just exit. Return
314 something to indicate a quit. */
316 struct internal_problem
319 int user_settable_should_quit
;
320 const char *should_quit
;
321 int user_settable_should_dump_core
;
322 const char *should_dump_core
;
325 /* Report a problem, internal to GDB, to the user. Once the problem
326 has been reported, and assuming GDB didn't quit, the caller can
327 either allow execution to resume or throw an error. */
329 static void ATTRIBUTE_PRINTF (4, 0)
330 internal_vproblem (struct internal_problem
*problem
,
331 const char *file
, int line
, const char *fmt
, va_list ap
)
338 /* Don't allow infinite error/warning recursion. */
340 static char msg
[] = "Recursive internal problem.\n";
349 abort_with_message (msg
);
352 /* Newer GLIBC versions put the warn_unused_result attribute
353 on write, but this is one of those rare cases where
354 ignoring the return value is correct. Casting to (void)
355 does not fix this problem. This is the solution suggested
356 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
357 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
358 abort (); /* NOTE: GDB has only three calls to abort(). */
363 /* Create a string containing the full error/warning message. Need
364 to call query with this full string, as otherwize the reason
365 (error/warning) and question become separated. Format using a
366 style similar to a compiler error message. Include extra detail
367 so that the user knows that they are living on the edge. */
369 std::string msg
= string_vprintf (fmt
, ap
);
370 reason
= string_printf ("%s:%d: %s: %s\n"
371 "A problem internal to GDB has been detected,\n"
372 "further debugging may prove unreliable.",
373 file
, line
, problem
->name
, msg
.c_str ());
376 /* Fall back to abort_with_message if gdb_stderr is not set up. */
377 if (current_ui
== NULL
)
379 fputs (reason
.c_str (), stderr
);
380 abort_with_message ("\n");
383 /* Try to get the message out and at the start of a new line. */
384 gdb::optional
<target_terminal::scoped_restore_terminal_state
> term_state
;
385 if (target_supports_terminal_ours ())
387 term_state
.emplace ();
388 target_terminal::ours_for_output ();
390 if (filtered_printing_initialized ())
393 /* Emit the message unless query will emit it below. */
394 if (problem
->should_quit
!= internal_problem_ask
396 || !filtered_printing_initialized ())
397 fprintf_unfiltered (gdb_stderr
, "%s\n", reason
.c_str ());
399 if (problem
->should_quit
== internal_problem_ask
)
401 /* Default (yes/batch case) is to quit GDB. When in batch mode
402 this lessens the likelihood of GDB going into an infinite
404 if (!confirm
|| !filtered_printing_initialized ())
407 quit_p
= query (_("%s\nQuit this debugging session? "),
410 else if (problem
->should_quit
== internal_problem_yes
)
412 else if (problem
->should_quit
== internal_problem_no
)
415 internal_error (__FILE__
, __LINE__
, _("bad switch"));
417 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr
);
418 if (REPORT_BUGS_TO
[0])
419 fprintf_unfiltered (gdb_stderr
, _(" For instructions, see:\n%s."),
421 fputs_unfiltered ("\n\n", gdb_stderr
);
423 if (problem
->should_dump_core
== internal_problem_ask
)
425 if (!can_dump_core_warn (LIMIT_MAX
, reason
.c_str ()))
427 else if (!filtered_printing_initialized ())
431 /* Default (yes/batch case) is to dump core. This leaves a GDB
432 `dropping' so that it is easier to see that something went
434 dump_core_p
= query (_("%s\nCreate a core file of GDB? "),
438 else if (problem
->should_dump_core
== internal_problem_yes
)
439 dump_core_p
= can_dump_core_warn (LIMIT_MAX
, reason
.c_str ());
440 else if (problem
->should_dump_core
== internal_problem_no
)
443 internal_error (__FILE__
, __LINE__
, _("bad switch"));
456 #ifdef HAVE_WORKING_FORK
466 static struct internal_problem internal_error_problem
= {
467 "internal-error", 1, internal_problem_ask
, 1, internal_problem_ask
471 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
473 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
474 throw_quit (_("Command aborted."));
477 static struct internal_problem internal_warning_problem
= {
478 "internal-warning", 1, internal_problem_ask
, 1, internal_problem_ask
482 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
484 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
487 static struct internal_problem demangler_warning_problem
= {
488 "demangler-warning", 1, internal_problem_ask
, 0, internal_problem_no
492 demangler_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
494 internal_vproblem (&demangler_warning_problem
, file
, line
, fmt
, ap
);
498 demangler_warning (const char *file
, int line
, const char *string
, ...)
502 va_start (ap
, string
);
503 demangler_vwarning (file
, line
, string
, ap
);
507 /* Dummy functions to keep add_prefix_cmd happy. */
510 set_internal_problem_cmd (const char *args
, int from_tty
)
515 show_internal_problem_cmd (const char *args
, int from_tty
)
519 /* When GDB reports an internal problem (error or warning) it gives
520 the user the opportunity to quit GDB and/or create a core file of
521 the current debug session. This function registers a few commands
522 that make it possible to specify that GDB should always or never
523 quit or create a core file, without asking. The commands look
526 maint set PROBLEM-NAME quit ask|yes|no
527 maint show PROBLEM-NAME quit
528 maint set PROBLEM-NAME corefile ask|yes|no
529 maint show PROBLEM-NAME corefile
531 Where PROBLEM-NAME is currently "internal-error" or
532 "internal-warning". */
535 add_internal_problem_command (struct internal_problem
*problem
)
537 struct cmd_list_element
**set_cmd_list
;
538 struct cmd_list_element
**show_cmd_list
;
542 set_cmd_list
= XNEW (struct cmd_list_element
*);
543 show_cmd_list
= XNEW (struct cmd_list_element
*);
544 *set_cmd_list
= NULL
;
545 *show_cmd_list
= NULL
;
547 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
550 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
553 add_prefix_cmd (problem
->name
,
554 class_maintenance
, set_internal_problem_cmd
, set_doc
,
556 concat ("maintenance set ", problem
->name
, " ",
558 0/*allow-unknown*/, &maintenance_set_cmdlist
);
560 add_prefix_cmd (problem
->name
,
561 class_maintenance
, show_internal_problem_cmd
, show_doc
,
563 concat ("maintenance show ", problem
->name
, " ",
565 0/*allow-unknown*/, &maintenance_show_cmdlist
);
567 if (problem
->user_settable_should_quit
)
569 set_doc
= xstrprintf (_("Set whether GDB should quit "
570 "when an %s is detected"),
572 show_doc
= xstrprintf (_("Show whether GDB will quit "
573 "when an %s is detected"),
575 add_setshow_enum_cmd ("quit", class_maintenance
,
576 internal_problem_modes
,
577 &problem
->should_quit
,
590 if (problem
->user_settable_should_dump_core
)
592 set_doc
= xstrprintf (_("Set whether GDB should create a core "
593 "file of GDB when %s is detected"),
595 show_doc
= xstrprintf (_("Show whether GDB will create a core "
596 "file of GDB when %s is detected"),
598 add_setshow_enum_cmd ("corefile", class_maintenance
,
599 internal_problem_modes
,
600 &problem
->should_dump_core
,
614 /* Return a newly allocated string, containing the PREFIX followed
615 by the system error message for errno (separated by a colon). */
618 perror_string (const char *prefix
)
622 err
= safe_strerror (errno
);
623 return std::string (prefix
) + ": " + err
;
626 /* Print the system error message for errno, and also mention STRING
627 as the file name for which the error was encountered. Use ERRCODE
628 for the thrown exception. Then return to command level. */
631 throw_perror_with_name (enum errors errcode
, const char *string
)
633 std::string combined
= perror_string (string
);
635 /* I understand setting these is a matter of taste. Still, some people
636 may clear errno but not know about bfd_error. Doing this here is not
638 bfd_set_error (bfd_error_no_error
);
641 throw_error (errcode
, _("%s."), combined
.c_str ());
644 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
647 perror_with_name (const char *string
)
649 throw_perror_with_name (GENERIC_ERROR
, string
);
652 /* Same as perror_with_name except that it prints a warning instead
653 of throwing an error. */
656 perror_warning_with_name (const char *string
)
658 std::string combined
= perror_string (string
);
659 warning (_("%s"), combined
.c_str ());
662 /* Print the system error message for ERRCODE, and also mention STRING
663 as the file name for which the error was encountered. */
666 print_sys_errmsg (const char *string
, int errcode
)
671 err
= safe_strerror (errcode
);
672 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
673 strcpy (combined
, string
);
674 strcat (combined
, ": ");
675 strcat (combined
, err
);
677 /* We want anything which was printed on stdout to come out first, before
679 gdb_flush (gdb_stdout
);
680 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
683 /* Control C eventually causes this to be called, at a convenient time. */
688 if (sync_quit_force_run
)
690 sync_quit_force_run
= 0;
691 quit_force (NULL
, 0);
695 /* No steenking SIGINT will ever be coming our way when the
696 program is resumed. Don't lie. */
700 /* If there is no terminal switching for this target, then we can't
701 possibly get screwed by the lack of job control. */
702 || !target_supports_terminal_ours ())
705 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
714 if (sync_quit_force_run
)
719 if (deprecated_interactive_hook
)
720 deprecated_interactive_hook ();
724 /* Called when a memory allocation fails, with the number of bytes of
725 memory requested in SIZE. */
728 malloc_failure (long size
)
732 internal_error (__FILE__
, __LINE__
,
733 _("virtual memory exhausted: can't allocate %ld bytes."),
738 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
742 /* My replacement for the read system call.
743 Used like `read' but keeps going if `read' returns too soon. */
746 myread (int desc
, char *addr
, int len
)
753 val
= read (desc
, addr
, len
);
765 print_spaces (int n
, struct ui_file
*file
)
767 fputs_unfiltered (n_spaces (n
), file
);
770 /* Print a host address. */
773 gdb_print_host_address_1 (const void *addr
, struct ui_file
*stream
)
775 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
781 make_hex_string (const gdb_byte
*data
, size_t length
)
783 char *result
= (char *) xmalloc (length
* 2 + 1);
788 for (i
= 0; i
< length
; ++i
)
789 p
+= xsnprintf (p
, 3, "%02x", data
[i
]);
796 /* An RAII class that sets up to handle input and then tears down
797 during destruction. */
799 class scoped_input_handler
803 scoped_input_handler ()
804 : m_quit_handler (&quit_handler
, default_quit_handler
),
807 target_terminal::ours ();
808 ui_register_input_event_handler (current_ui
);
809 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
813 ~scoped_input_handler ()
816 ui_unregister_input_event_handler (m_ui
);
819 DISABLE_COPY_AND_ASSIGN (scoped_input_handler
);
823 /* Save and restore the terminal state. */
824 target_terminal::scoped_restore_terminal_state m_term_state
;
826 /* Save and restore the quit handler. */
827 scoped_restore_tmpl
<quit_handler_ftype
*> m_quit_handler
;
829 /* The saved UI, if non-NULL. */
835 /* This function supports the query, nquery, and yquery functions.
836 Ask user a y-or-n question and return 0 if answer is no, 1 if
837 answer is yes, or default the answer to the specified default
838 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
839 default answer, or '\0' for no default.
840 CTLSTR is the control string and should end in "? ". It should
841 not say how to answer, because we do that.
842 ARGS are the arguments passed along with the CTLSTR argument to
845 static int ATTRIBUTE_PRINTF (1, 0)
846 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
850 char def_answer
, not_def_answer
;
851 const char *y_string
, *n_string
;
853 /* Set up according to which answer is the default. */
858 not_def_answer
= 'N';
862 else if (defchar
== 'y')
866 not_def_answer
= 'N';
874 not_def_answer
= 'Y';
879 /* Automatically answer the default value if the user did not want
880 prompts or the command was issued with the server prefix. */
881 if (!confirm
|| server_command
)
884 /* If input isn't coming from the user directly, just say what
885 question we're asking, and then answer the default automatically. This
886 way, important error messages don't get lost when talking to GDB
888 if (current_ui
->instream
!= current_ui
->stdin_stream
889 || !input_interactive_p (current_ui
)
890 /* Restrict queries to the main UI. */
891 || current_ui
!= main_ui
)
893 target_terminal::scoped_restore_terminal_state term_state
;
894 target_terminal::ours_for_output ();
896 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
898 printf_filtered (_("(%s or %s) [answered %c; "
899 "input not from terminal]\n"),
900 y_string
, n_string
, def_answer
);
901 gdb_flush (gdb_stdout
);
906 if (deprecated_query_hook
)
908 target_terminal::scoped_restore_terminal_state term_state
;
909 return deprecated_query_hook (ctlstr
, args
);
912 /* Format the question outside of the loop, to avoid reusing args. */
913 std::string question
= string_vprintf (ctlstr
, args
);
915 = string_printf (_("%s%s(%s or %s) %s"),
916 annotation_level
> 1 ? "\n\032\032pre-query\n" : "",
917 question
.c_str (), y_string
, n_string
,
918 annotation_level
> 1 ? "\n\032\032query\n" : "");
920 /* Used to add duration we waited for user to respond to
921 prompt_for_continue_wait_time. */
922 using namespace std::chrono
;
923 steady_clock::time_point prompt_started
= steady_clock::now ();
925 scoped_input_handler prepare_input
;
929 char *response
, answer
;
931 gdb_flush (gdb_stdout
);
932 response
= gdb_readline_wrapper (prompt
.c_str ());
934 if (response
== NULL
) /* C-d */
936 printf_filtered ("EOF [assumed %c]\n", def_answer
);
941 answer
= response
[0];
946 /* Check answer. For the non-default, the user must specify
947 the non-default explicitly. */
948 if (answer
== not_def_answer
)
953 /* Otherwise, if a default was specified, the user may either
954 specify the required input or have it default by entering
956 if (answer
== def_answer
957 || (defchar
!= '\0' && answer
== '\0'))
962 /* Invalid entries are not defaulted and require another selection. */
963 printf_filtered (_("Please answer %s or %s.\n"),
967 /* Add time spend in this routine to prompt_for_continue_wait_time. */
968 prompt_for_continue_wait_time
+= steady_clock::now () - prompt_started
;
970 if (annotation_level
> 1)
971 printf_filtered (("\n\032\032post-query\n"));
976 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
977 answer is yes, or 0 if answer is defaulted.
978 Takes three args which are given to printf to print the question.
979 The first, a control string, should end in "? ".
980 It should not say how to answer, because we do that. */
983 nquery (const char *ctlstr
, ...)
988 va_start (args
, ctlstr
);
989 ret
= defaulted_query (ctlstr
, 'n', args
);
994 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
995 answer is yes, or 1 if answer is defaulted.
996 Takes three args which are given to printf to print the question.
997 The first, a control string, should end in "? ".
998 It should not say how to answer, because we do that. */
1001 yquery (const char *ctlstr
, ...)
1006 va_start (args
, ctlstr
);
1007 ret
= defaulted_query (ctlstr
, 'y', args
);
1012 /* Ask user a y-or-n question and return 1 iff answer is yes.
1013 Takes three args which are given to printf to print the question.
1014 The first, a control string, should end in "? ".
1015 It should not say how to answer, because we do that. */
1018 query (const char *ctlstr
, ...)
1023 va_start (args
, ctlstr
);
1024 ret
= defaulted_query (ctlstr
, '\0', args
);
1029 /* A helper for parse_escape that converts a host character to a
1030 target character. C is the host character. If conversion is
1031 possible, then the target character is stored in *TARGET_C and the
1032 function returns 1. Otherwise, the function returns 0. */
1035 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1040 auto_obstack host_data
;
1042 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1043 (gdb_byte
*) &the_char
, 1, 1,
1044 &host_data
, translit_none
);
1046 if (obstack_object_size (&host_data
) == 1)
1049 *target_c
= *(char *) obstack_base (&host_data
);
1055 /* Parse a C escape sequence. STRING_PTR points to a variable
1056 containing a pointer to the string to parse. That pointer
1057 should point to the character after the \. That pointer
1058 is updated past the characters we use. The value of the
1059 escape sequence is returned.
1061 A negative value means the sequence \ newline was seen,
1062 which is supposed to be equivalent to nothing at all.
1064 If \ is followed by a null character, we return a negative
1065 value and leave the string pointer pointing at the null character.
1067 If \ is followed by 000, we return 0 and leave the string pointer
1068 after the zeros. A value of 0 does not mean end of string. */
1071 parse_escape (struct gdbarch
*gdbarch
, const char **string_ptr
)
1073 int target_char
= -2; /* Initialize to avoid GCC warnings. */
1074 int c
= *(*string_ptr
)++;
1093 int i
= host_hex_value (c
);
1098 if (isdigit (c
) && c
!= '8' && c
!= '9')
1102 i
+= host_hex_value (c
);
1138 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1139 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1140 " which has no equivalent\nin the `%s' character set."),
1141 c
, c
, target_charset (gdbarch
));
1145 /* Print the character C on STREAM as part of the contents of a literal
1146 string whose delimiter is QUOTER. Note that this routine should only
1147 be called for printing things which are independent of the language
1148 of the program being debugged.
1150 printchar will normally escape backslashes and instances of QUOTER. If
1151 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1152 As a side effect, if you pass the backslash character as the QUOTER,
1153 printchar will escape backslashes as usual, but not any other quoting
1157 printchar (int c
, do_fputc_ftype do_fputc
, ui_file
*stream
, int quoter
)
1159 c
&= 0xFF; /* Avoid sign bit follies */
1161 if (c
< 0x20 || /* Low control chars */
1162 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1163 (sevenbit_strings
&& c
>= 0x80))
1164 { /* high order bit set */
1165 do_fputc ('\\', stream
);
1170 do_fputc ('n', stream
);
1173 do_fputc ('b', stream
);
1176 do_fputc ('t', stream
);
1179 do_fputc ('f', stream
);
1182 do_fputc ('r', stream
);
1185 do_fputc ('e', stream
);
1188 do_fputc ('a', stream
);
1192 do_fputc ('0' + ((c
>> 6) & 0x7), stream
);
1193 do_fputc ('0' + ((c
>> 3) & 0x7), stream
);
1194 do_fputc ('0' + ((c
>> 0) & 0x7), stream
);
1201 if (quoter
!= 0 && (c
== '\\' || c
== quoter
))
1202 do_fputc ('\\', stream
);
1203 do_fputc (c
, stream
);
1207 /* Print the character C on STREAM as part of the contents of a
1208 literal string whose delimiter is QUOTER. Note that these routines
1209 should only be call for printing things which are independent of
1210 the language of the program being debugged. */
1213 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1216 printchar (*str
++, fputc_filtered
, stream
, quoter
);
1220 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1223 printchar (*str
++, fputc_unfiltered
, stream
, quoter
);
1227 fputstrn_filtered (const char *str
, int n
, int quoter
,
1228 struct ui_file
*stream
)
1230 for (int i
= 0; i
< n
; i
++)
1231 printchar (str
[i
], fputc_filtered
, stream
, quoter
);
1235 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1236 do_fputc_ftype do_fputc
, struct ui_file
*stream
)
1238 for (int i
= 0; i
< n
; i
++)
1239 printchar (str
[i
], do_fputc
, stream
, quoter
);
1243 /* Number of lines per page or UINT_MAX if paging is disabled. */
1244 static unsigned int lines_per_page
;
1246 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1247 struct cmd_list_element
*c
, const char *value
)
1249 fprintf_filtered (file
,
1250 _("Number of lines gdb thinks are in a page is %s.\n"),
1254 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1255 static unsigned int chars_per_line
;
1257 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1258 struct cmd_list_element
*c
, const char *value
)
1260 fprintf_filtered (file
,
1261 _("Number of characters gdb thinks "
1262 "are in a line is %s.\n"),
1266 /* Current count of lines printed on this page, chars on this line. */
1267 static unsigned int lines_printed
, chars_printed
;
1269 /* True if pagination is disabled for just one command. */
1271 static bool pagination_disabled_for_command
;
1273 /* Buffer and start column of buffered text, for doing smarter word-
1274 wrapping. When someone calls wrap_here(), we start buffering output
1275 that comes through fputs_filtered(). If we see a newline, we just
1276 spit it out and forget about the wrap_here(). If we see another
1277 wrap_here(), we spit it out and remember the newer one. If we see
1278 the end of the line, we spit out a newline, the indent, and then
1279 the buffered output. */
1281 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1282 are waiting to be output (they have already been counted in chars_printed).
1283 When wrap_buffer[0] is null, the buffer is empty. */
1284 static char *wrap_buffer
;
1286 /* Pointer in wrap_buffer to the next character to fill. */
1287 static char *wrap_pointer
;
1289 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1291 static const char *wrap_indent
;
1293 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1294 is not in effect. */
1295 static int wrap_column
;
1298 /* Initialize the number of lines per page and chars per line. */
1301 init_page_info (void)
1305 lines_per_page
= UINT_MAX
;
1306 chars_per_line
= UINT_MAX
;
1310 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1315 #if defined(__GO32__)
1316 rows
= ScreenRows ();
1317 cols
= ScreenCols ();
1318 lines_per_page
= rows
;
1319 chars_per_line
= cols
;
1321 /* Make sure Readline has initialized its terminal settings. */
1322 rl_reset_terminal (NULL
);
1324 /* Get the screen size from Readline. */
1325 rl_get_screen_size (&rows
, &cols
);
1326 lines_per_page
= rows
;
1327 chars_per_line
= cols
;
1329 /* Readline should have fetched the termcap entry for us.
1330 Only try to use tgetnum function if rl_get_screen_size
1331 did not return a useful value. */
1332 if (((rows
<= 0) && (tgetnum ((char *) "li") < 0))
1333 /* Also disable paging if inside Emacs. $EMACS was used
1334 before Emacs v25.1, $INSIDE_EMACS is used since then. */
1335 || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1337 /* The number of lines per page is not mentioned in the terminal
1338 description or EMACS evironment variable is set. This probably
1339 means that paging is not useful, so disable paging. */
1340 lines_per_page
= UINT_MAX
;
1343 /* If the output is not a terminal, don't paginate it. */
1344 if (!ui_file_isatty (gdb_stdout
))
1345 lines_per_page
= UINT_MAX
;
1349 /* We handle SIGWINCH ourselves. */
1350 rl_catch_sigwinch
= 0;
1356 /* Return nonzero if filtered printing is initialized. */
1358 filtered_printing_initialized (void)
1360 return wrap_buffer
!= NULL
;
1363 set_batch_flag_and_restore_page_info::set_batch_flag_and_restore_page_info ()
1364 : m_save_lines_per_page (lines_per_page
),
1365 m_save_chars_per_line (chars_per_line
),
1366 m_save_batch_flag (batch_flag
)
1372 set_batch_flag_and_restore_page_info::~set_batch_flag_and_restore_page_info ()
1374 batch_flag
= m_save_batch_flag
;
1375 chars_per_line
= m_save_chars_per_line
;
1376 lines_per_page
= m_save_lines_per_page
;
1382 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1385 set_screen_size (void)
1387 int rows
= lines_per_page
;
1388 int cols
= chars_per_line
;
1396 /* Update Readline's idea of the terminal size. */
1397 rl_set_screen_size (rows
, cols
);
1400 /* Reinitialize WRAP_BUFFER according to the current value of
1406 if (chars_per_line
== 0)
1411 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1412 wrap_buffer
[0] = '\0';
1415 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1416 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1420 set_width_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1427 set_height_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1435 set_screen_width_and_height (int width
, int height
)
1437 lines_per_page
= height
;
1438 chars_per_line
= width
;
1444 /* Wait, so the user can read what's on the screen. Prompt the user
1445 to continue by pressing RETURN. 'q' is also provided because
1446 telling users what to do in the prompt is more user-friendly than
1447 expecting them to think of Ctrl-C/SIGINT. */
1450 prompt_for_continue (void)
1452 char cont_prompt
[120];
1453 /* Used to add duration we waited for user to respond to
1454 prompt_for_continue_wait_time. */
1455 using namespace std::chrono
;
1456 steady_clock::time_point prompt_started
= steady_clock::now ();
1457 bool disable_pagination
= pagination_disabled_for_command
;
1459 if (annotation_level
> 1)
1460 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1462 strcpy (cont_prompt
,
1463 "--Type <RET> for more, q to quit, "
1464 "c to continue without paging--");
1465 if (annotation_level
> 1)
1466 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1468 /* We must do this *before* we call gdb_readline_wrapper, else it
1469 will eventually call us -- thinking that we're trying to print
1470 beyond the end of the screen. */
1471 reinitialize_more_filter ();
1473 scoped_input_handler prepare_input
;
1475 /* Call gdb_readline_wrapper, not readline, in order to keep an
1476 event loop running. */
1477 gdb::unique_xmalloc_ptr
<char> ignore (gdb_readline_wrapper (cont_prompt
));
1479 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1480 prompt_for_continue_wait_time
+= steady_clock::now () - prompt_started
;
1482 if (annotation_level
> 1)
1483 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1487 char *p
= ignore
.get ();
1489 while (*p
== ' ' || *p
== '\t')
1492 /* Do not call quit here; there is no possibility of SIGINT. */
1493 throw_quit ("Quit");
1495 disable_pagination
= true;
1498 /* Now we have to do this again, so that GDB will know that it doesn't
1499 need to save the ---Type <return>--- line at the top of the screen. */
1500 reinitialize_more_filter ();
1501 pagination_disabled_for_command
= disable_pagination
;
1503 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1506 /* Initialize timer to keep track of how long we waited for the user. */
1509 reset_prompt_for_continue_wait_time (void)
1511 using namespace std::chrono
;
1513 prompt_for_continue_wait_time
= steady_clock::duration::zero ();
1516 /* Fetch the cumulative time spent in prompt_for_continue. */
1518 std::chrono::steady_clock::duration
1519 get_prompt_for_continue_wait_time ()
1521 return prompt_for_continue_wait_time
;
1524 /* Reinitialize filter; ie. tell it to reset to original values. */
1527 reinitialize_more_filter (void)
1531 pagination_disabled_for_command
= false;
1534 /* Indicate that if the next sequence of characters overflows the line,
1535 a newline should be inserted here rather than when it hits the end.
1536 If INDENT is non-null, it is a string to be printed to indent the
1537 wrapped part on the next line. INDENT must remain accessible until
1538 the next call to wrap_here() or until a newline is printed through
1541 If the line is already overfull, we immediately print a newline and
1542 the indentation, and disable further wrapping.
1544 If we don't know the width of lines, but we know the page height,
1545 we must not wrap words, but should still keep track of newlines
1546 that were explicitly printed.
1548 INDENT should not contain tabs, as that will mess up the char count
1549 on the next line. FIXME.
1551 This routine is guaranteed to force out any output which has been
1552 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1553 used to force out output from the wrap_buffer. */
1556 wrap_here (const char *indent
)
1558 /* This should have been allocated, but be paranoid anyway. */
1560 internal_error (__FILE__
, __LINE__
,
1561 _("failed internal consistency check"));
1565 *wrap_pointer
= '\0';
1566 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1568 wrap_pointer
= wrap_buffer
;
1569 wrap_buffer
[0] = '\0';
1570 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
1574 else if (chars_printed
>= chars_per_line
)
1576 puts_filtered ("\n");
1578 puts_filtered (indent
);
1583 wrap_column
= chars_printed
;
1587 wrap_indent
= indent
;
1591 /* Print input string to gdb_stdout, filtered, with wrap,
1592 arranging strings in columns of n chars. String can be
1593 right or left justified in the column. Never prints
1594 trailing spaces. String should never be longer than
1595 width. FIXME: this could be useful for the EXAMINE
1596 command, which currently doesn't tabulate very well. */
1599 puts_filtered_tabular (char *string
, int width
, int right
)
1605 gdb_assert (chars_per_line
> 0);
1606 if (chars_per_line
== UINT_MAX
)
1608 fputs_filtered (string
, gdb_stdout
);
1609 fputs_filtered ("\n", gdb_stdout
);
1613 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1614 fputs_filtered ("\n", gdb_stdout
);
1616 if (width
>= chars_per_line
)
1617 width
= chars_per_line
- 1;
1619 stringlen
= strlen (string
);
1621 if (chars_printed
> 0)
1622 spaces
= width
- (chars_printed
- 1) % width
- 1;
1624 spaces
+= width
- stringlen
;
1626 spacebuf
= (char *) alloca (spaces
+ 1);
1627 spacebuf
[spaces
] = '\0';
1629 spacebuf
[spaces
] = ' ';
1631 fputs_filtered (spacebuf
, gdb_stdout
);
1632 fputs_filtered (string
, gdb_stdout
);
1636 /* Ensure that whatever gets printed next, using the filtered output
1637 commands, starts at the beginning of the line. I.e. if there is
1638 any pending output for the current line, flush it and start a new
1639 line. Otherwise do nothing. */
1644 if (chars_printed
> 0)
1646 puts_filtered ("\n");
1651 /* Like fputs but if FILTER is true, pause after every screenful.
1653 Regardless of FILTER can wrap at points other than the final
1654 character of a line.
1656 Unlike fputs, fputs_maybe_filtered does not return a value.
1657 It is OK for LINEBUFFER to be NULL, in which case just don't print
1660 Note that a longjmp to top level may occur in this routine (only if
1661 FILTER is true) (since prompt_for_continue may do so) so this
1662 routine should not be called when cleanups are not in place. */
1665 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1668 const char *lineptr
;
1670 if (linebuffer
== 0)
1673 /* Don't do any filtering if it is disabled. */
1674 if (stream
!= gdb_stdout
1675 || !pagination_enabled
1676 || pagination_disabled_for_command
1678 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
1679 || top_level_interpreter () == NULL
1680 || top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ())
1682 fputs_unfiltered (linebuffer
, stream
);
1686 /* Go through and output each character. Show line extension
1687 when this is necessary; prompt user for new page when this is
1690 lineptr
= linebuffer
;
1693 /* Possible new page. Note that PAGINATION_DISABLED_FOR_COMMAND
1694 might be set during this loop, so we must continue to check
1696 if (filter
&& (lines_printed
>= lines_per_page
- 1)
1697 && !pagination_disabled_for_command
)
1698 prompt_for_continue ();
1700 while (*lineptr
&& *lineptr
!= '\n')
1702 /* Print a single line. */
1703 if (*lineptr
== '\t')
1706 *wrap_pointer
++ = '\t';
1708 fputc_unfiltered ('\t', stream
);
1709 /* Shifting right by 3 produces the number of tab stops
1710 we have already passed, and then adding one and
1711 shifting left 3 advances to the next tab stop. */
1712 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1718 *wrap_pointer
++ = *lineptr
;
1720 fputc_unfiltered (*lineptr
, stream
);
1725 if (chars_printed
>= chars_per_line
)
1727 unsigned int save_chars
= chars_printed
;
1731 /* If we aren't actually wrapping, don't output newline --
1732 if chars_per_line is right, we probably just overflowed
1733 anyway; if it's wrong, let us keep going. */
1735 fputc_unfiltered ('\n', stream
);
1737 /* Possible new page. Note that
1738 PAGINATION_DISABLED_FOR_COMMAND might be set during
1739 this loop, so we must continue to check it here. */
1740 if (lines_printed
>= lines_per_page
- 1
1741 && !pagination_disabled_for_command
)
1742 prompt_for_continue ();
1744 /* Now output indentation and wrapped string. */
1747 fputs_unfiltered (wrap_indent
, stream
);
1748 *wrap_pointer
= '\0'; /* Null-terminate saved stuff, */
1749 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it. */
1750 /* FIXME, this strlen is what prevents wrap_indent from
1751 containing tabs. However, if we recurse to print it
1752 and count its chars, we risk trouble if wrap_indent is
1753 longer than (the user settable) chars_per_line.
1754 Note also that this can set chars_printed > chars_per_line
1755 if we are printing a long string. */
1756 chars_printed
= strlen (wrap_indent
)
1757 + (save_chars
- wrap_column
);
1758 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1759 wrap_buffer
[0] = '\0';
1760 wrap_column
= 0; /* And disable fancy wrap */
1765 if (*lineptr
== '\n')
1768 wrap_here ((char *) 0); /* Spit out chars, cancel
1771 fputc_unfiltered ('\n', stream
);
1778 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1780 fputs_maybe_filtered (linebuffer
, stream
, 1);
1784 putchar_unfiltered (int c
)
1788 ui_file_write (gdb_stdout
, &buf
, 1);
1792 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1793 May return nonlocally. */
1796 putchar_filtered (int c
)
1798 return fputc_filtered (c
, gdb_stdout
);
1802 fputc_unfiltered (int c
, struct ui_file
*stream
)
1806 ui_file_write (stream
, &buf
, 1);
1811 fputc_filtered (int c
, struct ui_file
*stream
)
1817 fputs_filtered (buf
, stream
);
1821 /* puts_debug is like fputs_unfiltered, except it prints special
1822 characters in printable fashion. */
1825 puts_debug (char *prefix
, char *string
, char *suffix
)
1829 /* Print prefix and suffix after each line. */
1830 static int new_line
= 1;
1831 static int return_p
= 0;
1832 static const char *prev_prefix
= "";
1833 static const char *prev_suffix
= "";
1835 if (*string
== '\n')
1838 /* If the prefix is changing, print the previous suffix, a new line,
1839 and the new prefix. */
1840 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
1842 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
1843 fputs_unfiltered ("\n", gdb_stdlog
);
1844 fputs_unfiltered (prefix
, gdb_stdlog
);
1847 /* Print prefix if we printed a newline during the previous call. */
1851 fputs_unfiltered (prefix
, gdb_stdlog
);
1854 prev_prefix
= prefix
;
1855 prev_suffix
= suffix
;
1857 /* Output characters in a printable format. */
1858 while ((ch
= *string
++) != '\0')
1864 fputc_unfiltered (ch
, gdb_stdlog
);
1867 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
1871 fputs_unfiltered ("\\\\", gdb_stdlog
);
1874 fputs_unfiltered ("\\b", gdb_stdlog
);
1877 fputs_unfiltered ("\\f", gdb_stdlog
);
1881 fputs_unfiltered ("\\n", gdb_stdlog
);
1884 fputs_unfiltered ("\\r", gdb_stdlog
);
1887 fputs_unfiltered ("\\t", gdb_stdlog
);
1890 fputs_unfiltered ("\\v", gdb_stdlog
);
1894 return_p
= ch
== '\r';
1897 /* Print suffix if we printed a newline. */
1900 fputs_unfiltered (suffix
, gdb_stdlog
);
1901 fputs_unfiltered ("\n", gdb_stdlog
);
1906 /* Print a variable number of ARGS using format FORMAT. If this
1907 information is going to put the amount written (since the last call
1908 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1909 call prompt_for_continue to get the users permision to continue.
1911 Unlike fprintf, this function does not return a value.
1913 We implement three variants, vfprintf (takes a vararg list and stream),
1914 fprintf (takes a stream to write on), and printf (the usual).
1916 Note also that a longjmp to top level may occur in this routine
1917 (since prompt_for_continue may do so) so this routine should not be
1918 called when cleanups are not in place. */
1921 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
1922 va_list args
, int filter
)
1924 std::string linebuffer
= string_vprintf (format
, args
);
1925 fputs_maybe_filtered (linebuffer
.c_str (), stream
, filter
);
1930 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
1932 vfprintf_maybe_filtered (stream
, format
, args
, 1);
1936 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
1938 std::string linebuffer
= string_vprintf (format
, args
);
1939 if (debug_timestamp
&& stream
== gdb_stdlog
)
1941 using namespace std::chrono
;
1944 steady_clock::time_point now
= steady_clock::now ();
1945 seconds s
= duration_cast
<seconds
> (now
.time_since_epoch ());
1946 microseconds us
= duration_cast
<microseconds
> (now
.time_since_epoch () - s
);
1948 len
= linebuffer
.size ();
1949 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
1951 std::string timestamp
= string_printf ("%ld.%06ld %s%s",
1954 linebuffer
.c_str (),
1955 need_nl
? "\n": "");
1956 fputs_unfiltered (timestamp
.c_str (), stream
);
1959 fputs_unfiltered (linebuffer
.c_str (), stream
);
1963 vprintf_filtered (const char *format
, va_list args
)
1965 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
1969 vprintf_unfiltered (const char *format
, va_list args
)
1971 vfprintf_unfiltered (gdb_stdout
, format
, args
);
1975 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
1979 va_start (args
, format
);
1980 vfprintf_filtered (stream
, format
, args
);
1985 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
1989 va_start (args
, format
);
1990 vfprintf_unfiltered (stream
, format
, args
);
1994 /* Like fprintf_filtered, but prints its result indented.
1995 Called as fprintfi_filtered (spaces, stream, format, ...); */
1998 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2003 va_start (args
, format
);
2004 print_spaces_filtered (spaces
, stream
);
2006 vfprintf_filtered (stream
, format
, args
);
2012 printf_filtered (const char *format
, ...)
2016 va_start (args
, format
);
2017 vfprintf_filtered (gdb_stdout
, format
, args
);
2023 printf_unfiltered (const char *format
, ...)
2027 va_start (args
, format
);
2028 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2032 /* Like printf_filtered, but prints it's result indented.
2033 Called as printfi_filtered (spaces, format, ...); */
2036 printfi_filtered (int spaces
, const char *format
, ...)
2040 va_start (args
, format
);
2041 print_spaces_filtered (spaces
, gdb_stdout
);
2042 vfprintf_filtered (gdb_stdout
, format
, args
);
2046 /* Easy -- but watch out!
2048 This routine is *not* a replacement for puts()! puts() appends a newline.
2049 This one doesn't, and had better not! */
2052 puts_filtered (const char *string
)
2054 fputs_filtered (string
, gdb_stdout
);
2058 puts_unfiltered (const char *string
)
2060 fputs_unfiltered (string
, gdb_stdout
);
2063 /* Return a pointer to N spaces and a null. The pointer is good
2064 until the next call to here. */
2069 static char *spaces
= 0;
2070 static int max_spaces
= -1;
2076 spaces
= (char *) xmalloc (n
+ 1);
2077 for (t
= spaces
+ n
; t
!= spaces
;)
2083 return spaces
+ max_spaces
- n
;
2086 /* Print N spaces. */
2088 print_spaces_filtered (int n
, struct ui_file
*stream
)
2090 fputs_filtered (n_spaces (n
), stream
);
2093 /* C++/ObjC demangler stuff. */
2095 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2096 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2097 If the name is not mangled, or the language for the name is unknown, or
2098 demangling is off, the name is printed in its "raw" form. */
2101 fprintf_symbol_filtered (struct ui_file
*stream
, const char *name
,
2102 enum language lang
, int arg_mode
)
2108 /* If user wants to see raw output, no problem. */
2111 fputs_filtered (name
, stream
);
2115 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2116 fputs_filtered (demangled
? demangled
: name
, stream
);
2117 if (demangled
!= NULL
)
2125 /* True if CH is a character that can be part of a symbol name. I.e.,
2126 either a number, a letter, or a '_'. */
2129 valid_identifier_name_char (int ch
)
2131 return (isalnum (ch
) || ch
== '_');
2134 /* Skip to end of token, or to END, whatever comes first. Input is
2135 assumed to be a C++ operator name. */
2138 cp_skip_operator_token (const char *token
, const char *end
)
2140 const char *p
= token
;
2141 while (p
!= end
&& !isspace (*p
) && *p
!= '(')
2143 if (valid_identifier_name_char (*p
))
2145 while (p
!= end
&& valid_identifier_name_char (*p
))
2151 /* Note, ordered such that among ops that share a prefix,
2152 longer comes first. This is so that the loop below can
2153 bail on first match. */
2154 static const char *ops
[] =
2160 "-=", "--", "->", "-",
2169 "<<=", "<=", "<<", "<",
2170 ">>=", ">=", ">>", ">",
2174 for (const char *op
: ops
)
2176 size_t oplen
= strlen (op
);
2177 size_t lencmp
= std::min
<size_t> (oplen
, end
- p
);
2179 if (strncmp (p
, op
, lencmp
) == 0)
2182 /* Some unidentified character. Return it. */
2190 /* Advance STRING1/STRING2 past whitespace. */
2193 skip_ws (const char *&string1
, const char *&string2
, const char *end_str2
)
2195 while (isspace (*string1
))
2197 while (string2
< end_str2
&& isspace (*string2
))
2201 /* True if STRING points at the start of a C++ operator name. START
2202 is the start of the string that STRING points to, hence when
2203 reading backwards, we must not read any character before START. */
2206 cp_is_operator (const char *string
, const char *start
)
2208 return ((string
== start
2209 || !valid_identifier_name_char (string
[-1]))
2210 && strncmp (string
, CP_OPERATOR_STR
, CP_OPERATOR_LEN
) == 0
2211 && !valid_identifier_name_char (string
[CP_OPERATOR_LEN
]));
2214 /* If *NAME points at an ABI tag, skip it and return true. Otherwise
2215 leave *NAME unmodified and return false. (see GCC's abi_tag
2216 attribute), such names are demangled as e.g.,
2217 "function[abi:cxx11]()". */
2220 skip_abi_tag (const char **name
)
2222 const char *p
= *name
;
2224 if (startswith (p
, "[abi:"))
2228 while (valid_identifier_name_char (*p
))
2244 strncmp_iw_with_mode (const char *string1
, const char *string2
,
2245 size_t string2_len
, strncmp_iw_mode mode
,
2246 enum language language
,
2247 completion_match_for_lcd
*match_for_lcd
)
2249 const char *string1_start
= string1
;
2250 const char *end_str2
= string2
+ string2_len
;
2251 bool skip_spaces
= true;
2252 bool have_colon_op
= (language
== language_cplus
2253 || language
== language_rust
2254 || language
== language_fortran
);
2259 || ((isspace (*string1
) && !valid_identifier_name_char (*string2
))
2260 || (isspace (*string2
) && !valid_identifier_name_char (*string1
))))
2262 skip_ws (string1
, string2
, end_str2
);
2263 skip_spaces
= false;
2266 /* Skip [abi:cxx11] tags in the symbol name if the lookup name
2267 doesn't include them. E.g.:
2269 string1: function[abi:cxx1](int)
2272 string1: function[abi:cxx1](int)
2273 string2: function(int)
2275 string1: Struct[abi:cxx1]::function()
2276 string2: Struct::function()
2278 string1: function(Struct[abi:cxx1], int)
2279 string2: function(Struct, int)
2281 if (string2
== end_str2
2282 || (*string2
!= '[' && !valid_identifier_name_char (*string2
)))
2284 const char *abi_start
= string1
;
2286 /* There can be more than one tag. */
2287 while (*string1
== '[' && skip_abi_tag (&string1
))
2290 if (match_for_lcd
!= NULL
&& abi_start
!= string1
)
2291 match_for_lcd
->mark_ignored_range (abi_start
, string1
);
2293 while (isspace (*string1
))
2297 if (*string1
== '\0' || string2
== end_str2
)
2300 /* Handle the :: operator. */
2301 if (have_colon_op
&& string1
[0] == ':' && string1
[1] == ':')
2303 if (*string2
!= ':')
2309 if (string2
== end_str2
)
2312 if (*string2
!= ':')
2318 while (isspace (*string1
))
2320 while (string2
< end_str2
&& isspace (*string2
))
2325 /* Handle C++ user-defined operators. */
2326 else if (language
== language_cplus
2329 if (cp_is_operator (string1
, string1_start
))
2331 /* An operator name in STRING1. Check STRING2. */
2333 = std::min
<size_t> (CP_OPERATOR_LEN
, end_str2
- string2
);
2334 if (strncmp (string1
, string2
, cmplen
) != 0)
2340 if (string2
!= end_str2
)
2342 /* Check for "operatorX" in STRING2. */
2343 if (valid_identifier_name_char (*string2
))
2346 skip_ws (string1
, string2
, end_str2
);
2349 /* Handle operator(). */
2350 if (*string1
== '(')
2352 if (string2
== end_str2
)
2354 if (mode
== strncmp_iw_mode::NORMAL
)
2358 /* Don't break for the regular return at the
2359 bottom, because "operator" should not
2360 match "operator()", since this open
2361 parentheses is not the parameter list
2363 return *string1
!= '\0';
2367 if (*string1
!= *string2
)
2376 skip_ws (string1
, string2
, end_str2
);
2378 /* Skip to end of token, or to END, whatever comes
2380 const char *end_str1
= string1
+ strlen (string1
);
2381 const char *p1
= cp_skip_operator_token (string1
, end_str1
);
2382 const char *p2
= cp_skip_operator_token (string2
, end_str2
);
2384 cmplen
= std::min (p1
- string1
, p2
- string2
);
2387 if (strncmp (string1
, string2
, cmplen
) != 0)
2392 if (p1
- string1
!= p2
- string2
)
2394 if (strncmp (string1
, string2
, cmplen
) != 0)
2401 if (*string1
== '\0' || string2
== end_str2
)
2403 if (*string1
== '(' || *string2
== '(')
2411 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
2413 if (case_sensitivity
== case_sensitive_off
2414 && (tolower ((unsigned char) *string1
)
2415 != tolower ((unsigned char) *string2
)))
2418 /* If we see any non-whitespace, non-identifier-name character
2419 (any of "()<>*&" etc.), then skip spaces the next time
2421 if (!isspace (*string1
) && !valid_identifier_name_char (*string1
))
2428 if (string2
== end_str2
)
2430 if (mode
== strncmp_iw_mode::NORMAL
)
2432 /* Strip abi tag markers from the matched symbol name.
2433 Usually the ABI marker will be found on function name
2434 (automatically added because the function returns an
2435 object marked with an ABI tag). However, it's also
2436 possible to see a marker in one of the function
2437 parameters, for example.
2439 string2 (lookup name):
2442 function(some_struct[abi:cxx11], int)
2444 and for completion LCD computation we want to say that
2446 function(some_struct, int)
2448 if (match_for_lcd
!= NULL
)
2450 while ((string1
= strstr (string1
, "[abi:")) != NULL
)
2452 const char *abi_start
= string1
;
2454 /* There can be more than one tag. */
2455 while (skip_abi_tag (&string1
) && *string1
== '[')
2458 if (abi_start
!= string1
)
2459 match_for_lcd
->mark_ignored_range (abi_start
, string1
);
2466 return (*string1
!= '\0' && *string1
!= '(');
2475 strncmp_iw (const char *string1
, const char *string2
, size_t string2_len
)
2477 return strncmp_iw_with_mode (string1
, string2
, string2_len
,
2478 strncmp_iw_mode::NORMAL
, language_minimal
);
2484 strcmp_iw (const char *string1
, const char *string2
)
2486 return strncmp_iw_with_mode (string1
, string2
, strlen (string2
),
2487 strncmp_iw_mode::MATCH_PARAMS
, language_minimal
);
2490 /* This is like strcmp except that it ignores whitespace and treats
2491 '(' as the first non-NULL character in terms of ordering. Like
2492 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2493 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2494 according to that ordering.
2496 If a list is sorted according to this function and if you want to
2497 find names in the list that match some fixed NAME according to
2498 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2499 where this function would put NAME.
2501 This function must be neutral to the CASE_SENSITIVITY setting as the user
2502 may choose it during later lookup. Therefore this function always sorts
2503 primarily case-insensitively and secondarily case-sensitively.
2505 Here are some examples of why using strcmp to sort is a bad idea:
2509 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2510 we try to do a search for "foo<char*>", strcmp will locate this
2511 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2512 will start looking at strings beginning with "goo", and will never
2513 see the correct match of "foo<char *>".
2515 Parenthesis example:
2517 In practice, this is less like to be an issue, but I'll give it a
2518 shot. Let's assume that '$' is a legitimate character to occur in
2519 symbols. (Which may well even be the case on some systems.) Then
2520 say that the partial symbol table contains "foo$" and "foo(int)".
2521 strcmp will put them in this order, since '$' < '('. Now, if the
2522 user searches for "foo", then strcmp will sort "foo" before "foo$".
2523 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2524 "foo") is false, so it won't proceed to the actual match of
2525 "foo(int)" with "foo". */
2528 strcmp_iw_ordered (const char *string1
, const char *string2
)
2530 const char *saved_string1
= string1
, *saved_string2
= string2
;
2531 enum case_sensitivity case_pass
= case_sensitive_off
;
2535 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2536 Provide stub characters if we are already at the end of one of the
2538 char c1
= 'X', c2
= 'X';
2540 while (*string1
!= '\0' && *string2
!= '\0')
2542 while (isspace (*string1
))
2544 while (isspace (*string2
))
2549 case case_sensitive_off
:
2550 c1
= tolower ((unsigned char) *string1
);
2551 c2
= tolower ((unsigned char) *string2
);
2553 case case_sensitive_on
:
2561 if (*string1
!= '\0')
2570 /* Characters are non-equal unless they're both '\0'; we want to
2571 make sure we get the comparison right according to our
2572 comparison in the cases where one of them is '\0' or '('. */
2574 if (*string2
== '\0')
2579 if (*string2
== '\0')
2584 if (*string2
== '\0' || *string2
== '(')
2593 if (case_pass
== case_sensitive_on
)
2596 /* Otherwise the strings were equal in case insensitive way, make
2597 a more fine grained comparison in a case sensitive way. */
2599 case_pass
= case_sensitive_on
;
2600 string1
= saved_string1
;
2601 string2
= saved_string2
;
2608 streq (const char *lhs
, const char *rhs
)
2610 return !strcmp (lhs
, rhs
);
2616 streq_hash (const void *lhs
, const void *rhs
)
2618 return streq ((const char *) lhs
, (const char *) rhs
);
2625 ** Answer whether string_to_compare is a full or partial match to
2626 ** template_string. The partial match must be in sequence starting
2630 subset_compare (const char *string_to_compare
, const char *template_string
)
2634 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2635 && strlen (string_to_compare
) <= strlen (template_string
))
2637 (startswith (template_string
, string_to_compare
));
2644 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2645 struct cmd_list_element
*c
, const char *value
)
2647 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
2653 initialize_utils (void)
2655 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2656 Set number of characters where GDB should wrap lines of its output."), _("\
2657 Show number of characters where GDB should wrap lines of its output."), _("\
2658 This affects where GDB wraps its output to fit the screen width.\n\
2659 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2661 show_chars_per_line
,
2662 &setlist
, &showlist
);
2664 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2665 Set number of lines in a page for GDB output pagination."), _("\
2666 Show number of lines in a page for GDB output pagination."), _("\
2667 This affects the number of lines after which GDB will pause\n\
2668 its output and ask you whether to continue.\n\
2669 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2671 show_lines_per_page
,
2672 &setlist
, &showlist
);
2674 add_setshow_boolean_cmd ("pagination", class_support
,
2675 &pagination_enabled
, _("\
2676 Set state of GDB output pagination."), _("\
2677 Show state of GDB output pagination."), _("\
2678 When pagination is ON, GDB pauses at end of each screenful of\n\
2679 its output and asks you whether to continue.\n\
2680 Turning pagination off is an alternative to \"set height unlimited\"."),
2682 show_pagination_enabled
,
2683 &setlist
, &showlist
);
2685 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2686 &sevenbit_strings
, _("\
2687 Set printing of 8-bit characters in strings as \\nnn."), _("\
2688 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2690 show_sevenbit_strings
,
2691 &setprintlist
, &showprintlist
);
2693 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2694 &debug_timestamp
, _("\
2695 Set timestamping of debugging messages."), _("\
2696 Show timestamping of debugging messages."), _("\
2697 When set, debugging messages will be marked with seconds and microseconds."),
2699 show_debug_timestamp
,
2700 &setdebuglist
, &showdebuglist
);
2706 address_significant (gdbarch
*gdbarch
, CORE_ADDR addr
)
2708 /* Clear insignificant bits of a target address and sign extend resulting
2709 address, avoiding shifts larger or equal than the width of a CORE_ADDR.
2710 The local variable ADDR_BIT stops the compiler reporting a shift overflow
2711 when it won't occur. Skip updating of target address if current target
2712 has not set gdbarch significant_addr_bit. */
2713 int addr_bit
= gdbarch_significant_addr_bit (gdbarch
);
2715 if (addr_bit
&& (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
)))
2717 CORE_ADDR sign
= (CORE_ADDR
) 1 << (addr_bit
- 1);
2718 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2719 addr
= (addr
^ sign
) - sign
;
2726 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2728 /* Truncate address to the size of a target address, avoiding shifts
2729 larger or equal than the width of a CORE_ADDR. The local
2730 variable ADDR_BIT stops the compiler reporting a shift overflow
2731 when it won't occur. */
2732 /* NOTE: This assumes that the significant address information is
2733 kept in the least significant bits of ADDR - the upper bits were
2734 either zero or sign extended. Should gdbarch_address_to_pointer or
2735 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2737 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2739 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2740 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2741 return hex_string (addr
);
2744 /* This function is described in "defs.h". */
2747 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2749 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2751 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2752 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2754 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2755 that returns the language localized string formatted to a width
2756 based on gdbarch_addr_bit. */
2758 return hex_string_custom (address
, 8);
2760 return hex_string_custom (address
, 16);
2763 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2766 core_addr_hash (const void *ap
)
2768 const CORE_ADDR
*addrp
= (const CORE_ADDR
*) ap
;
2773 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2776 core_addr_eq (const void *ap
, const void *bp
)
2778 const CORE_ADDR
*addr_ap
= (const CORE_ADDR
*) ap
;
2779 const CORE_ADDR
*addr_bp
= (const CORE_ADDR
*) bp
;
2781 return *addr_ap
== *addr_bp
;
2784 /* Convert a string back into a CORE_ADDR. */
2786 string_to_core_addr (const char *my_string
)
2790 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2792 /* Assume that it is in hex. */
2795 for (i
= 2; my_string
[i
] != '\0'; i
++)
2797 if (isdigit (my_string
[i
]))
2798 addr
= (my_string
[i
] - '0') + (addr
* 16);
2799 else if (isxdigit (my_string
[i
]))
2800 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2802 error (_("invalid hex \"%s\""), my_string
);
2807 /* Assume that it is in decimal. */
2810 for (i
= 0; my_string
[i
] != '\0'; i
++)
2812 if (isdigit (my_string
[i
]))
2813 addr
= (my_string
[i
] - '0') + (addr
* 10);
2815 error (_("invalid decimal \"%s\""), my_string
);
2825 gdb_realpath_check_trailer (const char *input
, const char *trailer
)
2827 gdb::unique_xmalloc_ptr
<char> result
= gdb_realpath (input
);
2829 size_t len
= strlen (result
.get ());
2830 size_t trail_len
= strlen (trailer
);
2832 SELF_CHECK (len
>= trail_len
2833 && strcmp (result
.get () + len
- trail_len
, trailer
) == 0);
2837 gdb_realpath_tests ()
2839 /* A file which contains a directory prefix. */
2840 gdb_realpath_check_trailer ("./xfullpath.exp", "/xfullpath.exp");
2841 /* A file which contains a directory prefix. */
2842 gdb_realpath_check_trailer ("../../defs.h", "/defs.h");
2843 /* A one-character filename. */
2844 gdb_realpath_check_trailer ("./a", "/a");
2845 /* A file in the root directory. */
2846 gdb_realpath_check_trailer ("/root_file_which_should_exist",
2847 "/root_file_which_should_exist");
2848 /* A file which does not have a directory prefix. */
2849 gdb_realpath_check_trailer ("xfullpath.exp", "xfullpath.exp");
2850 /* A one-char filename without any directory prefix. */
2851 gdb_realpath_check_trailer ("a", "a");
2852 /* An empty filename. */
2853 gdb_realpath_check_trailer ("", "");
2856 #endif /* GDB_SELF_TEST */
2858 /* Allocation function for the libiberty hash table which uses an
2859 obstack. The obstack is passed as DATA. */
2862 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
2864 size_t total
= size
* count
;
2865 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
2867 memset (ptr
, 0, total
);
2871 /* Trivial deallocation function for the libiberty splay tree and hash
2872 table - don't deallocate anything. Rely on later deletion of the
2873 obstack. DATA will be the obstack, although it is not needed
2877 dummy_obstack_deallocate (void *object
, void *data
)
2882 /* Simple, portable version of dirname that does not modify its
2886 ldirname (const char *filename
)
2888 std::string dirname
;
2889 const char *base
= lbasename (filename
);
2891 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
2894 if (base
== filename
)
2897 dirname
= std::string (filename
, base
- filename
);
2899 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
2900 create "d:./bar" later instead of the (different) "d:/bar". */
2901 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
2902 && !IS_DIR_SEPARATOR (filename
[0]))
2903 dirname
[base
++ - filename
] = '.';
2911 gdb_argv::reset (const char *s
)
2913 char **argv
= buildargv (s
);
2915 if (s
!= NULL
&& argv
== NULL
)
2923 compare_positive_ints (const void *ap
, const void *bp
)
2925 /* Because we know we're comparing two ints which are positive,
2926 there's no danger of overflow here. */
2927 return * (int *) ap
- * (int *) bp
;
2930 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
2931 #define AMBIGUOUS_MESS2 \
2932 ".\nUse \"set gnutarget format-name\" to specify the format."
2935 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
2941 /* Check if errmsg just need simple return. */
2942 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
2943 return bfd_errmsg (error_tag
);
2945 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
2946 + strlen (AMBIGUOUS_MESS2
);
2947 for (p
= matching
; *p
; p
++)
2948 ret_len
+= strlen (*p
) + 1;
2949 ret
= (char *) xmalloc (ret_len
+ 1);
2951 make_cleanup (xfree
, ret
);
2953 strcpy (retp
, bfd_errmsg (error_tag
));
2954 retp
+= strlen (retp
);
2956 strcpy (retp
, AMBIGUOUS_MESS1
);
2957 retp
+= strlen (retp
);
2959 for (p
= matching
; *p
; p
++)
2961 sprintf (retp
, " %s", *p
);
2962 retp
+= strlen (retp
);
2966 strcpy (retp
, AMBIGUOUS_MESS2
);
2971 /* Return ARGS parsed as a valid pid, or throw an error. */
2974 parse_pid_to_attach (const char *args
)
2980 error_no_arg (_("process-id to attach"));
2982 dummy
= (char *) args
;
2983 pid
= strtoul (args
, &dummy
, 0);
2984 /* Some targets don't set errno on errors, grrr! */
2985 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
2986 error (_("Illegal process-id: %s."), args
);
2991 /* Helper for make_bpstat_clear_actions_cleanup. */
2994 do_bpstat_clear_actions_cleanup (void *unused
)
2996 bpstat_clear_actions ();
2999 /* Call bpstat_clear_actions for the case an exception is throw. You should
3000 discard_cleanups if no exception is caught. */
3003 make_bpstat_clear_actions_cleanup (void)
3005 return make_cleanup (do_bpstat_clear_actions_cleanup
, NULL
);
3008 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3009 must come from xrealloc-compatible allocator and it may be updated. FROM
3010 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3011 located at the start or end of *STRINGP. */
3014 substitute_path_component (char **stringp
, const char *from
, const char *to
)
3016 char *string
= *stringp
, *s
;
3017 const size_t from_len
= strlen (from
);
3018 const size_t to_len
= strlen (to
);
3022 s
= strstr (s
, from
);
3026 if ((s
== string
|| IS_DIR_SEPARATOR (s
[-1])
3027 || s
[-1] == DIRNAME_SEPARATOR
)
3028 && (s
[from_len
] == '\0' || IS_DIR_SEPARATOR (s
[from_len
])
3029 || s
[from_len
] == DIRNAME_SEPARATOR
))
3034 = (char *) xrealloc (string
, (strlen (string
) + to_len
+ 1));
3036 /* Relocate the current S pointer. */
3037 s
= s
- string
+ string_new
;
3038 string
= string_new
;
3040 /* Replace from by to. */
3041 memmove (&s
[to_len
], &s
[from_len
], strlen (&s
[from_len
]) + 1);
3042 memcpy (s
, to
, to_len
);
3057 /* SIGALRM handler for waitpid_with_timeout. */
3060 sigalrm_handler (int signo
)
3062 /* Nothing to do. */
3067 /* Wrapper to wait for child PID to die with TIMEOUT.
3068 TIMEOUT is the time to stop waiting in seconds.
3069 If TIMEOUT is zero, pass WNOHANG to waitpid.
3070 Returns PID if it was successfully waited for, otherwise -1.
3072 Timeouts are currently implemented with alarm and SIGALRM.
3073 If the host does not support them, this waits "forever".
3074 It would be odd though for a host to have waitpid and not SIGALRM. */
3077 wait_to_die_with_timeout (pid_t pid
, int *status
, int timeout
)
3079 pid_t waitpid_result
;
3081 gdb_assert (pid
> 0);
3082 gdb_assert (timeout
>= 0);
3087 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3088 struct sigaction sa
, old_sa
;
3090 sa
.sa_handler
= sigalrm_handler
;
3091 sigemptyset (&sa
.sa_mask
);
3093 sigaction (SIGALRM
, &sa
, &old_sa
);
3097 ofunc
= signal (SIGALRM
, sigalrm_handler
);
3103 waitpid_result
= waitpid (pid
, status
, 0);
3107 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3108 sigaction (SIGALRM
, &old_sa
, NULL
);
3110 signal (SIGALRM
, ofunc
);
3115 waitpid_result
= waitpid (pid
, status
, WNOHANG
);
3117 if (waitpid_result
== pid
)
3123 #endif /* HAVE_WAITPID */
3125 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3126 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3128 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3129 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3132 gdb_filename_fnmatch (const char *pattern
, const char *string
, int flags
)
3134 gdb_assert ((flags
& FNM_FILE_NAME
) != 0);
3136 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3137 gdb_assert ((flags
& FNM_NOESCAPE
) != 0);
3139 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3141 char *pattern_slash
, *string_slash
;
3143 /* Replace '\' by '/' in both strings. */
3145 pattern_slash
= (char *) alloca (strlen (pattern
) + 1);
3146 strcpy (pattern_slash
, pattern
);
3147 pattern
= pattern_slash
;
3148 for (; *pattern_slash
!= 0; pattern_slash
++)
3149 if (IS_DIR_SEPARATOR (*pattern_slash
))
3150 *pattern_slash
= '/';
3152 string_slash
= (char *) alloca (strlen (string
) + 1);
3153 strcpy (string_slash
, string
);
3154 string
= string_slash
;
3155 for (; *string_slash
!= 0; string_slash
++)
3156 if (IS_DIR_SEPARATOR (*string_slash
))
3157 *string_slash
= '/';
3159 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3161 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3162 flags
|= FNM_CASEFOLD
;
3163 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3165 return fnmatch (pattern
, string
, flags
);
3168 /* Return the number of path elements in PATH.
3176 count_path_elements (const char *path
)
3179 const char *p
= path
;
3181 if (HAS_DRIVE_SPEC (p
))
3183 p
= STRIP_DRIVE_SPEC (p
);
3189 if (IS_DIR_SEPARATOR (*p
))
3194 /* Backup one if last character is /, unless it's the only one. */
3195 if (p
> path
+ 1 && IS_DIR_SEPARATOR (p
[-1]))
3198 /* Add one for the file name, if present. */
3199 if (p
> path
&& !IS_DIR_SEPARATOR (p
[-1]))
3205 /* Remove N leading path elements from PATH.
3206 N must be non-negative.
3207 If PATH has more than N path elements then return NULL.
3208 If PATH has exactly N path elements then return "".
3209 See count_path_elements for a description of how we do the counting. */
3212 strip_leading_path_elements (const char *path
, int n
)
3215 const char *p
= path
;
3217 gdb_assert (n
>= 0);
3222 if (HAS_DRIVE_SPEC (p
))
3224 p
= STRIP_DRIVE_SPEC (p
);
3230 while (*p
!= '\0' && !IS_DIR_SEPARATOR (*p
))
3246 _initialize_utils (void)
3248 add_internal_problem_command (&internal_error_problem
);
3249 add_internal_problem_command (&internal_warning_problem
);
3250 add_internal_problem_command (&demangler_warning_problem
);
3253 selftests::register_test ("gdb_realpath", gdb_realpath_tests
);