#ifndef IN_PROCESS_AGENT
-#if USE_WIN32API
-# define INVALID_DESCRIPTOR INVALID_SOCKET
-#else
-# define INVALID_DESCRIPTOR -1
-#endif
-
/* Extra value for readchar_callback. */
enum {
/* The callback is currently not scheduled. */
static int remote_is_stdio = 0;
-static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR;
-static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
+static int remote_desc = -1;
+static int listen_desc = -1;
#ifdef USE_WIN32API
# define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
int
gdb_connected (void)
{
- return remote_desc != INVALID_DESCRIPTOR;
+ return remote_desc != -1;
}
/* Return true if the remote connection is over stdio. */
#endif
}
-static int
+static void
handle_accept_event (int err, gdb_client_data client_data)
{
struct sockaddr_storage sockaddr;
until GDB as selected all-stop/non-stop, and has queried the
threads' status ('?'). */
target_async (0);
-
- return 0;
}
/* Prepare for a later connection to a remote debugger.
if (! remote_connection_is_stdio ())
close (remote_desc);
#endif
- remote_desc = INVALID_DESCRIPTOR;
+ remote_desc = -1;
reset_readchar ();
}
/* Check for an input interrupt while we're here. */
if (cc == '\003' && current_thread != NULL)
- the_target->pt->request_interrupt ();
+ the_target->request_interrupt ();
}
while (cc != '+');
return;
}
- the_target->pt->request_interrupt ();
+ the_target->request_interrupt ();
}
}
/* This function may be called before establishing communications,
therefore we need to validate the remote descriptor. */
- if (remote_desc == INVALID_DESCRIPTOR)
+ if (remote_desc == -1)
return;
input_interrupt (0);
readchar_bufcnt = 0;
if (readchar_callback != NOT_SCHEDULED)
{
- delete_callback_event (readchar_callback);
+ delete_timer (readchar_callback);
readchar_callback = NOT_SCHEDULED;
}
}
/* Process remaining data in readchar_buf. */
-static int
+static void
process_remaining (void *context)
{
- int res;
-
/* This is a one-shot event. */
readchar_callback = NOT_SCHEDULED;
if (readchar_bufcnt > 0)
- res = handle_serial_event (0, NULL);
- else
- res = 0;
-
- return res;
+ handle_serial_event (0, NULL);
}
/* If there is still data in the buffer, queue another event to process it,
reschedule (void)
{
if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED)
- readchar_callback = append_callback_event (process_remaining, NULL);
+ readchar_callback = create_timer (0, process_remaining, NULL);
}
/* Read a packet from the remote machine, with error checking,
check for an input interrupt. */
if (c == '\003')
{
- the_target->pt->request_interrupt ();
+ the_target->request_interrupt ();
continue;
}
{
/* Consume the interrupt character in the buffer. */
readchar ();
- the_target->pt->request_interrupt ();
+ the_target->request_interrupt ();
}
return bp - buf;
else
sprintf (buf, "T%02x", status->value.sig);
+ if (disable_packet_T)
+ {
+ /* This is a bit (OK, a lot) of a kludge, however, this isn't
+ really a user feature, but exists only so GDB can use the
+ gdbserver to test handling of the 'S' stop reply packet, so
+ we would rather this code be as simple as possible.
+
+ By this point we've started to build the 'T' stop packet,
+ and it should look like 'Txx....' where 'x' is a hex digit.
+ An 'S' stop packet always looks like 'Sxx', so all we do
+ here is convert the buffer from a T packet to an S packet
+ and the avoid adding any extra content by breaking out. */
+ gdb_assert (*buf == 'T');
+ gdb_assert (isxdigit (*(buf + 1)));
+ gdb_assert (isxdigit (*(buf + 2)));
+ *buf = 'S';
+ *(buf + 3) = '\0';
+ break;
+ }
+
buf += strlen (buf);
saved_thread = current_thread;
regcache = get_thread_regcache (current_thread, 1);
- if (the_target->stopped_by_watchpoint != NULL
- && (*the_target->stopped_by_watchpoint) ())
+ if (the_target->stopped_by_watchpoint ())
{
CORE_ADDR addr;
int i;
memcpy (buf, "watch:", 6);
buf += 6;
- addr = (*the_target->stopped_data_address) ();
+ addr = the_target->stopped_data_address ();
/* Convert each byte of the address into two hexadecimal
chars. Note that we take sizeof (void *) instead of