1 /* General utility routines for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* FIXME: cagney/2002-02-28: The GDB coding standard indicates that
24 "defs.h" should be included first. Unfortunatly some systems
25 (currently Debian GNU/Linux) include the <stdbool.h> via <curses.h>
26 and they clash with "bfd.h"'s definiton of true/false. The correct
27 fix is to remove true/false from "bfd.h", however, until that
28 happens, hack around it by including "config.h" and <curses.h>
41 #include "gdb_assert.h"
43 #include "gdb_string.h"
44 #include "event-top.h"
50 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
61 #include "expression.h"
65 #include "inferior.h" /* for signed_pointer_to_address */
67 #include <sys/param.h> /* For MAXPATHLEN */
69 #include <readline/readline.h>
75 #ifdef NEED_DECLARATION_MALLOC
78 #ifdef NEED_DECLARATION_REALLOC
79 extern PTR realloc ();
81 #ifdef NEED_DECLARATION_FREE
84 /* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
85 #if defined(HAVE_CANONICALIZE_FILE_NAME) \
86 && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
87 extern char *canonicalize_file_name (const char *);
91 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
93 /* readline defines this. */
96 void (*error_begin_hook) (void);
98 /* Holds the last error message issued by gdb */
100 static struct ui_file *gdb_lasterr;
102 /* Prototypes for local functions */
104 static void vfprintf_maybe_filtered (struct ui_file *, const char *,
107 static void fputs_maybe_filtered (const char *, struct ui_file *, int);
109 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
110 static void malloc_botch (void);
113 static void prompt_for_continue (void);
115 static void set_width_command (char *, int, struct cmd_list_element *);
117 static void set_width (void);
119 /* Chain of cleanup actions established with make_cleanup,
120 to be executed if an error happens. */
122 static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
123 static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
124 static struct cleanup *run_cleanup_chain; /* cleaned up on each 'run' */
125 static struct cleanup *exec_cleanup_chain; /* cleaned up on each execution command */
126 /* cleaned up on each error from within an execution command */
127 static struct cleanup *exec_error_cleanup_chain;
129 /* Pointer to what is left to do for an execution command after the
130 target stops. Used only in asynchronous mode, by targets that
131 support async execution. The finish and until commands use it. So
132 does the target extended-remote command. */
133 struct continuation *cmd_continuation;
134 struct continuation *intermediate_continuation;
136 /* Nonzero if we have job control. */
140 /* Nonzero means a quit has been requested. */
144 /* Nonzero means quit immediately if Control-C is typed now, rather
145 than waiting until QUIT is executed. Be careful in setting this;
146 code which executes with immediate_quit set has to be very careful
147 about being able to deal with being interrupted at any time. It is
148 almost always better to use QUIT; the only exception I can think of
149 is being able to quit out of a system call (using EINTR loses if
150 the SIGINT happens between the previous QUIT and the system call).
151 To immediately quit in the case in which a SIGINT happens between
152 the previous QUIT and setting immediate_quit (desirable anytime we
153 expect to block), call QUIT after setting immediate_quit. */
157 /* Nonzero means that encoded C++ names should be printed out in their
158 C++ form rather than raw. */
162 /* Nonzero means that encoded C++ names should be printed out in their
163 C++ form even in assembler language displays. If this is set, but
164 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
166 int asm_demangle = 0;
168 /* Nonzero means that strings with character values >0x7F should be printed
169 as octal escapes. Zero means just print the value (e.g. it's an
170 international character, and the terminal or window can cope.) */
172 int sevenbit_strings = 0;
174 /* String to be printed before error messages, if any. */
176 char *error_pre_print;
178 /* String to be printed before quit messages, if any. */
180 char *quit_pre_print;
182 /* String to be printed before warning messages, if any. */
184 char *warning_pre_print = "\nwarning: ";
186 int pagination_enabled = 1;
189 /* Add a new cleanup to the cleanup_chain,
190 and return the previous chain pointer
191 to be passed later to do_cleanups or discard_cleanups.
192 Args are FUNCTION to clean up with, and ARG to pass to it. */
195 make_cleanup (make_cleanup_ftype *function, void *arg)
197 return make_my_cleanup (&cleanup_chain, function, arg);
201 make_final_cleanup (make_cleanup_ftype *function, void *arg)
203 return make_my_cleanup (&final_cleanup_chain, function, arg);
207 make_run_cleanup (make_cleanup_ftype *function, void *arg)
209 return make_my_cleanup (&run_cleanup_chain, function, arg);
213 make_exec_cleanup (make_cleanup_ftype *function, void *arg)
215 return make_my_cleanup (&exec_cleanup_chain, function, arg);
219 make_exec_error_cleanup (make_cleanup_ftype *function, void *arg)
221 return make_my_cleanup (&exec_error_cleanup_chain, function, arg);
225 do_freeargv (void *arg)
227 freeargv ((char **) arg);
231 make_cleanup_freeargv (char **arg)
233 return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
237 do_bfd_close_cleanup (void *arg)
243 make_cleanup_bfd_close (bfd *abfd)
245 return make_cleanup (do_bfd_close_cleanup, abfd);
249 do_close_cleanup (void *arg)
257 make_cleanup_close (int fd)
259 int *saved_fd = xmalloc (sizeof (fd));
261 return make_cleanup (do_close_cleanup, saved_fd);
265 do_ui_file_delete (void *arg)
267 ui_file_delete (arg);
271 make_cleanup_ui_file_delete (struct ui_file *arg)
273 return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
277 make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
280 register struct cleanup *new
281 = (struct cleanup *) xmalloc (sizeof (struct cleanup));
282 register struct cleanup *old_chain = *pmy_chain;
284 new->next = *pmy_chain;
285 new->function = function;
292 /* Discard cleanups and do the actions they describe
293 until we get back to the point OLD_CHAIN in the cleanup_chain. */
296 do_cleanups (register struct cleanup *old_chain)
298 do_my_cleanups (&cleanup_chain, old_chain);
302 do_final_cleanups (register struct cleanup *old_chain)
304 do_my_cleanups (&final_cleanup_chain, old_chain);
308 do_run_cleanups (register struct cleanup *old_chain)
310 do_my_cleanups (&run_cleanup_chain, old_chain);
314 do_exec_cleanups (register struct cleanup *old_chain)
316 do_my_cleanups (&exec_cleanup_chain, old_chain);
320 do_exec_error_cleanups (register struct cleanup *old_chain)
322 do_my_cleanups (&exec_error_cleanup_chain, old_chain);
326 do_my_cleanups (register struct cleanup **pmy_chain,
327 register struct cleanup *old_chain)
329 register struct cleanup *ptr;
330 while ((ptr = *pmy_chain) != old_chain)
332 *pmy_chain = ptr->next; /* Do this first incase recursion */
333 (*ptr->function) (ptr->arg);
338 /* Discard cleanups, not doing the actions they describe,
339 until we get back to the point OLD_CHAIN in the cleanup_chain. */
342 discard_cleanups (register struct cleanup *old_chain)
344 discard_my_cleanups (&cleanup_chain, old_chain);
348 discard_final_cleanups (register struct cleanup *old_chain)
350 discard_my_cleanups (&final_cleanup_chain, old_chain);
354 discard_exec_error_cleanups (register struct cleanup *old_chain)
356 discard_my_cleanups (&exec_error_cleanup_chain, old_chain);
360 discard_my_cleanups (register struct cleanup **pmy_chain,
361 register struct cleanup *old_chain)
363 register struct cleanup *ptr;
364 while ((ptr = *pmy_chain) != old_chain)
366 *pmy_chain = ptr->next;
371 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
375 return save_my_cleanups (&cleanup_chain);
379 save_final_cleanups (void)
381 return save_my_cleanups (&final_cleanup_chain);
385 save_my_cleanups (struct cleanup **pmy_chain)
387 struct cleanup *old_chain = *pmy_chain;
393 /* Restore the cleanup chain from a previously saved chain. */
395 restore_cleanups (struct cleanup *chain)
397 restore_my_cleanups (&cleanup_chain, chain);
401 restore_final_cleanups (struct cleanup *chain)
403 restore_my_cleanups (&final_cleanup_chain, chain);
407 restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain)
412 /* This function is useful for cleanups.
416 old_chain = make_cleanup (free_current_contents, &foo);
418 to arrange to free the object thus allocated. */
421 free_current_contents (void *ptr)
423 void **location = ptr;
424 if (location == NULL)
425 internal_error (__FILE__, __LINE__,
426 "free_current_contents: NULL pointer");
427 if (*location != NULL)
434 /* Provide a known function that does nothing, to use as a base for
435 for a possibly long chain of cleanups. This is useful where we
436 use the cleanup chain for handling normal cleanups as well as dealing
437 with cleanups that need to be done as a result of a call to error().
438 In such cases, we may not be certain where the first cleanup is, unless
439 we have a do-nothing one to always use as the base. */
443 null_cleanup (void *arg)
447 /* Add a continuation to the continuation list, the global list
448 cmd_continuation. The new continuation will be added at the front.*/
450 add_continuation (void (*continuation_hook) (struct continuation_arg *),
451 struct continuation_arg *arg_list)
453 struct continuation *continuation_ptr;
455 continuation_ptr = (struct continuation *) xmalloc (sizeof (struct continuation));
456 continuation_ptr->continuation_hook = continuation_hook;
457 continuation_ptr->arg_list = arg_list;
458 continuation_ptr->next = cmd_continuation;
459 cmd_continuation = continuation_ptr;
462 /* Walk down the cmd_continuation list, and execute all the
463 continuations. There is a problem though. In some cases new
464 continuations may be added while we are in the middle of this
465 loop. If this happens they will be added in the front, and done
466 before we have a chance of exhausting those that were already
467 there. We need to then save the beginning of the list in a pointer
468 and do the continuations from there on, instead of using the
469 global beginning of list as our iteration pointer.*/
471 do_all_continuations (void)
473 struct continuation *continuation_ptr;
474 struct continuation *saved_continuation;
476 /* Copy the list header into another pointer, and set the global
477 list header to null, so that the global list can change as a side
478 effect of invoking the continuations and the processing of
479 the preexisting continuations will not be affected. */
480 continuation_ptr = cmd_continuation;
481 cmd_continuation = NULL;
483 /* Work now on the list we have set aside. */
484 while (continuation_ptr)
486 (continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
487 saved_continuation = continuation_ptr;
488 continuation_ptr = continuation_ptr->next;
489 xfree (saved_continuation);
493 /* Walk down the cmd_continuation list, and get rid of all the
496 discard_all_continuations (void)
498 struct continuation *continuation_ptr;
500 while (cmd_continuation)
502 continuation_ptr = cmd_continuation;
503 cmd_continuation = continuation_ptr->next;
504 xfree (continuation_ptr);
508 /* Add a continuation to the continuation list, the global list
509 intermediate_continuation. The new continuation will be added at the front.*/
511 add_intermediate_continuation (void (*continuation_hook)
512 (struct continuation_arg *),
513 struct continuation_arg *arg_list)
515 struct continuation *continuation_ptr;
517 continuation_ptr = (struct continuation *) xmalloc (sizeof (struct continuation));
518 continuation_ptr->continuation_hook = continuation_hook;
519 continuation_ptr->arg_list = arg_list;
520 continuation_ptr->next = intermediate_continuation;
521 intermediate_continuation = continuation_ptr;
524 /* Walk down the cmd_continuation list, and execute all the
525 continuations. There is a problem though. In some cases new
526 continuations may be added while we are in the middle of this
527 loop. If this happens they will be added in the front, and done
528 before we have a chance of exhausting those that were already
529 there. We need to then save the beginning of the list in a pointer
530 and do the continuations from there on, instead of using the
531 global beginning of list as our iteration pointer.*/
533 do_all_intermediate_continuations (void)
535 struct continuation *continuation_ptr;
536 struct continuation *saved_continuation;
538 /* Copy the list header into another pointer, and set the global
539 list header to null, so that the global list can change as a side
540 effect of invoking the continuations and the processing of
541 the preexisting continuations will not be affected. */
542 continuation_ptr = intermediate_continuation;
543 intermediate_continuation = NULL;
545 /* Work now on the list we have set aside. */
546 while (continuation_ptr)
548 (continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
549 saved_continuation = continuation_ptr;
550 continuation_ptr = continuation_ptr->next;
551 xfree (saved_continuation);
555 /* Walk down the cmd_continuation list, and get rid of all the
558 discard_all_intermediate_continuations (void)
560 struct continuation *continuation_ptr;
562 while (intermediate_continuation)
564 continuation_ptr = intermediate_continuation;
565 intermediate_continuation = continuation_ptr->next;
566 xfree (continuation_ptr);
572 /* Print a warning message. The first argument STRING is the warning
573 message, used as an fprintf format string, the second is the
574 va_list of arguments for that string. A warning is unfiltered (not
575 paginated) so that the user does not need to page through each
576 screen full of warnings when there are lots of them. */
579 vwarning (const char *string, va_list args)
582 (*warning_hook) (string, args);
585 target_terminal_ours ();
586 wrap_here (""); /* Force out any buffered output */
587 gdb_flush (gdb_stdout);
588 if (warning_pre_print)
589 fprintf_unfiltered (gdb_stderr, warning_pre_print);
590 vfprintf_unfiltered (gdb_stderr, string, args);
591 fprintf_unfiltered (gdb_stderr, "\n");
596 /* Print a warning message.
597 The first argument STRING is the warning message, used as a fprintf string,
598 and the remaining args are passed as arguments to it.
599 The primary difference between warnings and errors is that a warning
600 does not force the return to command level. */
603 warning (const char *string,...)
606 va_start (args, string);
607 vwarning (string, args);
611 /* Print an error message and return to command level.
612 The first argument STRING is the error message, used as a fprintf string,
613 and the remaining args are passed as arguments to it. */
616 verror (const char *string, va_list args)
618 struct ui_file *tmp_stream = mem_fileopen ();
619 make_cleanup_ui_file_delete (tmp_stream);
620 vfprintf_unfiltered (tmp_stream, string, args);
621 error_stream (tmp_stream);
625 error (const char *string,...)
628 va_start (args, string);
629 verror (string, args);
634 do_write (void *data, const char *buffer, long length_buffer)
636 ui_file_write (data, buffer, length_buffer);
640 error_stream (struct ui_file *stream)
642 if (error_begin_hook)
645 /* Copy the stream into the GDB_LASTERR buffer. */
646 ui_file_rewind (gdb_lasterr);
647 ui_file_put (stream, do_write, gdb_lasterr);
649 /* Write the message plus any error_pre_print to gdb_stderr. */
650 target_terminal_ours ();
651 wrap_here (""); /* Force out any buffered output */
652 gdb_flush (gdb_stdout);
653 annotate_error_begin ();
655 fprintf_filtered (gdb_stderr, error_pre_print);
656 ui_file_put (stream, do_write, gdb_stderr);
657 fprintf_filtered (gdb_stderr, "\n");
659 throw_exception (RETURN_ERROR);
662 /* Get the last error message issued by gdb */
665 error_last_message (void)
668 return ui_file_xstrdup (gdb_lasterr, &len);
671 /* This is to be called by main() at the very beginning */
676 gdb_lasterr = mem_fileopen ();
679 /* Print a message reporting an internal error. Ask the user if they
680 want to continue, dump core, or just exit. */
683 internal_verror (const char *file, int line,
684 const char *fmt, va_list ap)
686 static char msg[] = "Internal GDB error: recursive internal error.\n";
687 static int dejavu = 0;
691 /* don't allow infinite error recursion. */
699 fputs_unfiltered (msg, gdb_stderr);
700 abort (); /* NOTE: GDB has only three calls to abort(). */
703 write (STDERR_FILENO, msg, sizeof (msg));
707 /* Try to get the message out */
708 target_terminal_ours ();
709 fprintf_unfiltered (gdb_stderr, "%s:%d: gdb-internal-error: ", file, line);
710 vfprintf_unfiltered (gdb_stderr, fmt, ap);
711 fputs_unfiltered ("\n", gdb_stderr);
713 /* Default (yes/batch case) is to quit GDB. When in batch mode this
714 lessens the likelhood of GDB going into an infinate loop. */
716 An internal GDB error was detected. This may make further\n\
717 debugging unreliable. Quit this debugging session? ");
719 /* Default (yes/batch case) is to dump core. This leaves a GDB
720 dropping so that it is easier to see that something went wrong to
722 dump_core_p = query ("\
723 Create a core file containing the current state of GDB? ");
728 abort (); /* NOTE: GDB has only three calls to abort(). */
737 abort (); /* NOTE: GDB has only three calls to abort(). */
742 throw_exception (RETURN_ERROR);
746 internal_error (const char *file, int line, const char *string, ...)
749 va_start (ap, string);
751 internal_verror (file, line, string, ap);
755 /* The strerror() function can return NULL for errno values that are
756 out of range. Provide a "safe" version that always returns a
760 safe_strerror (int errnum)
765 if ((msg = strerror (errnum)) == NULL)
767 sprintf (buf, "(undocumented errno %d)", errnum);
773 /* Print the system error message for errno, and also mention STRING
774 as the file name for which the error was encountered.
775 Then return to command level. */
778 perror_with_name (const char *string)
783 err = safe_strerror (errno);
784 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
785 strcpy (combined, string);
786 strcat (combined, ": ");
787 strcat (combined, err);
789 /* I understand setting these is a matter of taste. Still, some people
790 may clear errno but not know about bfd_error. Doing this here is not
792 bfd_set_error (bfd_error_no_error);
795 error ("%s.", combined);
798 /* Print the system error message for ERRCODE, and also mention STRING
799 as the file name for which the error was encountered. */
802 print_sys_errmsg (const char *string, int errcode)
807 err = safe_strerror (errcode);
808 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
809 strcpy (combined, string);
810 strcat (combined, ": ");
811 strcat (combined, err);
813 /* We want anything which was printed on stdout to come out first, before
815 gdb_flush (gdb_stdout);
816 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
819 /* Control C eventually causes this to be called, at a convenient time. */
824 struct serial *gdb_stdout_serial = serial_fdopen (1);
826 target_terminal_ours ();
828 /* We want all output to appear now, before we print "Quit". We
829 have 3 levels of buffering we have to flush (it's possible that
830 some of these should be changed to flush the lower-level ones
833 /* 1. The _filtered buffer. */
834 wrap_here ((char *) 0);
836 /* 2. The stdio buffer. */
837 gdb_flush (gdb_stdout);
838 gdb_flush (gdb_stderr);
840 /* 3. The system-level buffer. */
841 serial_drain_output (gdb_stdout_serial);
842 serial_un_fdopen (gdb_stdout_serial);
844 annotate_error_begin ();
846 /* Don't use *_filtered; we don't want to prompt the user to continue. */
848 fprintf_unfiltered (gdb_stderr, quit_pre_print);
851 /* No steenking SIGINT will ever be coming our way when the
852 program is resumed. Don't lie. */
853 fprintf_unfiltered (gdb_stderr, "Quit\n");
856 /* If there is no terminal switching for this target, then we can't
857 possibly get screwed by the lack of job control. */
858 || current_target.to_terminal_ours == NULL)
859 fprintf_unfiltered (gdb_stderr, "Quit\n");
861 fprintf_unfiltered (gdb_stderr,
862 "Quit (expect signal SIGINT when the program is resumed)\n");
864 throw_exception (RETURN_QUIT);
867 /* Control C comes here */
869 request_quit (int signo)
872 /* Restore the signal handler. Harmless with BSD-style signals, needed
873 for System V-style signals. So just always do it, rather than worrying
874 about USG defines and stuff like that. */
875 signal (signo, request_quit);
885 /* Memory management stuff (malloc friends). */
887 #if !defined (USE_MMALLOC)
889 /* NOTE: These must use PTR so that their definition matches the
890 declaration found in "mmalloc.h". */
893 mmalloc (void *md, size_t size)
895 return malloc (size); /* NOTE: GDB's only call to malloc() */
899 mrealloc (void *md, void *ptr, size_t size)
901 if (ptr == 0) /* Guard against old realloc's */
902 return mmalloc (md, size);
904 return realloc (ptr, size); /* NOTE: GDB's only call to ralloc() */
908 mcalloc (void *md, size_t number, size_t size)
910 return calloc (number, size); /* NOTE: GDB's only call to calloc() */
914 mfree (void *md, void *ptr)
916 free (ptr); /* NOTE: GDB's only call to free() */
919 #endif /* USE_MMALLOC */
921 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
924 init_malloc (void *md)
928 #else /* Have mmalloc and want corruption checking */
933 fprintf_unfiltered (gdb_stderr, "Memory corruption\n");
934 internal_error (__FILE__, __LINE__, "failed internal consistency check");
937 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
938 by MD, to detect memory corruption. Note that MD may be NULL to specify
939 the default heap that grows via sbrk.
941 Note that for freshly created regions, we must call mmcheckf prior to any
942 mallocs in the region. Otherwise, any region which was allocated prior to
943 installing the checking hooks, which is later reallocated or freed, will
944 fail the checks! The mmcheck function only allows initial hooks to be
945 installed before the first mmalloc. However, anytime after we have called
946 mmcheck the first time to install the checking hooks, we can call it again
947 to update the function pointer to the memory corruption handler.
949 Returns zero on failure, non-zero on success. */
951 #ifndef MMCHECK_FORCE
952 #define MMCHECK_FORCE 0
956 init_malloc (void *md)
958 if (!mmcheckf (md, malloc_botch, MMCHECK_FORCE))
960 /* Don't use warning(), which relies on current_target being set
961 to something other than dummy_target, until after
962 initialize_all_files(). */
965 (gdb_stderr, "warning: failed to install memory consistency checks; ");
967 (gdb_stderr, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
973 #endif /* Have mmalloc and want corruption checking */
975 /* Called when a memory allocation fails, with the number of bytes of
976 memory requested in SIZE. */
983 internal_error (__FILE__, __LINE__,
984 "virtual memory exhausted: can't allocate %ld bytes.", size);
988 internal_error (__FILE__, __LINE__,
989 "virtual memory exhausted.");
993 /* The xmmalloc() family of memory management routines.
995 These are are like the mmalloc() family except that they implement
996 consistent semantics and guard against typical memory management
997 problems: if a malloc fails, an internal error is thrown; if
998 free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
1001 All these routines are implemented using the mmalloc() family. */
1004 xmmalloc (void *md, size_t size)
1014 val = mmalloc (md, size);
1022 xmrealloc (void *md, void *ptr, size_t size)
1036 val = mrealloc (md, ptr, size);
1040 val = mmalloc (md, size);
1051 xmcalloc (void *md, size_t number, size_t size)
1054 if (number == 0 || size == 0)
1058 mem = mcalloc (md, number, size);
1060 nomem (number * size);
1066 xmfree (void *md, void *ptr)
1072 /* The xmalloc() (libiberty.h) family of memory management routines.
1074 These are like the ISO-C malloc() family except that they implement
1075 consistent semantics and guard against typical memory management
1076 problems. See xmmalloc() above for further information.
1078 All these routines are wrappers to the xmmalloc() family. */
1080 /* NOTE: These are declared using PTR to ensure consistency with
1081 "libiberty.h". xfree() is GDB local. */
1084 xmalloc (size_t size)
1086 return xmmalloc (NULL, size);
1090 xrealloc (PTR ptr, size_t size)
1092 return xmrealloc (NULL, ptr, size);
1096 xcalloc (size_t number, size_t size)
1098 return xmcalloc (NULL, number, size);
1108 /* Like asprintf/vasprintf but get an internal_error if the call
1112 xasprintf (char **ret, const char *format, ...)
1115 va_start (args, format);
1116 xvasprintf (ret, format, args);
1121 xvasprintf (char **ret, const char *format, va_list ap)
1123 int status = vasprintf (ret, format, ap);
1124 /* NULL could be returned due to a memory allocation problem; a
1125 badly format string; or something else. */
1127 internal_error (__FILE__, __LINE__,
1128 "vasprintf returned NULL buffer (errno %d)",
1130 /* A negative status with a non-NULL buffer shouldn't never
1131 happen. But to be sure. */
1133 internal_error (__FILE__, __LINE__,
1134 "vasprintf call failed (errno %d)",
1139 /* My replacement for the read system call.
1140 Used like `read' but keeps going if `read' returns too soon. */
1143 myread (int desc, char *addr, int len)
1150 val = read (desc, addr, len);
1154 return orglen - len;
1161 /* Make a copy of the string at PTR with SIZE characters
1162 (and add a null character at the end in the copy).
1163 Uses malloc to get the space. Returns the address of the copy. */
1166 savestring (const char *ptr, size_t size)
1168 register char *p = (char *) xmalloc (size + 1);
1169 memcpy (p, ptr, size);
1175 msavestring (void *md, const char *ptr, size_t size)
1177 register char *p = (char *) xmmalloc (md, size + 1);
1178 memcpy (p, ptr, size);
1184 mstrsave (void *md, const char *ptr)
1186 return (msavestring (md, ptr, strlen (ptr)));
1190 print_spaces (register int n, register struct ui_file *file)
1192 fputs_unfiltered (n_spaces (n), file);
1195 /* Print a host address. */
1198 gdb_print_host_address (void *addr, struct ui_file *stream)
1201 /* We could use the %p conversion specifier to fprintf if we had any
1202 way of knowing whether this host supports it. But the following
1203 should work on the Alpha and on 32 bit machines. */
1205 fprintf_filtered (stream, "0x%lx", (unsigned long) addr);
1208 /* Ask user a y-or-n question and return 1 iff answer is yes.
1209 Takes three args which are given to printf to print the question.
1210 The first, a control string, should end in "? ".
1211 It should not say how to answer, because we do that. */
1215 query (const char *ctlstr,...)
1218 register int answer;
1222 va_start (args, ctlstr);
1226 return query_hook (ctlstr, args);
1229 /* Automatically answer "yes" if input is not from a terminal. */
1230 if (!input_from_terminal_p ())
1235 wrap_here (""); /* Flush any buffered output */
1236 gdb_flush (gdb_stdout);
1238 if (annotation_level > 1)
1239 printf_filtered ("\n\032\032pre-query\n");
1241 vfprintf_filtered (gdb_stdout, ctlstr, args);
1242 printf_filtered ("(y or n) ");
1244 if (annotation_level > 1)
1245 printf_filtered ("\n\032\032query\n");
1248 gdb_flush (gdb_stdout);
1250 answer = fgetc (stdin);
1251 clearerr (stdin); /* in case of C-d */
1252 if (answer == EOF) /* C-d */
1257 /* Eat rest of input line, to EOF or newline */
1261 ans2 = fgetc (stdin);
1264 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1278 printf_filtered ("Please answer y or n.\n");
1281 if (annotation_level > 1)
1282 printf_filtered ("\n\032\032post-query\n");
1287 /* Parse a C escape sequence. STRING_PTR points to a variable
1288 containing a pointer to the string to parse. That pointer
1289 should point to the character after the \. That pointer
1290 is updated past the characters we use. The value of the
1291 escape sequence is returned.
1293 A negative value means the sequence \ newline was seen,
1294 which is supposed to be equivalent to nothing at all.
1296 If \ is followed by a null character, we return a negative
1297 value and leave the string pointer pointing at the null character.
1299 If \ is followed by 000, we return 0 and leave the string pointer
1300 after the zeros. A value of 0 does not mean end of string. */
1303 parse_escape (char **string_ptr)
1305 register int c = *(*string_ptr)++;
1309 return 007; /* Bell (alert) char */
1312 case 'e': /* Escape character */
1330 c = *(*string_ptr)++;
1332 c = parse_escape (string_ptr);
1335 return (c & 0200) | (c & 037);
1346 register int i = c - '0';
1347 register int count = 0;
1350 if ((c = *(*string_ptr)++) >= '0' && c <= '7')
1368 /* Print the character C on STREAM as part of the contents of a literal
1369 string whose delimiter is QUOTER. Note that this routine should only
1370 be call for printing things which are independent of the language
1371 of the program being debugged. */
1374 printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1375 void (*do_fprintf) (struct ui_file *, const char *, ...),
1376 struct ui_file *stream, int quoter)
1379 c &= 0xFF; /* Avoid sign bit follies */
1381 if (c < 0x20 || /* Low control chars */
1382 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1383 (sevenbit_strings && c >= 0x80))
1384 { /* high order bit set */
1388 do_fputs ("\\n", stream);
1391 do_fputs ("\\b", stream);
1394 do_fputs ("\\t", stream);
1397 do_fputs ("\\f", stream);
1400 do_fputs ("\\r", stream);
1403 do_fputs ("\\e", stream);
1406 do_fputs ("\\a", stream);
1409 do_fprintf (stream, "\\%.3o", (unsigned int) c);
1415 if (c == '\\' || c == quoter)
1416 do_fputs ("\\", stream);
1417 do_fprintf (stream, "%c", c);
1421 /* Print the character C on STREAM as part of the contents of a
1422 literal string whose delimiter is QUOTER. Note that these routines
1423 should only be call for printing things which are independent of
1424 the language of the program being debugged. */
1427 fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
1430 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1434 fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
1437 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1441 fputstrn_unfiltered (const char *str, int n, int quoter, struct ui_file *stream)
1444 for (i = 0; i < n; i++)
1445 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1450 /* Number of lines per page or UINT_MAX if paging is disabled. */
1451 static unsigned int lines_per_page;
1452 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1453 static unsigned int chars_per_line;
1454 /* Current count of lines printed on this page, chars on this line. */
1455 static unsigned int lines_printed, chars_printed;
1457 /* Buffer and start column of buffered text, for doing smarter word-
1458 wrapping. When someone calls wrap_here(), we start buffering output
1459 that comes through fputs_filtered(). If we see a newline, we just
1460 spit it out and forget about the wrap_here(). If we see another
1461 wrap_here(), we spit it out and remember the newer one. If we see
1462 the end of the line, we spit out a newline, the indent, and then
1463 the buffered output. */
1465 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1466 are waiting to be output (they have already been counted in chars_printed).
1467 When wrap_buffer[0] is null, the buffer is empty. */
1468 static char *wrap_buffer;
1470 /* Pointer in wrap_buffer to the next character to fill. */
1471 static char *wrap_pointer;
1473 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1475 static char *wrap_indent;
1477 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1478 is not in effect. */
1479 static int wrap_column;
1482 /* Inialize the lines and chars per page */
1484 init_page_info (void)
1487 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
1490 /* These defaults will be used if we are unable to get the correct
1491 values from termcap. */
1492 #if defined(__GO32__)
1493 lines_per_page = ScreenRows ();
1494 chars_per_line = ScreenCols ();
1496 lines_per_page = 24;
1497 chars_per_line = 80;
1499 #if !defined (_WIN32)
1500 /* No termcap under MPW, although might be cool to do something
1501 by looking at worksheet or console window sizes. */
1502 /* Initialize the screen height and width from termcap. */
1504 char *termtype = getenv ("TERM");
1506 /* Positive means success, nonpositive means failure. */
1509 /* 2048 is large enough for all known terminals, according to the
1510 GNU termcap manual. */
1511 char term_buffer[2048];
1515 status = tgetent (term_buffer, termtype);
1519 int running_in_emacs = getenv ("EMACS") != NULL;
1521 val = tgetnum ("li");
1522 if (val >= 0 && !running_in_emacs)
1523 lines_per_page = val;
1525 /* The number of lines per page is not mentioned
1526 in the terminal description. This probably means
1527 that paging is not useful (e.g. emacs shell window),
1528 so disable paging. */
1529 lines_per_page = UINT_MAX;
1531 val = tgetnum ("co");
1533 chars_per_line = val;
1539 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1541 /* If there is a better way to determine the window size, use it. */
1542 SIGWINCH_HANDLER (SIGWINCH);
1545 /* If the output is not a terminal, don't paginate it. */
1546 if (!ui_file_isatty (gdb_stdout))
1547 lines_per_page = UINT_MAX;
1548 } /* the command_line_version */
1555 if (chars_per_line == 0)
1560 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1561 wrap_buffer[0] = '\0';
1564 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1565 wrap_pointer = wrap_buffer; /* Start it at the beginning */
1570 set_width_command (char *args, int from_tty, struct cmd_list_element *c)
1575 /* Wait, so the user can read what's on the screen. Prompt the user
1576 to continue by pressing RETURN. */
1579 prompt_for_continue (void)
1582 char cont_prompt[120];
1584 if (annotation_level > 1)
1585 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1587 strcpy (cont_prompt,
1588 "---Type <return> to continue, or q <return> to quit---");
1589 if (annotation_level > 1)
1590 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1592 /* We must do this *before* we call gdb_readline, else it will eventually
1593 call us -- thinking that we're trying to print beyond the end of the
1595 reinitialize_more_filter ();
1598 /* On a real operating system, the user can quit with SIGINT.
1601 'q' is provided on all systems so users don't have to change habits
1602 from system to system, and because telling them what to do in
1603 the prompt is more user-friendly than expecting them to think of
1605 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1606 whereas control-C to gdb_readline will cause the user to get dumped
1608 ignore = readline (cont_prompt);
1610 if (annotation_level > 1)
1611 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1616 while (*p == ' ' || *p == '\t')
1621 request_quit (SIGINT);
1623 async_request_quit (0);
1629 /* Now we have to do this again, so that GDB will know that it doesn't
1630 need to save the ---Type <return>--- line at the top of the screen. */
1631 reinitialize_more_filter ();
1633 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1636 /* Reinitialize filter; ie. tell it to reset to original values. */
1639 reinitialize_more_filter (void)
1645 /* Indicate that if the next sequence of characters overflows the line,
1646 a newline should be inserted here rather than when it hits the end.
1647 If INDENT is non-null, it is a string to be printed to indent the
1648 wrapped part on the next line. INDENT must remain accessible until
1649 the next call to wrap_here() or until a newline is printed through
1652 If the line is already overfull, we immediately print a newline and
1653 the indentation, and disable further wrapping.
1655 If we don't know the width of lines, but we know the page height,
1656 we must not wrap words, but should still keep track of newlines
1657 that were explicitly printed.
1659 INDENT should not contain tabs, as that will mess up the char count
1660 on the next line. FIXME.
1662 This routine is guaranteed to force out any output which has been
1663 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1664 used to force out output from the wrap_buffer. */
1667 wrap_here (char *indent)
1669 /* This should have been allocated, but be paranoid anyway. */
1671 internal_error (__FILE__, __LINE__, "failed internal consistency check");
1675 *wrap_pointer = '\0';
1676 fputs_unfiltered (wrap_buffer, gdb_stdout);
1678 wrap_pointer = wrap_buffer;
1679 wrap_buffer[0] = '\0';
1680 if (chars_per_line == UINT_MAX) /* No line overflow checking */
1684 else if (chars_printed >= chars_per_line)
1686 puts_filtered ("\n");
1688 puts_filtered (indent);
1693 wrap_column = chars_printed;
1697 wrap_indent = indent;
1701 /* Ensure that whatever gets printed next, using the filtered output
1702 commands, starts at the beginning of the line. I.E. if there is
1703 any pending output for the current line, flush it and start a new
1704 line. Otherwise do nothing. */
1709 if (chars_printed > 0)
1711 puts_filtered ("\n");
1716 /* Like fputs but if FILTER is true, pause after every screenful.
1718 Regardless of FILTER can wrap at points other than the final
1719 character of a line.
1721 Unlike fputs, fputs_maybe_filtered does not return a value.
1722 It is OK for LINEBUFFER to be NULL, in which case just don't print
1725 Note that a longjmp to top level may occur in this routine (only if
1726 FILTER is true) (since prompt_for_continue may do so) so this
1727 routine should not be called when cleanups are not in place. */
1730 fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
1733 const char *lineptr;
1735 if (linebuffer == 0)
1738 /* Don't do any filtering if it is disabled. */
1739 if ((stream != gdb_stdout) || !pagination_enabled
1740 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
1742 fputs_unfiltered (linebuffer, stream);
1746 /* Go through and output each character. Show line extension
1747 when this is necessary; prompt user for new page when this is
1750 lineptr = linebuffer;
1753 /* Possible new page. */
1755 (lines_printed >= lines_per_page - 1))
1756 prompt_for_continue ();
1758 while (*lineptr && *lineptr != '\n')
1760 /* Print a single line. */
1761 if (*lineptr == '\t')
1764 *wrap_pointer++ = '\t';
1766 fputc_unfiltered ('\t', stream);
1767 /* Shifting right by 3 produces the number of tab stops
1768 we have already passed, and then adding one and
1769 shifting left 3 advances to the next tab stop. */
1770 chars_printed = ((chars_printed >> 3) + 1) << 3;
1776 *wrap_pointer++ = *lineptr;
1778 fputc_unfiltered (*lineptr, stream);
1783 if (chars_printed >= chars_per_line)
1785 unsigned int save_chars = chars_printed;
1789 /* If we aren't actually wrapping, don't output newline --
1790 if chars_per_line is right, we probably just overflowed
1791 anyway; if it's wrong, let us keep going. */
1793 fputc_unfiltered ('\n', stream);
1795 /* Possible new page. */
1796 if (lines_printed >= lines_per_page - 1)
1797 prompt_for_continue ();
1799 /* Now output indentation and wrapped string */
1802 fputs_unfiltered (wrap_indent, stream);
1803 *wrap_pointer = '\0'; /* Null-terminate saved stuff */
1804 fputs_unfiltered (wrap_buffer, stream); /* and eject it */
1805 /* FIXME, this strlen is what prevents wrap_indent from
1806 containing tabs. However, if we recurse to print it
1807 and count its chars, we risk trouble if wrap_indent is
1808 longer than (the user settable) chars_per_line.
1809 Note also that this can set chars_printed > chars_per_line
1810 if we are printing a long string. */
1811 chars_printed = strlen (wrap_indent)
1812 + (save_chars - wrap_column);
1813 wrap_pointer = wrap_buffer; /* Reset buffer */
1814 wrap_buffer[0] = '\0';
1815 wrap_column = 0; /* And disable fancy wrap */
1820 if (*lineptr == '\n')
1823 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1825 fputc_unfiltered ('\n', stream);
1832 fputs_filtered (const char *linebuffer, struct ui_file *stream)
1834 fputs_maybe_filtered (linebuffer, stream, 1);
1838 putchar_unfiltered (int c)
1841 ui_file_write (gdb_stdout, &buf, 1);
1845 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1846 May return nonlocally. */
1849 putchar_filtered (int c)
1851 return fputc_filtered (c, gdb_stdout);
1855 fputc_unfiltered (int c, struct ui_file *stream)
1858 ui_file_write (stream, &buf, 1);
1863 fputc_filtered (int c, struct ui_file *stream)
1869 fputs_filtered (buf, stream);
1873 /* puts_debug is like fputs_unfiltered, except it prints special
1874 characters in printable fashion. */
1877 puts_debug (char *prefix, char *string, char *suffix)
1881 /* Print prefix and suffix after each line. */
1882 static int new_line = 1;
1883 static int return_p = 0;
1884 static char *prev_prefix = "";
1885 static char *prev_suffix = "";
1887 if (*string == '\n')
1890 /* If the prefix is changing, print the previous suffix, a new line,
1891 and the new prefix. */
1892 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
1894 fputs_unfiltered (prev_suffix, gdb_stdlog);
1895 fputs_unfiltered ("\n", gdb_stdlog);
1896 fputs_unfiltered (prefix, gdb_stdlog);
1899 /* Print prefix if we printed a newline during the previous call. */
1903 fputs_unfiltered (prefix, gdb_stdlog);
1906 prev_prefix = prefix;
1907 prev_suffix = suffix;
1909 /* Output characters in a printable format. */
1910 while ((ch = *string++) != '\0')
1916 fputc_unfiltered (ch, gdb_stdlog);
1919 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
1923 fputs_unfiltered ("\\\\", gdb_stdlog);
1926 fputs_unfiltered ("\\b", gdb_stdlog);
1929 fputs_unfiltered ("\\f", gdb_stdlog);
1933 fputs_unfiltered ("\\n", gdb_stdlog);
1936 fputs_unfiltered ("\\r", gdb_stdlog);
1939 fputs_unfiltered ("\\t", gdb_stdlog);
1942 fputs_unfiltered ("\\v", gdb_stdlog);
1946 return_p = ch == '\r';
1949 /* Print suffix if we printed a newline. */
1952 fputs_unfiltered (suffix, gdb_stdlog);
1953 fputs_unfiltered ("\n", gdb_stdlog);
1958 /* Print a variable number of ARGS using format FORMAT. If this
1959 information is going to put the amount written (since the last call
1960 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1961 call prompt_for_continue to get the users permision to continue.
1963 Unlike fprintf, this function does not return a value.
1965 We implement three variants, vfprintf (takes a vararg list and stream),
1966 fprintf (takes a stream to write on), and printf (the usual).
1968 Note also that a longjmp to top level may occur in this routine
1969 (since prompt_for_continue may do so) so this routine should not be
1970 called when cleanups are not in place. */
1973 vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
1974 va_list args, int filter)
1977 struct cleanup *old_cleanups;
1979 xvasprintf (&linebuffer, format, args);
1980 old_cleanups = make_cleanup (xfree, linebuffer);
1981 fputs_maybe_filtered (linebuffer, stream, filter);
1982 do_cleanups (old_cleanups);
1987 vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
1989 vfprintf_maybe_filtered (stream, format, args, 1);
1993 vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
1996 struct cleanup *old_cleanups;
1998 xvasprintf (&linebuffer, format, args);
1999 old_cleanups = make_cleanup (xfree, linebuffer);
2000 fputs_unfiltered (linebuffer, stream);
2001 do_cleanups (old_cleanups);
2005 vprintf_filtered (const char *format, va_list args)
2007 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2011 vprintf_unfiltered (const char *format, va_list args)
2013 vfprintf_unfiltered (gdb_stdout, format, args);
2017 fprintf_filtered (struct ui_file * stream, const char *format,...)
2020 va_start (args, format);
2021 vfprintf_filtered (stream, format, args);
2026 fprintf_unfiltered (struct ui_file * stream, const char *format,...)
2029 va_start (args, format);
2030 vfprintf_unfiltered (stream, format, args);
2034 /* Like fprintf_filtered, but prints its result indented.
2035 Called as fprintfi_filtered (spaces, stream, format, ...); */
2038 fprintfi_filtered (int spaces, struct ui_file * stream, const char *format,...)
2041 va_start (args, format);
2042 print_spaces_filtered (spaces, stream);
2044 vfprintf_filtered (stream, format, args);
2050 printf_filtered (const char *format,...)
2053 va_start (args, format);
2054 vfprintf_filtered (gdb_stdout, format, args);
2060 printf_unfiltered (const char *format,...)
2063 va_start (args, format);
2064 vfprintf_unfiltered (gdb_stdout, format, args);
2068 /* Like printf_filtered, but prints it's result indented.
2069 Called as printfi_filtered (spaces, format, ...); */
2072 printfi_filtered (int spaces, const char *format,...)
2075 va_start (args, format);
2076 print_spaces_filtered (spaces, gdb_stdout);
2077 vfprintf_filtered (gdb_stdout, format, args);
2081 /* Easy -- but watch out!
2083 This routine is *not* a replacement for puts()! puts() appends a newline.
2084 This one doesn't, and had better not! */
2087 puts_filtered (const char *string)
2089 fputs_filtered (string, gdb_stdout);
2093 puts_unfiltered (const char *string)
2095 fputs_unfiltered (string, gdb_stdout);
2098 /* Return a pointer to N spaces and a null. The pointer is good
2099 until the next call to here. */
2104 static char *spaces = 0;
2105 static int max_spaces = -1;
2111 spaces = (char *) xmalloc (n + 1);
2112 for (t = spaces + n; t != spaces;)
2118 return spaces + max_spaces - n;
2121 /* Print N spaces. */
2123 print_spaces_filtered (int n, struct ui_file *stream)
2125 fputs_filtered (n_spaces (n), stream);
2128 /* C++ demangler stuff. */
2130 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2131 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2132 If the name is not mangled, or the language for the name is unknown, or
2133 demangling is off, the name is printed in its "raw" form. */
2136 fprintf_symbol_filtered (struct ui_file *stream, char *name, enum language lang,
2143 /* If user wants to see raw output, no problem. */
2146 fputs_filtered (name, stream);
2152 case language_cplus:
2153 demangled = cplus_demangle (name, arg_mode);
2156 demangled = cplus_demangle (name, arg_mode | DMGL_JAVA);
2158 case language_chill:
2159 demangled = chill_demangle (name);
2165 fputs_filtered (demangled ? demangled : name, stream);
2166 if (demangled != NULL)
2174 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2175 differences in whitespace. Returns 0 if they match, non-zero if they
2176 don't (slightly different than strcmp()'s range of return values).
2178 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2179 This "feature" is useful when searching for matching C++ function names
2180 (such as if the user types 'break FOO', where FOO is a mangled C++
2184 strcmp_iw (const char *string1, const char *string2)
2186 while ((*string1 != '\0') && (*string2 != '\0'))
2188 while (isspace (*string1))
2192 while (isspace (*string2))
2196 if (*string1 != *string2)
2200 if (*string1 != '\0')
2206 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2212 ** Answer whether string_to_compare is a full or partial match to
2213 ** template_string. The partial match must be in sequence starting
2217 subset_compare (char *string_to_compare, char *template_string)
2220 if (template_string != (char *) NULL && string_to_compare != (char *) NULL &&
2221 strlen (string_to_compare) <= strlen (template_string))
2222 match = (strncmp (template_string,
2224 strlen (string_to_compare)) == 0);
2231 static void pagination_on_command (char *arg, int from_tty);
2233 pagination_on_command (char *arg, int from_tty)
2235 pagination_enabled = 1;
2238 static void pagination_on_command (char *arg, int from_tty);
2240 pagination_off_command (char *arg, int from_tty)
2242 pagination_enabled = 0;
2247 initialize_utils (void)
2249 struct cmd_list_element *c;
2251 c = add_set_cmd ("width", class_support, var_uinteger,
2252 (char *) &chars_per_line,
2253 "Set number of characters gdb thinks are in a line.",
2255 add_show_from_set (c, &showlist);
2256 set_cmd_sfunc (c, set_width_command);
2259 (add_set_cmd ("height", class_support,
2260 var_uinteger, (char *) &lines_per_page,
2261 "Set number of lines gdb thinks are in a page.", &setlist),
2266 /* If the output is not a terminal, don't paginate it. */
2267 if (!ui_file_isatty (gdb_stdout))
2268 lines_per_page = UINT_MAX;
2270 set_width_command ((char *) NULL, 0, c);
2273 (add_set_cmd ("demangle", class_support, var_boolean,
2275 "Set demangling of encoded C++ names when displaying symbols.",
2280 (add_set_cmd ("pagination", class_support,
2281 var_boolean, (char *) &pagination_enabled,
2282 "Set state of pagination.", &setlist),
2287 add_com ("am", class_support, pagination_on_command,
2288 "Enable pagination");
2289 add_com ("sm", class_support, pagination_off_command,
2290 "Disable pagination");
2294 (add_set_cmd ("sevenbit-strings", class_support, var_boolean,
2295 (char *) &sevenbit_strings,
2296 "Set printing of 8-bit characters in strings as \\nnn.",
2301 (add_set_cmd ("asm-demangle", class_support, var_boolean,
2302 (char *) &asm_demangle,
2303 "Set demangling of C++ names in disassembly listings.",
2308 /* Machine specific function to handle SIGWINCH signal. */
2310 #ifdef SIGWINCH_HANDLER_BODY
2311 SIGWINCH_HANDLER_BODY
2314 /* print routines to handle variable size regs, etc. */
2316 /* temporary storage using circular buffer */
2322 static char buf[NUMCELLS][CELLSIZE];
2323 static int cell = 0;
2324 if (++cell >= NUMCELLS)
2332 return (TARGET_ADDR_BIT / 8 * 2);
2336 paddr (CORE_ADDR addr)
2338 return phex (addr, TARGET_ADDR_BIT / 8);
2342 paddr_nz (CORE_ADDR addr)
2344 return phex_nz (addr, TARGET_ADDR_BIT / 8);
2348 decimal2str (char *paddr_str, char *sign, ULONGEST addr)
2350 /* steal code from valprint.c:print_decimal(). Should this worry
2351 about the real size of addr as the above does? */
2352 unsigned long temp[3];
2356 temp[i] = addr % (1000 * 1000 * 1000);
2357 addr /= (1000 * 1000 * 1000);
2360 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
2364 sprintf (paddr_str, "%s%lu",
2368 sprintf (paddr_str, "%s%lu%09lu",
2369 sign, temp[1], temp[0]);
2372 sprintf (paddr_str, "%s%lu%09lu%09lu",
2373 sign, temp[2], temp[1], temp[0]);
2376 internal_error (__FILE__, __LINE__, "failed internal consistency check");
2381 paddr_u (CORE_ADDR addr)
2383 char *paddr_str = get_cell ();
2384 decimal2str (paddr_str, "", addr);
2389 paddr_d (LONGEST addr)
2391 char *paddr_str = get_cell ();
2393 decimal2str (paddr_str, "-", -addr);
2395 decimal2str (paddr_str, "", addr);
2399 /* eliminate warning from compiler on 32-bit systems */
2400 static int thirty_two = 32;
2403 phex (ULONGEST l, int sizeof_l)
2410 sprintf (str, "%08lx%08lx",
2411 (unsigned long) (l >> thirty_two),
2412 (unsigned long) (l & 0xffffffff));
2416 sprintf (str, "%08lx", (unsigned long) l);
2420 sprintf (str, "%04x", (unsigned short) (l & 0xffff));
2423 str = phex (l, sizeof (l));
2430 phex_nz (ULONGEST l, int sizeof_l)
2437 unsigned long high = (unsigned long) (l >> thirty_two);
2440 sprintf (str, "%lx", (unsigned long) (l & 0xffffffff));
2442 sprintf (str, "%lx%08lx",
2443 high, (unsigned long) (l & 0xffffffff));
2448 sprintf (str, "%lx", (unsigned long) l);
2452 sprintf (str, "%x", (unsigned short) (l & 0xffff));
2455 str = phex_nz (l, sizeof (l));
2462 /* Convert to / from the hosts pointer to GDB's internal CORE_ADDR
2463 using the target's conversion routines. */
2465 host_pointer_to_address (void *ptr)
2467 if (sizeof (ptr) != TYPE_LENGTH (builtin_type_void_data_ptr))
2468 internal_error (__FILE__, __LINE__,
2469 "core_addr_to_void_ptr: bad cast");
2470 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr, &ptr);
2474 address_to_host_pointer (CORE_ADDR addr)
2477 if (sizeof (ptr) != TYPE_LENGTH (builtin_type_void_data_ptr))
2478 internal_error (__FILE__, __LINE__,
2479 "core_addr_to_void_ptr: bad cast");
2480 ADDRESS_TO_POINTER (builtin_type_void_data_ptr, &ptr, addr);
2484 /* Convert a CORE_ADDR into a string. */
2486 core_addr_to_string (const CORE_ADDR addr)
2488 char *str = get_cell ();
2490 strcat (str, phex (addr, sizeof (addr)));
2495 core_addr_to_string_nz (const CORE_ADDR addr)
2497 char *str = get_cell ();
2499 strcat (str, phex_nz (addr, sizeof (addr)));
2503 /* Convert a string back into a CORE_ADDR. */
2505 string_to_core_addr (const char *my_string)
2508 if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
2510 /* Assume that it is in decimal. */
2512 for (i = 2; my_string[i] != '\0'; i++)
2514 if (isdigit (my_string[i]))
2515 addr = (my_string[i] - '0') + (addr * 16);
2516 else if (isxdigit (my_string[i]))
2517 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
2519 internal_error (__FILE__, __LINE__, "invalid hex");
2524 /* Assume that it is in decimal. */
2526 for (i = 0; my_string[i] != '\0'; i++)
2528 if (isdigit (my_string[i]))
2529 addr = (my_string[i] - '0') + (addr * 10);
2531 internal_error (__FILE__, __LINE__, "invalid decimal");
2538 gdb_realpath (const char *filename)
2540 #if defined(HAVE_REALPATH)
2541 # if defined (PATH_MAX)
2543 # define USE_REALPATH
2544 # elif defined (MAXPATHLEN)
2545 char buf[MAXPATHLEN];
2546 # define USE_REALPATH
2547 # elif defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2548 char *buf = alloca ((size_t)pathconf ("/", _PC_PATH_MAX));
2549 # define USE_REALPATH
2551 #endif /* HAVE_REALPATH */
2553 #if defined(USE_REALPATH)
2554 char *rp = realpath (filename, buf);
2555 return xstrdup (rp ? rp : filename);
2556 #elif defined(HAVE_CANONICALIZE_FILE_NAME)
2557 return canonicalize_file_name (filename);
2559 return xstrdup (filename);