Committed after testing and independent approval/endorsement.

[deliverable/binutils-gdb.git] / gdb / remote-st.c

diff --git a/gdb/remote-st.c b/gdb/remote-st.c
index e820b28e51a00637333fa7accc73eb1ae2673a41..ce4c7ab13e5cf6a63e2445ca94e61d287f5e927c 100644 (file)
--- a/gdb/remote-st.c
+++ b/gdb/remote-st.c
@@ -1,5 +1,8 @@
 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.

-   Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
+
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000,
+   2001, 2002 Free Software Foundation, Inc.
+

    Contributed by Cygnus Support.  Written by Jim Kingdon for Cygnus.
 
    This file is part of GDB.
    Contributed by Cygnus Support.  Written by Jim Kingdon for Cygnus.
 
    This file is part of GDB.


@@ -38,11 +41,10 @@
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"

-#include "gdb_wait.h"
-#include <signal.h>

 #include "gdb_string.h"
 #include <sys/types.h>
 #include "serial.h"
 #include "gdb_string.h"
 #include <sys/types.h>
 #include "serial.h"

+#include "regcache.h"

 
 extern struct target_ops st2000_ops;   /* Forward declaration */
 
 
 extern struct target_ops st2000_ops;   /* Forward declaration */
 


@@ -61,7 +63,7 @@ static int timeout = 24;
    st2000_open knows that we don't have a file open when the program
    starts.  */
 
    st2000_open knows that we don't have a file open when the program
    starts.  */
 

-static serial_t st2000_desc;
+static struct serial *st2000_desc;

 
 /* Send data to stdebug.  Works just like printf. */
 
 
 /* Send data to stdebug.  Works just like printf. */
 


@@ -76,20 +78,20 @@ printf_stdebug (char *pattern,...)
   vsprintf (buf, pattern, args);
   va_end (args);
 
   vsprintf (buf, pattern, args);
   va_end (args);
 

-  if (SERIAL_WRITE (st2000_desc, buf, strlen (buf)))
-    fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
+  if (serial_write (st2000_desc, buf, strlen (buf)))
+    fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
+                       safe_strerror (errno));

 }
 
 /* Read a character from the remote system, doing all the fancy timeout
    stuff.  */
 
 static int
 }
 
 /* Read a character from the remote system, doing all the fancy timeout
    stuff.  */
 
 static int

-readchar (timeout)
-     int timeout;
+readchar (int timeout)

 {
   int c;
 
 {
   int c;
 

-  c = SERIAL_READCHAR (st2000_desc, timeout);
+  c = serial_readchar (st2000_desc, timeout);

 
 #ifdef LOG_FILE
   putc (c & 0x7f, log_file);
 
 #ifdef LOG_FILE
   putc (c & 0x7f, log_file);


@@ -113,14 +115,12 @@ readchar (timeout)
    non-zero, then discard non-matching input, else print it out.
    Let the user break out immediately.  */
 static void
    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;
 
 {
   char *p = string;
   int c;
 

-  immediate_quit = 1;
+  immediate_quit++;

   while (1)
     {
       c = readchar (timeout);
   while (1)
     {
       c = readchar (timeout);


@@ -128,7 +128,7 @@ expect (string, discard)
        {
          if (*p == '\0')
            {
        {
          if (*p == '\0')
            {

-             immediate_quit = 0;
+             immediate_quit--;

              return;
            }
        }
              return;
            }
        }


@@ -160,8 +160,7 @@ expect (string, discard)
    necessary to prevent getting into states from which we can't
    recover.  */
 static void
    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
 {
 #if defined (LOG_FILE)
   /* This is a convenient place to do this.  The idea is to do it often


@@ -174,8 +173,7 @@ expect_prompt (discard)
 /* 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 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)
 {
   int ch;
   while (1)


@@ -200,8 +198,7 @@ get_hex_digit (ignore_space)
 /* Get a byte from stdebug and put it in *BYT.  Accept any number
    leading spaces.  */
 static void
 /* 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;
 
 {
   int val;
 


@@ -213,9 +210,7 @@ get_hex_byte (byt)
 /* Get N 32-bit words from remote, each preceded by a space,
    and put them in registers starting at REGNO.  */
 static void
 /* 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;
 {
   long val;
   int i;


@@ -234,10 +229,7 @@ get_hex_regs (n, regno)
 /* This is called not only when we first attach, but also when the
    user types "run" after having attached.  */
 static void
 /* 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;
 
 {
   int entry_pt;
 


@@ -276,9 +268,7 @@ static int baudrate = 9600;
 static char dev_name[100];
 
 static void
 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];
 {
   int n;
   char junk[100];


@@ -293,14 +283,18 @@ or target st2000 <host> <port>\n");
 
   st2000_close (0);
 
 
   st2000_close (0);
 

-  st2000_desc = SERIAL_OPEN (dev_name);
+  st2000_desc = serial_open (dev_name);

 
   if (!st2000_desc)
     perror_with_name (dev_name);
 
 
   if (!st2000_desc)
     perror_with_name (dev_name);
 

-  SERIAL_SETBAUDRATE (st2000_desc, baudrate);
+  if (serial_setbaudrate (st2000_desc, baudrate))
+    {
+      serial_close (dev_name);
+      perror_with_name (dev_name);
+    }

 
 

-  SERIAL_RAW (st2000_desc);
+  serial_raw (st2000_desc);

 
   push_target (&st2000_ops);
 
 
   push_target (&st2000_ops);
 


@@ -323,18 +317,17 @@ or target st2000 <host> <port>\n");
 /* Close out all files and local state before this target loses control. */
 
 static void
 /* 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);
+  serial_close (st2000_desc);

 
 #if defined (LOG_FILE)
   if (log_file)
     {
       if (ferror (log_file))
 
 #if defined (LOG_FILE)
   if (log_file)
     {
       if (ferror (log_file))

-       fprintf (stderr, "Error writing log file.\n");
+       fprintf_unfiltered (gdb_stderr, "Error writing log file.\n");

       if (fclose (log_file) != 0)
       if (fclose (log_file) != 0)

-       fprintf (stderr, "Error closing log file.\n");
+       fprintf_unfiltered (gdb_stderr, "Error closing log file.\n");

     }
 #endif
 }
     }
 #endif
 }


@@ -343,8 +336,7 @@ st2000_close (quitting)
    Use this when you want to detach and do something else
    with your gdb.  */
 static void
    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)
 {
   pop_target ();               /* calls st2000_close to do the real work */
   if (from_tty)


@@ -354,9 +346,7 @@ st2000_detach (from_tty)
 /* Tell the remote machine to resume.  */
 
 static void
 /* Tell the remote machine to resume.  */
 
 static void

-st2000_resume (pid, step, sig)
-     int pid, step;
-     enum target_signal sig;
+st2000_resume (ptid_t ptid, int step, enum target_signal sig)

 {
   if (step)
     {
 {
   if (step)
     {


@@ -375,9 +365,8 @@ st2000_resume (pid, step, sig)
 /* Wait until the remote machine stops, then return,
    storing status in STATUS just as `wait' would.  */
 
 /* Wait until the remote machine stops, then return,
    storing status in STATUS just as `wait' would.  */
 

-static int
-st2000_wait (status)
-     struct target_waitstatus *status;
+static ptid_t
+st2000_wait (ptid_t ptid, struct target_waitstatus *status)

 {
   int old_timeout = timeout;
 
 {
   int old_timeout = timeout;
 


@@ -393,16 +382,16 @@ st2000_wait (status)
 
   timeout = old_timeout;
 
 
   timeout = old_timeout;
 

-  return 0;
+  return inferior_ptid;

 }
 
 }
 

-/* Return the name of register number REGNO in the form input and output by
-   STDEBUG.  Currently, REGISTER_NAMES just happens to contain exactly what
-   STDEBUG wants.  Lets take advantage of that just as long as possible! */
+/* Return the name of register number REGNO in the form input and
+   output by STDEBUG.  Currently, REGISTER_NAME just happens return
+   exactly what STDEBUG wants.  Lets take advantage of that just as
+   long as possible! */

 
 static char *
 
 static char *

-get_reg_name (regno)
-     int regno;
+get_reg_name (int regno)

 {
   static char buf[50];
   const char *p;
 {
   static char buf[50];
   const char *p;


@@ -420,7 +409,7 @@ get_reg_name (regno)
 /* Read the remote registers into the block REGS.  */
 
 static void
 /* Read the remote registers into the block REGS.  */
 
 static void

-st2000_fetch_registers ()
+st2000_fetch_registers (void)

 {
   int regno;
 
 {
   int regno;
 


@@ -434,8 +423,7 @@ st2000_fetch_registers ()
 /* Fetch register REGNO, or all registers if REGNO is -1.
    Returns errno value.  */
 static void
 /* 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 ();
 {
   if (regno == -1)
     st2000_fetch_registers ();


@@ -454,7 +442,7 @@ st2000_fetch_register (regno)
 /* Store the remote registers from the contents of the block REGS.  */
 
 static void
 /* Store the remote registers from the contents of the block REGS.  */
 
 static void

-st2000_store_registers ()
+st2000_store_registers (void)

 {
   int regno;
 
 {
   int regno;
 


@@ -467,8 +455,7 @@ st2000_store_registers ()
 /* Store register REGNO, or all if REGNO == 0.
    Return errno value.  */
 static void
 /* 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 ();
 {
   if (regno == -1)
     st2000_store_registers ();


@@ -488,13 +475,13 @@ st2000_store_register (regno)
    debugged.  */
 
 static void
    debugged.  */
 
 static void

-st2000_prepare_to_store ()
+st2000_prepare_to_store (void)

 {
   /* Do nothing, since we can store individual regs */
 }
 
 static 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);
 {
   printf ("\tAttached to %s at %d baud.\n",
          dev_name, baudrate);


@@ -503,10 +490,7 @@ st2000_files_info ()
 /* Copy LEN bytes of data from debugger memory at MYADDR
    to inferior's memory at MEMADDR.  Returns length moved.  */
 static int
 /* 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;
 
 {
   int i;
 


@@ -521,10 +505,7 @@ st2000_write_inferior_memory (memaddr, myaddr, len)
 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
    at debugger address MYADDR.  Returns length moved.  */
 static int
 /* 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;
 
 {
   int i;
 


@@ -575,14 +556,16 @@ st2000_read_inferior_memory (memaddr, myaddr, len)
   return len;
 }
 
   return len;
 }
 

-/* FIXME-someday!  Merge these two.  */
+/* Transfer LEN bytes between GDB address MYADDR and target address
+   MEMADDR.  If WRITE is non-zero, transfer them to the target,
+   otherwise transfer them from the target.  TARGET is unused.
+
+   Returns the number of bytes transferred. */
+

 static int
 static int

-st2000_xfer_inferior_memory (memaddr, myaddr, len, write, target)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int write;
-     struct target_ops *target;        /* ignored */
+st2000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
+                            int write, struct mem_attrib *attrib,
+                            struct target_ops *target)

 {
   if (write)
     return st2000_write_inferior_memory (memaddr, myaddr, len);
 {
   if (write)
     return st2000_write_inferior_memory (memaddr, myaddr, len);


@@ -591,9 +574,7 @@ st2000_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 }
 
 static void
 }
 
 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 */
 }
 {
   return;                      /* Ignore attempts to kill target system */
 }


@@ -605,7 +586,7 @@ st2000_kill (args, from_tty)
    instructions.  */
 
 static void
    instructions.  */
 
 static void

-st2000_mourn_inferior ()
+st2000_mourn_inferior (void)

 {
   remove_breakpoints ();
   unpush_target (&st2000_ops);
 {
   remove_breakpoints ();
   unpush_target (&st2000_ops);


@@ -618,9 +599,7 @@ static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] =
 {0};
 
 static int
 {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;
 {
   int i;
   CORE_ADDR bp_addr = addr;


@@ -639,14 +618,12 @@ st2000_insert_breakpoint (addr, shadow)
        return 0;
       }
 
        return 0;
       }
 

-  fprintf (stderr, "Too many breakpoints (> 16) for STDBUG\n");
+  fprintf_unfiltered (gdb_stderr, "Too many breakpoints (> 16) for STDBUG\n");

   return 1;
 }
 
 static int
   return 1;
 }
 
 static int

-st2000_remove_breakpoint (addr, shadow)
-     CORE_ADDR addr;
-     char *shadow;
+st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)

 {
   int i;
 
 {
   int i;
 


@@ -660,7 +637,8 @@ st2000_remove_breakpoint (addr, shadow)
        return 0;
       }
 
        return 0;
       }
 

-  fprintf (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
+  fprintf_unfiltered (gdb_stderr,
+                     "Can't find breakpoint associated with 0x%x\n", addr);

   return 1;
 }
 
   return 1;
 }
 


@@ -669,9 +647,7 @@ st2000_remove_breakpoint (addr, shadow)
    on the users terminal until the prompt is seen. */
 
 static void
    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.");
 {
   if (!st2000_desc)
     error ("st2000 target not open.");


@@ -689,19 +665,17 @@ st2000_command (args, fromtty)
 /*static struct ttystate ttystate; */
 
 static void
 /*static struct ttystate ttystate; */
 
 static void

-cleanup_tty ()
+cleanup_tty (void)

 {
   printf ("\r\n[Exiting connect mode]\r\n");
 {
   printf ("\r\n[Exiting connect mode]\r\n");

-/*  SERIAL_RESTORE(0, &ttystate); */
+/*  serial_restore(0, &ttystate); */

 }
 
 #if 0
 /* This all should now be in serial.c */
 
 static void
 }
 
 #if 0
 /* 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;
 {
   fd_set readfds;
   int numfds;


@@ -729,7 +703,7 @@ connect_command (args, fromtty)
       do
        {
          FD_SET (0, &readfds);
       do
        {
          FD_SET (0, &readfds);

-         FD_SET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds);
+         FD_SET (deprecated_serial_fd (st2000_desc), &readfds);

          numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
        }
       while (numfds == 0);
          numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
        }
       while (numfds == 0);


@@ -764,7 +738,7 @@ connect_command (args, fromtty)
            }
        }
 
            }
        }
 

-      if (FD_ISSET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds))
+      if (FD_ISSET (deprecated_serial_fd (st2000_desc), &readfds))

        {
          while (1)
            {
        {
          while (1)
            {


@@ -794,14 +768,9 @@ Arguments are the name of the device for the serial line,\n\
 the speed to connect at in bits per second.";
   st2000_ops.to_open = st2000_open;
   st2000_ops.to_close = st2000_close;
 the speed to connect at in bits per second.";
   st2000_ops.to_open = st2000_open;
   st2000_ops.to_close = st2000_close;

-  st2000_ops.to_attach = 0;
-  st2000_run_ops.to_post_attach = NULL;
-  st2000_ops.to_require_attach = NULL;

   st2000_ops.to_detach = st2000_detach;
   st2000_ops.to_detach = st2000_detach;

-  st2000_ops.to_require_detach = NULL;

   st2000_ops.to_resume = st2000_resume;
   st2000_ops.to_wait = st2000_wait;
   st2000_ops.to_resume = st2000_resume;
   st2000_ops.to_wait = st2000_wait;

-  st2000_ops.to_post_wait = NULL;

   st2000_ops.to_fetch_registers = st2000_fetch_register;
   st2000_ops.to_store_registers = st2000_store_register;
   st2000_ops.to_prepare_to_store = st2000_prepare_to_store;
   st2000_ops.to_fetch_registers = st2000_fetch_register;
   st2000_ops.to_store_registers = st2000_store_register;
   st2000_ops.to_prepare_to_store = st2000_prepare_to_store;


@@ -809,53 +778,20 @@ the speed to connect at in bits per second.";
   st2000_ops.to_files_info = st2000_files_info;
   st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
   st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint;  /* Breakpoints */
   st2000_ops.to_files_info = st2000_files_info;
   st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
   st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint;  /* Breakpoints */

-  st2000_ops.to_terminal_init = 0;
-  st2000_ops.to_terminal_inferior = 0;
-  st2000_ops.to_terminal_ours_for_output = 0;
-  st2000_ops.to_terminal_ours = 0;
-  st2000_ops.to_terminal_info = 0;     /* Terminal handling */

   st2000_ops.to_kill = st2000_kill;
   st2000_ops.to_kill = st2000_kill;

-  st2000_ops.to_load = 0;      /* load */
-  st2000_ops.to_lookup_symbol = 0;     /* lookup_symbol */

   st2000_ops.to_create_inferior = st2000_create_inferior;
   st2000_ops.to_create_inferior = st2000_create_inferior;

-  st2000_ops.to_post_startup_inferior = NULL;
-  st2000_ops.to_acknowledge_created_inferior = NULL;
-  st2000_ops.to_clone_and_follow_inferior = NULL;
-  st2000_ops.to_post_follow_inferior_by_clone = NULL;
-  st2000_run_ops.to_insert_fork_catchpoint = NULL;
-  st2000_run_ops.to_remove_fork_catchpoint = NULL;
-  st2000_run_ops.to_insert_vfork_catchpoint = NULL;
-  st2000_run_ops.to_remove_vfork_catchpoint = NULL;
-  st2000_ops.to_has_forked = NULL;
-  st2000_ops.to_has_vforked = NULL;
-  st2000_run_ops.to_can_follow_vfork_prior_to_exec = NULL;
-  st2000_ops.to_post_follow_vfork = NULL;
-  st2000_run_ops.to_insert_exec_catchpoint = NULL;
-  st2000_run_ops.to_remove_exec_catchpoint = NULL;
-  st2000_run_ops.to_has_execd = NULL;
-  st2000_run_ops.to_reported_exec_events_per_exec_call = NULL;
-  st2000_run_ops.to_has_exited = NULL;

   st2000_ops.to_mourn_inferior = st2000_mourn_inferior;
   st2000_ops.to_mourn_inferior = st2000_mourn_inferior;

-  st2000_ops.to_can_run = 0;   /* can_run */
-  st2000_ops.to_notice_signals = 0;    /* notice_signals */
-  st2000_ops.to_thread_alive = 0;      /* thread alive */
-  st2000_ops.to_stop = 0;      /* to_stop */
-  st2000_ops.to_pid_to_exec_file = NULL;
-  st2000_run_ops.to_core_file_to_sym_file = NULL;

   st2000_ops.to_stratum = process_stratum;
   st2000_ops.to_stratum = process_stratum;

-  st2000_ops.DONT_USE = 0;     /* next */

   st2000_ops.to_has_all_memory = 1;
   st2000_ops.to_has_memory = 1;
   st2000_ops.to_has_stack = 1;
   st2000_ops.to_has_registers = 1;
   st2000_ops.to_has_execution = 1;     /* all mem, mem, stack, regs, exec */
   st2000_ops.to_has_all_memory = 1;
   st2000_ops.to_has_memory = 1;
   st2000_ops.to_has_stack = 1;
   st2000_ops.to_has_registers = 1;
   st2000_ops.to_has_execution = 1;     /* all mem, mem, stack, regs, exec */

-  st2000_ops.to_sections = 0;
-  st2000_ops.to_sections_end = 0;      /* Section pointers */

   st2000_ops.to_magic = OPS_MAGIC;     /* Always the last thing */
 };
 
 void
   st2000_ops.to_magic = OPS_MAGIC;     /* Always the last thing */
 };
 
 void

-_initialize_remote_st2000 ()
+_initialize_remote_st2000 (void)

 {
   init_st2000_ops ();
   add_target (&st2000_ops);
 {
   init_st2000_ops ();
   add_target (&st2000_ops);