1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 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/>. */
21 #include "dyn-string.h"
24 #include "event-top.h"
25 #include "gdbthread.h"
28 #ifdef HAVE_SYS_RESOURCE_H
29 #include <sys/resource.h>
30 #endif /* HAVE_SYS_RESOURCE_H */
33 #include "tui/tui.h" /* For tui_get_command_dimension. */
41 #include "timeval-utils.h"
46 #include "gdb-demangle.h"
47 #include "expression.h"
51 #include "filenames.h"
53 #include "gdb_obstack.h"
59 #include "inferior.h" /* for signed_pointer_to_address */
61 #include "gdb_curses.h"
63 #include "readline/readline.h"
65 #include "gdb_sys_time.h"
68 #include "gdb_usleep.h"
70 #include "gdb_regex.h"
73 extern PTR malloc (); /* ARI: PTR */
75 #if !HAVE_DECL_REALLOC
76 extern PTR realloc (); /* ARI: PTR */
82 void (*deprecated_error_begin_hook) (void);
84 /* Prototypes for local functions */
86 static void vfprintf_maybe_filtered (struct ui_file *, const char *,
87 va_list, int) ATTRIBUTE_PRINTF (2, 0);
89 static void fputs_maybe_filtered (const char *, struct ui_file *, int);
91 static void prompt_for_continue (void);
93 static void set_screen_size (void);
94 static void set_width (void);
96 /* Time spent in prompt_for_continue in the currently executing command
97 waiting for user to respond.
98 Initialized in make_command_stats_cleanup.
99 Modified in prompt_for_continue and defaulted_query.
100 Used in report_command_stats. */
102 static struct timeval prompt_for_continue_wait_time;
104 /* A flag indicating whether to timestamp debugging messages. */
106 static int debug_timestamp = 0;
108 /* Nonzero if we have job control. */
112 /* Nonzero means quit immediately if Control-C is typed now, rather
113 than waiting until QUIT is executed. Be careful in setting this;
114 code which executes with immediate_quit set has to be very careful
115 about being able to deal with being interrupted at any time. It is
116 almost always better to use QUIT; the only exception I can think of
117 is being able to quit out of a system call (using EINTR loses if
118 the SIGINT happens between the previous QUIT and the system call).
119 To immediately quit in the case in which a SIGINT happens between
120 the previous QUIT and setting immediate_quit (desirable anytime we
121 expect to block), call QUIT after setting immediate_quit. */
125 /* Nonzero means that strings with character values >0x7F should be printed
126 as octal escapes. Zero means just print the value (e.g. it's an
127 international character, and the terminal or window can cope.) */
129 int sevenbit_strings = 0;
131 show_sevenbit_strings (struct ui_file *file, int from_tty,
132 struct cmd_list_element *c, const char *value)
134 fprintf_filtered (file, _("Printing of 8-bit characters "
135 "in strings as \\nnn is %s.\n"),
139 /* String to be printed before warning messages, if any. */
141 char *warning_pre_print = "\nwarning: ";
143 int pagination_enabled = 1;
145 show_pagination_enabled (struct ui_file *file, int from_tty,
146 struct cmd_list_element *c, const char *value)
148 fprintf_filtered (file, _("State of pagination is %s.\n"), value);
152 /* Cleanup utilities.
154 These are not defined in cleanups.c (nor declared in cleanups.h)
155 because while they use the "cleanup API" they are not part of the
159 do_freeargv (void *arg)
161 freeargv ((char **) arg);
165 make_cleanup_freeargv (char **arg)
167 return make_cleanup (do_freeargv, arg);
171 do_dyn_string_delete (void *arg)
173 dyn_string_delete ((dyn_string_t) arg);
177 make_cleanup_dyn_string_delete (dyn_string_t arg)
179 return make_cleanup (do_dyn_string_delete, arg);
183 do_bfd_close_cleanup (void *arg)
185 gdb_bfd_unref ((bfd *) arg);
189 make_cleanup_bfd_unref (bfd *abfd)
191 return make_cleanup (do_bfd_close_cleanup, abfd);
194 /* Helper function which does the work for make_cleanup_fclose. */
197 do_fclose_cleanup (void *arg)
199 FILE *file = (FILE *) arg;
204 /* Return a new cleanup that closes FILE. */
207 make_cleanup_fclose (FILE *file)
209 return make_cleanup (do_fclose_cleanup, file);
212 /* Helper function which does the work for make_cleanup_obstack_free. */
215 do_obstack_free (void *arg)
217 struct obstack *ob = (struct obstack *) arg;
219 obstack_free (ob, NULL);
222 /* Return a new cleanup that frees OBSTACK. */
225 make_cleanup_obstack_free (struct obstack *obstack)
227 return make_cleanup (do_obstack_free, obstack);
231 do_ui_file_delete (void *arg)
233 ui_file_delete ((struct ui_file *) arg);
237 make_cleanup_ui_file_delete (struct ui_file *arg)
239 return make_cleanup (do_ui_file_delete, arg);
242 /* Helper function for make_cleanup_ui_out_redirect_pop. */
245 do_ui_out_redirect_pop (void *arg)
247 struct ui_out *uiout = (struct ui_out *) arg;
249 if (ui_out_redirect (uiout, NULL) < 0)
250 warning (_("Cannot restore redirection of the current output protocol"));
253 /* Return a new cleanup that pops the last redirection by ui_out_redirect
254 with NULL parameter. */
257 make_cleanup_ui_out_redirect_pop (struct ui_out *uiout)
259 return make_cleanup (do_ui_out_redirect_pop, uiout);
263 do_free_section_addr_info (void *arg)
265 free_section_addr_info ((struct section_addr_info *) arg);
269 make_cleanup_free_section_addr_info (struct section_addr_info *addrs)
271 return make_cleanup (do_free_section_addr_info, addrs);
274 struct restore_integer_closure
281 restore_integer (void *p)
283 struct restore_integer_closure *closure
284 = (struct restore_integer_closure *) p;
286 *(closure->variable) = closure->value;
289 /* Remember the current value of *VARIABLE and make it restored when
290 the cleanup is run. */
293 make_cleanup_restore_integer (int *variable)
295 struct restore_integer_closure *c = XNEW (struct restore_integer_closure);
297 c->variable = variable;
298 c->value = *variable;
300 return make_cleanup_dtor (restore_integer, (void *) c, xfree);
303 /* Remember the current value of *VARIABLE and make it restored when
304 the cleanup is run. */
307 make_cleanup_restore_uinteger (unsigned int *variable)
309 return make_cleanup_restore_integer ((int *) variable);
312 /* Helper for make_cleanup_unpush_target. */
315 do_unpush_target (void *arg)
317 struct target_ops *ops = (struct target_ops *) arg;
322 /* Return a new cleanup that unpushes OPS. */
325 make_cleanup_unpush_target (struct target_ops *ops)
327 return make_cleanup (do_unpush_target, ops);
330 /* Helper for make_cleanup_htab_delete compile time checking the types. */
333 do_htab_delete_cleanup (void *htab_voidp)
335 htab_t htab = (htab_t) htab_voidp;
340 /* Return a new cleanup that deletes HTAB. */
343 make_cleanup_htab_delete (htab_t htab)
345 return make_cleanup (do_htab_delete_cleanup, htab);
348 struct restore_ui_out_closure
350 struct ui_out **variable;
351 struct ui_out *value;
355 do_restore_ui_out (void *p)
357 struct restore_ui_out_closure *closure
358 = (struct restore_ui_out_closure *) p;
360 *(closure->variable) = closure->value;
363 /* Remember the current value of *VARIABLE and make it restored when
364 the cleanup is run. */
367 make_cleanup_restore_ui_out (struct ui_out **variable)
369 struct restore_ui_out_closure *c = XNEW (struct restore_ui_out_closure);
371 c->variable = variable;
372 c->value = *variable;
374 return make_cleanup_dtor (do_restore_ui_out, (void *) c, xfree);
377 struct restore_ui_file_closure
379 struct ui_file **variable;
380 struct ui_file *value;
384 do_restore_ui_file (void *p)
386 struct restore_ui_file_closure *closure
387 = (struct restore_ui_file_closure *) p;
389 *(closure->variable) = closure->value;
392 /* Remember the current value of *VARIABLE and make it restored when
393 the cleanup is run. */
396 make_cleanup_restore_ui_file (struct ui_file **variable)
398 struct restore_ui_file_closure *c = XNEW (struct restore_ui_file_closure);
400 c->variable = variable;
401 c->value = *variable;
403 return make_cleanup_dtor (do_restore_ui_file, (void *) c, xfree);
406 /* Helper for make_cleanup_value_free_to_mark. */
409 do_value_free_to_mark (void *value)
411 value_free_to_mark ((struct value *) value);
414 /* Free all values allocated since MARK was obtained by value_mark
415 (except for those released) when the cleanup is run. */
418 make_cleanup_value_free_to_mark (struct value *mark)
420 return make_cleanup (do_value_free_to_mark, mark);
423 /* Helper for make_cleanup_value_free. */
426 do_value_free (void *value)
428 value_free ((struct value *) value);
434 make_cleanup_value_free (struct value *value)
436 return make_cleanup (do_value_free, value);
439 /* Helper for make_cleanup_free_so. */
442 do_free_so (void *arg)
444 struct so_list *so = (struct so_list *) arg;
449 /* Make cleanup handler calling free_so for SO. */
452 make_cleanup_free_so (struct so_list *so)
454 return make_cleanup (do_free_so, so);
457 /* Helper for make_cleanup_restore_current_language. */
460 do_restore_current_language (void *p)
462 enum language saved_lang = (enum language) (uintptr_t) p;
464 set_language (saved_lang);
467 /* Remember the current value of CURRENT_LANGUAGE and make it restored when
468 the cleanup is run. */
471 make_cleanup_restore_current_language (void)
473 enum language saved_lang = current_language->la_language;
475 return make_cleanup (do_restore_current_language,
476 (void *) (uintptr_t) saved_lang);
479 /* Helper function for make_cleanup_clear_parser_state. */
482 do_clear_parser_state (void *ptr)
484 struct parser_state **p = (struct parser_state **) ptr;
489 /* Clean (i.e., set to NULL) the parser state variable P. */
492 make_cleanup_clear_parser_state (struct parser_state **p)
494 return make_cleanup (do_clear_parser_state, (void *) p);
497 /* This function is useful for cleanups.
501 old_chain = make_cleanup (free_current_contents, &foo);
503 to arrange to free the object thus allocated. */
506 free_current_contents (void *ptr)
508 void **location = (void **) ptr;
510 if (location == NULL)
511 internal_error (__FILE__, __LINE__,
512 _("free_current_contents: NULL pointer"));
513 if (*location != NULL)
522 /* Print a warning message. The first argument STRING is the warning
523 message, used as an fprintf format string, the second is the
524 va_list of arguments for that string. A warning is unfiltered (not
525 paginated) so that the user does not need to page through each
526 screen full of warnings when there are lots of them. */
529 vwarning (const char *string, va_list args)
531 if (deprecated_warning_hook)
532 (*deprecated_warning_hook) (string, args);
535 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
537 if (target_supports_terminal_ours ())
539 make_cleanup_restore_target_terminal ();
540 target_terminal_ours_for_output ();
542 if (filtered_printing_initialized ())
543 wrap_here (""); /* Force out any buffered output. */
544 gdb_flush (gdb_stdout);
545 if (warning_pre_print)
546 fputs_unfiltered (warning_pre_print, gdb_stderr);
547 vfprintf_unfiltered (gdb_stderr, string, args);
548 fprintf_unfiltered (gdb_stderr, "\n");
550 do_cleanups (old_chain);
554 /* Print an error message and return to command level.
555 The first argument STRING is the error message, used as a fprintf string,
556 and the remaining args are passed as arguments to it. */
559 verror (const char *string, va_list args)
561 throw_verror (GENERIC_ERROR, string, args);
565 error_stream (struct ui_file *stream)
567 char *message = ui_file_xstrdup (stream, NULL);
569 make_cleanup (xfree, message);
570 error (("%s"), message);
573 /* Emit a message and abort. */
575 static void ATTRIBUTE_NORETURN
576 abort_with_message (const char *msg)
578 if (gdb_stderr == NULL)
581 fputs_unfiltered (msg, gdb_stderr);
583 abort (); /* NOTE: GDB has only three calls to abort(). */
586 /* Dump core trying to increase the core soft limit to hard limit first. */
591 #ifdef HAVE_SETRLIMIT
592 struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY };
594 setrlimit (RLIMIT_CORE, &rlim);
595 #endif /* HAVE_SETRLIMIT */
597 abort (); /* NOTE: GDB has only three calls to abort(). */
600 /* Check whether GDB will be able to dump core using the dump_core
601 function. Returns zero if GDB cannot or should not dump core.
602 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
603 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
606 can_dump_core (enum resource_limit_kind limit_kind)
608 #ifdef HAVE_GETRLIMIT
611 /* Be quiet and assume we can dump if an error is returned. */
612 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
618 if (rlim.rlim_cur == 0)
622 if (rlim.rlim_max == 0)
625 #endif /* HAVE_GETRLIMIT */
630 /* Print a warning that we cannot dump core. */
633 warn_cant_dump_core (const char *reason)
635 fprintf_unfiltered (gdb_stderr,
636 _("%s\nUnable to dump core, use `ulimit -c"
637 " unlimited' before executing GDB next time.\n"),
641 /* Check whether GDB will be able to dump core using the dump_core
642 function, and print a warning if we cannot. */
645 can_dump_core_warn (enum resource_limit_kind limit_kind,
648 int core_dump_allowed = can_dump_core (limit_kind);
650 if (!core_dump_allowed)
651 warn_cant_dump_core (reason);
653 return core_dump_allowed;
656 /* Allow the user to configure the debugger behavior with respect to
657 what to do when an internal problem is detected. */
659 const char internal_problem_ask[] = "ask";
660 const char internal_problem_yes[] = "yes";
661 const char internal_problem_no[] = "no";
662 static const char *const internal_problem_modes[] =
664 internal_problem_ask,
665 internal_problem_yes,
670 /* Print a message reporting an internal error/warning. Ask the user
671 if they want to continue, dump core, or just exit. Return
672 something to indicate a quit. */
674 struct internal_problem
677 int user_settable_should_quit;
678 const char *should_quit;
679 int user_settable_should_dump_core;
680 const char *should_dump_core;
683 /* Report a problem, internal to GDB, to the user. Once the problem
684 has been reported, and assuming GDB didn't quit, the caller can
685 either allow execution to resume or throw an error. */
687 static void ATTRIBUTE_PRINTF (4, 0)
688 internal_vproblem (struct internal_problem *problem,
689 const char *file, int line, const char *fmt, va_list ap)
695 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
697 /* Don't allow infinite error/warning recursion. */
699 static char msg[] = "Recursive internal problem.\n";
708 abort_with_message (msg);
711 /* Newer GLIBC versions put the warn_unused_result attribute
712 on write, but this is one of those rare cases where
713 ignoring the return value is correct. Casting to (void)
714 does not fix this problem. This is the solution suggested
715 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
716 if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg))
717 abort (); /* NOTE: GDB has only three calls to abort(). */
722 /* Create a string containing the full error/warning message. Need
723 to call query with this full string, as otherwize the reason
724 (error/warning) and question become separated. Format using a
725 style similar to a compiler error message. Include extra detail
726 so that the user knows that they are living on the edge. */
730 msg = xstrvprintf (fmt, ap);
731 reason = xstrprintf ("%s:%d: %s: %s\n"
732 "A problem internal to GDB has been detected,\n"
733 "further debugging may prove unreliable.",
734 file, line, problem->name, msg);
736 make_cleanup (xfree, reason);
739 /* Fall back to abort_with_message if gdb_stderr is not set up. */
740 if (gdb_stderr == NULL)
742 fputs (reason, stderr);
743 abort_with_message ("\n");
746 /* Try to get the message out and at the start of a new line. */
747 if (target_supports_terminal_ours ())
749 make_cleanup_restore_target_terminal ();
750 target_terminal_ours_for_output ();
752 if (filtered_printing_initialized ())
755 /* Emit the message unless query will emit it below. */
756 if (problem->should_quit != internal_problem_ask
758 || !filtered_printing_initialized ())
759 fprintf_unfiltered (gdb_stderr, "%s\n", reason);
761 if (problem->should_quit == internal_problem_ask)
763 /* Default (yes/batch case) is to quit GDB. When in batch mode
764 this lessens the likelihood of GDB going into an infinite
766 if (!confirm || !filtered_printing_initialized ())
769 quit_p = query (_("%s\nQuit this debugging session? "), reason);
771 else if (problem->should_quit == internal_problem_yes)
773 else if (problem->should_quit == internal_problem_no)
776 internal_error (__FILE__, __LINE__, _("bad switch"));
778 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr);
779 if (REPORT_BUGS_TO[0])
780 fprintf_unfiltered (gdb_stderr, _(" For instructions, see:\n%s."),
782 fputs_unfiltered ("\n\n", gdb_stderr);
784 if (problem->should_dump_core == internal_problem_ask)
786 if (!can_dump_core_warn (LIMIT_MAX, reason))
788 else if (!filtered_printing_initialized ())
792 /* Default (yes/batch case) is to dump core. This leaves a GDB
793 `dropping' so that it is easier to see that something went
795 dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
798 else if (problem->should_dump_core == internal_problem_yes)
799 dump_core_p = can_dump_core_warn (LIMIT_MAX, reason);
800 else if (problem->should_dump_core == internal_problem_no)
803 internal_error (__FILE__, __LINE__, _("bad switch"));
816 #ifdef HAVE_WORKING_FORK
824 do_cleanups (cleanup);
827 static struct internal_problem internal_error_problem = {
828 "internal-error", 1, internal_problem_ask, 1, internal_problem_ask
832 internal_verror (const char *file, int line, const char *fmt, va_list ap)
834 internal_vproblem (&internal_error_problem, file, line, fmt, ap);
835 throw_quit (_("Command aborted."));
838 static struct internal_problem internal_warning_problem = {
839 "internal-warning", 1, internal_problem_ask, 1, internal_problem_ask
843 internal_vwarning (const char *file, int line, const char *fmt, va_list ap)
845 internal_vproblem (&internal_warning_problem, file, line, fmt, ap);
848 static struct internal_problem demangler_warning_problem = {
849 "demangler-warning", 1, internal_problem_ask, 0, internal_problem_no
853 demangler_vwarning (const char *file, int line, const char *fmt, va_list ap)
855 internal_vproblem (&demangler_warning_problem, file, line, fmt, ap);
859 demangler_warning (const char *file, int line, const char *string, ...)
863 va_start (ap, string);
864 demangler_vwarning (file, line, string, ap);
868 /* Dummy functions to keep add_prefix_cmd happy. */
871 set_internal_problem_cmd (char *args, int from_tty)
876 show_internal_problem_cmd (char *args, int from_tty)
880 /* When GDB reports an internal problem (error or warning) it gives
881 the user the opportunity to quit GDB and/or create a core file of
882 the current debug session. This function registers a few commands
883 that make it possible to specify that GDB should always or never
884 quit or create a core file, without asking. The commands look
887 maint set PROBLEM-NAME quit ask|yes|no
888 maint show PROBLEM-NAME quit
889 maint set PROBLEM-NAME corefile ask|yes|no
890 maint show PROBLEM-NAME corefile
892 Where PROBLEM-NAME is currently "internal-error" or
893 "internal-warning". */
896 add_internal_problem_command (struct internal_problem *problem)
898 struct cmd_list_element **set_cmd_list;
899 struct cmd_list_element **show_cmd_list;
903 set_cmd_list = XNEW (struct cmd_list_element *);
904 show_cmd_list = XNEW (struct cmd_list_element *);
905 *set_cmd_list = NULL;
906 *show_cmd_list = NULL;
908 set_doc = xstrprintf (_("Configure what GDB does when %s is detected."),
911 show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
914 add_prefix_cmd ((char*) problem->name,
915 class_maintenance, set_internal_problem_cmd, set_doc,
917 concat ("maintenance set ", problem->name, " ",
919 0/*allow-unknown*/, &maintenance_set_cmdlist);
921 add_prefix_cmd ((char*) problem->name,
922 class_maintenance, show_internal_problem_cmd, show_doc,
924 concat ("maintenance show ", problem->name, " ",
926 0/*allow-unknown*/, &maintenance_show_cmdlist);
928 if (problem->user_settable_should_quit)
930 set_doc = xstrprintf (_("Set whether GDB should quit "
931 "when an %s is detected"),
933 show_doc = xstrprintf (_("Show whether GDB will quit "
934 "when an %s is detected"),
936 add_setshow_enum_cmd ("quit", class_maintenance,
937 internal_problem_modes,
938 &problem->should_quit,
951 if (problem->user_settable_should_dump_core)
953 set_doc = xstrprintf (_("Set whether GDB should create a core "
954 "file of GDB when %s is detected"),
956 show_doc = xstrprintf (_("Show whether GDB will create a core "
957 "file of GDB when %s is detected"),
959 add_setshow_enum_cmd ("corefile", class_maintenance,
960 internal_problem_modes,
961 &problem->should_dump_core,
975 /* Return a newly allocated string, containing the PREFIX followed
976 by the system error message for errno (separated by a colon).
978 The result must be deallocated after use. */
981 perror_string (const char *prefix)
986 err = safe_strerror (errno);
987 combined = (char *) xmalloc (strlen (err) + strlen (prefix) + 3);
988 strcpy (combined, prefix);
989 strcat (combined, ": ");
990 strcat (combined, err);
995 /* Print the system error message for errno, and also mention STRING
996 as the file name for which the error was encountered. Use ERRCODE
997 for the thrown exception. Then return to command level. */
1000 throw_perror_with_name (enum errors errcode, const char *string)
1004 combined = perror_string (string);
1005 make_cleanup (xfree, combined);
1007 /* I understand setting these is a matter of taste. Still, some people
1008 may clear errno but not know about bfd_error. Doing this here is not
1010 bfd_set_error (bfd_error_no_error);
1013 throw_error (errcode, _("%s."), combined);
1016 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
1019 perror_with_name (const char *string)
1021 throw_perror_with_name (GENERIC_ERROR, string);
1024 /* Same as perror_with_name except that it prints a warning instead
1025 of throwing an error. */
1028 perror_warning_with_name (const char *string)
1032 combined = perror_string (string);
1033 warning (_("%s"), combined);
1037 /* Print the system error message for ERRCODE, and also mention STRING
1038 as the file name for which the error was encountered. */
1041 print_sys_errmsg (const char *string, int errcode)
1046 err = safe_strerror (errcode);
1047 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
1048 strcpy (combined, string);
1049 strcat (combined, ": ");
1050 strcat (combined, err);
1052 /* We want anything which was printed on stdout to come out first, before
1054 gdb_flush (gdb_stdout);
1055 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
1058 /* Control C eventually causes this to be called, at a convenient time. */
1063 if (sync_quit_force_run)
1065 sync_quit_force_run = 0;
1066 quit_force (NULL, stdin == instream);
1070 /* No steenking SIGINT will ever be coming our way when the
1071 program is resumed. Don't lie. */
1072 throw_quit ("Quit");
1075 /* If there is no terminal switching for this target, then we can't
1076 possibly get screwed by the lack of job control. */
1077 || !target_supports_terminal_ours ())
1078 throw_quit ("Quit");
1080 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
1089 if (check_quit_flag () || sync_quit_force_run)
1091 if (deprecated_interactive_hook)
1092 deprecated_interactive_hook ();
1093 target_check_pending_interrupt ();
1097 /* Called when a memory allocation fails, with the number of bytes of
1098 memory requested in SIZE. */
1101 malloc_failure (long size)
1105 internal_error (__FILE__, __LINE__,
1106 _("virtual memory exhausted: can't allocate %ld bytes."),
1111 internal_error (__FILE__, __LINE__, _("virtual memory exhausted."));
1115 /* My replacement for the read system call.
1116 Used like `read' but keeps going if `read' returns too soon. */
1119 myread (int desc, char *addr, int len)
1126 val = read (desc, addr, len);
1130 return orglen - len;
1138 print_spaces (int n, struct ui_file *file)
1140 fputs_unfiltered (n_spaces (n), file);
1143 /* Print a host address. */
1146 gdb_print_host_address_1 (const void *addr, struct ui_file *stream)
1148 fprintf_filtered (stream, "%s", host_address_to_string (addr));
1154 make_hex_string (const gdb_byte *data, size_t length)
1156 char *result = (char *) xmalloc (length * 2 + 1);
1161 for (i = 0; i < length; ++i)
1162 p += xsnprintf (p, 3, "%02x", data[i]);
1169 /* A cleanup function that calls regfree. */
1172 do_regfree_cleanup (void *r)
1174 regfree ((regex_t *) r);
1177 /* Create a new cleanup that frees the compiled regular expression R. */
1180 make_regfree_cleanup (regex_t *r)
1182 return make_cleanup (do_regfree_cleanup, r);
1185 /* Return an xmalloc'd error message resulting from a regular
1186 expression compilation failure. */
1189 get_regcomp_error (int code, regex_t *rx)
1191 size_t length = regerror (code, rx, NULL, 0);
1192 char *result = (char *) xmalloc (length);
1194 regerror (code, rx, result, length);
1198 /* Compile a regexp and throw an exception on error. This returns a
1199 cleanup to free the resulting pattern on success. RX must not be
1203 compile_rx_or_error (regex_t *pattern, const char *rx, const char *message)
1207 gdb_assert (rx != NULL);
1209 code = regcomp (pattern, rx, REG_NOSUB);
1212 char *err = get_regcomp_error (code, pattern);
1214 make_cleanup (xfree, err);
1215 error (("%s: %s"), message, err);
1218 return make_regfree_cleanup (pattern);
1223 /* This function supports the query, nquery, and yquery functions.
1224 Ask user a y-or-n question and return 0 if answer is no, 1 if
1225 answer is yes, or default the answer to the specified default
1226 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1227 default answer, or '\0' for no default.
1228 CTLSTR is the control string and should end in "? ". It should
1229 not say how to answer, because we do that.
1230 ARGS are the arguments passed along with the CTLSTR argument to
1233 static int ATTRIBUTE_PRINTF (1, 0)
1234 defaulted_query (const char *ctlstr, const char defchar, va_list args)
1239 char def_answer, not_def_answer;
1240 char *y_string, *n_string, *question, *prompt;
1241 /* Used to add duration we waited for user to respond to
1242 prompt_for_continue_wait_time. */
1243 struct timeval prompt_started, prompt_ended, prompt_delta;
1245 /* Set up according to which answer is the default. */
1246 if (defchar == '\0')
1250 not_def_answer = 'N';
1254 else if (defchar == 'y')
1258 not_def_answer = 'N';
1266 not_def_answer = 'Y';
1271 /* Automatically answer the default value if the user did not want
1272 prompts or the command was issued with the server prefix. */
1273 if (!confirm || server_command)
1276 /* If input isn't coming from the user directly, just say what
1277 question we're asking, and then answer the default automatically. This
1278 way, important error messages don't get lost when talking to GDB
1280 if (! input_from_terminal_p ())
1283 vfprintf_filtered (gdb_stdout, ctlstr, args);
1285 printf_filtered (_("(%s or %s) [answered %c; "
1286 "input not from terminal]\n"),
1287 y_string, n_string, def_answer);
1288 gdb_flush (gdb_stdout);
1293 if (deprecated_query_hook)
1295 return deprecated_query_hook (ctlstr, args);
1298 /* Format the question outside of the loop, to avoid reusing args. */
1299 question = xstrvprintf (ctlstr, args);
1300 prompt = xstrprintf (_("%s%s(%s or %s) %s"),
1301 annotation_level > 1 ? "\n\032\032pre-query\n" : "",
1302 question, y_string, n_string,
1303 annotation_level > 1 ? "\n\032\032query\n" : "");
1306 /* Used for calculating time spend waiting for user. */
1307 gettimeofday (&prompt_started, NULL);
1311 char *response, answer;
1313 gdb_flush (gdb_stdout);
1314 response = gdb_readline_wrapper (prompt);
1316 if (response == NULL) /* C-d */
1318 printf_filtered ("EOF [assumed %c]\n", def_answer);
1323 answer = response[0];
1328 /* Check answer. For the non-default, the user must specify
1329 the non-default explicitly. */
1330 if (answer == not_def_answer)
1332 retval = !def_value;
1335 /* Otherwise, if a default was specified, the user may either
1336 specify the required input or have it default by entering
1338 if (answer == def_answer
1339 || (defchar != '\0' && answer == '\0'))
1344 /* Invalid entries are not defaulted and require another selection. */
1345 printf_filtered (_("Please answer %s or %s.\n"),
1346 y_string, n_string);
1349 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1350 gettimeofday (&prompt_ended, NULL);
1351 timeval_sub (&prompt_delta, &prompt_ended, &prompt_started);
1352 timeval_add (&prompt_for_continue_wait_time,
1353 &prompt_for_continue_wait_time, &prompt_delta);
1356 if (annotation_level > 1)
1357 printf_filtered (("\n\032\032post-query\n"));
1362 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1363 answer is yes, or 0 if answer is defaulted.
1364 Takes three args which are given to printf to print the question.
1365 The first, a control string, should end in "? ".
1366 It should not say how to answer, because we do that. */
1369 nquery (const char *ctlstr, ...)
1374 va_start (args, ctlstr);
1375 ret = defaulted_query (ctlstr, 'n', args);
1380 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1381 answer is yes, or 1 if answer is defaulted.
1382 Takes three args which are given to printf to print the question.
1383 The first, a control string, should end in "? ".
1384 It should not say how to answer, because we do that. */
1387 yquery (const char *ctlstr, ...)
1392 va_start (args, ctlstr);
1393 ret = defaulted_query (ctlstr, 'y', args);
1398 /* Ask user a y-or-n question and return 1 iff answer is yes.
1399 Takes three args which are given to printf to print the question.
1400 The first, a control string, should end in "? ".
1401 It should not say how to answer, because we do that. */
1404 query (const char *ctlstr, ...)
1409 va_start (args, ctlstr);
1410 ret = defaulted_query (ctlstr, '\0', args);
1415 /* A helper for parse_escape that converts a host character to a
1416 target character. C is the host character. If conversion is
1417 possible, then the target character is stored in *TARGET_C and the
1418 function returns 1. Otherwise, the function returns 0. */
1421 host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c)
1423 struct obstack host_data;
1425 struct cleanup *cleanups;
1428 obstack_init (&host_data);
1429 cleanups = make_cleanup_obstack_free (&host_data);
1431 convert_between_encodings (target_charset (gdbarch), host_charset (),
1432 (gdb_byte *) &the_char, 1, 1,
1433 &host_data, translit_none);
1435 if (obstack_object_size (&host_data) == 1)
1438 *target_c = *(char *) obstack_base (&host_data);
1441 do_cleanups (cleanups);
1445 /* Parse a C escape sequence. STRING_PTR points to a variable
1446 containing a pointer to the string to parse. That pointer
1447 should point to the character after the \. That pointer
1448 is updated past the characters we use. The value of the
1449 escape sequence is returned.
1451 A negative value means the sequence \ newline was seen,
1452 which is supposed to be equivalent to nothing at all.
1454 If \ is followed by a null character, we return a negative
1455 value and leave the string pointer pointing at the null character.
1457 If \ is followed by 000, we return 0 and leave the string pointer
1458 after the zeros. A value of 0 does not mean end of string. */
1461 parse_escape (struct gdbarch *gdbarch, const char **string_ptr)
1463 int target_char = -2; /* Initialize to avoid GCC warnings. */
1464 int c = *(*string_ptr)++;
1483 int i = host_hex_value (c);
1488 if (isdigit (c) && c != '8' && c != '9')
1492 i += host_hex_value (c);
1528 if (!host_char_to_target (gdbarch, c, &target_char))
1529 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1530 " which has no equivalent\nin the `%s' character set."),
1531 c, c, target_charset (gdbarch));
1535 /* Print the character C on STREAM as part of the contents of a literal
1536 string whose delimiter is QUOTER. Note that this routine should only
1537 be called for printing things which are independent of the language
1538 of the program being debugged.
1540 printchar will normally escape backslashes and instances of QUOTER. If
1541 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1542 As a side effect, if you pass the backslash character as the QUOTER,
1543 printchar will escape backslashes as usual, but not any other quoting
1547 printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1548 void (*do_fprintf) (struct ui_file *, const char *, ...)
1549 ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
1551 c &= 0xFF; /* Avoid sign bit follies */
1553 if (c < 0x20 || /* Low control chars */
1554 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1555 (sevenbit_strings && c >= 0x80))
1556 { /* high order bit set */
1560 do_fputs ("\\n", stream);
1563 do_fputs ("\\b", stream);
1566 do_fputs ("\\t", stream);
1569 do_fputs ("\\f", stream);
1572 do_fputs ("\\r", stream);
1575 do_fputs ("\\e", stream);
1578 do_fputs ("\\a", stream);
1581 do_fprintf (stream, "\\%.3o", (unsigned int) c);
1587 if (quoter != 0 && (c == '\\' || c == quoter))
1588 do_fputs ("\\", stream);
1589 do_fprintf (stream, "%c", c);
1593 /* Print the character C on STREAM as part of the contents of a
1594 literal string whose delimiter is QUOTER. Note that these routines
1595 should only be call for printing things which are independent of
1596 the language of the program being debugged. */
1599 fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
1602 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1606 fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
1609 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1613 fputstrn_filtered (const char *str, int n, int quoter,
1614 struct ui_file *stream)
1618 for (i = 0; i < n; i++)
1619 printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
1623 fputstrn_unfiltered (const char *str, int n, int quoter,
1624 struct ui_file *stream)
1628 for (i = 0; i < n; i++)
1629 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1633 /* Number of lines per page or UINT_MAX if paging is disabled. */
1634 static unsigned int lines_per_page;
1636 show_lines_per_page (struct ui_file *file, int from_tty,
1637 struct cmd_list_element *c, const char *value)
1639 fprintf_filtered (file,
1640 _("Number of lines gdb thinks are in a page is %s.\n"),
1644 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1645 static unsigned int chars_per_line;
1647 show_chars_per_line (struct ui_file *file, int from_tty,
1648 struct cmd_list_element *c, const char *value)
1650 fprintf_filtered (file,
1651 _("Number of characters gdb thinks "
1652 "are in a line is %s.\n"),
1656 /* Current count of lines printed on this page, chars on this line. */
1657 static unsigned int lines_printed, chars_printed;
1659 /* Buffer and start column of buffered text, for doing smarter word-
1660 wrapping. When someone calls wrap_here(), we start buffering output
1661 that comes through fputs_filtered(). If we see a newline, we just
1662 spit it out and forget about the wrap_here(). If we see another
1663 wrap_here(), we spit it out and remember the newer one. If we see
1664 the end of the line, we spit out a newline, the indent, and then
1665 the buffered output. */
1667 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1668 are waiting to be output (they have already been counted in chars_printed).
1669 When wrap_buffer[0] is null, the buffer is empty. */
1670 static char *wrap_buffer;
1672 /* Pointer in wrap_buffer to the next character to fill. */
1673 static char *wrap_pointer;
1675 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1677 static char *wrap_indent;
1679 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1680 is not in effect. */
1681 static int wrap_column;
1684 /* Inialize the number of lines per page and chars per line. */
1687 init_page_info (void)
1691 lines_per_page = UINT_MAX;
1692 chars_per_line = UINT_MAX;
1696 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
1701 #if defined(__GO32__)
1702 rows = ScreenRows ();
1703 cols = ScreenCols ();
1704 lines_per_page = rows;
1705 chars_per_line = cols;
1707 /* Make sure Readline has initialized its terminal settings. */
1708 rl_reset_terminal (NULL);
1710 /* Get the screen size from Readline. */
1711 rl_get_screen_size (&rows, &cols);
1712 lines_per_page = rows;
1713 chars_per_line = cols;
1715 /* Readline should have fetched the termcap entry for us.
1716 Only try to use tgetnum function if rl_get_screen_size
1717 did not return a useful value. */
1718 if (((rows <= 0) && (tgetnum ("li") < 0))
1719 /* Also disable paging if inside Emacs. $EMACS was used
1720 before Emacs v25.1, $INSIDE_EMACS is used since then. */
1721 || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1723 /* The number of lines per page is not mentioned in the terminal
1724 description or EMACS evironment variable is set. This probably
1725 means that paging is not useful, so disable paging. */
1726 lines_per_page = UINT_MAX;
1729 /* If the output is not a terminal, don't paginate it. */
1730 if (!ui_file_isatty (gdb_stdout))
1731 lines_per_page = UINT_MAX;
1735 /* We handle SIGWINCH ourselves. */
1736 rl_catch_sigwinch = 0;
1742 /* Return nonzero if filtered printing is initialized. */
1744 filtered_printing_initialized (void)
1746 return wrap_buffer != NULL;
1749 /* Helper for make_cleanup_restore_page_info. */
1752 do_restore_page_info_cleanup (void *arg)
1758 /* Provide cleanup for restoring the terminal size. */
1761 make_cleanup_restore_page_info (void)
1763 struct cleanup *back_to;
1765 back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
1766 make_cleanup_restore_uinteger (&lines_per_page);
1767 make_cleanup_restore_uinteger (&chars_per_line);
1772 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1773 Provide cleanup for restoring the original state. */
1776 set_batch_flag_and_make_cleanup_restore_page_info (void)
1778 struct cleanup *back_to = make_cleanup_restore_page_info ();
1780 make_cleanup_restore_integer (&batch_flag);
1787 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1790 set_screen_size (void)
1792 int rows = lines_per_page;
1793 int cols = chars_per_line;
1801 /* Update Readline's idea of the terminal size. */
1802 rl_set_screen_size (rows, cols);
1805 /* Reinitialize WRAP_BUFFER according to the current value of
1811 if (chars_per_line == 0)
1816 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1817 wrap_buffer[0] = '\0';
1820 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1821 wrap_pointer = wrap_buffer; /* Start it at the beginning. */
1825 set_width_command (char *args, int from_tty, struct cmd_list_element *c)
1832 set_height_command (char *args, int from_tty, struct cmd_list_element *c)
1840 set_screen_width_and_height (int width, int height)
1842 lines_per_page = height;
1843 chars_per_line = width;
1849 /* Wait, so the user can read what's on the screen. Prompt the user
1850 to continue by pressing RETURN. 'q' is also provided because
1851 telling users what to do in the prompt is more user-friendly than
1852 expecting them to think of Ctrl-C/SIGINT. */
1855 prompt_for_continue (void)
1858 char cont_prompt[120];
1859 /* Used to add duration we waited for user to respond to
1860 prompt_for_continue_wait_time. */
1861 struct timeval prompt_started, prompt_ended, prompt_delta;
1863 gettimeofday (&prompt_started, NULL);
1865 if (annotation_level > 1)
1866 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1868 strcpy (cont_prompt,
1869 "---Type <return> to continue, or q <return> to quit---");
1870 if (annotation_level > 1)
1871 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1873 /* We must do this *before* we call gdb_readline_wrapper, else it
1874 will eventually call us -- thinking that we're trying to print
1875 beyond the end of the screen. */
1876 reinitialize_more_filter ();
1878 /* We'll need to handle input. */
1879 target_terminal_ours ();
1881 /* Call gdb_readline_wrapper, not readline, in order to keep an
1882 event loop running. */
1883 ignore = gdb_readline_wrapper (cont_prompt);
1885 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1886 gettimeofday (&prompt_ended, NULL);
1887 timeval_sub (&prompt_delta, &prompt_ended, &prompt_started);
1888 timeval_add (&prompt_for_continue_wait_time,
1889 &prompt_for_continue_wait_time, &prompt_delta);
1891 if (annotation_level > 1)
1892 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1898 while (*p == ' ' || *p == '\t')
1901 /* Do not call quit here; there is no possibility of SIGINT. */
1902 throw_quit ("Quit");
1906 /* Now we have to do this again, so that GDB will know that it doesn't
1907 need to save the ---Type <return>--- line at the top of the screen. */
1908 reinitialize_more_filter ();
1910 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1913 /* Initalize timer to keep track of how long we waited for the user. */
1916 reset_prompt_for_continue_wait_time (void)
1918 static const struct timeval zero_timeval = { 0 };
1920 prompt_for_continue_wait_time = zero_timeval;
1923 /* Fetch the cumulative time spent in prompt_for_continue. */
1926 get_prompt_for_continue_wait_time (void)
1928 return prompt_for_continue_wait_time;
1931 /* Reinitialize filter; ie. tell it to reset to original values. */
1934 reinitialize_more_filter (void)
1940 /* Indicate that if the next sequence of characters overflows the line,
1941 a newline should be inserted here rather than when it hits the end.
1942 If INDENT is non-null, it is a string to be printed to indent the
1943 wrapped part on the next line. INDENT must remain accessible until
1944 the next call to wrap_here() or until a newline is printed through
1947 If the line is already overfull, we immediately print a newline and
1948 the indentation, and disable further wrapping.
1950 If we don't know the width of lines, but we know the page height,
1951 we must not wrap words, but should still keep track of newlines
1952 that were explicitly printed.
1954 INDENT should not contain tabs, as that will mess up the char count
1955 on the next line. FIXME.
1957 This routine is guaranteed to force out any output which has been
1958 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1959 used to force out output from the wrap_buffer. */
1962 wrap_here (char *indent)
1964 /* This should have been allocated, but be paranoid anyway. */
1966 internal_error (__FILE__, __LINE__,
1967 _("failed internal consistency check"));
1971 *wrap_pointer = '\0';
1972 fputs_unfiltered (wrap_buffer, gdb_stdout);
1974 wrap_pointer = wrap_buffer;
1975 wrap_buffer[0] = '\0';
1976 if (chars_per_line == UINT_MAX) /* No line overflow checking. */
1980 else if (chars_printed >= chars_per_line)
1982 puts_filtered ("\n");
1984 puts_filtered (indent);
1989 wrap_column = chars_printed;
1993 wrap_indent = indent;
1997 /* Print input string to gdb_stdout, filtered, with wrap,
1998 arranging strings in columns of n chars. String can be
1999 right or left justified in the column. Never prints
2000 trailing spaces. String should never be longer than
2001 width. FIXME: this could be useful for the EXAMINE
2002 command, which currently doesn't tabulate very well. */
2005 puts_filtered_tabular (char *string, int width, int right)
2011 gdb_assert (chars_per_line > 0);
2012 if (chars_per_line == UINT_MAX)
2014 fputs_filtered (string, gdb_stdout);
2015 fputs_filtered ("\n", gdb_stdout);
2019 if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
2020 fputs_filtered ("\n", gdb_stdout);
2022 if (width >= chars_per_line)
2023 width = chars_per_line - 1;
2025 stringlen = strlen (string);
2027 if (chars_printed > 0)
2028 spaces = width - (chars_printed - 1) % width - 1;
2030 spaces += width - stringlen;
2032 spacebuf = (char *) alloca (spaces + 1);
2033 spacebuf[spaces] = '\0';
2035 spacebuf[spaces] = ' ';
2037 fputs_filtered (spacebuf, gdb_stdout);
2038 fputs_filtered (string, gdb_stdout);
2042 /* Ensure that whatever gets printed next, using the filtered output
2043 commands, starts at the beginning of the line. I.e. if there is
2044 any pending output for the current line, flush it and start a new
2045 line. Otherwise do nothing. */
2050 if (chars_printed > 0)
2052 puts_filtered ("\n");
2057 /* Like fputs but if FILTER is true, pause after every screenful.
2059 Regardless of FILTER can wrap at points other than the final
2060 character of a line.
2062 Unlike fputs, fputs_maybe_filtered does not return a value.
2063 It is OK for LINEBUFFER to be NULL, in which case just don't print
2066 Note that a longjmp to top level may occur in this routine (only if
2067 FILTER is true) (since prompt_for_continue may do so) so this
2068 routine should not be called when cleanups are not in place. */
2071 fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
2074 const char *lineptr;
2076 if (linebuffer == 0)
2079 /* Don't do any filtering if it is disabled. */
2080 if (stream != gdb_stdout
2081 || !pagination_enabled
2083 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
2084 || top_level_interpreter () == NULL
2085 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2087 fputs_unfiltered (linebuffer, stream);
2091 /* Go through and output each character. Show line extension
2092 when this is necessary; prompt user for new page when this is
2095 lineptr = linebuffer;
2098 /* Possible new page. */
2099 if (filter && (lines_printed >= lines_per_page - 1))
2100 prompt_for_continue ();
2102 while (*lineptr && *lineptr != '\n')
2104 /* Print a single line. */
2105 if (*lineptr == '\t')
2108 *wrap_pointer++ = '\t';
2110 fputc_unfiltered ('\t', stream);
2111 /* Shifting right by 3 produces the number of tab stops
2112 we have already passed, and then adding one and
2113 shifting left 3 advances to the next tab stop. */
2114 chars_printed = ((chars_printed >> 3) + 1) << 3;
2120 *wrap_pointer++ = *lineptr;
2122 fputc_unfiltered (*lineptr, stream);
2127 if (chars_printed >= chars_per_line)
2129 unsigned int save_chars = chars_printed;
2133 /* If we aren't actually wrapping, don't output newline --
2134 if chars_per_line is right, we probably just overflowed
2135 anyway; if it's wrong, let us keep going. */
2137 fputc_unfiltered ('\n', stream);
2139 /* Possible new page. */
2140 if (lines_printed >= lines_per_page - 1)
2141 prompt_for_continue ();
2143 /* Now output indentation and wrapped string. */
2146 fputs_unfiltered (wrap_indent, stream);
2147 *wrap_pointer = '\0'; /* Null-terminate saved stuff, */
2148 fputs_unfiltered (wrap_buffer, stream); /* and eject it. */
2149 /* FIXME, this strlen is what prevents wrap_indent from
2150 containing tabs. However, if we recurse to print it
2151 and count its chars, we risk trouble if wrap_indent is
2152 longer than (the user settable) chars_per_line.
2153 Note also that this can set chars_printed > chars_per_line
2154 if we are printing a long string. */
2155 chars_printed = strlen (wrap_indent)
2156 + (save_chars - wrap_column);
2157 wrap_pointer = wrap_buffer; /* Reset buffer */
2158 wrap_buffer[0] = '\0';
2159 wrap_column = 0; /* And disable fancy wrap */
2164 if (*lineptr == '\n')
2167 wrap_here ((char *) 0); /* Spit out chars, cancel
2170 fputc_unfiltered ('\n', stream);
2177 fputs_filtered (const char *linebuffer, struct ui_file *stream)
2179 fputs_maybe_filtered (linebuffer, stream, 1);
2183 putchar_unfiltered (int c)
2187 ui_file_write (gdb_stdout, &buf, 1);
2191 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2192 May return nonlocally. */
2195 putchar_filtered (int c)
2197 return fputc_filtered (c, gdb_stdout);
2201 fputc_unfiltered (int c, struct ui_file *stream)
2205 ui_file_write (stream, &buf, 1);
2210 fputc_filtered (int c, struct ui_file *stream)
2216 fputs_filtered (buf, stream);
2220 /* puts_debug is like fputs_unfiltered, except it prints special
2221 characters in printable fashion. */
2224 puts_debug (char *prefix, char *string, char *suffix)
2228 /* Print prefix and suffix after each line. */
2229 static int new_line = 1;
2230 static int return_p = 0;
2231 static char *prev_prefix = "";
2232 static char *prev_suffix = "";
2234 if (*string == '\n')
2237 /* If the prefix is changing, print the previous suffix, a new line,
2238 and the new prefix. */
2239 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2241 fputs_unfiltered (prev_suffix, gdb_stdlog);
2242 fputs_unfiltered ("\n", gdb_stdlog);
2243 fputs_unfiltered (prefix, gdb_stdlog);
2246 /* Print prefix if we printed a newline during the previous call. */
2250 fputs_unfiltered (prefix, gdb_stdlog);
2253 prev_prefix = prefix;
2254 prev_suffix = suffix;
2256 /* Output characters in a printable format. */
2257 while ((ch = *string++) != '\0')
2263 fputc_unfiltered (ch, gdb_stdlog);
2266 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2270 fputs_unfiltered ("\\\\", gdb_stdlog);
2273 fputs_unfiltered ("\\b", gdb_stdlog);
2276 fputs_unfiltered ("\\f", gdb_stdlog);
2280 fputs_unfiltered ("\\n", gdb_stdlog);
2283 fputs_unfiltered ("\\r", gdb_stdlog);
2286 fputs_unfiltered ("\\t", gdb_stdlog);
2289 fputs_unfiltered ("\\v", gdb_stdlog);
2293 return_p = ch == '\r';
2296 /* Print suffix if we printed a newline. */
2299 fputs_unfiltered (suffix, gdb_stdlog);
2300 fputs_unfiltered ("\n", gdb_stdlog);
2305 /* Print a variable number of ARGS using format FORMAT. If this
2306 information is going to put the amount written (since the last call
2307 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2308 call prompt_for_continue to get the users permision to continue.
2310 Unlike fprintf, this function does not return a value.
2312 We implement three variants, vfprintf (takes a vararg list and stream),
2313 fprintf (takes a stream to write on), and printf (the usual).
2315 Note also that a longjmp to top level may occur in this routine
2316 (since prompt_for_continue may do so) so this routine should not be
2317 called when cleanups are not in place. */
2320 vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2321 va_list args, int filter)
2324 struct cleanup *old_cleanups;
2326 linebuffer = xstrvprintf (format, args);
2327 old_cleanups = make_cleanup (xfree, linebuffer);
2328 fputs_maybe_filtered (linebuffer, stream, filter);
2329 do_cleanups (old_cleanups);
2334 vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2336 vfprintf_maybe_filtered (stream, format, args, 1);
2340 vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2343 struct cleanup *old_cleanups;
2345 linebuffer = xstrvprintf (format, args);
2346 old_cleanups = make_cleanup (xfree, linebuffer);
2347 if (debug_timestamp && stream == gdb_stdlog)
2353 gettimeofday (&tm, NULL);
2355 len = strlen (linebuffer);
2356 need_nl = (len > 0 && linebuffer[len - 1] != '\n');
2358 timestamp = xstrprintf ("%ld:%ld %s%s",
2359 (long) tm.tv_sec, (long) tm.tv_usec,
2361 need_nl ? "\n": "");
2362 make_cleanup (xfree, timestamp);
2363 fputs_unfiltered (timestamp, stream);
2366 fputs_unfiltered (linebuffer, stream);
2367 do_cleanups (old_cleanups);
2371 vprintf_filtered (const char *format, va_list args)
2373 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2377 vprintf_unfiltered (const char *format, va_list args)
2379 vfprintf_unfiltered (gdb_stdout, format, args);
2383 fprintf_filtered (struct ui_file *stream, const char *format, ...)
2387 va_start (args, format);
2388 vfprintf_filtered (stream, format, args);
2393 fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2397 va_start (args, format);
2398 vfprintf_unfiltered (stream, format, args);
2402 /* Like fprintf_filtered, but prints its result indented.
2403 Called as fprintfi_filtered (spaces, stream, format, ...); */
2406 fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2411 va_start (args, format);
2412 print_spaces_filtered (spaces, stream);
2414 vfprintf_filtered (stream, format, args);
2420 printf_filtered (const char *format, ...)
2424 va_start (args, format);
2425 vfprintf_filtered (gdb_stdout, format, args);
2431 printf_unfiltered (const char *format, ...)
2435 va_start (args, format);
2436 vfprintf_unfiltered (gdb_stdout, format, args);
2440 /* Like printf_filtered, but prints it's result indented.
2441 Called as printfi_filtered (spaces, format, ...); */
2444 printfi_filtered (int spaces, const char *format, ...)
2448 va_start (args, format);
2449 print_spaces_filtered (spaces, gdb_stdout);
2450 vfprintf_filtered (gdb_stdout, format, args);
2454 /* Easy -- but watch out!
2456 This routine is *not* a replacement for puts()! puts() appends a newline.
2457 This one doesn't, and had better not! */
2460 puts_filtered (const char *string)
2462 fputs_filtered (string, gdb_stdout);
2466 puts_unfiltered (const char *string)
2468 fputs_unfiltered (string, gdb_stdout);
2471 /* Return a pointer to N spaces and a null. The pointer is good
2472 until the next call to here. */
2477 static char *spaces = 0;
2478 static int max_spaces = -1;
2484 spaces = (char *) xmalloc (n + 1);
2485 for (t = spaces + n; t != spaces;)
2491 return spaces + max_spaces - n;
2494 /* Print N spaces. */
2496 print_spaces_filtered (int n, struct ui_file *stream)
2498 fputs_filtered (n_spaces (n), stream);
2501 /* C++/ObjC demangler stuff. */
2503 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2504 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2505 If the name is not mangled, or the language for the name is unknown, or
2506 demangling is off, the name is printed in its "raw" form. */
2509 fprintf_symbol_filtered (struct ui_file *stream, const char *name,
2510 enum language lang, int arg_mode)
2516 /* If user wants to see raw output, no problem. */
2519 fputs_filtered (name, stream);
2523 demangled = language_demangle (language_def (lang), name, arg_mode);
2524 fputs_filtered (demangled ? demangled : name, stream);
2525 if (demangled != NULL)
2533 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2534 differences in whitespace. Returns 0 if they match, non-zero if they
2535 don't (slightly different than strcmp()'s range of return values).
2537 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2538 This "feature" is useful when searching for matching C++ function names
2539 (such as if the user types 'break FOO', where FOO is a mangled C++
2543 strcmp_iw (const char *string1, const char *string2)
2545 while ((*string1 != '\0') && (*string2 != '\0'))
2547 while (isspace (*string1))
2551 while (isspace (*string2))
2555 if (case_sensitivity == case_sensitive_on && *string1 != *string2)
2557 if (case_sensitivity == case_sensitive_off
2558 && (tolower ((unsigned char) *string1)
2559 != tolower ((unsigned char) *string2)))
2561 if (*string1 != '\0')
2567 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2570 /* This is like strcmp except that it ignores whitespace and treats
2571 '(' as the first non-NULL character in terms of ordering. Like
2572 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2573 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2574 according to that ordering.
2576 If a list is sorted according to this function and if you want to
2577 find names in the list that match some fixed NAME according to
2578 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2579 where this function would put NAME.
2581 This function must be neutral to the CASE_SENSITIVITY setting as the user
2582 may choose it during later lookup. Therefore this function always sorts
2583 primarily case-insensitively and secondarily case-sensitively.
2585 Here are some examples of why using strcmp to sort is a bad idea:
2589 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2590 we try to do a search for "foo<char*>", strcmp will locate this
2591 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2592 will start looking at strings beginning with "goo", and will never
2593 see the correct match of "foo<char *>".
2595 Parenthesis example:
2597 In practice, this is less like to be an issue, but I'll give it a
2598 shot. Let's assume that '$' is a legitimate character to occur in
2599 symbols. (Which may well even be the case on some systems.) Then
2600 say that the partial symbol table contains "foo$" and "foo(int)".
2601 strcmp will put them in this order, since '$' < '('. Now, if the
2602 user searches for "foo", then strcmp will sort "foo" before "foo$".
2603 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2604 "foo") is false, so it won't proceed to the actual match of
2605 "foo(int)" with "foo". */
2608 strcmp_iw_ordered (const char *string1, const char *string2)
2610 const char *saved_string1 = string1, *saved_string2 = string2;
2611 enum case_sensitivity case_pass = case_sensitive_off;
2615 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2616 Provide stub characters if we are already at the end of one of the
2618 char c1 = 'X', c2 = 'X';
2620 while (*string1 != '\0' && *string2 != '\0')
2622 while (isspace (*string1))
2624 while (isspace (*string2))
2629 case case_sensitive_off:
2630 c1 = tolower ((unsigned char) *string1);
2631 c2 = tolower ((unsigned char) *string2);
2633 case case_sensitive_on:
2641 if (*string1 != '\0')
2650 /* Characters are non-equal unless they're both '\0'; we want to
2651 make sure we get the comparison right according to our
2652 comparison in the cases where one of them is '\0' or '('. */
2654 if (*string2 == '\0')
2659 if (*string2 == '\0')
2664 if (*string2 == '\0' || *string2 == '(')
2673 if (case_pass == case_sensitive_on)
2676 /* Otherwise the strings were equal in case insensitive way, make
2677 a more fine grained comparison in a case sensitive way. */
2679 case_pass = case_sensitive_on;
2680 string1 = saved_string1;
2681 string2 = saved_string2;
2685 /* A simple comparison function with opposite semantics to strcmp. */
2688 streq (const char *lhs, const char *rhs)
2690 return !strcmp (lhs, rhs);
2696 ** Answer whether string_to_compare is a full or partial match to
2697 ** template_string. The partial match must be in sequence starting
2701 subset_compare (char *string_to_compare, char *template_string)
2705 if (template_string != (char *) NULL && string_to_compare != (char *) NULL
2706 && strlen (string_to_compare) <= strlen (template_string))
2708 (startswith (template_string, string_to_compare));
2715 show_debug_timestamp (struct ui_file *file, int from_tty,
2716 struct cmd_list_element *c, const char *value)
2718 fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"),
2724 initialize_utils (void)
2726 add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
2727 Set number of characters where GDB should wrap lines of its output."), _("\
2728 Show number of characters where GDB should wrap lines of its output."), _("\
2729 This affects where GDB wraps its output to fit the screen width.\n\
2730 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2732 show_chars_per_line,
2733 &setlist, &showlist);
2735 add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
2736 Set number of lines in a page for GDB output pagination."), _("\
2737 Show number of lines in a page for GDB output pagination."), _("\
2738 This affects the number of lines after which GDB will pause\n\
2739 its output and ask you whether to continue.\n\
2740 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2742 show_lines_per_page,
2743 &setlist, &showlist);
2745 add_setshow_boolean_cmd ("pagination", class_support,
2746 &pagination_enabled, _("\
2747 Set state of GDB output pagination."), _("\
2748 Show state of GDB output pagination."), _("\
2749 When pagination is ON, GDB pauses at end of each screenful of\n\
2750 its output and asks you whether to continue.\n\
2751 Turning pagination off is an alternative to \"set height unlimited\"."),
2753 show_pagination_enabled,
2754 &setlist, &showlist);
2756 add_setshow_boolean_cmd ("sevenbit-strings", class_support,
2757 &sevenbit_strings, _("\
2758 Set printing of 8-bit characters in strings as \\nnn."), _("\
2759 Show printing of 8-bit characters in strings as \\nnn."), NULL,
2761 show_sevenbit_strings,
2762 &setprintlist, &showprintlist);
2764 add_setshow_boolean_cmd ("timestamp", class_maintenance,
2765 &debug_timestamp, _("\
2766 Set timestamping of debugging messages."), _("\
2767 Show timestamping of debugging messages."), _("\
2768 When set, debugging messages will be marked with seconds and microseconds."),
2770 show_debug_timestamp,
2771 &setdebuglist, &showdebuglist);
2775 paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
2777 /* Truncate address to the size of a target address, avoiding shifts
2778 larger or equal than the width of a CORE_ADDR. The local
2779 variable ADDR_BIT stops the compiler reporting a shift overflow
2780 when it won't occur. */
2781 /* NOTE: This assumes that the significant address information is
2782 kept in the least significant bits of ADDR - the upper bits were
2783 either zero or sign extended. Should gdbarch_address_to_pointer or
2784 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2786 int addr_bit = gdbarch_addr_bit (gdbarch);
2788 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2789 addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
2790 return hex_string (addr);
2793 /* This function is described in "defs.h". */
2796 print_core_address (struct gdbarch *gdbarch, CORE_ADDR address)
2798 int addr_bit = gdbarch_addr_bit (gdbarch);
2800 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2801 address &= ((CORE_ADDR) 1 << addr_bit) - 1;
2803 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2804 that returns the language localized string formatted to a width
2805 based on gdbarch_addr_bit. */
2807 return hex_string_custom (address, 8);
2809 return hex_string_custom (address, 16);
2812 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2815 core_addr_hash (const void *ap)
2817 const CORE_ADDR *addrp = (const CORE_ADDR *) ap;
2822 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2825 core_addr_eq (const void *ap, const void *bp)
2827 const CORE_ADDR *addr_ap = (const CORE_ADDR *) ap;
2828 const CORE_ADDR *addr_bp = (const CORE_ADDR *) bp;
2830 return *addr_ap == *addr_bp;
2833 /* Convert a string back into a CORE_ADDR. */
2835 string_to_core_addr (const char *my_string)
2839 if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
2841 /* Assume that it is in hex. */
2844 for (i = 2; my_string[i] != '\0'; i++)
2846 if (isdigit (my_string[i]))
2847 addr = (my_string[i] - '0') + (addr * 16);
2848 else if (isxdigit (my_string[i]))
2849 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
2851 error (_("invalid hex \"%s\""), my_string);
2856 /* Assume that it is in decimal. */
2859 for (i = 0; my_string[i] != '\0'; i++)
2861 if (isdigit (my_string[i]))
2862 addr = (my_string[i] - '0') + (addr * 10);
2864 error (_("invalid decimal \"%s\""), my_string);
2872 gdb_realpath (const char *filename)
2874 /* On most hosts, we rely on canonicalize_file_name to compute
2875 the FILENAME's realpath.
2877 But the situation is slightly more complex on Windows, due to some
2878 versions of GCC which were reported to generate paths where
2879 backlashes (the directory separator) were doubled. For instance:
2880 c:\\some\\double\\slashes\\dir
2882 c:\some\double\slashes\dir
2883 Those double-slashes were getting in the way when comparing paths,
2884 for instance when trying to insert a breakpoint as follow:
2885 (gdb) b c:/some/double/slashes/dir/foo.c:4
2886 No source file named c:/some/double/slashes/dir/foo.c:4.
2887 (gdb) b c:\some\double\slashes\dir\foo.c:4
2888 No source file named c:\some\double\slashes\dir\foo.c:4.
2889 To prevent this from happening, we need this function to always
2890 strip those extra backslashes. While canonicalize_file_name does
2891 perform this simplification, it only works when the path is valid.
2892 Since the simplification would be useful even if the path is not
2893 valid (one can always set a breakpoint on a file, even if the file
2894 does not exist locally), we rely instead on GetFullPathName to
2895 perform the canonicalization. */
2897 #if defined (_WIN32)
2900 DWORD len = GetFullPathName (filename, MAX_PATH, buf, NULL);
2902 /* The file system is case-insensitive but case-preserving.
2903 So it is important we do not lowercase the path. Otherwise,
2904 we might not be able to display the original casing in a given
2906 if (len > 0 && len < MAX_PATH)
2907 return xstrdup (buf);
2911 char *rp = canonicalize_file_name (filename);
2918 /* This system is a lost cause, just dup the buffer. */
2919 return xstrdup (filename);
2922 /* Return a copy of FILENAME, with its directory prefix canonicalized
2926 gdb_realpath_keepfile (const char *filename)
2928 const char *base_name = lbasename (filename);
2933 /* Extract the basename of filename, and return immediately
2934 a copy of filename if it does not contain any directory prefix. */
2935 if (base_name == filename)
2936 return xstrdup (filename);
2938 dir_name = (char *) alloca ((size_t) (base_name - filename + 2));
2939 /* Allocate enough space to store the dir_name + plus one extra
2940 character sometimes needed under Windows (see below), and
2941 then the closing \000 character. */
2942 strncpy (dir_name, filename, base_name - filename);
2943 dir_name[base_name - filename] = '\000';
2945 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2946 /* We need to be careful when filename is of the form 'd:foo', which
2947 is equivalent of d:./foo, which is totally different from d:/foo. */
2948 if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
2951 dir_name[3] = '\000';
2955 /* Canonicalize the directory prefix, and build the resulting
2956 filename. If the dirname realpath already contains an ending
2957 directory separator, avoid doubling it. */
2958 real_path = gdb_realpath (dir_name);
2959 if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
2960 result = concat (real_path, base_name, (char *) NULL);
2962 result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
2968 /* Return PATH in absolute form, performing tilde-expansion if necessary.
2969 PATH cannot be NULL or the empty string.
2970 This does not resolve symlinks however, use gdb_realpath for that.
2971 Space for the result is allocated with malloc.
2972 If the path is already absolute, it is strdup'd.
2973 If there is a problem computing the absolute path, the path is returned
2974 unchanged (still strdup'd). */
2977 gdb_abspath (const char *path)
2979 gdb_assert (path != NULL && path[0] != '\0');
2982 return tilde_expand (path);
2984 if (IS_ABSOLUTE_PATH (path))
2985 return xstrdup (path);
2987 /* Beware the // my son, the Emacs barfs, the botch that catch... */
2988 return concat (current_directory,
2989 IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
2990 ? "" : SLASH_STRING,
2991 path, (char *) NULL);
2995 align_up (ULONGEST v, int n)
2997 /* Check that N is really a power of two. */
2998 gdb_assert (n && (n & (n-1)) == 0);
2999 return (v + n - 1) & -n;
3003 align_down (ULONGEST v, int n)
3005 /* Check that N is really a power of two. */
3006 gdb_assert (n && (n & (n-1)) == 0);
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 const char *base = lbasename (filename);
3043 while (base > filename && IS_DIR_SEPARATOR (base[-1]))
3046 if (base == filename)
3049 dirname = (char *) xmalloc (base - filename + 2);
3050 memcpy (dirname, filename, base - filename);
3052 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3053 create "d:./bar" later instead of the (different) "d:/bar". */
3054 if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
3055 && !IS_DIR_SEPARATOR (filename[0]))
3056 dirname[base++ - filename] = '.';
3058 dirname[base - filename] = '\0';
3062 /* Call libiberty's buildargv, and return the result.
3063 If buildargv fails due to out-of-memory, call nomem.
3064 Therefore, the returned value is guaranteed to be non-NULL,
3065 unless the parameter itself is NULL. */
3068 gdb_buildargv (const char *s)
3070 char **argv = buildargv (s);
3072 if (s != NULL && argv == NULL)
3078 compare_positive_ints (const void *ap, const void *bp)
3080 /* Because we know we're comparing two ints which are positive,
3081 there's no danger of overflow here. */
3082 return * (int *) ap - * (int *) bp;
3085 /* String compare function for qsort. */
3088 compare_strings (const void *arg1, const void *arg2)
3090 const char **s1 = (const char **) arg1;
3091 const char **s2 = (const char **) arg2;
3093 return strcmp (*s1, *s2);
3096 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3097 #define AMBIGUOUS_MESS2 \
3098 ".\nUse \"set gnutarget format-name\" to specify the format."
3101 gdb_bfd_errmsg (bfd_error_type error_tag, char **matching)
3107 /* Check if errmsg just need simple return. */
3108 if (error_tag != bfd_error_file_ambiguously_recognized || matching == NULL)
3109 return bfd_errmsg (error_tag);
3111 ret_len = strlen (bfd_errmsg (error_tag)) + strlen (AMBIGUOUS_MESS1)
3112 + strlen (AMBIGUOUS_MESS2);
3113 for (p = matching; *p; p++)
3114 ret_len += strlen (*p) + 1;
3115 ret = (char *) xmalloc (ret_len + 1);
3117 make_cleanup (xfree, ret);
3119 strcpy (retp, bfd_errmsg (error_tag));
3120 retp += strlen (retp);
3122 strcpy (retp, AMBIGUOUS_MESS1);
3123 retp += strlen (retp);
3125 for (p = matching; *p; p++)
3127 sprintf (retp, " %s", *p);
3128 retp += strlen (retp);
3132 strcpy (retp, AMBIGUOUS_MESS2);
3137 /* Return ARGS parsed as a valid pid, or throw an error. */
3140 parse_pid_to_attach (const char *args)
3146 error_no_arg (_("process-id to attach"));
3148 dummy = (char *) args;
3149 pid = strtoul (args, &dummy, 0);
3150 /* Some targets don't set errno on errors, grrr! */
3151 if ((pid == 0 && dummy == args) || dummy != &args[strlen (args)])
3152 error (_("Illegal process-id: %s."), args);
3157 /* Helper for make_bpstat_clear_actions_cleanup. */
3160 do_bpstat_clear_actions_cleanup (void *unused)
3162 bpstat_clear_actions ();
3165 /* Call bpstat_clear_actions for the case an exception is throw. You should
3166 discard_cleanups if no exception is caught. */
3169 make_bpstat_clear_actions_cleanup (void)
3171 return make_cleanup (do_bpstat_clear_actions_cleanup, NULL);
3174 /* Check for GCC >= 4.x according to the symtab->producer string. Return minor
3175 version (x) of 4.x in such case. If it is not GCC or it is GCC older than
3176 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
3179 producer_is_gcc_ge_4 (const char *producer)
3183 if (! producer_is_gcc (producer, &major, &minor))
3192 /* Returns nonzero if the given PRODUCER string is GCC and sets the MAJOR
3193 and MINOR versions when not NULL. Returns zero if the given PRODUCER
3194 is NULL or it isn't GCC. */
3197 producer_is_gcc (const char *producer, int *major, int *minor)
3201 if (producer != NULL && startswith (producer, "GNU "))
3210 /* Skip any identifier after "GNU " - such as "C11" "C++" or "Java".
3211 A full producer string might look like:
3213 "GNU Fortran 4.8.2 20140120 (Red Hat 4.8.2-16) -mtune=generic ..."
3214 "GNU C++14 5.0.0 20150123 (experimental)"
3216 cs = &producer[strlen ("GNU ")];
3217 while (*cs && !isspace (*cs))
3219 if (*cs && isspace (*cs))
3221 if (sscanf (cs, "%d.%d", major, minor) == 2)
3225 /* Not recognized as GCC. */
3229 /* Helper for make_cleanup_free_char_ptr_vec. */
3232 do_free_char_ptr_vec (void *arg)
3234 VEC (char_ptr) *char_ptr_vec = (VEC (char_ptr) *) arg;
3236 free_char_ptr_vec (char_ptr_vec);
3239 /* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
3240 final VEC_free for CHAR_PTR_VEC itself.
3242 You must not modify CHAR_PTR_VEC after this cleanup registration as the
3243 CHAR_PTR_VEC base address may change on its updates. Contrary to VEC_free
3244 this function does not (cannot) clear the pointer. */
3247 make_cleanup_free_char_ptr_vec (VEC (char_ptr) *char_ptr_vec)
3249 return make_cleanup (do_free_char_ptr_vec, char_ptr_vec);
3252 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3253 must come from xrealloc-compatible allocator and it may be updated. FROM
3254 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3255 located at the start or end of *STRINGP. */
3258 substitute_path_component (char **stringp, const char *from, const char *to)
3260 char *string = *stringp, *s;
3261 const size_t from_len = strlen (from);
3262 const size_t to_len = strlen (to);
3266 s = strstr (s, from);
3270 if ((s == string || IS_DIR_SEPARATOR (s[-1])
3271 || s[-1] == DIRNAME_SEPARATOR)
3272 && (s[from_len] == '\0' || IS_DIR_SEPARATOR (s[from_len])
3273 || s[from_len] == DIRNAME_SEPARATOR))
3278 = (char *) xrealloc (string, (strlen (string) + to_len + 1));
3280 /* Relocate the current S pointer. */
3281 s = s - string + string_new;
3282 string = string_new;
3284 /* Replace from by to. */
3285 memmove (&s[to_len], &s[from_len], strlen (&s[from_len]) + 1);
3286 memcpy (s, to, to_len);
3301 /* SIGALRM handler for waitpid_with_timeout. */
3304 sigalrm_handler (int signo)
3306 /* Nothing to do. */
3311 /* Wrapper to wait for child PID to die with TIMEOUT.
3312 TIMEOUT is the time to stop waiting in seconds.
3313 If TIMEOUT is zero, pass WNOHANG to waitpid.
3314 Returns PID if it was successfully waited for, otherwise -1.
3316 Timeouts are currently implemented with alarm and SIGALRM.
3317 If the host does not support them, this waits "forever".
3318 It would be odd though for a host to have waitpid and not SIGALRM. */
3321 wait_to_die_with_timeout (pid_t pid, int *status, int timeout)
3323 pid_t waitpid_result;
3325 gdb_assert (pid > 0);
3326 gdb_assert (timeout >= 0);
3331 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3332 struct sigaction sa, old_sa;
3334 sa.sa_handler = sigalrm_handler;
3335 sigemptyset (&sa.sa_mask);
3337 sigaction (SIGALRM, &sa, &old_sa);
3341 ofunc = signal (SIGALRM, sigalrm_handler);
3347 waitpid_result = waitpid (pid, status, 0);
3351 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3352 sigaction (SIGALRM, &old_sa, NULL);
3354 signal (SIGALRM, ofunc);
3359 waitpid_result = waitpid (pid, status, WNOHANG);
3361 if (waitpid_result == pid)
3367 #endif /* HAVE_WAITPID */
3369 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3370 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3372 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3373 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3376 gdb_filename_fnmatch (const char *pattern, const char *string, int flags)
3378 gdb_assert ((flags & FNM_FILE_NAME) != 0);
3380 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3381 gdb_assert ((flags & FNM_NOESCAPE) != 0);
3383 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3385 char *pattern_slash, *string_slash;
3387 /* Replace '\' by '/' in both strings. */
3389 pattern_slash = (char *) alloca (strlen (pattern) + 1);
3390 strcpy (pattern_slash, pattern);
3391 pattern = pattern_slash;
3392 for (; *pattern_slash != 0; pattern_slash++)
3393 if (IS_DIR_SEPARATOR (*pattern_slash))
3394 *pattern_slash = '/';
3396 string_slash = (char *) alloca (strlen (string) + 1);
3397 strcpy (string_slash, string);
3398 string = string_slash;
3399 for (; *string_slash != 0; string_slash++)
3400 if (IS_DIR_SEPARATOR (*string_slash))
3401 *string_slash = '/';
3403 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3405 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3406 flags |= FNM_CASEFOLD;
3407 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3409 return fnmatch (pattern, string, flags);
3412 /* Return the number of path elements in PATH.
3420 count_path_elements (const char *path)
3423 const char *p = path;
3425 if (HAS_DRIVE_SPEC (p))
3427 p = STRIP_DRIVE_SPEC (p);
3433 if (IS_DIR_SEPARATOR (*p))
3438 /* Backup one if last character is /, unless it's the only one. */
3439 if (p > path + 1 && IS_DIR_SEPARATOR (p[-1]))
3442 /* Add one for the file name, if present. */
3443 if (p > path && !IS_DIR_SEPARATOR (p[-1]))
3449 /* Remove N leading path elements from PATH.
3450 N must be non-negative.
3451 If PATH has more than N path elements then return NULL.
3452 If PATH has exactly N path elements then return "".
3453 See count_path_elements for a description of how we do the counting. */
3456 strip_leading_path_elements (const char *path, int n)
3459 const char *p = path;
3461 gdb_assert (n >= 0);
3466 if (HAS_DRIVE_SPEC (p))
3468 p = STRIP_DRIVE_SPEC (p);
3474 while (*p != '\0' && !IS_DIR_SEPARATOR (*p))
3489 /* Provide a prototype to silence -Wmissing-prototypes. */
3490 extern initialize_file_ftype _initialize_utils;
3493 _initialize_utils (void)
3495 add_internal_problem_command (&internal_error_problem);
3496 add_internal_problem_command (&internal_warning_problem);
3497 add_internal_problem_command (&demangler_warning_problem);