🚀 go-pugleaf

I am in the process of modifying a critical error handler in various ways,
mostly for my own edification and amusement.  This handler is actually a TSR
that hooks INT24.  It appears to me that such a handler cannot be installed
in the usual way (that is, using INT21 function 25), because when the
program terminates staying resident, DOS restores the old values of the
INT24 vector from the PSP.  Thus, the program must write the address of the
new handler into its own PSP before terminating.  My problem is that I would
like to be able to load the thing high using QEMM (for example), but would
not like to be *forced* to do so.

When loading high using QEMM, one actually runs the LOADHI program, which
exec's the program being loaded high.  LOADHI then terminates staying
resident after the loaded program does.  Thus, DOS restores the INT24 vector
from LOADHI's PSP.  So, if being loaded by LOADHI, I need to modify LOADHI's
PSP.  I can find that by threading through the undocumented offset (80, I
think) in my PSP.  My problem is, though, how do I *know* whether LOADHI (or
whatever its equivalent is in other memory managers) is being used?  How
about memory managers such as HIMEM.SYS which, as I understand it, don't use
a separate program to accomplish this function?

Note that this kind of problem doesn't arise with normal TSR's, as they
simply hook an interrupt vector via INT21 function 25.

Any help (including help of the form "you're really doing this quite all
wrong") would be appreciated.

Roger Lipsett
Intermetrics, Inc.
Cambridge, MA 02138

+--------------------------------------------------------------------+
| internet:	lipsett@inmet.com	      | Voice:	617-661-1840 |
| uunet:		uunet!inmet!lipsett   | Fax:    617-868-2843 |
|    or:          lipsett%inmet@uunet.uu.net  |                      |
+--------------------------------------------------------------------+