* Makefile.in: Add mswin to SUBDIRS. Add rules for

	mswin/libwingdb.a and remote-wiggler.o.
	* breakpoint.c (breakpoint_here_p):  Clean up bp enabled test.
	* (breakpoint_inserted_here_p):  New func, just like
	breakpoint_here_p, except it's honest.  Honestly.
	* breakpoint.h:  Proto for above.
start-sanitize-gdbtk
	* configure configure.in:  Add host *windows* to list of hosts
	that don't support GDBtk.
end-sanitize-gdbtk
	* configure configure.in:  Add mswin to configdirs if host is
	i[3456]86-*-windows.
	* core-aout.c (fetch_core_registers register_addr) gdbcore.h:
	Change all vars that can contain addresses to type CORE_ADDR.
	* findvar.c (supply_register):  Allow val to be NULL.  This means
	that regno is unsupported.
	* (read_pc read_pc_pid write_pc write_pc_pid):  Make non-pid forms
	just call pid forms with inferior_pid so that there's only once
	place to hack PC's and such.
	* infrun.c (proceed):  Don't skip breakpoints if user changed PC.
	* remote-wiggler.c:  New file.  Support for BDM interface from
	Macraigor Systems.
	* serial.c:  Enhance serial logging capability.  Add hex and octal
	output modes (set remotelogbase {hex|octal|ascii}.  Also log
	breaks, timeouts, errors, and eofs.
	* serial.h:  Redefine SERIAL_SEND_BREAK to go through a wrapper
	function so that we can log breaks.  Don't export serial_logfile
	or serial_logfp.
	* top.c (execute_command):  Don't test for serial_logfp here.
	Just call serial_log_comand, and let serial.c sort it out.
	* valops.c (value_of_variable):  Don't attempt to establish frames
	for static and global variables.  This makes things work a bit
	better if the stack or frame pointer is trashed.
	* config/m68k/monitor.mt (TDEPFILES):  Add remote-wiggler.o.
	* config/m68k/tm-m68k.h:  Define STACK_ALIGN.  CPU32 can't hack
	misaligned stacks during function calls.

1 files changed, 86 insertions, 19 deletions

diff --git a/gdb/serial.c b/gdb/serial.c
index 151881a..c30fda6 100644
--- a/gdb/serial.c
+++ b/gdb/serial.c
@@ -38,11 +38,16 @@ static serial_t scb_base;
 /* 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));
+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;
 
 
 static int serial_reading = 0;
@@ -52,6 +57,9 @@ void
 serial_log_command (cmd)
      const char *cmd;
 {
+  if (!serial_logfp)
+    return;
+
   if (serial_reading || serial_writing)
     {
       fputc_unfiltered ('\n', serial_logfp);
@@ -64,21 +72,50 @@ serial_log_command (cmd)
   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_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;
-    }
+    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
@@ -98,13 +135,12 @@ serial_write (scb, str, len)
 	}
       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. */
@@ -130,11 +166,10 @@ serial_readchar (scb, timeout)
 	}
       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);
@@ -142,6 +177,30 @@ serial_readchar (scb, timeout)
   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;
@@ -471,6 +530,8 @@ serial_printf (va_alist)
 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\
@@ -484,4 +545,10 @@ This file is used to record the remote session for future playback\n\
 by gdbserver.", &setlist),
 		     &showlist);
 
+  add_show_from_set (add_set_enum_cmd ("remotelogbase", no_class,
+				       logbase_enums,
+				       (char *)&serial_logbase,
+				       "Set ...",
+				       &setlist),
+			   &showlist);
 }