1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "event-top.h"
24 #include "gdbthread.h"
27 #ifdef HAVE_SYS_RESOURCE_H
28 #include <sys/resource.h>
29 #endif /* HAVE_SYS_RESOURCE_H */
32 #include "tui/tui.h" /* For tui_get_command_dimension. */
44 #include "gdb-demangle.h"
45 #include "expression.h"
49 #include "filenames.h"
51 #include "gdb_obstack.h"
57 #include "inferior.h" /* for signed_pointer_to_address */
59 #include "gdb_curses.h"
61 #include "readline/readline.h"
65 #include "gdb_usleep.h"
67 #include "gdb_regex.h"
68 #include "job-control.h"
71 extern PTR
malloc (); /* ARI: PTR */
73 #if !HAVE_DECL_REALLOC
74 extern PTR
realloc (); /* ARI: PTR */
80 void (*deprecated_error_begin_hook
) (void);
82 /* Prototypes for local functions */
84 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
85 va_list, int) ATTRIBUTE_PRINTF (2, 0);
87 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
89 static void prompt_for_continue (void);
91 static void set_screen_size (void);
92 static void set_width (void);
94 /* Time spent in prompt_for_continue in the currently executing command
95 waiting for user to respond.
96 Initialized in make_command_stats_cleanup.
97 Modified in prompt_for_continue and defaulted_query.
98 Used in report_command_stats. */
100 static std::chrono::steady_clock::duration prompt_for_continue_wait_time
;
102 /* A flag indicating whether to timestamp debugging messages. */
104 static int debug_timestamp
= 0;
106 /* Nonzero means that strings with character values >0x7F should be printed
107 as octal escapes. Zero means just print the value (e.g. it's an
108 international character, and the terminal or window can cope.) */
110 int sevenbit_strings
= 0;
112 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
113 struct cmd_list_element
*c
, const char *value
)
115 fprintf_filtered (file
, _("Printing of 8-bit characters "
116 "in strings as \\nnn is %s.\n"),
120 /* String to be printed before warning messages, if any. */
122 const char *warning_pre_print
= "\nwarning: ";
124 int pagination_enabled
= 1;
126 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
127 struct cmd_list_element
*c
, const char *value
)
129 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
133 /* Cleanup utilities.
135 These are not defined in cleanups.c (nor declared in cleanups.h)
136 because while they use the "cleanup API" they are not part of the
140 do_freeargv (void *arg
)
142 freeargv ((char **) arg
);
146 make_cleanup_freeargv (char **arg
)
148 return make_cleanup (do_freeargv
, arg
);
151 /* Helper function for make_cleanup_ui_out_redirect_pop. */
154 do_ui_out_redirect_pop (void *arg
)
156 struct ui_out
*uiout
= (struct ui_out
*) arg
;
158 uiout
->redirect (NULL
);
161 /* Return a new cleanup that pops the last redirection by ui_out_redirect
162 with NULL parameter. */
165 make_cleanup_ui_out_redirect_pop (struct ui_out
*uiout
)
167 return make_cleanup (do_ui_out_redirect_pop
, uiout
);
171 do_free_section_addr_info (void *arg
)
173 free_section_addr_info ((struct section_addr_info
*) arg
);
177 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
179 return make_cleanup (do_free_section_addr_info
, addrs
);
182 struct restore_integer_closure
189 restore_integer (void *p
)
191 struct restore_integer_closure
*closure
192 = (struct restore_integer_closure
*) p
;
194 *(closure
->variable
) = closure
->value
;
197 /* Remember the current value of *VARIABLE and make it restored when
198 the cleanup is run. */
201 make_cleanup_restore_integer (int *variable
)
203 struct restore_integer_closure
*c
= XNEW (struct restore_integer_closure
);
205 c
->variable
= variable
;
206 c
->value
= *variable
;
208 return make_cleanup_dtor (restore_integer
, (void *) c
, xfree
);
211 /* Remember the current value of *VARIABLE and make it restored when
212 the cleanup is run. */
215 make_cleanup_restore_uinteger (unsigned int *variable
)
217 return make_cleanup_restore_integer ((int *) variable
);
220 /* Helper for make_cleanup_unpush_target. */
223 do_unpush_target (void *arg
)
225 struct target_ops
*ops
= (struct target_ops
*) arg
;
230 /* Return a new cleanup that unpushes OPS. */
233 make_cleanup_unpush_target (struct target_ops
*ops
)
235 return make_cleanup (do_unpush_target
, ops
);
238 /* Helper for make_cleanup_value_free_to_mark. */
241 do_value_free_to_mark (void *value
)
243 value_free_to_mark ((struct value
*) value
);
246 /* Free all values allocated since MARK was obtained by value_mark
247 (except for those released) when the cleanup is run. */
250 make_cleanup_value_free_to_mark (struct value
*mark
)
252 return make_cleanup (do_value_free_to_mark
, mark
);
255 /* Helper for make_cleanup_value_free. */
258 do_value_free (void *value
)
260 value_free ((struct value
*) value
);
266 make_cleanup_value_free (struct value
*value
)
268 return make_cleanup (do_value_free
, value
);
271 /* Helper for make_cleanup_free_so. */
274 do_free_so (void *arg
)
276 struct so_list
*so
= (struct so_list
*) arg
;
281 /* Make cleanup handler calling free_so for SO. */
284 make_cleanup_free_so (struct so_list
*so
)
286 return make_cleanup (do_free_so
, so
);
289 /* Helper function for make_cleanup_clear_parser_state. */
292 do_clear_parser_state (void *ptr
)
294 struct parser_state
**p
= (struct parser_state
**) ptr
;
299 /* Clean (i.e., set to NULL) the parser state variable P. */
302 make_cleanup_clear_parser_state (struct parser_state
**p
)
304 return make_cleanup (do_clear_parser_state
, (void *) p
);
307 /* This function is useful for cleanups.
311 old_chain = make_cleanup (free_current_contents, &foo);
313 to arrange to free the object thus allocated. */
316 free_current_contents (void *ptr
)
318 void **location
= (void **) ptr
;
320 if (location
== NULL
)
321 internal_error (__FILE__
, __LINE__
,
322 _("free_current_contents: NULL pointer"));
323 if (*location
!= NULL
)
332 /* Print a warning message. The first argument STRING is the warning
333 message, used as an fprintf format string, the second is the
334 va_list of arguments for that string. A warning is unfiltered (not
335 paginated) so that the user does not need to page through each
336 screen full of warnings when there are lots of them. */
339 vwarning (const char *string
, va_list args
)
341 if (deprecated_warning_hook
)
342 (*deprecated_warning_hook
) (string
, args
);
345 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
347 if (target_supports_terminal_ours ())
349 make_cleanup_restore_target_terminal ();
350 target_terminal_ours_for_output ();
352 if (filtered_printing_initialized ())
353 wrap_here (""); /* Force out any buffered output. */
354 gdb_flush (gdb_stdout
);
355 if (warning_pre_print
)
356 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
357 vfprintf_unfiltered (gdb_stderr
, string
, args
);
358 fprintf_unfiltered (gdb_stderr
, "\n");
360 do_cleanups (old_chain
);
364 /* Print an error message and return to command level.
365 The first argument STRING is the error message, used as a fprintf string,
366 and the remaining args are passed as arguments to it. */
369 verror (const char *string
, va_list args
)
371 throw_verror (GENERIC_ERROR
, string
, args
);
375 error_stream (const string_file
&stream
)
377 error (("%s"), stream
.c_str ());
380 /* Emit a message and abort. */
382 static void ATTRIBUTE_NORETURN
383 abort_with_message (const char *msg
)
385 if (gdb_stderr
== NULL
)
388 fputs_unfiltered (msg
, gdb_stderr
);
390 abort (); /* NOTE: GDB has only three calls to abort(). */
393 /* Dump core trying to increase the core soft limit to hard limit first. */
398 #ifdef HAVE_SETRLIMIT
399 struct rlimit rlim
= { RLIM_INFINITY
, RLIM_INFINITY
};
401 setrlimit (RLIMIT_CORE
, &rlim
);
402 #endif /* HAVE_SETRLIMIT */
404 abort (); /* NOTE: GDB has only three calls to abort(). */
407 /* Check whether GDB will be able to dump core using the dump_core
408 function. Returns zero if GDB cannot or should not dump core.
409 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
410 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
413 can_dump_core (enum resource_limit_kind limit_kind
)
415 #ifdef HAVE_GETRLIMIT
418 /* Be quiet and assume we can dump if an error is returned. */
419 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
425 if (rlim
.rlim_cur
== 0)
429 if (rlim
.rlim_max
== 0)
432 #endif /* HAVE_GETRLIMIT */
437 /* Print a warning that we cannot dump core. */
440 warn_cant_dump_core (const char *reason
)
442 fprintf_unfiltered (gdb_stderr
,
443 _("%s\nUnable to dump core, use `ulimit -c"
444 " unlimited' before executing GDB next time.\n"),
448 /* Check whether GDB will be able to dump core using the dump_core
449 function, and print a warning if we cannot. */
452 can_dump_core_warn (enum resource_limit_kind limit_kind
,
455 int core_dump_allowed
= can_dump_core (limit_kind
);
457 if (!core_dump_allowed
)
458 warn_cant_dump_core (reason
);
460 return core_dump_allowed
;
463 /* Allow the user to configure the debugger behavior with respect to
464 what to do when an internal problem is detected. */
466 const char internal_problem_ask
[] = "ask";
467 const char internal_problem_yes
[] = "yes";
468 const char internal_problem_no
[] = "no";
469 static const char *const internal_problem_modes
[] =
471 internal_problem_ask
,
472 internal_problem_yes
,
477 /* Print a message reporting an internal error/warning. Ask the user
478 if they want to continue, dump core, or just exit. Return
479 something to indicate a quit. */
481 struct internal_problem
484 int user_settable_should_quit
;
485 const char *should_quit
;
486 int user_settable_should_dump_core
;
487 const char *should_dump_core
;
490 /* Report a problem, internal to GDB, to the user. Once the problem
491 has been reported, and assuming GDB didn't quit, the caller can
492 either allow execution to resume or throw an error. */
494 static void ATTRIBUTE_PRINTF (4, 0)
495 internal_vproblem (struct internal_problem
*problem
,
496 const char *file
, int line
, const char *fmt
, va_list ap
)
502 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
504 /* Don't allow infinite error/warning recursion. */
506 static char msg
[] = "Recursive internal problem.\n";
515 abort_with_message (msg
);
518 /* Newer GLIBC versions put the warn_unused_result attribute
519 on write, but this is one of those rare cases where
520 ignoring the return value is correct. Casting to (void)
521 does not fix this problem. This is the solution suggested
522 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
523 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
524 abort (); /* NOTE: GDB has only three calls to abort(). */
529 /* Create a string containing the full error/warning message. Need
530 to call query with this full string, as otherwize the reason
531 (error/warning) and question become separated. Format using a
532 style similar to a compiler error message. Include extra detail
533 so that the user knows that they are living on the edge. */
537 msg
= xstrvprintf (fmt
, ap
);
538 reason
= xstrprintf ("%s:%d: %s: %s\n"
539 "A problem internal to GDB has been detected,\n"
540 "further debugging may prove unreliable.",
541 file
, line
, problem
->name
, msg
);
543 make_cleanup (xfree
, reason
);
546 /* Fall back to abort_with_message if gdb_stderr is not set up. */
547 if (gdb_stderr
== NULL
)
549 fputs (reason
, stderr
);
550 abort_with_message ("\n");
553 /* Try to get the message out and at the start of a new line. */
554 if (target_supports_terminal_ours ())
556 make_cleanup_restore_target_terminal ();
557 target_terminal_ours_for_output ();
559 if (filtered_printing_initialized ())
562 /* Emit the message unless query will emit it below. */
563 if (problem
->should_quit
!= internal_problem_ask
565 || !filtered_printing_initialized ())
566 fprintf_unfiltered (gdb_stderr
, "%s\n", reason
);
568 if (problem
->should_quit
== internal_problem_ask
)
570 /* Default (yes/batch case) is to quit GDB. When in batch mode
571 this lessens the likelihood of GDB going into an infinite
573 if (!confirm
|| !filtered_printing_initialized ())
576 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
578 else if (problem
->should_quit
== internal_problem_yes
)
580 else if (problem
->should_quit
== internal_problem_no
)
583 internal_error (__FILE__
, __LINE__
, _("bad switch"));
585 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr
);
586 if (REPORT_BUGS_TO
[0])
587 fprintf_unfiltered (gdb_stderr
, _(" For instructions, see:\n%s."),
589 fputs_unfiltered ("\n\n", gdb_stderr
);
591 if (problem
->should_dump_core
== internal_problem_ask
)
593 if (!can_dump_core_warn (LIMIT_MAX
, reason
))
595 else if (!filtered_printing_initialized ())
599 /* Default (yes/batch case) is to dump core. This leaves a GDB
600 `dropping' so that it is easier to see that something went
602 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
605 else if (problem
->should_dump_core
== internal_problem_yes
)
606 dump_core_p
= can_dump_core_warn (LIMIT_MAX
, reason
);
607 else if (problem
->should_dump_core
== internal_problem_no
)
610 internal_error (__FILE__
, __LINE__
, _("bad switch"));
623 #ifdef HAVE_WORKING_FORK
631 do_cleanups (cleanup
);
634 static struct internal_problem internal_error_problem
= {
635 "internal-error", 1, internal_problem_ask
, 1, internal_problem_ask
639 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
641 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
642 throw_quit (_("Command aborted."));
645 static struct internal_problem internal_warning_problem
= {
646 "internal-warning", 1, internal_problem_ask
, 1, internal_problem_ask
650 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
652 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
655 static struct internal_problem demangler_warning_problem
= {
656 "demangler-warning", 1, internal_problem_ask
, 0, internal_problem_no
660 demangler_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
662 internal_vproblem (&demangler_warning_problem
, file
, line
, fmt
, ap
);
666 demangler_warning (const char *file
, int line
, const char *string
, ...)
670 va_start (ap
, string
);
671 demangler_vwarning (file
, line
, string
, ap
);
675 /* Dummy functions to keep add_prefix_cmd happy. */
678 set_internal_problem_cmd (char *args
, int from_tty
)
683 show_internal_problem_cmd (char *args
, int from_tty
)
687 /* When GDB reports an internal problem (error or warning) it gives
688 the user the opportunity to quit GDB and/or create a core file of
689 the current debug session. This function registers a few commands
690 that make it possible to specify that GDB should always or never
691 quit or create a core file, without asking. The commands look
694 maint set PROBLEM-NAME quit ask|yes|no
695 maint show PROBLEM-NAME quit
696 maint set PROBLEM-NAME corefile ask|yes|no
697 maint show PROBLEM-NAME corefile
699 Where PROBLEM-NAME is currently "internal-error" or
700 "internal-warning". */
703 add_internal_problem_command (struct internal_problem
*problem
)
705 struct cmd_list_element
**set_cmd_list
;
706 struct cmd_list_element
**show_cmd_list
;
710 set_cmd_list
= XNEW (struct cmd_list_element
*);
711 show_cmd_list
= XNEW (struct cmd_list_element
*);
712 *set_cmd_list
= NULL
;
713 *show_cmd_list
= NULL
;
715 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
718 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
721 add_prefix_cmd ((char*) problem
->name
,
722 class_maintenance
, set_internal_problem_cmd
, set_doc
,
724 concat ("maintenance set ", problem
->name
, " ",
726 0/*allow-unknown*/, &maintenance_set_cmdlist
);
728 add_prefix_cmd ((char*) problem
->name
,
729 class_maintenance
, show_internal_problem_cmd
, show_doc
,
731 concat ("maintenance show ", problem
->name
, " ",
733 0/*allow-unknown*/, &maintenance_show_cmdlist
);
735 if (problem
->user_settable_should_quit
)
737 set_doc
= xstrprintf (_("Set whether GDB should quit "
738 "when an %s is detected"),
740 show_doc
= xstrprintf (_("Show whether GDB will quit "
741 "when an %s is detected"),
743 add_setshow_enum_cmd ("quit", class_maintenance
,
744 internal_problem_modes
,
745 &problem
->should_quit
,
758 if (problem
->user_settable_should_dump_core
)
760 set_doc
= xstrprintf (_("Set whether GDB should create a core "
761 "file of GDB when %s is detected"),
763 show_doc
= xstrprintf (_("Show whether GDB will create a core "
764 "file of GDB when %s is detected"),
766 add_setshow_enum_cmd ("corefile", class_maintenance
,
767 internal_problem_modes
,
768 &problem
->should_dump_core
,
782 /* Return a newly allocated string, containing the PREFIX followed
783 by the system error message for errno (separated by a colon).
785 The result must be deallocated after use. */
788 perror_string (const char *prefix
)
793 err
= safe_strerror (errno
);
794 combined
= (char *) xmalloc (strlen (err
) + strlen (prefix
) + 3);
795 strcpy (combined
, prefix
);
796 strcat (combined
, ": ");
797 strcat (combined
, err
);
802 /* Print the system error message for errno, and also mention STRING
803 as the file name for which the error was encountered. Use ERRCODE
804 for the thrown exception. Then return to command level. */
807 throw_perror_with_name (enum errors errcode
, const char *string
)
811 combined
= perror_string (string
);
812 make_cleanup (xfree
, combined
);
814 /* I understand setting these is a matter of taste. Still, some people
815 may clear errno but not know about bfd_error. Doing this here is not
817 bfd_set_error (bfd_error_no_error
);
820 throw_error (errcode
, _("%s."), combined
);
823 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
826 perror_with_name (const char *string
)
828 throw_perror_with_name (GENERIC_ERROR
, string
);
831 /* Same as perror_with_name except that it prints a warning instead
832 of throwing an error. */
835 perror_warning_with_name (const char *string
)
839 combined
= perror_string (string
);
840 warning (_("%s"), combined
);
844 /* Print the system error message for ERRCODE, and also mention STRING
845 as the file name for which the error was encountered. */
848 print_sys_errmsg (const char *string
, int errcode
)
853 err
= safe_strerror (errcode
);
854 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
855 strcpy (combined
, string
);
856 strcat (combined
, ": ");
857 strcat (combined
, err
);
859 /* We want anything which was printed on stdout to come out first, before
861 gdb_flush (gdb_stdout
);
862 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
865 /* Control C eventually causes this to be called, at a convenient time. */
870 struct ui
*ui
= current_ui
;
872 if (sync_quit_force_run
)
874 sync_quit_force_run
= 0;
875 quit_force (NULL
, 0);
879 /* No steenking SIGINT will ever be coming our way when the
880 program is resumed. Don't lie. */
884 /* If there is no terminal switching for this target, then we can't
885 possibly get screwed by the lack of job control. */
886 || !target_supports_terminal_ours ())
889 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
898 if (sync_quit_force_run
)
903 if (deprecated_interactive_hook
)
904 deprecated_interactive_hook ();
908 /* Called when a memory allocation fails, with the number of bytes of
909 memory requested in SIZE. */
912 malloc_failure (long size
)
916 internal_error (__FILE__
, __LINE__
,
917 _("virtual memory exhausted: can't allocate %ld bytes."),
922 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
926 /* My replacement for the read system call.
927 Used like `read' but keeps going if `read' returns too soon. */
930 myread (int desc
, char *addr
, int len
)
937 val
= read (desc
, addr
, len
);
949 print_spaces (int n
, struct ui_file
*file
)
951 fputs_unfiltered (n_spaces (n
), file
);
954 /* Print a host address. */
957 gdb_print_host_address_1 (const void *addr
, struct ui_file
*stream
)
959 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
965 make_hex_string (const gdb_byte
*data
, size_t length
)
967 char *result
= (char *) xmalloc (length
* 2 + 1);
972 for (i
= 0; i
< length
; ++i
)
973 p
+= xsnprintf (p
, 3, "%02x", data
[i
]);
980 /* A cleanup that simply calls ui_unregister_input_event_handler. */
983 ui_unregister_input_event_handler_cleanup (void *ui
)
985 ui_unregister_input_event_handler ((struct ui
*) ui
);
988 /* Set up to handle input. */
990 static struct cleanup
*
991 prepare_to_handle_input (void)
993 struct cleanup
*old_chain
;
995 old_chain
= make_cleanup_restore_target_terminal ();
996 target_terminal_ours ();
998 ui_register_input_event_handler (current_ui
);
999 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1000 make_cleanup (ui_unregister_input_event_handler_cleanup
, current_ui
);
1002 make_cleanup_override_quit_handler (default_quit_handler
);
1009 /* This function supports the query, nquery, and yquery functions.
1010 Ask user a y-or-n question and return 0 if answer is no, 1 if
1011 answer is yes, or default the answer to the specified default
1012 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1013 default answer, or '\0' for no default.
1014 CTLSTR is the control string and should end in "? ". It should
1015 not say how to answer, because we do that.
1016 ARGS are the arguments passed along with the CTLSTR argument to
1019 static int ATTRIBUTE_PRINTF (1, 0)
1020 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1025 char def_answer
, not_def_answer
;
1026 const char *y_string
, *n_string
;
1027 char *question
, *prompt
;
1028 struct cleanup
*old_chain
;
1030 /* Set up according to which answer is the default. */
1031 if (defchar
== '\0')
1035 not_def_answer
= 'N';
1039 else if (defchar
== 'y')
1043 not_def_answer
= 'N';
1051 not_def_answer
= 'Y';
1056 /* Automatically answer the default value if the user did not want
1057 prompts or the command was issued with the server prefix. */
1058 if (!confirm
|| server_command
)
1061 /* If input isn't coming from the user directly, just say what
1062 question we're asking, and then answer the default automatically. This
1063 way, important error messages don't get lost when talking to GDB
1065 if (current_ui
->instream
!= current_ui
->stdin_stream
1066 || !input_interactive_p (current_ui
)
1067 /* Restrict queries to the main UI. */
1068 || current_ui
!= main_ui
)
1070 old_chain
= make_cleanup_restore_target_terminal ();
1072 target_terminal_ours_for_output ();
1074 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1076 printf_filtered (_("(%s or %s) [answered %c; "
1077 "input not from terminal]\n"),
1078 y_string
, n_string
, def_answer
);
1079 gdb_flush (gdb_stdout
);
1081 do_cleanups (old_chain
);
1085 if (deprecated_query_hook
)
1089 old_chain
= make_cleanup_restore_target_terminal ();
1090 res
= deprecated_query_hook (ctlstr
, args
);
1091 do_cleanups (old_chain
);
1095 /* Format the question outside of the loop, to avoid reusing args. */
1096 question
= xstrvprintf (ctlstr
, args
);
1097 old_chain
= make_cleanup (xfree
, question
);
1098 prompt
= xstrprintf (_("%s%s(%s or %s) %s"),
1099 annotation_level
> 1 ? "\n\032\032pre-query\n" : "",
1100 question
, y_string
, n_string
,
1101 annotation_level
> 1 ? "\n\032\032query\n" : "");
1102 make_cleanup (xfree
, prompt
);
1104 /* Used to add duration we waited for user to respond to
1105 prompt_for_continue_wait_time. */
1106 using namespace std::chrono
;
1107 steady_clock::time_point prompt_started
= steady_clock::now ();
1109 prepare_to_handle_input ();
1113 char *response
, answer
;
1115 gdb_flush (gdb_stdout
);
1116 response
= gdb_readline_wrapper (prompt
);
1118 if (response
== NULL
) /* C-d */
1120 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1125 answer
= response
[0];
1130 /* Check answer. For the non-default, the user must specify
1131 the non-default explicitly. */
1132 if (answer
== not_def_answer
)
1134 retval
= !def_value
;
1137 /* Otherwise, if a default was specified, the user may either
1138 specify the required input or have it default by entering
1140 if (answer
== def_answer
1141 || (defchar
!= '\0' && answer
== '\0'))
1146 /* Invalid entries are not defaulted and require another selection. */
1147 printf_filtered (_("Please answer %s or %s.\n"),
1148 y_string
, n_string
);
1151 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1152 prompt_for_continue_wait_time
+= steady_clock::now () - prompt_started
;
1154 if (annotation_level
> 1)
1155 printf_filtered (("\n\032\032post-query\n"));
1156 do_cleanups (old_chain
);
1161 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1162 answer is yes, or 0 if answer is defaulted.
1163 Takes three args which are given to printf to print the question.
1164 The first, a control string, should end in "? ".
1165 It should not say how to answer, because we do that. */
1168 nquery (const char *ctlstr
, ...)
1173 va_start (args
, ctlstr
);
1174 ret
= defaulted_query (ctlstr
, 'n', args
);
1179 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1180 answer is yes, or 1 if answer is defaulted.
1181 Takes three args which are given to printf to print the question.
1182 The first, a control string, should end in "? ".
1183 It should not say how to answer, because we do that. */
1186 yquery (const char *ctlstr
, ...)
1191 va_start (args
, ctlstr
);
1192 ret
= defaulted_query (ctlstr
, 'y', args
);
1197 /* Ask user a y-or-n question and return 1 iff answer is yes.
1198 Takes three args which are given to printf to print the question.
1199 The first, a control string, should end in "? ".
1200 It should not say how to answer, because we do that. */
1203 query (const char *ctlstr
, ...)
1208 va_start (args
, ctlstr
);
1209 ret
= defaulted_query (ctlstr
, '\0', args
);
1214 /* A helper for parse_escape that converts a host character to a
1215 target character. C is the host character. If conversion is
1216 possible, then the target character is stored in *TARGET_C and the
1217 function returns 1. Otherwise, the function returns 0. */
1220 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1225 auto_obstack host_data
;
1227 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1228 (gdb_byte
*) &the_char
, 1, 1,
1229 &host_data
, translit_none
);
1231 if (obstack_object_size (&host_data
) == 1)
1234 *target_c
= *(char *) obstack_base (&host_data
);
1240 /* Parse a C escape sequence. STRING_PTR points to a variable
1241 containing a pointer to the string to parse. That pointer
1242 should point to the character after the \. That pointer
1243 is updated past the characters we use. The value of the
1244 escape sequence is returned.
1246 A negative value means the sequence \ newline was seen,
1247 which is supposed to be equivalent to nothing at all.
1249 If \ is followed by a null character, we return a negative
1250 value and leave the string pointer pointing at the null character.
1252 If \ is followed by 000, we return 0 and leave the string pointer
1253 after the zeros. A value of 0 does not mean end of string. */
1256 parse_escape (struct gdbarch
*gdbarch
, const char **string_ptr
)
1258 int target_char
= -2; /* Initialize to avoid GCC warnings. */
1259 int c
= *(*string_ptr
)++;
1278 int i
= host_hex_value (c
);
1283 if (isdigit (c
) && c
!= '8' && c
!= '9')
1287 i
+= host_hex_value (c
);
1323 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1324 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1325 " which has no equivalent\nin the `%s' character set."),
1326 c
, c
, target_charset (gdbarch
));
1330 /* Print the character C on STREAM as part of the contents of a literal
1331 string whose delimiter is QUOTER. Note that this routine should only
1332 be called for printing things which are independent of the language
1333 of the program being debugged.
1335 printchar will normally escape backslashes and instances of QUOTER. If
1336 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1337 As a side effect, if you pass the backslash character as the QUOTER,
1338 printchar will escape backslashes as usual, but not any other quoting
1342 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1343 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1344 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1346 c
&= 0xFF; /* Avoid sign bit follies */
1348 if (c
< 0x20 || /* Low control chars */
1349 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1350 (sevenbit_strings
&& c
>= 0x80))
1351 { /* high order bit set */
1355 do_fputs ("\\n", stream
);
1358 do_fputs ("\\b", stream
);
1361 do_fputs ("\\t", stream
);
1364 do_fputs ("\\f", stream
);
1367 do_fputs ("\\r", stream
);
1370 do_fputs ("\\e", stream
);
1373 do_fputs ("\\a", stream
);
1376 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1382 if (quoter
!= 0 && (c
== '\\' || c
== quoter
))
1383 do_fputs ("\\", stream
);
1384 do_fprintf (stream
, "%c", c
);
1388 /* Print the character C on STREAM as part of the contents of a
1389 literal string whose delimiter is QUOTER. Note that these routines
1390 should only be call for printing things which are independent of
1391 the language of the program being debugged. */
1394 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1397 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1401 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1404 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1408 fputstrn_filtered (const char *str
, int n
, int quoter
,
1409 struct ui_file
*stream
)
1413 for (i
= 0; i
< n
; i
++)
1414 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1418 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1419 struct ui_file
*stream
)
1423 for (i
= 0; i
< n
; i
++)
1424 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1428 /* Number of lines per page or UINT_MAX if paging is disabled. */
1429 static unsigned int lines_per_page
;
1431 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1432 struct cmd_list_element
*c
, const char *value
)
1434 fprintf_filtered (file
,
1435 _("Number of lines gdb thinks are in a page is %s.\n"),
1439 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1440 static unsigned int chars_per_line
;
1442 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1443 struct cmd_list_element
*c
, const char *value
)
1445 fprintf_filtered (file
,
1446 _("Number of characters gdb thinks "
1447 "are in a line is %s.\n"),
1451 /* Current count of lines printed on this page, chars on this line. */
1452 static unsigned int lines_printed
, chars_printed
;
1454 /* Buffer and start column of buffered text, for doing smarter word-
1455 wrapping. When someone calls wrap_here(), we start buffering output
1456 that comes through fputs_filtered(). If we see a newline, we just
1457 spit it out and forget about the wrap_here(). If we see another
1458 wrap_here(), we spit it out and remember the newer one. If we see
1459 the end of the line, we spit out a newline, the indent, and then
1460 the buffered output. */
1462 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1463 are waiting to be output (they have already been counted in chars_printed).
1464 When wrap_buffer[0] is null, the buffer is empty. */
1465 static char *wrap_buffer
;
1467 /* Pointer in wrap_buffer to the next character to fill. */
1468 static char *wrap_pointer
;
1470 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1472 static const char *wrap_indent
;
1474 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1475 is not in effect. */
1476 static int wrap_column
;
1479 /* Initialize the number of lines per page and chars per line. */
1482 init_page_info (void)
1486 lines_per_page
= UINT_MAX
;
1487 chars_per_line
= UINT_MAX
;
1491 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1496 #if defined(__GO32__)
1497 rows
= ScreenRows ();
1498 cols
= ScreenCols ();
1499 lines_per_page
= rows
;
1500 chars_per_line
= cols
;
1502 /* Make sure Readline has initialized its terminal settings. */
1503 rl_reset_terminal (NULL
);
1505 /* Get the screen size from Readline. */
1506 rl_get_screen_size (&rows
, &cols
);
1507 lines_per_page
= rows
;
1508 chars_per_line
= cols
;
1510 /* Readline should have fetched the termcap entry for us.
1511 Only try to use tgetnum function if rl_get_screen_size
1512 did not return a useful value. */
1513 if (((rows
<= 0) && (tgetnum ((char *) "li") < 0))
1514 /* Also disable paging if inside Emacs. $EMACS was used
1515 before Emacs v25.1, $INSIDE_EMACS is used since then. */
1516 || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1518 /* The number of lines per page is not mentioned in the terminal
1519 description or EMACS evironment variable is set. This probably
1520 means that paging is not useful, so disable paging. */
1521 lines_per_page
= UINT_MAX
;
1524 /* If the output is not a terminal, don't paginate it. */
1525 if (!ui_file_isatty (gdb_stdout
))
1526 lines_per_page
= UINT_MAX
;
1530 /* We handle SIGWINCH ourselves. */
1531 rl_catch_sigwinch
= 0;
1537 /* Return nonzero if filtered printing is initialized. */
1539 filtered_printing_initialized (void)
1541 return wrap_buffer
!= NULL
;
1544 /* Helper for make_cleanup_restore_page_info. */
1547 do_restore_page_info_cleanup (void *arg
)
1553 /* Provide cleanup for restoring the terminal size. */
1556 make_cleanup_restore_page_info (void)
1558 struct cleanup
*back_to
;
1560 back_to
= make_cleanup (do_restore_page_info_cleanup
, NULL
);
1561 make_cleanup_restore_uinteger (&lines_per_page
);
1562 make_cleanup_restore_uinteger (&chars_per_line
);
1567 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1568 Provide cleanup for restoring the original state. */
1571 set_batch_flag_and_make_cleanup_restore_page_info (void)
1573 struct cleanup
*back_to
= make_cleanup_restore_page_info ();
1575 make_cleanup_restore_integer (&batch_flag
);
1582 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1585 set_screen_size (void)
1587 int rows
= lines_per_page
;
1588 int cols
= chars_per_line
;
1596 /* Update Readline's idea of the terminal size. */
1597 rl_set_screen_size (rows
, cols
);
1600 /* Reinitialize WRAP_BUFFER according to the current value of
1606 if (chars_per_line
== 0)
1611 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1612 wrap_buffer
[0] = '\0';
1615 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1616 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1620 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1627 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1635 set_screen_width_and_height (int width
, int height
)
1637 lines_per_page
= height
;
1638 chars_per_line
= width
;
1644 /* Wait, so the user can read what's on the screen. Prompt the user
1645 to continue by pressing RETURN. 'q' is also provided because
1646 telling users what to do in the prompt is more user-friendly than
1647 expecting them to think of Ctrl-C/SIGINT. */
1650 prompt_for_continue (void)
1653 char cont_prompt
[120];
1654 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1655 /* Used to add duration we waited for user to respond to
1656 prompt_for_continue_wait_time. */
1657 using namespace std::chrono
;
1658 steady_clock::time_point prompt_started
= steady_clock::now ();
1660 if (annotation_level
> 1)
1661 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1663 strcpy (cont_prompt
,
1664 "---Type <return> to continue, or q <return> to quit---");
1665 if (annotation_level
> 1)
1666 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1668 /* We must do this *before* we call gdb_readline_wrapper, else it
1669 will eventually call us -- thinking that we're trying to print
1670 beyond the end of the screen. */
1671 reinitialize_more_filter ();
1673 prepare_to_handle_input ();
1675 /* Call gdb_readline_wrapper, not readline, in order to keep an
1676 event loop running. */
1677 ignore
= gdb_readline_wrapper (cont_prompt
);
1678 make_cleanup (xfree
, ignore
);
1680 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1681 prompt_for_continue_wait_time
+= steady_clock::now () - prompt_started
;
1683 if (annotation_level
> 1)
1684 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1690 while (*p
== ' ' || *p
== '\t')
1693 /* Do not call quit here; there is no possibility of SIGINT. */
1694 throw_quit ("Quit");
1697 /* Now we have to do this again, so that GDB will know that it doesn't
1698 need to save the ---Type <return>--- line at the top of the screen. */
1699 reinitialize_more_filter ();
1701 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1703 do_cleanups (old_chain
);
1706 /* Initialize timer to keep track of how long we waited for the user. */
1709 reset_prompt_for_continue_wait_time (void)
1711 using namespace std::chrono
;
1713 prompt_for_continue_wait_time
= steady_clock::duration::zero ();
1716 /* Fetch the cumulative time spent in prompt_for_continue. */
1718 std::chrono::steady_clock::duration
1719 get_prompt_for_continue_wait_time ()
1721 return prompt_for_continue_wait_time
;
1724 /* Reinitialize filter; ie. tell it to reset to original values. */
1727 reinitialize_more_filter (void)
1733 /* Indicate that if the next sequence of characters overflows the line,
1734 a newline should be inserted here rather than when it hits the end.
1735 If INDENT is non-null, it is a string to be printed to indent the
1736 wrapped part on the next line. INDENT must remain accessible until
1737 the next call to wrap_here() or until a newline is printed through
1740 If the line is already overfull, we immediately print a newline and
1741 the indentation, and disable further wrapping.
1743 If we don't know the width of lines, but we know the page height,
1744 we must not wrap words, but should still keep track of newlines
1745 that were explicitly printed.
1747 INDENT should not contain tabs, as that will mess up the char count
1748 on the next line. FIXME.
1750 This routine is guaranteed to force out any output which has been
1751 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1752 used to force out output from the wrap_buffer. */
1755 wrap_here (const char *indent
)
1757 /* This should have been allocated, but be paranoid anyway. */
1759 internal_error (__FILE__
, __LINE__
,
1760 _("failed internal consistency check"));
1764 *wrap_pointer
= '\0';
1765 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1767 wrap_pointer
= wrap_buffer
;
1768 wrap_buffer
[0] = '\0';
1769 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
1773 else if (chars_printed
>= chars_per_line
)
1775 puts_filtered ("\n");
1777 puts_filtered (indent
);
1782 wrap_column
= chars_printed
;
1786 wrap_indent
= indent
;
1790 /* Print input string to gdb_stdout, filtered, with wrap,
1791 arranging strings in columns of n chars. String can be
1792 right or left justified in the column. Never prints
1793 trailing spaces. String should never be longer than
1794 width. FIXME: this could be useful for the EXAMINE
1795 command, which currently doesn't tabulate very well. */
1798 puts_filtered_tabular (char *string
, int width
, int right
)
1804 gdb_assert (chars_per_line
> 0);
1805 if (chars_per_line
== UINT_MAX
)
1807 fputs_filtered (string
, gdb_stdout
);
1808 fputs_filtered ("\n", gdb_stdout
);
1812 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1813 fputs_filtered ("\n", gdb_stdout
);
1815 if (width
>= chars_per_line
)
1816 width
= chars_per_line
- 1;
1818 stringlen
= strlen (string
);
1820 if (chars_printed
> 0)
1821 spaces
= width
- (chars_printed
- 1) % width
- 1;
1823 spaces
+= width
- stringlen
;
1825 spacebuf
= (char *) alloca (spaces
+ 1);
1826 spacebuf
[spaces
] = '\0';
1828 spacebuf
[spaces
] = ' ';
1830 fputs_filtered (spacebuf
, gdb_stdout
);
1831 fputs_filtered (string
, gdb_stdout
);
1835 /* Ensure that whatever gets printed next, using the filtered output
1836 commands, starts at the beginning of the line. I.e. if there is
1837 any pending output for the current line, flush it and start a new
1838 line. Otherwise do nothing. */
1843 if (chars_printed
> 0)
1845 puts_filtered ("\n");
1850 /* Like fputs but if FILTER is true, pause after every screenful.
1852 Regardless of FILTER can wrap at points other than the final
1853 character of a line.
1855 Unlike fputs, fputs_maybe_filtered does not return a value.
1856 It is OK for LINEBUFFER to be NULL, in which case just don't print
1859 Note that a longjmp to top level may occur in this routine (only if
1860 FILTER is true) (since prompt_for_continue may do so) so this
1861 routine should not be called when cleanups are not in place. */
1864 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1867 const char *lineptr
;
1869 if (linebuffer
== 0)
1872 /* Don't do any filtering if it is disabled. */
1873 if (stream
!= gdb_stdout
1874 || !pagination_enabled
1876 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
1877 || top_level_interpreter () == NULL
1878 || interp_ui_out (top_level_interpreter ())->is_mi_like_p ())
1880 fputs_unfiltered (linebuffer
, stream
);
1884 /* Go through and output each character. Show line extension
1885 when this is necessary; prompt user for new page when this is
1888 lineptr
= linebuffer
;
1891 /* Possible new page. */
1892 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1893 prompt_for_continue ();
1895 while (*lineptr
&& *lineptr
!= '\n')
1897 /* Print a single line. */
1898 if (*lineptr
== '\t')
1901 *wrap_pointer
++ = '\t';
1903 fputc_unfiltered ('\t', stream
);
1904 /* Shifting right by 3 produces the number of tab stops
1905 we have already passed, and then adding one and
1906 shifting left 3 advances to the next tab stop. */
1907 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1913 *wrap_pointer
++ = *lineptr
;
1915 fputc_unfiltered (*lineptr
, stream
);
1920 if (chars_printed
>= chars_per_line
)
1922 unsigned int save_chars
= chars_printed
;
1926 /* If we aren't actually wrapping, don't output newline --
1927 if chars_per_line is right, we probably just overflowed
1928 anyway; if it's wrong, let us keep going. */
1930 fputc_unfiltered ('\n', stream
);
1932 /* Possible new page. */
1933 if (lines_printed
>= lines_per_page
- 1)
1934 prompt_for_continue ();
1936 /* Now output indentation and wrapped string. */
1939 fputs_unfiltered (wrap_indent
, stream
);
1940 *wrap_pointer
= '\0'; /* Null-terminate saved stuff, */
1941 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it. */
1942 /* FIXME, this strlen is what prevents wrap_indent from
1943 containing tabs. However, if we recurse to print it
1944 and count its chars, we risk trouble if wrap_indent is
1945 longer than (the user settable) chars_per_line.
1946 Note also that this can set chars_printed > chars_per_line
1947 if we are printing a long string. */
1948 chars_printed
= strlen (wrap_indent
)
1949 + (save_chars
- wrap_column
);
1950 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1951 wrap_buffer
[0] = '\0';
1952 wrap_column
= 0; /* And disable fancy wrap */
1957 if (*lineptr
== '\n')
1960 wrap_here ((char *) 0); /* Spit out chars, cancel
1963 fputc_unfiltered ('\n', stream
);
1970 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1972 fputs_maybe_filtered (linebuffer
, stream
, 1);
1976 putchar_unfiltered (int c
)
1980 ui_file_write (gdb_stdout
, &buf
, 1);
1984 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1985 May return nonlocally. */
1988 putchar_filtered (int c
)
1990 return fputc_filtered (c
, gdb_stdout
);
1994 fputc_unfiltered (int c
, struct ui_file
*stream
)
1998 ui_file_write (stream
, &buf
, 1);
2003 fputc_filtered (int c
, struct ui_file
*stream
)
2009 fputs_filtered (buf
, stream
);
2013 /* puts_debug is like fputs_unfiltered, except it prints special
2014 characters in printable fashion. */
2017 puts_debug (char *prefix
, char *string
, char *suffix
)
2021 /* Print prefix and suffix after each line. */
2022 static int new_line
= 1;
2023 static int return_p
= 0;
2024 static const char *prev_prefix
= "";
2025 static const char *prev_suffix
= "";
2027 if (*string
== '\n')
2030 /* If the prefix is changing, print the previous suffix, a new line,
2031 and the new prefix. */
2032 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2034 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2035 fputs_unfiltered ("\n", gdb_stdlog
);
2036 fputs_unfiltered (prefix
, gdb_stdlog
);
2039 /* Print prefix if we printed a newline during the previous call. */
2043 fputs_unfiltered (prefix
, gdb_stdlog
);
2046 prev_prefix
= prefix
;
2047 prev_suffix
= suffix
;
2049 /* Output characters in a printable format. */
2050 while ((ch
= *string
++) != '\0')
2056 fputc_unfiltered (ch
, gdb_stdlog
);
2059 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2063 fputs_unfiltered ("\\\\", gdb_stdlog
);
2066 fputs_unfiltered ("\\b", gdb_stdlog
);
2069 fputs_unfiltered ("\\f", gdb_stdlog
);
2073 fputs_unfiltered ("\\n", gdb_stdlog
);
2076 fputs_unfiltered ("\\r", gdb_stdlog
);
2079 fputs_unfiltered ("\\t", gdb_stdlog
);
2082 fputs_unfiltered ("\\v", gdb_stdlog
);
2086 return_p
= ch
== '\r';
2089 /* Print suffix if we printed a newline. */
2092 fputs_unfiltered (suffix
, gdb_stdlog
);
2093 fputs_unfiltered ("\n", gdb_stdlog
);
2098 /* Print a variable number of ARGS using format FORMAT. If this
2099 information is going to put the amount written (since the last call
2100 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2101 call prompt_for_continue to get the users permision to continue.
2103 Unlike fprintf, this function does not return a value.
2105 We implement three variants, vfprintf (takes a vararg list and stream),
2106 fprintf (takes a stream to write on), and printf (the usual).
2108 Note also that a longjmp to top level may occur in this routine
2109 (since prompt_for_continue may do so) so this routine should not be
2110 called when cleanups are not in place. */
2113 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2114 va_list args
, int filter
)
2117 struct cleanup
*old_cleanups
;
2119 linebuffer
= xstrvprintf (format
, args
);
2120 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2121 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2122 do_cleanups (old_cleanups
);
2127 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2129 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2133 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2136 struct cleanup
*old_cleanups
;
2138 linebuffer
= xstrvprintf (format
, args
);
2139 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2140 if (debug_timestamp
&& stream
== gdb_stdlog
)
2142 using namespace std::chrono
;
2145 steady_clock::time_point now
= steady_clock::now ();
2146 seconds s
= duration_cast
<seconds
> (now
.time_since_epoch ());
2147 microseconds us
= duration_cast
<microseconds
> (now
.time_since_epoch () - s
);
2149 len
= strlen (linebuffer
);
2150 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2152 std::string timestamp
= string_printf ("%ld.%06ld %s%s",
2155 linebuffer
, need_nl
? "\n": "");
2156 fputs_unfiltered (timestamp
.c_str (), stream
);
2159 fputs_unfiltered (linebuffer
, stream
);
2160 do_cleanups (old_cleanups
);
2164 vprintf_filtered (const char *format
, va_list args
)
2166 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2170 vprintf_unfiltered (const char *format
, va_list args
)
2172 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2176 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2180 va_start (args
, format
);
2181 vfprintf_filtered (stream
, format
, args
);
2186 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2190 va_start (args
, format
);
2191 vfprintf_unfiltered (stream
, format
, args
);
2195 /* Like fprintf_filtered, but prints its result indented.
2196 Called as fprintfi_filtered (spaces, stream, format, ...); */
2199 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2204 va_start (args
, format
);
2205 print_spaces_filtered (spaces
, stream
);
2207 vfprintf_filtered (stream
, format
, args
);
2213 printf_filtered (const char *format
, ...)
2217 va_start (args
, format
);
2218 vfprintf_filtered (gdb_stdout
, format
, args
);
2224 printf_unfiltered (const char *format
, ...)
2228 va_start (args
, format
);
2229 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2233 /* Like printf_filtered, but prints it's result indented.
2234 Called as printfi_filtered (spaces, format, ...); */
2237 printfi_filtered (int spaces
, const char *format
, ...)
2241 va_start (args
, format
);
2242 print_spaces_filtered (spaces
, gdb_stdout
);
2243 vfprintf_filtered (gdb_stdout
, format
, args
);
2247 /* Easy -- but watch out!
2249 This routine is *not* a replacement for puts()! puts() appends a newline.
2250 This one doesn't, and had better not! */
2253 puts_filtered (const char *string
)
2255 fputs_filtered (string
, gdb_stdout
);
2259 puts_unfiltered (const char *string
)
2261 fputs_unfiltered (string
, gdb_stdout
);
2264 /* Return a pointer to N spaces and a null. The pointer is good
2265 until the next call to here. */
2270 static char *spaces
= 0;
2271 static int max_spaces
= -1;
2277 spaces
= (char *) xmalloc (n
+ 1);
2278 for (t
= spaces
+ n
; t
!= spaces
;)
2284 return spaces
+ max_spaces
- n
;
2287 /* Print N spaces. */
2289 print_spaces_filtered (int n
, struct ui_file
*stream
)
2291 fputs_filtered (n_spaces (n
), stream
);
2294 /* C++/ObjC demangler stuff. */
2296 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2297 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2298 If the name is not mangled, or the language for the name is unknown, or
2299 demangling is off, the name is printed in its "raw" form. */
2302 fprintf_symbol_filtered (struct ui_file
*stream
, const char *name
,
2303 enum language lang
, int arg_mode
)
2309 /* If user wants to see raw output, no problem. */
2312 fputs_filtered (name
, stream
);
2316 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2317 fputs_filtered (demangled
? demangled
: name
, stream
);
2318 if (demangled
!= NULL
)
2326 /* Modes of operation for strncmp_iw_with_mode. */
2328 enum class strncmp_iw_mode
2330 /* Work like strncmp, while ignoring whitespace. */
2333 /* Like NORMAL, but also apply the strcmp_iw hack. I.e.,
2334 string1=="FOO(PARAMS)" matches string2=="FOO". */
2338 /* Helper for strncmp_iw and strcmp_iw. */
2341 strncmp_iw_with_mode (const char *string1
, const char *string2
,
2342 size_t string2_len
, strncmp_iw_mode mode
)
2344 const char *end_str2
= string2
+ string2_len
;
2348 while (isspace (*string1
))
2350 while (string2
< end_str2
&& isspace (*string2
))
2352 if (*string1
== '\0' || string2
== end_str2
)
2354 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
2356 if (case_sensitivity
== case_sensitive_off
2357 && (tolower ((unsigned char) *string1
)
2358 != tolower ((unsigned char) *string2
)))
2365 if (string2
== end_str2
)
2367 if (mode
== strncmp_iw_mode::NORMAL
)
2370 return (*string1
!= '\0' && *string1
!= '(');
2379 strncmp_iw (const char *string1
, const char *string2
, size_t string2_len
)
2381 return strncmp_iw_with_mode (string1
, string2
, string2_len
,
2382 strncmp_iw_mode::NORMAL
);
2388 strcmp_iw (const char *string1
, const char *string2
)
2390 return strncmp_iw_with_mode (string1
, string2
, strlen (string2
),
2391 strncmp_iw_mode::MATCH_PARAMS
);
2394 /* This is like strcmp except that it ignores whitespace and treats
2395 '(' as the first non-NULL character in terms of ordering. Like
2396 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2397 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2398 according to that ordering.
2400 If a list is sorted according to this function and if you want to
2401 find names in the list that match some fixed NAME according to
2402 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2403 where this function would put NAME.
2405 This function must be neutral to the CASE_SENSITIVITY setting as the user
2406 may choose it during later lookup. Therefore this function always sorts
2407 primarily case-insensitively and secondarily case-sensitively.
2409 Here are some examples of why using strcmp to sort is a bad idea:
2413 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2414 we try to do a search for "foo<char*>", strcmp will locate this
2415 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2416 will start looking at strings beginning with "goo", and will never
2417 see the correct match of "foo<char *>".
2419 Parenthesis example:
2421 In practice, this is less like to be an issue, but I'll give it a
2422 shot. Let's assume that '$' is a legitimate character to occur in
2423 symbols. (Which may well even be the case on some systems.) Then
2424 say that the partial symbol table contains "foo$" and "foo(int)".
2425 strcmp will put them in this order, since '$' < '('. Now, if the
2426 user searches for "foo", then strcmp will sort "foo" before "foo$".
2427 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2428 "foo") is false, so it won't proceed to the actual match of
2429 "foo(int)" with "foo". */
2432 strcmp_iw_ordered (const char *string1
, const char *string2
)
2434 const char *saved_string1
= string1
, *saved_string2
= string2
;
2435 enum case_sensitivity case_pass
= case_sensitive_off
;
2439 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2440 Provide stub characters if we are already at the end of one of the
2442 char c1
= 'X', c2
= 'X';
2444 while (*string1
!= '\0' && *string2
!= '\0')
2446 while (isspace (*string1
))
2448 while (isspace (*string2
))
2453 case case_sensitive_off
:
2454 c1
= tolower ((unsigned char) *string1
);
2455 c2
= tolower ((unsigned char) *string2
);
2457 case case_sensitive_on
:
2465 if (*string1
!= '\0')
2474 /* Characters are non-equal unless they're both '\0'; we want to
2475 make sure we get the comparison right according to our
2476 comparison in the cases where one of them is '\0' or '('. */
2478 if (*string2
== '\0')
2483 if (*string2
== '\0')
2488 if (*string2
== '\0' || *string2
== '(')
2497 if (case_pass
== case_sensitive_on
)
2500 /* Otherwise the strings were equal in case insensitive way, make
2501 a more fine grained comparison in a case sensitive way. */
2503 case_pass
= case_sensitive_on
;
2504 string1
= saved_string1
;
2505 string2
= saved_string2
;
2509 /* A simple comparison function with opposite semantics to strcmp. */
2512 streq (const char *lhs
, const char *rhs
)
2514 return !strcmp (lhs
, rhs
);
2520 ** Answer whether string_to_compare is a full or partial match to
2521 ** template_string. The partial match must be in sequence starting
2525 subset_compare (const char *string_to_compare
, const char *template_string
)
2529 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2530 && strlen (string_to_compare
) <= strlen (template_string
))
2532 (startswith (template_string
, string_to_compare
));
2539 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2540 struct cmd_list_element
*c
, const char *value
)
2542 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
2548 initialize_utils (void)
2550 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2551 Set number of characters where GDB should wrap lines of its output."), _("\
2552 Show number of characters where GDB should wrap lines of its output."), _("\
2553 This affects where GDB wraps its output to fit the screen width.\n\
2554 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2556 show_chars_per_line
,
2557 &setlist
, &showlist
);
2559 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2560 Set number of lines in a page for GDB output pagination."), _("\
2561 Show number of lines in a page for GDB output pagination."), _("\
2562 This affects the number of lines after which GDB will pause\n\
2563 its output and ask you whether to continue.\n\
2564 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2566 show_lines_per_page
,
2567 &setlist
, &showlist
);
2569 add_setshow_boolean_cmd ("pagination", class_support
,
2570 &pagination_enabled
, _("\
2571 Set state of GDB output pagination."), _("\
2572 Show state of GDB output pagination."), _("\
2573 When pagination is ON, GDB pauses at end of each screenful of\n\
2574 its output and asks you whether to continue.\n\
2575 Turning pagination off is an alternative to \"set height unlimited\"."),
2577 show_pagination_enabled
,
2578 &setlist
, &showlist
);
2580 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2581 &sevenbit_strings
, _("\
2582 Set printing of 8-bit characters in strings as \\nnn."), _("\
2583 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2585 show_sevenbit_strings
,
2586 &setprintlist
, &showprintlist
);
2588 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2589 &debug_timestamp
, _("\
2590 Set timestamping of debugging messages."), _("\
2591 Show timestamping of debugging messages."), _("\
2592 When set, debugging messages will be marked with seconds and microseconds."),
2594 show_debug_timestamp
,
2595 &setdebuglist
, &showdebuglist
);
2599 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2601 /* Truncate address to the size of a target address, avoiding shifts
2602 larger or equal than the width of a CORE_ADDR. The local
2603 variable ADDR_BIT stops the compiler reporting a shift overflow
2604 when it won't occur. */
2605 /* NOTE: This assumes that the significant address information is
2606 kept in the least significant bits of ADDR - the upper bits were
2607 either zero or sign extended. Should gdbarch_address_to_pointer or
2608 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2610 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2612 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2613 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2614 return hex_string (addr
);
2617 /* This function is described in "defs.h". */
2620 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2622 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2624 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2625 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2627 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2628 that returns the language localized string formatted to a width
2629 based on gdbarch_addr_bit. */
2631 return hex_string_custom (address
, 8);
2633 return hex_string_custom (address
, 16);
2636 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2639 core_addr_hash (const void *ap
)
2641 const CORE_ADDR
*addrp
= (const CORE_ADDR
*) ap
;
2646 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2649 core_addr_eq (const void *ap
, const void *bp
)
2651 const CORE_ADDR
*addr_ap
= (const CORE_ADDR
*) ap
;
2652 const CORE_ADDR
*addr_bp
= (const CORE_ADDR
*) bp
;
2654 return *addr_ap
== *addr_bp
;
2657 /* Convert a string back into a CORE_ADDR. */
2659 string_to_core_addr (const char *my_string
)
2663 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2665 /* Assume that it is in hex. */
2668 for (i
= 2; my_string
[i
] != '\0'; i
++)
2670 if (isdigit (my_string
[i
]))
2671 addr
= (my_string
[i
] - '0') + (addr
* 16);
2672 else if (isxdigit (my_string
[i
]))
2673 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2675 error (_("invalid hex \"%s\""), my_string
);
2680 /* Assume that it is in decimal. */
2683 for (i
= 0; my_string
[i
] != '\0'; i
++)
2685 if (isdigit (my_string
[i
]))
2686 addr
= (my_string
[i
] - '0') + (addr
* 10);
2688 error (_("invalid decimal \"%s\""), my_string
);
2696 gdb_realpath (const char *filename
)
2698 /* On most hosts, we rely on canonicalize_file_name to compute
2699 the FILENAME's realpath.
2701 But the situation is slightly more complex on Windows, due to some
2702 versions of GCC which were reported to generate paths where
2703 backlashes (the directory separator) were doubled. For instance:
2704 c:\\some\\double\\slashes\\dir
2706 c:\some\double\slashes\dir
2707 Those double-slashes were getting in the way when comparing paths,
2708 for instance when trying to insert a breakpoint as follow:
2709 (gdb) b c:/some/double/slashes/dir/foo.c:4
2710 No source file named c:/some/double/slashes/dir/foo.c:4.
2711 (gdb) b c:\some\double\slashes\dir\foo.c:4
2712 No source file named c:\some\double\slashes\dir\foo.c:4.
2713 To prevent this from happening, we need this function to always
2714 strip those extra backslashes. While canonicalize_file_name does
2715 perform this simplification, it only works when the path is valid.
2716 Since the simplification would be useful even if the path is not
2717 valid (one can always set a breakpoint on a file, even if the file
2718 does not exist locally), we rely instead on GetFullPathName to
2719 perform the canonicalization. */
2721 #if defined (_WIN32)
2724 DWORD len
= GetFullPathName (filename
, MAX_PATH
, buf
, NULL
);
2726 /* The file system is case-insensitive but case-preserving.
2727 So it is important we do not lowercase the path. Otherwise,
2728 we might not be able to display the original casing in a given
2730 if (len
> 0 && len
< MAX_PATH
)
2731 return xstrdup (buf
);
2735 char *rp
= canonicalize_file_name (filename
);
2742 /* This system is a lost cause, just dup the buffer. */
2743 return xstrdup (filename
);
2746 /* Return a copy of FILENAME, with its directory prefix canonicalized
2750 gdb_realpath_keepfile (const char *filename
)
2752 const char *base_name
= lbasename (filename
);
2757 /* Extract the basename of filename, and return immediately
2758 a copy of filename if it does not contain any directory prefix. */
2759 if (base_name
== filename
)
2760 return xstrdup (filename
);
2762 dir_name
= (char *) alloca ((size_t) (base_name
- filename
+ 2));
2763 /* Allocate enough space to store the dir_name + plus one extra
2764 character sometimes needed under Windows (see below), and
2765 then the closing \000 character. */
2766 strncpy (dir_name
, filename
, base_name
- filename
);
2767 dir_name
[base_name
- filename
] = '\000';
2769 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2770 /* We need to be careful when filename is of the form 'd:foo', which
2771 is equivalent of d:./foo, which is totally different from d:/foo. */
2772 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
2775 dir_name
[3] = '\000';
2779 /* Canonicalize the directory prefix, and build the resulting
2780 filename. If the dirname realpath already contains an ending
2781 directory separator, avoid doubling it. */
2782 real_path
= gdb_realpath (dir_name
);
2783 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2784 result
= concat (real_path
, base_name
, (char *) NULL
);
2786 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *) NULL
);
2792 /* Return PATH in absolute form, performing tilde-expansion if necessary.
2793 PATH cannot be NULL or the empty string.
2794 This does not resolve symlinks however, use gdb_realpath for that.
2795 Space for the result is allocated with malloc.
2796 If the path is already absolute, it is strdup'd.
2797 If there is a problem computing the absolute path, the path is returned
2798 unchanged (still strdup'd). */
2801 gdb_abspath (const char *path
)
2803 gdb_assert (path
!= NULL
&& path
[0] != '\0');
2806 return tilde_expand (path
);
2808 if (IS_ABSOLUTE_PATH (path
))
2809 return xstrdup (path
);
2811 /* Beware the // my son, the Emacs barfs, the botch that catch... */
2812 return concat (current_directory
,
2813 IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1])
2814 ? "" : SLASH_STRING
,
2815 path
, (char *) NULL
);
2819 align_up (ULONGEST v
, int n
)
2821 /* Check that N is really a power of two. */
2822 gdb_assert (n
&& (n
& (n
-1)) == 0);
2823 return (v
+ n
- 1) & -n
;
2827 align_down (ULONGEST v
, int n
)
2829 /* Check that N is really a power of two. */
2830 gdb_assert (n
&& (n
& (n
-1)) == 0);
2834 /* Allocation function for the libiberty hash table which uses an
2835 obstack. The obstack is passed as DATA. */
2838 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
2840 size_t total
= size
* count
;
2841 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
2843 memset (ptr
, 0, total
);
2847 /* Trivial deallocation function for the libiberty splay tree and hash
2848 table - don't deallocate anything. Rely on later deletion of the
2849 obstack. DATA will be the obstack, although it is not needed
2853 dummy_obstack_deallocate (void *object
, void *data
)
2858 /* Simple, portable version of dirname that does not modify its
2862 ldirname (const char *filename
)
2864 std::string dirname
;
2865 const char *base
= lbasename (filename
);
2867 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
2870 if (base
== filename
)
2873 dirname
= std::string (filename
, base
- filename
);
2875 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
2876 create "d:./bar" later instead of the (different) "d:/bar". */
2877 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
2878 && !IS_DIR_SEPARATOR (filename
[0]))
2879 dirname
[base
++ - filename
] = '.';
2884 /* Call libiberty's buildargv, and return the result.
2885 If buildargv fails due to out-of-memory, call nomem.
2886 Therefore, the returned value is guaranteed to be non-NULL,
2887 unless the parameter itself is NULL. */
2890 gdb_buildargv (const char *s
)
2892 char **argv
= buildargv (s
);
2894 if (s
!= NULL
&& argv
== NULL
)
2900 compare_positive_ints (const void *ap
, const void *bp
)
2902 /* Because we know we're comparing two ints which are positive,
2903 there's no danger of overflow here. */
2904 return * (int *) ap
- * (int *) bp
;
2907 /* String compare function for qsort. */
2910 compare_strings (const void *arg1
, const void *arg2
)
2912 const char **s1
= (const char **) arg1
;
2913 const char **s2
= (const char **) arg2
;
2915 return strcmp (*s1
, *s2
);
2918 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
2919 #define AMBIGUOUS_MESS2 \
2920 ".\nUse \"set gnutarget format-name\" to specify the format."
2923 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
2929 /* Check if errmsg just need simple return. */
2930 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
2931 return bfd_errmsg (error_tag
);
2933 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
2934 + strlen (AMBIGUOUS_MESS2
);
2935 for (p
= matching
; *p
; p
++)
2936 ret_len
+= strlen (*p
) + 1;
2937 ret
= (char *) xmalloc (ret_len
+ 1);
2939 make_cleanup (xfree
, ret
);
2941 strcpy (retp
, bfd_errmsg (error_tag
));
2942 retp
+= strlen (retp
);
2944 strcpy (retp
, AMBIGUOUS_MESS1
);
2945 retp
+= strlen (retp
);
2947 for (p
= matching
; *p
; p
++)
2949 sprintf (retp
, " %s", *p
);
2950 retp
+= strlen (retp
);
2954 strcpy (retp
, AMBIGUOUS_MESS2
);
2959 /* Return ARGS parsed as a valid pid, or throw an error. */
2962 parse_pid_to_attach (const char *args
)
2968 error_no_arg (_("process-id to attach"));
2970 dummy
= (char *) args
;
2971 pid
= strtoul (args
, &dummy
, 0);
2972 /* Some targets don't set errno on errors, grrr! */
2973 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
2974 error (_("Illegal process-id: %s."), args
);
2979 /* Helper for make_bpstat_clear_actions_cleanup. */
2982 do_bpstat_clear_actions_cleanup (void *unused
)
2984 bpstat_clear_actions ();
2987 /* Call bpstat_clear_actions for the case an exception is throw. You should
2988 discard_cleanups if no exception is caught. */
2991 make_bpstat_clear_actions_cleanup (void)
2993 return make_cleanup (do_bpstat_clear_actions_cleanup
, NULL
);
2996 /* Check for GCC >= 4.x according to the symtab->producer string. Return minor
2997 version (x) of 4.x in such case. If it is not GCC or it is GCC older than
2998 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
3001 producer_is_gcc_ge_4 (const char *producer
)
3005 if (! producer_is_gcc (producer
, &major
, &minor
))
3014 /* Returns nonzero if the given PRODUCER string is GCC and sets the MAJOR
3015 and MINOR versions when not NULL. Returns zero if the given PRODUCER
3016 is NULL or it isn't GCC. */
3019 producer_is_gcc (const char *producer
, int *major
, int *minor
)
3023 if (producer
!= NULL
&& startswith (producer
, "GNU "))
3032 /* Skip any identifier after "GNU " - such as "C11" or "C++".
3033 A full producer string might look like:
3035 "GNU Fortran 4.8.2 20140120 (Red Hat 4.8.2-16) -mtune=generic ..."
3036 "GNU C++14 5.0.0 20150123 (experimental)"
3038 cs
= &producer
[strlen ("GNU ")];
3039 while (*cs
&& !isspace (*cs
))
3041 if (*cs
&& isspace (*cs
))
3043 if (sscanf (cs
, "%d.%d", major
, minor
) == 2)
3047 /* Not recognized as GCC. */
3051 /* Helper for make_cleanup_free_char_ptr_vec. */
3054 do_free_char_ptr_vec (void *arg
)
3056 VEC (char_ptr
) *char_ptr_vec
= (VEC (char_ptr
) *) arg
;
3058 free_char_ptr_vec (char_ptr_vec
);
3061 /* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
3062 final VEC_free for CHAR_PTR_VEC itself.
3064 You must not modify CHAR_PTR_VEC after this cleanup registration as the
3065 CHAR_PTR_VEC base address may change on its updates. Contrary to VEC_free
3066 this function does not (cannot) clear the pointer. */
3069 make_cleanup_free_char_ptr_vec (VEC (char_ptr
) *char_ptr_vec
)
3071 return make_cleanup (do_free_char_ptr_vec
, char_ptr_vec
);
3074 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3075 must come from xrealloc-compatible allocator and it may be updated. FROM
3076 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3077 located at the start or end of *STRINGP. */
3080 substitute_path_component (char **stringp
, const char *from
, const char *to
)
3082 char *string
= *stringp
, *s
;
3083 const size_t from_len
= strlen (from
);
3084 const size_t to_len
= strlen (to
);
3088 s
= strstr (s
, from
);
3092 if ((s
== string
|| IS_DIR_SEPARATOR (s
[-1])
3093 || s
[-1] == DIRNAME_SEPARATOR
)
3094 && (s
[from_len
] == '\0' || IS_DIR_SEPARATOR (s
[from_len
])
3095 || s
[from_len
] == DIRNAME_SEPARATOR
))
3100 = (char *) xrealloc (string
, (strlen (string
) + to_len
+ 1));
3102 /* Relocate the current S pointer. */
3103 s
= s
- string
+ string_new
;
3104 string
= string_new
;
3106 /* Replace from by to. */
3107 memmove (&s
[to_len
], &s
[from_len
], strlen (&s
[from_len
]) + 1);
3108 memcpy (s
, to
, to_len
);
3123 /* SIGALRM handler for waitpid_with_timeout. */
3126 sigalrm_handler (int signo
)
3128 /* Nothing to do. */
3133 /* Wrapper to wait for child PID to die with TIMEOUT.
3134 TIMEOUT is the time to stop waiting in seconds.
3135 If TIMEOUT is zero, pass WNOHANG to waitpid.
3136 Returns PID if it was successfully waited for, otherwise -1.
3138 Timeouts are currently implemented with alarm and SIGALRM.
3139 If the host does not support them, this waits "forever".
3140 It would be odd though for a host to have waitpid and not SIGALRM. */
3143 wait_to_die_with_timeout (pid_t pid
, int *status
, int timeout
)
3145 pid_t waitpid_result
;
3147 gdb_assert (pid
> 0);
3148 gdb_assert (timeout
>= 0);
3153 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3154 struct sigaction sa
, old_sa
;
3156 sa
.sa_handler
= sigalrm_handler
;
3157 sigemptyset (&sa
.sa_mask
);
3159 sigaction (SIGALRM
, &sa
, &old_sa
);
3163 ofunc
= signal (SIGALRM
, sigalrm_handler
);
3169 waitpid_result
= waitpid (pid
, status
, 0);
3173 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3174 sigaction (SIGALRM
, &old_sa
, NULL
);
3176 signal (SIGALRM
, ofunc
);
3181 waitpid_result
= waitpid (pid
, status
, WNOHANG
);
3183 if (waitpid_result
== pid
)
3189 #endif /* HAVE_WAITPID */
3191 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3192 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3194 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3195 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3198 gdb_filename_fnmatch (const char *pattern
, const char *string
, int flags
)
3200 gdb_assert ((flags
& FNM_FILE_NAME
) != 0);
3202 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3203 gdb_assert ((flags
& FNM_NOESCAPE
) != 0);
3205 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3207 char *pattern_slash
, *string_slash
;
3209 /* Replace '\' by '/' in both strings. */
3211 pattern_slash
= (char *) alloca (strlen (pattern
) + 1);
3212 strcpy (pattern_slash
, pattern
);
3213 pattern
= pattern_slash
;
3214 for (; *pattern_slash
!= 0; pattern_slash
++)
3215 if (IS_DIR_SEPARATOR (*pattern_slash
))
3216 *pattern_slash
= '/';
3218 string_slash
= (char *) alloca (strlen (string
) + 1);
3219 strcpy (string_slash
, string
);
3220 string
= string_slash
;
3221 for (; *string_slash
!= 0; string_slash
++)
3222 if (IS_DIR_SEPARATOR (*string_slash
))
3223 *string_slash
= '/';
3225 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3227 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3228 flags
|= FNM_CASEFOLD
;
3229 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3231 return fnmatch (pattern
, string
, flags
);
3234 /* Return the number of path elements in PATH.
3242 count_path_elements (const char *path
)
3245 const char *p
= path
;
3247 if (HAS_DRIVE_SPEC (p
))
3249 p
= STRIP_DRIVE_SPEC (p
);
3255 if (IS_DIR_SEPARATOR (*p
))
3260 /* Backup one if last character is /, unless it's the only one. */
3261 if (p
> path
+ 1 && IS_DIR_SEPARATOR (p
[-1]))
3264 /* Add one for the file name, if present. */
3265 if (p
> path
&& !IS_DIR_SEPARATOR (p
[-1]))
3271 /* Remove N leading path elements from PATH.
3272 N must be non-negative.
3273 If PATH has more than N path elements then return NULL.
3274 If PATH has exactly N path elements then return "".
3275 See count_path_elements for a description of how we do the counting. */
3278 strip_leading_path_elements (const char *path
, int n
)
3281 const char *p
= path
;
3283 gdb_assert (n
>= 0);
3288 if (HAS_DRIVE_SPEC (p
))
3290 p
= STRIP_DRIVE_SPEC (p
);
3296 while (*p
!= '\0' && !IS_DIR_SEPARATOR (*p
))
3311 /* Provide a prototype to silence -Wmissing-prototypes. */
3312 extern initialize_file_ftype _initialize_utils
;
3315 _initialize_utils (void)
3317 add_internal_problem_command (&internal_error_problem
);
3318 add_internal_problem_command (&internal_warning_problem
);
3319 add_internal_problem_command (&demangler_warning_problem
);