This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

[PATCH] factor out some functions in remote.c


Checked in, after changes based on Andrew's input.
2001-05-10  Michael Snyder  <msnyder@redhat.com>

	* remote.c (bin2hex, hex2bin): New functions.  Factor out these
	two conversions which are coded for repeatedly in this module.
	(remote_threads_extra_info, remote_wait, remote_async_wait, 
	store_register_using_P, remote_store_registers, remote_write_bytes,
	remote_read_bytes, remote_rcmd): Use bin2hex and hex2bin instead
	of coding the conversions inline.
	(fromhex): Not exported, change from extern to static.

Index: remote.c
===================================================================
RCS file: /cvs/src/src/gdb/remote.c,v
retrieving revision 1.47
diff -c -3 -p -r1.47 remote.c
*** remote.c	2001/05/04 04:15:27	1.47
--- remote.c	2001/05/10 18:49:00
*************** static void remote_find_new_threads (voi
*** 186,194 ****
  
  static void record_currthread (int currthread);
  
! /* exported functions */
  
! extern int fromhex (int a);
  
  static int putpkt_binary (char *buf, int cnt);
  
--- 186,194 ----
  
  static void record_currthread (int currthread);
  
! static int fromhex (int a);
  
! static int hex2bin (const char *hex, char *bin, int);
  
  static int putpkt_binary (char *buf, int cnt);
  
*************** remote_threads_extra_info (struct thread
*** 1735,1751 ****
        getpkt (bufp, PBUFSIZ, 0);
        if (bufp[0] != 0)
  	{
! 	  char *p;
! 
! 	  for (p = display_buf; 
! 	       p < display_buf + sizeof(display_buf) - 1 &&
! 		 bufp[0] != 0 &&
! 		 bufp[1] != 0;
! 	       p++, bufp+=2)
! 	    {
! 	      *p = fromhex (bufp[0]) * 16 + fromhex (bufp[1]);
! 	    }
! 	  *p = 0;
  	  return display_buf;
  	}
      }
--- 1735,1743 ----
        getpkt (bufp, PBUFSIZ, 0);
        if (bufp[0] != 0)
  	{
! 	  n = min (strlen (bufp) / 2, sizeof (display_buf));
! 	  result = hex2bin (bufp, display_buf, n);
! 	  display_buf [result] = '\0';
  	  return display_buf;
  	}
      }
*************** remote_async_detach (char *args, int fro
*** 2322,2328 ****
  
  /* Convert hex digit A to a number.  */
  
! int
  fromhex (int a)
  {
    if (a >= '0' && a <= '9')
--- 2314,2320 ----
  
  /* Convert hex digit A to a number.  */
  
! static int
  fromhex (int a)
  {
    if (a >= '0' && a <= '9')
*************** fromhex (int a)
*** 2335,2340 ****
--- 2327,2355 ----
      error ("Reply contains invalid hex digit %d", a);
  }
  
+ static int
+ hex2bin (const char *hex, char *bin, int count)
+ {
+   int i;
+ 
+   /* May use a length, or a nul-terminated string as input. */
+   if (count == 0)
+     count = strlen (hex) / 2;
+ 
+   for (i = 0; i < count; i++)
+     {
+       if (hex[0] == 0 || hex[1] == 0)
+ 	{
+ 	  /* Hex string is short, or of uneven length.
+ 	     Return the count that has been converted so far. */
+ 	  return i;
+ 	}
+       *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
+       hex += 2;
+     }
+   return i;
+ }
+ 
  /* Convert number NIB to a hex digit.  */
  
  static int
*************** tohex (int nib)
*** 2345,2350 ****
--- 2360,2382 ----
    else
      return 'a' + nib - 10;
  }
+ 
+ static int
+ bin2hex (char *bin, char *hex, int count)
+ {
+   int i;
+   /* May use a length, or a nul-terminated string as input. */
+   if (count == 0)
+     count = strlen (bin);
+ 
+   for (i = 0; i < count; i++)
+     {
+       *hex++ = tohex ((*bin >> 4) & 0xf);
+       *hex++ = tohex (*bin++ & 0xf);
+     }
+   *hex = 0;
+   return i;
+ }
  
  /* Tell the remote machine to resume.  */
  
*************** Packet: '%s'\n",
*** 2830,2842 ****
  Packet: '%s'\n",
  			       regno, p, buf);
  
! 		    for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
! 		      {
! 			if (p[0] == 0 || p[1] == 0)
! 			  warning ("Remote reply is too short: %s", buf);
! 			regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
! 			p += 2;
! 		      }
  		    supply_register (regno, regs);
  		  }
  
--- 2862,2870 ----
  Packet: '%s'\n",
  			       regno, p, buf);
  
! 		    if (hex2bin (p, regs, REGISTER_RAW_SIZE (regno))
! 			< REGISTER_RAW_SIZE (regno))
! 		      warning ("Remote reply is too short: %s", buf);
  		    supply_register (regno, regs);
  		  }
  
*************** Packet: '%s'\n",
*** 3051,3063 ****
  Packet: '%s'\n",
  			       regno, p, buf);
  
! 		    for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
! 		      {
! 			if (p[0] == 0 || p[1] == 0)
! 			  warning ("Remote reply is too short: %s", buf);
! 			regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
! 			p += 2;
! 		      }
  		    supply_register (regno, regs);
  		  }
  
--- 3079,3087 ----
  Packet: '%s'\n",
  			       regno, p, buf);
  
! 		    if (hex2bin (p, regs, REGISTER_RAW_SIZE (regno)) 
! 			< REGISTER_RAW_SIZE (regno))
! 		      warning ("Remote reply is too short: %s", buf);
  		    supply_register (regno, regs);
  		  }
  
*************** store_register_using_P (int regno)
*** 3307,3318 ****
    sprintf (buf, "P%x=", regno);
    p = buf + strlen (buf);
    regp = register_buffer (regno);
!   for (i = 0; i < REGISTER_RAW_SIZE (regno); ++i)
!     {
!       *p++ = tohex ((regp[i] >> 4) & 0xf);
!       *p++ = tohex (regp[i] & 0xf);
!     }
!   *p = '\0';
    remote_send (buf, PBUFSIZ);
  
    return buf[0] != '\0';
--- 3331,3337 ----
    sprintf (buf, "P%x=", regno);
    p = buf + strlen (buf);
    regp = register_buffer (regno);
!   bin2hex (regp, p, REGISTER_RAW_SIZE (regno));
    remote_send (buf, PBUFSIZ);
  
    return buf[0] != '\0';
*************** remote_store_registers (int regno)
*** 3369,3381 ****
    regs = register_buffer (-1);
    p = buf + 1;
    /* remote_prepare_to_store insures that register_bytes_found gets set.  */
!   for (i = 0; i < register_bytes_found; i++)
!     {
!       *p++ = tohex ((regs[i] >> 4) & 0xf);
!       *p++ = tohex (regs[i] & 0xf);
!     }
!   *p = '\0';
! 
    remote_send (buf, PBUFSIZ);
  }
  
--- 3388,3394 ----
    regs = register_buffer (-1);
    p = buf + 1;
    /* remote_prepare_to_store insures that register_bytes_found gets set.  */
!   bin2hex (regs, p, register_bytes_found);
    remote_send (buf, PBUFSIZ);
  }
  
*************** remote_write_bytes (CORE_ADDR memaddr, c
*** 3602,3613 ****
        /* Normal mode: Send target system values byte by byte, in
  	 increasing byte addresses.  Each byte is encoded as a two hex
  	 value.  */
!       for (nr_bytes = 0; nr_bytes < todo; nr_bytes++)
! 	{
! 	  *p++ = tohex ((myaddr[nr_bytes] >> 4) & 0xf);
! 	  *p++ = tohex (myaddr[nr_bytes] & 0xf);
! 	}
!       *p = '\0';
        break;
      case PACKET_SUPPORT_UNKNOWN:
        internal_error (__FILE__, __LINE__,
--- 3615,3621 ----
        /* Normal mode: Send target system values byte by byte, in
  	 increasing byte addresses.  Each byte is encoded as a two hex
  	 value.  */
!       bin2hex (myaddr, p, todo);
        break;
      case PACKET_SUPPORT_UNKNOWN:
        internal_error (__FILE__, __LINE__,
*************** remote_read_bytes (CORE_ADDR memaddr, ch
*** 3698,3711 ****
           each byte encoded as two hex characters.  */
  
        p = buf;
!       for (i = 0; i < todo; i++)
  	{
! 	  if (p[0] == 0 || p[1] == 0)
! 	    /* Reply is short.  This means that we were able to read
! 	       only part of what we wanted to.  */
! 	    return i + (origlen - len);
! 	  myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
! 	  p += 2;
  	}
        myaddr += todo;
        memaddr += todo;
--- 3706,3716 ----
           each byte encoded as two hex characters.  */
  
        p = buf;
!       if ((i = hex2bin (p, myaddr, todo)) < todo)
  	{
! 	  /* Reply is short.  This means that we were able to read
! 	     only part of what we wanted to. */
! 	  return i + (origlen - len);
  	}
        myaddr += todo;
        memaddr += todo;
*************** remote_rcmd (char *command,
*** 4905,4916 ****
      error ("\"monitor\" command ``%s'' is too long\n", command);
  
    /* Encode the actual command */
!   for (i = 0; command[i]; i++)
!     {
!       *p++ = tohex ((command[i] >> 4) & 0xf);
!       *p++ = tohex (command[i] & 0xf);
!     }
!   *p = '\0';
  
    if (putpkt (buf) < 0)
      error ("Communication problem with target\n");
--- 4910,4916 ----
      error ("\"monitor\" command ``%s'' is too long\n", command);
  
    /* Encode the actual command */
!   bin2hex (command, p, 0);
  
    if (putpkt (buf) < 0)
      error ("Communication problem with target\n");

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]