1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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/>. */
22 #include "gdbsupport/gdb_wait.h"
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 "gdbsupport/job-control.h"
69 #include "gdbsupport/selftest.h"
70 #include "gdbsupport/gdb_optional.h"
71 #include "cp-support.h"
73 #include "gdbsupport/pathstuff.h"
74 #include "cli/cli-style.h"
75 #include "gdbsupport/scope-exit.h"
78 void (*deprecated_error_begin_hook
) (void);
80 /* Prototypes for local functions */
82 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
83 va_list, int) ATTRIBUTE_PRINTF (2, 0);
85 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
87 static void prompt_for_continue (void);
89 static void set_screen_size (void);
90 static void set_width (void);
92 /* Time spent in prompt_for_continue in the currently executing command
93 waiting for user to respond.
94 Initialized in make_command_stats_cleanup.
95 Modified in prompt_for_continue and defaulted_query.
96 Used in report_command_stats. */
98 static std::chrono::steady_clock::duration prompt_for_continue_wait_time
;
100 /* A flag indicating whether to timestamp debugging messages. */
102 static bool debug_timestamp
= false;
104 /* True means that strings with character values >0x7F should be printed
105 as octal escapes. False means just print the value (e.g. it's an
106 international character, and the terminal or window can cope.) */
108 bool sevenbit_strings
= false;
110 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
111 struct cmd_list_element
*c
, const char *value
)
113 fprintf_filtered (file
, _("Printing of 8-bit characters "
114 "in strings as \\nnn is %s.\n"),
118 /* String to be printed before warning messages, if any. */
120 const char *warning_pre_print
= "\nwarning: ";
122 bool pagination_enabled
= true;
124 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
125 struct cmd_list_element
*c
, const char *value
)
127 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
133 /* Print a warning message. The first argument STRING is the warning
134 message, used as an fprintf format string, the second is the
135 va_list of arguments for that string. A warning is unfiltered (not
136 paginated) so that the user does not need to page through each
137 screen full of warnings when there are lots of them. */
140 vwarning (const char *string
, va_list args
)
142 if (deprecated_warning_hook
)
143 (*deprecated_warning_hook
) (string
, args
);
146 gdb::optional
<target_terminal::scoped_restore_terminal_state
> term_state
;
147 if (target_supports_terminal_ours ())
149 term_state
.emplace ();
150 target_terminal::ours_for_output ();
152 if (filtered_printing_initialized ())
153 wrap_here (""); /* Force out any buffered output. */
154 gdb_flush (gdb_stdout
);
155 if (warning_pre_print
)
156 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
157 vfprintf_unfiltered (gdb_stderr
, string
, args
);
158 fprintf_unfiltered (gdb_stderr
, "\n");
162 /* Print an error message and return to command level.
163 The first argument STRING is the error message, used as a fprintf string,
164 and the remaining args are passed as arguments to it. */
167 verror (const char *string
, va_list args
)
169 throw_verror (GENERIC_ERROR
, string
, args
);
173 error_stream (const string_file
&stream
)
175 error (("%s"), stream
.c_str ());
178 /* Emit a message and abort. */
180 static void ATTRIBUTE_NORETURN
181 abort_with_message (const char *msg
)
183 if (current_ui
== NULL
)
186 fputs_unfiltered (msg
, gdb_stderr
);
188 abort (); /* NOTE: GDB has only three calls to abort(). */
191 /* Dump core trying to increase the core soft limit to hard limit first. */
196 #ifdef HAVE_SETRLIMIT
197 struct rlimit rlim
= { (rlim_t
) RLIM_INFINITY
, (rlim_t
) RLIM_INFINITY
};
199 setrlimit (RLIMIT_CORE
, &rlim
);
200 #endif /* HAVE_SETRLIMIT */
202 abort (); /* NOTE: GDB has only three calls to abort(). */
205 /* Check whether GDB will be able to dump core using the dump_core
206 function. Returns zero if GDB cannot or should not dump core.
207 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
208 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
211 can_dump_core (enum resource_limit_kind limit_kind
)
213 #ifdef HAVE_GETRLIMIT
216 /* Be quiet and assume we can dump if an error is returned. */
217 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
223 if (rlim
.rlim_cur
== 0)
228 if (rlim
.rlim_max
== 0)
231 #endif /* HAVE_GETRLIMIT */
236 /* Print a warning that we cannot dump core. */
239 warn_cant_dump_core (const char *reason
)
241 fprintf_unfiltered (gdb_stderr
,
242 _("%s\nUnable to dump core, use `ulimit -c"
243 " unlimited' before executing GDB next time.\n"),
247 /* Check whether GDB will be able to dump core using the dump_core
248 function, and print a warning if we cannot. */
251 can_dump_core_warn (enum resource_limit_kind limit_kind
,
254 int core_dump_allowed
= can_dump_core (limit_kind
);
256 if (!core_dump_allowed
)
257 warn_cant_dump_core (reason
);
259 return core_dump_allowed
;
262 /* Allow the user to configure the debugger behavior with respect to
263 what to do when an internal problem is detected. */
265 const char internal_problem_ask
[] = "ask";
266 const char internal_problem_yes
[] = "yes";
267 const char internal_problem_no
[] = "no";
268 static const char *const internal_problem_modes
[] =
270 internal_problem_ask
,
271 internal_problem_yes
,
276 /* Print a message reporting an internal error/warning. Ask the user
277 if they want to continue, dump core, or just exit. Return
278 something to indicate a quit. */
280 struct internal_problem
283 int user_settable_should_quit
;
284 const char *should_quit
;
285 int user_settable_should_dump_core
;
286 const char *should_dump_core
;
289 /* Report a problem, internal to GDB, to the user. Once the problem
290 has been reported, and assuming GDB didn't quit, the caller can
291 either allow execution to resume or throw an error. */
293 static void ATTRIBUTE_PRINTF (4, 0)
294 internal_vproblem (struct internal_problem
*problem
,
295 const char *file
, int line
, const char *fmt
, va_list ap
)
302 /* Don't allow infinite error/warning recursion. */
304 static const char msg
[] = "Recursive internal problem.\n";
313 abort_with_message (msg
);
316 /* Newer GLIBC versions put the warn_unused_result attribute
317 on write, but this is one of those rare cases where
318 ignoring the return value is correct. Casting to (void)
319 does not fix this problem. This is the solution suggested
320 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
321 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
322 abort (); /* NOTE: GDB has only three calls to abort(). */
327 /* Create a string containing the full error/warning message. Need
328 to call query with this full string, as otherwize the reason
329 (error/warning) and question become separated. Format using a
330 style similar to a compiler error message. Include extra detail
331 so that the user knows that they are living on the edge. */
333 std::string msg
= string_vprintf (fmt
, ap
);
334 reason
= string_printf ("%s:%d: %s: %s\n"
335 "A problem internal to GDB has been detected,\n"
336 "further debugging may prove unreliable.",
337 file
, line
, problem
->name
, msg
.c_str ());
340 /* Fall back to abort_with_message if gdb_stderr is not set up. */
341 if (current_ui
== NULL
)
343 fputs (reason
.c_str (), stderr
);
344 abort_with_message ("\n");
347 /* Try to get the message out and at the start of a new line. */
348 gdb::optional
<target_terminal::scoped_restore_terminal_state
> term_state
;
349 if (target_supports_terminal_ours ())
351 term_state
.emplace ();
352 target_terminal::ours_for_output ();
354 if (filtered_printing_initialized ())
357 /* Emit the message unless query will emit it below. */
358 if (problem
->should_quit
!= internal_problem_ask
360 || !filtered_printing_initialized ())
361 fprintf_unfiltered (gdb_stderr
, "%s\n", reason
.c_str ());
363 if (problem
->should_quit
== internal_problem_ask
)
365 /* Default (yes/batch case) is to quit GDB. When in batch mode
366 this lessens the likelihood of GDB going into an infinite
368 if (!confirm
|| !filtered_printing_initialized ())
371 quit_p
= query (_("%s\nQuit this debugging session? "),
374 else if (problem
->should_quit
== internal_problem_yes
)
376 else if (problem
->should_quit
== internal_problem_no
)
379 internal_error (__FILE__
, __LINE__
, _("bad switch"));
381 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr
);
382 if (REPORT_BUGS_TO
[0])
383 fprintf_unfiltered (gdb_stderr
, _(" For instructions, see:\n%s."),
385 fputs_unfiltered ("\n\n", gdb_stderr
);
387 if (problem
->should_dump_core
== internal_problem_ask
)
389 if (!can_dump_core_warn (LIMIT_MAX
, reason
.c_str ()))
391 else if (!filtered_printing_initialized ())
395 /* Default (yes/batch case) is to dump core. This leaves a GDB
396 `dropping' so that it is easier to see that something went
398 dump_core_p
= query (_("%s\nCreate a core file of GDB? "),
402 else if (problem
->should_dump_core
== internal_problem_yes
)
403 dump_core_p
= can_dump_core_warn (LIMIT_MAX
, reason
.c_str ());
404 else if (problem
->should_dump_core
== internal_problem_no
)
407 internal_error (__FILE__
, __LINE__
, _("bad switch"));
420 #ifdef HAVE_WORKING_FORK
430 static struct internal_problem internal_error_problem
= {
431 "internal-error", 1, internal_problem_ask
, 1, internal_problem_ask
435 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
437 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
438 throw_quit (_("Command aborted."));
441 static struct internal_problem internal_warning_problem
= {
442 "internal-warning", 1, internal_problem_ask
, 1, internal_problem_ask
446 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
448 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
451 static struct internal_problem demangler_warning_problem
= {
452 "demangler-warning", 1, internal_problem_ask
, 0, internal_problem_no
456 demangler_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
458 internal_vproblem (&demangler_warning_problem
, file
, line
, fmt
, ap
);
462 demangler_warning (const char *file
, int line
, const char *string
, ...)
466 va_start (ap
, string
);
467 demangler_vwarning (file
, line
, string
, ap
);
471 /* Dummy functions to keep add_prefix_cmd happy. */
474 set_internal_problem_cmd (const char *args
, int from_tty
)
479 show_internal_problem_cmd (const char *args
, int from_tty
)
483 /* When GDB reports an internal problem (error or warning) it gives
484 the user the opportunity to quit GDB and/or create a core file of
485 the current debug session. This function registers a few commands
486 that make it possible to specify that GDB should always or never
487 quit or create a core file, without asking. The commands look
490 maint set PROBLEM-NAME quit ask|yes|no
491 maint show PROBLEM-NAME quit
492 maint set PROBLEM-NAME corefile ask|yes|no
493 maint show PROBLEM-NAME corefile
495 Where PROBLEM-NAME is currently "internal-error" or
496 "internal-warning". */
499 add_internal_problem_command (struct internal_problem
*problem
)
501 struct cmd_list_element
**set_cmd_list
;
502 struct cmd_list_element
**show_cmd_list
;
506 set_cmd_list
= XNEW (struct cmd_list_element
*);
507 show_cmd_list
= XNEW (struct cmd_list_element
*);
508 *set_cmd_list
= NULL
;
509 *show_cmd_list
= NULL
;
511 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
514 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
517 add_prefix_cmd (problem
->name
,
518 class_maintenance
, set_internal_problem_cmd
, set_doc
,
520 concat ("maintenance set ", problem
->name
, " ",
522 0/*allow-unknown*/, &maintenance_set_cmdlist
);
524 add_prefix_cmd (problem
->name
,
525 class_maintenance
, show_internal_problem_cmd
, show_doc
,
527 concat ("maintenance show ", problem
->name
, " ",
529 0/*allow-unknown*/, &maintenance_show_cmdlist
);
531 if (problem
->user_settable_should_quit
)
533 set_doc
= xstrprintf (_("Set whether GDB should quit "
534 "when an %s is detected."),
536 show_doc
= xstrprintf (_("Show whether GDB will quit "
537 "when an %s is detected."),
539 add_setshow_enum_cmd ("quit", class_maintenance
,
540 internal_problem_modes
,
541 &problem
->should_quit
,
554 if (problem
->user_settable_should_dump_core
)
556 set_doc
= xstrprintf (_("Set whether GDB should create a core "
557 "file of GDB when %s is detected."),
559 show_doc
= xstrprintf (_("Show whether GDB will create a core "
560 "file of GDB when %s is detected."),
562 add_setshow_enum_cmd ("corefile", class_maintenance
,
563 internal_problem_modes
,
564 &problem
->should_dump_core
,
578 /* Return a newly allocated string, containing the PREFIX followed
579 by the system error message for errno (separated by a colon). */
582 perror_string (const char *prefix
)
586 err
= safe_strerror (errno
);
587 return std::string (prefix
) + ": " + err
;
590 /* Print the system error message for errno, and also mention STRING
591 as the file name for which the error was encountered. Use ERRCODE
592 for the thrown exception. Then return to command level. */
595 throw_perror_with_name (enum errors errcode
, const char *string
)
597 std::string combined
= perror_string (string
);
599 /* I understand setting these is a matter of taste. Still, some people
600 may clear errno but not know about bfd_error. Doing this here is not
602 bfd_set_error (bfd_error_no_error
);
605 throw_error (errcode
, _("%s."), combined
.c_str ());
608 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
611 perror_with_name (const char *string
)
613 throw_perror_with_name (GENERIC_ERROR
, string
);
616 /* Same as perror_with_name except that it prints a warning instead
617 of throwing an error. */
620 perror_warning_with_name (const char *string
)
622 std::string combined
= perror_string (string
);
623 warning (_("%s"), combined
.c_str ());
626 /* Print the system error message for ERRCODE, and also mention STRING
627 as the file name for which the error was encountered. */
630 print_sys_errmsg (const char *string
, int errcode
)
635 err
= safe_strerror (errcode
);
636 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
637 strcpy (combined
, string
);
638 strcat (combined
, ": ");
639 strcat (combined
, err
);
641 /* We want anything which was printed on stdout to come out first, before
643 gdb_flush (gdb_stdout
);
644 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
647 /* Control C eventually causes this to be called, at a convenient time. */
652 if (sync_quit_force_run
)
654 sync_quit_force_run
= 0;
655 quit_force (NULL
, 0);
659 /* No steenking SIGINT will ever be coming our way when the
660 program is resumed. Don't lie. */
664 /* If there is no terminal switching for this target, then we can't
665 possibly get screwed by the lack of job control. */
666 || !target_supports_terminal_ours ())
669 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
678 if (sync_quit_force_run
)
685 /* Called when a memory allocation fails, with the number of bytes of
686 memory requested in SIZE. */
689 malloc_failure (long size
)
693 internal_error (__FILE__
, __LINE__
,
694 _("virtual memory exhausted: can't allocate %ld bytes."),
699 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
703 /* My replacement for the read system call.
704 Used like `read' but keeps going if `read' returns too soon. */
707 myread (int desc
, char *addr
, int len
)
714 val
= read (desc
, addr
, len
);
726 print_spaces (int n
, struct ui_file
*file
)
728 fputs_unfiltered (n_spaces (n
), file
);
731 /* Print a host address. */
734 gdb_print_host_address_1 (const void *addr
, struct ui_file
*stream
)
736 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
741 /* An RAII class that sets up to handle input and then tears down
742 during destruction. */
744 class scoped_input_handler
748 scoped_input_handler ()
749 : m_quit_handler (&quit_handler
, default_quit_handler
),
752 target_terminal::ours ();
753 ui_register_input_event_handler (current_ui
);
754 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
758 ~scoped_input_handler ()
761 ui_unregister_input_event_handler (m_ui
);
764 DISABLE_COPY_AND_ASSIGN (scoped_input_handler
);
768 /* Save and restore the terminal state. */
769 target_terminal::scoped_restore_terminal_state m_term_state
;
771 /* Save and restore the quit handler. */
772 scoped_restore_tmpl
<quit_handler_ftype
*> m_quit_handler
;
774 /* The saved UI, if non-NULL. */
780 /* This function supports the query, nquery, and yquery functions.
781 Ask user a y-or-n question and return 0 if answer is no, 1 if
782 answer is yes, or default the answer to the specified default
783 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
784 default answer, or '\0' for no default.
785 CTLSTR is the control string and should end in "? ". It should
786 not say how to answer, because we do that.
787 ARGS are the arguments passed along with the CTLSTR argument to
790 static int ATTRIBUTE_PRINTF (1, 0)
791 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
795 char def_answer
, not_def_answer
;
796 const char *y_string
, *n_string
;
798 /* Set up according to which answer is the default. */
803 not_def_answer
= 'N';
807 else if (defchar
== 'y')
811 not_def_answer
= 'N';
819 not_def_answer
= 'Y';
824 /* Automatically answer the default value if the user did not want
825 prompts or the command was issued with the server prefix. */
826 if (!confirm
|| server_command
)
829 /* If input isn't coming from the user directly, just say what
830 question we're asking, and then answer the default automatically. This
831 way, important error messages don't get lost when talking to GDB
833 if (current_ui
->instream
!= current_ui
->stdin_stream
834 || !input_interactive_p (current_ui
)
835 /* Restrict queries to the main UI. */
836 || current_ui
!= main_ui
)
838 target_terminal::scoped_restore_terminal_state term_state
;
839 target_terminal::ours_for_output ();
841 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
843 printf_filtered (_("(%s or %s) [answered %c; "
844 "input not from terminal]\n"),
845 y_string
, n_string
, def_answer
);
850 if (deprecated_query_hook
)
852 target_terminal::scoped_restore_terminal_state term_state
;
853 return deprecated_query_hook (ctlstr
, args
);
856 /* Format the question outside of the loop, to avoid reusing args. */
857 std::string question
= string_vprintf (ctlstr
, args
);
859 = string_printf (_("%s%s(%s or %s) %s"),
860 annotation_level
> 1 ? "\n\032\032pre-query\n" : "",
861 question
.c_str (), y_string
, n_string
,
862 annotation_level
> 1 ? "\n\032\032query\n" : "");
864 /* Used to add duration we waited for user to respond to
865 prompt_for_continue_wait_time. */
866 using namespace std::chrono
;
867 steady_clock::time_point prompt_started
= steady_clock::now ();
869 scoped_input_handler prepare_input
;
873 char *response
, answer
;
875 gdb_flush (gdb_stdout
);
876 response
= gdb_readline_wrapper (prompt
.c_str ());
878 if (response
== NULL
) /* C-d */
880 printf_filtered ("EOF [assumed %c]\n", def_answer
);
885 answer
= response
[0];
890 /* Check answer. For the non-default, the user must specify
891 the non-default explicitly. */
892 if (answer
== not_def_answer
)
897 /* Otherwise, if a default was specified, the user may either
898 specify the required input or have it default by entering
900 if (answer
== def_answer
901 || (defchar
!= '\0' && answer
== '\0'))
906 /* Invalid entries are not defaulted and require another selection. */
907 printf_filtered (_("Please answer %s or %s.\n"),
911 /* Add time spend in this routine to prompt_for_continue_wait_time. */
912 prompt_for_continue_wait_time
+= steady_clock::now () - prompt_started
;
914 if (annotation_level
> 1)
915 printf_filtered (("\n\032\032post-query\n"));
920 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
921 answer is yes, or 0 if answer is defaulted.
922 Takes three args which are given to printf to print the question.
923 The first, a control string, should end in "? ".
924 It should not say how to answer, because we do that. */
927 nquery (const char *ctlstr
, ...)
932 va_start (args
, ctlstr
);
933 ret
= defaulted_query (ctlstr
, 'n', args
);
938 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
939 answer is yes, or 1 if answer is defaulted.
940 Takes three args which are given to printf to print the question.
941 The first, a control string, should end in "? ".
942 It should not say how to answer, because we do that. */
945 yquery (const char *ctlstr
, ...)
950 va_start (args
, ctlstr
);
951 ret
= defaulted_query (ctlstr
, 'y', args
);
956 /* Ask user a y-or-n question and return 1 iff answer is yes.
957 Takes three args which are given to printf to print the question.
958 The first, a control string, should end in "? ".
959 It should not say how to answer, because we do that. */
962 query (const char *ctlstr
, ...)
967 va_start (args
, ctlstr
);
968 ret
= defaulted_query (ctlstr
, '\0', args
);
973 /* A helper for parse_escape that converts a host character to a
974 target character. C is the host character. If conversion is
975 possible, then the target character is stored in *TARGET_C and the
976 function returns 1. Otherwise, the function returns 0. */
979 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
984 auto_obstack host_data
;
986 convert_between_encodings (target_charset (gdbarch
), host_charset (),
987 (gdb_byte
*) &the_char
, 1, 1,
988 &host_data
, translit_none
);
990 if (obstack_object_size (&host_data
) == 1)
993 *target_c
= *(char *) obstack_base (&host_data
);
999 /* Parse a C escape sequence. STRING_PTR points to a variable
1000 containing a pointer to the string to parse. That pointer
1001 should point to the character after the \. That pointer
1002 is updated past the characters we use. The value of the
1003 escape sequence is returned.
1005 A negative value means the sequence \ newline was seen,
1006 which is supposed to be equivalent to nothing at all.
1008 If \ is followed by a null character, we return a negative
1009 value and leave the string pointer pointing at the null character.
1011 If \ is followed by 000, we return 0 and leave the string pointer
1012 after the zeros. A value of 0 does not mean end of string. */
1015 parse_escape (struct gdbarch
*gdbarch
, const char **string_ptr
)
1017 int target_char
= -2; /* Initialize to avoid GCC warnings. */
1018 int c
= *(*string_ptr
)++;
1037 int i
= host_hex_value (c
);
1042 if (isdigit (c
) && c
!= '8' && c
!= '9')
1046 i
+= host_hex_value (c
);
1082 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1083 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1084 " which has no equivalent\nin the `%s' character set."),
1085 c
, c
, target_charset (gdbarch
));
1089 /* Print the character C on STREAM as part of the contents of a literal
1090 string whose delimiter is QUOTER. Note that this routine should only
1091 be called for printing things which are independent of the language
1092 of the program being debugged.
1094 printchar will normally escape backslashes and instances of QUOTER. If
1095 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1096 As a side effect, if you pass the backslash character as the QUOTER,
1097 printchar will escape backslashes as usual, but not any other quoting
1101 printchar (int c
, do_fputc_ftype do_fputc
, ui_file
*stream
, int quoter
)
1103 c
&= 0xFF; /* Avoid sign bit follies */
1105 if (c
< 0x20 || /* Low control chars */
1106 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1107 (sevenbit_strings
&& c
>= 0x80))
1108 { /* high order bit set */
1109 do_fputc ('\\', stream
);
1114 do_fputc ('n', stream
);
1117 do_fputc ('b', stream
);
1120 do_fputc ('t', stream
);
1123 do_fputc ('f', stream
);
1126 do_fputc ('r', stream
);
1129 do_fputc ('e', stream
);
1132 do_fputc ('a', stream
);
1136 do_fputc ('0' + ((c
>> 6) & 0x7), stream
);
1137 do_fputc ('0' + ((c
>> 3) & 0x7), stream
);
1138 do_fputc ('0' + ((c
>> 0) & 0x7), stream
);
1145 if (quoter
!= 0 && (c
== '\\' || c
== quoter
))
1146 do_fputc ('\\', stream
);
1147 do_fputc (c
, stream
);
1151 /* Print the character C on STREAM as part of the contents of a
1152 literal string whose delimiter is QUOTER. Note that these routines
1153 should only be call for printing things which are independent of
1154 the language of the program being debugged. */
1157 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1160 printchar (*str
++, fputc_filtered
, stream
, quoter
);
1164 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1167 printchar (*str
++, fputc_unfiltered
, stream
, quoter
);
1171 fputstrn_filtered (const char *str
, int n
, int quoter
,
1172 struct ui_file
*stream
)
1174 for (int i
= 0; i
< n
; i
++)
1175 printchar (str
[i
], fputc_filtered
, stream
, quoter
);
1179 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1180 do_fputc_ftype do_fputc
, struct ui_file
*stream
)
1182 for (int i
= 0; i
< n
; i
++)
1183 printchar (str
[i
], do_fputc
, stream
, quoter
);
1187 /* Number of lines per page or UINT_MAX if paging is disabled. */
1188 static unsigned int lines_per_page
;
1190 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1191 struct cmd_list_element
*c
, const char *value
)
1193 fprintf_filtered (file
,
1194 _("Number of lines gdb thinks are in a page is %s.\n"),
1198 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1199 static unsigned int chars_per_line
;
1201 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1202 struct cmd_list_element
*c
, const char *value
)
1204 fprintf_filtered (file
,
1205 _("Number of characters gdb thinks "
1206 "are in a line is %s.\n"),
1210 /* Current count of lines printed on this page, chars on this line. */
1211 static unsigned int lines_printed
, chars_printed
;
1213 /* True if pagination is disabled for just one command. */
1215 static bool pagination_disabled_for_command
;
1217 /* Buffer and start column of buffered text, for doing smarter word-
1218 wrapping. When someone calls wrap_here(), we start buffering output
1219 that comes through fputs_filtered(). If we see a newline, we just
1220 spit it out and forget about the wrap_here(). If we see another
1221 wrap_here(), we spit it out and remember the newer one. If we see
1222 the end of the line, we spit out a newline, the indent, and then
1223 the buffered output. */
1225 static bool filter_initialized
= false;
1227 /* Contains characters which are waiting to be output (they have
1228 already been counted in chars_printed). */
1229 static std::string wrap_buffer
;
1231 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1233 static const char *wrap_indent
;
1235 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1236 is not in effect. */
1237 static int wrap_column
;
1239 /* The style applied at the time that wrap_here was called. */
1240 static ui_file_style wrap_style
;
1243 /* Initialize the number of lines per page and chars per line. */
1246 init_page_info (void)
1250 lines_per_page
= UINT_MAX
;
1251 chars_per_line
= UINT_MAX
;
1255 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1260 #if defined(__GO32__)
1261 rows
= ScreenRows ();
1262 cols
= ScreenCols ();
1263 lines_per_page
= rows
;
1264 chars_per_line
= cols
;
1266 /* Make sure Readline has initialized its terminal settings. */
1267 rl_reset_terminal (NULL
);
1269 /* Get the screen size from Readline. */
1270 rl_get_screen_size (&rows
, &cols
);
1271 lines_per_page
= rows
;
1272 chars_per_line
= cols
;
1274 /* Readline should have fetched the termcap entry for us.
1275 Only try to use tgetnum function if rl_get_screen_size
1276 did not return a useful value. */
1277 if (((rows
<= 0) && (tgetnum ((char *) "li") < 0))
1278 /* Also disable paging if inside Emacs. $EMACS was used
1279 before Emacs v25.1, $INSIDE_EMACS is used since then. */
1280 || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1282 /* The number of lines per page is not mentioned in the terminal
1283 description or EMACS evironment variable is set. This probably
1284 means that paging is not useful, so disable paging. */
1285 lines_per_page
= UINT_MAX
;
1288 /* If the output is not a terminal, don't paginate it. */
1289 if (!ui_file_isatty (gdb_stdout
))
1290 lines_per_page
= UINT_MAX
;
1294 /* We handle SIGWINCH ourselves. */
1295 rl_catch_sigwinch
= 0;
1301 /* Return nonzero if filtered printing is initialized. */
1303 filtered_printing_initialized (void)
1305 return filter_initialized
;
1308 set_batch_flag_and_restore_page_info::set_batch_flag_and_restore_page_info ()
1309 : m_save_lines_per_page (lines_per_page
),
1310 m_save_chars_per_line (chars_per_line
),
1311 m_save_batch_flag (batch_flag
)
1317 set_batch_flag_and_restore_page_info::~set_batch_flag_and_restore_page_info ()
1319 batch_flag
= m_save_batch_flag
;
1320 chars_per_line
= m_save_chars_per_line
;
1321 lines_per_page
= m_save_lines_per_page
;
1327 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1330 set_screen_size (void)
1332 int rows
= lines_per_page
;
1333 int cols
= chars_per_line
;
1335 /* If we get 0 or negative ROWS or COLS, treat as "infinite" size.
1336 A negative number can be seen here with the "set width/height"
1337 commands and either:
1339 - the user specified "unlimited", which maps to UINT_MAX, or
1340 - the user spedified some number between INT_MAX and UINT_MAX.
1342 Cap "infinity" to approximately sqrt(INT_MAX) so that we don't
1343 overflow in rl_set_screen_size, which multiplies rows and columns
1344 to compute the number of characters on the screen. */
1346 const int sqrt_int_max
= INT_MAX
>> (sizeof (int) * 8 / 2);
1348 if (rows
<= 0 || rows
> sqrt_int_max
)
1350 rows
= sqrt_int_max
;
1351 lines_per_page
= UINT_MAX
;
1354 if (cols
<= 0 || cols
> sqrt_int_max
)
1356 cols
= sqrt_int_max
;
1357 chars_per_line
= UINT_MAX
;
1360 /* Update Readline's idea of the terminal size. */
1361 rl_set_screen_size (rows
, cols
);
1364 /* Reinitialize WRAP_BUFFER. */
1369 if (chars_per_line
== 0)
1372 wrap_buffer
.clear ();
1373 filter_initialized
= true;
1377 set_width_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1384 set_height_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1392 set_screen_width_and_height (int width
, int height
)
1394 lines_per_page
= height
;
1395 chars_per_line
= width
;
1401 /* The currently applied style. */
1403 static ui_file_style applied_style
;
1405 /* Emit an ANSI style escape for STYLE. If STREAM is nullptr, emit to
1406 the wrap buffer; otherwise emit to STREAM. */
1409 emit_style_escape (const ui_file_style
&style
,
1410 struct ui_file
*stream
= nullptr)
1412 applied_style
= style
;
1414 if (stream
== nullptr)
1415 wrap_buffer
.append (style
.to_ansi ());
1417 fputs_unfiltered (style
.to_ansi ().c_str (), stream
);
1420 /* Set the current output style. This will affect future uses of the
1421 _filtered output functions. */
1424 set_output_style (struct ui_file
*stream
, const ui_file_style
&style
)
1426 if (!stream
->can_emit_style_escape ())
1429 /* Note that we may not pass STREAM here, when we want to emit to
1430 the wrap buffer, not directly to STREAM. */
1431 if (stream
== gdb_stdout
)
1433 emit_style_escape (style
, stream
);
1439 reset_terminal_style (struct ui_file
*stream
)
1441 if (stream
->can_emit_style_escape ())
1443 /* Force the setting, regardless of what we think the setting
1444 might already be. */
1445 applied_style
= ui_file_style ();
1446 wrap_buffer
.append (applied_style
.to_ansi ());
1450 /* Wait, so the user can read what's on the screen. Prompt the user
1451 to continue by pressing RETURN. 'q' is also provided because
1452 telling users what to do in the prompt is more user-friendly than
1453 expecting them to think of Ctrl-C/SIGINT. */
1456 prompt_for_continue (void)
1458 char cont_prompt
[120];
1459 /* Used to add duration we waited for user to respond to
1460 prompt_for_continue_wait_time. */
1461 using namespace std::chrono
;
1462 steady_clock::time_point prompt_started
= steady_clock::now ();
1463 bool disable_pagination
= pagination_disabled_for_command
;
1465 /* Clear the current styling. */
1466 if (gdb_stdout
->can_emit_style_escape ())
1467 emit_style_escape (ui_file_style (), gdb_stdout
);
1469 if (annotation_level
> 1)
1470 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1472 strcpy (cont_prompt
,
1473 "--Type <RET> for more, q to quit, "
1474 "c to continue without paging--");
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");
1505 disable_pagination
= true;
1508 /* Now we have to do this again, so that GDB will know that it doesn't
1509 need to save the ---Type <return>--- line at the top of the screen. */
1510 reinitialize_more_filter ();
1511 pagination_disabled_for_command
= disable_pagination
;
1513 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1516 /* Initialize timer to keep track of how long we waited for the user. */
1519 reset_prompt_for_continue_wait_time (void)
1521 using namespace std::chrono
;
1523 prompt_for_continue_wait_time
= steady_clock::duration::zero ();
1526 /* Fetch the cumulative time spent in prompt_for_continue. */
1528 std::chrono::steady_clock::duration
1529 get_prompt_for_continue_wait_time ()
1531 return prompt_for_continue_wait_time
;
1534 /* Reinitialize filter; ie. tell it to reset to original values. */
1537 reinitialize_more_filter (void)
1541 pagination_disabled_for_command
= false;
1544 /* Flush the wrap buffer to STREAM, if necessary. */
1547 flush_wrap_buffer (struct ui_file
*stream
)
1549 if (stream
== gdb_stdout
&& !wrap_buffer
.empty ())
1551 fputs_unfiltered (wrap_buffer
.c_str (), stream
);
1552 wrap_buffer
.clear ();
1556 /* Indicate that if the next sequence of characters overflows the line,
1557 a newline should be inserted here rather than when it hits the end.
1558 If INDENT is non-null, it is a string to be printed to indent the
1559 wrapped part on the next line. INDENT must remain accessible until
1560 the next call to wrap_here() or until a newline is printed through
1563 If the line is already overfull, we immediately print a newline and
1564 the indentation, and disable further wrapping.
1566 If we don't know the width of lines, but we know the page height,
1567 we must not wrap words, but should still keep track of newlines
1568 that were explicitly printed.
1570 INDENT should not contain tabs, as that will mess up the char count
1571 on the next line. FIXME.
1573 This routine is guaranteed to force out any output which has been
1574 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1575 used to force out output from the wrap_buffer. */
1578 wrap_here (const char *indent
)
1580 /* This should have been allocated, but be paranoid anyway. */
1581 if (!filter_initialized
)
1582 internal_error (__FILE__
, __LINE__
,
1583 _("failed internal consistency check"));
1585 flush_wrap_buffer (gdb_stdout
);
1586 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
1590 else if (chars_printed
>= chars_per_line
)
1592 puts_filtered ("\n");
1594 puts_filtered (indent
);
1599 wrap_column
= chars_printed
;
1603 wrap_indent
= indent
;
1604 wrap_style
= applied_style
;
1608 /* Print input string to gdb_stdout, filtered, with wrap,
1609 arranging strings in columns of n chars. String can be
1610 right or left justified in the column. Never prints
1611 trailing spaces. String should never be longer than
1612 width. FIXME: this could be useful for the EXAMINE
1613 command, which currently doesn't tabulate very well. */
1616 puts_filtered_tabular (char *string
, int width
, int right
)
1622 gdb_assert (chars_per_line
> 0);
1623 if (chars_per_line
== UINT_MAX
)
1625 fputs_filtered (string
, gdb_stdout
);
1626 fputs_filtered ("\n", gdb_stdout
);
1630 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1631 fputs_filtered ("\n", gdb_stdout
);
1633 if (width
>= chars_per_line
)
1634 width
= chars_per_line
- 1;
1636 stringlen
= strlen (string
);
1638 if (chars_printed
> 0)
1639 spaces
= width
- (chars_printed
- 1) % width
- 1;
1641 spaces
+= width
- stringlen
;
1643 spacebuf
= (char *) alloca (spaces
+ 1);
1644 spacebuf
[spaces
] = '\0';
1646 spacebuf
[spaces
] = ' ';
1648 fputs_filtered (spacebuf
, gdb_stdout
);
1649 fputs_filtered (string
, gdb_stdout
);
1653 /* Ensure that whatever gets printed next, using the filtered output
1654 commands, starts at the beginning of the line. I.e. if there is
1655 any pending output for the current line, flush it and start a new
1656 line. Otherwise do nothing. */
1661 if (chars_printed
> 0)
1663 puts_filtered ("\n");
1668 /* Like fputs but if FILTER is true, pause after every screenful.
1670 Regardless of FILTER can wrap at points other than the final
1671 character of a line.
1673 Unlike fputs, fputs_maybe_filtered does not return a value.
1674 It is OK for LINEBUFFER to be NULL, in which case just don't print
1677 Note that a longjmp to top level may occur in this routine (only if
1678 FILTER is true) (since prompt_for_continue may do so) so this
1679 routine should not be called when cleanups are not in place. */
1682 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1685 const char *lineptr
;
1687 if (linebuffer
== 0)
1690 /* Don't do any filtering if it is disabled. */
1691 if (stream
!= gdb_stdout
1692 || !pagination_enabled
1693 || pagination_disabled_for_command
1695 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
1696 || top_level_interpreter () == NULL
1697 || top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ())
1699 flush_wrap_buffer (stream
);
1700 fputs_unfiltered (linebuffer
, stream
);
1705 = make_scope_exit ([&] ()
1707 wrap_buffer
.clear ();
1712 /* Go through and output each character. Show line extension
1713 when this is necessary; prompt user for new page when this is
1716 lineptr
= linebuffer
;
1719 /* Possible new page. Note that PAGINATION_DISABLED_FOR_COMMAND
1720 might be set during this loop, so we must continue to check
1722 if (filter
&& (lines_printed
>= lines_per_page
- 1)
1723 && !pagination_disabled_for_command
)
1724 prompt_for_continue ();
1726 while (*lineptr
&& *lineptr
!= '\n')
1730 /* Print a single line. */
1731 if (*lineptr
== '\t')
1733 wrap_buffer
.push_back ('\t');
1734 /* Shifting right by 3 produces the number of tab stops
1735 we have already passed, and then adding one and
1736 shifting left 3 advances to the next tab stop. */
1737 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1740 else if (*lineptr
== '\033'
1741 && skip_ansi_escape (lineptr
, &skip_bytes
))
1743 wrap_buffer
.append (lineptr
, skip_bytes
);
1744 /* Note that we don't consider this a character, so we
1745 don't increment chars_printed here. */
1746 lineptr
+= skip_bytes
;
1750 wrap_buffer
.push_back (*lineptr
);
1755 if (chars_printed
>= chars_per_line
)
1757 unsigned int save_chars
= chars_printed
;
1759 /* If we change the style, below, we'll want to reset it
1760 before continuing to print. If there is no wrap
1761 column, then we'll only reset the style if the pager
1762 prompt is given; and to avoid emitting style
1763 sequences in the middle of a run of text, we track
1765 ui_file_style save_style
;
1766 bool did_paginate
= false;
1772 save_style
= wrap_style
;
1773 if (stream
->can_emit_style_escape ())
1774 emit_style_escape (ui_file_style (), stream
);
1775 /* If we aren't actually wrapping, don't output
1776 newline -- if chars_per_line is right, we
1777 probably just overflowed anyway; if it's wrong,
1778 let us keep going. */
1779 fputc_unfiltered ('\n', stream
);
1783 save_style
= applied_style
;
1784 flush_wrap_buffer (stream
);
1787 /* Possible new page. Note that
1788 PAGINATION_DISABLED_FOR_COMMAND might be set during
1789 this loop, so we must continue to check it here. */
1790 if (lines_printed
>= lines_per_page
- 1
1791 && !pagination_disabled_for_command
)
1793 prompt_for_continue ();
1794 did_paginate
= true;
1797 /* Now output indentation and wrapped string. */
1800 fputs_unfiltered (wrap_indent
, stream
);
1801 if (stream
->can_emit_style_escape ())
1802 emit_style_escape (save_style
, stream
);
1803 /* FIXME, this strlen is what prevents wrap_indent from
1804 containing tabs. However, if we recurse to print it
1805 and count its chars, we risk trouble if wrap_indent is
1806 longer than (the user settable) chars_per_line.
1807 Note also that this can set chars_printed > chars_per_line
1808 if we are printing a long string. */
1809 chars_printed
= strlen (wrap_indent
)
1810 + (save_chars
- wrap_column
);
1811 wrap_column
= 0; /* And disable fancy wrap */
1813 else if (did_paginate
&& stream
->can_emit_style_escape ())
1814 emit_style_escape (save_style
, stream
);
1818 if (*lineptr
== '\n')
1821 wrap_here ((char *) 0); /* Spit out chars, cancel
1824 fputc_unfiltered ('\n', stream
);
1829 buffer_clearer
.release ();
1833 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1835 fputs_maybe_filtered (linebuffer
, stream
, 1);
1841 fputs_styled (const char *linebuffer
, const ui_file_style
&style
,
1842 struct ui_file
*stream
)
1844 /* This just makes it so we emit somewhat fewer escape
1846 if (style
.is_default ())
1847 fputs_maybe_filtered (linebuffer
, stream
, 1);
1850 set_output_style (stream
, style
);
1851 fputs_maybe_filtered (linebuffer
, stream
, 1);
1852 set_output_style (stream
, ui_file_style ());
1859 fputs_highlighted (const char *str
, const compiled_regex
&highlight
,
1860 struct ui_file
*stream
)
1864 while (*str
&& highlight
.exec (str
, 1, &pmatch
, 0) == 0)
1866 size_t n_highlight
= pmatch
.rm_eo
- pmatch
.rm_so
;
1868 /* Output the part before pmatch with current style. */
1869 while (pmatch
.rm_so
> 0)
1871 fputc_filtered (*str
, stream
);
1876 /* Output pmatch with the highlight style. */
1877 set_output_style (stream
, highlight_style
.style ());
1878 while (n_highlight
> 0)
1880 fputc_filtered (*str
, stream
);
1884 set_output_style (stream
, ui_file_style ());
1887 /* Output the trailing part of STR not matching HIGHLIGHT. */
1889 fputs_filtered (str
, stream
);
1893 putchar_unfiltered (int c
)
1897 ui_file_write (gdb_stdout
, &buf
, 1);
1901 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1902 May return nonlocally. */
1905 putchar_filtered (int c
)
1907 return fputc_filtered (c
, gdb_stdout
);
1911 fputc_unfiltered (int c
, struct ui_file
*stream
)
1915 ui_file_write (stream
, &buf
, 1);
1920 fputc_filtered (int c
, struct ui_file
*stream
)
1926 fputs_filtered (buf
, stream
);
1930 /* puts_debug is like fputs_unfiltered, except it prints special
1931 characters in printable fashion. */
1934 puts_debug (char *prefix
, char *string
, char *suffix
)
1938 /* Print prefix and suffix after each line. */
1939 static int new_line
= 1;
1940 static int return_p
= 0;
1941 static const char *prev_prefix
= "";
1942 static const char *prev_suffix
= "";
1944 if (*string
== '\n')
1947 /* If the prefix is changing, print the previous suffix, a new line,
1948 and the new prefix. */
1949 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
1951 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
1952 fputs_unfiltered ("\n", gdb_stdlog
);
1953 fputs_unfiltered (prefix
, gdb_stdlog
);
1956 /* Print prefix if we printed a newline during the previous call. */
1960 fputs_unfiltered (prefix
, gdb_stdlog
);
1963 prev_prefix
= prefix
;
1964 prev_suffix
= suffix
;
1966 /* Output characters in a printable format. */
1967 while ((ch
= *string
++) != '\0')
1973 fputc_unfiltered (ch
, gdb_stdlog
);
1976 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
1980 fputs_unfiltered ("\\\\", gdb_stdlog
);
1983 fputs_unfiltered ("\\b", gdb_stdlog
);
1986 fputs_unfiltered ("\\f", gdb_stdlog
);
1990 fputs_unfiltered ("\\n", gdb_stdlog
);
1993 fputs_unfiltered ("\\r", gdb_stdlog
);
1996 fputs_unfiltered ("\\t", gdb_stdlog
);
1999 fputs_unfiltered ("\\v", gdb_stdlog
);
2003 return_p
= ch
== '\r';
2006 /* Print suffix if we printed a newline. */
2009 fputs_unfiltered (suffix
, gdb_stdlog
);
2010 fputs_unfiltered ("\n", gdb_stdlog
);
2015 /* Print a variable number of ARGS using format FORMAT. If this
2016 information is going to put the amount written (since the last call
2017 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2018 call prompt_for_continue to get the users permision to continue.
2020 Unlike fprintf, this function does not return a value.
2022 We implement three variants, vfprintf (takes a vararg list and stream),
2023 fprintf (takes a stream to write on), and printf (the usual).
2025 Note also that a longjmp to top level may occur in this routine
2026 (since prompt_for_continue may do so) so this routine should not be
2027 called when cleanups are not in place. */
2030 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2031 va_list args
, int filter
)
2033 std::string linebuffer
= string_vprintf (format
, args
);
2034 fputs_maybe_filtered (linebuffer
.c_str (), stream
, filter
);
2039 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2041 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2045 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2047 std::string linebuffer
= string_vprintf (format
, args
);
2048 if (debug_timestamp
&& stream
== gdb_stdlog
)
2050 using namespace std::chrono
;
2053 steady_clock::time_point now
= steady_clock::now ();
2054 seconds s
= duration_cast
<seconds
> (now
.time_since_epoch ());
2055 microseconds us
= duration_cast
<microseconds
> (now
.time_since_epoch () - s
);
2057 len
= linebuffer
.size ();
2058 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2060 std::string timestamp
= string_printf ("%ld.%06ld %s%s",
2063 linebuffer
.c_str (),
2064 need_nl
? "\n": "");
2065 fputs_unfiltered (timestamp
.c_str (), stream
);
2068 fputs_unfiltered (linebuffer
.c_str (), stream
);
2072 vprintf_filtered (const char *format
, va_list args
)
2074 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2078 vprintf_unfiltered (const char *format
, va_list args
)
2080 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2084 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2088 va_start (args
, format
);
2089 vfprintf_filtered (stream
, format
, args
);
2094 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2098 va_start (args
, format
);
2099 vfprintf_unfiltered (stream
, format
, args
);
2103 /* Like fprintf_filtered, but prints its result indented.
2104 Called as fprintfi_filtered (spaces, stream, format, ...); */
2107 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2112 va_start (args
, format
);
2113 print_spaces_filtered (spaces
, stream
);
2115 vfprintf_filtered (stream
, format
, args
);
2122 fprintf_styled (struct ui_file
*stream
, const ui_file_style
&style
,
2123 const char *format
, ...)
2127 set_output_style (stream
, style
);
2128 va_start (args
, format
);
2129 vfprintf_filtered (stream
, format
, args
);
2131 set_output_style (stream
, ui_file_style ());
2136 printf_filtered (const char *format
, ...)
2140 va_start (args
, format
);
2141 vfprintf_filtered (gdb_stdout
, format
, args
);
2147 printf_unfiltered (const char *format
, ...)
2151 va_start (args
, format
);
2152 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2156 /* Like printf_filtered, but prints it's result indented.
2157 Called as printfi_filtered (spaces, format, ...); */
2160 printfi_filtered (int spaces
, const char *format
, ...)
2164 va_start (args
, format
);
2165 print_spaces_filtered (spaces
, gdb_stdout
);
2166 vfprintf_filtered (gdb_stdout
, format
, args
);
2170 /* Easy -- but watch out!
2172 This routine is *not* a replacement for puts()! puts() appends a newline.
2173 This one doesn't, and had better not! */
2176 puts_filtered (const char *string
)
2178 fputs_filtered (string
, gdb_stdout
);
2182 puts_unfiltered (const char *string
)
2184 fputs_unfiltered (string
, gdb_stdout
);
2187 /* Return a pointer to N spaces and a null. The pointer is good
2188 until the next call to here. */
2193 static char *spaces
= 0;
2194 static int max_spaces
= -1;
2200 spaces
= (char *) xmalloc (n
+ 1);
2201 for (t
= spaces
+ n
; t
!= spaces
;)
2207 return spaces
+ max_spaces
- n
;
2210 /* Print N spaces. */
2212 print_spaces_filtered (int n
, struct ui_file
*stream
)
2214 fputs_filtered (n_spaces (n
), stream
);
2217 /* C++/ObjC demangler stuff. */
2219 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2220 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2221 If the name is not mangled, or the language for the name is unknown, or
2222 demangling is off, the name is printed in its "raw" form. */
2225 fprintf_symbol_filtered (struct ui_file
*stream
, const char *name
,
2226 enum language lang
, int arg_mode
)
2232 /* If user wants to see raw output, no problem. */
2235 fputs_filtered (name
, stream
);
2239 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2240 fputs_filtered (demangled
? demangled
: name
, stream
);
2241 if (demangled
!= NULL
)
2249 /* True if CH is a character that can be part of a symbol name. I.e.,
2250 either a number, a letter, or a '_'. */
2253 valid_identifier_name_char (int ch
)
2255 return (isalnum (ch
) || ch
== '_');
2258 /* Skip to end of token, or to END, whatever comes first. Input is
2259 assumed to be a C++ operator name. */
2262 cp_skip_operator_token (const char *token
, const char *end
)
2264 const char *p
= token
;
2265 while (p
!= end
&& !isspace (*p
) && *p
!= '(')
2267 if (valid_identifier_name_char (*p
))
2269 while (p
!= end
&& valid_identifier_name_char (*p
))
2275 /* Note, ordered such that among ops that share a prefix,
2276 longer comes first. This is so that the loop below can
2277 bail on first match. */
2278 static const char *ops
[] =
2284 "-=", "--", "->", "-",
2293 "<<=", "<=", "<<", "<",
2294 ">>=", ">=", ">>", ">",
2298 for (const char *op
: ops
)
2300 size_t oplen
= strlen (op
);
2301 size_t lencmp
= std::min
<size_t> (oplen
, end
- p
);
2303 if (strncmp (p
, op
, lencmp
) == 0)
2306 /* Some unidentified character. Return it. */
2314 /* Advance STRING1/STRING2 past whitespace. */
2317 skip_ws (const char *&string1
, const char *&string2
, const char *end_str2
)
2319 while (isspace (*string1
))
2321 while (string2
< end_str2
&& isspace (*string2
))
2325 /* True if STRING points at the start of a C++ operator name. START
2326 is the start of the string that STRING points to, hence when
2327 reading backwards, we must not read any character before START. */
2330 cp_is_operator (const char *string
, const char *start
)
2332 return ((string
== start
2333 || !valid_identifier_name_char (string
[-1]))
2334 && strncmp (string
, CP_OPERATOR_STR
, CP_OPERATOR_LEN
) == 0
2335 && !valid_identifier_name_char (string
[CP_OPERATOR_LEN
]));
2338 /* If *NAME points at an ABI tag, skip it and return true. Otherwise
2339 leave *NAME unmodified and return false. (see GCC's abi_tag
2340 attribute), such names are demangled as e.g.,
2341 "function[abi:cxx11]()". */
2344 skip_abi_tag (const char **name
)
2346 const char *p
= *name
;
2348 if (startswith (p
, "[abi:"))
2352 while (valid_identifier_name_char (*p
))
2368 strncmp_iw_with_mode (const char *string1
, const char *string2
,
2369 size_t string2_len
, strncmp_iw_mode mode
,
2370 enum language language
,
2371 completion_match_for_lcd
*match_for_lcd
)
2373 const char *string1_start
= string1
;
2374 const char *end_str2
= string2
+ string2_len
;
2375 bool skip_spaces
= true;
2376 bool have_colon_op
= (language
== language_cplus
2377 || language
== language_rust
2378 || language
== language_fortran
);
2383 || ((isspace (*string1
) && !valid_identifier_name_char (*string2
))
2384 || (isspace (*string2
) && !valid_identifier_name_char (*string1
))))
2386 skip_ws (string1
, string2
, end_str2
);
2387 skip_spaces
= false;
2390 /* Skip [abi:cxx11] tags in the symbol name if the lookup name
2391 doesn't include them. E.g.:
2393 string1: function[abi:cxx1](int)
2396 string1: function[abi:cxx1](int)
2397 string2: function(int)
2399 string1: Struct[abi:cxx1]::function()
2400 string2: Struct::function()
2402 string1: function(Struct[abi:cxx1], int)
2403 string2: function(Struct, int)
2405 if (string2
== end_str2
2406 || (*string2
!= '[' && !valid_identifier_name_char (*string2
)))
2408 const char *abi_start
= string1
;
2410 /* There can be more than one tag. */
2411 while (*string1
== '[' && skip_abi_tag (&string1
))
2414 if (match_for_lcd
!= NULL
&& abi_start
!= string1
)
2415 match_for_lcd
->mark_ignored_range (abi_start
, string1
);
2417 while (isspace (*string1
))
2421 if (*string1
== '\0' || string2
== end_str2
)
2424 /* Handle the :: operator. */
2425 if (have_colon_op
&& string1
[0] == ':' && string1
[1] == ':')
2427 if (*string2
!= ':')
2433 if (string2
== end_str2
)
2436 if (*string2
!= ':')
2442 while (isspace (*string1
))
2444 while (string2
< end_str2
&& isspace (*string2
))
2449 /* Handle C++ user-defined operators. */
2450 else if (language
== language_cplus
2453 if (cp_is_operator (string1
, string1_start
))
2455 /* An operator name in STRING1. Check STRING2. */
2457 = std::min
<size_t> (CP_OPERATOR_LEN
, end_str2
- string2
);
2458 if (strncmp (string1
, string2
, cmplen
) != 0)
2464 if (string2
!= end_str2
)
2466 /* Check for "operatorX" in STRING2. */
2467 if (valid_identifier_name_char (*string2
))
2470 skip_ws (string1
, string2
, end_str2
);
2473 /* Handle operator(). */
2474 if (*string1
== '(')
2476 if (string2
== end_str2
)
2478 if (mode
== strncmp_iw_mode::NORMAL
)
2482 /* Don't break for the regular return at the
2483 bottom, because "operator" should not
2484 match "operator()", since this open
2485 parentheses is not the parameter list
2487 return *string1
!= '\0';
2491 if (*string1
!= *string2
)
2500 skip_ws (string1
, string2
, end_str2
);
2502 /* Skip to end of token, or to END, whatever comes
2504 const char *end_str1
= string1
+ strlen (string1
);
2505 const char *p1
= cp_skip_operator_token (string1
, end_str1
);
2506 const char *p2
= cp_skip_operator_token (string2
, end_str2
);
2508 cmplen
= std::min (p1
- string1
, p2
- string2
);
2511 if (strncmp (string1
, string2
, cmplen
) != 0)
2516 if (p1
- string1
!= p2
- string2
)
2518 if (strncmp (string1
, string2
, cmplen
) != 0)
2525 if (*string1
== '\0' || string2
== end_str2
)
2527 if (*string1
== '(' || *string2
== '(')
2535 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
2537 if (case_sensitivity
== case_sensitive_off
2538 && (tolower ((unsigned char) *string1
)
2539 != tolower ((unsigned char) *string2
)))
2542 /* If we see any non-whitespace, non-identifier-name character
2543 (any of "()<>*&" etc.), then skip spaces the next time
2545 if (!isspace (*string1
) && !valid_identifier_name_char (*string1
))
2552 if (string2
== end_str2
)
2554 if (mode
== strncmp_iw_mode::NORMAL
)
2556 /* Strip abi tag markers from the matched symbol name.
2557 Usually the ABI marker will be found on function name
2558 (automatically added because the function returns an
2559 object marked with an ABI tag). However, it's also
2560 possible to see a marker in one of the function
2561 parameters, for example.
2563 string2 (lookup name):
2566 function(some_struct[abi:cxx11], int)
2568 and for completion LCD computation we want to say that
2570 function(some_struct, int)
2572 if (match_for_lcd
!= NULL
)
2574 while ((string1
= strstr (string1
, "[abi:")) != NULL
)
2576 const char *abi_start
= string1
;
2578 /* There can be more than one tag. */
2579 while (skip_abi_tag (&string1
) && *string1
== '[')
2582 if (abi_start
!= string1
)
2583 match_for_lcd
->mark_ignored_range (abi_start
, string1
);
2590 return (*string1
!= '\0' && *string1
!= '(');
2599 strncmp_iw (const char *string1
, const char *string2
, size_t string2_len
)
2601 return strncmp_iw_with_mode (string1
, string2
, string2_len
,
2602 strncmp_iw_mode::NORMAL
, language_minimal
);
2608 strcmp_iw (const char *string1
, const char *string2
)
2610 return strncmp_iw_with_mode (string1
, string2
, strlen (string2
),
2611 strncmp_iw_mode::MATCH_PARAMS
, language_minimal
);
2614 /* This is like strcmp except that it ignores whitespace and treats
2615 '(' as the first non-NULL character in terms of ordering. Like
2616 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2617 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2618 according to that ordering.
2620 If a list is sorted according to this function and if you want to
2621 find names in the list that match some fixed NAME according to
2622 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2623 where this function would put NAME.
2625 This function must be neutral to the CASE_SENSITIVITY setting as the user
2626 may choose it during later lookup. Therefore this function always sorts
2627 primarily case-insensitively and secondarily case-sensitively.
2629 Here are some examples of why using strcmp to sort is a bad idea:
2633 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2634 we try to do a search for "foo<char*>", strcmp will locate this
2635 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2636 will start looking at strings beginning with "goo", and will never
2637 see the correct match of "foo<char *>".
2639 Parenthesis example:
2641 In practice, this is less like to be an issue, but I'll give it a
2642 shot. Let's assume that '$' is a legitimate character to occur in
2643 symbols. (Which may well even be the case on some systems.) Then
2644 say that the partial symbol table contains "foo$" and "foo(int)".
2645 strcmp will put them in this order, since '$' < '('. Now, if the
2646 user searches for "foo", then strcmp will sort "foo" before "foo$".
2647 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2648 "foo") is false, so it won't proceed to the actual match of
2649 "foo(int)" with "foo". */
2652 strcmp_iw_ordered (const char *string1
, const char *string2
)
2654 const char *saved_string1
= string1
, *saved_string2
= string2
;
2655 enum case_sensitivity case_pass
= case_sensitive_off
;
2659 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2660 Provide stub characters if we are already at the end of one of the
2662 char c1
= 'X', c2
= 'X';
2664 while (*string1
!= '\0' && *string2
!= '\0')
2666 while (isspace (*string1
))
2668 while (isspace (*string2
))
2673 case case_sensitive_off
:
2674 c1
= tolower ((unsigned char) *string1
);
2675 c2
= tolower ((unsigned char) *string2
);
2677 case case_sensitive_on
:
2685 if (*string1
!= '\0')
2694 /* Characters are non-equal unless they're both '\0'; we want to
2695 make sure we get the comparison right according to our
2696 comparison in the cases where one of them is '\0' or '('. */
2698 if (*string2
== '\0')
2703 if (*string2
== '\0')
2708 if (*string2
== '\0' || *string2
== '(')
2717 if (case_pass
== case_sensitive_on
)
2720 /* Otherwise the strings were equal in case insensitive way, make
2721 a more fine grained comparison in a case sensitive way. */
2723 case_pass
= case_sensitive_on
;
2724 string1
= saved_string1
;
2725 string2
= saved_string2
;
2732 streq (const char *lhs
, const char *rhs
)
2734 return !strcmp (lhs
, rhs
);
2740 streq_hash (const void *lhs
, const void *rhs
)
2742 return streq ((const char *) lhs
, (const char *) rhs
);
2749 ** Answer whether string_to_compare is a full or partial match to
2750 ** template_string. The partial match must be in sequence starting
2754 subset_compare (const char *string_to_compare
, const char *template_string
)
2758 if (template_string
!= NULL
&& string_to_compare
!= NULL
2759 && strlen (string_to_compare
) <= strlen (template_string
))
2761 (startswith (template_string
, string_to_compare
));
2768 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2769 struct cmd_list_element
*c
, const char *value
)
2771 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
2779 address_significant (gdbarch
*gdbarch
, CORE_ADDR addr
)
2781 /* Clear insignificant bits of a target address and sign extend resulting
2782 address, avoiding shifts larger or equal than the width of a CORE_ADDR.
2783 The local variable ADDR_BIT stops the compiler reporting a shift overflow
2784 when it won't occur. Skip updating of target address if current target
2785 has not set gdbarch significant_addr_bit. */
2786 int addr_bit
= gdbarch_significant_addr_bit (gdbarch
);
2788 if (addr_bit
&& (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
)))
2790 CORE_ADDR sign
= (CORE_ADDR
) 1 << (addr_bit
- 1);
2791 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2792 addr
= (addr
^ sign
) - sign
;
2799 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2801 /* Truncate address to the size of a target address, avoiding shifts
2802 larger or equal than the width of a CORE_ADDR. The local
2803 variable ADDR_BIT stops the compiler reporting a shift overflow
2804 when it won't occur. */
2805 /* NOTE: This assumes that the significant address information is
2806 kept in the least significant bits of ADDR - the upper bits were
2807 either zero or sign extended. Should gdbarch_address_to_pointer or
2808 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2810 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2812 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2813 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2814 return hex_string (addr
);
2817 /* This function is described in "defs.h". */
2820 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2822 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2824 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2825 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2827 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2828 that returns the language localized string formatted to a width
2829 based on gdbarch_addr_bit. */
2831 return hex_string_custom (address
, 8);
2833 return hex_string_custom (address
, 16);
2836 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2839 core_addr_hash (const void *ap
)
2841 const CORE_ADDR
*addrp
= (const CORE_ADDR
*) ap
;
2846 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2849 core_addr_eq (const void *ap
, const void *bp
)
2851 const CORE_ADDR
*addr_ap
= (const CORE_ADDR
*) ap
;
2852 const CORE_ADDR
*addr_bp
= (const CORE_ADDR
*) bp
;
2854 return *addr_ap
== *addr_bp
;
2857 /* Convert a string back into a CORE_ADDR. */
2859 string_to_core_addr (const char *my_string
)
2863 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2865 /* Assume that it is in hex. */
2868 for (i
= 2; my_string
[i
] != '\0'; i
++)
2870 if (isdigit (my_string
[i
]))
2871 addr
= (my_string
[i
] - '0') + (addr
* 16);
2872 else if (isxdigit (my_string
[i
]))
2873 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2875 error (_("invalid hex \"%s\""), my_string
);
2880 /* Assume that it is in decimal. */
2883 for (i
= 0; my_string
[i
] != '\0'; i
++)
2885 if (isdigit (my_string
[i
]))
2886 addr
= (my_string
[i
] - '0') + (addr
* 10);
2888 error (_("invalid decimal \"%s\""), my_string
);
2898 gdb_realpath_check_trailer (const char *input
, const char *trailer
)
2900 gdb::unique_xmalloc_ptr
<char> result
= gdb_realpath (input
);
2902 size_t len
= strlen (result
.get ());
2903 size_t trail_len
= strlen (trailer
);
2905 SELF_CHECK (len
>= trail_len
2906 && strcmp (result
.get () + len
- trail_len
, trailer
) == 0);
2910 gdb_realpath_tests ()
2912 /* A file which contains a directory prefix. */
2913 gdb_realpath_check_trailer ("./xfullpath.exp", "/xfullpath.exp");
2914 /* A file which contains a directory prefix. */
2915 gdb_realpath_check_trailer ("../../defs.h", "/defs.h");
2916 /* A one-character filename. */
2917 gdb_realpath_check_trailer ("./a", "/a");
2918 /* A file in the root directory. */
2919 gdb_realpath_check_trailer ("/root_file_which_should_exist",
2920 "/root_file_which_should_exist");
2921 /* A file which does not have a directory prefix. */
2922 gdb_realpath_check_trailer ("xfullpath.exp", "xfullpath.exp");
2923 /* A one-char filename without any directory prefix. */
2924 gdb_realpath_check_trailer ("a", "a");
2925 /* An empty filename. */
2926 gdb_realpath_check_trailer ("", "");
2929 #endif /* GDB_SELF_TEST */
2931 /* Allocation function for the libiberty hash table which uses an
2932 obstack. The obstack is passed as DATA. */
2935 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
2937 size_t total
= size
* count
;
2938 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
2940 memset (ptr
, 0, total
);
2944 /* Trivial deallocation function for the libiberty splay tree and hash
2945 table - don't deallocate anything. Rely on later deletion of the
2946 obstack. DATA will be the obstack, although it is not needed
2950 dummy_obstack_deallocate (void *object
, void *data
)
2955 /* Simple, portable version of dirname that does not modify its
2959 ldirname (const char *filename
)
2961 std::string dirname
;
2962 const char *base
= lbasename (filename
);
2964 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
2967 if (base
== filename
)
2970 dirname
= std::string (filename
, base
- filename
);
2972 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
2973 create "d:./bar" later instead of the (different) "d:/bar". */
2974 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
2975 && !IS_DIR_SEPARATOR (filename
[0]))
2976 dirname
[base
++ - filename
] = '.';
2984 gdb_argv::reset (const char *s
)
2986 char **argv
= buildargv (s
);
2988 if (s
!= NULL
&& argv
== NULL
)
2996 compare_positive_ints (const void *ap
, const void *bp
)
2998 /* Because we know we're comparing two ints which are positive,
2999 there's no danger of overflow here. */
3000 return * (int *) ap
- * (int *) bp
;
3003 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3004 #define AMBIGUOUS_MESS2 \
3005 ".\nUse \"set gnutarget format-name\" to specify the format."
3008 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
3012 /* Check if errmsg just need simple return. */
3013 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
3014 return bfd_errmsg (error_tag
);
3016 std::string
ret (bfd_errmsg (error_tag
));
3017 ret
+= AMBIGUOUS_MESS1
;
3019 for (p
= matching
; *p
; p
++)
3024 ret
+= AMBIGUOUS_MESS2
;
3031 /* Return ARGS parsed as a valid pid, or throw an error. */
3034 parse_pid_to_attach (const char *args
)
3040 error_no_arg (_("process-id to attach"));
3042 dummy
= (char *) args
;
3043 pid
= strtoul (args
, &dummy
, 0);
3044 /* Some targets don't set errno on errors, grrr! */
3045 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
3046 error (_("Illegal process-id: %s."), args
);
3051 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3052 must come from xrealloc-compatible allocator and it may be updated. FROM
3053 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3054 located at the start or end of *STRINGP. */
3057 substitute_path_component (char **stringp
, const char *from
, const char *to
)
3059 char *string
= *stringp
, *s
;
3060 const size_t from_len
= strlen (from
);
3061 const size_t to_len
= strlen (to
);
3065 s
= strstr (s
, from
);
3069 if ((s
== string
|| IS_DIR_SEPARATOR (s
[-1])
3070 || s
[-1] == DIRNAME_SEPARATOR
)
3071 && (s
[from_len
] == '\0' || IS_DIR_SEPARATOR (s
[from_len
])
3072 || s
[from_len
] == DIRNAME_SEPARATOR
))
3077 = (char *) xrealloc (string
, (strlen (string
) + to_len
+ 1));
3079 /* Relocate the current S pointer. */
3080 s
= s
- string
+ string_new
;
3081 string
= string_new
;
3083 /* Replace from by to. */
3084 memmove (&s
[to_len
], &s
[from_len
], strlen (&s
[from_len
]) + 1);
3085 memcpy (s
, to
, to_len
);
3100 /* SIGALRM handler for waitpid_with_timeout. */
3103 sigalrm_handler (int signo
)
3105 /* Nothing to do. */
3110 /* Wrapper to wait for child PID to die with TIMEOUT.
3111 TIMEOUT is the time to stop waiting in seconds.
3112 If TIMEOUT is zero, pass WNOHANG to waitpid.
3113 Returns PID if it was successfully waited for, otherwise -1.
3115 Timeouts are currently implemented with alarm and SIGALRM.
3116 If the host does not support them, this waits "forever".
3117 It would be odd though for a host to have waitpid and not SIGALRM. */
3120 wait_to_die_with_timeout (pid_t pid
, int *status
, int timeout
)
3122 pid_t waitpid_result
;
3124 gdb_assert (pid
> 0);
3125 gdb_assert (timeout
>= 0);
3130 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3131 struct sigaction sa
, old_sa
;
3133 sa
.sa_handler
= sigalrm_handler
;
3134 sigemptyset (&sa
.sa_mask
);
3136 sigaction (SIGALRM
, &sa
, &old_sa
);
3140 ofunc
= signal (SIGALRM
, sigalrm_handler
);
3146 waitpid_result
= waitpid (pid
, status
, 0);
3150 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3151 sigaction (SIGALRM
, &old_sa
, NULL
);
3153 signal (SIGALRM
, ofunc
);
3158 waitpid_result
= waitpid (pid
, status
, WNOHANG
);
3160 if (waitpid_result
== pid
)
3166 #endif /* HAVE_WAITPID */
3168 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3169 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3171 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3172 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3175 gdb_filename_fnmatch (const char *pattern
, const char *string
, int flags
)
3177 gdb_assert ((flags
& FNM_FILE_NAME
) != 0);
3179 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3180 gdb_assert ((flags
& FNM_NOESCAPE
) != 0);
3182 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3184 char *pattern_slash
, *string_slash
;
3186 /* Replace '\' by '/' in both strings. */
3188 pattern_slash
= (char *) alloca (strlen (pattern
) + 1);
3189 strcpy (pattern_slash
, pattern
);
3190 pattern
= pattern_slash
;
3191 for (; *pattern_slash
!= 0; pattern_slash
++)
3192 if (IS_DIR_SEPARATOR (*pattern_slash
))
3193 *pattern_slash
= '/';
3195 string_slash
= (char *) alloca (strlen (string
) + 1);
3196 strcpy (string_slash
, string
);
3197 string
= string_slash
;
3198 for (; *string_slash
!= 0; string_slash
++)
3199 if (IS_DIR_SEPARATOR (*string_slash
))
3200 *string_slash
= '/';
3202 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3204 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3205 flags
|= FNM_CASEFOLD
;
3206 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3208 return fnmatch (pattern
, string
, flags
);
3211 /* Return the number of path elements in PATH.
3219 count_path_elements (const char *path
)
3222 const char *p
= path
;
3224 if (HAS_DRIVE_SPEC (p
))
3226 p
= STRIP_DRIVE_SPEC (p
);
3232 if (IS_DIR_SEPARATOR (*p
))
3237 /* Backup one if last character is /, unless it's the only one. */
3238 if (p
> path
+ 1 && IS_DIR_SEPARATOR (p
[-1]))
3241 /* Add one for the file name, if present. */
3242 if (p
> path
&& !IS_DIR_SEPARATOR (p
[-1]))
3248 /* Remove N leading path elements from PATH.
3249 N must be non-negative.
3250 If PATH has more than N path elements then return NULL.
3251 If PATH has exactly N path elements then return "".
3252 See count_path_elements for a description of how we do the counting. */
3255 strip_leading_path_elements (const char *path
, int n
)
3258 const char *p
= path
;
3260 gdb_assert (n
>= 0);
3265 if (HAS_DRIVE_SPEC (p
))
3267 p
= STRIP_DRIVE_SPEC (p
);
3273 while (*p
!= '\0' && !IS_DIR_SEPARATOR (*p
))
3291 copy_bitwise (gdb_byte
*dest
, ULONGEST dest_offset
,
3292 const gdb_byte
*source
, ULONGEST source_offset
,
3293 ULONGEST nbits
, int bits_big_endian
)
3295 unsigned int buf
, avail
;
3300 if (bits_big_endian
)
3302 /* Start from the end, then work backwards. */
3303 dest_offset
+= nbits
- 1;
3304 dest
+= dest_offset
/ 8;
3305 dest_offset
= 7 - dest_offset
% 8;
3306 source_offset
+= nbits
- 1;
3307 source
+= source_offset
/ 8;
3308 source_offset
= 7 - source_offset
% 8;
3312 dest
+= dest_offset
/ 8;
3314 source
+= source_offset
/ 8;
3318 /* Fill BUF with DEST_OFFSET bits from the destination and 8 -
3319 SOURCE_OFFSET bits from the source. */
3320 buf
= *(bits_big_endian
? source
-- : source
++) >> source_offset
;
3321 buf
<<= dest_offset
;
3322 buf
|= *dest
& ((1 << dest_offset
) - 1);
3324 /* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
3325 nbits
+= dest_offset
;
3326 avail
= dest_offset
+ 8 - source_offset
;
3328 /* Flush 8 bits from BUF, if appropriate. */
3329 if (nbits
>= 8 && avail
>= 8)
3331 *(bits_big_endian
? dest
-- : dest
++) = buf
;
3337 /* Copy the middle part. */
3340 size_t len
= nbits
/ 8;
3342 /* Use a faster method for byte-aligned copies. */
3345 if (bits_big_endian
)
3349 memcpy (dest
+ 1, source
+ 1, len
);
3353 memcpy (dest
, source
, len
);
3362 buf
|= *(bits_big_endian
? source
-- : source
++) << avail
;
3363 *(bits_big_endian
? dest
-- : dest
++) = buf
;
3370 /* Write the last byte. */
3374 buf
|= *source
<< avail
;
3376 buf
&= (1 << nbits
) - 1;
3377 *dest
= (*dest
& (~0 << nbits
)) | buf
;
3382 _initialize_utils (void)
3384 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
3385 Set number of characters where GDB should wrap lines of its output."), _("\
3386 Show number of characters where GDB should wrap lines of its output."), _("\
3387 This affects where GDB wraps its output to fit the screen width.\n\
3388 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
3390 show_chars_per_line
,
3391 &setlist
, &showlist
);
3393 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
3394 Set number of lines in a page for GDB output pagination."), _("\
3395 Show number of lines in a page for GDB output pagination."), _("\
3396 This affects the number of lines after which GDB will pause\n\
3397 its output and ask you whether to continue.\n\
3398 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
3400 show_lines_per_page
,
3401 &setlist
, &showlist
);
3403 add_setshow_boolean_cmd ("pagination", class_support
,
3404 &pagination_enabled
, _("\
3405 Set state of GDB output pagination."), _("\
3406 Show state of GDB output pagination."), _("\
3407 When pagination is ON, GDB pauses at end of each screenful of\n\
3408 its output and asks you whether to continue.\n\
3409 Turning pagination off is an alternative to \"set height unlimited\"."),
3411 show_pagination_enabled
,
3412 &setlist
, &showlist
);
3414 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
3415 &sevenbit_strings
, _("\
3416 Set printing of 8-bit characters in strings as \\nnn."), _("\
3417 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
3419 show_sevenbit_strings
,
3420 &setprintlist
, &showprintlist
);
3422 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
3423 &debug_timestamp
, _("\
3424 Set timestamping of debugging messages."), _("\
3425 Show timestamping of debugging messages."), _("\
3426 When set, debugging messages will be marked with seconds and microseconds."),
3428 show_debug_timestamp
,
3429 &setdebuglist
, &showdebuglist
);
3431 add_internal_problem_command (&internal_error_problem
);
3432 add_internal_problem_command (&internal_warning_problem
);
3433 add_internal_problem_command (&demangler_warning_problem
);
3436 selftests::register_test ("gdb_realpath", gdb_realpath_tests
);