diff --git a/debugger/README b/debugger/README
index 02cad9b..412b7e8 100644
--- a/debugger/README
+++ b/debugger/README
@@ -1,8 +1,7 @@
-	This is the core of the Wine debugger.  Many pieces have been
-shamelessly stolen - the reverse assember was stolen from Mach more or
-less intact.  It turns out that there are two variables that are set
-differently if you are reverse assembling 16 bit code, and on the
-whole it seems to work.
+	This is the core of the Wine debugger.  The reverse assember
+was stolen from Mach more or less intact.  It turns out that there are
+two variables that are set differently if you are reverse assembling
+16 bit code, and on the whole it seems to work.
 
 NEWS:
 
@@ -63,6 +62,16 @@
 automatic display expressions.  An example is at the end of this file.  The
 syntax and usage should be identical to that of gdb.
 
+	8) Type casts can be made from within the debugger, but they currently
+don't work with typedef'ed types.  They only work with builtin types and
+named structures unions, etc.  The problem is that internally we don't always
+record the typedefed names of structures, so we have no guarantee that we
+would know what each type is.  This can be fixed, of course -  it just takes
+more memory.  Note that in some cases, typedefed structures could be cast
+using '(struct typedfname)' instead of '(typedfname)'.   Technically this
+isn't quite correct, but if and when the rest of this stuff gets fixed,
+this would need to get corrected too.
+
 NOTES:
 
 	If it weren't for the fact that gdb doesn't grok the Win32 debug
@@ -73,16 +82,6 @@
 
 LIMITATIONS AND DIFFERENCES FROM GDB:
 
-	You cannot use type casts in expressions that you give to the
-debugger.  The hardest part about adding support for this is fixing
-the parser/lexer to know when it is handling a type cast, and when it
-is handling any other type of parenthesized expression.  With lexer
-states, it may be possible to keep track of what we would expect at
-any given moment, but it would be tedious to go through and make sure
-that the state is set up correctly for all of the different operators
-and characters that we accept, and I am not yet convinced that this would
-even work.
-
 	You cannot set a breakpoint by file and line number as you can
 with gdb.  Adding support for this wouldn't be all that tough, I guess, but
 it would be a nuisance.   You can set a breakpoint given a function and
@@ -348,11 +347,6 @@
 	You can use the set command to set more or less anything.  Note
 however that you cannot use enumerated types on the RHS of the expression.
 
-	Finally, type casts are not yet supported in the expression
-handling.  There is sufficient information stored internally to be
-able to handle this - the main challenge is that the parser would
-need to be fixed to correctly parse the type cast.
-
 *******************************************************************
 
 
diff --git a/debugger/TODO b/debugger/TODO
index 3544b12..c527b922 100644
--- a/debugger/TODO
+++ b/debugger/TODO
@@ -3,10 +3,9 @@
 possible to me right now.   In no particular order.  If someone else
 wants to dig in, feel free.
 
-1) Some kind of watchpoint capability.  Pretty easy once we have a
-	single step capability, but we end up running the program
-	really slowly one instruction at a time.  Use hardware debug
-	registers for this???
+1) Some kind of watchpoint capability.  Pretty easy, but we end up
+        running the program really slowly one instruction at a time.  
+	Use hardware debug registers for this (much harder)???
 
 2) Some kind of .wdbinit file.
 
@@ -31,14 +30,6 @@
 8) Some of the newer displays are still a little bit sparse on information.
 	Make these more like gdb.
 
-9) Don't bother to disassemble an instruction when we stop at a breakpoint
-	and if we have a valid source line we are displaying.
-
-10) Add support for '/i', etc in display command.  Make sure 'display/i $eip'
-	does the correct thing, and then skip automatic disassembly completely.
-
-11)	Limit amount of information displayed with print command.
-
-12)	Make sure operator precedence works OK.
+9) Make sure operator precedence works OK.
 
 ****************
diff --git a/debugger/break.c b/debugger/break.c
index 5cf164f..d84427d 100644
--- a/debugger/break.c
+++ b/debugger/break.c
@@ -252,6 +252,13 @@
         fprintf( stderr, "Invalid breakpoint number %d\n", num );
         return;
     }
+
+    if( breakpoints[num].condition != NULL )
+      {
+	DEBUG_FreeExpr(breakpoints[num].condition);
+	breakpoints[num].condition = NULL;
+      }
+
     breakpoints[num].enabled = FALSE;
     breakpoints[num].in_use  = FALSE;
     breakpoints[num].skipcount = 0;
diff --git a/debugger/dbg.y b/debugger/dbg.y
index 8db0885..f79a3ff 100644
--- a/debugger/dbg.y
+++ b/debugger/dbg.y
@@ -41,6 +41,7 @@
     int              integer;
     struct list_id   listing;
     struct expr *    expression;
+    struct datatype * type;
 }
 
 %token tCONT tSTEP tLIST tNEXT tQUIT tHELP tBACKTRACE tINFO tWALK tUP tDOWN
@@ -48,12 +49,15 @@
 %token tCLASS tMODULE tSTACK tSEGMENTS tREGS tWND tQUEUE tLOCAL
 %token tEOL tSTRING
 %token tFRAME tSHARE tCOND tDISPLAY tUNDISPLAY
-%token tSTEPI tNEXTI tFINISH tSHOW tDIR 
+%token tSTEPI tNEXTI tFINISH tSHOW tDIR
 %token <string> tPATH
 %token <string> tIDENTIFIER tSTRING
 %token <integer> tNUM tFORMAT
 %token <reg> tREG
 
+%token tCHAR tSHORT tINT tLONG tFLOAT tDOUBLE tUNSIGNED tSIGNED 
+%token tSTRUCT tUNION tENUM
+
 /* %left ',' */
 /* %left '=' OP_OR_EQUAL OP_XOR_EQUAL OP_AND_EQUAL OP_SHL_EQUAL \
          OP_SHR_EQUAL OP_PLUS_EQUAL OP_MINUS_EQUAL \
@@ -66,14 +70,15 @@
 %left '&'
 %left OP_EQ OP_NE
 %left '<' '>' OP_LE OP_GE
-%left OP_SHL OP_SHR OP_DRF
+%left OP_SHL OP_SHR
 %left '+' '-'
 %left '*' '/' '%'
 %left OP_SIGN '!' '~' OP_DEREF /* OP_INC OP_DEC OP_ADDR */
-%left '.' '['
+%left '.' '[' OP_DRF
 %nonassoc ':'
 
-%type <expression> expr lval lvalue
+%type <expression> expr lval lvalue 
+%type <type> type_cast type_expr
 %type <address> expr_addr lval_addr
 %type <integer> expr_value
 %type <string> pathname
@@ -129,7 +134,9 @@
     | tSHOW tDIR tEOL	       { DEBUG_ShowDir(); }
     | tDIR pathname tEOL       { DEBUG_AddPath( $2 ); }
     | tDIR tEOL		       { DEBUG_NukePath(); }
-    | tDISPLAY expr tEOL       { DEBUG_AddDisplay($2); }
+    | tDISPLAY tEOL	       { DEBUG_InfoDisplay(); }
+    | tDISPLAY expr tEOL       { DEBUG_AddDisplay($2, 1, 0); }
+    | tDISPLAY tFORMAT expr tEOL { DEBUG_AddDisplay($3, $2 >> 8, $2 & 0xff); }
     | tDELETE tDISPLAY tNUM tEOL { DEBUG_DelDisplay( $3 ); }
     | tDELETE tDISPLAY tEOL    { DEBUG_DelDisplay( -1 ); }
     | tUNDISPLAY tNUM tEOL     { DEBUG_DelDisplay( $2 ); }
@@ -257,6 +264,30 @@
     | tWALK tWND tEOL           { WIN_WalkWindows( 0, 0 ); }
     | tWALK tWND tNUM tEOL      { WIN_WalkWindows( $3, 0 ); }
 
+
+type_cast: 
+      '(' type_expr ')'		{ $$ = $2; }
+
+type_expr:
+      type_expr '*'		{ $$ = DEBUG_FindOrMakePointerType($1); }
+    |  tINT			{ $$ = DEBUG_TypeCast(BASIC, "int"); }
+    | tCHAR			{ $$ = DEBUG_TypeCast(BASIC, "char"); }
+    | tLONG tINT		{ $$ = DEBUG_TypeCast(BASIC, "long int"); }
+    | tUNSIGNED tINT		{ $$ = DEBUG_TypeCast(BASIC, "unsigned int"); }
+    | tLONG tUNSIGNED tINT	{ $$ = DEBUG_TypeCast(BASIC, "long unsigned int"); }
+    | tLONG tLONG tINT		{ $$ = DEBUG_TypeCast(BASIC, "long long int"); }
+    | tLONG tLONG tUNSIGNED tINT { $$ = DEBUG_TypeCast(BASIC, "long long unsigned int"); }
+    | tSHORT tINT		{ $$ = DEBUG_TypeCast(BASIC, "short int"); }
+    | tSHORT tUNSIGNED tINT	{ $$ = DEBUG_TypeCast(BASIC, "short unsigned int"); }
+    | tSIGNED tCHAR		{ $$ = DEBUG_TypeCast(BASIC, "signed char"); }
+    | tUNSIGNED tCHAR		{ $$ = DEBUG_TypeCast(BASIC, "unsigned char"); }
+    | tFLOAT			{ $$ = DEBUG_TypeCast(BASIC, "float"); }
+    | tDOUBLE			{ $$ = DEBUG_TypeCast(BASIC, "double"); }
+    | tLONG tDOUBLE		{ $$ = DEBUG_TypeCast(BASIC, "long double"); }
+    | tSTRUCT tIDENTIFIER	{ $$ = DEBUG_TypeCast(STRUCT, $2); }
+    | tUNION tIDENTIFIER	{ $$ = DEBUG_TypeCast(STRUCT, $2); }
+    | tENUM tIDENTIFIER		{ $$ = DEBUG_TypeCast(ENUM, $2); }
+
 expr_addr:
     expr			 { $$ = DEBUG_EvalExpr($1) }
 
@@ -310,6 +341,7 @@
     | '(' expr ')'               { $$ = $2; }
     | '*' expr %prec OP_DEREF    { $$ = DEBUG_UnopExpr(EXP_OP_DEREF, $2); }
     | '&' expr %prec OP_DEREF    { $$ = DEBUG_UnopExpr(EXP_OP_ADDR, $2); }
+    | type_cast expr %prec OP_DEREF { $$ = DEBUG_TypeCastExpr($1, $2); } 
 	
 /*
  * The lvalue rule builds an expression tree.  This is a limited form
@@ -460,15 +492,18 @@
 	    DEBUG_SilentBackTrace();
 	}
 
-        /* Show where we crashed */
-        curr_frame = 0;
-        DEBUG_PrintAddress( &addr, dbg_mode, TRUE );
-        fprintf(stderr,":  ");
-        if (DBG_CHECK_READ_PTR( &addr, 1 ))
-        {
-            DEBUG_Disasm( &addr, TRUE );
-            fprintf(stderr,"\n");
-        }
+	if( signal != SIGTRAP )
+	  {
+	    /* Show where we crashed */
+	    curr_frame = 0;
+	    DEBUG_PrintAddress( &addr, dbg_mode, TRUE );
+	    fprintf(stderr,":  ");
+	    if (DBG_CHECK_READ_PTR( &addr, 1 ))
+	      {
+		DEBUG_Disasm( &addr, TRUE );
+		fprintf(stderr,"\n");
+	      }
+	  }
 
         ret_ok = 0;
         do
diff --git a/debugger/dbgmain.c b/debugger/dbgmain.c
index 9d3fb8c..7c1992b 100644
--- a/debugger/dbgmain.c
+++ b/debugger/dbgmain.c
@@ -6,15 +6,16 @@
 #include <signal.h>
 
 #include <ldt.h>
-#include <windows.h>
-#include <toolhelp.h>
-#include <module.h>
-#include <debugger.h>
-#include <class.h>
+#include "windows.h"
+#include "toolhelp.h"
+#include "module.h"
+#include "debugger.h"
+#include "class.h"
 #include <X11/Xlib.h>
 
 #include "debugger.h"
 #include "peexe.h"
+#include "pe_image.h"
 
 ldt_copy_entry ldt_copy[LDT_SIZE];
 unsigned char ldt_flags_copy[LDT_SIZE];
@@ -171,7 +172,7 @@
 	int				  dbg_size;
 	struct PE_Debug_dir		* dbgdir;
 	struct pe_data			* pe;
-        struct pe_segment_table         * sectp;
+        LPIMAGE_SECTION_HEADER            sectp;
 	int				  nsect;
 	short int			  dbg_index;			
 	char				  loaded;
@@ -190,7 +191,7 @@
   struct deferred_debug_info deefer;
   struct PE_Debug_dir	dinfo;
   struct CodeViewDebug cdebug;
-  struct pe_segment_table sects[10];
+  IMAGE_SECTION_HEADER  sects[10];
 
   memset(&deefer, 0, sizeof(deefer));
   memset(&dinfo, 0, sizeof(dinfo));
@@ -201,7 +202,7 @@
   dinfo.timestamp = 812932395;
   cdebug.cv_timestamp = 833392137  /* 841951397 */;
   deefer.dbgdir = &dinfo;
-  deefer.sectp = &sects;
+  deefer.sectp = sects;
   deefer.nsect = 10;
 
   DEBUG_InitTypes();
diff --git a/debugger/debug.l b/debugger/debug.l
index 5f6cce2..d33b4c0 100644
--- a/debugger/debug.l
+++ b/debugger/debug.l
@@ -113,7 +113,7 @@
 <INITIAL>list|lis|li|l			{ BEGIN(PATH_EXPECTED); return tLIST; }
 <INITIAL>enable|enabl|enab|ena		{ BEGIN(NOCMD); return tENABLE;}
 <INITIAL>disable|disabl|disab|disa|dis	{ BEGIN(NOCMD); return tDISABLE; }
-<INITIAL,INFO_CMD,DEL_CMD>display|displa|displ|disp	{ BEGIN(NOCMD); return tDISPLAY; }
+<INITIAL,INFO_CMD,DEL_CMD>display|displa|displ|disp	{ BEGIN(FORMAT_EXPECTED); return tDISPLAY; }
 <INITIAL>undisplay|undispla|undispl|undisp|undis|undi|und	{ BEGIN(NOCMD); return tUNDISPLAY; }
 <INITIAL>delete|delet|dele|del		{ BEGIN(DEL_CMD); return tDELETE; }
 <INITIAL>quit|qui|qu|q			{ BEGIN(NOCMD); return tQUIT; }
@@ -155,11 +155,22 @@
 <INITIAL,SHOW_CMD>directories|directorie|directori|director|directo|direct|direc|direc|dir { 
 			BEGIN(PATH_EXPECTED); return tDIR; }
 
+char					{ return tCHAR; }
+short					{ return tSHORT; }
+int					{ return tINT; }
+long					{ return tLONG; }
+float					{ return tFLOAT; }
+double					{ return tDOUBLE; }
+unsigned				{ return tUNSIGNED; }
+signed					{ return tSIGNED; }
+struct					{ return tSTRUCT; }
+union					{ return tUNION; }
+enum					{ return tENUM; }
+
 {IDENTIFIER}	{ yylval.string = make_symbol(yytext); return tIDENTIFIER; }
 
 <PATH_EXPECTED>{PATHNAME}	{ yylval.string = make_symbol(yytext); return tPATH; }
 
-
 [ \t]+        /* Eat up whitespace */
 
 .		{ if (syntax_error == 0)
diff --git a/debugger/display.c b/debugger/display.c
index b170026..fd7e8c6 100644
--- a/debugger/display.c
+++ b/debugger/display.c
@@ -20,10 +20,18 @@
 #include <stdarg.h>
 
 #define MAX_DISPLAY 25
-static struct expr * displaypoints[MAX_DISPLAY];
+
+struct display
+{
+  struct expr *	exp;
+  int		count;
+  char		format;
+};
+
+static struct display displaypoints[MAX_DISPLAY];
 
 int
-DEBUG_AddDisplay(struct expr * exp)
+DEBUG_AddDisplay(struct expr * exp, int count, char format)
 {
   int i;
 
@@ -32,9 +40,11 @@
    */
   for(i=0; i < MAX_DISPLAY; i++ )
     {
-      if( displaypoints[i] == NULL )
+      if( displaypoints[i].exp == NULL )
 	{
-	  displaypoints[i] = DEBUG_CloneExpr(exp);
+	  displaypoints[i].exp = DEBUG_CloneExpr(exp);
+	  displaypoints[i].count  = count;
+	  displaypoints[i].format = format;
 	  break;
 	}
     }
@@ -52,10 +62,10 @@
    */
   for(i=0; i < MAX_DISPLAY; i++ )
     {
-      if( displaypoints[i] != NULL )
+      if( displaypoints[i].exp != NULL )
 	{
 	  fprintf(stderr, "%d : ", i+1);
-	  DEBUG_DisplayExpr(displaypoints[i]);
+	  DEBUG_DisplayExpr(displaypoints[i].exp);
 	  fprintf(stderr, "\n");
 	}
     }
@@ -74,22 +84,33 @@
    */
   for(i=0; i < MAX_DISPLAY; i++ )
     {
-      if( displaypoints[i] != NULL )
+      if( displaypoints[i].exp != NULL )
 	{
-	  addr = DEBUG_EvalExpr(displaypoints[i]);
+	  addr = DEBUG_EvalExpr(displaypoints[i].exp);
 	  if( addr.type == NULL )
 	    {
 	      fprintf(stderr, "Unable to evaluate expression ");
-	      DEBUG_DisplayExpr(displaypoints[i]);
+	      DEBUG_DisplayExpr(displaypoints[i].exp);
 	      fprintf(stderr, "\nDisabling...\n");
 	      DEBUG_DelDisplay(i);
 	    }
 	  else
 	    {
 	      fprintf(stderr, "%d  : ", i + 1);
-	      DEBUG_DisplayExpr(displaypoints[i]);
+	      DEBUG_DisplayExpr(displaypoints[i].exp);
 	      fprintf(stderr, " = ");
-	      DEBUG_Print( &addr, 1, 0, 0);
+	      if( displaypoints[i].format == 'i' )
+		{
+		  DEBUG_ExamineMemory( &addr, 
+			       displaypoints[i].count, 
+			       displaypoints[i].format);
+		}
+	      else
+		{
+		  DEBUG_Print( &addr, 
+			       displaypoints[i].count, 
+			       displaypoints[i].format, 0);
+		}
 	    }
 	}
     }
@@ -111,17 +132,17 @@
     {
       for(i=0; i < MAX_DISPLAY; i++ )
 	{
-	  if( displaypoints[i] != NULL )
+	  if( displaypoints[i].exp != NULL )
 	    {
-	      DEBUG_FreeExpr(displaypoints[i]);
-	      displaypoints[i] = NULL;
+	      DEBUG_FreeExpr(displaypoints[i].exp);
+	      displaypoints[i].exp = NULL;
 	    }
 	}
     }
-  else if( displaypoints[displaynum - 1] != NULL )
+  else if( displaypoints[displaynum - 1].exp != NULL )
     {
-      DEBUG_FreeExpr(displaypoints[displaynum - 1]);
-      displaypoints[displaynum - 1] = NULL;
+      DEBUG_FreeExpr(displaypoints[displaynum - 1].exp);
+      displaypoints[displaynum - 1].exp = NULL;
     }
   return TRUE;
 }
diff --git a/debugger/expr.c b/debugger/expr.c
index 4bf78ef..6ef8d37 100644
--- a/debugger/expr.c
+++ b/debugger/expr.c
@@ -70,6 +70,12 @@
 
     struct
     {
+      struct datatype * cast;
+      struct expr     * expr;
+    } cast;
+
+    struct
+    {
       struct expr * exp1;
       const char * element_name;
       int result;
@@ -103,6 +109,7 @@
 #define EXPR_TYPE_ARRAY		8
 #define EXPR_TYPE_CALL		9
 #define EXPR_TYPE_STRING	10
+#define EXPR_TYPE_CAST		11
 
 static char expr_list[4096];
 static int next_expr_free = 0;
@@ -132,6 +139,18 @@
   next_expr_free = 0;
 }
 
+struct expr *
+DEBUG_TypeCastExpr(struct datatype * dt, struct expr * exp)
+{
+  struct expr * ex;
+
+  ex = DEBUG_GetFreeExpr();
+
+  ex->type        = EXPR_TYPE_CAST;
+  ex->un.cast.cast = dt;
+  ex->un.cast.expr = exp;
+  return ex;
+}
 
 struct expr *
 DEBUG_RegisterExpr(enum debug_regs regno)
@@ -294,6 +313,10 @@
 
   switch(exp->type)
     {
+    case EXPR_TYPE_CAST:
+      rtn = DEBUG_EvalExpr(exp->un.cast.expr);
+      rtn.type = exp->un.cast.cast;
+      break;
     case EXPR_TYPE_STRING:
       rtn.type = DEBUG_TypeString;
       rtn.off = (unsigned int) &exp->un.string.str;
@@ -620,6 +643,13 @@
 
   switch(exp->type)
     {
+    case EXPR_TYPE_CAST:
+      fprintf(stderr, "((");
+      DEBUG_PrintTypeCast(exp->un.cast.cast);
+      fprintf(stderr, ")");
+      DEBUG_DisplayExpr(exp->un.cast.expr);
+      fprintf(stderr, ")");
+      break;
     case EXPR_TYPE_REGISTER:
       DEBUG_PrintRegister(exp->un.rgister.reg);
       break;
@@ -780,6 +810,9 @@
 
   switch(exp->type)
     {
+    case EXPR_TYPE_CAST:
+      rtn->un.cast.expr = DEBUG_CloneExpr(exp->un.cast.expr);
+      break;
     case EXPR_TYPE_REGISTER:
     case EXPR_TYPE_US_CONST:
     case EXPR_TYPE_CONST:
@@ -834,6 +867,9 @@
 
   switch(exp->type)
     {
+    case EXPR_TYPE_CAST:
+      DEBUG_FreeExpr(exp->un.cast.expr);
+      break;
     case EXPR_TYPE_REGISTER:
     case EXPR_TYPE_US_CONST:
     case EXPR_TYPE_CONST:
diff --git a/debugger/hash.c b/debugger/hash.c
index 2684ea0..20f3e64 100644
--- a/debugger/hash.c
+++ b/debugger/hash.c
@@ -18,6 +18,9 @@
 #include "xmalloc.h"
 
 #define NR_NAME_HASH 16384
+#ifndef PATH_MAX
+#define PATH_MAX _MAX_PATH
+#endif
 
 static char * reg_name[] =
 {
diff --git a/debugger/info.c b/debugger/info.c
index 6c5f4de..dd5b76a 100644
--- a/debugger/info.c
+++ b/debugger/info.c
@@ -17,10 +17,10 @@
  */
 void DEBUG_PrintBasic( const DBG_ADDR *addr, int count, char format )
 {
-  char * default_format;
+  char        * default_format;
   long long int value;
 
-    if( addr->type == NULL )
+  if( addr->type == NULL )
     {
       fprintf(stderr, "Unable to evaluate expression\n");
       return;
@@ -32,16 +32,22 @@
   switch(format)
     {
     case 'x':
-      if (addr->seg) fprintf( stderr, "0x%04lx", (long unsigned int) value );
-      else fprintf( stderr, "0x%08lx", (long unsigned int) value );
+      if (addr->seg) 
+	{
+	  DEBUG_nchar += fprintf( stderr, "0x%04lx", (long unsigned int) value );
+	}
+      else 
+	{
+	  DEBUG_nchar += fprintf( stderr, "0x%08lx", (long unsigned int) value );
+	}
       break;
       
     case 'd':
-      fprintf( stderr, "%ld\n", (long int) value );
+      DEBUG_nchar += fprintf( stderr, "%ld\n", (long int) value );
       break;
       
     case 'c':
-      fprintf( stderr, "%d = '%c'",
+      DEBUG_nchar += fprintf( stderr, "%d = '%c'",
 	       (char)(value & 0xff), (char)(value & 0xff) );
       break;
       
@@ -53,11 +59,10 @@
     case 0:
       if( default_format != NULL )
 	{
-	  fprintf( stderr, default_format, value );
+	  DEBUG_nchar += fprintf( stderr, default_format, value );
 	}
       break;
     }
-
 }
 
 
diff --git a/debugger/msc.c b/debugger/msc.c
index 1c1817b..90bf0fd 100644
--- a/debugger/msc.c
+++ b/debugger/msc.c
@@ -512,9 +512,9 @@
 	char				* module_name;
 	char				* dbg_info;
 	int				  dbg_size;
-	struct PE_Debug_dir		* dbgdir;
+	LPIMAGE_DEBUG_DIRECTORY           dbgdir;
 	struct pe_data			* pe;
-        struct pe_segment_table         * sectp;
+        LPIMAGE_SECTION_HEADER	          sectp;
 	int				  nsect;
 	short int			  dbg_index;			
 	char				  loaded;
@@ -747,17 +747,24 @@
 	    }
 	  memset(symname, 0, sizeof(symname));
 	  memcpy(symname, type->structure.name, type->structure.namelen);
-	  typeptr = DEBUG_NewDataType(STRUCT, symname);
+	  if( strcmp(symname, "__unnamed") == 0 )
+	    {
+	      typeptr = DEBUG_NewDataType(STRUCT, NULL);
+	    }
+	  else
+	    {
+	      typeptr = DEBUG_NewDataType(STRUCT, symname);
+	    }
 	  cv_defined_types[curr_type - 0x1000] = typeptr;
 
 	  /*
 	   * Now copy the relevant bits from the fieldlist that we specified.
 	   */
 	  subtype = DEBUG_GetCVType(type->structure.fieldlist);
-	  DEBUG_SetStructSize(typeptr, type->structure.structlen);
 
 	  if( subtype != NULL )
 	    {
+	      DEBUG_SetStructSize(typeptr, type->structure.structlen);
 	      DEBUG_CopyFieldlist(typeptr, subtype);
 	    }
 	  break;
@@ -773,17 +780,26 @@
 	    }
 	  memset(symname, 0, sizeof(symname));
 	  memcpy(symname, type->t_union.name, type->t_union.namelen);
-	  typeptr = DEBUG_NewDataType(STRUCT, symname);
+
+	  if( strcmp(symname, "__unnamed") == 0 )
+	    {
+	      typeptr = DEBUG_NewDataType(STRUCT, NULL);
+	    }
+	  else
+	    {
+	      typeptr = DEBUG_NewDataType(STRUCT, symname);
+	    }
+
 	  cv_defined_types[curr_type - 0x1000] = typeptr;
 
 	  /*
 	   * Now copy the relevant bits from the fieldlist that we specified.
 	   */
 	  subtype = DEBUG_GetCVType(type->t_union.field);
-	  DEBUG_SetStructSize(typeptr, type->t_union.un_len);
 
 	  if( subtype != NULL )
 	    {
+	      DEBUG_SetStructSize(typeptr, type->t_union.un_len);
 	      DEBUG_CopyFieldlist(typeptr, subtype);
 	    }
 	  break;
@@ -874,14 +890,14 @@
   int			  has_codeview = FALSE;
   int			  rtn = FALSE;
   int			  orig_size;
-  struct PE_Debug_dir	* dbgptr;
+  LPIMAGE_DEBUG_DIRECTORY dbgptr;
   struct deferred_debug_info * deefer;
 
   orig_size = size;
-  dbgptr = (struct PE_Debug_dir *) (load_addr + v_addr);
+  dbgptr = (LPIMAGE_DEBUG_DIRECTORY) (load_addr + v_addr);
   for(; size > 0; size -= sizeof(*dbgptr), dbgptr++ )
     {
-      switch(dbgptr->type)
+      switch(dbgptr->Type)
 	{
 	case IMAGE_DEBUG_TYPE_CODEVIEW:
 	case IMAGE_DEBUG_TYPE_MISC:
@@ -891,10 +907,10 @@
     }
 
   size = orig_size;
-  dbgptr = (struct PE_Debug_dir *) (load_addr + v_addr);
+  dbgptr = (LPIMAGE_DEBUG_DIRECTORY) (load_addr + v_addr);
   for(; size > 0; size -= sizeof(*dbgptr), dbgptr++ )
     {
-      switch(dbgptr->type)
+      switch(dbgptr->Type)
 	{
 	case IMAGE_DEBUG_TYPE_COFF:
 	  /*
@@ -921,8 +937,8 @@
 	   * means that this entry points to a .DBG file.  Otherwise,
 	   * it just points to itself, and we can ignore this.
 	   */
-	  if(    (dbgptr->type == IMAGE_DEBUG_TYPE_MISC)
-	      && (pe->pe_header->coff.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) == 0 )
+	  if(    (dbgptr->Type == IMAGE_DEBUG_TYPE_MISC)
+	      && (pe->pe_header->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) == 0 )
 	    {
 	      break;
 	    }
@@ -938,9 +954,9 @@
 	   * upon the type, but this is always enough so we are able
 	   * to proceed if we know what we need to do next.
 	   */
-	  deefer->dbg_size = dbgptr->dbgsize;
-	  deefer->dbg_info = (char *) xmalloc(dbgptr->dbgsize);
-	  lseek(fd, dbgptr->dbgoff, SEEK_SET);
+	  deefer->dbg_size = dbgptr->SizeOfData;
+	  deefer->dbg_info = (char *) xmalloc(dbgptr->SizeOfData);
+	  lseek(fd, dbgptr->PointerToRawData, SEEK_SET);
 	  read(fd, deefer->dbg_info, deefer->dbg_size);
 
 	  deefer->load_addr = (char *) load_addr;
@@ -951,7 +967,7 @@
 	  deefer->module_name = xstrdup(DEBUG_curr_module);
 
 	  deefer->sectp = pe->pe_seg;
-	  deefer->nsect = pe->pe_header->coff.NumberOfSections;
+	  deefer->nsect = pe->pe_header->FileHeader.NumberOfSections;
 
 	  dbglist = deefer;
 	  break;
@@ -1538,7 +1554,7 @@
   DBG_ADDR		  new_addr;
   int			  nsect;
   union any_size	  ptr;
-  struct pe_segment_table * sectp;
+  IMAGE_SECTION_HEADER  * sectp;
   union	codeview_symbol	* sym;
   char			  symname[PATH_MAX];
   struct name_hash	* thunk_sym = NULL;
@@ -1601,7 +1617,7 @@
 	  new_addr.seg = 0;
 	  new_addr.type = DEBUG_GetCVType(sym->data.symtype);
 	  new_addr.off = (unsigned int) deefer->load_addr + 
-	    sectp[sym->data.seg - 1].Virtual_Address + 
+	    sectp[sym->data.seg - 1].VirtualAddress + 
 	    sym->data.offset;
 	  DEBUG_AddSymbol( symname, &new_addr, NULL, SYM_WIN32 | SYM_DATA );
 	  break;
@@ -1615,7 +1631,7 @@
 	  new_addr.seg = 0;
 	  new_addr.type = NULL;
 	  new_addr.off = (unsigned int) deefer->load_addr + 
-	    sectp[sym->thunk.segment - 1].Virtual_Address + 
+	    sectp[sym->thunk.segment - 1].VirtualAddress + 
 	    sym->thunk.offset;
 	  thunk_sym = DEBUG_AddSymbol( symname, &new_addr, NULL, 
 				       SYM_WIN32 | SYM_FUNC);
@@ -1630,7 +1646,7 @@
 	  new_addr.seg = 0;
 	  new_addr.type = DEBUG_GetCVType(sym->proc.proctype);
 	  new_addr.off = (unsigned int) deefer->load_addr + 
-	    sectp[sym->proc.segment - 1].Virtual_Address + 
+	    sectp[sym->proc.segment - 1].VirtualAddress + 
 	    sym->proc.offset;
 	  /*
 	   * See if we can find a segment that this goes with.  If so,
@@ -1640,10 +1656,10 @@
 	  for(i=0; linetab[i].linetab != NULL; i++)
 	    {
 	      if(     ((unsigned int) deefer->load_addr 
-		       + sectp[linetab[i].segno - 1].Virtual_Address 
+		       + sectp[linetab[i].segno - 1].VirtualAddress 
 		       + linetab[i].start <= new_addr.off)
 		  &&  ((unsigned int) deefer->load_addr 
-		       + sectp[linetab[i].segno - 1].Virtual_Address 
+		       + sectp[linetab[i].segno - 1].VirtualAddress 
 		       + linetab[i].end > new_addr.off) )
 		{
 		  break;
@@ -2119,8 +2135,8 @@
   int				j;
   struct codeview_linetab_hdr * linetab;
   int				nsect;
-  struct PE_DBG_FileHeader    * pdbg = NULL;
-  struct pe_segment_table     * sectp;
+  LPIMAGE_SEPARATE_DEBUG_HEADER pdbg = NULL;
+  IMAGE_SECTION_HEADER        * sectp;
   struct stat			statbuf;
   int				status;
   
@@ -2148,9 +2164,9 @@
   addr = mmap(0, statbuf.st_size, PROT_READ, 
 	      MAP_PRIVATE, fd, 0);
 
-  pdbg = (struct PE_DBG_FileHeader *) addr;
+  pdbg = (LPIMAGE_SEPARATE_DEBUG_HEADER) addr;
 
-  if( pdbg->TimeDateStamp != deefer->dbgdir->timestamp )
+  if( pdbg->TimeDateStamp != deefer->dbgdir->TimeDateStamp )
     {
       fprintf(stderr, "Warning - %s has incorrect internal timestamp\n",
 	      filename);
@@ -2160,10 +2176,10 @@
   fprintf(stderr, "Processing symbols from %s...\n", filename);
 
   dbghdr = (struct PE_Debug_dir *) (  addr + sizeof(*pdbg) 
-		 + pdbg->NumberOfSections * sizeof(struct pe_segment_table) 
+		 + pdbg->NumberOfSections * sizeof(IMAGE_SECTION_HEADER) 
 		 + pdbg->ExportedNamesSize);
 
-  sectp = (struct pe_segment_table *) ((char *) pdbg + sizeof(*pdbg));
+  sectp = (LPIMAGE_SECTION_HEADER) ((char *) pdbg + sizeof(*pdbg));
   nsect = pdbg->NumberOfSections;
 
   for( i=0; i < pdbg->DebugDirectorySize / sizeof(*pdbg); i++, dbghdr++ )
@@ -2300,7 +2316,7 @@
 	  last_proc = deefer->dbg_index;
 	}
 
-      switch(deefer->dbgdir->type)
+      switch(deefer->dbgdir->Type)
 	{
 	case IMAGE_DEBUG_TYPE_COFF:
 	  /*
diff --git a/debugger/registers.c b/debugger/registers.c
index 7c68f6a..5ed74dd 100644
--- a/debugger/registers.c
+++ b/debugger/registers.c
@@ -188,7 +188,7 @@
 #ifdef GS_sig
     GS_sig(sigcontext)  = GS_reg(&DEBUG_context);
 #else
-    __asm__("movw %w0,%%gs"::"r" (FS_reg(&DEBUG_context)));
+    __asm__("movw %w0,%%gs"::"r" (GS_reg(&DEBUG_context)));
 #endif
 }
 
diff --git a/debugger/source.c b/debugger/source.c
index d80d386..4ece937 100644
--- a/debugger/source.c
+++ b/debugger/source.c
@@ -93,7 +93,7 @@
 }
 
 static
-void
+int
 DEBUG_DisplaySource(char * sourcefile, int start, int end)
 {
   char			      * addr;
@@ -103,6 +103,7 @@
   struct open_filelist	      * ol;
   int				nlines;
   char			      * pnt;
+  int				rtn;
   struct searchlist	      * sl;
   struct stat			statbuf;
   int				status;
@@ -217,7 +218,7 @@
 		  ol->linelist = NULL;
 		  ofiles = ol;
 		  fprintf(stderr,"Unable to open file %s\n", tmppath);
-		  return;
+		  return FALSE;
 		}
 	    }
 	}
@@ -239,13 +240,13 @@
       fd = open(tmppath, O_RDONLY);
       if( fd == -1 )
 	{
-	  return;
+	  return FALSE;
 	}
 
       addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
       if( addr == (char *) -1 )
 	{
-	  return;
+	  return FALSE;
 	}
 
       /*
@@ -285,19 +286,20 @@
       fd = open(ol->real_path, O_RDONLY);
       if( fd == -1 )
 	{
-	  return;
+	  return FALSE;
 	}
       
       addr = mmap(0, ol->size, PROT_READ, MAP_PRIVATE, fd, 0);
       if( addr == (char *) -1 )
 	{
-	  return;
+	  return FALSE;
 	}
     }
   
   /*
    * All we need to do is to display the source lines here.
    */
+  rtn = FALSE;
   for(i=start - 1; i <= end - 1; i++)
     {
       if( i < 0 || i >= ol->nlines - 1)
@@ -305,6 +307,7 @@
 	  continue;
 	}
 
+      rtn = TRUE;
       memset(&buffer, 0, sizeof(buffer));
       if( ol->linelist[i+1] != ol->linelist[i] )
 	{
@@ -317,6 +320,8 @@
   munmap(addr, ol->size);
   close(fd);
 
+  return rtn;
+
 }
 
 void
@@ -324,6 +329,7 @@
 			 int delta)
 {
   int    end;
+  int    rtn;
   int    start;
   char * sourcefile;
 
@@ -406,7 +412,7 @@
   /*
    * Now call this function to do the dirty work.
    */
-  DEBUG_DisplaySource(sourcefile, start, end);
+  rtn = DEBUG_DisplaySource(sourcefile, start, end);
 
   if( sourcefile != (char *) &DEBUG_current_sourcefile )
     {
diff --git a/debugger/stabs.c b/debugger/stabs.c
index 0c1ddf1..a52c467 100644
--- a/debugger/stabs.c
+++ b/debugger/stabs.c
@@ -75,6 +75,44 @@
   unsigned long n_value;
 };
 
+/*
+ * This is used to keep track of known datatypes so that we don't redefine
+ * them over and over again.  It sucks up lots of memory otherwise.
+ */
+struct known_typedef
+{
+  struct known_typedef * next;
+  char		       * name;
+  int			 ndefs;
+  struct datatype      * types[0];
+};
+
+#define NR_STAB_HASH 521
+
+struct known_typedef * ktd_head[NR_STAB_HASH];
+
+static unsigned int stab_hash( const char * name )
+{
+    unsigned int hash = 0;
+    unsigned int tmp;
+    const char * p;
+
+    p = name;
+
+    while (*p) 
+      {
+	hash = (hash << 4) + *p++;
+
+	if( (tmp = (hash & 0xf0000000)) )
+	  {
+	    hash ^= tmp >> 24;
+	  }
+	hash &= ~tmp;
+      }
+    return hash % NR_STAB_HASH;
+}
+
+
 static void stab_strcpy(char * dest, const char * source)
 {
   /*
@@ -89,6 +127,179 @@
   *dest++ = '\0';
 }
 
+#define MAX_TD_NESTING	128
+
+static
+int
+DEBUG_RegisterTypedef(const char * name, struct datatype ** types, int ndef)
+{
+  int			 hash;
+  struct known_typedef * ktd;
+
+  if( ndef == 1 )
+    {
+      return TRUE;
+    }
+
+  ktd = (struct known_typedef *) malloc(sizeof(struct known_typedef) 
+					+ ndef * sizeof(struct datatype *));
+  
+  hash = stab_hash(name);
+
+  ktd->name = xstrdup(name);
+  ktd->ndefs = ndef;
+  memcpy(&ktd->types[0], types, ndef * sizeof(struct datatype *));
+  ktd->next = ktd_head[hash];
+  ktd_head[hash] = ktd;
+
+  return TRUE;
+}
+
+static
+int
+DEBUG_HandlePreviousTypedef(const char * name, const char * stab)
+{
+  int			 count;
+  enum debug_type	 expect;
+  int			 hash;
+  struct known_typedef * ktd;
+  char		       * ptr;
+  char		       * tc;
+  int			 typenum;
+
+  hash = stab_hash(name);
+
+  for(ktd = ktd_head[hash]; ktd; ktd = ktd->next)
+    {
+      if(    (ktd->name[0] == name[0])
+	  && (strcmp(name, ktd->name) == 0) )
+	{
+	  break;
+	}
+    }
+
+  /*
+   * Didn't find it.  This must be a new one.
+   */
+  if( ktd == NULL )
+    {
+      return FALSE;
+    }
+
+  /*
+   * Examine the stab to make sure it has the same number of definitions.
+   */
+  count = 0;
+  for(ptr = strchr(stab, '='); ptr; ptr = strchr(ptr+1, '='))
+    {
+      if( count >= ktd->ndefs )
+	{
+	  return FALSE;
+	}
+
+      /*
+       * Make sure the types of all of the objects is consistent with
+       * what we have already parsed.
+       */
+      switch(ptr[1])
+	{
+	case '*':
+	  expect = POINTER;
+	  break;
+	case 's':
+	case 'u':
+	  expect = STRUCT;
+	  break;
+	case 'a':
+	  expect = ARRAY;
+	  break;
+	case '1':
+	case 'r':
+	  expect = BASIC;
+	  break;
+	case 'x':
+	  expect = STRUCT;
+	  break;
+	case 'e':
+	  expect = ENUM;
+	  break;
+	case 'f':
+	  expect = FUNC;
+	  break;
+	default:
+	  fprintf(stderr, "Unknown type.\n");
+          return FALSE;
+	}
+      if( expect != DEBUG_GetType(ktd->types[count]) )
+	{
+	  return FALSE;
+	}
+      count++;
+    }
+
+  if( ktd->ndefs != count )
+    {
+      return FALSE;
+    }
+
+  /*
+   * OK, this one is safe.  Go through, dig out all of the type numbers,
+   * and substitute the appropriate things.
+   */
+  count = 0;
+  for(ptr = strchr(stab, '='); ptr; ptr = strchr(ptr+1, '='))
+    {
+      /*
+       * Back up until we get to a non-numeric character.  This is the type
+       * number.
+       */
+      tc = ptr - 1;
+      while( *tc >= '0' && *tc <= '9' )
+	{
+	  tc--;
+	}
+      
+      typenum = atol(tc + 1);
+      if( num_stab_types <= typenum )
+	{
+	  num_stab_types = typenum + 32;
+	  stab_types = (struct datatype **) xrealloc(stab_types, 
+						     num_stab_types * sizeof(struct datatype *));
+	  if( stab_types == NULL )
+	    {
+	      return FALSE;
+	    }
+	}
+
+      stab_types[typenum] = ktd->types[count++];
+    }
+
+  return TRUE;
+}
+
+static int DEBUG_FreeRegisteredTypedefs()
+{
+  int			 count;
+  int			 j;
+  struct known_typedef * ktd;
+  struct known_typedef * next;
+
+  count = 0;
+  for(j=0; j < NR_STAB_HASH; j++ )
+    {
+      for(ktd = ktd_head[j]; ktd; ktd = next)
+	{
+	  count++;
+	  next = ktd->next;
+	  free(ktd->name);
+	  free(ktd);
+	}  
+      ktd_head[j] = NULL;
+    }
+
+  return TRUE;
+
+}
 
 static 
 int
@@ -96,21 +307,33 @@
 {
   int		    arrmax;
   int		    arrmin;
-  char * c;
+  char		  * c;
   struct datatype * curr_type;
   struct datatype * datatype;
+  struct datatype * curr_types[MAX_TD_NESTING];
   char	            element_name[1024];
+  int		    ntypes = 0;
   int		    offset;
+  const char	  * orig_typename;
   int		    rtn = FALSE;
   int		    size;
   char		  * tc;
   char		  * tc2;
   int		    typenum;
 
-  /*
-   * Go from back to front.  First we go through and figure out what type numbers
-   * we need, and register those types.  Then we go in and fill the details.
+  orig_typename = typename;
+
+  if( DEBUG_HandlePreviousTypedef(typename, ptr) == TRUE )
+    {
+      return TRUE;
+    }
+
+  /* 
+   * Go from back to front.  First we go through and figure out what
+   * type numbers we need, and register those types.  Then we go in
+   * and fill the details.  
    */
+
   for( c = strchr(ptr, '='); c != NULL; c = strchr(c + 1, '=') )
     {
       /*
@@ -134,31 +357,47 @@
 	    }
 	}
 
+      if( ntypes >= MAX_TD_NESTING )
+	{
+	  /*
+	   * If this ever happens, just bump the counter.
+	   */
+	  fprintf(stderr, "Typedef nesting overflow\n");
+	  return FALSE;
+	}
+
       switch(c[1])
 	{
 	case '*':
 	  stab_types[typenum] = DEBUG_NewDataType(POINTER, NULL);
+	  curr_types[ntypes++] = stab_types[typenum];
 	  break;
 	case 's':
 	case 'u':
 	  stab_types[typenum] = DEBUG_NewDataType(STRUCT, typename);
+	  curr_types[ntypes++] = stab_types[typenum];
 	  break;
 	case 'a':
 	  stab_types[typenum] = DEBUG_NewDataType(ARRAY, NULL);
+	  curr_types[ntypes++] = stab_types[typenum];
 	  break;
 	case '1':
 	case 'r':
 	  stab_types[typenum] = DEBUG_NewDataType(BASIC, typename);
+	  curr_types[ntypes++] = stab_types[typenum];
 	  break;
 	case 'x':
 	  stab_strcpy(element_name, c + 3);
 	  stab_types[typenum] = DEBUG_NewDataType(STRUCT, element_name);
+	  curr_types[ntypes++] = stab_types[typenum];
 	  break;
 	case 'e':
 	  stab_types[typenum] = DEBUG_NewDataType(ENUM, NULL);
+	  curr_types[ntypes++] = stab_types[typenum];
 	  break;
 	case 'f':
 	  stab_types[typenum] = DEBUG_NewDataType(FUNC, NULL);
+	  curr_types[ntypes++] = stab_types[typenum];
 	  break;
 	default:
 	  fprintf(stderr, "Unknown type.\n");
@@ -166,154 +405,184 @@
       typename = NULL;
     }
 
-     /*
-      * OK, now take a second sweep through.  Now we will be digging out the definitions
-      * of the various components, and storing them in the skeletons that we have already
-      * allocated.  We take a right-to left search as this is much easier to parse.
-      */
-  for( c = strrchr(ptr, '='); c != NULL; c = strrchr(ptr, '=') )
-    {
       /*
-       * Back up until we get to a non-numeric character.  This is the type
-       * number.
-       */
-      tc = c - 1;
-      while( *tc >= '0' && *tc <= '9' )
-	{
-	  tc--;
-	}
-      typenum = atol(tc + 1);
-      curr_type = stab_types[typenum];
+      * Now register the type so that if we encounter it again, we will know
+      * what to do.
+      */
+     DEBUG_RegisterTypedef(orig_typename, curr_types, ntypes);
 
-      switch(c[1])
-	{
-	case 'x':
-	  tc = c + 3;
-	  while( *tc != ':' )
-	    {
-	      tc ++;
-	    }
-	  tc++;
-	  if( *tc == '\0' )
-	    {
-	      *c = '\0';
-	    }
-	  else
-	    {
-	      strcpy(c, tc);
-	    }
+     /* 
+      * OK, now take a second sweep through.  Now we will be digging
+      * out the definitions of the various components, and storing
+      * them in the skeletons that we have already allocated.  We take
+      * a right-to left search as this is much easier to parse.  
+      */
+     for( c = strrchr(ptr, '='); c != NULL; c = strrchr(ptr, '=') )
+       {
+	 /*
+	  * Back up until we get to a non-numeric character.  This is the type
+	  * number.
+	  */
+	 tc = c - 1;
+	 while( *tc >= '0' && *tc <= '9' )
+	   {
+	     tc--;
+	   }
+	 typenum = atol(tc + 1);
+	 curr_type = stab_types[typenum];
+	 
+	 switch(c[1])
+	   {
+	   case 'x':
+	     tc = c + 3;
+	     while( *tc != ':' )
+	       {
+		 tc ++;
+	       }
+	     tc++;
+	     if( *tc == '\0' )
+	       {
+		 *c = '\0';
+	       }
+	     else
+	       {
+		 strcpy(c, tc);
+	       }
+	     
+	     break;
+	   case '*':
+	   case 'f':
+	     tc = c + 2;
+	     datatype = stab_types[strtol(tc, &tc, 10)];
+	     DEBUG_SetPointerType(curr_type, datatype);
+	     if( *tc == '\0' )
+	       {
+		 *c = '\0';
+	       }
+	     else
+	       {
+		 strcpy(c, tc);
+	       }
+	     break;
+	   case '1':
+	   case 'r':
+	     /*
+	      * We have already handled these above.
+	      */
+	     *c = '\0';
+	     break;
+	   case 'a':
+	     tc  = c + 5;
+	     arrmin = strtol(tc, &tc, 10);
+	     tc++;
+	     arrmax = strtol(tc, &tc, 10);
+	     tc++;
+	     datatype = stab_types[strtol(tc, &tc, 10)];
+	     if( *tc == '\0' )
+	       {
+		 *c = '\0';
+	       }
+	     else
+	       {
+		 strcpy(c, tc);
+	       }
+	     
+	     DEBUG_SetArrayParams(curr_type, arrmin, arrmax, datatype);
+	     break;
+	   case 's':
+	   case 'u':
+	     tc = c + 2;
+	     if( DEBUG_SetStructSize(curr_type, strtol(tc, &tc, 10)) == FALSE )
+	       {
+		 /*
+		  * We have already filled out this structure.  Nothing to do,
+		  * so just skip forward to the end of the definition.
+		  */
+		 while( tc[0] != ';' && tc[1] != ';' )
+		   {
+		     tc++;
+		   }
+		 
+		 tc += 2;
+		 
+		 if( *tc == '\0' )
+		   {
+		     *c = '\0';
+		   }
+		 else
+		   {
+		     strcpy(c, tc + 1);
+		   }
+		 continue;
+	       }
 
-	  break;
-	case '*':
-	case 'f':
-	  tc = c + 2;
-	  datatype = stab_types[strtol(tc, &tc, 10)];
-	  DEBUG_SetPointerType(curr_type, datatype);
-	  if( *tc == '\0' )
-	    {
-	      *c = '\0';
-	    }
-	  else
-	    {
-	      strcpy(c, tc);
-	    }
-	  break;
-	case '1':
-	case 'r':
-	  /*
-	   * We have already handled these above.
-	   */
-	  *c = '\0';
-	  break;
-	case 'a':
-	  tc  = c + 5;
- 	  arrmin = strtol(tc, &tc, 10);
-	  tc++;
- 	  arrmax = strtol(tc, &tc, 10);
-	  tc++;
-	  datatype = stab_types[strtol(tc, &tc, 10)];
-	  if( *tc == '\0' )
-	    {
-	      *c = '\0';
-	    }
-	  else
-	    {
-	      strcpy(c, tc);
-	    }
-	  
-	  DEBUG_SetArrayParams(curr_type, arrmin, arrmax, datatype);
-	  break;
-	case 's':
-	case 'u':
-	  tc = c + 2;
-	  DEBUG_SetStructSize(curr_type, strtol(tc, &tc, 10));
-	  /*
-	   * Now parse the individual elements of the structure/union.
-	   */
-	  while(*tc != ';')
-	    {
-	      tc2 = element_name;
-	      while(*tc != ':')
-		{
-		  *tc2++ = *tc++;
-		}
-	      tc++;
-	      *tc2++ = '\0';
-	      datatype = stab_types[strtol(tc, &tc, 10)];
-	      tc++;
-	      offset  = strtol(tc, &tc, 10);
-	      tc++;
-	      size  = strtol(tc, &tc, 10);
-	      tc++;
-	      DEBUG_AddStructElement(curr_type, element_name, datatype, offset, size);
-	    }
-	  if( *tc == '\0' )
-	    {
-	      *c = '\0';
-	    }
-	  else
-	    {
-	      strcpy(c, tc + 1);
-	    }
-	  break;
-	case 'e':
-	  tc = c + 2;
-	  /*
-	   * Now parse the individual elements of the structure/union.
-	   */
-	  while(*tc != ';')
-	    {
-	      tc2 = element_name;
-	      while(*tc != ':')
-		{
-		  *tc2++ = *tc++;
-		}
-	      tc++;
-	      *tc2++ = '\0';
-	      offset  = strtol(tc, &tc, 10);
-	      tc++;
-	      DEBUG_AddStructElement(curr_type, element_name, NULL, offset, 0);
-	    }
-	  if( *tc == '\0' )
-	    {
-	      *c = '\0';
-	    }
-	  else
-	    {
-	      strcpy(c, tc + 1);
-	    }
-	  break;
-	default:
-	  fprintf(stderr, "Unknown type.\n");
-	  break;
-	}
-    }
-
-  rtn = TRUE;
-
+	     /*
+	      * Now parse the individual elements of the structure/union.
+	      */
+	     while(*tc != ';')
+	       {
+		 tc2 = element_name;
+		 while(*tc != ':')
+		   {
+		     *tc2++ = *tc++;
+		   }
+		 tc++;
+		 *tc2++ = '\0';
+		 datatype = stab_types[strtol(tc, &tc, 10)];
+		 tc++;
+		 offset  = strtol(tc, &tc, 10);
+		 tc++;
+		 size  = strtol(tc, &tc, 10);
+		 tc++;
+		 DEBUG_AddStructElement(curr_type, element_name, datatype, offset, size);
+	       }
+	     if( *tc == '\0' )
+	       {
+		 *c = '\0';
+	       }
+	     else
+	       {
+		 strcpy(c, tc + 1);
+	       }
+	     break;
+	   case 'e':
+	     tc = c + 2;
+	     /*
+	      * Now parse the individual elements of the structure/union.
+	      */
+	     while(*tc != ';')
+	       {
+		 tc2 = element_name;
+		 while(*tc != ':')
+		   {
+		     *tc2++ = *tc++;
+		   }
+		 tc++;
+		 *tc2++ = '\0';
+		 offset  = strtol(tc, &tc, 10);
+		 tc++;
+		 DEBUG_AddStructElement(curr_type, element_name, NULL, offset, 0);
+	       }
+	     if( *tc == '\0' )
+	       {
+		 *c = '\0';
+	       }
+	     else
+	       {
+		 strcpy(c, tc + 1);
+	       }
+	     break;
+	   default:
+	     fprintf(stderr, "Unknown type.\n");
+	     break;
+	   }
+       }
+     
+     rtn = TRUE;
+     
 leave:
-
-  return rtn;
+     
+     return rtn;
 
 }
 
@@ -676,6 +945,9 @@
       num_stab_types = 0;
     }
 
+
+  DEBUG_FreeRegisteredTypedefs();
+
   return TRUE;
 }
 
diff --git a/debugger/types.c b/debugger/types.c
index 581d096..0b26d50 100644
--- a/debugger/types.c
+++ b/debugger/types.c
@@ -11,8 +11,11 @@
 #include <stdlib.h>
 
 #include <assert.h>
+#ifndef __EMX__
 #include <sys/mman.h>
+#endif
 #include <fcntl.h>
+#include <sys/types.h>
 #include <sys/stat.h>
 #include <limits.h>
 #include <strings.h>
@@ -28,6 +31,9 @@
 
 #define NR_TYPE_HASH 521
 
+int		  DEBUG_nchar;
+static int	  DEBUG_maxchar = 1024;
+
 struct en_values
 {
   struct en_values* next;
@@ -177,6 +183,32 @@
   return dt;
 }
 
+static
+struct datatype *
+DEBUG_LookupDataType(enum debug_type xtype, int hash, const char * typename)
+{
+  struct datatype * dt = NULL;
+
+  if( typename != NULL )
+    {
+      for( dt = type_hash_table[hash]; dt; dt = dt->next )
+	{
+	  if( xtype != dt->type || dt->name == NULL 
+	      || dt->name[0] != typename[0])
+	    {
+	      continue;
+	    }
+	  	  
+	  if( strcmp(dt->name, typename) == 0 )
+	    {
+	      return dt;
+	    }
+	}
+    }
+
+  return dt;
+}
+
 struct datatype *
 DEBUG_NewDataType(enum debug_type xtype, const char * typename)
 {
@@ -195,22 +227,7 @@
       hash = type_hash(typename);
     }
 
-  if( typename != NULL )
-    {
-      for( dt = type_hash_table[hash]; dt; dt = dt->next )
-	{
-	  if( xtype != dt->type || dt->name == NULL 
-	      || dt->name[0] != typename[0])
-	    {
-	      continue;
-	    }
-	  	  
-	  if( strcmp(dt->name, typename) == 0 )
-	    {
-	      return dt;
-	    }
-	}
-    }
+  dt = DEBUG_LookupDataType(xtype, hash, typename);
 
   if( dt == NULL )
     {
@@ -347,6 +364,11 @@
   switch(addr->type->type)
     {
     case BASIC:
+      if (!DBG_CHECK_READ_PTR( addr,  addr->type->un.basic.basic_size)) 
+	{
+	  return 0;
+	}
+
       memcpy(&rtn, (char *) addr->off, addr->type->un.basic.basic_size);
       if(    (addr->type->un.basic.b_signed)
 	  && ((addr->type->un.basic.basic_size & 3) != 0)
@@ -495,6 +517,12 @@
 DEBUG_SetStructSize(struct datatype * dt, int size)
 {
   assert(dt->type == STRUCT);
+
+  if( dt->un.structure.members != NULL )
+    {
+      return FALSE;
+    }
+
   dt->un.structure.size = size;
   dt->un.structure.members = NULL;
 
@@ -710,7 +738,8 @@
  *
  * Implementation of the 'print' command.
  */
-void DEBUG_Print( const DBG_ADDR *addr, int count, char format, int level )
+void
+DEBUG_Print( const DBG_ADDR *addr, int count, char format, int level )
 {
   DBG_ADDR	  addr1;
   int		  i;
@@ -728,9 +757,20 @@
   if( addr->type == NULL )
     {
       fprintf(stderr, "Unable to evaluate expression\n");
-      return;
+      goto leave;
     }
   
+  if( level == 0 )
+    {
+      DEBUG_nchar = 0;
+    }
+
+  if( DEBUG_nchar > DEBUG_maxchar )
+    {
+      fprintf(stderr, "...");
+      goto leave;
+    }
+
   if( format == 'i' || format == 's' || format == 'w' || format == 'b' )
     {
       fprintf( stderr, "Format specifier '%c' is meaningless in 'print' command\n", format );
@@ -746,20 +786,25 @@
       DEBUG_PrintBasic(addr, 1, format);
       break;
     case STRUCT:
-      fprintf(stderr, "{");
+      DEBUG_nchar += fprintf(stderr, "{");
       for(m = addr->type->un.structure.members; m; m = m->next)
 	{
 	  addr1 = *addr;
 	  DEBUG_FindStructElement(&addr1, m->name,
 				  (int *) &value);
-	  fprintf(stderr, "%s=", m->name);
+	  DEBUG_nchar += fprintf(stderr, "%s=", m->name);
 	  DEBUG_Print(&addr1, 1, format, level + 1);
 	  if( m->next != NULL )
 	    {
-	      fprintf(stderr, ", ");
+	      DEBUG_nchar += fprintf(stderr, ", ");
+	    }
+	  if( DEBUG_nchar > DEBUG_maxchar )
+	    {
+	      fprintf(stderr, "...}");
+	      goto leave;
 	    }
 	}
-      fprintf(stderr, "}");
+      DEBUG_nchar += fprintf(stderr, "}");
       break;
     case ARRAY:
       /*
@@ -772,28 +817,39 @@
 	   * Special handling for character arrays.
 	   */
 	  pnt = (char *) addr->off;
-	  fprintf(stderr, "\"");
+	  DEBUG_nchar += fprintf(stderr, "\"");
 	  for( i=addr->type->un.array.start; i < addr->type->un.array.end; i++ )
 	    {
 	      fputc(*pnt++, stderr);
+	      DEBUG_nchar++;
+	      if( DEBUG_nchar > DEBUG_maxchar )
+		{
+		  fprintf(stderr, "...\"");
+		  goto leave;
+		}
 	    }
-	  fprintf(stderr, "\"");
+	  DEBUG_nchar += fprintf(stderr, "\"");
 	  break;
 	}
       addr1 = *addr;
       addr1.type = addr->type->un.array.basictype;
-      fprintf(stderr, "{");
+      DEBUG_nchar += fprintf(stderr, "{");
       for( i=addr->type->un.array.start; i <= addr->type->un.array.end; i++ )
 	{
 	  DEBUG_Print(&addr1, 1, format, level + 1);
 	  addr1.off += size;
 	  if( i == addr->type->un.array.end )
 	    {
-	      fprintf(stderr, "}");
+	      DEBUG_nchar += fprintf(stderr, "}");
 	    }
 	  else
 	    {
-	      fprintf(stderr, ", ");
+	      DEBUG_nchar += fprintf(stderr, ", ");
+	    }
+	  if( DEBUG_nchar > DEBUG_maxchar )
+	    {
+	      fprintf(stderr, "...}");
+	      goto leave;
 	    }
 	}
       break;
@@ -802,8 +858,157 @@
       break;
     }
 
+leave:
+
   if( level == 0 )
     {
-      fprintf(stderr, "\n");
+      DEBUG_nchar += fprintf(stderr, "\n");
     }
+  return;
 }
+
+int
+DEBUG_DumpTypes()
+{
+  struct datatype * dt = NULL;
+  struct member * m;
+  int hash;
+  int nm;
+  char * name;
+  char * member_name;
+
+  for(hash = 0; hash < NR_TYPE_HASH + 1; hash++)
+    {
+      for( dt = type_hash_table[hash]; dt; dt = dt->next )
+	{
+	  name =  "none";
+	  if( dt->name != NULL )
+	    {
+	      name = dt->name;
+	    }
+	  switch(dt->type)
+	    {
+	    case BASIC:
+	      fprintf(stderr, "0x%p - BASIC(%s)\n",
+		      dt, name);
+	      break;
+	    case POINTER:
+	      fprintf(stderr, "0x%p - POINTER(%s)(%p)\n",
+		      dt, name, dt->un.pointer.pointsto);
+	      break;
+	    case STRUCT:
+	      member_name = "none";
+	      nm = 0;
+	      if( dt->un.structure.members != NULL
+		  && dt->un.structure.members->name != NULL )
+		{
+		  member_name = dt->un.structure.members->name;
+		  for( m = dt->un.structure.members; m; m = m->next)
+		    {
+		      nm++;
+		    }
+		}
+	      fprintf(stderr, "0x%p - STRUCT(%s) %d %d %s\n", dt, name,
+		      dt->un.structure.size, nm, member_name);
+	      break;
+	    case ARRAY:
+	      fprintf(stderr, "0x%p - ARRAY(%s)(%p)\n",
+		      dt, name, dt->un.array.basictype);
+	      break;
+	    case ENUM:
+	      fprintf(stderr, "0x%p - ENUM(%s)\n",
+		      dt, name);
+	      break;
+	    case BITFIELD:
+	      fprintf(stderr, "0x%p - BITFIELD(%s)\n", dt, name);
+	      break;
+	    case FUNC:
+	      fprintf(stderr, "0x%p - FUNC(%s)(%p)\n",
+		      dt, name, dt->un.funct.rettype);
+	      break;
+	    case CONST:
+	    case TYPEDEF:
+	      fprintf(stderr, "What???\n");
+	      break;
+	    }
+	}
+    }
+  return TRUE;
+}
+
+
+enum debug_type DEBUG_GetType(struct datatype * dt)
+{
+  return dt->type;
+}
+
+struct datatype *
+DEBUG_TypeCast(enum debug_type type, const char * name)
+{
+  int			  hash;
+  struct datatype	* rtn;
+
+  /*
+   * The last bucket is special, and is used to hold typeless names.
+   */
+  if( name == NULL )
+    {
+      hash = NR_TYPE_HASH;
+    }
+  else
+    {
+      hash = type_hash(name);
+    }
+
+  rtn = DEBUG_LookupDataType(type, hash, name);
+
+  return rtn;
+
+}
+
+int
+DEBUG_PrintTypeCast(struct datatype * dt)
+{
+  char		* name;
+
+  name =  "none";
+  if( dt->name != NULL )
+    {
+      name = dt->name;
+    }
+
+  switch(dt->type)
+    {
+    case BASIC:
+      fprintf(stderr, "%s", name);
+      break;
+    case POINTER:
+      DEBUG_PrintTypeCast(dt->un.pointer.pointsto);
+      fprintf(stderr, "*");
+      break;
+    case STRUCT:
+      fprintf(stderr, "struct %s", name);
+      break;
+    case ARRAY:
+      fprintf(stderr, "%s[]", name);
+      break;
+    case ENUM:
+      fprintf(stderr, "enum %s", name);
+      break;
+    case BITFIELD:
+      fprintf(stderr, "unsigned %s", name);
+      break;
+    case FUNC:
+      DEBUG_PrintTypeCast(dt->un.funct.rettype);
+      fprintf(stderr, "(*%s)()", name);
+      break;
+    case CONST:
+    case TYPEDEF:
+      fprintf(stderr, "What???\n");
+      break;
+    }
+
+  return TRUE;
+}
+
+