home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / dos_ency / 13 / divzero.asm next >
Encoding:
Assembly Source File  |  1988-08-11  |  7.8 KB  |  247 lines
  1.         name    divzero
  2.         title   'DIVZERO - Interrupt 00H Handler'
  3. ;
  4. ; DIVZERO.ASM: Demonstration Interrupt 00H Handler
  5. ; 
  6. ; To assemble, link, and convert to COM file:
  7. ;
  8. ;       C>MASM DIVZERO;  <Enter>
  9. ;       C>LINK DIVZERO;  <Enter>
  10. ;       C>EXE2BIN DIVZERO.EXE DIVZERO.COM  <Enter>
  11. ;       C>DEL DIVZERO.EXE  <Enter>
  12. ;
  13.  
  14. cr      equ     0dh             ; ASCII carriage return
  15. lf      equ     0ah             ; ASCII linefeed
  16. eos     equ     '$'             ; end of string marker
  17.  
  18. _TEXT   segment word public 'CODE'
  19.  
  20.         assume  cs:_TEXT,ds:_TEXT,es:_TEXT,ss:_TEXT
  21.  
  22.         org     100h
  23.  
  24. entry:  jmp     start           ; skip over data area
  25.  
  26. intmsg  db      'Divide by Zero Occurred!',cr,lf,eos
  27.  
  28. divmsg  db      'Dividing '     ; message used by demo
  29. par1    db      '0000h'         ; dividend goes here
  30.         db      ' by '
  31. par2    db      '00h'           ; divisor goes here
  32.         db      ' equals '
  33. par3    db      '00h'           ; quotient here
  34.         db      ' remainder '
  35. par4    db      '00h'           ; and remainder here
  36.         db      cr,lf,eos
  37.  
  38. oldint0 dd      ?               ; save old Int 00H vector
  39.  
  40. intflag db      0               ; nonzero if divide by
  41.                                 ; zero interrupt occurred
  42.  
  43. oldip   dw      0               ; save old IP value
  44.  
  45.  
  46. ;
  47. ; The routine 'int0' is the actual divide by zero
  48. ; interrupt handler.  It gains control whenever a
  49. ; divide by zero or overflow occurs.  Its action
  50. ; is to set a flag and then increment the instruction
  51. ; pointer saved on the stack so that the failing 
  52. ; divide will not be reexecuted after the IRET.
  53. ;
  54. ; In this particular case we can call MS-DOS to 
  55. ; display a message during interrupt handling
  56. ; because the application triggers the interrupt
  57. ; intentionally. Thus, it is known that MS-DOS or
  58. ; other interrupt handlers are not in control
  59. ; at the point of interrupt.
  60. ; 
  61.  
  62. int0:   pop     cs:oldip        ; capture instruction pointer
  63.  
  64.         push    ax
  65.         push    bx
  66.         push    cx
  67.         push    dx
  68.         push    di
  69.         push    si
  70.         push    ds
  71.         push    es
  72.  
  73.         push    cs              ; set DS = CS
  74.         pop     ds
  75.  
  76.         mov     ah,09h          ; print error message
  77.         mov     dx,offset _TEXT:intmsg
  78.         int     21h
  79.  
  80.         add     oldip,2         ; bypass instruction causing
  81.                                 ; divide by zero error
  82.  
  83.         mov     intflag,1       ; set divide by 0 flag
  84.  
  85.         pop     es              ; restore all registers
  86.         pop     ds
  87.         pop     si
  88.         pop     di
  89.         pop     dx
  90.         pop     cx
  91.         pop     bx
  92.         pop     ax
  93.  
  94.         push    cs:oldip        ; restore instruction pointer
  95.  
  96.         iret                    ; return from interrupt
  97.  
  98.  
  99. ;
  100. ; The code beginning at 'start' is the application
  101. ; program.  It alters the vector for Interrupt 00H to
  102. ; point to the new handler, carries out some divide
  103. ; operations (including one that will trigger an
  104. ; interrupt) for demonstration purposes, restores
  105. ; the original contents of the Interrupt 00H vector,
  106. ; and then terminates.
  107. ;
  108.  
  109. start:  mov     ax,3500h        ; get current contents 
  110.         int     21h             ; of Int 00H vector
  111.  
  112.                                 ; save segment:offset
  113.                                 ; of previous Int 00H handler
  114.         mov     word ptr oldint0,bx
  115.         mov     word ptr oldint0+2,es
  116.  
  117.                                 ; install new handler...
  118.         mov     dx,offset int0  ; DS:DX = handler address
  119.         mov     ax,2500h        ; call MS-DOS to set
  120.         int     21h             ; Int 00H vector
  121.         
  122.                                 ; now our handler is active,
  123.                                 ; carry out some test divides.
  124.  
  125.         mov     ax,20h          ; test divide
  126.         mov     bx,1            ; divide by 1
  127.         call    divide      
  128.  
  129.         mov     ax,1234h        ; test divide
  130.         mov     bx,5eh          ; divide by 5EH
  131.         call    divide      
  132.  
  133.         mov     ax,5678h        ; test divide
  134.         mov     bx,7fh          ; divide by 127
  135.         call    divide      
  136.  
  137.         mov     ax,20h          ; test divide
  138.         mov     bx,0            ; divide by 0
  139.         call    divide          ; (triggers interrupt)
  140.  
  141.                                 ; demonstration complete,
  142.                                 ; restore old handler
  143.  
  144.         lds     dx,oldint0      ; DS:DX = handler address
  145.         mov     ax,2500h        ; call MS-DOS to set
  146.         int     21h             ; Int 00H vector
  147.  
  148.         mov     ax,4c00h        ; final exit to MS-DOS
  149.         int     21h             ; with return code = 0
  150.  
  151. ;
  152. ; The routine 'divide' carries out a trial division,
  153. ; displaying the arguments and the results.  It is
  154. ; called with AX = dividend and BL = divisor.
  155. ;
  156.  
  157. divide  proc    near
  158.  
  159.         push    ax              ; save arguments
  160.         push    bx
  161.  
  162.         mov     di,offset par1  ; convert dividend to 
  163.         call    wtoa            ; ASCII for display
  164.  
  165.         mov     ax,bx           ; convert divisor to
  166.         mov     di,offset par2  ; ASCII for display
  167.         call    btoa
  168.  
  169.         pop     bx              ; restore arguments
  170.         pop     ax
  171.  
  172.         div     bl              ; perform the division
  173.         cmp     intflag,0       ; divide by zero detected?
  174.         jne     nodiv           ; yes, skip display
  175.  
  176.         push    ax              ; no, convert quotient to
  177.         mov     di,offset par3  ; ASCII for display
  178.         call    btoa
  179.  
  180.         pop     ax              ; convert remainder to 
  181.         xchg    ah,al           ; ASCII for display
  182.         mov     di,offset par4
  183.         call    btoa
  184.  
  185.         mov     ah,09h          ; show arguments, results 
  186.         mov     dx,offset divmsg
  187.         int     21h
  188.  
  189. nodiv:  mov     intflag,0       ; clear divide by 0 flag
  190.         ret                     ; and return to caller
  191.  
  192. divide  endp
  193.  
  194.  
  195.  
  196. wtoa    proc    near            ; convert word to hex ASCII
  197.                                 ; call with AX = binary value
  198.                                 ;           DI = addr for string
  199.                                 ; returns AX, CX, DI destroyed
  200.  
  201.         push    ax              ; save original value
  202.         mov     al,ah
  203.         call    btoa            ; convert upper byte
  204.         add     di,2            ; increment output address
  205.         pop     ax
  206.         call    btoa            ; convert lower byte
  207.         ret                     ; return to caller
  208.  
  209. wtoa    endp
  210.  
  211.  
  212.  
  213. btoa    proc    near            ; convert byte to hex ASCII
  214.                                 ; call with AL = binary value
  215.                                 ;           DI = addr to store string
  216.                                 ; returns AX, CX destroyed
  217.  
  218.         mov     ah,al           ; save lower nibble
  219.         mov     cx,4            ; shift right 4 positions
  220.         shr     al,cl           ; to get upper nibble
  221.         call    ascii           ; convert 4 bits to ASCII
  222.         mov     [di],al         ; store in output string
  223.         mov     al,ah           ; get back lower nibble
  224.  
  225.         and     al,0fh          ; blank out upper one
  226.         call    ascii           ; convert 4 bits to ASCII
  227.         mov     [di+1],al       ; store in output string
  228.         ret                     ; back to caller
  229.  
  230. btoa    endp
  231.  
  232.  
  233.  
  234. ascii   proc    near            ; convert AL bits 0-3 to 
  235.                                 ; ASCII {0...9,A...F}
  236.         add     al,'0'          ; and return digit in AL
  237.         cmp     al,'9'
  238.         jle     ascii2     
  239.         add     al,'A'-'9'-1    ; "fudge factor" for A-F
  240. ascii2: ret                     ; return to caller
  241.  
  242. ascii   endp
  243.  
  244. _TEXT   ends
  245.  
  246.         end     entry
  247.