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. */
24 #include "gdb_assert.h"
26 #include "gdb_string.h"
27 #include "event-top.h"
33 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
44 #include "expression.h"
48 #include "filenames.h"
50 #include "inferior.h" /* for signed_pointer_to_address */
52 #include <sys/param.h> /* For MAXPATHLEN */
61 #include <readline/readline.h>
67 #ifdef NEED_DECLARATION_MALLOC
70 #ifdef NEED_DECLARATION_REALLOC
71 extern PTR
realloc ();
73 #ifdef NEED_DECLARATION_FREE
76 /* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
77 #if defined(HAVE_CANONICALIZE_FILE_NAME) \
78 && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
79 extern char *canonicalize_file_name (const char *);
82 /* readline defines this. */
85 void (*error_begin_hook
) (void);
87 /* Holds the last error message issued by gdb */
89 static struct ui_file
*gdb_lasterr
;
91 /* Prototypes for local functions */
93 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
96 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
98 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
99 static void malloc_botch (void);
102 static void prompt_for_continue (void);
104 static void set_width_command (char *, int, struct cmd_list_element
*);
106 static void set_width (void);
108 /* Chain of cleanup actions established with make_cleanup,
109 to be executed if an error happens. */
111 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
112 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
113 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
114 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
115 /* cleaned up on each error from within an execution command */
116 static struct cleanup
*exec_error_cleanup_chain
;
118 /* Pointer to what is left to do for an execution command after the
119 target stops. Used only in asynchronous mode, by targets that
120 support async execution. The finish and until commands use it. So
121 does the target extended-remote command. */
122 struct continuation
*cmd_continuation
;
123 struct continuation
*intermediate_continuation
;
125 /* Nonzero if we have job control. */
129 /* Nonzero means a quit has been requested. */
133 /* Nonzero means quit immediately if Control-C is typed now, rather
134 than waiting until QUIT is executed. Be careful in setting this;
135 code which executes with immediate_quit set has to be very careful
136 about being able to deal with being interrupted at any time. It is
137 almost always better to use QUIT; the only exception I can think of
138 is being able to quit out of a system call (using EINTR loses if
139 the SIGINT happens between the previous QUIT and the system call).
140 To immediately quit in the case in which a SIGINT happens between
141 the previous QUIT and setting immediate_quit (desirable anytime we
142 expect to block), call QUIT after setting immediate_quit. */
146 /* Nonzero means that encoded C++/ObjC names should be printed out in their
147 C++/ObjC form rather than raw. */
151 /* Nonzero means that encoded C++/ObjC names should be printed out in their
152 C++/ObjC form even in assembler language displays. If this is set, but
153 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
155 int asm_demangle
= 0;
157 /* Nonzero means that strings with character values >0x7F should be printed
158 as octal escapes. Zero means just print the value (e.g. it's an
159 international character, and the terminal or window can cope.) */
161 int sevenbit_strings
= 0;
163 /* String to be printed before error messages, if any. */
165 char *error_pre_print
;
167 /* String to be printed before quit messages, if any. */
169 char *quit_pre_print
;
171 /* String to be printed before warning messages, if any. */
173 char *warning_pre_print
= "\nwarning: ";
175 int pagination_enabled
= 1;
178 /* Add a new cleanup to the cleanup_chain,
179 and return the previous chain pointer
180 to be passed later to do_cleanups or discard_cleanups.
181 Args are FUNCTION to clean up with, and ARG to pass to it. */
184 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
186 return make_my_cleanup (&cleanup_chain
, function
, arg
);
190 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
192 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
196 make_run_cleanup (make_cleanup_ftype
*function
, void *arg
)
198 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
202 make_exec_cleanup (make_cleanup_ftype
*function
, void *arg
)
204 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
208 make_exec_error_cleanup (make_cleanup_ftype
*function
, void *arg
)
210 return make_my_cleanup (&exec_error_cleanup_chain
, function
, arg
);
214 do_freeargv (void *arg
)
216 freeargv ((char **) arg
);
220 make_cleanup_freeargv (char **arg
)
222 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
226 do_bfd_close_cleanup (void *arg
)
232 make_cleanup_bfd_close (bfd
*abfd
)
234 return make_cleanup (do_bfd_close_cleanup
, abfd
);
238 do_close_cleanup (void *arg
)
246 make_cleanup_close (int fd
)
248 int *saved_fd
= xmalloc (sizeof (fd
));
250 return make_cleanup (do_close_cleanup
, saved_fd
);
254 do_ui_file_delete (void *arg
)
256 ui_file_delete (arg
);
260 make_cleanup_ui_file_delete (struct ui_file
*arg
)
262 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
266 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
269 register struct cleanup
*new
270 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
271 register struct cleanup
*old_chain
= *pmy_chain
;
273 new->next
= *pmy_chain
;
274 new->function
= function
;
281 /* Discard cleanups and do the actions they describe
282 until we get back to the point OLD_CHAIN in the cleanup_chain. */
285 do_cleanups (register struct cleanup
*old_chain
)
287 do_my_cleanups (&cleanup_chain
, old_chain
);
291 do_final_cleanups (register struct cleanup
*old_chain
)
293 do_my_cleanups (&final_cleanup_chain
, old_chain
);
297 do_run_cleanups (register struct cleanup
*old_chain
)
299 do_my_cleanups (&run_cleanup_chain
, old_chain
);
303 do_exec_cleanups (register struct cleanup
*old_chain
)
305 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
309 do_exec_error_cleanups (register struct cleanup
*old_chain
)
311 do_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
315 do_my_cleanups (register struct cleanup
**pmy_chain
,
316 register struct cleanup
*old_chain
)
318 register struct cleanup
*ptr
;
319 while ((ptr
= *pmy_chain
) != old_chain
)
321 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
322 (*ptr
->function
) (ptr
->arg
);
327 /* Discard cleanups, not doing the actions they describe,
328 until we get back to the point OLD_CHAIN in the cleanup_chain. */
331 discard_cleanups (register struct cleanup
*old_chain
)
333 discard_my_cleanups (&cleanup_chain
, old_chain
);
337 discard_final_cleanups (register struct cleanup
*old_chain
)
339 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
343 discard_exec_error_cleanups (register struct cleanup
*old_chain
)
345 discard_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
349 discard_my_cleanups (register struct cleanup
**pmy_chain
,
350 register struct cleanup
*old_chain
)
352 register struct cleanup
*ptr
;
353 while ((ptr
= *pmy_chain
) != old_chain
)
355 *pmy_chain
= ptr
->next
;
360 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
364 return save_my_cleanups (&cleanup_chain
);
368 save_final_cleanups (void)
370 return save_my_cleanups (&final_cleanup_chain
);
374 save_my_cleanups (struct cleanup
**pmy_chain
)
376 struct cleanup
*old_chain
= *pmy_chain
;
382 /* Restore the cleanup chain from a previously saved chain. */
384 restore_cleanups (struct cleanup
*chain
)
386 restore_my_cleanups (&cleanup_chain
, chain
);
390 restore_final_cleanups (struct cleanup
*chain
)
392 restore_my_cleanups (&final_cleanup_chain
, chain
);
396 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
401 /* This function is useful for cleanups.
405 old_chain = make_cleanup (free_current_contents, &foo);
407 to arrange to free the object thus allocated. */
410 free_current_contents (void *ptr
)
412 void **location
= ptr
;
413 if (location
== NULL
)
414 internal_error (__FILE__
, __LINE__
,
415 "free_current_contents: NULL pointer");
416 if (*location
!= NULL
)
423 /* Provide a known function that does nothing, to use as a base for
424 for a possibly long chain of cleanups. This is useful where we
425 use the cleanup chain for handling normal cleanups as well as dealing
426 with cleanups that need to be done as a result of a call to error().
427 In such cases, we may not be certain where the first cleanup is, unless
428 we have a do-nothing one to always use as the base. */
432 null_cleanup (void *arg
)
436 /* Add a continuation to the continuation list, the global list
437 cmd_continuation. The new continuation will be added at the front.*/
439 add_continuation (void (*continuation_hook
) (struct continuation_arg
*),
440 struct continuation_arg
*arg_list
)
442 struct continuation
*continuation_ptr
;
444 continuation_ptr
= (struct continuation
*) xmalloc (sizeof (struct continuation
));
445 continuation_ptr
->continuation_hook
= continuation_hook
;
446 continuation_ptr
->arg_list
= arg_list
;
447 continuation_ptr
->next
= cmd_continuation
;
448 cmd_continuation
= continuation_ptr
;
451 /* Walk down the cmd_continuation list, and execute all the
452 continuations. There is a problem though. In some cases new
453 continuations may be added while we are in the middle of this
454 loop. If this happens they will be added in the front, and done
455 before we have a chance of exhausting those that were already
456 there. We need to then save the beginning of the list in a pointer
457 and do the continuations from there on, instead of using the
458 global beginning of list as our iteration pointer.*/
460 do_all_continuations (void)
462 struct continuation
*continuation_ptr
;
463 struct continuation
*saved_continuation
;
465 /* Copy the list header into another pointer, and set the global
466 list header to null, so that the global list can change as a side
467 effect of invoking the continuations and the processing of
468 the preexisting continuations will not be affected. */
469 continuation_ptr
= cmd_continuation
;
470 cmd_continuation
= NULL
;
472 /* Work now on the list we have set aside. */
473 while (continuation_ptr
)
475 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
476 saved_continuation
= continuation_ptr
;
477 continuation_ptr
= continuation_ptr
->next
;
478 xfree (saved_continuation
);
482 /* Walk down the cmd_continuation list, and get rid of all the
485 discard_all_continuations (void)
487 struct continuation
*continuation_ptr
;
489 while (cmd_continuation
)
491 continuation_ptr
= cmd_continuation
;
492 cmd_continuation
= continuation_ptr
->next
;
493 xfree (continuation_ptr
);
497 /* Add a continuation to the continuation list, the global list
498 intermediate_continuation. The new continuation will be added at the front.*/
500 add_intermediate_continuation (void (*continuation_hook
)
501 (struct continuation_arg
*),
502 struct continuation_arg
*arg_list
)
504 struct continuation
*continuation_ptr
;
506 continuation_ptr
= (struct continuation
*) xmalloc (sizeof (struct continuation
));
507 continuation_ptr
->continuation_hook
= continuation_hook
;
508 continuation_ptr
->arg_list
= arg_list
;
509 continuation_ptr
->next
= intermediate_continuation
;
510 intermediate_continuation
= continuation_ptr
;
513 /* Walk down the cmd_continuation list, and execute all the
514 continuations. There is a problem though. In some cases new
515 continuations may be added while we are in the middle of this
516 loop. If this happens they will be added in the front, and done
517 before we have a chance of exhausting those that were already
518 there. We need to then save the beginning of the list in a pointer
519 and do the continuations from there on, instead of using the
520 global beginning of list as our iteration pointer.*/
522 do_all_intermediate_continuations (void)
524 struct continuation
*continuation_ptr
;
525 struct continuation
*saved_continuation
;
527 /* Copy the list header into another pointer, and set the global
528 list header to null, so that the global list can change as a side
529 effect of invoking the continuations and the processing of
530 the preexisting continuations will not be affected. */
531 continuation_ptr
= intermediate_continuation
;
532 intermediate_continuation
= NULL
;
534 /* Work now on the list we have set aside. */
535 while (continuation_ptr
)
537 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
538 saved_continuation
= continuation_ptr
;
539 continuation_ptr
= continuation_ptr
->next
;
540 xfree (saved_continuation
);
544 /* Walk down the cmd_continuation list, and get rid of all the
547 discard_all_intermediate_continuations (void)
549 struct continuation
*continuation_ptr
;
551 while (intermediate_continuation
)
553 continuation_ptr
= intermediate_continuation
;
554 intermediate_continuation
= continuation_ptr
->next
;
555 xfree (continuation_ptr
);
561 /* Print a warning message. The first argument STRING is the warning
562 message, used as an fprintf format string, the second is the
563 va_list of arguments for that string. A warning is unfiltered (not
564 paginated) so that the user does not need to page through each
565 screen full of warnings when there are lots of them. */
568 vwarning (const char *string
, va_list args
)
571 (*warning_hook
) (string
, args
);
574 target_terminal_ours ();
575 wrap_here (""); /* Force out any buffered output */
576 gdb_flush (gdb_stdout
);
577 if (warning_pre_print
)
578 fprintf_unfiltered (gdb_stderr
, warning_pre_print
);
579 vfprintf_unfiltered (gdb_stderr
, string
, args
);
580 fprintf_unfiltered (gdb_stderr
, "\n");
585 /* Print a warning message.
586 The first argument STRING is the warning message, used as a fprintf string,
587 and the remaining args are passed as arguments to it.
588 The primary difference between warnings and errors is that a warning
589 does not force the return to command level. */
592 warning (const char *string
,...)
595 va_start (args
, string
);
596 vwarning (string
, args
);
600 /* Print an error message and return to command level.
601 The first argument STRING is the error message, used as a fprintf string,
602 and the remaining args are passed as arguments to it. */
605 verror (const char *string
, va_list args
)
607 struct ui_file
*tmp_stream
= mem_fileopen ();
608 make_cleanup_ui_file_delete (tmp_stream
);
609 vfprintf_unfiltered (tmp_stream
, string
, args
);
610 error_stream (tmp_stream
);
614 error (const char *string
,...)
617 va_start (args
, string
);
618 verror (string
, args
);
623 do_write (void *data
, const char *buffer
, long length_buffer
)
625 ui_file_write (data
, buffer
, length_buffer
);
629 error_stream (struct ui_file
*stream
)
631 if (error_begin_hook
)
634 /* Copy the stream into the GDB_LASTERR buffer. */
635 ui_file_rewind (gdb_lasterr
);
636 ui_file_put (stream
, do_write
, gdb_lasterr
);
638 /* Write the message plus any error_pre_print to gdb_stderr. */
639 target_terminal_ours ();
640 wrap_here (""); /* Force out any buffered output */
641 gdb_flush (gdb_stdout
);
642 annotate_error_begin ();
644 fprintf_filtered (gdb_stderr
, error_pre_print
);
645 ui_file_put (stream
, do_write
, gdb_stderr
);
646 fprintf_filtered (gdb_stderr
, "\n");
648 throw_exception (RETURN_ERROR
);
651 /* Get the last error message issued by gdb */
654 error_last_message (void)
657 return ui_file_xstrdup (gdb_lasterr
, &len
);
660 /* This is to be called by main() at the very beginning */
665 gdb_lasterr
= mem_fileopen ();
668 /* Print a message reporting an internal error/warning. Ask the user
669 if they want to continue, dump core, or just exit. Return
670 something to indicate a quit. */
672 struct internal_problem
675 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
676 commands available for controlling these variables. */
677 enum auto_boolean should_quit
;
678 enum auto_boolean should_dump_core
;
681 /* Report a problem, internal to GDB, to the user. Once the problem
682 has been reported, and assuming GDB didn't quit, the caller can
683 either allow execution to resume or throw an error. */
686 internal_vproblem (struct internal_problem
*problem
,
687 const char *file
, int line
,
688 const char *fmt
, va_list ap
)
690 static char msg
[] = "Recursive internal problem.\n";
695 /* Don't allow infinite error/warning recursion. */
703 fputs_unfiltered (msg
, gdb_stderr
);
704 abort (); /* NOTE: GDB has only three calls to abort(). */
707 write (STDERR_FILENO
, msg
, sizeof (msg
));
711 /* Try to get the message out and at the start of a new line. */
712 target_terminal_ours ();
715 /* The error/warning message. Format using a style similar to a
716 compiler error message. */
717 fprintf_unfiltered (gdb_stderr
, "%s:%d: %s: ", file
, line
, problem
->name
);
718 vfprintf_unfiltered (gdb_stderr
, fmt
, ap
);
719 fputs_unfiltered ("\n", gdb_stderr
);
721 /* Provide more details so that the user knows that they are living
723 fprintf_unfiltered (gdb_stderr
, "\
724 A problem internal to GDB has been detected. Further\n\
725 debugging may prove unreliable.\n");
727 switch (problem
->should_quit
)
729 case AUTO_BOOLEAN_AUTO
:
730 /* Default (yes/batch case) is to quit GDB. When in batch mode
731 this lessens the likelhood of GDB going into an infinate
733 quit_p
= query ("Quit this debugging session? ");
735 case AUTO_BOOLEAN_TRUE
:
738 case AUTO_BOOLEAN_FALSE
:
742 internal_error (__FILE__
, __LINE__
, "bad switch");
745 switch (problem
->should_dump_core
)
747 case AUTO_BOOLEAN_AUTO
:
748 /* Default (yes/batch case) is to dump core. This leaves a GDB
749 `dropping' so that it is easier to see that something went
751 dump_core_p
= query ("Create a core file of GDB? ");
754 case AUTO_BOOLEAN_TRUE
:
757 case AUTO_BOOLEAN_FALSE
:
761 internal_error (__FILE__
, __LINE__
, "bad switch");
767 abort (); /* NOTE: GDB has only three calls to abort(). */
776 abort (); /* NOTE: GDB has only three calls to abort(). */
783 static struct internal_problem internal_error_problem
= {
784 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
788 internal_verror (const char *file
, int line
,
789 const char *fmt
, va_list ap
)
791 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
792 throw_exception (RETURN_ERROR
);
796 internal_error (const char *file
, int line
, const char *string
, ...)
799 va_start (ap
, string
);
800 internal_verror (file
, line
, string
, ap
);
804 static struct internal_problem internal_warning_problem
= {
805 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
809 internal_vwarning (const char *file
, int line
,
810 const char *fmt
, va_list ap
)
812 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
816 internal_warning (const char *file
, int line
, const char *string
, ...)
819 va_start (ap
, string
);
820 internal_vwarning (file
, line
, string
, ap
);
824 /* The strerror() function can return NULL for errno values that are
825 out of range. Provide a "safe" version that always returns a
829 safe_strerror (int errnum
)
834 if ((msg
= strerror (errnum
)) == NULL
)
836 sprintf (buf
, "(undocumented errno %d)", errnum
);
842 /* Print the system error message for errno, and also mention STRING
843 as the file name for which the error was encountered.
844 Then return to command level. */
847 perror_with_name (const char *string
)
852 err
= safe_strerror (errno
);
853 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
854 strcpy (combined
, string
);
855 strcat (combined
, ": ");
856 strcat (combined
, err
);
858 /* I understand setting these is a matter of taste. Still, some people
859 may clear errno but not know about bfd_error. Doing this here is not
861 bfd_set_error (bfd_error_no_error
);
864 error ("%s.", combined
);
867 /* Print the system error message for ERRCODE, and also mention STRING
868 as the file name for which the error was encountered. */
871 print_sys_errmsg (const char *string
, int errcode
)
876 err
= safe_strerror (errcode
);
877 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
878 strcpy (combined
, string
);
879 strcat (combined
, ": ");
880 strcat (combined
, err
);
882 /* We want anything which was printed on stdout to come out first, before
884 gdb_flush (gdb_stdout
);
885 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
888 /* Control C eventually causes this to be called, at a convenient time. */
893 struct serial
*gdb_stdout_serial
= serial_fdopen (1);
895 target_terminal_ours ();
897 /* We want all output to appear now, before we print "Quit". We
898 have 3 levels of buffering we have to flush (it's possible that
899 some of these should be changed to flush the lower-level ones
902 /* 1. The _filtered buffer. */
903 wrap_here ((char *) 0);
905 /* 2. The stdio buffer. */
906 gdb_flush (gdb_stdout
);
907 gdb_flush (gdb_stderr
);
909 /* 3. The system-level buffer. */
910 serial_drain_output (gdb_stdout_serial
);
911 serial_un_fdopen (gdb_stdout_serial
);
913 annotate_error_begin ();
915 /* Don't use *_filtered; we don't want to prompt the user to continue. */
917 fprintf_unfiltered (gdb_stderr
, quit_pre_print
);
920 /* No steenking SIGINT will ever be coming our way when the
921 program is resumed. Don't lie. */
922 fprintf_unfiltered (gdb_stderr
, "Quit\n");
925 /* If there is no terminal switching for this target, then we can't
926 possibly get screwed by the lack of job control. */
927 || current_target
.to_terminal_ours
== NULL
)
928 fprintf_unfiltered (gdb_stderr
, "Quit\n");
930 fprintf_unfiltered (gdb_stderr
,
931 "Quit (expect signal SIGINT when the program is resumed)\n");
933 throw_exception (RETURN_QUIT
);
936 /* Control C comes here */
938 request_quit (int signo
)
941 /* Restore the signal handler. Harmless with BSD-style signals, needed
942 for System V-style signals. So just always do it, rather than worrying
943 about USG defines and stuff like that. */
944 signal (signo
, request_quit
);
954 /* Memory management stuff (malloc friends). */
956 #if !defined (USE_MMALLOC)
958 /* NOTE: These must use PTR so that their definition matches the
959 declaration found in "mmalloc.h". */
962 mmalloc (void *md
, size_t size
)
964 return malloc (size
); /* NOTE: GDB's only call to malloc() */
968 mrealloc (void *md
, void *ptr
, size_t size
)
970 if (ptr
== 0) /* Guard against old realloc's */
971 return mmalloc (md
, size
);
973 return realloc (ptr
, size
); /* NOTE: GDB's only call to ralloc() */
977 mcalloc (void *md
, size_t number
, size_t size
)
979 return calloc (number
, size
); /* NOTE: GDB's only call to calloc() */
983 mfree (void *md
, void *ptr
)
985 free (ptr
); /* NOTE: GDB's only call to free() */
988 #endif /* USE_MMALLOC */
990 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
993 init_malloc (void *md
)
997 #else /* Have mmalloc and want corruption checking */
1002 fprintf_unfiltered (gdb_stderr
, "Memory corruption\n");
1003 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1006 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
1007 by MD, to detect memory corruption. Note that MD may be NULL to specify
1008 the default heap that grows via sbrk.
1010 Note that for freshly created regions, we must call mmcheckf prior to any
1011 mallocs in the region. Otherwise, any region which was allocated prior to
1012 installing the checking hooks, which is later reallocated or freed, will
1013 fail the checks! The mmcheck function only allows initial hooks to be
1014 installed before the first mmalloc. However, anytime after we have called
1015 mmcheck the first time to install the checking hooks, we can call it again
1016 to update the function pointer to the memory corruption handler.
1018 Returns zero on failure, non-zero on success. */
1020 #ifndef MMCHECK_FORCE
1021 #define MMCHECK_FORCE 0
1025 init_malloc (void *md
)
1027 if (!mmcheckf (md
, malloc_botch
, MMCHECK_FORCE
))
1029 /* Don't use warning(), which relies on current_target being set
1030 to something other than dummy_target, until after
1031 initialize_all_files(). */
1034 (gdb_stderr
, "warning: failed to install memory consistency checks; ");
1036 (gdb_stderr
, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
1042 #endif /* Have mmalloc and want corruption checking */
1044 /* Called when a memory allocation fails, with the number of bytes of
1045 memory requested in SIZE. */
1052 internal_error (__FILE__
, __LINE__
,
1053 "virtual memory exhausted: can't allocate %ld bytes.", size
);
1057 internal_error (__FILE__
, __LINE__
,
1058 "virtual memory exhausted.");
1062 /* The xmmalloc() family of memory management routines.
1064 These are are like the mmalloc() family except that they implement
1065 consistent semantics and guard against typical memory management
1066 problems: if a malloc fails, an internal error is thrown; if
1067 free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
1070 All these routines are implemented using the mmalloc() family. */
1073 xmmalloc (void *md
, size_t size
)
1083 val
= mmalloc (md
, size
);
1091 xmrealloc (void *md
, void *ptr
, size_t size
)
1105 val
= mrealloc (md
, ptr
, size
);
1109 val
= mmalloc (md
, size
);
1120 xmcalloc (void *md
, size_t number
, size_t size
)
1123 if (number
== 0 || size
== 0)
1127 mem
= mcalloc (md
, number
, size
);
1129 nomem (number
* size
);
1135 xmfree (void *md
, void *ptr
)
1141 /* The xmalloc() (libiberty.h) family of memory management routines.
1143 These are like the ISO-C malloc() family except that they implement
1144 consistent semantics and guard against typical memory management
1145 problems. See xmmalloc() above for further information.
1147 All these routines are wrappers to the xmmalloc() family. */
1149 /* NOTE: These are declared using PTR to ensure consistency with
1150 "libiberty.h". xfree() is GDB local. */
1153 xmalloc (size_t size
)
1155 return xmmalloc (NULL
, size
);
1159 xrealloc (PTR ptr
, size_t size
)
1161 return xmrealloc (NULL
, ptr
, size
);
1165 xcalloc (size_t number
, size_t size
)
1167 return xmcalloc (NULL
, number
, size
);
1177 /* Like asprintf/vasprintf but get an internal_error if the call
1181 xasprintf (char **ret
, const char *format
, ...)
1184 va_start (args
, format
);
1185 xvasprintf (ret
, format
, args
);
1190 xvasprintf (char **ret
, const char *format
, va_list ap
)
1192 int status
= vasprintf (ret
, format
, ap
);
1193 /* NULL could be returned due to a memory allocation problem; a
1194 badly format string; or something else. */
1196 internal_error (__FILE__
, __LINE__
,
1197 "vasprintf returned NULL buffer (errno %d)",
1199 /* A negative status with a non-NULL buffer shouldn't never
1200 happen. But to be sure. */
1202 internal_error (__FILE__
, __LINE__
,
1203 "vasprintf call failed (errno %d)",
1208 /* My replacement for the read system call.
1209 Used like `read' but keeps going if `read' returns too soon. */
1212 myread (int desc
, char *addr
, int len
)
1219 val
= read (desc
, addr
, len
);
1223 return orglen
- len
;
1230 /* Make a copy of the string at PTR with SIZE characters
1231 (and add a null character at the end in the copy).
1232 Uses malloc to get the space. Returns the address of the copy. */
1235 savestring (const char *ptr
, size_t size
)
1237 register char *p
= (char *) xmalloc (size
+ 1);
1238 memcpy (p
, ptr
, size
);
1244 msavestring (void *md
, const char *ptr
, size_t size
)
1246 register char *p
= (char *) xmmalloc (md
, size
+ 1);
1247 memcpy (p
, ptr
, size
);
1253 mstrsave (void *md
, const char *ptr
)
1255 return (msavestring (md
, ptr
, strlen (ptr
)));
1259 print_spaces (register int n
, register struct ui_file
*file
)
1261 fputs_unfiltered (n_spaces (n
), file
);
1264 /* Print a host address. */
1267 gdb_print_host_address (void *addr
, struct ui_file
*stream
)
1270 /* We could use the %p conversion specifier to fprintf if we had any
1271 way of knowing whether this host supports it. But the following
1272 should work on the Alpha and on 32 bit machines. */
1274 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1277 /* Ask user a y-or-n question and return 1 iff answer is yes.
1278 Takes three args which are given to printf to print the question.
1279 The first, a control string, should end in "? ".
1280 It should not say how to answer, because we do that. */
1284 query (const char *ctlstr
,...)
1287 register int answer
;
1291 va_start (args
, ctlstr
);
1295 return query_hook (ctlstr
, args
);
1298 /* Automatically answer "yes" if input is not from a terminal. */
1299 if (!input_from_terminal_p ())
1304 wrap_here (""); /* Flush any buffered output */
1305 gdb_flush (gdb_stdout
);
1307 if (annotation_level
> 1)
1308 printf_filtered ("\n\032\032pre-query\n");
1310 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1311 printf_filtered ("(y or n) ");
1313 if (annotation_level
> 1)
1314 printf_filtered ("\n\032\032query\n");
1317 gdb_flush (gdb_stdout
);
1319 answer
= fgetc (stdin
);
1320 clearerr (stdin
); /* in case of C-d */
1321 if (answer
== EOF
) /* C-d */
1326 /* Eat rest of input line, to EOF or newline */
1330 ans2
= fgetc (stdin
);
1333 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1347 printf_filtered ("Please answer y or n.\n");
1350 if (annotation_level
> 1)
1351 printf_filtered ("\n\032\032post-query\n");
1356 /* Print an error message saying that we couldn't make sense of a
1357 \^mumble sequence in a string or character constant. START and END
1358 indicate a substring of some larger string that contains the
1359 erroneous backslash sequence, missing the initial backslash. */
1361 no_control_char_error (const char *start
, const char *end
)
1363 int len
= end
- start
;
1364 char *copy
= alloca (end
- start
+ 1);
1366 memcpy (copy
, start
, len
);
1369 error ("There is no control character `\\%s' in the `%s' character set.",
1370 copy
, target_charset ());
1373 /* Parse a C escape sequence. STRING_PTR points to a variable
1374 containing a pointer to the string to parse. That pointer
1375 should point to the character after the \. That pointer
1376 is updated past the characters we use. The value of the
1377 escape sequence is returned.
1379 A negative value means the sequence \ newline was seen,
1380 which is supposed to be equivalent to nothing at all.
1382 If \ is followed by a null character, we return a negative
1383 value and leave the string pointer pointing at the null character.
1385 If \ is followed by 000, we return 0 and leave the string pointer
1386 after the zeros. A value of 0 does not mean end of string. */
1389 parse_escape (char **string_ptr
)
1392 register int c
= *(*string_ptr
)++;
1393 if (c_parse_backslash (c
, &target_char
))
1404 /* Remember where this escape sequence started, for reporting
1406 char *sequence_start_pos
= *string_ptr
- 1;
1408 c
= *(*string_ptr
)++;
1412 /* XXXCHARSET: What is `delete' in the host character set? */
1415 if (! host_char_to_target (c
, &target_char
))
1416 error ("There is no character corresponding to `Delete' "
1417 "in the target character set `%s'.",
1423 target_char
= parse_escape (string_ptr
);
1426 if (! host_char_to_target (c
, &target_char
))
1427 no_control_char_error (sequence_start_pos
, *string_ptr
);
1430 /* Now target_char is something like `c', and we want to find
1431 its control-character equivalent. */
1432 if (! target_char_to_control_char (target_char
, &target_char
))
1433 no_control_char_error (sequence_start_pos
, *string_ptr
);
1438 /* XXXCHARSET: we need to use isdigit and value-of-digit
1439 methods of the host character set here. */
1450 register int i
= c
- '0';
1451 register int count
= 0;
1454 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
1468 if (! host_char_to_target (c
, &target_char
))
1469 error ("The escape sequence `\%c' is equivalent to plain `%c', which"
1470 " has no equivalent\n"
1471 "in the `%s' character set.",
1472 c
, c
, target_charset ());
1477 /* Print the character C on STREAM as part of the contents of a literal
1478 string whose delimiter is QUOTER. Note that this routine should only
1479 be call for printing things which are independent of the language
1480 of the program being debugged. */
1483 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1484 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1485 struct ui_file
*stream
, int quoter
)
1488 c
&= 0xFF; /* Avoid sign bit follies */
1490 if (c
< 0x20 || /* Low control chars */
1491 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1492 (sevenbit_strings
&& c
>= 0x80))
1493 { /* high order bit set */
1497 do_fputs ("\\n", stream
);
1500 do_fputs ("\\b", stream
);
1503 do_fputs ("\\t", stream
);
1506 do_fputs ("\\f", stream
);
1509 do_fputs ("\\r", stream
);
1512 do_fputs ("\\e", stream
);
1515 do_fputs ("\\a", stream
);
1518 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1524 if (c
== '\\' || c
== quoter
)
1525 do_fputs ("\\", stream
);
1526 do_fprintf (stream
, "%c", c
);
1530 /* Print the character C on STREAM as part of the contents of a
1531 literal string whose delimiter is QUOTER. Note that these routines
1532 should only be call for printing things which are independent of
1533 the language of the program being debugged. */
1536 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1539 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1543 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1546 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1550 fputstrn_unfiltered (const char *str
, int n
, int quoter
, struct ui_file
*stream
)
1553 for (i
= 0; i
< n
; i
++)
1554 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1559 /* Number of lines per page or UINT_MAX if paging is disabled. */
1560 static unsigned int lines_per_page
;
1561 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1562 static unsigned int chars_per_line
;
1563 /* Current count of lines printed on this page, chars on this line. */
1564 static unsigned int lines_printed
, chars_printed
;
1566 /* Buffer and start column of buffered text, for doing smarter word-
1567 wrapping. When someone calls wrap_here(), we start buffering output
1568 that comes through fputs_filtered(). If we see a newline, we just
1569 spit it out and forget about the wrap_here(). If we see another
1570 wrap_here(), we spit it out and remember the newer one. If we see
1571 the end of the line, we spit out a newline, the indent, and then
1572 the buffered output. */
1574 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1575 are waiting to be output (they have already been counted in chars_printed).
1576 When wrap_buffer[0] is null, the buffer is empty. */
1577 static char *wrap_buffer
;
1579 /* Pointer in wrap_buffer to the next character to fill. */
1580 static char *wrap_pointer
;
1582 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1584 static char *wrap_indent
;
1586 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1587 is not in effect. */
1588 static int wrap_column
;
1591 /* Inialize the lines and chars per page */
1593 init_page_info (void)
1596 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1599 /* These defaults will be used if we are unable to get the correct
1600 values from termcap. */
1601 #if defined(__GO32__)
1602 lines_per_page
= ScreenRows ();
1603 chars_per_line
= ScreenCols ();
1605 lines_per_page
= 24;
1606 chars_per_line
= 80;
1608 #if !defined (_WIN32)
1609 /* No termcap under MPW, although might be cool to do something
1610 by looking at worksheet or console window sizes. */
1611 /* Initialize the screen height and width from termcap. */
1613 char *termtype
= getenv ("TERM");
1615 /* Positive means success, nonpositive means failure. */
1618 /* 2048 is large enough for all known terminals, according to the
1619 GNU termcap manual. */
1620 char term_buffer
[2048];
1624 status
= tgetent (term_buffer
, termtype
);
1628 int running_in_emacs
= getenv ("EMACS") != NULL
;
1630 val
= tgetnum ("li");
1631 if (val
>= 0 && !running_in_emacs
)
1632 lines_per_page
= val
;
1634 /* The number of lines per page is not mentioned
1635 in the terminal description. This probably means
1636 that paging is not useful (e.g. emacs shell window),
1637 so disable paging. */
1638 lines_per_page
= UINT_MAX
;
1640 val
= tgetnum ("co");
1642 chars_per_line
= val
;
1648 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1650 /* If there is a better way to determine the window size, use it. */
1651 SIGWINCH_HANDLER (SIGWINCH
);
1654 /* If the output is not a terminal, don't paginate it. */
1655 if (!ui_file_isatty (gdb_stdout
))
1656 lines_per_page
= UINT_MAX
;
1657 } /* the command_line_version */
1664 if (chars_per_line
== 0)
1669 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1670 wrap_buffer
[0] = '\0';
1673 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1674 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
1679 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1684 /* Wait, so the user can read what's on the screen. Prompt the user
1685 to continue by pressing RETURN. */
1688 prompt_for_continue (void)
1691 char cont_prompt
[120];
1693 if (annotation_level
> 1)
1694 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1696 strcpy (cont_prompt
,
1697 "---Type <return> to continue, or q <return> to quit---");
1698 if (annotation_level
> 1)
1699 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1701 /* We must do this *before* we call gdb_readline, else it will eventually
1702 call us -- thinking that we're trying to print beyond the end of the
1704 reinitialize_more_filter ();
1707 /* On a real operating system, the user can quit with SIGINT.
1710 'q' is provided on all systems so users don't have to change habits
1711 from system to system, and because telling them what to do in
1712 the prompt is more user-friendly than expecting them to think of
1714 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1715 whereas control-C to gdb_readline will cause the user to get dumped
1717 ignore
= gdb_readline_wrapper (cont_prompt
);
1719 if (annotation_level
> 1)
1720 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1725 while (*p
== ' ' || *p
== '\t')
1730 request_quit (SIGINT
);
1732 async_request_quit (0);
1738 /* Now we have to do this again, so that GDB will know that it doesn't
1739 need to save the ---Type <return>--- line at the top of the screen. */
1740 reinitialize_more_filter ();
1742 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1745 /* Reinitialize filter; ie. tell it to reset to original values. */
1748 reinitialize_more_filter (void)
1754 /* Indicate that if the next sequence of characters overflows the line,
1755 a newline should be inserted here rather than when it hits the end.
1756 If INDENT is non-null, it is a string to be printed to indent the
1757 wrapped part on the next line. INDENT must remain accessible until
1758 the next call to wrap_here() or until a newline is printed through
1761 If the line is already overfull, we immediately print a newline and
1762 the indentation, and disable further wrapping.
1764 If we don't know the width of lines, but we know the page height,
1765 we must not wrap words, but should still keep track of newlines
1766 that were explicitly printed.
1768 INDENT should not contain tabs, as that will mess up the char count
1769 on the next line. FIXME.
1771 This routine is guaranteed to force out any output which has been
1772 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1773 used to force out output from the wrap_buffer. */
1776 wrap_here (char *indent
)
1778 /* This should have been allocated, but be paranoid anyway. */
1780 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1784 *wrap_pointer
= '\0';
1785 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1787 wrap_pointer
= wrap_buffer
;
1788 wrap_buffer
[0] = '\0';
1789 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1793 else if (chars_printed
>= chars_per_line
)
1795 puts_filtered ("\n");
1797 puts_filtered (indent
);
1802 wrap_column
= chars_printed
;
1806 wrap_indent
= indent
;
1810 /* Print input string to gdb_stdout, filtered, with wrap,
1811 arranging strings in columns of n chars. String can be
1812 right or left justified in the column. Never prints
1813 trailing spaces. String should never be longer than
1814 width. FIXME: this could be useful for the EXAMINE
1815 command, which currently doesn't tabulate very well */
1818 puts_filtered_tabular (char *string
, int width
, int right
)
1824 gdb_assert (chars_per_line
> 0);
1825 if (chars_per_line
== UINT_MAX
)
1827 fputs_filtered (string
, gdb_stdout
);
1828 fputs_filtered ("\n", gdb_stdout
);
1832 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1833 fputs_filtered ("\n", gdb_stdout
);
1835 if (width
>= chars_per_line
)
1836 width
= chars_per_line
- 1;
1838 stringlen
= strlen (string
);
1840 if (chars_printed
> 0)
1841 spaces
= width
- (chars_printed
- 1) % width
- 1;
1843 spaces
+= width
- stringlen
;
1845 spacebuf
= alloca (spaces
+ 1);
1846 spacebuf
[spaces
] = '\0';
1848 spacebuf
[spaces
] = ' ';
1850 fputs_filtered (spacebuf
, gdb_stdout
);
1851 fputs_filtered (string
, gdb_stdout
);
1855 /* Ensure that whatever gets printed next, using the filtered output
1856 commands, starts at the beginning of the line. I.E. if there is
1857 any pending output for the current line, flush it and start a new
1858 line. Otherwise do nothing. */
1863 if (chars_printed
> 0)
1865 puts_filtered ("\n");
1870 /* Like fputs but if FILTER is true, pause after every screenful.
1872 Regardless of FILTER can wrap at points other than the final
1873 character of a line.
1875 Unlike fputs, fputs_maybe_filtered does not return a value.
1876 It is OK for LINEBUFFER to be NULL, in which case just don't print
1879 Note that a longjmp to top level may occur in this routine (only if
1880 FILTER is true) (since prompt_for_continue may do so) so this
1881 routine should not be called when cleanups are not in place. */
1884 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1887 const char *lineptr
;
1889 if (linebuffer
== 0)
1892 /* Don't do any filtering if it is disabled. */
1893 if ((stream
!= gdb_stdout
) || !pagination_enabled
1894 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1896 fputs_unfiltered (linebuffer
, stream
);
1900 /* Go through and output each character. Show line extension
1901 when this is necessary; prompt user for new page when this is
1904 lineptr
= linebuffer
;
1907 /* Possible new page. */
1909 (lines_printed
>= lines_per_page
- 1))
1910 prompt_for_continue ();
1912 while (*lineptr
&& *lineptr
!= '\n')
1914 /* Print a single line. */
1915 if (*lineptr
== '\t')
1918 *wrap_pointer
++ = '\t';
1920 fputc_unfiltered ('\t', stream
);
1921 /* Shifting right by 3 produces the number of tab stops
1922 we have already passed, and then adding one and
1923 shifting left 3 advances to the next tab stop. */
1924 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1930 *wrap_pointer
++ = *lineptr
;
1932 fputc_unfiltered (*lineptr
, stream
);
1937 if (chars_printed
>= chars_per_line
)
1939 unsigned int save_chars
= chars_printed
;
1943 /* If we aren't actually wrapping, don't output newline --
1944 if chars_per_line is right, we probably just overflowed
1945 anyway; if it's wrong, let us keep going. */
1947 fputc_unfiltered ('\n', stream
);
1949 /* Possible new page. */
1950 if (lines_printed
>= lines_per_page
- 1)
1951 prompt_for_continue ();
1953 /* Now output indentation and wrapped string */
1956 fputs_unfiltered (wrap_indent
, stream
);
1957 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1958 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1959 /* FIXME, this strlen is what prevents wrap_indent from
1960 containing tabs. However, if we recurse to print it
1961 and count its chars, we risk trouble if wrap_indent is
1962 longer than (the user settable) chars_per_line.
1963 Note also that this can set chars_printed > chars_per_line
1964 if we are printing a long string. */
1965 chars_printed
= strlen (wrap_indent
)
1966 + (save_chars
- wrap_column
);
1967 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1968 wrap_buffer
[0] = '\0';
1969 wrap_column
= 0; /* And disable fancy wrap */
1974 if (*lineptr
== '\n')
1977 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1979 fputc_unfiltered ('\n', stream
);
1986 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1988 fputs_maybe_filtered (linebuffer
, stream
, 1);
1992 putchar_unfiltered (int c
)
1995 ui_file_write (gdb_stdout
, &buf
, 1);
1999 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2000 May return nonlocally. */
2003 putchar_filtered (int c
)
2005 return fputc_filtered (c
, gdb_stdout
);
2009 fputc_unfiltered (int c
, struct ui_file
*stream
)
2012 ui_file_write (stream
, &buf
, 1);
2017 fputc_filtered (int c
, struct ui_file
*stream
)
2023 fputs_filtered (buf
, stream
);
2027 /* puts_debug is like fputs_unfiltered, except it prints special
2028 characters in printable fashion. */
2031 puts_debug (char *prefix
, char *string
, char *suffix
)
2035 /* Print prefix and suffix after each line. */
2036 static int new_line
= 1;
2037 static int return_p
= 0;
2038 static char *prev_prefix
= "";
2039 static char *prev_suffix
= "";
2041 if (*string
== '\n')
2044 /* If the prefix is changing, print the previous suffix, a new line,
2045 and the new prefix. */
2046 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2048 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2049 fputs_unfiltered ("\n", gdb_stdlog
);
2050 fputs_unfiltered (prefix
, gdb_stdlog
);
2053 /* Print prefix if we printed a newline during the previous call. */
2057 fputs_unfiltered (prefix
, gdb_stdlog
);
2060 prev_prefix
= prefix
;
2061 prev_suffix
= suffix
;
2063 /* Output characters in a printable format. */
2064 while ((ch
= *string
++) != '\0')
2070 fputc_unfiltered (ch
, gdb_stdlog
);
2073 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2077 fputs_unfiltered ("\\\\", gdb_stdlog
);
2080 fputs_unfiltered ("\\b", gdb_stdlog
);
2083 fputs_unfiltered ("\\f", gdb_stdlog
);
2087 fputs_unfiltered ("\\n", gdb_stdlog
);
2090 fputs_unfiltered ("\\r", gdb_stdlog
);
2093 fputs_unfiltered ("\\t", gdb_stdlog
);
2096 fputs_unfiltered ("\\v", gdb_stdlog
);
2100 return_p
= ch
== '\r';
2103 /* Print suffix if we printed a newline. */
2106 fputs_unfiltered (suffix
, gdb_stdlog
);
2107 fputs_unfiltered ("\n", gdb_stdlog
);
2112 /* Print a variable number of ARGS using format FORMAT. If this
2113 information is going to put the amount written (since the last call
2114 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2115 call prompt_for_continue to get the users permision to continue.
2117 Unlike fprintf, this function does not return a value.
2119 We implement three variants, vfprintf (takes a vararg list and stream),
2120 fprintf (takes a stream to write on), and printf (the usual).
2122 Note also that a longjmp to top level may occur in this routine
2123 (since prompt_for_continue may do so) so this routine should not be
2124 called when cleanups are not in place. */
2127 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2128 va_list args
, int filter
)
2131 struct cleanup
*old_cleanups
;
2133 xvasprintf (&linebuffer
, format
, args
);
2134 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2135 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2136 do_cleanups (old_cleanups
);
2141 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2143 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2147 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2150 struct cleanup
*old_cleanups
;
2152 xvasprintf (&linebuffer
, format
, args
);
2153 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2154 fputs_unfiltered (linebuffer
, stream
);
2155 do_cleanups (old_cleanups
);
2159 vprintf_filtered (const char *format
, va_list args
)
2161 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2165 vprintf_unfiltered (const char *format
, va_list args
)
2167 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2171 fprintf_filtered (struct ui_file
* stream
, const char *format
,...)
2174 va_start (args
, format
);
2175 vfprintf_filtered (stream
, format
, args
);
2180 fprintf_unfiltered (struct ui_file
* stream
, const char *format
,...)
2183 va_start (args
, format
);
2184 vfprintf_unfiltered (stream
, format
, args
);
2188 /* Like fprintf_filtered, but prints its result indented.
2189 Called as fprintfi_filtered (spaces, stream, format, ...); */
2192 fprintfi_filtered (int spaces
, struct ui_file
* stream
, const char *format
,...)
2195 va_start (args
, format
);
2196 print_spaces_filtered (spaces
, stream
);
2198 vfprintf_filtered (stream
, format
, args
);
2204 printf_filtered (const char *format
,...)
2207 va_start (args
, format
);
2208 vfprintf_filtered (gdb_stdout
, format
, args
);
2214 printf_unfiltered (const char *format
,...)
2217 va_start (args
, format
);
2218 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2222 /* Like printf_filtered, but prints it's result indented.
2223 Called as printfi_filtered (spaces, format, ...); */
2226 printfi_filtered (int spaces
, const char *format
,...)
2229 va_start (args
, format
);
2230 print_spaces_filtered (spaces
, gdb_stdout
);
2231 vfprintf_filtered (gdb_stdout
, format
, args
);
2235 /* Easy -- but watch out!
2237 This routine is *not* a replacement for puts()! puts() appends a newline.
2238 This one doesn't, and had better not! */
2241 puts_filtered (const char *string
)
2243 fputs_filtered (string
, gdb_stdout
);
2247 puts_unfiltered (const char *string
)
2249 fputs_unfiltered (string
, gdb_stdout
);
2252 /* Return a pointer to N spaces and a null. The pointer is good
2253 until the next call to here. */
2258 static char *spaces
= 0;
2259 static int max_spaces
= -1;
2265 spaces
= (char *) xmalloc (n
+ 1);
2266 for (t
= spaces
+ n
; t
!= spaces
;)
2272 return spaces
+ max_spaces
- n
;
2275 /* Print N spaces. */
2277 print_spaces_filtered (int n
, struct ui_file
*stream
)
2279 fputs_filtered (n_spaces (n
), stream
);
2282 /* C++/ObjC demangler stuff. */
2284 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2285 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2286 If the name is not mangled, or the language for the name is unknown, or
2287 demangling is off, the name is printed in its "raw" form. */
2290 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
, enum language lang
,
2297 /* If user wants to see raw output, no problem. */
2300 fputs_filtered (name
, stream
);
2306 case language_cplus
:
2307 demangled
= cplus_demangle (name
, arg_mode
);
2310 demangled
= cplus_demangle (name
, arg_mode
| DMGL_JAVA
);
2313 /* Commented out until ObjC handling is enabled. */
2314 /*demangled = objc_demangle (name);*/
2320 fputs_filtered (demangled
? demangled
: name
, stream
);
2321 if (demangled
!= NULL
)
2329 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2330 differences in whitespace. Returns 0 if they match, non-zero if they
2331 don't (slightly different than strcmp()'s range of return values).
2333 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2334 This "feature" is useful when searching for matching C++ function names
2335 (such as if the user types 'break FOO', where FOO is a mangled C++
2339 strcmp_iw (const char *string1
, const char *string2
)
2341 while ((*string1
!= '\0') && (*string2
!= '\0'))
2343 while (isspace (*string1
))
2347 while (isspace (*string2
))
2351 if (*string1
!= *string2
)
2355 if (*string1
!= '\0')
2361 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2367 ** Answer whether string_to_compare is a full or partial match to
2368 ** template_string. The partial match must be in sequence starting
2372 subset_compare (char *string_to_compare
, char *template_string
)
2375 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
&&
2376 strlen (string_to_compare
) <= strlen (template_string
))
2377 match
= (strncmp (template_string
,
2379 strlen (string_to_compare
)) == 0);
2386 static void pagination_on_command (char *arg
, int from_tty
);
2388 pagination_on_command (char *arg
, int from_tty
)
2390 pagination_enabled
= 1;
2393 static void pagination_on_command (char *arg
, int from_tty
);
2395 pagination_off_command (char *arg
, int from_tty
)
2397 pagination_enabled
= 0;
2402 initialize_utils (void)
2404 struct cmd_list_element
*c
;
2406 c
= add_set_cmd ("width", class_support
, var_uinteger
,
2407 (char *) &chars_per_line
,
2408 "Set number of characters gdb thinks are in a line.",
2410 add_show_from_set (c
, &showlist
);
2411 set_cmd_sfunc (c
, set_width_command
);
2414 (add_set_cmd ("height", class_support
,
2415 var_uinteger
, (char *) &lines_per_page
,
2416 "Set number of lines gdb thinks are in a page.", &setlist
),
2421 /* If the output is not a terminal, don't paginate it. */
2422 if (!ui_file_isatty (gdb_stdout
))
2423 lines_per_page
= UINT_MAX
;
2425 set_width_command ((char *) NULL
, 0, c
);
2428 (add_set_cmd ("demangle", class_support
, var_boolean
,
2430 "Set demangling of encoded C++/ObjC names when displaying symbols.",
2435 (add_set_cmd ("pagination", class_support
,
2436 var_boolean
, (char *) &pagination_enabled
,
2437 "Set state of pagination.", &setlist
),
2442 add_com ("am", class_support
, pagination_on_command
,
2443 "Enable pagination");
2444 add_com ("sm", class_support
, pagination_off_command
,
2445 "Disable pagination");
2449 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2450 (char *) &sevenbit_strings
,
2451 "Set printing of 8-bit characters in strings as \\nnn.",
2456 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2457 (char *) &asm_demangle
,
2458 "Set demangling of C++/ObjC names in disassembly listings.",
2463 /* Machine specific function to handle SIGWINCH signal. */
2465 #ifdef SIGWINCH_HANDLER_BODY
2466 SIGWINCH_HANDLER_BODY
2469 /* print routines to handle variable size regs, etc. */
2471 /* temporary storage using circular buffer */
2477 static char buf
[NUMCELLS
][CELLSIZE
];
2478 static int cell
= 0;
2479 if (++cell
>= NUMCELLS
)
2487 return (TARGET_ADDR_BIT
/ 8 * 2);
2491 paddr (CORE_ADDR addr
)
2493 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2497 paddr_nz (CORE_ADDR addr
)
2499 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2503 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
)
2505 /* steal code from valprint.c:print_decimal(). Should this worry
2506 about the real size of addr as the above does? */
2507 unsigned long temp
[3];
2511 temp
[i
] = addr
% (1000 * 1000 * 1000);
2512 addr
/= (1000 * 1000 * 1000);
2515 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2519 sprintf (paddr_str
, "%s%lu",
2523 sprintf (paddr_str
, "%s%lu%09lu",
2524 sign
, temp
[1], temp
[0]);
2527 sprintf (paddr_str
, "%s%lu%09lu%09lu",
2528 sign
, temp
[2], temp
[1], temp
[0]);
2531 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
2536 paddr_u (CORE_ADDR addr
)
2538 char *paddr_str
= get_cell ();
2539 decimal2str (paddr_str
, "", addr
);
2544 paddr_d (LONGEST addr
)
2546 char *paddr_str
= get_cell ();
2548 decimal2str (paddr_str
, "-", -addr
);
2550 decimal2str (paddr_str
, "", addr
);
2554 /* eliminate warning from compiler on 32-bit systems */
2555 static int thirty_two
= 32;
2558 phex (ULONGEST l
, int sizeof_l
)
2565 sprintf (str
, "%08lx%08lx",
2566 (unsigned long) (l
>> thirty_two
),
2567 (unsigned long) (l
& 0xffffffff));
2571 sprintf (str
, "%08lx", (unsigned long) l
);
2575 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2578 str
= phex (l
, sizeof (l
));
2585 phex_nz (ULONGEST l
, int sizeof_l
)
2592 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2595 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
2597 sprintf (str
, "%lx%08lx",
2598 high
, (unsigned long) (l
& 0xffffffff));
2603 sprintf (str
, "%lx", (unsigned long) l
);
2607 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
2610 str
= phex_nz (l
, sizeof (l
));
2617 /* Convert to / from the hosts pointer to GDB's internal CORE_ADDR
2618 using the target's conversion routines. */
2620 host_pointer_to_address (void *ptr
)
2622 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2623 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2627 address_to_host_pointer (CORE_ADDR addr
)
2631 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2632 ADDRESS_TO_POINTER (builtin_type_void_data_ptr
, &ptr
, addr
);
2636 /* Convert a CORE_ADDR into a string. */
2638 core_addr_to_string (const CORE_ADDR addr
)
2640 char *str
= get_cell ();
2642 strcat (str
, phex (addr
, sizeof (addr
)));
2647 core_addr_to_string_nz (const CORE_ADDR addr
)
2649 char *str
= get_cell ();
2651 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2655 /* Convert a string back into a CORE_ADDR. */
2657 string_to_core_addr (const char *my_string
)
2660 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2662 /* Assume that it is in decimal. */
2664 for (i
= 2; my_string
[i
] != '\0'; i
++)
2666 if (isdigit (my_string
[i
]))
2667 addr
= (my_string
[i
] - '0') + (addr
* 16);
2668 else if (isxdigit (my_string
[i
]))
2669 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2671 internal_error (__FILE__
, __LINE__
, "invalid hex");
2676 /* Assume that it is in decimal. */
2678 for (i
= 0; my_string
[i
] != '\0'; i
++)
2680 if (isdigit (my_string
[i
]))
2681 addr
= (my_string
[i
] - '0') + (addr
* 10);
2683 internal_error (__FILE__
, __LINE__
, "invalid decimal");
2690 gdb_realpath (const char *filename
)
2692 /* Method 1: The system has a compile time upper bound on a filename
2693 path. Use that and realpath() to canonicalize the name. This is
2694 the most common case. Note that, if there isn't a compile time
2695 upper bound, you want to avoid realpath() at all costs. */
2696 #if defined(HAVE_REALPATH)
2698 # if defined (PATH_MAX)
2700 # define USE_REALPATH
2701 # elif defined (MAXPATHLEN)
2702 char buf
[MAXPATHLEN
];
2703 # define USE_REALPATH
2705 # if defined (USE_REALPATH)
2706 const char *rp
= realpath (filename
, buf
);
2709 return xstrdup (rp
);
2712 #endif /* HAVE_REALPATH */
2714 /* Method 2: The host system (i.e., GNU) has the function
2715 canonicalize_file_name() which malloc's a chunk of memory and
2716 returns that, use that. */
2717 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2719 char *rp
= canonicalize_file_name (filename
);
2721 return xstrdup (filename
);
2727 /* FIXME: cagney/2002-11-13:
2729 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2730 to the problems described in in method 3, have modified their
2731 realpath() implementation so that it will allocate a buffer when
2732 NULL is passed in. Before this can be used, though, some sort of
2733 configure time test would need to be added. Otherwize the code
2734 will likely core dump. */
2736 /* Method 3: Now we're getting desperate! The system doesn't have a
2737 compile time buffer size and no alternative function. Query the
2738 OS, using pathconf(), for the buffer limit. Care is needed
2739 though, some systems do not limit PATH_MAX (return -1 for
2740 pathconf()) making it impossible to pass a correctly sized buffer
2741 to realpath() (it could always overflow). On those systems, we
2743 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2745 /* Find out the max path size. */
2746 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2749 /* PATH_MAX is bounded. */
2750 char *buf
= alloca (path_max
);
2751 char *rp
= realpath (filename
, buf
);
2752 return xstrdup (rp
? rp
: filename
);
2757 /* This system is a lost cause, just dup the buffer. */
2758 return xstrdup (filename
);
2761 /* Return a copy of FILENAME, with its directory prefix canonicalized
2765 xfullpath (const char *filename
)
2767 const char *base_name
= lbasename (filename
);
2772 /* Extract the basename of filename, and return immediately
2773 a copy of filename if it does not contain any directory prefix. */
2774 if (base_name
== filename
)
2775 return xstrdup (filename
);
2777 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
2778 /* Allocate enough space to store the dir_name + plus one extra
2779 character sometimes needed under Windows (see below), and
2780 then the closing \000 character */
2781 strncpy (dir_name
, filename
, base_name
- filename
);
2782 dir_name
[base_name
- filename
] = '\000';
2784 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2785 /* We need to be careful when filename is of the form 'd:foo', which
2786 is equivalent of d:./foo, which is totally different from d:/foo. */
2787 if (strlen (dir_name
) == 2 &&
2788 isalpha (dir_name
[0]) && dir_name
[1] == ':')
2791 dir_name
[3] = '\000';
2795 /* Canonicalize the directory prefix, and build the resulting
2796 filename. If the dirname realpath already contains an ending
2797 directory separator, avoid doubling it. */
2798 real_path
= gdb_realpath (dir_name
);
2799 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
2800 result
= concat (real_path
, base_name
, NULL
);
2802 result
= concat (real_path
, SLASH_STRING
, base_name
, NULL
);