Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "defs.h"
+#include <ctype.h>
#include "serial.h"
#include "gdb_string.h"
#include "gdbcmd.h"
+/*#define DEBUGIFY*/
+#include "debugify.h"
+
+
/* Linked list of serial I/O handlers */
static struct serial_ops *serial_ops_list = NULL;
/* Non-NULL gives filename which contains a recording of the remote session,
suitable for playback by gdbserver. */
-char *serial_logfile = NULL;
-FILE *serial_logfp = NULL;
+static char *serial_logfile = NULL;
+static FILE *serial_logfp = NULL;
+
+static struct serial_ops *serial_interface_lookup PARAMS ((char *));
+static void serial_logchar PARAMS ((int ch, int timeout));
+static char logbase_hex[] = "hex";
+static char logbase_octal[] = "octal";
+static char logbase_ascii[] = "ascii";
+static char *logbase_enums[] = {logbase_hex, logbase_octal, logbase_ascii, NULL};
+static char *serial_logbase = logbase_ascii;
\f
static int serial_reading = 0;
serial_log_command (cmd)
const char *cmd;
{
+ if (!serial_logfp)
+ return;
+
if (serial_reading || serial_writing)
{
- fputc ('\n', serial_logfp);
+ fputc_unfiltered ('\n', serial_logfp);
serial_reading = 0;
serial_writing = 0;
}
- fprintf (serial_logfp, "c %s\n", cmd);
+ fprintf_unfiltered (serial_logfp, "c %s\n", cmd);
/* Make sure that the log file is as up-to-date as possible,
in case we are getting ready to dump core or something. */
fflush (serial_logfp);
}
+/* Define bogus char to represent a BREAK. Should be careful to choose a value
+ that can't be confused with a normal char, or an error code. */
+#define SERIAL_BREAK 1235
+
static void
-serial_logchar (ch)
+serial_logchar (ch, timeout)
int ch;
+ int timeout;
{
+ if (serial_logbase != logbase_ascii)
+ fputc_unfiltered (' ', serial_logfp);
+
switch (ch)
{
- case '\\': fputs ("\\\\", serial_logfp); break;
- case '\b': fputs ("\\b", serial_logfp); break;
- case '\f': fputs ("\\f", serial_logfp); break;
- case '\n': fputs ("\\n", serial_logfp); break;
- case '\r': fputs ("\\r", serial_logfp); break;
- case '\t': fputs ("\\t", serial_logfp); break;
- case '\v': fputs ("\\v", serial_logfp); break;
- default: fprintf (serial_logfp, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF); break;
- }
+ case SERIAL_TIMEOUT:
+ fprintf_unfiltered (serial_logfp, "<Timeout: %d seconds>", timeout);
+ return;
+ case SERIAL_ERROR:
+ fprintf_unfiltered (serial_logfp, "<Error: %s>", safe_strerror (errno));
+ return;
+ case SERIAL_EOF:
+ fputs_unfiltered ("<Eof>", serial_logfp);
+ return;
+ case SERIAL_BREAK:
+ fputs_unfiltered ("<Break>", serial_logfp);
+ return;
+ default:
+ if (serial_logbase == logbase_hex)
+ fprintf_unfiltered (serial_logfp, "%02x", ch & 0xff);
+ else if (serial_logbase == logbase_octal)
+ fprintf_unfiltered (serial_logfp, "%03o", ch & 0xff);
+ else
+ switch (ch)
+ {
+ case '\\': fputs_unfiltered ("\\\\", serial_logfp); break;
+ case '\b': fputs_unfiltered ("\\b", serial_logfp); break;
+ case '\f': fputs_unfiltered ("\\f", serial_logfp); break;
+ case '\n': fputs_unfiltered ("\\n", serial_logfp); break;
+ case '\r': fputs_unfiltered ("\\r", serial_logfp); break;
+ case '\t': fputs_unfiltered ("\\t", serial_logfp); break;
+ case '\v': fputs_unfiltered ("\\v", serial_logfp); break;
+ default: fprintf_unfiltered (serial_logfp, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF); break;
+ }
+ }
}
int
{
if (serial_reading)
{
- fputc ('\n', serial_logfp);
+ fputc_unfiltered ('\n', serial_logfp);
serial_reading = 0;
}
if (!serial_writing)
{
- serial_logchar ('w');
- serial_logchar (' ');
+ fputs_unfiltered ("w ", serial_logfp);
serial_writing = 1;
}
for (count = 0; count < len; count++)
{
- serial_logchar (str[count]);
+ serial_logchar (str[count] & 0xff, 0);
}
/* Make sure that the log file is as up-to-date as possible,
in case we are getting ready to dump core or something. */
{
if (serial_writing)
{
- fputc ('\n', serial_logfp);
+ fputc_unfiltered ('\n', serial_logfp);
serial_writing = 0;
}
if (!serial_reading)
{
- serial_logchar ('r');
- serial_logchar (' ');
+ fputs_unfiltered ("r ", serial_logfp);
serial_reading = 1;
}
- serial_logchar (ch);
+ serial_logchar (ch, timeout);
/* Make sure that the log file is as up-to-date as possible,
in case we are getting ready to dump core or something. */
fflush (serial_logfp);
return (ch);
}
+int
+serial_send_break (scb)
+ serial_t scb;
+{
+ if (serial_logfp != NULL)
+ {
+ if (serial_reading)
+ {
+ fputc_unfiltered ('\n', serial_logfp);
+ serial_reading = 0;
+ }
+ if (!serial_writing)
+ {
+ fputs_unfiltered ("w ", serial_logfp);
+ serial_writing = 1;
+ }
+ serial_logchar (SERIAL_BREAK, 0);
+ /* Make sure that the log file is as up-to-date as possible,
+ in case we are getting ready to dump core or something. */
+ fflush (serial_logfp);
+ }
+ return (scb -> ops -> send_break (scb));
+}
+
static struct serial_ops *
serial_interface_lookup (name)
char *name;
{
struct serial_ops *ops;
+ DBG(("serial_interface_lookup(%s)\n",name));
for (ops = serial_ops_list; ops; ops = ops->next)
if (strcmp (name, ops->name) == 0)
return ops;
+ DBG(("serial_interface_lookup: %s not found!\n",name));
return NULL;
}
serial_t scb;
struct serial_ops *ops;
+ DBG(("serial_open\n"));
for (scb = scb_base; scb; scb = scb->next)
if (scb->name && strcmp (scb->name, name) == 0)
{
scb->refcnt++;
+ DBG(("serial_open: scb %s found\n", name));
return scb;
}
ops = serial_interface_lookup ("hardwire");
if (!ops)
+ {
+ DBG(("serial_open: !ops; returning NULL\n"));
return NULL;
+ }
scb = (serial_t)xmalloc (sizeof (struct _serial_t));
if (scb->ops->open(scb, name))
{
free (scb);
+ DBG(("serial_open: scb->ops->open failed!\n"));
return NULL;
}
serial_logfp = fopen (serial_logfile, "w");
if (serial_logfp == NULL)
{
+ DBG(("serial_open: unable to open serial logfile %s!\n",serial_logfile));
perror_with_name (serial_logfile);
}
}
+ DBG(("serial_open: Done! :-)\n"));
return scb;
}
{
serial_t scb;
struct serial_ops *ops;
+ DBG(("serial_fdopen\n"));
for (scb = scb_base; scb; scb = scb->next)
if (scb->fd == fd)
{
if (serial_reading || serial_writing)
{
- fputc ('\n', serial_logfp);
+ fputc_unfiltered ('\n', serial_logfp);
serial_reading = 0;
serial_writing = 0;
}
char cur_esc = 0;
serial_ttystate ttystate;
serial_t port_desc; /* TTY port */
+ DBG(("connect_command\n"));
dont_repeat();
void
_initialize_serial ()
{
+ struct cmd_list_element *cmd;
+
#if 0
add_com ("connect", class_obscure, connect_command,
"Connect the terminal directly up to the command monitor.\n\
by gdbserver.", &setlist),
&showlist);
+ add_show_from_set (add_set_enum_cmd ("remotelogbase", no_class,
+ logbase_enums,
+ (char *)&serial_logbase,
+ "Set ...",
+ &setlist),
+ &showlist);
}
projects / binutils-gdb.git / blobdiff