home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 595.lha / Notify_v1.1 / Source / DosWedge.asm < prev    next >
Assembly Source File  |  1991-09-07  |  4KB  |  148 lines
  1.         section code
  2.  
  3.  
  4. *
  5. *   In both functions, we need a buffer area.  Here's what will be in the
  6. *   buffer area:
  7. *
  8. *     area - area+6    : backup of what was in the DosBase jump table
  9. *     area+6 - area+12 : a jump to the new code (serves also as linked list)
  10. *     area+12 - area+20: the "old code", made either of:
  11. *
  12. *                            moveq.l #xx, d0
  13. *                            jmp     #longadd
  14. *
  15. *                                   or
  16. *
  17. *                            nop
  18. *                            jmp     #longadd
  19. *
  20. *                        depending if we were the first to modify the DosBase
  21. *                        function.
  22. *
  23.  
  24.  
  25. *   DosWedge
  26. *
  27. *     On entry, on the stack we have:
  28. *
  29. *       sp+16:  new function address
  30. *       sp+12:  backup area (10 words == 20 bytes)
  31. *       sp+8 :  offset of function in DosBase   
  32. *       sp+4 :  DosBase
  33. *       sp   :  return address (what did ya think?)
  34. *
  35. *     You can declare the DosWedge function like this in Lattice 5.10:
  36. *
  37. *     __fptr __stdargs DosWedge (struct DosBase *, LONG Offset, WORD *BackUp, __fptrNewFunc);
  38. *
  39.  
  40. JUMP    equ $4EF9
  41.  
  42.     XDEF    _DosWedge
  43.  
  44. _DosWedge:
  45.  
  46.     move.l  a6,-(a7)
  47.     move.l  4,a6
  48.     jsr     -$84(a6)            ; Forbid
  49.     move.l  8(a7),a0            ; DosBase
  50.     add.l   12(a7),a0           ; add offset of function
  51.     move.l  16(a7),a1           ; backup for old jump
  52.     move.w  (a0),(a1)           ; contains a moveq+bra or jmp
  53.     move.l  2(a0),2(a1)
  54.     cmp.w   #JUMP,(a1)          ; if old stuff is a jmp someone passed b4 us
  55.     beq     NotFirst
  56.  
  57. HereFirst:
  58.     move.w  (a0),12(a1)         ; get old moveq code
  59.     move.w  #JUMP,14(a1)        ; put a JMP #longaddr instruction
  60.     move.l  a0,16(a1)           ; get DosBase+offset
  61.     moveq.l #0,d1               ; clear register
  62.     move.w  4(a0),d1            ; get old BRA offset
  63.     addq.l  #4,d1               ; add 4 : offset relative to PC at fetch time
  64.     add.l   d1,16(a1)           ; and add it
  65.     bra     SetJump             ; go set new jump address
  66.  
  67. NotFirst:
  68.     move.w  #$4E71,12(a1)       ; put a NOP
  69.     move.w  #JUMP,14(a1)        ; put a jmp instruction
  70.     move.l  2(a0),16(a1)        ; get address of the one who passed here
  71.  
  72. SetJump:
  73.     move.w  #JUMP,(a0)          ; put a JMP #longaddr instruction
  74.     addq.l  #6,a1               ; start of new code
  75.     move.l  a1,2(a0)            ; put new code jumper
  76.     move.w  #JUMP,(a1)          ; put a JMP #longaddr instruction
  77.     move.l  20(a7),2(a1)        ; put address of new function
  78.     move.l  a1,d0
  79.     addq.l  #6,d0               ; this is the "old function ptr"
  80.     move.l  8(a7),a0            ; get DOSBase
  81.     move.l  d0,-(a7)
  82.     jsr     CheckSum            ; calculate checksum
  83.     jsr     -$8A(a6)            ; Permit
  84.     move.l  (a7)+,d0
  85.     move.l  (a7)+,a6
  86.     rts
  87.  
  88.  
  89. *   UnWedge
  90. *
  91. *     On entry, on the stack we have:
  92. *
  93. *       sp+12:  backup area (10 words == 20 bytes)
  94. *       sp+8 :  offset of function in DosBase   
  95. *       sp+4 :  DosBase
  96. *       sp   :  return address (what did ya think?)
  97. *
  98. *     You can declare the UnWedge function like this in Lattice 5.10:
  99. *
  100. *     void __stdargs UnWedge (struct DosBase *, LONG Offset, WORD *Backup);
  101. *
  102.  
  103.     XDEF    _UnWedge
  104.  
  105. _UnWedge:
  106.     move.l  a6,-(a7)
  107.     move.l  4,a6
  108.     jsr     -$84(a6)            ; Forbid
  109.     move.l  8(a7),a0            ; DosBase
  110.     add.l   12(a7),a0           ; offset
  111.     move.l  16(a7),a1           ; backup area
  112.     move.l  a1,d0               ; get our new function address
  113.     addq.l  #6,d0
  114.     cmp.l   2(a0),d0            ; check if it's in DosBase
  115.     beq     Alone
  116.  
  117. NotAlone:
  118.     move.l  2(a0),a0            ; get the address of the one who passed here
  119.     subq.l  #6,a0               ; get start of his backup
  120.     cmp.l   2(a0),d0            ; check if its backup contains that
  121.     bne     NotAlone            ; if not, get next in "list"
  122.     move.w  12(a1),12(a0)       ; copy noop or moveq
  123.     move.l  16(a1),16(a0)       ; modify its "old function pointer"
  124.  
  125. Alone:
  126.     move.w  (a1),(a0)           ; no one passed after us
  127.     move.l  2(a1),2(a0)         ; so we restore what was there
  128.     move.l  8(a7),a0            ; get DOSBase
  129.     jsr     CheckSum            ; do checksum
  130.     jsr     -$8A(a6)            ; Permit
  131.     move.l  (a7)+,a6
  132.     rts
  133.  
  134. CheckSum:
  135.     move.l  a0,a1
  136.     move.w  16(a1),d0
  137.     lsr.w   #1,d0
  138.     moveq.l #0,d1
  139.     bra     later
  140. loop:
  141.     add.w   -(a1),d1
  142. later:
  143.     dbf     d0,loop
  144.     move.w  d1,28(a0)
  145.     rts
  146.  
  147.     end
  148.