(DEPRECATED_SERIAL_FD): Delete.
(SERIAL_DEBUG): Delete.
(SERIAL_DEBUG_P): Delete.
(SERIAL_DRAIN_OUTPUT): Delete.
(SERIAL_FLUSH_OUTPUT): Delete.
(SERIAL_FLUSH_INPUT): Delete.
(SERIAL_SEND_BREAK): Delete.
(SERIAL_RAW): Delete.
(SERIAL_GET_TTY_STATE): Delete.
(SERIAL_SET_TTY_STATE): Delete.
(SERIAL_PRINT_TTY_STATE): Delete.
(SERIAL_NOFLUSH_SET_TTY_STATE): Delete.
(SERIAL_SETBAUDRATE): Delete.
(SERIAL_SETSTOPBITS): Delete.
(SERIAL_CAN_ASYNC_P): Delete.
(SERIAL_IS_ASYNC_P): Delete.
(SERIAL_UN_FDOPEN): Delete.
(SERIAL_READCHAR): Delete.
(SERIAL_CLOSE): Delete.
(SERIAL_FDOPEN): Delete.
(SERIAL_OPEN): Delete.
2001-07-14 Andrew Cagney <ac131313@redhat.com>
+ * serial.h (SERIAL_ASYNC): Delete.
+ (DEPRECATED_SERIAL_FD): Delete.
+ (SERIAL_DEBUG): Delete.
+ (SERIAL_DEBUG_P): Delete.
+ (SERIAL_DRAIN_OUTPUT): Delete.
+ (SERIAL_FLUSH_OUTPUT): Delete.
+ (SERIAL_FLUSH_INPUT): Delete.
+ (SERIAL_SEND_BREAK): Delete.
+ (SERIAL_RAW): Delete.
+ (SERIAL_GET_TTY_STATE): Delete.
+ (SERIAL_SET_TTY_STATE): Delete.
+ (SERIAL_PRINT_TTY_STATE): Delete.
+ (SERIAL_NOFLUSH_SET_TTY_STATE): Delete.
+ (SERIAL_SETBAUDRATE): Delete.
+ (SERIAL_SETSTOPBITS): Delete.
+ (SERIAL_CAN_ASYNC_P): Delete.
+ (SERIAL_IS_ASYNC_P): Delete.
+ (SERIAL_UN_FDOPEN): Delete.
+ (SERIAL_READCHAR): Delete.
+ (SERIAL_CLOSE): Delete.
+ (SERIAL_FDOPEN): Delete.
+ (SERIAL_OPEN): Delete.
+ * ser-unix.c: Update.
+ * sparclet-rom.c: Update.
+ * remote-bug.c: Update.
+ * dsrec.c: Update.
+ * xmodem.c: Update.
+ * nindy-share/ttyflush.c: Update.
+ * nindy-share/Onindy.c: Update.
+ * utils.c: Update.
+ * serial.c: Update.
+ * remote-nindy.c: Update.
+ * inflow.c: Update.
+ * sparcl-tdep.c: Update.
+ * sh3-rom.c: Update.
+ * remote.c: Update.
+ * remote-utils.c: Update.
+ * remote-st.c: Update.
+ * remote-sds.c: Update.
+ * remote-rdp.c: Update.
+ * remote-os9k.c: Update.
+ * remote-nrom.c: Update.
+ * remote-mips.c: Update.
+ * remote-es.c: Update.
+ * remote-e7000.c: Update.
+ * remote-array.c: Update.
+ * ocd.c: Update.
+ * nindy-share/nindy.c: Update.
+ * monitor.c: Update.
+
+2001-07-14 Andrew Cagney <ac131313@redhat.com>
+
* mn10200-tdep.c: Replace value_ptr with ``struct value *''.
* mcore-tdep.c: Ditto.
* sparc-tdep.c: Ditto.
srec[reclen] = '\0';
puts_debug ("sent -->", srec, "<--");
}
- SERIAL_WRITE (desc, srec, reclen);
+ serial_write (desc, srec, reclen);
for (s = abfd->sections; s; s = s->next)
if (s->flags & SEC_LOAD)
acknowledgement is sent back. */
do
{
- SERIAL_WRITE (desc, srec, reclen);
+ serial_write (desc, srec, reclen);
if (ui_load_progress_hook)
if (ui_load_progress_hook (section_name, (unsigned long) i))
error ("Canceled the download");
puts_debug ("sent -->", srec, "<--");
}
- SERIAL_WRITE (desc, srec, reclen);
+ serial_write (desc, srec, reclen);
/* Some monitors need these to wake up properly. (Which ones? -sts) */
- SERIAL_WRITE (desc, "\r\r", 2);
+ serial_write (desc, "\r\r", 2);
if (remote_debug)
puts_debug ("sent -->", "\r\r", "<---");
- SERIAL_FLUSH_INPUT (desc);
+ serial_flush_input (desc);
report_transfer_performance (data_count, start_time, end_time);
}
case no:
return 0;
case have_not_checked:
- /* Get all the current tty settings (including whether we have a tty at
- all!). Can't do this in _initialize_inflow because SERIAL_FDOPEN
- won't work until the serial_ops_list is initialized. */
+ /* Get all the current tty settings (including whether we have a
+ tty at all!). Can't do this in _initialize_inflow because
+ serial_fdopen() won't work until the serial_ops_list is
+ initialized. */
#ifdef F_GETFL
tflags_ours = fcntl (0, F_GETFL, 0);
#endif
gdb_has_a_terminal_flag = no;
- stdin_serial = SERIAL_FDOPEN (0);
+ stdin_serial = serial_fdopen (0);
if (stdin_serial != NULL)
{
- our_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
+ our_ttystate = serial_get_tty_state (stdin_serial);
if (our_ttystate != NULL)
{
{
if (gdb_has_a_terminal ())
{
- /* We could just as well copy our_ttystate (if we felt like adding
- a new function SERIAL_COPY_TTY_STATE). */
+ /* We could just as well copy our_ttystate (if we felt like
+ adding a new function serial_copy_tty_state()). */
if (inferior_ttystate)
xfree (inferior_ttystate);
- inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
+ inferior_ttystate = serial_get_tty_state (stdin_serial);
#ifdef PROCESS_GROUP_TYPE
inferior_process_group = pgrp;
/* Because we were careful to not change in or out of raw mode in
terminal_ours, we will not change in our out of raw mode with
this call, so we don't flush any input. */
- result = SERIAL_SET_TTY_STATE (stdin_serial, inferior_ttystate);
+ result = serial_set_tty_state (stdin_serial, inferior_ttystate);
OOPSY ("setting tty state");
if (!job_control)
if (inferior_ttystate)
xfree (inferior_ttystate);
- inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
+ inferior_ttystate = serial_get_tty_state (stdin_serial);
#ifdef HAVE_TERMIOS
inferior_process_group = tcgetpgrp (0);
#endif
though, since readline will deal with raw mode when/if it needs to.
*/
- SERIAL_NOFLUSH_SET_TTY_STATE (stdin_serial, our_ttystate,
+ serial_noflush_set_tty_state (stdin_serial, our_ttystate,
inferior_ttystate);
if (job_control)
(int) inferior_process_group);
#endif
- SERIAL_PRINT_TTY_STATE (stdin_serial, inferior_ttystate, gdb_stdout);
+ serial_print_tty_state (stdin_serial, inferior_ttystate, gdb_stdout);
}
\f
/* NEW_TTY_PREFORK is called before forking a new child process,
void
monitor_write (char *buf, int buflen)
{
- if (SERIAL_WRITE (monitor_desc, buf, buflen))
- fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
+ if (serial_write (monitor_desc, buf, buflen))
+ fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
safe_strerror (errno));
}
do
{
looping = 0;
- c = SERIAL_READCHAR (monitor_desc, timeout);
+ c = serial_readchar (monitor_desc, timeout);
if (c >= 0)
c &= 0xff; /* don't lose bit 7 */
do
{
looping = 0;
- c = SERIAL_READCHAR (monitor_desc, timeout);
+ c = serial_readchar (monitor_desc, timeout);
if (c >= 0)
{
xfree (dev_name);
dev_name = xstrdup (args);
- monitor_desc = SERIAL_OPEN (dev_name);
+ monitor_desc = serial_open (dev_name);
if (!monitor_desc)
perror_with_name (dev_name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
+ if (serial_setbaudrate (monitor_desc, baud_rate))
{
- SERIAL_CLOSE (monitor_desc);
+ serial_close (monitor_desc);
perror_with_name (dev_name);
}
}
- SERIAL_RAW (monitor_desc);
+ serial_raw (monitor_desc);
- SERIAL_FLUSH_INPUT (monitor_desc);
+ serial_flush_input (monitor_desc);
/* some systems only work with 2 stop bits */
- SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
+ serial_setstopbits (monitor_desc, mon_ops->stopbits);
current_monitor = mon_ops;
monitor_expect_prompt (NULL, 0);
}
- SERIAL_FLUSH_INPUT (monitor_desc);
+ serial_flush_input (monitor_desc);
/* Alloc breakpoints */
if (mon_ops->set_break != NULL)
monitor_close (int quitting)
{
if (monitor_desc)
- SERIAL_CLOSE (monitor_desc);
+ serial_close (monitor_desc);
/* Free breakpoint memory */
if (breakaddr != NULL)
if (current_monitor->getmem.term_cmd)
{
- SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
+ serial_write (monitor_desc, current_monitor->getmem.term_cmd,
strlen (current_monitor->getmem.term_cmd));
monitor_expect_prompt (NULL, 0);
}
{
monitor_debug ("MON stop\n");
if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
- SERIAL_SEND_BREAK (monitor_desc);
+ serial_send_break (monitor_desc);
if (current_monitor->stop)
monitor_printf_noecho (current_monitor->stop);
}
readchar()
{
/* FIXME: Do we really want to be reading without a timeout? */
- return SERIAL_READCHAR (nindy_serial, -1);
+ return serial_readchar (nindy_serial, -1);
}
/******************************************************************************
fprintf(stderr,
"Bad checksum (recv=0x%02x; calc=0x%02x); retrying\r\n",
recv, csum );
- SERIAL_WRITE (nindy_serial, "-", 1);
+ serial_write (nindy_serial, "-", 1);
}
- SERIAL_WRITE (nindy_serial, "+", 1);
+ serial_write (nindy_serial, "+", 1);
}
resend = 1;
do {
if ( resend ) {
- SERIAL_WRITE ( nindy_serial, "\020", 1 );
- SERIAL_WRITE( nindy_serial, cmd, strlen(cmd) );
- SERIAL_WRITE( nindy_serial, checksum, strlen(checksum) );
+ serial_write ( nindy_serial, "\020", 1 );
+ serial_write( nindy_serial, cmd, strlen(cmd) );
+ serial_write( nindy_serial, checksum, strlen(checksum) );
}
/* FIXME: do we really want to be reading without timeout? */
- ack = SERIAL_READCHAR (nindy_serial, -1);
+ ack = serial_readchar (nindy_serial, -1);
if (ack < 0)
{
fprintf (stderr, "error reading from serial port\n");
escape_seen = 0;
while (n)
{
- c = SERIAL_READCHAR (nindy_serial, timeout);
+ c = serial_readchar (nindy_serial, timeout);
switch (c)
{
case SERIAL_ERROR:
cs_calc += buf[i];
}
if ( cs_calc == cs_recv ){
- SERIAL_WRITE (nindy_serial, "+", 1);
+ serial_write (nindy_serial, "+", 1);
return hdr[2];
}
/* Bad checksum: report, send NAK, and re-receive
*/
fprintf(stderr, errfmt, cs_recv, cs_calc );
- SERIAL_WRITE (nindy_serial, "-", 1);
+ serial_write (nindy_serial, "-", 1);
}
}
/* Attention, NINDY!
*/
- SERIAL_WRITE (nindy_serial, "\020", 1);
+ serial_write (nindy_serial, "\020", 1);
lenlo = len & 0xff;
/* Send checksummed message over and over until we get a positive ack
*/
- SERIAL_WRITE (nindy_serial, buf, p - buf);
+ serial_write (nindy_serial, buf, p - buf);
while (1){
if ( !rdnin(&ack,1,5) ){
/* timed out */
fprintf(stderr,"ACK timed out; resending\r\n");
/* Attention, NINDY! */
- SERIAL_WRITE (nindy_serial, "\020", 1);
- SERIAL_WRITE (nindy_serial, buf, p - buf);
+ serial_write (nindy_serial, "\020", 1);
+ serial_write (nindy_serial, buf, p - buf);
} else if ( ack == '+' ){
return;
} else if ( ack == '-' ){
fprintf( stderr, "Remote NAK; resending\r\n" );
- SERIAL_WRITE (nindy_serial, buf, p - buf);
+ serial_write (nindy_serial, buf, p - buf);
} else {
fprintf( stderr, "Bad ACK, ignored: <%c>\r\n", ack );
}
unsigned char c;
/* Set specified baud rate and flush all pending input */
- SERIAL_SETBAUDRATE (serial, brp->rate);
+ serial_setbaudrate (serial, brp->rate);
tty_flush (serial);
/* Send empty command with bad checksum, hope for NAK ('-') response */
- SERIAL_WRITE (serial, "\020\0\0\001", 4);
+ serial_write (serial, "\020\0\0\001", 4);
/* Anything but a quick '-', including error, eof, or timeout, means that
this baudrate doesn't work. */
- return SERIAL_READCHAR (serial, 1) == '-';
+ return serial_readchar (serial, 1) == '-';
}
/******************************************************************************
ninBaud (brp->string);
/* Change our baud rate back to rate to which we just set NINDY. */
- SERIAL_SETBAUDRATE (serial, brp->rate);
+ serial_setbaudrate (serial, brp->rate);
}
\f
/**********************************
csum += *p;
}
sprintf (msg, "\020z%s#%02x", baudrate, csum);
- SERIAL_WRITE (nindy_serial, msg, strlen (msg));
+ serial_write (nindy_serial, msg, strlen (msg));
}
else
{
p = xmalloc(strlen(prefix[i]) + strlen(name) + 1 );
strcpy( p, prefix[i] );
strcat( p, name );
- nindy_serial = SERIAL_OPEN (p);
+ nindy_serial = serial_open (p);
if (nindy_serial != NULL) {
#ifdef TIOCEXCL
/* Exclusive use mode (hp9000 does not support it) */
ioctl(nindy_serial->fd,TIOCEXCL,NULL);
#endif
- SERIAL_RAW (nindy_serial);
+ serial_raw (nindy_serial);
if (brk)
{
- SERIAL_SEND_BREAK (nindy_serial);
+ serial_send_break (nindy_serial);
}
brp = parse_baudrate( baudrate );
{
while (1)
{
- SERIAL_FLUSH_INPUT (serial);
- SERIAL_FLUSH_OUTPUT (serial);
+ serial_flush_input (serial);
+ serial_flush_output (serial);
sleep(1);
- switch (SERIAL_READCHAR (serial, 0))
+ switch (serial_readchar (serial, 0))
{
case SERIAL_TIMEOUT:
case SERIAL_ERROR:
ocd_close (int quitting)
{
if (ocd_desc)
- SERIAL_CLOSE (ocd_desc);
+ serial_close (ocd_desc);
ocd_desc = NULL;
}
immediate_quit++; /* Allow user to interrupt it */
- SERIAL_SEND_BREAK (ocd_desc); /* Wake up the wiggler */
+ serial_send_break (ocd_desc); /* Wake up the wiggler */
speed = 80; /* Divide clock by 4000 */
if (strncmp (name, "wiggler", 7) == 0)
{
- ocd_desc = SERIAL_OPEN ("ocd");
+ ocd_desc = serial_open ("ocd");
if (!ocd_desc)
perror_with_name (name);
else
/* not using Wigglers.dll */
{
- ocd_desc = SERIAL_OPEN (name);
+ ocd_desc = serial_open (name);
if (!ocd_desc)
perror_with_name (name);
}
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (ocd_desc, baud_rate))
+ if (serial_setbaudrate (ocd_desc, baud_rate))
{
- SERIAL_CLOSE (ocd_desc);
+ serial_close (ocd_desc);
perror_with_name (name);
}
}
- SERIAL_RAW (ocd_desc);
+ serial_raw (ocd_desc);
/* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
- SERIAL_FLUSH_INPUT (ocd_desc);
+ serial_flush_input (ocd_desc);
if (from_tty)
{
{
int ch;
- ch = SERIAL_READCHAR (ocd_desc, timeout);
+ ch = serial_readchar (ocd_desc, timeout);
switch (ch)
{
static void
output_packet (void)
{
- if (SERIAL_WRITE (ocd_desc, pkt, pktp - pkt))
+ if (serial_write (ocd_desc, pkt, pktp - pkt))
perror_with_name ("output_packet: write failed");
reset_packet ();
}
*packet_ptr++ = -checksum;
- if (SERIAL_WRITE (ocd_desc, packet, packet_ptr - packet))
+ if (serial_write (ocd_desc, packet, packet_ptr - packet))
perror_with_name ("output_packet: write failed");
}
#endif
if (strlen (buf) > PBUFSIZ)
error ("printf_monitor(): string too long");
- if (SERIAL_WRITE (array_desc, buf, strlen (buf)))
- fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
+ if (serial_write (array_desc, buf, strlen (buf)))
+ fprintf (stderr, "serial_write failed: %s\n", safe_strerror (errno));
}
/*
* write_monitor -- send raw data to monitor.
static void
write_monitor (char data[], int len)
{
- if (SERIAL_WRITE (array_desc, data, len))
- fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
+ if (serial_write (array_desc, data, len))
+ fprintf (stderr, "serial_write failed: %s\n", safe_strerror (errno));
*(data + len + 1) = '\0';
debuglogs (1, "write_monitor(), Sending: \"%s\".", data);
{
int c;
- c = SERIAL_READCHAR (array_desc, abs (timeout));
+ c = serial_readchar (array_desc, abs (timeout));
if (sr_get_debug () > 5)
{
mips_set_processor_type_command ("lsi33k", 0);
strcpy (dev_name, args);
- array_desc = SERIAL_OPEN (dev_name);
+ array_desc = serial_open (dev_name);
if (array_desc == NULL)
perror_with_name (dev_name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (array_desc, baud_rate))
+ if (serial_setbaudrate (array_desc, baud_rate))
{
- SERIAL_CLOSE (array_desc);
+ serial_close (array_desc);
perror_with_name (name);
}
}
- SERIAL_RAW (array_desc);
+ serial_raw (array_desc);
#if defined (LOG_FILE)
log_file = fopen (LOG_FILE, "w");
static void
array_close (int quitting)
{
- SERIAL_CLOSE (array_desc);
+ serial_close (array_desc);
array_desc = NULL;
debuglogs (1, "array_close (quitting=%d)", quitting);
timeout = 0; /* Don't time out -- user program is running. */
#if !defined(__GO32__) && !defined(__MSDOS__) && !defined(_WIN32)
- tty_desc = SERIAL_FDOPEN (0);
- ttystate = SERIAL_GET_TTY_STATE (tty_desc);
- SERIAL_RAW (tty_desc);
+ tty_desc = serial_fdopen (0);
+ ttystate = serial_get_tty_state (tty_desc);
+ serial_raw (tty_desc);
i = 0;
/* poll on the serial port and the keyboard. */
fputc_unfiltered (c, gdb_stdout);
gdb_flush (gdb_stdout);
}
- c = SERIAL_READCHAR (tty_desc, timeout);
+ c = serial_readchar (tty_desc, timeout);
if (c > 0)
{
- SERIAL_WRITE (array_desc, &c, 1);
+ serial_write (array_desc, &c, 1);
/* do this so it looks like there's keyboard echo */
if (c == 3) /* exit on Control-C */
break;
#endif
}
}
- SERIAL_SET_TTY_STATE (tty_desc, ttystate);
+ serial_set_tty_state (tty_desc, ttystate);
#else
expect_prompt (1);
debuglogs (4, "array_wait(), got the expect_prompt.");
printf ("%c", *p);
do
- SERIAL_WRITE (sr_get_desc (), p, 1);
+ serial_write (sr_get_desc (), p, 1);
while (sr_pollchar () != *p);
}
else
if (remote_debug)
printf_unfiltered ("Sending %s\n", buf);
- if (SERIAL_WRITE (e7000_desc, buf, strlen (buf)))
- fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
+ if (serial_write (e7000_desc, buf, strlen (buf)))
+ fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n", safe_strerror (errno));
/* And expect to see it echoed, unless using the pc interface */
#if 0
char b[1];
b[0] = x;
- SERIAL_WRITE (e7000_desc, b, 1);
+ serial_write (e7000_desc, b, 1);
}
static void
write_e7000 (char *s)
{
- SERIAL_WRITE (e7000_desc, s, strlen (s));
+ serial_write (e7000_desc, s, strlen (s));
}
static int
do
{
- c = SERIAL_READCHAR (e7000_desc, timeout);
+ c = serial_readchar (e7000_desc, timeout);
}
while (c > 127);
push_target (&e7000_ops);
- e7000_desc = SERIAL_OPEN (dev_name);
+ e7000_desc = serial_open (dev_name);
if (!e7000_desc)
perror_with_name (dev_name);
- if (SERIAL_SETBAUDRATE (e7000_desc, baudrate))
+ if (serial_setbaudrate (e7000_desc, baudrate))
{
- SERIAL_CLOSE (e7000_desc);
+ serial_close (e7000_desc);
perror_with_name (dev_name);
}
- SERIAL_RAW (e7000_desc);
+ serial_raw (e7000_desc);
#ifdef GDB_TARGET_IS_H8300
h8300hmode = 1;
{
if (e7000_desc)
{
- SERIAL_CLOSE (e7000_desc);
+ serial_close (e7000_desc);
e7000_desc = 0;
}
}
compose[where++] = '\n';
compose[where++] = 0;
- SERIAL_WRITE (e7000_desc, compose, where);
+ serial_write (e7000_desc, compose, where);
j = readchar (0);
if (j == -1)
{
bfd_get_section_contents (pbfd, section, buf + 10, fptr, count);
- if (SERIAL_WRITE (e7000_desc, buf, count + 10))
+ if (serial_write (e7000_desc, buf, count + 10))
fprintf_unfiltered (gdb_stderr,
- "e7000_load: SERIAL_WRITE failed: %s\n",
+ "e7000_load: serial_write failed: %s\n",
safe_strerror (errno));
expect ("OK");
#ifndef DEBUG_STDIN
- es1800_desc = SERIAL_OPEN (name);
+ es1800_desc = serial_open (name);
if (es1800_desc == NULL)
{
perror_with_name (name);
}
savename = savestring (name, strlen (name));
- es1800_saved_ttystate = SERIAL_GET_TTY_STATE (es1800_desc);
+ es1800_saved_ttystate = serial_get_tty_state (es1800_desc);
- if ((fcflag = fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_GETFL, 0)) == -1)
+ if ((fcflag = fcntl (deprecated_serial_fd (es1800_desc), F_GETFL, 0)) == -1)
{
perror_with_name ("fcntl serial");
}
es1800_fc_save = fcflag;
fcflag = (fcflag & (FREAD | FWRITE)); /* mask out any funny stuff */
- if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_SETFL, fcflag) == -1)
+ if (fcntl (deprecated_serial_fd (es1800_desc), F_SETFL, fcflag) == -1)
{
perror_with_name ("fcntl serial");
}
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (es1800_desc, baud_rate))
+ if (serial_setbaudrate (es1800_desc, baud_rate))
{
- SERIAL_CLOSE (es1800_desc);
+ serial_close (es1800_desc);
perror_with_name (name);
}
}
- SERIAL_RAW (es1800_desc);
+ serial_raw (es1800_desc);
/* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
- SERIAL_FLUSH_INPUT (es1800_desc);
+ serial_flush_input (es1800_desc);
#endif /* DEBUG_STDIN */
if (es1800_desc != NULL)
{
printf ("\nClosing connection to emulator...\n");
- if (SERIAL_SET_TTY_STATE (es1800_desc, es1800_saved_ttystate) < 0)
+ if (serial_set_tty_state (es1800_desc, es1800_saved_ttystate) < 0)
print_sys_errmsg ("warning: unable to restore tty state", errno);
- fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_SETFL, es1800_fc_save);
- SERIAL_CLOSE (es1800_desc);
+ fcntl (deprecated_serial_fd (es1800_desc), F_SETFL, es1800_fc_save);
+ serial_close (es1800_desc);
es1800_desc = NULL;
}
if (savename != NULL)
{
int ch;
- ch = SERIAL_READCHAR (es1800_desc, timeout);
+ ch = serial_readchar (es1800_desc, timeout);
/* FIXME: doing an error() here will probably cause trouble, at least if from
es1800_wait. */
send_with_reply (char *string, char *buf, int len)
{
send (string);
- SERIAL_WRITE (es1800_desc, "\r", 1);
+ serial_write (es1800_desc, "\r", 1);
#ifndef DEBUG_STDIN
expect (string, 1);
send_command (char *string)
{
send (string);
- SERIAL_WRITE (es1800_desc, "\r", 1);
+ serial_write (es1800_desc, "\r", 1);
#ifndef DEBUG_STDIN
expect (string, 0);
{
fprintf (stderr, "Sending: %s\n", string);
}
- SERIAL_WRITE (es1800_desc, string, strlen (string));
+ serial_write (es1800_desc, string, strlen (string));
}
perror_with_name ("ioctl console");
}
- if ((fcflag = fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_GETFL, 0)) == -1)
+ if ((fcflag = fcntl (deprecated_serial_fd (es1800_desc), F_GETFL, 0)) == -1)
{
perror_with_name ("fcntl serial");
}
es1800_fc_save = fcflag;
fcflag = fcflag | FNDELAY;
- if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_SETFL, fcflag) == -1)
+ if (fcntl (deprecated_serial_fd (es1800_desc), F_SETFL, fcflag) == -1)
{
perror_with_name ("fcntl serial");
}
{
es1800_buf[es1800_cnt++] = inputbuf[i++];
}
- if ((cc = SERIAL_WRITE (es1800_desc, es1800_buf, es1800_cnt)) == -1)
+ if ((cc = serial_write (es1800_desc, es1800_buf, es1800_cnt)) == -1)
{
perror_with_name ("FEL! write:");
}
perror_with_name ("FEL! read:");
}
- cc = read (DEPRECATED_SERIAL_FD (es1800_desc), inputbuf, inputcnt);
+ cc = read (deprecated_serial_fd (es1800_desc), inputbuf, inputcnt);
if (cc != -1)
{
for (i = 0; i < cc;)
close (console);
- if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_SETFL, es1800_fc_save) == -1)
+ if (fcntl (deprecated_serial_fd (es1800_desc), F_SETFL, es1800_fc_save) == -1)
{
perror_with_name ("FEL! fcntl");
}
close_ports (void)
{
mips_is_open = 0;
- SERIAL_CLOSE (mips_desc);
+ serial_close (mips_desc);
if (udp_in_use)
{
- SERIAL_CLOSE (udp_desc);
+ serial_close (udp_desc);
udp_in_use = 0;
}
tftp_in_use = 0;
{
int c;
-/* Must use SERIAL_READCHAR here cuz mips_readchar would get confused if we
- were waiting for the mips_monitor_prompt... */
+ /* Must use serial_readchar() here cuz mips_readchar would get
+ confused if we were waiting for the mips_monitor_prompt... */
- c = SERIAL_READCHAR (mips_desc, timeout);
+ c = serial_readchar (mips_desc, timeout);
if (c == SERIAL_TIMEOUT)
{
immediate_quit++;
while (n > 0)
{
- c = SERIAL_READCHAR (mips_desc, remote_timeout);
+ c = serial_readchar (mips_desc, remote_timeout);
if (c == SERIAL_TIMEOUT)
{
}
/* Read a character from the remote, aborting on error. Returns
- SERIAL_TIMEOUT on timeout (since that's what SERIAL_READCHAR
- returns). FIXME: If we see the string mips_monitor_prompt from
- the board, then we are debugging on the main console port, and we
- have somehow dropped out of remote debugging mode. In this case,
- we automatically go back in to remote debugging mode. This is a
- hack, put in because I can't find any way for a program running on
- the remote board to terminate without also ending remote debugging
+ SERIAL_TIMEOUT on timeout (since that's what serial_readchar()
+ returns). FIXME: If we see the string mips_monitor_prompt from the
+ board, then we are debugging on the main console port, and we have
+ somehow dropped out of remote debugging mode. In this case, we
+ automatically go back in to remote debugging mode. This is a hack,
+ put in because I can't find any way for a program running on the
+ remote board to terminate without also ending remote debugging
mode. I assume users won't have any trouble with this; for one
thing, the IDT documentation generally assumes that the remote
debugging port is not the console port. This is, however, very
if (state == mips_monitor_prompt_len)
timeout = 1;
- ch = SERIAL_READCHAR (mips_desc, timeout);
+ ch = serial_readchar (mips_desc, timeout);
if (ch == SERIAL_TIMEOUT && timeout == -1) /* Watchdog went off */
{
fprintf_unfiltered (gdb_stdlog, "Writing \"%s\"\n", packet + 1);
}
- if (SERIAL_WRITE (mips_desc, packet,
+ if (serial_write (mips_desc, packet,
HDR_LENGTH + len + TRLR_LENGTH) != 0)
mips_error ("write to target failed: %s", safe_strerror (errno));
ack + 1);
}
- if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
+ if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
{
if (throw_error)
mips_error ("write to target failed: %s", safe_strerror (errno));
ack + 1);
}
- if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
+ if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
{
if (throw_error)
mips_error ("write to target failed: %s", safe_strerror (errno));
static void
mips_send_command (const char *cmd, int prompt)
{
- SERIAL_WRITE (mips_desc, cmd, strlen (cmd));
+ serial_write (mips_desc, cmd, strlen (cmd));
mips_expect (cmd);
mips_expect ("\n");
if (prompt)
mips_send_command ("db tty0\r", 0);
sleep (1);
- SERIAL_WRITE (mips_desc, "\r", sizeof "\r" - 1);
+ serial_write (mips_desc, "\r", sizeof "\r" - 1);
/* We don't need to absorb any spurious characters here, since the
mips_receive_header will eat up a reasonable number of characters
switch (j)
{
case 0: /* First, try sending a CR */
- SERIAL_FLUSH_INPUT (mips_desc);
- SERIAL_WRITE (mips_desc, "\r", 1);
+ serial_flush_input (mips_desc);
+ serial_write (mips_desc, "\r", 1);
break;
case 1: /* First, try sending a break */
- SERIAL_SEND_BREAK (mips_desc);
+ serial_send_break (mips_desc);
break;
case 2: /* Then, try a ^C */
- SERIAL_WRITE (mips_desc, "\003", 1);
+ serial_write (mips_desc, "\003", 1);
break;
case 3: /* Then, try escaping from download */
{
packets. In-case we were downloading a large packet
we flush the output buffer before inserting a
termination sequence. */
- SERIAL_FLUSH_OUTPUT (mips_desc);
+ serial_flush_output (mips_desc);
sprintf (tbuff, "\r/E/E\r");
- SERIAL_WRITE (mips_desc, tbuff, 6);
+ serial_write (mips_desc, tbuff, 6);
}
else
{
for (i = 1; i <= 33; i++)
{
- SERIAL_WRITE (mips_desc, srec, 8);
+ serial_write (mips_desc, srec, 8);
- if (SERIAL_READCHAR (mips_desc, 0) >= 0)
+ if (serial_readchar (mips_desc, 0) >= 0)
break; /* Break immediatly if we get something from
the board. */
}
unpush_target (current_ops);
/* Open and initialize the serial port. */
- mips_desc = SERIAL_OPEN (serial_port_name);
+ mips_desc = serial_open (serial_port_name);
if (mips_desc == NULL)
perror_with_name (serial_port_name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (mips_desc, baud_rate))
+ if (serial_setbaudrate (mips_desc, baud_rate))
{
- SERIAL_CLOSE (mips_desc);
+ serial_close (mips_desc);
perror_with_name (serial_port_name);
}
}
- SERIAL_RAW (mips_desc);
+ serial_raw (mips_desc);
/* Open and initialize the optional download port. If it is in the form
hostname#portnumber, it's a UDP socket. If it is in the form
{
if (strchr (remote_name, '#'))
{
- udp_desc = SERIAL_OPEN (remote_name);
+ udp_desc = serial_open (remote_name);
if (!udp_desc)
perror_with_name ("Unable to open UDP port");
udp_in_use = 1;
if (remote_debug > 0)
printf_unfiltered ("Sending break\n");
- SERIAL_SEND_BREAK (mips_desc);
+ serial_send_break (mips_desc);
#if 0
if (mips_is_open)
/* Send a ^C. */
cc = '\003';
- SERIAL_WRITE (mips_desc, &cc, 1);
+ serial_write (mips_desc, &cc, 1);
sleep (1);
target_mourn_inferior ();
}
{
int ch;
- SERIAL_WRITE (mips_desc, srec, len);
+ serial_write (mips_desc, srec, len);
ch = mips_readchar (remote_timeout);
send_srec (srec, reclen, abfd->start_address);
- SERIAL_FLUSH_INPUT (mips_desc);
+ serial_flush_input (mips_desc);
}
/*
if (!tftp_in_use)
{
- c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc,
+ c = serial_readchar (udp_in_use ? udp_desc : mips_desc,
remote_timeout);
if ((c == SERIAL_TIMEOUT) || (c != 0x06))
{
if (tftp_in_use)
fwrite (buffer, 1, length, tftp_file);
else
- SERIAL_WRITE (udp_in_use ? udp_desc : mips_desc, buffer, length);
+ serial_write (udp_in_use ? udp_desc : mips_desc, buffer, length);
}
static void
if (finished)
{ /* Ignore the termination message: */
- SERIAL_FLUSH_INPUT (udp_in_use ? udp_desc : mips_desc);
+ serial_flush_input (udp_in_use ? udp_desc : mips_desc);
}
else
{ /* Deal with termination message: */
nindy_close (int quitting)
{
if (nindy_serial != NULL)
- SERIAL_CLOSE (nindy_serial);
+ serial_close (nindy_serial);
nindy_serial = NULL;
if (savename)
clean_up_tty (PTR ptrarg)
{
struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
- SERIAL_SET_TTY_STATE (args->serial, args->state);
+ serial_set_tty_state (args->serial, args->state);
xfree (args->state);
warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
}
static void
clean_up_int (void)
{
- SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
+ serial_set_tty_state (tty_args.serial, tty_args.state);
xfree (tty_args.state);
signal (SIGINT, old_ctrlc);
/* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
/* Save current tty attributes, and restore them when done. */
- tty_args.serial = SERIAL_FDOPEN (0);
- tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
+ tty_args.serial = serial_fdopen (0);
+ tty_args.state = serial_get_tty_state (tty_args.serial);
old_ctrlc = signal (SIGINT, clean_up_int);
#ifdef SIGTSTP
old_ctrlz = signal (SIGTSTP, clean_up_int);
<CR> and perform echo. */
/* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
enough. */
- SERIAL_RAW (tty_args.serial);
+ serial_raw (tty_args.serial);
while (1)
{
/* Input on remote */
- c = SERIAL_READCHAR (nindy_serial, -1);
+ c = serial_readchar (nindy_serial, -1);
if (c == SERIAL_ERROR)
{
error ("Cannot read from serial line");
}
else if (c == 0x1b) /* ESC */
{
- c = SERIAL_READCHAR (nindy_serial, -1);
+ c = serial_readchar (nindy_serial, -1);
c &= ~0x40;
}
else if (c != 0x10) /* DLE */
}
}
- SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
+ serial_set_tty_state (tty_args.serial, tty_args.state);
xfree (tty_args.state);
discard_cleanups (old_cleanups);
}
if (query ("Really reset the target system?", 0, 0))
{
- SERIAL_SEND_BREAK (nindy_serial);
+ serial_send_break (nindy_serial);
tty_flush (nindy_serial);
}
}
while (1)
{
- c = SERIAL_READCHAR (ctrl_desc, 5);
+ c = serial_readchar (ctrl_desc, 5);
if (c == *p++)
{
struct serial *desc;
sprintf (sockname, "%s:%d", name, port);
- desc = SERIAL_OPEN (sockname);
+ desc = serial_open (sockname);
if (!desc)
perror_with_name (sockname);
static void
load_cleanup (void)
{
- SERIAL_CLOSE (load_desc);
+ serial_close (load_desc);
load_desc = NULL;
}
struct cleanup *old_chain;
/* Tell the netrom to get ready to download. */
- if (SERIAL_WRITE (ctrl_desc, downloadstring, strlen (downloadstring)))
+ if (serial_write (ctrl_desc, downloadstring, strlen (downloadstring)))
error ("nrom_load: control_send() of `%s' failed", downloadstring);
expect ("Waiting for a connection...\n");
bfd_get_section_contents (pbfd, section, buffer, fptr,
count);
- SERIAL_WRITE (load_desc, buffer, count);
+ serial_write (load_desc, buffer, count);
section_address += count;
fptr += count;
section_size -= count;
nrom_close (int quitting)
{
if (load_desc)
- SERIAL_CLOSE (load_desc);
+ serial_close (load_desc);
if (ctrl_desc)
- SERIAL_CLOSE (ctrl_desc);
+ serial_close (ctrl_desc);
}
/* Pass arguments directly to the NetROM. */
char buf[1024];
sprintf (buf, "%s\n", args);
- if (SERIAL_WRITE (ctrl_desc, buf, strlen (buf)))
+ if (serial_write (ctrl_desc, buf, strlen (buf)))
error ("nrom_reset: control_send() of `%s'failed", args);
}
vsprintf (buf, pattern, args);
va_end (args);
- if (SERIAL_WRITE (monitor_desc, buf, strlen (buf)))
- fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
+ if (serial_write (monitor_desc, buf, strlen (buf)))
+ fprintf (stderr, "serial_write failed: %s\n", safe_strerror (errno));
}
/* Read a character from the remote system, doing all the fancy timeout stuff */
{
int c;
- c = SERIAL_READCHAR (monitor_desc, timeout);
+ c = serial_readchar (monitor_desc, timeout);
if (sr_get_debug ())
putchar (c & 0x7f);
unpush_target (&rombug_ops);
strcpy (dev_name, args);
- monitor_desc = SERIAL_OPEN (dev_name);
+ monitor_desc = serial_open (dev_name);
if (monitor_desc == NULL)
perror_with_name (dev_name);
/* if baud rate is set by 'set remotebaud' */
- if (SERIAL_SETBAUDRATE (monitor_desc, sr_get_baud_rate ()))
+ if (serial_setbaudrate (monitor_desc, sr_get_baud_rate ()))
{
- SERIAL_CLOSE (monitor_desc);
+ serial_close (monitor_desc);
perror_with_name ("RomBug");
}
- SERIAL_RAW (monitor_desc);
+ serial_raw (monitor_desc);
if (tty_xon || tty_xoff)
{
struct hardware_ttystate
}
*tty_s;
- tty_s = (struct hardware_ttystate *) SERIAL_GET_TTY_STATE (monitor_desc);
+ tty_s = (struct hardware_ttystate *) serial_get_tty_state (monitor_desc);
if (tty_xon)
tty_s->t.c_iflag |= IXON;
if (tty_xoff)
tty_s->t.c_iflag |= IXOFF;
- SERIAL_SET_TTY_STATE (monitor_desc, (serial_ttystate) tty_s);
+ serial_set_tty_state (monitor_desc, (serial_ttystate) tty_s);
}
rombug_is_open = 1;
{
if (rombug_is_open)
{
- SERIAL_CLOSE (monitor_desc);
+ serial_close (monitor_desc);
monitor_desc = NULL;
rombug_is_open = 0;
}
fflush (stdout);
}
- if (SERIAL_WRITE (monitor_desc, buf, bytes_read))
+ if (serial_write (monitor_desc, buf, bytes_read))
{
- fprintf (stderr, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror (errno));
+ fprintf (stderr, "serial_write failed: (while downloading) %s\n", safe_strerror (errno));
break;
}
i = 0;
cleanup_tty (void)
{
printf ("\r\n[Exiting connect mode]\r\n");
- /*SERIAL_RESTORE(0, &ttystate); */
+ /*serial_restore(0, &ttystate); */
}
static void
do
{
FD_SET (0, &readfds);
- FD_SET (DEPRECATED_SERIAL_FD (monitor_desc), &readfds);
+ FD_SET (deprecated_serial_fd (monitor_desc), &readfds);
numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
}
while (numfds == 0);
}
}
- if (FD_ISSET (DEPRECATED_SERIAL_FD (monitor_desc), &readfds))
+ if (FD_ISSET (deprecated_serial_fd (monitor_desc), &readfds))
{
while (1)
{
static unsigned char
get_byte (void)
{
- int c = SERIAL_READCHAR (io, timeout);
+ int c = serial_readchar (io, timeout);
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", c);
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);
- SERIAL_WRITE (io, &val, 1);
+ serial_write (io, &val, 1);
}
static void
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "(%04x)", val);
- SERIAL_WRITE (io, b, 4);
+ serial_write (io, b, 4);
}
int restype;
QUIT;
- SERIAL_FLUSH_INPUT (io);
- SERIAL_FLUSH_OUTPUT (io);
+ serial_flush_input (io);
+ serial_flush_output (io);
if (tty)
printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);
if (cold)
{
put_byte (RDP_RESET);
- while ((restype = SERIAL_READCHAR (io, 1)) > 0)
+ while ((restype = serial_readchar (io, 1)) > 0)
{
switch (restype)
{
put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
put_word (0);
- while (!sync && (restype = SERIAL_READCHAR (io, 1)) > 0)
+ while (!sync && (restype = serial_readchar (io, 1)) > 0)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype);
break;
case RDP_RESET:
- while ((restype = SERIAL_READCHAR (io, 1)) == RDP_RESET)
+ while ((restype = serial_readchar (io, 1)) == RDP_RESET)
;
do
{
printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
}
- while ((restype = SERIAL_READCHAR (io, 1)) > 0);
+ while ((restype = serial_readchar (io, 1)) > 0);
if (tty)
{
case RDP_RES_VALUE:
{
- int resval = SERIAL_READCHAR (io, 1);
+ int resval = serial_readchar (io, 1);
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval);
pc = va_arg (alist, char *);
val = va_arg (alist, int);
dst = buf;
- SERIAL_WRITE (io, pc, val);
+ serial_write (io, pc, val);
break;
case '-':
/* Send whats in the queue */
if (dst != buf)
{
- SERIAL_WRITE (io, buf, dst - buf);
+ serial_write (io, buf, dst - buf);
dst = buf;
}
break;
while (running)
{
int res;
- res = SERIAL_READCHAR (io, 1);
+ res = serial_readchar (io, 1);
while (res == SERIAL_TIMEOUT)
{
QUIT;
printf_filtered ("Waiting for target..\n");
- res = SERIAL_READCHAR (io, 1);
+ res = serial_readchar (io, 1);
}
switch (res)
target_preopen (from_tty);
- io = SERIAL_OPEN (args);
+ io = serial_open (args);
if (!io)
perror_with_name (args);
- SERIAL_RAW (io);
+ serial_raw (io);
rdp_init (1, from_tty);
{
callback->shutdown (callback);
if (io)
- SERIAL_CLOSE (io);
+ serial_close (io);
io = 0;
}
sds_close (int quitting)
{
if (sds_desc)
- SERIAL_CLOSE (sds_desc);
+ serial_close (sds_desc);
sds_desc = NULL;
}
immediate_quit++; /* Allow user to interrupt it */
/* Ack any packet which the remote side has already sent. */
- SERIAL_WRITE (sds_desc, "{#*\r\n", 5);
- SERIAL_WRITE (sds_desc, "{#}\r\n", 5);
+ serial_write (sds_desc, "{#*\r\n", 5);
+ serial_write (sds_desc, "{#}\r\n", 5);
while ((c = readchar (1)) >= 0)
printf_unfiltered ("%c", c);
unpush_target (&sds_ops);
- sds_desc = SERIAL_OPEN (name);
+ sds_desc = serial_open (name);
if (!sds_desc)
perror_with_name (name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (sds_desc, baud_rate))
+ if (serial_setbaudrate (sds_desc, baud_rate))
{
- SERIAL_CLOSE (sds_desc);
+ serial_close (sds_desc);
perror_with_name (name);
}
}
- SERIAL_RAW (sds_desc);
+ serial_raw (sds_desc);
/* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
- SERIAL_FLUSH_INPUT (sds_desc);
+ serial_flush_input (sds_desc);
if (from_tty)
{
{
int ch;
- ch = SERIAL_READCHAR (sds_desc, timeout);
+ ch = serial_readchar (sds_desc, timeout);
if (remote_debug > 1 && ch >= 0)
fprintf_unfiltered (gdb_stdlog, "%c(%x)", ch, ch);
header[0], header[1], header[2]);
gdb_flush (gdb_stdlog);
}
- if (SERIAL_WRITE (sds_desc, buf2, p - buf2))
+ if (serial_write (sds_desc, buf2, p - buf2))
perror_with_name ("putmessage: write failed");
return 1;
vsprintf (buf, pattern, args);
va_end (args);
- if (SERIAL_WRITE (st2000_desc, buf, strlen (buf)))
- fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
+ if (serial_write (st2000_desc, buf, strlen (buf)))
+ fprintf (stderr, "serial_write failed: %s\n", safe_strerror (errno));
}
/* Read a character from the remote system, doing all the fancy timeout
{
int c;
- c = SERIAL_READCHAR (st2000_desc, timeout);
+ c = serial_readchar (st2000_desc, timeout);
#ifdef LOG_FILE
putc (c & 0x7f, log_file);
st2000_close (0);
- st2000_desc = SERIAL_OPEN (dev_name);
+ st2000_desc = serial_open (dev_name);
if (!st2000_desc)
perror_with_name (dev_name);
- if (SERIAL_SETBAUDRATE (st2000_desc, baudrate))
+ if (serial_setbaudrate (st2000_desc, baudrate))
{
- SERIAL_CLOSE (dev_name);
+ serial_close (dev_name);
perror_with_name (dev_name);
}
- SERIAL_RAW (st2000_desc);
+ serial_raw (st2000_desc);
push_target (&st2000_ops);
static void
st2000_close (int quitting)
{
- SERIAL_CLOSE (st2000_desc);
+ serial_close (st2000_desc);
#if defined (LOG_FILE)
if (log_file)
cleanup_tty (void)
{
printf ("\r\n[Exiting connect mode]\r\n");
-/* SERIAL_RESTORE(0, &ttystate); */
+/* serial_restore(0, &ttystate); */
}
#if 0
do
{
FD_SET (0, &readfds);
- FD_SET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds);
+ FD_SET (deprecated_serial_fd (st2000_desc), &readfds);
numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
}
while (numfds == 0);
}
}
- if (FD_ISSET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds))
+ if (FD_ISSET (deprecated_serial_fd (st2000_desc), &readfds))
{
while (1)
{
if (sr_get_device () == NULL)
usage (gr->ops->to_shortname, NULL);
- sr_set_desc (SERIAL_OPEN (sr_get_device ()));
+ sr_set_desc (serial_open (sr_get_device ()));
if (!sr_get_desc ())
perror_with_name ((char *) sr_get_device ());
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (sr_get_desc (), baud_rate) != 0)
+ if (serial_setbaudrate (sr_get_desc (), baud_rate) != 0)
{
- SERIAL_CLOSE (sr_get_desc ());
+ serial_close (sr_get_desc ());
perror_with_name (sr_get_device ());
}
}
- SERIAL_RAW (sr_get_desc ());
+ serial_raw (sr_get_desc ());
/* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
- SERIAL_FLUSH_INPUT (sr_get_desc ());
+ serial_flush_input (sr_get_desc ());
/* default retries */
if (sr_get_retries () == 0)
{
int buf;
- buf = SERIAL_READCHAR (sr_get_desc (), sr_get_timeout ());
+ buf = serial_readchar (sr_get_desc (), sr_get_timeout ());
if (buf == SERIAL_TIMEOUT)
error ("Timeout reading from remote system.");
{
int buf;
- buf = SERIAL_READCHAR (sr_get_desc (), 0);
+ buf = serial_readchar (sr_get_desc (), 0);
if (buf == SERIAL_TIMEOUT)
buf = 0;
if (sr_get_debug () > 0)
{
int i;
- if (SERIAL_WRITE (sr_get_desc (), a, l) != 0)
+ if (serial_write (sr_get_desc (), a, l) != 0)
perror_with_name ("sr_write: Error writing to remote");
if (sr_get_debug () > 0)
if (sr_is_open ())
{
- SERIAL_CLOSE (sr_get_desc ());
+ serial_close (sr_get_desc ());
sr_set_desc (NULL);
}
remote_close (int quitting)
{
if (remote_desc)
- SERIAL_CLOSE (remote_desc);
+ serial_close (remote_desc);
remote_desc = NULL;
}
immediate_quit++; /* Allow user to interrupt it */
/* Ack any packet which the remote side has already sent. */
- SERIAL_WRITE (remote_desc, "+", 1);
+ serial_write (remote_desc, "+", 1);
/* Let the stub know that we want it to return the thread. */
set_thread (-1, 0);
unpush_target (target);
- remote_desc = SERIAL_OPEN (name);
+ remote_desc = serial_open (name);
if (!remote_desc)
perror_with_name (name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
+ if (serial_setbaudrate (remote_desc, baud_rate))
{
- SERIAL_CLOSE (remote_desc);
+ serial_close (remote_desc);
perror_with_name (name);
}
}
- SERIAL_RAW (remote_desc);
+ serial_raw (remote_desc);
/* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
- SERIAL_FLUSH_INPUT (remote_desc);
+ serial_flush_input (remote_desc);
if (from_tty)
{
unpush_target (target);
- remote_desc = SERIAL_OPEN (name);
+ remote_desc = serial_open (name);
if (!remote_desc)
perror_with_name (name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
+ if (serial_setbaudrate (remote_desc, baud_rate))
{
- SERIAL_CLOSE (remote_desc);
+ serial_close (remote_desc);
perror_with_name (name);
}
}
- SERIAL_RAW (remote_desc);
+ serial_raw (remote_desc);
/* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
- SERIAL_FLUSH_INPUT (remote_desc);
+ serial_flush_input (remote_desc);
if (from_tty)
{
/* Unregister the file descriptor from the event loop. */
if (target_is_async_p ())
- SERIAL_ASYNC (remote_desc, NULL, 0);
+ serial_async (remote_desc, NULL, 0);
target_mourn_inferior ();
if (from_tty)
fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
if (remote_break)
- SERIAL_SEND_BREAK (remote_desc);
+ serial_send_break (remote_desc);
else
- SERIAL_WRITE (remote_desc, "\003", 1);
+ serial_write (remote_desc, "\003", 1);
}
/* Ask the user what to do when an interrupt is received. */
{
int ch;
- ch = SERIAL_READCHAR (remote_desc, timeout);
+ ch = serial_readchar (remote_desc, timeout);
if (ch >= 0)
return (ch & 0x7f);
fprintf_unfiltered (gdb_stdlog, "...");
gdb_flush (gdb_stdlog);
}
- if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
+ if (serial_write (remote_desc, buf2, p - buf2))
perror_with_name ("putpkt: write failed");
/* read until either a timeout occurs (-2) or '+' is read */
fputstr_unfiltered (buf, 0, gdb_stdlog);
fprintf_unfiltered (gdb_stdlog, "\n");
}
- SERIAL_WRITE (remote_desc, "+", 1);
+ serial_write (remote_desc, "+", 1);
return 0;
}
/* Try the whole thing again. */
retry:
- SERIAL_WRITE (remote_desc, "-", 1);
+ serial_write (remote_desc, "-", 1);
}
/* We have tried hard enough, and just can't receive the packet. Give up. */
printf_unfiltered ("Ignoring packet error, continuing...\n");
- SERIAL_WRITE (remote_desc, "+", 1);
+ serial_write (remote_desc, "+", 1);
return 1;
}
\f
{
/* Unregister the file descriptor from the event loop. */
if (target_is_async_p ())
- SERIAL_ASYNC (remote_desc, NULL, 0);
+ serial_async (remote_desc, NULL, 0);
/* For some mysterious reason, wait_for_inferior calls kill instead of
mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
unpush_target (&remote_cisco_ops);
- remote_desc = SERIAL_OPEN (name);
+ remote_desc = serial_open (name);
if (!remote_desc)
perror_with_name (name);
*/
baud_rate = (baud_rate > 0) ? baud_rate : 9600;
- if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
+ if (serial_setbaudrate (remote_desc, baud_rate))
{
- SERIAL_CLOSE (remote_desc);
+ serial_close (remote_desc);
perror_with_name (name);
}
- SERIAL_RAW (remote_desc);
+ serial_raw (remote_desc);
/* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
- SERIAL_FLUSH_INPUT (remote_desc);
+ serial_flush_input (remote_desc);
if (from_tty)
{
/* Make this a zero terminated string and write it out */
tty_input[tty_bytecount] = 0;
- if (SERIAL_WRITE (remote_desc, tty_input, tty_bytecount))
+ if (serial_write (remote_desc, tty_input, tty_bytecount))
{
perror_with_name ("readtty: write failed");
return FATAL_ERROR;
FD_ZERO (&input);
FD_SET (fileno (stdin), &input);
- FD_SET (DEPRECATED_SERIAL_FD (remote_desc), &input);
+ FD_SET (deprecated_serial_fd (remote_desc), &input);
status = select (tablesize, &input, 0, 0, 0);
if ((status == -1) && (errno != EINTR))
quit_flag = 0;
if (remote_break)
- SERIAL_SEND_BREAK (remote_desc);
+ serial_send_break (remote_desc);
else
- SERIAL_WRITE (remote_desc, "\003", 1);
+ serial_write (remote_desc, "\003", 1);
continue;
}
remote_can_async_p (void)
{
/* We're async whenever the serial device is. */
- return (current_target.to_async_mask_value) && SERIAL_CAN_ASYNC_P (remote_desc);
+ return (current_target.to_async_mask_value) && serial_can_async_p (remote_desc);
}
static int
remote_is_async_p (void)
{
/* We're async whenever the serial device is. */
- return (current_target.to_async_mask_value) && SERIAL_IS_ASYNC_P (remote_desc);
+ return (current_target.to_async_mask_value) && serial_is_async_p (remote_desc);
}
/* Pass the SERIAL event on and up to the client. One day this code
if (callback != NULL)
{
- SERIAL_ASYNC (remote_desc, remote_async_serial_handler, NULL);
+ serial_async (remote_desc, remote_async_serial_handler, NULL);
async_client_callback = callback;
async_client_context = context;
}
else
- SERIAL_ASYNC (remote_desc, NULL, NULL);
+ serial_async (remote_desc, NULL, NULL);
}
/* Target async and target extended-async.
static void
reschedule (struct serial *scb)
{
- if (SERIAL_IS_ASYNC_P (scb))
+ if (serial_is_async_p (scb))
{
int next_state;
switch (scb->async_state)
next_state = scb->async_state;
break;
}
- if (SERIAL_DEBUG_P (scb))
+ if (serial_debug_p (scb))
{
switch (next_state)
{
{
/* Force a re-schedule. */
scb->async_state = NOTHING_SCHEDULED;
- if (SERIAL_DEBUG_P (scb))
+ if (serial_debug_p (scb))
fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
scb->fd);
reschedule (scb);
}
else
{
- if (SERIAL_DEBUG_P (scb))
+ if (serial_debug_p (scb))
fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
scb->fd);
/* De-schedule whatever tasks are currently scheduled. */
/* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
code is finished. */
- if (0 && SERIAL_IS_ASYNC_P (scb) && timeout < 0)
+ if (0 && serial_is_async_p (scb) && timeout < 0)
internal_error (__FILE__, __LINE__,
"serial_readchar: blocking read in async mode");
in case we are getting ready to dump core or something. */
gdb_flush (serial_logfp);
}
- if (SERIAL_DEBUG_P (scb))
+ if (serial_debug_p (scb))
{
fprintf_unfiltered (gdb_stdlog, "[");
serial_logchar (gdb_stdlog, 'r', ch, timeout);
va_start (args, format);
xvasprintf (&buf, format, args);
- SERIAL_WRITE (desc, buf, strlen (buf));
+ serial_write (desc, buf, strlen (buf));
xfree (buf);
va_end (args);
cleanup_tty (serial_ttystate ttystate)
{
printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
- SERIAL_SET_TTY_STATE (tty_desc, ttystate);
+ serial_set_tty_state (tty_desc, ttystate);
xfree (ttystate);
- SERIAL_CLOSE (tty_desc);
+ serial_close (tty_desc);
}
static void
printf_unfiltered ("[Entering connect mode. Use ~. or ~^D to escape]\n");
- tty_desc = SERIAL_FDOPEN (0);
+ tty_desc = serial_fdopen (0);
port_desc = last_serial_opened;
- ttystate = SERIAL_GET_TTY_STATE (tty_desc);
+ ttystate = serial_get_tty_state (tty_desc);
- SERIAL_RAW (tty_desc);
- SERIAL_RAW (port_desc);
+ serial_raw (tty_desc);
+ serial_raw (port_desc);
make_cleanup (cleanup_tty, ttystate);
{
int mask;
- mask = SERIAL_WAIT_2 (tty_desc, port_desc, -1);
+ mask = serial_wait_2 (tty_desc, port_desc, -1);
if (mask & 2)
{ /* tty input */
while (1)
{
- c = SERIAL_READCHAR (tty_desc, 0);
+ c = serial_readchar (tty_desc, 0);
if (c == SERIAL_TIMEOUT)
break;
perror_with_name ("connect");
cx = c;
- SERIAL_WRITE (port_desc, &cx, 1);
+ serial_write (port_desc, &cx, 1);
switch (cur_esc)
{
while (1)
{
- c = SERIAL_READCHAR (port_desc, 0);
+ c = serial_readchar (port_desc, 0);
if (c == SERIAL_TIMEOUT)
break;
cx = c;
- SERIAL_WRITE (tty_desc, &cx, 1);
+ serial_write (tty_desc, &cx, 1);
}
}
}
on failure. */
extern struct serial *serial_open (const char *name);
-#define SERIAL_OPEN(NAME) serial_open(NAME)
/* Open a new serial stream using a file handle. */
extern struct serial *serial_fdopen (const int fd);
-#define SERIAL_FDOPEN(FD) serial_fdopen(FD)
/* Push out all buffers, close the device and destroy SCB. */
extern void serial_close (struct serial *scb);
-#define SERIAL_CLOSE(SERIAL_T) serial_close ((SERIAL_T))
/* Push out all buffers and destroy SCB without closing the device. */
extern void serial_un_fdopen (struct serial *scb);
-#define SERIAL_UN_FDOPEN(SERIAL_T) serial_un_fdopen ((SERIAL_T))
/* Read one char from the serial device with TIMEOUT seconds to wait
or -1 to wait forever. Use timeout of 0 to effect a poll.
};
extern int serial_readchar (struct serial *scb, int timeout);
-#define SERIAL_READCHAR(SERIAL_T, TIMEOUT) serial_readchar ((SERIAL_T), (TIMEOUT))
/* Write LEN chars from STRING to the port SCB. Returns 0 for
success, non-zero for failure. */
extern int serial_write (struct serial *scb, const char *str, int len);
-#define SERIAL_WRITE(SERIAL_T, STRING,LEN) serial_write (SERIAL_T, STRING, LEN)
/* Write a printf style string onto the serial port. */
/* Allow pending output to drain. */
extern int serial_drain_output (struct serial *);
-#define SERIAL_DRAIN_OUTPUT(SERIAL_T) serial_drain_output ((SERIAL_T))
/* Flush (discard) pending output. Might also flush input (if this
system can't flush only output). */
extern int serial_flush_output (struct serial *);
-#define SERIAL_FLUSH_OUTPUT(SERIAL_T) serial_flush_output ((SERIAL_T))
/* Flush pending input. Might also flush output (if this system can't
flush only input). */
extern int serial_flush_input (struct serial *);
-#define SERIAL_FLUSH_INPUT(SERIAL_T) serial_flush_input ((SERIAL_T))
/* Send a break between 0.25 and 0.5 seconds long. */
extern int serial_send_break (struct serial *scb);
-#define SERIAL_SEND_BREAK(SERIAL_T) serial_send_break (SERIAL_T)
/* Turn the port into raw mode. */
extern void serial_raw (struct serial *scb);
-#define SERIAL_RAW(SERIAL_T) serial_raw ((SERIAL_T))
/* Return a pointer to a newly malloc'd ttystate containing the state
of the tty. */
extern serial_ttystate serial_get_tty_state (struct serial *scb);
-#define SERIAL_GET_TTY_STATE(SERIAL_T) serial_get_tty_state ((SERIAL_T))
/* Set the state of the tty to TTYSTATE. The change is immediate.
When changing to or from raw mode, input might be discarded.
errno contains the error). */
extern int serial_set_tty_state (struct serial *scb, serial_ttystate ttystate);
-#define SERIAL_SET_TTY_STATE(SERIAL_T, TTYSTATE) serial_set_tty_state ((SERIAL_T), (TTYSTATE))
/* printf_filtered a user-comprehensible description of ttystate on
the specified STREAM. FIXME: At present this sends output to the
default stream - GDB_STDOUT. */
extern void serial_print_tty_state (struct serial *scb, serial_ttystate ttystate, struct ui_file *);
-#define SERIAL_PRINT_TTY_STATE(SERIAL_T, TTYSTATE, STREAM) serial_print_tty_state ((SERIAL_T), (TTYSTATE), (STREAM))
/* Set the tty state to NEW_TTYSTATE, where OLD_TTYSTATE is the
current state (generally obtained from a recent call to
- SERIAL_GET_TTY_STATE), but be careful not to discard any input.
+ serial_get_tty_state()), but be careful not to discard any input.
This means that we never switch in or out of raw mode, even if
NEW_TTYSTATE specifies a switch. */
extern int serial_noflush_set_tty_state (struct serial *scb, serial_ttystate new_ttystate, serial_ttystate old_ttystate);
-#define SERIAL_NOFLUSH_SET_TTY_STATE(SERIAL_T, NEW_TTYSTATE, OLD_TTYSTATE) \
-serial_noflush_set_tty_state ((SERIAL_T), (NEW_TTYSTATE), (OLD_TTYSTATE))
/* Set the baudrate to the decimal value supplied. Returns 0 for
success, -1 for failure. */
extern int serial_setbaudrate (struct serial *scb, int rate);
-#define SERIAL_SETBAUDRATE(SERIAL_T, RATE) serial_setbaudrate ((SERIAL_T), (RATE))
/* Set the number of stop bits to the value specified. Returns 0 for
success, -1 for failure. */
#define SERIAL_2_STOPBITS 3
extern int serial_setstopbits (struct serial *scb, int num);
-#define SERIAL_SETSTOPBITS(SERIAL_T, NUM) serial_setstopbits ((SERIAL_T), (NUM))
/* Asynchronous serial interface: */
/* Can the serial device support asynchronous mode? */
extern int serial_can_async_p (struct serial *scb);
-#define SERIAL_CAN_ASYNC_P(SERIAL_T) serial_can_async_p ((SERIAL_T))
/* Has the serial device been put in asynchronous mode? */
extern int serial_is_async_p (struct serial *scb);
-#define SERIAL_IS_ASYNC_P(SERIAL_T) serial_is_async_p ((SERIAL_T))
/* For ASYNC enabled devices, register a callback and enable
asynchronous mode. To disable asynchronous mode, register a NULL
typedef void (serial_event_ftype) (struct serial *scb, void *context);
extern void serial_async (struct serial *scb, serial_event_ftype *handler, void *context);
-#define SERIAL_ASYNC(SERIAL_T, HANDLER, CONTEXT) serial_async ((SERIAL_T), (HANDLER), (CONTEXT))
/* Provide direct access to the underlying FD (if any) used to
implement the serial device. This interface is clearly
applicable to the current serial device. */
extern int deprecated_serial_fd (struct serial *scb);
-#define DEPRECATED_SERIAL_FD(SERIAL_T) deprecated_serial_fd ((SERIAL_T))
/* Trace/debug mechanism.
- SERIAL_DEBUG() enables/disables internal debugging.
- SERIAL_DEBUG_P() indicates the current debug state. */
+ serial_debug() enables/disables internal debugging.
+ serial_debug_p() indicates the current debug state. */
extern void serial_debug (struct serial *scb, int debug_p);
-#define SERIAL_DEBUG(SERIAL_T, DEBUG_P) serial_debug ((SERIAL_T), (DEBUG_P))
extern int serial_debug_p (struct serial *scb);
-#define SERIAL_DEBUG_P(SERIAL_T) serial_debug_p ((SERIAL_T))
/* Details of an instance of a serial object */
{
monitor_printf ("il;s:x\r");
monitor_expect ("\005", NULL, 0); /* Look for ENQ */
- SERIAL_WRITE (desc, "\006", 1); /* Send ACK */
+ serial_write (desc, "\006", 1); /* Send ACK */
monitor_expect ("LO x\r", NULL, 0); /* Look for filename */
load_srec (desc, file, 0, 80, SREC_ALL, hashmark, NULL);
monitor_expect ("\005", NULL, 0); /* Look for ENQ */
- SERIAL_WRITE (desc, "\006", 1); /* Send ACK */
+ serial_write (desc, "\006", 1); /* Send ACK */
monitor_expect_prompt (NULL, 0);
}
}
if (parallel_port_name)
{
- parallel = SERIAL_OPEN (parallel_port_name);
+ parallel = serial_open (parallel_port_name);
if (!parallel)
perror_with_name ("Unable to open parallel port.");
if (parallel_port_name)
{
- parallel = SERIAL_OPEN (parallel_port_name);
+ parallel = serial_open (parallel_port_name);
if (!parallel)
perror_with_name ("Unable to open parallel port.");
monitor_close (quitting);
if (parallel_in_use)
{
- SERIAL_CLOSE (parallel);
+ serial_close (parallel);
parallel_in_use = 0;
}
}
{
struct serial *desc;
- desc = SERIAL_OPEN (name);
+ desc = serial_open (name);
if (!desc)
perror_with_name (name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (desc, baud_rate))
+ if (serial_setbaudrate (desc, baud_rate))
{
- SERIAL_CLOSE (desc);
+ serial_close (desc);
perror_with_name (name);
}
}
- SERIAL_RAW (desc);
+ serial_raw (desc);
- SERIAL_FLUSH_INPUT (desc);
+ serial_flush_input (desc);
return desc;
}
int ch;
char s[10];
- ch = SERIAL_READCHAR (desc, timeout);
+ ch = serial_readchar (desc, timeout);
switch (ch)
{
{
char s[10];
- SERIAL_WRITE (desc, buf, len);
+ serial_write (desc, buf, len);
if (remote_debug > 0)
{
while (len-- > 0)
if (!remote_desc)
return;
- SERIAL_CLOSE (remote_desc);
+ serial_close (remote_desc);
remote_desc = NULL;
}
bfd_get_section_contents (abfd, s, buf, i, numbytes);
- SERIAL_WRITE (desc, buf, numbytes);
+ serial_write (desc, buf, numbytes);
if (hashmark)
{
gdb_flush (gdb_stderr);
/* 3. The system-level buffer. */
- SERIAL_DRAIN_OUTPUT (gdb_stdout_serial);
- SERIAL_UN_FDOPEN (gdb_stdout_serial);
+ serial_drain_output (gdb_stdout_serial);
+ serial_un_fdopen (gdb_stdout_serial);
annotate_error_begin ();
{
int c;
- c = SERIAL_READCHAR (desc, timeout);
+ c = serial_readchar (desc, timeout);
if (remote_debug > 0)
fputc_unfiltered (c, gdb_stdlog);
{
int c;
- SERIAL_WRITE (desc, packet, pktlen);
+ serial_write (desc, packet, pktlen);
c = readchar (desc, 3);
switch (c)
}
}
- SERIAL_WRITE (desc, "\004", 1); /* Send an EOT */
+ serial_write (desc, "\004", 1); /* Send an EOT */
error ("xmodem_send_packet: Excessive retries.");
}
{
int c;
- SERIAL_WRITE (desc, "\004", 1); /* Send an EOT */
+ serial_write (desc, "\004", 1); /* Send an EOT */
c = readchar (desc, 3);
switch (c)
projects / external / binutils.git / commitdiff