diff options
Diffstat (limited to 'gdb/utils.c')
| -rw-r--r-- | gdb/utils.c | 2932 |
1 files changed, 2932 insertions, 0 deletions
diff --git a/gdb/utils.c b/gdb/utils.c new file mode 100644 index 00000000000..08b801b9759 --- /dev/null +++ b/gdb/utils.c @@ -0,0 +1,2932 @@ +/* General utility routines for GDB, the GNU debugger. + Copyright 1986, 89, 90, 91, 92, 95, 96, 1998 Free Software Foundation, Inc. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "defs.h" +#include <ctype.h> +#include "gdb_string.h" +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif + +#ifdef HAVE_CURSES_H +#include <curses.h> +#endif +#ifdef HAVE_TERM_H +#include <term.h> +#endif + +/* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */ +#ifdef reg +#undef reg +#endif + +#include "signals.h" +#include "gdbcmd.h" +#include "serial.h" +#include "bfd.h" +#include "target.h" +#include "demangle.h" +#include "expression.h" +#include "language.h" +#include "annotate.h" + +#include <readline/readline.h> + +/* readline defines this. */ +#undef savestring + +void (*error_begin_hook) PARAMS ((void)); + +/* Prototypes for local functions */ + +static void vfprintf_maybe_filtered PARAMS ((GDB_FILE *, const char *, + va_list, int)); + +static void fputs_maybe_filtered PARAMS ((const char *, GDB_FILE *, int)); + +#if defined (USE_MMALLOC) && !defined (NO_MMCHECK) +static void malloc_botch PARAMS ((void)); +#endif + +static void +fatal_dump_core PARAMS((char *, ...)); + +static void +prompt_for_continue PARAMS ((void)); + +static void +set_width_command PARAMS ((char *, int, struct cmd_list_element *)); + +static void +set_width PARAMS ((void)); + +/* If this definition isn't overridden by the header files, assume + that isatty and fileno exist on this system. */ +#ifndef ISATTY +#define ISATTY(FP) (isatty (fileno (FP))) +#endif + +#ifndef GDB_FILE_ISATTY +#define GDB_FILE_ISATTY(GDB_FILE_PTR) (gdb_file_isatty(GDB_FILE_PTR)) +#endif + +/* Chain of cleanup actions established with make_cleanup, + to be executed if an error happens. */ + +static struct cleanup *cleanup_chain; /* cleaned up after a failed command */ +static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */ +static struct cleanup *run_cleanup_chain; /* cleaned up on each 'run' */ + +/* Nonzero if we have job control. */ + +int job_control; + +/* Nonzero means a quit has been requested. */ + +int quit_flag; + +/* Nonzero means quit immediately if Control-C is typed now, rather + than waiting until QUIT is executed. Be careful in setting this; + code which executes with immediate_quit set has to be very careful + about being able to deal with being interrupted at any time. It is + almost always better to use QUIT; the only exception I can think of + is being able to quit out of a system call (using EINTR loses if + the SIGINT happens between the previous QUIT and the system call). + To immediately quit in the case in which a SIGINT happens between + the previous QUIT and setting immediate_quit (desirable anytime we + expect to block), call QUIT after setting immediate_quit. */ + +int immediate_quit; + +/* Nonzero means that encoded C++ names should be printed out in their + C++ form rather than raw. */ + +int demangle = 1; + +/* Nonzero means that encoded C++ names should be printed out in their + C++ form even in assembler language displays. If this is set, but + DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */ + +int asm_demangle = 0; + +/* Nonzero means that strings with character values >0x7F should be printed + as octal escapes. Zero means just print the value (e.g. it's an + international character, and the terminal or window can cope.) */ + +int sevenbit_strings = 0; + +/* String to be printed before error messages, if any. */ + +char *error_pre_print; + +/* String to be printed before quit messages, if any. */ + +char *quit_pre_print; + +/* String to be printed before warning messages, if any. */ + +char *warning_pre_print = "\nwarning: "; + +int pagination_enabled = 1; + + +/* Add a new cleanup to the cleanup_chain, + and return the previous chain pointer + to be passed later to do_cleanups or discard_cleanups. + Args are FUNCTION to clean up with, and ARG to pass to it. */ + +struct cleanup * +make_cleanup (function, arg) + void (*function) PARAMS ((PTR)); + PTR arg; +{ + return make_my_cleanup (&cleanup_chain, function, arg); +} + +struct cleanup * +make_final_cleanup (function, arg) + void (*function) PARAMS ((PTR)); + PTR arg; +{ + return make_my_cleanup (&final_cleanup_chain, function, arg); +} +struct cleanup * +make_run_cleanup (function, arg) + void (*function) PARAMS ((PTR)); + PTR arg; +{ + return make_my_cleanup (&run_cleanup_chain, function, arg); +} +struct cleanup * +make_my_cleanup (pmy_chain, function, arg) + struct cleanup **pmy_chain; + void (*function) PARAMS ((PTR)); + PTR arg; +{ + register struct cleanup *new + = (struct cleanup *) xmalloc (sizeof (struct cleanup)); + register struct cleanup *old_chain = *pmy_chain; + + new->next = *pmy_chain; + new->function = function; + new->arg = arg; + *pmy_chain = new; + + return old_chain; +} + +/* Discard cleanups and do the actions they describe + until we get back to the point OLD_CHAIN in the cleanup_chain. */ + +void +do_cleanups (old_chain) + register struct cleanup *old_chain; +{ + do_my_cleanups (&cleanup_chain, old_chain); +} + +void +do_final_cleanups (old_chain) + register struct cleanup *old_chain; +{ + do_my_cleanups (&final_cleanup_chain, old_chain); +} + +void +do_run_cleanups (old_chain) + register struct cleanup *old_chain; +{ + do_my_cleanups (&run_cleanup_chain, old_chain); +} + +void +do_my_cleanups (pmy_chain, old_chain) + register struct cleanup **pmy_chain; + register struct cleanup *old_chain; +{ + register struct cleanup *ptr; + while ((ptr = *pmy_chain) != old_chain) + { + *pmy_chain = ptr->next; /* Do this first incase recursion */ + (*ptr->function) (ptr->arg); + free (ptr); + } +} + +/* Discard cleanups, not doing the actions they describe, + until we get back to the point OLD_CHAIN in the cleanup_chain. */ + +void +discard_cleanups (old_chain) + register struct cleanup *old_chain; +{ + discard_my_cleanups (&cleanup_chain, old_chain); +} + +void +discard_final_cleanups (old_chain) + register struct cleanup *old_chain; +{ + discard_my_cleanups (&final_cleanup_chain, old_chain); +} + +void +discard_my_cleanups (pmy_chain, old_chain) + register struct cleanup **pmy_chain; + register struct cleanup *old_chain; +{ + register struct cleanup *ptr; + while ((ptr = *pmy_chain) != old_chain) + { + *pmy_chain = ptr->next; + free ((PTR)ptr); + } +} + +/* Set the cleanup_chain to 0, and return the old cleanup chain. */ +struct cleanup * +save_cleanups () +{ + return save_my_cleanups (&cleanup_chain); +} + +struct cleanup * +save_final_cleanups () +{ + return save_my_cleanups (&final_cleanup_chain); +} + +struct cleanup * +save_my_cleanups (pmy_chain) + struct cleanup **pmy_chain; +{ + struct cleanup *old_chain = *pmy_chain; + + *pmy_chain = 0; + return old_chain; +} + +/* Restore the cleanup chain from a previously saved chain. */ +void +restore_cleanups (chain) + struct cleanup *chain; +{ + restore_my_cleanups (&cleanup_chain, chain); +} + +void +restore_final_cleanups (chain) + struct cleanup *chain; +{ + restore_my_cleanups (&final_cleanup_chain, chain); +} + +void +restore_my_cleanups (pmy_chain, chain) + struct cleanup **pmy_chain; + struct cleanup *chain; +{ + *pmy_chain = chain; +} + +/* This function is useful for cleanups. + Do + + foo = xmalloc (...); + old_chain = make_cleanup (free_current_contents, &foo); + + to arrange to free the object thus allocated. */ + +void +free_current_contents (location) + char **location; +{ + free (*location); +} + +/* Provide a known function that does nothing, to use as a base for + for a possibly long chain of cleanups. This is useful where we + use the cleanup chain for handling normal cleanups as well as dealing + with cleanups that need to be done as a result of a call to error(). + In such cases, we may not be certain where the first cleanup is, unless + we have a do-nothing one to always use as the base. */ + +/* ARGSUSED */ +void +null_cleanup (arg) + PTR arg; +{ +} + + +/* Print a warning message. Way to use this is to call warning_begin, + output the warning message (use unfiltered output to gdb_stderr), + ending in a newline. There is not currently a warning_end that you + call afterwards, but such a thing might be added if it is useful + for a GUI to separate warning messages from other output. + + FIXME: Why do warnings use unfiltered output and errors filtered? + Is this anything other than a historical accident? */ + +void +warning_begin () +{ + target_terminal_ours (); + wrap_here(""); /* Force out any buffered output */ + gdb_flush (gdb_stdout); + if (warning_pre_print) + fprintf_unfiltered (gdb_stderr, warning_pre_print); +} + +/* Print a warning message. + The first argument STRING is the warning message, used as a fprintf string, + and the remaining args are passed as arguments to it. + The primary difference between warnings and errors is that a warning + does not force the return to command level. */ + +/* VARARGS */ +void +#ifdef ANSI_PROTOTYPES +warning (const char *string, ...) +#else +warning (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, string); +#else + char *string; + + va_start (args); + string = va_arg (args, char *); +#endif + if (warning_hook) + (*warning_hook) (string, args); + else + { + warning_begin (); + vfprintf_unfiltered (gdb_stderr, string, args); + fprintf_unfiltered (gdb_stderr, "\n"); + va_end (args); + } +} + +/* Start the printing of an error message. Way to use this is to call + this, output the error message (use filtered output to gdb_stderr + (FIXME: Some callers, like memory_error, use gdb_stdout)), ending + in a newline, and then call return_to_top_level (RETURN_ERROR). + error() provides a convenient way to do this for the special case + that the error message can be formatted with a single printf call, + but this is more general. */ +void +error_begin () +{ + if (error_begin_hook) + error_begin_hook (); + + target_terminal_ours (); + wrap_here (""); /* Force out any buffered output */ + gdb_flush (gdb_stdout); + + annotate_error_begin (); + + if (error_pre_print) + fprintf_filtered (gdb_stderr, error_pre_print); +} + +/* Print an error message and return to command level. + The first argument STRING is the error message, used as a fprintf string, + and the remaining args are passed as arguments to it. */ + +/* VARARGS */ +NORETURN void +#ifdef ANSI_PROTOTYPES +error (const char *string, ...) +#else +error (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, string); +#else + va_start (args); +#endif + if (error_hook) + (*error_hook) (); + else + { + error_begin (); +#ifdef ANSI_PROTOTYPES + vfprintf_filtered (gdb_stderr, string, args); +#else + { + char *string1; + + string1 = va_arg (args, char *); + vfprintf_filtered (gdb_stderr, string1, args); + } +#endif + fprintf_filtered (gdb_stderr, "\n"); + va_end (args); + return_to_top_level (RETURN_ERROR); + } +} + + +/* Print an error message and exit reporting failure. + This is for a error that we cannot continue from. + The arguments are printed a la printf. + + This function cannot be declared volatile (NORETURN) in an + ANSI environment because exit() is not declared volatile. */ + +/* VARARGS */ +NORETURN void +#ifdef ANSI_PROTOTYPES +fatal (char *string, ...) +#else +fatal (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, string); +#else + char *string; + va_start (args); + string = va_arg (args, char *); +#endif + fprintf_unfiltered (gdb_stderr, "\ngdb: "); + vfprintf_unfiltered (gdb_stderr, string, args); + fprintf_unfiltered (gdb_stderr, "\n"); + va_end (args); + exit (1); +} + +/* Print an error message and exit, dumping core. + The arguments are printed a la printf (). */ + +/* VARARGS */ +static void +#ifdef ANSI_PROTOTYPES +fatal_dump_core (char *string, ...) +#else +fatal_dump_core (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, string); +#else + char *string; + + va_start (args); + string = va_arg (args, char *); +#endif + /* "internal error" is always correct, since GDB should never dump + core, no matter what the input. */ + fprintf_unfiltered (gdb_stderr, "\ngdb internal error: "); + vfprintf_unfiltered (gdb_stderr, string, args); + fprintf_unfiltered (gdb_stderr, "\n"); + va_end (args); + + signal (SIGQUIT, SIG_DFL); + kill (getpid (), SIGQUIT); + /* We should never get here, but just in case... */ + exit (1); +} + +/* The strerror() function can return NULL for errno values that are + out of range. Provide a "safe" version that always returns a + printable string. */ + +char * +safe_strerror (errnum) + int errnum; +{ + char *msg; + static char buf[32]; + + if ((msg = strerror (errnum)) == NULL) + { + sprintf (buf, "(undocumented errno %d)", errnum); + msg = buf; + } + return (msg); +} + +/* The strsignal() function can return NULL for signal values that are + out of range. Provide a "safe" version that always returns a + printable string. */ + +char * +safe_strsignal (signo) + int signo; +{ + char *msg; + static char buf[32]; + + if ((msg = strsignal (signo)) == NULL) + { + sprintf (buf, "(undocumented signal %d)", signo); + msg = buf; + } + return (msg); +} + + +/* Print the system error message for errno, and also mention STRING + as the file name for which the error was encountered. + Then return to command level. */ + +NORETURN void +perror_with_name (string) + char *string; +{ + char *err; + char *combined; + + err = safe_strerror (errno); + combined = (char *) alloca (strlen (err) + strlen (string) + 3); + strcpy (combined, string); + strcat (combined, ": "); + strcat (combined, err); + + /* I understand setting these is a matter of taste. Still, some people + may clear errno but not know about bfd_error. Doing this here is not + unreasonable. */ + bfd_set_error (bfd_error_no_error); + errno = 0; + + error ("%s.", combined); +} + +/* Print the system error message for ERRCODE, and also mention STRING + as the file name for which the error was encountered. */ + +void +print_sys_errmsg (string, errcode) + char *string; + int errcode; +{ + char *err; + char *combined; + + err = safe_strerror (errcode); + combined = (char *) alloca (strlen (err) + strlen (string) + 3); + strcpy (combined, string); + strcat (combined, ": "); + strcat (combined, err); + + /* We want anything which was printed on stdout to come out first, before + this message. */ + gdb_flush (gdb_stdout); + fprintf_unfiltered (gdb_stderr, "%s.\n", combined); +} + +/* Control C eventually causes this to be called, at a convenient time. */ + +void +quit () +{ + serial_t gdb_stdout_serial = serial_fdopen (1); + + target_terminal_ours (); + + /* We want all output to appear now, before we print "Quit". We + have 3 levels of buffering we have to flush (it's possible that + some of these should be changed to flush the lower-level ones + too): */ + + /* 1. The _filtered buffer. */ + wrap_here ((char *)0); + + /* 2. The stdio buffer. */ + gdb_flush (gdb_stdout); + gdb_flush (gdb_stderr); + + /* 3. The system-level buffer. */ + SERIAL_DRAIN_OUTPUT (gdb_stdout_serial); + SERIAL_UN_FDOPEN (gdb_stdout_serial); + + annotate_error_begin (); + + /* Don't use *_filtered; we don't want to prompt the user to continue. */ + if (quit_pre_print) + fprintf_unfiltered (gdb_stderr, quit_pre_print); + + if (job_control + /* If there is no terminal switching for this target, then we can't + possibly get screwed by the lack of job control. */ + || current_target.to_terminal_ours == NULL) + fprintf_unfiltered (gdb_stderr, "Quit\n"); + else + fprintf_unfiltered (gdb_stderr, + "Quit (expect signal SIGINT when the program is resumed)\n"); + return_to_top_level (RETURN_QUIT); +} + + +#if defined(__GO32__) + +/* In the absence of signals, poll keyboard for a quit. + Called from #define QUIT pollquit() in xm-go32.h. */ + +void +notice_quit() +{ + if (kbhit ()) + switch (getkey ()) + { + case 1: + quit_flag = 1; + break; + case 2: + immediate_quit = 2; + break; + default: + /* We just ignore it */ + /* FIXME!! Don't think this actually works! */ + fprintf_unfiltered (gdb_stderr, "CTRL-A to quit, CTRL-B to quit harder\n"); + break; + } +} + +#elif defined(_MSC_VER) /* should test for wingdb instead? */ + +/* + * Windows translates all keyboard and mouse events + * into a message which is appended to the message + * queue for the process. + */ + +void notice_quit() +{ + int k = win32pollquit(); + if (k == 1) + quit_flag = 1; + else if (k == 2) + immediate_quit = 1; +} + +#else /* !defined(__GO32__) && !defined(_MSC_VER) */ + +void notice_quit() +{ + /* Done by signals */ +} + +#endif /* !defined(__GO32__) && !defined(_MSC_VER) */ + +void +pollquit() +{ + notice_quit (); + if (quit_flag || immediate_quit) + quit (); +} + +/* Control C comes here */ + +void +request_quit (signo) + int signo; +{ + quit_flag = 1; + /* Restore the signal handler. Harmless with BSD-style signals, needed + for System V-style signals. So just always do it, rather than worrying + about USG defines and stuff like that. */ + signal (signo, request_quit); + +#ifdef REQUEST_QUIT + REQUEST_QUIT; +#else + if (immediate_quit) + quit (); +#endif +} + + +/* Memory management stuff (malloc friends). */ + +/* Make a substitute size_t for non-ANSI compilers. */ + +#ifndef HAVE_STDDEF_H +#ifndef size_t +#define size_t unsigned int +#endif +#endif + +#if !defined (USE_MMALLOC) + +PTR +mmalloc (md, size) + PTR md; + size_t size; +{ + return malloc (size); +} + +PTR +mrealloc (md, ptr, size) + PTR md; + PTR ptr; + size_t size; +{ + if (ptr == 0) /* Guard against old realloc's */ + return malloc (size); + else + return realloc (ptr, size); +} + +void +mfree (md, ptr) + PTR md; + PTR ptr; +{ + free (ptr); +} + +#endif /* USE_MMALLOC */ + +#if !defined (USE_MMALLOC) || defined (NO_MMCHECK) + +void +init_malloc (md) + PTR md; +{ +} + +#else /* Have mmalloc and want corruption checking */ + +static void +malloc_botch () +{ + fatal_dump_core ("Memory corruption"); +} + +/* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified + by MD, to detect memory corruption. Note that MD may be NULL to specify + the default heap that grows via sbrk. + + Note that for freshly created regions, we must call mmcheckf prior to any + mallocs in the region. Otherwise, any region which was allocated prior to + installing the checking hooks, which is later reallocated or freed, will + fail the checks! The mmcheck function only allows initial hooks to be + installed before the first mmalloc. However, anytime after we have called + mmcheck the first time to install the checking hooks, we can call it again + to update the function pointer to the memory corruption handler. + + Returns zero on failure, non-zero on success. */ + +#ifndef MMCHECK_FORCE +#define MMCHECK_FORCE 0 +#endif + +void +init_malloc (md) + PTR md; +{ + if (!mmcheckf (md, malloc_botch, MMCHECK_FORCE)) + { + /* Don't use warning(), which relies on current_target being set + to something other than dummy_target, until after + initialize_all_files(). */ + + fprintf_unfiltered + (gdb_stderr, "warning: failed to install memory consistency checks; "); + fprintf_unfiltered + (gdb_stderr, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n"); + } + + mmtrace (); +} + +#endif /* Have mmalloc and want corruption checking */ + +/* Called when a memory allocation fails, with the number of bytes of + memory requested in SIZE. */ + +NORETURN void +nomem (size) + long size; +{ + if (size > 0) + { + fatal ("virtual memory exhausted: can't allocate %ld bytes.", size); + } + else + { + fatal ("virtual memory exhausted."); + } +} + +/* Like mmalloc but get error if no storage available, and protect against + the caller wanting to allocate zero bytes. Whether to return NULL for + a zero byte request, or translate the request into a request for one + byte of zero'd storage, is a religious issue. */ + +PTR +xmmalloc (md, size) + PTR md; + long size; +{ + register PTR val; + + if (size == 0) + { + val = NULL; + } + else if ((val = mmalloc (md, size)) == NULL) + { + nomem (size); + } + return (val); +} + +/* Like mrealloc but get error if no storage available. */ + +PTR +xmrealloc (md, ptr, size) + PTR md; + PTR ptr; + long size; +{ + register PTR val; + + if (ptr != NULL) + { + val = mrealloc (md, ptr, size); + } + else + { + val = mmalloc (md, size); + } + if (val == NULL) + { + nomem (size); + } + return (val); +} + +/* Like malloc but get error if no storage available, and protect against + the caller wanting to allocate zero bytes. */ + +PTR +xmalloc (size) + size_t size; +{ + return (xmmalloc ((PTR) NULL, size)); +} + +/* Like mrealloc but get error if no storage available. */ + +PTR +xrealloc (ptr, size) + PTR ptr; + size_t size; +{ + return (xmrealloc ((PTR) NULL, ptr, size)); +} + + +/* My replacement for the read system call. + Used like `read' but keeps going if `read' returns too soon. */ + +int +myread (desc, addr, len) + int desc; + char *addr; + int len; +{ + register int val; + int orglen = len; + + while (len > 0) + { + val = read (desc, addr, len); + if (val < 0) + return val; + if (val == 0) + return orglen - len; + len -= val; + addr += val; + } + return orglen; +} + +/* Make a copy of the string at PTR with SIZE characters + (and add a null character at the end in the copy). + Uses malloc to get the space. Returns the address of the copy. */ + +char * +savestring (ptr, size) + const char *ptr; + int size; +{ + register char *p = (char *) xmalloc (size + 1); + memcpy (p, ptr, size); + p[size] = 0; + return p; +} + +char * +msavestring (md, ptr, size) + PTR md; + const char *ptr; + int size; +{ + register char *p = (char *) xmmalloc (md, size + 1); + memcpy (p, ptr, size); + p[size] = 0; + return p; +} + +/* The "const" is so it compiles under DGUX (which prototypes strsave + in <string.h>. FIXME: This should be named "xstrsave", shouldn't it? + Doesn't real strsave return NULL if out of memory? */ +char * +strsave (ptr) + const char *ptr; +{ + return savestring (ptr, strlen (ptr)); +} + +char * +mstrsave (md, ptr) + PTR md; + const char *ptr; +{ + return (msavestring (md, ptr, strlen (ptr))); +} + +void +print_spaces (n, file) + register int n; + register GDB_FILE *file; +{ + if (file->ts_streamtype == astring) + { + char *p; + + gdb_file_adjust_strbuf (n, file); + p = file->ts_strbuf + strlen (file->ts_strbuf); + + memset (p, ' ', n); + p[n] = '\000'; + } + else + { + while (n-- > 0) + fputc (' ', file->ts_filestream); + } +} + +/* Print a host address. */ + +void +gdb_print_address (addr, stream) + PTR addr; + GDB_FILE *stream; +{ + + /* We could use the %p conversion specifier to fprintf if we had any + way of knowing whether this host supports it. But the following + should work on the Alpha and on 32 bit machines. */ + + fprintf_filtered (stream, "0x%lx", (unsigned long)addr); +} + +/* Ask user a y-or-n question and return 1 iff answer is yes. + Takes three args which are given to printf to print the question. + The first, a control string, should end in "? ". + It should not say how to answer, because we do that. */ + +/* VARARGS */ +int +#ifdef ANSI_PROTOTYPES +query (char *ctlstr, ...) +#else +query (va_alist) + va_dcl +#endif +{ + va_list args; + register int answer; + register int ans2; + int retval; + +#ifdef ANSI_PROTOTYPES + va_start (args, ctlstr); +#else + char *ctlstr; + va_start (args); + ctlstr = va_arg (args, char *); +#endif + + if (query_hook) + { + return query_hook (ctlstr, args); + } + + /* Automatically answer "yes" if input is not from a terminal. */ + if (!input_from_terminal_p ()) + return 1; +#ifdef MPW + /* FIXME Automatically answer "yes" if called from MacGDB. */ + if (mac_app) + return 1; +#endif /* MPW */ + + while (1) + { + wrap_here (""); /* Flush any buffered output */ + gdb_flush (gdb_stdout); + + if (annotation_level > 1) + printf_filtered ("\n\032\032pre-query\n"); + + vfprintf_filtered (gdb_stdout, ctlstr, args); + printf_filtered ("(y or n) "); + + if (annotation_level > 1) + printf_filtered ("\n\032\032query\n"); + +#ifdef MPW + /* If not in MacGDB, move to a new line so the entered line doesn't + have a prompt on the front of it. */ + if (!mac_app) + fputs_unfiltered ("\n", gdb_stdout); +#endif /* MPW */ + + wrap_here(""); + gdb_flush (gdb_stdout); + +#if defined(TUI) + if (!tui_version || cmdWin == tuiWinWithFocus()) +#endif + answer = fgetc (stdin); +#if defined(TUI) + else + + answer = (unsigned char)tuiBufferGetc(); + +#endif + clearerr (stdin); /* in case of C-d */ + if (answer == EOF) /* C-d */ + { + retval = 1; + break; + } + /* Eat rest of input line, to EOF or newline */ + if ((answer != '\n') || (tui_version && answer != '\r')) + do + { +#if defined(TUI) + if (!tui_version || cmdWin == tuiWinWithFocus()) +#endif + ans2 = fgetc (stdin); +#if defined(TUI) + else + + ans2 = (unsigned char)tuiBufferGetc(); +#endif + clearerr (stdin); + } + while (ans2 != EOF && ans2 != '\n' && ans2 != '\r'); + TUIDO(((TuiOpaqueFuncPtr)tui_vStartNewLines, 1)); + + if (answer >= 'a') + answer -= 040; + if (answer == 'Y') + { + retval = 1; + break; + } + if (answer == 'N') + { + retval = 0; + break; + } + printf_filtered ("Please answer y or n.\n"); + } + + if (annotation_level > 1) + printf_filtered ("\n\032\032post-query\n"); + return retval; +} + + +/* Parse a C escape sequence. STRING_PTR points to a variable + containing a pointer to the string to parse. That pointer + should point to the character after the \. That pointer + is updated past the characters we use. The value of the + escape sequence is returned. + + A negative value means the sequence \ newline was seen, + which is supposed to be equivalent to nothing at all. + + If \ is followed by a null character, we return a negative + value and leave the string pointer pointing at the null character. + + If \ is followed by 000, we return 0 and leave the string pointer + after the zeros. A value of 0 does not mean end of string. */ + +int +parse_escape (string_ptr) + char **string_ptr; +{ + register int c = *(*string_ptr)++; + switch (c) + { + case 'a': + return 007; /* Bell (alert) char */ + case 'b': + return '\b'; + case 'e': /* Escape character */ + return 033; + case 'f': + return '\f'; + case 'n': + return '\n'; + case 'r': + return '\r'; + case 't': + return '\t'; + case 'v': + return '\v'; + case '\n': + return -2; + case 0: + (*string_ptr)--; + return 0; + case '^': + c = *(*string_ptr)++; + if (c == '\\') + c = parse_escape (string_ptr); + if (c == '?') + return 0177; + return (c & 0200) | (c & 037); + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + register int i = c - '0'; + register int count = 0; + while (++count < 3) + { + if ((c = *(*string_ptr)++) >= '0' && c <= '7') + { + i *= 8; + i += c - '0'; + } + else + { + (*string_ptr)--; + break; + } + } + return i; + } + default: + return c; + } +} + +/* Print the character C on STREAM as part of the contents of a literal + string whose delimiter is QUOTER. Note that this routine should only + be call for printing things which are independent of the language + of the program being debugged. */ + +void +gdb_printchar (c, stream, quoter) + register int c; + GDB_FILE *stream; + int quoter; +{ + + c &= 0xFF; /* Avoid sign bit follies */ + + if ( c < 0x20 || /* Low control chars */ + (c >= 0x7F && c < 0xA0) || /* DEL, High controls */ + (sevenbit_strings && c >= 0x80)) { /* high order bit set */ + switch (c) + { + case '\n': + fputs_filtered ("\\n", stream); + break; + case '\b': + fputs_filtered ("\\b", stream); + break; + case '\t': + fputs_filtered ("\\t", stream); + break; + case '\f': + fputs_filtered ("\\f", stream); + break; + case '\r': + fputs_filtered ("\\r", stream); + break; + case '\033': + fputs_filtered ("\\e", stream); + break; + case '\007': + fputs_filtered ("\\a", stream); + break; + default: + fprintf_filtered (stream, "\\%.3o", (unsigned int) c); + break; + } + } else { + if (c == '\\' || c == quoter) + fputs_filtered ("\\", stream); + fprintf_filtered (stream, "%c", c); + } +} + + + + +static char * hexlate = "0123456789abcdef" ; +int fmthex(inbuf,outbuff,length,linelength) + unsigned char * inbuf ; + unsigned char * outbuff; + int length; + int linelength; +{ + unsigned char byte , nib ; + int outlength = 0 ; + + while (length) + { + if (outlength >= linelength) break ; + byte = *inbuf ; + inbuf++ ; + nib = byte >> 4 ; + *outbuff++ = hexlate[nib] ; + nib = byte &0x0f ; + *outbuff++ = hexlate[nib] ; + *outbuff++ = ' ' ; + length-- ; + outlength += 3 ; + } + *outbuff = '\0' ; /* null terminate our output line */ + return outlength ; +} + + +/* Number of lines per page or UINT_MAX if paging is disabled. */ +static unsigned int lines_per_page; +/* Number of chars per line or UNIT_MAX is line folding is disabled. */ +static unsigned int chars_per_line; +/* Current count of lines printed on this page, chars on this line. */ +static unsigned int lines_printed, chars_printed; + +/* Buffer and start column of buffered text, for doing smarter word- + wrapping. When someone calls wrap_here(), we start buffering output + that comes through fputs_filtered(). If we see a newline, we just + spit it out and forget about the wrap_here(). If we see another + wrap_here(), we spit it out and remember the newer one. If we see + the end of the line, we spit out a newline, the indent, and then + the buffered output. */ + +/* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which + are waiting to be output (they have already been counted in chars_printed). + When wrap_buffer[0] is null, the buffer is empty. */ +static char *wrap_buffer; + +/* Pointer in wrap_buffer to the next character to fill. */ +static char *wrap_pointer; + +/* String to indent by if the wrap occurs. Must not be NULL if wrap_column + is non-zero. */ +static char *wrap_indent; + +/* Column number on the screen where wrap_buffer begins, or 0 if wrapping + is not in effect. */ +static int wrap_column; + + +/* Inialize the lines and chars per page */ +void +init_page_info() +{ +#if defined(TUI) + if (tui_version && m_winPtrNotNull(cmdWin)) + { + lines_per_page = cmdWin->generic.height; + chars_per_line = cmdWin->generic.width; + } + else +#endif + { + /* These defaults will be used if we are unable to get the correct + values from termcap. */ +#if defined(__GO32__) + lines_per_page = ScreenRows(); + chars_per_line = ScreenCols(); +#else + lines_per_page = 24; + chars_per_line = 80; + +#if !defined (MPW) && !defined (_WIN32) + /* No termcap under MPW, although might be cool to do something + by looking at worksheet or console window sizes. */ + /* Initialize the screen height and width from termcap. */ + { + char *termtype = getenv ("TERM"); + + /* Positive means success, nonpositive means failure. */ + int status; + + /* 2048 is large enough for all known terminals, according to the + GNU termcap manual. */ + char term_buffer[2048]; + + if (termtype) + { + status = tgetent (term_buffer, termtype); + if (status > 0) + { + int val; + int running_in_emacs = getenv ("EMACS") != NULL; + + val = tgetnum ("li"); + if (val >= 0 && !running_in_emacs) + lines_per_page = val; + else + /* The number of lines per page is not mentioned + in the terminal description. This probably means + that paging is not useful (e.g. emacs shell window), + so disable paging. */ + lines_per_page = UINT_MAX; + + val = tgetnum ("co"); + if (val >= 0) + chars_per_line = val; + } + } + } +#endif /* MPW */ + +#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER) + + /* If there is a better way to determine the window size, use it. */ + SIGWINCH_HANDLER (SIGWINCH); +#endif +#endif + /* If the output is not a terminal, don't paginate it. */ + if (!GDB_FILE_ISATTY (gdb_stdout)) + lines_per_page = UINT_MAX; + } /* the command_line_version */ + set_width(); +} + +static void +set_width() +{ + if (chars_per_line == 0) + init_page_info(); + + if (!wrap_buffer) + { + wrap_buffer = (char *) xmalloc (chars_per_line + 2); + wrap_buffer[0] = '\0'; + } + else + wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2); + wrap_pointer = wrap_buffer; /* Start it at the beginning */ +} + +/* ARGSUSED */ +static void +set_width_command (args, from_tty, c) + char *args; + int from_tty; + struct cmd_list_element *c; +{ + set_width (); +} + +/* Wait, so the user can read what's on the screen. Prompt the user + to continue by pressing RETURN. */ + +static void +prompt_for_continue () +{ + char *ignore; + char cont_prompt[120]; + + if (annotation_level > 1) + printf_unfiltered ("\n\032\032pre-prompt-for-continue\n"); + + strcpy (cont_prompt, + "---Type <return> to continue, or q <return> to quit---"); + if (annotation_level > 1) + strcat (cont_prompt, "\n\032\032prompt-for-continue\n"); + + /* We must do this *before* we call gdb_readline, else it will eventually + call us -- thinking that we're trying to print beyond the end of the + screen. */ + reinitialize_more_filter (); + + immediate_quit++; + /* On a real operating system, the user can quit with SIGINT. + But not on GO32. + + 'q' is provided on all systems so users don't have to change habits + from system to system, and because telling them what to do in + the prompt is more user-friendly than expecting them to think of + SIGINT. */ + /* Call readline, not gdb_readline, because GO32 readline handles control-C + whereas control-C to gdb_readline will cause the user to get dumped + out to DOS. */ + ignore = readline (cont_prompt); + + if (annotation_level > 1) + printf_unfiltered ("\n\032\032post-prompt-for-continue\n"); + + if (ignore) + { + char *p = ignore; + while (*p == ' ' || *p == '\t') + ++p; + if (p[0] == 'q') + request_quit (SIGINT); + free (ignore); + } + immediate_quit--; + + /* Now we have to do this again, so that GDB will know that it doesn't + need to save the ---Type <return>--- line at the top of the screen. */ + reinitialize_more_filter (); + + dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */ +} + +/* Reinitialize filter; ie. tell it to reset to original values. */ + +void +reinitialize_more_filter () +{ + lines_printed = 0; + chars_printed = 0; +} + +/* Indicate that if the next sequence of characters overflows the line, + a newline should be inserted here rather than when it hits the end. + If INDENT is non-null, it is a string to be printed to indent the + wrapped part on the next line. INDENT must remain accessible until + the next call to wrap_here() or until a newline is printed through + fputs_filtered(). + + If the line is already overfull, we immediately print a newline and + the indentation, and disable further wrapping. + + If we don't know the width of lines, but we know the page height, + we must not wrap words, but should still keep track of newlines + that were explicitly printed. + + INDENT should not contain tabs, as that will mess up the char count + on the next line. FIXME. + + This routine is guaranteed to force out any output which has been + squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be + used to force out output from the wrap_buffer. */ + +void +wrap_here(indent) + char *indent; +{ + /* This should have been allocated, but be paranoid anyway. */ + if (!wrap_buffer) + abort (); + + if (wrap_buffer[0]) + { + *wrap_pointer = '\0'; + fputs_unfiltered (wrap_buffer, gdb_stdout); + } + wrap_pointer = wrap_buffer; + wrap_buffer[0] = '\0'; + if (chars_per_line == UINT_MAX) /* No line overflow checking */ + { + wrap_column = 0; + } + else if (chars_printed >= chars_per_line) + { + puts_filtered ("\n"); + if (indent != NULL) + puts_filtered (indent); + wrap_column = 0; + } + else + { + wrap_column = chars_printed; + if (indent == NULL) + wrap_indent = ""; + else + wrap_indent = indent; + } +} + +/* Ensure that whatever gets printed next, using the filtered output + commands, starts at the beginning of the line. I.E. if there is + any pending output for the current line, flush it and start a new + line. Otherwise do nothing. */ + +void +begin_line () +{ + if (chars_printed > 0) + { + puts_filtered ("\n"); + } +} + +int +gdb_file_isatty (stream) + GDB_FILE *stream; +{ + + if (stream->ts_streamtype == afile) + return (isatty(fileno(stream->ts_filestream))); + else return 0; +} + +GDB_FILE * +gdb_file_init_astring (n) + int n; +{ + GDB_FILE *tmpstream; + + tmpstream = xmalloc (sizeof(GDB_FILE)); + tmpstream->ts_streamtype = astring; + tmpstream->ts_filestream = NULL; + if (n > 0) + { + tmpstream->ts_strbuf = xmalloc ((n + 1)*sizeof(char)); + tmpstream->ts_strbuf[0] = '\0'; + } + else + tmpstream->ts_strbuf = NULL; + tmpstream->ts_buflen = n; + + return tmpstream; +} + +void +gdb_file_deallocate (streamptr) + GDB_FILE **streamptr; +{ + GDB_FILE *tmpstream; + + tmpstream = *streamptr; + if ((tmpstream->ts_streamtype == astring) && + (tmpstream->ts_strbuf != NULL)) + { + free (tmpstream->ts_strbuf); + } + + free (tmpstream); + *streamptr = NULL; +} + +char * +gdb_file_get_strbuf (stream) + GDB_FILE *stream; +{ + return (stream->ts_strbuf); +} + +/* adjust the length of the buffer by the amount necessary + to accomodate appending a string of length N to the buffer contents */ +void +gdb_file_adjust_strbuf (n, stream) + int n; + GDB_FILE *stream; +{ + int non_null_chars; + + non_null_chars = strlen(stream->ts_strbuf); + + if (n > (stream->ts_buflen - non_null_chars - 1)) + { + stream->ts_buflen = n + non_null_chars + 1; + stream->ts_strbuf = xrealloc (stream->ts_strbuf, stream->ts_buflen); + } +} + +GDB_FILE * +gdb_fopen (name, mode) + char * name; + char * mode; +{ + int gdb_file_size; + GDB_FILE *tmp; + + gdb_file_size = sizeof(GDB_FILE); + tmp = (GDB_FILE *) xmalloc (gdb_file_size); + tmp->ts_streamtype = afile; + tmp->ts_filestream = fopen (name, mode); + tmp->ts_strbuf = NULL; + tmp->ts_buflen = 0; + + return tmp; +} + +void +gdb_flush (stream) + GDB_FILE *stream; +{ + if (flush_hook + && (stream == gdb_stdout + || stream == gdb_stderr)) + { + flush_hook (stream); + return; + } + + fflush (stream->ts_filestream); +} + +void +gdb_fclose(streamptr) + GDB_FILE **streamptr; +{ + GDB_FILE *tmpstream; + + tmpstream = *streamptr; + fclose (tmpstream->ts_filestream); + gdb_file_deallocate (streamptr); +} + +/* Like fputs but if FILTER is true, pause after every screenful. + + Regardless of FILTER can wrap at points other than the final + character of a line. + + Unlike fputs, fputs_maybe_filtered does not return a value. + It is OK for LINEBUFFER to be NULL, in which case just don't print + anything. + + Note that a longjmp to top level may occur in this routine (only if + FILTER is true) (since prompt_for_continue may do so) so this + routine should not be called when cleanups are not in place. */ + +static void +fputs_maybe_filtered (linebuffer, stream, filter) + const char *linebuffer; + GDB_FILE *stream; + int filter; +{ + const char *lineptr; + + if (linebuffer == 0) + return; + + /* Don't do any filtering if it is disabled. */ + if (stream != gdb_stdout + || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)) + { + fputs_unfiltered (linebuffer, stream); + return; + } + + /* Go through and output each character. Show line extension + when this is necessary; prompt user for new page when this is + necessary. */ + + lineptr = linebuffer; + while (*lineptr) + { + /* Possible new page. */ + if (filter && + (lines_printed >= lines_per_page - 1)) + prompt_for_continue (); + + while (*lineptr && *lineptr != '\n') + { + /* Print a single line. */ + if (*lineptr == '\t') + { + if (wrap_column) + *wrap_pointer++ = '\t'; + else + fputc_unfiltered ('\t', stream); + /* Shifting right by 3 produces the number of tab stops + we have already passed, and then adding one and + shifting left 3 advances to the next tab stop. */ + chars_printed = ((chars_printed >> 3) + 1) << 3; + lineptr++; + } + else + { + if (wrap_column) + *wrap_pointer++ = *lineptr; + else + fputc_unfiltered (*lineptr, stream); + chars_printed++; + lineptr++; + } + + if (chars_printed >= chars_per_line) + { + unsigned int save_chars = chars_printed; + + chars_printed = 0; + lines_printed++; + /* If we aren't actually wrapping, don't output newline -- + if chars_per_line is right, we probably just overflowed + anyway; if it's wrong, let us keep going. */ + if (wrap_column) + fputc_unfiltered ('\n', stream); + + /* Possible new page. */ + if (lines_printed >= lines_per_page - 1) + prompt_for_continue (); + + /* Now output indentation and wrapped string */ + if (wrap_column) + { + fputs_unfiltered (wrap_indent, stream); + *wrap_pointer = '\0'; /* Null-terminate saved stuff */ + fputs_unfiltered (wrap_buffer, stream); /* and eject it */ + /* FIXME, this strlen is what prevents wrap_indent from + containing tabs. However, if we recurse to print it + and count its chars, we risk trouble if wrap_indent is + longer than (the user settable) chars_per_line. + Note also that this can set chars_printed > chars_per_line + if we are printing a long string. */ + chars_printed = strlen (wrap_indent) + + (save_chars - wrap_column); + wrap_pointer = wrap_buffer; /* Reset buffer */ + wrap_buffer[0] = '\0'; + wrap_column = 0; /* And disable fancy wrap */ + } + } + } + + if (*lineptr == '\n') + { + chars_printed = 0; + wrap_here ((char *)0); /* Spit out chars, cancel further wraps */ + lines_printed++; + fputc_unfiltered ('\n', stream); + lineptr++; + } + } +} + +void +fputs_filtered (linebuffer, stream) + const char *linebuffer; + GDB_FILE *stream; +{ + fputs_maybe_filtered (linebuffer, stream, 1); +} + +int +putchar_unfiltered (c) + int c; +{ + char buf[2]; + + buf[0] = c; + buf[1] = 0; + fputs_unfiltered (buf, gdb_stdout); + return c; +} + +int +fputc_unfiltered (c, stream) + int c; + GDB_FILE * stream; +{ + char buf[2]; + + buf[0] = c; + buf[1] = 0; + fputs_unfiltered (buf, stream); + return c; +} + +int +fputc_filtered (c, stream) + int c; + GDB_FILE * stream; +{ + char buf[2]; + + buf[0] = c; + buf[1] = 0; + fputs_filtered (buf, stream); + return c; +} + +/* puts_debug is like fputs_unfiltered, except it prints special + characters in printable fashion. */ + +void +puts_debug (prefix, string, suffix) + char *prefix; + char *string; + char *suffix; +{ + int ch; + + /* Print prefix and suffix after each line. */ + static int new_line = 1; + static int return_p = 0; + static char *prev_prefix = ""; + static char *prev_suffix = ""; + + if (*string == '\n') + return_p = 0; + + /* If the prefix is changing, print the previous suffix, a new line, + and the new prefix. */ + if ((return_p || (strcmp(prev_prefix, prefix) != 0)) && !new_line) + { + fputs_unfiltered (prev_suffix, gdb_stderr); + fputs_unfiltered ("\n", gdb_stderr); + fputs_unfiltered (prefix, gdb_stderr); + } + + /* Print prefix if we printed a newline during the previous call. */ + if (new_line) + { + new_line = 0; + fputs_unfiltered (prefix, gdb_stderr); + } + + prev_prefix = prefix; + prev_suffix = suffix; + + /* Output characters in a printable format. */ + while ((ch = *string++) != '\0') + { + switch (ch) + { + default: + if (isprint (ch)) + fputc_unfiltered (ch, gdb_stderr); + + else + fprintf_unfiltered (gdb_stderr, "\\x%02x", ch & 0xff); + break; + + case '\\': fputs_unfiltered ("\\\\", gdb_stderr); break; + case '\b': fputs_unfiltered ("\\b", gdb_stderr); break; + case '\f': fputs_unfiltered ("\\f", gdb_stderr); break; + case '\n': new_line = 1; + fputs_unfiltered ("\\n", gdb_stderr); break; + case '\r': fputs_unfiltered ("\\r", gdb_stderr); break; + case '\t': fputs_unfiltered ("\\t", gdb_stderr); break; + case '\v': fputs_unfiltered ("\\v", gdb_stderr); break; + } + + return_p = ch == '\r'; + } + + /* Print suffix if we printed a newline. */ + if (new_line) + { + fputs_unfiltered (suffix, gdb_stderr); + fputs_unfiltered ("\n", gdb_stderr); + } +} + + +/* Print a variable number of ARGS using format FORMAT. If this + information is going to put the amount written (since the last call + to REINITIALIZE_MORE_FILTER or the last page break) over the page size, + call prompt_for_continue to get the users permision to continue. + + Unlike fprintf, this function does not return a value. + + We implement three variants, vfprintf (takes a vararg list and stream), + fprintf (takes a stream to write on), and printf (the usual). + + Note also that a longjmp to top level may occur in this routine + (since prompt_for_continue may do so) so this routine should not be + called when cleanups are not in place. */ + +static void +vfprintf_maybe_filtered (stream, format, args, filter) + GDB_FILE *stream; + const char *format; + va_list args; + int filter; +{ + char *linebuffer; + struct cleanup *old_cleanups; + + vasprintf (&linebuffer, format, args); + if (linebuffer == NULL) + { + fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr); + exit (1); + } + old_cleanups = make_cleanup (free, linebuffer); + fputs_maybe_filtered (linebuffer, stream, filter); + do_cleanups (old_cleanups); +} + + +void +vfprintf_filtered (stream, format, args) + GDB_FILE *stream; + const char *format; + va_list args; +{ + vfprintf_maybe_filtered (stream, format, args, 1); +} + +void +vfprintf_unfiltered (stream, format, args) + GDB_FILE *stream; + const char *format; + va_list args; +{ + char *linebuffer; + struct cleanup *old_cleanups; + + vasprintf (&linebuffer, format, args); + if (linebuffer == NULL) + { + fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr); + exit (1); + } + old_cleanups = make_cleanup (free, linebuffer); + fputs_unfiltered (linebuffer, stream); + do_cleanups (old_cleanups); +} + +void +vprintf_filtered (format, args) + const char *format; + va_list args; +{ + vfprintf_maybe_filtered (gdb_stdout, format, args, 1); +} + +void +vprintf_unfiltered (format, args) + const char *format; + va_list args; +{ + vfprintf_unfiltered (gdb_stdout, format, args); +} + +/* VARARGS */ +void +#ifdef ANSI_PROTOTYPES +fprintf_filtered (GDB_FILE *stream, const char *format, ...) +#else +fprintf_filtered (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, format); +#else + GDB_FILE *stream; + char *format; + + va_start (args); + stream = va_arg (args, GDB_FILE *); + format = va_arg (args, char *); +#endif + vfprintf_filtered (stream, format, args); + va_end (args); +} + +/* VARARGS */ +void +#ifdef ANSI_PROTOTYPES +fprintf_unfiltered (GDB_FILE *stream, const char *format, ...) +#else +fprintf_unfiltered (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, format); +#else + GDB_FILE *stream; + char *format; + + va_start (args); + stream = va_arg (args, GDB_FILE *); + format = va_arg (args, char *); +#endif + vfprintf_unfiltered (stream, format, args); + va_end (args); +} + +/* Like fprintf_filtered, but prints its result indented. + Called as fprintfi_filtered (spaces, stream, format, ...); */ + +/* VARARGS */ +void +#ifdef ANSI_PROTOTYPES +fprintfi_filtered (int spaces, GDB_FILE *stream, const char *format, ...) +#else +fprintfi_filtered (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, format); +#else + int spaces; + GDB_FILE *stream; + char *format; + + va_start (args); + spaces = va_arg (args, int); + stream = va_arg (args, GDB_FILE *); + format = va_arg (args, char *); +#endif + print_spaces_filtered (spaces, stream); + + vfprintf_filtered (stream, format, args); + va_end (args); +} + + +/* VARARGS */ +void +#ifdef ANSI_PROTOTYPES +printf_filtered (const char *format, ...) +#else +printf_filtered (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, format); +#else + char *format; + + va_start (args); + format = va_arg (args, char *); +#endif + vfprintf_filtered (gdb_stdout, format, args); + va_end (args); +} + + +/* VARARGS */ +void +#ifdef ANSI_PROTOTYPES +printf_unfiltered (const char *format, ...) +#else +printf_unfiltered (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, format); +#else + char *format; + + va_start (args); + format = va_arg (args, char *); +#endif + vfprintf_unfiltered (gdb_stdout, format, args); + va_end (args); +} + +/* Like printf_filtered, but prints it's result indented. + Called as printfi_filtered (spaces, format, ...); */ + +/* VARARGS */ +void +#ifdef ANSI_PROTOTYPES +printfi_filtered (int spaces, const char *format, ...) +#else +printfi_filtered (va_alist) + va_dcl +#endif +{ + va_list args; +#ifdef ANSI_PROTOTYPES + va_start (args, format); +#else + int spaces; + char *format; + + va_start (args); + spaces = va_arg (args, int); + format = va_arg (args, char *); +#endif + print_spaces_filtered (spaces, gdb_stdout); + vfprintf_filtered (gdb_stdout, format, args); + va_end (args); +} + +/* Easy -- but watch out! + + This routine is *not* a replacement for puts()! puts() appends a newline. + This one doesn't, and had better not! */ + +void +puts_filtered (string) + const char *string; +{ + fputs_filtered (string, gdb_stdout); +} + +void +puts_unfiltered (string) + const char *string; +{ + fputs_unfiltered (string, gdb_stdout); +} + +/* Return a pointer to N spaces and a null. The pointer is good + until the next call to here. */ +char * +n_spaces (n) + int n; +{ + register char *t; + static char *spaces; + static int max_spaces; + + if (n > max_spaces) + { + if (spaces) + free (spaces); + spaces = (char *) xmalloc (n+1); + for (t = spaces+n; t != spaces;) + *--t = ' '; + spaces[n] = '\0'; + max_spaces = n; + } + + return spaces + max_spaces - n; +} + +/* Print N spaces. */ +void +print_spaces_filtered (n, stream) + int n; + GDB_FILE *stream; +{ + fputs_filtered (n_spaces (n), stream); +} + +/* C++ demangler stuff. */ + +/* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language + LANG, using demangling args ARG_MODE, and print it filtered to STREAM. + If the name is not mangled, or the language for the name is unknown, or + demangling is off, the name is printed in its "raw" form. */ + +void +fprintf_symbol_filtered (stream, name, lang, arg_mode) + GDB_FILE *stream; + char *name; + enum language lang; + int arg_mode; +{ + char *demangled; + + if (name != NULL) + { + /* If user wants to see raw output, no problem. */ + if (!demangle) + { + fputs_filtered (name, stream); + } + else + { + switch (lang) + { + case language_cplus: + demangled = cplus_demangle (name, arg_mode); + break; + case language_java: + demangled = cplus_demangle (name, arg_mode | DMGL_JAVA); + break; + case language_chill: + demangled = chill_demangle (name); + break; + default: + demangled = NULL; + break; + } + fputs_filtered (demangled ? demangled : name, stream); + if (demangled != NULL) + { + free (demangled); + } + } + } +} + +/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any + differences in whitespace. Returns 0 if they match, non-zero if they + don't (slightly different than strcmp()'s range of return values). + + As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO". + This "feature" is useful when searching for matching C++ function names + (such as if the user types 'break FOO', where FOO is a mangled C++ + function). */ + +int +strcmp_iw (string1, string2) + const char *string1; + const char *string2; +{ + while ((*string1 != '\0') && (*string2 != '\0')) + { + while (isspace (*string1)) + { + string1++; + } + while (isspace (*string2)) + { + string2++; + } + if (*string1 != *string2) + { + break; + } + if (*string1 != '\0') + { + string1++; + string2++; + } + } + return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0'); +} + + +/* +** subsetCompare() +** Answer whether stringToCompare is a full or partial match to +** templateString. The partial match must be in sequence starting +** at index 0. +*/ +int +#ifdef _STDC__ +subsetCompare( + char *stringToCompare, + char *templateString) +#else +subsetCompare(stringToCompare, templateString) + char *stringToCompare; + char *templateString; +#endif +{ + int match = 0; + + if (templateString != (char *)NULL && stringToCompare != (char *)NULL && + strlen(stringToCompare) <= strlen(templateString)) + match = (strncmp(templateString, + stringToCompare, + strlen(stringToCompare)) == 0); + + return match; +} /* subsetCompare */ + + +void pagination_on_command(arg, from_tty) + char *arg; + int from_tty; +{ + pagination_enabled = 1; +} + +void pagination_off_command(arg, from_tty) + char *arg; + int from_tty; +{ + pagination_enabled = 0; +} + + +void +initialize_utils () +{ + struct cmd_list_element *c; + + c = add_set_cmd ("width", class_support, var_uinteger, + (char *)&chars_per_line, + "Set number of characters gdb thinks are in a line.", + &setlist); + add_show_from_set (c, &showlist); + c->function.sfunc = set_width_command; + + add_show_from_set + (add_set_cmd ("height", class_support, + var_uinteger, (char *)&lines_per_page, + "Set number of lines gdb thinks are in a page.", &setlist), + &showlist); + + init_page_info (); + + /* If the output is not a terminal, don't paginate it. */ + if (!GDB_FILE_ISATTY (gdb_stdout)) + lines_per_page = UINT_MAX; + + set_width_command ((char *)NULL, 0, c); + + add_show_from_set + (add_set_cmd ("demangle", class_support, var_boolean, + (char *)&demangle, + "Set demangling of encoded C++ names when displaying symbols.", + &setprintlist), + &showprintlist); + + add_show_from_set + (add_set_cmd ("pagination", class_support, + var_boolean, (char *)&pagination_enabled, + "Set state of pagination.", &setlist), + &showlist); + if (xdb_commands) + { + add_com("am", class_support, pagination_on_command, + "Enable pagination"); + add_com("sm", class_support, pagination_off_command, + "Disable pagination"); + } + + add_show_from_set + (add_set_cmd ("sevenbit-strings", class_support, var_boolean, + (char *)&sevenbit_strings, + "Set printing of 8-bit characters in strings as \\nnn.", + &setprintlist), + &showprintlist); + + add_show_from_set + (add_set_cmd ("asm-demangle", class_support, var_boolean, + (char *)&asm_demangle, + "Set demangling of C++ names in disassembly listings.", + &setprintlist), + &showprintlist); +} + +/* Machine specific function to handle SIGWINCH signal. */ + +#ifdef SIGWINCH_HANDLER_BODY + SIGWINCH_HANDLER_BODY +#endif + +/* Support for converting target fp numbers into host DOUBLEST format. */ + +/* XXX - This code should really be in libiberty/floatformat.c, however + configuration issues with libiberty made this very difficult to do in the + available time. */ + +#include "floatformat.h" +#include <math.h> /* ldexp */ + +/* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not + going to bother with trying to muck around with whether it is defined in + a system header, what we do if not, etc. */ +#define FLOATFORMAT_CHAR_BIT 8 + +static unsigned long get_field PARAMS ((unsigned char *, + enum floatformat_byteorders, + unsigned int, + unsigned int, + unsigned int)); + +/* Extract a field which starts at START and is LEN bytes long. DATA and + TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ +static unsigned long +get_field (data, order, total_len, start, len) + unsigned char *data; + enum floatformat_byteorders order; + unsigned int total_len; + unsigned int start; + unsigned int len; +{ + unsigned long result; + unsigned int cur_byte; + int cur_bitshift; + + /* Start at the least significant part of the field. */ + cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT; + if (order == floatformat_little || order == floatformat_littlebyte_bigword) + cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1; + cur_bitshift = + ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT; + result = *(data + cur_byte) >> (-cur_bitshift); + cur_bitshift += FLOATFORMAT_CHAR_BIT; + if (order == floatformat_little || order == floatformat_littlebyte_bigword) + ++cur_byte; + else + --cur_byte; + + /* Move towards the most significant part of the field. */ + while (cur_bitshift < len) + { + if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT) + /* This is the last byte; zero out the bits which are not part of + this field. */ + result |= + (*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1)) + << cur_bitshift; + else + result |= *(data + cur_byte) << cur_bitshift; + cur_bitshift += FLOATFORMAT_CHAR_BIT; + if (order == floatformat_little || order == floatformat_littlebyte_bigword) + ++cur_byte; + else + --cur_byte; + } + return result; +} + +/* Convert from FMT to a DOUBLEST. + FROM is the address of the extended float. + Store the DOUBLEST in *TO. */ + +void +floatformat_to_doublest (fmt, from, to) + const struct floatformat *fmt; + char *from; + DOUBLEST *to; +{ + unsigned char *ufrom = (unsigned char *)from; + DOUBLEST dto; + long exponent; + unsigned long mant; + unsigned int mant_bits, mant_off; + int mant_bits_left; + int special_exponent; /* It's a NaN, denorm or zero */ + + /* If the mantissa bits are not contiguous from one end of the + mantissa to the other, we need to make a private copy of the + source bytes that is in the right order since the unpacking + algorithm assumes that the bits are contiguous. + + Swap the bytes individually rather than accessing them through + "long *" since we have no guarantee that they start on a long + alignment, and also sizeof(long) for the host could be different + than sizeof(long) for the target. FIXME: Assumes sizeof(long) + for the target is 4. */ + + if (fmt -> byteorder == floatformat_littlebyte_bigword) + { + static unsigned char *newfrom; + unsigned char *swapin, *swapout; + int longswaps; + + longswaps = fmt -> totalsize / FLOATFORMAT_CHAR_BIT; + longswaps >>= 3; + + if (newfrom == NULL) + { + newfrom = (unsigned char *) xmalloc (fmt -> totalsize); + } + swapout = newfrom; + swapin = ufrom; + ufrom = newfrom; + while (longswaps-- > 0) + { + /* This is ugly, but efficient */ + *swapout++ = swapin[4]; + *swapout++ = swapin[5]; + *swapout++ = swapin[6]; + *swapout++ = swapin[7]; + *swapout++ = swapin[0]; + *swapout++ = swapin[1]; + *swapout++ = swapin[2]; + *swapout++ = swapin[3]; + swapin += 8; + } + } + + exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, + fmt->exp_start, fmt->exp_len); + /* Note that if exponent indicates a NaN, we can't really do anything useful + (not knowing if the host has NaN's, or how to build one). So it will + end up as an infinity or something close; that is OK. */ + + mant_bits_left = fmt->man_len; + mant_off = fmt->man_start; + dto = 0.0; + + special_exponent = exponent == 0 || exponent == fmt->exp_nan; + +/* Don't bias zero's, denorms or NaNs. */ + if (!special_exponent) + exponent -= fmt->exp_bias; + + /* Build the result algebraically. Might go infinite, underflow, etc; + who cares. */ + +/* If this format uses a hidden bit, explicitly add it in now. Otherwise, + increment the exponent by one to account for the integer bit. */ + + if (!special_exponent) + if (fmt->intbit == floatformat_intbit_no) + dto = ldexp (1.0, exponent); + else + exponent++; + + while (mant_bits_left > 0) + { + mant_bits = min (mant_bits_left, 32); + + mant = get_field (ufrom, fmt->byteorder, fmt->totalsize, + mant_off, mant_bits); + + dto += ldexp ((double)mant, exponent - mant_bits); + exponent -= mant_bits; + mant_off += mant_bits; + mant_bits_left -= mant_bits; + } + + /* Negate it if negative. */ + if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) + dto = -dto; + *to = dto; +} + +static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders, + unsigned int, + unsigned int, + unsigned int, + unsigned long)); + +/* Set a field which starts at START and is LEN bytes long. DATA and + TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ +static void +put_field (data, order, total_len, start, len, stuff_to_put) + unsigned char *data; + enum floatformat_byteorders order; + unsigned int total_len; + unsigned int start; + unsigned int len; + unsigned long stuff_to_put; +{ + unsigned int cur_byte; + int cur_bitshift; + + /* Start at the least significant part of the field. */ + cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT; + if (order == floatformat_little || order == floatformat_littlebyte_bigword) + cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1; + cur_bitshift = + ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT; + *(data + cur_byte) &= + ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift)); + *(data + cur_byte) |= + (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift); + cur_bitshift += FLOATFORMAT_CHAR_BIT; + if (order == floatformat_little || order == floatformat_littlebyte_bigword) + ++cur_byte; + else + --cur_byte; + + /* Move towards the most significant part of the field. */ + while (cur_bitshift < len) + { + if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT) + { + /* This is the last byte. */ + *(data + cur_byte) &= + ~((1 << (len - cur_bitshift)) - 1); + *(data + cur_byte) |= (stuff_to_put >> cur_bitshift); + } + else + *(data + cur_byte) = ((stuff_to_put >> cur_bitshift) + & ((1 << FLOATFORMAT_CHAR_BIT) - 1)); + cur_bitshift += FLOATFORMAT_CHAR_BIT; + if (order == floatformat_little || order == floatformat_littlebyte_bigword) + ++cur_byte; + else + --cur_byte; + } +} + +#ifdef HAVE_LONG_DOUBLE +/* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR. + The range of the returned value is >= 0.5 and < 1.0. This is equivalent to + frexp, but operates on the long double data type. */ + +static long double ldfrexp PARAMS ((long double value, int *eptr)); + +static long double +ldfrexp (value, eptr) + long double value; + int *eptr; +{ + long double tmp; + int exp; + + /* Unfortunately, there are no portable functions for extracting the exponent + of a long double, so we have to do it iteratively by multiplying or dividing + by two until the fraction is between 0.5 and 1.0. */ + + if (value < 0.0l) + value = -value; + + tmp = 1.0l; + exp = 0; + + if (value >= tmp) /* Value >= 1.0 */ + while (value >= tmp) + { + tmp *= 2.0l; + exp++; + } + else if (value != 0.0l) /* Value < 1.0 and > 0.0 */ + { + while (value < tmp) + { + tmp /= 2.0l; + exp--; + } + tmp *= 2.0l; + exp++; + } + + *eptr = exp; + return value/tmp; +} +#endif /* HAVE_LONG_DOUBLE */ + + +/* The converse: convert the DOUBLEST *FROM to an extended float + and store where TO points. Neither FROM nor TO have any alignment + restrictions. */ + +void +floatformat_from_doublest (fmt, from, to) + CONST struct floatformat *fmt; + DOUBLEST *from; + char *to; +{ + DOUBLEST dfrom; + int exponent; + DOUBLEST mant; + unsigned int mant_bits, mant_off; + int mant_bits_left; + unsigned char *uto = (unsigned char *)to; + + memcpy (&dfrom, from, sizeof (dfrom)); + memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT); + if (dfrom == 0) + return; /* Result is zero */ + if (dfrom != dfrom) /* Result is NaN */ + { + /* From is NaN */ + put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, + fmt->exp_len, fmt->exp_nan); + /* Be sure it's not infinity, but NaN value is irrel */ + put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start, + 32, 1); + return; + } + + /* If negative, set the sign bit. */ + if (dfrom < 0) + { + put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1); + dfrom = -dfrom; + } + + if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity */ + { + /* Infinity exponent is same as NaN's. */ + put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, + fmt->exp_len, fmt->exp_nan); + /* Infinity mantissa is all zeroes. */ + put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start, + fmt->man_len, 0); + return; + } + +#ifdef HAVE_LONG_DOUBLE + mant = ldfrexp (dfrom, &exponent); +#else + mant = frexp (dfrom, &exponent); +#endif + + put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len, + exponent + fmt->exp_bias - 1); + + mant_bits_left = fmt->man_len; + mant_off = fmt->man_start; + while (mant_bits_left > 0) + { + unsigned long mant_long; + mant_bits = mant_bits_left < 32 ? mant_bits_left : 32; + + mant *= 4294967296.0; + mant_long = (unsigned long)mant; + mant -= mant_long; + + /* If the integer bit is implicit, then we need to discard it. + If we are discarding a zero, we should be (but are not) creating + a denormalized number which means adjusting the exponent + (I think). */ + if (mant_bits_left == fmt->man_len + && fmt->intbit == floatformat_intbit_no) + { + mant_long <<= 1; + mant_bits -= 1; + } + + if (mant_bits < 32) + { + /* The bits we want are in the most significant MANT_BITS bits of + mant_long. Move them to the least significant. */ + mant_long >>= 32 - mant_bits; + } + + put_field (uto, fmt->byteorder, fmt->totalsize, + mant_off, mant_bits, mant_long); + mant_off += mant_bits; + mant_bits_left -= mant_bits; + } + if (fmt -> byteorder == floatformat_littlebyte_bigword) + { + int count; + unsigned char *swaplow = uto; + unsigned char *swaphigh = uto + 4; + unsigned char tmp; + + for (count = 0; count < 4; count++) + { + tmp = *swaplow; + *swaplow++ = *swaphigh; + *swaphigh++ = tmp; + } + } +} + +/* temporary storage using circular buffer */ +#define NUMCELLS 16 +#define CELLSIZE 32 +static char* +get_cell() +{ + static char buf[NUMCELLS][CELLSIZE]; + static int cell=0; + if (++cell>=NUMCELLS) cell=0; + return buf[cell]; +} + +/* print routines to handle variable size regs, etc. + + FIXME: Note that t_addr is a bfd_vma, which is currently either an + unsigned long or unsigned long long, determined at configure time. + If t_addr is an unsigned long long and sizeof (unsigned long long) + is greater than sizeof (unsigned long), then I believe this code will + probably lose, at least for little endian machines. I believe that + it would also be better to eliminate the switch on the absolute size + of t_addr and replace it with a sequence of if statements that compare + sizeof t_addr with sizeof the various types and do the right thing, + which includes knowing whether or not the host supports long long. + -fnf + + */ + +static int thirty_two = 32; /* eliminate warning from compiler on 32-bit systems */ + +char* +paddr(addr) + t_addr addr; +{ + char *paddr_str=get_cell(); + switch (sizeof(t_addr)) + { + case 8: + sprintf (paddr_str, "%08lx%08lx", + (unsigned long) (addr >> thirty_two), (unsigned long) (addr & 0xffffffff)); + break; + case 4: + sprintf (paddr_str, "%08lx", (unsigned long) addr); + break; + case 2: + sprintf (paddr_str, "%04x", (unsigned short) (addr & 0xffff)); + break; + default: + sprintf (paddr_str, "%lx", (unsigned long) addr); + } + return paddr_str; +} + +char* +preg(reg) + t_reg reg; +{ + char *preg_str=get_cell(); + switch (sizeof(t_reg)) + { + case 8: + sprintf (preg_str, "%08lx%08lx", + (unsigned long) (reg >> thirty_two), (unsigned long) (reg & 0xffffffff)); + break; + case 4: + sprintf (preg_str, "%08lx", (unsigned long) reg); + break; + case 2: + sprintf (preg_str, "%04x", (unsigned short) (reg & 0xffff)); + break; + default: + sprintf (preg_str, "%lx", (unsigned long) reg); + } + return preg_str; +} + +char* +paddr_nz(addr) + t_addr addr; +{ + char *paddr_str=get_cell(); + switch (sizeof(t_addr)) + { + case 8: + { + unsigned long high = (unsigned long) (addr >> thirty_two); + if (high == 0) + sprintf (paddr_str, "%lx", (unsigned long) (addr & 0xffffffff)); + else + sprintf (paddr_str, "%lx%08lx", + high, (unsigned long) (addr & 0xffffffff)); + break; + } + case 4: + sprintf (paddr_str, "%lx", (unsigned long) addr); + break; + case 2: + sprintf (paddr_str, "%x", (unsigned short) (addr & 0xffff)); + break; + default: + sprintf (paddr_str,"%lx", (unsigned long) addr); + } + return paddr_str; +} + +char* +preg_nz(reg) + t_reg reg; +{ + char *preg_str=get_cell(); + switch (sizeof(t_reg)) + { + case 8: + { + unsigned long high = (unsigned long) (reg >> thirty_two); + if (high == 0) + sprintf (preg_str, "%lx", (unsigned long) (reg & 0xffffffff)); + else + sprintf (preg_str, "%lx%08lx", + high, (unsigned long) (reg & 0xffffffff)); + break; + } + case 4: + sprintf (preg_str, "%lx", (unsigned long) reg); + break; + case 2: + sprintf (preg_str, "%x", (unsigned short) (reg & 0xffff)); + break; + default: + sprintf (preg_str, "%lx", (unsigned long) reg); + } + return preg_str; +} |