1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 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"
66 #include "gdb_regex.h"
67 #include "gdbsupport/job-control.h"
68 #include "gdbsupport/selftest.h"
69 #include "gdbsupport/gdb_optional.h"
70 #include "cp-support.h"
72 #include "gdbsupport/pathstuff.h"
73 #include "cli/cli-style.h"
74 #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 *,
84 ATTRIBUTE_PRINTF (2, 0);
86 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
88 static void prompt_for_continue (void);
90 static void set_screen_size (void);
91 static void set_width (void);
93 /* Time spent in prompt_for_continue in the currently executing command
94 waiting for user to respond.
95 Initialized in make_command_stats_cleanup.
96 Modified in prompt_for_continue and defaulted_query.
97 Used in report_command_stats. */
99 static std::chrono::steady_clock::duration prompt_for_continue_wait_time
;
101 /* A flag indicating whether to timestamp debugging messages. */
103 static bool debug_timestamp
= false;
105 /* True means that strings with character values >0x7F should be printed
106 as octal escapes. False means just print the value (e.g. it's an
107 international character, and the terminal or window can cope.) */
109 bool sevenbit_strings
= false;
111 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
112 struct cmd_list_element
*c
, const char *value
)
114 fprintf_filtered (file
, _("Printing of 8-bit characters "
115 "in strings as \\nnn is %s.\n"),
119 /* String to be printed before warning messages, if any. */
121 const char *warning_pre_print
= "\nwarning: ";
123 bool pagination_enabled
= true;
125 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
126 struct cmd_list_element
*c
, const char *value
)
128 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
134 /* Print a warning message. The first argument STRING is the warning
135 message, used as an fprintf format string, the second is the
136 va_list of arguments for that string. A warning is unfiltered (not
137 paginated) so that the user does not need to page through each
138 screen full of warnings when there are lots of them. */
141 vwarning (const char *string
, va_list args
)
143 if (deprecated_warning_hook
)
144 (*deprecated_warning_hook
) (string
, args
);
147 gdb::optional
<target_terminal::scoped_restore_terminal_state
> term_state
;
148 if (target_supports_terminal_ours ())
150 term_state
.emplace ();
151 target_terminal::ours_for_output ();
153 if (filtered_printing_initialized ())
154 wrap_here (""); /* Force out any buffered output. */
155 gdb_flush (gdb_stdout
);
156 if (warning_pre_print
)
157 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
158 vfprintf_unfiltered (gdb_stderr
, string
, args
);
159 fprintf_unfiltered (gdb_stderr
, "\n");
163 /* Print an error message and return to command level.
164 The first argument STRING is the error message, used as a fprintf string,
165 and the remaining args are passed as arguments to it. */
168 verror (const char *string
, va_list args
)
170 throw_verror (GENERIC_ERROR
, string
, args
);
174 error_stream (const string_file
&stream
)
176 error (("%s"), stream
.c_str ());
179 /* Emit a message and abort. */
181 static void ATTRIBUTE_NORETURN
182 abort_with_message (const char *msg
)
184 if (current_ui
== NULL
)
187 fputs_unfiltered (msg
, gdb_stderr
);
189 abort (); /* ARI: abort */
192 /* Dump core trying to increase the core soft limit to hard limit first. */
197 #ifdef HAVE_SETRLIMIT
198 struct rlimit rlim
= { (rlim_t
) RLIM_INFINITY
, (rlim_t
) RLIM_INFINITY
};
200 setrlimit (RLIMIT_CORE
, &rlim
);
201 #endif /* HAVE_SETRLIMIT */
203 abort (); /* ARI: abort */
206 /* Check whether GDB will be able to dump core using the dump_core
207 function. Returns zero if GDB cannot or should not dump core.
208 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
209 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
212 can_dump_core (enum resource_limit_kind limit_kind
)
214 #ifdef HAVE_GETRLIMIT
217 /* Be quiet and assume we can dump if an error is returned. */
218 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
224 if (rlim
.rlim_cur
== 0)
229 if (rlim
.rlim_max
== 0)
232 #endif /* HAVE_GETRLIMIT */
237 /* Print a warning that we cannot dump core. */
240 warn_cant_dump_core (const char *reason
)
242 fprintf_unfiltered (gdb_stderr
,
243 _("%s\nUnable to dump core, use `ulimit -c"
244 " unlimited' before executing GDB next time.\n"),
248 /* Check whether GDB will be able to dump core using the dump_core
249 function, and print a warning if we cannot. */
252 can_dump_core_warn (enum resource_limit_kind limit_kind
,
255 int core_dump_allowed
= can_dump_core (limit_kind
);
257 if (!core_dump_allowed
)
258 warn_cant_dump_core (reason
);
260 return core_dump_allowed
;
263 /* Allow the user to configure the debugger behavior with respect to
264 what to do when an internal problem is detected. */
266 const char internal_problem_ask
[] = "ask";
267 const char internal_problem_yes
[] = "yes";
268 const char internal_problem_no
[] = "no";
269 static const char *const internal_problem_modes
[] =
271 internal_problem_ask
,
272 internal_problem_yes
,
277 /* Print a message reporting an internal error/warning. Ask the user
278 if they want to continue, dump core, or just exit. Return
279 something to indicate a quit. */
281 struct internal_problem
284 int user_settable_should_quit
;
285 const char *should_quit
;
286 int user_settable_should_dump_core
;
287 const char *should_dump_core
;
290 /* Report a problem, internal to GDB, to the user. Once the problem
291 has been reported, and assuming GDB didn't quit, the caller can
292 either allow execution to resume or throw an error. */
294 static void ATTRIBUTE_PRINTF (4, 0)
295 internal_vproblem (struct internal_problem
*problem
,
296 const char *file
, int line
, const char *fmt
, va_list ap
)
303 /* Don't allow infinite error/warning recursion. */
305 static const char msg
[] = "Recursive internal problem.\n";
314 abort_with_message (msg
);
317 /* Newer GLIBC versions put the warn_unused_result attribute
318 on write, but this is one of those rare cases where
319 ignoring the return value is correct. Casting to (void)
320 does not fix this problem. This is the solution suggested
321 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
322 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
323 abort (); /* ARI: abort */
328 /* Create a string containing the full error/warning message. Need
329 to call query with this full string, as otherwize the reason
330 (error/warning) and question become separated. Format using a
331 style similar to a compiler error message. Include extra detail
332 so that the user knows that they are living on the edge. */
334 std::string msg
= string_vprintf (fmt
, ap
);
335 reason
= string_printf ("%s:%d: %s: %s\n"
336 "A problem internal to GDB has been detected,\n"
337 "further debugging may prove unreliable.",
338 file
, line
, problem
->name
, msg
.c_str ());
341 /* Fall back to abort_with_message if gdb_stderr is not set up. */
342 if (current_ui
== NULL
)
344 fputs (reason
.c_str (), stderr
);
345 abort_with_message ("\n");
348 /* Try to get the message out and at the start of a new line. */
349 gdb::optional
<target_terminal::scoped_restore_terminal_state
> term_state
;
350 if (target_supports_terminal_ours ())
352 term_state
.emplace ();
353 target_terminal::ours_for_output ();
355 if (filtered_printing_initialized ())
358 /* Emit the message unless query will emit it below. */
359 if (problem
->should_quit
!= internal_problem_ask
361 || !filtered_printing_initialized ())
362 fprintf_unfiltered (gdb_stderr
, "%s\n", reason
.c_str ());
364 if (problem
->should_quit
== internal_problem_ask
)
366 /* Default (yes/batch case) is to quit GDB. When in batch mode
367 this lessens the likelihood of GDB going into an infinite
369 if (!confirm
|| !filtered_printing_initialized ())
372 quit_p
= query (_("%s\nQuit this debugging session? "),
375 else if (problem
->should_quit
== internal_problem_yes
)
377 else if (problem
->should_quit
== internal_problem_no
)
380 internal_error (__FILE__
, __LINE__
, _("bad switch"));
382 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr
);
383 if (REPORT_BUGS_TO
[0])
384 fprintf_unfiltered (gdb_stderr
, _(" For instructions, see:\n%s."),
386 fputs_unfiltered ("\n\n", gdb_stderr
);
388 if (problem
->should_dump_core
== internal_problem_ask
)
390 if (!can_dump_core_warn (LIMIT_MAX
, reason
.c_str ()))
392 else if (!filtered_printing_initialized ())
396 /* Default (yes/batch case) is to dump core. This leaves a GDB
397 `dropping' so that it is easier to see that something went
399 dump_core_p
= query (_("%s\nCreate a core file of GDB? "),
403 else if (problem
->should_dump_core
== internal_problem_yes
)
404 dump_core_p
= can_dump_core_warn (LIMIT_MAX
, reason
.c_str ());
405 else if (problem
->should_dump_core
== internal_problem_no
)
408 internal_error (__FILE__
, __LINE__
, _("bad switch"));
421 #ifdef HAVE_WORKING_FORK
431 static struct internal_problem internal_error_problem
= {
432 "internal-error", 1, internal_problem_ask
, 1, internal_problem_ask
436 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
438 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
439 throw_quit (_("Command aborted."));
442 static struct internal_problem internal_warning_problem
= {
443 "internal-warning", 1, internal_problem_ask
, 1, internal_problem_ask
447 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
449 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
452 static struct internal_problem demangler_warning_problem
= {
453 "demangler-warning", 1, internal_problem_ask
, 0, internal_problem_no
457 demangler_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
459 internal_vproblem (&demangler_warning_problem
, file
, line
, fmt
, ap
);
463 demangler_warning (const char *file
, int line
, const char *string
, ...)
467 va_start (ap
, string
);
468 demangler_vwarning (file
, line
, string
, ap
);
472 /* Dummy functions to keep add_prefix_cmd happy. */
475 set_internal_problem_cmd (const char *args
, int from_tty
)
480 show_internal_problem_cmd (const char *args
, int from_tty
)
484 /* When GDB reports an internal problem (error or warning) it gives
485 the user the opportunity to quit GDB and/or create a core file of
486 the current debug session. This function registers a few commands
487 that make it possible to specify that GDB should always or never
488 quit or create a core file, without asking. The commands look
491 maint set PROBLEM-NAME quit ask|yes|no
492 maint show PROBLEM-NAME quit
493 maint set PROBLEM-NAME corefile ask|yes|no
494 maint show PROBLEM-NAME corefile
496 Where PROBLEM-NAME is currently "internal-error" or
497 "internal-warning". */
500 add_internal_problem_command (struct internal_problem
*problem
)
502 struct cmd_list_element
**set_cmd_list
;
503 struct cmd_list_element
**show_cmd_list
;
507 set_cmd_list
= XNEW (struct cmd_list_element
*);
508 show_cmd_list
= XNEW (struct cmd_list_element
*);
509 *set_cmd_list
= NULL
;
510 *show_cmd_list
= NULL
;
512 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
515 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
518 add_prefix_cmd (problem
->name
,
519 class_maintenance
, set_internal_problem_cmd
, set_doc
,
521 concat ("maintenance set ", problem
->name
, " ",
523 0/*allow-unknown*/, &maintenance_set_cmdlist
);
525 add_prefix_cmd (problem
->name
,
526 class_maintenance
, show_internal_problem_cmd
, show_doc
,
528 concat ("maintenance show ", problem
->name
, " ",
530 0/*allow-unknown*/, &maintenance_show_cmdlist
);
532 if (problem
->user_settable_should_quit
)
534 set_doc
= xstrprintf (_("Set whether GDB should quit "
535 "when an %s is detected."),
537 show_doc
= xstrprintf (_("Show whether GDB will quit "
538 "when an %s is detected."),
540 add_setshow_enum_cmd ("quit", class_maintenance
,
541 internal_problem_modes
,
542 &problem
->should_quit
,
555 if (problem
->user_settable_should_dump_core
)
557 set_doc
= xstrprintf (_("Set whether GDB should create a core "
558 "file of GDB when %s is detected."),
560 show_doc
= xstrprintf (_("Show whether GDB will create a core "
561 "file of GDB when %s is detected."),
563 add_setshow_enum_cmd ("corefile", class_maintenance
,
564 internal_problem_modes
,
565 &problem
->should_dump_core
,
579 /* Return a newly allocated string, containing the PREFIX followed
580 by the system error message for errno (separated by a colon). */
583 perror_string (const char *prefix
)
585 const char *err
= safe_strerror (errno
);
586 return std::string (prefix
) + ": " + err
;
589 /* Print the system error message for errno, and also mention STRING
590 as the file name for which the error was encountered. Use ERRCODE
591 for the thrown exception. Then return to command level. */
594 throw_perror_with_name (enum errors errcode
, const char *string
)
596 std::string combined
= perror_string (string
);
598 /* I understand setting these is a matter of taste. Still, some people
599 may clear errno but not know about bfd_error. Doing this here is not
601 bfd_set_error (bfd_error_no_error
);
604 throw_error (errcode
, _("%s."), combined
.c_str ());
607 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
610 perror_with_name (const char *string
)
612 throw_perror_with_name (GENERIC_ERROR
, string
);
615 /* Same as perror_with_name except that it prints a warning instead
616 of throwing an error. */
619 perror_warning_with_name (const char *string
)
621 std::string combined
= perror_string (string
);
622 warning (_("%s"), combined
.c_str ());
625 /* Print the system error message for ERRCODE, and also mention STRING
626 as the file name for which the error was encountered. */
629 print_sys_errmsg (const char *string
, int errcode
)
631 const char *err
= safe_strerror (errcode
);
632 /* We want anything which was printed on stdout to come out first, before
634 gdb_flush (gdb_stdout
);
635 fprintf_unfiltered (gdb_stderr
, "%s: %s.\n", string
, err
);
638 /* Control C eventually causes this to be called, at a convenient time. */
643 if (sync_quit_force_run
)
645 sync_quit_force_run
= 0;
646 quit_force (NULL
, 0);
650 /* No steenking SIGINT will ever be coming our way when the
651 program is resumed. Don't lie. */
655 /* If there is no terminal switching for this target, then we can't
656 possibly get screwed by the lack of job control. */
657 || !target_supports_terminal_ours ())
660 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
669 if (sync_quit_force_run
)
676 /* Called when a memory allocation fails, with the number of bytes of
677 memory requested in SIZE. */
680 malloc_failure (long size
)
684 internal_error (__FILE__
, __LINE__
,
685 _("virtual memory exhausted: can't allocate %ld bytes."),
690 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
694 /* See common/errors.h. */
699 gdb_stdout
->flush ();
700 gdb_stderr
->flush ();
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 environment 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 (!gdb_stdout
->isatty ())
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 specified 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 stream
->puts (style
.to_ansi ().c_str ());
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 stream
->puts (wrap_buffer
.c_str ());
1552 wrap_buffer
.clear ();
1559 gdb_flush (struct ui_file
*stream
)
1561 flush_wrap_buffer (stream
);
1565 /* Indicate that if the next sequence of characters overflows the line,
1566 a newline should be inserted here rather than when it hits the end.
1567 If INDENT is non-null, it is a string to be printed to indent the
1568 wrapped part on the next line. INDENT must remain accessible until
1569 the next call to wrap_here() or until a newline is printed through
1572 If the line is already overfull, we immediately print a newline and
1573 the indentation, and disable further wrapping.
1575 If we don't know the width of lines, but we know the page height,
1576 we must not wrap words, but should still keep track of newlines
1577 that were explicitly printed.
1579 INDENT should not contain tabs, as that will mess up the char count
1580 on the next line. FIXME.
1582 This routine is guaranteed to force out any output which has been
1583 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1584 used to force out output from the wrap_buffer. */
1587 wrap_here (const char *indent
)
1589 /* This should have been allocated, but be paranoid anyway. */
1590 gdb_assert (filter_initialized
);
1592 flush_wrap_buffer (gdb_stdout
);
1593 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
1597 else if (chars_printed
>= chars_per_line
)
1599 puts_filtered ("\n");
1601 puts_filtered (indent
);
1606 wrap_column
= chars_printed
;
1610 wrap_indent
= indent
;
1611 wrap_style
= applied_style
;
1615 /* Print input string to gdb_stdout, filtered, with wrap,
1616 arranging strings in columns of n chars. String can be
1617 right or left justified in the column. Never prints
1618 trailing spaces. String should never be longer than
1619 width. FIXME: this could be useful for the EXAMINE
1620 command, which currently doesn't tabulate very well. */
1623 puts_filtered_tabular (char *string
, int width
, int right
)
1629 gdb_assert (chars_per_line
> 0);
1630 if (chars_per_line
== UINT_MAX
)
1632 fputs_filtered (string
, gdb_stdout
);
1633 fputs_filtered ("\n", gdb_stdout
);
1637 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1638 fputs_filtered ("\n", gdb_stdout
);
1640 if (width
>= chars_per_line
)
1641 width
= chars_per_line
- 1;
1643 stringlen
= strlen (string
);
1645 if (chars_printed
> 0)
1646 spaces
= width
- (chars_printed
- 1) % width
- 1;
1648 spaces
+= width
- stringlen
;
1650 spacebuf
= (char *) alloca (spaces
+ 1);
1651 spacebuf
[spaces
] = '\0';
1653 spacebuf
[spaces
] = ' ';
1655 fputs_filtered (spacebuf
, gdb_stdout
);
1656 fputs_filtered (string
, gdb_stdout
);
1660 /* Ensure that whatever gets printed next, using the filtered output
1661 commands, starts at the beginning of the line. I.e. if there is
1662 any pending output for the current line, flush it and start a new
1663 line. Otherwise do nothing. */
1668 if (chars_printed
> 0)
1670 puts_filtered ("\n");
1675 /* Like fputs but if FILTER is true, pause after every screenful.
1677 Regardless of FILTER can wrap at points other than the final
1678 character of a line.
1680 Unlike fputs, fputs_maybe_filtered does not return a value.
1681 It is OK for LINEBUFFER to be NULL, in which case just don't print
1684 Note that a longjmp to top level may occur in this routine (only if
1685 FILTER is true) (since prompt_for_continue may do so) so this
1686 routine should not be called when cleanups are not in place. */
1689 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1692 const char *lineptr
;
1694 if (linebuffer
== 0)
1697 /* Don't do any filtering if it is disabled. */
1698 if (stream
!= gdb_stdout
1699 || !pagination_enabled
1700 || pagination_disabled_for_command
1702 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
1703 || top_level_interpreter () == NULL
1704 || top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ())
1706 flush_wrap_buffer (stream
);
1707 stream
->puts (linebuffer
);
1712 = make_scope_exit ([&] ()
1714 wrap_buffer
.clear ();
1719 /* Go through and output each character. Show line extension
1720 when this is necessary; prompt user for new page when this is
1723 lineptr
= linebuffer
;
1726 /* Possible new page. Note that PAGINATION_DISABLED_FOR_COMMAND
1727 might be set during this loop, so we must continue to check
1729 if (filter
&& (lines_printed
>= lines_per_page
- 1)
1730 && !pagination_disabled_for_command
)
1731 prompt_for_continue ();
1733 while (*lineptr
&& *lineptr
!= '\n')
1737 /* Print a single line. */
1738 if (*lineptr
== '\t')
1740 wrap_buffer
.push_back ('\t');
1741 /* Shifting right by 3 produces the number of tab stops
1742 we have already passed, and then adding one and
1743 shifting left 3 advances to the next tab stop. */
1744 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1747 else if (*lineptr
== '\033'
1748 && skip_ansi_escape (lineptr
, &skip_bytes
))
1750 wrap_buffer
.append (lineptr
, skip_bytes
);
1751 /* Note that we don't consider this a character, so we
1752 don't increment chars_printed here. */
1753 lineptr
+= skip_bytes
;
1757 wrap_buffer
.push_back (*lineptr
);
1762 if (chars_printed
>= chars_per_line
)
1764 unsigned int save_chars
= chars_printed
;
1766 /* If we change the style, below, we'll want to reset it
1767 before continuing to print. If there is no wrap
1768 column, then we'll only reset the style if the pager
1769 prompt is given; and to avoid emitting style
1770 sequences in the middle of a run of text, we track
1772 ui_file_style save_style
;
1773 bool did_paginate
= false;
1779 save_style
= wrap_style
;
1780 if (stream
->can_emit_style_escape ())
1781 emit_style_escape (ui_file_style (), stream
);
1782 /* If we aren't actually wrapping, don't output
1783 newline -- if chars_per_line is right, we
1784 probably just overflowed anyway; if it's wrong,
1785 let us keep going. */
1786 /* XXX: The ideal thing would be to call
1787 'stream->putc' here, but we can't because it
1788 currently calls 'fputc_unfiltered', which ends up
1789 calling us, which generates an infinite
1791 stream
->puts ("\n");
1795 save_style
= applied_style
;
1796 flush_wrap_buffer (stream
);
1799 /* Possible new page. Note that
1800 PAGINATION_DISABLED_FOR_COMMAND might be set during
1801 this loop, so we must continue to check it here. */
1802 if (lines_printed
>= lines_per_page
- 1
1803 && !pagination_disabled_for_command
)
1805 prompt_for_continue ();
1806 did_paginate
= true;
1809 /* Now output indentation and wrapped string. */
1812 stream
->puts (wrap_indent
);
1813 if (stream
->can_emit_style_escape ())
1814 emit_style_escape (save_style
, stream
);
1815 /* FIXME, this strlen is what prevents wrap_indent from
1816 containing tabs. However, if we recurse to print it
1817 and count its chars, we risk trouble if wrap_indent is
1818 longer than (the user settable) chars_per_line.
1819 Note also that this can set chars_printed > chars_per_line
1820 if we are printing a long string. */
1821 chars_printed
= strlen (wrap_indent
)
1822 + (save_chars
- wrap_column
);
1823 wrap_column
= 0; /* And disable fancy wrap */
1825 else if (did_paginate
&& stream
->can_emit_style_escape ())
1826 emit_style_escape (save_style
, stream
);
1830 if (*lineptr
== '\n')
1833 wrap_here ((char *) 0); /* Spit out chars, cancel
1836 /* XXX: The ideal thing would be to call
1837 'stream->putc' here, but we can't because it
1838 currently calls 'fputc_unfiltered', which ends up
1839 calling us, which generates an infinite
1841 stream
->puts ("\n");
1846 buffer_clearer
.release ();
1850 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1852 fputs_maybe_filtered (linebuffer
, stream
, 1);
1856 fputs_unfiltered (const char *linebuffer
, struct ui_file
*stream
)
1858 fputs_maybe_filtered (linebuffer
, stream
, 0);
1864 fputs_styled (const char *linebuffer
, const ui_file_style
&style
,
1865 struct ui_file
*stream
)
1867 /* This just makes it so we emit somewhat fewer escape
1869 if (style
.is_default ())
1870 fputs_maybe_filtered (linebuffer
, stream
, 1);
1873 set_output_style (stream
, style
);
1874 fputs_maybe_filtered (linebuffer
, stream
, 1);
1875 set_output_style (stream
, ui_file_style ());
1882 fputs_styled_unfiltered (const char *linebuffer
, const ui_file_style
&style
,
1883 struct ui_file
*stream
)
1885 /* This just makes it so we emit somewhat fewer escape
1887 if (style
.is_default ())
1888 fputs_maybe_filtered (linebuffer
, stream
, 0);
1891 set_output_style (stream
, style
);
1892 fputs_maybe_filtered (linebuffer
, stream
, 0);
1893 set_output_style (stream
, ui_file_style ());
1900 fputs_highlighted (const char *str
, const compiled_regex
&highlight
,
1901 struct ui_file
*stream
)
1905 while (*str
&& highlight
.exec (str
, 1, &pmatch
, 0) == 0)
1907 size_t n_highlight
= pmatch
.rm_eo
- pmatch
.rm_so
;
1909 /* Output the part before pmatch with current style. */
1910 while (pmatch
.rm_so
> 0)
1912 fputc_filtered (*str
, stream
);
1917 /* Output pmatch with the highlight style. */
1918 set_output_style (stream
, highlight_style
.style ());
1919 while (n_highlight
> 0)
1921 fputc_filtered (*str
, stream
);
1925 set_output_style (stream
, ui_file_style ());
1928 /* Output the trailing part of STR not matching HIGHLIGHT. */
1930 fputs_filtered (str
, stream
);
1934 putchar_unfiltered (int c
)
1936 return fputc_unfiltered (c
, gdb_stdout
);
1939 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1940 May return nonlocally. */
1943 putchar_filtered (int c
)
1945 return fputc_filtered (c
, gdb_stdout
);
1949 fputc_unfiltered (int c
, struct ui_file
*stream
)
1955 fputs_unfiltered (buf
, stream
);
1960 fputc_filtered (int c
, struct ui_file
*stream
)
1966 fputs_filtered (buf
, stream
);
1970 /* puts_debug is like fputs_unfiltered, except it prints special
1971 characters in printable fashion. */
1974 puts_debug (char *prefix
, char *string
, char *suffix
)
1978 /* Print prefix and suffix after each line. */
1979 static int new_line
= 1;
1980 static int return_p
= 0;
1981 static const char *prev_prefix
= "";
1982 static const char *prev_suffix
= "";
1984 if (*string
== '\n')
1987 /* If the prefix is changing, print the previous suffix, a new line,
1988 and the new prefix. */
1989 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
1991 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
1992 fputs_unfiltered ("\n", gdb_stdlog
);
1993 fputs_unfiltered (prefix
, gdb_stdlog
);
1996 /* Print prefix if we printed a newline during the previous call. */
2000 fputs_unfiltered (prefix
, gdb_stdlog
);
2003 prev_prefix
= prefix
;
2004 prev_suffix
= suffix
;
2006 /* Output characters in a printable format. */
2007 while ((ch
= *string
++) != '\0')
2013 fputc_unfiltered (ch
, gdb_stdlog
);
2016 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2020 fputs_unfiltered ("\\\\", gdb_stdlog
);
2023 fputs_unfiltered ("\\b", gdb_stdlog
);
2026 fputs_unfiltered ("\\f", gdb_stdlog
);
2030 fputs_unfiltered ("\\n", gdb_stdlog
);
2033 fputs_unfiltered ("\\r", gdb_stdlog
);
2036 fputs_unfiltered ("\\t", gdb_stdlog
);
2039 fputs_unfiltered ("\\v", gdb_stdlog
);
2043 return_p
= ch
== '\r';
2046 /* Print suffix if we printed a newline. */
2049 fputs_unfiltered (suffix
, gdb_stdlog
);
2050 fputs_unfiltered ("\n", gdb_stdlog
);
2055 /* Print a variable number of ARGS using format FORMAT. If this
2056 information is going to put the amount written (since the last call
2057 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2058 call prompt_for_continue to get the users permission to continue.
2060 Unlike fprintf, this function does not return a value.
2062 We implement three variants, vfprintf (takes a vararg list and stream),
2063 fprintf (takes a stream to write on), and printf (the usual).
2065 Note also that this may throw a quit (since prompt_for_continue may
2069 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2070 va_list args
, bool filter
, bool gdbfmt
)
2074 ui_out_flags flags
= disallow_ui_out_field
;
2076 flags
|= unfiltered_output
;
2077 cli_ui_out (stream
, flags
).vmessage (applied_style
, format
, args
);
2081 std::string str
= string_vprintf (format
, args
);
2082 fputs_maybe_filtered (str
.c_str (), stream
, filter
);
2088 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2090 vfprintf_maybe_filtered (stream
, format
, args
, true, true);
2094 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2096 if (debug_timestamp
&& stream
== gdb_stdlog
)
2098 using namespace std::chrono
;
2102 cli_ui_out (&sfile
, 0).vmessage (ui_file_style (), format
, args
);
2103 std::string linebuffer
= std::move (sfile
.string ());
2105 steady_clock::time_point now
= steady_clock::now ();
2106 seconds s
= duration_cast
<seconds
> (now
.time_since_epoch ());
2107 microseconds us
= duration_cast
<microseconds
> (now
.time_since_epoch () - s
);
2109 len
= linebuffer
.size ();
2110 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2112 std::string timestamp
= string_printf ("%ld.%06ld %s%s",
2115 linebuffer
.c_str (),
2116 need_nl
? "\n": "");
2117 fputs_unfiltered (timestamp
.c_str (), stream
);
2120 vfprintf_maybe_filtered (stream
, format
, args
, false, true);
2124 vprintf_filtered (const char *format
, va_list args
)
2126 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, true, false);
2130 vprintf_unfiltered (const char *format
, va_list args
)
2132 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2136 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2140 va_start (args
, format
);
2141 vfprintf_filtered (stream
, format
, args
);
2146 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2150 va_start (args
, format
);
2151 vfprintf_unfiltered (stream
, format
, args
);
2155 /* Like fprintf_filtered, but prints its result indented.
2156 Called as fprintfi_filtered (spaces, stream, format, ...); */
2159 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2164 va_start (args
, format
);
2165 print_spaces_filtered (spaces
, stream
);
2167 vfprintf_filtered (stream
, format
, args
);
2174 fprintf_styled (struct ui_file
*stream
, const ui_file_style
&style
,
2175 const char *format
, ...)
2179 set_output_style (stream
, style
);
2180 va_start (args
, format
);
2181 vfprintf_filtered (stream
, format
, args
);
2183 set_output_style (stream
, ui_file_style ());
2189 vfprintf_styled (struct ui_file
*stream
, const ui_file_style
&style
,
2190 const char *format
, va_list args
)
2192 set_output_style (stream
, style
);
2193 vfprintf_filtered (stream
, format
, args
);
2194 set_output_style (stream
, ui_file_style ());
2200 vfprintf_styled_no_gdbfmt (struct ui_file
*stream
, const ui_file_style
&style
,
2201 bool filter
, const char *format
, va_list args
)
2203 std::string str
= string_vprintf (format
, args
);
2206 if (!style
.is_default ())
2207 set_output_style (stream
, style
);
2208 fputs_maybe_filtered (str
.c_str (), stream
, filter
);
2209 if (!style
.is_default ())
2210 set_output_style (stream
, ui_file_style ());
2215 printf_filtered (const char *format
, ...)
2219 va_start (args
, format
);
2220 vfprintf_filtered (gdb_stdout
, format
, args
);
2226 printf_unfiltered (const char *format
, ...)
2230 va_start (args
, format
);
2231 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2235 /* Like printf_filtered, but prints it's result indented.
2236 Called as printfi_filtered (spaces, format, ...); */
2239 printfi_filtered (int spaces
, const char *format
, ...)
2243 va_start (args
, format
);
2244 print_spaces_filtered (spaces
, gdb_stdout
);
2245 vfprintf_filtered (gdb_stdout
, format
, args
);
2249 /* Easy -- but watch out!
2251 This routine is *not* a replacement for puts()! puts() appends a newline.
2252 This one doesn't, and had better not! */
2255 puts_filtered (const char *string
)
2257 fputs_filtered (string
, gdb_stdout
);
2261 puts_unfiltered (const char *string
)
2263 fputs_unfiltered (string
, gdb_stdout
);
2266 /* Return a pointer to N spaces and a null. The pointer is good
2267 until the next call to here. */
2272 static char *spaces
= 0;
2273 static int max_spaces
= -1;
2279 spaces
= (char *) xmalloc (n
+ 1);
2280 for (t
= spaces
+ n
; t
!= spaces
;)
2286 return spaces
+ max_spaces
- n
;
2289 /* Print N spaces. */
2291 print_spaces_filtered (int n
, struct ui_file
*stream
)
2293 fputs_filtered (n_spaces (n
), stream
);
2296 /* C++/ObjC demangler stuff. */
2298 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2299 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2300 If the name is not mangled, or the language for the name is unknown, or
2301 demangling is off, the name is printed in its "raw" form. */
2304 fprintf_symbol_filtered (struct ui_file
*stream
, const char *name
,
2305 enum language lang
, int arg_mode
)
2311 /* If user wants to see raw output, no problem. */
2314 fputs_filtered (name
, stream
);
2318 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2319 fputs_filtered (demangled
? demangled
: name
, stream
);
2320 if (demangled
!= NULL
)
2328 /* True if CH is a character that can be part of a symbol name. I.e.,
2329 either a number, a letter, or a '_'. */
2332 valid_identifier_name_char (int ch
)
2334 return (isalnum (ch
) || ch
== '_');
2337 /* Skip to end of token, or to END, whatever comes first. Input is
2338 assumed to be a C++ operator name. */
2341 cp_skip_operator_token (const char *token
, const char *end
)
2343 const char *p
= token
;
2344 while (p
!= end
&& !isspace (*p
) && *p
!= '(')
2346 if (valid_identifier_name_char (*p
))
2348 while (p
!= end
&& valid_identifier_name_char (*p
))
2354 /* Note, ordered such that among ops that share a prefix,
2355 longer comes first. This is so that the loop below can
2356 bail on first match. */
2357 static const char *ops
[] =
2363 "-=", "--", "->", "-",
2372 "<<=", "<=", "<<", "<",
2373 ">>=", ">=", ">>", ">",
2377 for (const char *op
: ops
)
2379 size_t oplen
= strlen (op
);
2380 size_t lencmp
= std::min
<size_t> (oplen
, end
- p
);
2382 if (strncmp (p
, op
, lencmp
) == 0)
2385 /* Some unidentified character. Return it. */
2393 /* Advance STRING1/STRING2 past whitespace. */
2396 skip_ws (const char *&string1
, const char *&string2
, const char *end_str2
)
2398 while (isspace (*string1
))
2400 while (string2
< end_str2
&& isspace (*string2
))
2404 /* True if STRING points at the start of a C++ operator name. START
2405 is the start of the string that STRING points to, hence when
2406 reading backwards, we must not read any character before START. */
2409 cp_is_operator (const char *string
, const char *start
)
2411 return ((string
== start
2412 || !valid_identifier_name_char (string
[-1]))
2413 && strncmp (string
, CP_OPERATOR_STR
, CP_OPERATOR_LEN
) == 0
2414 && !valid_identifier_name_char (string
[CP_OPERATOR_LEN
]));
2417 /* If *NAME points at an ABI tag, skip it and return true. Otherwise
2418 leave *NAME unmodified and return false. (see GCC's abi_tag
2419 attribute), such names are demangled as e.g.,
2420 "function[abi:cxx11]()". */
2423 skip_abi_tag (const char **name
)
2425 const char *p
= *name
;
2427 if (startswith (p
, "[abi:"))
2431 while (valid_identifier_name_char (*p
))
2447 strncmp_iw_with_mode (const char *string1
, const char *string2
,
2448 size_t string2_len
, strncmp_iw_mode mode
,
2449 enum language language
,
2450 completion_match_for_lcd
*match_for_lcd
)
2452 const char *string1_start
= string1
;
2453 const char *end_str2
= string2
+ string2_len
;
2454 bool skip_spaces
= true;
2455 bool have_colon_op
= (language
== language_cplus
2456 || language
== language_rust
2457 || language
== language_fortran
);
2462 || ((isspace (*string1
) && !valid_identifier_name_char (*string2
))
2463 || (isspace (*string2
) && !valid_identifier_name_char (*string1
))))
2465 skip_ws (string1
, string2
, end_str2
);
2466 skip_spaces
= false;
2469 /* Skip [abi:cxx11] tags in the symbol name if the lookup name
2470 doesn't include them. E.g.:
2472 string1: function[abi:cxx1](int)
2475 string1: function[abi:cxx1](int)
2476 string2: function(int)
2478 string1: Struct[abi:cxx1]::function()
2479 string2: Struct::function()
2481 string1: function(Struct[abi:cxx1], int)
2482 string2: function(Struct, int)
2484 if (string2
== end_str2
2485 || (*string2
!= '[' && !valid_identifier_name_char (*string2
)))
2487 const char *abi_start
= string1
;
2489 /* There can be more than one tag. */
2490 while (*string1
== '[' && skip_abi_tag (&string1
))
2493 if (match_for_lcd
!= NULL
&& abi_start
!= string1
)
2494 match_for_lcd
->mark_ignored_range (abi_start
, string1
);
2496 while (isspace (*string1
))
2500 if (*string1
== '\0' || string2
== end_str2
)
2503 /* Handle the :: operator. */
2504 if (have_colon_op
&& string1
[0] == ':' && string1
[1] == ':')
2506 if (*string2
!= ':')
2512 if (string2
== end_str2
)
2515 if (*string2
!= ':')
2521 while (isspace (*string1
))
2523 while (string2
< end_str2
&& isspace (*string2
))
2528 /* Handle C++ user-defined operators. */
2529 else if (language
== language_cplus
2532 if (cp_is_operator (string1
, string1_start
))
2534 /* An operator name in STRING1. Check STRING2. */
2536 = std::min
<size_t> (CP_OPERATOR_LEN
, end_str2
- string2
);
2537 if (strncmp (string1
, string2
, cmplen
) != 0)
2543 if (string2
!= end_str2
)
2545 /* Check for "operatorX" in STRING2. */
2546 if (valid_identifier_name_char (*string2
))
2549 skip_ws (string1
, string2
, end_str2
);
2552 /* Handle operator(). */
2553 if (*string1
== '(')
2555 if (string2
== end_str2
)
2557 if (mode
== strncmp_iw_mode::NORMAL
)
2561 /* Don't break for the regular return at the
2562 bottom, because "operator" should not
2563 match "operator()", since this open
2564 parentheses is not the parameter list
2566 return *string1
!= '\0';
2570 if (*string1
!= *string2
)
2579 skip_ws (string1
, string2
, end_str2
);
2581 /* Skip to end of token, or to END, whatever comes
2583 const char *end_str1
= string1
+ strlen (string1
);
2584 const char *p1
= cp_skip_operator_token (string1
, end_str1
);
2585 const char *p2
= cp_skip_operator_token (string2
, end_str2
);
2587 cmplen
= std::min (p1
- string1
, p2
- string2
);
2590 if (strncmp (string1
, string2
, cmplen
) != 0)
2595 if (p1
- string1
!= p2
- string2
)
2597 if (strncmp (string1
, string2
, cmplen
) != 0)
2604 if (*string1
== '\0' || string2
== end_str2
)
2606 if (*string1
== '(' || *string2
== '(')
2614 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
2616 if (case_sensitivity
== case_sensitive_off
2617 && (tolower ((unsigned char) *string1
)
2618 != tolower ((unsigned char) *string2
)))
2621 /* If we see any non-whitespace, non-identifier-name character
2622 (any of "()<>*&" etc.), then skip spaces the next time
2624 if (!isspace (*string1
) && !valid_identifier_name_char (*string1
))
2631 if (string2
== end_str2
)
2633 if (mode
== strncmp_iw_mode::NORMAL
)
2635 /* Strip abi tag markers from the matched symbol name.
2636 Usually the ABI marker will be found on function name
2637 (automatically added because the function returns an
2638 object marked with an ABI tag). However, it's also
2639 possible to see a marker in one of the function
2640 parameters, for example.
2642 string2 (lookup name):
2645 function(some_struct[abi:cxx11], int)
2647 and for completion LCD computation we want to say that
2649 function(some_struct, int)
2651 if (match_for_lcd
!= NULL
)
2653 while ((string1
= strstr (string1
, "[abi:")) != NULL
)
2655 const char *abi_start
= string1
;
2657 /* There can be more than one tag. */
2658 while (skip_abi_tag (&string1
) && *string1
== '[')
2661 if (abi_start
!= string1
)
2662 match_for_lcd
->mark_ignored_range (abi_start
, string1
);
2669 return (*string1
!= '\0' && *string1
!= '(');
2678 strncmp_iw (const char *string1
, const char *string2
, size_t string2_len
)
2680 return strncmp_iw_with_mode (string1
, string2
, string2_len
,
2681 strncmp_iw_mode::NORMAL
, language_minimal
);
2687 strcmp_iw (const char *string1
, const char *string2
)
2689 return strncmp_iw_with_mode (string1
, string2
, strlen (string2
),
2690 strncmp_iw_mode::MATCH_PARAMS
, language_minimal
);
2693 /* This is like strcmp except that it ignores whitespace and treats
2694 '(' as the first non-NULL character in terms of ordering. Like
2695 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2696 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2697 according to that ordering.
2699 If a list is sorted according to this function and if you want to
2700 find names in the list that match some fixed NAME according to
2701 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2702 where this function would put NAME.
2704 This function must be neutral to the CASE_SENSITIVITY setting as the user
2705 may choose it during later lookup. Therefore this function always sorts
2706 primarily case-insensitively and secondarily case-sensitively.
2708 Here are some examples of why using strcmp to sort is a bad idea:
2712 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2713 we try to do a search for "foo<char*>", strcmp will locate this
2714 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2715 will start looking at strings beginning with "goo", and will never
2716 see the correct match of "foo<char *>".
2718 Parenthesis example:
2720 In practice, this is less like to be an issue, but I'll give it a
2721 shot. Let's assume that '$' is a legitimate character to occur in
2722 symbols. (Which may well even be the case on some systems.) Then
2723 say that the partial symbol table contains "foo$" and "foo(int)".
2724 strcmp will put them in this order, since '$' < '('. Now, if the
2725 user searches for "foo", then strcmp will sort "foo" before "foo$".
2726 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2727 "foo") is false, so it won't proceed to the actual match of
2728 "foo(int)" with "foo". */
2731 strcmp_iw_ordered (const char *string1
, const char *string2
)
2733 const char *saved_string1
= string1
, *saved_string2
= string2
;
2734 enum case_sensitivity case_pass
= case_sensitive_off
;
2738 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2739 Provide stub characters if we are already at the end of one of the
2741 char c1
= 'X', c2
= 'X';
2743 while (*string1
!= '\0' && *string2
!= '\0')
2745 while (isspace (*string1
))
2747 while (isspace (*string2
))
2752 case case_sensitive_off
:
2753 c1
= tolower ((unsigned char) *string1
);
2754 c2
= tolower ((unsigned char) *string2
);
2756 case case_sensitive_on
:
2764 if (*string1
!= '\0')
2773 /* Characters are non-equal unless they're both '\0'; we want to
2774 make sure we get the comparison right according to our
2775 comparison in the cases where one of them is '\0' or '('. */
2777 if (*string2
== '\0')
2782 if (*string2
== '\0')
2787 if (*string2
== '\0' || *string2
== '(')
2796 if (case_pass
== case_sensitive_on
)
2799 /* Otherwise the strings were equal in case insensitive way, make
2800 a more fine grained comparison in a case sensitive way. */
2802 case_pass
= case_sensitive_on
;
2803 string1
= saved_string1
;
2804 string2
= saved_string2
;
2811 streq (const char *lhs
, const char *rhs
)
2813 return !strcmp (lhs
, rhs
);
2819 streq_hash (const void *lhs
, const void *rhs
)
2821 return streq ((const char *) lhs
, (const char *) rhs
);
2828 ** Answer whether string_to_compare is a full or partial match to
2829 ** template_string. The partial match must be in sequence starting
2833 subset_compare (const char *string_to_compare
, const char *template_string
)
2837 if (template_string
!= NULL
&& string_to_compare
!= NULL
2838 && strlen (string_to_compare
) <= strlen (template_string
))
2840 (startswith (template_string
, string_to_compare
));
2847 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2848 struct cmd_list_element
*c
, const char *value
)
2850 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
2858 address_significant (gdbarch
*gdbarch
, CORE_ADDR addr
)
2860 /* Clear insignificant bits of a target address and sign extend resulting
2861 address, avoiding shifts larger or equal than the width of a CORE_ADDR.
2862 The local variable ADDR_BIT stops the compiler reporting a shift overflow
2863 when it won't occur. Skip updating of target address if current target
2864 has not set gdbarch significant_addr_bit. */
2865 int addr_bit
= gdbarch_significant_addr_bit (gdbarch
);
2867 if (addr_bit
&& (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
)))
2869 CORE_ADDR sign
= (CORE_ADDR
) 1 << (addr_bit
- 1);
2870 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2871 addr
= (addr
^ sign
) - sign
;
2878 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2880 /* Truncate address to the size of a target address, avoiding shifts
2881 larger or equal than the width of a CORE_ADDR. The local
2882 variable ADDR_BIT stops the compiler reporting a shift overflow
2883 when it won't occur. */
2884 /* NOTE: This assumes that the significant address information is
2885 kept in the least significant bits of ADDR - the upper bits were
2886 either zero or sign extended. Should gdbarch_address_to_pointer or
2887 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2889 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2891 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2892 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2893 return hex_string (addr
);
2896 /* This function is described in "defs.h". */
2899 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2901 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2903 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2904 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2906 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2907 that returns the language localized string formatted to a width
2908 based on gdbarch_addr_bit. */
2910 return hex_string_custom (address
, 8);
2912 return hex_string_custom (address
, 16);
2915 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2918 core_addr_hash (const void *ap
)
2920 const CORE_ADDR
*addrp
= (const CORE_ADDR
*) ap
;
2925 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2928 core_addr_eq (const void *ap
, const void *bp
)
2930 const CORE_ADDR
*addr_ap
= (const CORE_ADDR
*) ap
;
2931 const CORE_ADDR
*addr_bp
= (const CORE_ADDR
*) bp
;
2933 return *addr_ap
== *addr_bp
;
2936 /* Convert a string back into a CORE_ADDR. */
2938 string_to_core_addr (const char *my_string
)
2942 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2944 /* Assume that it is in hex. */
2947 for (i
= 2; my_string
[i
] != '\0'; i
++)
2949 if (isdigit (my_string
[i
]))
2950 addr
= (my_string
[i
] - '0') + (addr
* 16);
2951 else if (isxdigit (my_string
[i
]))
2952 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2954 error (_("invalid hex \"%s\""), my_string
);
2959 /* Assume that it is in decimal. */
2962 for (i
= 0; my_string
[i
] != '\0'; i
++)
2964 if (isdigit (my_string
[i
]))
2965 addr
= (my_string
[i
] - '0') + (addr
* 10);
2967 error (_("invalid decimal \"%s\""), my_string
);
2977 gdb_realpath_check_trailer (const char *input
, const char *trailer
)
2979 gdb::unique_xmalloc_ptr
<char> result
= gdb_realpath (input
);
2981 size_t len
= strlen (result
.get ());
2982 size_t trail_len
= strlen (trailer
);
2984 SELF_CHECK (len
>= trail_len
2985 && strcmp (result
.get () + len
- trail_len
, trailer
) == 0);
2989 gdb_realpath_tests ()
2991 /* A file which contains a directory prefix. */
2992 gdb_realpath_check_trailer ("./xfullpath.exp", "/xfullpath.exp");
2993 /* A file which contains a directory prefix. */
2994 gdb_realpath_check_trailer ("../../defs.h", "/defs.h");
2995 /* A one-character filename. */
2996 gdb_realpath_check_trailer ("./a", "/a");
2997 /* A file in the root directory. */
2998 gdb_realpath_check_trailer ("/root_file_which_should_exist",
2999 "/root_file_which_should_exist");
3000 /* A file which does not have a directory prefix. */
3001 gdb_realpath_check_trailer ("xfullpath.exp", "xfullpath.exp");
3002 /* A one-char filename without any directory prefix. */
3003 gdb_realpath_check_trailer ("a", "a");
3004 /* An empty filename. */
3005 gdb_realpath_check_trailer ("", "");
3008 #endif /* GDB_SELF_TEST */
3010 /* Allocation function for the libiberty hash table which uses an
3011 obstack. The obstack is passed as DATA. */
3014 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3016 size_t total
= size
* count
;
3017 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3019 memset (ptr
, 0, total
);
3023 /* Trivial deallocation function for the libiberty splay tree and hash
3024 table - don't deallocate anything. Rely on later deletion of the
3025 obstack. DATA will be the obstack, although it is not needed
3029 dummy_obstack_deallocate (void *object
, void *data
)
3034 /* Simple, portable version of dirname that does not modify its
3038 ldirname (const char *filename
)
3040 std::string dirname
;
3041 const char *base
= lbasename (filename
);
3043 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3046 if (base
== filename
)
3049 dirname
= std::string (filename
, base
- filename
);
3051 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3052 create "d:./bar" later instead of the (different) "d:/bar". */
3053 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3054 && !IS_DIR_SEPARATOR (filename
[0]))
3055 dirname
[base
++ - filename
] = '.';
3063 gdb_argv::reset (const char *s
)
3065 char **argv
= buildargv (s
);
3071 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3072 #define AMBIGUOUS_MESS2 \
3073 ".\nUse \"set gnutarget format-name\" to specify the format."
3076 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
3080 /* Check if errmsg just need simple return. */
3081 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
3082 return bfd_errmsg (error_tag
);
3084 std::string
ret (bfd_errmsg (error_tag
));
3085 ret
+= AMBIGUOUS_MESS1
;
3087 for (p
= matching
; *p
; p
++)
3092 ret
+= AMBIGUOUS_MESS2
;
3099 /* Return ARGS parsed as a valid pid, or throw an error. */
3102 parse_pid_to_attach (const char *args
)
3108 error_no_arg (_("process-id to attach"));
3110 dummy
= (char *) args
;
3111 pid
= strtoul (args
, &dummy
, 0);
3112 /* Some targets don't set errno on errors, grrr! */
3113 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
3114 error (_("Illegal process-id: %s."), args
);
3119 /* Substitute all occurrences of string FROM by string TO in *STRINGP. *STRINGP
3120 must come from xrealloc-compatible allocator and it may be updated. FROM
3121 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3122 located at the start or end of *STRINGP. */
3125 substitute_path_component (char **stringp
, const char *from
, const char *to
)
3127 char *string
= *stringp
, *s
;
3128 const size_t from_len
= strlen (from
);
3129 const size_t to_len
= strlen (to
);
3133 s
= strstr (s
, from
);
3137 if ((s
== string
|| IS_DIR_SEPARATOR (s
[-1])
3138 || s
[-1] == DIRNAME_SEPARATOR
)
3139 && (s
[from_len
] == '\0' || IS_DIR_SEPARATOR (s
[from_len
])
3140 || s
[from_len
] == DIRNAME_SEPARATOR
))
3145 = (char *) xrealloc (string
, (strlen (string
) + to_len
+ 1));
3147 /* Relocate the current S pointer. */
3148 s
= s
- string
+ string_new
;
3149 string
= string_new
;
3151 /* Replace from by to. */
3152 memmove (&s
[to_len
], &s
[from_len
], strlen (&s
[from_len
]) + 1);
3153 memcpy (s
, to
, to_len
);
3168 /* SIGALRM handler for waitpid_with_timeout. */
3171 sigalrm_handler (int signo
)
3173 /* Nothing to do. */
3178 /* Wrapper to wait for child PID to die with TIMEOUT.
3179 TIMEOUT is the time to stop waiting in seconds.
3180 If TIMEOUT is zero, pass WNOHANG to waitpid.
3181 Returns PID if it was successfully waited for, otherwise -1.
3183 Timeouts are currently implemented with alarm and SIGALRM.
3184 If the host does not support them, this waits "forever".
3185 It would be odd though for a host to have waitpid and not SIGALRM. */
3188 wait_to_die_with_timeout (pid_t pid
, int *status
, int timeout
)
3190 pid_t waitpid_result
;
3192 gdb_assert (pid
> 0);
3193 gdb_assert (timeout
>= 0);
3198 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3199 struct sigaction sa
, old_sa
;
3201 sa
.sa_handler
= sigalrm_handler
;
3202 sigemptyset (&sa
.sa_mask
);
3204 sigaction (SIGALRM
, &sa
, &old_sa
);
3208 ofunc
= signal (SIGALRM
, sigalrm_handler
);
3214 waitpid_result
= waitpid (pid
, status
, 0);
3218 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3219 sigaction (SIGALRM
, &old_sa
, NULL
);
3221 signal (SIGALRM
, ofunc
);
3226 waitpid_result
= waitpid (pid
, status
, WNOHANG
);
3228 if (waitpid_result
== pid
)
3234 #endif /* HAVE_WAITPID */
3236 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3237 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3239 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3240 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3243 gdb_filename_fnmatch (const char *pattern
, const char *string
, int flags
)
3245 gdb_assert ((flags
& FNM_FILE_NAME
) != 0);
3247 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3248 gdb_assert ((flags
& FNM_NOESCAPE
) != 0);
3250 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3252 char *pattern_slash
, *string_slash
;
3254 /* Replace '\' by '/' in both strings. */
3256 pattern_slash
= (char *) alloca (strlen (pattern
) + 1);
3257 strcpy (pattern_slash
, pattern
);
3258 pattern
= pattern_slash
;
3259 for (; *pattern_slash
!= 0; pattern_slash
++)
3260 if (IS_DIR_SEPARATOR (*pattern_slash
))
3261 *pattern_slash
= '/';
3263 string_slash
= (char *) alloca (strlen (string
) + 1);
3264 strcpy (string_slash
, string
);
3265 string
= string_slash
;
3266 for (; *string_slash
!= 0; string_slash
++)
3267 if (IS_DIR_SEPARATOR (*string_slash
))
3268 *string_slash
= '/';
3270 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3272 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3273 flags
|= FNM_CASEFOLD
;
3274 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3276 return fnmatch (pattern
, string
, flags
);
3279 /* Return the number of path elements in PATH.
3287 count_path_elements (const char *path
)
3290 const char *p
= path
;
3292 if (HAS_DRIVE_SPEC (p
))
3294 p
= STRIP_DRIVE_SPEC (p
);
3300 if (IS_DIR_SEPARATOR (*p
))
3305 /* Backup one if last character is /, unless it's the only one. */
3306 if (p
> path
+ 1 && IS_DIR_SEPARATOR (p
[-1]))
3309 /* Add one for the file name, if present. */
3310 if (p
> path
&& !IS_DIR_SEPARATOR (p
[-1]))
3316 /* Remove N leading path elements from PATH.
3317 N must be non-negative.
3318 If PATH has more than N path elements then return NULL.
3319 If PATH has exactly N path elements then return "".
3320 See count_path_elements for a description of how we do the counting. */
3323 strip_leading_path_elements (const char *path
, int n
)
3326 const char *p
= path
;
3328 gdb_assert (n
>= 0);
3333 if (HAS_DRIVE_SPEC (p
))
3335 p
= STRIP_DRIVE_SPEC (p
);
3341 while (*p
!= '\0' && !IS_DIR_SEPARATOR (*p
))
3359 copy_bitwise (gdb_byte
*dest
, ULONGEST dest_offset
,
3360 const gdb_byte
*source
, ULONGEST source_offset
,
3361 ULONGEST nbits
, int bits_big_endian
)
3363 unsigned int buf
, avail
;
3368 if (bits_big_endian
)
3370 /* Start from the end, then work backwards. */
3371 dest_offset
+= nbits
- 1;
3372 dest
+= dest_offset
/ 8;
3373 dest_offset
= 7 - dest_offset
% 8;
3374 source_offset
+= nbits
- 1;
3375 source
+= source_offset
/ 8;
3376 source_offset
= 7 - source_offset
% 8;
3380 dest
+= dest_offset
/ 8;
3382 source
+= source_offset
/ 8;
3386 /* Fill BUF with DEST_OFFSET bits from the destination and 8 -
3387 SOURCE_OFFSET bits from the source. */
3388 buf
= *(bits_big_endian
? source
-- : source
++) >> source_offset
;
3389 buf
<<= dest_offset
;
3390 buf
|= *dest
& ((1 << dest_offset
) - 1);
3392 /* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
3393 nbits
+= dest_offset
;
3394 avail
= dest_offset
+ 8 - source_offset
;
3396 /* Flush 8 bits from BUF, if appropriate. */
3397 if (nbits
>= 8 && avail
>= 8)
3399 *(bits_big_endian
? dest
-- : dest
++) = buf
;
3405 /* Copy the middle part. */
3408 size_t len
= nbits
/ 8;
3410 /* Use a faster method for byte-aligned copies. */
3413 if (bits_big_endian
)
3417 memcpy (dest
+ 1, source
+ 1, len
);
3421 memcpy (dest
, source
, len
);
3430 buf
|= *(bits_big_endian
? source
-- : source
++) << avail
;
3431 *(bits_big_endian
? dest
-- : dest
++) = buf
;
3438 /* Write the last byte. */
3442 buf
|= *source
<< avail
;
3444 buf
&= (1 << nbits
) - 1;
3445 *dest
= (*dest
& (~0U << nbits
)) | buf
;
3449 void _initialize_utils ();
3451 _initialize_utils ()
3453 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
3454 Set number of characters where GDB should wrap lines of its output."), _("\
3455 Show number of characters where GDB should wrap lines of its output."), _("\
3456 This affects where GDB wraps its output to fit the screen width.\n\
3457 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
3459 show_chars_per_line
,
3460 &setlist
, &showlist
);
3462 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
3463 Set number of lines in a page for GDB output pagination."), _("\
3464 Show number of lines in a page for GDB output pagination."), _("\
3465 This affects the number of lines after which GDB will pause\n\
3466 its output and ask you whether to continue.\n\
3467 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
3469 show_lines_per_page
,
3470 &setlist
, &showlist
);
3472 add_setshow_boolean_cmd ("pagination", class_support
,
3473 &pagination_enabled
, _("\
3474 Set state of GDB output pagination."), _("\
3475 Show state of GDB output pagination."), _("\
3476 When pagination is ON, GDB pauses at end of each screenful of\n\
3477 its output and asks you whether to continue.\n\
3478 Turning pagination off is an alternative to \"set height unlimited\"."),
3480 show_pagination_enabled
,
3481 &setlist
, &showlist
);
3483 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
3484 &sevenbit_strings
, _("\
3485 Set printing of 8-bit characters in strings as \\nnn."), _("\
3486 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
3488 show_sevenbit_strings
,
3489 &setprintlist
, &showprintlist
);
3491 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
3492 &debug_timestamp
, _("\
3493 Set timestamping of debugging messages."), _("\
3494 Show timestamping of debugging messages."), _("\
3495 When set, debugging messages will be marked with seconds and microseconds."),
3497 show_debug_timestamp
,
3498 &setdebuglist
, &showdebuglist
);
3500 add_internal_problem_command (&internal_error_problem
);
3501 add_internal_problem_command (&internal_warning_problem
);
3502 add_internal_problem_command (&demangler_warning_problem
);
3505 selftests::register_test ("gdb_realpath", gdb_realpath_tests
);