* So many patches have been posted recently on the mailing list and

	because we were unable to find correct solution to compile on various
	linux distros (due to rpcgen incompatibilities), and because the coding
	style of rdbg was rather inconsistant among various pieces of code, I
	decided to:
	    1) make some cleaning regarding global coding style (using
	       indent + manual edits),
	    2) incorporate/review the paches send by various people
	       (S. Holford, T. Strauman),
	    3) Fix the bug due to varying rpcgen code generation
	       in remdeb_svc.c,
	    4) Remove some dead code,
	    5) Apply a patches enabling to call enterRdbg imediately
	       after rdbg initialization is done,

	NB : the paches is huge but it is mainly due to coding styke chnages.
	Only few lines of codes have been really changed and they do not impact
	rdbg functionnality (AFAIKT).

	* include/rdbg/servrpc.h, include/rdbg/i386/rdbg_f.h,
	include/rdbg/m68k/rdbg_f.h, include/rdbg/powerpc/rdbg_f.h,
	src/_servtgt.c, src/awk.svc, src/excep.c, src/ptrace.c, src/rdbg.c,
	src/remdeb.x, src/servbkpt.c, src/servcon.c, src/servrpc.c,
	src/servtgt.c, src/servtsp.c, src/servutil.c, src/i386/excep_f.c,
	src/i386/rdbg_f.c, src/i386/any/Makefile.am, src/i386/any/remdeb.h,
	src/i386/any/remdeb_svc.c, src/i386/any/remdeb_xdr.c,
	src/m68k/excep_f.c, src/m68k/rdbg_f.c, src/m68k/any/Makefile.am,
	src/m68k/any/remdeb.h, src/m68k/any/remdeb_svc.c,
	src/m68k/any/remdeb_xdr.c, src/powerpc/excep_f.c, src/powerpc/rdbg_f.c,
	src/powerpc/new_exception_processing/Makefile.am,
	src/powerpc/new_exception_processing/remdeb.h,
	src/powerpc/new_exception_processing/remdeb_svc.c,
	src/powerpc/new_exception_processing/remdeb_xdr.c: Modified.

1 files changed, 576 insertions, 527 deletions

diff --git a/c/src/librdbg/src/servrpc.c b/c/src/librdbg/src/servrpc.c
index 310f3bb6c4..9fd56080f5 100644
--- a/c/src/librdbg/src/servrpc.c
+++ b/c/src/librdbg/src/servrpc.c
@@ -31,48 +31,53 @@
 	properly.
    ----------------------------------------------------------------------- */
 
-open_out* RPCGENSRVNAME(open_connex_2_svc) (open_in *in, struct svc_req *rqstp)
+  open_out *
+RPCGENSRVNAME (open_connex_2_svc) (open_in * in,
+                                   struct svc_req * rqstp)
 {
-  static open_out out;		/* output response. This could be heap local */
-  int		idx;
-  static int	one_time = 0;	/* we do one-time setup on back port */
-
-  /* need to support in->debug_type, in->flags, and in->destination!!! */
-
-  if (!one_time)
-  {				/* only setup one backport socket */
-    /* now setup signals and the like for handling process changes */
-    setErrno(0);
-    TspInit(rqstp->rq_xprt->xp_sock); /* init transport system */
-    if (getErrno())
-    {				/* failed in setup */
-      out.port = (u_long)-1;
-      out.fp = getErrno();		/* error causing to fail */
-      return(&out);		/* fail */
+  static open_out out;          /* output response. This could be heap local */
+  int idx;
+  static int one_time = 0;      /* we do one-time setup on back port */
+
+  /*
+   * need to support in->debug_type, in->flags, and in->destination!!! 
+   */
+
+  if (!one_time) {              /* only setup one backport socket */
+    /*
+     * now setup signals and the like for handling process changes 
+     */
+    setErrno (0);
+    TspInit (rqstp->rq_xprt->xp_sock);  /* init transport system */
+    if (getErrno ()) {          /* failed in setup */
+      out.port = (u_long) - 1;
+      out.fp = getErrno ();     /* error causing to fail */
+      return (&out);            /* fail */
     }
-    one_time = True;		/* disable doing this again */
+    one_time = True;            /* disable doing this again */
   }
 
-  DPRINTF(("open_connex_2_svc: Opening connection from '%s'\n",
-	in->user_name));
+  DPRINTF (("open_connex_2_svc: Opening connection from '%s'\n",
+            in->user_name));
 
-  /* now setup a validation of all other connections */
+  /*
+   * now setup a validation of all other connections 
+   */
   for (idx = 0; idx < conn_list_cnt; idx++)
-    if (conn_list[idx].in_use)
-    { 				/* setup retry timer */
-      DPRINTF(("open_connex_2_svc: Still have connection %d with port %d\n",
-	idx, HL_W(*((UINT16*)&conn_list[idx].back_port.c[2]))));
+    if (conn_list[idx].in_use) {    /* setup retry timer */
+      DPRINTF (("open_connex_2_svc: Still have connection %d with port %d\n",
+                idx, HL_W (*((UINT16 *) & conn_list[idx].back_port.c[2]))));
     }
 
-  idx = ConnCreate(rqstp, in);	/* setup the connection */
-  out.port = idx;		/* connection number */
+  idx = ConnCreate (rqstp, in); /* setup the connection */
+  out.port = idx;               /* connection number */
   if (idx == -1)
-    out.fp = getErrno();		/* error causing to fail */
+    out.fp = getErrno ();       /* error causing to fail */
   else
     out.fp = TARGET_PROC_TYPE;
 
   out.server_vers = SERVER_VERS;
-  return(&out);
+  return (&out);
 }
 
 /* -----------------------------------------------------------------------
@@ -86,30 +91,36 @@ open_out* RPCGENSRVNAME(open_connex_2_svc) (open_in *in, struct svc_req *rqstp)
 	needed.
    ----------------------------------------------------------------------- */
 
-signal_out *RPCGENSRVNAME(send_signal_2_svc) (signal_in *in, struct svc_req *rqstp)
+  signal_out *
+RPCGENSRVNAME (send_signal_2_svc) (signal_in * in,
+                                   struct svc_req * rqstp)
 {
-  static signal_out out;	/* return code from kill */
+  static signal_out out;        /* return code from kill */
 
-  /* we do not care if connected */
-  setErrno(0);
+  /*
+   * we do not care if connected 
+   */
+  setErrno (0);
   out.kill_return = 0;
   out.errNo = 0;
   TotalReboot = 1;
-  return(&out);
+  return (&out);
 }
 
 /* -----------------------------------------------------------------------
    close_connex_2_svc - close a connection from a client.
    ----------------------------------------------------------------------- */
 
-void *RPCGENSRVNAME(close_connex_2_svc) (close_in *in, struct svc_req *rqstp)
+  void *
+RPCGENSRVNAME (close_connex_2_svc) (close_in * in,
+                                    struct svc_req * rqstp)
 {
-  int		conn_idx = TspConnGetIndex(rqstp);
+  int conn_idx = TspConnGetIndex (rqstp);
 
-  if (conn_idx != -1)		/* found it, clear out */
-    ConnDelete(conn_idx, rqstp, in->control);
+  if (conn_idx != -1)           /* found it, clear out */
+    ConnDelete (conn_idx, rqstp, in->control);
 
-  return (void*) ""; /* need to return something */
+  return (void *) "";           /* need to return something */
 }
 
 /* -----------------------------------------------------------------------
@@ -119,121 +130,123 @@ void *RPCGENSRVNAME(close_connex_2_svc) (close_in *in, struct svc_req *rqstp)
 #define REG_COUNT \
     (sizeof (xdr_regs) / sizeof (int))
 
-ptrace_out *RPCGENSRVNAME(ptrace_2_svc) (ptrace_in *in, struct svc_req *rqstp)
+  ptrace_out *
+RPCGENSRVNAME (ptrace_2_svc) (ptrace_in * in,
+                              struct svc_req * rqstp)
 {
-  int		conn_idx = rqstp ? TspConnGetIndex(rqstp) : -1;
-  static ptrace_out out;	/* outut response (error or data) */
-  void		*addr, *addr2;	/* used for actual ptrace call */
-  unsigned int	data;
-  int		req, pid, ret, pid_idx, idx;
-  static union
-  {				/* local buffer for returned data */
-    Objects_Id	t_list[UTHREAD_MAX]; /* thread_list return */
-    char	t_name[THREADNAMEMAX]; /* thread name return */
-  } local_buff;			/* for return handling of strings and the like */
-  PID_LIST	*plst = NULL;	/* current pid_list entry */
+  int conn_idx = rqstp ? TspConnGetIndex (rqstp) : -1;
+  static ptrace_out out;        /* outut response (error or data) */
+  void *addr, *addr2;           /* used for actual ptrace call */
+  unsigned int data;
+  int req, pid, ret, pid_idx, idx;
+  static union {                /* local buffer for returned data */
+    Objects_Id t_list[UTHREAD_MAX]; /* thread_list return */
+    char t_name[THREADNAMEMAX]; /* thread name return */
+  } local_buff;                 /* for return handling of strings and the like */
+  PID_LIST *plst = NULL;        /* current pid_list entry */
 
   DPRINTF (("ptrace_2_svc: entered (%s (%d), %d, XXXX, %d, XXXX)\n",
-      PtraceName (in->addr.req), in->addr.req, in->pid,
-      in->data));
+            PtraceName (in->addr.req), in->addr.req, in->pid, in->data));
 
   out.addr.ptrace_addr_data_out_u.addr = 0;
 
-  /* validate the connection */
-  if (conn_idx == -1  &&  rqstp != NULL)
-  {				/* no connection, error */
-    DPRINTF(("ptrace_2_svc: msg from unknown debugger!\n"));
+  /*
+   * validate the connection 
+   */
+  if (conn_idx == -1 && rqstp != NULL) {    /* no connection, error */
+    DPRINTF (("ptrace_2_svc: msg from unknown debugger!\n"));
     out.result = -1;
-    out.errNo = ECHILD;		/* closest error */
-    out.addr.req = 0;		/* to avoid copies that should not occur */
-    return(&out);
+    out.errNo = ECHILD;         /* closest error */
+    out.addr.req = 0;           /* to avoid copies that should not occur */
+    return (&out);
   }
-    /* Consider that the last back-message is acknowledged */
-  if (conn_idx >= 0  &&  conn_list[conn_idx].retry) {
-    TspMessageReceive(conn_idx, in->pid);
+  /*
+   * Consider that the last back-message is acknowledged 
+   */
+  if (conn_idx >= 0 && conn_list[conn_idx].retry) {
+    TspMessageReceive (conn_idx, in->pid);
   }
 
   req = in->addr.req;
-  out.addr.req = req; 		/* needed for RPC */
+  out.addr.req = req;           /* needed for RPC */
   pid = in->pid;
   addr = addr2 = NULL;
   data = in->data;
-  setErrno(0);			/* assume works */
-  out.result = 0;		/* assume worked ok */
+  setErrno (0);                 /* assume works */
+  out.result = 0;               /* assume worked ok */
   out.errNo = 0;
 
-  /* lookup process to make sure we have under control */
+  /*
+   * lookup process to make sure we have under control 
+   */
   pid_idx = FindPidEntry (in->pid);
-  if (pid_idx >= 0)		/* found it */
-  {
+  if (pid_idx >= 0) {           /* found it */
     plst = &pid_list[pid_idx];
     if (conn_idx < 0)
       conn_idx = plst->primary_conn;
   }
 
-  /* now we handle the special case of ATTACH to a pid we already control */
-  if (req == RPT_ATTACH)
-  {				/* look it up first */
-    if (plst)
-    {				/* we have controlled , so return ok+show conn */
-      ret = 2;			/* normally secondary connection */
-      if (! PIDMAP_TEST (conn_idx, pid_idx))
-      {				/* mark as an owner if not already */
-	plst->owners++;
-	PIDMAP_SET (conn_idx, pid_idx);		/* mask in */
-      }
-      else if (plst->primary_conn != NO_PRIMARY)
-      {				/* regrab makes primary */
-	    /* Only if not primary already */
-	if (plst->primary_conn != conn_idx) {
-	    TspSendWaitChange(plst->primary_conn, BMSG_NOT_PRIM,
-			conn_idx, plst->pid, 0, False); /* tell old owner */
-	}
-	plst->primary_conn = NO_PRIMARY;
+  /*
+   * now we handle the special case of ATTACH to a pid we already control 
+   */
+  if (req == RPT_ATTACH) {      /* look it up first */
+    if (plst) {                 /* we have controlled , so return ok+show conn */
+      ret = 2;                  /* normally secondary connection */
+      if (!PIDMAP_TEST (conn_idx, pid_idx)) {   /* mark as an owner if not already */
+        plst->owners++;
+        PIDMAP_SET (conn_idx, pid_idx); /* mask in */
+      } else if (plst->primary_conn != NO_PRIMARY) {    /* regrab makes primary */
+        /*
+         * Only if not primary already 
+         */
+        if (plst->primary_conn != conn_idx) {
+          TspSendWaitChange (plst->primary_conn, BMSG_NOT_PRIM, conn_idx, plst->pid, 0, False); /* tell old owner */
+        }
+        plst->primary_conn = NO_PRIMARY;
       }
 
-      if (plst->primary_conn == NO_PRIMARY)
-      {				/* none now, so take over */
-	plst->primary_conn = conn_idx; /* new primary */
-	ret = 1;		/* primary */
+      if (plst->primary_conn == NO_PRIMARY) {   /* none now, so take over */
+        plst->primary_conn = conn_idx;  /* new primary */
+        ret = 1;                /* primary */
       }
-      out.result = ret; 	/* primary or secondary owner */
-      return(&out);
+      out.result = ret;         /* primary or secondary owner */
+      return (&out);
     }
-    /* else attach process using target code */
-    setErrno(ESRCH); 		/* assume the worst */
-    if (!TgtAttach(conn_idx, pid))
-    {				/* failed */
-      out.errNo = getErrno();
+    /*
+     * else attach process using target code 
+     */
+    setErrno (ESRCH);           /* assume the worst */
+    if (!TgtAttach (conn_idx, pid)) {   /* failed */
+      out.errNo = getErrno ();
       out.result = 0;
     }
-    return(&out);
-  }
-  else if (req == RPT_DETACH)
-  {				/* see which kind of detach */
-    if (data == PTRDET_UNOWN)
-    {				/* only want to disconnect from */
-      TgtDetachCon(conn_idx, pid_idx, True); /* remove from control */
-      return(&out);		/* done */
+    return (&out);
+  } else if (req == RPT_DETACH) {   /* see which kind of detach */
+    if (data == PTRDET_UNOWN) { /* only want to disconnect from */
+      TgtDetachCon (conn_idx, pid_idx, True);   /* remove from control */
+      return (&out);            /* done */
     }
-  }
-  else if (plst  &&  (req == RPT_GETNAME  ||  req == RPT_GETBREAK))
-  {
-    /* do nothing */
+  } else if (plst && (req == RPT_GETNAME || req == RPT_GETBREAK)) {
+    /*
+     * do nothing 
+     */
   }
 
-  else if (plst  &&  req == RPT_CLRBREAK) {
-     /* To be able to remove breakpoints from a "running" system */
+  else if (plst && req == RPT_CLRBREAK) {
+    /*
+     * To be able to remove breakpoints from a "running" system 
+     */
     DPRINTF (("ptrace_2_svc: allowing RPT_CLRBREAK %d\n", data));
-	/* do nothing */
+    /*
+     * do nothing 
+     */
   }
 
-  else if (plst && plst->running)
-  {				/* error, process is running and not detach */
+  else if (plst && plst->running) { /* error, process is running and not detach */
     out.result = -1;
-    out.errNo = ETXTBSY;	/* closest error */
+    out.errNo = ETXTBSY;        /* closest error */
     DPRINTF (("ptrace_2_svc: failed, still running.\n"));
-    return(&out);
+    return (&out);
   }
   if (plst == NULL) {
     out.result = -1;
@@ -242,457 +255,494 @@ ptrace_out *RPCGENSRVNAME(ptrace_2_svc) (ptrace_in *in, struct svc_req *rqstp)
     return (&out);
   }
 
-  /* now make sure secondary owner is not trying to modify */
-  if (!(in->flags & PTRFLG_NON_OWNER)) /* if not overriden */
+  /*
+   * now make sure secondary owner is not trying to modify 
+   */
+  if (!(in->flags & PTRFLG_NON_OWNER))  /* if not overriden */
     if (conn_idx != plst->primary_conn
-    &&  ( (req >= RPT_POKETEXT && req <= RPT_SINGLESTEP)
-       	  || (req >= RPT_SETREGS && req <= RPT_SETFPAREGS && (req & 1))
-	  || (req >= RPT_SYSCALL && req <= RPT_DUMPCORE)
-	  || (req >= RPT_SETTARGETTHREAD && req <= RPT_THREADRESUME)
-	  || (req >= RPT_SETTHREADNAME && req <= RPT_SETTHREADREGS)
-       	  || (req >= RPT_STEPRANGE && req <= RPT_CLRBREAK)
-	  || (req == RPT_STOP)
-	  || (req >= RPT_PSETREGS && req <= RPT_PSETTHREADREGS)))
-    {				/* not owner */
+        && ((req >= RPT_POKETEXT && req <= RPT_SINGLESTEP)
+            || (req >= RPT_SETREGS && req <= RPT_SETFPAREGS && (req & 1))
+            || (req >= RPT_SYSCALL && req <= RPT_DUMPCORE)
+            || (req >= RPT_SETTARGETTHREAD && req <= RPT_THREADRESUME)
+            || (req >= RPT_SETTHREADNAME && req <= RPT_SETTHREADREGS)
+            || (req >= RPT_STEPRANGE && req <= RPT_CLRBREAK)
+            || (req == RPT_STOP)
+            || (req >= RPT_PSETREGS && req <= RPT_PSETTHREADREGS))) {   /* not owner */
       out.result = -1;
-      out.errNo = EPERM;		/* cannot alter as not primary */
-      DPRINTF (("ptrace_2_svc: refused, not owner, flags %d conn_idx %d primary_conn %d\n", in->flags, conn_idx,
-	plst->primary_conn));
-      return(&out);
+      out.errNo = EPERM;        /* cannot alter as not primary */
+      DPRINTF (("ptrace_2_svc: refused, not owner, flags %d conn_idx %d primary_conn %d\n", in->flags, conn_idx, plst->primary_conn));
+      return (&out);
     }
 
-  addr = (void *)in->addr.ptrace_addr_data_in_u.address; /* default */
-  /* now setup normal ptrace request by unpacking. May execute here. */
-  switch (req)
-  {				/* handle unpacking or setup for real call */
-    /* first the ones where addr points to input data */
-    case RPT_SETREGS:
-    case RPT_SETTHREADREGS:
-      addr = (void *)&in->addr.ptrace_addr_data_in_u.regs; /* reg list */
-      break;
-
-    case RPT_PSETREGS:
-    case RPT_PSETTHREADREGS:
-      if (in->addr.ptrace_addr_data_in_u.pregs.pregs_len != REG_COUNT) {
-	DPRINTF(("ptrace_2_svc: pid %d got %d expected %d\n", pid,
-	    in->addr.ptrace_addr_data_in_u.pregs.pregs_len, REG_COUNT));
-	setErrno(EINVAL);
-	break;
-      }
-      req = req == RPT_PSETREGS ? RPT_SETREGS : RPT_SETTHREADREGS;
-      addr = (void *) in->addr.ptrace_addr_data_in_u.pregs.pregs_val;
-      break;
-
-    case RPT_SETTHREADNAME:
-      addr = (void *)in->addr.ptrace_addr_data_in_u.name;
+  addr = (void *) in->addr.ptrace_addr_data_in_u.address;   /* default */
+  /*
+   * now setup normal ptrace request by unpacking. May execute here. 
+   */
+  switch (req) {                /* handle unpacking or setup for real call */
+    /*
+     * first the ones where addr points to input data 
+     */
+  case RPT_SETREGS:
+  case RPT_SETTHREADREGS:
+    addr = (void *) &in->addr.ptrace_addr_data_in_u.regs;   /* reg list */
+    break;
+
+  case RPT_PSETREGS:
+  case RPT_PSETTHREADREGS:
+    if (in->addr.ptrace_addr_data_in_u.pregs.pregs_len != REG_COUNT) {
+      DPRINTF (("ptrace_2_svc: pid %d got %d expected %d\n", pid,
+                in->addr.ptrace_addr_data_in_u.pregs.pregs_len, REG_COUNT));
+      setErrno (EINVAL);
       break;
-    case RPT_WRITETEXT:
-    case RPT_WRITEDATA:
-      if ((int) data < 0) {
-	setErrno(EINVAL);
-	break;
-      }
-      addr = (void *)in->addr.ptrace_addr_data_in_u.mem.addr; /* targ addr */
-      addr2 = (void *)in->addr.ptrace_addr_data_in_u.mem.data; /* buff */
-
-	/* Forbid writing over breakpoints */
-      if (BreakOverwrite (plst, addr, data)) {
-	setErrno(EBUSY);
-      }
-      break;
-
-    case RPT_POKETEXT:
-    case RPT_POKEDATA:
-	/* Forbid writing over breakpoints */
-      if (BreakOverwrite (plst, addr, sizeof (int))) {
-	setErrno(EBUSY);
-      }
-      break;
-
-    /* now ones where we handle locally */
-    case RPT_GETTARGETTHREAD:
-      out.result = plst->thread;
-      req = 0;			/* force exit */
-      break;
-
-    case RPT_PGETREGS:	/* return from our buffer */
-      out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
-      out.addr.ptrace_addr_data_out_u.pregs.pregs_val = (u_int*) &plst->regs;
-      req = 0;			/* force exit */     
-      break;
-
-    case RPT_GETREGS:
-      /* return directly from our buffer */
-      /* this buffer is refreshed when changing target thread */
-      out.addr.ptrace_addr_data_out_u.regs = plst->regs;
-      req = 0;			/* force exit */     
-      break;
-
-    case RPT_SETBREAK:
-      idx = BreakSet (plst, conn_idx, &in->addr.ptrace_addr_data_in_u.breakp);
-      if (idx < 0) break;
-      req = 0;			/* force exit */
-      out.result = idx;		/* return break index (>0) */ 
-      break;
- 
-    case RPT_CLRBREAK:
-      if (conn_list[conn_idx].flags & DEBUGGER_IS_GDB) {
-          data = BreakGetIndex (plst, addr);
-      }
-      out.result = BreakClear (plst, conn_idx, data);
-      /* if errored, errno will still be set */
-      req = 0;
+    }
+    req = req == RPT_PSETREGS ? RPT_SETREGS : RPT_SETTHREADREGS;
+    addr = (void *) in->addr.ptrace_addr_data_in_u.pregs.pregs_val;
+    break;
+
+  case RPT_SETTHREADNAME:
+    addr = (void *) in->addr.ptrace_addr_data_in_u.name;
+    break;
+  case RPT_WRITETEXT:
+  case RPT_WRITEDATA:
+    if ((int) data < 0) {
+      setErrno (EINVAL);
       break;
-
-    case RPT_GETBREAK:
-      /* data=handle, addr=in_buffer, returns next break. Data=0, returns cnt */
-      out.result = BreakGet (plst, data, &out.addr.
-	ptrace_addr_data_out_u.breakp);
-      req = 0;			/* handle locally */
+    }
+    addr = (void *) in->addr.ptrace_addr_data_in_u.mem.addr;    /* targ addr */
+    addr2 = (void *) in->addr.ptrace_addr_data_in_u.mem.data;   /* buff */
+
+    /*
+     * Forbid writing over breakpoints 
+     */
+    if (BreakOverwrite (plst, addr, data)) {
+      setErrno (EBUSY);
+    }
+    break;
+
+  case RPT_POKETEXT:
+  case RPT_POKEDATA:
+    /*
+     * Forbid writing over breakpoints 
+     */
+    if (BreakOverwrite (plst, addr, sizeof (int))) {
+      setErrno (EBUSY);
+    }
+    break;
+
+    /*
+     * now ones where we handle locally 
+     */
+  case RPT_GETTARGETTHREAD:
+    out.result = plst->thread;
+    req = 0;                    /* force exit */
+    break;
+
+  case RPT_PGETREGS:           /* return from our buffer */
+    out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
+    out.addr.ptrace_addr_data_out_u.pregs.pregs_val = (u_int *) & plst->regs;
+    req = 0;                    /* force exit */
+    break;
+
+  case RPT_GETREGS:
+    /*
+     * return directly from our buffer 
+     */
+    /*
+     * this buffer is refreshed when changing target thread 
+     */
+    out.addr.ptrace_addr_data_out_u.regs = plst->regs;
+    req = 0;                    /* force exit */
+    break;
+
+  case RPT_SETBREAK:
+    idx = BreakSet (plst, conn_idx, &in->addr.ptrace_addr_data_in_u.breakp);
+    if (idx < 0)
       break;
+    req = 0;                    /* force exit */
+    out.result = idx;           /* return break index (>0) */
+    break;
 
-    case RPT_GETNAME:		/* get the name of the process */
-      if (!plst->name)
-        out.addr.ptrace_addr_data_out_u.mem.dataNb = 0;
-      else
-      {
-	int maxLen = sizeof out.addr.ptrace_addr_data_out_u.mem.data - 1;
-	data = strlen(plst->name);
-	if (data > maxLen)
-	  data = maxLen;
-        out.addr.ptrace_addr_data_out_u.mem.dataNb = data+1;
-        memcpy(out.addr.ptrace_addr_data_out_u.mem.data, plst->name, data+1);
-        out.addr.ptrace_addr_data_out_u.mem.data [maxLen] = '\0';
-      }
-      req = 0;
-      break;
+  case RPT_CLRBREAK:
+    if (conn_list[conn_idx].flags & DEBUGGER_IS_GDB) {
+      data = BreakGetIndex (plst, addr);
+    }
+    out.result = BreakClear (plst, conn_idx, data);
+    /*
+     * if errored, errno will still be set 
+     */
+    req = 0;
+    break;
+
+  case RPT_GETBREAK:
+    /*
+     * data=handle, addr=in_buffer, returns next break. Data=0, returns cnt 
+     */
+    out.result = BreakGet (plst, data, &out.addr.
+                           ptrace_addr_data_out_u.breakp);
+    req = 0;                    /* handle locally */
+    break;
+
+  case RPT_GETNAME:            /* get the name of the process */
+    if (!plst->name)
+      out.addr.ptrace_addr_data_out_u.mem.dataNb = 0;
+    else {
+      int maxLen = sizeof(out.addr.ptrace_addr_data_out_u.mem.data) - 1;
+      data = strlen (plst->name);
+      if (data > maxLen)
+        data = maxLen;
+      out.addr.ptrace_addr_data_out_u.mem.dataNb = data + 1;
+      memcpy (out.addr.ptrace_addr_data_out_u.mem.data, plst->name, data + 1);
+      out.addr.ptrace_addr_data_out_u.mem.data[maxLen] = '\0';
+    }
+    req = 0;
+    break;
 
-    case RPT_CONTTO:
-      if (BreakSetAt (plst, conn_idx, (u_long) addr, BRKT_STEPEMUL) < 0)
-      {
-	DPRINTF(("ptrace_2_svc: BreakSet failed at %x", addr));
-	break;
-      }
-      req = RPT_CONT;
-      /* data can contain a signal number, addr2 is unused */
-      goto case_RPT_CONT;
-
-    case RPT_STEPRANGE:
-      /* convert to step */
-      if (!data)
-        data = 1;		/* should we give an error?? */
-      BreakStepRange (plst, addr, data);
-      if (getErrno()) break;
-
-      req = RPT_SINGLESTEP;	/* do by stepping */
-      addr = (void*) 1;		/* start from current PC */
-      data = -2;		/* want non-atomic stepping */
-      /* fall through to other exec cases */
-
-    case RPT_CONT:
-    case_RPT_CONT:
-    case RPT_SINGLESTEP:
-
-      if (BreakStepOff (plst, &addr2))
-      {				/* need clear then step off break */
-	    /* clear break, step, then do exec */
-	if (addr == (void*) 1)
-	  addr = (void*) plst->regs.REG_PC;/* need for patch */
-
-	  /* data is always 0, so atomic single-step */
-      } else if (req == RPT_SINGLESTEP) {
-	data = -2;		/* want non-atomic stepping */
-      }
+  case RPT_CONTTO:
+    if (BreakSetAt (plst, conn_idx, (u_long) addr, BRKT_STEPEMUL) < 0) {
+      DPRINTF (("ptrace_2_svc: BreakSet failed at %x", addr));
       break;
-
-    /* now ones where addr points to an output area */
-    case RPT_PGETTHREADREGS:
-      addr = (void*) out.addr.ptrace_addr_data_out_u.mem.data;
-      if (sizeof out.addr.ptrace_addr_data_out_u.mem.data <
-	    REG_COUNT * sizeof(int)) {
-	setErrno(EINVAL);
-	break;
-      }
-      if (data == plst->thread) {
-	out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
-	out.addr.ptrace_addr_data_out_u.pregs.pregs_val = (u_int*) &plst->regs;
-	req = 0;			/* force exit */
-	break;
-      }
-      req = RPT_GETTHREADREGS;
+    }
+    req = RPT_CONT;
+    /*
+     * data can contain a signal number, addr2 is unused 
+     */
+    goto case_RPT_CONT;
+
+  case RPT_STEPRANGE:
+    /*
+     * convert to step 
+     */
+    if (!data)
+      data = 1;                 /* should we give an error?? */
+    BreakStepRange (plst, addr, data);
+    if (getErrno ())
       break;
 
-    case RPT_GETTHREADREGS:
-      addr = (void*) &out.addr.ptrace_addr_data_out_u.regs;
-      break;
-    case RPT_GETTHREADNAME:
-      out.addr.ptrace_addr_data_out_u.name = local_buff.t_name;
-      addr = (void*) out.addr.ptrace_addr_data_out_u.name;
+    req = RPT_SINGLESTEP;       /* do by stepping */
+    addr = (void *) 1;          /* start from current PC */
+    data = -2;                  /* want non-atomic stepping */
+    /*
+     * fall through to other exec cases 
+     */
+
+  case RPT_CONT:
+  case_RPT_CONT:
+  case RPT_SINGLESTEP:
+
+    if (BreakStepOff (plst, &addr2)) {  /* need clear then step off break */
+      /*
+       * clear break, step, then do exec 
+       */
+      if (addr == (void *) 1)
+        addr = (void *) plst->regs.REG_PC;  /* need for patch */
+
+      /*
+       * data is always 0, so atomic single-step 
+       */
+    } else if (req == RPT_SINGLESTEP) {
+      data = -2;                /* want non-atomic stepping */
+    }
+    break;
+
+    /*
+     * now ones where addr points to an output area 
+     */
+  case RPT_PGETTHREADREGS:
+    addr = (void *) out.addr.ptrace_addr_data_out_u.mem.data;
+    if (sizeof(out.addr.ptrace_addr_data_out_u.mem.data) < REG_COUNT * sizeof (int)) {
+      setErrno (EINVAL);
       break;
-    case RPT_THREADLIST:
-      out.addr.ptrace_addr_data_out_u.threads.threads =(ptThreadList) local_buff.t_list;
-      addr = (void*) out.addr.ptrace_addr_data_out_u.threads.threads;
+    }
+    if (data == plst->thread) {
+      out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
+      out.addr.ptrace_addr_data_out_u.pregs.pregs_val =
+        (u_int *) & plst->regs;
+      req = 0;                  /* force exit */
       break;
-    case RPT_READTEXT:
-    case RPT_READDATA:
-      if ((int) data < 0) {
-	setErrno(EINVAL);
-	break;
-      }
-      addr = (void *)in->addr.ptrace_addr_data_in_u.address;
-      addr2 = (void *)out.addr.ptrace_addr_data_out_u.mem.data;
-      out.addr.ptrace_addr_data_out_u.mem.dataNb = data;
+    }
+    req = RPT_GETTHREADREGS;
+    break;
+
+  case RPT_GETTHREADREGS:
+    addr = (void *) &out.addr.ptrace_addr_data_out_u.regs;
+    break;
+  case RPT_GETTHREADNAME:
+    out.addr.ptrace_addr_data_out_u.name = local_buff.t_name;
+    addr = (void *) out.addr.ptrace_addr_data_out_u.name;
+    break;
+  case RPT_THREADLIST:
+    out.addr.ptrace_addr_data_out_u.threads.threads =
+      (ptThreadList) local_buff.t_list;
+    addr = (void *) out.addr.ptrace_addr_data_out_u.threads.threads;
+    break;
+  case RPT_READTEXT:
+  case RPT_READDATA:
+    if ((int) data < 0) {
+      setErrno (EINVAL);
       break;
-    case RPT_DETACH:
-      /* Do not allow detaching if breakpoints still there */
-      if (BreakGet (plst, 0, NULL))
-      {				/* some bkpts still set */
-	setErrno(EINVAL);		/* cannot detach safely */
-	break;
-      }
-      /* fall through */
-    case RPT_KILL:
-      /* in the event they are trying to detach or kill a terminated process,
-	 we just delete the entry.					*/
-      if (PROC_TERMINATED (plst))
-      { 
-	TgtDelete(plst, -1, BMSG_KILLED);	/* just blow off */
-	req = 0;		/* now exit */
-      }
+    }
+    addr = (void *) in->addr.ptrace_addr_data_in_u.address;
+    addr2 = (void *) out.addr.ptrace_addr_data_out_u.mem.data;
+    out.addr.ptrace_addr_data_out_u.mem.dataNb = data;
+    break;
+  case RPT_DETACH:
+    /*
+     * Do not allow detaching if breakpoints still there 
+     */
+    if (BreakGet (plst, 0, NULL)) { /* some bkpts still set */
+      setErrno (EINVAL);        /* cannot detach safely */
       break;
+    }
+    /*
+     * fall through 
+     */
+  case RPT_KILL:
+    /*
+     * in the event they are trying to detach or kill a terminated process,
+     * we just delete the entry.                  
+     */
+    if (PROC_TERMINATED (plst)) {
+      TgtDelete (plst, -1, BMSG_KILLED);    /* just blow off */
+      req = 0;                  /* now exit */
+    }
+    break;
   }
 
-  if (getErrno())
-  {				/* failed in code above */
+  if (getErrno ()) {            /* failed in code above */
     out.result = -1;
-    out.errNo = getErrno();
-    DPRINTF(("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
-    return(&out);
-  }
-  else if (!req)
-  {				/* bail out now */
-    DPRINTF(("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
-    return(&out); 
+    out.errNo = getErrno ();
+    DPRINTF (("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
+    return (&out);
+  } else if (!req) {            /* bail out now */
+    DPRINTF (("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
+    return (&out);
   }
 
-  /* OK, make the call */
-  out.result = TgtPtrace(req, pid, addr, data, addr2);
-  out.errNo = getErrno();
-
-  /* if no error, cleanup afterwards */
-  if (getErrno())
-  {
-      /* Remove step-emul breakpoints if any */
+  /*
+   * OK, make the call 
+   */
+  out.result = TgtPtrace (req, pid, addr, data, addr2);
+  out.errNo = getErrno ();
+
+  /*
+   * if no error, cleanup afterwards 
+   */
+  if (getErrno ()) {
+    /*
+     * Remove step-emul breakpoints if any 
+     */
     if (req == RPT_SINGLESTEP || req == RPT_CONT) {
       BreakClear (plst, -1, -1);
     }
-    DPRINTF(("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
-    return(&out);		/* return error */
+    DPRINTF (("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
+    return (&out);              /* return error */
   }
 
-  switch (in->addr.req)
-  {				/* handle some special calls that affect state */
-    case RPT_CONT:
-    case RPT_STEPRANGE:
-      /* change to running */
-      if (in->addr.req == RPT_STEPRANGE)
-	plst->last_start = LAST_RANGE; /* so range steps */
-      else if (addr2)
-	plst->last_start = LAST_STEPOFF; /* now continue after wait */
-      else
-          plst->last_start = LAST_CONT;
-      plst->running = 1; 	/* mark as running */
-      if (!rqstp) /* Called internally to restart bkpt, no msg to anybody */
-	break;
-      TgtNotifyAll(pid_idx, BMSG_WAIT, 0, 0, (in->flags & PTRFLG_NON_OWNER)
-			? -1 : conn_idx, True);
-      break;
-    case RPT_SINGLESTEP:
-      /* mark as step */
-      plst->last_start = LAST_STEP; /* so we know how started */
-      plst->running = 1; 	/* mark as running (wait should catch fast) */
-      break;
-    case RPT_DETACH: 		/* mark as disconnected */
-    case RPT_KILL:		/* mark as killed */
-      if (in->flags & PTRFLG_FREE) /* notify and delete entry */
-        TgtDelete(plst, -1, (in->addr.req==RPT_KILL) ? BMSG_KILLED : BMSG_DETACH);
-      else
-      {				/* notify and mark */
-	plst->last_start = (in->addr.req==RPT_KILL) ? 
-		LAST_KILLED : LAST_DETACHED;
-	plst->state = -1;
-	plst->running = False;
-	TgtNotifyAll(pid_idx, (in->addr.req==RPT_KILL) ? 
-		BMSG_KILLED : BMSG_DETACH, 0, 0, -1, True);
-      }
+  switch (in->addr.req) {       /* handle some special calls that affect state */
+  case RPT_CONT:
+  case RPT_STEPRANGE:
+    /*
+     * change to running 
+     */
+    if (in->addr.req == RPT_STEPRANGE)
+      plst->last_start = LAST_RANGE;    /* so range steps */
+    else if (addr2)
+      plst->last_start = LAST_STEPOFF;  /* now continue after wait */
+    else
+      plst->last_start = LAST_CONT;
+    plst->running = 1;          /* mark as running */
+    if (!rqstp)                 /* Called internally to restart bkpt, no msg to anybody */
       break;
-    case RPT_SETTHREADREGS:
-    case RPT_PSETTHREADREGS:
-	if (data != plst->thread)
-	  break;
-	DPRINTF(("ptrace_2_svc: pid %d target thread regs changed!\n", pid));
-
-    case RPT_SETREGS:
-    case RPT_PSETREGS:
-      /* change our buffer as well */
-      if (plst->regs.REG_PC != ((xdr_regs*)addr)->REG_PC)
-	BreakPcChanged (plst);
-      plst->regs = *(xdr_regs*) addr; /* copy in */
-      break;
-
-    /* case RPT_PGETREGS has been handled locally above */
-    case RPT_PGETTHREADREGS:
-	/* We need to update pointer so that XDR works on return */
-      out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
-      out.addr.ptrace_addr_data_out_u.pregs.pregs_val =
-	  (void*) out.addr.ptrace_addr_data_out_u.mem.data;
-      break;
-
-    case RPT_PEEKTEXT:
-    case RPT_PEEKDATA:
-    case RPT_READDATA:
-    case RPT_READTEXT:
-      if (req < RPT_READDATA)
-      {				/* peek */
-	/* addr is start */
-	data = sizeof(int);
-	addr2 = &out.result;	/* data buffer */
-	/* Like read: addr is start, data is length, addr2 is buffer */
-      }
-      BreakHide (plst, addr, data, addr2);
-      break;
-
-    case RPT_SETTARGETTHREAD:
-      DPRINTF(("ptrace_2_svc: pid %d new target thread %d\n", pid, data));
-      TgtPtrace (RPT_GETREGS, pid, (char*) &plst->regs, 0, NULL);
-      plst->thread = data;
-      if (plst->break_list) {	/* Forget we had to step off breakpoint */
-	BASE_BREAK* base = (BASE_BREAK*) plst->break_list;
-	DPRINTF(("ptrace_2_svc: clr_step %d last_break %d\n", base->clr_step,
-		base->last_break));
-	base->clr_step = 0;	/* Not stopped on break */
-	base->last_break = 0;
-      }
+    TgtNotifyAll (pid_idx, BMSG_WAIT, 0, 0, (in->flags & PTRFLG_NON_OWNER)
+                  ? -1 : conn_idx, True);
+    break;
+  case RPT_SINGLESTEP:
+    /*
+     * mark as step 
+     */
+    plst->last_start = LAST_STEP;   /* so we know how started */
+    plst->running = 1;          /* mark as running (wait should catch fast) */
+    break;
+  case RPT_DETACH:             /* mark as disconnected */
+  case RPT_KILL:               /* mark as killed */
+    if (in->flags & PTRFLG_FREE)    /* notify and delete entry */
+      TgtDelete (plst, -1,
+                 (in->addr.req == RPT_KILL) ? BMSG_KILLED : BMSG_DETACH);
+    else {                      /* notify and mark */
+      plst->last_start = (in->addr.req == RPT_KILL) ?
+        LAST_KILLED : LAST_DETACHED;
+      plst->state = -1;
+      plst->running = False;
+      TgtNotifyAll (pid_idx, (in->addr.req == RPT_KILL) ?
+                    BMSG_KILLED : BMSG_DETACH, 0, 0, -1, True);
+    }
+    break;
+  case RPT_SETTHREADREGS:
+  case RPT_PSETTHREADREGS:
+    if (data != plst->thread)
       break;
+    DPRINTF (("ptrace_2_svc: pid %d target thread regs changed!\n", pid));
+
+  case RPT_SETREGS:
+  case RPT_PSETREGS:
+    /*
+     * change our buffer as well 
+     */
+    if (plst->regs.REG_PC != ((xdr_regs *) addr)->REG_PC)
+      BreakPcChanged (plst);
+    plst->regs = *(xdr_regs *) addr;    /* copy in */
+    break;
+
+    /*
+     * case RPT_PGETREGS has been handled locally above 
+     */
+  case RPT_PGETTHREADREGS:
+    /*
+     * We need to update pointer so that XDR works on return 
+     */
+    out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
+    out.addr.ptrace_addr_data_out_u.pregs.pregs_val =
+      (void *) out.addr.ptrace_addr_data_out_u.mem.data;
+    break;
+
+  case RPT_PEEKTEXT:
+  case RPT_PEEKDATA:
+  case RPT_READDATA:
+  case RPT_READTEXT:
+    if (req < RPT_READDATA) {   /* peek */
+      /*
+       * addr is start 
+       */
+      data = sizeof (int);
+      addr2 = &out.result;      /* data buffer */
+      /*
+       * Like read: addr is start, data is length, addr2 is buffer 
+       */
+    }
+    BreakHide (plst, addr, data, addr2);
+    break;
+
+  case RPT_SETTARGETTHREAD:
+    DPRINTF (("ptrace_2_svc: pid %d new target thread %d\n", pid, data));
+    TgtPtrace (RPT_GETREGS, pid, (char *) &plst->regs, 0, NULL);
+    plst->thread = data;
+    if (plst->break_list) {     /* Forget we had to step off breakpoint */
+      BASE_BREAK *base = (BASE_BREAK *) plst->break_list;
+      DPRINTF (("ptrace_2_svc: clr_step %d last_break %d\n", base->clr_step,
+                base->last_break));
+      base->clr_step = 0;       /* Not stopped on break */
+      base->last_break = 0;
+    }
+    break;
 
-    case RPT_THREADLIST:
-      out.addr.ptrace_addr_data_out_u.threads.nbThread = out.result;      
-      break;
+  case RPT_THREADLIST:
+    out.addr.ptrace_addr_data_out_u.threads.nbThread = out.result;
+    break;
 
-    default:
-      break;
-  }				/* end switch */
-  DPRINTF(("ptrace_2_svc 2: result %d errNo %d\n", out.result, out.errNo));
-  return(&out);
+  default:
+    break;
+  }                             /* end switch */
+  DPRINTF (("ptrace_2_svc 2: result %d errNo %d\n", out.result, out.errNo));
+  return (&out);
 }
 
 /* -----------------------------------------------------------------------
    wait_info_2_svc - non-blocking wait request to check status.
    ----------------------------------------------------------------------- */
 
-wait_out *RPCGENSRVNAME(wait_info_2_svc) (in, rqstp)
-     wait_in *in;
-     struct svc_req *rqstp;	/* server info */
+  wait_out *
+RPCGENSRVNAME (wait_info_2_svc) (wait_in * in, struct svc_req *rqstp)
 {
-  int		conn_idx = TspConnGetIndex(rqstp);
-  static wait_out out;		/* output of pid and status */
-  int		idx;
-  PID_LIST	*plst;
+  int conn_idx = TspConnGetIndex (rqstp);
+  static wait_out out;          /* output of pid and status */
+  int idx;
+  PID_LIST *plst;
 
-  memset(&out, 0, sizeof(out));	/* zero for safety */
-  out.reason = STOP_ERROR;	/* assume the worst */
+  memset (&out, 0, sizeof (out));   /* zero for safety */
+  out.reason = STOP_ERROR;      /* assume the worst */
 
-  if (conn_idx == -1)
-  {				/* no connection, error */
-    DPRINTF(("wait_info_2_svc: msg from unknown debugger!\n"));
+  if (conn_idx == -1) {         /* no connection, error */
+    DPRINTF (("wait_info_2_svc: msg from unknown debugger!\n"));
     out.wait_return = -1;
-    out.errNo = ECHILD;		/* closest error */
-    return(&out);
-  }
-  else
-  {				/* see if confirming message received */
+    out.errNo = ECHILD;         /* closest error */
+    return (&out);
+  } else {                      /* see if confirming message received */
     if (conn_list[conn_idx].retry)
-      TspMessageReceive(conn_idx, in->pid);
+      TspMessageReceive (conn_idx, in->pid);
   }
 
-  if (!in->pid)
-  {				/* warm test verify only */
-    /* this call (pid==0) is made to confirm that that connection is still
-	active.		*/
-    /* we let it fall through as an error since any use other than connection
-	reset would be an error (there is no pid0).			*/
-  }
-  else
-  {				/* normal request */
+  if (!in->pid) {               /* warm test verify only */
+    /*
+     * this call (pid==0) is made to confirm that that connection is still
+     * active.      
+     */
+    /*
+     * we let it fall through as an error since any use other than connection
+     * reset would be an error (there is no pid0).          
+     */
+  } else {                      /* normal request */
     idx = FindPidEntry (in->pid);
-    if (idx >= 0)
-    {				/* found process they requested on */
+    if (idx >= 0) {             /* found process they requested on */
       plst = &pid_list[idx];
       out.wait_return = plst->running ? 0 : in->pid;
-      /* return: 0 is running, pid is stopped/term */
+      /*
+       * return: 0 is running, pid is stopped/term 
+       */
       out.errNo = 0;
       out.status = plst->state; /* last stopped reason if stopped */
-      out.thread = plst->thread;/* current thread (or -1 if none) from stop */
+      out.thread = plst->thread;    /* current thread (or -1 if none) from stop */
       if (!out.wait_return)
-	out.reason = STOP_NONE;	/* running, no action */
-      else if (STS_SIGNALLED (out.status))
-      {			/* stopped on signal */
-	out.handle = STS_GETSIG (out.status); /* signal number */
-	if (out.handle == SIGTRAP)
-	  if (plst->is_step)
-	  {			/* single step with hitting a break */
-	    out.reason = STOP_STEP;
-	    out.handle = 0;	/* no information */
-	  }
-	  else
-	  {			/* stopped on break */
-	    out.reason = STOP_BREAK; 
-	    if (plst->break_list) 
-	      out.handle = ((BASE_BREAK*)plst->break_list)->last_break;
-	    else
-	      out.handle = 0;	/* no break */
-	  }
-	else
-	  out.reason = STOP_SIGNAL;
-	out.PC = plst->regs.REG_PC; /* copy standard regs */
-	out.SP = plst->regs.REG_SP;
-	out.FP = plst->regs.REG_FP;
-      } 
-      else
-      {				/* terminated, so lower use count */
-	if (plst->last_start == LAST_KILLED)
-	  out.reason = STOP_KILLED;
-	else if (plst->last_start == LAST_DETACHED)
-	  out.reason = STOP_DETACHED;
-	else if (plst->last_start == LAST_START)
-	{			/* failed in exec */
-	  out.reason = STOP_SPAWN_FAILED;
-	  out.handle = STS_GETCODE (out.status); /* errno reason */
-	}
-	else if (STS_TERMONSIG (out.status))
-	{			/* terminated on signal */
-	  out.reason = STOP_TERM_SIG;
-	  /* mask off the core-dumped bit 7 */
-	  out.handle = (int)(unsigned)(u_char) STS_TERMGETSIG (out.status);
-	}
-	else
-	{			/* exit(2)ed */
-	  out.reason = STOP_TERM_EXIT;
-	  out.handle = STS_GETCODE (out.status); /* code */
-	}
+        out.reason = STOP_NONE; /* running, no action */
+      else if (STS_SIGNALLED (out.status)) {    /* stopped on signal */
+        out.handle = STS_GETSIG (out.status);   /* signal number */
+        if (out.handle == SIGTRAP)
+          if (plst->is_step) {  /* single step with hitting a break */
+            out.reason = STOP_STEP;
+            out.handle = 0;     /* no information */
+          } else {              /* stopped on break */
+            out.reason = STOP_BREAK;
+            if (plst->break_list)
+              out.handle = ((BASE_BREAK *) plst->break_list)->last_break;
+            else
+              out.handle = 0;   /* no break */
+        } else
+          out.reason = STOP_SIGNAL;
+        out.PC = plst->regs.REG_PC; /* copy standard regs */
+        out.SP = plst->regs.REG_SP;
+        out.FP = plst->regs.REG_FP;
+      } else {                  /* terminated, so lower use count */
+        if (plst->last_start == LAST_KILLED)
+          out.reason = STOP_KILLED;
+        else if (plst->last_start == LAST_DETACHED)
+          out.reason = STOP_DETACHED;
+        else if (plst->last_start == LAST_START) {  /* failed in exec */
+          out.reason = STOP_SPAWN_FAILED;
+          out.handle = STS_GETCODE (out.status);    /* errno reason */
+        } else if (STS_TERMONSIG (out.status)) {    /* terminated on signal */
+          out.reason = STOP_TERM_SIG;
+          /*
+           * mask off the core-dumped bit 7 
+           */
+          out.handle = (int) (unsigned) (u_char) STS_TERMGETSIG (out.status);
+        } else {                /* exit(2)ed */
+          out.reason = STOP_TERM_EXIT;
+          out.handle = STS_GETCODE (out.status);    /* code */
+        }
       }
-      DPRINTF(("wait_info_2_svc: pid %d return %d status %x errNo %d"
-	" reason %d handle %d pc %x sp %x fp %x thread %d\n",
-	in->pid, out.wait_return, out.status, out.errNo, out.reason,
-	out.handle, out.PC, out.SP, out.FP, out.thread));
-      return(&out);
+      DPRINTF (("wait_info_2_svc: pid %d return %d status %x errNo %d"
+                " reason %d handle %d pc %x sp %x fp %x thread %d\n",
+                in->pid, out.wait_return, out.status, out.errNo, out.reason,
+                out.handle, out.PC, out.SP, out.FP, out.thread));
+      return (&out);
     }
   }
-  /* if not found in list, we return error: no such process */
+  /*
+   * if not found in list, we return error: no such process 
+   */
   out.wait_return = -1;
-  out.errNo = ESRCH;		/* no process */
+  out.errNo = ESRCH;            /* no process */
   out.status = 0;
-  return(&out);
+  return (&out);
 }
 
 /* -----------------------------------------------------------------------
@@ -700,23 +750,22 @@ wait_out *RPCGENSRVNAME(wait_info_2_svc) (in, rqstp)
    ----------------------------------------------------------------------- */
 
 static one_signal SignalNames[] = {
-    {SIGILL,	"SIGILL/EVT_ILL"},
-    {SIGTRAP,	"SIGTRAP/EVT_BKPT"},	
-    {SIGFPE,	"SIGFPE/EVT_FPE"},
-    {SIGKILL,	"SIGKILL/EVT_AKILL"},
-    {SIGSEGV,	"SIGSEGV/EVT_SEGV"},
-    {17,	"SIGSTOP"},		
-    {23,	"SIGSTOP"}		
+  {SIGILL, "SIGILL/EVT_ILL"},
+  {SIGTRAP, "SIGTRAP/EVT_BKPT"},
+  {SIGFPE, "SIGFPE/EVT_FPE"},
+  {SIGKILL, "SIGKILL/EVT_AKILL"},
+  {SIGSEGV, "SIGSEGV/EVT_SEGV"},
+  {17, "SIGSTOP"},
+  {23, "SIGSTOP"}
 };
 
-get_signal_names_out* RPCGENSRVNAME(get_signal_names_2_svc) (in, rqstp)
-     void* in;
-     struct svc_req *rqstp;	/* server info */
+  get_signal_names_out *
+RPCGENSRVNAME (get_signal_names_2_svc) (void * in, struct svc_req * rqstp)
 {
   static get_signal_names_out out;
 
-  out.signals.all_signals_len = sizeof SignalNames / sizeof SignalNames[0];
+  out.signals.all_signals_len = sizeof (SignalNames) / sizeof (SignalNames[0]);
   out.signals.all_signals_val = SignalNames;
 
-  return(&out);
+  return (&out);
 }