#include <sys/time.h>
#include <time.h>
+#include "gdb_usleep.h"
+
#if !HAVE_DECL_MALLOC
-extern PTR malloc (); /* OK: PTR */
+extern PTR malloc (); /* ARI: PTR */
#endif
#if !HAVE_DECL_REALLOC
-extern PTR realloc (); /* OK: PTR */
+extern PTR realloc (); /* ARI: PTR */
#endif
#if !HAVE_DECL_FREE
extern void free ();
NORETURN void
error_stream (struct ui_file *stream)
{
- long len;
- char *message = ui_file_xstrdup (stream, &len);
+ char *message = ui_file_xstrdup (stream, NULL);
make_cleanup (xfree, message);
error (("%s"), message);
}
/* Default (yes/batch case) is to quit GDB. When in batch mode
this lessens the likelihood of GDB going into an infinite
loop. */
- quit_p = query (_("%s\nQuit this debugging session? "), reason);
+ if (caution == 0)
+ {
+ /* Emit the message and quit. */
+ fputs_unfiltered (reason, gdb_stderr);
+ fputs_unfiltered ("\n", gdb_stderr);
+ quit_p = 1;
+ }
+ else
+ quit_p = query (_("%s\nQuit this debugging session? "), reason);
}
else if (problem->should_quit == internal_problem_yes)
quit_p = 1;
set_cmd_list,
show_cmd_list);
+ xfree (set_doc);
+ xfree (show_doc);
+
set_doc = xstrprintf (_("\
Set whether GDB should create a core file of GDB when %s is detected"),
problem->name);
NULL, /* showfunc */
set_cmd_list,
show_cmd_list);
+
+ xfree (set_doc);
+ xfree (show_doc);
}
/* Print the system error message for errno, and also mention STRING
/* NOTE: These are declared using PTR to ensure consistency with
"libiberty.h". xfree() is GDB local. */
-PTR /* OK: PTR */
+PTR /* ARI: PTR */
xmalloc (size_t size)
{
void *val;
if (size == 0)
size = 1;
- val = malloc (size); /* OK: malloc */
+ val = malloc (size); /* ARI: malloc */
if (val == NULL)
nomem (size);
return xcalloc (1, size);
}
-PTR /* OK: PTR */
-xrealloc (PTR ptr, size_t size) /* OK: PTR */
+PTR /* ARI: PTR */
+xrealloc (PTR ptr, size_t size) /* ARI: PTR */
{
void *val;
size = 1;
if (ptr != NULL)
- val = realloc (ptr, size); /* OK: realloc */
+ val = realloc (ptr, size); /* ARI: realloc */
else
- val = malloc (size); /* OK: malloc */
+ val = malloc (size); /* ARI: malloc */
if (val == NULL)
nomem (size);
return (val);
}
-PTR /* OK: PTR */
+PTR /* ARI: PTR */
xcalloc (size_t number, size_t size)
{
void *mem;
size = 1;
}
- mem = calloc (number, size); /* OK: xcalloc */
+ mem = calloc (number, size); /* ARI: xcalloc */
if (mem == NULL)
nomem (number * size);
xfree (void *ptr)
{
if (ptr != NULL)
- free (ptr); /* OK: free */
+ free (ptr); /* ARI: free */
}
\f
}
/* Automatically answer the default value if the user did not want
- prompts. */
- if (! caution)
+ prompts or the command was issued with the server prefix. */
+ if (! caution || server_command)
return def_value;
/* If input isn't coming from the user directly, just say what
- question we're asking, and then answer "yes" automatically. This
+ question we're asking, and then answer the default automatically. This
way, important error messages don't get lost when talking to GDB
over a pipe. */
if (! input_from_terminal_p ())
return def_value;
}
- /* Automatically answer the default value if input is not from the user
- directly, or if the user did not want prompts. */
- if (!input_from_terminal_p () || !caution)
- return def_value;
-
if (deprecated_query_hook)
{
return deprecated_query_hook (ctlstr, args);
gdb_flush (gdb_stdout);
answer = fgetc (stdin);
+
+ /* We expect fgetc to block until a character is read. But
+ this may not be the case if the terminal was opened with
+ the NONBLOCK flag. In that case, if there is nothing to
+ read on stdin, fgetc returns EOF, but also sets the error
+ condition flag on stdin and errno to EAGAIN. With a true
+ EOF, stdin's error condition flag is not set.
+
+ A situation where this behavior was observed is a pseudo
+ terminal on AIX. */
+ while (answer == EOF && ferror (stdin) && errno == EAGAIN)
+ {
+ /* Not a real EOF. Wait a little while and try again until
+ we read something. */
+ clearerr (stdin);
+ gdb_usleep (10000);
+ answer = fgetc (stdin);
+ }
+
clearerr (stdin); /* in case of C-d */
if (answer == EOF) /* C-d */
{
return buf[cell];
}
-int
-strlen_paddr (void)
-{
- return (gdbarch_addr_bit (current_gdbarch) / 8 * 2);
-}
-
-char *
-paddr (CORE_ADDR addr)
-{
- return phex (addr, gdbarch_addr_bit (current_gdbarch) / 8);
-}
-
-char *
-paddr_nz (CORE_ADDR addr)
-{
- return phex_nz (addr, gdbarch_addr_bit (current_gdbarch) / 8);
-}
-
const char *
-paddress (CORE_ADDR addr)
+paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
{
/* Truncate address to the size of a target address, avoiding shifts
larger or equal than the width of a CORE_ADDR. The local
either zero or sign extended. Should gdbarch_address_to_pointer or
some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
- int addr_bit = gdbarch_addr_bit (current_gdbarch);
+ int addr_bit = gdbarch_addr_bit (gdbarch);
if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
CORE_ADDR
string_to_core_addr (const char *my_string)
{
- int addr_bit = gdbarch_addr_bit (current_gdbarch);
CORE_ADDR addr = 0;
if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
else
error (_("invalid hex \"%s\""), my_string);
}
-
- /* Not very modular, but if the executable format expects
- addresses to be sign-extended, then do so if the address was
- specified with only 32 significant bits. Really this should
- be determined by the target architecture, not by the object
- file. */
- if (i - 2 == addr_bit / 4
- && exec_bfd
- && bfd_get_sign_extend_vma (exec_bfd))
- addr = (addr ^ ((CORE_ADDR) 1 << (addr_bit - 1)))
- - ((CORE_ADDR) 1 << (addr_bit - 1));
}
else
{
unsigned long
gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len)
{
- static const unsigned long crc32_table[256] = {
+ static const unsigned int crc32_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,