import gdb-1999-07-07 post reformat

1 files changed, 226 insertions, 215 deletions

diff --git a/gdb/remote-nindy.c b/gdb/remote-nindy.c
index 58e89b8..9a25986 100644
--- a/gdb/remote-nindy.c
+++ b/gdb/remote-nindy.c
@@ -2,29 +2,29 @@
    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
    Contributed by Intel Corporation.  Modified from remote.c by Chris Benenati.
 
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY.  No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License.  A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities.  It
-should be in a file named COPYING.  Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther.  Help stamp out software hoarding!
-*/
+   GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY.  No author or distributor accepts responsibility to anyone
+   for the consequences of using it or for whether it serves any
+   particular purpose or works at all, unless he says so in writing.
+   Refer to the GDB General Public License for full details.
+
+   Everyone is granted permission to copy, modify and redistribute GDB,
+   but only under the conditions described in the GDB General Public
+   License.  A copy of this license is supposed to have been given to you
+   along with GDB so you can know your rights and responsibilities.  It
+   should be in a file named COPYING.  Among other things, the copyright
+   notice and this notice must be preserved on all copies.
+
+   In other words, go ahead and share GDB, but don't try to stop
+   anyone else from sharing it farther.  Help stamp out software hoarding!
+ */
 
 /*
-Except for the data cache routines, this file bears little resemblence
-to remote.c.  A new (although similar) protocol has been specified, and
-portions of the code are entirely dependent on having an i80960 with a
-NINDY ROM monitor at the other end of the line.
-*/
+   Except for the data cache routines, this file bears little resemblence
+   to remote.c.  A new (although similar) protocol has been specified, and
+   portions of the code are entirely dependent on having an i80960 with a
+   NINDY ROM monitor at the other end of the line.
+ */
 
 /*****************************************************************************
  *
@@ -121,9 +121,9 @@ NINDY ROM monitor at the other end of the line.
 
 static DCACHE *nindy_dcache;
 
-extern int unlink();
-extern char *getenv();
-extern char *mktemp();
+extern int unlink ();
+extern char *getenv ();
+extern char *mktemp ();
 
 extern void generic_mourn_inferior ();
 
@@ -134,12 +134,12 @@ extern char ninStopWhy ();
 extern int ninMemGet ();
 extern int ninMemPut ();
 
-int nindy_initial_brk;	/* nonzero if want to send an initial BREAK to nindy */
-int nindy_old_protocol;	/* nonzero if want to use old protocol */
-char *nindy_ttyname;	/* name of tty to talk to nindy on, or null */
+int nindy_initial_brk;		/* nonzero if want to send an initial BREAK to nindy */
+int nindy_old_protocol;		/* nonzero if want to use old protocol */
+char *nindy_ttyname;		/* name of tty to talk to nindy on, or null */
 
-#define DLE	'\020'	/* Character NINDY sends to indicate user program has
-			 * halted.  */
+#define DLE	'\020'		/* Character NINDY sends to indicate user program has
+				   * halted.  */
 #define TRUE	1
 #define FALSE	0
 
@@ -149,7 +149,7 @@ extern serial_t nindy_serial;
 static int have_regs = 0;	/* 1 iff regs read since i960 last halted */
 static int regs_changed = 0;	/* 1 iff regs were modified since last read */
 
-extern char *exists();
+extern char *exists ();
 
 static void
 nindy_fetch_registers PARAMS ((int));
@@ -178,8 +178,8 @@ nindy_close (quitting)
    and initial_brk).  */
 void
 nindy_open (name, from_tty)
-    char *name;		/* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
-    int from_tty;
+     char *name;		/* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
+     int from_tty;
 {
   char baudrate[1024];
 
@@ -191,7 +191,7 @@ nindy_open (name, from_tty)
   nindy_close (0);
 
   have_regs = regs_changed = 0;
-  nindy_dcache = dcache_init(ninMemGet, ninMemPut);
+  nindy_dcache = dcache_init (ninMemGet, ninMemPut);
 
   /* Allow user to interrupt the following -- we could hang if there's
      no NINDY at the other end of the remote tty.  */
@@ -199,9 +199,9 @@ nindy_open (name, from_tty)
   /* If baud_rate is -1, then ninConnect will not recognize the baud rate
      and will deal with the situation in a (more or less) reasonable
      fashion.  */
-  sprintf(baudrate, "%d", baud_rate);
-  ninConnect(name, baudrate,
-	     nindy_initial_brk, !from_tty, nindy_old_protocol);
+  sprintf (baudrate, "%d", baud_rate);
+  ninConnect (name, baudrate,
+	      nindy_initial_brk, !from_tty, nindy_old_protocol);
   immediate_quit--;
 
   if (nindy_serial == NULL)
@@ -212,7 +212,7 @@ nindy_open (name, from_tty)
   savename = savestring (name, strlen (name));
   push_target (&nindy_ops);
 
-  target_fetch_registers(-1);
+  target_fetch_registers (-1);
 
   init_thread_list ();
   init_wait_for_inferior ();
@@ -236,10 +236,10 @@ static void
 nindy_files_info ()
 {
   /* FIXME: this lies about the baud rate if we autobauded.  */
-  printf_unfiltered("\tAttached to %s at %d bits per second%s%s.\n", savename,
-	 baud_rate,
-	 nindy_old_protocol? " in old protocol": "",
-         nindy_initial_brk? " with initial break": "");
+  printf_unfiltered ("\tAttached to %s at %d bits per second%s%s.\n", savename,
+		     baud_rate,
+		     nindy_old_protocol ? " in old protocol" : "",
+		     nindy_initial_brk ? " with initial break" : "");
 }
 
 /* Return the number of characters in the buffer before
@@ -247,17 +247,19 @@ nindy_files_info ()
 
 static
 int
-non_dle( buf, n )
-    char *buf;		/* Character buffer; NOT '\0'-terminated */
-    int n;		/* Number of characters in buffer */
+non_dle (buf, n)
+     char *buf;			/* Character buffer; NOT '\0'-terminated */
+     int n;			/* Number of characters in buffer */
 {
   int i;
 
-  for ( i = 0; i < n; i++ ){
-    if ( buf[i] == DLE ){
-      break;
+  for (i = 0; i < n; i++)
+    {
+      if (buf[i] == DLE)
+	{
+	  break;
+	}
     }
-  }
   return i;
 }
 
@@ -271,14 +273,14 @@ nindy_resume (pid, step, siggnal)
   if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
     warning ("Can't send signals to remote NINDY targets.");
 
-  dcache_flush(nindy_dcache);
-  if ( regs_changed )
+  dcache_flush (nindy_dcache);
+  if (regs_changed)
     {
       nindy_store_registers (-1);
       regs_changed = 0;
     }
   have_regs = 0;
-  ninGo( step );
+  ninGo (step);
 }
 
 /* FIXME, we can probably use the normal terminal_inferior stuff here.
@@ -286,11 +288,12 @@ nindy_resume (pid, step, siggnal)
    settings initially.  Thereafter, terminal_ours and terminal_inferior
    will automatically swap the settings around for us.  */
 
-struct clean_up_tty_args {
+struct clean_up_tty_args
+{
   serial_ttystate state;
   serial_t serial;
 };
-static  struct clean_up_tty_args tty_args;
+static struct clean_up_tty_args tty_args;
 
 static void
 clean_up_tty (ptrarg)
@@ -303,22 +306,22 @@ clean_up_tty (ptrarg)
 }
 
 /* Recover from ^Z or ^C while remote process is running */
-static void (*old_ctrlc)();  
+static void (*old_ctrlc) ();
 #ifdef SIGTSTP
-static void (*old_ctrlz)();
+static void (*old_ctrlz) ();
 #endif
 
 static void
-clean_up_int()
+clean_up_int ()
 {
   SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
   free (tty_args.state);
 
-  signal(SIGINT, old_ctrlc);
+  signal (SIGINT, old_ctrlc);
 #ifdef SIGTSTP
-  signal(SIGTSTP, old_ctrlz);
+  signal (SIGTSTP, old_ctrlz);
 #endif
-  error("\n\nYou may need to reset the 80960 and/or reload your program.\n");
+  error ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
 }
 
 /* Wait until the remote machine stops. While waiting, operate in passthrough
@@ -329,9 +332,9 @@ clean_up_int()
  */
 
 static int
-nindy_wait( pid, status )
-    int pid;
-    struct target_waitstatus *status;
+nindy_wait (pid, status)
+     int pid;
+     struct target_waitstatus *status;
 {
   fd_set fds;
   int c;
@@ -350,9 +353,9 @@ nindy_wait( pid, status )
   /* Save current tty attributes, and restore them when done.  */
   tty_args.serial = SERIAL_FDOPEN (0);
   tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
-  old_ctrlc = signal( SIGINT, clean_up_int );
+  old_ctrlc = signal (SIGINT, clean_up_int);
 #ifdef SIGTSTP
-  old_ctrlz = signal( SIGTSTP, clean_up_int );
+  old_ctrlz = signal (SIGTSTP, clean_up_int);
 #endif
 
   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
@@ -371,36 +374,36 @@ nindy_wait( pid, status )
 	{
 	  error ("Cannot read from serial line");
 	}
-      else if (c == 0x1b) /* ESC */
+      else if (c == 0x1b)	/* ESC */
 	{
 	  c = SERIAL_READCHAR (nindy_serial, -1);
 	  c &= ~0x40;
-	} 
-      else if (c != 0x10) /* DLE */
+	}
+      else if (c != 0x10)	/* DLE */
 	/* Write out any characters preceding DLE */
 	{
-	  buf[0] = (char)c;
+	  buf[0] = (char) c;
 	  write (1, buf, 1);
 	}
       else
 	{
-	  stop_exit = ninStopWhy(&stop_code,
-				 &ip_value, &fp_value, &sp_value);
+	  stop_exit = ninStopWhy (&stop_code,
+				  &ip_value, &fp_value, &sp_value);
 	  if (!stop_exit && (stop_code == STOP_SRQ))
 	    {
 	      immediate_quit++;
-	      ninSrq();
+	      ninSrq ();
 	      immediate_quit--;
 	    }
 	  else
 	    {
 	      /* Get out of loop */
-	      supply_register (IP_REGNUM, 
-			       (char *)&ip_value);
-	      supply_register (FP_REGNUM, 
-			       (char *)&fp_value);
-	      supply_register (SP_REGNUM, 
-			       (char *)&sp_value);
+	      supply_register (IP_REGNUM,
+			       (char *) &ip_value);
+	      supply_register (FP_REGNUM,
+			       (char *) &fp_value);
+	      supply_register (SP_REGNUM,
+			       (char *) &sp_value);
 	      break;
 	    }
 	}
@@ -429,59 +432,60 @@ nindy_wait( pid, status )
 /* Read the remote registers into the block REGS.  */
 
 /* This is the block that ninRegsGet and ninRegsPut handles.  */
-struct nindy_regs {
-  char	local_regs[16 * 4];
-  char	global_regs[16 * 4];
-  char	pcw_acw[2 * 4];
-  char	ip[4];
-  char	tcw[4];
-  char	fp_as_double[4 * 8];
+struct nindy_regs
+{
+  char local_regs[16 * 4];
+  char global_regs[16 * 4];
+  char pcw_acw[2 * 4];
+  char ip[4];
+  char tcw[4];
+  char fp_as_double[4 * 8];
 };
 
 static void
-nindy_fetch_registers(regno)
+nindy_fetch_registers (regno)
      int regno;
 {
   struct nindy_regs nindy_regs;
   int regnum;
 
   immediate_quit++;
-  ninRegsGet( (char *) &nindy_regs );
+  ninRegsGet ((char *) &nindy_regs);
   immediate_quit--;
 
-  memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16*4);
-  memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16*4);
-  memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4);
-  memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4);
-  memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4);
+  memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16 * 4);
+  memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16 * 4);
+  memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2 * 4);
+  memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1 * 4);
+  memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1 * 4);
   memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8);
 
   registers_fetched ();
 }
 
 static void
-nindy_prepare_to_store()
+nindy_prepare_to_store ()
 {
   /* Fetch all regs if they aren't already here.  */
   read_register_bytes (0, NULL, REGISTER_BYTES);
 }
 
 static void
-nindy_store_registers(regno)
+nindy_store_registers (regno)
      int regno;
 {
   struct nindy_regs nindy_regs;
   int regnum;
 
-  memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16*4);
-  memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16*4);
-  memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2*4);
-  memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1*4);
-  memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1*4);
-  memcpy (nindy_regs.fp_as_double, &registers[REGISTER_BYTE (FP0_REGNUM)], 8*4);
+  memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16 * 4);
+  memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16 * 4);
+  memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2 * 4);
+  memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1 * 4);
+  memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1 * 4);
+  memcpy (nindy_regs.fp_as_double, &registers[REGISTER_BYTE (FP0_REGNUM)], 8 * 4);
 
   immediate_quit++;
-  ninRegsPut( (char *) &nindy_regs );
+  ninRegsPut ((char *) &nindy_regs);
   immediate_quit--;
 }
 
@@ -492,7 +496,7 @@ int
 nindy_fetch_word (addr)
      CORE_ADDR addr;
 {
-	return dcache_fetch (nindy_dcache, addr);
+  return dcache_fetch (nindy_dcache, addr);
 }
 
 /* Write a word WORD into remote address ADDR.
@@ -503,7 +507,7 @@ nindy_store_word (addr, word)
      CORE_ADDR addr;
      int word;
 {
-	dcache_poke (nindy_dcache, addr, word);
+  dcache_poke (nindy_dcache, addr, word);
 }
 
 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
@@ -515,19 +519,19 @@ nindy_store_word (addr, word)
    FIXME, rewrite this to not use the word-oriented routines.  */
 
 int
-nindy_xfer_inferior_memory(memaddr, myaddr, len, should_write, target)
+nindy_xfer_inferior_memory (memaddr, myaddr, len, should_write, target)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
      int should_write;
-     struct target_ops *target;			/* ignored */
+     struct target_ops *target;	/* ignored */
 {
   register int i;
   /* Round starting address down to longword boundary.  */
-  register CORE_ADDR addr = memaddr & - sizeof (int);
+  register CORE_ADDR addr = memaddr & -sizeof (int);
   /* Round ending address up; get number of longwords that makes.  */
   register int count
-    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+  = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
   /* Allocate buffer of that many longwords.  */
   register int *buffer = (int *) alloca (count * sizeof (int));
 
@@ -535,10 +539,11 @@ nindy_xfer_inferior_memory(memaddr, myaddr, len, should_write, target)
     {
       /* Fill start and end extra bytes of buffer with existing memory data.  */
 
-      if (addr != memaddr || len < (int)sizeof (int)) {
-	/* Need part of initial word -- fetch it.  */
-        buffer[0] = nindy_fetch_word (addr);
-      }
+      if (addr != memaddr || len < (int) sizeof (int))
+	{
+	  /* Need part of initial word -- fetch it.  */
+	  buffer[0] = nindy_fetch_word (addr);
+	}
 
       if (count > 1)		/* FIXME, avoid if even boundary */
 	{
@@ -616,19 +621,19 @@ nindy_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);
 }
 
 static void
-reset_command(args, from_tty)
+reset_command (args, from_tty)
      char *args;
      int from_tty;
 {
   if (nindy_serial == NULL)
     {
-      error( "No target system to reset -- use 'target nindy' command.");
+      error ("No target system to reset -- use 'target nindy' command.");
     }
-  if ( query("Really reset the target system?",0,0) )
+  if (query ("Really reset the target system?", 0, 0))
     {
       SERIAL_SEND_BREAK (nindy_serial);
       tty_flush (nindy_serial);
@@ -640,7 +645,7 @@ nindy_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.
@@ -667,43 +672,43 @@ nindy_open_stub (arg)
 }
 
 static void
-nindy_load( filename, from_tty )
-    char *filename;
-    int from_tty;
+nindy_load (filename, from_tty)
+     char *filename;
+     int from_tty;
 {
   asection *s;
   /* Can't do unix style forking on a VMS system, so we'll use bfd to do
      all the work for us
-     */
+   */
 
-  bfd *file = bfd_openr(filename,0);
+  bfd *file = bfd_openr (filename, 0);
   if (!file)
-  {
-    perror_with_name(filename);
-    return;
-  }
-
-  if (!bfd_check_format(file, bfd_object))
-  {
-    error("can't prove it's an object file\n");
-    return;
-  }
- 
-  for ( s = file->sections; s; s=s->next)
-  {
-    if (s->flags & SEC_LOAD)
     {
-      char *buffer = xmalloc(s->_raw_size);
-      bfd_get_section_contents(file, s, buffer, 0, s->_raw_size);
-      printf("Loading section %s, size %x vma %x\n",
-             s->name,
-             s->_raw_size,
-             s->vma);
-      ninMemPut(s->vma, buffer, s->_raw_size);
-      free(buffer);
+      perror_with_name (filename);
+      return;
     }
-  }
-  bfd_close(file);
+
+  if (!bfd_check_format (file, bfd_object))
+    {
+      error ("can't prove it's an object file\n");
+      return;
+    }
+
+  for (s = file->sections; s; s = s->next)
+    {
+      if (s->flags & SEC_LOAD)
+	{
+	  char *buffer = xmalloc (s->_raw_size);
+	  bfd_get_section_contents (file, s, buffer, 0, s->_raw_size);
+	  printf ("Loading section %s, size %x vma %x\n",
+		  s->name,
+		  s->_raw_size,
+		  s->vma);
+	  ninMemPut (s->vma, buffer, s->_raw_size);
+	  free (buffer);
+	}
+    }
+  bfd_close (file);
 }
 
 static int
@@ -728,82 +733,88 @@ nindy_before_main_loop ()
   char ttyname[100];
   char *p, *p2;
 
-  while (target_stack->target_ops != &nindy_ops) /* What is this crap??? */
+  while (target_stack->target_ops != &nindy_ops)	/* What is this crap??? */
     {				/* remote tty not specified yet */
-	if ( instream == stdin ){
-		printf_unfiltered("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
-		gdb_flush( gdb_stdout );
+      if (instream == stdin)
+	{
+	  printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
+	  gdb_flush (gdb_stdout);
 	}
-	fgets( ttyname, sizeof(ttyname)-1, stdin );
+      fgets (ttyname, sizeof (ttyname) - 1, stdin);
 
-	/* Strip leading and trailing whitespace */
-	for ( p = ttyname; isspace(*p); p++ ){
-		;
+      /* Strip leading and trailing whitespace */
+      for (p = ttyname; isspace (*p); p++)
+	{
+	  ;
 	}
-	if ( *p == '\0' ){
-		return;		/* User just hit spaces or return, wants out */
+      if (*p == '\0')
+	{
+	  return;		/* User just hit spaces or return, wants out */
 	}
-	for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
-		;
+      for (p2 = p; !isspace (*p2) && (*p2 != '\0'); p2++)
+	{
+	  ;
 	}
-	*p2= '\0';
-	if ( STREQ("quit",p) ){
-		exit(1);
+      *p2 = '\0';
+      if (STREQ ("quit", p))
+	{
+	  exit (1);
 	}
 
-	if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
-	  {
-	    /* Now that we have a tty open for talking to the remote machine,
-	       download the executable file if one was specified.  */
-	    if (exec_bfd)
-	      {
-		catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
-			      RETURN_MASK_ALL);
-	      }
-	  }
-      }
+      if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
+	{
+	  /* Now that we have a tty open for talking to the remote machine,
+	     download the executable file if one was specified.  */
+	  if (exec_bfd)
+	    {
+	      catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
+			    RETURN_MASK_ALL);
+	    }
+	}
+    }
 }
 
 /* Define the target subroutine names */
 
-struct target_ops nindy_ops ;
+struct target_ops nindy_ops;
 
-static void 
-init_nindy_ops(void)
+static void
+init_nindy_ops (void)
 {
-  nindy_ops.to_shortname =   "nindy"; "Remote serial target in i960 NINDY-specific protocol",
-					nindy_ops.to_longname =   "Use a remote i960 system running NINDY connected by a serial line.\n\
+  nindy_ops.to_shortname = "nindy";
+  "Remote serial target in i960 NINDY-specific protocol",
+    nindy_ops.to_longname = "Use a remote i960 system running NINDY connected by a serial line.\n\
 Specify the name of the device the serial line is connected to.\n\
 The speed (baud rate), whether to use the old NINDY protocol,\n\
 and whether to send a break on startup, are controlled by options\n\
-specified when you started GDB." ;
-  nindy_ops.to_doc =   "";
-  nindy_ops.to_open =   nindy_open;
-  nindy_ops.to_close =   nindy_close;
-  nindy_ops.to_attach =   0;
+specified when you started GDB.";
+  nindy_ops.to_doc = "";
+  nindy_ops.to_open = nindy_open;
+  nindy_ops.to_close = nindy_close;
+  nindy_ops.to_attach = 0;
   nindy_ops.to_post_attach = NULL;
   nindy_ops.to_require_attach = NULL;
-  nindy_ops.to_detach =   nindy_detach;
+  nindy_ops.to_detach = nindy_detach;
   nindy_ops.to_require_detach = NULL;
-  nindy_ops.to_resume =   nindy_resume;
-  nindy_ops.to_wait  =   nindy_wait;
+  nindy_ops.to_resume = nindy_resume;
+  nindy_ops.to_wait = nindy_wait;
   nindy_ops.to_post_wait = NULL;
-  nindy_ops.to_fetch_registers  =   nindy_fetch_registers;
-  nindy_ops.to_store_registers  =   nindy_store_registers;
-  nindy_ops.to_prepare_to_store =   nindy_prepare_to_store;
-  nindy_ops.to_xfer_memory  =   nindy_xfer_inferior_memory;
-  nindy_ops.to_files_info  =   nindy_files_info;
-  nindy_ops.to_insert_breakpoint =   memory_insert_breakpoint;
-  nindy_ops.to_remove_breakpoint =   memory_remove_breakpoint;
-  nindy_ops.to_terminal_init  =   0;
-  nindy_ops.to_terminal_inferior =   0;
-  nindy_ops.to_terminal_ours_for_output =   0;
-  nindy_ops.to_terminal_ours  =   0;
-  nindy_ops.to_terminal_info  =   0;	/* Terminal crud */
-  nindy_ops.to_kill  =   nindy_kill;
-  nindy_ops.to_load  =   nindy_load;
-  nindy_ops.to_lookup_symbol =   0; /* lookup_symbol */
-  nindy_ops.to_create_inferior =   nindy_create_inferior;
+  nindy_ops.to_fetch_registers = nindy_fetch_registers;
+  nindy_ops.to_store_registers = nindy_store_registers;
+  nindy_ops.to_prepare_to_store = nindy_prepare_to_store;
+  nindy_ops.to_xfer_memory = nindy_xfer_inferior_memory;
+  nindy_ops.to_files_info = nindy_files_info;
+  nindy_ops.to_insert_breakpoint = memory_insert_breakpoint;
+  nindy_ops.to_remove_breakpoint = memory_remove_breakpoint;
+  nindy_ops.to_terminal_init = 0;
+  nindy_ops.to_terminal_inferior = 0;
+  nindy_ops.to_terminal_ours_for_output = 0;
+  nindy_ops.to_terminal_ours = 0;
+  nindy_ops.to_terminal_info = 0;	/* Terminal crud */
+  nindy_ops.to_kill = nindy_kill;
+  nindy_ops.to_load = nindy_load;
+  nindy_ops.to_lookup_symbol = 0;	/* lookup_symbol */
+  nindy_ops.to_create_inferior = nindy_create_inferior;
   nindy_ops.to_post_startup_inferior = NULL;
   nindy_ops.to_acknowledge_created_inferior = NULL;
   nindy_ops.to_clone_and_follow_inferior = NULL;
@@ -821,29 +832,29 @@ specified when you started GDB." ;
   nindy_ops.to_has_execd = NULL;
   nindy_ops.to_reported_exec_events_per_exec_call = NULL;
   nindy_ops.to_has_exited = NULL;
-  nindy_ops.to_mourn_inferior =   nindy_mourn_inferior;
-  nindy_ops.to_can_run  =   0;		/* can_run */
-  nindy_ops.to_notice_signals =   0; /* notice_signals */
-  nindy_ops.to_thread_alive  =   0;			/* to_thread_alive */
-  nindy_ops.to_stop  =   0;			/* to_stop */
+  nindy_ops.to_mourn_inferior = nindy_mourn_inferior;
+  nindy_ops.to_can_run = 0;	/* can_run */
+  nindy_ops.to_notice_signals = 0;	/* notice_signals */
+  nindy_ops.to_thread_alive = 0;	/* to_thread_alive */
+  nindy_ops.to_stop = 0;	/* to_stop */
   nindy_ops.to_pid_to_exec_file = NULL;
   nindy_ops.to_core_file_to_sym_file = NULL;
-  nindy_ops.to_stratum =   process_stratum;
-  nindy_ops.DONT_USE =   0; /* next */
-  nindy_ops.to_has_all_memory =   1;
-  nindy_ops.to_has_memory =   1;
-  nindy_ops.to_has_stack =   1;
-  nindy_ops.to_has_registers =   1;
-  nindy_ops.to_has_execution =   1;	/* all mem, mem, stack, regs, exec */
-  nindy_ops.to_sections =   0;
-  nindy_ops.to_sections_end =   0;			/* Section pointers */
-  nindy_ops.to_magic =   OPS_MAGIC;		/* Always the last thing */
+  nindy_ops.to_stratum = process_stratum;
+  nindy_ops.DONT_USE = 0;	/* next */
+  nindy_ops.to_has_all_memory = 1;
+  nindy_ops.to_has_memory = 1;
+  nindy_ops.to_has_stack = 1;
+  nindy_ops.to_has_registers = 1;
+  nindy_ops.to_has_execution = 1;	/* all mem, mem, stack, regs, exec */
+  nindy_ops.to_sections = 0;
+  nindy_ops.to_sections_end = 0;	/* Section pointers */
+  nindy_ops.to_magic = OPS_MAGIC;	/* Always the last thing */
 }
 
 void
 _initialize_nindy ()
 {
-  init_nindy_ops() ;
+  init_nindy_ops ();
   add_target (&nindy_ops);
   add_com ("reset", class_obscure, reset_command,
 	   "Send a 'break' to the remote target system.\n\