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. */
25 /* Include before "bfd.h" so that we get stdbool.h in time, if <curses.h>
35 #include "gdb_assert.h"
37 #include "gdb_string.h"
38 #include "event-top.h"
44 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
55 #include "expression.h"
59 #include "inferior.h" /* for signed_pointer_to_address */
61 #include <sys/param.h> /* For MAXPATHLEN */
63 #include <readline/readline.h>
69 #ifdef NEED_DECLARATION_MALLOC
72 #ifdef NEED_DECLARATION_REALLOC
73 extern PTR
realloc ();
75 #ifdef NEED_DECLARATION_FREE
80 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
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++ names should be printed out in their
147 C++ form rather than raw. */
151 /* Nonzero means that encoded C++ names should be printed out in their
152 C++ 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. Ask the user if they
669 want to continue, dump core, or just exit. */
672 internal_verror (const char *file
, int line
,
673 const char *fmt
, va_list ap
)
675 static char msg
[] = "Internal GDB error: recursive internal error.\n";
676 static int dejavu
= 0;
680 /* don't allow infinite error recursion. */
688 fputs_unfiltered (msg
, gdb_stderr
);
689 abort (); /* NOTE: GDB has only three calls to abort(). */
692 write (STDERR_FILENO
, msg
, sizeof (msg
));
696 /* Try to get the message out */
697 target_terminal_ours ();
698 fprintf_unfiltered (gdb_stderr
, "%s:%d: gdb-internal-error: ", file
, line
);
699 vfprintf_unfiltered (gdb_stderr
, fmt
, ap
);
700 fputs_unfiltered ("\n", gdb_stderr
);
702 /* Default (yes/batch case) is to quit GDB. When in batch mode this
703 lessens the likelhood of GDB going into an infinate loop. */
705 An internal GDB error was detected. This may make further\n\
706 debugging unreliable. Quit this debugging session? ");
708 /* Default (yes/batch case) is to dump core. This leaves a GDB
709 dropping so that it is easier to see that something went wrong to
711 dump_core_p
= query ("\
712 Create a core file containing the current state of GDB? ");
717 abort (); /* NOTE: GDB has only three calls to abort(). */
726 abort (); /* NOTE: GDB has only three calls to abort(). */
731 throw_exception (RETURN_ERROR
);
735 internal_error (const char *file
, int line
, const char *string
, ...)
738 va_start (ap
, string
);
740 internal_verror (file
, line
, string
, ap
);
744 /* The strerror() function can return NULL for errno values that are
745 out of range. Provide a "safe" version that always returns a
749 safe_strerror (int errnum
)
754 if ((msg
= strerror (errnum
)) == NULL
)
756 sprintf (buf
, "(undocumented errno %d)", errnum
);
762 /* Print the system error message for errno, and also mention STRING
763 as the file name for which the error was encountered.
764 Then return to command level. */
767 perror_with_name (char *string
)
772 err
= safe_strerror (errno
);
773 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
774 strcpy (combined
, string
);
775 strcat (combined
, ": ");
776 strcat (combined
, err
);
778 /* I understand setting these is a matter of taste. Still, some people
779 may clear errno but not know about bfd_error. Doing this here is not
781 bfd_set_error (bfd_error_no_error
);
784 error ("%s.", combined
);
787 /* Print the system error message for ERRCODE, and also mention STRING
788 as the file name for which the error was encountered. */
791 print_sys_errmsg (char *string
, int errcode
)
796 err
= safe_strerror (errcode
);
797 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
798 strcpy (combined
, string
);
799 strcat (combined
, ": ");
800 strcat (combined
, err
);
802 /* We want anything which was printed on stdout to come out first, before
804 gdb_flush (gdb_stdout
);
805 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
808 /* Control C eventually causes this to be called, at a convenient time. */
813 struct serial
*gdb_stdout_serial
= serial_fdopen (1);
815 target_terminal_ours ();
817 /* We want all output to appear now, before we print "Quit". We
818 have 3 levels of buffering we have to flush (it's possible that
819 some of these should be changed to flush the lower-level ones
822 /* 1. The _filtered buffer. */
823 wrap_here ((char *) 0);
825 /* 2. The stdio buffer. */
826 gdb_flush (gdb_stdout
);
827 gdb_flush (gdb_stderr
);
829 /* 3. The system-level buffer. */
830 serial_drain_output (gdb_stdout_serial
);
831 serial_un_fdopen (gdb_stdout_serial
);
833 annotate_error_begin ();
835 /* Don't use *_filtered; we don't want to prompt the user to continue. */
837 fprintf_unfiltered (gdb_stderr
, quit_pre_print
);
840 /* No steenking SIGINT will ever be coming our way when the
841 program is resumed. Don't lie. */
842 fprintf_unfiltered (gdb_stderr
, "Quit\n");
845 /* If there is no terminal switching for this target, then we can't
846 possibly get screwed by the lack of job control. */
847 || current_target
.to_terminal_ours
== NULL
)
848 fprintf_unfiltered (gdb_stderr
, "Quit\n");
850 fprintf_unfiltered (gdb_stderr
,
851 "Quit (expect signal SIGINT when the program is resumed)\n");
853 throw_exception (RETURN_QUIT
);
856 /* Control C comes here */
858 request_quit (int signo
)
861 /* Restore the signal handler. Harmless with BSD-style signals, needed
862 for System V-style signals. So just always do it, rather than worrying
863 about USG defines and stuff like that. */
864 signal (signo
, request_quit
);
874 /* Memory management stuff (malloc friends). */
876 #if !defined (USE_MMALLOC)
878 /* NOTE: These must use PTR so that their definition matches the
879 declaration found in "mmalloc.h". */
882 mmalloc (void *md
, size_t size
)
884 return malloc (size
); /* NOTE: GDB's only call to malloc() */
888 mrealloc (void *md
, void *ptr
, size_t size
)
890 if (ptr
== 0) /* Guard against old realloc's */
891 return mmalloc (md
, size
);
893 return realloc (ptr
, size
); /* NOTE: GDB's only call to ralloc() */
897 mcalloc (void *md
, size_t number
, size_t size
)
899 return calloc (number
, size
); /* NOTE: GDB's only call to calloc() */
903 mfree (void *md
, void *ptr
)
905 free (ptr
); /* NOTE: GDB's only call to free() */
908 #endif /* USE_MMALLOC */
910 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
913 init_malloc (void *md
)
917 #else /* Have mmalloc and want corruption checking */
922 fprintf_unfiltered (gdb_stderr
, "Memory corruption\n");
923 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
926 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
927 by MD, to detect memory corruption. Note that MD may be NULL to specify
928 the default heap that grows via sbrk.
930 Note that for freshly created regions, we must call mmcheckf prior to any
931 mallocs in the region. Otherwise, any region which was allocated prior to
932 installing the checking hooks, which is later reallocated or freed, will
933 fail the checks! The mmcheck function only allows initial hooks to be
934 installed before the first mmalloc. However, anytime after we have called
935 mmcheck the first time to install the checking hooks, we can call it again
936 to update the function pointer to the memory corruption handler.
938 Returns zero on failure, non-zero on success. */
940 #ifndef MMCHECK_FORCE
941 #define MMCHECK_FORCE 0
945 init_malloc (void *md
)
947 if (!mmcheckf (md
, malloc_botch
, MMCHECK_FORCE
))
949 /* Don't use warning(), which relies on current_target being set
950 to something other than dummy_target, until after
951 initialize_all_files(). */
954 (gdb_stderr
, "warning: failed to install memory consistency checks; ");
956 (gdb_stderr
, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
962 #endif /* Have mmalloc and want corruption checking */
964 /* Called when a memory allocation fails, with the number of bytes of
965 memory requested in SIZE. */
972 internal_error (__FILE__
, __LINE__
,
973 "virtual memory exhausted: can't allocate %ld bytes.", size
);
977 internal_error (__FILE__
, __LINE__
,
978 "virtual memory exhausted.");
982 /* The xmmalloc() family of memory management routines.
984 These are are like the mmalloc() family except that they implement
985 consistent semantics and guard against typical memory management
986 problems: if a malloc fails, an internal error is thrown; if
987 free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
990 All these routines are implemented using the mmalloc() family. */
993 xmmalloc (void *md
, size_t size
)
1003 val
= mmalloc (md
, size
);
1011 xmrealloc (void *md
, void *ptr
, size_t size
)
1025 val
= mrealloc (md
, ptr
, size
);
1029 val
= mmalloc (md
, size
);
1040 xmcalloc (void *md
, size_t number
, size_t size
)
1043 if (number
== 0 || size
== 0)
1047 mem
= mcalloc (md
, number
, size
);
1049 nomem (number
* size
);
1055 xmfree (void *md
, void *ptr
)
1061 /* The xmalloc() (libiberty.h) family of memory management routines.
1063 These are like the ISO-C malloc() family except that they implement
1064 consistent semantics and guard against typical memory management
1065 problems. See xmmalloc() above for further information.
1067 All these routines are wrappers to the xmmalloc() family. */
1069 /* NOTE: These are declared using PTR to ensure consistency with
1070 "libiberty.h". xfree() is GDB local. */
1073 xmalloc (size_t size
)
1075 return xmmalloc (NULL
, size
);
1079 xrealloc (PTR ptr
, size_t size
)
1081 return xmrealloc (NULL
, ptr
, size
);
1085 xcalloc (size_t number
, size_t size
)
1087 return xmcalloc (NULL
, number
, size
);
1097 /* Like asprintf/vasprintf but get an internal_error if the call
1101 xasprintf (char **ret
, const char *format
, ...)
1104 va_start (args
, format
);
1105 xvasprintf (ret
, format
, args
);
1110 xvasprintf (char **ret
, const char *format
, va_list ap
)
1112 int status
= vasprintf (ret
, format
, ap
);
1113 /* NULL could be returned due to a memory allocation problem; a
1114 badly format string; or something else. */
1116 internal_error (__FILE__
, __LINE__
,
1117 "vasprintf returned NULL buffer (errno %d)",
1119 /* A negative status with a non-NULL buffer shouldn't never
1120 happen. But to be sure. */
1122 internal_error (__FILE__
, __LINE__
,
1123 "vasprintf call failed (errno %d)",
1128 /* My replacement for the read system call.
1129 Used like `read' but keeps going if `read' returns too soon. */
1132 myread (int desc
, char *addr
, int len
)
1139 val
= read (desc
, addr
, len
);
1143 return orglen
- len
;
1150 /* Make a copy of the string at PTR with SIZE characters
1151 (and add a null character at the end in the copy).
1152 Uses malloc to get the space. Returns the address of the copy. */
1155 savestring (const char *ptr
, size_t size
)
1157 register char *p
= (char *) xmalloc (size
+ 1);
1158 memcpy (p
, ptr
, size
);
1164 msavestring (void *md
, const char *ptr
, size_t size
)
1166 register char *p
= (char *) xmmalloc (md
, size
+ 1);
1167 memcpy (p
, ptr
, size
);
1173 mstrsave (void *md
, const char *ptr
)
1175 return (msavestring (md
, ptr
, strlen (ptr
)));
1179 print_spaces (register int n
, register struct ui_file
*file
)
1181 fputs_unfiltered (n_spaces (n
), file
);
1184 /* Print a host address. */
1187 gdb_print_host_address (void *addr
, struct ui_file
*stream
)
1190 /* We could use the %p conversion specifier to fprintf if we had any
1191 way of knowing whether this host supports it. But the following
1192 should work on the Alpha and on 32 bit machines. */
1194 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1197 /* Ask user a y-or-n question and return 1 iff answer is yes.
1198 Takes three args which are given to printf to print the question.
1199 The first, a control string, should end in "? ".
1200 It should not say how to answer, because we do that. */
1204 query (char *ctlstr
,...)
1207 register int answer
;
1211 va_start (args
, ctlstr
);
1215 return query_hook (ctlstr
, args
);
1218 /* Automatically answer "yes" if input is not from a terminal. */
1219 if (!input_from_terminal_p ())
1224 wrap_here (""); /* Flush any buffered output */
1225 gdb_flush (gdb_stdout
);
1227 if (annotation_level
> 1)
1228 printf_filtered ("\n\032\032pre-query\n");
1230 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1231 printf_filtered ("(y or n) ");
1233 if (annotation_level
> 1)
1234 printf_filtered ("\n\032\032query\n");
1237 gdb_flush (gdb_stdout
);
1239 answer
= fgetc (stdin
);
1240 clearerr (stdin
); /* in case of C-d */
1241 if (answer
== EOF
) /* C-d */
1246 /* Eat rest of input line, to EOF or newline */
1250 ans2
= fgetc (stdin
);
1253 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1267 printf_filtered ("Please answer y or n.\n");
1270 if (annotation_level
> 1)
1271 printf_filtered ("\n\032\032post-query\n");
1276 /* Parse a C escape sequence. STRING_PTR points to a variable
1277 containing a pointer to the string to parse. That pointer
1278 should point to the character after the \. That pointer
1279 is updated past the characters we use. The value of the
1280 escape sequence is returned.
1282 A negative value means the sequence \ newline was seen,
1283 which is supposed to be equivalent to nothing at all.
1285 If \ is followed by a null character, we return a negative
1286 value and leave the string pointer pointing at the null character.
1288 If \ is followed by 000, we return 0 and leave the string pointer
1289 after the zeros. A value of 0 does not mean end of string. */
1292 parse_escape (char **string_ptr
)
1294 register int c
= *(*string_ptr
)++;
1298 return 007; /* Bell (alert) char */
1301 case 'e': /* Escape character */
1319 c
= *(*string_ptr
)++;
1321 c
= parse_escape (string_ptr
);
1324 return (c
& 0200) | (c
& 037);
1335 register int i
= c
- '0';
1336 register int count
= 0;
1339 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
1357 /* Print the character C on STREAM as part of the contents of a literal
1358 string whose delimiter is QUOTER. Note that this routine should only
1359 be call for printing things which are independent of the language
1360 of the program being debugged. */
1363 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1364 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1365 struct ui_file
*stream
, int quoter
)
1368 c
&= 0xFF; /* Avoid sign bit follies */
1370 if (c
< 0x20 || /* Low control chars */
1371 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1372 (sevenbit_strings
&& c
>= 0x80))
1373 { /* high order bit set */
1377 do_fputs ("\\n", stream
);
1380 do_fputs ("\\b", stream
);
1383 do_fputs ("\\t", stream
);
1386 do_fputs ("\\f", stream
);
1389 do_fputs ("\\r", stream
);
1392 do_fputs ("\\e", stream
);
1395 do_fputs ("\\a", stream
);
1398 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1404 if (c
== '\\' || c
== quoter
)
1405 do_fputs ("\\", stream
);
1406 do_fprintf (stream
, "%c", c
);
1410 /* Print the character C on STREAM as part of the contents of a
1411 literal string whose delimiter is QUOTER. Note that these routines
1412 should only be call for printing things which are independent of
1413 the language of the program being debugged. */
1416 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1419 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1423 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1426 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1430 fputstrn_unfiltered (const char *str
, int n
, int quoter
, struct ui_file
*stream
)
1433 for (i
= 0; i
< n
; i
++)
1434 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1439 /* Number of lines per page or UINT_MAX if paging is disabled. */
1440 static unsigned int lines_per_page
;
1441 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1442 static unsigned int chars_per_line
;
1443 /* Current count of lines printed on this page, chars on this line. */
1444 static unsigned int lines_printed
, chars_printed
;
1446 /* Buffer and start column of buffered text, for doing smarter word-
1447 wrapping. When someone calls wrap_here(), we start buffering output
1448 that comes through fputs_filtered(). If we see a newline, we just
1449 spit it out and forget about the wrap_here(). If we see another
1450 wrap_here(), we spit it out and remember the newer one. If we see
1451 the end of the line, we spit out a newline, the indent, and then
1452 the buffered output. */
1454 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1455 are waiting to be output (they have already been counted in chars_printed).
1456 When wrap_buffer[0] is null, the buffer is empty. */
1457 static char *wrap_buffer
;
1459 /* Pointer in wrap_buffer to the next character to fill. */
1460 static char *wrap_pointer
;
1462 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1464 static char *wrap_indent
;
1466 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1467 is not in effect. */
1468 static int wrap_column
;
1471 /* Inialize the lines and chars per page */
1473 init_page_info (void)
1476 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1479 /* These defaults will be used if we are unable to get the correct
1480 values from termcap. */
1481 #if defined(__GO32__)
1482 lines_per_page
= ScreenRows ();
1483 chars_per_line
= ScreenCols ();
1485 lines_per_page
= 24;
1486 chars_per_line
= 80;
1488 #if !defined (_WIN32)
1489 /* No termcap under MPW, although might be cool to do something
1490 by looking at worksheet or console window sizes. */
1491 /* Initialize the screen height and width from termcap. */
1493 char *termtype
= getenv ("TERM");
1495 /* Positive means success, nonpositive means failure. */
1498 /* 2048 is large enough for all known terminals, according to the
1499 GNU termcap manual. */
1500 char term_buffer
[2048];
1504 status
= tgetent (term_buffer
, termtype
);
1508 int running_in_emacs
= getenv ("EMACS") != NULL
;
1510 val
= tgetnum ("li");
1511 if (val
>= 0 && !running_in_emacs
)
1512 lines_per_page
= val
;
1514 /* The number of lines per page is not mentioned
1515 in the terminal description. This probably means
1516 that paging is not useful (e.g. emacs shell window),
1517 so disable paging. */
1518 lines_per_page
= UINT_MAX
;
1520 val
= tgetnum ("co");
1522 chars_per_line
= val
;
1528 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1530 /* If there is a better way to determine the window size, use it. */
1531 SIGWINCH_HANDLER (SIGWINCH
);
1534 /* If the output is not a terminal, don't paginate it. */
1535 if (!ui_file_isatty (gdb_stdout
))
1536 lines_per_page
= UINT_MAX
;
1537 } /* the command_line_version */
1544 if (chars_per_line
== 0)
1549 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1550 wrap_buffer
[0] = '\0';
1553 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1554 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
1559 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1564 /* Wait, so the user can read what's on the screen. Prompt the user
1565 to continue by pressing RETURN. */
1568 prompt_for_continue (void)
1571 char cont_prompt
[120];
1573 if (annotation_level
> 1)
1574 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1576 strcpy (cont_prompt
,
1577 "---Type <return> to continue, or q <return> to quit---");
1578 if (annotation_level
> 1)
1579 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1581 /* We must do this *before* we call gdb_readline, else it will eventually
1582 call us -- thinking that we're trying to print beyond the end of the
1584 reinitialize_more_filter ();
1587 /* On a real operating system, the user can quit with SIGINT.
1590 'q' is provided on all systems so users don't have to change habits
1591 from system to system, and because telling them what to do in
1592 the prompt is more user-friendly than expecting them to think of
1594 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1595 whereas control-C to gdb_readline will cause the user to get dumped
1597 ignore
= readline (cont_prompt
);
1599 if (annotation_level
> 1)
1600 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1605 while (*p
== ' ' || *p
== '\t')
1610 request_quit (SIGINT
);
1612 async_request_quit (0);
1618 /* Now we have to do this again, so that GDB will know that it doesn't
1619 need to save the ---Type <return>--- line at the top of the screen. */
1620 reinitialize_more_filter ();
1622 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1625 /* Reinitialize filter; ie. tell it to reset to original values. */
1628 reinitialize_more_filter (void)
1634 /* Indicate that if the next sequence of characters overflows the line,
1635 a newline should be inserted here rather than when it hits the end.
1636 If INDENT is non-null, it is a string to be printed to indent the
1637 wrapped part on the next line. INDENT must remain accessible until
1638 the next call to wrap_here() or until a newline is printed through
1641 If the line is already overfull, we immediately print a newline and
1642 the indentation, and disable further wrapping.
1644 If we don't know the width of lines, but we know the page height,
1645 we must not wrap words, but should still keep track of newlines
1646 that were explicitly printed.
1648 INDENT should not contain tabs, as that will mess up the char count
1649 on the next line. FIXME.
1651 This routine is guaranteed to force out any output which has been
1652 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1653 used to force out output from the wrap_buffer. */
1656 wrap_here (char *indent
)
1658 /* This should have been allocated, but be paranoid anyway. */
1660 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1664 *wrap_pointer
= '\0';
1665 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1667 wrap_pointer
= wrap_buffer
;
1668 wrap_buffer
[0] = '\0';
1669 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1673 else if (chars_printed
>= chars_per_line
)
1675 puts_filtered ("\n");
1677 puts_filtered (indent
);
1682 wrap_column
= chars_printed
;
1686 wrap_indent
= indent
;
1690 /* Ensure that whatever gets printed next, using the filtered output
1691 commands, starts at the beginning of the line. I.E. if there is
1692 any pending output for the current line, flush it and start a new
1693 line. Otherwise do nothing. */
1698 if (chars_printed
> 0)
1700 puts_filtered ("\n");
1705 /* Like fputs but if FILTER is true, pause after every screenful.
1707 Regardless of FILTER can wrap at points other than the final
1708 character of a line.
1710 Unlike fputs, fputs_maybe_filtered does not return a value.
1711 It is OK for LINEBUFFER to be NULL, in which case just don't print
1714 Note that a longjmp to top level may occur in this routine (only if
1715 FILTER is true) (since prompt_for_continue may do so) so this
1716 routine should not be called when cleanups are not in place. */
1719 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1722 const char *lineptr
;
1724 if (linebuffer
== 0)
1727 /* Don't do any filtering if it is disabled. */
1728 if ((stream
!= gdb_stdout
) || !pagination_enabled
1729 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1731 fputs_unfiltered (linebuffer
, stream
);
1735 /* Go through and output each character. Show line extension
1736 when this is necessary; prompt user for new page when this is
1739 lineptr
= linebuffer
;
1742 /* Possible new page. */
1744 (lines_printed
>= lines_per_page
- 1))
1745 prompt_for_continue ();
1747 while (*lineptr
&& *lineptr
!= '\n')
1749 /* Print a single line. */
1750 if (*lineptr
== '\t')
1753 *wrap_pointer
++ = '\t';
1755 fputc_unfiltered ('\t', stream
);
1756 /* Shifting right by 3 produces the number of tab stops
1757 we have already passed, and then adding one and
1758 shifting left 3 advances to the next tab stop. */
1759 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1765 *wrap_pointer
++ = *lineptr
;
1767 fputc_unfiltered (*lineptr
, stream
);
1772 if (chars_printed
>= chars_per_line
)
1774 unsigned int save_chars
= chars_printed
;
1778 /* If we aren't actually wrapping, don't output newline --
1779 if chars_per_line is right, we probably just overflowed
1780 anyway; if it's wrong, let us keep going. */
1782 fputc_unfiltered ('\n', stream
);
1784 /* Possible new page. */
1785 if (lines_printed
>= lines_per_page
- 1)
1786 prompt_for_continue ();
1788 /* Now output indentation and wrapped string */
1791 fputs_unfiltered (wrap_indent
, stream
);
1792 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1793 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1794 /* FIXME, this strlen is what prevents wrap_indent from
1795 containing tabs. However, if we recurse to print it
1796 and count its chars, we risk trouble if wrap_indent is
1797 longer than (the user settable) chars_per_line.
1798 Note also that this can set chars_printed > chars_per_line
1799 if we are printing a long string. */
1800 chars_printed
= strlen (wrap_indent
)
1801 + (save_chars
- wrap_column
);
1802 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1803 wrap_buffer
[0] = '\0';
1804 wrap_column
= 0; /* And disable fancy wrap */
1809 if (*lineptr
== '\n')
1812 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1814 fputc_unfiltered ('\n', stream
);
1821 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1823 fputs_maybe_filtered (linebuffer
, stream
, 1);
1827 putchar_unfiltered (int c
)
1830 ui_file_write (gdb_stdout
, &buf
, 1);
1834 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1835 May return nonlocally. */
1838 putchar_filtered (int c
)
1840 return fputc_filtered (c
, gdb_stdout
);
1844 fputc_unfiltered (int c
, struct ui_file
*stream
)
1847 ui_file_write (stream
, &buf
, 1);
1852 fputc_filtered (int c
, struct ui_file
*stream
)
1858 fputs_filtered (buf
, stream
);
1862 /* puts_debug is like fputs_unfiltered, except it prints special
1863 characters in printable fashion. */
1866 puts_debug (char *prefix
, char *string
, char *suffix
)
1870 /* Print prefix and suffix after each line. */
1871 static int new_line
= 1;
1872 static int return_p
= 0;
1873 static char *prev_prefix
= "";
1874 static char *prev_suffix
= "";
1876 if (*string
== '\n')
1879 /* If the prefix is changing, print the previous suffix, a new line,
1880 and the new prefix. */
1881 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
1883 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
1884 fputs_unfiltered ("\n", gdb_stdlog
);
1885 fputs_unfiltered (prefix
, gdb_stdlog
);
1888 /* Print prefix if we printed a newline during the previous call. */
1892 fputs_unfiltered (prefix
, gdb_stdlog
);
1895 prev_prefix
= prefix
;
1896 prev_suffix
= suffix
;
1898 /* Output characters in a printable format. */
1899 while ((ch
= *string
++) != '\0')
1905 fputc_unfiltered (ch
, gdb_stdlog
);
1908 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
1912 fputs_unfiltered ("\\\\", gdb_stdlog
);
1915 fputs_unfiltered ("\\b", gdb_stdlog
);
1918 fputs_unfiltered ("\\f", gdb_stdlog
);
1922 fputs_unfiltered ("\\n", gdb_stdlog
);
1925 fputs_unfiltered ("\\r", gdb_stdlog
);
1928 fputs_unfiltered ("\\t", gdb_stdlog
);
1931 fputs_unfiltered ("\\v", gdb_stdlog
);
1935 return_p
= ch
== '\r';
1938 /* Print suffix if we printed a newline. */
1941 fputs_unfiltered (suffix
, gdb_stdlog
);
1942 fputs_unfiltered ("\n", gdb_stdlog
);
1947 /* Print a variable number of ARGS using format FORMAT. If this
1948 information is going to put the amount written (since the last call
1949 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1950 call prompt_for_continue to get the users permision to continue.
1952 Unlike fprintf, this function does not return a value.
1954 We implement three variants, vfprintf (takes a vararg list and stream),
1955 fprintf (takes a stream to write on), and printf (the usual).
1957 Note also that a longjmp to top level may occur in this routine
1958 (since prompt_for_continue may do so) so this routine should not be
1959 called when cleanups are not in place. */
1962 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
1963 va_list args
, int filter
)
1966 struct cleanup
*old_cleanups
;
1968 xvasprintf (&linebuffer
, format
, args
);
1969 old_cleanups
= make_cleanup (xfree
, linebuffer
);
1970 fputs_maybe_filtered (linebuffer
, stream
, filter
);
1971 do_cleanups (old_cleanups
);
1976 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
1978 vfprintf_maybe_filtered (stream
, format
, args
, 1);
1982 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
1985 struct cleanup
*old_cleanups
;
1987 xvasprintf (&linebuffer
, format
, args
);
1988 old_cleanups
= make_cleanup (xfree
, linebuffer
);
1989 fputs_unfiltered (linebuffer
, stream
);
1990 do_cleanups (old_cleanups
);
1994 vprintf_filtered (const char *format
, va_list args
)
1996 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2000 vprintf_unfiltered (const char *format
, va_list args
)
2002 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2006 fprintf_filtered (struct ui_file
* stream
, const char *format
,...)
2009 va_start (args
, format
);
2010 vfprintf_filtered (stream
, format
, args
);
2015 fprintf_unfiltered (struct ui_file
* stream
, const char *format
,...)
2018 va_start (args
, format
);
2019 vfprintf_unfiltered (stream
, format
, args
);
2023 /* Like fprintf_filtered, but prints its result indented.
2024 Called as fprintfi_filtered (spaces, stream, format, ...); */
2027 fprintfi_filtered (int spaces
, struct ui_file
* stream
, const char *format
,...)
2030 va_start (args
, format
);
2031 print_spaces_filtered (spaces
, stream
);
2033 vfprintf_filtered (stream
, format
, args
);
2039 printf_filtered (const char *format
,...)
2042 va_start (args
, format
);
2043 vfprintf_filtered (gdb_stdout
, format
, args
);
2049 printf_unfiltered (const char *format
,...)
2052 va_start (args
, format
);
2053 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2057 /* Like printf_filtered, but prints it's result indented.
2058 Called as printfi_filtered (spaces, format, ...); */
2061 printfi_filtered (int spaces
, const char *format
,...)
2064 va_start (args
, format
);
2065 print_spaces_filtered (spaces
, gdb_stdout
);
2066 vfprintf_filtered (gdb_stdout
, format
, args
);
2070 /* Easy -- but watch out!
2072 This routine is *not* a replacement for puts()! puts() appends a newline.
2073 This one doesn't, and had better not! */
2076 puts_filtered (const char *string
)
2078 fputs_filtered (string
, gdb_stdout
);
2082 puts_unfiltered (const char *string
)
2084 fputs_unfiltered (string
, gdb_stdout
);
2087 /* Return a pointer to N spaces and a null. The pointer is good
2088 until the next call to here. */
2093 static char *spaces
= 0;
2094 static int max_spaces
= -1;
2100 spaces
= (char *) xmalloc (n
+ 1);
2101 for (t
= spaces
+ n
; t
!= spaces
;)
2107 return spaces
+ max_spaces
- n
;
2110 /* Print N spaces. */
2112 print_spaces_filtered (int n
, struct ui_file
*stream
)
2114 fputs_filtered (n_spaces (n
), stream
);
2117 /* C++ demangler stuff. */
2119 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2120 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2121 If the name is not mangled, or the language for the name is unknown, or
2122 demangling is off, the name is printed in its "raw" form. */
2125 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
, enum language lang
,
2132 /* If user wants to see raw output, no problem. */
2135 fputs_filtered (name
, stream
);
2141 case language_cplus
:
2142 demangled
= cplus_demangle (name
, arg_mode
);
2145 demangled
= cplus_demangle (name
, arg_mode
| DMGL_JAVA
);
2147 case language_chill
:
2148 demangled
= chill_demangle (name
);
2154 fputs_filtered (demangled
? demangled
: name
, stream
);
2155 if (demangled
!= NULL
)
2163 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2164 differences in whitespace. Returns 0 if they match, non-zero if they
2165 don't (slightly different than strcmp()'s range of return values).
2167 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2168 This "feature" is useful when searching for matching C++ function names
2169 (such as if the user types 'break FOO', where FOO is a mangled C++
2173 strcmp_iw (const char *string1
, const char *string2
)
2175 while ((*string1
!= '\0') && (*string2
!= '\0'))
2177 while (isspace (*string1
))
2181 while (isspace (*string2
))
2185 if (*string1
!= *string2
)
2189 if (*string1
!= '\0')
2195 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2201 ** Answer whether string_to_compare is a full or partial match to
2202 ** template_string. The partial match must be in sequence starting
2206 subset_compare (char *string_to_compare
, char *template_string
)
2209 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
&&
2210 strlen (string_to_compare
) <= strlen (template_string
))
2211 match
= (strncmp (template_string
,
2213 strlen (string_to_compare
)) == 0);
2220 static void pagination_on_command (char *arg
, int from_tty
);
2222 pagination_on_command (char *arg
, int from_tty
)
2224 pagination_enabled
= 1;
2227 static void pagination_on_command (char *arg
, int from_tty
);
2229 pagination_off_command (char *arg
, int from_tty
)
2231 pagination_enabled
= 0;
2236 initialize_utils (void)
2238 struct cmd_list_element
*c
;
2240 c
= add_set_cmd ("width", class_support
, var_uinteger
,
2241 (char *) &chars_per_line
,
2242 "Set number of characters gdb thinks are in a line.",
2244 add_show_from_set (c
, &showlist
);
2245 set_cmd_sfunc (c
, set_width_command
);
2248 (add_set_cmd ("height", class_support
,
2249 var_uinteger
, (char *) &lines_per_page
,
2250 "Set number of lines gdb thinks are in a page.", &setlist
),
2255 /* If the output is not a terminal, don't paginate it. */
2256 if (!ui_file_isatty (gdb_stdout
))
2257 lines_per_page
= UINT_MAX
;
2259 set_width_command ((char *) NULL
, 0, c
);
2262 (add_set_cmd ("demangle", class_support
, var_boolean
,
2264 "Set demangling of encoded C++ names when displaying symbols.",
2269 (add_set_cmd ("pagination", class_support
,
2270 var_boolean
, (char *) &pagination_enabled
,
2271 "Set state of pagination.", &setlist
),
2276 add_com ("am", class_support
, pagination_on_command
,
2277 "Enable pagination");
2278 add_com ("sm", class_support
, pagination_off_command
,
2279 "Disable pagination");
2283 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2284 (char *) &sevenbit_strings
,
2285 "Set printing of 8-bit characters in strings as \\nnn.",
2290 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2291 (char *) &asm_demangle
,
2292 "Set demangling of C++ names in disassembly listings.",
2297 /* Machine specific function to handle SIGWINCH signal. */
2299 #ifdef SIGWINCH_HANDLER_BODY
2300 SIGWINCH_HANDLER_BODY
2303 /* print routines to handle variable size regs, etc. */
2305 /* temporary storage using circular buffer */
2311 static char buf
[NUMCELLS
][CELLSIZE
];
2312 static int cell
= 0;
2313 if (++cell
>= NUMCELLS
)
2321 return (TARGET_ADDR_BIT
/ 8 * 2);
2325 paddr (CORE_ADDR addr
)
2327 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2331 paddr_nz (CORE_ADDR addr
)
2333 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2337 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
)
2339 /* steal code from valprint.c:print_decimal(). Should this worry
2340 about the real size of addr as the above does? */
2341 unsigned long temp
[3];
2345 temp
[i
] = addr
% (1000 * 1000 * 1000);
2346 addr
/= (1000 * 1000 * 1000);
2349 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2353 sprintf (paddr_str
, "%s%lu",
2357 sprintf (paddr_str
, "%s%lu%09lu",
2358 sign
, temp
[1], temp
[0]);
2361 sprintf (paddr_str
, "%s%lu%09lu%09lu",
2362 sign
, temp
[2], temp
[1], temp
[0]);
2365 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
2370 paddr_u (CORE_ADDR addr
)
2372 char *paddr_str
= get_cell ();
2373 decimal2str (paddr_str
, "", addr
);
2378 paddr_d (LONGEST addr
)
2380 char *paddr_str
= get_cell ();
2382 decimal2str (paddr_str
, "-", -addr
);
2384 decimal2str (paddr_str
, "", addr
);
2388 /* eliminate warning from compiler on 32-bit systems */
2389 static int thirty_two
= 32;
2392 phex (ULONGEST l
, int sizeof_l
)
2399 sprintf (str
, "%08lx%08lx",
2400 (unsigned long) (l
>> thirty_two
),
2401 (unsigned long) (l
& 0xffffffff));
2405 sprintf (str
, "%08lx", (unsigned long) l
);
2409 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2412 str
= phex (l
, sizeof (l
));
2419 phex_nz (ULONGEST l
, int sizeof_l
)
2426 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2429 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
2431 sprintf (str
, "%lx%08lx",
2432 high
, (unsigned long) (l
& 0xffffffff));
2437 sprintf (str
, "%lx", (unsigned long) l
);
2441 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
2444 str
= phex_nz (l
, sizeof (l
));
2451 /* Convert to / from the hosts pointer to GDB's internal CORE_ADDR
2452 using the target's conversion routines. */
2454 host_pointer_to_address (void *ptr
)
2456 if (sizeof (ptr
) != TYPE_LENGTH (builtin_type_void_data_ptr
))
2457 internal_error (__FILE__
, __LINE__
,
2458 "core_addr_to_void_ptr: bad cast");
2459 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2463 address_to_host_pointer (CORE_ADDR addr
)
2466 if (sizeof (ptr
) != TYPE_LENGTH (builtin_type_void_data_ptr
))
2467 internal_error (__FILE__
, __LINE__
,
2468 "core_addr_to_void_ptr: bad cast");
2469 ADDRESS_TO_POINTER (builtin_type_void_data_ptr
, &ptr
, addr
);
2473 /* Convert a CORE_ADDR into a string. */
2475 core_addr_to_string (const CORE_ADDR addr
)
2477 char *str
= get_cell ();
2479 strcat (str
, phex (addr
, sizeof (addr
)));
2484 core_addr_to_string_nz (const CORE_ADDR addr
)
2486 char *str
= get_cell ();
2488 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2492 /* Convert a string back into a CORE_ADDR. */
2494 string_to_core_addr (const char *my_string
)
2497 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2499 /* Assume that it is in decimal. */
2501 for (i
= 2; my_string
[i
] != '\0'; i
++)
2503 if (isdigit (my_string
[i
]))
2504 addr
= (my_string
[i
] - '0') + (addr
* 16);
2505 else if (isxdigit (my_string
[i
]))
2506 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2508 internal_error (__FILE__
, __LINE__
, "invalid hex");
2513 /* Assume that it is in decimal. */
2515 for (i
= 0; my_string
[i
] != '\0'; i
++)
2517 if (isdigit (my_string
[i
]))
2518 addr
= (my_string
[i
] - '0') + (addr
* 10);
2520 internal_error (__FILE__
, __LINE__
, "invalid decimal");
2527 gdb_realpath (const char *filename
)
2529 #ifdef HAVE_REALPATH
2530 #if defined (PATH_MAX)
2532 #elif defined (MAXPATHLEN)
2533 char buf
[MAXPATHLEN
];
2535 #error "Neither PATH_MAX nor MAXPATHLEN defined"
2537 char *rp
= realpath (filename
, buf
);
2538 return xstrdup (rp
? rp
: filename
);
2540 return xstrdup (filename
);