home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c005 / 5.ddi / ISCALINT.ASM < prev    next >
Encoding:
Assembly Source File  |  1986-08-05  |  7.0 KB  |  298 lines
  1.     page 60,126
  2. ;
  3. ; Name        iscalint -- Simulate software-interrupt-style call to
  4. ;                interrupt service routine.
  5. ;
  6. ; Synopsis    ercode = iscalint(pintvec,preg);
  7. ;
  8. ;        int    ercode      Error code:  0 if okay;
  9. ;                  1 if interrupt vector is invalid.
  10. ;        ADS    *pintvec   Address of ADS structure containing
  11. ;                  four-byte address to call
  12. ;        ALLREG *preg      Standard registers
  13. ;
  14. ; Description    This function invokes the interrupt service routine
  15. ;        whose address is contained in *pintvec and returns the
  16. ;        results in the most general fashion.  All values
  17. ;        specified in *preg are passed to the interrupt service
  18. ;        routine in the corresponding registers except for CS,
  19. ;        IP, SS, and SP.  All the resulting register contents are
  20. ;        returned in *preg (again, except for CS, IP, SS, and
  21. ;        SP).
  22. ;
  23. ;        The interrupt state (that is, whether interrupts are
  24. ;        enabled or disabled) is preserved.
  25. ;
  26. ;        Use ISRETVEC to obtain the address of an interrupt
  27. ;        service routine which is installed in one of the
  28. ;        standard interrupt vectors in low memory.
  29. ;
  30. ;        Use the function called DOS for invoking DOS functions
  31. ;        because it protects against certain DOS bugs.
  32. ;
  33. ; Returns    ercode          Error code:  0 if okay, 1 if interrupt
  34. ;                  vector is invalid.
  35. ;        *preg          The values of the registers may be altered
  36. ;                  by the interrupt handler.
  37. ;
  38. ; Version    3.0 (C)Copyright Blaise Computing Inc. 1983,1984,1985,1986
  39. ;
  40.  
  41. popff     macro                ;; Simulate POPF instruction
  42.      local    do_call,do_iret
  43.      jmp    short do_call
  44. do_iret: iret                ;; Pop IP, CS, flags.
  45. do_call: push    cs            ;; Push CS
  46.      call    do_iret         ;; Push IP & jump.
  47.      endm
  48.  
  49.      name       iscalint
  50.  
  51.      LONGPROG  = 0               ; initialize constants for
  52.      LONGDATA  = 0               ; Pass1 of the assembler
  53.  
  54.      include   compiler.mac        ; Specifies the C compiler
  55.  
  56.      if LAT200 or LAT210 or LAT300
  57.      include  dos.mac
  58.      LONGPROG = LPROG
  59.      LONGDATA = LDATA
  60.  
  61.      pseg
  62.      public   iscalint
  63.      if      LPROG
  64.      x   equ  6             ; parameter offset
  65. iscalint proc      far
  66.      else
  67.      x   equ  4
  68. iscalint proc      near
  69.      endif
  70.      endif
  71.  
  72.      if CI201A
  73.      include  model.h
  74.      include  prologue.h
  75.      LONGPROG = @bigmodel
  76.      LONGDATA = @bigmodel
  77.  
  78.      public   iscalint
  79.      if      @bigmodel
  80.      x   equ  6               ; parameter offset
  81. iscalint proc      far
  82.      else
  83.      x   equ  4
  84. iscalint proc      near
  85.      endif
  86.      endif
  87.  
  88.      if MSC300
  89.      include  dos.mac
  90.      LONGPROG = LPROG
  91.      LONGDATA = LDATA
  92.  
  93.      pseg      iscalint
  94.      public   _iscalint
  95.      if      LPROG
  96.      x   equ  6             ; parameter offset
  97. _iscalint proc       far
  98.      else
  99.      x   equ  4
  100. _iscalint proc       near
  101.      endif
  102.      endif
  103.  
  104. ERR_BADVEC  equ     1            ; Error code indicating invalid
  105.                     ; interrupt vector.
  106.  
  107.      if    LONGDATA
  108. pintvec  equ    dword ptr [bp + x]
  109. preg     equ    dword ptr [bp + x + 4]
  110.      else
  111. pintvec  equ    word ptr [bp + x]
  112. preg     equ    word ptr [bp + x + 2]
  113.      endif
  114.  
  115. ALLREG     struc                ; ALLREG structure
  116. reg_ax     dw    ?            ; (This must match declaration in
  117. reg_bx     dw    ?            ; BUTILITY.H).
  118. reg_cx     dw    ?
  119. reg_dx     dw    ?
  120. reg_si     dw    ?
  121. reg_di     dw    ?
  122. reg_ds     dw    ?
  123. reg_es     dw    ?
  124. reg_ss     dw    ?
  125. reg_cs     dw    ?
  126. reg_flags dw    ?
  127. reg_bp     dw    ?
  128. reg_sp     dw    ?
  129. reg_ip     dw    ?
  130. ALLREG     ends
  131.  
  132.  
  133.      push    bp
  134.      mov    bp,sp
  135.  
  136.      push    si            ; Save registers that are important
  137.      push    di            ; to the C environment.
  138.      push    ds
  139.      push    es
  140.                     ; Obtain interrupt vector
  141.      if    LONGDATA
  142.      lds    bx,pintvec
  143.      assume ds:nothing
  144.      else
  145.      mov    bx,pintvec
  146.      endif
  147.      mov    ax,ds            ; Quit if pintvec is 0:0.
  148.      or    ax,bx
  149.      jz    bad_vector
  150.      les    si,[bx]
  151.      assume es:nothing        ; Now ES:SI is address of interrupt
  152.                     ; handler.
  153.      mov    ax,es            ; Quit if *pintvec is 0:0.
  154.      or    ax,si
  155.      jnz    ok_vector
  156.  
  157. bad_vector:
  158.      mov    ax,ERR_BADVEC
  159.      jmp    short exit
  160.  
  161. ok_vector:
  162.                     ; Obtain contents of preg.
  163.      if    LONGDATA
  164.      lds    bx,preg
  165.      assume ds:nothing
  166.      else
  167.      mov    bx,preg
  168.      endif
  169.                     ; Now DS:BX points to *preg
  170.                     ; (ALLREG structure is at DS:BX).
  171.  
  172.                     ; Begin setting up for the call:
  173.  
  174.      push    ds            ; Step 1:  Save stack frame pointer
  175.      push    bp            ; so we can restore it in Step 10.
  176.  
  177.      pushf                ; Step 2:  Save our own flags
  178.                     ; for restoration in Step 9.
  179.  
  180.                     ; Step 3:  Push the stack items that
  181.                     ; the ISR will see:  a copy of its
  182.                     ; flags and its return address
  183.                     ; (CS:ret_addr).
  184.  
  185.      mov    ax,[bx.reg_flags]   ; Push the flags
  186.      push    ax            ;    without clearing IF and TF.
  187.      push    cs            ; Push CS.
  188.      mov    cx,offset ret_addr
  189.      push    cx            ; Push ret_addr.
  190.  
  191.                     ; Step 4:
  192.                     ; We will enter the handler by doing
  193.                     ; an IRET, so push the flags and the
  194.                     ; vector.
  195.  
  196.      and    ah,0fch         ; Push the flags
  197.      push    ax            ;    with IF and TF cleared.
  198.      push    es            ; Push the vector.
  199.      push    si
  200.  
  201.      mov    ax,[bx.reg_ax]        ; Step 5:  Load the easy registers.
  202.      mov    cx,[bx.reg_cx]
  203.      mov    dx,[bx.reg_dx]
  204.      mov    si,[bx.reg_si]
  205.      mov    di,[bx.reg_di]
  206.      mov    es,[bx.reg_es]
  207.      assume es:nothing
  208.      mov    bp,[bx.reg_bp]
  209.  
  210.      push    [bx.reg_bx]        ; Step 6:  Load DS and BX
  211.      mov    ds,[bx.reg_ds]        ; by temporarily using the stack.
  212.      assume ds:nothing
  213.      pop    bx
  214.  
  215.      iret                ; Step 7:  Load the flags and jump
  216.                     ; to the handler.  (This IRET uses &
  217.                     ; removes what was pushed in Step 4.)
  218.  
  219. ret_addr:
  220.      assume es:nothing,ds:nothing
  221.                     ; The interrupt handler brought us here
  222.                     ; by performing an IRET, thus popping
  223.                     ; what was pushed in Step 3.
  224.                     ; (However, the interrupt handler
  225.                     ; may choose to modify the flags
  226.                     ; before popping them.)
  227.  
  228.      push    bp            ; Step 8:  Temporarily preserve
  229.      push    ds            ; returned values of BP, DS, BX,
  230.      push    bx            ; and flags.
  231.      pushf
  232.  
  233.      mov    bp,sp            ; Step 9:  Restore our own flags
  234.      mov    bx,[bp+8]        ; (which were pushed in Step 2).
  235.      push    bx            ; (They may contain special values
  236.      popff                ; required by the C environment).
  237.  
  238.      lds    bp,[bp+10]        ; Step 10:    Restore stack frame pointer
  239.      assume ds:nothing        ; (pushed in Step 1) so we can find preg.
  240.  
  241.                     ; Obtain contents of preg.
  242.      if    LONGDATA
  243.      lds    bx,preg
  244.      assume ds:nothing
  245.      else
  246.      mov    bx,preg
  247.      endif
  248.                     ; Now DS:BX points to *preg
  249.                     ; (ALLREG structure is at DS:BX).
  250.  
  251.      mov    [bx.reg_ax],ax        ; Store the easy registers in
  252.      mov    [bx.reg_cx],cx        ; the *preg structure.
  253.      mov    [bx.reg_dx],dx
  254.      mov    [bx.reg_si],si
  255.      mov    [bx.reg_di],di
  256.      mov    [bx.reg_es],es
  257.  
  258.      pop    [bx.reg_flags]        ; Transfer values pushed in Step 8
  259.      pop    [bx.reg_bx]        ; to the *preg structure.
  260.      pop    [bx.reg_ds]
  261.      pop    [bx.reg_bp]
  262.  
  263.      add    sp,6            ; Discard values pushed in
  264.                     ; Steps 2 and 1.
  265.  
  266.      xor    ax,ax            ; Success code.
  267.  
  268. exit:
  269.                     ; Now AX contains the error/success code.
  270.  
  271.      pop    es            ; Restore registers that are important
  272.      pop    ds            ; to the C environment.
  273.      pop    di
  274.      pop    si
  275.  
  276.      pop    bp
  277.      ret
  278.  
  279.      if MSC300
  280. _iscalint endp
  281.      else
  282. iscalint endp
  283.      endif
  284.  
  285.      if LAT200 or LAT210 or LAT300
  286.      endps
  287.      endif
  288.  
  289.      if CI201A
  290.      include  epilogue.h
  291.      endif
  292.  
  293.      if MSC300
  294.      endps      iscalint
  295.      endif
  296.  
  297.      end
  298.