1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
5 2009, 2010 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_assert.h"
25 #include "gdb_string.h"
26 #include "event-top.h"
27 #include "exceptions.h"
28 #include "gdbthread.h"
29 #ifdef HAVE_SYS_RESOURCE_H
30 #include <sys/resource.h>
31 #endif /* HAVE_SYS_RESOURCE_H */
34 #include "tui/tui.h" /* For tui_get_command_dimension. */
41 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
52 #include "expression.h"
56 #include "filenames.h"
58 #include "gdb_obstack.h"
63 #include "inferior.h" /* for signed_pointer_to_address */
65 #include <sys/param.h> /* For MAXPATHLEN */
67 #include "gdb_curses.h"
69 #include "readline/readline.h"
74 #include "gdb_usleep.h"
78 extern PTR
malloc (); /* ARI: PTR */
80 #if !HAVE_DECL_REALLOC
81 extern PTR
realloc (); /* ARI: PTR */
87 /* readline defines this. */
90 void (*deprecated_error_begin_hook
) (void);
92 /* Prototypes for local functions */
94 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
95 va_list, int) ATTRIBUTE_PRINTF (2, 0);
97 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
99 static void do_my_cleanups (struct cleanup
**, struct cleanup
*);
101 static void prompt_for_continue (void);
103 static void set_screen_size (void);
104 static void set_width (void);
106 /* A flag indicating whether to timestamp debugging messages. */
108 static int debug_timestamp
= 0;
110 /* Chain of cleanup actions established with make_cleanup,
111 to be executed if an error happens. */
113 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
114 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
116 /* Nonzero if we have job control. */
120 /* Nonzero means a quit has been requested. */
124 /* Nonzero means quit immediately if Control-C is typed now, rather
125 than waiting until QUIT is executed. Be careful in setting this;
126 code which executes with immediate_quit set has to be very careful
127 about being able to deal with being interrupted at any time. It is
128 almost always better to use QUIT; the only exception I can think of
129 is being able to quit out of a system call (using EINTR loses if
130 the SIGINT happens between the previous QUIT and the system call).
131 To immediately quit in the case in which a SIGINT happens between
132 the previous QUIT and setting immediate_quit (desirable anytime we
133 expect to block), call QUIT after setting immediate_quit. */
137 /* Nonzero means that encoded C++/ObjC names should be printed out in their
138 C++/ObjC form rather than raw. */
142 show_demangle (struct ui_file
*file
, int from_tty
,
143 struct cmd_list_element
*c
, const char *value
)
145 fprintf_filtered (file
, _("\
146 Demangling of encoded C++/ObjC names when displaying symbols is %s.\n"),
150 /* Nonzero means that encoded C++/ObjC names should be printed out in their
151 C++/ObjC form even in assembler language displays. If this is set, but
152 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
154 int asm_demangle
= 0;
156 show_asm_demangle (struct ui_file
*file
, int from_tty
,
157 struct cmd_list_element
*c
, const char *value
)
159 fprintf_filtered (file
, _("\
160 Demangling of C++/ObjC names in disassembly listings is %s.\n"),
164 /* Nonzero means that strings with character values >0x7F should be printed
165 as octal escapes. Zero means just print the value (e.g. it's an
166 international character, and the terminal or window can cope.) */
168 int sevenbit_strings
= 0;
170 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
171 struct cmd_list_element
*c
, const char *value
)
173 fprintf_filtered (file
, _("\
174 Printing of 8-bit characters in strings as \\nnn is %s.\n"),
178 /* String to be printed before error messages, if any. */
180 char *error_pre_print
;
182 /* String to be printed before quit messages, if any. */
184 char *quit_pre_print
;
186 /* String to be printed before warning messages, if any. */
188 char *warning_pre_print
= "\nwarning: ";
190 int pagination_enabled
= 1;
192 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
193 struct cmd_list_element
*c
, const char *value
)
195 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
200 /* Add a new cleanup to the cleanup_chain,
201 and return the previous chain pointer
202 to be passed later to do_cleanups or discard_cleanups.
203 Args are FUNCTION to clean up with, and ARG to pass to it. */
206 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
208 return make_my_cleanup (&cleanup_chain
, function
, arg
);
212 make_cleanup_dtor (make_cleanup_ftype
*function
, void *arg
,
213 void (*dtor
) (void *))
215 return make_my_cleanup2 (&cleanup_chain
,
216 function
, arg
, dtor
);
220 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
222 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
226 do_freeargv (void *arg
)
228 freeargv ((char **) arg
);
232 make_cleanup_freeargv (char **arg
)
234 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
238 do_bfd_close_cleanup (void *arg
)
244 make_cleanup_bfd_close (bfd
*abfd
)
246 return make_cleanup (do_bfd_close_cleanup
, abfd
);
250 do_close_cleanup (void *arg
)
257 make_cleanup_close (int fd
)
259 int *saved_fd
= xmalloc (sizeof (fd
));
261 return make_cleanup_dtor (do_close_cleanup
, saved_fd
, xfree
);
264 /* Helper function which does the work for make_cleanup_fclose. */
267 do_fclose_cleanup (void *arg
)
273 /* Return a new cleanup that closes FILE. */
276 make_cleanup_fclose (FILE *file
)
278 return make_cleanup (do_fclose_cleanup
, file
);
281 /* Helper function which does the work for make_cleanup_obstack_free. */
284 do_obstack_free (void *arg
)
286 struct obstack
*ob
= arg
;
287 obstack_free (ob
, NULL
);
290 /* Return a new cleanup that frees OBSTACK. */
293 make_cleanup_obstack_free (struct obstack
*obstack
)
295 return make_cleanup (do_obstack_free
, obstack
);
299 do_ui_file_delete (void *arg
)
301 ui_file_delete (arg
);
305 make_cleanup_ui_file_delete (struct ui_file
*arg
)
307 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
311 do_free_section_addr_info (void *arg
)
313 free_section_addr_info (arg
);
317 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
319 return make_my_cleanup (&cleanup_chain
, do_free_section_addr_info
, addrs
);
322 struct restore_integer_closure
329 restore_integer (void *p
)
331 struct restore_integer_closure
*closure
= p
;
332 *(closure
->variable
) = closure
->value
;
335 /* Remember the current value of *VARIABLE and make it restored when the cleanup
338 make_cleanup_restore_integer (int *variable
)
340 struct restore_integer_closure
*c
=
341 xmalloc (sizeof (struct restore_integer_closure
));
342 c
->variable
= variable
;
343 c
->value
= *variable
;
345 return make_my_cleanup2 (&cleanup_chain
, restore_integer
, (void *)c
,
350 make_my_cleanup2 (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
351 void *arg
, void (*free_arg
) (void *))
354 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
355 struct cleanup
*old_chain
= *pmy_chain
;
357 new->next
= *pmy_chain
;
358 new->function
= function
;
359 new->free_arg
= free_arg
;
367 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
370 return make_my_cleanup2 (pmy_chain
, function
, arg
, NULL
);
373 /* Discard cleanups and do the actions they describe
374 until we get back to the point OLD_CHAIN in the cleanup_chain. */
377 do_cleanups (struct cleanup
*old_chain
)
379 do_my_cleanups (&cleanup_chain
, old_chain
);
383 do_final_cleanups (struct cleanup
*old_chain
)
385 do_my_cleanups (&final_cleanup_chain
, old_chain
);
389 do_my_cleanups (struct cleanup
**pmy_chain
,
390 struct cleanup
*old_chain
)
393 while ((ptr
= *pmy_chain
) != old_chain
)
395 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
396 (*ptr
->function
) (ptr
->arg
);
398 (*ptr
->free_arg
) (ptr
->arg
);
403 /* Discard cleanups, not doing the actions they describe,
404 until we get back to the point OLD_CHAIN in the cleanup_chain. */
407 discard_cleanups (struct cleanup
*old_chain
)
409 discard_my_cleanups (&cleanup_chain
, old_chain
);
413 discard_final_cleanups (struct cleanup
*old_chain
)
415 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
419 discard_my_cleanups (struct cleanup
**pmy_chain
,
420 struct cleanup
*old_chain
)
423 while ((ptr
= *pmy_chain
) != old_chain
)
425 *pmy_chain
= ptr
->next
;
427 (*ptr
->free_arg
) (ptr
->arg
);
432 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
436 return save_my_cleanups (&cleanup_chain
);
440 save_final_cleanups (void)
442 return save_my_cleanups (&final_cleanup_chain
);
446 save_my_cleanups (struct cleanup
**pmy_chain
)
448 struct cleanup
*old_chain
= *pmy_chain
;
454 /* Restore the cleanup chain from a previously saved chain. */
456 restore_cleanups (struct cleanup
*chain
)
458 restore_my_cleanups (&cleanup_chain
, chain
);
462 restore_final_cleanups (struct cleanup
*chain
)
464 restore_my_cleanups (&final_cleanup_chain
, chain
);
468 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
473 /* This function is useful for cleanups.
477 old_chain = make_cleanup (free_current_contents, &foo);
479 to arrange to free the object thus allocated. */
482 free_current_contents (void *ptr
)
484 void **location
= ptr
;
485 if (location
== NULL
)
486 internal_error (__FILE__
, __LINE__
,
487 _("free_current_contents: NULL pointer"));
488 if (*location
!= NULL
)
495 /* Provide a known function that does nothing, to use as a base for
496 for a possibly long chain of cleanups. This is useful where we
497 use the cleanup chain for handling normal cleanups as well as dealing
498 with cleanups that need to be done as a result of a call to error().
499 In such cases, we may not be certain where the first cleanup is, unless
500 we have a do-nothing one to always use as the base. */
503 null_cleanup (void *arg
)
507 /* Continuations are implemented as cleanups internally. Inherit from
514 /* Add a continuation to the continuation list of THREAD. The new
515 continuation will be added at the front. */
517 add_continuation (struct thread_info
*thread
,
518 void (*continuation_hook
) (void *), void *args
,
519 void (*continuation_free_args
) (void *))
521 struct cleanup
*as_cleanup
= &thread
->continuations
->base
;
522 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
524 make_my_cleanup2 (&as_cleanup
,
525 continuation_hook_fn
,
527 continuation_free_args
);
529 thread
->continuations
= (struct continuation
*) as_cleanup
;
532 /* Add a continuation to the continuation list of INFERIOR. The new
533 continuation will be added at the front. */
536 add_inferior_continuation (void (*continuation_hook
) (void *), void *args
,
537 void (*continuation_free_args
) (void *))
539 struct inferior
*inf
= current_inferior ();
540 struct cleanup
*as_cleanup
= &inf
->continuations
->base
;
541 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
543 make_my_cleanup2 (&as_cleanup
,
544 continuation_hook_fn
,
546 continuation_free_args
);
548 inf
->continuations
= (struct continuation
*) as_cleanup
;
551 /* Do all continuations of the current inferior. */
554 do_all_inferior_continuations (void)
556 struct cleanup
*old_chain
;
557 struct cleanup
*as_cleanup
;
558 struct inferior
*inf
= current_inferior ();
560 if (inf
->continuations
== NULL
)
563 /* Copy the list header into another pointer, and set the global
564 list header to null, so that the global list can change as a side
565 effect of invoking the continuations and the processing of the
566 preexisting continuations will not be affected. */
568 as_cleanup
= &inf
->continuations
->base
;
569 inf
->continuations
= NULL
;
571 /* Work now on the list we have set aside. */
572 do_my_cleanups (&as_cleanup
, NULL
);
575 /* Get rid of all the inferior-wide continuations of INF. */
578 discard_all_inferior_continuations (struct inferior
*inf
)
580 struct cleanup
*continuation_ptr
= &inf
->continuations
->base
;
581 discard_my_cleanups (&continuation_ptr
, NULL
);
582 inf
->continuations
= NULL
;
586 restore_thread_cleanup (void *arg
)
588 ptid_t
*ptid_p
= arg
;
589 switch_to_thread (*ptid_p
);
592 /* Walk down the continuation list of PTID, and execute all the
593 continuations. There is a problem though. In some cases new
594 continuations may be added while we are in the middle of this loop.
595 If this happens they will be added in the front, and done before we
596 have a chance of exhausting those that were already there. We need
597 to then save the beginning of the list in a pointer and do the
598 continuations from there on, instead of using the global beginning
599 of list as our iteration pointer. */
601 do_all_continuations_ptid (ptid_t ptid
,
602 struct continuation
**continuations_p
)
604 struct cleanup
*old_chain
;
605 ptid_t current_thread
;
606 struct cleanup
*as_cleanup
;
608 if (*continuations_p
== NULL
)
611 current_thread
= inferior_ptid
;
613 /* Restore selected thread on exit. Don't try to restore the frame
616 - When running continuations, the selected frame is always #0.
618 - The continuations may trigger symbol file loads, which may
619 change the frame layout (frame ids change), which would trigger
620 a warning if we used make_cleanup_restore_current_thread. */
622 old_chain
= make_cleanup (restore_thread_cleanup
, ¤t_thread
);
624 /* Let the continuation see this thread as selected. */
625 switch_to_thread (ptid
);
627 /* Copy the list header into another pointer, and set the global
628 list header to null, so that the global list can change as a side
629 effect of invoking the continuations and the processing of the
630 preexisting continuations will not be affected. */
632 as_cleanup
= &(*continuations_p
)->base
;
633 *continuations_p
= NULL
;
635 /* Work now on the list we have set aside. */
636 do_my_cleanups (&as_cleanup
, NULL
);
638 do_cleanups (old_chain
);
641 /* Callback for iterate over threads. */
643 do_all_continuations_thread_callback (struct thread_info
*thread
, void *data
)
645 do_all_continuations_ptid (thread
->ptid
, &thread
->continuations
);
649 /* Do all continuations of thread THREAD. */
651 do_all_continuations_thread (struct thread_info
*thread
)
653 do_all_continuations_thread_callback (thread
, NULL
);
656 /* Do all continuations of all threads. */
658 do_all_continuations (void)
660 iterate_over_threads (do_all_continuations_thread_callback
, NULL
);
663 /* Callback for iterate over threads. */
665 discard_all_continuations_thread_callback (struct thread_info
*thread
,
668 struct cleanup
*continuation_ptr
= &thread
->continuations
->base
;
669 discard_my_cleanups (&continuation_ptr
, NULL
);
670 thread
->continuations
= NULL
;
674 /* Get rid of all the continuations of THREAD. */
676 discard_all_continuations_thread (struct thread_info
*thread
)
678 discard_all_continuations_thread_callback (thread
, NULL
);
681 /* Get rid of all the continuations of all threads. */
683 discard_all_continuations (void)
685 iterate_over_threads (discard_all_continuations_thread_callback
, NULL
);
689 /* Add a continuation to the intermediate continuation list of THREAD.
690 The new continuation will be added at the front. */
692 add_intermediate_continuation (struct thread_info
*thread
,
693 void (*continuation_hook
)
694 (void *), void *args
,
695 void (*continuation_free_args
) (void *))
697 struct cleanup
*as_cleanup
= &thread
->intermediate_continuations
->base
;
698 make_cleanup_ftype
*continuation_hook_fn
= continuation_hook
;
700 make_my_cleanup2 (&as_cleanup
,
701 continuation_hook_fn
,
703 continuation_free_args
);
705 thread
->intermediate_continuations
= (struct continuation
*) as_cleanup
;
708 /* Walk down the cmd_continuation list, and execute all the
709 continuations. There is a problem though. In some cases new
710 continuations may be added while we are in the middle of this
711 loop. If this happens they will be added in the front, and done
712 before we have a chance of exhausting those that were already
713 there. We need to then save the beginning of the list in a pointer
714 and do the continuations from there on, instead of using the
715 global beginning of list as our iteration pointer.*/
717 do_all_intermediate_continuations_thread_callback (struct thread_info
*thread
,
720 do_all_continuations_ptid (thread
->ptid
,
721 &thread
->intermediate_continuations
);
725 /* Do all intermediate continuations of thread THREAD. */
727 do_all_intermediate_continuations_thread (struct thread_info
*thread
)
729 do_all_intermediate_continuations_thread_callback (thread
, NULL
);
732 /* Do all intermediate continuations of all threads. */
734 do_all_intermediate_continuations (void)
736 iterate_over_threads (do_all_intermediate_continuations_thread_callback
, NULL
);
739 /* Callback for iterate over threads. */
741 discard_all_intermediate_continuations_thread_callback (struct thread_info
*thread
,
744 struct cleanup
*continuation_ptr
= &thread
->intermediate_continuations
->base
;
745 discard_my_cleanups (&continuation_ptr
, NULL
);
746 thread
->intermediate_continuations
= NULL
;
750 /* Get rid of all the intermediate continuations of THREAD. */
752 discard_all_intermediate_continuations_thread (struct thread_info
*thread
)
754 discard_all_intermediate_continuations_thread_callback (thread
, NULL
);
757 /* Get rid of all the intermediate continuations of all threads. */
759 discard_all_intermediate_continuations (void)
761 iterate_over_threads (discard_all_intermediate_continuations_thread_callback
, NULL
);
766 /* Print a warning message. The first argument STRING is the warning
767 message, used as an fprintf format string, the second is the
768 va_list of arguments for that string. A warning is unfiltered (not
769 paginated) so that the user does not need to page through each
770 screen full of warnings when there are lots of them. */
773 vwarning (const char *string
, va_list args
)
775 if (deprecated_warning_hook
)
776 (*deprecated_warning_hook
) (string
, args
);
779 target_terminal_ours ();
780 wrap_here (""); /* Force out any buffered output */
781 gdb_flush (gdb_stdout
);
782 if (warning_pre_print
)
783 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
784 vfprintf_unfiltered (gdb_stderr
, string
, args
);
785 fprintf_unfiltered (gdb_stderr
, "\n");
790 /* Print a warning message.
791 The first argument STRING is the warning message, used as a fprintf string,
792 and the remaining args are passed as arguments to it.
793 The primary difference between warnings and errors is that a warning
794 does not force the return to command level. */
797 warning (const char *string
, ...)
800 va_start (args
, string
);
801 vwarning (string
, args
);
805 /* Print an error message and return to command level.
806 The first argument STRING is the error message, used as a fprintf string,
807 and the remaining args are passed as arguments to it. */
810 verror (const char *string
, va_list args
)
812 throw_verror (GENERIC_ERROR
, string
, args
);
816 error (const char *string
, ...)
819 va_start (args
, string
);
820 throw_verror (GENERIC_ERROR
, string
, args
);
824 /* Print an error message and quit.
825 The first argument STRING is the error message, used as a fprintf string,
826 and the remaining args are passed as arguments to it. */
829 vfatal (const char *string
, va_list args
)
831 throw_vfatal (string
, args
);
835 fatal (const char *string
, ...)
838 va_start (args
, string
);
839 throw_vfatal (string
, args
);
844 error_stream (struct ui_file
*stream
)
846 char *message
= ui_file_xstrdup (stream
, NULL
);
847 make_cleanup (xfree
, message
);
848 error (("%s"), message
);
851 /* Dump core trying to increase the core soft limit to hard limit first. */
856 #ifdef HAVE_SETRLIMIT
857 struct rlimit rlim
= { RLIM_INFINITY
, RLIM_INFINITY
};
859 setrlimit (RLIMIT_CORE
, &rlim
);
860 #endif /* HAVE_SETRLIMIT */
862 abort (); /* NOTE: GDB has only three calls to abort(). */
865 /* Check whether GDB will be able to dump core using the dump_core function. */
868 can_dump_core (const char *reason
)
870 #ifdef HAVE_GETRLIMIT
873 /* Be quiet and assume we can dump if an error is returned. */
874 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
877 if (rlim
.rlim_max
== 0)
879 fprintf_unfiltered (gdb_stderr
,
880 _("%s\nUnable to dump core, use `ulimit -c unlimited'"
881 " before executing GDB next time.\n"), reason
);
884 #endif /* HAVE_GETRLIMIT */
889 /* Allow the user to configure the debugger behavior with respect to
890 what to do when an internal problem is detected. */
892 const char internal_problem_ask
[] = "ask";
893 const char internal_problem_yes
[] = "yes";
894 const char internal_problem_no
[] = "no";
895 static const char *internal_problem_modes
[] =
897 internal_problem_ask
,
898 internal_problem_yes
,
902 static const char *internal_problem_mode
= internal_problem_ask
;
904 /* Print a message reporting an internal error/warning. Ask the user
905 if they want to continue, dump core, or just exit. Return
906 something to indicate a quit. */
908 struct internal_problem
911 const char *should_quit
;
912 const char *should_dump_core
;
915 /* Report a problem, internal to GDB, to the user. Once the problem
916 has been reported, and assuming GDB didn't quit, the caller can
917 either allow execution to resume or throw an error. */
919 static void ATTRIBUTE_PRINTF (4, 0)
920 internal_vproblem (struct internal_problem
*problem
,
921 const char *file
, int line
, const char *fmt
, va_list ap
)
928 /* Don't allow infinite error/warning recursion. */
930 static char msg
[] = "Recursive internal problem.\n";
938 fputs_unfiltered (msg
, gdb_stderr
);
939 abort (); /* NOTE: GDB has only three calls to abort(). */
942 /* Newer GLIBC versions put the warn_unused_result attribute
943 on write, but this is one of those rare cases where
944 ignoring the return value is correct. Casting to (void)
945 does not fix this problem. This is the solution suggested
946 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
947 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
948 abort (); /* NOTE: GDB has only three calls to abort(). */
953 /* Try to get the message out and at the start of a new line. */
954 target_terminal_ours ();
957 /* Create a string containing the full error/warning message. Need
958 to call query with this full string, as otherwize the reason
959 (error/warning) and question become separated. Format using a
960 style similar to a compiler error message. Include extra detail
961 so that the user knows that they are living on the edge. */
964 msg
= xstrvprintf (fmt
, ap
);
965 reason
= xstrprintf ("\
967 A problem internal to GDB has been detected,\n\
968 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
970 make_cleanup (xfree
, reason
);
973 if (problem
->should_quit
== internal_problem_ask
)
975 /* Default (yes/batch case) is to quit GDB. When in batch mode
976 this lessens the likelihood of GDB going into an infinite
980 /* Emit the message and quit. */
981 fputs_unfiltered (reason
, gdb_stderr
);
982 fputs_unfiltered ("\n", gdb_stderr
);
986 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
988 else if (problem
->should_quit
== internal_problem_yes
)
990 else if (problem
->should_quit
== internal_problem_no
)
993 internal_error (__FILE__
, __LINE__
, _("bad switch"));
995 if (problem
->should_dump_core
== internal_problem_ask
)
997 if (!can_dump_core (reason
))
1001 /* Default (yes/batch case) is to dump core. This leaves a GDB
1002 `dropping' so that it is easier to see that something went
1004 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
1007 else if (problem
->should_dump_core
== internal_problem_yes
)
1008 dump_core_p
= can_dump_core (reason
);
1009 else if (problem
->should_dump_core
== internal_problem_no
)
1012 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1025 #ifdef HAVE_WORKING_FORK
1035 static struct internal_problem internal_error_problem
= {
1036 "internal-error", internal_problem_ask
, internal_problem_ask
1040 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
1042 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
1043 deprecated_throw_reason (RETURN_ERROR
);
1047 internal_error (const char *file
, int line
, const char *string
, ...)
1050 va_start (ap
, string
);
1051 internal_verror (file
, line
, string
, ap
);
1055 static struct internal_problem internal_warning_problem
= {
1056 "internal-warning", internal_problem_ask
, internal_problem_ask
1060 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
1062 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
1066 internal_warning (const char *file
, int line
, const char *string
, ...)
1069 va_start (ap
, string
);
1070 internal_vwarning (file
, line
, string
, ap
);
1074 /* Dummy functions to keep add_prefix_cmd happy. */
1077 set_internal_problem_cmd (char *args
, int from_tty
)
1082 show_internal_problem_cmd (char *args
, int from_tty
)
1086 /* When GDB reports an internal problem (error or warning) it gives
1087 the user the opportunity to quit GDB and/or create a core file of
1088 the current debug session. This function registers a few commands
1089 that make it possible to specify that GDB should always or never
1090 quit or create a core file, without asking. The commands look
1093 maint set PROBLEM-NAME quit ask|yes|no
1094 maint show PROBLEM-NAME quit
1095 maint set PROBLEM-NAME corefile ask|yes|no
1096 maint show PROBLEM-NAME corefile
1098 Where PROBLEM-NAME is currently "internal-error" or
1099 "internal-warning". */
1102 add_internal_problem_command (struct internal_problem
*problem
)
1104 struct cmd_list_element
**set_cmd_list
;
1105 struct cmd_list_element
**show_cmd_list
;
1109 set_cmd_list
= xmalloc (sizeof (*set_cmd_list
));
1110 show_cmd_list
= xmalloc (sizeof (*set_cmd_list
));
1111 *set_cmd_list
= NULL
;
1112 *show_cmd_list
= NULL
;
1114 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
1117 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
1120 add_prefix_cmd ((char*) problem
->name
,
1121 class_maintenance
, set_internal_problem_cmd
, set_doc
,
1123 concat ("maintenance set ", problem
->name
, " ",
1125 0/*allow-unknown*/, &maintenance_set_cmdlist
);
1127 add_prefix_cmd ((char*) problem
->name
,
1128 class_maintenance
, show_internal_problem_cmd
, show_doc
,
1130 concat ("maintenance show ", problem
->name
, " ",
1132 0/*allow-unknown*/, &maintenance_show_cmdlist
);
1134 set_doc
= xstrprintf (_("\
1135 Set whether GDB should quit when an %s is detected"),
1137 show_doc
= xstrprintf (_("\
1138 Show whether GDB will quit when an %s is detected"),
1140 add_setshow_enum_cmd ("quit", class_maintenance
,
1141 internal_problem_modes
,
1142 &problem
->should_quit
,
1145 NULL
, /* help_doc */
1147 NULL
, /* showfunc */
1154 set_doc
= xstrprintf (_("\
1155 Set whether GDB should create a core file of GDB when %s is detected"),
1157 show_doc
= xstrprintf (_("\
1158 Show whether GDB will create a core file of GDB when %s is detected"),
1160 add_setshow_enum_cmd ("corefile", class_maintenance
,
1161 internal_problem_modes
,
1162 &problem
->should_dump_core
,
1165 NULL
, /* help_doc */
1167 NULL
, /* showfunc */
1175 /* Print the system error message for errno, and also mention STRING
1176 as the file name for which the error was encountered.
1177 Then return to command level. */
1180 perror_with_name (const char *string
)
1185 err
= safe_strerror (errno
);
1186 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1187 strcpy (combined
, string
);
1188 strcat (combined
, ": ");
1189 strcat (combined
, err
);
1191 /* I understand setting these is a matter of taste. Still, some people
1192 may clear errno but not know about bfd_error. Doing this here is not
1194 bfd_set_error (bfd_error_no_error
);
1197 error (_("%s."), combined
);
1200 /* Print the system error message for ERRCODE, and also mention STRING
1201 as the file name for which the error was encountered. */
1204 print_sys_errmsg (const char *string
, int errcode
)
1209 err
= safe_strerror (errcode
);
1210 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1211 strcpy (combined
, string
);
1212 strcat (combined
, ": ");
1213 strcat (combined
, err
);
1215 /* We want anything which was printed on stdout to come out first, before
1217 gdb_flush (gdb_stdout
);
1218 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
1221 /* Control C eventually causes this to be called, at a convenient time. */
1227 /* No steenking SIGINT will ever be coming our way when the
1228 program is resumed. Don't lie. */
1232 /* If there is no terminal switching for this target, then we can't
1233 possibly get screwed by the lack of job control. */
1234 || current_target
.to_terminal_ours
== NULL
)
1237 fatal ("Quit (expect signal SIGINT when the program is resumed)");
1242 /* Called when a memory allocation fails, with the number of bytes of
1243 memory requested in SIZE. */
1250 internal_error (__FILE__
, __LINE__
,
1251 _("virtual memory exhausted: can't allocate %ld bytes."),
1256 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
1260 /* The xmalloc() (libiberty.h) family of memory management routines.
1262 These are like the ISO-C malloc() family except that they implement
1263 consistent semantics and guard against typical memory management
1266 /* NOTE: These are declared using PTR to ensure consistency with
1267 "libiberty.h". xfree() is GDB local. */
1270 xmalloc (size_t size
)
1274 /* See libiberty/xmalloc.c. This function need's to match that's
1275 semantics. It never returns NULL. */
1279 val
= malloc (size
); /* ARI: malloc */
1287 xzalloc (size_t size
)
1289 return xcalloc (1, size
);
1293 xrealloc (PTR ptr
, size_t size
) /* ARI: PTR */
1297 /* See libiberty/xmalloc.c. This function need's to match that's
1298 semantics. It never returns NULL. */
1303 val
= realloc (ptr
, size
); /* ARI: realloc */
1305 val
= malloc (size
); /* ARI: malloc */
1313 xcalloc (size_t number
, size_t size
)
1317 /* See libiberty/xmalloc.c. This function need's to match that's
1318 semantics. It never returns NULL. */
1319 if (number
== 0 || size
== 0)
1325 mem
= calloc (number
, size
); /* ARI: xcalloc */
1327 nomem (number
* size
);
1336 free (ptr
); /* ARI: free */
1340 /* Like asprintf/vasprintf but get an internal_error if the call
1344 xstrprintf (const char *format
, ...)
1348 va_start (args
, format
);
1349 ret
= xstrvprintf (format
, args
);
1355 xasprintf (char **ret
, const char *format
, ...)
1358 va_start (args
, format
);
1359 (*ret
) = xstrvprintf (format
, args
);
1364 xvasprintf (char **ret
, const char *format
, va_list ap
)
1366 (*ret
) = xstrvprintf (format
, ap
);
1370 xstrvprintf (const char *format
, va_list ap
)
1373 int status
= vasprintf (&ret
, format
, ap
);
1374 /* NULL is returned when there was a memory allocation problem, or
1375 any other error (for instance, a bad format string). A negative
1376 status (the printed length) with a non-NULL buffer should never
1377 happen, but just to be sure. */
1378 if (ret
== NULL
|| status
< 0)
1379 internal_error (__FILE__
, __LINE__
, _("vasprintf call failed"));
1384 xsnprintf (char *str
, size_t size
, const char *format
, ...)
1389 va_start (args
, format
);
1390 ret
= vsnprintf (str
, size
, format
, args
);
1391 gdb_assert (ret
< size
);
1397 /* My replacement for the read system call.
1398 Used like `read' but keeps going if `read' returns too soon. */
1401 myread (int desc
, char *addr
, int len
)
1408 val
= read (desc
, addr
, len
);
1412 return orglen
- len
;
1419 /* Make a copy of the string at PTR with SIZE characters
1420 (and add a null character at the end in the copy).
1421 Uses malloc to get the space. Returns the address of the copy. */
1424 savestring (const char *ptr
, size_t size
)
1426 char *p
= (char *) xmalloc (size
+ 1);
1427 memcpy (p
, ptr
, size
);
1433 print_spaces (int n
, struct ui_file
*file
)
1435 fputs_unfiltered (n_spaces (n
), file
);
1438 /* Print a host address. */
1441 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1443 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
1447 /* This function supports the query, nquery, and yquery functions.
1448 Ask user a y-or-n question and return 0 if answer is no, 1 if
1449 answer is yes, or default the answer to the specified default
1450 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1451 default answer, or '\0' for no default.
1452 CTLSTR is the control string and should end in "? ". It should
1453 not say how to answer, because we do that.
1454 ARGS are the arguments passed along with the CTLSTR argument to
1457 static int ATTRIBUTE_PRINTF (1, 0)
1458 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1464 char def_answer
, not_def_answer
;
1465 char *y_string
, *n_string
, *question
;
1467 /* Set up according to which answer is the default. */
1468 if (defchar
== '\0')
1472 not_def_answer
= 'N';
1476 else if (defchar
== 'y')
1480 not_def_answer
= 'N';
1488 not_def_answer
= 'Y';
1493 /* Automatically answer the default value if the user did not want
1494 prompts or the command was issued with the server prefix. */
1495 if (! caution
|| server_command
)
1498 /* If input isn't coming from the user directly, just say what
1499 question we're asking, and then answer the default automatically. This
1500 way, important error messages don't get lost when talking to GDB
1502 if (batch_flag
|| ! input_from_terminal_p ())
1505 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1507 printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"),
1508 y_string
, n_string
, def_answer
);
1509 gdb_flush (gdb_stdout
);
1514 if (deprecated_query_hook
)
1516 return deprecated_query_hook (ctlstr
, args
);
1519 /* Format the question outside of the loop, to avoid reusing args. */
1520 question
= xstrvprintf (ctlstr
, args
);
1524 wrap_here (""); /* Flush any buffered output */
1525 gdb_flush (gdb_stdout
);
1527 if (annotation_level
> 1)
1528 printf_filtered (("\n\032\032pre-query\n"));
1530 fputs_filtered (question
, gdb_stdout
);
1531 printf_filtered (_("(%s or %s) "), y_string
, n_string
);
1533 if (annotation_level
> 1)
1534 printf_filtered (("\n\032\032query\n"));
1537 gdb_flush (gdb_stdout
);
1539 answer
= fgetc (stdin
);
1541 /* We expect fgetc to block until a character is read. But
1542 this may not be the case if the terminal was opened with
1543 the NONBLOCK flag. In that case, if there is nothing to
1544 read on stdin, fgetc returns EOF, but also sets the error
1545 condition flag on stdin and errno to EAGAIN. With a true
1546 EOF, stdin's error condition flag is not set.
1548 A situation where this behavior was observed is a pseudo
1550 while (answer
== EOF
&& ferror (stdin
) && errno
== EAGAIN
)
1552 /* Not a real EOF. Wait a little while and try again until
1553 we read something. */
1556 answer
= fgetc (stdin
);
1559 clearerr (stdin
); /* in case of C-d */
1560 if (answer
== EOF
) /* C-d */
1562 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1566 /* Eat rest of input line, to EOF or newline */
1570 ans2
= fgetc (stdin
);
1573 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1577 /* Check answer. For the non-default, the user must specify
1578 the non-default explicitly. */
1579 if (answer
== not_def_answer
)
1581 retval
= !def_value
;
1584 /* Otherwise, if a default was specified, the user may either
1585 specify the required input or have it default by entering
1587 if (answer
== def_answer
1588 || (defchar
!= '\0' &&
1589 (answer
== '\n' || answer
== '\r' || answer
== EOF
)))
1594 /* Invalid entries are not defaulted and require another selection. */
1595 printf_filtered (_("Please answer %s or %s.\n"),
1596 y_string
, n_string
);
1600 if (annotation_level
> 1)
1601 printf_filtered (("\n\032\032post-query\n"));
1606 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1607 answer is yes, or 0 if answer is defaulted.
1608 Takes three args which are given to printf to print the question.
1609 The first, a control string, should end in "? ".
1610 It should not say how to answer, because we do that. */
1613 nquery (const char *ctlstr
, ...)
1617 va_start (args
, ctlstr
);
1618 return defaulted_query (ctlstr
, 'n', args
);
1622 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1623 answer is yes, or 1 if answer is defaulted.
1624 Takes three args which are given to printf to print the question.
1625 The first, a control string, should end in "? ".
1626 It should not say how to answer, because we do that. */
1629 yquery (const char *ctlstr
, ...)
1633 va_start (args
, ctlstr
);
1634 return defaulted_query (ctlstr
, 'y', args
);
1638 /* Ask user a y-or-n question and return 1 iff answer is yes.
1639 Takes three args which are given to printf to print the question.
1640 The first, a control string, should end in "? ".
1641 It should not say how to answer, because we do that. */
1644 query (const char *ctlstr
, ...)
1648 va_start (args
, ctlstr
);
1649 return defaulted_query (ctlstr
, '\0', args
);
1653 /* A helper for parse_escape that converts a host character to a
1654 target character. C is the host character. If conversion is
1655 possible, then the target character is stored in *TARGET_C and the
1656 function returns 1. Otherwise, the function returns 0. */
1659 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1661 struct obstack host_data
;
1663 struct cleanup
*cleanups
;
1666 obstack_init (&host_data
);
1667 cleanups
= make_cleanup_obstack_free (&host_data
);
1669 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1670 &the_char
, 1, 1, &host_data
, translit_none
);
1672 if (obstack_object_size (&host_data
) == 1)
1675 *target_c
= *(char *) obstack_base (&host_data
);
1678 do_cleanups (cleanups
);
1682 /* Parse a C escape sequence. STRING_PTR points to a variable
1683 containing a pointer to the string to parse. That pointer
1684 should point to the character after the \. That pointer
1685 is updated past the characters we use. The value of the
1686 escape sequence is returned.
1688 A negative value means the sequence \ newline was seen,
1689 which is supposed to be equivalent to nothing at all.
1691 If \ is followed by a null character, we return a negative
1692 value and leave the string pointer pointing at the null character.
1694 If \ is followed by 000, we return 0 and leave the string pointer
1695 after the zeros. A value of 0 does not mean end of string. */
1698 parse_escape (struct gdbarch
*gdbarch
, char **string_ptr
)
1700 int target_char
= -2; /* initialize to avoid GCC warnings */
1701 int c
= *(*string_ptr
)++;
1719 int i
= host_hex_value (c
);
1724 if (isdigit (c
) && c
!= '8' && c
!= '9')
1728 i
+= host_hex_value (c
);
1764 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1766 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1767 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1768 target_charset (gdbarch
));
1772 /* Print the character C on STREAM as part of the contents of a literal
1773 string whose delimiter is QUOTER. Note that this routine should only
1774 be call for printing things which are independent of the language
1775 of the program being debugged. */
1778 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1779 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1780 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1783 c
&= 0xFF; /* Avoid sign bit follies */
1785 if (c
< 0x20 || /* Low control chars */
1786 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1787 (sevenbit_strings
&& c
>= 0x80))
1788 { /* high order bit set */
1792 do_fputs ("\\n", stream
);
1795 do_fputs ("\\b", stream
);
1798 do_fputs ("\\t", stream
);
1801 do_fputs ("\\f", stream
);
1804 do_fputs ("\\r", stream
);
1807 do_fputs ("\\e", stream
);
1810 do_fputs ("\\a", stream
);
1813 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1819 if (c
== '\\' || c
== quoter
)
1820 do_fputs ("\\", stream
);
1821 do_fprintf (stream
, "%c", c
);
1825 /* Print the character C on STREAM as part of the contents of a
1826 literal string whose delimiter is QUOTER. Note that these routines
1827 should only be call for printing things which are independent of
1828 the language of the program being debugged. */
1831 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1834 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1838 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1841 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1845 fputstrn_filtered (const char *str
, int n
, int quoter
,
1846 struct ui_file
*stream
)
1849 for (i
= 0; i
< n
; i
++)
1850 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1854 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1855 struct ui_file
*stream
)
1858 for (i
= 0; i
< n
; i
++)
1859 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1863 /* Number of lines per page or UINT_MAX if paging is disabled. */
1864 static unsigned int lines_per_page
;
1866 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1867 struct cmd_list_element
*c
, const char *value
)
1869 fprintf_filtered (file
, _("\
1870 Number of lines gdb thinks are in a page is %s.\n"),
1874 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1875 static unsigned int chars_per_line
;
1877 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1878 struct cmd_list_element
*c
, const char *value
)
1880 fprintf_filtered (file
, _("\
1881 Number of characters gdb thinks are in a line is %s.\n"),
1885 /* Current count of lines printed on this page, chars on this line. */
1886 static unsigned int lines_printed
, chars_printed
;
1888 /* Buffer and start column of buffered text, for doing smarter word-
1889 wrapping. When someone calls wrap_here(), we start buffering output
1890 that comes through fputs_filtered(). If we see a newline, we just
1891 spit it out and forget about the wrap_here(). If we see another
1892 wrap_here(), we spit it out and remember the newer one. If we see
1893 the end of the line, we spit out a newline, the indent, and then
1894 the buffered output. */
1896 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1897 are waiting to be output (they have already been counted in chars_printed).
1898 When wrap_buffer[0] is null, the buffer is empty. */
1899 static char *wrap_buffer
;
1901 /* Pointer in wrap_buffer to the next character to fill. */
1902 static char *wrap_pointer
;
1904 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1906 static char *wrap_indent
;
1908 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1909 is not in effect. */
1910 static int wrap_column
;
1913 /* Inialize the number of lines per page and chars per line. */
1916 init_page_info (void)
1919 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1924 #if defined(__GO32__)
1925 rows
= ScreenRows ();
1926 cols
= ScreenCols ();
1927 lines_per_page
= rows
;
1928 chars_per_line
= cols
;
1930 /* Make sure Readline has initialized its terminal settings. */
1931 rl_reset_terminal (NULL
);
1933 /* Get the screen size from Readline. */
1934 rl_get_screen_size (&rows
, &cols
);
1935 lines_per_page
= rows
;
1936 chars_per_line
= cols
;
1938 /* Readline should have fetched the termcap entry for us. */
1939 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1941 /* The number of lines per page is not mentioned in the
1942 terminal description. This probably means that paging is
1943 not useful (e.g. emacs shell window), so disable paging. */
1944 lines_per_page
= UINT_MAX
;
1947 /* FIXME: Get rid of this junk. */
1948 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1949 SIGWINCH_HANDLER (SIGWINCH
);
1952 /* If the output is not a terminal, don't paginate it. */
1953 if (!ui_file_isatty (gdb_stdout
))
1954 lines_per_page
= UINT_MAX
;
1962 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1965 set_screen_size (void)
1967 int rows
= lines_per_page
;
1968 int cols
= chars_per_line
;
1976 /* Update Readline's idea of the terminal size. */
1977 rl_set_screen_size (rows
, cols
);
1980 /* Reinitialize WRAP_BUFFER according to the current value of
1986 if (chars_per_line
== 0)
1991 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1992 wrap_buffer
[0] = '\0';
1995 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1996 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
2000 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
2007 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
2012 /* Wait, so the user can read what's on the screen. Prompt the user
2013 to continue by pressing RETURN. */
2016 prompt_for_continue (void)
2019 char cont_prompt
[120];
2021 if (annotation_level
> 1)
2022 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
2024 strcpy (cont_prompt
,
2025 "---Type <return> to continue, or q <return> to quit---");
2026 if (annotation_level
> 1)
2027 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
2029 /* We must do this *before* we call gdb_readline, else it will eventually
2030 call us -- thinking that we're trying to print beyond the end of the
2032 reinitialize_more_filter ();
2035 /* On a real operating system, the user can quit with SIGINT.
2038 'q' is provided on all systems so users don't have to change habits
2039 from system to system, and because telling them what to do in
2040 the prompt is more user-friendly than expecting them to think of
2042 /* Call readline, not gdb_readline, because GO32 readline handles control-C
2043 whereas control-C to gdb_readline will cause the user to get dumped
2045 ignore
= gdb_readline_wrapper (cont_prompt
);
2047 if (annotation_level
> 1)
2048 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
2053 while (*p
== ' ' || *p
== '\t')
2056 async_request_quit (0);
2061 /* Now we have to do this again, so that GDB will know that it doesn't
2062 need to save the ---Type <return>--- line at the top of the screen. */
2063 reinitialize_more_filter ();
2065 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
2068 /* Reinitialize filter; ie. tell it to reset to original values. */
2071 reinitialize_more_filter (void)
2077 /* Indicate that if the next sequence of characters overflows the line,
2078 a newline should be inserted here rather than when it hits the end.
2079 If INDENT is non-null, it is a string to be printed to indent the
2080 wrapped part on the next line. INDENT must remain accessible until
2081 the next call to wrap_here() or until a newline is printed through
2084 If the line is already overfull, we immediately print a newline and
2085 the indentation, and disable further wrapping.
2087 If we don't know the width of lines, but we know the page height,
2088 we must not wrap words, but should still keep track of newlines
2089 that were explicitly printed.
2091 INDENT should not contain tabs, as that will mess up the char count
2092 on the next line. FIXME.
2094 This routine is guaranteed to force out any output which has been
2095 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
2096 used to force out output from the wrap_buffer. */
2099 wrap_here (char *indent
)
2101 /* This should have been allocated, but be paranoid anyway. */
2103 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
2107 *wrap_pointer
= '\0';
2108 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
2110 wrap_pointer
= wrap_buffer
;
2111 wrap_buffer
[0] = '\0';
2112 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
2116 else if (chars_printed
>= chars_per_line
)
2118 puts_filtered ("\n");
2120 puts_filtered (indent
);
2125 wrap_column
= chars_printed
;
2129 wrap_indent
= indent
;
2133 /* Print input string to gdb_stdout, filtered, with wrap,
2134 arranging strings in columns of n chars. String can be
2135 right or left justified in the column. Never prints
2136 trailing spaces. String should never be longer than
2137 width. FIXME: this could be useful for the EXAMINE
2138 command, which currently doesn't tabulate very well */
2141 puts_filtered_tabular (char *string
, int width
, int right
)
2147 gdb_assert (chars_per_line
> 0);
2148 if (chars_per_line
== UINT_MAX
)
2150 fputs_filtered (string
, gdb_stdout
);
2151 fputs_filtered ("\n", gdb_stdout
);
2155 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
2156 fputs_filtered ("\n", gdb_stdout
);
2158 if (width
>= chars_per_line
)
2159 width
= chars_per_line
- 1;
2161 stringlen
= strlen (string
);
2163 if (chars_printed
> 0)
2164 spaces
= width
- (chars_printed
- 1) % width
- 1;
2166 spaces
+= width
- stringlen
;
2168 spacebuf
= alloca (spaces
+ 1);
2169 spacebuf
[spaces
] = '\0';
2171 spacebuf
[spaces
] = ' ';
2173 fputs_filtered (spacebuf
, gdb_stdout
);
2174 fputs_filtered (string
, gdb_stdout
);
2178 /* Ensure that whatever gets printed next, using the filtered output
2179 commands, starts at the beginning of the line. I.E. if there is
2180 any pending output for the current line, flush it and start a new
2181 line. Otherwise do nothing. */
2186 if (chars_printed
> 0)
2188 puts_filtered ("\n");
2193 /* Like fputs but if FILTER is true, pause after every screenful.
2195 Regardless of FILTER can wrap at points other than the final
2196 character of a line.
2198 Unlike fputs, fputs_maybe_filtered does not return a value.
2199 It is OK for LINEBUFFER to be NULL, in which case just don't print
2202 Note that a longjmp to top level may occur in this routine (only if
2203 FILTER is true) (since prompt_for_continue may do so) so this
2204 routine should not be called when cleanups are not in place. */
2207 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
2210 const char *lineptr
;
2212 if (linebuffer
== 0)
2215 /* Don't do any filtering if it is disabled. */
2216 if (stream
!= gdb_stdout
2217 || !pagination_enabled
2218 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
2219 || top_level_interpreter () == NULL
2220 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2222 fputs_unfiltered (linebuffer
, stream
);
2226 /* Go through and output each character. Show line extension
2227 when this is necessary; prompt user for new page when this is
2230 lineptr
= linebuffer
;
2233 /* Possible new page. */
2234 if (filter
&& (lines_printed
>= lines_per_page
- 1))
2235 prompt_for_continue ();
2237 while (*lineptr
&& *lineptr
!= '\n')
2239 /* Print a single line. */
2240 if (*lineptr
== '\t')
2243 *wrap_pointer
++ = '\t';
2245 fputc_unfiltered ('\t', stream
);
2246 /* Shifting right by 3 produces the number of tab stops
2247 we have already passed, and then adding one and
2248 shifting left 3 advances to the next tab stop. */
2249 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2255 *wrap_pointer
++ = *lineptr
;
2257 fputc_unfiltered (*lineptr
, stream
);
2262 if (chars_printed
>= chars_per_line
)
2264 unsigned int save_chars
= chars_printed
;
2268 /* If we aren't actually wrapping, don't output newline --
2269 if chars_per_line is right, we probably just overflowed
2270 anyway; if it's wrong, let us keep going. */
2272 fputc_unfiltered ('\n', stream
);
2274 /* Possible new page. */
2275 if (lines_printed
>= lines_per_page
- 1)
2276 prompt_for_continue ();
2278 /* Now output indentation and wrapped string */
2281 fputs_unfiltered (wrap_indent
, stream
);
2282 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
2283 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
2284 /* FIXME, this strlen is what prevents wrap_indent from
2285 containing tabs. However, if we recurse to print it
2286 and count its chars, we risk trouble if wrap_indent is
2287 longer than (the user settable) chars_per_line.
2288 Note also that this can set chars_printed > chars_per_line
2289 if we are printing a long string. */
2290 chars_printed
= strlen (wrap_indent
)
2291 + (save_chars
- wrap_column
);
2292 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2293 wrap_buffer
[0] = '\0';
2294 wrap_column
= 0; /* And disable fancy wrap */
2299 if (*lineptr
== '\n')
2302 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2304 fputc_unfiltered ('\n', stream
);
2311 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2313 fputs_maybe_filtered (linebuffer
, stream
, 1);
2317 putchar_unfiltered (int c
)
2320 ui_file_write (gdb_stdout
, &buf
, 1);
2324 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2325 May return nonlocally. */
2328 putchar_filtered (int c
)
2330 return fputc_filtered (c
, gdb_stdout
);
2334 fputc_unfiltered (int c
, struct ui_file
*stream
)
2337 ui_file_write (stream
, &buf
, 1);
2342 fputc_filtered (int c
, struct ui_file
*stream
)
2348 fputs_filtered (buf
, stream
);
2352 /* puts_debug is like fputs_unfiltered, except it prints special
2353 characters in printable fashion. */
2356 puts_debug (char *prefix
, char *string
, char *suffix
)
2360 /* Print prefix and suffix after each line. */
2361 static int new_line
= 1;
2362 static int return_p
= 0;
2363 static char *prev_prefix
= "";
2364 static char *prev_suffix
= "";
2366 if (*string
== '\n')
2369 /* If the prefix is changing, print the previous suffix, a new line,
2370 and the new prefix. */
2371 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2373 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2374 fputs_unfiltered ("\n", gdb_stdlog
);
2375 fputs_unfiltered (prefix
, gdb_stdlog
);
2378 /* Print prefix if we printed a newline during the previous call. */
2382 fputs_unfiltered (prefix
, gdb_stdlog
);
2385 prev_prefix
= prefix
;
2386 prev_suffix
= suffix
;
2388 /* Output characters in a printable format. */
2389 while ((ch
= *string
++) != '\0')
2395 fputc_unfiltered (ch
, gdb_stdlog
);
2398 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2402 fputs_unfiltered ("\\\\", gdb_stdlog
);
2405 fputs_unfiltered ("\\b", gdb_stdlog
);
2408 fputs_unfiltered ("\\f", gdb_stdlog
);
2412 fputs_unfiltered ("\\n", gdb_stdlog
);
2415 fputs_unfiltered ("\\r", gdb_stdlog
);
2418 fputs_unfiltered ("\\t", gdb_stdlog
);
2421 fputs_unfiltered ("\\v", gdb_stdlog
);
2425 return_p
= ch
== '\r';
2428 /* Print suffix if we printed a newline. */
2431 fputs_unfiltered (suffix
, gdb_stdlog
);
2432 fputs_unfiltered ("\n", gdb_stdlog
);
2437 /* Print a variable number of ARGS using format FORMAT. If this
2438 information is going to put the amount written (since the last call
2439 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2440 call prompt_for_continue to get the users permision to continue.
2442 Unlike fprintf, this function does not return a value.
2444 We implement three variants, vfprintf (takes a vararg list and stream),
2445 fprintf (takes a stream to write on), and printf (the usual).
2447 Note also that a longjmp to top level may occur in this routine
2448 (since prompt_for_continue may do so) so this routine should not be
2449 called when cleanups are not in place. */
2452 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2453 va_list args
, int filter
)
2456 struct cleanup
*old_cleanups
;
2458 linebuffer
= xstrvprintf (format
, args
);
2459 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2460 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2461 do_cleanups (old_cleanups
);
2466 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2468 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2472 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2475 struct cleanup
*old_cleanups
;
2477 linebuffer
= xstrvprintf (format
, args
);
2478 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2479 if (debug_timestamp
&& stream
== gdb_stdlog
)
2485 gettimeofday (&tm
, NULL
);
2487 len
= strlen (linebuffer
);
2488 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2490 timestamp
= xstrprintf ("%ld:%ld %s%s",
2491 (long) tm
.tv_sec
, (long) tm
.tv_usec
,
2493 need_nl
? "\n": "");
2494 make_cleanup (xfree
, timestamp
);
2495 fputs_unfiltered (timestamp
, stream
);
2498 fputs_unfiltered (linebuffer
, stream
);
2499 do_cleanups (old_cleanups
);
2503 vprintf_filtered (const char *format
, va_list args
)
2505 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2509 vprintf_unfiltered (const char *format
, va_list args
)
2511 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2515 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2518 va_start (args
, format
);
2519 vfprintf_filtered (stream
, format
, args
);
2524 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2527 va_start (args
, format
);
2528 vfprintf_unfiltered (stream
, format
, args
);
2532 /* Like fprintf_filtered, but prints its result indented.
2533 Called as fprintfi_filtered (spaces, stream, format, ...); */
2536 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2540 va_start (args
, format
);
2541 print_spaces_filtered (spaces
, stream
);
2543 vfprintf_filtered (stream
, format
, args
);
2549 printf_filtered (const char *format
, ...)
2552 va_start (args
, format
);
2553 vfprintf_filtered (gdb_stdout
, format
, args
);
2559 printf_unfiltered (const char *format
, ...)
2562 va_start (args
, format
);
2563 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2567 /* Like printf_filtered, but prints it's result indented.
2568 Called as printfi_filtered (spaces, format, ...); */
2571 printfi_filtered (int spaces
, const char *format
, ...)
2574 va_start (args
, format
);
2575 print_spaces_filtered (spaces
, gdb_stdout
);
2576 vfprintf_filtered (gdb_stdout
, format
, args
);
2580 /* Easy -- but watch out!
2582 This routine is *not* a replacement for puts()! puts() appends a newline.
2583 This one doesn't, and had better not! */
2586 puts_filtered (const char *string
)
2588 fputs_filtered (string
, gdb_stdout
);
2592 puts_unfiltered (const char *string
)
2594 fputs_unfiltered (string
, gdb_stdout
);
2597 /* Return a pointer to N spaces and a null. The pointer is good
2598 until the next call to here. */
2603 static char *spaces
= 0;
2604 static int max_spaces
= -1;
2610 spaces
= (char *) xmalloc (n
+ 1);
2611 for (t
= spaces
+ n
; t
!= spaces
;)
2617 return spaces
+ max_spaces
- n
;
2620 /* Print N spaces. */
2622 print_spaces_filtered (int n
, struct ui_file
*stream
)
2624 fputs_filtered (n_spaces (n
), stream
);
2627 /* C++/ObjC demangler stuff. */
2629 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2630 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2631 If the name is not mangled, or the language for the name is unknown, or
2632 demangling is off, the name is printed in its "raw" form. */
2635 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2636 enum language lang
, int arg_mode
)
2642 /* If user wants to see raw output, no problem. */
2645 fputs_filtered (name
, stream
);
2649 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2650 fputs_filtered (demangled
? demangled
: name
, stream
);
2651 if (demangled
!= NULL
)
2659 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2660 differences in whitespace. Returns 0 if they match, non-zero if they
2661 don't (slightly different than strcmp()'s range of return values).
2663 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2664 This "feature" is useful when searching for matching C++ function names
2665 (such as if the user types 'break FOO', where FOO is a mangled C++
2669 strcmp_iw (const char *string1
, const char *string2
)
2671 while ((*string1
!= '\0') && (*string2
!= '\0'))
2673 while (isspace (*string1
))
2677 while (isspace (*string2
))
2681 if (*string1
!= *string2
)
2685 if (*string1
!= '\0')
2691 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2694 /* This is like strcmp except that it ignores whitespace and treats
2695 '(' as the first non-NULL character in terms of ordering. Like
2696 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2697 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2698 according to that ordering.
2700 If a list is sorted according to this function and if you want to
2701 find names in the list that match some fixed NAME according to
2702 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2703 where this function would put NAME.
2705 Here are some examples of why using strcmp to sort is a bad idea:
2709 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2710 we try to do a search for "foo<char*>", strcmp will locate this
2711 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2712 will start looking at strings beginning with "goo", and will never
2713 see the correct match of "foo<char *>".
2715 Parenthesis example:
2717 In practice, this is less like to be an issue, but I'll give it a
2718 shot. Let's assume that '$' is a legitimate character to occur in
2719 symbols. (Which may well even be the case on some systems.) Then
2720 say that the partial symbol table contains "foo$" and "foo(int)".
2721 strcmp will put them in this order, since '$' < '('. Now, if the
2722 user searches for "foo", then strcmp will sort "foo" before "foo$".
2723 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2724 "foo") is false, so it won't proceed to the actual match of
2725 "foo(int)" with "foo". */
2728 strcmp_iw_ordered (const char *string1
, const char *string2
)
2730 while ((*string1
!= '\0') && (*string2
!= '\0'))
2732 while (isspace (*string1
))
2736 while (isspace (*string2
))
2740 if (*string1
!= *string2
)
2744 if (*string1
!= '\0')
2753 /* Characters are non-equal unless they're both '\0'; we want to
2754 make sure we get the comparison right according to our
2755 comparison in the cases where one of them is '\0' or '('. */
2757 if (*string2
== '\0')
2762 if (*string2
== '\0')
2767 if (*string2
== '(')
2770 return *string1
- *string2
;
2774 /* A simple comparison function with opposite semantics to strcmp. */
2777 streq (const char *lhs
, const char *rhs
)
2779 return !strcmp (lhs
, rhs
);
2785 ** Answer whether string_to_compare is a full or partial match to
2786 ** template_string. The partial match must be in sequence starting
2790 subset_compare (char *string_to_compare
, char *template_string
)
2793 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2794 && strlen (string_to_compare
) <= strlen (template_string
))
2797 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2804 pagination_on_command (char *arg
, int from_tty
)
2806 pagination_enabled
= 1;
2810 pagination_off_command (char *arg
, int from_tty
)
2812 pagination_enabled
= 0;
2816 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2817 struct cmd_list_element
*c
, const char *value
)
2819 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"), value
);
2824 initialize_utils (void)
2826 struct cmd_list_element
*c
;
2828 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2829 Set number of characters gdb thinks are in a line."), _("\
2830 Show number of characters gdb thinks are in a line."), NULL
,
2832 show_chars_per_line
,
2833 &setlist
, &showlist
);
2835 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2836 Set number of lines gdb thinks are in a page."), _("\
2837 Show number of lines gdb thinks are in a page."), NULL
,
2839 show_lines_per_page
,
2840 &setlist
, &showlist
);
2844 add_setshow_boolean_cmd ("demangle", class_support
, &demangle
, _("\
2845 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
2846 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL
,
2849 &setprintlist
, &showprintlist
);
2851 add_setshow_boolean_cmd ("pagination", class_support
,
2852 &pagination_enabled
, _("\
2853 Set state of pagination."), _("\
2854 Show state of pagination."), NULL
,
2856 show_pagination_enabled
,
2857 &setlist
, &showlist
);
2861 add_com ("am", class_support
, pagination_on_command
,
2862 _("Enable pagination"));
2863 add_com ("sm", class_support
, pagination_off_command
,
2864 _("Disable pagination"));
2867 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2868 &sevenbit_strings
, _("\
2869 Set printing of 8-bit characters in strings as \\nnn."), _("\
2870 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2872 show_sevenbit_strings
,
2873 &setprintlist
, &showprintlist
);
2875 add_setshow_boolean_cmd ("asm-demangle", class_support
, &asm_demangle
, _("\
2876 Set demangling of C++/ObjC names in disassembly listings."), _("\
2877 Show demangling of C++/ObjC names in disassembly listings."), NULL
,
2880 &setprintlist
, &showprintlist
);
2882 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2883 &debug_timestamp
, _("\
2884 Set timestamping of debugging messages."), _("\
2885 Show timestamping of debugging messages."), _("\
2886 When set, debugging messages will be marked with seconds and microseconds."),
2888 show_debug_timestamp
,
2889 &setdebuglist
, &showdebuglist
);
2892 /* Machine specific function to handle SIGWINCH signal. */
2894 #ifdef SIGWINCH_HANDLER_BODY
2895 SIGWINCH_HANDLER_BODY
2897 /* print routines to handle variable size regs, etc. */
2898 /* temporary storage using circular buffer */
2904 static char buf
[NUMCELLS
][CELLSIZE
];
2905 static int cell
= 0;
2906 if (++cell
>= NUMCELLS
)
2912 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2914 /* Truncate address to the size of a target address, avoiding shifts
2915 larger or equal than the width of a CORE_ADDR. The local
2916 variable ADDR_BIT stops the compiler reporting a shift overflow
2917 when it won't occur. */
2918 /* NOTE: This assumes that the significant address information is
2919 kept in the least significant bits of ADDR - the upper bits were
2920 either zero or sign extended. Should gdbarch_address_to_pointer or
2921 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2923 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2925 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2926 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2927 return hex_string (addr
);
2931 decimal2str (char *sign
, ULONGEST addr
, int width
)
2933 /* Steal code from valprint.c:print_decimal(). Should this worry
2934 about the real size of addr as the above does? */
2935 unsigned long temp
[3];
2936 char *str
= get_cell ();
2941 temp
[i
] = addr
% (1000 * 1000 * 1000);
2942 addr
/= (1000 * 1000 * 1000);
2946 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2955 xsnprintf (str
, CELLSIZE
, "%s%0*lu", sign
, width
, temp
[0]);
2958 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu", sign
, width
,
2962 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu%09lu", sign
, width
,
2963 temp
[2], temp
[1], temp
[0]);
2966 internal_error (__FILE__
, __LINE__
,
2967 _("failed internal consistency check"));
2974 octal2str (ULONGEST addr
, int width
)
2976 unsigned long temp
[3];
2977 char *str
= get_cell ();
2982 temp
[i
] = addr
% (0100000 * 0100000);
2983 addr
/= (0100000 * 0100000);
2987 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2997 xsnprintf (str
, CELLSIZE
, "%*o", width
, 0);
2999 xsnprintf (str
, CELLSIZE
, "0%0*lo", width
, temp
[0]);
3002 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
3005 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo%010lo", width
,
3006 temp
[2], temp
[1], temp
[0]);
3009 internal_error (__FILE__
, __LINE__
,
3010 _("failed internal consistency check"));
3017 pulongest (ULONGEST u
)
3019 return decimal2str ("", u
, 0);
3023 plongest (LONGEST l
)
3026 return decimal2str ("-", -l
, 0);
3028 return decimal2str ("", l
, 0);
3031 /* Eliminate warning from compiler on 32-bit systems. */
3032 static int thirty_two
= 32;
3035 phex (ULONGEST l
, int sizeof_l
)
3043 xsnprintf (str
, CELLSIZE
, "%08lx%08lx",
3044 (unsigned long) (l
>> thirty_two
),
3045 (unsigned long) (l
& 0xffffffff));
3049 xsnprintf (str
, CELLSIZE
, "%08lx", (unsigned long) l
);
3053 xsnprintf (str
, CELLSIZE
, "%04x", (unsigned short) (l
& 0xffff));
3056 str
= phex (l
, sizeof (l
));
3064 phex_nz (ULONGEST l
, int sizeof_l
)
3072 unsigned long high
= (unsigned long) (l
>> thirty_two
);
3075 xsnprintf (str
, CELLSIZE
, "%lx",
3076 (unsigned long) (l
& 0xffffffff));
3078 xsnprintf (str
, CELLSIZE
, "%lx%08lx", high
,
3079 (unsigned long) (l
& 0xffffffff));
3084 xsnprintf (str
, CELLSIZE
, "%lx", (unsigned long) l
);
3088 xsnprintf (str
, CELLSIZE
, "%x", (unsigned short) (l
& 0xffff));
3091 str
= phex_nz (l
, sizeof (l
));
3098 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
3099 in a static string. Returns a pointer to this string. */
3101 hex_string (LONGEST num
)
3103 char *result
= get_cell ();
3104 xsnprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
3108 /* Converts a LONGEST number to a C-format hexadecimal literal and
3109 stores it in a static string. Returns a pointer to this string
3110 that is valid until the next call. The number is padded on the
3111 left with 0s to at least WIDTH characters. */
3113 hex_string_custom (LONGEST num
, int width
)
3115 char *result
= get_cell ();
3116 char *result_end
= result
+ CELLSIZE
- 1;
3117 const char *hex
= phex_nz (num
, sizeof (num
));
3118 int hex_len
= strlen (hex
);
3120 if (hex_len
> width
)
3122 if (width
+ 2 >= CELLSIZE
)
3123 internal_error (__FILE__
, __LINE__
,
3124 _("hex_string_custom: insufficient space to store result"));
3126 strcpy (result_end
- width
- 2, "0x");
3127 memset (result_end
- width
, '0', width
);
3128 strcpy (result_end
- hex_len
, hex
);
3129 return result_end
- width
- 2;
3132 /* Convert VAL to a numeral in the given radix. For
3133 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
3134 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
3135 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
3136 * to use C format in all cases. If it is false, then 'x'
3137 * and 'o' formats do not include a prefix (0x or leading 0). */
3140 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
3149 result
= hex_string (val
);
3151 result
= hex_string_custom (val
, width
);
3158 if (is_signed
&& val
< 0)
3159 return decimal2str ("-", -val
, width
);
3161 return decimal2str ("", val
, width
);
3165 char *result
= octal2str (val
, width
);
3166 if (use_c_format
|| val
== 0)
3172 internal_error (__FILE__
, __LINE__
,
3173 _("failed internal consistency check"));
3177 /* Convert a CORE_ADDR into a string. */
3179 core_addr_to_string (const CORE_ADDR addr
)
3181 char *str
= get_cell ();
3183 strcat (str
, phex (addr
, sizeof (addr
)));
3188 core_addr_to_string_nz (const CORE_ADDR addr
)
3190 char *str
= get_cell ();
3192 strcat (str
, phex_nz (addr
, sizeof (addr
)));
3196 /* Convert a string back into a CORE_ADDR. */
3198 string_to_core_addr (const char *my_string
)
3202 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
3204 /* Assume that it is in hex. */
3206 for (i
= 2; my_string
[i
] != '\0'; i
++)
3208 if (isdigit (my_string
[i
]))
3209 addr
= (my_string
[i
] - '0') + (addr
* 16);
3210 else if (isxdigit (my_string
[i
]))
3211 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
3213 error (_("invalid hex \"%s\""), my_string
);
3218 /* Assume that it is in decimal. */
3220 for (i
= 0; my_string
[i
] != '\0'; i
++)
3222 if (isdigit (my_string
[i
]))
3223 addr
= (my_string
[i
] - '0') + (addr
* 10);
3225 error (_("invalid decimal \"%s\""), my_string
);
3233 host_address_to_string (const void *addr
)
3235 char *str
= get_cell ();
3237 xsnprintf (str
, CELLSIZE
, "0x%s", phex_nz ((uintptr_t) addr
, sizeof (addr
)));
3242 gdb_realpath (const char *filename
)
3244 /* Method 1: The system has a compile time upper bound on a filename
3245 path. Use that and realpath() to canonicalize the name. This is
3246 the most common case. Note that, if there isn't a compile time
3247 upper bound, you want to avoid realpath() at all costs. */
3248 #if defined(HAVE_REALPATH)
3250 # if defined (PATH_MAX)
3252 # define USE_REALPATH
3253 # elif defined (MAXPATHLEN)
3254 char buf
[MAXPATHLEN
];
3255 # define USE_REALPATH
3257 # if defined (USE_REALPATH)
3258 const char *rp
= realpath (filename
, buf
);
3261 return xstrdup (rp
);
3264 #endif /* HAVE_REALPATH */
3266 /* Method 2: The host system (i.e., GNU) has the function
3267 canonicalize_file_name() which malloc's a chunk of memory and
3268 returns that, use that. */
3269 #if defined(HAVE_CANONICALIZE_FILE_NAME)
3271 char *rp
= canonicalize_file_name (filename
);
3273 return xstrdup (filename
);
3279 /* FIXME: cagney/2002-11-13:
3281 Method 2a: Use realpath() with a NULL buffer. Some systems, due
3282 to the problems described in in method 3, have modified their
3283 realpath() implementation so that it will allocate a buffer when
3284 NULL is passed in. Before this can be used, though, some sort of
3285 configure time test would need to be added. Otherwize the code
3286 will likely core dump. */
3288 /* Method 3: Now we're getting desperate! The system doesn't have a
3289 compile time buffer size and no alternative function. Query the
3290 OS, using pathconf(), for the buffer limit. Care is needed
3291 though, some systems do not limit PATH_MAX (return -1 for
3292 pathconf()) making it impossible to pass a correctly sized buffer
3293 to realpath() (it could always overflow). On those systems, we
3295 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
3297 /* Find out the max path size. */
3298 long path_max
= pathconf ("/", _PC_PATH_MAX
);
3301 /* PATH_MAX is bounded. */
3302 char *buf
= alloca (path_max
);
3303 char *rp
= realpath (filename
, buf
);
3304 return xstrdup (rp
? rp
: filename
);
3309 /* This system is a lost cause, just dup the buffer. */
3310 return xstrdup (filename
);
3313 /* Return a copy of FILENAME, with its directory prefix canonicalized
3317 xfullpath (const char *filename
)
3319 const char *base_name
= lbasename (filename
);
3324 /* Extract the basename of filename, and return immediately
3325 a copy of filename if it does not contain any directory prefix. */
3326 if (base_name
== filename
)
3327 return xstrdup (filename
);
3329 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
3330 /* Allocate enough space to store the dir_name + plus one extra
3331 character sometimes needed under Windows (see below), and
3332 then the closing \000 character */
3333 strncpy (dir_name
, filename
, base_name
- filename
);
3334 dir_name
[base_name
- filename
] = '\000';
3336 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3337 /* We need to be careful when filename is of the form 'd:foo', which
3338 is equivalent of d:./foo, which is totally different from d:/foo. */
3339 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
3342 dir_name
[3] = '\000';
3346 /* Canonicalize the directory prefix, and build the resulting
3347 filename. If the dirname realpath already contains an ending
3348 directory separator, avoid doubling it. */
3349 real_path
= gdb_realpath (dir_name
);
3350 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
3351 result
= concat (real_path
, base_name
, (char *) NULL
);
3353 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *) NULL
);
3360 /* This is the 32-bit CRC function used by the GNU separate debug
3361 facility. An executable may contain a section named
3362 .gnu_debuglink, which holds the name of a separate executable file
3363 containing its debug info, and a checksum of that file's contents,
3364 computed using this function. */
3366 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3368 static const unsigned int crc32_table
[256] = {
3369 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3370 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3371 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3372 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3373 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3374 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3375 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3376 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3377 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3378 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3379 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3380 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3381 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3382 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3383 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3384 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3385 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3386 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3387 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3388 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3389 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3390 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3391 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3392 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3393 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3394 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3395 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3396 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3397 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3398 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3399 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3400 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3401 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3402 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3403 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3404 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3405 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3406 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3407 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3408 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3409 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3410 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3411 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3412 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3413 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3414 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3415 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3416 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3417 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3418 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3419 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3424 crc
= ~crc
& 0xffffffff;
3425 for (end
= buf
+ len
; buf
< end
; ++buf
)
3426 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3427 return ~crc
& 0xffffffff;;
3431 align_up (ULONGEST v
, int n
)
3433 /* Check that N is really a power of two. */
3434 gdb_assert (n
&& (n
& (n
-1)) == 0);
3435 return (v
+ n
- 1) & -n
;
3439 align_down (ULONGEST v
, int n
)
3441 /* Check that N is really a power of two. */
3442 gdb_assert (n
&& (n
& (n
-1)) == 0);
3446 /* Allocation function for the libiberty hash table which uses an
3447 obstack. The obstack is passed as DATA. */
3450 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3452 unsigned int total
= size
* count
;
3453 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3454 memset (ptr
, 0, total
);
3458 /* Trivial deallocation function for the libiberty splay tree and hash
3459 table - don't deallocate anything. Rely on later deletion of the
3460 obstack. DATA will be the obstack, although it is not needed
3464 dummy_obstack_deallocate (void *object
, void *data
)
3469 /* The bit offset of the highest byte in a ULONGEST, for overflow
3472 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3474 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3475 where 2 <= BASE <= 36. */
3478 is_digit_in_base (unsigned char digit
, int base
)
3480 if (!isalnum (digit
))
3483 return (isdigit (digit
) && digit
< base
+ '0');
3485 return (isdigit (digit
) || tolower (digit
) < base
- 10 + 'a');
3489 digit_to_int (unsigned char c
)
3494 return tolower (c
) - 'a' + 10;
3497 /* As for strtoul, but for ULONGEST results. */
3500 strtoulst (const char *num
, const char **trailer
, int base
)
3502 unsigned int high_part
;
3507 /* Skip leading whitespace. */
3508 while (isspace (num
[i
]))
3511 /* Handle prefixes. */
3514 else if (num
[i
] == '-')
3520 if (base
== 0 || base
== 16)
3522 if (num
[i
] == '0' && (num
[i
+ 1] == 'x' || num
[i
+ 1] == 'X'))
3530 if (base
== 0 && num
[i
] == '0')
3536 if (base
< 2 || base
> 36)
3542 result
= high_part
= 0;
3543 for (; is_digit_in_base (num
[i
], base
); i
+= 1)
3545 result
= result
* base
+ digit_to_int (num
[i
]);
3546 high_part
= high_part
* base
+ (unsigned int) (result
>> HIGH_BYTE_POSN
);
3547 result
&= ((ULONGEST
) 1 << HIGH_BYTE_POSN
) - 1;
3548 if (high_part
> 0xff)
3551 result
= ~ (ULONGEST
) 0;
3558 if (trailer
!= NULL
)
3561 result
= result
+ ((ULONGEST
) high_part
<< HIGH_BYTE_POSN
);
3568 /* Simple, portable version of dirname that does not modify its
3572 ldirname (const char *filename
)
3574 const char *base
= lbasename (filename
);
3577 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3580 if (base
== filename
)
3583 dirname
= xmalloc (base
- filename
+ 2);
3584 memcpy (dirname
, filename
, base
- filename
);
3586 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3587 create "d:./bar" later instead of the (different) "d:/bar". */
3588 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3589 && !IS_DIR_SEPARATOR (filename
[0]))
3590 dirname
[base
++ - filename
] = '.';
3592 dirname
[base
- filename
] = '\0';
3596 /* Call libiberty's buildargv, and return the result.
3597 If buildargv fails due to out-of-memory, call nomem.
3598 Therefore, the returned value is guaranteed to be non-NULL,
3599 unless the parameter itself is NULL. */
3602 gdb_buildargv (const char *s
)
3604 char **argv
= buildargv (s
);
3605 if (s
!= NULL
&& argv
== NULL
)
3611 compare_positive_ints (const void *ap
, const void *bp
)
3613 /* Because we know we're comparing two ints which are positive,
3614 there's no danger of overflow here. */
3615 return * (int *) ap
- * (int *) bp
;
3618 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3619 #define AMBIGUOUS_MESS2 ".\nUse \"set gnutarget format-name\" to specify the format."
3622 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
3628 /* Check if errmsg just need simple return. */
3629 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
3630 return bfd_errmsg (error_tag
);
3632 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
3633 + strlen (AMBIGUOUS_MESS2
);
3634 for (p
= matching
; *p
; p
++)
3635 ret_len
+= strlen (*p
) + 1;
3636 ret
= xmalloc (ret_len
+ 1);
3638 make_cleanup (xfree
, ret
);
3640 strcpy (retp
, bfd_errmsg (error_tag
));
3641 retp
+= strlen (retp
);
3643 strcpy (retp
, AMBIGUOUS_MESS1
);
3644 retp
+= strlen (retp
);
3646 for (p
= matching
; *p
; p
++)
3648 sprintf (retp
, " %s", *p
);
3649 retp
+= strlen (retp
);
3653 strcpy (retp
, AMBIGUOUS_MESS2
);
3658 /* Return ARGS parsed as a valid pid, or throw an error. */
3661 parse_pid_to_attach (char *args
)
3667 error_no_arg (_("process-id to attach"));
3670 pid
= strtoul (args
, &dummy
, 0);
3671 /* Some targets don't set errno on errors, grrr! */
3672 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
3673 error (_("Illegal process-id: %s."), args
);
3678 /* Provide a prototype to silence -Wmissing-prototypes. */
3679 extern initialize_file_ftype _initialize_utils
;
3682 _initialize_utils (void)
3684 add_internal_problem_command (&internal_error_problem
);
3685 add_internal_problem_command (&internal_warning_problem
);