1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 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"
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)
189 make_cleanup_bfd_unref (bfd *abfd)
191 return make_cleanup (do_bfd_close_cleanup, abfd);
195 do_close_cleanup (void *arg)
203 make_cleanup_close (int fd)
205 int *saved_fd = xmalloc (sizeof (fd));
208 return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree);
211 /* Helper function which does the work for make_cleanup_fclose. */
214 do_fclose_cleanup (void *arg)
221 /* Return a new cleanup that closes FILE. */
224 make_cleanup_fclose (FILE *file)
226 return make_cleanup (do_fclose_cleanup, file);
229 /* Helper function which does the work for make_cleanup_obstack_free. */
232 do_obstack_free (void *arg)
234 struct obstack *ob = arg;
236 obstack_free (ob, NULL);
239 /* Return a new cleanup that frees OBSTACK. */
242 make_cleanup_obstack_free (struct obstack *obstack)
244 return make_cleanup (do_obstack_free, obstack);
248 do_ui_file_delete (void *arg)
250 ui_file_delete (arg);
254 make_cleanup_ui_file_delete (struct ui_file *arg)
256 return make_cleanup (do_ui_file_delete, arg);
259 /* Helper function for make_cleanup_ui_out_redirect_pop. */
262 do_ui_out_redirect_pop (void *arg)
264 struct ui_out *uiout = arg;
266 if (ui_out_redirect (uiout, NULL) < 0)
267 warning (_("Cannot restore redirection of the current output protocol"));
270 /* Return a new cleanup that pops the last redirection by ui_out_redirect
271 with NULL parameter. */
274 make_cleanup_ui_out_redirect_pop (struct ui_out *uiout)
276 return make_cleanup (do_ui_out_redirect_pop, uiout);
280 do_free_section_addr_info (void *arg)
282 free_section_addr_info (arg);
286 make_cleanup_free_section_addr_info (struct section_addr_info *addrs)
288 return make_cleanup (do_free_section_addr_info, addrs);
291 struct restore_integer_closure
298 restore_integer (void *p)
300 struct restore_integer_closure *closure = p;
302 *(closure->variable) = closure->value;
305 /* Remember the current value of *VARIABLE and make it restored when
306 the cleanup is run. */
309 make_cleanup_restore_integer (int *variable)
311 struct restore_integer_closure *c =
312 xmalloc (sizeof (struct restore_integer_closure));
314 c->variable = variable;
315 c->value = *variable;
317 return make_cleanup_dtor (restore_integer, (void *) c, xfree);
320 /* Remember the current value of *VARIABLE and make it restored when
321 the cleanup is run. */
324 make_cleanup_restore_uinteger (unsigned int *variable)
326 return make_cleanup_restore_integer ((int *) variable);
329 /* Helper for make_cleanup_unpush_target. */
332 do_unpush_target (void *arg)
334 struct target_ops *ops = arg;
339 /* Return a new cleanup that unpushes OPS. */
342 make_cleanup_unpush_target (struct target_ops *ops)
344 return make_cleanup (do_unpush_target, ops);
347 /* Helper for make_cleanup_htab_delete compile time checking the types. */
350 do_htab_delete_cleanup (void *htab_voidp)
352 htab_t htab = htab_voidp;
357 /* Return a new cleanup that deletes HTAB. */
360 make_cleanup_htab_delete (htab_t htab)
362 return make_cleanup (do_htab_delete_cleanup, htab);
365 struct restore_ui_file_closure
367 struct ui_file **variable;
368 struct ui_file *value;
372 do_restore_ui_file (void *p)
374 struct restore_ui_file_closure *closure = p;
376 *(closure->variable) = closure->value;
379 /* Remember the current value of *VARIABLE and make it restored when
380 the cleanup is run. */
383 make_cleanup_restore_ui_file (struct ui_file **variable)
385 struct restore_ui_file_closure *c = XNEW (struct restore_ui_file_closure);
387 c->variable = variable;
388 c->value = *variable;
390 return make_cleanup_dtor (do_restore_ui_file, (void *) c, xfree);
393 /* Helper for make_cleanup_value_free_to_mark. */
396 do_value_free_to_mark (void *value)
398 value_free_to_mark ((struct value *) value);
401 /* Free all values allocated since MARK was obtained by value_mark
402 (except for those released) when the cleanup is run. */
405 make_cleanup_value_free_to_mark (struct value *mark)
407 return make_cleanup (do_value_free_to_mark, mark);
410 /* Helper for make_cleanup_value_free. */
413 do_value_free (void *value)
421 make_cleanup_value_free (struct value *value)
423 return make_cleanup (do_value_free, value);
426 /* Helper for make_cleanup_free_so. */
429 do_free_so (void *arg)
431 struct so_list *so = arg;
436 /* Make cleanup handler calling free_so for SO. */
439 make_cleanup_free_so (struct so_list *so)
441 return make_cleanup (do_free_so, so);
444 /* Helper for make_cleanup_restore_current_language. */
447 do_restore_current_language (void *p)
449 enum language saved_lang = (uintptr_t) p;
451 set_language (saved_lang);
454 /* Remember the current value of CURRENT_LANGUAGE and make it restored when
455 the cleanup is run. */
458 make_cleanup_restore_current_language (void)
460 enum language saved_lang = current_language->la_language;
462 return make_cleanup (do_restore_current_language,
463 (void *) (uintptr_t) saved_lang);
466 /* Helper function for make_cleanup_clear_parser_state. */
469 do_clear_parser_state (void *ptr)
471 struct parser_state **p = (struct parser_state **) ptr;
476 /* Clean (i.e., set to NULL) the parser state variable P. */
479 make_cleanup_clear_parser_state (struct parser_state **p)
481 return make_cleanup (do_clear_parser_state, (void *) p);
484 /* This function is useful for cleanups.
488 old_chain = make_cleanup (free_current_contents, &foo);
490 to arrange to free the object thus allocated. */
493 free_current_contents (void *ptr)
495 void **location = ptr;
497 if (location == NULL)
498 internal_error (__FILE__, __LINE__,
499 _("free_current_contents: NULL pointer"));
500 if (*location != NULL)
509 /* Print a warning message. The first argument STRING is the warning
510 message, used as an fprintf format string, the second is the
511 va_list of arguments for that string. A warning is unfiltered (not
512 paginated) so that the user does not need to page through each
513 screen full of warnings when there are lots of them. */
516 vwarning (const char *string, va_list args)
518 if (deprecated_warning_hook)
519 (*deprecated_warning_hook) (string, args);
522 if (target_supports_terminal_ours ())
523 target_terminal_ours ();
524 if (filtered_printing_initialized ())
525 wrap_here (""); /* Force out any buffered output. */
526 gdb_flush (gdb_stdout);
527 if (warning_pre_print)
528 fputs_unfiltered (warning_pre_print, gdb_stderr);
529 vfprintf_unfiltered (gdb_stderr, string, args);
530 fprintf_unfiltered (gdb_stderr, "\n");
534 /* Print an error message and return to command level.
535 The first argument STRING is the error message, used as a fprintf string,
536 and the remaining args are passed as arguments to it. */
539 verror (const char *string, va_list args)
541 throw_verror (GENERIC_ERROR, string, args);
545 error_stream (struct ui_file *stream)
547 char *message = ui_file_xstrdup (stream, NULL);
549 make_cleanup (xfree, message);
550 error (("%s"), message);
553 /* Emit a message and abort. */
555 static void ATTRIBUTE_NORETURN
556 abort_with_message (const char *msg)
558 if (gdb_stderr == NULL)
561 fputs_unfiltered (msg, gdb_stderr);
563 abort (); /* NOTE: GDB has only three calls to abort(). */
566 /* Dump core trying to increase the core soft limit to hard limit first. */
571 #ifdef HAVE_SETRLIMIT
572 struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY };
574 setrlimit (RLIMIT_CORE, &rlim);
575 #endif /* HAVE_SETRLIMIT */
577 abort (); /* NOTE: GDB has only three calls to abort(). */
580 /* Check whether GDB will be able to dump core using the dump_core
581 function. Returns zero if GDB cannot or should not dump core.
582 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
583 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
586 can_dump_core (enum resource_limit_kind limit_kind)
588 #ifdef HAVE_GETRLIMIT
591 /* Be quiet and assume we can dump if an error is returned. */
592 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
598 if (rlim.rlim_cur == 0)
602 if (rlim.rlim_max == 0)
605 #endif /* HAVE_GETRLIMIT */
610 /* Print a warning that we cannot dump core. */
613 warn_cant_dump_core (const char *reason)
615 fprintf_unfiltered (gdb_stderr,
616 _("%s\nUnable to dump core, use `ulimit -c"
617 " unlimited' before executing GDB next time.\n"),
621 /* Check whether GDB will be able to dump core using the dump_core
622 function, and print a warning if we cannot. */
625 can_dump_core_warn (enum resource_limit_kind limit_kind,
628 int core_dump_allowed = can_dump_core (limit_kind);
630 if (!core_dump_allowed)
631 warn_cant_dump_core (reason);
633 return core_dump_allowed;
636 /* Allow the user to configure the debugger behavior with respect to
637 what to do when an internal problem is detected. */
639 const char internal_problem_ask[] = "ask";
640 const char internal_problem_yes[] = "yes";
641 const char internal_problem_no[] = "no";
642 static const char *const internal_problem_modes[] =
644 internal_problem_ask,
645 internal_problem_yes,
650 /* Print a message reporting an internal error/warning. Ask the user
651 if they want to continue, dump core, or just exit. Return
652 something to indicate a quit. */
654 struct internal_problem
657 int user_settable_should_quit;
658 const char *should_quit;
659 int user_settable_should_dump_core;
660 const char *should_dump_core;
663 /* Report a problem, internal to GDB, to the user. Once the problem
664 has been reported, and assuming GDB didn't quit, the caller can
665 either allow execution to resume or throw an error. */
667 static void ATTRIBUTE_PRINTF (4, 0)
668 internal_vproblem (struct internal_problem *problem,
669 const char *file, int line, const char *fmt, va_list ap)
675 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
677 /* Don't allow infinite error/warning recursion. */
679 static char msg[] = "Recursive internal problem.\n";
688 abort_with_message (msg);
691 /* Newer GLIBC versions put the warn_unused_result attribute
692 on write, but this is one of those rare cases where
693 ignoring the return value is correct. Casting to (void)
694 does not fix this problem. This is the solution suggested
695 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
696 if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg))
697 abort (); /* NOTE: GDB has only three calls to abort(). */
702 /* Create a string containing the full error/warning message. Need
703 to call query with this full string, as otherwize the reason
704 (error/warning) and question become separated. Format using a
705 style similar to a compiler error message. Include extra detail
706 so that the user knows that they are living on the edge. */
710 msg = xstrvprintf (fmt, ap);
711 reason = xstrprintf ("%s:%d: %s: %s\n"
712 "A problem internal to GDB has been detected,\n"
713 "further debugging may prove unreliable.",
714 file, line, problem->name, msg);
716 make_cleanup (xfree, reason);
719 /* Fall back to abort_with_message if gdb_stderr is not set up. */
720 if (gdb_stderr == NULL)
722 fputs (reason, stderr);
723 abort_with_message ("\n");
726 /* Try to get the message out and at the start of a new line. */
727 if (target_supports_terminal_ours ())
728 target_terminal_ours ();
729 if (filtered_printing_initialized ())
732 /* Emit the message unless query will emit it below. */
733 if (problem->should_quit != internal_problem_ask
735 || !filtered_printing_initialized ())
736 fprintf_unfiltered (gdb_stderr, "%s\n", reason);
738 if (problem->should_quit == internal_problem_ask)
740 /* Default (yes/batch case) is to quit GDB. When in batch mode
741 this lessens the likelihood of GDB going into an infinite
743 if (!confirm || !filtered_printing_initialized ())
746 quit_p = query (_("%s\nQuit this debugging session? "), reason);
748 else if (problem->should_quit == internal_problem_yes)
750 else if (problem->should_quit == internal_problem_no)
753 internal_error (__FILE__, __LINE__, _("bad switch"));
755 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr);
756 if (REPORT_BUGS_TO[0])
757 fprintf_unfiltered (gdb_stderr, _(" For instructions, see:\n%s."),
759 fputs_unfiltered ("\n\n", gdb_stderr);
761 if (problem->should_dump_core == internal_problem_ask)
763 if (!can_dump_core_warn (LIMIT_MAX, reason))
765 else if (!filtered_printing_initialized ())
769 /* Default (yes/batch case) is to dump core. This leaves a GDB
770 `dropping' so that it is easier to see that something went
772 dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
775 else if (problem->should_dump_core == internal_problem_yes)
776 dump_core_p = can_dump_core_warn (LIMIT_MAX, reason);
777 else if (problem->should_dump_core == internal_problem_no)
780 internal_error (__FILE__, __LINE__, _("bad switch"));
793 #ifdef HAVE_WORKING_FORK
801 do_cleanups (cleanup);
804 static struct internal_problem internal_error_problem = {
805 "internal-error", 1, internal_problem_ask, 1, internal_problem_ask
809 internal_verror (const char *file, int line, const char *fmt, va_list ap)
811 internal_vproblem (&internal_error_problem, file, line, fmt, ap);
812 throw_quit (_("Command aborted."));
815 static struct internal_problem internal_warning_problem = {
816 "internal-warning", 1, internal_problem_ask, 1, internal_problem_ask
820 internal_vwarning (const char *file, int line, const char *fmt, va_list ap)
822 internal_vproblem (&internal_warning_problem, file, line, fmt, ap);
825 static struct internal_problem demangler_warning_problem = {
826 "demangler-warning", 1, internal_problem_ask, 0, internal_problem_no
830 demangler_vwarning (const char *file, int line, const char *fmt, va_list ap)
832 internal_vproblem (&demangler_warning_problem, file, line, fmt, ap);
836 demangler_warning (const char *file, int line, const char *string, ...)
840 va_start (ap, string);
841 demangler_vwarning (file, line, string, ap);
845 /* Dummy functions to keep add_prefix_cmd happy. */
848 set_internal_problem_cmd (char *args, int from_tty)
853 show_internal_problem_cmd (char *args, int from_tty)
857 /* When GDB reports an internal problem (error or warning) it gives
858 the user the opportunity to quit GDB and/or create a core file of
859 the current debug session. This function registers a few commands
860 that make it possible to specify that GDB should always or never
861 quit or create a core file, without asking. The commands look
864 maint set PROBLEM-NAME quit ask|yes|no
865 maint show PROBLEM-NAME quit
866 maint set PROBLEM-NAME corefile ask|yes|no
867 maint show PROBLEM-NAME corefile
869 Where PROBLEM-NAME is currently "internal-error" or
870 "internal-warning". */
873 add_internal_problem_command (struct internal_problem *problem)
875 struct cmd_list_element **set_cmd_list;
876 struct cmd_list_element **show_cmd_list;
880 set_cmd_list = xmalloc (sizeof (*set_cmd_list));
881 show_cmd_list = xmalloc (sizeof (*set_cmd_list));
882 *set_cmd_list = NULL;
883 *show_cmd_list = NULL;
885 set_doc = xstrprintf (_("Configure what GDB does when %s is detected."),
888 show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
891 add_prefix_cmd ((char*) problem->name,
892 class_maintenance, set_internal_problem_cmd, set_doc,
894 concat ("maintenance set ", problem->name, " ",
896 0/*allow-unknown*/, &maintenance_set_cmdlist);
898 add_prefix_cmd ((char*) problem->name,
899 class_maintenance, show_internal_problem_cmd, show_doc,
901 concat ("maintenance show ", problem->name, " ",
903 0/*allow-unknown*/, &maintenance_show_cmdlist);
905 if (problem->user_settable_should_quit)
907 set_doc = xstrprintf (_("Set whether GDB should quit "
908 "when an %s is detected"),
910 show_doc = xstrprintf (_("Show whether GDB will quit "
911 "when an %s is detected"),
913 add_setshow_enum_cmd ("quit", class_maintenance,
914 internal_problem_modes,
915 &problem->should_quit,
928 if (problem->user_settable_should_dump_core)
930 set_doc = xstrprintf (_("Set whether GDB should create a core "
931 "file of GDB when %s is detected"),
933 show_doc = xstrprintf (_("Show whether GDB will create a core "
934 "file of GDB when %s is detected"),
936 add_setshow_enum_cmd ("corefile", class_maintenance,
937 internal_problem_modes,
938 &problem->should_dump_core,
952 /* Return a newly allocated string, containing the PREFIX followed
953 by the system error message for errno (separated by a colon).
955 The result must be deallocated after use. */
958 perror_string (const char *prefix)
963 err = safe_strerror (errno);
964 combined = (char *) xmalloc (strlen (err) + strlen (prefix) + 3);
965 strcpy (combined, prefix);
966 strcat (combined, ": ");
967 strcat (combined, err);
972 /* Print the system error message for errno, and also mention STRING
973 as the file name for which the error was encountered. Use ERRCODE
974 for the thrown exception. Then return to command level. */
977 throw_perror_with_name (enum errors errcode, const char *string)
981 combined = perror_string (string);
982 make_cleanup (xfree, combined);
984 /* I understand setting these is a matter of taste. Still, some people
985 may clear errno but not know about bfd_error. Doing this here is not
987 bfd_set_error (bfd_error_no_error);
990 throw_error (errcode, _("%s."), combined);
993 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
996 perror_with_name (const char *string)
998 throw_perror_with_name (GENERIC_ERROR, string);
1001 /* Same as perror_with_name except that it prints a warning instead
1002 of throwing an error. */
1005 perror_warning_with_name (const char *string)
1009 combined = perror_string (string);
1010 warning (_("%s"), combined);
1014 /* Print the system error message for ERRCODE, and also mention STRING
1015 as the file name for which the error was encountered. */
1018 print_sys_errmsg (const char *string, int errcode)
1023 err = safe_strerror (errcode);
1024 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
1025 strcpy (combined, string);
1026 strcat (combined, ": ");
1027 strcat (combined, err);
1029 /* We want anything which was printed on stdout to come out first, before
1031 gdb_flush (gdb_stdout);
1032 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
1035 /* Control C eventually causes this to be called, at a convenient time. */
1040 if (sync_quit_force_run)
1042 sync_quit_force_run = 0;
1043 quit_force (NULL, stdin == instream);
1047 /* No steenking SIGINT will ever be coming our way when the
1048 program is resumed. Don't lie. */
1049 throw_quit ("Quit");
1052 /* If there is no terminal switching for this target, then we can't
1053 possibly get screwed by the lack of job control. */
1054 || !target_supports_terminal_ours ())
1055 throw_quit ("Quit");
1057 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
1062 /* Called when a memory allocation fails, with the number of bytes of
1063 memory requested in SIZE. */
1066 malloc_failure (long size)
1070 internal_error (__FILE__, __LINE__,
1071 _("virtual memory exhausted: can't allocate %ld bytes."),
1076 internal_error (__FILE__, __LINE__, _("virtual memory exhausted."));
1080 /* My replacement for the read system call.
1081 Used like `read' but keeps going if `read' returns too soon. */
1084 myread (int desc, char *addr, int len)
1091 val = read (desc, addr, len);
1095 return orglen - len;
1103 print_spaces (int n, struct ui_file *file)
1105 fputs_unfiltered (n_spaces (n), file);
1108 /* Print a host address. */
1111 gdb_print_host_address (const void *addr, struct ui_file *stream)
1113 fprintf_filtered (stream, "%s", host_address_to_string (addr));
1117 /* A cleanup function that calls regfree. */
1120 do_regfree_cleanup (void *r)
1125 /* Create a new cleanup that frees the compiled regular expression R. */
1128 make_regfree_cleanup (regex_t *r)
1130 return make_cleanup (do_regfree_cleanup, r);
1133 /* Return an xmalloc'd error message resulting from a regular
1134 expression compilation failure. */
1137 get_regcomp_error (int code, regex_t *rx)
1139 size_t length = regerror (code, rx, NULL, 0);
1140 char *result = xmalloc (length);
1142 regerror (code, rx, result, length);
1146 /* Compile a regexp and throw an exception on error. This returns a
1147 cleanup to free the resulting pattern on success. RX must not be
1151 compile_rx_or_error (regex_t *pattern, const char *rx, const char *message)
1155 gdb_assert (rx != NULL);
1157 code = regcomp (pattern, rx, REG_NOSUB);
1160 char *err = get_regcomp_error (code, pattern);
1162 make_cleanup (xfree, err);
1163 error (("%s: %s"), message, err);
1166 return make_regfree_cleanup (pattern);
1171 /* This function supports the query, nquery, and yquery functions.
1172 Ask user a y-or-n question and return 0 if answer is no, 1 if
1173 answer is yes, or default the answer to the specified default
1174 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1175 default answer, or '\0' for no default.
1176 CTLSTR is the control string and should end in "? ". It should
1177 not say how to answer, because we do that.
1178 ARGS are the arguments passed along with the CTLSTR argument to
1181 static int ATTRIBUTE_PRINTF (1, 0)
1182 defaulted_query (const char *ctlstr, const char defchar, va_list args)
1188 char def_answer, not_def_answer;
1189 char *y_string, *n_string, *question;
1190 /* Used to add duration we waited for user to respond to
1191 prompt_for_continue_wait_time. */
1192 struct timeval prompt_started, prompt_ended, prompt_delta;
1194 /* Set up according to which answer is the default. */
1195 if (defchar == '\0')
1199 not_def_answer = 'N';
1203 else if (defchar == 'y')
1207 not_def_answer = 'N';
1215 not_def_answer = 'Y';
1220 /* Automatically answer the default value if the user did not want
1221 prompts or the command was issued with the server prefix. */
1222 if (!confirm || server_command)
1225 /* If input isn't coming from the user directly, just say what
1226 question we're asking, and then answer the default automatically. This
1227 way, important error messages don't get lost when talking to GDB
1229 if (! input_from_terminal_p ())
1232 vfprintf_filtered (gdb_stdout, ctlstr, args);
1234 printf_filtered (_("(%s or %s) [answered %c; "
1235 "input not from terminal]\n"),
1236 y_string, n_string, def_answer);
1237 gdb_flush (gdb_stdout);
1242 if (deprecated_query_hook)
1244 return deprecated_query_hook (ctlstr, args);
1247 /* Format the question outside of the loop, to avoid reusing args. */
1248 question = xstrvprintf (ctlstr, args);
1250 /* Used for calculating time spend waiting for user. */
1251 gettimeofday (&prompt_started, NULL);
1255 wrap_here (""); /* Flush any buffered output. */
1256 gdb_flush (gdb_stdout);
1258 if (annotation_level > 1)
1259 printf_filtered (("\n\032\032pre-query\n"));
1261 fputs_filtered (question, gdb_stdout);
1262 printf_filtered (_("(%s or %s) "), y_string, n_string);
1264 if (annotation_level > 1)
1265 printf_filtered (("\n\032\032query\n"));
1268 gdb_flush (gdb_stdout);
1270 answer = fgetc (stdin);
1272 /* We expect fgetc to block until a character is read. But
1273 this may not be the case if the terminal was opened with
1274 the NONBLOCK flag. In that case, if there is nothing to
1275 read on stdin, fgetc returns EOF, but also sets the error
1276 condition flag on stdin and errno to EAGAIN. With a true
1277 EOF, stdin's error condition flag is not set.
1279 A situation where this behavior was observed is a pseudo
1281 while (answer == EOF && ferror (stdin) && errno == EAGAIN)
1283 /* Not a real EOF. Wait a little while and try again until
1284 we read something. */
1287 answer = fgetc (stdin);
1290 clearerr (stdin); /* in case of C-d */
1291 if (answer == EOF) /* C-d */
1293 printf_filtered ("EOF [assumed %c]\n", def_answer);
1297 /* Eat rest of input line, to EOF or newline. */
1301 ans2 = fgetc (stdin);
1304 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1308 /* Check answer. For the non-default, the user must specify
1309 the non-default explicitly. */
1310 if (answer == not_def_answer)
1312 retval = !def_value;
1315 /* Otherwise, if a default was specified, the user may either
1316 specify the required input or have it default by entering
1318 if (answer == def_answer
1319 || (defchar != '\0' &&
1320 (answer == '\n' || answer == '\r' || answer == EOF)))
1325 /* Invalid entries are not defaulted and require another selection. */
1326 printf_filtered (_("Please answer %s or %s.\n"),
1327 y_string, n_string);
1330 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1331 gettimeofday (&prompt_ended, NULL);
1332 timeval_sub (&prompt_delta, &prompt_ended, &prompt_started);
1333 timeval_add (&prompt_for_continue_wait_time,
1334 &prompt_for_continue_wait_time, &prompt_delta);
1337 if (annotation_level > 1)
1338 printf_filtered (("\n\032\032post-query\n"));
1343 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1344 answer is yes, or 0 if answer is defaulted.
1345 Takes three args which are given to printf to print the question.
1346 The first, a control string, should end in "? ".
1347 It should not say how to answer, because we do that. */
1350 nquery (const char *ctlstr, ...)
1355 va_start (args, ctlstr);
1356 ret = defaulted_query (ctlstr, 'n', args);
1361 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1362 answer is yes, or 1 if answer is defaulted.
1363 Takes three args which are given to printf to print the question.
1364 The first, a control string, should end in "? ".
1365 It should not say how to answer, because we do that. */
1368 yquery (const char *ctlstr, ...)
1373 va_start (args, ctlstr);
1374 ret = defaulted_query (ctlstr, 'y', args);
1379 /* Ask user a y-or-n question and return 1 iff answer is yes.
1380 Takes three args which are given to printf to print the question.
1381 The first, a control string, should end in "? ".
1382 It should not say how to answer, because we do that. */
1385 query (const char *ctlstr, ...)
1390 va_start (args, ctlstr);
1391 ret = defaulted_query (ctlstr, '\0', args);
1396 /* A helper for parse_escape that converts a host character to a
1397 target character. C is the host character. If conversion is
1398 possible, then the target character is stored in *TARGET_C and the
1399 function returns 1. Otherwise, the function returns 0. */
1402 host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c)
1404 struct obstack host_data;
1406 struct cleanup *cleanups;
1409 obstack_init (&host_data);
1410 cleanups = make_cleanup_obstack_free (&host_data);
1412 convert_between_encodings (target_charset (gdbarch), host_charset (),
1413 (gdb_byte *) &the_char, 1, 1,
1414 &host_data, translit_none);
1416 if (obstack_object_size (&host_data) == 1)
1419 *target_c = *(char *) obstack_base (&host_data);
1422 do_cleanups (cleanups);
1426 /* Parse a C escape sequence. STRING_PTR points to a variable
1427 containing a pointer to the string to parse. That pointer
1428 should point to the character after the \. That pointer
1429 is updated past the characters we use. The value of the
1430 escape sequence is returned.
1432 A negative value means the sequence \ newline was seen,
1433 which is supposed to be equivalent to nothing at all.
1435 If \ is followed by a null character, we return a negative
1436 value and leave the string pointer pointing at the null character.
1438 If \ is followed by 000, we return 0 and leave the string pointer
1439 after the zeros. A value of 0 does not mean end of string. */
1442 parse_escape (struct gdbarch *gdbarch, const char **string_ptr)
1444 int target_char = -2; /* Initialize to avoid GCC warnings. */
1445 int c = *(*string_ptr)++;
1464 int i = host_hex_value (c);
1469 if (isdigit (c) && c != '8' && c != '9')
1473 i += host_hex_value (c);
1509 if (!host_char_to_target (gdbarch, c, &target_char))
1510 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1511 " which has no equivalent\nin the `%s' character set."),
1512 c, c, target_charset (gdbarch));
1516 /* Print the character C on STREAM as part of the contents of a literal
1517 string whose delimiter is QUOTER. Note that this routine should only
1518 be call for printing things which are independent of the language
1519 of the program being debugged.
1521 printchar will normally escape backslashes and instances of QUOTER. If
1522 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1523 As a side effect, if you pass the backslash character as the QUOTER,
1524 printchar will escape backslashes as usual, but not any other quoting
1528 printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1529 void (*do_fprintf) (struct ui_file *, const char *, ...)
1530 ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
1532 c &= 0xFF; /* Avoid sign bit follies */
1534 if (c < 0x20 || /* Low control chars */
1535 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1536 (sevenbit_strings && c >= 0x80))
1537 { /* high order bit set */
1541 do_fputs ("\\n", stream);
1544 do_fputs ("\\b", stream);
1547 do_fputs ("\\t", stream);
1550 do_fputs ("\\f", stream);
1553 do_fputs ("\\r", stream);
1556 do_fputs ("\\e", stream);
1559 do_fputs ("\\a", stream);
1562 do_fprintf (stream, "\\%.3o", (unsigned int) c);
1568 if (quoter != 0 && (c == '\\' || c == quoter))
1569 do_fputs ("\\", stream);
1570 do_fprintf (stream, "%c", c);
1574 /* Print the character C on STREAM as part of the contents of a
1575 literal string whose delimiter is QUOTER. Note that these routines
1576 should only be call for printing things which are independent of
1577 the language of the program being debugged. */
1580 fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
1583 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1587 fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
1590 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1594 fputstrn_filtered (const char *str, int n, int quoter,
1595 struct ui_file *stream)
1599 for (i = 0; i < n; i++)
1600 printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
1604 fputstrn_unfiltered (const char *str, int n, int quoter,
1605 struct ui_file *stream)
1609 for (i = 0; i < n; i++)
1610 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1614 /* Number of lines per page or UINT_MAX if paging is disabled. */
1615 static unsigned int lines_per_page;
1617 show_lines_per_page (struct ui_file *file, int from_tty,
1618 struct cmd_list_element *c, const char *value)
1620 fprintf_filtered (file,
1621 _("Number of lines gdb thinks are in a page is %s.\n"),
1625 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1626 static unsigned int chars_per_line;
1628 show_chars_per_line (struct ui_file *file, int from_tty,
1629 struct cmd_list_element *c, const char *value)
1631 fprintf_filtered (file,
1632 _("Number of characters gdb thinks "
1633 "are in a line is %s.\n"),
1637 /* Current count of lines printed on this page, chars on this line. */
1638 static unsigned int lines_printed, chars_printed;
1640 /* Buffer and start column of buffered text, for doing smarter word-
1641 wrapping. When someone calls wrap_here(), we start buffering output
1642 that comes through fputs_filtered(). If we see a newline, we just
1643 spit it out and forget about the wrap_here(). If we see another
1644 wrap_here(), we spit it out and remember the newer one. If we see
1645 the end of the line, we spit out a newline, the indent, and then
1646 the buffered output. */
1648 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1649 are waiting to be output (they have already been counted in chars_printed).
1650 When wrap_buffer[0] is null, the buffer is empty. */
1651 static char *wrap_buffer;
1653 /* Pointer in wrap_buffer to the next character to fill. */
1654 static char *wrap_pointer;
1656 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1658 static char *wrap_indent;
1660 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1661 is not in effect. */
1662 static int wrap_column;
1665 /* Inialize the number of lines per page and chars per line. */
1668 init_page_info (void)
1672 lines_per_page = UINT_MAX;
1673 chars_per_line = UINT_MAX;
1677 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
1682 #if defined(__GO32__)
1683 rows = ScreenRows ();
1684 cols = ScreenCols ();
1685 lines_per_page = rows;
1686 chars_per_line = cols;
1688 /* Make sure Readline has initialized its terminal settings. */
1689 rl_reset_terminal (NULL);
1691 /* Get the screen size from Readline. */
1692 rl_get_screen_size (&rows, &cols);
1693 lines_per_page = rows;
1694 chars_per_line = cols;
1696 /* Readline should have fetched the termcap entry for us.
1697 Only try to use tgetnum function if rl_get_screen_size
1698 did not return a useful value. */
1699 if (((rows <= 0) && (tgetnum ("li") < 0))
1700 /* Also disable paging if inside EMACS. */
1701 || getenv ("EMACS"))
1703 /* The number of lines per page is not mentioned in the terminal
1704 description or EMACS evironment variable is set. This probably
1705 means that paging is not useful, so disable paging. */
1706 lines_per_page = UINT_MAX;
1709 /* If the output is not a terminal, don't paginate it. */
1710 if (!ui_file_isatty (gdb_stdout))
1711 lines_per_page = UINT_MAX;
1719 /* Return nonzero if filtered printing is initialized. */
1721 filtered_printing_initialized (void)
1723 return wrap_buffer != NULL;
1726 /* Helper for make_cleanup_restore_page_info. */
1729 do_restore_page_info_cleanup (void *arg)
1735 /* Provide cleanup for restoring the terminal size. */
1738 make_cleanup_restore_page_info (void)
1740 struct cleanup *back_to;
1742 back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
1743 make_cleanup_restore_uinteger (&lines_per_page);
1744 make_cleanup_restore_uinteger (&chars_per_line);
1749 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1750 Provide cleanup for restoring the original state. */
1753 set_batch_flag_and_make_cleanup_restore_page_info (void)
1755 struct cleanup *back_to = make_cleanup_restore_page_info ();
1757 make_cleanup_restore_integer (&batch_flag);
1764 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1767 set_screen_size (void)
1769 int rows = lines_per_page;
1770 int cols = chars_per_line;
1778 /* Update Readline's idea of the terminal size. */
1779 rl_set_screen_size (rows, cols);
1782 /* Reinitialize WRAP_BUFFER according to the current value of
1788 if (chars_per_line == 0)
1793 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1794 wrap_buffer[0] = '\0';
1797 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1798 wrap_pointer = wrap_buffer; /* Start it at the beginning. */
1802 set_width_command (char *args, int from_tty, struct cmd_list_element *c)
1809 set_height_command (char *args, int from_tty, struct cmd_list_element *c)
1814 /* Wait, so the user can read what's on the screen. Prompt the user
1815 to continue by pressing RETURN. */
1818 prompt_for_continue (void)
1821 char cont_prompt[120];
1822 /* Used to add duration we waited for user to respond to
1823 prompt_for_continue_wait_time. */
1824 struct timeval prompt_started, prompt_ended, prompt_delta;
1826 gettimeofday (&prompt_started, NULL);
1828 if (annotation_level > 1)
1829 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1831 strcpy (cont_prompt,
1832 "---Type <return> to continue, or q <return> to quit---");
1833 if (annotation_level > 1)
1834 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1836 /* We must do this *before* we call gdb_readline, else it will eventually
1837 call us -- thinking that we're trying to print beyond the end of the
1839 reinitialize_more_filter ();
1844 /* We'll need to handle input. */
1845 target_terminal_ours ();
1847 /* On a real operating system, the user can quit with SIGINT.
1850 'q' is provided on all systems so users don't have to change habits
1851 from system to system, and because telling them what to do in
1852 the prompt is more user-friendly than expecting them to think of
1854 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1855 whereas control-C to gdb_readline will cause the user to get dumped
1857 ignore = gdb_readline_wrapper (cont_prompt);
1859 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1860 gettimeofday (&prompt_ended, NULL);
1861 timeval_sub (&prompt_delta, &prompt_ended, &prompt_started);
1862 timeval_add (&prompt_for_continue_wait_time,
1863 &prompt_for_continue_wait_time, &prompt_delta);
1865 if (annotation_level > 1)
1866 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1872 while (*p == ' ' || *p == '\t')
1880 /* Now we have to do this again, so that GDB will know that it doesn't
1881 need to save the ---Type <return>--- line at the top of the screen. */
1882 reinitialize_more_filter ();
1884 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1887 /* Initalize timer to keep track of how long we waited for the user. */
1890 reset_prompt_for_continue_wait_time (void)
1892 static const struct timeval zero_timeval = { 0 };
1894 prompt_for_continue_wait_time = zero_timeval;
1897 /* Fetch the cumulative time spent in prompt_for_continue. */
1900 get_prompt_for_continue_wait_time (void)
1902 return prompt_for_continue_wait_time;
1905 /* Reinitialize filter; ie. tell it to reset to original values. */
1908 reinitialize_more_filter (void)
1914 /* Indicate that if the next sequence of characters overflows the line,
1915 a newline should be inserted here rather than when it hits the end.
1916 If INDENT is non-null, it is a string to be printed to indent the
1917 wrapped part on the next line. INDENT must remain accessible until
1918 the next call to wrap_here() or until a newline is printed through
1921 If the line is already overfull, we immediately print a newline and
1922 the indentation, and disable further wrapping.
1924 If we don't know the width of lines, but we know the page height,
1925 we must not wrap words, but should still keep track of newlines
1926 that were explicitly printed.
1928 INDENT should not contain tabs, as that will mess up the char count
1929 on the next line. FIXME.
1931 This routine is guaranteed to force out any output which has been
1932 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1933 used to force out output from the wrap_buffer. */
1936 wrap_here (char *indent)
1938 /* This should have been allocated, but be paranoid anyway. */
1940 internal_error (__FILE__, __LINE__,
1941 _("failed internal consistency check"));
1945 *wrap_pointer = '\0';
1946 fputs_unfiltered (wrap_buffer, gdb_stdout);
1948 wrap_pointer = wrap_buffer;
1949 wrap_buffer[0] = '\0';
1950 if (chars_per_line == UINT_MAX) /* No line overflow checking. */
1954 else if (chars_printed >= chars_per_line)
1956 puts_filtered ("\n");
1958 puts_filtered (indent);
1963 wrap_column = chars_printed;
1967 wrap_indent = indent;
1971 /* Print input string to gdb_stdout, filtered, with wrap,
1972 arranging strings in columns of n chars. String can be
1973 right or left justified in the column. Never prints
1974 trailing spaces. String should never be longer than
1975 width. FIXME: this could be useful for the EXAMINE
1976 command, which currently doesn't tabulate very well. */
1979 puts_filtered_tabular (char *string, int width, int right)
1985 gdb_assert (chars_per_line > 0);
1986 if (chars_per_line == UINT_MAX)
1988 fputs_filtered (string, gdb_stdout);
1989 fputs_filtered ("\n", gdb_stdout);
1993 if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
1994 fputs_filtered ("\n", gdb_stdout);
1996 if (width >= chars_per_line)
1997 width = chars_per_line - 1;
1999 stringlen = strlen (string);
2001 if (chars_printed > 0)
2002 spaces = width - (chars_printed - 1) % width - 1;
2004 spaces += width - stringlen;
2006 spacebuf = alloca (spaces + 1);
2007 spacebuf[spaces] = '\0';
2009 spacebuf[spaces] = ' ';
2011 fputs_filtered (spacebuf, gdb_stdout);
2012 fputs_filtered (string, gdb_stdout);
2016 /* Ensure that whatever gets printed next, using the filtered output
2017 commands, starts at the beginning of the line. I.e. if there is
2018 any pending output for the current line, flush it and start a new
2019 line. Otherwise do nothing. */
2024 if (chars_printed > 0)
2026 puts_filtered ("\n");
2031 /* Like fputs but if FILTER is true, pause after every screenful.
2033 Regardless of FILTER can wrap at points other than the final
2034 character of a line.
2036 Unlike fputs, fputs_maybe_filtered does not return a value.
2037 It is OK for LINEBUFFER to be NULL, in which case just don't print
2040 Note that a longjmp to top level may occur in this routine (only if
2041 FILTER is true) (since prompt_for_continue may do so) so this
2042 routine should not be called when cleanups are not in place. */
2045 fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
2048 const char *lineptr;
2050 if (linebuffer == 0)
2053 /* Don't do any filtering if it is disabled. */
2054 if (stream != gdb_stdout
2055 || !pagination_enabled
2057 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
2058 || top_level_interpreter () == NULL
2059 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2061 fputs_unfiltered (linebuffer, stream);
2065 /* Go through and output each character. Show line extension
2066 when this is necessary; prompt user for new page when this is
2069 lineptr = linebuffer;
2072 /* Possible new page. */
2073 if (filter && (lines_printed >= lines_per_page - 1))
2074 prompt_for_continue ();
2076 while (*lineptr && *lineptr != '\n')
2078 /* Print a single line. */
2079 if (*lineptr == '\t')
2082 *wrap_pointer++ = '\t';
2084 fputc_unfiltered ('\t', stream);
2085 /* Shifting right by 3 produces the number of tab stops
2086 we have already passed, and then adding one and
2087 shifting left 3 advances to the next tab stop. */
2088 chars_printed = ((chars_printed >> 3) + 1) << 3;
2094 *wrap_pointer++ = *lineptr;
2096 fputc_unfiltered (*lineptr, stream);
2101 if (chars_printed >= chars_per_line)
2103 unsigned int save_chars = chars_printed;
2107 /* If we aren't actually wrapping, don't output newline --
2108 if chars_per_line is right, we probably just overflowed
2109 anyway; if it's wrong, let us keep going. */
2111 fputc_unfiltered ('\n', stream);
2113 /* Possible new page. */
2114 if (lines_printed >= lines_per_page - 1)
2115 prompt_for_continue ();
2117 /* Now output indentation and wrapped string. */
2120 fputs_unfiltered (wrap_indent, stream);
2121 *wrap_pointer = '\0'; /* Null-terminate saved stuff, */
2122 fputs_unfiltered (wrap_buffer, stream); /* and eject it. */
2123 /* FIXME, this strlen is what prevents wrap_indent from
2124 containing tabs. However, if we recurse to print it
2125 and count its chars, we risk trouble if wrap_indent is
2126 longer than (the user settable) chars_per_line.
2127 Note also that this can set chars_printed > chars_per_line
2128 if we are printing a long string. */
2129 chars_printed = strlen (wrap_indent)
2130 + (save_chars - wrap_column);
2131 wrap_pointer = wrap_buffer; /* Reset buffer */
2132 wrap_buffer[0] = '\0';
2133 wrap_column = 0; /* And disable fancy wrap */
2138 if (*lineptr == '\n')
2141 wrap_here ((char *) 0); /* Spit out chars, cancel
2144 fputc_unfiltered ('\n', stream);
2151 fputs_filtered (const char *linebuffer, struct ui_file *stream)
2153 fputs_maybe_filtered (linebuffer, stream, 1);
2157 putchar_unfiltered (int c)
2161 ui_file_write (gdb_stdout, &buf, 1);
2165 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2166 May return nonlocally. */
2169 putchar_filtered (int c)
2171 return fputc_filtered (c, gdb_stdout);
2175 fputc_unfiltered (int c, struct ui_file *stream)
2179 ui_file_write (stream, &buf, 1);
2184 fputc_filtered (int c, struct ui_file *stream)
2190 fputs_filtered (buf, stream);
2194 /* puts_debug is like fputs_unfiltered, except it prints special
2195 characters in printable fashion. */
2198 puts_debug (char *prefix, char *string, char *suffix)
2202 /* Print prefix and suffix after each line. */
2203 static int new_line = 1;
2204 static int return_p = 0;
2205 static char *prev_prefix = "";
2206 static char *prev_suffix = "";
2208 if (*string == '\n')
2211 /* If the prefix is changing, print the previous suffix, a new line,
2212 and the new prefix. */
2213 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2215 fputs_unfiltered (prev_suffix, gdb_stdlog);
2216 fputs_unfiltered ("\n", gdb_stdlog);
2217 fputs_unfiltered (prefix, gdb_stdlog);
2220 /* Print prefix if we printed a newline during the previous call. */
2224 fputs_unfiltered (prefix, gdb_stdlog);
2227 prev_prefix = prefix;
2228 prev_suffix = suffix;
2230 /* Output characters in a printable format. */
2231 while ((ch = *string++) != '\0')
2237 fputc_unfiltered (ch, gdb_stdlog);
2240 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2244 fputs_unfiltered ("\\\\", gdb_stdlog);
2247 fputs_unfiltered ("\\b", gdb_stdlog);
2250 fputs_unfiltered ("\\f", gdb_stdlog);
2254 fputs_unfiltered ("\\n", gdb_stdlog);
2257 fputs_unfiltered ("\\r", gdb_stdlog);
2260 fputs_unfiltered ("\\t", gdb_stdlog);
2263 fputs_unfiltered ("\\v", gdb_stdlog);
2267 return_p = ch == '\r';
2270 /* Print suffix if we printed a newline. */
2273 fputs_unfiltered (suffix, gdb_stdlog);
2274 fputs_unfiltered ("\n", gdb_stdlog);
2279 /* Print a variable number of ARGS using format FORMAT. If this
2280 information is going to put the amount written (since the last call
2281 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2282 call prompt_for_continue to get the users permision to continue.
2284 Unlike fprintf, this function does not return a value.
2286 We implement three variants, vfprintf (takes a vararg list and stream),
2287 fprintf (takes a stream to write on), and printf (the usual).
2289 Note also that a longjmp to top level may occur in this routine
2290 (since prompt_for_continue may do so) so this routine should not be
2291 called when cleanups are not in place. */
2294 vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2295 va_list args, int filter)
2298 struct cleanup *old_cleanups;
2300 linebuffer = xstrvprintf (format, args);
2301 old_cleanups = make_cleanup (xfree, linebuffer);
2302 fputs_maybe_filtered (linebuffer, stream, filter);
2303 do_cleanups (old_cleanups);
2308 vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2310 vfprintf_maybe_filtered (stream, format, args, 1);
2314 vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2317 struct cleanup *old_cleanups;
2319 linebuffer = xstrvprintf (format, args);
2320 old_cleanups = make_cleanup (xfree, linebuffer);
2321 if (debug_timestamp && stream == gdb_stdlog)
2327 gettimeofday (&tm, NULL);
2329 len = strlen (linebuffer);
2330 need_nl = (len > 0 && linebuffer[len - 1] != '\n');
2332 timestamp = xstrprintf ("%ld:%ld %s%s",
2333 (long) tm.tv_sec, (long) tm.tv_usec,
2335 need_nl ? "\n": "");
2336 make_cleanup (xfree, timestamp);
2337 fputs_unfiltered (timestamp, stream);
2340 fputs_unfiltered (linebuffer, stream);
2341 do_cleanups (old_cleanups);
2345 vprintf_filtered (const char *format, va_list args)
2347 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2351 vprintf_unfiltered (const char *format, va_list args)
2353 vfprintf_unfiltered (gdb_stdout, format, args);
2357 fprintf_filtered (struct ui_file *stream, const char *format, ...)
2361 va_start (args, format);
2362 vfprintf_filtered (stream, format, args);
2367 fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2371 va_start (args, format);
2372 vfprintf_unfiltered (stream, format, args);
2376 /* Like fprintf_filtered, but prints its result indented.
2377 Called as fprintfi_filtered (spaces, stream, format, ...); */
2380 fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2385 va_start (args, format);
2386 print_spaces_filtered (spaces, stream);
2388 vfprintf_filtered (stream, format, args);
2394 printf_filtered (const char *format, ...)
2398 va_start (args, format);
2399 vfprintf_filtered (gdb_stdout, format, args);
2405 printf_unfiltered (const char *format, ...)
2409 va_start (args, format);
2410 vfprintf_unfiltered (gdb_stdout, format, args);
2414 /* Like printf_filtered, but prints it's result indented.
2415 Called as printfi_filtered (spaces, format, ...); */
2418 printfi_filtered (int spaces, const char *format, ...)
2422 va_start (args, format);
2423 print_spaces_filtered (spaces, gdb_stdout);
2424 vfprintf_filtered (gdb_stdout, format, args);
2428 /* Easy -- but watch out!
2430 This routine is *not* a replacement for puts()! puts() appends a newline.
2431 This one doesn't, and had better not! */
2434 puts_filtered (const char *string)
2436 fputs_filtered (string, gdb_stdout);
2440 puts_unfiltered (const char *string)
2442 fputs_unfiltered (string, gdb_stdout);
2445 /* Return a pointer to N spaces and a null. The pointer is good
2446 until the next call to here. */
2451 static char *spaces = 0;
2452 static int max_spaces = -1;
2458 spaces = (char *) xmalloc (n + 1);
2459 for (t = spaces + n; t != spaces;)
2465 return spaces + max_spaces - n;
2468 /* Print N spaces. */
2470 print_spaces_filtered (int n, struct ui_file *stream)
2472 fputs_filtered (n_spaces (n), stream);
2475 /* C++/ObjC demangler stuff. */
2477 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2478 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2479 If the name is not mangled, or the language for the name is unknown, or
2480 demangling is off, the name is printed in its "raw" form. */
2483 fprintf_symbol_filtered (struct ui_file *stream, const char *name,
2484 enum language lang, int arg_mode)
2490 /* If user wants to see raw output, no problem. */
2493 fputs_filtered (name, stream);
2497 demangled = language_demangle (language_def (lang), name, arg_mode);
2498 fputs_filtered (demangled ? demangled : name, stream);
2499 if (demangled != NULL)
2507 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2508 differences in whitespace. Returns 0 if they match, non-zero if they
2509 don't (slightly different than strcmp()'s range of return values).
2511 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2512 This "feature" is useful when searching for matching C++ function names
2513 (such as if the user types 'break FOO', where FOO is a mangled C++
2517 strcmp_iw (const char *string1, const char *string2)
2519 while ((*string1 != '\0') && (*string2 != '\0'))
2521 while (isspace (*string1))
2525 while (isspace (*string2))
2529 if (case_sensitivity == case_sensitive_on && *string1 != *string2)
2531 if (case_sensitivity == case_sensitive_off
2532 && (tolower ((unsigned char) *string1)
2533 != tolower ((unsigned char) *string2)))
2535 if (*string1 != '\0')
2541 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2544 /* This is like strcmp except that it ignores whitespace and treats
2545 '(' as the first non-NULL character in terms of ordering. Like
2546 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2547 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2548 according to that ordering.
2550 If a list is sorted according to this function and if you want to
2551 find names in the list that match some fixed NAME according to
2552 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2553 where this function would put NAME.
2555 This function must be neutral to the CASE_SENSITIVITY setting as the user
2556 may choose it during later lookup. Therefore this function always sorts
2557 primarily case-insensitively and secondarily case-sensitively.
2559 Here are some examples of why using strcmp to sort is a bad idea:
2563 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2564 we try to do a search for "foo<char*>", strcmp will locate this
2565 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2566 will start looking at strings beginning with "goo", and will never
2567 see the correct match of "foo<char *>".
2569 Parenthesis example:
2571 In practice, this is less like to be an issue, but I'll give it a
2572 shot. Let's assume that '$' is a legitimate character to occur in
2573 symbols. (Which may well even be the case on some systems.) Then
2574 say that the partial symbol table contains "foo$" and "foo(int)".
2575 strcmp will put them in this order, since '$' < '('. Now, if the
2576 user searches for "foo", then strcmp will sort "foo" before "foo$".
2577 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2578 "foo") is false, so it won't proceed to the actual match of
2579 "foo(int)" with "foo". */
2582 strcmp_iw_ordered (const char *string1, const char *string2)
2584 const char *saved_string1 = string1, *saved_string2 = string2;
2585 enum case_sensitivity case_pass = case_sensitive_off;
2589 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2590 Provide stub characters if we are already at the end of one of the
2592 char c1 = 'X', c2 = 'X';
2594 while (*string1 != '\0' && *string2 != '\0')
2596 while (isspace (*string1))
2598 while (isspace (*string2))
2603 case case_sensitive_off:
2604 c1 = tolower ((unsigned char) *string1);
2605 c2 = tolower ((unsigned char) *string2);
2607 case case_sensitive_on:
2615 if (*string1 != '\0')
2624 /* Characters are non-equal unless they're both '\0'; we want to
2625 make sure we get the comparison right according to our
2626 comparison in the cases where one of them is '\0' or '('. */
2628 if (*string2 == '\0')
2633 if (*string2 == '\0')
2638 if (*string2 == '\0' || *string2 == '(')
2647 if (case_pass == case_sensitive_on)
2650 /* Otherwise the strings were equal in case insensitive way, make
2651 a more fine grained comparison in a case sensitive way. */
2653 case_pass = case_sensitive_on;
2654 string1 = saved_string1;
2655 string2 = saved_string2;
2659 /* A simple comparison function with opposite semantics to strcmp. */
2662 streq (const char *lhs, const char *rhs)
2664 return !strcmp (lhs, rhs);
2670 ** Answer whether string_to_compare is a full or partial match to
2671 ** template_string. The partial match must be in sequence starting
2675 subset_compare (char *string_to_compare, char *template_string)
2679 if (template_string != (char *) NULL && string_to_compare != (char *) NULL
2680 && strlen (string_to_compare) <= strlen (template_string))
2683 (template_string, string_to_compare, strlen (string_to_compare)) == 0);
2690 pagination_on_command (char *arg, int from_tty)
2692 pagination_enabled = 1;
2696 pagination_off_command (char *arg, int from_tty)
2698 pagination_enabled = 0;
2702 show_debug_timestamp (struct ui_file *file, int from_tty,
2703 struct cmd_list_element *c, const char *value)
2705 fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"),
2711 initialize_utils (void)
2713 add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
2714 Set number of characters where GDB should wrap lines of its output."), _("\
2715 Show number of characters where GDB should wrap lines of its output."), _("\
2716 This affects where GDB wraps its output to fit the screen width.\n\
2717 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2719 show_chars_per_line,
2720 &setlist, &showlist);
2722 add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
2723 Set number of lines in a page for GDB output pagination."), _("\
2724 Show number of lines in a page for GDB output pagination."), _("\
2725 This affects the number of lines after which GDB will pause\n\
2726 its output and ask you whether to continue.\n\
2727 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2729 show_lines_per_page,
2730 &setlist, &showlist);
2734 add_setshow_boolean_cmd ("pagination", class_support,
2735 &pagination_enabled, _("\
2736 Set state of GDB output pagination."), _("\
2737 Show state of GDB output pagination."), _("\
2738 When pagination is ON, GDB pauses at end of each screenful of\n\
2739 its output and asks you whether to continue.\n\
2740 Turning pagination off is an alternative to \"set height unlimited\"."),
2742 show_pagination_enabled,
2743 &setlist, &showlist);
2747 add_com ("am", class_support, pagination_on_command,
2748 _("Enable pagination"));
2749 add_com ("sm", class_support, pagination_off_command,
2750 _("Disable pagination"));
2753 add_setshow_boolean_cmd ("sevenbit-strings", class_support,
2754 &sevenbit_strings, _("\
2755 Set printing of 8-bit characters in strings as \\nnn."), _("\
2756 Show printing of 8-bit characters in strings as \\nnn."), NULL,
2758 show_sevenbit_strings,
2759 &setprintlist, &showprintlist);
2761 add_setshow_boolean_cmd ("timestamp", class_maintenance,
2762 &debug_timestamp, _("\
2763 Set timestamping of debugging messages."), _("\
2764 Show timestamping of debugging messages."), _("\
2765 When set, debugging messages will be marked with seconds and microseconds."),
2767 show_debug_timestamp,
2768 &setdebuglist, &showdebuglist);
2772 paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
2774 /* Truncate address to the size of a target address, avoiding shifts
2775 larger or equal than the width of a CORE_ADDR. The local
2776 variable ADDR_BIT stops the compiler reporting a shift overflow
2777 when it won't occur. */
2778 /* NOTE: This assumes that the significant address information is
2779 kept in the least significant bits of ADDR - the upper bits were
2780 either zero or sign extended. Should gdbarch_address_to_pointer or
2781 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2783 int addr_bit = gdbarch_addr_bit (gdbarch);
2785 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2786 addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
2787 return hex_string (addr);
2790 /* This function is described in "defs.h". */
2793 print_core_address (struct gdbarch *gdbarch, CORE_ADDR address)
2795 int addr_bit = gdbarch_addr_bit (gdbarch);
2797 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2798 address &= ((CORE_ADDR) 1 << addr_bit) - 1;
2800 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2801 that returns the language localized string formatted to a width
2802 based on gdbarch_addr_bit. */
2804 return hex_string_custom (address, 8);
2806 return hex_string_custom (address, 16);
2809 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2812 core_addr_hash (const void *ap)
2814 const CORE_ADDR *addrp = ap;
2819 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2822 core_addr_eq (const void *ap, const void *bp)
2824 const CORE_ADDR *addr_ap = ap;
2825 const CORE_ADDR *addr_bp = bp;
2827 return *addr_ap == *addr_bp;
2830 /* Convert a string back into a CORE_ADDR. */
2832 string_to_core_addr (const char *my_string)
2836 if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
2838 /* Assume that it is in hex. */
2841 for (i = 2; my_string[i] != '\0'; i++)
2843 if (isdigit (my_string[i]))
2844 addr = (my_string[i] - '0') + (addr * 16);
2845 else if (isxdigit (my_string[i]))
2846 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
2848 error (_("invalid hex \"%s\""), my_string);
2853 /* Assume that it is in decimal. */
2856 for (i = 0; my_string[i] != '\0'; i++)
2858 if (isdigit (my_string[i]))
2859 addr = (my_string[i] - '0') + (addr * 10);
2861 error (_("invalid decimal \"%s\""), my_string);
2869 gdb_realpath (const char *filename)
2871 /* Method 1: The system has a compile time upper bound on a filename
2872 path. Use that and realpath() to canonicalize the name. This is
2873 the most common case. Note that, if there isn't a compile time
2874 upper bound, you want to avoid realpath() at all costs. */
2875 #if defined (HAVE_REALPATH) && defined (PATH_MAX)
2878 const char *rp = realpath (filename, buf);
2882 return xstrdup (rp);
2884 #endif /* HAVE_REALPATH */
2886 /* Method 2: The host system (i.e., GNU) has the function
2887 canonicalize_file_name() which malloc's a chunk of memory and
2888 returns that, use that. */
2889 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2891 char *rp = canonicalize_file_name (filename);
2894 return xstrdup (filename);
2900 /* FIXME: cagney/2002-11-13:
2902 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2903 to the problems described in method 3, have modified their
2904 realpath() implementation so that it will allocate a buffer when
2905 NULL is passed in. Before this can be used, though, some sort of
2906 configure time test would need to be added. Otherwize the code
2907 will likely core dump. */
2909 /* Method 3: Now we're getting desperate! The system doesn't have a
2910 compile time buffer size and no alternative function. Query the
2911 OS, using pathconf(), for the buffer limit. Care is needed
2912 though, some systems do not limit PATH_MAX (return -1 for
2913 pathconf()) making it impossible to pass a correctly sized buffer
2914 to realpath() (it could always overflow). On those systems, we
2916 #if defined (HAVE_REALPATH) && defined (_PC_PATH_MAX) && defined(HAVE_ALLOCA)
2918 /* Find out the max path size. */
2919 long path_max = pathconf ("/", _PC_PATH_MAX);
2923 /* PATH_MAX is bounded. */
2924 char *buf = alloca (path_max);
2925 char *rp = realpath (filename, buf);
2927 return xstrdup (rp ? rp : filename);
2932 /* The MS Windows method. If we don't have realpath, we assume we
2933 don't have symlinks and just canonicalize to a Windows absolute
2934 path. GetFullPath converts ../ and ./ in relative paths to
2935 absolute paths, filling in current drive if one is not given
2936 or using the current directory of a specified drive (eg, "E:foo").
2937 It also converts all forward slashes to back slashes. */
2938 /* The file system is case-insensitive but case-preserving.
2939 So we do not lowercase the path. Otherwise, we might not
2940 be able to display the original casing in a given path. */
2941 #if defined (_WIN32)
2944 DWORD len = GetFullPathName (filename, MAX_PATH, buf, NULL);
2946 if (len > 0 && len < MAX_PATH)
2947 return xstrdup (buf);
2951 /* This system is a lost cause, just dup the buffer. */
2952 return xstrdup (filename);
2955 /* Return a copy of FILENAME, with its directory prefix canonicalized
2959 gdb_realpath_keepfile (const char *filename)
2961 const char *base_name = lbasename (filename);
2966 /* Extract the basename of filename, and return immediately
2967 a copy of filename if it does not contain any directory prefix. */
2968 if (base_name == filename)
2969 return xstrdup (filename);
2971 dir_name = alloca ((size_t) (base_name - filename + 2));
2972 /* Allocate enough space to store the dir_name + plus one extra
2973 character sometimes needed under Windows (see below), and
2974 then the closing \000 character. */
2975 strncpy (dir_name, filename, base_name - filename);
2976 dir_name[base_name - filename] = '\000';
2978 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2979 /* We need to be careful when filename is of the form 'd:foo', which
2980 is equivalent of d:./foo, which is totally different from d:/foo. */
2981 if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
2984 dir_name[3] = '\000';
2988 /* Canonicalize the directory prefix, and build the resulting
2989 filename. If the dirname realpath already contains an ending
2990 directory separator, avoid doubling it. */
2991 real_path = gdb_realpath (dir_name);
2992 if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
2993 result = concat (real_path, base_name, (char *) NULL);
2995 result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
3001 /* Return PATH in absolute form, performing tilde-expansion if necessary.
3002 PATH cannot be NULL or the empty string.
3003 This does not resolve symlinks however, use gdb_realpath for that.
3004 Space for the result is allocated with malloc.
3005 If the path is already absolute, it is strdup'd.
3006 If there is a problem computing the absolute path, the path is returned
3007 unchanged (still strdup'd). */
3010 gdb_abspath (const char *path)
3012 gdb_assert (path != NULL && path[0] != '\0');
3015 return tilde_expand (path);
3017 if (IS_ABSOLUTE_PATH (path))
3018 return xstrdup (path);
3020 /* Beware the // my son, the Emacs barfs, the botch that catch... */
3021 return concat (current_directory,
3022 IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
3023 ? "" : SLASH_STRING,
3024 path, (char *) NULL);
3028 align_up (ULONGEST v, int n)
3030 /* Check that N is really a power of two. */
3031 gdb_assert (n && (n & (n-1)) == 0);
3032 return (v + n - 1) & -n;
3036 align_down (ULONGEST v, int n)
3038 /* Check that N is really a power of two. */
3039 gdb_assert (n && (n & (n-1)) == 0);
3046 gdb_sign_extend (LONGEST value, int bit)
3048 gdb_assert (bit >= 1 && bit <= 8 * sizeof (LONGEST));
3050 if (((value >> (bit - 1)) & 1) != 0)
3052 LONGEST signbit = ((LONGEST) 1) << (bit - 1);
3054 value = (value ^ signbit) - signbit;
3060 /* Allocation function for the libiberty hash table which uses an
3061 obstack. The obstack is passed as DATA. */
3064 hashtab_obstack_allocate (void *data, size_t size, size_t count)
3066 size_t total = size * count;
3067 void *ptr = obstack_alloc ((struct obstack *) data, total);
3069 memset (ptr, 0, total);
3073 /* Trivial deallocation function for the libiberty splay tree and hash
3074 table - don't deallocate anything. Rely on later deletion of the
3075 obstack. DATA will be the obstack, although it is not needed
3079 dummy_obstack_deallocate (void *object, void *data)
3084 /* The bit offset of the highest byte in a ULONGEST, for overflow
3087 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3089 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3090 where 2 <= BASE <= 36. */
3093 is_digit_in_base (unsigned char digit, int base)
3095 if (!isalnum (digit))
3098 return (isdigit (digit) && digit < base + '0');
3100 return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
3104 digit_to_int (unsigned char c)
3109 return tolower (c) - 'a' + 10;
3112 /* As for strtoul, but for ULONGEST results. */
3115 strtoulst (const char *num, const char **trailer, int base)
3117 unsigned int high_part;
3122 /* Skip leading whitespace. */
3123 while (isspace (num[i]))
3126 /* Handle prefixes. */
3129 else if (num[i] == '-')
3135 if (base == 0 || base == 16)
3137 if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X'))
3145 if (base == 0 && num[i] == '0')
3151 if (base < 2 || base > 36)
3157 result = high_part = 0;
3158 for (; is_digit_in_base (num[i], base); i += 1)
3160 result = result * base + digit_to_int (num[i]);
3161 high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN);
3162 result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
3163 if (high_part > 0xff)
3166 result = ~ (ULONGEST) 0;
3173 if (trailer != NULL)
3176 result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
3183 /* Simple, portable version of dirname that does not modify its
3187 ldirname (const char *filename)
3189 const char *base = lbasename (filename);
3192 while (base > filename && IS_DIR_SEPARATOR (base[-1]))
3195 if (base == filename)
3198 dirname = xmalloc (base - filename + 2);
3199 memcpy (dirname, filename, base - filename);
3201 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3202 create "d:./bar" later instead of the (different) "d:/bar". */
3203 if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
3204 && !IS_DIR_SEPARATOR (filename[0]))
3205 dirname[base++ - filename] = '.';
3207 dirname[base - filename] = '\0';
3211 /* Call libiberty's buildargv, and return the result.
3212 If buildargv fails due to out-of-memory, call nomem.
3213 Therefore, the returned value is guaranteed to be non-NULL,
3214 unless the parameter itself is NULL. */
3217 gdb_buildargv (const char *s)
3219 char **argv = buildargv (s);
3221 if (s != NULL && argv == NULL)
3227 compare_positive_ints (const void *ap, const void *bp)
3229 /* Because we know we're comparing two ints which are positive,
3230 there's no danger of overflow here. */
3231 return * (int *) ap - * (int *) bp;
3234 /* String compare function for qsort. */
3237 compare_strings (const void *arg1, const void *arg2)
3239 const char **s1 = (const char **) arg1;
3240 const char **s2 = (const char **) arg2;
3242 return strcmp (*s1, *s2);
3245 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3246 #define AMBIGUOUS_MESS2 \
3247 ".\nUse \"set gnutarget format-name\" to specify the format."
3250 gdb_bfd_errmsg (bfd_error_type error_tag, char **matching)
3256 /* Check if errmsg just need simple return. */
3257 if (error_tag != bfd_error_file_ambiguously_recognized || matching == NULL)
3258 return bfd_errmsg (error_tag);
3260 ret_len = strlen (bfd_errmsg (error_tag)) + strlen (AMBIGUOUS_MESS1)
3261 + strlen (AMBIGUOUS_MESS2);
3262 for (p = matching; *p; p++)
3263 ret_len += strlen (*p) + 1;
3264 ret = xmalloc (ret_len + 1);
3266 make_cleanup (xfree, ret);
3268 strcpy (retp, bfd_errmsg (error_tag));
3269 retp += strlen (retp);
3271 strcpy (retp, AMBIGUOUS_MESS1);
3272 retp += strlen (retp);
3274 for (p = matching; *p; p++)
3276 sprintf (retp, " %s", *p);
3277 retp += strlen (retp);
3281 strcpy (retp, AMBIGUOUS_MESS2);
3286 /* Return ARGS parsed as a valid pid, or throw an error. */
3289 parse_pid_to_attach (const char *args)
3295 error_no_arg (_("process-id to attach"));
3297 dummy = (char *) args;
3298 pid = strtoul (args, &dummy, 0);
3299 /* Some targets don't set errno on errors, grrr! */
3300 if ((pid == 0 && dummy == args) || dummy != &args[strlen (args)])
3301 error (_("Illegal process-id: %s."), args);
3306 /* Helper for make_bpstat_clear_actions_cleanup. */
3309 do_bpstat_clear_actions_cleanup (void *unused)
3311 bpstat_clear_actions ();
3314 /* Call bpstat_clear_actions for the case an exception is throw. You should
3315 discard_cleanups if no exception is caught. */
3318 make_bpstat_clear_actions_cleanup (void)
3320 return make_cleanup (do_bpstat_clear_actions_cleanup, NULL);
3323 /* Check for GCC >= 4.x according to the symtab->producer string. Return minor
3324 version (x) of 4.x in such case. If it is not GCC or it is GCC older than
3325 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
3328 producer_is_gcc_ge_4 (const char *producer)
3333 if (producer == NULL)
3335 /* For unknown compilers expect their behavior is not compliant. For GCC
3336 this case can also happen for -gdwarf-4 type units supported since
3342 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
3344 if (strncmp (producer, "GNU ", strlen ("GNU ")) != 0)
3346 /* For non-GCC compilers expect their behavior is not compliant. */
3350 cs = &producer[strlen ("GNU ")];
3351 while (*cs && !isdigit (*cs))
3353 if (sscanf (cs, "%d.%d", &major, &minor) != 2)
3355 /* Not recognized as GCC. */
3367 /* Helper for make_cleanup_free_char_ptr_vec. */
3370 do_free_char_ptr_vec (void *arg)
3372 VEC (char_ptr) *char_ptr_vec = arg;
3374 free_char_ptr_vec (char_ptr_vec);
3377 /* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
3378 final VEC_free for CHAR_PTR_VEC itself.
3380 You must not modify CHAR_PTR_VEC after this cleanup registration as the
3381 CHAR_PTR_VEC base address may change on its updates. Contrary to VEC_free
3382 this function does not (cannot) clear the pointer. */
3385 make_cleanup_free_char_ptr_vec (VEC (char_ptr) *char_ptr_vec)
3387 return make_cleanup (do_free_char_ptr_vec, char_ptr_vec);
3390 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3391 must come from xrealloc-compatible allocator and it may be updated. FROM
3392 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3393 located at the start or end of *STRINGP. */
3396 substitute_path_component (char **stringp, const char *from, const char *to)
3398 char *string = *stringp, *s;
3399 const size_t from_len = strlen (from);
3400 const size_t to_len = strlen (to);
3404 s = strstr (s, from);
3408 if ((s == string || IS_DIR_SEPARATOR (s[-1])
3409 || s[-1] == DIRNAME_SEPARATOR)
3410 && (s[from_len] == '\0' || IS_DIR_SEPARATOR (s[from_len])
3411 || s[from_len] == DIRNAME_SEPARATOR))
3415 string_new = xrealloc (string, (strlen (string) + to_len + 1));
3417 /* Relocate the current S pointer. */
3418 s = s - string + string_new;
3419 string = string_new;
3421 /* Replace from by to. */
3422 memmove (&s[to_len], &s[from_len], strlen (&s[from_len]) + 1);
3423 memcpy (s, to, to_len);
3438 /* SIGALRM handler for waitpid_with_timeout. */
3441 sigalrm_handler (int signo)
3443 /* Nothing to do. */
3448 /* Wrapper to wait for child PID to die with TIMEOUT.
3449 TIMEOUT is the time to stop waiting in seconds.
3450 If TIMEOUT is zero, pass WNOHANG to waitpid.
3451 Returns PID if it was successfully waited for, otherwise -1.
3453 Timeouts are currently implemented with alarm and SIGALRM.
3454 If the host does not support them, this waits "forever".
3455 It would be odd though for a host to have waitpid and not SIGALRM. */
3458 wait_to_die_with_timeout (pid_t pid, int *status, int timeout)
3460 pid_t waitpid_result;
3462 gdb_assert (pid > 0);
3463 gdb_assert (timeout >= 0);
3468 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3469 struct sigaction sa, old_sa;
3471 sa.sa_handler = sigalrm_handler;
3472 sigemptyset (&sa.sa_mask);
3474 sigaction (SIGALRM, &sa, &old_sa);
3478 ofunc = (void (*)()) signal (SIGALRM, sigalrm_handler);
3484 waitpid_result = waitpid (pid, status, 0);
3488 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3489 sigaction (SIGALRM, &old_sa, NULL);
3491 signal (SIGALRM, ofunc);
3496 waitpid_result = waitpid (pid, status, WNOHANG);
3498 if (waitpid_result == pid)
3504 #endif /* HAVE_WAITPID */
3506 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3507 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3509 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3510 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3513 gdb_filename_fnmatch (const char *pattern, const char *string, int flags)
3515 gdb_assert ((flags & FNM_FILE_NAME) != 0);
3517 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3518 gdb_assert ((flags & FNM_NOESCAPE) != 0);
3520 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3522 char *pattern_slash, *string_slash;
3524 /* Replace '\' by '/' in both strings. */
3526 pattern_slash = alloca (strlen (pattern) + 1);
3527 strcpy (pattern_slash, pattern);
3528 pattern = pattern_slash;
3529 for (; *pattern_slash != 0; pattern_slash++)
3530 if (IS_DIR_SEPARATOR (*pattern_slash))
3531 *pattern_slash = '/';
3533 string_slash = alloca (strlen (string) + 1);
3534 strcpy (string_slash, string);
3535 string = string_slash;
3536 for (; *string_slash != 0; string_slash++)
3537 if (IS_DIR_SEPARATOR (*string_slash))
3538 *string_slash = '/';
3540 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3542 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3543 flags |= FNM_CASEFOLD;
3544 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3546 return fnmatch (pattern, string, flags);
3549 /* Provide a prototype to silence -Wmissing-prototypes. */
3550 extern initialize_file_ftype _initialize_utils;
3553 _initialize_utils (void)
3555 add_internal_problem_command (&internal_error_problem);
3556 add_internal_problem_command (&internal_warning_problem);
3557 add_internal_problem_command (&demangler_warning_problem);