1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "dyn-string.h"
24 #include "event-top.h"
25 #include "gdbthread.h"
28 #ifdef HAVE_SYS_RESOURCE_H
29 #include <sys/resource.h>
30 #endif /* HAVE_SYS_RESOURCE_H */
33 #include "tui/tui.h" /* For tui_get_command_dimension. */
41 #include "timeval-utils.h"
46 #include "gdb-demangle.h"
47 #include "expression.h"
51 #include "filenames.h"
53 #include "gdb_obstack.h"
59 #include "inferior.h" /* for signed_pointer_to_address */
61 #include "gdb_curses.h"
63 #include "readline/readline.h"
65 #include "gdb_sys_time.h"
68 #include "gdb_usleep.h"
70 #include "gdb_regex.h"
73 extern PTR
malloc (); /* ARI: PTR */
75 #if !HAVE_DECL_REALLOC
76 extern PTR
realloc (); /* ARI: PTR */
82 void (*deprecated_error_begin_hook
) (void);
84 /* Prototypes for local functions */
86 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
87 va_list, int) ATTRIBUTE_PRINTF (2, 0);
89 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
91 static void prompt_for_continue (void);
93 static void set_screen_size (void);
94 static void set_width (void);
96 /* Time spent in prompt_for_continue in the currently executing command
97 waiting for user to respond.
98 Initialized in make_command_stats_cleanup.
99 Modified in prompt_for_continue and defaulted_query.
100 Used in report_command_stats. */
102 static struct timeval prompt_for_continue_wait_time
;
104 /* A flag indicating whether to timestamp debugging messages. */
106 static int debug_timestamp
= 0;
108 /* Nonzero if we have job control. */
112 /* Nonzero means quit immediately if Control-C is typed now, rather
113 than waiting until QUIT is executed. Be careful in setting this;
114 code which executes with immediate_quit set has to be very careful
115 about being able to deal with being interrupted at any time. It is
116 almost always better to use QUIT; the only exception I can think of
117 is being able to quit out of a system call (using EINTR loses if
118 the SIGINT happens between the previous QUIT and the system call).
119 To immediately quit in the case in which a SIGINT happens between
120 the previous QUIT and setting immediate_quit (desirable anytime we
121 expect to block), call QUIT after setting immediate_quit. */
125 /* Nonzero means that strings with character values >0x7F should be printed
126 as octal escapes. Zero means just print the value (e.g. it's an
127 international character, and the terminal or window can cope.) */
129 int sevenbit_strings
= 0;
131 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
132 struct cmd_list_element
*c
, const char *value
)
134 fprintf_filtered (file
, _("Printing of 8-bit characters "
135 "in strings as \\nnn is %s.\n"),
139 /* String to be printed before warning messages, if any. */
141 char *warning_pre_print
= "\nwarning: ";
143 int pagination_enabled
= 1;
145 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
146 struct cmd_list_element
*c
, const char *value
)
148 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
152 /* Cleanup utilities.
154 These are not defined in cleanups.c (nor declared in cleanups.h)
155 because while they use the "cleanup API" they are not part of the
159 do_freeargv (void *arg
)
161 freeargv ((char **) arg
);
165 make_cleanup_freeargv (char **arg
)
167 return make_cleanup (do_freeargv
, arg
);
171 do_dyn_string_delete (void *arg
)
173 dyn_string_delete ((dyn_string_t
) arg
);
177 make_cleanup_dyn_string_delete (dyn_string_t arg
)
179 return make_cleanup (do_dyn_string_delete
, arg
);
183 do_bfd_close_cleanup (void *arg
)
185 gdb_bfd_unref ((bfd
*) arg
);
189 make_cleanup_bfd_unref (bfd
*abfd
)
191 return make_cleanup (do_bfd_close_cleanup
, abfd
);
194 /* Helper function which does the work for make_cleanup_fclose. */
197 do_fclose_cleanup (void *arg
)
199 FILE *file
= (FILE *) arg
;
204 /* Return a new cleanup that closes FILE. */
207 make_cleanup_fclose (FILE *file
)
209 return make_cleanup (do_fclose_cleanup
, file
);
212 /* Helper function which does the work for make_cleanup_obstack_free. */
215 do_obstack_free (void *arg
)
217 struct obstack
*ob
= (struct obstack
*) arg
;
219 obstack_free (ob
, NULL
);
222 /* Return a new cleanup that frees OBSTACK. */
225 make_cleanup_obstack_free (struct obstack
*obstack
)
227 return make_cleanup (do_obstack_free
, obstack
);
231 do_ui_file_delete (void *arg
)
233 ui_file_delete ((struct ui_file
*) arg
);
237 make_cleanup_ui_file_delete (struct ui_file
*arg
)
239 return make_cleanup (do_ui_file_delete
, arg
);
242 /* Helper function for make_cleanup_ui_out_redirect_pop. */
245 do_ui_out_redirect_pop (void *arg
)
247 struct ui_out
*uiout
= (struct ui_out
*) arg
;
249 if (ui_out_redirect (uiout
, NULL
) < 0)
250 warning (_("Cannot restore redirection of the current output protocol"));
253 /* Return a new cleanup that pops the last redirection by ui_out_redirect
254 with NULL parameter. */
257 make_cleanup_ui_out_redirect_pop (struct ui_out
*uiout
)
259 return make_cleanup (do_ui_out_redirect_pop
, uiout
);
263 do_free_section_addr_info (void *arg
)
265 free_section_addr_info ((struct section_addr_info
*) arg
);
269 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
271 return make_cleanup (do_free_section_addr_info
, addrs
);
274 struct restore_integer_closure
281 restore_integer (void *p
)
283 struct restore_integer_closure
*closure
284 = (struct restore_integer_closure
*) p
;
286 *(closure
->variable
) = closure
->value
;
289 /* Remember the current value of *VARIABLE and make it restored when
290 the cleanup is run. */
293 make_cleanup_restore_integer (int *variable
)
295 struct restore_integer_closure
*c
= XNEW (struct restore_integer_closure
);
297 c
->variable
= variable
;
298 c
->value
= *variable
;
300 return make_cleanup_dtor (restore_integer
, (void *) c
, xfree
);
303 /* Remember the current value of *VARIABLE and make it restored when
304 the cleanup is run. */
307 make_cleanup_restore_uinteger (unsigned int *variable
)
309 return make_cleanup_restore_integer ((int *) variable
);
312 /* Helper for make_cleanup_unpush_target. */
315 do_unpush_target (void *arg
)
317 struct target_ops
*ops
= (struct target_ops
*) arg
;
322 /* Return a new cleanup that unpushes OPS. */
325 make_cleanup_unpush_target (struct target_ops
*ops
)
327 return make_cleanup (do_unpush_target
, ops
);
330 /* Helper for make_cleanup_htab_delete compile time checking the types. */
333 do_htab_delete_cleanup (void *htab_voidp
)
335 htab_t htab
= (htab_t
) htab_voidp
;
340 /* Return a new cleanup that deletes HTAB. */
343 make_cleanup_htab_delete (htab_t htab
)
345 return make_cleanup (do_htab_delete_cleanup
, htab
);
348 struct restore_ui_out_closure
350 struct ui_out
**variable
;
351 struct ui_out
*value
;
355 do_restore_ui_out (void *p
)
357 struct restore_ui_out_closure
*closure
358 = (struct restore_ui_out_closure
*) p
;
360 *(closure
->variable
) = closure
->value
;
363 /* Remember the current value of *VARIABLE and make it restored when
364 the cleanup is run. */
367 make_cleanup_restore_ui_out (struct ui_out
**variable
)
369 struct restore_ui_out_closure
*c
= XNEW (struct restore_ui_out_closure
);
371 c
->variable
= variable
;
372 c
->value
= *variable
;
374 return make_cleanup_dtor (do_restore_ui_out
, (void *) c
, xfree
);
377 struct restore_ui_file_closure
379 struct ui_file
**variable
;
380 struct ui_file
*value
;
384 do_restore_ui_file (void *p
)
386 struct restore_ui_file_closure
*closure
387 = (struct restore_ui_file_closure
*) p
;
389 *(closure
->variable
) = closure
->value
;
392 /* Remember the current value of *VARIABLE and make it restored when
393 the cleanup is run. */
396 make_cleanup_restore_ui_file (struct ui_file
**variable
)
398 struct restore_ui_file_closure
*c
= XNEW (struct restore_ui_file_closure
);
400 c
->variable
= variable
;
401 c
->value
= *variable
;
403 return make_cleanup_dtor (do_restore_ui_file
, (void *) c
, xfree
);
406 /* Helper for make_cleanup_value_free_to_mark. */
409 do_value_free_to_mark (void *value
)
411 value_free_to_mark ((struct value
*) value
);
414 /* Free all values allocated since MARK was obtained by value_mark
415 (except for those released) when the cleanup is run. */
418 make_cleanup_value_free_to_mark (struct value
*mark
)
420 return make_cleanup (do_value_free_to_mark
, mark
);
423 /* Helper for make_cleanup_value_free. */
426 do_value_free (void *value
)
428 value_free ((struct value
*) value
);
434 make_cleanup_value_free (struct value
*value
)
436 return make_cleanup (do_value_free
, value
);
439 /* Helper for make_cleanup_free_so. */
442 do_free_so (void *arg
)
444 struct so_list
*so
= (struct so_list
*) arg
;
449 /* Make cleanup handler calling free_so for SO. */
452 make_cleanup_free_so (struct so_list
*so
)
454 return make_cleanup (do_free_so
, so
);
457 /* Helper for make_cleanup_restore_current_language. */
460 do_restore_current_language (void *p
)
462 enum language saved_lang
= (enum language
) (uintptr_t) p
;
464 set_language (saved_lang
);
467 /* Remember the current value of CURRENT_LANGUAGE and make it restored when
468 the cleanup is run. */
471 make_cleanup_restore_current_language (void)
473 enum language saved_lang
= current_language
->la_language
;
475 return make_cleanup (do_restore_current_language
,
476 (void *) (uintptr_t) saved_lang
);
479 /* Helper function for make_cleanup_clear_parser_state. */
482 do_clear_parser_state (void *ptr
)
484 struct parser_state
**p
= (struct parser_state
**) ptr
;
489 /* Clean (i.e., set to NULL) the parser state variable P. */
492 make_cleanup_clear_parser_state (struct parser_state
**p
)
494 return make_cleanup (do_clear_parser_state
, (void *) p
);
497 /* This function is useful for cleanups.
501 old_chain = make_cleanup (free_current_contents, &foo);
503 to arrange to free the object thus allocated. */
506 free_current_contents (void *ptr
)
508 void **location
= (void **) ptr
;
510 if (location
== NULL
)
511 internal_error (__FILE__
, __LINE__
,
512 _("free_current_contents: NULL pointer"));
513 if (*location
!= NULL
)
522 /* Print a warning message. The first argument STRING is the warning
523 message, used as an fprintf format string, the second is the
524 va_list of arguments for that string. A warning is unfiltered (not
525 paginated) so that the user does not need to page through each
526 screen full of warnings when there are lots of them. */
529 vwarning (const char *string
, va_list args
)
531 if (deprecated_warning_hook
)
532 (*deprecated_warning_hook
) (string
, args
);
535 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
537 if (target_supports_terminal_ours ())
539 make_cleanup_restore_target_terminal ();
540 target_terminal_ours_for_output ();
542 if (filtered_printing_initialized ())
543 wrap_here (""); /* Force out any buffered output. */
544 gdb_flush (gdb_stdout
);
545 if (warning_pre_print
)
546 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
547 vfprintf_unfiltered (gdb_stderr
, string
, args
);
548 fprintf_unfiltered (gdb_stderr
, "\n");
550 do_cleanups (old_chain
);
554 /* Print an error message and return to command level.
555 The first argument STRING is the error message, used as a fprintf string,
556 and the remaining args are passed as arguments to it. */
559 verror (const char *string
, va_list args
)
561 throw_verror (GENERIC_ERROR
, string
, args
);
565 error_stream (struct ui_file
*stream
)
567 char *message
= ui_file_xstrdup (stream
, NULL
);
569 make_cleanup (xfree
, message
);
570 error (("%s"), message
);
573 /* Emit a message and abort. */
575 static void ATTRIBUTE_NORETURN
576 abort_with_message (const char *msg
)
578 if (gdb_stderr
== NULL
)
581 fputs_unfiltered (msg
, gdb_stderr
);
583 abort (); /* NOTE: GDB has only three calls to abort(). */
586 /* Dump core trying to increase the core soft limit to hard limit first. */
591 #ifdef HAVE_SETRLIMIT
592 struct rlimit rlim
= { RLIM_INFINITY
, RLIM_INFINITY
};
594 setrlimit (RLIMIT_CORE
, &rlim
);
595 #endif /* HAVE_SETRLIMIT */
597 abort (); /* NOTE: GDB has only three calls to abort(). */
600 /* Check whether GDB will be able to dump core using the dump_core
601 function. Returns zero if GDB cannot or should not dump core.
602 If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected.
603 If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */
606 can_dump_core (enum resource_limit_kind limit_kind
)
608 #ifdef HAVE_GETRLIMIT
611 /* Be quiet and assume we can dump if an error is returned. */
612 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
618 if (rlim
.rlim_cur
== 0)
622 if (rlim
.rlim_max
== 0)
625 #endif /* HAVE_GETRLIMIT */
630 /* Print a warning that we cannot dump core. */
633 warn_cant_dump_core (const char *reason
)
635 fprintf_unfiltered (gdb_stderr
,
636 _("%s\nUnable to dump core, use `ulimit -c"
637 " unlimited' before executing GDB next time.\n"),
641 /* Check whether GDB will be able to dump core using the dump_core
642 function, and print a warning if we cannot. */
645 can_dump_core_warn (enum resource_limit_kind limit_kind
,
648 int core_dump_allowed
= can_dump_core (limit_kind
);
650 if (!core_dump_allowed
)
651 warn_cant_dump_core (reason
);
653 return core_dump_allowed
;
656 /* Allow the user to configure the debugger behavior with respect to
657 what to do when an internal problem is detected. */
659 const char internal_problem_ask
[] = "ask";
660 const char internal_problem_yes
[] = "yes";
661 const char internal_problem_no
[] = "no";
662 static const char *const internal_problem_modes
[] =
664 internal_problem_ask
,
665 internal_problem_yes
,
670 /* Print a message reporting an internal error/warning. Ask the user
671 if they want to continue, dump core, or just exit. Return
672 something to indicate a quit. */
674 struct internal_problem
677 int user_settable_should_quit
;
678 const char *should_quit
;
679 int user_settable_should_dump_core
;
680 const char *should_dump_core
;
683 /* Report a problem, internal to GDB, to the user. Once the problem
684 has been reported, and assuming GDB didn't quit, the caller can
685 either allow execution to resume or throw an error. */
687 static void ATTRIBUTE_PRINTF (4, 0)
688 internal_vproblem (struct internal_problem
*problem
,
689 const char *file
, int line
, const char *fmt
, va_list ap
)
695 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
697 /* Don't allow infinite error/warning recursion. */
699 static char msg
[] = "Recursive internal problem.\n";
708 abort_with_message (msg
);
711 /* Newer GLIBC versions put the warn_unused_result attribute
712 on write, but this is one of those rare cases where
713 ignoring the return value is correct. Casting to (void)
714 does not fix this problem. This is the solution suggested
715 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
716 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
717 abort (); /* NOTE: GDB has only three calls to abort(). */
722 /* Create a string containing the full error/warning message. Need
723 to call query with this full string, as otherwize the reason
724 (error/warning) and question become separated. Format using a
725 style similar to a compiler error message. Include extra detail
726 so that the user knows that they are living on the edge. */
730 msg
= xstrvprintf (fmt
, ap
);
731 reason
= xstrprintf ("%s:%d: %s: %s\n"
732 "A problem internal to GDB has been detected,\n"
733 "further debugging may prove unreliable.",
734 file
, line
, problem
->name
, msg
);
736 make_cleanup (xfree
, reason
);
739 /* Fall back to abort_with_message if gdb_stderr is not set up. */
740 if (gdb_stderr
== NULL
)
742 fputs (reason
, stderr
);
743 abort_with_message ("\n");
746 /* Try to get the message out and at the start of a new line. */
747 if (target_supports_terminal_ours ())
749 make_cleanup_restore_target_terminal ();
750 target_terminal_ours_for_output ();
752 if (filtered_printing_initialized ())
755 /* Emit the message unless query will emit it below. */
756 if (problem
->should_quit
!= internal_problem_ask
758 || !filtered_printing_initialized ())
759 fprintf_unfiltered (gdb_stderr
, "%s\n", reason
);
761 if (problem
->should_quit
== internal_problem_ask
)
763 /* Default (yes/batch case) is to quit GDB. When in batch mode
764 this lessens the likelihood of GDB going into an infinite
766 if (!confirm
|| !filtered_printing_initialized ())
769 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
771 else if (problem
->should_quit
== internal_problem_yes
)
773 else if (problem
->should_quit
== internal_problem_no
)
776 internal_error (__FILE__
, __LINE__
, _("bad switch"));
778 fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr
);
779 if (REPORT_BUGS_TO
[0])
780 fprintf_unfiltered (gdb_stderr
, _(" For instructions, see:\n%s."),
782 fputs_unfiltered ("\n\n", gdb_stderr
);
784 if (problem
->should_dump_core
== internal_problem_ask
)
786 if (!can_dump_core_warn (LIMIT_MAX
, reason
))
788 else if (!filtered_printing_initialized ())
792 /* Default (yes/batch case) is to dump core. This leaves a GDB
793 `dropping' so that it is easier to see that something went
795 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
798 else if (problem
->should_dump_core
== internal_problem_yes
)
799 dump_core_p
= can_dump_core_warn (LIMIT_MAX
, reason
);
800 else if (problem
->should_dump_core
== internal_problem_no
)
803 internal_error (__FILE__
, __LINE__
, _("bad switch"));
816 #ifdef HAVE_WORKING_FORK
824 do_cleanups (cleanup
);
827 static struct internal_problem internal_error_problem
= {
828 "internal-error", 1, internal_problem_ask
, 1, internal_problem_ask
832 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
834 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
835 throw_quit (_("Command aborted."));
838 static struct internal_problem internal_warning_problem
= {
839 "internal-warning", 1, internal_problem_ask
, 1, internal_problem_ask
843 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
845 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
848 static struct internal_problem demangler_warning_problem
= {
849 "demangler-warning", 1, internal_problem_ask
, 0, internal_problem_no
853 demangler_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
855 internal_vproblem (&demangler_warning_problem
, file
, line
, fmt
, ap
);
859 demangler_warning (const char *file
, int line
, const char *string
, ...)
863 va_start (ap
, string
);
864 demangler_vwarning (file
, line
, string
, ap
);
868 /* Dummy functions to keep add_prefix_cmd happy. */
871 set_internal_problem_cmd (char *args
, int from_tty
)
876 show_internal_problem_cmd (char *args
, int from_tty
)
880 /* When GDB reports an internal problem (error or warning) it gives
881 the user the opportunity to quit GDB and/or create a core file of
882 the current debug session. This function registers a few commands
883 that make it possible to specify that GDB should always or never
884 quit or create a core file, without asking. The commands look
887 maint set PROBLEM-NAME quit ask|yes|no
888 maint show PROBLEM-NAME quit
889 maint set PROBLEM-NAME corefile ask|yes|no
890 maint show PROBLEM-NAME corefile
892 Where PROBLEM-NAME is currently "internal-error" or
893 "internal-warning". */
896 add_internal_problem_command (struct internal_problem
*problem
)
898 struct cmd_list_element
**set_cmd_list
;
899 struct cmd_list_element
**show_cmd_list
;
903 set_cmd_list
= XNEW (struct cmd_list_element
*);
904 show_cmd_list
= XNEW (struct cmd_list_element
*);
905 *set_cmd_list
= NULL
;
906 *show_cmd_list
= NULL
;
908 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
911 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
914 add_prefix_cmd ((char*) problem
->name
,
915 class_maintenance
, set_internal_problem_cmd
, set_doc
,
917 concat ("maintenance set ", problem
->name
, " ",
919 0/*allow-unknown*/, &maintenance_set_cmdlist
);
921 add_prefix_cmd ((char*) problem
->name
,
922 class_maintenance
, show_internal_problem_cmd
, show_doc
,
924 concat ("maintenance show ", problem
->name
, " ",
926 0/*allow-unknown*/, &maintenance_show_cmdlist
);
928 if (problem
->user_settable_should_quit
)
930 set_doc
= xstrprintf (_("Set whether GDB should quit "
931 "when an %s is detected"),
933 show_doc
= xstrprintf (_("Show whether GDB will quit "
934 "when an %s is detected"),
936 add_setshow_enum_cmd ("quit", class_maintenance
,
937 internal_problem_modes
,
938 &problem
->should_quit
,
951 if (problem
->user_settable_should_dump_core
)
953 set_doc
= xstrprintf (_("Set whether GDB should create a core "
954 "file of GDB when %s is detected"),
956 show_doc
= xstrprintf (_("Show whether GDB will create a core "
957 "file of GDB when %s is detected"),
959 add_setshow_enum_cmd ("corefile", class_maintenance
,
960 internal_problem_modes
,
961 &problem
->should_dump_core
,
975 /* Return a newly allocated string, containing the PREFIX followed
976 by the system error message for errno (separated by a colon).
978 The result must be deallocated after use. */
981 perror_string (const char *prefix
)
986 err
= safe_strerror (errno
);
987 combined
= (char *) xmalloc (strlen (err
) + strlen (prefix
) + 3);
988 strcpy (combined
, prefix
);
989 strcat (combined
, ": ");
990 strcat (combined
, err
);
995 /* Print the system error message for errno, and also mention STRING
996 as the file name for which the error was encountered. Use ERRCODE
997 for the thrown exception. Then return to command level. */
1000 throw_perror_with_name (enum errors errcode
, const char *string
)
1004 combined
= perror_string (string
);
1005 make_cleanup (xfree
, combined
);
1007 /* I understand setting these is a matter of taste. Still, some people
1008 may clear errno but not know about bfd_error. Doing this here is not
1010 bfd_set_error (bfd_error_no_error
);
1013 throw_error (errcode
, _("%s."), combined
);
1016 /* See throw_perror_with_name, ERRCODE defaults here to GENERIC_ERROR. */
1019 perror_with_name (const char *string
)
1021 throw_perror_with_name (GENERIC_ERROR
, string
);
1024 /* Same as perror_with_name except that it prints a warning instead
1025 of throwing an error. */
1028 perror_warning_with_name (const char *string
)
1032 combined
= perror_string (string
);
1033 warning (_("%s"), combined
);
1037 /* Print the system error message for ERRCODE, and also mention STRING
1038 as the file name for which the error was encountered. */
1041 print_sys_errmsg (const char *string
, int errcode
)
1046 err
= safe_strerror (errcode
);
1047 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1048 strcpy (combined
, string
);
1049 strcat (combined
, ": ");
1050 strcat (combined
, err
);
1052 /* We want anything which was printed on stdout to come out first, before
1054 gdb_flush (gdb_stdout
);
1055 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
1058 /* Control C eventually causes this to be called, at a convenient time. */
1063 if (sync_quit_force_run
)
1065 sync_quit_force_run
= 0;
1066 quit_force (NULL
, stdin
== instream
);
1070 /* No steenking SIGINT will ever be coming our way when the
1071 program is resumed. Don't lie. */
1072 throw_quit ("Quit");
1075 /* If there is no terminal switching for this target, then we can't
1076 possibly get screwed by the lack of job control. */
1077 || !target_supports_terminal_ours ())
1078 throw_quit ("Quit");
1080 throw_quit ("Quit (expect signal SIGINT when the program is resumed)");
1089 if (check_quit_flag () || sync_quit_force_run
)
1091 if (deprecated_interactive_hook
)
1092 deprecated_interactive_hook ();
1093 target_check_pending_interrupt ();
1097 /* Called when a memory allocation fails, with the number of bytes of
1098 memory requested in SIZE. */
1101 malloc_failure (long size
)
1105 internal_error (__FILE__
, __LINE__
,
1106 _("virtual memory exhausted: can't allocate %ld bytes."),
1111 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
1115 /* My replacement for the read system call.
1116 Used like `read' but keeps going if `read' returns too soon. */
1119 myread (int desc
, char *addr
, int len
)
1126 val
= read (desc
, addr
, len
);
1130 return orglen
- len
;
1138 print_spaces (int n
, struct ui_file
*file
)
1140 fputs_unfiltered (n_spaces (n
), file
);
1143 /* Print a host address. */
1146 gdb_print_host_address_1 (const void *addr
, struct ui_file
*stream
)
1148 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
1154 make_hex_string (const gdb_byte
*data
, size_t length
)
1156 char *result
= (char *) xmalloc (length
* 2 + 1);
1161 for (i
= 0; i
< length
; ++i
)
1162 p
+= xsnprintf (p
, 3, "%02x", data
[i
]);
1169 /* A cleanup function that calls regfree. */
1172 do_regfree_cleanup (void *r
)
1174 regfree ((regex_t
*) r
);
1177 /* Create a new cleanup that frees the compiled regular expression R. */
1180 make_regfree_cleanup (regex_t
*r
)
1182 return make_cleanup (do_regfree_cleanup
, r
);
1185 /* Return an xmalloc'd error message resulting from a regular
1186 expression compilation failure. */
1189 get_regcomp_error (int code
, regex_t
*rx
)
1191 size_t length
= regerror (code
, rx
, NULL
, 0);
1192 char *result
= (char *) xmalloc (length
);
1194 regerror (code
, rx
, result
, length
);
1198 /* Compile a regexp and throw an exception on error. This returns a
1199 cleanup to free the resulting pattern on success. RX must not be
1203 compile_rx_or_error (regex_t
*pattern
, const char *rx
, const char *message
)
1207 gdb_assert (rx
!= NULL
);
1209 code
= regcomp (pattern
, rx
, REG_NOSUB
);
1212 char *err
= get_regcomp_error (code
, pattern
);
1214 make_cleanup (xfree
, err
);
1215 error (("%s: %s"), message
, err
);
1218 return make_regfree_cleanup (pattern
);
1223 /* This function supports the query, nquery, and yquery functions.
1224 Ask user a y-or-n question and return 0 if answer is no, 1 if
1225 answer is yes, or default the answer to the specified default
1226 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1227 default answer, or '\0' for no default.
1228 CTLSTR is the control string and should end in "? ". It should
1229 not say how to answer, because we do that.
1230 ARGS are the arguments passed along with the CTLSTR argument to
1233 static int ATTRIBUTE_PRINTF (1, 0)
1234 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1239 char def_answer
, not_def_answer
;
1240 char *y_string
, *n_string
, *question
, *prompt
;
1241 /* Used to add duration we waited for user to respond to
1242 prompt_for_continue_wait_time. */
1243 struct timeval prompt_started
, prompt_ended
, prompt_delta
;
1244 struct cleanup
*old_chain
;
1246 /* Set up according to which answer is the default. */
1247 if (defchar
== '\0')
1251 not_def_answer
= 'N';
1255 else if (defchar
== 'y')
1259 not_def_answer
= 'N';
1267 not_def_answer
= 'Y';
1272 /* Automatically answer the default value if the user did not want
1273 prompts or the command was issued with the server prefix. */
1274 if (!confirm
|| server_command
)
1277 /* If input isn't coming from the user directly, just say what
1278 question we're asking, and then answer the default automatically. This
1279 way, important error messages don't get lost when talking to GDB
1281 if (! input_from_terminal_p ())
1284 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1286 printf_filtered (_("(%s or %s) [answered %c; "
1287 "input not from terminal]\n"),
1288 y_string
, n_string
, def_answer
);
1289 gdb_flush (gdb_stdout
);
1294 if (deprecated_query_hook
)
1296 return deprecated_query_hook (ctlstr
, args
);
1299 old_chain
= make_cleanup (null_cleanup
, NULL
);
1301 /* Format the question outside of the loop, to avoid reusing args. */
1302 question
= xstrvprintf (ctlstr
, args
);
1303 make_cleanup (xfree
, question
);
1304 prompt
= xstrprintf (_("%s%s(%s or %s) %s"),
1305 annotation_level
> 1 ? "\n\032\032pre-query\n" : "",
1306 question
, y_string
, n_string
,
1307 annotation_level
> 1 ? "\n\032\032query\n" : "");
1308 make_cleanup (xfree
, prompt
);
1310 /* Used for calculating time spend waiting for user. */
1311 gettimeofday (&prompt_started
, NULL
);
1315 char *response
, answer
;
1317 gdb_flush (gdb_stdout
);
1318 response
= gdb_readline_wrapper (prompt
);
1320 if (response
== NULL
) /* C-d */
1322 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1327 answer
= response
[0];
1332 /* Check answer. For the non-default, the user must specify
1333 the non-default explicitly. */
1334 if (answer
== not_def_answer
)
1336 retval
= !def_value
;
1339 /* Otherwise, if a default was specified, the user may either
1340 specify the required input or have it default by entering
1342 if (answer
== def_answer
1343 || (defchar
!= '\0' && answer
== '\0'))
1348 /* Invalid entries are not defaulted and require another selection. */
1349 printf_filtered (_("Please answer %s or %s.\n"),
1350 y_string
, n_string
);
1353 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1354 gettimeofday (&prompt_ended
, NULL
);
1355 timeval_sub (&prompt_delta
, &prompt_ended
, &prompt_started
);
1356 timeval_add (&prompt_for_continue_wait_time
,
1357 &prompt_for_continue_wait_time
, &prompt_delta
);
1359 if (annotation_level
> 1)
1360 printf_filtered (("\n\032\032post-query\n"));
1361 do_cleanups (old_chain
);
1366 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1367 answer is yes, or 0 if answer is defaulted.
1368 Takes three args which are given to printf to print the question.
1369 The first, a control string, should end in "? ".
1370 It should not say how to answer, because we do that. */
1373 nquery (const char *ctlstr
, ...)
1378 va_start (args
, ctlstr
);
1379 ret
= defaulted_query (ctlstr
, 'n', args
);
1384 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1385 answer is yes, or 1 if answer is defaulted.
1386 Takes three args which are given to printf to print the question.
1387 The first, a control string, should end in "? ".
1388 It should not say how to answer, because we do that. */
1391 yquery (const char *ctlstr
, ...)
1396 va_start (args
, ctlstr
);
1397 ret
= defaulted_query (ctlstr
, 'y', args
);
1402 /* Ask user a y-or-n question and return 1 iff answer is yes.
1403 Takes three args which are given to printf to print the question.
1404 The first, a control string, should end in "? ".
1405 It should not say how to answer, because we do that. */
1408 query (const char *ctlstr
, ...)
1413 va_start (args
, ctlstr
);
1414 ret
= defaulted_query (ctlstr
, '\0', args
);
1419 /* A helper for parse_escape that converts a host character to a
1420 target character. C is the host character. If conversion is
1421 possible, then the target character is stored in *TARGET_C and the
1422 function returns 1. Otherwise, the function returns 0. */
1425 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1427 struct obstack host_data
;
1429 struct cleanup
*cleanups
;
1432 obstack_init (&host_data
);
1433 cleanups
= make_cleanup_obstack_free (&host_data
);
1435 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1436 (gdb_byte
*) &the_char
, 1, 1,
1437 &host_data
, translit_none
);
1439 if (obstack_object_size (&host_data
) == 1)
1442 *target_c
= *(char *) obstack_base (&host_data
);
1445 do_cleanups (cleanups
);
1449 /* Parse a C escape sequence. STRING_PTR points to a variable
1450 containing a pointer to the string to parse. That pointer
1451 should point to the character after the \. That pointer
1452 is updated past the characters we use. The value of the
1453 escape sequence is returned.
1455 A negative value means the sequence \ newline was seen,
1456 which is supposed to be equivalent to nothing at all.
1458 If \ is followed by a null character, we return a negative
1459 value and leave the string pointer pointing at the null character.
1461 If \ is followed by 000, we return 0 and leave the string pointer
1462 after the zeros. A value of 0 does not mean end of string. */
1465 parse_escape (struct gdbarch
*gdbarch
, const char **string_ptr
)
1467 int target_char
= -2; /* Initialize to avoid GCC warnings. */
1468 int c
= *(*string_ptr
)++;
1487 int i
= host_hex_value (c
);
1492 if (isdigit (c
) && c
!= '8' && c
!= '9')
1496 i
+= host_hex_value (c
);
1532 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1533 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1534 " which has no equivalent\nin the `%s' character set."),
1535 c
, c
, target_charset (gdbarch
));
1539 /* Print the character C on STREAM as part of the contents of a literal
1540 string whose delimiter is QUOTER. Note that this routine should only
1541 be called for printing things which are independent of the language
1542 of the program being debugged.
1544 printchar will normally escape backslashes and instances of QUOTER. If
1545 QUOTER is 0, printchar won't escape backslashes or any quoting character.
1546 As a side effect, if you pass the backslash character as the QUOTER,
1547 printchar will escape backslashes as usual, but not any other quoting
1551 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1552 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1553 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1555 c
&= 0xFF; /* Avoid sign bit follies */
1557 if (c
< 0x20 || /* Low control chars */
1558 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1559 (sevenbit_strings
&& c
>= 0x80))
1560 { /* high order bit set */
1564 do_fputs ("\\n", stream
);
1567 do_fputs ("\\b", stream
);
1570 do_fputs ("\\t", stream
);
1573 do_fputs ("\\f", stream
);
1576 do_fputs ("\\r", stream
);
1579 do_fputs ("\\e", stream
);
1582 do_fputs ("\\a", stream
);
1585 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1591 if (quoter
!= 0 && (c
== '\\' || c
== quoter
))
1592 do_fputs ("\\", stream
);
1593 do_fprintf (stream
, "%c", c
);
1597 /* Print the character C on STREAM as part of the contents of a
1598 literal string whose delimiter is QUOTER. Note that these routines
1599 should only be call for printing things which are independent of
1600 the language of the program being debugged. */
1603 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1606 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1610 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1613 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1617 fputstrn_filtered (const char *str
, int n
, int quoter
,
1618 struct ui_file
*stream
)
1622 for (i
= 0; i
< n
; i
++)
1623 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1627 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1628 struct ui_file
*stream
)
1632 for (i
= 0; i
< n
; i
++)
1633 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1637 /* Number of lines per page or UINT_MAX if paging is disabled. */
1638 static unsigned int lines_per_page
;
1640 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1641 struct cmd_list_element
*c
, const char *value
)
1643 fprintf_filtered (file
,
1644 _("Number of lines gdb thinks are in a page is %s.\n"),
1648 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1649 static unsigned int chars_per_line
;
1651 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1652 struct cmd_list_element
*c
, const char *value
)
1654 fprintf_filtered (file
,
1655 _("Number of characters gdb thinks "
1656 "are in a line is %s.\n"),
1660 /* Current count of lines printed on this page, chars on this line. */
1661 static unsigned int lines_printed
, chars_printed
;
1663 /* Buffer and start column of buffered text, for doing smarter word-
1664 wrapping. When someone calls wrap_here(), we start buffering output
1665 that comes through fputs_filtered(). If we see a newline, we just
1666 spit it out and forget about the wrap_here(). If we see another
1667 wrap_here(), we spit it out and remember the newer one. If we see
1668 the end of the line, we spit out a newline, the indent, and then
1669 the buffered output. */
1671 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1672 are waiting to be output (they have already been counted in chars_printed).
1673 When wrap_buffer[0] is null, the buffer is empty. */
1674 static char *wrap_buffer
;
1676 /* Pointer in wrap_buffer to the next character to fill. */
1677 static char *wrap_pointer
;
1679 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1681 static char *wrap_indent
;
1683 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1684 is not in effect. */
1685 static int wrap_column
;
1688 /* Inialize the number of lines per page and chars per line. */
1691 init_page_info (void)
1695 lines_per_page
= UINT_MAX
;
1696 chars_per_line
= UINT_MAX
;
1700 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1705 #if defined(__GO32__)
1706 rows
= ScreenRows ();
1707 cols
= ScreenCols ();
1708 lines_per_page
= rows
;
1709 chars_per_line
= cols
;
1711 /* Make sure Readline has initialized its terminal settings. */
1712 rl_reset_terminal (NULL
);
1714 /* Get the screen size from Readline. */
1715 rl_get_screen_size (&rows
, &cols
);
1716 lines_per_page
= rows
;
1717 chars_per_line
= cols
;
1719 /* Readline should have fetched the termcap entry for us.
1720 Only try to use tgetnum function if rl_get_screen_size
1721 did not return a useful value. */
1722 if (((rows
<= 0) && (tgetnum ("li") < 0))
1723 /* Also disable paging if inside Emacs. $EMACS was used
1724 before Emacs v25.1, $INSIDE_EMACS is used since then. */
1725 || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
1727 /* The number of lines per page is not mentioned in the terminal
1728 description or EMACS evironment variable is set. This probably
1729 means that paging is not useful, so disable paging. */
1730 lines_per_page
= UINT_MAX
;
1733 /* If the output is not a terminal, don't paginate it. */
1734 if (!ui_file_isatty (gdb_stdout
))
1735 lines_per_page
= UINT_MAX
;
1739 /* We handle SIGWINCH ourselves. */
1740 rl_catch_sigwinch
= 0;
1746 /* Return nonzero if filtered printing is initialized. */
1748 filtered_printing_initialized (void)
1750 return wrap_buffer
!= NULL
;
1753 /* Helper for make_cleanup_restore_page_info. */
1756 do_restore_page_info_cleanup (void *arg
)
1762 /* Provide cleanup for restoring the terminal size. */
1765 make_cleanup_restore_page_info (void)
1767 struct cleanup
*back_to
;
1769 back_to
= make_cleanup (do_restore_page_info_cleanup
, NULL
);
1770 make_cleanup_restore_uinteger (&lines_per_page
);
1771 make_cleanup_restore_uinteger (&chars_per_line
);
1776 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1777 Provide cleanup for restoring the original state. */
1780 set_batch_flag_and_make_cleanup_restore_page_info (void)
1782 struct cleanup
*back_to
= make_cleanup_restore_page_info ();
1784 make_cleanup_restore_integer (&batch_flag
);
1791 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1794 set_screen_size (void)
1796 int rows
= lines_per_page
;
1797 int cols
= chars_per_line
;
1805 /* Update Readline's idea of the terminal size. */
1806 rl_set_screen_size (rows
, cols
);
1809 /* Reinitialize WRAP_BUFFER according to the current value of
1815 if (chars_per_line
== 0)
1820 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1821 wrap_buffer
[0] = '\0';
1824 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1825 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1829 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1836 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1844 set_screen_width_and_height (int width
, int height
)
1846 lines_per_page
= height
;
1847 chars_per_line
= width
;
1853 /* Wait, so the user can read what's on the screen. Prompt the user
1854 to continue by pressing RETURN. 'q' is also provided because
1855 telling users what to do in the prompt is more user-friendly than
1856 expecting them to think of Ctrl-C/SIGINT. */
1859 prompt_for_continue (void)
1862 char cont_prompt
[120];
1863 /* Used to add duration we waited for user to respond to
1864 prompt_for_continue_wait_time. */
1865 struct timeval prompt_started
, prompt_ended
, prompt_delta
;
1866 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1868 gettimeofday (&prompt_started
, NULL
);
1870 if (annotation_level
> 1)
1871 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1873 strcpy (cont_prompt
,
1874 "---Type <return> to continue, or q <return> to quit---");
1875 if (annotation_level
> 1)
1876 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1878 /* We must do this *before* we call gdb_readline_wrapper, else it
1879 will eventually call us -- thinking that we're trying to print
1880 beyond the end of the screen. */
1881 reinitialize_more_filter ();
1883 /* We'll need to handle input. */
1884 target_terminal_ours ();
1886 /* Call gdb_readline_wrapper, not readline, in order to keep an
1887 event loop running. */
1888 ignore
= gdb_readline_wrapper (cont_prompt
);
1889 make_cleanup (xfree
, ignore
);
1891 /* Add time spend in this routine to prompt_for_continue_wait_time. */
1892 gettimeofday (&prompt_ended
, NULL
);
1893 timeval_sub (&prompt_delta
, &prompt_ended
, &prompt_started
);
1894 timeval_add (&prompt_for_continue_wait_time
,
1895 &prompt_for_continue_wait_time
, &prompt_delta
);
1897 if (annotation_level
> 1)
1898 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1904 while (*p
== ' ' || *p
== '\t')
1907 /* Do not call quit here; there is no possibility of SIGINT. */
1908 throw_quit ("Quit");
1911 /* Now we have to do this again, so that GDB will know that it doesn't
1912 need to save the ---Type <return>--- line at the top of the screen. */
1913 reinitialize_more_filter ();
1915 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1917 do_cleanups (old_chain
);
1920 /* Initalize timer to keep track of how long we waited for the user. */
1923 reset_prompt_for_continue_wait_time (void)
1925 static const struct timeval zero_timeval
= { 0 };
1927 prompt_for_continue_wait_time
= zero_timeval
;
1930 /* Fetch the cumulative time spent in prompt_for_continue. */
1933 get_prompt_for_continue_wait_time (void)
1935 return prompt_for_continue_wait_time
;
1938 /* Reinitialize filter; ie. tell it to reset to original values. */
1941 reinitialize_more_filter (void)
1947 /* Indicate that if the next sequence of characters overflows the line,
1948 a newline should be inserted here rather than when it hits the end.
1949 If INDENT is non-null, it is a string to be printed to indent the
1950 wrapped part on the next line. INDENT must remain accessible until
1951 the next call to wrap_here() or until a newline is printed through
1954 If the line is already overfull, we immediately print a newline and
1955 the indentation, and disable further wrapping.
1957 If we don't know the width of lines, but we know the page height,
1958 we must not wrap words, but should still keep track of newlines
1959 that were explicitly printed.
1961 INDENT should not contain tabs, as that will mess up the char count
1962 on the next line. FIXME.
1964 This routine is guaranteed to force out any output which has been
1965 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1966 used to force out output from the wrap_buffer. */
1969 wrap_here (char *indent
)
1971 /* This should have been allocated, but be paranoid anyway. */
1973 internal_error (__FILE__
, __LINE__
,
1974 _("failed internal consistency check"));
1978 *wrap_pointer
= '\0';
1979 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1981 wrap_pointer
= wrap_buffer
;
1982 wrap_buffer
[0] = '\0';
1983 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
1987 else if (chars_printed
>= chars_per_line
)
1989 puts_filtered ("\n");
1991 puts_filtered (indent
);
1996 wrap_column
= chars_printed
;
2000 wrap_indent
= indent
;
2004 /* Print input string to gdb_stdout, filtered, with wrap,
2005 arranging strings in columns of n chars. String can be
2006 right or left justified in the column. Never prints
2007 trailing spaces. String should never be longer than
2008 width. FIXME: this could be useful for the EXAMINE
2009 command, which currently doesn't tabulate very well. */
2012 puts_filtered_tabular (char *string
, int width
, int right
)
2018 gdb_assert (chars_per_line
> 0);
2019 if (chars_per_line
== UINT_MAX
)
2021 fputs_filtered (string
, gdb_stdout
);
2022 fputs_filtered ("\n", gdb_stdout
);
2026 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
2027 fputs_filtered ("\n", gdb_stdout
);
2029 if (width
>= chars_per_line
)
2030 width
= chars_per_line
- 1;
2032 stringlen
= strlen (string
);
2034 if (chars_printed
> 0)
2035 spaces
= width
- (chars_printed
- 1) % width
- 1;
2037 spaces
+= width
- stringlen
;
2039 spacebuf
= (char *) alloca (spaces
+ 1);
2040 spacebuf
[spaces
] = '\0';
2042 spacebuf
[spaces
] = ' ';
2044 fputs_filtered (spacebuf
, gdb_stdout
);
2045 fputs_filtered (string
, gdb_stdout
);
2049 /* Ensure that whatever gets printed next, using the filtered output
2050 commands, starts at the beginning of the line. I.e. if there is
2051 any pending output for the current line, flush it and start a new
2052 line. Otherwise do nothing. */
2057 if (chars_printed
> 0)
2059 puts_filtered ("\n");
2064 /* Like fputs but if FILTER is true, pause after every screenful.
2066 Regardless of FILTER can wrap at points other than the final
2067 character of a line.
2069 Unlike fputs, fputs_maybe_filtered does not return a value.
2070 It is OK for LINEBUFFER to be NULL, in which case just don't print
2073 Note that a longjmp to top level may occur in this routine (only if
2074 FILTER is true) (since prompt_for_continue may do so) so this
2075 routine should not be called when cleanups are not in place. */
2078 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
2081 const char *lineptr
;
2083 if (linebuffer
== 0)
2086 /* Don't do any filtering if it is disabled. */
2087 if (stream
!= gdb_stdout
2088 || !pagination_enabled
2090 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
2091 || top_level_interpreter () == NULL
2092 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2094 fputs_unfiltered (linebuffer
, stream
);
2098 /* Go through and output each character. Show line extension
2099 when this is necessary; prompt user for new page when this is
2102 lineptr
= linebuffer
;
2105 /* Possible new page. */
2106 if (filter
&& (lines_printed
>= lines_per_page
- 1))
2107 prompt_for_continue ();
2109 while (*lineptr
&& *lineptr
!= '\n')
2111 /* Print a single line. */
2112 if (*lineptr
== '\t')
2115 *wrap_pointer
++ = '\t';
2117 fputc_unfiltered ('\t', stream
);
2118 /* Shifting right by 3 produces the number of tab stops
2119 we have already passed, and then adding one and
2120 shifting left 3 advances to the next tab stop. */
2121 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2127 *wrap_pointer
++ = *lineptr
;
2129 fputc_unfiltered (*lineptr
, stream
);
2134 if (chars_printed
>= chars_per_line
)
2136 unsigned int save_chars
= chars_printed
;
2140 /* If we aren't actually wrapping, don't output newline --
2141 if chars_per_line is right, we probably just overflowed
2142 anyway; if it's wrong, let us keep going. */
2144 fputc_unfiltered ('\n', stream
);
2146 /* Possible new page. */
2147 if (lines_printed
>= lines_per_page
- 1)
2148 prompt_for_continue ();
2150 /* Now output indentation and wrapped string. */
2153 fputs_unfiltered (wrap_indent
, stream
);
2154 *wrap_pointer
= '\0'; /* Null-terminate saved stuff, */
2155 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it. */
2156 /* FIXME, this strlen is what prevents wrap_indent from
2157 containing tabs. However, if we recurse to print it
2158 and count its chars, we risk trouble if wrap_indent is
2159 longer than (the user settable) chars_per_line.
2160 Note also that this can set chars_printed > chars_per_line
2161 if we are printing a long string. */
2162 chars_printed
= strlen (wrap_indent
)
2163 + (save_chars
- wrap_column
);
2164 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2165 wrap_buffer
[0] = '\0';
2166 wrap_column
= 0; /* And disable fancy wrap */
2171 if (*lineptr
== '\n')
2174 wrap_here ((char *) 0); /* Spit out chars, cancel
2177 fputc_unfiltered ('\n', stream
);
2184 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2186 fputs_maybe_filtered (linebuffer
, stream
, 1);
2190 putchar_unfiltered (int c
)
2194 ui_file_write (gdb_stdout
, &buf
, 1);
2198 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2199 May return nonlocally. */
2202 putchar_filtered (int c
)
2204 return fputc_filtered (c
, gdb_stdout
);
2208 fputc_unfiltered (int c
, struct ui_file
*stream
)
2212 ui_file_write (stream
, &buf
, 1);
2217 fputc_filtered (int c
, struct ui_file
*stream
)
2223 fputs_filtered (buf
, stream
);
2227 /* puts_debug is like fputs_unfiltered, except it prints special
2228 characters in printable fashion. */
2231 puts_debug (char *prefix
, char *string
, char *suffix
)
2235 /* Print prefix and suffix after each line. */
2236 static int new_line
= 1;
2237 static int return_p
= 0;
2238 static char *prev_prefix
= "";
2239 static char *prev_suffix
= "";
2241 if (*string
== '\n')
2244 /* If the prefix is changing, print the previous suffix, a new line,
2245 and the new prefix. */
2246 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2248 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2249 fputs_unfiltered ("\n", gdb_stdlog
);
2250 fputs_unfiltered (prefix
, gdb_stdlog
);
2253 /* Print prefix if we printed a newline during the previous call. */
2257 fputs_unfiltered (prefix
, gdb_stdlog
);
2260 prev_prefix
= prefix
;
2261 prev_suffix
= suffix
;
2263 /* Output characters in a printable format. */
2264 while ((ch
= *string
++) != '\0')
2270 fputc_unfiltered (ch
, gdb_stdlog
);
2273 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2277 fputs_unfiltered ("\\\\", gdb_stdlog
);
2280 fputs_unfiltered ("\\b", gdb_stdlog
);
2283 fputs_unfiltered ("\\f", gdb_stdlog
);
2287 fputs_unfiltered ("\\n", gdb_stdlog
);
2290 fputs_unfiltered ("\\r", gdb_stdlog
);
2293 fputs_unfiltered ("\\t", gdb_stdlog
);
2296 fputs_unfiltered ("\\v", gdb_stdlog
);
2300 return_p
= ch
== '\r';
2303 /* Print suffix if we printed a newline. */
2306 fputs_unfiltered (suffix
, gdb_stdlog
);
2307 fputs_unfiltered ("\n", gdb_stdlog
);
2312 /* Print a variable number of ARGS using format FORMAT. If this
2313 information is going to put the amount written (since the last call
2314 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2315 call prompt_for_continue to get the users permision to continue.
2317 Unlike fprintf, this function does not return a value.
2319 We implement three variants, vfprintf (takes a vararg list and stream),
2320 fprintf (takes a stream to write on), and printf (the usual).
2322 Note also that a longjmp to top level may occur in this routine
2323 (since prompt_for_continue may do so) so this routine should not be
2324 called when cleanups are not in place. */
2327 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2328 va_list args
, int filter
)
2331 struct cleanup
*old_cleanups
;
2333 linebuffer
= xstrvprintf (format
, args
);
2334 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2335 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2336 do_cleanups (old_cleanups
);
2341 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2343 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2347 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2350 struct cleanup
*old_cleanups
;
2352 linebuffer
= xstrvprintf (format
, args
);
2353 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2354 if (debug_timestamp
&& stream
== gdb_stdlog
)
2360 gettimeofday (&tm
, NULL
);
2362 len
= strlen (linebuffer
);
2363 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2365 timestamp
= xstrprintf ("%ld:%ld %s%s",
2366 (long) tm
.tv_sec
, (long) tm
.tv_usec
,
2368 need_nl
? "\n": "");
2369 make_cleanup (xfree
, timestamp
);
2370 fputs_unfiltered (timestamp
, stream
);
2373 fputs_unfiltered (linebuffer
, stream
);
2374 do_cleanups (old_cleanups
);
2378 vprintf_filtered (const char *format
, va_list args
)
2380 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2384 vprintf_unfiltered (const char *format
, va_list args
)
2386 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2390 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2394 va_start (args
, format
);
2395 vfprintf_filtered (stream
, format
, args
);
2400 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2404 va_start (args
, format
);
2405 vfprintf_unfiltered (stream
, format
, args
);
2409 /* Like fprintf_filtered, but prints its result indented.
2410 Called as fprintfi_filtered (spaces, stream, format, ...); */
2413 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2418 va_start (args
, format
);
2419 print_spaces_filtered (spaces
, stream
);
2421 vfprintf_filtered (stream
, format
, args
);
2427 printf_filtered (const char *format
, ...)
2431 va_start (args
, format
);
2432 vfprintf_filtered (gdb_stdout
, format
, args
);
2438 printf_unfiltered (const char *format
, ...)
2442 va_start (args
, format
);
2443 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2447 /* Like printf_filtered, but prints it's result indented.
2448 Called as printfi_filtered (spaces, format, ...); */
2451 printfi_filtered (int spaces
, const char *format
, ...)
2455 va_start (args
, format
);
2456 print_spaces_filtered (spaces
, gdb_stdout
);
2457 vfprintf_filtered (gdb_stdout
, format
, args
);
2461 /* Easy -- but watch out!
2463 This routine is *not* a replacement for puts()! puts() appends a newline.
2464 This one doesn't, and had better not! */
2467 puts_filtered (const char *string
)
2469 fputs_filtered (string
, gdb_stdout
);
2473 puts_unfiltered (const char *string
)
2475 fputs_unfiltered (string
, gdb_stdout
);
2478 /* Return a pointer to N spaces and a null. The pointer is good
2479 until the next call to here. */
2484 static char *spaces
= 0;
2485 static int max_spaces
= -1;
2491 spaces
= (char *) xmalloc (n
+ 1);
2492 for (t
= spaces
+ n
; t
!= spaces
;)
2498 return spaces
+ max_spaces
- n
;
2501 /* Print N spaces. */
2503 print_spaces_filtered (int n
, struct ui_file
*stream
)
2505 fputs_filtered (n_spaces (n
), stream
);
2508 /* C++/ObjC demangler stuff. */
2510 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2511 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2512 If the name is not mangled, or the language for the name is unknown, or
2513 demangling is off, the name is printed in its "raw" form. */
2516 fprintf_symbol_filtered (struct ui_file
*stream
, const char *name
,
2517 enum language lang
, int arg_mode
)
2523 /* If user wants to see raw output, no problem. */
2526 fputs_filtered (name
, stream
);
2530 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2531 fputs_filtered (demangled
? demangled
: name
, stream
);
2532 if (demangled
!= NULL
)
2540 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2541 differences in whitespace. Returns 0 if they match, non-zero if they
2542 don't (slightly different than strcmp()'s range of return values).
2544 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2545 This "feature" is useful when searching for matching C++ function names
2546 (such as if the user types 'break FOO', where FOO is a mangled C++
2550 strcmp_iw (const char *string1
, const char *string2
)
2552 while ((*string1
!= '\0') && (*string2
!= '\0'))
2554 while (isspace (*string1
))
2558 while (isspace (*string2
))
2562 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
2564 if (case_sensitivity
== case_sensitive_off
2565 && (tolower ((unsigned char) *string1
)
2566 != tolower ((unsigned char) *string2
)))
2568 if (*string1
!= '\0')
2574 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2577 /* This is like strcmp except that it ignores whitespace and treats
2578 '(' as the first non-NULL character in terms of ordering. Like
2579 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2580 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2581 according to that ordering.
2583 If a list is sorted according to this function and if you want to
2584 find names in the list that match some fixed NAME according to
2585 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2586 where this function would put NAME.
2588 This function must be neutral to the CASE_SENSITIVITY setting as the user
2589 may choose it during later lookup. Therefore this function always sorts
2590 primarily case-insensitively and secondarily case-sensitively.
2592 Here are some examples of why using strcmp to sort is a bad idea:
2596 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2597 we try to do a search for "foo<char*>", strcmp will locate this
2598 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2599 will start looking at strings beginning with "goo", and will never
2600 see the correct match of "foo<char *>".
2602 Parenthesis example:
2604 In practice, this is less like to be an issue, but I'll give it a
2605 shot. Let's assume that '$' is a legitimate character to occur in
2606 symbols. (Which may well even be the case on some systems.) Then
2607 say that the partial symbol table contains "foo$" and "foo(int)".
2608 strcmp will put them in this order, since '$' < '('. Now, if the
2609 user searches for "foo", then strcmp will sort "foo" before "foo$".
2610 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2611 "foo") is false, so it won't proceed to the actual match of
2612 "foo(int)" with "foo". */
2615 strcmp_iw_ordered (const char *string1
, const char *string2
)
2617 const char *saved_string1
= string1
, *saved_string2
= string2
;
2618 enum case_sensitivity case_pass
= case_sensitive_off
;
2622 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2623 Provide stub characters if we are already at the end of one of the
2625 char c1
= 'X', c2
= 'X';
2627 while (*string1
!= '\0' && *string2
!= '\0')
2629 while (isspace (*string1
))
2631 while (isspace (*string2
))
2636 case case_sensitive_off
:
2637 c1
= tolower ((unsigned char) *string1
);
2638 c2
= tolower ((unsigned char) *string2
);
2640 case case_sensitive_on
:
2648 if (*string1
!= '\0')
2657 /* Characters are non-equal unless they're both '\0'; we want to
2658 make sure we get the comparison right according to our
2659 comparison in the cases where one of them is '\0' or '('. */
2661 if (*string2
== '\0')
2666 if (*string2
== '\0')
2671 if (*string2
== '\0' || *string2
== '(')
2680 if (case_pass
== case_sensitive_on
)
2683 /* Otherwise the strings were equal in case insensitive way, make
2684 a more fine grained comparison in a case sensitive way. */
2686 case_pass
= case_sensitive_on
;
2687 string1
= saved_string1
;
2688 string2
= saved_string2
;
2692 /* A simple comparison function with opposite semantics to strcmp. */
2695 streq (const char *lhs
, const char *rhs
)
2697 return !strcmp (lhs
, rhs
);
2703 ** Answer whether string_to_compare is a full or partial match to
2704 ** template_string. The partial match must be in sequence starting
2708 subset_compare (char *string_to_compare
, char *template_string
)
2712 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2713 && strlen (string_to_compare
) <= strlen (template_string
))
2715 (startswith (template_string
, string_to_compare
));
2722 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2723 struct cmd_list_element
*c
, const char *value
)
2725 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
2731 initialize_utils (void)
2733 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2734 Set number of characters where GDB should wrap lines of its output."), _("\
2735 Show number of characters where GDB should wrap lines of its output."), _("\
2736 This affects where GDB wraps its output to fit the screen width.\n\
2737 Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
2739 show_chars_per_line
,
2740 &setlist
, &showlist
);
2742 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2743 Set number of lines in a page for GDB output pagination."), _("\
2744 Show number of lines in a page for GDB output pagination."), _("\
2745 This affects the number of lines after which GDB will pause\n\
2746 its output and ask you whether to continue.\n\
2747 Setting this to \"unlimited\" or zero causes GDB never pause during output."),
2749 show_lines_per_page
,
2750 &setlist
, &showlist
);
2752 add_setshow_boolean_cmd ("pagination", class_support
,
2753 &pagination_enabled
, _("\
2754 Set state of GDB output pagination."), _("\
2755 Show state of GDB output pagination."), _("\
2756 When pagination is ON, GDB pauses at end of each screenful of\n\
2757 its output and asks you whether to continue.\n\
2758 Turning pagination off is an alternative to \"set height unlimited\"."),
2760 show_pagination_enabled
,
2761 &setlist
, &showlist
);
2763 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2764 &sevenbit_strings
, _("\
2765 Set printing of 8-bit characters in strings as \\nnn."), _("\
2766 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2768 show_sevenbit_strings
,
2769 &setprintlist
, &showprintlist
);
2771 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2772 &debug_timestamp
, _("\
2773 Set timestamping of debugging messages."), _("\
2774 Show timestamping of debugging messages."), _("\
2775 When set, debugging messages will be marked with seconds and microseconds."),
2777 show_debug_timestamp
,
2778 &setdebuglist
, &showdebuglist
);
2782 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2784 /* Truncate address to the size of a target address, avoiding shifts
2785 larger or equal than the width of a CORE_ADDR. The local
2786 variable ADDR_BIT stops the compiler reporting a shift overflow
2787 when it won't occur. */
2788 /* NOTE: This assumes that the significant address information is
2789 kept in the least significant bits of ADDR - the upper bits were
2790 either zero or sign extended. Should gdbarch_address_to_pointer or
2791 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2793 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2795 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2796 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2797 return hex_string (addr
);
2800 /* This function is described in "defs.h". */
2803 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2805 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2807 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2808 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2810 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2811 that returns the language localized string formatted to a width
2812 based on gdbarch_addr_bit. */
2814 return hex_string_custom (address
, 8);
2816 return hex_string_custom (address
, 16);
2819 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2822 core_addr_hash (const void *ap
)
2824 const CORE_ADDR
*addrp
= (const CORE_ADDR
*) ap
;
2829 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2832 core_addr_eq (const void *ap
, const void *bp
)
2834 const CORE_ADDR
*addr_ap
= (const CORE_ADDR
*) ap
;
2835 const CORE_ADDR
*addr_bp
= (const CORE_ADDR
*) bp
;
2837 return *addr_ap
== *addr_bp
;
2840 /* Convert a string back into a CORE_ADDR. */
2842 string_to_core_addr (const char *my_string
)
2846 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2848 /* Assume that it is in hex. */
2851 for (i
= 2; my_string
[i
] != '\0'; i
++)
2853 if (isdigit (my_string
[i
]))
2854 addr
= (my_string
[i
] - '0') + (addr
* 16);
2855 else if (isxdigit (my_string
[i
]))
2856 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2858 error (_("invalid hex \"%s\""), my_string
);
2863 /* Assume that it is in decimal. */
2866 for (i
= 0; my_string
[i
] != '\0'; i
++)
2868 if (isdigit (my_string
[i
]))
2869 addr
= (my_string
[i
] - '0') + (addr
* 10);
2871 error (_("invalid decimal \"%s\""), my_string
);
2879 gdb_realpath (const char *filename
)
2881 /* On most hosts, we rely on canonicalize_file_name to compute
2882 the FILENAME's realpath.
2884 But the situation is slightly more complex on Windows, due to some
2885 versions of GCC which were reported to generate paths where
2886 backlashes (the directory separator) were doubled. For instance:
2887 c:\\some\\double\\slashes\\dir
2889 c:\some\double\slashes\dir
2890 Those double-slashes were getting in the way when comparing paths,
2891 for instance when trying to insert a breakpoint as follow:
2892 (gdb) b c:/some/double/slashes/dir/foo.c:4
2893 No source file named c:/some/double/slashes/dir/foo.c:4.
2894 (gdb) b c:\some\double\slashes\dir\foo.c:4
2895 No source file named c:\some\double\slashes\dir\foo.c:4.
2896 To prevent this from happening, we need this function to always
2897 strip those extra backslashes. While canonicalize_file_name does
2898 perform this simplification, it only works when the path is valid.
2899 Since the simplification would be useful even if the path is not
2900 valid (one can always set a breakpoint on a file, even if the file
2901 does not exist locally), we rely instead on GetFullPathName to
2902 perform the canonicalization. */
2904 #if defined (_WIN32)
2907 DWORD len
= GetFullPathName (filename
, MAX_PATH
, buf
, NULL
);
2909 /* The file system is case-insensitive but case-preserving.
2910 So it is important we do not lowercase the path. Otherwise,
2911 we might not be able to display the original casing in a given
2913 if (len
> 0 && len
< MAX_PATH
)
2914 return xstrdup (buf
);
2918 char *rp
= canonicalize_file_name (filename
);
2925 /* This system is a lost cause, just dup the buffer. */
2926 return xstrdup (filename
);
2929 /* Return a copy of FILENAME, with its directory prefix canonicalized
2933 gdb_realpath_keepfile (const char *filename
)
2935 const char *base_name
= lbasename (filename
);
2940 /* Extract the basename of filename, and return immediately
2941 a copy of filename if it does not contain any directory prefix. */
2942 if (base_name
== filename
)
2943 return xstrdup (filename
);
2945 dir_name
= (char *) alloca ((size_t) (base_name
- filename
+ 2));
2946 /* Allocate enough space to store the dir_name + plus one extra
2947 character sometimes needed under Windows (see below), and
2948 then the closing \000 character. */
2949 strncpy (dir_name
, filename
, base_name
- filename
);
2950 dir_name
[base_name
- filename
] = '\000';
2952 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2953 /* We need to be careful when filename is of the form 'd:foo', which
2954 is equivalent of d:./foo, which is totally different from d:/foo. */
2955 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
2958 dir_name
[3] = '\000';
2962 /* Canonicalize the directory prefix, and build the resulting
2963 filename. If the dirname realpath already contains an ending
2964 directory separator, avoid doubling it. */
2965 real_path
= gdb_realpath (dir_name
);
2966 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2967 result
= concat (real_path
, base_name
, (char *) NULL
);
2969 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *) NULL
);
2975 /* Return PATH in absolute form, performing tilde-expansion if necessary.
2976 PATH cannot be NULL or the empty string.
2977 This does not resolve symlinks however, use gdb_realpath for that.
2978 Space for the result is allocated with malloc.
2979 If the path is already absolute, it is strdup'd.
2980 If there is a problem computing the absolute path, the path is returned
2981 unchanged (still strdup'd). */
2984 gdb_abspath (const char *path
)
2986 gdb_assert (path
!= NULL
&& path
[0] != '\0');
2989 return tilde_expand (path
);
2991 if (IS_ABSOLUTE_PATH (path
))
2992 return xstrdup (path
);
2994 /* Beware the // my son, the Emacs barfs, the botch that catch... */
2995 return concat (current_directory
,
2996 IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1])
2997 ? "" : SLASH_STRING
,
2998 path
, (char *) NULL
);
3002 align_up (ULONGEST v
, int n
)
3004 /* Check that N is really a power of two. */
3005 gdb_assert (n
&& (n
& (n
-1)) == 0);
3006 return (v
+ n
- 1) & -n
;
3010 align_down (ULONGEST v
, int n
)
3012 /* Check that N is really a power of two. */
3013 gdb_assert (n
&& (n
& (n
-1)) == 0);
3017 /* Allocation function for the libiberty hash table which uses an
3018 obstack. The obstack is passed as DATA. */
3021 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3023 size_t total
= size
* count
;
3024 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3026 memset (ptr
, 0, total
);
3030 /* Trivial deallocation function for the libiberty splay tree and hash
3031 table - don't deallocate anything. Rely on later deletion of the
3032 obstack. DATA will be the obstack, although it is not needed
3036 dummy_obstack_deallocate (void *object
, void *data
)
3041 /* Simple, portable version of dirname that does not modify its
3045 ldirname (const char *filename
)
3047 const char *base
= lbasename (filename
);
3050 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3053 if (base
== filename
)
3056 dirname
= (char *) xmalloc (base
- filename
+ 2);
3057 memcpy (dirname
, filename
, base
- filename
);
3059 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3060 create "d:./bar" later instead of the (different) "d:/bar". */
3061 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3062 && !IS_DIR_SEPARATOR (filename
[0]))
3063 dirname
[base
++ - filename
] = '.';
3065 dirname
[base
- filename
] = '\0';
3069 /* Call libiberty's buildargv, and return the result.
3070 If buildargv fails due to out-of-memory, call nomem.
3071 Therefore, the returned value is guaranteed to be non-NULL,
3072 unless the parameter itself is NULL. */
3075 gdb_buildargv (const char *s
)
3077 char **argv
= buildargv (s
);
3079 if (s
!= NULL
&& argv
== NULL
)
3085 compare_positive_ints (const void *ap
, const void *bp
)
3087 /* Because we know we're comparing two ints which are positive,
3088 there's no danger of overflow here. */
3089 return * (int *) ap
- * (int *) bp
;
3092 /* String compare function for qsort. */
3095 compare_strings (const void *arg1
, const void *arg2
)
3097 const char **s1
= (const char **) arg1
;
3098 const char **s2
= (const char **) arg2
;
3100 return strcmp (*s1
, *s2
);
3103 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3104 #define AMBIGUOUS_MESS2 \
3105 ".\nUse \"set gnutarget format-name\" to specify the format."
3108 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
3114 /* Check if errmsg just need simple return. */
3115 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
3116 return bfd_errmsg (error_tag
);
3118 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
3119 + strlen (AMBIGUOUS_MESS2
);
3120 for (p
= matching
; *p
; p
++)
3121 ret_len
+= strlen (*p
) + 1;
3122 ret
= (char *) xmalloc (ret_len
+ 1);
3124 make_cleanup (xfree
, ret
);
3126 strcpy (retp
, bfd_errmsg (error_tag
));
3127 retp
+= strlen (retp
);
3129 strcpy (retp
, AMBIGUOUS_MESS1
);
3130 retp
+= strlen (retp
);
3132 for (p
= matching
; *p
; p
++)
3134 sprintf (retp
, " %s", *p
);
3135 retp
+= strlen (retp
);
3139 strcpy (retp
, AMBIGUOUS_MESS2
);
3144 /* Return ARGS parsed as a valid pid, or throw an error. */
3147 parse_pid_to_attach (const char *args
)
3153 error_no_arg (_("process-id to attach"));
3155 dummy
= (char *) args
;
3156 pid
= strtoul (args
, &dummy
, 0);
3157 /* Some targets don't set errno on errors, grrr! */
3158 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
3159 error (_("Illegal process-id: %s."), args
);
3164 /* Helper for make_bpstat_clear_actions_cleanup. */
3167 do_bpstat_clear_actions_cleanup (void *unused
)
3169 bpstat_clear_actions ();
3172 /* Call bpstat_clear_actions for the case an exception is throw. You should
3173 discard_cleanups if no exception is caught. */
3176 make_bpstat_clear_actions_cleanup (void)
3178 return make_cleanup (do_bpstat_clear_actions_cleanup
, NULL
);
3181 /* Check for GCC >= 4.x according to the symtab->producer string. Return minor
3182 version (x) of 4.x in such case. If it is not GCC or it is GCC older than
3183 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
3186 producer_is_gcc_ge_4 (const char *producer
)
3190 if (! producer_is_gcc (producer
, &major
, &minor
))
3199 /* Returns nonzero if the given PRODUCER string is GCC and sets the MAJOR
3200 and MINOR versions when not NULL. Returns zero if the given PRODUCER
3201 is NULL or it isn't GCC. */
3204 producer_is_gcc (const char *producer
, int *major
, int *minor
)
3208 if (producer
!= NULL
&& startswith (producer
, "GNU "))
3217 /* Skip any identifier after "GNU " - such as "C11" "C++" or "Java".
3218 A full producer string might look like:
3220 "GNU Fortran 4.8.2 20140120 (Red Hat 4.8.2-16) -mtune=generic ..."
3221 "GNU C++14 5.0.0 20150123 (experimental)"
3223 cs
= &producer
[strlen ("GNU ")];
3224 while (*cs
&& !isspace (*cs
))
3226 if (*cs
&& isspace (*cs
))
3228 if (sscanf (cs
, "%d.%d", major
, minor
) == 2)
3232 /* Not recognized as GCC. */
3236 /* Helper for make_cleanup_free_char_ptr_vec. */
3239 do_free_char_ptr_vec (void *arg
)
3241 VEC (char_ptr
) *char_ptr_vec
= (VEC (char_ptr
) *) arg
;
3243 free_char_ptr_vec (char_ptr_vec
);
3246 /* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
3247 final VEC_free for CHAR_PTR_VEC itself.
3249 You must not modify CHAR_PTR_VEC after this cleanup registration as the
3250 CHAR_PTR_VEC base address may change on its updates. Contrary to VEC_free
3251 this function does not (cannot) clear the pointer. */
3254 make_cleanup_free_char_ptr_vec (VEC (char_ptr
) *char_ptr_vec
)
3256 return make_cleanup (do_free_char_ptr_vec
, char_ptr_vec
);
3259 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3260 must come from xrealloc-compatible allocator and it may be updated. FROM
3261 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3262 located at the start or end of *STRINGP. */
3265 substitute_path_component (char **stringp
, const char *from
, const char *to
)
3267 char *string
= *stringp
, *s
;
3268 const size_t from_len
= strlen (from
);
3269 const size_t to_len
= strlen (to
);
3273 s
= strstr (s
, from
);
3277 if ((s
== string
|| IS_DIR_SEPARATOR (s
[-1])
3278 || s
[-1] == DIRNAME_SEPARATOR
)
3279 && (s
[from_len
] == '\0' || IS_DIR_SEPARATOR (s
[from_len
])
3280 || s
[from_len
] == DIRNAME_SEPARATOR
))
3285 = (char *) xrealloc (string
, (strlen (string
) + to_len
+ 1));
3287 /* Relocate the current S pointer. */
3288 s
= s
- string
+ string_new
;
3289 string
= string_new
;
3291 /* Replace from by to. */
3292 memmove (&s
[to_len
], &s
[from_len
], strlen (&s
[from_len
]) + 1);
3293 memcpy (s
, to
, to_len
);
3308 /* SIGALRM handler for waitpid_with_timeout. */
3311 sigalrm_handler (int signo
)
3313 /* Nothing to do. */
3318 /* Wrapper to wait for child PID to die with TIMEOUT.
3319 TIMEOUT is the time to stop waiting in seconds.
3320 If TIMEOUT is zero, pass WNOHANG to waitpid.
3321 Returns PID if it was successfully waited for, otherwise -1.
3323 Timeouts are currently implemented with alarm and SIGALRM.
3324 If the host does not support them, this waits "forever".
3325 It would be odd though for a host to have waitpid and not SIGALRM. */
3328 wait_to_die_with_timeout (pid_t pid
, int *status
, int timeout
)
3330 pid_t waitpid_result
;
3332 gdb_assert (pid
> 0);
3333 gdb_assert (timeout
>= 0);
3338 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3339 struct sigaction sa
, old_sa
;
3341 sa
.sa_handler
= sigalrm_handler
;
3342 sigemptyset (&sa
.sa_mask
);
3344 sigaction (SIGALRM
, &sa
, &old_sa
);
3348 ofunc
= signal (SIGALRM
, sigalrm_handler
);
3354 waitpid_result
= waitpid (pid
, status
, 0);
3358 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3359 sigaction (SIGALRM
, &old_sa
, NULL
);
3361 signal (SIGALRM
, ofunc
);
3366 waitpid_result
= waitpid (pid
, status
, WNOHANG
);
3368 if (waitpid_result
== pid
)
3374 #endif /* HAVE_WAITPID */
3376 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3377 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3379 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3380 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3383 gdb_filename_fnmatch (const char *pattern
, const char *string
, int flags
)
3385 gdb_assert ((flags
& FNM_FILE_NAME
) != 0);
3387 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3388 gdb_assert ((flags
& FNM_NOESCAPE
) != 0);
3390 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3392 char *pattern_slash
, *string_slash
;
3394 /* Replace '\' by '/' in both strings. */
3396 pattern_slash
= (char *) alloca (strlen (pattern
) + 1);
3397 strcpy (pattern_slash
, pattern
);
3398 pattern
= pattern_slash
;
3399 for (; *pattern_slash
!= 0; pattern_slash
++)
3400 if (IS_DIR_SEPARATOR (*pattern_slash
))
3401 *pattern_slash
= '/';
3403 string_slash
= (char *) alloca (strlen (string
) + 1);
3404 strcpy (string_slash
, string
);
3405 string
= string_slash
;
3406 for (; *string_slash
!= 0; string_slash
++)
3407 if (IS_DIR_SEPARATOR (*string_slash
))
3408 *string_slash
= '/';
3410 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3412 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3413 flags
|= FNM_CASEFOLD
;
3414 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3416 return fnmatch (pattern
, string
, flags
);
3419 /* Return the number of path elements in PATH.
3427 count_path_elements (const char *path
)
3430 const char *p
= path
;
3432 if (HAS_DRIVE_SPEC (p
))
3434 p
= STRIP_DRIVE_SPEC (p
);
3440 if (IS_DIR_SEPARATOR (*p
))
3445 /* Backup one if last character is /, unless it's the only one. */
3446 if (p
> path
+ 1 && IS_DIR_SEPARATOR (p
[-1]))
3449 /* Add one for the file name, if present. */
3450 if (p
> path
&& !IS_DIR_SEPARATOR (p
[-1]))
3456 /* Remove N leading path elements from PATH.
3457 N must be non-negative.
3458 If PATH has more than N path elements then return NULL.
3459 If PATH has exactly N path elements then return "".
3460 See count_path_elements for a description of how we do the counting. */
3463 strip_leading_path_elements (const char *path
, int n
)
3466 const char *p
= path
;
3468 gdb_assert (n
>= 0);
3473 if (HAS_DRIVE_SPEC (p
))
3475 p
= STRIP_DRIVE_SPEC (p
);
3481 while (*p
!= '\0' && !IS_DIR_SEPARATOR (*p
))
3496 /* Provide a prototype to silence -Wmissing-prototypes. */
3497 extern initialize_file_ftype _initialize_utils
;
3500 _initialize_utils (void)
3502 add_internal_problem_command (&internal_error_problem
);
3503 add_internal_problem_command (&internal_warning_problem
);
3504 add_internal_problem_command (&demangler_warning_problem
);