* config/m32r/m32r.mt (GDBSERVER_LIBS): Added ../../intl/libintl.a.

* config/mips/vr5000.mt (GDBSERVER_LIBS): Likewise.
* config/tic80/tic80.mt (GDBSERVER_LIBS): Likewise.
* gdbserver/low-sim.c (#include "defs.h"): Removed.
(mygeneric_load): Rename from generic_load.

* gdbserver/low-hppabsd.c (#include "server.h"): Added.
(#include "defs.h"): Removed.
(inferior_pid, perror_with_name): Remove declarations.
* gdbserver/low-linux.c: Likewise.
* gdbserver/low-nbsd.c: Likewise.
* gdbserver/low-sparc.c: Likewise.
* gdbserver/low-sun3.c: Likewise.

* i386-stub.c: Re-indent.
* m68k-stub.c: Re-indent.

12 files changed, 746 insertions, 612 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 924f3d11c83..dc1e3e0d3dc 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,22 @@
+2001-01-23  J.T. Conklin  <jtc@redback.com>
+	
+	* config/m32r/m32r.mt (GDBSERVER_LIBS): Added ../../intl/libintl.a.
+	* config/mips/vr5000.mt (GDBSERVER_LIBS): Likewise.
+	* config/tic80/tic80.mt (GDBSERVER_LIBS): Likewise.
+	* gdbserver/low-sim.c (#include "defs.h"): Removed.
+	(mygeneric_load): Rename from generic_load.
+	
+	* gdbserver/low-hppabsd.c (#include "server.h"): Added.
+	(#include "defs.h"): Removed.
+	(inferior_pid, perror_with_name): Remove declarations.
+	* gdbserver/low-linux.c: Likewise.
+	* gdbserver/low-nbsd.c: Likewise.
+	* gdbserver/low-sparc.c: Likewise.
+	* gdbserver/low-sun3.c: Likewise.
+
+	* i386-stub.c: Re-indent.
+	* m68k-stub.c: Re-indent.
+
 2001-01-22  Nicholas Duffek  <nsd@redhat.com>
 
 	* gdbarch.sh (PARM_BOUNDARY): Define.
diff --git a/gdb/config/m32r/m32r.mt b/gdb/config/m32r/m32r.mt
index 8b957059ca1..bdc3f381060 100644
--- a/gdb/config/m32r/m32r.mt
+++ b/gdb/config/m32r/m32r.mt
@@ -4,4 +4,4 @@ TM_FILE= tm-m32r.h
 SIM_OBS = remote-sim.o
 SIM = ../sim/m32r/libsim.a
 GDBSERVER_DEPFILES= low-sim.o
-GDBSERVER_LIBS = ../../sim/m32r/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a ../../opcodes/libopcodes.a
+GDBSERVER_LIBS = ../../sim/m32r/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a ../../opcodes/libopcodes.a ../../intl/libintl.a
diff --git a/gdb/config/mips/vr5000.mt b/gdb/config/mips/vr5000.mt
index 316c548de09..eaf7a2a0b3f 100644
--- a/gdb/config/mips/vr5000.mt
+++ b/gdb/config/mips/vr5000.mt
@@ -4,4 +4,4 @@ TM_FILE= tm-vr5000.h
 SIM_OBS = remote-sim.o
 SIM = ../sim/mips/libsim.a
 GDBSERVER_DEPFILES= low-sim.o
-GDBSERVER_LIBS = ../../sim/mips/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a -lm
+GDBSERVER_LIBS = ../../sim/mips/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a -lm ../../intl/libintl.a
diff --git a/gdb/config/tic80/tic80.mt b/gdb/config/tic80/tic80.mt
index 10be27e2633..5daba66ad0a 100644
--- a/gdb/config/tic80/tic80.mt
+++ b/gdb/config/tic80/tic80.mt
@@ -4,4 +4,4 @@ TM_FILE= tm-tic80.h
 SIM_OBS = remote-sim.o
 SIM = ../sim/tic80/libsim.a
 GDBSERVER_DEPFILES= low-sim.o
-GDBSERVER_LIBS = ../../sim/tic80/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a -lm
+GDBSERVER_LIBS = ../../sim/tic80/libsim.a ../../bfd/libbfd.a ../../libiberty/libiberty.a -lm ../../intl/libintl.a
diff --git a/gdb/gdbserver/low-hppabsd.c b/gdb/gdbserver/low-hppabsd.c
index d031e307f10..571991569e3 100644
--- a/gdb/gdbserver/low-hppabsd.c
+++ b/gdb/gdbserver/low-hppabsd.c
@@ -18,7 +18,7 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#include "defs.h"
+#include "server.h"
 #include <sys/wait.h>
 #include "frame.h"
 #include "inferior.h"
@@ -41,8 +41,6 @@ char *registers = my_registers;
 #include <machine/reg.h>
 
 extern int errno;
-extern int inferior_pid;
-void perror_with_name ();
 
 /* Start an inferior process and returns its pid.
    ALLARGS is a vector of program-name and args. */
diff --git a/gdb/gdbserver/low-linux.c b/gdb/gdbserver/low-linux.c
index c718c4ea9ab..ce57d32e877 100644
--- a/gdb/gdbserver/low-linux.c
+++ b/gdb/gdbserver/low-linux.c
@@ -18,7 +18,7 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#include "defs.h"
+#include "server.h"
 #include <sys/wait.h>
 #include "frame.h"
 #include "inferior.h"
@@ -47,8 +47,6 @@ char *registers = my_registers;
 #endif
 
 extern int errno;
-extern int inferior_pid;
-void perror_with_name ();
 
 static void initialize_arch (void);
 
diff --git a/gdb/gdbserver/low-nbsd.c b/gdb/gdbserver/low-nbsd.c
index fc54845f48d..0ff8524f483 100644
--- a/gdb/gdbserver/low-nbsd.c
+++ b/gdb/gdbserver/low-nbsd.c
@@ -17,7 +17,7 @@ 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.  */
 
-#include "defs.h"
+#include "server.h"
 #include <sys/types.h>
 #include <sys/wait.h>
 #include "frame.h"
@@ -34,11 +34,6 @@ char *registers = my_registers;
 #include <sys/ptrace.h>
 #include <machine/reg.h>
 
-// extern int sys_nerr;
-// extern char **sys_errlist;
-extern int inferior_pid;
-void perror_with_name ();
-
 #define RF(dst, src) \
 	memcpy(&registers[REGISTER_BYTE(dst)], &src, sizeof(src))
 
diff --git a/gdb/gdbserver/low-sim.c b/gdb/gdbserver/low-sim.c
index a0a9aa6cb93..d82aad12f58 100644
--- a/gdb/gdbserver/low-sim.c
+++ b/gdb/gdbserver/low-sim.c
@@ -18,9 +18,8 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#include "defs.h"
-#include "bfd.h"
 #include "server.h"
+#include "bfd.h"
 #include "callback.h"		/* GDB simulator callback interface */
 #include "remote-sim.h"		/* GDB simulator interface */
 
@@ -41,7 +40,7 @@ static SIM_DESC gdbsim_desc = 0;
    does not support loading itself.  */
 
 static void
-generic_load (bfd *loadfile_bfd)
+mygeneric_load (bfd *loadfile_bfd)
 {
   asection *s;
 
@@ -131,7 +130,7 @@ create_inferior (char *program, char **argv)
   /* Load the program into the simulator.  */
   if (abfd)
     if (sim_load (gdbsim_desc, program, NULL, 0) == SIM_RC_FAIL)
-      generic_load (abfd);
+      mygeneric_load (abfd);
 
   /* Create an inferior process in the simulator.  This initializes SP.  */
   sim_create_inferior (gdbsim_desc, abfd, argv, /* env */ NULL);
diff --git a/gdb/gdbserver/low-sparc.c b/gdb/gdbserver/low-sparc.c
index 34e4192521f..b7f348627dc 100644
--- a/gdb/gdbserver/low-sparc.c
+++ b/gdb/gdbserver/low-sparc.c
@@ -18,7 +18,7 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#include "defs.h"
+#include "server.h"
 #include <sys/wait.h>
 #include "frame.h"
 #include "inferior.h"
@@ -46,8 +46,6 @@ char *registers = my_registers;
 extern int sys_nerr;
 extern char **sys_errlist;
 extern int errno;
-extern int inferior_pid;
-void perror_with_name ();
 
 /* Start an inferior process and returns its pid.
    ALLARGS is a vector of program-name and args. */
diff --git a/gdb/gdbserver/low-sun3.c b/gdb/gdbserver/low-sun3.c
index e1e64b6ba1d..17a64b5a83c 100644
--- a/gdb/gdbserver/low-sun3.c
+++ b/gdb/gdbserver/low-sun3.c
@@ -18,7 +18,7 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#include "defs.h"
+#include "server.h"
 #include "<sys/wait.h>"
 #include "frame.h"
 #include "inferior.h"
@@ -43,8 +43,6 @@ char *registers = my_registers;
 extern int sys_nerr;
 extern char **sys_errlist;
 extern int errno;
-extern int inferior_pid;
-void perror_with_name ();
 
 /* Start an inferior process and returns its pid.
    ALLARGS is a vector of program-name and args. */
diff --git a/gdb/i386-stub.c b/gdb/i386-stub.c
index 2b08e3431fb..7aa5da9369c 100644
--- a/gdb/i386-stub.c
+++ b/gdb/i386-stub.c
@@ -429,17 +429,22 @@ asm("		movl _stackPtr, %esp"); /* move to remcom stack area  */
 asm("		pushl %eax");	/* push exception onto stack  */
 asm("		call  _handle_exception");    /* this never returns */
 
-void _returnFromException()
+void
+_returnFromException ()
 {
   return_to_prog ();
 }
 
-int hex(ch)
-char ch;
+int
+hex (ch)
+     char ch;
 {
-  if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10);
-  if ((ch >= '0') && (ch <= '9')) return (ch-'0');
-  if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10);
+  if ((ch >= 'a') && (ch <= 'f'))
+    return (ch - 'a' + 10);
+  if ((ch >= '0') && (ch <= '9'))
+    return (ch - '0');
+  if ((ch >= 'A') && (ch <= 'F'))
+    return (ch - 'A' + 10);
   return (-1);
 }
 
@@ -463,7 +468,7 @@ getpacket (void)
       while ((ch = getDebugChar ()) != '$')
 	;
 
-retry:
+    retry:
       checksum = 0;
       xmitcsum = -1;
       count = 0;
@@ -472,7 +477,7 @@ retry:
       while (count < BUFMAX)
 	{
 	  ch = getDebugChar ();
-          if (ch == '$')
+	  if (ch == '$')
 	    goto retry;
 	  if (ch == '#')
 	    break;
@@ -494,7 +499,7 @@ retry:
 	      if (remote_debug)
 		{
 		  fprintf (stderr,
-		      "bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
+			   "bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
 			   checksum, xmitcsum, buffer);
 		}
 	      putDebugChar ('-');	/* failed checksum */
@@ -520,42 +525,46 @@ retry:
 
 /* send the packet in buffer.  */
 
-void putpacket(buffer)
-    unsigned char *buffer;
+void
+putpacket (unsigned char *buffer)
 {
   unsigned char checksum;
-  int  count;
+  int count;
   char ch;
 
   /*  $<packet info>#<checksum>. */
-  do {
-  putDebugChar('$');
-  checksum = 0;
-  count    = 0;
-
-  while (ch=buffer[count]) {
-    putDebugChar(ch);
-    checksum += ch;
-    count += 1;
-  }
+  do
+    {
+      putDebugChar ('$');
+      checksum = 0;
+      count = 0;
 
-  putDebugChar('#');
-  putDebugChar(hexchars[checksum >> 4]);
-  putDebugChar(hexchars[checksum % 16]);
+      while (ch = buffer[count])
+	{
+	  putDebugChar (ch);
+	  checksum += ch;
+	  count += 1;
+	}
 
-  } while (getDebugChar() != '+');
+      putDebugChar ('#');
+      putDebugChar (hexchars[checksum >> 4]);
+      putDebugChar (hexchars[checksum % 16]);
 
+    }
+  while (getDebugChar () != '+');
 }
 
-void debug_error(format, parm)
-char * format;
-char * parm;
+void
+debug_error (format, parm)
+     char *format;
+     char *parm;
 {
-  if (remote_debug) fprintf (stderr,format,parm);
+  if (remote_debug)
+    fprintf (stderr, format, parm);
 }
 
 /* Address of a routine to RTE to if we get a memory fault.  */
-static void (*volatile mem_fault_routine)() = NULL;
+static void (*volatile mem_fault_routine) () = NULL;
 
 /* Indicate to caller of mem2hex or hex2mem that there has been an
    error.  */
@@ -587,80 +596,115 @@ set_char (char *addr, int val)
 /* return a pointer to the last char put in buf (null) */
 /* If MAY_FAULT is non-zero, then we should set mem_err in response to
    a fault; if zero treat a fault like any other fault in the stub.  */
-char* mem2hex(mem, buf, count, may_fault)
-char* mem;
-char* buf;
-int   count;
-int may_fault;
+char *
+mem2hex (mem, buf, count, may_fault)
+     char *mem;
+     char *buf;
+     int count;
+     int may_fault;
 {
-      int i;
-      unsigned char ch;
-
-      if (may_fault)
-	  mem_fault_routine = set_mem_err;
-      for (i=0;i<count;i++) {
-          ch = get_char (mem++);
-	  if (may_fault && mem_err)
-	    return (buf);
-          *buf++ = hexchars[ch >> 4];
-          *buf++ = hexchars[ch % 16];
-      }
-      *buf = 0;
-      if (may_fault)
-	  mem_fault_routine = NULL;
-      return(buf);
+  int i;
+  unsigned char ch;
+
+  if (may_fault)
+    mem_fault_routine = set_mem_err;
+  for (i = 0; i < count; i++)
+    {
+      ch = get_char (mem++);
+      if (may_fault && mem_err)
+	return (buf);
+      *buf++ = hexchars[ch >> 4];
+      *buf++ = hexchars[ch % 16];
+    }
+  *buf = 0;
+  if (may_fault)
+    mem_fault_routine = NULL;
+  return (buf);
 }
 
 /* convert the hex array pointed to by buf into binary to be placed in mem */
 /* return a pointer to the character AFTER the last byte written */
-char* hex2mem(buf, mem, count, may_fault)
-char* buf;
-char* mem;
-int   count;
-int may_fault;
+char *
+hex2mem (buf, mem, count, may_fault)
+     char *buf;
+     char *mem;
+     int count;
+     int may_fault;
 {
-      int i;
-      unsigned char ch;
-
-      if (may_fault)
-	  mem_fault_routine = set_mem_err;
-      for (i=0;i<count;i++) {
-          ch = hex(*buf++) << 4;
-          ch = ch + hex(*buf++);
-          set_char (mem++, ch);
-	  if (may_fault && mem_err)
-	    return (mem);
-      }
-      if (may_fault)
-	  mem_fault_routine = NULL;
-      return(mem);
+  int i;
+  unsigned char ch;
+
+  if (may_fault)
+    mem_fault_routine = set_mem_err;
+  for (i = 0; i < count; i++)
+    {
+      ch = hex (*buf++) << 4;
+      ch = ch + hex (*buf++);
+      set_char (mem++, ch);
+      if (may_fault && mem_err)
+	return (mem);
+    }
+  if (may_fault)
+    mem_fault_routine = NULL;
+  return (mem);
 }
 
 /* this function takes the 386 exception vector and attempts to
    translate this number into a unix compatible signal value */
-int computeSignal( exceptionVector )
-int exceptionVector;
+int
+computeSignal (int exceptionVector)
 {
   int sigval;
-  switch (exceptionVector) {
-    case 0 : sigval = 8; break; /* divide by zero */
-    case 1 : sigval = 5; break; /* debug exception */
-    case 3 : sigval = 5; break; /* breakpoint */
-    case 4 : sigval = 16; break; /* into instruction (overflow) */
-    case 5 : sigval = 16; break; /* bound instruction */
-    case 6 : sigval = 4; break; /* Invalid opcode */
-    case 7 : sigval = 8; break; /* coprocessor not available */
-    case 8 : sigval = 7; break; /* double fault */
-    case 9 : sigval = 11; break; /* coprocessor segment overrun */
-    case 10 : sigval = 11; break; /* Invalid TSS */
-    case 11 : sigval = 11; break; /* Segment not present */
-    case 12 : sigval = 11; break; /* stack exception */
-    case 13 : sigval = 11; break; /* general protection */
-    case 14 : sigval = 11; break; /* page fault */
-    case 16 : sigval = 7; break; /* coprocessor error */
+  switch (exceptionVector)
+    {
+    case 0:
+      sigval = 8;
+      break;			/* divide by zero */
+    case 1:
+      sigval = 5;
+      break;			/* debug exception */
+    case 3:
+      sigval = 5;
+      break;			/* breakpoint */
+    case 4:
+      sigval = 16;
+      break;			/* into instruction (overflow) */
+    case 5:
+      sigval = 16;
+      break;			/* bound instruction */
+    case 6:
+      sigval = 4;
+      break;			/* Invalid opcode */
+    case 7:
+      sigval = 8;
+      break;			/* coprocessor not available */
+    case 8:
+      sigval = 7;
+      break;			/* double fault */
+    case 9:
+      sigval = 11;
+      break;			/* coprocessor segment overrun */
+    case 10:
+      sigval = 11;
+      break;			/* Invalid TSS */
+    case 11:
+      sigval = 11;
+      break;			/* Segment not present */
+    case 12:
+      sigval = 11;
+      break;			/* stack exception */
+    case 13:
+      sigval = 11;
+      break;			/* general protection */
+    case 14:
+      sigval = 11;
+      break;			/* page fault */
+    case 16:
+      sigval = 7;
+      break;			/* coprocessor error */
     default:
-      sigval = 7;         /* "software generated"*/
-  }
+      sigval = 7;		/* "software generated" */
+    }
   return (sigval);
 }
 
@@ -668,184 +712,194 @@ int exceptionVector;
 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
 /* RETURN NUMBER OF CHARS PROCESSED           */
 /**********************************************/
-int hexToInt(char **ptr, int *intValue)
+int
+hexToInt (char **ptr, int *intValue)
 {
-    int numChars = 0;
-    int hexValue;
+  int numChars = 0;
+  int hexValue;
 
-    *intValue = 0;
+  *intValue = 0;
 
-    while (**ptr)
+  while (**ptr)
     {
-        hexValue = hex(**ptr);
-        if (hexValue >=0)
-        {
-            *intValue = (*intValue <<4) | hexValue;
-            numChars ++;
-        }
-        else
-            break;
-
-        (*ptr)++;
+      hexValue = hex (**ptr);
+      if (hexValue >= 0)
+	{
+	  *intValue = (*intValue << 4) | hexValue;
+	  numChars++;
+	}
+      else
+	break;
+
+      (*ptr)++;
     }
 
-    return (numChars);
+  return (numChars);
 }
 
 /*
  * This function does all command procesing for interfacing to gdb.
  */
-void handle_exception(int exceptionVector)
+void
+handle_exception (int exceptionVector)
 {
-  int    sigval, stepping;
-  int    addr, length;
-  char * ptr;
-  int    newPC;
+  int sigval, stepping;
+  int addr, length;
+  char *ptr;
+  int newPC;
 
   gdb_i386vector = exceptionVector;
 
-  if (remote_debug) printf("vector=%d, sr=0x%x, pc=0x%x\n",
-			    exceptionVector,
-			    registers[ PS ],
-			    registers[ PC ]);
+  if (remote_debug)
+    {
+      printf ("vector=%d, sr=0x%x, pc=0x%x\n",
+	      exceptionVector, registers[PS], registers[PC]);
+    }
 
   /* reply to host that an exception has occurred */
-  sigval = computeSignal( exceptionVector );
+  sigval = computeSignal (exceptionVector);
   remcomOutBuffer[0] = 'S';
-  remcomOutBuffer[1] =  hexchars[sigval >> 4];
-  remcomOutBuffer[2] =  hexchars[sigval % 16];
+  remcomOutBuffer[1] = hexchars[sigval >> 4];
+  remcomOutBuffer[2] = hexchars[sigval % 16];
   remcomOutBuffer[3] = 0;
 
-  putpacket(remcomOutBuffer);
+  putpacket (remcomOutBuffer);
 
   stepping = 0;
 
-  while (1==1) {
-    remcomOutBuffer[0] = 0;
-    ptr = getpacket();
-
-    switch (*ptr++) {
-      case '?' :   remcomOutBuffer[0] = 'S';
-                   remcomOutBuffer[1] =  hexchars[sigval >> 4];
-                   remcomOutBuffer[2] =  hexchars[sigval % 16];
-                   remcomOutBuffer[3] = 0;
-                 break;
-      case 'd' : remote_debug = !(remote_debug);  /* toggle debug flag */
-                 break;
-      case 'g' : /* return the value of the CPU registers */
-                mem2hex((char*) registers, remcomOutBuffer, NUMREGBYTES, 0);
-                break;
-      case 'G' : /* set the value of the CPU registers - return OK */
-                hex2mem(ptr, (char*) registers, NUMREGBYTES, 0);
-                strcpy(remcomOutBuffer,"OK");
-                break;
-      case 'P' : /* set the value of a single CPU register - return OK */
-                {
-                  int regno;
-
-                  if (hexToInt (&ptr, &regno) && *ptr++ == '=') 
-                  if (regno >= 0 && regno < NUMREGS)
-                    {
-                      hex2mem (ptr, (char *)&registers[regno], 4, 0);
-                      strcpy(remcomOutBuffer,"OK");
-                      break;
-                    }
-
-                  strcpy (remcomOutBuffer, "E01");
-                  break;
-                }
-
-      /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
-      case 'm' :
-		    /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
-                    if (hexToInt(&ptr,&addr))
-                        if (*(ptr++) == ',')
-                            if (hexToInt(&ptr,&length))
-                            {
-                                ptr = 0;
-				mem_err = 0;
-                                mem2hex((char*) addr, remcomOutBuffer, length, 1);
-				if (mem_err) {
-				    strcpy (remcomOutBuffer, "E03");
-				    debug_error ("memory fault");
-				}
-                            }
-
-                    if (ptr)
-                    {
-		      strcpy(remcomOutBuffer,"E01");
-		    }
-	          break;
-
-      /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
-      case 'M' :
-		    /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
-                    if (hexToInt(&ptr,&addr))
-                        if (*(ptr++) == ',')
-                            if (hexToInt(&ptr,&length))
-                                if (*(ptr++) == ':')
-                                {
-				    mem_err = 0;
-                                    hex2mem(ptr, (char*) addr, length, 1);
-
-				    if (mem_err) {
-					strcpy (remcomOutBuffer, "E03");
-					debug_error ("memory fault");
-				    } else {
-				        strcpy(remcomOutBuffer,"OK");
-				    }
-
-                                    ptr = 0;
-                                }
-                    if (ptr)
-                    {
-		      strcpy(remcomOutBuffer,"E02");
+  while (1 == 1)
+    {
+      remcomOutBuffer[0] = 0;
+      ptr = getpacket ();
+
+      switch (*ptr++)
+	{
+	case '?':
+	  remcomOutBuffer[0] = 'S';
+	  remcomOutBuffer[1] = hexchars[sigval >> 4];
+	  remcomOutBuffer[2] = hexchars[sigval % 16];
+	  remcomOutBuffer[3] = 0;
+	  break;
+	case 'd':
+	  remote_debug = !(remote_debug);	/* toggle debug flag */
+	  break;
+	case 'g':		/* return the value of the CPU registers */
+	  mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES, 0);
+	  break;
+	case 'G':		/* set the value of the CPU registers - return OK */
+	  hex2mem (ptr, (char *) registers, NUMREGBYTES, 0);
+	  strcpy (remcomOutBuffer, "OK");
+	  break;
+	case 'P':		/* set the value of a single CPU register - return OK */
+	  {
+	    int regno;
+
+	    if (hexToInt (&ptr, &regno) && *ptr++ == '=')
+	      if (regno >= 0 && regno < NUMREGS)
+		{
+		  hex2mem (ptr, (char *) &registers[regno], 4, 0);
+		  strcpy (remcomOutBuffer, "OK");
+		  break;
+		}
+
+	    strcpy (remcomOutBuffer, "E01");
+	    break;
+	  }
+
+	  /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
+	case 'm':
+	  /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
+	  if (hexToInt (&ptr, &addr))
+	    if (*(ptr++) == ',')
+	      if (hexToInt (&ptr, &length))
+		{
+		  ptr = 0;
+		  mem_err = 0;
+		  mem2hex ((char *) addr, remcomOutBuffer, length, 1);
+		  if (mem_err)
+		    {
+		      strcpy (remcomOutBuffer, "E03");
+		      debug_error ("memory fault");
 		    }
-                break;
+		}
 
-     /* cAA..AA    Continue at address AA..AA(optional) */
-     /* sAA..AA   Step one instruction from AA..AA(optional) */
-     case 's' :
-	 stepping = 1;
-     case 'c' :
-          /* try to read optional parameter, pc unchanged if no parm */
-         if (hexToInt(&ptr,&addr))
-             registers[ PC ] = addr;
+	  if (ptr)
+	    {
+	      strcpy (remcomOutBuffer, "E01");
+	    }
+	  break;
+
+	  /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
+	case 'M':
+	  /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
+	  if (hexToInt (&ptr, &addr))
+	    if (*(ptr++) == ',')
+	      if (hexToInt (&ptr, &length))
+		if (*(ptr++) == ':')
+		  {
+		    mem_err = 0;
+		    hex2mem (ptr, (char *) addr, length, 1);
+
+		    if (mem_err)
+		      {
+			strcpy (remcomOutBuffer, "E03");
+			debug_error ("memory fault");
+		      }
+		    else
+		      {
+			strcpy (remcomOutBuffer, "OK");
+		      }
+
+		    ptr = 0;
+		  }
+	  if (ptr)
+	    {
+	      strcpy (remcomOutBuffer, "E02");
+	    }
+	  break;
+
+	  /* cAA..AA    Continue at address AA..AA(optional) */
+	  /* sAA..AA   Step one instruction from AA..AA(optional) */
+	case 's':
+	  stepping = 1;
+	case 'c':
+	  /* try to read optional parameter, pc unchanged if no parm */
+	  if (hexToInt (&ptr, &addr))
+	    registers[PC] = addr;
 
-          newPC = registers[ PC];
+	  newPC = registers[PC];
 
-          /* clear the trace bit */
-          registers[ PS ] &= 0xfffffeff;
+	  /* clear the trace bit */
+	  registers[PS] &= 0xfffffeff;
 
-          /* set the trace bit if we're stepping */
-          if (stepping) registers[ PS ] |= 0x100;
+	  /* set the trace bit if we're stepping */
+	  if (stepping)
+	    registers[PS] |= 0x100;
 
-	  _returnFromException(); /* this is a jump */
-          break;
+	  _returnFromException ();	/* this is a jump */
+	  break;
 
-      /* kill the program */
-      case 'k' :  /* do nothing */
+	  /* kill the program */
+	case 'k':		/* do nothing */
 #if 0
-	/* Huh? This doesn't look like "nothing".
-	   m68k-stub.c and sparc-stub.c don't have it.  */
-		BREAKPOINT();
+	  /* Huh? This doesn't look like "nothing".
+	     m68k-stub.c and sparc-stub.c don't have it.  */
+	  BREAKPOINT ();
 #endif
-                break;
-      } /* switch */
+	  break;
+	}			/* switch */
 
-    /* reply to the request */
-    putpacket(remcomOutBuffer);
+      /* reply to the request */
+      putpacket (remcomOutBuffer);
     }
 }
 
 /* this function is used to set up exception handlers for tracing and
    breakpoints */
-void set_debug_traps()
+void
+set_debug_traps (void)
 {
-extern void remcomHandler();
-int exception;
-
-  stackPtr  = &remcomStack[STACKSIZE/sizeof(int) - 1];
+  stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
 
   exceptionHandler (0, _catchException0);
   exceptionHandler (1, _catchException1);
@@ -871,8 +925,9 @@ int exception;
    otherwise as a quick means to stop program execution and "break" into
    the debugger. */
 
-void breakpoint()
+void
+breakpoint (void)
 {
   if (initialized)
-    BREAKPOINT();
+    BREAKPOINT ();
 }
diff --git a/gdb/m68k-stub.c b/gdb/m68k-stub.c
index 72281da1697..54e06b13ccb 100644
--- a/gdb/m68k-stub.c
+++ b/gdb/m68k-stub.c
@@ -477,48 +477,53 @@ asm("		movel   d0,sp@-");	/* push exception onto stack  */
 asm("		jbsr    _handle_exception");    /* this never returns */
 asm("           rts");                  /* return */
 
-void _returnFromException( Frame *frame )
+void
+_returnFromException (Frame * frame)
 {
-    /* if no passed in frame, use the last one */
-    if (! frame)
+  /* if no passed in frame, use the last one */
+  if (!frame)
     {
-        frame = lastFrame;
-	frame->frameSize = 4;
-        frame->format = 0;
-        frame->fsaveHeader = -1; /* restore regs, but we dont have fsave info*/
+      frame = lastFrame;
+      frame->frameSize = 4;
+      frame->format = 0;
+      frame->fsaveHeader = -1;	/* restore regs, but we dont have fsave info */
     }
 
 #if !defined (mc68020) && !defined (mc68332)
-    /* a 68000 cannot use the internal info pushed onto a bus error
-     * or address error frame when doing an RTE so don't put this info
-     * onto the stack or the stack will creep every time this happens.
-     */
-    frame->frameSize=3;
+  /* a 68000 cannot use the internal info pushed onto a bus error
+   * or address error frame when doing an RTE so don't put this info
+   * onto the stack or the stack will creep every time this happens.
+   */
+  frame->frameSize = 3;
 #endif
 
-    /* throw away any frames in the list after this frame */
-    lastFrame = frame;
+  /* throw away any frames in the list after this frame */
+  lastFrame = frame;
 
-    frame->sr = registers[(int) PS];
-    frame->pc = registers[(int) PC];
+  frame->sr = registers[(int) PS];
+  frame->pc = registers[(int) PC];
 
-    if (registers[(int) PS] & 0x2000)
-    { 
-        /* return to supervisor mode... */
-        return_to_super();
+  if (registers[(int) PS] & 0x2000)
+    {
+      /* return to supervisor mode... */
+      return_to_super ();
     }
-    else
-    { /* return to user mode */
-        return_to_user();
+  else
+    {				/* return to user mode */
+      return_to_user ();
     }
 }
 
-int hex(ch)
-char ch;
+int
+hex (ch)
+     char ch;
 {
-  if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10);
-  if ((ch >= '0') && (ch <= '9')) return (ch-'0');
-  if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10);
+  if ((ch >= 'a') && (ch <= 'f'))
+    return (ch - 'a' + 10);
+  if ((ch >= '0') && (ch <= '9'))
+    return (ch - '0');
+  if ((ch >= 'A') && (ch <= 'F'))
+    return (ch - 'A' + 10);
   return (-1);
 }
 
@@ -526,7 +531,7 @@ static char remcomInBuffer[BUFMAX];
 static char remcomOutBuffer[BUFMAX];
 
 /* scan for the sequence $<data>#<checksum>     */
-  
+
 unsigned char *
 getpacket (void)
 {
@@ -542,7 +547,7 @@ getpacket (void)
       while ((ch = getDebugChar ()) != '$')
 	;
 
-retry:
+    retry:
       checksum = 0;
       xmitcsum = -1;
       count = 0;
@@ -552,7 +557,7 @@ retry:
 	{
 	  ch = getDebugChar ();
 	  if (ch == '$')
-            goto retry;
+	    goto retry;
 	  if (ch == '#')
 	    break;
 	  checksum = checksum + ch;
@@ -573,7 +578,7 @@ retry:
 	      if (remote_debug)
 		{
 		  fprintf (stderr,
-		      "bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
+			   "bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
 			   checksum, xmitcsum, buffer);
 		}
 	      putDebugChar ('-');	/* failed checksum */
@@ -599,125 +604,179 @@ retry:
 
 /* send the packet in buffer. */
 
-
-void putpacket(buffer)
-char * buffer;
+void
+putpacket (buffer)
+     char *buffer;
 {
   unsigned char checksum;
-  int  count;
+  int count;
   char ch;
-  
+
   /*  $<packet info>#<checksum>. */
-  do {
-  putDebugChar('$');
-  checksum = 0;
-  count    = 0;
-  
-  while (ch=buffer[count]) {
-    putDebugChar(ch);
-    checksum += ch;
-    count += 1;
-  }
-  
-  putDebugChar('#');
-  putDebugChar(hexchars[checksum >> 4]);
-  putDebugChar(hexchars[checksum % 16]);
-
-  } while (getDebugChar() != '+');
-  
+  do
+    {
+      putDebugChar ('$');
+      checksum = 0;
+      count = 0;
+
+      while (ch = buffer[count])
+	{
+	  putDebugChar (ch);
+	  checksum += ch;
+	  count += 1;
+	}
+
+      putDebugChar ('#');
+      putDebugChar (hexchars[checksum >> 4]);
+      putDebugChar (hexchars[checksum % 16]);
+
+    }
+  while (getDebugChar () != '+');
+
 }
 
-void debug_error(format, parm)
-char * format;
-char * parm;
+void
+debug_error (format, parm)
+     char *format;
+     char *parm;
 {
-  if (remote_debug) fprintf (stderr,format,parm);
+  if (remote_debug)
+    fprintf (stderr, format, parm);
 }
 
 /* convert the memory pointed to by mem into hex, placing result in buf */
 /* return a pointer to the last char put in buf (null) */
-char* mem2hex(mem, buf, count)
-char* mem;
-char* buf;
-int   count;
+char *
+mem2hex (mem, buf, count)
+     char *mem;
+     char *buf;
+     int count;
 {
-      int i;
-      unsigned char ch;
-      for (i=0;i<count;i++) {
-          ch = *mem++;
-          *buf++ = hexchars[ch >> 4];
-          *buf++ = hexchars[ch % 16];
-      }
-      *buf = 0; 
-      return(buf);
+  int i;
+  unsigned char ch;
+  for (i = 0; i < count; i++)
+    {
+      ch = *mem++;
+      *buf++ = hexchars[ch >> 4];
+      *buf++ = hexchars[ch % 16];
+    }
+  *buf = 0;
+  return (buf);
 }
 
 /* convert the hex array pointed to by buf into binary to be placed in mem */
 /* return a pointer to the character AFTER the last byte written */
-char* hex2mem(buf, mem, count)
-char* buf;
-char* mem;
-int   count;
+char *
+hex2mem (buf, mem, count)
+     char *buf;
+     char *mem;
+     int count;
 {
-      int i;
-      unsigned char ch;
-      for (i=0;i<count;i++) {
-          ch = hex(*buf++) << 4;
-          ch = ch + hex(*buf++);
-          *mem++ = ch;
-      }
-      return(mem);
+  int i;
+  unsigned char ch;
+  for (i = 0; i < count; i++)
+    {
+      ch = hex (*buf++) << 4;
+      ch = ch + hex (*buf++);
+      *mem++ = ch;
+    }
+  return (mem);
 }
 
 /* a bus error has occurred, perform a longjmp
    to return execution and allow handling of the error */
 
-void handle_buserror()
+void
+handle_buserror ()
 {
-  longjmp(remcomEnv,1);
+  longjmp (remcomEnv, 1);
 }
 
 /* this function takes the 68000 exception number and attempts to 
    translate this number into a unix compatible signal value */
-int computeSignal( exceptionVector )
-int exceptionVector;
+int
+computeSignal (exceptionVector)
+     int exceptionVector;
 {
   int sigval;
-  switch (exceptionVector) {
-    case 2 : sigval = 10; break; /* bus error           */
-    case 3 : sigval = 10; break; /* address error       */
-    case 4 : sigval = 4;  break; /* illegal instruction */
-    case 5 : sigval = 8;  break; /* zero divide         */
-    case 6 : sigval = 8; break; /* chk instruction     */
-    case 7 : sigval = 8; break; /* trapv instruction   */
-    case 8 : sigval = 11; break; /* privilege violation */
-    case 9 : sigval = 5;  break; /* trace trap          */
-    case 10: sigval = 4;  break; /* line 1010 emulator  */
-    case 11: sigval = 4;  break; /* line 1111 emulator  */
+  switch (exceptionVector)
+    {
+    case 2:
+      sigval = 10;
+      break;			/* bus error           */
+    case 3:
+      sigval = 10;
+      break;			/* address error       */
+    case 4:
+      sigval = 4;
+      break;			/* illegal instruction */
+    case 5:
+      sigval = 8;
+      break;			/* zero divide         */
+    case 6:
+      sigval = 8;
+      break;			/* chk instruction     */
+    case 7:
+      sigval = 8;
+      break;			/* trapv instruction   */
+    case 8:
+      sigval = 11;
+      break;			/* privilege violation */
+    case 9:
+      sigval = 5;
+      break;			/* trace trap          */
+    case 10:
+      sigval = 4;
+      break;			/* line 1010 emulator  */
+    case 11:
+      sigval = 4;
+      break;			/* line 1111 emulator  */
 
       /* Coprocessor protocol violation.  Using a standard MMU or FPU
-	 this cannot be triggered by software.  Call it a SIGBUS.  */
-    case 13: sigval = 10;  break;
-
-    case 31: sigval = 2;  break; /* interrupt           */
-    case 33: sigval = 5;  break; /* breakpoint          */
+         this cannot be triggered by software.  Call it a SIGBUS.  */
+    case 13:
+      sigval = 10;
+      break;
+
+    case 31:
+      sigval = 2;
+      break;			/* interrupt           */
+    case 33:
+      sigval = 5;
+      break;			/* breakpoint          */
 
       /* This is a trap #8 instruction.  Apparently it is someone's software
-	 convention for some sort of SIGFPE condition.  Whose?  How many
-	 people are being screwed by having this code the way it is?
-	 Is there a clean solution?  */
-    case 40: sigval = 8;  break; /* floating point err  */
-
-    case 48: sigval = 8;  break; /* floating point err  */
-    case 49: sigval = 8;  break; /* floating point err  */
-    case 50: sigval = 8;  break; /* zero divide         */
-    case 51: sigval = 8;  break; /* underflow           */
-    case 52: sigval = 8;  break; /* operand error       */
-    case 53: sigval = 8;  break; /* overflow            */
-    case 54: sigval = 8;  break; /* NAN                 */
-    default: 
-      sigval = 7;         /* "software generated"*/
-  }
+         convention for some sort of SIGFPE condition.  Whose?  How many
+         people are being screwed by having this code the way it is?
+         Is there a clean solution?  */
+    case 40:
+      sigval = 8;
+      break;			/* floating point err  */
+
+    case 48:
+      sigval = 8;
+      break;			/* floating point err  */
+    case 49:
+      sigval = 8;
+      break;			/* floating point err  */
+    case 50:
+      sigval = 8;
+      break;			/* zero divide         */
+    case 51:
+      sigval = 8;
+      break;			/* underflow           */
+    case 52:
+      sigval = 8;
+      break;			/* operand error       */
+    case 53:
+      sigval = 8;
+      break;			/* overflow            */
+    case 54:
+      sigval = 8;
+      break;			/* NAN                 */
+    default:
+      sigval = 7;		/* "software generated" */
+    }
   return (sigval);
 }
 
@@ -725,242 +784,255 @@ int exceptionVector;
 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
 /* RETURN NUMBER OF CHARS PROCESSED           */
 /**********************************************/
-int hexToInt(char **ptr, int *intValue)
+int
+hexToInt (char **ptr, int *intValue)
 {
-    int numChars = 0;
-    int hexValue;
-    
-    *intValue = 0;
+  int numChars = 0;
+  int hexValue;
+
+  *intValue = 0;
 
-    while (**ptr)
+  while (**ptr)
     {
-        hexValue = hex(**ptr);
-        if (hexValue >=0)
-        {
-            *intValue = (*intValue <<4) | hexValue;
-            numChars ++;
-        }
-        else
-            break;
-        
-        (*ptr)++;
+      hexValue = hex (**ptr);
+      if (hexValue >= 0)
+	{
+	  *intValue = (*intValue << 4) | hexValue;
+	  numChars++;
+	}
+      else
+	break;
+
+      (*ptr)++;
     }
 
-    return (numChars);
+  return (numChars);
 }
 
 /*
  * This function does all command procesing for interfacing to gdb.
  */
-void handle_exception(int exceptionVector)
+void
+handle_exception (int exceptionVector)
 {
-  int    sigval, stepping;
-  int    addr, length;
-  char * ptr;
-  int    newPC;
-  Frame  *frame;
-  
-  if (remote_debug) printf("vector=%d, sr=0x%x, pc=0x%x\n", 
-			    exceptionVector,
-			    registers[ PS ], 
-			    registers[ PC ]);
+  int sigval, stepping;
+  int addr, length;
+  char *ptr;
+  int newPC;
+  Frame *frame;
+
+  if (remote_debug)
+    printf ("vector=%d, sr=0x%x, pc=0x%x\n",
+	    exceptionVector, registers[PS], registers[PC]);
 
   /* reply to host that an exception has occurred */
-  sigval = computeSignal( exceptionVector );
+  sigval = computeSignal (exceptionVector);
   remcomOutBuffer[0] = 'S';
-  remcomOutBuffer[1] =  hexchars[sigval >> 4];
-  remcomOutBuffer[2] =  hexchars[sigval % 16];
+  remcomOutBuffer[1] = hexchars[sigval >> 4];
+  remcomOutBuffer[2] = hexchars[sigval % 16];
   remcomOutBuffer[3] = 0;
 
-  putpacket(remcomOutBuffer); 
+  putpacket (remcomOutBuffer);
 
   stepping = 0;
 
-  while (1==1) { 
-    remcomOutBuffer[0] = 0;
-    ptr = getpacket();
-    switch (*ptr++) {
-      case '?' :   remcomOutBuffer[0] = 'S';
-                   remcomOutBuffer[1] =  hexchars[sigval >> 4];
-                   remcomOutBuffer[2] =  hexchars[sigval % 16];
-                   remcomOutBuffer[3] = 0;
-                 break; 
-      case 'd' : remote_debug = !(remote_debug);  /* toggle debug flag */
-                 break; 
-      case 'g' : /* return the value of the CPU registers */
-                mem2hex((char*) registers, remcomOutBuffer, NUMREGBYTES);
-                break;
-      case 'G' : /* set the value of the CPU registers - return OK */
-                hex2mem(ptr, (char*) registers, NUMREGBYTES);
-                strcpy(remcomOutBuffer,"OK");
-                break;
-      
-      /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
-      case 'm' : 
-	        if (setjmp(remcomEnv) == 0)
-                {
-                    exceptionHandler(2,handle_buserror); 
-
-		    /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
-                    if (hexToInt(&ptr,&addr))
-                        if (*(ptr++) == ',')
-                            if (hexToInt(&ptr,&length)) 
-                            {
-                                ptr = 0;
-                                mem2hex((char*) addr, remcomOutBuffer, length);
-                            }
-
-                    if (ptr)
-                    {
-		      strcpy(remcomOutBuffer,"E01");
-                    }     
-                } else {
-		  exceptionHandler(2,_catchException);   
-		  strcpy(remcomOutBuffer,"E03");
-		  debug_error("bus error");
-		}     
-                
-		/* restore handler for bus error */
-		exceptionHandler(2,_catchException);   
+  while (1 == 1)
+    {
+      remcomOutBuffer[0] = 0;
+      ptr = getpacket ();
+      switch (*ptr++)
+	{
+	case '?':
+	  remcomOutBuffer[0] = 'S';
+	  remcomOutBuffer[1] = hexchars[sigval >> 4];
+	  remcomOutBuffer[2] = hexchars[sigval % 16];
+	  remcomOutBuffer[3] = 0;
+	  break;
+	case 'd':
+	  remote_debug = !(remote_debug);	/* toggle debug flag */
+	  break;
+	case 'g':		/* return the value of the CPU registers */
+	  mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES);
+	  break;
+	case 'G':		/* set the value of the CPU registers - return OK */
+	  hex2mem (ptr, (char *) registers, NUMREGBYTES);
+	  strcpy (remcomOutBuffer, "OK");
+	  break;
+
+	  /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
+	case 'm':
+	  if (setjmp (remcomEnv) == 0)
+	    {
+	      exceptionHandler (2, handle_buserror);
+
+	      /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
+	      if (hexToInt (&ptr, &addr))
+		if (*(ptr++) == ',')
+		  if (hexToInt (&ptr, &length))
+		    {
+		      ptr = 0;
+		      mem2hex ((char *) addr, remcomOutBuffer, length);
+		    }
+
+	      if (ptr)
+		{
+		  strcpy (remcomOutBuffer, "E01");
+		}
+	    }
+	  else
+	    {
+	      exceptionHandler (2, _catchException);
+	      strcpy (remcomOutBuffer, "E03");
+	      debug_error ("bus error");
+	    }
+
+	  /* restore handler for bus error */
+	  exceptionHandler (2, _catchException);
+	  break;
+
+	  /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
+	case 'M':
+	  if (setjmp (remcomEnv) == 0)
+	    {
+	      exceptionHandler (2, handle_buserror);
+
+	      /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
+	      if (hexToInt (&ptr, &addr))
+		if (*(ptr++) == ',')
+		  if (hexToInt (&ptr, &length))
+		    if (*(ptr++) == ':')
+		      {
+			hex2mem (ptr, (char *) addr, length);
+			ptr = 0;
+			strcpy (remcomOutBuffer, "OK");
+		      }
+	      if (ptr)
+		{
+		  strcpy (remcomOutBuffer, "E02");
+		}
+	    }
+	  else
+	    {
+	      exceptionHandler (2, _catchException);
+	      strcpy (remcomOutBuffer, "E03");
+	      debug_error ("bus error");
+	    }
+
+	  /* restore handler for bus error */
+	  exceptionHandler (2, _catchException);
+	  break;
+
+	  /* cAA..AA    Continue at address AA..AA(optional) */
+	  /* sAA..AA   Step one instruction from AA..AA(optional) */
+	case 's':
+	  stepping = 1;
+	case 'c':
+	  /* try to read optional parameter, pc unchanged if no parm */
+	  if (hexToInt (&ptr, &addr))
+	    registers[PC] = addr;
+
+	  newPC = registers[PC];
+
+	  /* clear the trace bit */
+	  registers[PS] &= 0x7fff;
+
+	  /* set the trace bit if we're stepping */
+	  if (stepping)
+	    registers[PS] |= 0x8000;
+
+	  /*
+	   * look for newPC in the linked list of exception frames.
+	   * if it is found, use the old frame it.  otherwise,
+	   * fake up a dummy frame in returnFromException().
+	   */
+	  if (remote_debug)
+	    printf ("new pc = 0x%x\n", newPC);
+	  frame = lastFrame;
+	  while (frame)
+	    {
+	      if (remote_debug)
+		printf ("frame at 0x%x has pc=0x%x, except#=%d\n",
+			frame, frame->exceptionPC, frame->exceptionVector);
+	      if (frame->exceptionPC == newPC)
+		break;		/* bingo! a match */
+	      /*
+	       * for a breakpoint instruction, the saved pc may
+	       * be off by two due to re-executing the instruction
+	       * replaced by the trap instruction.  Check for this.
+	       */
+	      if ((frame->exceptionVector == 33) &&
+		  (frame->exceptionPC == (newPC + 2)))
 		break;
-      
-      /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
-      case 'M' : 
-	        if (setjmp(remcomEnv) == 0) {
-		    exceptionHandler(2,handle_buserror); 
-                    
-		    /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
-                    if (hexToInt(&ptr,&addr))
-                        if (*(ptr++) == ',')
-                            if (hexToInt(&ptr,&length))
-                                if (*(ptr++) == ':')
-                                {
-                                    hex2mem(ptr, (char*) addr, length);
-                                    ptr = 0;
-                                    strcpy(remcomOutBuffer,"OK");
-                                }
-                    if (ptr)
-                    {
-		      strcpy(remcomOutBuffer,"E02");
-		    }     
-                } else {
-		  exceptionHandler(2,_catchException);   
-		  strcpy(remcomOutBuffer,"E03");
-		  debug_error("bus error");
-		}     
-
-                /* restore handler for bus error */
-                exceptionHandler(2,_catchException);   
-                break;
-     
-     /* cAA..AA    Continue at address AA..AA(optional) */
-     /* sAA..AA   Step one instruction from AA..AA(optional) */
-     case 's' : 
-	 stepping = 1;
-     case 'c' : 
-          /* try to read optional parameter, pc unchanged if no parm */
-         if (hexToInt(&ptr,&addr))
-             registers[ PC ] = addr;
-             
-          newPC = registers[ PC];
-          
-          /* clear the trace bit */
-          registers[ PS ] &= 0x7fff;
-          
-          /* set the trace bit if we're stepping */
-          if (stepping) registers[ PS ] |= 0x8000;
-          
-          /*
-           * look for newPC in the linked list of exception frames.
-           * if it is found, use the old frame it.  otherwise,
-           * fake up a dummy frame in returnFromException().
-           */
-          if (remote_debug) printf("new pc = 0x%x\n",newPC);
-          frame = lastFrame;
-          while (frame)
-          {
-              if (remote_debug)
-                  printf("frame at 0x%x has pc=0x%x, except#=%d\n",
-                         frame,frame->exceptionPC,
-                         frame->exceptionVector);
-              if (frame->exceptionPC == newPC) break;  /* bingo! a match */
-              /*
-               * for a breakpoint instruction, the saved pc may
-               * be off by two due to re-executing the instruction
-               * replaced by the trap instruction.  Check for this.
-               */
-              if ((frame->exceptionVector == 33) &&
-                  (frame->exceptionPC == (newPC+2))) break;
-              if (frame == frame->previous)
-	      {
-	          frame = 0; /* no match found */ 
-	          break; 
-	      }
+	      if (frame == frame->previous)
+		{
+		  frame = 0;	/* no match found */
+		  break;
+		}
 	      frame = frame->previous;
-          }
-          
-          /*
-           * If we found a match for the PC AND we are not returning
-           * as a result of a breakpoint (33),
-           * trace exception (9), nmi (31), jmp to
-           * the old exception handler as if this code never ran.
-           */
-          if (frame) 
-          {
-              if ((frame->exceptionVector != 9)  && 
-                  (frame->exceptionVector != 31) && 
-                  (frame->exceptionVector != 33))
-              { 
-                  /*
-                   * invoke the previous handler.
-                   */
-                  if (oldExceptionHook)
-                      (*oldExceptionHook) (frame->exceptionVector);
-                  newPC = registers[ PC ];    /* pc may have changed  */
-                  if (newPC != frame->exceptionPC)
-                  {
-                      if (remote_debug)
-                          printf("frame at 0x%x has pc=0x%x, except#=%d\n",
-                                 frame,frame->exceptionPC,
-                                 frame->exceptionVector);
-                      /* re-use the last frame, we're skipping it (longjump?)*/
+	    }
+
+	  /*
+	   * If we found a match for the PC AND we are not returning
+	   * as a result of a breakpoint (33),
+	   * trace exception (9), nmi (31), jmp to
+	   * the old exception handler as if this code never ran.
+	   */
+	  if (frame)
+	    {
+	      if ((frame->exceptionVector != 9) &&
+		  (frame->exceptionVector != 31) &&
+		  (frame->exceptionVector != 33))
+		{
+		  /*
+		   * invoke the previous handler.
+		   */
+		  if (oldExceptionHook)
+		    (*oldExceptionHook) (frame->exceptionVector);
+		  newPC = registers[PC];	/* pc may have changed  */
+		  if (newPC != frame->exceptionPC)
+		    {
+		      if (remote_debug)
+			printf ("frame at 0x%x has pc=0x%x, except#=%d\n",
+				frame, frame->exceptionPC,
+				frame->exceptionVector);
+		      /* re-use the last frame, we're skipping it (longjump?) */
 		      frame = (Frame *) 0;
-	              _returnFromException( frame );  /* this is a jump */
-                  }
-              }
-          }         
-
-    	  /* if we couldn't find a frame, create one */
-          if (frame == 0)
-	  {
-    	      frame = lastFrame -1 ;
-	      
+		      _returnFromException (frame);	/* this is a jump */
+		    }
+		}
+	    }
+
+	  /* if we couldn't find a frame, create one */
+	  if (frame == 0)
+	    {
+	      frame = lastFrame - 1;
+
 	      /* by using a bunch of print commands with breakpoints,
-    	         it's possible for the frame stack to creep down.  If it creeps
-		 too far, give up and reset it to the top.  Normal use should
-    	         not see this happen.
-    	      */
-	      if ((unsigned int) (frame-2) < (unsigned int) &gdbFrameStack)
-    	      {
-    	         initializeRemcomErrorFrame();
-    	         frame = lastFrame; 
-	      }
-    	      frame->previous = lastFrame;
-              lastFrame = frame;
-              frame = 0;  /* null so _return... will properly initialize it */ 
-	  }    
-	  
-	  _returnFromException( frame ); /* this is a jump */
-
-          break;
-          
-      /* kill the program */
-      case 'k' :  /* do nothing */
-                break;
-      } /* switch */ 
-    
-    /* reply to the request */
-    putpacket(remcomOutBuffer); 
+	         it's possible for the frame stack to creep down.  If it creeps
+	         too far, give up and reset it to the top.  Normal use should
+	         not see this happen.
+	       */
+	      if ((unsigned int) (frame - 2) < (unsigned int) &gdbFrameStack)
+		{
+		  initializeRemcomErrorFrame ();
+		  frame = lastFrame;
+		}
+	      frame->previous = lastFrame;
+	      lastFrame = frame;
+	      frame = 0;	/* null so _return... will properly initialize it */
+	    }
+
+	  _returnFromException (frame);	/* this is a jump */
+
+	  break;
+
+	  /* kill the program */
+	case 'k':		/* do nothing */
+	  break;
+	}			/* switch */
+
+      /* reply to the request */
+      putpacket (remcomOutBuffer);
     }
 }
 
@@ -968,46 +1040,47 @@ void handle_exception(int exceptionVector)
 void
 initializeRemcomErrorFrame (void)
 {
-    lastFrame = ((Frame *) &gdbFrameStack[FRAMESIZE-1]) - 1;
-    lastFrame->previous = lastFrame;
+  lastFrame = ((Frame *) & gdbFrameStack[FRAMESIZE - 1]) - 1;
+  lastFrame->previous = lastFrame;
 }
 
 /* this function is used to set up exception handlers for tracing and 
    breakpoints */
-void set_debug_traps()
+void
+set_debug_traps ()
 {
-  extern void _debug_level7();
-  extern void remcomHandler();
+  extern void _debug_level7 ();
+  extern void remcomHandler ();
   int exception;
 
-  initializeRemcomErrorFrame();
-  stackPtr  = &remcomStack[STACKSIZE/sizeof(int) - 1];
+  initializeRemcomErrorFrame ();
+  stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
 
   for (exception = 2; exception <= 23; exception++)
-      exceptionHandler(exception,_catchException);   
+    exceptionHandler (exception, _catchException);
 
   /* level 7 interrupt              */
-  exceptionHandler(31,_debug_level7);    
-  
+  exceptionHandler (31, _debug_level7);
+
   /* breakpoint exception (trap #1) */
-  exceptionHandler(33,_catchException);
-  
+  exceptionHandler (33, _catchException);
+
   /* This is a trap #8 instruction.  Apparently it is someone's software
      convention for some sort of SIGFPE condition.  Whose?  How many
      people are being screwed by having this code the way it is?
      Is there a clean solution?  */
-  exceptionHandler(40,_catchException);
-  
+  exceptionHandler (40, _catchException);
+
   /* 48 to 54 are floating point coprocessor errors */
   for (exception = 48; exception <= 54; exception++)
-      exceptionHandler(exception,_catchException);   
+    exceptionHandler (exception, _catchException);
 
   if (oldExceptionHook != remcomHandler)
-  {
+    {
       oldExceptionHook = exceptionHook;
-      exceptionHook    = remcomHandler;
-  }
-  
+      exceptionHook = remcomHandler;
+    }
+
   initialized = 1;
 
 }
@@ -1016,9 +1089,10 @@ void set_debug_traps()
    beginning of a program to sync up with a debugger and can be used
    otherwise as a quick means to stop program execution and "break" into
    the debugger. */
-   
-void breakpoint()
+
+void
+breakpoint ()
 {
-  if (initialized) BREAKPOINT();
+  if (initialized)
+    BREAKPOINT ();
 }
-