* 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.

1 files changed, 428 insertions, 354 deletions

diff --git a/gdb/m68k-stub.c b/gdb/m68k-stub.c
index 72281da..54e06b1 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 ();
 }
-