page ,132
;---------------------------Module-Header-------------------------------;
; Module Name: MATH.ASM
;
; Contains FIXED point math routines.
;
; Created: Sun 30-Aug-1987 19:28:30
; Author: Charles Whitmer [chuckwh]
;
; Copyright (c) 1987 Microsoft Corporation
;-----------------------------------------------------------------------;
?WIN = 0
?PLM = 1
?NODATA = 0
.286
.xlist
include cmacros.inc
include windows.inc
.list
externA __WinFlags
UQUAD struc
uq0 dw ?
uq1 dw ?
uq2 dw ?
uq3 dw ?
UQUAD ends
; The following two equates are just used as shorthand
; for the "word ptr" and "byte ptr" overrides.
wptr equ word ptr
bptr equ byte ptr
; The following structure should be used to access high and low
; words of a DWORD. This means that "word ptr foo[2]" -> "foo.hi".
LONG struc
lo dw ?
hi dw ?
LONG ends
EAXtoDXAX macro
shld edx,eax,16 ; move HIWORD(eax) to dx
endm
DXAXtoEAX macro
ror eax,16 ; xchg HIWORD(eax) and LOWORD(eax)
shrd eax,edx,16 ; move LOWORD(edx) to HIWORD(eax)
endm
neg32 macro hi, lo
neg lo
adc hi,0 ; carry set unless lo zero
neg hi
endm
ifndef SEGNAME
SEGNAME equ <_TEXT>
endif
createSeg %SEGNAME, CodeSeg, word, public, CODE
sBegin CodeSeg
assumes cs,CodeSeg
assumes ds,nothing
assumes es,nothing
;---------------------------Public-Routine------------------------------;
; long muldiv32(long, long, long)
;
; multiples two 32 bit values and then divides the result by a third
; 32 bit value with full 64 bit presision
;
; lResult = (lNumber * lNumerator) / lDenominator with correct rounding
;
; Entry:
; lNumber = number to multiply by nNumerator
; lNumerator = number to multiply by nNumber
; lDenominator = number to divide the multiplication result by.
;
; Returns:
; DX:AX = result of multiplication and division.
;
; Error Returns:
; none
; Registers Preserved:
; DS,ES,SI,DI
; History:
; Fri 05-Oct-1990 -by- Rob Williams [Robwi]
; Behavior consistent with MulDiv16 routine (signed, no int 0 on overflow)
; Stole muldiv16 psuedocode
;
; Wed 14-June-1990 -by- Todd Laney [ToddLa]
; converted it to 386/286 code. (by checking __WinFlags)
;
; Tue 08-May-1990 -by- Rob Williams [Robwi]
; Wrote it.
;
;----------------------------Pseudo-Code--------------------------------;
; long FAR PASCAL muldiv32(long, long, long)
; long l;
; long Numer;
; long Denom;
; {
;
; Sign = sign of Denom; // Sign will keep track of final sign //
;
;
; if (Denom < 0)
; {
; negate Denom; // make sure Denom is positive //
; }
;
; if (l < 0)
; {
; negate l; // make sure l is positive //
; }
;
; make Sign reflect any sign change;
;
;
; if (Numer < 0)
; {
; negate Numer; // make sure Numer is positive //
; }
;
; make Sign reflect any sign change;
;
; Numer *= l;
; Numer += (Denom/2); // adjust for rounding //
;
; if (overflow) // check for overflow, and handle divide by zero //
; {
; jump to md5;
; }
;
; result = Numer/Denom;
;
; if (overflow) // check again to see if overflow occured //
; {
; jump to md5;
; }
;
; if (Sign is negative) // put sign on the result //
; {
; negate result;
; }
;
;md6:
; return(result);
;
;md5:
; DX = 7FFF; // indicate overflow by //
; AX = 0xFFFF // return largest integer //
; if (Sign is negative)
; {
; DX = 0x8000; // with correct sign //
; AX = 0x0000;
; }
;
; jump to md6;
; }
;-----------------------------------------------------------------------;
assumes ds,nothing
assumes es,nothing
cProc muldiv32,<PUBLIC,FAR,NODATA,NONWIN>,<>
; ParmD lNumber
; ParmD lNumerator
; ParmD lDenominator
cBegin <nogen>
mov ax,__WinFlags
test ax,WF_CPU286+WF_CPU086+WF_CPU186
jz md32_1
jmp NEAR PTR muldiv32_286
md32_1:
errn$ muldiv32_386
cEnd <nogen>
cProc muldiv32_386,<PUBLIC,FAR,NODATA,NONWIN>,<>
ParmD lNumber
ParmD lNumerator
ParmD lDenominator
cBegin
.386
mov ebx,lDenominator ; get the demoninator
mov ecx,ebx ; ECX holds the final sign in hiword
or ebx,ebx ; ensure the denominator is positive
jns md386_1
neg ebx
md386_1:
mov eax,lNumber ; get the long we are multiplying
xor ecx,eax ; make ECX reflect any sign change
or eax,eax ; ensure the long is positive
jns md386_2
neg eax
md386_2:
mov edx,lNumerator ; get the numerator
xor ecx,edx ; make ECX reflect any sign change
or edx,edx ; ensure the numerator is positive
jns md386_3
neg edx
md386_3:
mul edx ; multiply
mov cx,bx ; get half of the demoninator to adjust for rounding
sar ebx,1
add eax,ebx ; adjust for possible rounding error
adc edx,0 ; this is really a long addition
sal ebx,1 ; restore the demoninator
or bx,cx ; fix bottom bit
cmp edx,ebx ; check for overflow
jae md386_5 ; (ae handles /0 case)
div ebx ; divide
or eax,eax ; If sign is set, then overflow occured
js md386_5 ; Overflow.
or ecx,ecx ; put the sign on the result
jns md386_6
neg eax
md386_6:
EAXtoDXAX ; convert eax to dx:ax for 16 bit programs
.286
cEnd
.386
md386_5:
mov eax,7FFFFFFFh ; return the largest integer
or ecx,ecx ; with the correct sign
jns md386_6
not eax
jmp md386_6
.286
cProc muldiv32_286,<PUBLIC,FAR,NODATA,NONWIN>,<di,si>
ParmD lNumber
ParmD lNumerator
ParmD lDenominator
LocalW wSign
cBegin
mov dx,lDenominator.hi ; get the demoninator
mov si,dx ; SI holds the final sign
or dx,dx ; ensure the denominator is positive
jns md286_1
neg32 dx, lDenominator.lo
mov lDenominator.hi, dx
md286_1:
mov ax,lNumber.lo ; get the long we are multiplying
mov dx,lNumber.hi
xor si,dx ; make ECX reflect any sign change
or dx,dx ; ensure the long is positive
jns md286_2
neg32 dx, ax
md286_2:
mov bx,lNumerator.lo ; get the numerator
mov cx,lNumerator.hi ; get the numerator
xor si,cx ; make ECX reflect any sign change
or cx,cx ; ensure the numerator is positive
jns md286_3
neg32 cx, bx
md286_3:
mov wSign, si ; save sign
call dmul ; multiply (result in dx:cx:bx:ax)
mov si, lDenominator.hi
mov di, lDenominator.lo
sar si, 1 ; get half of the demoninator
rcr di, 1 ; to adjust for rounding
add ax, di ; adjust for possible rounding error
adc bx, si
adc cx, 0
adc dx, 0 ; this is really a long addition
sal di, 1 ; restore the demoninator
rcl si, 1
or di, lDenominator.lo ; fix bottom bit
cmp dx, si ; begin overflow check (unsigned for div 0 check)
ja md286_5 ; overflow
jb md286_7 ; no overflow
cmp cx, di
jae md286_5 ; overflow
md286_7:
call qdiv ; DX:AX is quotient
or dx,dx ; If sign is set, then overflow occured
js md286_5 ; Overflow.
mov cx, wSign
or cx,cx ; put the sign on the result
jns md286_6
neg32 dx,ax
md286_6:
cEnd
md286_5:
mov cx, wSign
mov ax, 0FFFFh ; return the largest integer
mov dx, 7FFFh
or cx, cx ; with the correct sign
jns md286_6
not dx
not ax
jmp md286_6
cProc muldivru32,<PUBLIC,FAR,NODATA,NONWIN>,<>
; ParmD lNumber
; ParmD lNumerator
; ParmD lDenominator
cBegin <nogen>
mov ax,__WinFlags
test ax,WF_CPU286+WF_CPU086+WF_CPU186
jz mdru32_1
jmp NEAR PTR muldivru32_286
mdru32_1:
errn$ muldivru32_386
cEnd <nogen>
cProc muldivru32_386,<PUBLIC,FAR,NODATA,NONWIN>,<>
ParmD lNumber
ParmD lNumerator
ParmD lDenominator
cBegin
.386
mov ebx,lDenominator ; get the demoninator
mov ecx,ebx ; ECX holds the final sign in hiword
or ebx,ebx ; ensure the denominator is positive
jns mdru386_1
neg ebx
mdru386_1:
mov eax,lNumber ; get the long we are multiplying
xor ecx,eax ; make ECX reflect any sign change
or eax,eax ; ensure the long is positive
jns mdru386_2
neg eax
mdru386_2:
mov edx,lNumerator ; get the numerator
xor ecx,edx ; make ECX reflect any sign change
or edx,edx ; ensure the numerator is positive
jns mdru386_3
neg edx
mdru386_3:
mul edx ; multiply
mov cx,bx ; get demoninator - 1 to adjust for rounding
sub ebx,1
add eax,ebx ; adjust for possible rounding error
adc edx,0 ; this is really a long addition
add ebx,1 ; restore the demoninator
cmp edx,ebx ; check for overflow
jae mdru386_5 ; (ae handles /0 case)
div ebx ; divide
or eax,eax ; If sign is set, then overflow occured
js mdru386_5 ; Overflow.
or ecx,ecx ; put the sign on the result
jns mdru386_6
neg eax
mdru386_6:
EAXtoDXAX ; convert eax to dx:ax for 16 bit programs
.286
cEnd
.386
mdru386_5:
mov eax,7FFFFFFFh ; return the largest integer
or ecx,ecx ; with the correct sign
jns mdru386_6
not eax
jmp mdru386_6
.286
cProc muldivru32_286,<PUBLIC,FAR,NODATA,NONWIN>,<di,si>
ParmD lNumber
ParmD lNumerator
ParmD lDenominator
LocalW wSign
cBegin
mov dx,lDenominator.hi ; get the demoninator
mov si,dx ; SI holds the final sign
or dx,dx ; ensure the denominator is positive
jns mdru286_1
neg32 dx, lDenominator.lo
mov lDenominator.hi, dx
mdru286_1:
mov ax,lNumber.lo ; get the long we are multiplying
mov dx,lNumber.hi
xor si,dx ; make ECX reflect any sign change
or dx,dx ; ensure the long is positive
jns mdru286_2
neg32 dx, ax
mdru286_2:
mov bx,lNumerator.lo ; get the numerator
mov cx,lNumerator.hi ; get the numerator
xor si,cx ; make ECX reflect any sign change
or cx,cx ; ensure the numerator is positive
jns mdru286_3
neg32 cx, bx
mdru286_3:
mov wSign, si ; save sign
call dmul ; multiply (result in dx:cx:bx:ax)
mov si, lDenominator.hi
mov di, lDenominator.lo
sub di, 1 ; get demoninator - 1
sbb si, 0 ; to adjust for rounding
add ax, di ; adjust for possible rounding error
adc bx, si
adc cx, 0
adc dx, 0 ; this is really a long addition
add di, 1 ; restore the demoninator
adc si, 0
cmp dx, si ; begin overflow check (unsigned for div 0 check)
ja mdru286_5 ; overflow
jb mdru286_7 ; no overflow
cmp cx, di
jae mdru286_5 ; overflow
mdru286_7:
call qdiv ; DX:AX is quotient
or dx,dx ; If sign is set, then overflow occured
js mdru286_5 ; Overflow.
mov cx, wSign
or cx,cx ; put the sign on the result
jns mdru286_6
neg32 dx,ax
mdru286_6:
cEnd
mdru286_5:
mov cx, wSign
mov ax, 0FFFFh ; return the largest integer
mov dx, 7FFFh
or cx, cx ; with the correct sign
jns mdru286_6
not dx
not ax
jmp mdru286_6
cProc muldivrd32,<PUBLIC,FAR,NODATA,NONWIN>,<>
; ParmD lNumber
; ParmD lNumerator
; ParmD lDenominator
cBegin <nogen>
mov ax,__WinFlags
test ax,WF_CPU286+WF_CPU086+WF_CPU186
jz mdrd32_1
jmp NEAR PTR muldivrd32_286
mdrd32_1:
errn$ muldivrd32_386
cEnd <nogen>
cProc muldivrd32_386,<PUBLIC,FAR,NODATA,NONWIN>,<>
ParmD lNumber
ParmD lNumerator
ParmD lDenominator
cBegin
.386
mov ebx,lDenominator ; get the demoninator
mov ecx,ebx ; ECX holds the final sign in hiword
or ebx,ebx ; ensure the denominator is positive
jns mdrd386_1
neg ebx
mdrd386_1:
mov eax,lNumber ; get the long we are multiplying
xor ecx,eax ; make ECX reflect any sign change
or eax,eax ; ensure the long is positive
jns mdrd386_2
neg eax
mdrd386_2:
mov edx,lNumerator ; get the numerator
xor ecx,edx ; make ECX reflect any sign change
or edx,edx ; ensure the numerator is positive
jns mdrd386_3
neg edx
mdrd386_3:
mul edx ; multiply
div ebx ; divide
or eax,eax ; If sign is set, then overflow occured
js mdrd386_5 ; Overflow.
or ecx,ecx ; put the sign on the result
jns mdrd386_6
neg eax
mdrd386_6:
EAXtoDXAX ; convert eax to dx:ax for 16 bit programs
.286
cEnd
.386
mdrd386_5:
mov eax,7FFFFFFFh ; return the largest integer
or ecx,ecx ; with the correct sign
jns mdrd386_6
not eax
jmp mdrd386_6
.286
cProc muldivrd32_286,<PUBLIC,FAR,NODATA,NONWIN>,<di,si>
ParmD lNumber
ParmD lNumerator
ParmD lDenominator
LocalW wSign
cBegin
mov dx,lDenominator.hi ; get the demoninator
mov si,dx ; SI holds the final sign
or dx,dx ; ensure the denominator is positive
jns mdrd286_1
neg32 dx, lDenominator.lo
mov lDenominator.hi, dx
mdrd286_1:
mov ax,lNumber.lo ; get the long we are multiplying
mov dx,lNumber.hi
xor si,dx ; make ECX reflect any sign change
or dx,dx ; ensure the long is positive
jns mdrd286_2
neg32 dx, ax
mdrd286_2:
mov bx,lNumerator.lo ; get the numerator
mov cx,lNumerator.hi ; get the numerator
xor si,cx ; make ECX reflect any sign change
or cx,cx ; ensure the numerator is positive
jns mdrd286_3
neg32 cx, bx
mdrd286_3:
mov wSign, si ; save sign
call dmul ; multiply (result in dx:cx:bx:ax)
mov si, lDenominator.hi
mov di, lDenominator.lo
cmp dx, si ; begin overflow check (unsigned for div 0 check)
ja mdrd286_5 ; overflow
jb mdrd286_7 ; no overflow
cmp cx, di
jae mdrd286_5 ; overflow
mdrd286_7:
call qdiv ; DX:AX is quotient
or dx,dx ; If sign is set, then overflow occured
js mdrd286_5 ; Overflow.
mov cx, wSign
or cx,cx ; put the sign on the result
jns mdrd286_6
neg32 dx,ax
mdrd286_6:
cEnd
mdrd286_5:
mov cx, wSign
mov ax, 0FFFFh ; return the largest integer
mov dx, 7FFFh
or cx, cx ; with the correct sign
jns mdrd286_6
not dx
not ax
jmp mdrd286_6
;---------------------------Public-Routine------------------------------;
; idmul
;
; This is an extended precision multiply routine, intended to emulate
; 80386 imul instruction.
;
; Entry:
; DX:AX = LONG
; CX:BX = LONG
; Returns:
; DX:CX:BX:AX = QUAD product
; Registers Destroyed:
; none
; History:
; Tue 26-Jan-1988 23:47:02 -by- Charles Whitmer [chuckwh]
; Wrote it.
;-----------------------------------------------------------------------;
assumes ds,nothing
assumes es,nothing
cProc idmul,<PUBLIC,NEAR>,<si,di>
localQ qTemp
cBegin
; put one argument in safe registers
mov si,dx
mov di,ax
; do the low order unsigned product
mul bx
mov qTemp.uq0,ax
mov qTemp.uq1,dx
; do the high order signed product
mov ax,si
imul cx
mov qTemp.uq2,ax
mov qTemp.uq3,dx
; do a mixed product
mov ax,si
cwd
and dx,bx
sub qTemp.uq2,dx ; adjust for sign bit
sbb qTemp.uq3,0
mul bx
add qTemp.uq1,ax
adc qTemp.uq2,dx
adc qTemp.uq3,0
; do the other mixed product
mov ax,cx
cwd
and dx,di
sub qTemp.uq2,dx
sbb qTemp.uq3,0
mul di
; pick up the answer
mov bx,ax
mov cx,dx
xor dx,dx
mov ax,qTemp.uq0
add bx,qTemp.uq1
adc cx,qTemp.uq2
adc dx,qTemp.uq3
cEnd
;---------------------------Public-Routine------------------------------;
; dmul
;
; This is an extended precision multiply routine, intended to emulate
; 80386 mul instruction.
;
; Entry:
; DX:AX = LONG
; CX:BX = LONG
; Returns:
; DX:CX:BX:AX = QUAD product
; Registers Destroyed:
; none
; History:
; Tue 02-Feb-1988 10:50:44 -by- Charles Whitmer [chuckwh]
; Copied from idmul and modified.
;-----------------------------------------------------------------------;
assumes ds,nothing
assumes es,nothing
cProc dmul,<PUBLIC,NEAR>,<si,di>
localQ qTemp
cBegin
; put one argument in safe registers
mov si,dx
mov di,ax
; do the low order product
mul bx
mov qTemp.uq0,ax
mov qTemp.uq1,dx
; do the high order product
mov ax,si
mul cx
mov qTemp.uq2,ax
mov qTemp.uq3,dx
; do a mixed product
mov ax,si
mul bx
add qTemp.uq1,ax
adc qTemp.uq2,dx
adc qTemp.uq3,0
; do the other mixed product
mov ax,cx
mul di
; pick up the answer
mov bx,ax
mov cx,dx
xor dx,dx
mov ax,qTemp.uq0
add bx,qTemp.uq1
adc cx,qTemp.uq2
adc dx,qTemp.uq3
cEnd
;---------------------------Public-Routine------------------------------;
; iqdiv
;
; This is an extended precision divide routine which is intended to
; emulate the 80386 64 bit/32 bit IDIV instruction. We don't have the
; 32 bit registers to work with, but we pack the arguments and results
; into what registers we do have. We will divide two signed numbers
; and return the quotient and remainder. We will do INT 0 for overflow,
; just like the 80386 microcode. This should ease conversion later.
;
; This routine just keeps track of the signs and calls qdiv to do the
; real work.
;
; Entry:
; DX:CX:BX:AX = QUAD Numerator
; SI:DI = LONG Denominator
; Returns:
; DX:AX = quotient
; CX:BX = remainder
; Registers Destroyed:
; DI,SI
; History:
; Tue 26-Jan-1988 02:49:19 -by- Charles Whitmer [chuckwh]
; Wrote it.
;-----------------------------------------------------------------------;
WIMP equ 1
IQDIV_RESULT_SIGN equ 1
IQDIV_REM_SIGN equ 2
assumes ds,nothing
assumes es,nothing
cProc iqdiv,<PUBLIC,NEAR>
localB flags
cBegin
mov flags,0
; take the absolute value of the denominator
or si,si
jns denominator_is_cool
xor flags,IQDIV_RESULT_SIGN
neg di
adc si,0
neg si
denominator_is_cool:
; take the absolute value of the denominator
or dx,dx
jns numerator_is_cool
xor flags,IQDIV_RESULT_SIGN + IQDIV_REM_SIGN
not ax
not bx
not cx
not dx
add ax,1
adc bx,0
adc cx,0
adc dx,0
numerator_is_cool:
; do the unsigned division
call qdiv
ifdef WIMP
jo iqdiv_exit
endif
; check for overflow
or dx,dx
jns have_a_bit_to_spare
ifdef WIMP
mov ax,8000h
dec ah
jmp short iqdiv_exit
else
int 0 ; You're toast, Jack!
endif
have_a_bit_to_spare:
; negate the result, if required
test flags,IQDIV_RESULT_SIGN
jz result_is_done
neg ax
adc dx,0
neg dx
result_is_done:
; negate the remainder, if required
test flags,IQDIV_REM_SIGN
jz remainder_is_done
neg bx
adc cx,0
neg cx
remainder_is_done:
iqdiv_exit:
cEnd
;---------------------------Public-Routine------------------------------;
; qdiv
;
; This is an extended precision divide routine which is intended to
; emulate the 80386 64 bit/32 bit DIV instruction. We don't have the
; 32 bit registers to work with, but we pack the arguments and results
; into what registers we do have. We will divide two unsigned numbers
; and return the quotient and remainder. We will do INT 0 for overflow,
; just like the 80386 microcode. This should ease conversion later.
;
; Entry:
; DX:CX:BX:AX = UQUAD Numerator
; SI:DI = ULONG Denominator
; Returns:
; DX:AX = quotient
; CX:BX = remainder
; Registers Destroyed:
; none
; History:
; Tue 26-Jan-1988 00:02:09 -by- Charles Whitmer [chuckwh]
; Wrote it.
;-----------------------------------------------------------------------;
assumes ds,nothing
assumes es,nothing
cProc qdiv,<PUBLIC,NEAR>,<si,di>
localQ uqNumerator
localD ulDenominator
localD ulQuotient
localW cShift
cBegin
; stuff the quad word into local memory
mov uqNumerator.uq0,ax
mov uqNumerator.uq1,bx
mov uqNumerator.uq2,cx
mov uqNumerator.uq3,dx
; check for overflow
qdiv_restart:
cmp si,dx
ja qdiv_no_overflow
jb qdiv_overflow
cmp di,cx
ja qdiv_no_overflow
qdiv_overflow:
ifdef WIMP
mov ax,8000h
dec ah
jmp qdiv_exit
else
int 0 ; You're toast, Jack!
jmp qdiv_restart
endif
qdiv_no_overflow:
; check for a zero Numerator
or ax,bx
or ax,cx
or ax,dx
jz qdiv_exit_relay ; quotient = remainder = 0
; handle the special case when the denominator lives in the low word
or si,si
jnz not_that_special
; calculate (DX=0):CX:BX:uqNumerator.uq0 / (SI=0):DI
cmp di,1 ; separate out the trivial case
jz div_by_one
xchg dx,cx ; CX = remainder.hi = 0
mov ax,bx
div di
mov bx,ax ; BX = quotient.hi
mov ax,uqNumerator.uq0
div di ; AX = quotient.lo
xchg bx,dx ; DX = quotient.hi, BX = remainder.lo
ifdef WIMP
or ax,ax ; clear OF
endif
qdiv_exit_relay:
jmp qdiv_exit
; calculate (DX=0):(CX=0):BX:uqNumerator.uq0 / (SI=0):(DI=1)
div_by_one:
xchg dx,bx ; DX = quotient.hi, BX = remainder.lo = 0
mov ax,uqNumerator.uq0 ; AX = quotient.lo
jmp qdiv_exit
not_that_special:
; handle the special case when the denominator lives in the high word
or di,di
jnz not_this_special_either
; calculate DX:CX:BX:uqNumerator.uq0 / SI:(DI=0)
cmp si,1 ; separate out the trivial case
jz div_by_10000h
mov ax,cx
div si
mov cx,ax ; CX = quotient.hi
mov ax,bx
div si ; AX = quotient.lo
xchg cx,dx ; DX = quotient.hi, CX = remainder.hi
mov bx,uqNumerator.uq0 ; BX = remainder.lo
ifdef WIMP
or ax,ax ; clear OF
endif
jmp qdiv_exit
; calculate (DX=0):CX:BX:uqNumerator.uq0 / (SI=1):(DI=0)
div_by_10000h:
xchg cx,dx ; DX = quotient.hi, CX = remainder.hi = 0
mov ax,bx ; AX = quotient.lo
mov bx,uqNumerator.uq0 ; BX = remainder.lo
jmp qdiv_exit
not_this_special_either:
; normalize the denominator
mov dx,si
mov ax,di
call ulNormalize ; DX:AX = normalized denominator
mov cShift,cx ; CX < 16
mov ulDenominator.lo,ax
mov ulDenominator.hi,dx
; shift the Numerator by the same amount
jcxz numerator_is_shifted
mov si,-1
shl si,cl
not si ; SI = mask
mov bx,uqNumerator.uq3
shl bx,cl
mov ax,uqNumerator.uq2
rol ax,cl
mov di,si
and di,ax
or bx,di
mov uqNumerator.uq3,bx
xor ax,di
mov bx,uqNumerator.uq1
rol bx,cl
mov di,si
and di,bx
or ax,di
mov uqNumerator.uq2,ax
xor bx,di
mov ax,uqNumerator.uq0
rol ax,cl
mov di,si
and di,ax
or bx,di
mov uqNumerator.uq1,bx
xor ax,di
mov uqNumerator.uq0,ax
numerator_is_shifted:
; set up registers for division
mov dx,uqNumerator.uq3
mov ax,uqNumerator.uq2
mov di,uqNumerator.uq1
mov cx,ulDenominator.hi
mov bx,ulDenominator.lo
; check for case when Denominator has only 16 bits
or bx,bx
jnz must_do_long_division
div cx
mov si,ax
mov ax,uqNumerator.uq1
div cx
xchg si,dx ; DX:AX = quotient
mov di,uqNumerator.uq0 ; SI:DI = remainder (shifted)
jmp short unshift_remainder
must_do_long_division:
; do the long division, part IZ@NL@%
cmp dx,cx ; we only know that DX:AX < CX:BX!
jb first_division_is_safe
mov ulQuotient.hi,0 ; i.e. 10000h, our guess is too big
mov si,ax
sub si,bx ; ... remainder is negative
jmp short first_adjuster
first_division_is_safe:
div cx
mov ulQuotient.hi,ax
mov si,dx
mul bx ; fix remainder for low order term
sub di,ax
sbb si,dx
jnc first_adjuster_done ; The remainder is UNSIGNED! We have
first_adjuster: ; to use the carry flag to keep track
dec ulQuotient.hi ; of the sign. The adjuster loop
add di,bx ; watches for a change to the carry
adc si,cx ; flag which would indicate a sign
jnc first_adjuster ; change IF we had more bits to keep
first_adjuster_done: ; a sign in.
; do the long division, part II
mov dx,si
mov ax,di
mov di,uqNumerator.uq0
cmp dx,cx ; we only know that DX:AX < CX:BX!
jb second_division_is_safe
mov ulQuotient.lo,0 ; i.e. 10000h, our guess is too big
mov si,ax
sub si,bx ; ... remainder is negative
jmp short second_adjuster
second_division_is_safe:
div cx
mov ulQuotient.lo,ax
mov si,dx
mul bx ; fix remainder for low order term
sub di,ax
sbb si,dx
jnc second_adjuster_done
second_adjuster:
dec ulQuotient.lo
add di,bx
adc si,cx
jnc second_adjuster
second_adjuster_done:
mov ax,ulQuotient.lo
mov dx,ulQuotient.hi
; unshift the remainder in SI:DI
unshift_remainder:
mov cx,cShift
jcxz remainder_unshifted
mov bx,-1
shr bx,cl
not bx
shr di,cl
ror si,cl
and bx,si
or di,bx
xor si,bx
remainder_unshifted:
mov cx,si
mov bx,di
ifdef WIMP
or ax,ax ; clear OF
endif
qdiv_exit:
cEnd
;---------------------------Public-Routine------------------------------;
; ulNormalize
;
; Normalizes a ULONG so that the highest order bit is 1. Returns the
; number of shifts done. Also returns ZF=1 if the ULONG was zero.
;
; Entry:
; DX:AX = ULONG
; Returns:
; DX:AX = normalized ULONG
; CX = shift count
; ZF = 1 if the ULONG is zero, 0 otherwise
; Registers Destroyed:
; none
; History:
; Mon 25-Jan-1988 22:07:03 -by- Charles Whitmer [chuckwh]
; Wrote it.
;-----------------------------------------------------------------------;
assumes ds,nothing
assumes es,nothing
cProc ulNormalize,<PUBLIC,NEAR>
cBegin
; shift by words
xor cx,cx
or dx,dx
js ulNormalize_exit
jnz top_word_ok
xchg ax,dx
or dx,dx
jz ulNormalize_exit ; the zero exit
mov cl,16
js ulNormalize_exit
top_word_ok:
; shift by bytes
or dh,dh
jnz top_byte_ok
xchg dh,dl
xchg dl,ah
xchg ah,al
add cl,8
or dh,dh
js ulNormalize_exit
top_byte_ok:
; do the rest by bits
inc cx
add ax,ax
adc dx,dx
js ulNormalize_exit
inc cx
add ax,ax
adc dx,dx
js ulNormalize_exit
inc cx
add ax,ax
adc dx,dx
js ulNormalize_exit
inc cx
add ax,ax
adc dx,dx
js ulNormalize_exit
inc cx
add ax,ax
adc dx,dx
js ulNormalize_exit
inc cx
add ax,ax
adc dx,dx
js ulNormalize_exit
inc cx
add ax,ax
adc dx,dx
ulNormalize_exit:
cEnd
sEnd CodeSeg
end