import gdb-1999-07-07 post reformat

1 files changed, 176 insertions, 172 deletions

diff --git a/gdb/remote-st.c b/gdb/remote-st.c
index 1efdbfa..79c6b42 100644
--- a/gdb/remote-st.c
+++ b/gdb/remote-st.c
@@ -2,27 +2,28 @@
    Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
    Contributed by Cygnus Support.  Written by Jim Kingdon for Cygnus.
 
-This file is part of GDB.
+   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 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.
+   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.  */
+   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.  */
 
 /* This file was derived from remote-eb.c, which did a similar job, but for
    an AMD-29K running EBMON.  That file was in turn derived from remote.c
    as mentioned in the following comment (left in for comic relief):
 
-  "This is like remote.c but is for an esoteric situation--
+   "This is like remote.c but is for an esoteric situation--
    having an a29k board in a PC hooked up to a unix machine with
    a serial line, and running ctty com1 on the PC, through which
    the unix machine can run ebmon.  Not to mention that the PC
@@ -48,11 +49,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include <sys/types.h>
 #include "serial.h"
 
-extern struct target_ops st2000_ops;		/* Forward declaration */
+extern struct target_ops st2000_ops;	/* Forward declaration */
 
-static void st2000_close();
-static void st2000_fetch_register();
-static void st2000_store_register();
+static void st2000_close ();
+static void st2000_fetch_register ();
+static void st2000_store_register ();
 
 #define LOG_FILE "st2000.log"
 #if defined (LOG_FILE)
@@ -71,9 +72,9 @@ static serial_t st2000_desc;
 
 static void
 #ifdef ANSI_PROTOTYPES
-printf_stdebug(char *pattern, ...)
+printf_stdebug (char *pattern,...)
 #else
-printf_stdebug(va_alist)
+printf_stdebug (va_alist)
      va_dcl
 #endif
 {
@@ -81,33 +82,33 @@ printf_stdebug(va_alist)
   char buf[200];
 
 #ifdef ANSI_PROTOTYPES
-  va_start(args, pattern);
+  va_start (args, pattern);
 #else
   char *pattern;
-  va_start(args);
-  pattern = va_arg(args, char *);
+  va_start (args);
+  pattern = va_arg (args, char *);
 #endif
 
-  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 (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
 }
 
 /* Read a character from the remote system, doing all the fancy timeout
    stuff.  */
 
 static int
-readchar(timeout)
+readchar (timeout)
      int timeout;
 {
   int c;
 
-  c = SERIAL_READCHAR(st2000_desc, timeout);
+  c = SERIAL_READCHAR (st2000_desc, timeout);
 
 #ifdef LOG_FILE
-  putc(c & 0x7f, log_file);
+  putc (c & 0x7f, log_file);
 #endif
 
   if (c >= 0)
@@ -118,17 +119,17 @@ readchar(timeout)
       if (timeout == 0)
 	return c;		/* Polls shouldn't generate timeout errors */
 
-      error("Timeout reading from remote system.");
+      error ("Timeout reading from remote system.");
     }
 
-  perror_with_name("remote-st2000");
+  perror_with_name ("remote-st2000");
 }
 
 /* Scan input from the remote system, until STRING is found.  If DISCARD is
    non-zero, then discard non-matching input, else print it out.
    Let the user break out immediately.  */
 static void
-expect(string, discard)
+expect (string, discard)
      char *string;
      int discard;
 {
@@ -138,7 +139,7 @@ expect(string, discard)
   immediate_quit = 1;
   while (1)
     {
-      c = readchar(timeout);
+      c = readchar (timeout);
       if (c == *p++)
 	{
 	  if (*p == '\0')
@@ -151,9 +152,9 @@ expect(string, discard)
 	{
 	  if (!discard)
 	    {
-	      fwrite(string, 1, (p - 1) - string, stdout);
-	      putchar((char)c);
-	      fflush(stdout);
+	      fwrite (string, 1, (p - 1) - string, stdout);
+	      putchar ((char) c);
+	      fflush (stdout);
 	    }
 	  p = string;
 	}
@@ -175,13 +176,13 @@ expect(string, discard)
    necessary to prevent getting into states from which we can't
    recover.  */
 static void
-expect_prompt(discard)
+expect_prompt (discard)
      int discard;
 {
 #if defined (LOG_FILE)
   /* This is a convenient place to do this.  The idea is to do it often
      enough that we never lose much data if we terminate abnormally.  */
-  fflush(log_file);
+  fflush (log_file);
 #endif
   expect ("dbug> ", discard);
 }
@@ -189,13 +190,13 @@ 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_hex_digit(ignore_space)
+get_hex_digit (ignore_space)
      int ignore_space;
 {
   int ch;
   while (1)
     {
-      ch = readchar(timeout);
+      ch = readchar (timeout);
       if (ch >= '0' && ch <= '9')
 	return ch - '0';
       else if (ch >= 'A' && ch <= 'F')
@@ -206,8 +207,8 @@ get_hex_digit(ignore_space)
 	;
       else
 	{
-	  expect_prompt(1);
-	  error("Invalid hex digit from remote system.");
+	  expect_prompt (1);
+	  error ("Invalid hex digit from remote system.");
 	}
     }
 }
@@ -238,7 +239,7 @@ get_hex_regs (n, regno)
   for (i = 0; i < n; i++)
     {
       int j;
-      
+
       val = 0;
       for (j = 0; j < 8; j++)
 	val = (val << 4) + get_hex_digit (j == 0);
@@ -257,10 +258,10 @@ st2000_create_inferior (execfile, args, env)
   int entry_pt;
 
   if (args && *args)
-    error("Can't pass arguments to remote STDEBUG process");
+    error ("Can't pass arguments to remote STDEBUG process");
 
   if (execfile == 0 || exec_bfd == 0)
-    error("No executable file specified");
+    error ("No executable file specified");
 
   entry_pt = (int) bfd_get_start_address (exec_bfd);
 
@@ -281,7 +282,7 @@ st2000_create_inferior (execfile, args, env)
 
   /* insert_step_breakpoint ();  FIXME, do we need this?  */
   /* Let 'er rip... */
-  proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
+  proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 }
 
 /* Open a connection to a remote debugger.
@@ -291,33 +292,33 @@ static int baudrate = 9600;
 static char dev_name[100];
 
 static void
-st2000_open(args, from_tty)
+st2000_open (args, from_tty)
      char *args;
      int from_tty;
 {
   int n;
   char junk[100];
 
-  target_preopen(from_tty);
-  
-  n = sscanf(args, " %s %d %s", dev_name, &baudrate, junk);
+  target_preopen (from_tty);
+
+  n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk);
 
   if (n != 2)
-    error("Bad arguments.  Usage: target st2000 <device> <speed>\n\
+    error ("Bad arguments.  Usage: target st2000 <device> <speed>\n\
 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);
+    perror_with_name (dev_name);
 
-  SERIAL_SETBAUDRATE(st2000_desc, baudrate);
+  SERIAL_SETBAUDRATE (st2000_desc, baudrate);
 
-  SERIAL_RAW(st2000_desc);
+  SERIAL_RAW (st2000_desc);
 
-  push_target(&st2000_ops);
+  push_target (&st2000_ops);
 
 #if defined (LOG_FILE)
   log_file = fopen (LOG_FILE, "w");
@@ -326,13 +327,13 @@ or target st2000 <host> <port>\n");
 #endif
 
   /* Hello?  Are you there?  */
-  printf_stdebug("\003");	/* ^C wakes up dbug */
-  
-  expect_prompt(1);
+  printf_stdebug ("\003");	/* ^C wakes up dbug */
+
+  expect_prompt (1);
 
   if (from_tty)
-    printf("Remote %s connected to %s\n", target_shortname,
-	   dev_name);
+    printf ("Remote %s connected to %s\n", target_shortname,
+	    dev_name);
 }
 
 /* Close out all files and local state before this target loses control. */
@@ -341,15 +342,16 @@ static void
 st2000_close (quitting)
      int quitting;
 {
-  SERIAL_CLOSE(st2000_desc);
+  SERIAL_CLOSE (st2000_desc);
 
 #if defined (LOG_FILE)
-  if (log_file) {
-    if (ferror(log_file))
-      fprintf(stderr, "Error writing log file.\n");
-    if (fclose(log_file) != 0)
-      fprintf(stderr, "Error closing log file.\n");
-  }
+  if (log_file)
+    {
+      if (ferror (log_file))
+	fprintf (stderr, "Error writing log file.\n");
+      if (fclose (log_file) != 0)
+	fprintf (stderr, "Error closing log file.\n");
+    }
 #endif
 }
 
@@ -360,11 +362,11 @@ static void
 st2000_detach (from_tty)
      int from_tty;
 {
-  pop_target();		/* calls st2000_close to do the real work */
+  pop_target ();		/* calls st2000_close to do the real work */
   if (from_tty)
     printf ("Ending remote %s debugging\n", target_shortname);
 }
- 
+
 /* Tell the remote machine to resume.  */
 
 static void
@@ -398,9 +400,9 @@ st2000_wait (status)
   status->kind = TARGET_WAITKIND_EXITED;
   status->value.integer = 0;
 
-  timeout = 0;		/* Don't time out -- user program is running. */
+  timeout = 0;			/* Don't time out -- user program is running. */
 
-  expect_prompt(0);    /* Wait for prompt, outputting extraneous text */
+  expect_prompt (0);		/* Wait for prompt, outputting extraneous text */
 
   status->kind = TARGET_WAITKIND_STOPPED;
   status->value.sig = TARGET_SIGNAL_TRAP;
@@ -425,7 +427,7 @@ get_reg_name (regno)
   b = buf;
 
   for (p = REGISTER_NAME (regno); *p; p++)
-    *b++ = toupper(*p);
+    *b++ = toupper (*p);
   *b = '\000';
 
   return buf;
@@ -442,7 +444,7 @@ st2000_fetch_registers ()
      very often...  I'll clean it up later.  */
 
   for (regno = 0; regno <= PC_REGNUM; regno++)
-    st2000_fetch_register(regno);
+    st2000_fetch_register (regno);
 }
 
 /* Fetch register REGNO, or all registers if REGNO is -1.
@@ -473,7 +475,7 @@ st2000_store_registers ()
   int regno;
 
   for (regno = 0; regno <= PC_REGNUM; regno++)
-    st2000_store_register(regno);
+    st2000_store_register (regno);
 
   registers_changed ();
 }
@@ -535,7 +537,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
-st2000_read_inferior_memory(memaddr, myaddr, len)
+st2000_read_inferior_memory (memaddr, myaddr, len)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
@@ -560,11 +562,12 @@ st2000_read_inferior_memory(memaddr, myaddr, len)
      st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
      doesn't need to work.  Detect it and give up if there's an attempt
      to do that.  */
-  if (((memaddr - 1) + len) < memaddr) {
-    errno = EIO;
-    return 0;
-  }
-  
+  if (((memaddr - 1) + len) < memaddr)
+    {
+      errno = EIO;
+      return 0;
+    }
+
   startaddr = memaddr;
   count = 0;
   while (count < len)
@@ -595,7 +598,7 @@ st2000_xfer_inferior_memory (memaddr, myaddr, len, write, target)
      char *myaddr;
      int len;
      int write;
-     struct target_ops *target;		/* ignored */
+     struct target_ops *target;	/* ignored */
 {
   if (write)
     return st2000_write_inferior_memory (memaddr, myaddr, len);
@@ -608,7 +611,7 @@ st2000_kill (args, from_tty)
      char *args;
      int from_tty;
 {
-  return;		/* Ignore attempts to kill target system */
+  return;			/* Ignore attempts to kill target system */
 }
 
 /* Clean up when a program exits.
@@ -627,7 +630,8 @@ st2000_mourn_inferior ()
 
 #define MAX_STDEBUG_BREAKPOINTS 16
 
-static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] = {0};
+static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] =
+{0};
 
 static int
 st2000_insert_breakpoint (addr, shadow)
@@ -646,12 +650,12 @@ st2000_insert_breakpoint (addr, shadow)
 	breakaddr[i] = addr;
 
 	st2000_read_inferior_memory (bp_addr, shadow, bp_size);
-	printf_stdebug("BR %x H\r", addr);
-	expect_prompt(1);
+	printf_stdebug ("BR %x H\r", addr);
+	expect_prompt (1);
 	return 0;
       }
 
-  fprintf(stderr, "Too many breakpoints (> 16) for STDBUG\n");
+  fprintf (stderr, "Too many breakpoints (> 16) for STDBUG\n");
   return 1;
 }
 
@@ -667,12 +671,12 @@ st2000_remove_breakpoint (addr, shadow)
       {
 	breakaddr[i] = 0;
 
-	printf_stdebug("CB %d\r", i);
-	expect_prompt(1);
+	printf_stdebug ("CB %d\r", i);
+	expect_prompt (1);
 	return 0;
       }
 
-  fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
+  fprintf (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
   return 1;
 }
 
@@ -682,29 +686,29 @@ st2000_remove_breakpoint (addr, shadow)
 
 static void
 st2000_command (args, fromtty)
-     char	*args;
-     int	fromtty;
+     char *args;
+     int fromtty;
 {
   if (!st2000_desc)
-    error("st2000 target not open.");
-  
+    error ("st2000 target not open.");
+
   if (!args)
-    error("Missing command.");
-	
-  printf_stdebug("%s\r", args);
-  expect_prompt(0);
+    error ("Missing command.");
+
+  printf_stdebug ("%s\r", args);
+  expect_prompt (0);
 }
 
 /* Connect the user directly to STDBUG.  This command acts just like the
    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 
-/*static struct ttystate ttystate;*/
+/*static struct ttystate ttystate; */
 
 static void
-cleanup_tty()
+cleanup_tty ()
 {
-  printf("\r\n[Exiting connect mode]\r\n");
-/*  SERIAL_RESTORE(0, &ttystate);*/
+  printf ("\r\n[Exiting connect mode]\r\n");
+/*  SERIAL_RESTORE(0, &ttystate); */
 }
 
 #if 0
@@ -712,50 +716,50 @@ cleanup_tty()
 
 static void
 connect_command (args, fromtty)
-     char	*args;
-     int	fromtty;
+     char *args;
+     int fromtty;
 {
   fd_set readfds;
   int numfds;
   int c;
   char cur_esc = 0;
 
-  dont_repeat();
+  dont_repeat ();
 
   if (st2000_desc < 0)
-    error("st2000 target not open.");
-  
+    error ("st2000 target not open.");
+
   if (args)
-    fprintf("This command takes no args.  They have been ignored.\n");
-	
-  printf("[Entering connect mode.  Use ~. or ~^D to escape]\n");
+    fprintf ("This command takes no args.  They have been ignored.\n");
 
-  serial_raw(0, &ttystate);
+  printf ("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 
-  make_cleanup(cleanup_tty, 0);
+  serial_raw (0, &ttystate);
 
-  FD_ZERO(&readfds);
+  make_cleanup (cleanup_tty, 0);
+
+  FD_ZERO (&readfds);
 
   while (1)
     {
       do
 	{
-	  FD_SET(0, &readfds);
-	  FD_SET(st2000_desc, &readfds);
-	  numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0);
+	  FD_SET (0, &readfds);
+	  FD_SET (st2000_desc, &readfds);
+	  numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
 	}
       while (numfds == 0);
 
       if (numfds < 0)
-	perror_with_name("select");
+	perror_with_name ("select");
 
-      if (FD_ISSET(0, &readfds))
+      if (FD_ISSET (0, &readfds))
 	{			/* tty input, send to stdebug */
-	  c = getchar();
+	  c = getchar ();
 	  if (c < 0)
-	    perror_with_name("connect");
+	    perror_with_name ("connect");
 
-	  printf_stdebug("%c", c);
+	  printf_stdebug ("%c", c);
 	  switch (cur_esc)
 	    {
 	    case 0:
@@ -776,16 +780,16 @@ connect_command (args, fromtty)
 	    }
 	}
 
-      if (FD_ISSET(st2000_desc, &readfds))
+      if (FD_ISSET (st2000_desc, &readfds))
 	{
 	  while (1)
 	    {
-	      c = readchar(0);
+	      c = readchar (0);
 	      if (c < 0)
 		break;
-	      putchar(c);
+	      putchar (c);
 	    }
-	  fflush(stdout);
+	  fflush (stdout);
 	}
     }
 }
@@ -793,43 +797,43 @@ connect_command (args, fromtty)
 
 /* Define the target subroutine names */
 
-struct target_ops st2000_ops ;
+struct target_ops st2000_ops;
 
-static void 
-init_st2000_ops(void)
+static void
+init_st2000_ops (void)
 {
-  st2000_ops.to_shortname =   "st2000";
-  st2000_ops.to_longname =   "Remote serial Tandem ST2000 target";
-  st2000_ops.to_doc =   "Use a remote computer running STDEBUG connected by a serial line;\n\
+  st2000_ops.to_shortname = "st2000";
+  st2000_ops.to_longname = "Remote serial Tandem ST2000 target";
+  st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\
 or a network connection.\n\
 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;
-  st2000_ops.to_attach =   0;
+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_xfer_memory  =   st2000_xfer_inferior_memory;
-  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_load  =   0;				/* load */
-  st2000_ops.to_lookup_symbol =   0;				/* lookup_symbol */
-  st2000_ops.to_create_inferior =   st2000_create_inferior;
+  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_xfer_memory = st2000_xfer_inferior_memory;
+  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_load = 0;	/* load */
+  st2000_ops.to_lookup_symbol = 0;	/* lookup_symbol */
+  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;
@@ -847,29 +851,29 @@ the speed to connect at in bits per second." ;
   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_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_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.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_sections =   0;
-  st2000_ops.to_sections_end =   0;				/* Section pointers */
-  st2000_ops.to_magic =   OPS_MAGIC;			/* Always the last thing */
-} ;
+  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_sections = 0;
+  st2000_ops.to_sections_end = 0;	/* Section pointers */
+  st2000_ops.to_magic = OPS_MAGIC;	/* Always the last thing */
+};
 
 void
 _initialize_remote_st2000 ()
 {
-  init_st2000_ops() ;
+  init_st2000_ops ();
   add_target (&st2000_ops);
   add_com ("st2000 <command>", class_obscure, st2000_command,
 	   "Send a command to the STDBUG monitor.");