Since the exception structure is static, a second exception which
happens before a first is finished causes lots of problems (potential
hangs, etc).  The protections to prevent this in the code are 
currently inadequate.  For example, a CTRL-C in the middle of 
a FPU emulation.

Making the exception structure an array instead of a single element
doesn't look too complicated, nor does it take up a lot of memory.
If anyone thinks it does, then save fewer registers.  Esp, Ebp, and Eip
seem to be enough.

Using malloc in an exception handler is probably out of the question,
so a static array is the best we can do.  (Hmm... could be allocate
storage on some stack?)

I have made exception handlers set the state of the interrupt flag to
disable interrupts when executing.  This would not fix the problem 
with true nested exceptions, but I expect this to be very rare.  It
should solve the problem of ctrl-c and timers in the middle of 
exception handlers.
Eventually I think we need to copy the current working version to 
the stack, but the exception stack itself is also static (sigh).
Lets see if anyone sees problems with the new setup; it may not
enable interrupts if IOPL != CPL, or it may not disable them at all.

The bugfix described above does indeed cause problems on some systems.
In particular, on a FPU-less box it was reported that the clock ticks
stop coming when floating emulation is used.  Reversing the patch 
solved the problem for that user.
One fix would be to fix longjmp to look at the IF flag to be restored
and do the appropriate NOP, CLI, STI as necessary to do the restore,
since popf or iret will not do the restore at certain IOPLs.
The correct fix is to make exceptions reentrant, but I don't have 
time to mess with that now.

The exception handling was recoded so that the exception structure
is on the stack, and contains a pointer to the previous exception.
There is a global variable which points to the current exception
structure (NULL if none).  setjmp() saves the current exception
state pointer; longjmp() restores it.  The various problems associated
with the single static design should be fixed.