descent/DIV/DIV0.ASM

;THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
;SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
;END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
;ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
;IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
;SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
;FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
;CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
;AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
;COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
;
; $Source: f:/miner/source/div/rcs/div0.asm $
; $Revision: 1.4 $
; $Author: john $
; $Date: 1995/02/07 17:55:58 $
;
; Divide by zero error handler functions
;
; $Log: div0.asm $
; Revision 1.4  1995/02/07  17:55:58  john
; Made the debug counter variables public.
; 
; Revision 1.3  1994/01/14  15:34:12  john
; Added counters for number of overflows.
; 
; Revision 1.2  1993/10/26  17:25:45  john
; fixed bug in init, cx was being trashed.
; 
; Revision 1.1  1993/09/17  12:37:51  john
; Initial revision
; 
;
;



; DIV0.ASM   - Provides routines to capture divide overflow exceptions.
;              See DIV0.H for calling parameters.

.386



_DATA   SEGMENT BYTE PUBLIC USE32 'DATA'

		MAX_SIZE EQU 100

		Old_Ex_Sel      dw ?            ; Old Selector
		Old_Ex_Off      dd ?            ; Old offset

		Already_Init    dd  0           ; Equal to 1 when installed

		DefaultMode dd  0               ; What to do when not in list.

		; Callback List
		CB_Size     dw  0
		CB_Source   dd  MAX_SIZE DUP (0)
		CB_Dest     dd  MAX_SIZE DUP (0)

		; Saturation List
		SAT_Size    dw  0
		SAT_Source  dd  MAX_SIZE DUP (0)


	       	PUBLIC _div0_num_handled_by_cblist
		PUBLIC _div0_num_handled_by_satlist
		PUBLIC _div0_num_saturated

	       	_div0_num_handled_by_cblist	dd	0
		_div0_num_handled_by_satlist	dd	0
		_div0_num_saturated		dd	0

_DATA   ENDS

DGROUP  GROUP _DATA


_TEXT   SEGMENT BYTE PUBLIC USE32 'CODE'

		ASSUME  DS:_DATA
		ASSUME  CS:_TEXT

DivideByZeroException:

PREFIX_ADRSIZ   EQU 01100111b
PREFIX_OPSIZE   EQU 01100110b
PREFIX_LOCK     EQU 11110000b
PREFIX_CS       EQU 00101110b
PREFIX_DS       EQU 00111110b
PREFIX_ES       EQU 00100110b
PREFIX_FS       EQU 01100100b
PREFIX_GS       EQU 01100101b
PREFIX_SS       EQU 00110110b
OPCODE_NOP      EQU 10010000b


OVERFLOW_8BIT_UNSIGNED EQU 0FFh
OVERFLOW_16BIT_UNSIGNED EQU 0FFFFh
OVERFLOW_32BIT_UNSIGNED EQU 0FFFFFFFFh

OVERFLOW_8BIT_NEGATIVE EQU -128
OVERFLOW_16BIT_NEGATIVE EQU -32768
OVERFLOW_32BIT_NEGATIVE EQU -2147483648


OVERFLOW_8BIT_POSITIVE EQU 127
OVERFLOW_16BIT_POSITIVE EQU 32767
OVERFLOW_32BIT_POSITIVE EQU 2147483647



SAVED_REGS  EQU 32
SAVED_EAX   EQU DWORD PTR SS:[ESP+0]         ; 4

SAVED_AL    EQU BYTE PTR SS:[ESP+0]
SAVED_AH    EQU BYTE PTR SS:[ESP+1]
SAVED_AX    EQU WORD PTR SS:[ESP+0]

SAVED_EBX   EQU DWORD PTR SS:[ESP+4]         ; 4

SAVED_BL    EQU BYTE PTR SS:[ESP+4]
SAVED_BH    EQU BYTE PTR SS:[ESP+5]
SAVED_BX    EQU WORD PTR SS:[ESP+4]

SAVED_ECX   EQU DWORD PTR SS:[ESP+8]         ; 4

SAVED_CL    EQU BYTE PTR SS:[ESP+8]
SAVED_CH    EQU BYTE PTR SS:[ESP+9]
SAVED_CX    EQU WORD PTR SS:[ESP+8]

SAVED_EDX   EQU DWORD PTR SS:[ESP+12]        ; 4

SAVED_DL    EQU BYTE PTR SS:[ESP+12]
SAVED_DH    EQU BYTE PTR SS:[ESP+13]
SAVED_DX    EQU WORD PTR SS:[ESP+12]

SAVED_ESI   EQU DWORD PTR SS:[ESP+16]        ; 4
SAVED_SI    EQU WORD PTR SS:[ESP+16]

SAVED_EDI   EQU DWORD PTR SS:[ESP+20]        ; 4
SAVED_DI    EQU WORD PTR SS:[ESP+20]

SAVED_ES    EQU WORD PTR SS:[ESP+24]        ; 4

SAVED_DS    EQU WORD PTR SS:[ESP+28]        ; 4

BAD_EIP     EQU DWORD PTR SS:[ESP+0Ch+SAVED_REGS]
BAD_CS      EQU WORD PTR SS:[ESP+10h+SAVED_REGS]
SAVED_ESP   EQU DWORD PTR SS:[ESP+18h+SAVED_REGS]
SAVED_SP    EQU WORD PTR SS:[ESP+18h+SAVED_REGS]
SAVED_SS    EQU WORD PTR SS:[ESP+1Ch+SAVED_REGS]

		;int 3       ; Bypass by typing:  /eip++

		push    ds
		push    es
		push    edi
		push    esi
		push    edx
		push    ecx
		push    ebx
		push    eax

		mov     ax, DGROUP
		mov     ds, ax

		mov     eax, BAD_EIP

		xor     ecx, ecx

NextCB:
		cmp     cx, CB_Size
		je      CheckSatList
		cmp     CB_Source[ecx*4], eax
		jne     NotIt
		; Found the right Call Back item
		inc	_div0_num_handled_by_cblist
		mov     ecx, CB_Dest[ecx*4]
		mov     BAD_EIP, ecx
		jmp     NormalReturn
NotIt:
		inc     cx
		jmp     NextCB



CheckSatList:
		xor     ecx, ecx
NextSAT:
		cmp     cx, SAT_Size
		je      UseDefaultAction
		cmp     SAT_Source[ecx*4], eax
		jne     NotIt1
		; Found the right Saturation item
		inc	_div0_num_handled_by_satlist

		jmp     SaturateIt
NotIt1:
		inc     cx
		jmp     NextCB



UseDefaultAction:
		cmp     DefaultMode, 1
		je      DefaultSaturate

		;======  Return Error Code. =============
		;int     3               ; Pop into debugger if active
		call    div0_close_
		jmp     NormalReturn

DefaultSaturate:
		; This is hit when mode=DM_SATURATE and the instruction
		; isn't in any callback or saturate lists. For your handy debugging
		; information, the instruction that caused this exception is at
		; BX:EAX.
		inc	_div0_num_saturated 

		mov     eax, BAD_EIP
		mov     bx, BAD_CS
		int     3

SaturateIt:

		xor     ebx, ebx
		xor     ecx, ecx
		xor     esi, esi
		xor     edi, edi

		mov     es, SAVED_DS

		mov     eax, BAD_EIP

		; EAX = Pointer to Div instruction
		; BH = temp byte holder
		; BL = temp byte holder
		; CH = Bits 0=8bit, 1=16bit, 2=32bit, 3=DIV
		; CL = Temp bit shifter
		; EDX = temp 32-bit holder


PrefixCheck:
		mov     bl, BYTE PTR CS:[eax]
		cmp     bl, PREFIX_OPSIZE
		je      OperandSize
		cmp     bl, PREFIX_ADRSIZ
		je      OverPrefix
		cmp     bl, PREFIX_LOCK
		je      OverPrefix
		cmp     bl, PREFIX_CS
		je      PrefixCS
		cmp     bl, PREFIX_DS
		je      PrefixDS
		cmp     bl, PREFIX_ES
		je      PrefixES
		cmp     bl, PREFIX_FS
		je      PrefixFS
		cmp     bl, PREFIX_GS
		je      PrefixGS
		cmp     bl, PREFIX_SS
		je      PrefixSS
		jmp     DoneWithPrefixes

OverPrefix:
		inc     eax
		jmp     PrefixCheck

PrefixCS:
		mov     es, BAD_CS
		jmp     OverPrefix

PrefixDS:
		push    ds
		pop     es
		jmp     OverPrefix

PrefixES:
		mov     es, SAVED_ES

PrefixFS:
		push    fs
		pop     es
		jmp     OverPrefix

PrefixGS:
		push    gs
		pop     es
		jmp     OverPrefix

PrefixSS:
		mov     es, SAVED_SS
		jmp     OverPrefix

OperandSize:
		or      ch, 10b     ; Flag 16-bit
		jmp     OverPrefix

DoneWithPrefixes:

		; Check for the divide opcode.
		cmp     bl, 0F7h
		je      OP32OR16BIT

		cmp     bl, 0F6h
		je      OP8BIT

		; Something is wrong!!!!! This should never be reached!!!
		pop     eax
		pop     ebx
		pop     ecx
		pop     edx
		pop     esi
		pop     edi
		pop     es
		pop     ds

		int     3
		retf


OP32OR16BIT:
		test    ch, 10b
		jnz     OP16BIT

OP32BIT:
		or      ch, 100b    ; Flag 32-bit
		jmp     GotOpSize

OP8BIT:
		or      ch, 1b      ; Flag 8-bit
		jmp     GotOpSize

OP16BIT:


GotOpSize:
		inc     eax     ; We should be pointing to the mod,111,r/m byte
		mov     bl, BYTE PTR CS:[eax]
		inc     eax

		mov     bh, bl
		shr     bh, 6       ; BH = mod bits

		test    bl, 001000b
		;           110 = Div
		;           111 = iDiv
		jz      IsDIV
		; This is a signed division
		or      ch, 1000b   ; Flag Signed
IsDIV:
		and     bl, 111b    ; BL = r/m bits

		cmp     bh, 11b
		je      MOD_11


DoRMbits:

		cmp     bl, 000b
		je      RM_000
		cmp     bl, 001b
		je      RM_001
		cmp     bl, 010b
		je      RM_010
		cmp     bl, 011b
		je      RM_011
		cmp     bl, 100b
		je      RM_100
		cmp     bl, 101b
		je      RM_101
		cmp     bl, 110b
		je      RM_110
		jmp     RM_111

RM_000:
		add     esi, SAVED_EAX
		jmp     doneRM

RM_001:
		add     esi, SAVED_ECX
		jmp     doneRM

RM_010:
		add     esi, SAVED_EDX
		jmp     doneRM

RM_011:
		add     esi, SAVED_EBX
		jmp     doneRM

RM_100:
		jmp     RM_SIB


RM_101:
		cmp     bh, 00b
		je      DSdisp32

		add     esi, ebp
		mov     es, SAVED_SS
		jmp     doneRM

DSdisp32:
		mov     bh, 10b
		jmp     doneRM

RM_110:
		add     esi, SAVED_ESI
		jmp     doneRM

RM_111:
		add     esi, SAVED_EDI
		jmp     doneRM


RM_SIB:
		mov     bl, BYTE PTR CS:[eax]   ; BL = s-i-b byte

		mov     cl, bl
		shl     cl, 6

		shl     bl, 3
		and     bl, 111b

		cmp     bl, 000b
		je      INDEX_EAX
		cmp     bl, 001b
		je      INDEX_ECX
		cmp     bl, 010b
		je      INDEX_EDX
		cmp     bl, 011b
		je      INDEX_EBX
		cmp     bl, 100b
		je      doneSIB1
		cmp     bl, 101b
		je      INDEX_EBP
		cmp     bl, 110b
		je      INDEX_ESI
		jmp     INDEX_EDI


INDEX_EAX:
		mov     edx, SAVED_EAX
		jmp     doneSIB
INDEX_ECX:
		mov     edx, SAVED_ECX
		jmp     doneSIB
INDEX_EDX:
		mov     edx, SAVED_EDX
		jmp     doneSIB
INDEX_EBX:
		mov     edx, SAVED_EBX
		jmp     doneSIB
INDEX_EBP:
		mov     edx, ebp
		jmp     doneSIB
INDEX_ESI:
		mov     edx, SAVED_ESI
		jmp     doneSIB
INDEX_EDI:
		mov     edx, SAVED_EDI
		jmp     doneSIB

doneSIB:
		shl     edx, cl
		add     esi, edx


doneSIB1:
		mov     bl, BYTE PTR CS:[eax]   ; BL = s-i-b byte
		inc     eax

		mov     bh, bl
		shl     bh, 6
		and     bl, 111b
		jmp     DoRMbits


doneRM: ;BH = mod

		cmp     bh, 00b
		je      MOD_00
		cmp     bh, 01b
		je      MOD_01
		cmp     bh, 10b
		je      MOD_10
		jmp     MOD_11


MOD_00:     ; No displacement
		jmp     doneMOD

MOD_01: ; disp8
		movsx   edx, BYTE PTR CS:[eax]
		add     eax, 1
		add     esi, edx
		jmp     doneMOD

MOD_10:
		mov     edx, DWORD PTR CS:[eax]
		add     eax, 4
		add     esi, edx
		jmp     doneMOD

MOD_11: cmp     bl, 000b
		je      REG_000
		cmp     bl, 001b
		je      REG_001
		cmp     bl, 010b
		je      REG_010
		cmp     bl, 011b
		je      REG_011
		cmp     bl, 100b
		je      REG_100
		cmp     bl, 101b
		je      REG_101
		cmp     bl, 110b
		je      REG_110
		jmp     REG_111


REG_000:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_AL
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_AX
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    SAVED_EAX
		jmp     GotValue

REG_001:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_CL
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_CX
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    SAVED_ECX
		jmp     GotValue
REG_010:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_DL
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_DX
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    SAVED_EDX
		jmp     GotValue
REG_011:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_BL
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_BX
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    SAVED_EDX
		jmp     GotValue
REG_100:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_AH
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx    edx,    SAVED_SP
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    SAVED_ESP
		jmp     GotValue
REG_101:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_CH
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx   edx,    bp
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    ebp
		jmp     GotValue
REG_110:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_DH
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_SI
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    SAVED_ESI
		jmp     GotValue
REG_111:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_BH
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx   edx,    SAVED_DI
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    SAVED_EDI
		jmp     GotValue


doneMOD:
		test    ch, 1b              ; Check if 8-bit
		jz      @f                  ; Skip if not
		movsx   edx,    BYTE PTR ES:[esi]
@@:     test    ch, 10b             ; Check if 16-bit
		jz      @f                  ; Skip if not
		movsx   edx,    WORD PTR ES:[esi]
@@:     test    ch, 100b            ; Check if 32-bit
		jz      GotValue            ; skip if not
		mov     edx,    DWORD PTR ES:[esi]

GotValue:
		; EAX = Pointer to instruction right after DIV
		; CH = Bits 0=8bit, 1=16bit, 2=32bit, 3=DIV
		; EDX = 32-bit sign extended divisor (source operand)

		mov     BAD_EIP, eax    ; Point EIP to next instruction


		; if size=8  then AL=1..., AH=1...
		; if size=16 then AX=1..., DX=1...
		; if size=32 then EAX=1..., EDX=1...
		;
		; resultsign = - (Assume negative or unsigned)
		;
		; If signed then
		;    if size=8 then  resultsign = sign(ah:al) * sign(edx)
		;    if size=16 then resultsign = sign(dx:ax) * sign(edx)
		;    if size=32 then resultsign = sign(dx:ax) * sign(edx)
		;
		; if resultsign == + then
		;    if size=8 then  AL = 01...
		;    if size=16 then AX = 01...
		;    if size=32 then EAX = 01...
		;

		test    ch, 1000b
		jz      UnSigned

		shr     edx, 31

		; Signed return
		test    ch, 1b              ; Check if 8-bit
		jnz     Get8Sign
		test    ch, 10b             ; Check if 16-bit
		jnz     Get16Sign
		jmp     Get32Sign         ; Else is 32-bit

Get8Sign:
		mov     ah, SAVED_AH
		shr     ah, 7           ; AH = sign of divisor
		xor     ah, dl
		jnz     Neg8Return
		jmp     Pos8Return

Get16Sign:
		mov     ah, SAVED_DH
		shr     ah, 7           ; AH = sign of divisor
		xor     ah, dl
		jnz     Neg16Return
		jmp     Pos16Return

Get32Sign:
		mov     eax, SAVED_EDX
		shr     eax, 31           ; AL = sign of divisor
		xor     al, dl
		jnz     Neg32Return
		jmp     Pos32Return

UnSigned: ; We need to find the sign
		; Unsigned div return
		test    ch, 1b              ; Check if 8-bit
		jnz     Unsigned8Return
		test    ch, 10b             ; Check if 16-bit
		jnz     Unsigned16Return
		jmp     Unsigned32Return         ; Else is 32-bit


NormalReturn:
		pop     eax
		pop     ebx
		pop     ecx
		pop     edx
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf


Neg8Return:
		pop     eax
		mov     al, OVERFLOW_8BIT_NEGATIVE
		mov     ah, 0       ; Remainder = 0
		pop     ebx
		pop     ecx
		pop     edx
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf

Neg16Return:
		pop     eax
		mov     ax, OVERFLOW_16BIT_NEGATIVE
		pop     ebx
		pop     ecx
		pop     edx
		mov     dx, 0       ; Remainder = 0
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf

Neg32Return:
		pop     eax
		mov     eax, OVERFLOW_32BIT_NEGATIVE
		pop     ebx
		pop     ecx
		pop     edx
		mov     edx, 0          ; Remainder = 0
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf


Pos8Return:
		pop     eax
		mov     al, OVERFLOW_8BIT_POSITIVE
		mov     ah, 0           ; Remainder = 0
		pop     ebx
		pop     ecx
		pop     edx
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf

Pos16Return:
		pop     eax
		mov     ax, OVERFLOW_16BIT_POSITIVE
		pop     ebx
		pop     ecx
		pop     edx
		mov     dx, 0           ; Remainder = 0
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf

Pos32Return:
		pop     eax
		mov     eax, OVERFLOW_32BIT_POSITIVE
		pop     ebx
		pop     ecx
		pop     edx
		mov     edx, 0          ; Remainder = 0
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf

Unsigned8Return:
		pop     eax
		mov     al, OVERFLOW_8BIT_UNSIGNED
		mov     ah, 0       ; Remainder = 0
		pop     ebx
		pop     ecx
		pop     edx
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf

Unsigned16Return:
		pop     eax
		mov     ax, OVERFLOW_16BIT_UNSIGNED
		pop     ebx
		pop     ecx
		pop     edx
		mov     dx, 0       ; Remainder = 0
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf

Unsigned32Return:
		pop     eax
		mov     eax, OVERFLOW_32BIT_UNSIGNED
		pop     ebx
		pop     ecx
		pop     edx
		mov     edx, 0          ; Remainder = 0
		pop     esi
		pop     edi
		pop     es
		pop     ds
		retf


PUBLIC  div0_close_

div0_close_:
		push    eax
		push    ecx
		push    edx

		mov     Already_Init, 0

		mov     eax, 0203h
		mov     bl, 0
		mov     cx, Old_Ex_Sel
		mov     edx, Old_Ex_Off
		int     31h

		pop     edx
		pop     ecx
		pop     eax

		ret





PUBLIC  div0_set_saturate_

div0_set_saturate_:
		; EAX = div_addr

		push    ecx

		xor     ecx, ecx
		mov     cx, SAT_Size
		inc     cx
		cmp     cx, MAX_SIZE
		jae     TooMany1
		mov     SAT_Size, cx

		dec     ecx
		mov     SAT_Source[ecx*4], eax

		mov     eax, 1
		pop     ecx
		ret

TooMany1:
		mov     eax, 0
		pop     ecx
		ret


PUBLIC  div0_set_handler_

div0_set_handler_:
		; EAX = div_addr
		; EDX = handler_addr
		push    ecx

		xor     ecx, ecx
		mov     cx, CB_Size
		inc     cx
		cmp     cx, MAX_SIZE
		jae     TooMany
		mov     CB_Size, cx

		dec     ecx
		mov     CB_Source[ecx*4], eax
		mov     CB_Dest[ecx*4], edx

		mov     eax, 1
		pop     ecx
		ret

TooMany:
		mov     eax, 0
		pop     ecx
		ret



PUBLIC  div0_set_mode_

div0_set_mode_:
		and     eax, 1
		mov     DefaultMode, eax
		ret


PUBLIC  div0_init_

div0_init_:
		push    ds
		push    ebx
		push    ecx
		push    edx

		cmp     Already_Init, 1
		je      AlreadyInstalled

		mov     Already_Init, 1

	       	mov	_div0_num_handled_by_cblist, 0
		mov	_div0_num_handled_by_satlist, 0
		mov	_div0_num_saturated, 0

		and     eax, 1
		mov     DefaultMode, eax

		mov     SAT_Size, 0
		mov     CB_Size, 0

		mov     eax, 0202h
		mov     bl, 0
		int     31h
		jc      ToBadSoSadItFailed
		mov     Old_Ex_Sel,cx
		mov     Old_Ex_Off,edx

		mov     eax, 0203h
		mov     bl, 0
		mov     cx, cs
		mov     edx, offset DivideByZeroException
		int     31h
		jc      ToBadSoSadItFailed

AlreadyInstalled:
		mov     eax, 1
		pop     edx
		pop     ecx
		pop     ebx
		pop     ds
		ret

ToBadSoSadItFailed:
		mov     eax, 0
		pop     edx
		pop     ebx
		pop     ds
		ret

_TEXT   ENDS


		END