#include "defs.h"
#include "gdbcore.h"
#include "target.h"
-#include "wait.h"
-#ifdef ANSI_PROTOTYPES
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
+#include "gdb_wait.h"
#include <signal.h>
#include "gdb_string.h"
#include <sys/types.h>
/* Send data to stdebug. Works just like printf. */
static void
-#ifdef ANSI_PROTOTYPES
printf_stdebug (char *pattern,...)
-#else
-printf_stdebug (va_alist)
- va_dcl
-#endif
{
va_list args;
char buf[200];
-#ifdef ANSI_PROTOTYPES
va_start (args, pattern);
-#else
- char *pattern;
- va_start (args);
- pattern = va_arg (args, char *);
-#endif
vsprintf (buf, pattern, args);
va_end (args);
stuff. */
static int
-readchar (timeout)
- int timeout;
+readchar (int timeout)
{
int c;
non-zero, then discard non-matching input, else print it out.
Let the user break out immediately. */
static void
-expect (string, discard)
- char *string;
- int discard;
+expect (char *string, int discard)
{
char *p = string;
int c;
necessary to prevent getting into states from which we can't
recover. */
static void
-expect_prompt (discard)
- int discard;
+expect_prompt (int discard)
{
#if defined (LOG_FILE)
/* This is a convenient place to do this. The idea is to do it often
/* Get a hex digit from the remote system & return its value.
If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
static int
-get_hex_digit (ignore_space)
- int ignore_space;
+get_hex_digit (int ignore_space)
{
int ch;
while (1)
/* Get a byte from stdebug and put it in *BYT. Accept any number
leading spaces. */
static void
-get_hex_byte (byt)
- char *byt;
+get_hex_byte (char *byt)
{
int val;
/* Get N 32-bit words from remote, each preceded by a space,
and put them in registers starting at REGNO. */
static void
-get_hex_regs (n, regno)
- int n;
- int regno;
+get_hex_regs (int n, int regno)
{
long val;
int i;
/* This is called not only when we first attach, but also when the
user types "run" after having attached. */
static void
-st2000_create_inferior (execfile, args, env)
- char *execfile;
- char *args;
- char **env;
+st2000_create_inferior (char *execfile, char *args, char **env)
{
int entry_pt;
static char dev_name[100];
static void
-st2000_open (args, from_tty)
- char *args;
- int from_tty;
+st2000_open (char *args, int from_tty)
{
int n;
char junk[100];
/* Close out all files and local state before this target loses control. */
static void
-st2000_close (quitting)
- int quitting;
+st2000_close (int quitting)
{
SERIAL_CLOSE (st2000_desc);
Use this when you want to detach and do something else
with your gdb. */
static void
-st2000_detach (from_tty)
- int from_tty;
+st2000_detach (int from_tty)
{
pop_target (); /* calls st2000_close to do the real work */
if (from_tty)
/* Tell the remote machine to resume. */
static void
-st2000_resume (pid, step, sig)
- int pid, step;
- enum target_signal sig;
+st2000_resume (int pid, int step, enum target_signal sig)
{
if (step)
{
storing status in STATUS just as `wait' would. */
static int
-st2000_wait (status)
- struct target_waitstatus *status;
+st2000_wait (struct target_waitstatus *status)
{
int old_timeout = timeout;
STDEBUG wants. Lets take advantage of that just as long as possible! */
static char *
-get_reg_name (regno)
- int regno;
+get_reg_name (int regno)
{
static char buf[50];
const char *p;
/* Read the remote registers into the block REGS. */
static void
-st2000_fetch_registers ()
+st2000_fetch_registers (void)
{
int regno;
/* Fetch register REGNO, or all registers if REGNO is -1.
Returns errno value. */
static void
-st2000_fetch_register (regno)
- int regno;
+st2000_fetch_register (int regno)
{
if (regno == -1)
st2000_fetch_registers ();
/* Store the remote registers from the contents of the block REGS. */
static void
-st2000_store_registers ()
+st2000_store_registers (void)
{
int regno;
/* Store register REGNO, or all if REGNO == 0.
Return errno value. */
static void
-st2000_store_register (regno)
- int regno;
+st2000_store_register (int regno)
{
if (regno == -1)
st2000_store_registers ();
debugged. */
static void
-st2000_prepare_to_store ()
+st2000_prepare_to_store (void)
{
/* Do nothing, since we can store individual regs */
}
static void
-st2000_files_info ()
+st2000_files_info (void)
{
printf ("\tAttached to %s at %d baud.\n",
dev_name, baudrate);
/* Copy LEN bytes of data from debugger memory at MYADDR
to inferior's memory at MEMADDR. Returns length moved. */
static int
-st2000_write_inferior_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- unsigned char *myaddr;
- int len;
+st2000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
{
int i;
/* Read LEN bytes from inferior memory at MEMADDR. Put the result
at debugger address MYADDR. Returns length moved. */
static int
-st2000_read_inferior_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+st2000_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
int i;
}
static void
-st2000_kill (args, from_tty)
- char *args;
- int from_tty;
+st2000_kill (char *args, int from_tty)
{
return; /* Ignore attempts to kill target system */
}
instructions. */
static void
-st2000_mourn_inferior ()
+st2000_mourn_inferior (void)
{
remove_breakpoints ();
unpush_target (&st2000_ops);
{0};
static int
-st2000_insert_breakpoint (addr, shadow)
- CORE_ADDR addr;
- char *shadow;
+st2000_insert_breakpoint (CORE_ADDR addr, char *shadow)
{
int i;
CORE_ADDR bp_addr = addr;
}
static int
-st2000_remove_breakpoint (addr, shadow)
- CORE_ADDR addr;
- char *shadow;
+st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
{
int i;
on the users terminal until the prompt is seen. */
static void
-st2000_command (args, fromtty)
- char *args;
- int fromtty;
+st2000_command (char *args, int fromtty)
{
if (!st2000_desc)
error ("st2000 target not open.");
/*static struct ttystate ttystate; */
static void
-cleanup_tty ()
+cleanup_tty (void)
{
printf ("\r\n[Exiting connect mode]\r\n");
/* SERIAL_RESTORE(0, &ttystate); */
/* This all should now be in serial.c */
static void
-connect_command (args, fromtty)
- char *args;
- int fromtty;
+connect_command (char *args, int fromtty)
{
fd_set readfds;
int numfds;
do
{
FD_SET (0, &readfds);
- FD_SET (st2000_desc, &readfds);
+ FD_SET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds);
numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
}
while (numfds == 0);
}
}
- if (FD_ISSET (st2000_desc, &readfds))
+ if (FD_ISSET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds))
{
while (1)
{
};
void
-_initialize_remote_st2000 ()
+_initialize_remote_st2000 (void)
{
init_st2000_ops ();
add_target (&st2000_ops);