#include "readline/readline.h"
-#include <sys/time.h>
+#include "gdb_sys_time.h"
#include <time.h>
#include "gdb_usleep.h"
static void
do_bfd_close_cleanup (void *arg)
{
- gdb_bfd_unref (arg);
+ gdb_bfd_unref ((bfd *) arg);
}
struct cleanup *
static void
do_fclose_cleanup (void *arg)
{
- FILE *file = arg;
+ FILE *file = (FILE *) arg;
fclose (file);
}
static void
do_obstack_free (void *arg)
{
- struct obstack *ob = arg;
+ struct obstack *ob = (struct obstack *) arg;
obstack_free (ob, NULL);
}
static void
do_ui_file_delete (void *arg)
{
- ui_file_delete (arg);
+ ui_file_delete ((struct ui_file *) arg);
}
struct cleanup *
static void
do_ui_out_redirect_pop (void *arg)
{
- struct ui_out *uiout = arg;
+ struct ui_out *uiout = (struct ui_out *) arg;
if (ui_out_redirect (uiout, NULL) < 0)
warning (_("Cannot restore redirection of the current output protocol"));
static void
do_free_section_addr_info (void *arg)
{
- free_section_addr_info (arg);
+ free_section_addr_info ((struct section_addr_info *) arg);
}
struct cleanup *
static void
restore_integer (void *p)
{
- struct restore_integer_closure *closure = p;
+ struct restore_integer_closure *closure
+ = (struct restore_integer_closure *) p;
*(closure->variable) = closure->value;
}
struct cleanup *
make_cleanup_restore_integer (int *variable)
{
- struct restore_integer_closure *c =
- xmalloc (sizeof (struct restore_integer_closure));
+ struct restore_integer_closure *c = XNEW (struct restore_integer_closure);
c->variable = variable;
c->value = *variable;
static void
do_unpush_target (void *arg)
{
- struct target_ops *ops = arg;
+ struct target_ops *ops = (struct target_ops *) arg;
unpush_target (ops);
}
static void
do_htab_delete_cleanup (void *htab_voidp)
{
- htab_t htab = htab_voidp;
+ htab_t htab = (htab_t) htab_voidp;
htab_delete (htab);
}
static void
do_restore_ui_file (void *p)
{
- struct restore_ui_file_closure *closure = p;
+ struct restore_ui_file_closure *closure
+ = (struct restore_ui_file_closure *) p;
*(closure->variable) = closure->value;
}
static void
do_value_free (void *value)
{
- value_free (value);
+ value_free ((struct value *) value);
}
/* Free VALUE. */
static void
do_free_so (void *arg)
{
- struct so_list *so = arg;
+ struct so_list *so = (struct so_list *) arg;
free_so (so);
}
static void
do_restore_current_language (void *p)
{
- enum language saved_lang = (uintptr_t) p;
+ enum language saved_lang = (enum language) (uintptr_t) p;
set_language (saved_lang);
}
void
free_current_contents (void *ptr)
{
- void **location = ptr;
+ void **location = (void **) ptr;
if (location == NULL)
internal_error (__FILE__, __LINE__,
char *set_doc;
char *show_doc;
- set_cmd_list = xmalloc (sizeof (*set_cmd_list));
- show_cmd_list = xmalloc (sizeof (*set_cmd_list));
+ set_cmd_list = XNEW (struct cmd_list_element *);
+ show_cmd_list = XNEW (struct cmd_list_element *);
*set_cmd_list = NULL;
*show_cmd_list = NULL;
#endif
}
+/* See defs.h. */
+
+void
+maybe_quit (void)
+{
+ if (check_quit_flag () || sync_quit_force_run)
+ quit ();
+ if (deprecated_interactive_hook)
+ deprecated_interactive_hook ();
+ target_check_pending_interrupt ();
+}
+
\f
/* Called when a memory allocation fails, with the number of bytes of
memory requested in SIZE. */
/* Print a host address. */
void
-gdb_print_host_address (const void *addr, struct ui_file *stream)
+gdb_print_host_address_1 (const void *addr, struct ui_file *stream)
{
fprintf_filtered (stream, "%s", host_address_to_string (addr));
}
char *
make_hex_string (const gdb_byte *data, size_t length)
{
- char *result = xmalloc (length * 2 + 1);
+ char *result = (char *) xmalloc (length * 2 + 1);
char *p;
size_t i;
static void
do_regfree_cleanup (void *r)
{
- regfree (r);
+ regfree ((regex_t *) r);
}
/* Create a new cleanup that frees the compiled regular expression R. */
get_regcomp_error (int code, regex_t *rx)
{
size_t length = regerror (code, rx, NULL, 0);
- char *result = xmalloc (length);
+ char *result = (char *) xmalloc (length);
regerror (code, rx, result, length);
return result;
\f
/* 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
+ be called for printing things which are independent of the language
of the program being debugged.
printchar will normally escape backslashes and instances of QUOTER. If
Only try to use tgetnum function if rl_get_screen_size
did not return a useful value. */
if (((rows <= 0) && (tgetnum ("li") < 0))
- /* Also disable paging if inside EMACS. */
- || getenv ("EMACS"))
+ /* Also disable paging if inside Emacs. $EMACS was used
+ before Emacs v25.1, $INSIDE_EMACS is used since then. */
+ || getenv ("EMACS") || getenv ("INSIDE_EMACS"))
{
/* The number of lines per page is not mentioned in the terminal
description or EMACS evironment variable is set. This probably
if (right)
spaces += width - stringlen;
- spacebuf = alloca (spaces + 1);
+ spacebuf = (char *) alloca (spaces + 1);
spacebuf[spaces] = '\0';
while (spaces--)
spacebuf[spaces] = ' ';
hashval_t
core_addr_hash (const void *ap)
{
- const CORE_ADDR *addrp = ap;
+ const CORE_ADDR *addrp = (const CORE_ADDR *) ap;
return *addrp;
}
int
core_addr_eq (const void *ap, const void *bp)
{
- const CORE_ADDR *addr_ap = ap;
- const CORE_ADDR *addr_bp = bp;
+ const CORE_ADDR *addr_ap = (const CORE_ADDR *) ap;
+ const CORE_ADDR *addr_bp = (const CORE_ADDR *) bp;
return *addr_ap == *addr_bp;
}
if (base_name == filename)
return xstrdup (filename);
- dir_name = alloca ((size_t) (base_name - filename + 2));
+ dir_name = (char *) alloca ((size_t) (base_name - filename + 2));
/* Allocate enough space to store the dir_name + plus one extra
character sometimes needed under Windows (see below), and
then the closing \000 character. */
if (base == filename)
return NULL;
- dirname = xmalloc (base - filename + 2);
+ dirname = (char *) xmalloc (base - filename + 2);
memcpy (dirname, filename, base - filename);
/* On DOS based file systems, convert "d:foo" to "d:.", so that we
+ strlen (AMBIGUOUS_MESS2);
for (p = matching; *p; p++)
ret_len += strlen (*p) + 1;
- ret = xmalloc (ret_len + 1);
+ ret = (char *) xmalloc (ret_len + 1);
retp = ret;
make_cleanup (xfree, ret);
static void
do_free_char_ptr_vec (void *arg)
{
- VEC (char_ptr) *char_ptr_vec = arg;
+ VEC (char_ptr) *char_ptr_vec = (VEC (char_ptr) *) arg;
free_char_ptr_vec (char_ptr_vec);
}
{
char *string_new;
- string_new = xrealloc (string, (strlen (string) + to_len + 1));
+ string_new
+ = (char *) xrealloc (string, (strlen (string) + to_len + 1));
/* Relocate the current S pointer. */
s = s - string + string_new;
sa.sa_flags = 0;
sigaction (SIGALRM, &sa, &old_sa);
#else
- void (*ofunc) ();
+ sighandler_t ofunc;
- ofunc = (void (*)()) signal (SIGALRM, sigalrm_handler);
+ ofunc = signal (SIGALRM, sigalrm_handler);
#endif
alarm (timeout);
/* Replace '\' by '/' in both strings. */
- pattern_slash = alloca (strlen (pattern) + 1);
+ pattern_slash = (char *) alloca (strlen (pattern) + 1);
strcpy (pattern_slash, pattern);
pattern = pattern_slash;
for (; *pattern_slash != 0; pattern_slash++)
if (IS_DIR_SEPARATOR (*pattern_slash))
*pattern_slash = '/';
- string_slash = alloca (strlen (string) + 1);
+ string_slash = (char *) alloca (strlen (string) + 1);
strcpy (string_slash, string);
string = string_slash;
for (; *string_slash != 0; string_slash++)
projects / deliverable / binutils-gdb.git / blobdiff