Return to setvec.c CVS log

Up to [OS/2 SDKs] / os2sdk / demos / examples / setvec

Annotation of os2sdk/demos/examples/setvec/setvec.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Example of DOSSETVEC usage
        !             3:  *
        !             4:  * This call allows a process to register a handler for the 80286
        !             5:  * exception vectors. This program works Family API.
        !             6:  *
        !             7:  * Notes:
        !             8:  *
        !             9:  *     When using the divide by zero trap in Family API mode, be
        !            10:  *     aware that the 8088/86 leaves the instruction pointer one
        !            11:  *     beyond the faulting instruction, whereas the 286 and 386 in
        !            12:  *     real mode leave it pointing to the faulting divide instruction.
        !            13:  *     The example here assumes a 286 or 386 as it tries to restart
        !            14:  *     the divide instruction.
        !            15:  *
        !            16:  *     It is possible, as in this example, to have exception handlers
        !            17:  *     written in C. In general these will be very simple handlers which
        !            18:  *     print a message before terminating the program. If you wish to
        !            19:  *     access the full register set at the time the exception occurred,
        !            20:  *     or get at the address of the failing instruction, then an assembler
        !            21:  *     handler is needed. Important caveats for handlers in C:
        !            22:  *
        !            23:  *             - disable stack checking in your program (-Gs), since the
        !            24:  *               handler is entered with unknown segment registers set up.
        !            25:  *
        !            26:  *             - if a program with multiple data segments traps and the
        !            27:  *               handler uses the segment registers (which are not saved
        !            28:  *               in C), then on return the program will crash. C handlers
        !            29:  *               which return to the faulting instruction only work in
        !            30:  *               simple cases.
        !            31:  *
        !            32:  *     The example here is carefully constructed to successfully return
        !            33:  *     to the faulting instruction from a C handler. It relies somewhat
        !            34:  *     on the compiler code generation, and the exact compiler options
        !            35:  *     used.
        !            36:  *
        !            37:  * Compile as: cl -AL -G2 -Gs -Lp setvec.c
        !            38:  *
        !            39:  * Copyright (C) Microsoft Corp. 1986
        !            40:  */
        !            41: 
        !            42: #include  <doscalls.h>
        !            43: 
        !            44: int j = 0;                 /* zero variable for division */
        !            45: 
        !            46: main()
        !            47: {
        !            48: 
        !            49:   unsigned int VecNum;      /* Exception number (0,4,5,6,7,16) */
        !            50:   void (*PrevAddress)();    /* Storage for old vector address, used to reset
        !            51:                                 the vector when finished */
        !            52:   void (*Dummy)();          /* Dummy variable used when resetting vector */
        !            53:   void handler();           /* Name of routine that will handle exception */
        !            54:   int i = 9;               /* Variable to be divided by 0 */
        !            55: 
        !            56:     /* Set up handler for Exception 0, 'divide by zero' */
        !            57:     VecNum = 0;
        !            58:     DOSSETVEC(VecNum,handler,&PrevAddress);
        !            59: 
        !            60:     /* Test the handler */
        !            61:     i = i/j;
        !            62:     printf("new i = %d\n", i);
        !            63: 
        !            64:     /* Reset handler for exception 0 */
        !            65:     DOSSETVEC(VecNum,PrevAddress,&Dummy);
        !            66: }
        !            67: 
        !            68: /*
        !            69:  * Handler subroutine for testing DOSSETVEC above.
        !            70:  * This is the routine that will get control
        !            71:  * when the exception occurs.
        !            72:  */
        !            73: void handler()
        !            74: {
        !            75:       j = 3;    /* Since j=0 caused this exception, setting j=3 will prevent
        !            76:                    the exception from recurring, when we return */
        !            77: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.