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 (sync_quit_force_run
)
1094 if (deprecated_interactive_hook
)
1095 deprecated_interactive_hook ();
1099 /* Called when a memory allocation fails, with the number of bytes of
1100 memory requested in SIZE. */
1103 malloc_failure (long size
)
1107 internal_error (__FILE__
, __LINE__
,
1108 _("virtual memory exhausted: can't allocate %ld bytes."),
1113 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
1117 /* My replacement for the read system call.
1118 Used like `read' but keeps going if `read' returns too soon. */
1121 myread (int desc
, char *addr
, int len
)
1128 val
= read (desc
, addr
, len
);
1132 return orglen
- len
;
1140 print_spaces (int n
, struct ui_file
*file
)
1142 fputs_unfiltered (n_spaces (n
), file
);
1145 /* Print a host address. */
1148 gdb_print_host_address_1 (const void *addr
, struct ui_file
*stream
)
1150 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
1156 make_hex_string (const gdb_byte
*data
, size_t length
)
1158 char *result
= (char *) xmalloc (length
* 2 + 1);
1163 for (i
= 0; i
< length
; ++i
)
1164 p
+= xsnprintf (p
, 3, "%02x", data
[i
]);
1171 /* A cleanup function that calls regfree. */
1174 do_regfree_cleanup (void *r
)
1176 regfree ((regex_t
*) r
);
1179 /* Create a new cleanup that frees the compiled regular expression R. */
1182 make_regfree_cleanup (regex_t
*r
)
1184 return make_cleanup (do_regfree_cleanup
, r
);
1187 /* Return an xmalloc'd error message resulting from a regular
1188 expression compilation failure. */
1191 get_regcomp_error (int code
, regex_t
*rx
)
1193 size_t length
= regerror (code
, rx
, NULL
, 0);
1194 char *result
= (char *) xmalloc (length
);
1196 regerror (code
, rx
, result
, length
);
1200 /* Compile a regexp and throw an exception on error. This returns a
1201 cleanup to free the resulting pattern on success. RX must not be
1205 compile_rx_or_error (regex_t
*pattern
, const char *rx
, const char *message
)
1209 gdb_assert (rx
!= NULL
);
1211 code
= regcomp (pattern
, rx
, REG_NOSUB
);
1214 char *err
= get_regcomp_error (code
, pattern
);
1216 make_cleanup (xfree
, err
);
1217 error (("%s: %s"), message
, err
);
1220 return make_regfree_cleanup (pattern
);
1225 /* This function supports the query, nquery, and yquery functions.
1226 Ask user a y-or-n question and return 0 if answer is no, 1 if
1227 answer is yes, or default the answer to the specified default
1228 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1229 default answer, or '\0' for no default.
1230 CTLSTR is the control string and should end in "? ". It should
1231 not say how to answer, because we do that.
1232 ARGS are the arguments passed along with the CTLSTR argument to
1235 static int ATTRIBUTE_PRINTF (1, 0)
1236 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1241 char def_answer
, not_def_answer
;
1242 char *y_string
, *n_string
, *question
, *prompt
;
1243 /* Used to add duration we waited for user to respond to
1244 prompt_for_continue_wait_time. */
1245 struct timeval prompt_started
, prompt_ended
, prompt_delta
;
1246 struct cleanup
*old_chain
;
1248 /* Set up according to which answer is the default. */
1249 if (defchar
== '\0')
1253 not_def_answer
= 'N';
1257 else if (defchar
== 'y')
1261 not_def_answer
= 'N';
1269 not_def_answer
= 'Y';
1274 /* Automatically answer the default value if the user did not want
1275 prompts or the command was issued with the server prefix. */
1276 if (!confirm
|| server_command
)
1279 old_chain
= make_cleanup_restore_target_terminal ();
1281 /* If input isn't coming from the user directly, just say what
1282 question we're asking, and then answer the default automatically. This
1283 way, important error messages don't get lost when talking to GDB
1285 if (! input_from_terminal_p ())
1287 target_terminal_ours_for_output ();
1289 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1291 printf_filtered (_("(%s or %s) [answered %c; "
1292 "input not from terminal]\n"),
1293 y_string
, n_string
, def_answer
);
1294 gdb_flush (gdb_stdout
);
1296 do_cleanups (old_chain
);
1300 if (deprecated_query_hook
)
1304 res
= deprecated_query_hook (ctlstr
, args
);
1305 do_cleanups (old_chain
);
1309 /* Format the question outside of the loop, to avoid reusing args. */
1310 question
= xstrvprintf (ctlstr
, args
);
1311 make_cleanup (xfree
, question
);
1312 prompt
= xstrprintf (_("%s%s(%s or %s) %s"),
1313 annotation_level
> 1 ? "\n\032\032pre-query\n" : "",
1314 question
, y_string
, n_string
,
1315 annotation_level
> 1 ? "\n\032\032query\n" : "");
1316 make_cleanup (xfree
, prompt
);
1318 /* Used for calculating time spend waiting for user. */
1319 gettimeofday (&prompt_started
, NULL
);
1321 /* We'll need to handle input. */
1322 target_terminal_ours ();
1323 make_cleanup_override_quit_handler (default_quit_handler
);
1327 char *response
, answer
;
1329 gdb_flush (gdb_stdout
);
1330 response
= gdb_readline_wrapper (prompt
);
1332 if (response
== NULL
) /* C-d */
1334 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1339 answer
= response
[0];
1344 /* Check answer. For the non-default, the user must specify
1345 the non-default explicitly. */
1346 if (answer
== not_def_answer
)
1348 retval
= !def_value
;
1351 /* Otherwise, if a default was specified, the user may either
1352 specify the required input or have it default by entering
1354 if (answer
== def_answer
1355 || (defchar
!= '\0' && answer
== '\0'))
1360 /* Invalid entries are not defaulted and require another selection. */
1361 printf_filtered (_("Please answer %s or %s.\n"),
1362 y_string
, n_string
);
1365 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1366 gettimeofday (&prompt_ended
, NULL
);
1367 timeval_sub (&prompt_delta
, &prompt_ended
, &prompt_started
);
1368 timeval_add (&prompt_for_continue_wait_time
,
1369 &prompt_for_continue_wait_time
, &prompt_delta
);
1371 if (annotation_level
> 1)
1372 printf_filtered (("\n\032\032post-query\n"));
1373 do_cleanups (old_chain
);
1378 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1379 answer is yes, or 0 if answer is defaulted.
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 nquery (const char *ctlstr
, ...)
1390 va_start (args
, ctlstr
);
1391 ret
= defaulted_query (ctlstr
, 'n', args
);
1396 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1397 answer is yes, or 1 if answer is defaulted.
1398 Takes three args which are given to printf to print the question.
1399 The first, a control string, should end in "? ".
1400 It should not say how to answer, because we do that. */
1403 yquery (const char *ctlstr
, ...)
1408 va_start (args
, ctlstr
);
1409 ret
= defaulted_query (ctlstr
, 'y', args
);
1414 /* Ask user a y-or-n question and return 1 iff answer is yes.
1415 Takes three args which are given to printf to print the question.
1416 The first, a control string, should end in "? ".
1417 It should not say how to answer, because we do that. */
1420 query (const char *ctlstr
, ...)
1425 va_start (args
, ctlstr
);
1426 ret
= defaulted_query (ctlstr
, '\0', args
);
1431 /* A helper for parse_escape that converts a host character to a
1432 target character. C is the host character. If conversion is
1433 possible, then the target character is stored in *TARGET_C and the
1434 function returns 1. Otherwise, the function returns 0. */
1437 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1439 struct obstack host_data
;
1441 struct cleanup
*cleanups
;
1444 obstack_init (&host_data
);
1445 cleanups
= make_cleanup_obstack_free (&host_data
);
1447 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1448 (gdb_byte
*) &the_char
, 1, 1,
1449 &host_data
, translit_none
);
1451 if (obstack_object_size (&host_data
) == 1)
1454 *target_c
= *(char *) obstack_base (&host_data
);
1457 do_cleanups (cleanups
);
1461 /* Parse a C escape sequence. STRING_PTR points to a variable
1462 containing a pointer to the string to parse. That pointer
1463 should point to the character after the \. That pointer
1464 is updated past the characters we use. The value of the
1465 escape sequence is returned.
1467 A negative value means the sequence \ newline was seen,
1468 which is supposed to be equivalent to nothing at all.
1470 If \ is followed by a null character, we return a negative
1471 value and leave the string pointer pointing at the null character.
1473 If \ is followed by 000, we return 0 and leave the string pointer
1474 after the zeros. A value of 0 does not mean end of string. */
1477 parse_escape (struct gdbarch
*gdbarch
, const char **string_ptr
)
1479 int target_char
= -2; /* Initialize to avoid GCC warnings. */
1480 int c
= *(*string_ptr
)++;
1499 int i
= host_hex_value (c
);
1504 if (isdigit (c
) && c
!= '8' && c
!= '9')
1508 i
+= host_hex_value (c
);
1544 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1545 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1546 " which has no equivalent\nin the `%s' character set."),
1547 c
, c
, target_charset (gdbarch
));
1551 /* Print the character C on STREAM as part of the contents of a literal
1552 string whose delimiter is QUOTER. Note that this routine should only
1553 be called for printing things which are independent of the language
1554 of the program being debugged.
1556 printchar will normally escape backslashes and instances of QUOTER. If
1557 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1558 As a side effect, if you pass the backslash character as the QUOTER,
1559 printchar will escape backslashes as usual, but not any other quoting
1563 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1564 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1565 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1567 c
&= 0xFF; /* Avoid sign bit follies */
1569 if (c
< 0x20 || /* Low control chars */
1570 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1571 (sevenbit_strings
&& c
>= 0x80))
1572 { /* high order bit set */
1576 do_fputs ("\\n", stream
);
1579 do_fputs ("\\b", stream
);
1582 do_fputs ("\\t", stream
);
1585 do_fputs ("\\f", stream
);
1588 do_fputs ("\\r", stream
);
1591 do_fputs ("\\e", stream
);
1594 do_fputs ("\\a", stream
);
1597 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1603 if (quoter
!= 0 && (c
== '\\' || c
== quoter
))
1604 do_fputs ("\\", stream
);
1605 do_fprintf (stream
, "%c", c
);
1609 /* Print the character C on STREAM as part of the contents of a
1610 literal string whose delimiter is QUOTER. Note that these routines
1611 should only be call for printing things which are independent of
1612 the language of the program being debugged. */
1615 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1618 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1622 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1625 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1629 fputstrn_filtered (const char *str
, int n
, int quoter
,
1630 struct ui_file
*stream
)
1634 for (i
= 0; i
< n
; i
++)
1635 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1639 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1640 struct ui_file
*stream
)
1644 for (i
= 0; i
< n
; i
++)
1645 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1649 /* Number of lines per page or UINT_MAX if paging is disabled. */
1650 static unsigned int lines_per_page
;
1652 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1653 struct cmd_list_element
*c
, const char *value
)
1655 fprintf_filtered (file
,
1656 _("Number of lines gdb thinks are in a page is %s.\n"),
1660 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1661 static unsigned int chars_per_line
;
1663 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1664 struct cmd_list_element
*c
, const char *value
)
1666 fprintf_filtered (file
,
1667 _("Number of characters gdb thinks "
1668 "are in a line is %s.\n"),
1672 /* Current count of lines printed on this page, chars on this line. */
1673 static unsigned int lines_printed
, chars_printed
;
1675 /* Buffer and start column of buffered text, for doing smarter word-
1676 wrapping. When someone calls wrap_here(), we start buffering output
1677 that comes through fputs_filtered(). If we see a newline, we just
1678 spit it out and forget about the wrap_here(). If we see another
1679 wrap_here(), we spit it out and remember the newer one. If we see
1680 the end of the line, we spit out a newline, the indent, and then
1681 the buffered output. */
1683 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1684 are waiting to be output (they have already been counted in chars_printed).
1685 When wrap_buffer[0] is null, the buffer is empty. */
1686 static char *wrap_buffer
;
1688 /* Pointer in wrap_buffer to the next character to fill. */
1689 static char *wrap_pointer
;
1691 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1693 static char *wrap_indent
;
1695 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1696 is not in effect. */
1697 static int wrap_column
;
1700 /* Inialize the number of lines per page and chars per line. */
1703 init_page_info (void)
1707 lines_per_page
= UINT_MAX
;
1708 chars_per_line
= UINT_MAX
;
1712 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1717 #if defined(__GO32__)
1718 rows
= ScreenRows ();
1719 cols
= ScreenCols ();
1720 lines_per_page
= rows
;
1721 chars_per_line
= cols
;
1723 /* Make sure Readline has initialized its terminal settings. */
1724 rl_reset_terminal (NULL
);
1726 /* Get the screen size from Readline. */
1727 rl_get_screen_size (&rows
, &cols
);
1728 lines_per_page
= rows
;
1729 chars_per_line
= cols
;
1731 /* Readline should have fetched the termcap entry for us.
1732 Only try to use tgetnum function if rl_get_screen_size
1733 did not return a useful value. */
1734 if (((rows
<= 0) && (tgetnum ("li") < 0))
1735 /* Also disable paging if inside Emacs. $EMACS was used
1736 before Emacs v25.1, $INSIDE_EMACS is used since then. */
1737 || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1739 /* The number of lines per page is not mentioned in the terminal
1740 description or EMACS evironment variable is set. This probably
1741 means that paging is not useful, so disable paging. */
1742 lines_per_page
= UINT_MAX
;
1745 /* If the output is not a terminal, don't paginate it. */
1746 if (!ui_file_isatty (gdb_stdout
))
1747 lines_per_page
= UINT_MAX
;
1751 /* We handle SIGWINCH ourselves. */
1752 rl_catch_sigwinch
= 0;
1758 /* Return nonzero if filtered printing is initialized. */
1760 filtered_printing_initialized (void)
1762 return wrap_buffer
!= NULL
;
1765 /* Helper for make_cleanup_restore_page_info. */
1768 do_restore_page_info_cleanup (void *arg
)
1774 /* Provide cleanup for restoring the terminal size. */
1777 make_cleanup_restore_page_info (void)
1779 struct cleanup
*back_to
;
1781 back_to
= make_cleanup (do_restore_page_info_cleanup
, NULL
);
1782 make_cleanup_restore_uinteger (&lines_per_page
);
1783 make_cleanup_restore_uinteger (&chars_per_line
);
1788 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1789 Provide cleanup for restoring the original state. */
1792 set_batch_flag_and_make_cleanup_restore_page_info (void)
1794 struct cleanup
*back_to
= make_cleanup_restore_page_info ();
1796 make_cleanup_restore_integer (&batch_flag
);
1803 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1806 set_screen_size (void)
1808 int rows
= lines_per_page
;
1809 int cols
= chars_per_line
;
1817 /* Update Readline's idea of the terminal size. */
1818 rl_set_screen_size (rows
, cols
);
1821 /* Reinitialize WRAP_BUFFER according to the current value of
1827 if (chars_per_line
== 0)
1832 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1833 wrap_buffer
[0] = '\0';
1836 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1837 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1841 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1848 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1856 set_screen_width_and_height (int width
, int height
)
1858 lines_per_page
= height
;
1859 chars_per_line
= width
;
1865 /* Wait, so the user can read what's on the screen. Prompt the user
1866 to continue by pressing RETURN. 'q' is also provided because
1867 telling users what to do in the prompt is more user-friendly than
1868 expecting them to think of Ctrl-C/SIGINT. */
1871 prompt_for_continue (void)
1874 char cont_prompt
[120];
1875 /* Used to add duration we waited for user to respond to
1876 prompt_for_continue_wait_time. */
1877 struct timeval prompt_started
, prompt_ended
, prompt_delta
;
1878 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1880 gettimeofday (&prompt_started
, NULL
);
1882 if (annotation_level
> 1)
1883 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1885 strcpy (cont_prompt
,
1886 "---Type <return> to continue, or q <return> to quit---");
1887 if (annotation_level
> 1)
1888 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1890 /* We must do this *before* we call gdb_readline_wrapper, else it
1891 will eventually call us -- thinking that we're trying to print
1892 beyond the end of the screen. */
1893 reinitialize_more_filter ();
1895 /* We'll need to handle input. */
1896 make_cleanup_restore_target_terminal ();
1897 target_terminal_ours ();
1898 make_cleanup_override_quit_handler (default_quit_handler
);
1900 /* Call gdb_readline_wrapper, not readline, in order to keep an
1901 event loop running. */
1902 ignore
= gdb_readline_wrapper (cont_prompt
);
1903 make_cleanup (xfree
, ignore
);
1905 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1906 gettimeofday (&prompt_ended
, NULL
);
1907 timeval_sub (&prompt_delta
, &prompt_ended
, &prompt_started
);
1908 timeval_add (&prompt_for_continue_wait_time
,
1909 &prompt_for_continue_wait_time
, &prompt_delta
);
1911 if (annotation_level
> 1)
1912 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1918 while (*p
== ' ' || *p
== '\t')
1921 /* Do not call quit here; there is no possibility of SIGINT. */
1922 throw_quit ("Quit");
1925 /* Now we have to do this again, so that GDB will know that it doesn't
1926 need to save the ---Type <return>--- line at the top of the screen. */
1927 reinitialize_more_filter ();
1929 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1931 do_cleanups (old_chain
);
1934 /* Initalize timer to keep track of how long we waited for the user. */
1937 reset_prompt_for_continue_wait_time (void)
1939 static const struct timeval zero_timeval
= { 0 };
1941 prompt_for_continue_wait_time
= zero_timeval
;
1944 /* Fetch the cumulative time spent in prompt_for_continue. */
1947 get_prompt_for_continue_wait_time (void)
1949 return prompt_for_continue_wait_time
;
1952 /* Reinitialize filter; ie. tell it to reset to original values. */
1955 reinitialize_more_filter (void)
1961 /* Indicate that if the next sequence of characters overflows the line,
1962 a newline should be inserted here rather than when it hits the end.
1963 If INDENT is non-null, it is a string to be printed to indent the
1964 wrapped part on the next line. INDENT must remain accessible until
1965 the next call to wrap_here() or until a newline is printed through
1968 If the line is already overfull, we immediately print a newline and
1969 the indentation, and disable further wrapping.
1971 If we don't know the width of lines, but we know the page height,
1972 we must not wrap words, but should still keep track of newlines
1973 that were explicitly printed.
1975 INDENT should not contain tabs, as that will mess up the char count
1976 on the next line. FIXME.
1978 This routine is guaranteed to force out any output which has been
1979 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1980 used to force out output from the wrap_buffer. */
1983 wrap_here (char *indent
)
1985 /* This should have been allocated, but be paranoid anyway. */
1987 internal_error (__FILE__
, __LINE__
,
1988 _("failed internal consistency check"));
1992 *wrap_pointer
= '\0';
1993 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1995 wrap_pointer
= wrap_buffer
;
1996 wrap_buffer
[0] = '\0';
1997 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
2001 else if (chars_printed
>= chars_per_line
)
2003 puts_filtered ("\n");
2005 puts_filtered (indent
);
2010 wrap_column
= chars_printed
;
2014 wrap_indent
= indent
;
2018 /* Print input string to gdb_stdout, filtered, with wrap,
2019 arranging strings in columns of n chars. String can be
2020 right or left justified in the column. Never prints
2021 trailing spaces. String should never be longer than
2022 width. FIXME: this could be useful for the EXAMINE
2023 command, which currently doesn't tabulate very well. */
2026 puts_filtered_tabular (char *string
, int width
, int right
)
2032 gdb_assert (chars_per_line
> 0);
2033 if (chars_per_line
== UINT_MAX
)
2035 fputs_filtered (string
, gdb_stdout
);
2036 fputs_filtered ("\n", gdb_stdout
);
2040 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
2041 fputs_filtered ("\n", gdb_stdout
);
2043 if (width
>= chars_per_line
)
2044 width
= chars_per_line
- 1;
2046 stringlen
= strlen (string
);
2048 if (chars_printed
> 0)
2049 spaces
= width
- (chars_printed
- 1) % width
- 1;
2051 spaces
+= width
- stringlen
;
2053 spacebuf
= (char *) alloca (spaces
+ 1);
2054 spacebuf
[spaces
] = '\0';
2056 spacebuf
[spaces
] = ' ';
2058 fputs_filtered (spacebuf
, gdb_stdout
);
2059 fputs_filtered (string
, gdb_stdout
);
2063 /* Ensure that whatever gets printed next, using the filtered output
2064 commands, starts at the beginning of the line. I.e. if there is
2065 any pending output for the current line, flush it and start a new
2066 line. Otherwise do nothing. */
2071 if (chars_printed
> 0)
2073 puts_filtered ("\n");
2078 /* Like fputs but if FILTER is true, pause after every screenful.
2080 Regardless of FILTER can wrap at points other than the final
2081 character of a line.
2083 Unlike fputs, fputs_maybe_filtered does not return a value.
2084 It is OK for LINEBUFFER to be NULL, in which case just don't print
2087 Note that a longjmp to top level may occur in this routine (only if
2088 FILTER is true) (since prompt_for_continue may do so) so this
2089 routine should not be called when cleanups are not in place. */
2092 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
2095 const char *lineptr
;
2097 if (linebuffer
== 0)
2100 /* Don't do any filtering if it is disabled. */
2101 if (stream
!= gdb_stdout
2102 || !pagination_enabled
2104 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
2105 || top_level_interpreter () == NULL
2106 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2108 fputs_unfiltered (linebuffer
, stream
);
2112 /* Go through and output each character. Show line extension
2113 when this is necessary; prompt user for new page when this is
2116 lineptr
= linebuffer
;
2119 /* Possible new page. */
2120 if (filter
&& (lines_printed
>= lines_per_page
- 1))
2121 prompt_for_continue ();
2123 while (*lineptr
&& *lineptr
!= '\n')
2125 /* Print a single line. */
2126 if (*lineptr
== '\t')
2129 *wrap_pointer
++ = '\t';
2131 fputc_unfiltered ('\t', stream
);
2132 /* Shifting right by 3 produces the number of tab stops
2133 we have already passed, and then adding one and
2134 shifting left 3 advances to the next tab stop. */
2135 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2141 *wrap_pointer
++ = *lineptr
;
2143 fputc_unfiltered (*lineptr
, stream
);
2148 if (chars_printed
>= chars_per_line
)
2150 unsigned int save_chars
= chars_printed
;
2154 /* If we aren't actually wrapping, don't output newline --
2155 if chars_per_line is right, we probably just overflowed
2156 anyway; if it's wrong, let us keep going. */
2158 fputc_unfiltered ('\n', stream
);
2160 /* Possible new page. */
2161 if (lines_printed
>= lines_per_page
- 1)
2162 prompt_for_continue ();
2164 /* Now output indentation and wrapped string. */
2167 fputs_unfiltered (wrap_indent
, stream
);
2168 *wrap_pointer
= '\0'; /* Null-terminate saved stuff, */
2169 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it. */
2170 /* FIXME, this strlen is what prevents wrap_indent from
2171 containing tabs. However, if we recurse to print it
2172 and count its chars, we risk trouble if wrap_indent is
2173 longer than (the user settable) chars_per_line.
2174 Note also that this can set chars_printed > chars_per_line
2175 if we are printing a long string. */
2176 chars_printed
= strlen (wrap_indent
)
2177 + (save_chars
- wrap_column
);
2178 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2179 wrap_buffer
[0] = '\0';
2180 wrap_column
= 0; /* And disable fancy wrap */
2185 if (*lineptr
== '\n')
2188 wrap_here ((char *) 0); /* Spit out chars, cancel
2191 fputc_unfiltered ('\n', stream
);
2198 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2200 fputs_maybe_filtered (linebuffer
, stream
, 1);
2204 putchar_unfiltered (int c
)
2208 ui_file_write (gdb_stdout
, &buf
, 1);
2212 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2213 May return nonlocally. */
2216 putchar_filtered (int c
)
2218 return fputc_filtered (c
, gdb_stdout
);
2222 fputc_unfiltered (int c
, struct ui_file
*stream
)
2226 ui_file_write (stream
, &buf
, 1);
2231 fputc_filtered (int c
, struct ui_file
*stream
)
2237 fputs_filtered (buf
, stream
);
2241 /* puts_debug is like fputs_unfiltered, except it prints special
2242 characters in printable fashion. */
2245 puts_debug (char *prefix
, char *string
, char *suffix
)
2249 /* Print prefix and suffix after each line. */
2250 static int new_line
= 1;
2251 static int return_p
= 0;
2252 static char *prev_prefix
= "";
2253 static char *prev_suffix
= "";
2255 if (*string
== '\n')
2258 /* If the prefix is changing, print the previous suffix, a new line,
2259 and the new prefix. */
2260 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2262 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2263 fputs_unfiltered ("\n", gdb_stdlog
);
2264 fputs_unfiltered (prefix
, gdb_stdlog
);
2267 /* Print prefix if we printed a newline during the previous call. */
2271 fputs_unfiltered (prefix
, gdb_stdlog
);
2274 prev_prefix
= prefix
;
2275 prev_suffix
= suffix
;
2277 /* Output characters in a printable format. */
2278 while ((ch
= *string
++) != '\0')
2284 fputc_unfiltered (ch
, gdb_stdlog
);
2287 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2291 fputs_unfiltered ("\\\\", gdb_stdlog
);
2294 fputs_unfiltered ("\\b", gdb_stdlog
);
2297 fputs_unfiltered ("\\f", gdb_stdlog
);
2301 fputs_unfiltered ("\\n", gdb_stdlog
);
2304 fputs_unfiltered ("\\r", gdb_stdlog
);
2307 fputs_unfiltered ("\\t", gdb_stdlog
);
2310 fputs_unfiltered ("\\v", gdb_stdlog
);
2314 return_p
= ch
== '\r';
2317 /* Print suffix if we printed a newline. */
2320 fputs_unfiltered (suffix
, gdb_stdlog
);
2321 fputs_unfiltered ("\n", gdb_stdlog
);
2326 /* Print a variable number of ARGS using format FORMAT. If this
2327 information is going to put the amount written (since the last call
2328 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2329 call prompt_for_continue to get the users permision to continue.
2331 Unlike fprintf, this function does not return a value.
2333 We implement three variants, vfprintf (takes a vararg list and stream),
2334 fprintf (takes a stream to write on), and printf (the usual).
2336 Note also that a longjmp to top level may occur in this routine
2337 (since prompt_for_continue may do so) so this routine should not be
2338 called when cleanups are not in place. */
2341 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2342 va_list args
, int filter
)
2345 struct cleanup
*old_cleanups
;
2347 linebuffer
= xstrvprintf (format
, args
);
2348 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2349 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2350 do_cleanups (old_cleanups
);
2355 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2357 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2361 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2364 struct cleanup
*old_cleanups
;
2366 linebuffer
= xstrvprintf (format
, args
);
2367 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2368 if (debug_timestamp
&& stream
== gdb_stdlog
)
2374 gettimeofday (&tm
, NULL
);
2376 len
= strlen (linebuffer
);
2377 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2379 timestamp
= xstrprintf ("%ld:%ld %s%s",
2380 (long) tm
.tv_sec
, (long) tm
.tv_usec
,
2382 need_nl
? "\n": "");
2383 make_cleanup (xfree
, timestamp
);
2384 fputs_unfiltered (timestamp
, stream
);
2387 fputs_unfiltered (linebuffer
, stream
);
2388 do_cleanups (old_cleanups
);
2392 vprintf_filtered (const char *format
, va_list args
)
2394 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2398 vprintf_unfiltered (const char *format
, va_list args
)
2400 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2404 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2408 va_start (args
, format
);
2409 vfprintf_filtered (stream
, format
, args
);
2414 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2418 va_start (args
, format
);
2419 vfprintf_unfiltered (stream
, format
, args
);
2423 /* Like fprintf_filtered, but prints its result indented.
2424 Called as fprintfi_filtered (spaces, stream, format, ...); */
2427 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2432 va_start (args
, format
);
2433 print_spaces_filtered (spaces
, stream
);
2435 vfprintf_filtered (stream
, format
, args
);
2441 printf_filtered (const char *format
, ...)
2445 va_start (args
, format
);
2446 vfprintf_filtered (gdb_stdout
, format
, args
);
2452 printf_unfiltered (const char *format
, ...)
2456 va_start (args
, format
);
2457 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2461 /* Like printf_filtered, but prints it's result indented.
2462 Called as printfi_filtered (spaces, format, ...); */
2465 printfi_filtered (int spaces
, const char *format
, ...)
2469 va_start (args
, format
);
2470 print_spaces_filtered (spaces
, gdb_stdout
);
2471 vfprintf_filtered (gdb_stdout
, format
, args
);
2475 /* Easy -- but watch out!
2477 This routine is *not* a replacement for puts()! puts() appends a newline.
2478 This one doesn't, and had better not! */
2481 puts_filtered (const char *string
)
2483 fputs_filtered (string
, gdb_stdout
);
2487 puts_unfiltered (const char *string
)
2489 fputs_unfiltered (string
, gdb_stdout
);
2492 /* Return a pointer to N spaces and a null. The pointer is good
2493 until the next call to here. */
2498 static char *spaces
= 0;
2499 static int max_spaces
= -1;
2505 spaces
= (char *) xmalloc (n
+ 1);
2506 for (t
= spaces
+ n
; t
!= spaces
;)
2512 return spaces
+ max_spaces
- n
;
2515 /* Print N spaces. */
2517 print_spaces_filtered (int n
, struct ui_file
*stream
)
2519 fputs_filtered (n_spaces (n
), stream
);
2522 /* C++/ObjC demangler stuff. */
2524 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2525 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2526 If the name is not mangled, or the language for the name is unknown, or
2527 demangling is off, the name is printed in its "raw" form. */
2530 fprintf_symbol_filtered (struct ui_file
*stream
, const char *name
,
2531 enum language lang
, int arg_mode
)
2537 /* If user wants to see raw output, no problem. */
2540 fputs_filtered (name
, stream
);
2544 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2545 fputs_filtered (demangled
? demangled
: name
, stream
);
2546 if (demangled
!= NULL
)
2554 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2555 differences in whitespace. Returns 0 if they match, non-zero if they
2556 don't (slightly different than strcmp()'s range of return values).
2558 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2559 This "feature" is useful when searching for matching C++ function names
2560 (such as if the user types 'break FOO', where FOO is a mangled C++
2564 strcmp_iw (const char *string1
, const char *string2
)
2566 while ((*string1
!= '\0') && (*string2
!= '\0'))
2568 while (isspace (*string1
))
2572 while (isspace (*string2
))
2576 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
2578 if (case_sensitivity
== case_sensitive_off
2579 && (tolower ((unsigned char) *string1
)
2580 != tolower ((unsigned char) *string2
)))
2582 if (*string1
!= '\0')
2588 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2591 /* This is like strcmp except that it ignores whitespace and treats
2592 '(' as the first non-NULL character in terms of ordering. Like
2593 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2594 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2595 according to that ordering.
2597 If a list is sorted according to this function and if you want to
2598 find names in the list that match some fixed NAME according to
2599 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2600 where this function would put NAME.
2602 This function must be neutral to the CASE_SENSITIVITY setting as the user
2603 may choose it during later lookup. Therefore this function always sorts
2604 primarily case-insensitively and secondarily case-sensitively.
2606 Here are some examples of why using strcmp to sort is a bad idea:
2610 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2611 we try to do a search for "foo<char*>", strcmp will locate this
2612 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2613 will start looking at strings beginning with "goo", and will never
2614 see the correct match of "foo<char *>".
2616 Parenthesis example:
2618 In practice, this is less like to be an issue, but I'll give it a
2619 shot. Let's assume that '$' is a legitimate character to occur in
2620 symbols. (Which may well even be the case on some systems.) Then
2621 say that the partial symbol table contains "foo$" and "foo(int)".
2622 strcmp will put them in this order, since '$' < '('. Now, if the
2623 user searches for "foo", then strcmp will sort "foo" before "foo$".
2624 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2625 "foo") is false, so it won't proceed to the actual match of
2626 "foo(int)" with "foo". */
2629 strcmp_iw_ordered (const char *string1
, const char *string2
)
2631 const char *saved_string1
= string1
, *saved_string2
= string2
;
2632 enum case_sensitivity case_pass
= case_sensitive_off
;
2636 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2637 Provide stub characters if we are already at the end of one of the
2639 char c1
= 'X', c2
= 'X';
2641 while (*string1
!= '\0' && *string2
!= '\0')
2643 while (isspace (*string1
))
2645 while (isspace (*string2
))
2650 case case_sensitive_off
:
2651 c1
= tolower ((unsigned char) *string1
);
2652 c2
= tolower ((unsigned char) *string2
);
2654 case case_sensitive_on
:
2662 if (*string1
!= '\0')
2671 /* Characters are non-equal unless they're both '\0'; we want to
2672 make sure we get the comparison right according to our
2673 comparison in the cases where one of them is '\0' or '('. */
2675 if (*string2
== '\0')
2680 if (*string2
== '\0')
2685 if (*string2
== '\0' || *string2
== '(')
2694 if (case_pass
== case_sensitive_on
)
2697 /* Otherwise the strings were equal in case insensitive way, make
2698 a more fine grained comparison in a case sensitive way. */
2700 case_pass
= case_sensitive_on
;
2701 string1
= saved_string1
;
2702 string2
= saved_string2
;
2706 /* A simple comparison function with opposite semantics to strcmp. */
2709 streq (const char *lhs
, const char *rhs
)
2711 return !strcmp (lhs
, rhs
);
2717 ** Answer whether string_to_compare is a full or partial match to
2718 ** template_string. The partial match must be in sequence starting
2722 subset_compare (char *string_to_compare
, char *template_string
)
2726 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2727 && strlen (string_to_compare
) <= strlen (template_string
))
2729 (startswith (template_string
, string_to_compare
));
2736 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2737 struct cmd_list_element
*c
, const char *value
)
2739 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
2745 initialize_utils (void)
2747 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2748 Set number of characters where GDB should wrap lines of its output."), _("\
2749 Show number of characters where GDB should wrap lines of its output."), _("\
2750 This affects where GDB wraps its output to fit the screen width.\n\
2751 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2753 show_chars_per_line
,
2754 &setlist
, &showlist
);
2756 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2757 Set number of lines in a page for GDB output pagination."), _("\
2758 Show number of lines in a page for GDB output pagination."), _("\
2759 This affects the number of lines after which GDB will pause\n\
2760 its output and ask you whether to continue.\n\
2761 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2763 show_lines_per_page
,
2764 &setlist
, &showlist
);
2766 add_setshow_boolean_cmd ("pagination", class_support
,
2767 &pagination_enabled
, _("\
2768 Set state of GDB output pagination."), _("\
2769 Show state of GDB output pagination."), _("\
2770 When pagination is ON, GDB pauses at end of each screenful of\n\
2771 its output and asks you whether to continue.\n\
2772 Turning pagination off is an alternative to \"set height unlimited\"."),
2774 show_pagination_enabled
,
2775 &setlist
, &showlist
);
2777 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2778 &sevenbit_strings
, _("\
2779 Set printing of 8-bit characters in strings as \\nnn."), _("\
2780 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2782 show_sevenbit_strings
,
2783 &setprintlist
, &showprintlist
);
2785 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2786 &debug_timestamp
, _("\
2787 Set timestamping of debugging messages."), _("\
2788 Show timestamping of debugging messages."), _("\
2789 When set, debugging messages will be marked with seconds and microseconds."),
2791 show_debug_timestamp
,
2792 &setdebuglist
, &showdebuglist
);
2796 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2798 /* Truncate address to the size of a target address, avoiding shifts
2799 larger or equal than the width of a CORE_ADDR. The local
2800 variable ADDR_BIT stops the compiler reporting a shift overflow
2801 when it won't occur. */
2802 /* NOTE: This assumes that the significant address information is
2803 kept in the least significant bits of ADDR - the upper bits were
2804 either zero or sign extended. Should gdbarch_address_to_pointer or
2805 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2807 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2809 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2810 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2811 return hex_string (addr
);
2814 /* This function is described in "defs.h". */
2817 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2819 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2821 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2822 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2824 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2825 that returns the language localized string formatted to a width
2826 based on gdbarch_addr_bit. */
2828 return hex_string_custom (address
, 8);
2830 return hex_string_custom (address
, 16);
2833 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2836 core_addr_hash (const void *ap
)
2838 const CORE_ADDR
*addrp
= (const CORE_ADDR
*) ap
;
2843 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2846 core_addr_eq (const void *ap
, const void *bp
)
2848 const CORE_ADDR
*addr_ap
= (const CORE_ADDR
*) ap
;
2849 const CORE_ADDR
*addr_bp
= (const CORE_ADDR
*) bp
;
2851 return *addr_ap
== *addr_bp
;
2854 /* Convert a string back into a CORE_ADDR. */
2856 string_to_core_addr (const char *my_string
)
2860 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2862 /* Assume that it is in hex. */
2865 for (i
= 2; my_string
[i
] != '\0'; i
++)
2867 if (isdigit (my_string
[i
]))
2868 addr
= (my_string
[i
] - '0') + (addr
* 16);
2869 else if (isxdigit (my_string
[i
]))
2870 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2872 error (_("invalid hex \"%s\""), my_string
);
2877 /* Assume that it is in decimal. */
2880 for (i
= 0; my_string
[i
] != '\0'; i
++)
2882 if (isdigit (my_string
[i
]))
2883 addr
= (my_string
[i
] - '0') + (addr
* 10);
2885 error (_("invalid decimal \"%s\""), my_string
);
2893 gdb_realpath (const char *filename
)
2895 /* On most hosts, we rely on canonicalize_file_name to compute
2896 the FILENAME's realpath.
2898 But the situation is slightly more complex on Windows, due to some
2899 versions of GCC which were reported to generate paths where
2900 backlashes (the directory separator) were doubled. For instance:
2901 c:\\some\\double\\slashes\\dir
2903 c:\some\double\slashes\dir
2904 Those double-slashes were getting in the way when comparing paths,
2905 for instance when trying to insert a breakpoint as follow:
2906 (gdb) b c:/some/double/slashes/dir/foo.c:4
2907 No source file named c:/some/double/slashes/dir/foo.c:4.
2908 (gdb) b c:\some\double\slashes\dir\foo.c:4
2909 No source file named c:\some\double\slashes\dir\foo.c:4.
2910 To prevent this from happening, we need this function to always
2911 strip those extra backslashes. While canonicalize_file_name does
2912 perform this simplification, it only works when the path is valid.
2913 Since the simplification would be useful even if the path is not
2914 valid (one can always set a breakpoint on a file, even if the file
2915 does not exist locally), we rely instead on GetFullPathName to
2916 perform the canonicalization. */
2918 #if defined (_WIN32)
2921 DWORD len
= GetFullPathName (filename
, MAX_PATH
, buf
, NULL
);
2923 /* The file system is case-insensitive but case-preserving.
2924 So it is important we do not lowercase the path. Otherwise,
2925 we might not be able to display the original casing in a given
2927 if (len
> 0 && len
< MAX_PATH
)
2928 return xstrdup (buf
);
2932 char *rp
= canonicalize_file_name (filename
);
2939 /* This system is a lost cause, just dup the buffer. */
2940 return xstrdup (filename
);
2943 /* Return a copy of FILENAME, with its directory prefix canonicalized
2947 gdb_realpath_keepfile (const char *filename
)
2949 const char *base_name
= lbasename (filename
);
2954 /* Extract the basename of filename, and return immediately
2955 a copy of filename if it does not contain any directory prefix. */
2956 if (base_name
== filename
)
2957 return xstrdup (filename
);
2959 dir_name
= (char *) alloca ((size_t) (base_name
- filename
+ 2));
2960 /* Allocate enough space to store the dir_name + plus one extra
2961 character sometimes needed under Windows (see below), and
2962 then the closing \000 character. */
2963 strncpy (dir_name
, filename
, base_name
- filename
);
2964 dir_name
[base_name
- filename
] = '\000';
2966 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2967 /* We need to be careful when filename is of the form 'd:foo', which
2968 is equivalent of d:./foo, which is totally different from d:/foo. */
2969 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
2972 dir_name
[3] = '\000';
2976 /* Canonicalize the directory prefix, and build the resulting
2977 filename. If the dirname realpath already contains an ending
2978 directory separator, avoid doubling it. */
2979 real_path
= gdb_realpath (dir_name
);
2980 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2981 result
= concat (real_path
, base_name
, (char *) NULL
);
2983 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *) NULL
);
2989 /* Return PATH in absolute form, performing tilde-expansion if necessary.
2990 PATH cannot be NULL or the empty string.
2991 This does not resolve symlinks however, use gdb_realpath for that.
2992 Space for the result is allocated with malloc.
2993 If the path is already absolute, it is strdup'd.
2994 If there is a problem computing the absolute path, the path is returned
2995 unchanged (still strdup'd). */
2998 gdb_abspath (const char *path
)
3000 gdb_assert (path
!= NULL
&& path
[0] != '\0');
3003 return tilde_expand (path
);
3005 if (IS_ABSOLUTE_PATH (path
))
3006 return xstrdup (path
);
3008 /* Beware the // my son, the Emacs barfs, the botch that catch... */
3009 return concat (current_directory
,
3010 IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1])
3011 ? "" : SLASH_STRING
,
3012 path
, (char *) NULL
);
3016 align_up (ULONGEST v
, int n
)
3018 /* Check that N is really a power of two. */
3019 gdb_assert (n
&& (n
& (n
-1)) == 0);
3020 return (v
+ n
- 1) & -n
;
3024 align_down (ULONGEST v
, int n
)
3026 /* Check that N is really a power of two. */
3027 gdb_assert (n
&& (n
& (n
-1)) == 0);
3031 /* Allocation function for the libiberty hash table which uses an
3032 obstack. The obstack is passed as DATA. */
3035 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3037 size_t total
= size
* count
;
3038 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3040 memset (ptr
, 0, total
);
3044 /* Trivial deallocation function for the libiberty splay tree and hash
3045 table - don't deallocate anything. Rely on later deletion of the
3046 obstack. DATA will be the obstack, although it is not needed
3050 dummy_obstack_deallocate (void *object
, void *data
)
3055 /* Simple, portable version of dirname that does not modify its
3059 ldirname (const char *filename
)
3061 const char *base
= lbasename (filename
);
3064 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3067 if (base
== filename
)
3070 dirname
= (char *) xmalloc (base
- filename
+ 2);
3071 memcpy (dirname
, filename
, base
- filename
);
3073 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3074 create "d:./bar" later instead of the (different) "d:/bar". */
3075 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3076 && !IS_DIR_SEPARATOR (filename
[0]))
3077 dirname
[base
++ - filename
] = '.';
3079 dirname
[base
- filename
] = '\0';
3083 /* Call libiberty's buildargv, and return the result.
3084 If buildargv fails due to out-of-memory, call nomem.
3085 Therefore, the returned value is guaranteed to be non-NULL,
3086 unless the parameter itself is NULL. */
3089 gdb_buildargv (const char *s
)
3091 char **argv
= buildargv (s
);
3093 if (s
!= NULL
&& argv
== NULL
)
3099 compare_positive_ints (const void *ap
, const void *bp
)
3101 /* Because we know we're comparing two ints which are positive,
3102 there's no danger of overflow here. */
3103 return * (int *) ap
- * (int *) bp
;
3106 /* String compare function for qsort. */
3109 compare_strings (const void *arg1
, const void *arg2
)
3111 const char **s1
= (const char **) arg1
;
3112 const char **s2
= (const char **) arg2
;
3114 return strcmp (*s1
, *s2
);
3117 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3118 #define AMBIGUOUS_MESS2 \
3119 ".\nUse \"set gnutarget format-name\" to specify the format."
3122 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
3128 /* Check if errmsg just need simple return. */
3129 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
3130 return bfd_errmsg (error_tag
);
3132 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
3133 + strlen (AMBIGUOUS_MESS2
);
3134 for (p
= matching
; *p
; p
++)
3135 ret_len
+= strlen (*p
) + 1;
3136 ret
= (char *) xmalloc (ret_len
+ 1);
3138 make_cleanup (xfree
, ret
);
3140 strcpy (retp
, bfd_errmsg (error_tag
));
3141 retp
+= strlen (retp
);
3143 strcpy (retp
, AMBIGUOUS_MESS1
);
3144 retp
+= strlen (retp
);
3146 for (p
= matching
; *p
; p
++)
3148 sprintf (retp
, " %s", *p
);
3149 retp
+= strlen (retp
);
3153 strcpy (retp
, AMBIGUOUS_MESS2
);
3158 /* Return ARGS parsed as a valid pid, or throw an error. */
3161 parse_pid_to_attach (const char *args
)
3167 error_no_arg (_("process-id to attach"));
3169 dummy
= (char *) args
;
3170 pid
= strtoul (args
, &dummy
, 0);
3171 /* Some targets don't set errno on errors, grrr! */
3172 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
3173 error (_("Illegal process-id: %s."), args
);
3178 /* Helper for make_bpstat_clear_actions_cleanup. */
3181 do_bpstat_clear_actions_cleanup (void *unused
)
3183 bpstat_clear_actions ();
3186 /* Call bpstat_clear_actions for the case an exception is throw. You should
3187 discard_cleanups if no exception is caught. */
3190 make_bpstat_clear_actions_cleanup (void)
3192 return make_cleanup (do_bpstat_clear_actions_cleanup
, NULL
);
3195 /* Check for GCC >= 4.x according to the symtab->producer string. Return minor
3196 version (x) of 4.x in such case. If it is not GCC or it is GCC older than
3197 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
3200 producer_is_gcc_ge_4 (const char *producer
)
3204 if (! producer_is_gcc (producer
, &major
, &minor
))
3213 /* Returns nonzero if the given PRODUCER string is GCC and sets the MAJOR
3214 and MINOR versions when not NULL. Returns zero if the given PRODUCER
3215 is NULL or it isn't GCC. */
3218 producer_is_gcc (const char *producer
, int *major
, int *minor
)
3222 if (producer
!= NULL
&& startswith (producer
, "GNU "))
3231 /* Skip any identifier after "GNU " - such as "C11" "C++" or "Java".
3232 A full producer string might look like:
3234 "GNU Fortran 4.8.2 20140120 (Red Hat 4.8.2-16) -mtune=generic ..."
3235 "GNU C++14 5.0.0 20150123 (experimental)"
3237 cs
= &producer
[strlen ("GNU ")];
3238 while (*cs
&& !isspace (*cs
))
3240 if (*cs
&& isspace (*cs
))
3242 if (sscanf (cs
, "%d.%d", major
, minor
) == 2)
3246 /* Not recognized as GCC. */
3250 /* Helper for make_cleanup_free_char_ptr_vec. */
3253 do_free_char_ptr_vec (void *arg
)
3255 VEC (char_ptr
) *char_ptr_vec
= (VEC (char_ptr
) *) arg
;
3257 free_char_ptr_vec (char_ptr_vec
);
3260 /* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
3261 final VEC_free for CHAR_PTR_VEC itself.
3263 You must not modify CHAR_PTR_VEC after this cleanup registration as the
3264 CHAR_PTR_VEC base address may change on its updates. Contrary to VEC_free
3265 this function does not (cannot) clear the pointer. */
3268 make_cleanup_free_char_ptr_vec (VEC (char_ptr
) *char_ptr_vec
)
3270 return make_cleanup (do_free_char_ptr_vec
, char_ptr_vec
);
3273 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3274 must come from xrealloc-compatible allocator and it may be updated. FROM
3275 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3276 located at the start or end of *STRINGP. */
3279 substitute_path_component (char **stringp
, const char *from
, const char *to
)
3281 char *string
= *stringp
, *s
;
3282 const size_t from_len
= strlen (from
);
3283 const size_t to_len
= strlen (to
);
3287 s
= strstr (s
, from
);
3291 if ((s
== string
|| IS_DIR_SEPARATOR (s
[-1])
3292 || s
[-1] == DIRNAME_SEPARATOR
)
3293 && (s
[from_len
] == '\0' || IS_DIR_SEPARATOR (s
[from_len
])
3294 || s
[from_len
] == DIRNAME_SEPARATOR
))
3299 = (char *) xrealloc (string
, (strlen (string
) + to_len
+ 1));
3301 /* Relocate the current S pointer. */
3302 s
= s
- string
+ string_new
;
3303 string
= string_new
;
3305 /* Replace from by to. */
3306 memmove (&s
[to_len
], &s
[from_len
], strlen (&s
[from_len
]) + 1);
3307 memcpy (s
, to
, to_len
);
3322 /* SIGALRM handler for waitpid_with_timeout. */
3325 sigalrm_handler (int signo
)
3327 /* Nothing to do. */
3332 /* Wrapper to wait for child PID to die with TIMEOUT.
3333 TIMEOUT is the time to stop waiting in seconds.
3334 If TIMEOUT is zero, pass WNOHANG to waitpid.
3335 Returns PID if it was successfully waited for, otherwise -1.
3337 Timeouts are currently implemented with alarm and SIGALRM.
3338 If the host does not support them, this waits "forever".
3339 It would be odd though for a host to have waitpid and not SIGALRM. */
3342 wait_to_die_with_timeout (pid_t pid
, int *status
, int timeout
)
3344 pid_t waitpid_result
;
3346 gdb_assert (pid
> 0);
3347 gdb_assert (timeout
>= 0);
3352 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3353 struct sigaction sa
, old_sa
;
3355 sa
.sa_handler
= sigalrm_handler
;
3356 sigemptyset (&sa
.sa_mask
);
3358 sigaction (SIGALRM
, &sa
, &old_sa
);
3362 ofunc
= signal (SIGALRM
, sigalrm_handler
);
3368 waitpid_result
= waitpid (pid
, status
, 0);
3372 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3373 sigaction (SIGALRM
, &old_sa
, NULL
);
3375 signal (SIGALRM
, ofunc
);
3380 waitpid_result
= waitpid (pid
, status
, WNOHANG
);
3382 if (waitpid_result
== pid
)
3388 #endif /* HAVE_WAITPID */
3390 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3391 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3393 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3394 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3397 gdb_filename_fnmatch (const char *pattern
, const char *string
, int flags
)
3399 gdb_assert ((flags
& FNM_FILE_NAME
) != 0);
3401 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3402 gdb_assert ((flags
& FNM_NOESCAPE
) != 0);
3404 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3406 char *pattern_slash
, *string_slash
;
3408 /* Replace '\' by '/' in both strings. */
3410 pattern_slash
= (char *) alloca (strlen (pattern
) + 1);
3411 strcpy (pattern_slash
, pattern
);
3412 pattern
= pattern_slash
;
3413 for (; *pattern_slash
!= 0; pattern_slash
++)
3414 if (IS_DIR_SEPARATOR (*pattern_slash
))
3415 *pattern_slash
= '/';
3417 string_slash
= (char *) alloca (strlen (string
) + 1);
3418 strcpy (string_slash
, string
);
3419 string
= string_slash
;
3420 for (; *string_slash
!= 0; string_slash
++)
3421 if (IS_DIR_SEPARATOR (*string_slash
))
3422 *string_slash
= '/';
3424 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3426 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3427 flags
|= FNM_CASEFOLD
;
3428 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3430 return fnmatch (pattern
, string
, flags
);
3433 /* Return the number of path elements in PATH.
3441 count_path_elements (const char *path
)
3444 const char *p
= path
;
3446 if (HAS_DRIVE_SPEC (p
))
3448 p
= STRIP_DRIVE_SPEC (p
);
3454 if (IS_DIR_SEPARATOR (*p
))
3459 /* Backup one if last character is /, unless it's the only one. */
3460 if (p
> path
+ 1 && IS_DIR_SEPARATOR (p
[-1]))
3463 /* Add one for the file name, if present. */
3464 if (p
> path
&& !IS_DIR_SEPARATOR (p
[-1]))
3470 /* Remove N leading path elements from PATH.
3471 N must be non-negative.
3472 If PATH has more than N path elements then return NULL.
3473 If PATH has exactly N path elements then return "".
3474 See count_path_elements for a description of how we do the counting. */
3477 strip_leading_path_elements (const char *path
, int n
)
3480 const char *p
= path
;
3482 gdb_assert (n
>= 0);
3487 if (HAS_DRIVE_SPEC (p
))
3489 p
= STRIP_DRIVE_SPEC (p
);
3495 while (*p
!= '\0' && !IS_DIR_SEPARATOR (*p
))
3510 /* Provide a prototype to silence -Wmissing-prototypes. */
3511 extern initialize_file_ftype _initialize_utils
;
3514 _initialize_utils (void)
3516 add_internal_problem_command (&internal_error_problem
);
3517 add_internal_problem_command (&internal_warning_problem
);
3518 add_internal_problem_command (&demangler_warning_problem
);