home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / pcmagazi / utility / extend / extend.asm next >
Assembly Source File  |  1987-10-26  |  9KB  |  226 lines
  1. ;   This is the source code for the replacement INT 21 handler EXTEND.PAS.
  2. ; This code is designed to be compiled by the A86 assembler and linked into
  3. ; the Pascal code.  I tried to include the necessary statements for it to
  4. ; compile under MASM as well, but I don't own MASM so I can't guarantee
  5. ; anything.
  6. ;
  7. ;   This code was based upon earlier work by Randy Forgaard, Bela Lubkin and
  8. ; Kim Kokkonen.  The previous implementation was based on using the same
  9. ; technique only not using an interrupt handler.  See EXTEND.DOC for more
  10. ; information.
  11. ;
  12. ;   To compile with A86:
  13. ;      A86 EXTEND.ASM EXTEND.OBJ
  14. ;
  15. ; Scott Bussinger
  16. ; Professional Practice Systems
  17. ; 110 South 131st
  18. ; Tacoma, WA  98444
  19. ; (206)531-8944
  20. ; Compuserve [72247,2671]
  21. ;
  22. ; Version 3.0 -- 10/26/1987 -- Reworked as a UNIT for use with Turbo Pascal 4
  23. ;                              EXTEND.ASM reworked to be compatible with A86 assembler
  24. ;         2.5 --  3/16/1987 -- EXTEND.ASM worked on by Kim Kokkonen and Brian Foley to work
  25. ;                                with Turbo Extender and whittle off a few clock cycles
  26. ;         2.4 -- 12/16/1986 -- Fixes problem with DUP function
  27. ;         2.3 -- 11/18/1986 -- EXTEND now only affects DOS calls made from
  28. ;                                same code segment it was installed from (fixes
  29. ;                                problems with EXEC and batch files and already
  30. ;                                resident TSR programs
  31. ;         2.2 -- 10/04/1986 -- Fixed problem with EXEC function destroying all
  32. ;                                registers including the stack
  33. ;                              Changed way that original handle number is kept
  34. ;                              Permit FORCEDUP to change a standard handle
  35. ;                              Improve some comments
  36. ;         2.1 -- 10/02/1986 -- Fixed problem of Turbo assuming registers valid
  37. ;                                after a call to DOS
  38. ;         2.0 -- 10/01/1986 -- Initial release of this inline code
  39. ;
  40.  
  41.         PUBLIC  ExtendInit,ExtendHandler
  42.  
  43. DSEG    SEGMENT WORD PUBLIC
  44.  
  45.         EXTRN   OldInt21:DWORD         ; Address of old INT 21 handler
  46.         EXTRN   PrefixSeg:WORD         ; Segment address of Pascal program's PSP
  47.  
  48. DSEG    ENDS
  49.  
  50.  
  51. CSEG    SEGMENT WORD PUBLIC
  52.  
  53.         ASSUME  CS:CSEG
  54.  
  55. ; CS relative Data Storage
  56.  
  57. HandleTable    DD ?                    ; Pointer to standard handle table in PSP
  58. IntVector      DD ?                    ; Provide CS relative storage for old INT 21 vector
  59. SaveFunction   DB ?                    ; Save DOS function number
  60. SaveHandle     DB ?                    ; Save original handle
  61. SaveLastDCB    DB ?                    ; Save original handle slot
  62.  
  63. ; Initialize a few CS relative variables
  64.  
  65. ExtendInit PROC NEAR
  66.         LES   AX,[OldInt21]            ; Get the original INT 21 vector into CS relative storage
  67.         MOV   CS:[IntVector],AX
  68.         MOV   CS:[IntVector+2],ES
  69.  
  70.         MOV   CS:[HandleTable],0018H   ; Create a pointer to handle table in PSP
  71.         MOV   AX,[PrefixSeg]
  72.         MOV   CS:[HandleTable+2],AX
  73.         RET
  74.  
  75. ExtendInit ENDP
  76.  
  77.  
  78. ; Main replacement for INT 21 handler
  79.  
  80. ExtendHandler PROC FAR
  81.  
  82.         PUSH  BP                       ; Save BP
  83.  
  84.         MOV   BP,SP                    ; Make sure this call is from our program
  85.         MOV   BP,[BP+4]                ; BP = caller's CS
  86.         CMP   BP,WORD PTR CS:[HandleTable+2] ; Is the caller's CS < our PSP address
  87.         JB    IgnoreExtend
  88.         CMP   BP,DSEG                  ; Is the caller's CS < our data segment
  89.         JAE   IgnoreExtend
  90.  
  91.         POP   BP                       ; Restore BP
  92.  
  93.         CMP   AH,4BH                   ; Skip the rest of this if an EXEC function
  94.         JNE   NotEXEC
  95.  
  96. IgnoreExtend:
  97.         POP   BP                       ; Restore BP
  98.         JMP   CS:[IntVector]           ; Go to original handler
  99.  
  100. NotEXEC:
  101.         CMP   AH,46H                   ; Function $46 is only partially supported
  102.         JNE   ValidFunction
  103.         CMP   CL,4                     ; Permit FORCEDUP if it's a standard handle
  104.         JBE   ValidFunction
  105.  
  106. NotSupported:
  107.         MOV   AX,6                     ; Tell the user it's an invalid handle
  108.         STC                            ; Signal an error
  109.         JMP   ReturnToTurbo
  110.  
  111. ValidFunction:
  112.         PUSH  DS                       ; Set up pointer to handle table
  113.         PUSH  CX
  114.         PUSH  DI
  115.         LDS   DI,CS:[HandleTable]
  116.         MOV   CL,[DI+19]               ; Remember contents of last handle slot
  117.         MOV   CS:[SaveLastDCB],CL
  118.         MOV   CS:[SaveFunction],AH     ; Save function code for later
  119.  
  120.         CMP   AH,3EH                   ; Check for DOS functions that pass a handle
  121.         JB    CallOldInt21
  122.  
  123.         CMP   AH,40H                   ; Convert functions $3E..$40 (Close,Read,Write)
  124.         JBE   ConvertDCB
  125.  
  126.         CMP   AH,42H                   ; Convert function $42 (Seek)
  127.         JE    ConvertDCB
  128.  
  129.         CMP   AH,44H                   ; Convert function $44..$46 (IOCTL,DUP,FORCEDUP)
  130.         JB    CallOldInt21
  131.  
  132.         CMP   AH,46H
  133.         JBE   ConvertDCB
  134.  
  135.         CMP   AH,57H                   ; Convert function $57 (File time/date)
  136.         JE    ConvertDCB
  137.  
  138.         CMP   AH,5CH                   ; Convert function $5C (Lock/Unlock)
  139.         JE    ConvertDCB
  140.  
  141.         CMP   AH,68H                   ; Convert function $68 (Commit File)
  142.         JNE   CallOldInt21
  143.  
  144. ConvertDCB:
  145.         MOV   CS:[SaveHandle],BL       ; Save the original handle
  146.         CMP   BL,4                     ; Check for output to standard handle
  147.         JBE   CallOldInt21             ; Let calls with standard handle pass through
  148.  
  149.         SUB   BL,5                     ; Account for an offset of 5 in DCB number
  150.         MOV   [DI+19],BL               ; Stuff DCB into last handle slot
  151.         MOV   BL,19                    ; Use number of last handle slot
  152.  
  153. CallOldInt21:
  154.         POP   DI                       ; Restore the registers
  155.         POP   CX
  156.         POP   DS
  157.         PUSHF
  158.         CALL  CS:[IntVector]           ; Fake an INT21 to original handler
  159.         STI                            ; Allow interrupts
  160.  
  161.         PUSH  DS                       ; Setup pointer to handle table
  162.         PUSH  DI
  163.         PUSH  BX
  164.         LDS   DI,CS:[HandleTable]      ; Check if INT handler returned an error
  165.         JC    Done                     ; Possibly needs to goto CheckForHandle??
  166.  
  167.         MOV   BL,CS:[SaveFunction]     ; Check for return handles
  168.         CMP   BL,3CH                   ; Convert function $3C (Create)
  169.         JE    ConvertHandle
  170.         CMP   BL,3DH                   ; Convert function $3D (Open)
  171.         JE    ConvertHandle
  172.         CMP   BL,45H                   ; Convert function $45 (Dup)
  173.         JE    ConvertHandle
  174.         CMP   BL,5AH                   ; Convert function $5A (Create unique)
  175.         JE    ConvertHandle
  176.         CMP   BL,5BH                   ; Convert function $5B (Create new)
  177.         JE    ConvertHandle
  178.         CMP   BL,68H                   ; Convert function $68 (Commit file)
  179.         JNE   CheckForHandle
  180.  
  181. ConvertHandle:
  182.         MOV   BX,AX                    ; Use handle as offset into handle table
  183.         MOV   AL,0FFH                  ; Show the handle as unused
  184.         XCHG  AL,[DI+BX]               ; Return DCB as handle number
  185.         ADD   AL,5                     ; Use offset of 5 to avoid standard handles
  186.  
  187. CheckForHandle:
  188.         MOV   BL,CS:[SaveFunction]     ; Check for handles left in registers
  189.         CMP   BL,3FH                   ; Convert function $3F (Read)
  190.         JE    RestoreHandle
  191.         CMP   BL,40H                   ; Convert function $40 (Write)
  192.         JE    RestoreHandle
  193.         CMP   BL,42H                   ; Convert function $42 (Seek)
  194.         JE    RestoreHandle
  195.         CMP   BL,44H                   ; Convert function $44..$46 (IOCTL,DUP,FORCEDUP)
  196.         JB    Success
  197.         CMP   BL,46H
  198.         JBE   RestoreHandle
  199.         CMP   BL,57H                   ; Convert function $57 (File time/date)
  200.         JE    RestoreHandle
  201.         CMP   BL,5CH                   ; Convert function $5C (Lock/Unlock)
  202.         JNE   Success
  203.  
  204. RestoreHandle:
  205.         POP   BX
  206.         MOV   BL,CS:[SaveHandle]       ; Restore original handle in case calling
  207.         PUSH  BX                       ; program assumes BX unchanged
  208.  
  209. Success:
  210.         CLC                            ; Everything is fine so clear error flag
  211.  
  212. Done:
  213.         MOV   BL,CS:[SaveLastDCB]      ; Restore contents of last handle slot
  214.         MOV   [DI+19],BL
  215.         POP   BX
  216.         POP   DI
  217.         POP   DS
  218. ReturnToTurbo:
  219.         RET   2                        ; Return to the calling program and cleanup stack
  220.  
  221. ExtendHandler ENDP
  222.  
  223. CSEG    ENDS
  224.  
  225.         END
  226.