1 /* General utility routines for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* FIXME: cagney/2002-02-28: The GDB coding standard indicates that
24 "defs.h" should be included first. Unfortunatly some systems
25 (currently Debian GNU/Linux) include the <stdbool.h> via <curses.h>
26 and they clash with "bfd.h"'s definiton of true/false. The correct
27 fix is to remove true/false from "bfd.h", however, until that
28 happens, hack around it by including "config.h" and <curses.h>
41 #include "gdb_assert.h"
43 #include "gdb_string.h"
44 #include "event-top.h"
50 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
61 #include "expression.h"
64 #include "filenames.h"
66 #include "inferior.h" /* for signed_pointer_to_address */
68 #include <sys/param.h> /* For MAXPATHLEN */
70 #include <readline/readline.h>
76 #ifdef NEED_DECLARATION_MALLOC
79 #ifdef NEED_DECLARATION_REALLOC
80 extern PTR
realloc ();
82 #ifdef NEED_DECLARATION_FREE
85 /* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
86 #if defined(HAVE_CANONICALIZE_FILE_NAME) \
87 && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
88 extern char *canonicalize_file_name (const char *);
91 /* readline defines this. */
94 void (*error_begin_hook
) (void);
96 /* Holds the last error message issued by gdb */
98 static struct ui_file
*gdb_lasterr
;
100 /* Prototypes for local functions */
102 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
105 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
107 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
108 static void malloc_botch (void);
111 static void prompt_for_continue (void);
113 static void set_width_command (char *, int, struct cmd_list_element
*);
115 static void set_width (void);
117 /* Chain of cleanup actions established with make_cleanup,
118 to be executed if an error happens. */
120 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
121 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
122 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
123 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
124 /* cleaned up on each error from within an execution command */
125 static struct cleanup
*exec_error_cleanup_chain
;
127 /* Pointer to what is left to do for an execution command after the
128 target stops. Used only in asynchronous mode, by targets that
129 support async execution. The finish and until commands use it. So
130 does the target extended-remote command. */
131 struct continuation
*cmd_continuation
;
132 struct continuation
*intermediate_continuation
;
134 /* Nonzero if we have job control. */
138 /* Nonzero means a quit has been requested. */
142 /* Nonzero means quit immediately if Control-C is typed now, rather
143 than waiting until QUIT is executed. Be careful in setting this;
144 code which executes with immediate_quit set has to be very careful
145 about being able to deal with being interrupted at any time. It is
146 almost always better to use QUIT; the only exception I can think of
147 is being able to quit out of a system call (using EINTR loses if
148 the SIGINT happens between the previous QUIT and the system call).
149 To immediately quit in the case in which a SIGINT happens between
150 the previous QUIT and setting immediate_quit (desirable anytime we
151 expect to block), call QUIT after setting immediate_quit. */
155 /* Nonzero means that encoded C++ names should be printed out in their
156 C++ form rather than raw. */
160 /* Nonzero means that encoded C++ names should be printed out in their
161 C++ form even in assembler language displays. If this is set, but
162 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
164 int asm_demangle
= 0;
166 /* Nonzero means that strings with character values >0x7F should be printed
167 as octal escapes. Zero means just print the value (e.g. it's an
168 international character, and the terminal or window can cope.) */
170 int sevenbit_strings
= 0;
172 /* String to be printed before error messages, if any. */
174 char *error_pre_print
;
176 /* String to be printed before quit messages, if any. */
178 char *quit_pre_print
;
180 /* String to be printed before warning messages, if any. */
182 char *warning_pre_print
= "\nwarning: ";
184 int pagination_enabled
= 1;
187 /* Add a new cleanup to the cleanup_chain,
188 and return the previous chain pointer
189 to be passed later to do_cleanups or discard_cleanups.
190 Args are FUNCTION to clean up with, and ARG to pass to it. */
193 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
195 return make_my_cleanup (&cleanup_chain
, function
, arg
);
199 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
201 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
205 make_run_cleanup (make_cleanup_ftype
*function
, void *arg
)
207 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
211 make_exec_cleanup (make_cleanup_ftype
*function
, void *arg
)
213 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
217 make_exec_error_cleanup (make_cleanup_ftype
*function
, void *arg
)
219 return make_my_cleanup (&exec_error_cleanup_chain
, function
, arg
);
223 do_freeargv (void *arg
)
225 freeargv ((char **) arg
);
229 make_cleanup_freeargv (char **arg
)
231 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
235 do_bfd_close_cleanup (void *arg
)
241 make_cleanup_bfd_close (bfd
*abfd
)
243 return make_cleanup (do_bfd_close_cleanup
, abfd
);
247 do_close_cleanup (void *arg
)
255 make_cleanup_close (int fd
)
257 int *saved_fd
= xmalloc (sizeof (fd
));
259 return make_cleanup (do_close_cleanup
, saved_fd
);
263 do_ui_file_delete (void *arg
)
265 ui_file_delete (arg
);
269 make_cleanup_ui_file_delete (struct ui_file
*arg
)
271 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
275 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
278 register struct cleanup
*new
279 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
280 register struct cleanup
*old_chain
= *pmy_chain
;
282 new->next
= *pmy_chain
;
283 new->function
= function
;
290 /* Discard cleanups and do the actions they describe
291 until we get back to the point OLD_CHAIN in the cleanup_chain. */
294 do_cleanups (register struct cleanup
*old_chain
)
296 do_my_cleanups (&cleanup_chain
, old_chain
);
300 do_final_cleanups (register struct cleanup
*old_chain
)
302 do_my_cleanups (&final_cleanup_chain
, old_chain
);
306 do_run_cleanups (register struct cleanup
*old_chain
)
308 do_my_cleanups (&run_cleanup_chain
, old_chain
);
312 do_exec_cleanups (register struct cleanup
*old_chain
)
314 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
318 do_exec_error_cleanups (register struct cleanup
*old_chain
)
320 do_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
324 do_my_cleanups (register struct cleanup
**pmy_chain
,
325 register struct cleanup
*old_chain
)
327 register struct cleanup
*ptr
;
328 while ((ptr
= *pmy_chain
) != old_chain
)
330 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
331 (*ptr
->function
) (ptr
->arg
);
336 /* Discard cleanups, not doing the actions they describe,
337 until we get back to the point OLD_CHAIN in the cleanup_chain. */
340 discard_cleanups (register struct cleanup
*old_chain
)
342 discard_my_cleanups (&cleanup_chain
, old_chain
);
346 discard_final_cleanups (register struct cleanup
*old_chain
)
348 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
352 discard_exec_error_cleanups (register struct cleanup
*old_chain
)
354 discard_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
358 discard_my_cleanups (register struct cleanup
**pmy_chain
,
359 register struct cleanup
*old_chain
)
361 register struct cleanup
*ptr
;
362 while ((ptr
= *pmy_chain
) != old_chain
)
364 *pmy_chain
= ptr
->next
;
369 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
373 return save_my_cleanups (&cleanup_chain
);
377 save_final_cleanups (void)
379 return save_my_cleanups (&final_cleanup_chain
);
383 save_my_cleanups (struct cleanup
**pmy_chain
)
385 struct cleanup
*old_chain
= *pmy_chain
;
391 /* Restore the cleanup chain from a previously saved chain. */
393 restore_cleanups (struct cleanup
*chain
)
395 restore_my_cleanups (&cleanup_chain
, chain
);
399 restore_final_cleanups (struct cleanup
*chain
)
401 restore_my_cleanups (&final_cleanup_chain
, chain
);
405 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
410 /* This function is useful for cleanups.
414 old_chain = make_cleanup (free_current_contents, &foo);
416 to arrange to free the object thus allocated. */
419 free_current_contents (void *ptr
)
421 void **location
= ptr
;
422 if (location
== NULL
)
423 internal_error (__FILE__
, __LINE__
,
424 "free_current_contents: NULL pointer");
425 if (*location
!= NULL
)
432 /* Provide a known function that does nothing, to use as a base for
433 for a possibly long chain of cleanups. This is useful where we
434 use the cleanup chain for handling normal cleanups as well as dealing
435 with cleanups that need to be done as a result of a call to error().
436 In such cases, we may not be certain where the first cleanup is, unless
437 we have a do-nothing one to always use as the base. */
441 null_cleanup (void *arg
)
445 /* Add a continuation to the continuation list, the global list
446 cmd_continuation. The new continuation will be added at the front.*/
448 add_continuation (void (*continuation_hook
) (struct continuation_arg
*),
449 struct continuation_arg
*arg_list
)
451 struct continuation
*continuation_ptr
;
453 continuation_ptr
= (struct continuation
*) xmalloc (sizeof (struct continuation
));
454 continuation_ptr
->continuation_hook
= continuation_hook
;
455 continuation_ptr
->arg_list
= arg_list
;
456 continuation_ptr
->next
= cmd_continuation
;
457 cmd_continuation
= continuation_ptr
;
460 /* Walk down the cmd_continuation list, and execute all the
461 continuations. There is a problem though. In some cases new
462 continuations may be added while we are in the middle of this
463 loop. If this happens they will be added in the front, and done
464 before we have a chance of exhausting those that were already
465 there. We need to then save the beginning of the list in a pointer
466 and do the continuations from there on, instead of using the
467 global beginning of list as our iteration pointer.*/
469 do_all_continuations (void)
471 struct continuation
*continuation_ptr
;
472 struct continuation
*saved_continuation
;
474 /* Copy the list header into another pointer, and set the global
475 list header to null, so that the global list can change as a side
476 effect of invoking the continuations and the processing of
477 the preexisting continuations will not be affected. */
478 continuation_ptr
= cmd_continuation
;
479 cmd_continuation
= NULL
;
481 /* Work now on the list we have set aside. */
482 while (continuation_ptr
)
484 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
485 saved_continuation
= continuation_ptr
;
486 continuation_ptr
= continuation_ptr
->next
;
487 xfree (saved_continuation
);
491 /* Walk down the cmd_continuation list, and get rid of all the
494 discard_all_continuations (void)
496 struct continuation
*continuation_ptr
;
498 while (cmd_continuation
)
500 continuation_ptr
= cmd_continuation
;
501 cmd_continuation
= continuation_ptr
->next
;
502 xfree (continuation_ptr
);
506 /* Add a continuation to the continuation list, the global list
507 intermediate_continuation. The new continuation will be added at the front.*/
509 add_intermediate_continuation (void (*continuation_hook
)
510 (struct continuation_arg
*),
511 struct continuation_arg
*arg_list
)
513 struct continuation
*continuation_ptr
;
515 continuation_ptr
= (struct continuation
*) xmalloc (sizeof (struct continuation
));
516 continuation_ptr
->continuation_hook
= continuation_hook
;
517 continuation_ptr
->arg_list
= arg_list
;
518 continuation_ptr
->next
= intermediate_continuation
;
519 intermediate_continuation
= continuation_ptr
;
522 /* Walk down the cmd_continuation list, and execute all the
523 continuations. There is a problem though. In some cases new
524 continuations may be added while we are in the middle of this
525 loop. If this happens they will be added in the front, and done
526 before we have a chance of exhausting those that were already
527 there. We need to then save the beginning of the list in a pointer
528 and do the continuations from there on, instead of using the
529 global beginning of list as our iteration pointer.*/
531 do_all_intermediate_continuations (void)
533 struct continuation
*continuation_ptr
;
534 struct continuation
*saved_continuation
;
536 /* Copy the list header into another pointer, and set the global
537 list header to null, so that the global list can change as a side
538 effect of invoking the continuations and the processing of
539 the preexisting continuations will not be affected. */
540 continuation_ptr
= intermediate_continuation
;
541 intermediate_continuation
= NULL
;
543 /* Work now on the list we have set aside. */
544 while (continuation_ptr
)
546 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
547 saved_continuation
= continuation_ptr
;
548 continuation_ptr
= continuation_ptr
->next
;
549 xfree (saved_continuation
);
553 /* Walk down the cmd_continuation list, and get rid of all the
556 discard_all_intermediate_continuations (void)
558 struct continuation
*continuation_ptr
;
560 while (intermediate_continuation
)
562 continuation_ptr
= intermediate_continuation
;
563 intermediate_continuation
= continuation_ptr
->next
;
564 xfree (continuation_ptr
);
570 /* Print a warning message. The first argument STRING is the warning
571 message, used as an fprintf format string, the second is the
572 va_list of arguments for that string. A warning is unfiltered (not
573 paginated) so that the user does not need to page through each
574 screen full of warnings when there are lots of them. */
577 vwarning (const char *string
, va_list args
)
580 (*warning_hook
) (string
, args
);
583 target_terminal_ours ();
584 wrap_here (""); /* Force out any buffered output */
585 gdb_flush (gdb_stdout
);
586 if (warning_pre_print
)
587 fprintf_unfiltered (gdb_stderr
, warning_pre_print
);
588 vfprintf_unfiltered (gdb_stderr
, string
, args
);
589 fprintf_unfiltered (gdb_stderr
, "\n");
594 /* Print a warning message.
595 The first argument STRING is the warning message, used as a fprintf string,
596 and the remaining args are passed as arguments to it.
597 The primary difference between warnings and errors is that a warning
598 does not force the return to command level. */
601 warning (const char *string
,...)
604 va_start (args
, string
);
605 vwarning (string
, args
);
609 /* Print an error message and return to command level.
610 The first argument STRING is the error message, used as a fprintf string,
611 and the remaining args are passed as arguments to it. */
614 verror (const char *string
, va_list args
)
616 struct ui_file
*tmp_stream
= mem_fileopen ();
617 make_cleanup_ui_file_delete (tmp_stream
);
618 vfprintf_unfiltered (tmp_stream
, string
, args
);
619 error_stream (tmp_stream
);
623 error (const char *string
,...)
626 va_start (args
, string
);
627 verror (string
, args
);
632 do_write (void *data
, const char *buffer
, long length_buffer
)
634 ui_file_write (data
, buffer
, length_buffer
);
638 error_stream (struct ui_file
*stream
)
640 if (error_begin_hook
)
643 /* Copy the stream into the GDB_LASTERR buffer. */
644 ui_file_rewind (gdb_lasterr
);
645 ui_file_put (stream
, do_write
, gdb_lasterr
);
647 /* Write the message plus any error_pre_print to gdb_stderr. */
648 target_terminal_ours ();
649 wrap_here (""); /* Force out any buffered output */
650 gdb_flush (gdb_stdout
);
651 annotate_error_begin ();
653 fprintf_filtered (gdb_stderr
, error_pre_print
);
654 ui_file_put (stream
, do_write
, gdb_stderr
);
655 fprintf_filtered (gdb_stderr
, "\n");
657 throw_exception (RETURN_ERROR
);
660 /* Get the last error message issued by gdb */
663 error_last_message (void)
666 return ui_file_xstrdup (gdb_lasterr
, &len
);
669 /* This is to be called by main() at the very beginning */
674 gdb_lasterr
= mem_fileopen ();
677 /* Print a message reporting an internal error/warning. Ask the user
678 if they want to continue, dump core, or just exit. Return
679 something to indicate a quit. */
681 struct internal_problem
684 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
685 commands available for controlling these variables. */
686 enum auto_boolean should_quit
;
687 enum auto_boolean should_dump_core
;
690 /* Report a problem, internal to GDB, to the user. Once the problem
691 has been reported, and assuming GDB didn't quit, the caller can
692 either allow execution to resume or throw an error. */
695 internal_vproblem (struct internal_problem
*problem
,
696 const char *file
, int line
,
697 const char *fmt
, va_list ap
)
699 static char msg
[] = "Recursive internal problem.\n";
704 /* Don't allow infinite error/warning recursion. */
712 fputs_unfiltered (msg
, gdb_stderr
);
713 abort (); /* NOTE: GDB has only three calls to abort(). */
716 write (STDERR_FILENO
, msg
, sizeof (msg
));
720 /* Try to get the message out and at the start of a new line. */
721 target_terminal_ours ();
724 /* The error/warning message. Format using a style similar to a
725 compiler error message. */
726 fprintf_unfiltered (gdb_stderr
, "%s:%d: %s: ", file
, line
, problem
->name
);
727 vfprintf_unfiltered (gdb_stderr
, fmt
, ap
);
728 fputs_unfiltered ("\n", gdb_stderr
);
730 /* Provide more details so that the user knows that they are living
732 fprintf_unfiltered (gdb_stderr
, "\
733 A problem internal to GDB has been detected. Further\n\
734 debugging may prove unreliable.\n");
736 switch (problem
->should_quit
)
738 case AUTO_BOOLEAN_AUTO
:
739 /* Default (yes/batch case) is to quit GDB. When in batch mode
740 this lessens the likelhood of GDB going into an infinate
742 quit_p
= query ("Quit this debugging session? ");
744 case AUTO_BOOLEAN_TRUE
:
747 case AUTO_BOOLEAN_FALSE
:
751 internal_error (__FILE__
, __LINE__
, "bad switch");
754 switch (problem
->should_dump_core
)
756 case AUTO_BOOLEAN_AUTO
:
757 /* Default (yes/batch case) is to dump core. This leaves a GDB
758 `dropping' so that it is easier to see that something went
760 dump_core_p
= query ("Create a core file of GDB? ");
763 case AUTO_BOOLEAN_TRUE
:
766 case AUTO_BOOLEAN_FALSE
:
770 internal_error (__FILE__
, __LINE__
, "bad switch");
776 abort (); /* NOTE: GDB has only three calls to abort(). */
785 abort (); /* NOTE: GDB has only three calls to abort(). */
792 static struct internal_problem internal_error_problem
= {
793 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
797 internal_verror (const char *file
, int line
,
798 const char *fmt
, va_list ap
)
800 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
801 throw_exception (RETURN_ERROR
);
805 internal_error (const char *file
, int line
, const char *string
, ...)
808 va_start (ap
, string
);
809 internal_verror (file
, line
, string
, ap
);
813 static struct internal_problem internal_warning_problem
= {
814 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
818 internal_vwarning (const char *file
, int line
,
819 const char *fmt
, va_list ap
)
821 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
825 internal_warning (const char *file
, int line
, const char *string
, ...)
828 va_start (ap
, string
);
829 internal_vwarning (file
, line
, string
, ap
);
833 /* The strerror() function can return NULL for errno values that are
834 out of range. Provide a "safe" version that always returns a
838 safe_strerror (int errnum
)
843 if ((msg
= strerror (errnum
)) == NULL
)
845 sprintf (buf
, "(undocumented errno %d)", errnum
);
851 /* Print the system error message for errno, and also mention STRING
852 as the file name for which the error was encountered.
853 Then return to command level. */
856 perror_with_name (const char *string
)
861 err
= safe_strerror (errno
);
862 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
863 strcpy (combined
, string
);
864 strcat (combined
, ": ");
865 strcat (combined
, err
);
867 /* I understand setting these is a matter of taste. Still, some people
868 may clear errno but not know about bfd_error. Doing this here is not
870 bfd_set_error (bfd_error_no_error
);
873 error ("%s.", combined
);
876 /* Print the system error message for ERRCODE, and also mention STRING
877 as the file name for which the error was encountered. */
880 print_sys_errmsg (const char *string
, int errcode
)
885 err
= safe_strerror (errcode
);
886 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
887 strcpy (combined
, string
);
888 strcat (combined
, ": ");
889 strcat (combined
, err
);
891 /* We want anything which was printed on stdout to come out first, before
893 gdb_flush (gdb_stdout
);
894 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
897 /* Control C eventually causes this to be called, at a convenient time. */
902 struct serial
*gdb_stdout_serial
= serial_fdopen (1);
904 target_terminal_ours ();
906 /* We want all output to appear now, before we print "Quit". We
907 have 3 levels of buffering we have to flush (it's possible that
908 some of these should be changed to flush the lower-level ones
911 /* 1. The _filtered buffer. */
912 wrap_here ((char *) 0);
914 /* 2. The stdio buffer. */
915 gdb_flush (gdb_stdout
);
916 gdb_flush (gdb_stderr
);
918 /* 3. The system-level buffer. */
919 serial_drain_output (gdb_stdout_serial
);
920 serial_un_fdopen (gdb_stdout_serial
);
922 annotate_error_begin ();
924 /* Don't use *_filtered; we don't want to prompt the user to continue. */
926 fprintf_unfiltered (gdb_stderr
, quit_pre_print
);
929 /* No steenking SIGINT will ever be coming our way when the
930 program is resumed. Don't lie. */
931 fprintf_unfiltered (gdb_stderr
, "Quit\n");
934 /* If there is no terminal switching for this target, then we can't
935 possibly get screwed by the lack of job control. */
936 || current_target
.to_terminal_ours
== NULL
)
937 fprintf_unfiltered (gdb_stderr
, "Quit\n");
939 fprintf_unfiltered (gdb_stderr
,
940 "Quit (expect signal SIGINT when the program is resumed)\n");
942 throw_exception (RETURN_QUIT
);
945 /* Control C comes here */
947 request_quit (int signo
)
950 /* Restore the signal handler. Harmless with BSD-style signals, needed
951 for System V-style signals. So just always do it, rather than worrying
952 about USG defines and stuff like that. */
953 signal (signo
, request_quit
);
963 /* Memory management stuff (malloc friends). */
965 #if !defined (USE_MMALLOC)
967 /* NOTE: These must use PTR so that their definition matches the
968 declaration found in "mmalloc.h". */
971 mmalloc (void *md
, size_t size
)
973 return malloc (size
); /* NOTE: GDB's only call to malloc() */
977 mrealloc (void *md
, void *ptr
, size_t size
)
979 if (ptr
== 0) /* Guard against old realloc's */
980 return mmalloc (md
, size
);
982 return realloc (ptr
, size
); /* NOTE: GDB's only call to ralloc() */
986 mcalloc (void *md
, size_t number
, size_t size
)
988 return calloc (number
, size
); /* NOTE: GDB's only call to calloc() */
992 mfree (void *md
, void *ptr
)
994 free (ptr
); /* NOTE: GDB's only call to free() */
997 #endif /* USE_MMALLOC */
999 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
1002 init_malloc (void *md
)
1006 #else /* Have mmalloc and want corruption checking */
1011 fprintf_unfiltered (gdb_stderr
, "Memory corruption\n");
1012 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1015 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
1016 by MD, to detect memory corruption. Note that MD may be NULL to specify
1017 the default heap that grows via sbrk.
1019 Note that for freshly created regions, we must call mmcheckf prior to any
1020 mallocs in the region. Otherwise, any region which was allocated prior to
1021 installing the checking hooks, which is later reallocated or freed, will
1022 fail the checks! The mmcheck function only allows initial hooks to be
1023 installed before the first mmalloc. However, anytime after we have called
1024 mmcheck the first time to install the checking hooks, we can call it again
1025 to update the function pointer to the memory corruption handler.
1027 Returns zero on failure, non-zero on success. */
1029 #ifndef MMCHECK_FORCE
1030 #define MMCHECK_FORCE 0
1034 init_malloc (void *md
)
1036 if (!mmcheckf (md
, malloc_botch
, MMCHECK_FORCE
))
1038 /* Don't use warning(), which relies on current_target being set
1039 to something other than dummy_target, until after
1040 initialize_all_files(). */
1043 (gdb_stderr
, "warning: failed to install memory consistency checks; ");
1045 (gdb_stderr
, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
1051 #endif /* Have mmalloc and want corruption checking */
1053 /* Called when a memory allocation fails, with the number of bytes of
1054 memory requested in SIZE. */
1061 internal_error (__FILE__
, __LINE__
,
1062 "virtual memory exhausted: can't allocate %ld bytes.", size
);
1066 internal_error (__FILE__
, __LINE__
,
1067 "virtual memory exhausted.");
1071 /* The xmmalloc() family of memory management routines.
1073 These are are like the mmalloc() family except that they implement
1074 consistent semantics and guard against typical memory management
1075 problems: if a malloc fails, an internal error is thrown; if
1076 free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
1079 All these routines are implemented using the mmalloc() family. */
1082 xmmalloc (void *md
, size_t size
)
1092 val
= mmalloc (md
, size
);
1100 xmrealloc (void *md
, void *ptr
, size_t size
)
1114 val
= mrealloc (md
, ptr
, size
);
1118 val
= mmalloc (md
, size
);
1129 xmcalloc (void *md
, size_t number
, size_t size
)
1132 if (number
== 0 || size
== 0)
1136 mem
= mcalloc (md
, number
, size
);
1138 nomem (number
* size
);
1144 xmfree (void *md
, void *ptr
)
1150 /* The xmalloc() (libiberty.h) family of memory management routines.
1152 These are like the ISO-C malloc() family except that they implement
1153 consistent semantics and guard against typical memory management
1154 problems. See xmmalloc() above for further information.
1156 All these routines are wrappers to the xmmalloc() family. */
1158 /* NOTE: These are declared using PTR to ensure consistency with
1159 "libiberty.h". xfree() is GDB local. */
1162 xmalloc (size_t size
)
1164 return xmmalloc (NULL
, size
);
1168 xrealloc (PTR ptr
, size_t size
)
1170 return xmrealloc (NULL
, ptr
, size
);
1174 xcalloc (size_t number
, size_t size
)
1176 return xmcalloc (NULL
, number
, size
);
1186 /* Like asprintf/vasprintf but get an internal_error if the call
1190 xasprintf (char **ret
, const char *format
, ...)
1193 va_start (args
, format
);
1194 xvasprintf (ret
, format
, args
);
1199 xvasprintf (char **ret
, const char *format
, va_list ap
)
1201 int status
= vasprintf (ret
, format
, ap
);
1202 /* NULL could be returned due to a memory allocation problem; a
1203 badly format string; or something else. */
1205 internal_error (__FILE__
, __LINE__
,
1206 "vasprintf returned NULL buffer (errno %d)",
1208 /* A negative status with a non-NULL buffer shouldn't never
1209 happen. But to be sure. */
1211 internal_error (__FILE__
, __LINE__
,
1212 "vasprintf call failed (errno %d)",
1217 /* My replacement for the read system call.
1218 Used like `read' but keeps going if `read' returns too soon. */
1221 myread (int desc
, char *addr
, int len
)
1228 val
= read (desc
, addr
, len
);
1232 return orglen
- len
;
1239 /* Make a copy of the string at PTR with SIZE characters
1240 (and add a null character at the end in the copy).
1241 Uses malloc to get the space. Returns the address of the copy. */
1244 savestring (const char *ptr
, size_t size
)
1246 register char *p
= (char *) xmalloc (size
+ 1);
1247 memcpy (p
, ptr
, size
);
1253 msavestring (void *md
, const char *ptr
, size_t size
)
1255 register char *p
= (char *) xmmalloc (md
, size
+ 1);
1256 memcpy (p
, ptr
, size
);
1262 mstrsave (void *md
, const char *ptr
)
1264 return (msavestring (md
, ptr
, strlen (ptr
)));
1268 print_spaces (register int n
, register struct ui_file
*file
)
1270 fputs_unfiltered (n_spaces (n
), file
);
1273 /* Print a host address. */
1276 gdb_print_host_address (void *addr
, struct ui_file
*stream
)
1279 /* We could use the %p conversion specifier to fprintf if we had any
1280 way of knowing whether this host supports it. But the following
1281 should work on the Alpha and on 32 bit machines. */
1283 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1286 /* Ask user a y-or-n question and return 1 iff answer is yes.
1287 Takes three args which are given to printf to print the question.
1288 The first, a control string, should end in "? ".
1289 It should not say how to answer, because we do that. */
1293 query (const char *ctlstr
,...)
1296 register int answer
;
1300 va_start (args
, ctlstr
);
1304 return query_hook (ctlstr
, args
);
1307 /* Automatically answer "yes" if input is not from a terminal. */
1308 if (!input_from_terminal_p ())
1313 wrap_here (""); /* Flush any buffered output */
1314 gdb_flush (gdb_stdout
);
1316 if (annotation_level
> 1)
1317 printf_filtered ("\n\032\032pre-query\n");
1319 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1320 printf_filtered ("(y or n) ");
1322 if (annotation_level
> 1)
1323 printf_filtered ("\n\032\032query\n");
1326 gdb_flush (gdb_stdout
);
1328 answer
= fgetc (stdin
);
1329 clearerr (stdin
); /* in case of C-d */
1330 if (answer
== EOF
) /* C-d */
1335 /* Eat rest of input line, to EOF or newline */
1339 ans2
= fgetc (stdin
);
1342 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1356 printf_filtered ("Please answer y or n.\n");
1359 if (annotation_level
> 1)
1360 printf_filtered ("\n\032\032post-query\n");
1365 /* Parse a C escape sequence. STRING_PTR points to a variable
1366 containing a pointer to the string to parse. That pointer
1367 should point to the character after the \. That pointer
1368 is updated past the characters we use. The value of the
1369 escape sequence is returned.
1371 A negative value means the sequence \ newline was seen,
1372 which is supposed to be equivalent to nothing at all.
1374 If \ is followed by a null character, we return a negative
1375 value and leave the string pointer pointing at the null character.
1377 If \ is followed by 000, we return 0 and leave the string pointer
1378 after the zeros. A value of 0 does not mean end of string. */
1381 parse_escape (char **string_ptr
)
1383 register int c
= *(*string_ptr
)++;
1387 return 007; /* Bell (alert) char */
1390 case 'e': /* Escape character */
1408 c
= *(*string_ptr
)++;
1410 c
= parse_escape (string_ptr
);
1413 return (c
& 0200) | (c
& 037);
1424 register int i
= c
- '0';
1425 register int count
= 0;
1428 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
1446 /* Print the character C on STREAM as part of the contents of a literal
1447 string whose delimiter is QUOTER. Note that this routine should only
1448 be call for printing things which are independent of the language
1449 of the program being debugged. */
1452 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1453 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1454 struct ui_file
*stream
, int quoter
)
1457 c
&= 0xFF; /* Avoid sign bit follies */
1459 if (c
< 0x20 || /* Low control chars */
1460 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1461 (sevenbit_strings
&& c
>= 0x80))
1462 { /* high order bit set */
1466 do_fputs ("\\n", stream
);
1469 do_fputs ("\\b", stream
);
1472 do_fputs ("\\t", stream
);
1475 do_fputs ("\\f", stream
);
1478 do_fputs ("\\r", stream
);
1481 do_fputs ("\\e", stream
);
1484 do_fputs ("\\a", stream
);
1487 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1493 if (c
== '\\' || c
== quoter
)
1494 do_fputs ("\\", stream
);
1495 do_fprintf (stream
, "%c", c
);
1499 /* Print the character C on STREAM as part of the contents of a
1500 literal string whose delimiter is QUOTER. Note that these routines
1501 should only be call for printing things which are independent of
1502 the language of the program being debugged. */
1505 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1508 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1512 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1515 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1519 fputstrn_unfiltered (const char *str
, int n
, int quoter
, struct ui_file
*stream
)
1522 for (i
= 0; i
< n
; i
++)
1523 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1528 /* Number of lines per page or UINT_MAX if paging is disabled. */
1529 static unsigned int lines_per_page
;
1530 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1531 static unsigned int chars_per_line
;
1532 /* Current count of lines printed on this page, chars on this line. */
1533 static unsigned int lines_printed
, chars_printed
;
1535 /* Buffer and start column of buffered text, for doing smarter word-
1536 wrapping. When someone calls wrap_here(), we start buffering output
1537 that comes through fputs_filtered(). If we see a newline, we just
1538 spit it out and forget about the wrap_here(). If we see another
1539 wrap_here(), we spit it out and remember the newer one. If we see
1540 the end of the line, we spit out a newline, the indent, and then
1541 the buffered output. */
1543 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1544 are waiting to be output (they have already been counted in chars_printed).
1545 When wrap_buffer[0] is null, the buffer is empty. */
1546 static char *wrap_buffer
;
1548 /* Pointer in wrap_buffer to the next character to fill. */
1549 static char *wrap_pointer
;
1551 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1553 static char *wrap_indent
;
1555 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1556 is not in effect. */
1557 static int wrap_column
;
1560 /* Inialize the lines and chars per page */
1562 init_page_info (void)
1565 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1568 /* These defaults will be used if we are unable to get the correct
1569 values from termcap. */
1570 #if defined(__GO32__)
1571 lines_per_page
= ScreenRows ();
1572 chars_per_line
= ScreenCols ();
1574 lines_per_page
= 24;
1575 chars_per_line
= 80;
1577 #if !defined (_WIN32)
1578 /* No termcap under MPW, although might be cool to do something
1579 by looking at worksheet or console window sizes. */
1580 /* Initialize the screen height and width from termcap. */
1582 char *termtype
= getenv ("TERM");
1584 /* Positive means success, nonpositive means failure. */
1587 /* 2048 is large enough for all known terminals, according to the
1588 GNU termcap manual. */
1589 char term_buffer
[2048];
1593 status
= tgetent (term_buffer
, termtype
);
1597 int running_in_emacs
= getenv ("EMACS") != NULL
;
1599 val
= tgetnum ("li");
1600 if (val
>= 0 && !running_in_emacs
)
1601 lines_per_page
= val
;
1603 /* The number of lines per page is not mentioned
1604 in the terminal description. This probably means
1605 that paging is not useful (e.g. emacs shell window),
1606 so disable paging. */
1607 lines_per_page
= UINT_MAX
;
1609 val
= tgetnum ("co");
1611 chars_per_line
= val
;
1617 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1619 /* If there is a better way to determine the window size, use it. */
1620 SIGWINCH_HANDLER (SIGWINCH
);
1623 /* If the output is not a terminal, don't paginate it. */
1624 if (!ui_file_isatty (gdb_stdout
))
1625 lines_per_page
= UINT_MAX
;
1626 } /* the command_line_version */
1633 if (chars_per_line
== 0)
1638 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1639 wrap_buffer
[0] = '\0';
1642 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1643 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
1648 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1653 /* Wait, so the user can read what's on the screen. Prompt the user
1654 to continue by pressing RETURN. */
1657 prompt_for_continue (void)
1660 char cont_prompt
[120];
1662 if (annotation_level
> 1)
1663 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1665 strcpy (cont_prompt
,
1666 "---Type <return> to continue, or q <return> to quit---");
1667 if (annotation_level
> 1)
1668 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1670 /* We must do this *before* we call gdb_readline, else it will eventually
1671 call us -- thinking that we're trying to print beyond the end of the
1673 reinitialize_more_filter ();
1676 /* On a real operating system, the user can quit with SIGINT.
1679 'q' is provided on all systems so users don't have to change habits
1680 from system to system, and because telling them what to do in
1681 the prompt is more user-friendly than expecting them to think of
1683 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1684 whereas control-C to gdb_readline will cause the user to get dumped
1686 ignore
= gdb_readline_wrapper (cont_prompt
);
1688 if (annotation_level
> 1)
1689 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1694 while (*p
== ' ' || *p
== '\t')
1699 request_quit (SIGINT
);
1701 async_request_quit (0);
1707 /* Now we have to do this again, so that GDB will know that it doesn't
1708 need to save the ---Type <return>--- line at the top of the screen. */
1709 reinitialize_more_filter ();
1711 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1714 /* Reinitialize filter; ie. tell it to reset to original values. */
1717 reinitialize_more_filter (void)
1723 /* Indicate that if the next sequence of characters overflows the line,
1724 a newline should be inserted here rather than when it hits the end.
1725 If INDENT is non-null, it is a string to be printed to indent the
1726 wrapped part on the next line. INDENT must remain accessible until
1727 the next call to wrap_here() or until a newline is printed through
1730 If the line is already overfull, we immediately print a newline and
1731 the indentation, and disable further wrapping.
1733 If we don't know the width of lines, but we know the page height,
1734 we must not wrap words, but should still keep track of newlines
1735 that were explicitly printed.
1737 INDENT should not contain tabs, as that will mess up the char count
1738 on the next line. FIXME.
1740 This routine is guaranteed to force out any output which has been
1741 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1742 used to force out output from the wrap_buffer. */
1745 wrap_here (char *indent
)
1747 /* This should have been allocated, but be paranoid anyway. */
1749 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1753 *wrap_pointer
= '\0';
1754 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1756 wrap_pointer
= wrap_buffer
;
1757 wrap_buffer
[0] = '\0';
1758 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1762 else if (chars_printed
>= chars_per_line
)
1764 puts_filtered ("\n");
1766 puts_filtered (indent
);
1771 wrap_column
= chars_printed
;
1775 wrap_indent
= indent
;
1779 /* Ensure that whatever gets printed next, using the filtered output
1780 commands, starts at the beginning of the line. I.E. if there is
1781 any pending output for the current line, flush it and start a new
1782 line. Otherwise do nothing. */
1787 if (chars_printed
> 0)
1789 puts_filtered ("\n");
1794 /* Like fputs but if FILTER is true, pause after every screenful.
1796 Regardless of FILTER can wrap at points other than the final
1797 character of a line.
1799 Unlike fputs, fputs_maybe_filtered does not return a value.
1800 It is OK for LINEBUFFER to be NULL, in which case just don't print
1803 Note that a longjmp to top level may occur in this routine (only if
1804 FILTER is true) (since prompt_for_continue may do so) so this
1805 routine should not be called when cleanups are not in place. */
1808 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1811 const char *lineptr
;
1813 if (linebuffer
== 0)
1816 /* Don't do any filtering if it is disabled. */
1817 if ((stream
!= gdb_stdout
) || !pagination_enabled
1818 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1820 fputs_unfiltered (linebuffer
, stream
);
1824 /* Go through and output each character. Show line extension
1825 when this is necessary; prompt user for new page when this is
1828 lineptr
= linebuffer
;
1831 /* Possible new page. */
1833 (lines_printed
>= lines_per_page
- 1))
1834 prompt_for_continue ();
1836 while (*lineptr
&& *lineptr
!= '\n')
1838 /* Print a single line. */
1839 if (*lineptr
== '\t')
1842 *wrap_pointer
++ = '\t';
1844 fputc_unfiltered ('\t', stream
);
1845 /* Shifting right by 3 produces the number of tab stops
1846 we have already passed, and then adding one and
1847 shifting left 3 advances to the next tab stop. */
1848 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1854 *wrap_pointer
++ = *lineptr
;
1856 fputc_unfiltered (*lineptr
, stream
);
1861 if (chars_printed
>= chars_per_line
)
1863 unsigned int save_chars
= chars_printed
;
1867 /* If we aren't actually wrapping, don't output newline --
1868 if chars_per_line is right, we probably just overflowed
1869 anyway; if it's wrong, let us keep going. */
1871 fputc_unfiltered ('\n', stream
);
1873 /* Possible new page. */
1874 if (lines_printed
>= lines_per_page
- 1)
1875 prompt_for_continue ();
1877 /* Now output indentation and wrapped string */
1880 fputs_unfiltered (wrap_indent
, stream
);
1881 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1882 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1883 /* FIXME, this strlen is what prevents wrap_indent from
1884 containing tabs. However, if we recurse to print it
1885 and count its chars, we risk trouble if wrap_indent is
1886 longer than (the user settable) chars_per_line.
1887 Note also that this can set chars_printed > chars_per_line
1888 if we are printing a long string. */
1889 chars_printed
= strlen (wrap_indent
)
1890 + (save_chars
- wrap_column
);
1891 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1892 wrap_buffer
[0] = '\0';
1893 wrap_column
= 0; /* And disable fancy wrap */
1898 if (*lineptr
== '\n')
1901 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1903 fputc_unfiltered ('\n', stream
);
1910 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1912 fputs_maybe_filtered (linebuffer
, stream
, 1);
1916 putchar_unfiltered (int c
)
1919 ui_file_write (gdb_stdout
, &buf
, 1);
1923 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1924 May return nonlocally. */
1927 putchar_filtered (int c
)
1929 return fputc_filtered (c
, gdb_stdout
);
1933 fputc_unfiltered (int c
, struct ui_file
*stream
)
1936 ui_file_write (stream
, &buf
, 1);
1941 fputc_filtered (int c
, struct ui_file
*stream
)
1947 fputs_filtered (buf
, stream
);
1951 /* puts_debug is like fputs_unfiltered, except it prints special
1952 characters in printable fashion. */
1955 puts_debug (char *prefix
, char *string
, char *suffix
)
1959 /* Print prefix and suffix after each line. */
1960 static int new_line
= 1;
1961 static int return_p
= 0;
1962 static char *prev_prefix
= "";
1963 static char *prev_suffix
= "";
1965 if (*string
== '\n')
1968 /* If the prefix is changing, print the previous suffix, a new line,
1969 and the new prefix. */
1970 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
1972 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
1973 fputs_unfiltered ("\n", gdb_stdlog
);
1974 fputs_unfiltered (prefix
, gdb_stdlog
);
1977 /* Print prefix if we printed a newline during the previous call. */
1981 fputs_unfiltered (prefix
, gdb_stdlog
);
1984 prev_prefix
= prefix
;
1985 prev_suffix
= suffix
;
1987 /* Output characters in a printable format. */
1988 while ((ch
= *string
++) != '\0')
1994 fputc_unfiltered (ch
, gdb_stdlog
);
1997 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2001 fputs_unfiltered ("\\\\", gdb_stdlog
);
2004 fputs_unfiltered ("\\b", gdb_stdlog
);
2007 fputs_unfiltered ("\\f", gdb_stdlog
);
2011 fputs_unfiltered ("\\n", gdb_stdlog
);
2014 fputs_unfiltered ("\\r", gdb_stdlog
);
2017 fputs_unfiltered ("\\t", gdb_stdlog
);
2020 fputs_unfiltered ("\\v", gdb_stdlog
);
2024 return_p
= ch
== '\r';
2027 /* Print suffix if we printed a newline. */
2030 fputs_unfiltered (suffix
, gdb_stdlog
);
2031 fputs_unfiltered ("\n", gdb_stdlog
);
2036 /* Print a variable number of ARGS using format FORMAT. If this
2037 information is going to put the amount written (since the last call
2038 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2039 call prompt_for_continue to get the users permision to continue.
2041 Unlike fprintf, this function does not return a value.
2043 We implement three variants, vfprintf (takes a vararg list and stream),
2044 fprintf (takes a stream to write on), and printf (the usual).
2046 Note also that a longjmp to top level may occur in this routine
2047 (since prompt_for_continue may do so) so this routine should not be
2048 called when cleanups are not in place. */
2051 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2052 va_list args
, int filter
)
2055 struct cleanup
*old_cleanups
;
2057 xvasprintf (&linebuffer
, format
, args
);
2058 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2059 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2060 do_cleanups (old_cleanups
);
2065 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2067 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2071 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2074 struct cleanup
*old_cleanups
;
2076 xvasprintf (&linebuffer
, format
, args
);
2077 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2078 fputs_unfiltered (linebuffer
, stream
);
2079 do_cleanups (old_cleanups
);
2083 vprintf_filtered (const char *format
, va_list args
)
2085 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2089 vprintf_unfiltered (const char *format
, va_list args
)
2091 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2095 fprintf_filtered (struct ui_file
* stream
, const char *format
,...)
2098 va_start (args
, format
);
2099 vfprintf_filtered (stream
, format
, args
);
2104 fprintf_unfiltered (struct ui_file
* stream
, const char *format
,...)
2107 va_start (args
, format
);
2108 vfprintf_unfiltered (stream
, format
, args
);
2112 /* Like fprintf_filtered, but prints its result indented.
2113 Called as fprintfi_filtered (spaces, stream, format, ...); */
2116 fprintfi_filtered (int spaces
, struct ui_file
* stream
, const char *format
,...)
2119 va_start (args
, format
);
2120 print_spaces_filtered (spaces
, stream
);
2122 vfprintf_filtered (stream
, format
, args
);
2128 printf_filtered (const char *format
,...)
2131 va_start (args
, format
);
2132 vfprintf_filtered (gdb_stdout
, format
, args
);
2138 printf_unfiltered (const char *format
,...)
2141 va_start (args
, format
);
2142 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2146 /* Like printf_filtered, but prints it's result indented.
2147 Called as printfi_filtered (spaces, format, ...); */
2150 printfi_filtered (int spaces
, const char *format
,...)
2153 va_start (args
, format
);
2154 print_spaces_filtered (spaces
, gdb_stdout
);
2155 vfprintf_filtered (gdb_stdout
, format
, args
);
2159 /* Easy -- but watch out!
2161 This routine is *not* a replacement for puts()! puts() appends a newline.
2162 This one doesn't, and had better not! */
2165 puts_filtered (const char *string
)
2167 fputs_filtered (string
, gdb_stdout
);
2171 puts_unfiltered (const char *string
)
2173 fputs_unfiltered (string
, gdb_stdout
);
2176 /* Return a pointer to N spaces and a null. The pointer is good
2177 until the next call to here. */
2182 static char *spaces
= 0;
2183 static int max_spaces
= -1;
2189 spaces
= (char *) xmalloc (n
+ 1);
2190 for (t
= spaces
+ n
; t
!= spaces
;)
2196 return spaces
+ max_spaces
- n
;
2199 /* Print N spaces. */
2201 print_spaces_filtered (int n
, struct ui_file
*stream
)
2203 fputs_filtered (n_spaces (n
), stream
);
2206 /* C++ demangler stuff. */
2208 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2209 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2210 If the name is not mangled, or the language for the name is unknown, or
2211 demangling is off, the name is printed in its "raw" form. */
2214 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
, enum language lang
,
2221 /* If user wants to see raw output, no problem. */
2224 fputs_filtered (name
, stream
);
2230 case language_cplus
:
2231 demangled
= cplus_demangle (name
, arg_mode
);
2234 demangled
= cplus_demangle (name
, arg_mode
| DMGL_JAVA
);
2237 /* OBSOLETE case language_chill: */
2238 /* OBSOLETE demangled = chill_demangle (name); */
2239 /* OBSOLETE break; */
2245 fputs_filtered (demangled
? demangled
: name
, stream
);
2246 if (demangled
!= NULL
)
2254 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2255 differences in whitespace. Returns 0 if they match, non-zero if they
2256 don't (slightly different than strcmp()'s range of return values).
2258 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2259 This "feature" is useful when searching for matching C++ function names
2260 (such as if the user types 'break FOO', where FOO is a mangled C++
2264 strcmp_iw (const char *string1
, const char *string2
)
2266 while ((*string1
!= '\0') && (*string2
!= '\0'))
2268 while (isspace (*string1
))
2272 while (isspace (*string2
))
2276 if (*string1
!= *string2
)
2280 if (*string1
!= '\0')
2286 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2292 ** Answer whether string_to_compare is a full or partial match to
2293 ** template_string. The partial match must be in sequence starting
2297 subset_compare (char *string_to_compare
, char *template_string
)
2300 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
&&
2301 strlen (string_to_compare
) <= strlen (template_string
))
2302 match
= (strncmp (template_string
,
2304 strlen (string_to_compare
)) == 0);
2311 static void pagination_on_command (char *arg
, int from_tty
);
2313 pagination_on_command (char *arg
, int from_tty
)
2315 pagination_enabled
= 1;
2318 static void pagination_on_command (char *arg
, int from_tty
);
2320 pagination_off_command (char *arg
, int from_tty
)
2322 pagination_enabled
= 0;
2327 initialize_utils (void)
2329 struct cmd_list_element
*c
;
2331 c
= add_set_cmd ("width", class_support
, var_uinteger
,
2332 (char *) &chars_per_line
,
2333 "Set number of characters gdb thinks are in a line.",
2335 add_show_from_set (c
, &showlist
);
2336 set_cmd_sfunc (c
, set_width_command
);
2339 (add_set_cmd ("height", class_support
,
2340 var_uinteger
, (char *) &lines_per_page
,
2341 "Set number of lines gdb thinks are in a page.", &setlist
),
2346 /* If the output is not a terminal, don't paginate it. */
2347 if (!ui_file_isatty (gdb_stdout
))
2348 lines_per_page
= UINT_MAX
;
2350 set_width_command ((char *) NULL
, 0, c
);
2353 (add_set_cmd ("demangle", class_support
, var_boolean
,
2355 "Set demangling of encoded C++ names when displaying symbols.",
2360 (add_set_cmd ("pagination", class_support
,
2361 var_boolean
, (char *) &pagination_enabled
,
2362 "Set state of pagination.", &setlist
),
2367 add_com ("am", class_support
, pagination_on_command
,
2368 "Enable pagination");
2369 add_com ("sm", class_support
, pagination_off_command
,
2370 "Disable pagination");
2374 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2375 (char *) &sevenbit_strings
,
2376 "Set printing of 8-bit characters in strings as \\nnn.",
2381 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2382 (char *) &asm_demangle
,
2383 "Set demangling of C++ names in disassembly listings.",
2388 /* Machine specific function to handle SIGWINCH signal. */
2390 #ifdef SIGWINCH_HANDLER_BODY
2391 SIGWINCH_HANDLER_BODY
2394 /* print routines to handle variable size regs, etc. */
2396 /* temporary storage using circular buffer */
2402 static char buf
[NUMCELLS
][CELLSIZE
];
2403 static int cell
= 0;
2404 if (++cell
>= NUMCELLS
)
2412 return (TARGET_ADDR_BIT
/ 8 * 2);
2416 paddr (CORE_ADDR addr
)
2418 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2422 paddr_nz (CORE_ADDR addr
)
2424 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2428 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
)
2430 /* steal code from valprint.c:print_decimal(). Should this worry
2431 about the real size of addr as the above does? */
2432 unsigned long temp
[3];
2436 temp
[i
] = addr
% (1000 * 1000 * 1000);
2437 addr
/= (1000 * 1000 * 1000);
2440 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2444 sprintf (paddr_str
, "%s%lu",
2448 sprintf (paddr_str
, "%s%lu%09lu",
2449 sign
, temp
[1], temp
[0]);
2452 sprintf (paddr_str
, "%s%lu%09lu%09lu",
2453 sign
, temp
[2], temp
[1], temp
[0]);
2456 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
2461 paddr_u (CORE_ADDR addr
)
2463 char *paddr_str
= get_cell ();
2464 decimal2str (paddr_str
, "", addr
);
2469 paddr_d (LONGEST addr
)
2471 char *paddr_str
= get_cell ();
2473 decimal2str (paddr_str
, "-", -addr
);
2475 decimal2str (paddr_str
, "", addr
);
2479 /* eliminate warning from compiler on 32-bit systems */
2480 static int thirty_two
= 32;
2483 phex (ULONGEST l
, int sizeof_l
)
2490 sprintf (str
, "%08lx%08lx",
2491 (unsigned long) (l
>> thirty_two
),
2492 (unsigned long) (l
& 0xffffffff));
2496 sprintf (str
, "%08lx", (unsigned long) l
);
2500 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2503 str
= phex (l
, sizeof (l
));
2510 phex_nz (ULONGEST l
, int sizeof_l
)
2517 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2520 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
2522 sprintf (str
, "%lx%08lx",
2523 high
, (unsigned long) (l
& 0xffffffff));
2528 sprintf (str
, "%lx", (unsigned long) l
);
2532 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
2535 str
= phex_nz (l
, sizeof (l
));
2542 /* Convert to / from the hosts pointer to GDB's internal CORE_ADDR
2543 using the target's conversion routines. */
2545 host_pointer_to_address (void *ptr
)
2547 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2548 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2552 address_to_host_pointer (CORE_ADDR addr
)
2556 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2557 ADDRESS_TO_POINTER (builtin_type_void_data_ptr
, &ptr
, addr
);
2561 /* Convert a CORE_ADDR into a string. */
2563 core_addr_to_string (const CORE_ADDR addr
)
2565 char *str
= get_cell ();
2567 strcat (str
, phex (addr
, sizeof (addr
)));
2572 core_addr_to_string_nz (const CORE_ADDR addr
)
2574 char *str
= get_cell ();
2576 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2580 /* Convert a string back into a CORE_ADDR. */
2582 string_to_core_addr (const char *my_string
)
2585 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2587 /* Assume that it is in decimal. */
2589 for (i
= 2; my_string
[i
] != '\0'; i
++)
2591 if (isdigit (my_string
[i
]))
2592 addr
= (my_string
[i
] - '0') + (addr
* 16);
2593 else if (isxdigit (my_string
[i
]))
2594 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2596 internal_error (__FILE__
, __LINE__
, "invalid hex");
2601 /* Assume that it is in decimal. */
2603 for (i
= 0; my_string
[i
] != '\0'; i
++)
2605 if (isdigit (my_string
[i
]))
2606 addr
= (my_string
[i
] - '0') + (addr
* 10);
2608 internal_error (__FILE__
, __LINE__
, "invalid decimal");
2615 gdb_realpath (const char *filename
)
2617 #if defined(HAVE_REALPATH)
2618 # if defined (PATH_MAX)
2620 # define USE_REALPATH
2621 # elif defined (MAXPATHLEN)
2622 char buf
[MAXPATHLEN
];
2623 # define USE_REALPATH
2624 # elif defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2625 char *buf
= alloca ((size_t)pathconf ("/", _PC_PATH_MAX
));
2626 # define USE_REALPATH
2628 #endif /* HAVE_REALPATH */
2630 #if defined(USE_REALPATH)
2631 char *rp
= realpath (filename
, buf
);
2632 return xstrdup (rp
? rp
: filename
);
2633 #elif defined(HAVE_CANONICALIZE_FILE_NAME)
2634 char *rp
= canonicalize_file_name (filename
);
2636 return xstrdup (filename
);
2640 return xstrdup (filename
);
2644 /* Return a copy of FILENAME, with its directory prefix canonicalized
2648 xfullpath (const char *filename
)
2650 const char *base_name
= lbasename (filename
);
2655 /* Extract the basename of filename, and return immediately
2656 a copy of filename if it does not contain any directory prefix. */
2657 if (base_name
== filename
)
2658 return xstrdup (filename
);
2660 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
2661 /* Allocate enough space to store the dir_name + plus one extra
2662 character sometimes needed under Windows (see below), and
2663 then the closing \000 character */
2664 strncpy (dir_name
, filename
, base_name
- filename
);
2665 dir_name
[base_name
- filename
] = '\000';
2667 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2668 /* We need to be careful when filename is of the form 'd:foo', which
2669 is equivalent of d:./foo, which is totally different from d:/foo. */
2670 if (strlen (dir_name
) == 2 &&
2671 isalpha (dir_name
[0]) && dir_name
[1] == ':')
2674 dir_name
[3] = '\000';
2678 /* Canonicalize the directory prefix, and build the resulting
2679 filename. If the dirname realpath already contains an ending
2680 directory separator, avoid doubling it. */
2681 real_path
= gdb_realpath (dir_name
);
2682 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2683 result
= concat (real_path
, base_name
, NULL
);
2685 result
= concat (real_path
, SLASH_STRING
, base_name
, NULL
);