;
StdGrp		group	StdLib, StdData
;
StdData		segment	para public 'sldata'
;
; Floating point package.
;
;
; Released to the public domain
; Created by: Randall Hyde
; Date: 8/13/90
;	8/28/91
;
;
; FP format:
;
; 80 bits:
; bit 79            bit 63                           bit 0
; |                 |                                    |
; seeeeeee eeeeeeee mmmmmmmm m...m m...m m...m m...m m...m
;
; e = bias 16384 exponent
; m = 64 bit mantissa with NO implied bit!
; s = sign (for mantissa)
;
;
; 64 bits:
; bit 63       bit 51                                               bit 0
; |            |                                                        |
; seeeeeee eeeemmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm
;
; e = bias 1023 exponent.
; s = sign bit.
; m = mantissa bits.  Bit 52 is an implied one bit.
;
; 32 bits:
; Bit 31    Bit 22              Bit 0
; |         |                       |
; seeeeeee emmmmmmm mmmmmmmm mmmmmmmm
;
; e = bias 127 exponent
; s = sign bit
; m = mantissa bits, bit 23 is an implied one bit.
;
;
;
; WARNING: Although this package uses IEEE format floating point numbers,
;	   it is by no means IEEE compliant.  In particular, it does not
;	   support denormalized numbers, special rounding options, and
;	   so on.  Why not?  Two reasons:  I'm lazy and I'm ignorant.
;	   I do not know all the little details surround the IEEE
;	   implementation and I'm not willing to spend more of my life
;	   (than I already have) figuring it out.  There are more
;	   important things to do in life.  Yep, numerical analysts can
;	   rip this stuff to shreads and come up with all kinds of degenerate
;	   cases where this package fails and the IEEE algorithms succeed,
;	   however, such cases are very rare.  One should not get the idea
;	   that IEEE is perfect.  It blows up with lots of degenerate cases
;	   too.  They just designed it so that it handles a few additional
;	   cases that mediocre packages (like this one) do not.  For most
;	   normal computations this package works just fine (what it lacks
;	   it good algorithms it more than makes up for by using an 88-bit
;	   internal format during internal computations).
;
;	   Moral of the story: If you need highly accurate routines which
;          produce okay results in the worst of cases, look elsewhere please.
;	   I don't want to be responsible for your blowups.  OTOH, if you need
;	   a fast floating point package which is reasonably accurate and
;	   you're not a statistician, astronomer, or other type for whom
;	   features like denormalized numbers are important, this package
;	   may work out just fine for you.
;
;						Randy Hyde
;						August 1990
;						(Hard to believe I started this
;						 a year ago and I'm just coming
;						 back to it now!)
;
;						UC Riverside &
;						Cal Poly Pomona.
;
; FPACC- Floating point accumuator.
; FPOP-  Floating point operand.
;
; These variables use the following format:
;
; 88 bits:
; sxxxxxxx eeeeeeee eeeeeeee m..m m..m m..m m..m m..m m..m m..m m..m
; Sign          exponent                   mantissa (64 bits)
;
; Only H.O. bit of Sign byte is significant.  The rest is garbage.
; Exponent is bias 32767 exponent.
; Mantissa does NOT have an implied one bit.
;
; This format was picked for convenience (it is easy to work with) and it
; exceeds the 80-bit format used by Intel on the 80x87 chips.
;
fptype		struc
Mantissa	dw	4 dup (?)
Exponent	dw	?
Sign		db	?
		db	?		;Padding
fptype		ends
;
;
;
;
		public	fpacc
fpacc		fptype	<>
;
		public	fpop
fpop		fptype  <>
;
;
; FProd- Holds 144-bit result obtained by multiplying fpacc.mant x fpop.mant
;
Quotient	equ	this word
fprod		dw	9 dup (?)
;
;
; Variables used by the floating point I/O routines:
;
TempExp		dw	?
ExpSign		db	?
DecExponent	dw	?
DecSign		db	0
DecDigits	db	31 dup (?)
;
;
;
StdData		ends
;
;
stdlib		segment	para public 'slcode'
		assume	cs:stdgrp, ds:nothing, es:nothing, ss:nothing
;
;
;
;
;
;
;
;
;
;
;---------------------------------------------------------------------------
;		Floating Point Load/Store Routines
;---------------------------------------------------------------------------
;
; sl_AccOp	Copies the floating point accumulator to the floating point
;		operand.
;
		public	sl_AccOp
sl_AccOp	proc	far
		assume	ds:StdGrp
		push	ax
		push	ds
		mov	ax, StdGrp
		mov	ds, ax
;
		mov	ax, FPacc.Exponent
		mov	FPop.Exponent, ax
		mov	ax, FPacc.Mantissa
		mov	FPop.Mantissa, ax
		mov	ax, FPacc.Mantissa+2
		mov	FPop.Mantissa+2, ax
		mov	ax, FPacc.Mantissa+4
		mov	FPop.Mantissa+4, ax
		mov	ax, FPacc.Mantissa+6
		mov	FPop.Mantissa+6, ax
		mov	al, Fpacc.Sign
		mov	FPop.Sign, al
;
		pop	ds
		pop	ax
		ret
sl_AccOp	endp
		assume	ds:nothing
;
;
; sl_XAccOp-	Exchanges the values in the floating point accumulator
;		and floating point operand.
;
		public	sl_XAccOp
sl_XAccOp	proc	far
		assume	ds:StdGrp
		push	ax
		push	ds
		mov	ax, StdGrp
		mov	ds, ax
;
		mov	ax, FPacc.Exponent
		xchg	ax, FPop.Exponent
		mov	FPacc.Exponent, ax
;
		mov	ax, FPacc.Mantissa
		xchg	ax, FPop.Mantissa
		mov	FPacc.Mantissa, ax
;
		mov	ax, FPacc.Mantissa+2
		xchg	ax, FPop.Mantissa+2
		mov	FPacc.Mantissa+2, ax
;
		mov	ax, FPacc.Mantissa+4
		xchg	ax, FPop.Mantissa+4
		mov	FPacc.Mantissa+4, ax
;
		mov	ax, FPacc.Mantissa+6
		xchg	ax, FPop.Mantissa+6
		mov	FPacc.Mantissa+6, ax
;
		mov	al, FPacc.Sign
		xchg	al, FPop.Sign
		mov	FPacc.Sign, al
;
		pop	ds
		pop	ax
		ret
sl_XAccOp	endp
		assume	ds:nothing
;
;
;
; sl_LSFPA- 	Loads a single precision (32-bit) IEEE format number into
;		the floating point accumulator.  ES:DI points at the # to
;		load into FPACC.
;
		public	sl_LSFPA
sl_LSFPA	proc	far
		push	ax
		push	bx
		mov	ax, es:[di]
		mov	word ptr StdGrp:fpacc.mantissa[5], ax
		mov	ax, es:2[di]
		mov	bx, ax
		shl	ax, 1
		mov	al, ah
		mov	ah, 0
		add	ax, 32767-127		;Adjust exponent bias.
		mov	word ptr StdGrp:fpacc.exponent, ax
		mov	StdGrp:fpacc.sign, bh	;Save sign away.
		mov	al, es:2[di]
		and	al, 7fh			;Strip out L.O. exp bit.
		or	al, 80h			;Add in implied bit.
		mov	byte ptr StdGrp:fpacc.mantissa[7], al ;Save H.O. mant byte.
		xor	ax, ax
		mov	word ptr StdGrp:fpacc.mantissa, ax
		mov	word ptr StdGrp:fpacc.mantissa[2], ax
		mov	byte ptr StdGrp:fpacc.mantissa[4], al
		pop	bx
		pop	ax
		ret
sl_LSFPA	endp
;
;
;
;
; sl_SSFPA-	Stores FPACC into the single precision variable pointed at by
;		ES:DI.  Performs appropriate rounding.  Returns carry clear
;		if the operation is successful, returns carry set if FPACC
;		cannot fit into a single precision variable.
;
		public	sl_SSFPA
sl_SSFPA	proc	far
		assume	ds:stdgrp
		push	ds
		push	ax
		push	bx
		mov	ax, StdGrp
		mov	ds, ax
		push	fpacc.Exponent
		push	fpacc.Mantissa   	;Save the stuff we tweak
		push	fpacc.Mantissa[2]	; so that this operation
		push	fpacc.Mantissa[4]	; will be non-destructive.
		push	fpacc.Mantissa[6]
;
; First, round FPACC:
;
		add	fpacc.Mantissa [4], 80h
		adc	fpacc.Mantissa [6], 0
		jnc	StoreAway
		rcl	fpacc.Mantissa [6], 1
		rcl	fpacc.Mantissa [4], 1
		inc	fpacc.Exponent
		jz	BadSSFPA		;If exp overflows.
;
; Store the value away:
;
StoreAway:	mov	ax, fpacc.Exponent
		sub	ax, 32767-127		;Convert to bias 127
		cmp	ah, 0
		jne	BadSSFPA
		mov	bl, fpacc.Sign
		shl	bl, 1			;Merge in the sign bit.
		rcr	al, 1
		mov	es:[di] + 3, al		;Save away exponent/sign
		pushf				;Save bit shifted out.
		mov	ax, fpacc.Mantissa [6]
		shl	ax, 1			;Get rid of implied bit and
		popf				; shift in the L.O. exponent
		rcr	ax, 1			; bit.
		mov	es:[di] + 1, ax
		mov	al, byte ptr fpacc.Mantissa [5]
		mov	es:[di], al
		clc
		jmp	SSFPADone
;
BadSSFPA:	stc
SSFPADone:	pop	fpacc.Mantissa[6]
		pop	fpacc.Mantissa[4]
		pop	fpacc.Mantissa[2]
		pop	fpacc.Mantissa
		pop	fpacc.Exponent
		pop	bx
		pop	ax
		pop	ds
		ret
		assume	ds:nothing
sl_SSFPA	endp
;
;
; sl_LDFPA-	Loads the double precision (64-bit) IEEE format number pointed
;		at by ES:DI into FPACC.
;
		public	sl_LDFPA
sl_LDFPA	proc	far
		push	ax
		push	bx
		push	cx
		mov	ax, es:6[di]
		mov	StdGrp:fpacc.sign, ah	;Save sign bit.
		mov	cl, 4
		shr	ax, cl			;Align exponent field.
		and	ah, 111b		;Strip the sign bit.
		add	ax, 32767-1023		;Adjust bias
		mov	StdGrp:fpacc.exponent, ax
;
; Get the mantissa bits and left justify them in the FPACC.
;
		mov	ax, es:5[di]
		and	ax, 0fffh		;Strip exponent bits.
		or	ah, 10h			;Add in implied bit.
		mov	cl, 3
		shl	ax, cl
		mov	bx, es:3[di]
		rol	bx, cl
		mov	ch, bl
		and	ch, 7
		or	al, ch
		mov	StdGrp:fpacc.mantissa[6], ax
;
		and	bl, 0f8h
		mov	ax, es:1[di]
		rol	ax, cl
		mov	ch, al
		and	ch, 7
		or	bl, ch
		mov	StdGrp:fpacc.mantissa[4], bx
;
		and	al, 0f8h
		mov	bh, es:[di]
		rol	bh, cl
		mov	ch, bh
		and	ch, 7
		or	al, ch
		mov	StdGrp:fpacc.mantissa[2], ax
		and	bh, 0f8h
		mov	bl, 0
		mov	StdGrp:fpacc.Mantissa[0], bx
;
		pop	cx
		pop	bx
		pop	ax
		ret
sl_LDFPA	endp
;
;
;
;
; sl_SDFPA-	Stores FPACC into the double precision variable pointed
;		at by ES:DI.
;
		public	sl_sdfpa
sl_SDFPA	proc	far
		assume	ds:stdgrp
		push	ds
		push	ax
		push	bx
		push	cx
		push	dx
		push	di
;
		mov	bx, StdGrp
		mov	ds, bx
;
		push	fpacc.Mantissa [0]
		push	fpacc.Mantissa [2]
		push	fpacc.Mantissa [4]
		push	fpacc.Mantissa [6]
		push	fpacc.Exponent
;
; First, round this guy to 52 bits:
;
		add	byte ptr fpacc.Mantissa [1], 8
		jnc	SkipRndUp
		inc	fpacc.Mantissa [2]
		jnz	SkipRndUp
		inc	fpacc.Mantissa [4]
		jnz	SkipRndUp
		inc	fpacc.Mantissa [6]
		jnz	SkipRndUp
;
; Whoops!  Got an overflow, fix that here:
;
		stc
		rcr	fpacc.Mantissa [6], 1
		rcr	fpacc.Mantissa [4], 1
		rcr	fpacc.Mantissa [2], 1
		rcr	byte ptr fpacc.Mantissa [1], 1
		inc	fpacc.Exponent
		jz	BadSDFPA		;In case exp was really big.
;
; Okay, adjust and store the exponent-
;
SkipRndUp:	mov	ax, fpacc.Exponent
		sub	ax, 32767-1023		;Adjust bias
		cmp	ax, 2048		;Make sure the value will still
		jae	BadSDFPA		; fit in an 8-byte real.
		mov	cl, 5
		shl	ax, cl			;Move exponent into place.
		mov	bl, fpacc.Sign
		shl	bl, 1
		rcr	ax, 1			;Merge in sign bit.
;
; Merge in the upper four bits of the Mantissa (don't forget that the H.O.
; Mantissa bit is lost due to the implied one bit).
;
		mov	bl, byte ptr fpacc.Mantissa [7]
		shr	bl, 1
		shr	bl, 1
		shr	bl, 1
		and	bl, 0fh			;Strip away H.O. mant bit.
		or	al, bl
		mov	es:[di]+6, ax		;Store away H.O. word.
;
; Okay, now adjust and store away the rest of the mantissa:
;
		mov	ax, fpacc.Mantissa [0]
		mov	bx, fpacc.Mantissa [2]
		mov	cx, fpacc.Mantissa [4]
		mov	dx, fpacc.Mantissa [6]
;
; Shift the bits to their appropriate places (to the left five bits):
;
		shl	ax, 1
		rcl	bx, 1
		rcl	cx, 1
		rcl	dx, 1
;
		shl	ax, 1
		rcl	bx, 1
		rcl	cx, 1
		rcl	dx, 1
;
		shl	ax, 1
		rcl	bx, 1
		rcl	cx, 1
		rcl	dx, 1
;
		shl	ax, 1
		rcl	bx, 1
		rcl	cx, 1
		rcl	dx, 1
;
		shl	ax, 1
		rcl	bx, 1
		rcl	cx, 1
		rcl	dx, 1
;
; Store away the results:
;
		mov	es:[di], bx
		mov	es:[di] + 2, cx
		mov	es: [di] + 4, dx
;
; Okay, we're done.  Return carry clear to denote success.
;
		clc
		jmp	short QuitSDFPA
;
BadSDFPA:	stc				;If an error occurred.
QuitSDFPA:	pop	fpacc.Exponent
		pop	fpacc.Mantissa [6]
		pop	fpacc.Mantissa [4]
		pop	fpacc.Mantissa [2]
		pop	fpacc.Mantissa [0]
		pop	di
		pop	dx
		pop	cx
		pop	bx
		pop	ax
		pop	ds
		ret
;
		assume	ds:nothing
sl_SDFPA	endp
;
;
;
;
; sl_LEFPA-	Loads an extended precision (80-bit) IEEE format number
;		into the floating point accumulator.  ES:DI points at the
;		number to load into FPACC.
;
		public	sl_LEFPA
sl_LEFPA	proc	far
		push	ax
		mov	ax, es:8[di]
		mov	StdGrp:fpacc.Sign, ah
		and 	ah, 7fh
		add	ax, 4000h
		mov	StdGrp:fpacc.Exponent, ax
		mov	ax, es:[di]
		mov	StdGrp:fpacc.Mantissa, ax
		mov	ax, es:2[di]
		mov	StdGrp:fpacc.Mantissa[2], ax
		mov	ax, es:4[di]
		mov	StdGrp:fpacc.Mantissa[4], ax
		mov	ax, es:6[di]
		mov	StdGrp:fpacc.Mantissa[6], ax
		pop	ax
		ret
sl_LEFPA	endp
;
;
; sl_LEFPAL-	Loads an extended precision (80-bit) IEEE format number
;		into the floating point accumulator.  The number to load
;		into FPACC follows the call in the code stream.
;
		public	sl_LEFPAL
sl_LEFPAL	proc	far
		push	bp
		mov	bp, sp
		push	es
		push	di
		push	ax
		les	di, 2[bp]
;
		mov	ax, es:8[di]
		mov	StdGrp:fpacc.Sign, ah
		and 	ah, 7fh
		add	ax, 4000h
		mov	StdGrp:fpacc.Exponent, ax
		mov	ax, es:[di]
		mov	StdGrp:fpacc.Mantissa, ax
		mov	ax, es:2[di]
		mov	StdGrp:fpacc.Mantissa[2], ax
		mov	ax, es:4[di]
		mov	StdGrp:fpacc.Mantissa[4], ax
		mov	ax, es:6[di]
		mov	StdGrp:fpacc.Mantissa[6], ax
;
; Adjust the return address to point past the floating point number we
; just loaded.
;
		add	word ptr 2[bp], 10
;
		pop	ax
		pop	di
		pop	es
		pop	bp
		ret
sl_LEFPAL	endp
;
;
; sl_SEFPA-	Stores FPACC into in the extended precision variable
;		pointed at by ES:DI.
;
		public	sl_sefpa
sl_SEFPA	proc	far
		assume	ds:stdgrp
		push	ds
		push	ax
		mov	ax, StdGrp
		mov	ds, ax
		push	fpacc.Mantissa [0]
		push	fpacc.Mantissa [2]
		push	fpacc.Mantissa [4]
		push	fpacc.Mantissa [6]
		push	fpacc.Exponent
;
		mov	ax, fpacc.Exponent
		sub	ax, 4000h
		cmp	ax, 8000h
		jae	BadSEFPA
		test	fpacc.Sign, 80h
		jz	StoreSEFPA
		or	ah, 80h
StoreSEFPA:	mov	es:[di]+8, ax
		mov	ax, fpacc.Mantissa [0]
		mov	es:[di], ax
		mov	ax, fpacc.Mantissa [2]
		mov	es:[di] + 2, ax
		mov	ax, fpacc.Mantissa [4]
		mov	es:[di] + 4, ax
		mov	ax, fpacc.Mantissa [6]
		mov	es:[di] + 6, ax
		clc
		jmp	SEFPADone
;
BadSEFPA:	stc
SEFPADone:	pop	fpacc.Exponent
		pop	fpacc.Mantissa[6]
		pop	fpacc.Mantissa[4]
		pop	fpacc.Mantissa[2]
		pop	fpacc.Mantissa[0]
		pop	ax
		pop	ds
		ret
		assume	ds:nothing
sl_SEFPA        endp
;
;
;
; sl_LSFPO- 	Loads a single precision (32-bit) IEEE format number into
;		the floating point operand.  ES:DI points at the # to
;		load into FPOP.
;
		public	sl_LSFPO
sl_LSFPO	proc	far
		push	ax
		push	bx
		mov	ax, es:[di]
		mov	word ptr StdGrp:fpop.mantissa[5], ax
		mov	ax, es:2[di]
		mov	bx, ax
		shl	ax, 1
		mov	al, ah
		mov	ah, 0
		add	ax, 32767-127		;Adjust exponent bias.
		mov	word ptr StdGrp:fpop.exponent, ax
		mov	StdGrp:fpop.sign, bh	;Save sign away.
		mov	al, es:2[di]
		and	al, 7fh			;Strip out L.O. exp bit.
		or	al, 80h			;Add in implied bit.
		mov	byte ptr StdGrp:fpop.mantissa[7], al
		xor	ax, ax
		mov	word ptr StdGrp:fpop.mantissa, ax
		mov	word ptr StdGrp:fpop.mantissa[2], ax
		mov	byte ptr StdGrp:fpop.mantissa[4], al
		pop	bx
		pop	ax
		ret
sl_LSFPO	endp
;
;
;
;
;
; sl_LDFPO-	Loads the double precision (64-bit) IEEE format number pointed
;		at by ES:DI into FPOP.
;
		public	sl_LDFPO
sl_LDFPO	proc	far
		push	ax
		push	bx
		push	cx
		mov	ax, es:6[di]
		mov	StdGrp:fpop.sign, ah	;Save sign bit.
		mov	cl, 4
		shr	ax, cl			;Align exponent field.
		and	ah, 111b		;Strip the sign bit.
		add	ax, 32767-1023		;Adjust bias
		mov	word ptr StdGrp:fpop.exponent, ax
;
; Get the mantissa bits and left justify them in the FPOP.
;
		mov	ax, es:5[di]
		and	ax, 0fffh		;Strip exponent bits.
		or	ah, 10h			;Add in implied bit.
		mov	cl, 3
		shl	ax, cl
		mov	bx, es:3[di]
		rol	bx, cl
		mov	ch, bl
		and	ch, 7
		or	al, ch
		mov	word ptr StdGrp:fpop.mantissa[6], ax
;
		and	bl, 0f8h
		mov	ax, es:1[di]
		rol	ax, cl
		mov	ch, al
		and	ch, 7
		or	bl, ch
		mov	word ptr StdGrp:fpop.mantissa[4], bx
;
		and	al, 0f8h
		mov	bh, es:[di]
		rol	bh, cl
		mov	ch, bh
		and	ch, 7
		or	al, ch
		mov	word ptr StdGrp:fpop.mantissa[2], ax
		and	bh, 0f8h
		mov	bl, 0
		mov	word ptr StdGrp:fpop.Mantissa[0], bx
;
		pop	cx
		pop	bx
		pop	ax
		ret
sl_LDFPO	endp
;
;
;
;
;
; sl_LEFPO-	Loads an extended precision (80-bit) IEEE format number
;		into the floating point operand.  ES:DI points at the
;		number to load into FPACC.
;
		public	sl_LEFPO
sl_LEFPO	proc	far
		push	ax
		mov	ax, es:8[di]
		mov	StdGrp:fpop.Sign, ah
		and 	ah, 7fh
		add	ax, 4000h
		mov	StdGrp:fpop.Exponent, ax
		mov	ax, es:[di]
		mov	StdGrp:fpop.Mantissa, ax
		mov	ax, es:2[di]
		mov	StdGrp:fpop.Mantissa[2], ax
		mov	ax, es:4[di]
		mov	StdGrp:fpop.Mantissa[4], ax
		mov	ax, es:6[di]
		mov	StdGrp:fpop.Mantissa[6], ax
		pop	ax
		ret
sl_LEFPO	endp
;
;
;
;
; sl_LEFPOL-	Loads an extended precision (80-bit) IEEE format number
;		into the floating point operand.  The number to load
;		follows the call instruction in the code stream.
;
		public	sl_LEFPOL
sl_LEFPOL	proc	far
		push	bp
		mov	bp, sp
		push	es
		push	di
		push	ax
		les	di, 2[bp]
;
		mov	ax, es:8[di]
		mov	StdGrp:fpop.Sign, ah
		and 	ah, 7fh
		add	ax, 4000h
		mov	StdGrp:fpop.Exponent, ax
		mov	ax, es:[di]
		mov	StdGrp:fpop.Mantissa, ax
		mov	ax, es:2[di]
		mov	StdGrp:fpop.Mantissa[2], ax
		mov	ax, es:4[di]
		mov	StdGrp:fpop.Mantissa[4], ax
		mov	ax, es:6[di]
		mov	StdGrp:fpop.Mantissa[6], ax
;
		add	word ptr 2[bp], 10	;Skip rtn adrs past #.
;
		pop	ax
		pop	di
		pop	es
		pop	bp
		ret
sl_LEFPOL	endp
;
;
;
;
;
;
;
;--------------------------------------------------------------------------
; 		Integer <=> FP Conversions
;--------------------------------------------------------------------------
;
;
;
; ITOF-		Converts 16-bit signed value in AX to a floating point value
;		in FPACC.
;
		public	sl_itof
sl_itof		proc	far
		assume	ds:stdgrp
		push	ds
		push	ax
		push	cx
		mov	cx, StdGrp
		mov	ds, cx
;
		mov	cx, 800Fh		;Magic exponent value (65536).
;
; Set the sign of the result:
;
		mov	fpacc.Sign, 0		;Assume a positive value.
		or	ax, ax			;Special case for zero!
		jz	SetFPACC0
		jns	DoUTOF			;Take care of neg values.
		mov	fpacc.sign, 80h		;This guy is negative!
		neg	ax			;Work with abs(AX).
		jmp	DoUTOF
sl_ITOF		endp
;
;
; UTOF-		Like ITOF above except this guy works for unsigned 16-bit
;		integer values.
;
		public	sl_utof
sl_UTOF		proc	far
		push	ds
		push	ax
		push	cx
;
;
		mov	cx, StdGrp
		mov	ds, cx
		mov	cx, 800Fh		;Magic exponent value (65536).
		or	ax, ax
		jz	SetFPACC0
		mov	fpacc.Sign, 0
;
sl_UTOF		endp
;
;
; Okay, convert the number to a floating point value:
; Remember, we need to end up with a normalized number (one where the H.O.
; bit of the mantissa contains a one).  The largest possible value (65535 or
; 0FFFFh) is equal to 800E FFFF 0000 0000 0000.  All other values have an
; exponent less than or equal to 800Eh.  If the H.O. bit of the value is
; not one, we must shift it to the left and dec the exp by 1.  E.g., if AX
; contains 1, then we will need to shift it 15 times to normalize the value,
; decrementing the exponent each time produces 7fffh which is the proper
; exponent for "1".
;
; Note: this is not a proc!  Making it a proc makes it incompatible with
; one or more different assemblers (TASM, OPTASM, MASM6).
; Besides, this has to be a near label with a far return!
;
DoUTOF:
UTOFWhlPos:	dec	cx
		shl	ax, 1
		jnc	UTOFWhlPos
		rcr	ax, 1			;Put bit back.
		mov	fpacc.Exponent, cx	;Save exponent value.
		mov	fpacc.Mantissa [6], ax	;Save Mantissa value.
		xor	ax, ax
		mov	fpacc.Mantissa [4], ax	;Zero out the rest of the
		mov	fpacc.Mantissa [2], ax	; mantissa.
		mov	fpacc.Mantissa [0], ax
		jmp     UTOFDone
;
; Special case for zero, must zero all bytes in FPACC.  Note that AX already
; contains zero.
;
SetFPACC0:	mov	fpacc.Exponent, ax
		mov	fpacc.Mantissa [6], ax
		mov	fpacc.Mantissa [4], ax
		mov	fpacc.Mantissa [2], ax
		mov	fpacc.Mantissa [0], ax
		mov	fpacc.Sign, al
;
UTOFDone:	pop	cx
		pop	ax
		pop	ds
		retf
;
;
;
;
;
;
; LTOF-		Converts 32-bit signed value in DX:AX to a floating point
;		value in FPACC.
;
		public	sl_ltof
sl_ltof		proc	far
		assume	ds:stdgrp
		push	ds
		push	ax
		push	cx
		push	dx
		mov	cx, StdGrp
		mov	ds, cx
;
; Set the sign of the result:
;
		mov	fpacc.Sign, 0		;Assumed a positive value.
		mov	cx, dx
		or	cx, ax
		jz	SetUL0
		or	dx, dx			;Special case for zero!
		jns	DoULTOF			;Take care of neg values.
		mov	fpacc.sign, 80h		;This guy is negative!
		neg	dx			;Do a 32-bit NEG operation
		neg	ax			; (yes, this really does
		sbb	dx, 0			;  work!).
		jmp	DoULTOF
sl_LTOF		endp
;
;
; ULTOF-	Like LTOF above except this guy works for unsigned 32-bit
;		integer values.
;
		public	sl_ultof
sl_ULTOF	proc	far
		push	ds
		push	ax
		push	cx
		push	dx
;
		mov	cx, StdGrp
		mov	ds, cx
;
		mov	cx, dx
		or	cx, ax
		jz	SetUL0
		mov	fpacc.Sign, 0
;
sl_ULTOF		endp
;
;
;
DoULTOF:
		mov	cx, 801Fh		;Magic exponent value (65536).
ULTOFWhlPos:	dec	cx
		shl	ax, 1
		rcl	dx, 1
		jnc	ULTOFWhlPos
		rcr	dx, 1			;Put bit back.
		rcr	ax, 1
		mov	fpacc.Exponent, cx	;Save exponent value.
		mov	fpacc.Mantissa [6], dx	;Save Mantissa value.
		mov	fpacc.Mantissa [4], ax
		xor	ax, ax			;Zero out the rest of the
		mov	fpacc.Mantissa [2], ax	; mantissa.
		mov	fpacc.Mantissa [0], ax
		jmp     ULTOFDone
;
; Special case for zero, must zero all bytes in FPACC.  Note that AX already
; contains zero.
;
SetUL0:		mov	fpacc.Exponent, ax
		mov	fpacc.Mantissa [6], ax
		mov	fpacc.Mantissa [4], ax
		mov	fpacc.Mantissa [2], ax
		mov	fpacc.Mantissa [0], ax
		mov	fpacc.Sign, al
;
ULTOFDone:	pop	dx
		pop	cx
		pop	ax
		pop	ds
		retf
;
;
;
;
; FTOI- Converts the floating point value in FPACC to a signed 16-bit
;	integer and returns this integer in AX.
;	Returns carry set if the number is too big to fit into AX.
;
		public	sl_FTOI
sl_FTOI		proc	far
		assume	ds:stdgrp
		push	ds
		push	cx
		mov	cx, StdGrp
		mov	ds, cx
;
		mov	cx, fpacc.Exponent
		cmp	cx, 800eh
		jb	FTOIok
;
; Handle special case of -32768:
;
		call	DoFToU
		cmp	ax, 8000h
		je	FtoiOk2
		stc
		jmp	TooBig
;
FTOIok:		call	DoFTOU
FtoiOk2:	cmp	fpacc.Sign, 0
		jns	FTOIJustRight
		neg	ax
FTOIJustRight:	clc
TooBig:		pop	cx
		pop	ds
		ret
sl_FTOI		endp
;
;
;
;
; FTOU- Like FTOI above, except this guy converts a floating point value
; 	to an unsigned integer in AX.
;	Returns carry set if out of range (including negative numbers).
;
		public	sl_FTOU
sl_FTOU		proc	far
		assume	ds:stdgrp
		push	ds
		push	cx
		mov	cx, StdGrp
		mov	ds, cx
;
		mov	cx, fpacc.Exponent
		cmp	cx, 800fh
		jb	FTOUok
BadU:		stc
		jmp	UTooBig
;
FTOUok:		call	DoFTOU
		cmp	fpacc.Sign, 0
		js	BadU
;
FTOUJustRight:	clc
UTooBig:	pop	cx
		pop	ds
		ret
sl_FTOU		endp
;
;
; DoFTOU- This code does the actual conversion!
;
DoFTOU		proc	near
		mov	ax, fpacc.Mantissa [6]
		cmp	cx, 7fffh
		jb	SetFTOU0
		sub	cx, 800eh
		neg	cx
		shr	ax, cl
		ret
;
SetFTOU0:	xor	ax, ax
		ret
DoFTOU		endp
;
;
;
;
;
; FTOL- Converts the floating point value in FPACC to a signed 32-bit
;	integer and returns this integer in DX:AX.
;	Returns carry set if the number is too big to fit into DX:AX.
;
		public	sl_FTOL
sl_FTOL		proc	far
		assume	ds:StdGrp
		push	ds
		push	cx
		mov	cx, StdGrp
		mov	ds, cx
;
		mov	cx, fpacc.Exponent
		cmp	cx, 801eh
		jb	FTOLok
		stc
		jmp	LTooBig
;
FTOLok:		call	DoFTOUL
		cmp	fpacc.Sign, 0
		jns	FTOLJustRight
		neg	dx    		;32-bit negate operation.
		neg	ax
		sbb	dx, 0
FTOLJustRight:	clc
LTooBig:	pop	cx
		pop	ds
		ret
sl_FTOL		endp
;
;
;
;
; FTOUL-Like FTOL above, except this guy converts a floating point value
; 	to a 32-bit unsigned integer in DX:AX.
;	Returns carry set if out of range (including negative numbers).
;
		public	sl_FTOUL
sl_FTOUL	proc	far
		assume	ds:StdGrp
		push	ds
		push	cx
		mov	cx, StdGrp
		mov	ds, cx
;
		mov	cx, fpacc.Exponent
		cmp	cx, 801fh
		jb	FTOULok
BadUL:		stc
		jmp	ULTooBig
;
FTOULok:	call	DoFTOUL
		cmp	fpacc.Sign, 0
		js	BadUL
;
		clc				;If the # is okay.
ULTooBig:	pop	cx
		pop	ds
		ret
sl_FTOUL	endp
;
;
; DoFTOUL- This code does the actual conversion!
;
DoFTOUL		proc	near
		mov	dx, fpacc.Mantissa [6]
		mov	ax, fpacc.Mantissa [4]
		cmp	cx, 7fffh
		jb	SetFTOUL0
		sub	cx, 801eh
		neg	cx
		jcxz	SetFTOULDone
FTOULLp:	shr	dx, 1
		rcr	ax, 1
		loop	FTOULLp
SetFToULDone:	ret
;
SetFTOUL0:	xor	ax, ax
		xor	dx, dx
		ret
DoFTOUL		endp
;
;
;
;
;
;
;
;
;
;
;
;
;
;---------------------------------------------------------------------------
;		Floating Point Addition & Subtraction
;---------------------------------------------------------------------------
;
;
;
;
; FADD- Adds FOP to FACC
; FSUB- Subtracts FOP from FACC
;	These routines destroy the value in FPOP!
;
		public	sl_fsub
		public	sl_fadd
;
		assume	ds:nothing
sl_fsub		proc	far
		xor	StdGrp:fpop.sign, 80h
sl_fsub		endp
;
		assume	ds:StdGrp
sl_fadd		proc	far
		push	ds
		push	ax
		push	bx
		push	cx
		push	dx
		push	si

; Use the current CS as the data segment to get direct access to
; the floating point accumulator and operands.

		mov	ax, StdGrp
		mov	ds, ax

; Kludge Alert!  Check to see if either operand is zero.  This code doesn't
; deal with zero very gracefully, so we have to specially check for zero
; here.

		mov	ax, fpacc.Mantissa[0]
		or	ax, fpacc.Mantissa[2]
		or	ax, fpacc.Mantissa[4]
		or	ax, fpacc.Mantissa[6]
		jne	FPACCNot0		; the whole thing is zero.

		mov	ax, fpop.exponent	;If FPACC is zero, simply
		mov	fpacc.exponent, ax	; copy FPOP to FPACC.
		mov	ax, fpop.Mantissa[0]
		mov	fpacc.Mantissa[0], ax
		mov	ax, fpop.Mantissa[2]
		mov	fpacc.Mantissa[2], ax
		mov	ax, fpop.Mantissa[4]
		mov	fpacc.Mantissa[4], ax
		mov	ax, fpop.Mantissa[6]
		mov	fpacc.Mantissa[6], ax
		mov	al, fpop.Sign
		mov	fpacc.Sign, al
		jmp	Done

FPACCNot0:
		mov	ax, fpop.Mantissa[0]
		or	ax, fpop.Mantissa[2]
		or	ax, fpop.Mantissa[4]
		or	ax, fpop.Mantissa[6]
		jne	FPOPNot0
		jmp	Done

; Adjust the smaller of the two operands so that the exponents of the two
; objects are the same:

FPOPNot0:
		mov	cx, fpacc.exponent
		sub	cx, fpop.exponent
		js	gotoAdjustFPA
		jnz	AdjustFPOP
		jmp	Adjusted		;Only if exponents are equal.
gotoAdjustFPA:	jmp	AdjustFPACC
;
; Since the difference of the exponents is negative, the magnitude of FPOP
; is smaller than the magnitude of fpacc.  Adjust FPOP here.
;
AdjustFPOP:	cmp	cx, 64			;If greater than 64, forget
		jb	short By16LoopTest	; it.  Sum is equal to FPACC.
		jmp	Done
;
; If the difference is greater than 16 bits, adjust FPOP a word at a time.
; Note that there may be multiple words adjusted in this fashion.
;
By16Loop:	mov	ax, fpop.mantissa[2]
		mov	fpop.mantissa[0], ax
		mov	ax, fpop.mantissa[4]
		mov	fpop.mantissa[2], ax
		mov	ax, fpop.mantissa[6]
		mov	fpop.mantissa[4], ax
		mov	fpop.mantissa[6], 0
		sub	cx, 16
By16LoopTest:	cmp	cx, 16
		jae	By16Loop
;
; After adjusting sixteen bits at a time, see if there are at least eight
; bits.  Note that this can only occur once, for if you could adjust by
; eight bits twice, you could have adjusted by 16 above.
;
		cmp	cx, 8
		jb	NotBy8
		mov	ax, fpop.mantissa[1]
		mov	fpop.mantissa[0], ax
		mov	ax, fpop.mantissa[3]
		mov	fpop.mantissa[2], ax
		mov	ax, fpop.mantissa[5]
		mov	fpop.mantissa[4], ax
		mov	al, byte ptr fpop.mantissa [7]
		mov	byte ptr fpop.mantissa [6], al
		mov	byte ptr fpop.mantissa[7], 0
		sub	cx, 8
;
; Well, now we're down to a bit at a time.
;
NotBy8:		jcxz	AdjFPOPDone
;
; Load the mantissa into registers to save processing time.
;
		mov	ax, fpop.mantissa[6]
		mov	bx, fpop.mantissa[4]
		mov	dx, fpop.mantissa[2]
		mov	si, fpop.mantissa[0]
By1Loop:	shr	ax, 1
		rcr	bx, 1
		rcr	dx, 1
		rcr	si, 1
		loop	By1Loop
		mov	fpop.mantissa[6], ax	;Save result back into
		mov	fpop.mantissa[4], bx	; fpop.
		mov	fpop.mantissa[2], dx
		mov	fpop.mantissa[0], si
AdjFPOPDone:	jmp     Adjusted
;
;
;
; AdjustFPACC- FPACC was smaller than FPOP, so adjust its bits down here.
;	       This code is pretty much identical to the above, the same
;	       comments apply.
;
AdjustFPACC:	neg	cx			;Take ABS(cx)
		cmp	cx, 64			;If greater than 64, forget
		jb	By16LpTest		; it.
		jmp	SetFPACC2Zero
;
By16Lp:		mov	ax, fpacc.mantissa[2]
		mov	fpacc.mantissa[0], ax
		mov	ax, fpacc.mantissa[4]
		mov	fpacc.mantissa[2], ax
		mov	ax, fpacc.mantissa[6]
		mov	fpacc.mantissa[4], ax
		mov	fpacc.mantissa[6], 0
		sub	cx, 16
By16LpTest:	cmp	cx, 16
		jae	By16Lp
;
		cmp	cx, 8
		jb	NotBy8a
		mov	ax, fpacc.mantissa[1]
		mov	fpacc.mantissa[0], ax
		mov	ax, fpacc.mantissa[3]
		mov	fpacc.mantissa[2], ax
		mov	ax, fpacc.mantissa[5]
		mov	fpacc.mantissa[4], ax
		mov	al, byte ptr fpacc.mantissa [7]
		mov	byte ptr fpacc.mantissa [6], al
		mov	byte ptr fpacc.mantissa[7], 0
		sub	cx, 8
;
NotBy8a:	jcxz	Adjusted
		mov	ax, fpacc.mantissa[6]
		mov	bx, fpacc.mantissa[4]
		mov	dx, fpacc.mantissa[2]
		mov	si, fpacc.mantissa[0]
By1Lp:		shr	ax, 1
		rcr	bx, 1
		rcr	dx, 1
		rcr	si, 1
		loop	By1Lp
		mov	fpacc.mantissa[6], ax
		mov	fpacc.mantissa[4], bx
		mov	fpacc.mantissa[2], dx
		mov	fpacc.mantissa[0], si
		mov	ax, fpop.Exponent	;FPACC assumes the same
		mov	fpacc.Exponent, ax	; exponent as FPOP.
AdjFPACCDone:	jmp     Adjusted
;
; If FPACC is so much smaller than FPOP that it is insignificant, set
; it to zero.
;
SetFPACC2Zero:	xor	ax, ax
		mov	fpacc.mantissa[0], ax
		mov	fpacc.mantissa[2], ax
		mov	fpacc.mantissa[4], ax
		mov	fpacc.mantissa[6], ax
		mov	fpacc.exponent, ax
		mov	fpacc.sign, al
;
; Now that the mantissas are aligned, let's add (or subtract) them.
;
Adjusted:	mov	al, fpacc.sign
		xor	al, fpop.sign
		js	SubEm
;
; If the signs are the same, simply add the mantissas together here.
;
		mov	ax, fpop.mantissa[0]
		add	fpacc.mantissa[0], ax
		mov	ax, fpop.mantissa[2]
		adc	fpacc.mantissa[2], ax
		mov	ax, fpop.mantissa[4]
		adc	fpacc.mantissa[4], ax
		mov	ax, fpop.mantissa[6]
		adc	fpacc.mantissa[6], ax
		jnc	Normalize
;
; If there was a carry out of the addition (quite possible since most
; fp values are normalized) then we need to shove the bit back into
; the number.
;
		rcr	fpacc.mantissa[6], 1
		rcr	fpacc.mantissa[4], 1
		rcr	fpacc.mantissa[2], 1
		rcr	fpacc.mantissa[0], 1
		inc	fpacc.exponent
;
; If there was a carry out of the bottom, add it back in (this rounds the
; result).  No need to worry about a carry out of the H.O. bit this time--
; there is no way to add together two numbers to get a carry *and* all
; one bits in the result.  Therefore, rounding at this point will not
; propagate all the way through.
;
		adc	fpacc.Mantissa [0], 0
		jnc	Normalize
		inc	fpacc.Mantissa [2]
		jnz	Normalize
		inc	fpacc.Mantissa [4]
		jnz	Normalize
		inc	fpacc.Mantissa [6]
		jmp	Normalize
;
;
;
; If the signs are different, we've got to deal with four possibilities:
;
; 1) fpacc is negative and its magnitude is greater than fpop's.
;	Result is negative, fpacc.mant := fpacc.mant - fpop.mant.
;
; 2) fpacc is positive and its magnitude is greater than fpop's.
;	Result is positive, fpacc.mant := fpacc.mant - fpop.mant.
;
; 3) fpacc is negative and its magnitude is less than fpop's.
;	Result is positive, fpacc.mant := fpop.mant - fpacc.mant.
;
; 4) fpacc is positive and its magnitude is less than fpop's.
;	Result is negative, fpacc.mant := fpop.mant - fpacc.mant.
;
SubEm:		mov	ax, fpacc.mantissa[0]
		mov	bx, fpacc.mantissa[2]
		mov	dx, fpacc.mantissa[4]
		mov	si, fpacc.mantissa[6]
		sub	ax, fpop.mantissa[0]
		sbb	bx, fpop.mantissa[2]
		sbb	dx, fpop.mantissa[4]
		sbb     si, fpop.mantissa[6]
		jnc	StoreFPACC
;
; Whoops!  FPOP > FPACC, fix that down here.
;
		not	ax
		not	bx
		not	dx
		not	si
		inc 	ax
		jnz	StoreFPACCSign
		inc	bx
		jnz	StoreFPAccSign
		inc	dx
		jnz	StoreFPAccSign
		inc	si
;
StoreFPAccSign:	xor	fpacc.sign, 80h			;Flip sign if case 3/4.
;
StoreFPAcc:	mov	fpacc.mantissa[0], ax
		mov	fpacc.mantissa[2], bx
		mov	fpacc.mantissa[4], dx
		mov	fpacc.mantissa[6], si


; Normalize the result down here.  Start by shifting 16 bits at a time,
; then eight bits, then one bit at a time.

Normalize:	mov	ax, fpacc.Mantissa[0]	;First, see if the result
		or	ax, fpacc.Mantissa[2]	; is zero.  Can't normalize
		or	ax, fpacc.Mantissa[4]	; if this is the case.
		or	ax, fpacc.Mantissa[6]
		jnz	NormLoop
		mov	fpacc.Exponent, ax	;Force everything to zero
		mov	fpacc.Sign, al		; if result is zero.
		jmp	Done

NormLoop:	mov	ax, fpacc.mantissa[6]
		or	ax, ax		      	;See if zero (which means we
		jnz	Try8Bits		; can shift 16 bits).
		mov	ax, fpacc.mantissa[4]
		mov	fpacc.mantissa[6], ax
		mov	ax, fpacc.mantissa[2]
		mov	fpacc.mantissa[4], ax
		mov	ax, fpacc.mantissa[0]
		mov	fpacc.mantissa[2], ax
		mov	fpacc.mantissa[0],0
		sub	fpacc.exponent, 16
		jmp	NormLoop
;
; Okay, see if we can normalize eight bits at a shot.
;
Try8Bits:	mov	al, byte ptr fpacc.mantissa[7]
		cmp	al, 0
		jnz	Try1Bit
		mov	ax, fpacc.mantissa[5]
		mov	fpacc.mantissa[6], ax
		mov	ax, fpacc.mantissa[3]
		mov	fpacc.mantissa[4], ax
		mov	ax, fpacc.mantissa[1]
		mov	fpacc.mantissa[3], ax
		mov	al, byte ptr fpacc.mantissa[0]
		mov	byte ptr fpacc.mantissa[1], al
		mov	byte ptr fpacc.mantissa[0], 0
		sub	fpacc.exponent, 8
;
Try1Bit:	mov	ax, fpacc.mantissa[6]
		test	ah, 80h
		jnz	Done
		mov	bx, fpacc.mantissa[4]
		mov	dx, fpacc.mantissa[2]
		mov	si, fpacc.mantissa[0]
OneBitLp:	dec	fpacc.exponent
		shl	si, 1
		rcl	dx, 1
		rcl	bx, 1
		rcl	ax, 1
		or	ax, ax			;See if bit 15 is set.
		jns	OneBitLp
		mov	fpacc.mantissa[6], ax
		mov	fpacc.mantissa[4], bx
		mov	fpacc.mantissa[2], dx
		mov	fpacc.mantissa[0], si
;
Done:
		pop	si
		pop	dx
		pop	cx
		pop	bx
		pop	ax
		pop	ds
		ret
sl_fadd		endp
;
;
;
;
;
;
;
;
;
;
;---------------------------------------------------------------------------
; Floating point comparison.
;---------------------------------------------------------------------------
;
;
; FCMP
; Compares value in FPACC to value in FPOP.
; Returns -1 in AX if FPACC is less than FPOP,
; Returns 0  in AX if FPACC is equal to FPOP,
; Returns 1  in AX if FPACC is greater than FPOP.
;
; Also returns this status in the flags (by comparing AX against zero
; before returning) so you can use JE, JNE, JG, JGE, JL, or JLE after this
; routine to test the comparison.
;
		public	sl_fcmp
sl_fcmp		proc	far
		assume	ds:StdGrp
		push	ds
		mov	ax, StdGrp
		mov	ds, ax
;
; First compare the signs of the mantissas.  If they are different, the
; negative one is smaller.
;
		mov	al, byte ptr FPACC+10	;Get sign bit
		xor	al, byte ptr FPOP+10	;See if the signs are different
		jns	SameSign
;
; If the signs are different, then the sign of FPACC determines the result
;
		test	byte ptr FPACC+10, 80h
		jnz	IsLT
		jmp	short IsGT
;
; Down here the signs are the same.  First order of business is to compare
; the exponents.  The one with the larger exponent wins.  If the exponents
; are equal, then we need to compare the mantissas.  If the mantissas are
; the same then the two numbers are equal.  If the mantissas are different
; then the larger one wins.  Note that this discussion is for positive values
; only, if the numbers are negative, then we must reverse the win/loss value
; (win=GT).
;
SameSign:	mov	ax, FPACC.exponent	;One thing cool about bias-
		cmp	ax, FPOP.exponent	; 1023 exponents is that we
		ja	MayBeGT			; can use an unsigned compare
		jb	MayBeLT
;
; If the exponents are equal, we need to start comparing the mantissas.
; This straight line code turns out to be about the fastest way to do it.
;
		mov	ax, word ptr FPACC.mantissa+6
		cmp	ax, word ptr FPOP.mantissa+6
		ja	MayBeGT
		jb	MayBeLT
		mov	ax, word ptr FPACC.mantissa+4
		cmp	ax, word ptr FPOP.mantissa+4
		ja	MayBeGT
		jb	MayBeLT
		mov	ax, word ptr FPACC.mantissa+2
		cmp	ax, word ptr FPOP.mantissa+2
		ja	MayBeGT
		jb	MayBeLT
		mov	ax, word ptr FPACC.mantissa
		cmp	ax, word ptr FPOP.mantissa
		ja	MayBeGT
		je	IsEq			;They're equal at this point.
;
; MayBeLT- Looks like less than so far, but we need to check the sign of the
; numbers, if they are negative then FPACC is really GT FPOP.  Remember, the
; sign is not part of the mantissa!
;
MayBeLT:	test	FPACC.sign, 80h
		js	IsGT
;
IsLT:		mov	ax, -1
		jmp	short cmpRtn
;
; Same story here for MayBeGT
;
MayBeGT:	test	FPACC.sign, 80h
		js	IsLT
;
IsGT:		mov	ax, 1
		jmp	short cmpRtn
;
IsEq:		xor	ax, ax
cmpRtn:		pop	ds
		cmp	ax, 0			;Set the flags as appropriate
		ret
sl_fcmp		endp
		assume	ds:nothing
;
;
;
;
;
;
;
;
;
;
;
;
;
;---------------------------------------------------------------------------
;		Floating Point Multiplication
;---------------------------------------------------------------------------
;
;
;
;
; sl_fmul- Multiplies facc by fop and leaves the result in facc.
;
		public	sl_fmul
sl_fmul		proc	far
		assume	ds:StdGrp
		push	ds
		push	ax
		push	bx
		push	cx
		push	dx
		push	si
		push	di
;
		mov	ax, StdGrp
		mov	ds, ax
;
; See if either operand is zero:
;
		mov	ax, fpacc.mantissa[0]	;No need to check exponent!
		or	ax, fpacc.mantissa[2]
		or	ax, fpacc.mantissa[4]
		or	ax, fpacc.mantissa[6]
		jz	ProdIsZero
;
		mov	ax, fpop.mantissa[0]
		or	ax, fpop.mantissa[2]
		or	ax, fpop.mantissa[4]
		or	ax, fpop.mantissa[6]
		jnz	ProdNotZero
;
ProdIsZero:	xor	ax, ax			;Need this!
		mov	fpacc.sign, al
		mov	fpacc.exponent, ax
		mov	fpacc.mantissa[0], ax
		mov	fpacc.mantissa[2], ax
		mov	fpacc.mantissa[4], ax
		mov	fpacc.mantissa[6], ax
		jmp	FMulDone
;
; If both operands are non-zero, compute the true product down here.
;
ProdNotZero:	mov	al, fpop.sign		;Compute the new sign.
		xor	fpacc.sign, al
;
; Eliminate bias in the exponents, add them, and check for 16-bit signed
; overflow.
;
		mov	ax, fpop.exponent	;Compute new exponent.
		sub	ax, 7fffh		;Subtract BIAS and adjust
		mov	bx, fpacc.Exponent
		sub	bx, 7fffh
		add	ax, bx			; for fractional multiply.
		jno	GoodExponent
;
; If the exponent overflowed, set up the overflow value here.
;
		mov	ax, 0ffffh
		mov	fpacc.exponent, ax	;Largest exponent value
		mov	fpacc.mantissa[0], ax	; and largest mantissa, too!
		mov	fpacc.mantissa[2], ax
		mov	fpacc.mantissa[4], ax
		mov	fpacc.mantissa[6], ax
		jmp	FMulDone
;
GoodExponent:	add	ax, 8000h		;Add the bias back in (note
		mov	fpacc.Exponent, ax	; Mul64 below causes shift
;						; to force bias of 7fffh.
; Okay, compute the product of the mantissas down here.
;
		call	Mul64
;
; Normalize the product.  Note: we know the product is non-zero because
; both of the original operands were non-zero.
;
		mov	cx, fpacc.exponent
		jmp	short TestNrmMul
NrmMul1:	sub	cx, 16
		mov	ax, fprod[12]
		mov	fprod[14], ax
		mov	ax, fprod[10]
		mov	fprod[12], ax
		mov	ax, fprod[8]
		mov	fprod[10], ax
		mov	ax, fprod[6]
		mov	fprod[8], ax
		mov	ax, fprod[4]
		mov	fprod[6], ax
		mov	ax, fprod[2]
		mov	fprod[4], ax
		mov	ax, fprod[0]
		mov	fprod[2], ax
		mov	fprod[0], 0
TestNrmMul:     cmp	cx, 16
		jb	DoNrmMul8
		mov  	ax, fprod[14]
		or	ax, ax
		jz	NrmMul1
;
; See if we can shift the product a whole byte
;
DoNrmMul8:	cmp	ah, 0			;Contains fprod[15] from above.
		jnz	DoOneBits
		cmp	cx, 8
		jb	DoOneBits
		mov	ax, fprod[13]
		mov	fprod[14], ax
		mov	ax, fprod[11]
		mov	fprod[12], ax
		mov	ax, fprod[9]
		mov	fprod[10], ax
		mov	ax, fprod[7]
		mov	fprod[8], ax
		mov	ax, fprod[5]
		mov	fprod[6], ax
		mov	ax, fprod[3]
		mov	fprod[4], ax
		mov	ax, fprod[1]
		mov	fprod[2], ax
		mov	al, byte ptr fprod[0]
		mov	byte ptr fprod[1], al
		mov	byte ptr fprod[0], 0
		sub	cx, 8
;
DoOneBits:	mov	ax, fprod[14]
		mov	bx, fprod[12]
		mov	dx, fprod[10]
		mov	si, fprod[8]
		mov	di, fprod[6]
		jmp	short TestOneBits
;
OneBitLoop:	shl	fprod[0], 1
		rcl	fprod[2], 1
		rcl	fprod[4], 1
		rcl	di, 1
		rcl	si, 1
		rcl	dx, 1
		rcl	bx, 1
		rcl	ax, 1
		dec	cx
TestOneBits:	jcxz	StoreProd
		test	ah, 80h
		jz	OneBitLoop
;
StoreProd:	mov	fpacc.mantissa[6], ax
		mov	fpacc.mantissa[4], bx
		mov	fpacc.mantissa[2], dx
		mov	fpacc.mantissa[0], si
		mov	fpacc.exponent, cx
		or	ax, bx
		or	ax, dx
		or	ax, si
		jnz	FMulDone
;
; If underflow occurs, set the result to zero.
;
		mov	fpacc.exponent, ax
		mov	fpacc.sign, al
;
FMulDone:	pop	di
		pop	si
		pop	dx
		pop	cx
		pop	bx
		pop	ax
		pop	ds
		ret
sl_fmul		endp
		assume	ds:nothing
;
;
;
;
; Mul64- Multiplies the 8 bytes in fpacc.mant by the 8 bytes in fpop.mant
;	 and leaves the result in fprod.
;
Mul64		proc	near
		assume	ds:StdGrp
		xor	ax, ax
		mov	fprod[0], ax
		mov	fprod[2], ax
		mov	fprod[4], ax
		mov	fprod[6], ax
		mov	fprod[8], ax
		mov	fprod[10], ax
		mov	fprod[12], ax
		mov	fprod[14], ax
;
; Computing the following (each character represents 16-bits):
;
;	A B C D
;    x  E F G H
;    -------
;
; Product is computed by:
;
;	A B C D
;    x  E F G H
;    ----------
;            HD
;	    HC0
;          HB00
;	  HA000
;	    GD0
;          GC00
;         GB000
;        GA0000
;          FD00
;	  FC000
;        FB0000
;       FA00000
;         ED000
;        EC0000
;       EB00000
;    + EA000000
;    ----------
;      xxxxxxxx
;
; In the loop below, si indexes through A, B, C, and D above (or E, F, G,
; and H since multiplication is commutative).
;
		mov	si, ax			;Set Index to zero.
flp1:		mov	ax, fpacc.mantissa[si]	;Multiply A, B, C, or D
		mul	fpop.mantissa[0]	; by H.
		add	fprod [si], ax		;Add it into the partial
		adc	fprod+2 [si], dx	; product computed so far.
		jnc	NoCarry0
		inc	fprod+4 [si]
		jnz	NoCarry0
		inc	fprod+6 [si]
		jnz	NoCarry0
		inc	fprod+8 [si]
		jnz	NoCarry0
		inc	fprod+10 [si]
		jnz	NoCarry0
		inc	fprod+12 [si]
		jnz	NoCarry0
		inc	fprod+14 [si]
;
NoCarry0:
		mov	ax, fpacc.mantissa[si]	;Multiply A, B, C, or D
		mul	fpop.mantissa[2]	; (selected by SI) by G
		add	fprod+2 [si], ax	; and add it into the
		adc	fprod+4 [si], dx	; partial product.
		jnc	NoCarry1
		inc	fprod+6 [si]
		jnz	NoCarry1
		inc	fprod+8 [si]
		jnz	NoCarry1
		inc	fprod+10 [si]
		jnz	NoCarry1
		inc	fprod+12 [si]
		jnz	NoCarry1
		inc	fprod [14]
;
NoCarry1:
		mov	ax, fpacc.mantissa [si]	;Multiply A, B, C, or D
		mul	fpop.mantissa [4]	; (SI selects) by F and add
		add	fprod+4 [si], ax	; it into the partial prod.
		adc	fprod+6 [si], dx
		jnc	NoCarry2
		inc	fprod+8 [si]
		jnz	NoCarry2
		inc	fprod+10 [si]
		jnz	NoCarry2
		inc	fprod+12 [si]
		jnz	NoCarry2
		inc	fprod+14 [si]
;
NoCarry2:
		mov	ax, fpacc.mantissa [si]	;Multiply A/B/C/D (selected
		mul	fpop.mantissa [6]	; by SI) by E and add it
		add	fprod+6 [si], ax	; into the partial product.
		adc	fprod+8 [si], dx
		jnc	NoCarry3
		inc	fprod+10 [si]
		jnz	NoCarry3
		inc	fprod+12 [si]
		jnz	NoCarry3
		inc	fprod+14 [si]
;
NoCarry3:
		inc	si			;Select next multiplier
		inc	si			; (B, C, or D above).
		cmp	si, 8			;Repeat for 64 bit x 64 bit
		jnb	QuitMul64		; multiply.
		jmp	flp1
QuitMul64:	ret
		assume	ds:nothing
Mul64		endp
;
;
;
;
;
;
;
;
;---------------------------------------------------------------------------
;		Floating Point Division
;---------------------------------------------------------------------------
;
;
;
;
; Floating point division: Divides fpacc by fpop.
;
		public	sl_fdiv
sl_fdiv		proc	far
		assume	ds:StdGrp
		push	ds
		push	ax
		push	bx
		push	cx
		push	dx
		push	si
		push	di
		push	bp
;
		mov	ax, StdGrp
		mov	ds, ax
;
; See if either operand is zero:
;
		mov	ax, fpacc.mantissa[0]	;No need to check exponent!
		or	ax, fpacc.mantissa[2]
		or	ax, fpacc.mantissa[4]
		or	ax, fpacc.mantissa[6]
		jz	QuoIsZero
;
		mov	ax, fpop.mantissa[0]
		or	ax, fpop.mantissa[2]
		or	ax, fpop.mantissa[4]
		or	ax, fpop.mantissa[6]
		jnz	DenomNotZero
;
; Whoops! Division by zero!  Set to largest possible value (+inf) and leave.
;
DivOvfl:	mov	ax, 0ffffh
		mov	fpacc.exponent, ax
		mov	fpacc.mantissa[0], ax
		mov	fpacc.mantissa[2], ax
		mov	fpacc.mantissa[4], ax
		mov	fpacc.mantissa[6], ax
		mov	al, fpop.sign
		xor	fpacc.sign, al
;
; Note: we could also do an INT 0 (div by zero) or floating point exception
; here, if necessary.
;
		jmp	FDivDone
;
;
; If the numerator is zero, the quotient is zero.  Handle that here.
;
QuoIsZero:	xor	ax, ax			;Need this!
		mov	fpacc.sign, al
		mov	fpacc.exponent, ax
		mov	fpacc.mantissa[0], ax
		mov	fpacc.mantissa[2], ax
		mov	fpacc.mantissa[4], ax
		mov	fpacc.mantissa[6], ax
		jmp	FDivDone
;
;
;
; If both operands are non-zero, compute the quotient down here.
;
DenomNotZero:	mov	al, fpop.sign		;Compute the new sign.
		xor	fpacc.sign, al
;
		mov	ax, fpop.exponent	;Compute new exponent.
		sub	ax, 7fffh		;Subtract BIAS.
		mov	bx, fpacc.exponent
		sub	bx, 7fffh
		sub	bx, ax			;Compute new exponent
		jo	DivOvfl
		add	bx, 7fffh		;Add in BIAS
		mov	fpacc.exponent, bx	;Save as new exponent.
;
; Okay, compute the quotient of the mantissas down here.
;
		call	Div64
;
; Normalize the Quotient.
;
		mov	cx, fpacc.exponent
		jmp	short TestNrmDiv
;
; Normalize by shifting 16 bits at a time here.
;
NrmDiv1:	sub	cx, 16
		mov	ax, fpacc.mantissa[4]
		mov	fpacc.mantissa[6], ax
		mov	ax, fpacc.mantissa[2]
		mov	fpacc.mantissa[4], ax
		mov	ax, fpacc.mantissa[0]
		mov	fpacc.mantissa[2], ax
		mov	fpacc.mantissa[0], 0
TestNrmDiv:     cmp	cx, 16
		jb	DoNrmDiv8
		mov  	ax, fpacc.mantissa[6]
		or	ax, ax
		jz	NrmDiv1
;
; Normalize by shifting eight bits at a time here.
;
; See if we can shift the product a whole byte
;
DoNrmDiv8:	cmp	byte ptr fpacc.mantissa[7], 0
		jnz	DoOneBitsDiv
		cmp	cx, 8
		jb	DoOneBitsDiv
		mov	ax, fpacc.mantissa[5]
		mov	fpacc.mantissa[6], ax
		mov	ax, fpacc.mantissa[3]
		mov	fpacc.mantissa[4], ax
		mov	ax, fpacc.mantissa[1]
		mov	fpacc.mantissa[2], ax
		mov	al, byte ptr fpacc.mantissa[0]
		mov	byte ptr fpacc.mantissa[1], al
		mov	byte ptr fpacc.mantissa[0], 0
		sub	cx, 8
;
DoOneBitsDiv:	mov	ax, fpacc.mantissa[6]
		mov	bx, fpacc.mantissa[4]
		mov	dx, fpacc.mantissa[2]
		mov	si, fpacc.mantissa[0]
		jmp	short TestOneBitsDiv
;
; One bit at a time normalization here.
;
OneBitLoopDiv:	shl	si, 1
		rcl	dx, 1
		rcl	bx, 1
		rcl	ax, 1
		dec	cx
TestOneBitsDiv:	jcxz	StoreQuo
		test	ah, 80h
		jz	OneBitLoopDiv
;
StoreQuo:	mov	fpacc.mantissa[6], ax
		mov	fpacc.mantissa[4], bx
		mov	fpacc.mantissa[2], dx
		mov	fpacc.mantissa[0], si
		mov	fpacc.exponent, cx
		or	ax, bx
		or	ax, dx
		or	ax, si
		jnz	FDivDone
;
; If underflow occurs, set the result to zero.
;
		mov	fpacc.exponent, ax
		mov	fpacc.sign, al
;
FDivDone:	pop	bp
		pop	di
		pop	si
		pop	dx
		pop	cx
		pop	bx
		pop	ax
		pop	ds
		ret
sl_fdiv		endp
		assume	ds:nothing
;
;
;
;
; Div64- Divides the 64-bit fpacc.mantissa by the 64-bit fpop.mantissa.
;
div64		proc	near
		assume	ds:StdGrp
;
;
; First, normalize fpop if necessary and possible:
;
		mov	ax, fpop.mantissa[6]
		mov	bx, fpop.mantissa[4]
		mov	cx, fpop.mantissa[2]
		mov	dx, fpop.mantissa[0]
		mov	si, fpacc.exponent
		jmp	short Div16NrmTest
;
; The following loop normalizes fpop 16 bits at a time.
;
Div16NrmLp:	mov	ax, bx
		mov	bx, dx
		mov	cx, dx
		xor	dx, dx
		add	si, 16
Div16NrmTest:	cmp	si, -16
		ja	Div16Nrm8		;Must be unsigned because this
		or	ax, ax			; is bias arithmetic, not
		jz	Div16NrmLp		; two's complement!
;
;
; The following code checks to see if it can normalize by eight bits at
; a time.
;
Div16Nrm8:	cmp	si, -8
		ja	Div1NrmTest		;Must be unsigned!
		cmp	ah, 0
		jnz	Div1NrmTest
		mov	ah, al
		mov	al, bh
		mov	bh, bl
		mov	bl, ch
		mov	ch, cl
		mov	cl, dh
		mov	dh, dl
		mov	dl, 0
		add	si, 8
		jmp	short Div1NrmTest
;
; Down here we're stuck with the slow task of normalizing by a bit
; at a time.
;
Div1NrmLp:	shl	dx, 1
		rcl	cx, 1
		rcl	bx, 1
		rcl	ax, 1
		inc	si
Div1NrmTest:	cmp	si, -1
		je	DivOvfl2		;Can't do it!
		test	ah, 80h
		jz	Div1NrmLp
		jmp	short DoSlowDiv
;
; If overflow occurs, set FPACC to the maximum possible value and quit.
;
DivOvfl2:	mov	ax, 0ffffh
		mov	fpacc.exponent, ax
		mov	fpacc.mantissa[0], ax
		mov	fpacc.mantissa[2], ax
		mov	fpacc.mantissa[4], ax
		mov	fpacc.mantissa[6], ax
		jmp	QuitDiv
;
; Oh No! A GawdAwful bit-by-bit division routine.  Terribly slow!
; Actually, it was sped up a little by checking to see if it could
; shift eight or sixteen bits at a time (because it encounters eight
; or sixteen zeros during the division).
;
; Could possibly speed this up some more by checking for the special
; case of n/16 bits.  Haven't tried this idea out though.
;
DoSlowDiv:	mov	fpacc.exponent, si
		mov	si, ax
		mov	di, bx
		mov	fpop.mantissa[2], cx
		mov	fpop.mantissa[0], dx
		mov	ax, fpacc.mantissa[6]
		mov	bx, fpacc.mantissa[4]
		mov	cx, fpacc.mantissa[2]
		mov	dx, fpacc.mantissa[0]
		mov	bp, 64
DivideLoop:	cmp	bp, 16
		jb      Test8
		or	ax, ax
		jnz	Test8
;
; Do a shift by 16 bits here:
;
		mov	ax, Quotient[4]
		mov	Quotient[6], ax
		mov	ax, Quotient[2]
		mov	Quotient[4], ax
		mov	ax, Quotient[0]
		mov	Quotient[2], ax
		mov	Quotient[0], 0
		mov	ax, bx
		mov	bx, cx
		mov	cx, dx
		xor	dx, dx
		sub	bp, 16
		jnz	DivideLoop
		jmp	FinishDivide
;
Test8:		cmp	bp, 8
		jb      Do1
		cmp	ah, 0
		jnz	Do1
;
; Do a shift by 8 bits here:
;
		push	ax
		mov	ax, Quotient[5]
		mov	Quotient[6], ax
		mov	ax, Quotient[3]
		mov	Quotient[4], ax
		mov	ax, Quotient[1]
		mov	Quotient[2], ax
		mov	al, byte ptr Quotient [0]
		mov	byte ptr Quotient [1], al
		mov	byte ptr Quotient[0], 0
		pop	ax
		mov	ah, al
		mov	al, bh
		mov	bh, bl
		mov	bl, ch
		mov	ch, cl
		mov	cl, dh
		mov	dh, dl
		mov	dl, 0
		sub	bp, 8
		jz	FinishDivide2
		jmp	DivideLoop
FinishDivide2:	jmp	FinishDivide
;
Do1:		cmp	ax, si
		jb	shift0
		ja	Shift1
		cmp	bx, di
		jb	shift0
		ja	Shift1
		cmp	cx, fpop.mantissa[2]
		jb	shift0
		ja	shift1
		cmp	dx, fpop.mantissa[0]
		jb	shift0
;
; fpacc.mantiss IS greater than fpop.mantissa, shift a one bit into
; the result here:
;
Shift1:		stc
		rcl	Quotient[0], 1
		rcl	Quotient[2], 1
		rcl	Quotient[4], 1
		rcl	Quotient[6], 1
		sub	dx, fpop.mantissa[0]
		sbb	cx, fpop.mantissa[2]
		sbb	bx, di
		sbb	ax, si
		shl	dx, 1
		rcl	cx, 1
		rcl	bx, 1
		rcl	ax, 1			;Never a carry out.
		dec	bp
		jnz	jDivideLoop
		jmp	FinishDivide
;
; If fpacc.mantissa was less than fpop.mantissa, shift a zero bit into
; the quotient.
;
Shift0:		shl	Quotient[0], 1
		rcl	Quotient[2], 1
		rcl	Quotient[4], 1
		rcl	Quotient[6], 1
		shl	dx, 1
		rcl	cx, 1
		rcl	bx, 1
		rcl	ax, 1
		jc	Greater
		dec	bp
		jnz	jDivideLoop
		jmp	FinishDivide
jDivideLoop:	jmp	DivideLoop
;
; If there was a carry out of the shift, we KNOW that fpacc must be
; greater than fpop.  Handle that case down here.
;
Greater:	dec	bp
		jz	FinishDivide
		stc
		rcl	Quotient[0], 1
		rcl	Quotient[2], 1
		rcl	Quotient[4], 1
		rcl	Quotient[6], 1
		sub	dx, fpop.mantissa[0]
		sbb	cx, fpop.mantissa[2]
		sbb	bx, di
		sbb	ax, si
		shl	dx, 1
		rcl	cx, 1
		rcl	bx, 1
		rcl	ax, 1
		jc	Greater
		dec	bp
		jz	FinishDivide
		jmp	DivideLoop
;
; Okay, clean everything up down here:
;
FinishDivide:	mov	ax, Quotient[0]
		mov	fpacc.mantissa[0], ax
		mov	ax, Quotient[2]
		mov	fpacc.mantissa[2], ax
		mov	ax, Quotient[4]
		mov	fpacc.mantissa[4], ax
		mov	ax, Quotient[6]
		mov	fpacc.mantissa[6], ax
;
QuitDiv:	ret
		assume	ds:nothing
div64		endp
;
;
;
;
;
;---------------------------------------------------------------------------
;		Floating Point => TEXT (Output) conversion routines.
;---------------------------------------------------------------------------
;
;
;
;
; Power of ten tables used by the floating point I/O routines.
;
; Format for each entry (13 bytes):
;
; 1st through
; 11th bytes	Internal FP format for this particular number.
;
; 12th &
; 13th bytes:	Decimal exponent for this value.
;
;
; This first table contains the negative powers of ten as follows:
;
;   for n:= 0 to 12 do
;	entry [12-n] := 10 ** (-2 ** n)
;   entry [13] := 1.0
;
PotTbln         dw	9fdeh, 0d2ceh, 4c8h, 0a6ddh, 4ad8h	; 1e-4096
		db	0					; Sign
		dw	-4096					; Dec Exponent
;
		dw	2de4h, 3436h, 534fh, 0ceaeh, 656bh	; 1e-2048
		db	0
		dw	-2048
;
		dw	0c0beh, 0da57h, 82a5h, 0a2a6h, 72b5h	; 1e-1024
		db	0
		dw	-1024
;
		dw	0d21ch, 0db23h, 0ee32h, 9049h, 795ah	; 1e-512
		db	0
		dw	-512
;
		dw	193ah, 637ah, 4325h, 0c031h, 7cach	; 1e-256
		db	0
		dw	-256
;
		dw	0e4a1h, 64bch, 467ch, 0ddd0h, 7e55h	; 1e-128
		db	0
		dw	-128
;
		dw	0e9a5h, 0a539h, 0ea27h, 0a87fh, 7f2ah	; 1e-64
		db	0
		dw	-64
;
		dw	94bah, 4539h, 1eadh, 0cfb1h, 7f94h	; 1e-32
		db	0
		dw	-32
;
		dw	0e15bh, 0c44dh, 94beh, 0e695h, 7fc9h	; 1e-16
		db	0
		dw	-16
;
		dw	0cefdh, 8461h, 7711h, 0abcch, 7fe4h	; 1e-8
		db	0
		dw	-8
;
		dw	652ch, 0e219h, 1758h, 0d1b7h, 7ff1h	; 1e-4
		db	0
		dw	-4
;
		dw	0d70ah, 70a3h, 0a3dh, 0a3d7h, 7ff8h	; 1e-2
		db	0
		dw	-2
;
Div10Value	dw	0cccdh, 0cccch, 0cccch, 0cccch, 7ffbh	; 1e-1
		db	0
		dw	-1
;
		dw	0, 0, 0, 8000h, 7fffh			; 1e0
		db	0
		dw	0
;
;
; PotTblP- Power of ten table.  Holds powers of ten raised to positive
;	   powers of two;
;
;		i.e., x(12-n) = 10 ** (2 ** n) for 0 <= n <= 12.
;		      x(13) = 1.0
;		      x(-1) = 10 ** (2 ** -4096)
;
; There is a -1 entry since it is possible for the algorithm to back up
; before the table.
;
		dw	979bh, 8a20h, 5202h, 0c460h, 0b525h	; 1e+4096
		db	0
		dw	4096
;
PotTblP		dw	979bh, 8a20h, 5202h, 0c460h, 0b525h	; 1e+4096
		db	0
		dw	4096
;
		dw	5de5h, 0c53dh, 3b5dh, 9e8bh, 09a92h	; 1e+2048
		db	0
		dw	2048
;
		dw	0c17h, 8175h, 7586h, 0c976h, 08d48h	; 1e+1024
		db	0
		dw	1024
;
		dw	91c7h, 0a60eh, 0a0aeh, 0e319h, 086a3h	; 1e+512
		db	0
		dw	512
;
		dw	0de8eh, 9df9h, 0ebfbh, 0aa7eh, 08351h	; 1e+256
		db	0
		dw	256
;
		dw	8ce0h, 80e9h, 47c9h, 93bah, 081a8h	; 1e+128
		db	0
		dw	128
;
		dw	0a6d5h, 0ffcfh, 1f49h, 0c278h, 080d3h	; 1e+64
		db	0
		dw	64
;
		dw	0b59eh, 2b70h, 0ada8h, 9dc5h, 08069h	; 1e+32
		db	0
		dw	32
;
		dw	0, 400h, 0c9bfh, 8e1bh, 08034h		; 1e+16
		db	0
		dw	16
;
		dw	0, 0, 2000h, 0bebch, 08019h		; 1e+8
		db	0
		dw	8
;
		dw	0, 0, 0, 9c40h, 0800ch			; 1e+4
		db	0
		dw	4
;
		dw	0, 0, 0, 0c800h, 08005h			; 1e+2
		db	0
		dw	2
;
		dw	0, 0, 0, 0a000h, 08002h			; 1e+1
		db	0
		dw	1
;
		dw	0, 0, 0, 8000h, 7fffh			; 1e0
		db	0
		dw	0
;
;
;
;
;
;
;
; SL_FTOA-	Converts extended precision value in FPACC to a decimal
;		string.  AL contains the field width, AH contains the
;		number of positions after the decimal point.  The format
;		of the converted string is:
;
;			sd.e
;
;		where "s" is a single character which is either a space
;		or "=", "e" is some number of digits which is equal to
;		the value passed in AL, and "d" is the number of digits
;		given by  (AL-AH-2).  If the field width is too small,
;		this routine creates a string of "#" characters AH long.
;
;		ES:DI contains the address where we're supposed to put
;		the resulting string.  This code assumes that there is
;		sufficient memory to hold (AL+1) characters at this address.
;
;
;
		public	sl_ftoa
sl_ftoa		proc	far
		push	di
		call	far ptr sl_ftoa2
		pop	di
		ret
sl_ftoa		endp
;
		public	sl_ftoa2
sl_ftoa2	proc	far
		assume	ds:StdGrp
;
		pushf
		push	ds
		push	ax
		push	bx
		push	cx
		push	dx
		push	si
;
		cld
		mov	bx, StdGrp
		mov	ds, bx
;
; Save fpacc 'cause it gets munged.
;
		push	fpacc.Mantissa [0]
		push	fpacc.Mantissa [2]
		push	fpacc.Mantissa [4]
		push	fpacc.Mantissa [6]
		push	fpacc.Exponent
		push	word ptr fpacc.Sign
;
		mov	cx, ax		;Save field width/dec pts here.
;
		call	fpdigits	;Convert fpacc to digit string.
;
; Round the string of digits to the number of significant digits we want to
; display for this number:
;
		mov	bx, DecExponent
		cmp	bx, 18
		jb	PosRS
		xor	bx, bx		;Force to zero if negative or too big.
;
PosRS:		add	bl, ch	       	;Compute position where we should start
		adc	bh, 0		; the rounding.
		inc	bx		;Tweak next digit.
		cmp	bx, 18		;Don't bother rounding if we have
		jae	RoundDone	; more than 18 digits here.
;
; Add 5 to the digit after the last digit we want to print.  Then propogate
; any overflow through the remaining digits.
;
		mov	al, DecDigits [bx]
		add	al, 5
		mov	DecDigits [bx], al
		cmp	al, "9"
		jbe     RoundDone
		sub	DecDigits [bx], 10
RoundLoop:	dec	bx
		js	FirstDigit
		inc	DecDigits[bx]
		cmp	DecDigits[bx], "9"
		jbe	RoundDone
		sub	DecDigits[bx], 10
		jmp	RoundLoop
;
; If we hit the first digit in the string, we've got to shift all the
; characters down one position and put a "1" in the first character
; position.
;
FirstDigit:     mov	bx, DecExponent
		cmp	bx, 18
		jb	FDOkay
		xor	bx, bx
;
FDOkay:		mov	bl, ch
		mov	bh, 0
		inc	bx
FDLp:		mov	al, byte ptr DecDigits[bx-1]
		mov	DecDigits [bx], al
		dec	bx
		jnz	FDLp
		mov	DecDigits, "1"
		inc	DecExponent	;Cause we just added a digit.
;
RoundDone:
;
; See if we're dealing with values greater than one (abs) or between 0 & 1.
;
		cmp	DecExponent, 0	;Handle positive/negative exponents
		jge	PositiveExp	; separately.
;
; Handle values between 0 & 1 here (negative powers of ten).
;
		mov	dl, ch		;Compute #'s width = DecPlaces+3
		add   	dl, 3		;Make room for "-0."
		jc	BadFieldWidth
		cmp	dl, 4
		jae	LengthOk
		mov	dl, 4		;Minimum string is "-0.0"
LengthOK:	mov	al, ' '
PutSpcs2:       cmp	dl, cl
		jae	PS2Done
		stosb
		inc	dl
		jmp	PutSpcs2
;
PS2Done:       	mov	al, DecSign
		stosb
		mov	al, "0"		;Output "0." before the number.
		stosb
		mov	al, "."
		stosb
		mov	ah, 0		;Used to count output digits
		lea	bx, stdGrp:DecDigits ;Pointer to number string.
PutDigits2:	inc	DecExponent
		jns	PutTheDigit
;
; If the exponent value is still negative, output zeros because we've yet
; to reach the beginning of the number.
;
PutZero2:	mov	al, '0'
		stosb
		jmp	TestDone2
;
PutTheDigit:	cmp	ah, 18		;If more than 18 digits so far, just
		jae	PutZero2	; output zeros.
;
		mov	al, [bx]
		inc	bx
		stosb
;
TestDone2:	inc	ah
		dec	ch
		jnz     PutDigits2
		mov	byte ptr es:[di], 0
		jmp	ftoaDone
;
;
; Okay, we've got a positive exponent here.  First, let's adjust the field
; width value (in CH) so that it includes the sign and possible decimal point.
;
PositiveExp:	mov	dx, DecExponent	;Get actual # of digits to left of "."
		inc	dx		;Allow for sign and the fact that there
		inc	dx		; is always one digit to left of ".".
		cmp	ch, 0		;# of chars after "." = 0?
		je	NoDecPt
		add	dl, ch		;Add in number of chars after "."
		adc	dh, 0
		inc	dx		;Make room for "."
NoDecPt:
;
;
; Make sure the field width is bigger than the number of decimal places to
; print.
;
		cmp	cl, ch
		jb	BadFieldWidth
;
;
; Okay, now see if the user is trying to print a value which is too large
; to fit in the given field width:
;
		cmp	dh, 0
		jne	BadFieldWidth	;Sorry, no output >= 256 chars.
		cmp	dl, cl		;Need field width > specified FW?
		jbe	GoodFieldWidth
;
; If we get down here, then we've got a number which will not fit in the
; specified field width.  Fill the string with #'s (sorta like FORTRAN).
;
BadFieldWidth:	mov	ch, 0		;Set CX=field width.
		mov	al, "#"
	rep	stosb
		mov	byte ptr es:[di], 0
		jmp	ftoaDone
;
;
; Print any necessary spaces in front of the number.
;
GoodFieldWidth:	call	PutSpaces
;
; Output the sign character (" " or "-"):
;
		mov	al, DecSign
		stosb
;
; Okay, output the digits for this number here.
;
		mov	ah, 0		;Counts off output characters.
		lea	bx, stdgrp:DecDigits ;Pointer to digit string.
		mov	cl, ch		;CX := # of chars after "."
		mov	ch, 0	       	; plus number of characters before
		add	cx, DecExponent	; the ".".
		inc	cx		;Always at least one digit before "."
OutputLp:	cmp	ah, 18		;Exceeded 18 digits?
		jae	PutZeros
		mov	al, [bx]
		inc	bx
		jmp	PutChar
;
PutZeros:	mov	al, '0'
PutChar:	stosb
		cmp	DecExponent, 0
		jne	DontPutPoint
		mov	al, '.'
		stosb
;
DontPutPoint:	dec	DecExponent
		inc	ah
		loop	OutputLp
		mov	byte ptr es:[di], 0 	;Output the zero byte.
;
ftoaDone:	pop	word ptr fpacc.Sign
		pop	fpacc.Exponent
		pop	fpacc.Mantissa [6]
		pop	fpacc.Mantissa [4]
		pop	fpacc.Mantissa [2]
		pop	fpacc.Mantissa [0]
		pop	si
		pop	dx
		pop	cx
		pop	bx
		pop	ax
		pop	ds
		popf
		ret
sl_ftoa2	endp
;
;
;
;
; Okay, now we need to insert any necessary leading spaces.  We need to
; put (FieldWidth - ActualWidth) spaces before the string of digits.
;
PutSpaces	proc	near
		cmp	dl, cl		;See if print width >= field width
		jae	NoSpaces
		mov	ah, cl
		sub	ah, dl		;Compute # of spaces to print.
		mov	al, ' '
PSLp:		stosb
		dec	ah
		jnz	PSLp
NoSpaces:	ret
PutSpaces	endp
;
;
;
;
;
;
;
;
;
;
;
;
;
;
; SL_ETOA-	Converts value in FPACC to exponential form.  AL contains
;		the number of print positions.  ES:DI points to the array
;		which will hold this string (it must be at least AL+1 chars
;		long).
;
;		The output string takes the format:
;
;		{" "|-} [0-9] "." [0-9]* "E" [+|-] [0-9]{2,4}
;
;		(The term "[0-9]{2,4}" means either two or four digits)
;
;		AL must be at least eight or this code outputs #s.
;
		public	sl_etoa
sl_etoa		proc	far
		push	di
		call	far ptr sl_etoa2
		pop	di
		ret
sl_etoa		endp
;
;
		public	sl_etoa2
sl_etoa2	proc	far
		assume	ds:StdGrp
;
		pushf
		push	ds
		push	ax
		push	bx
		push	cx
		push	si
;
		cld
		mov	bx, StdGrp
		mov	ds, bx
;
		push	fpacc.Mantissa [0]
		push	fpacc.Mantissa [2]
		push	fpacc.Mantissa [4]
		push	fpacc.Mantissa [6]
		push	fpacc.Exponent
		push	word ptr fpacc.Sign
;
		call	fpdigits
;
; See if we have sufficient room for the number-
;
		mov	ah, 0
		mov	cx, ax
;
; Okay, take out spots for sign, ".", "E", sign, and at least four exponent
; digits and the exponent's sign:
;
Subtract2:	sub	ax, 8
		jc	BadEWidth
		jnz	DoTheRound	;Make sure at least 1 digit left!
;
BadEWidth:	mov	ch, 0
		mov	al, "#"
	rep	stosb
		mov	al, 0
		stosb
		jmp	etoaDone
;
; Round the number to the specified number of places.
;
DoTheRound:	mov	ch, al		;# of decimal places is # of posns.
		mov	bl, ch	       	;Compute position where we should start
		mov	bh, 0		; the rounding.
		cmp	bx, 18		;Don't bother rounding if we have
		jae	eRoundDone	; more than 18 digits here.
;
; Add 5 to the digit after the last digit we want to print.  Then propogate
; any overflow through the remaining digits.
;
		mov	al, DecDigits [bx]
		add	al, 5
		mov	DecDigits [bx], al
		cmp	al, "9"
		jbe     eRoundDone
		sub	DecDigits [bx], 10
eRoundLoop:	dec	bx
		js	eFirstDigit
		inc	DecDigits[bx]
		cmp	DecDigits[bx], "9"
		jbe	eRoundDone
		sub	DecDigits[bx], 10
		jmp	eRoundLoop
;
; If we hit the first digit in the string, we've got to shift all the
; characters down one position and put a "1" in the first character
; position.
;
eFirstDigit:    mov	bl, ch
		mov	bh, 0
		inc	bx
eFDLp:		mov	al, byte ptr DecDigits[bx-1]
		mov	DecDigits [bx], al
		dec	bx
		jnz	eFDLp
		mov	DecDigits, "1"
		inc	DecExponent	;Cause we just added a digit.
;
eRoundDone:
;
; Okay, output the value here.
;
		mov	cl, ch		;Set CX=Number of output chars
		mov	ch, 0
		mov	al, DecSign
		stosb
		lea	si, stdgrp:DecDigits
		movsb			;Output first char.
		dec	cx		;See if we're done!
		jz	PutExponent
;
; Output the fractional part here
;
		mov	al, "."
		stosb
		mov	ah, 17		;Max # of chars to output.
PutFractional:	cmp	ah, 0
		jz	NoMoreDigs
		movsb
		dec	ah
		jmp	NextFraction
;
; If we've output more than 18 digits, just output zeros.
;
NoMoreDigs:	mov	al, "0"
		stosb
;
NextFraction:	loop	PutFractional
PutExponent:	mov	al, "E"
		stosb
		mov	al, "+"
		cmp	DecExponent, 0
		jge	NoNegExp
		mov	al, "-"
		neg	DecExponent
;
NoNegExp:	stosb
		mov	ax, DecExponent
		cwd			;Sets DX := 0.
		mov	cx, 1000
		div	cx
		or	al, "0"
		stosb			;Output 1000's digit
		xchg	ax, dx
		cwd
		mov	cx, 100
		div	cx
		or	al, "0"		;Output 100's digit
		stosb
		xchg	ax, dx
		cwd
		mov	cx, 10
		div	cx
		or	al, "0"		;Output 10's digit
		stosb
		xchg	ax, dx
		or	al, "0"		;Output 1's digit
		stosb
		mov	byte ptr es:[di], 0	;Output zero byte.
;
etoaDone:	pop	word ptr fpacc.Sign
		pop	fpacc.Exponent
		pop	fpacc.Mantissa [6]
		pop	fpacc.Mantissa [4]
		pop	fpacc.Mantissa [2]
		pop	fpacc.Mantissa [0]
		pop	si
		pop	cx
		pop	bx
		pop	ax
		pop	ds
		popf
		ret
sl_etoa2	endp
;
;
;
;
;
; FPDigits- Converts the floating point number in FPACC to a string of
;	    digits (in DecDigits), an integer exponent value (DecExp),
;	    and a sign character (DecSign).  The decimal point is assumed
;	    to be between the first and second characters in the string.
;
FPDigits	proc	near
		assume	ds:StdGrp
		push	ds
		push	ax
		push	bx
		push	cx
		push	dx
		push	di
		push	si
;
		mov	ax, seg StdGrp
		mov	ds, ax
;
; First things first, see if this value is zero:
;
		mov	ax, fpacc.Mantissa [0]
		or	ax, fpacc.Mantissa [2]
		or	ax, fpacc.Mantissa [4]
		or	ax, fpacc.Mantissa [6]
		jnz	fpdNotZero
;
; Well, it's zero.  Handle this as a special case:
;
		mov	ax, 3030h		;"00"
		mov	word ptr DecDigits[0], ax
		mov	word ptr DecDigits[2], ax
		mov	word ptr DecDigits[4], ax
		mov	word ptr DecDigits[6], ax
		mov	word ptr DecDigits[8], ax
		mov	word ptr DecDigits[10], ax
		mov	word ptr DecDigits[12], ax
		mov	word ptr DecDigits[14], ax
		mov	word ptr DecDigits[16], ax
		mov	word ptr DecDigits[18], ax
		mov	word ptr DecDigits[20], ax
		mov	word ptr DecDigits[22], ax
		mov	DecExponent, 0
		mov	DecSign, ' '
		jmp	fpdDone
;
; If the number is not zero, first fix up the sign:
;
fpdNotZero:	mov	DecSign, ' '		;Assume it's postive
		cmp	fpacc.Sign, 0
		jns	WasPositive
		mov	DecSign, '-'
		mov	fpacc.Sign, 0		;Take ABS(fpacc).
;
; This conversion routine is fairly standard.  See Neil Graham's
; "Microprocessor Programming for Computer Hobbyists" for the gruesome
; details.  Basically, it first gets the number between 1 & 10 by successively
; multiplying (or dividing) by ten.  For each multiply by 10 this code
; decrements DecExponent by one.  For each division by ten this code
; increments DecExponent by one.  Upon getting the value between 1 & 10
; DecExponent contains the integer equivalent of the exponent.  The
; following code does this.
;
; Note: if the value falls between 1 & 10, then the exponent portion of
;	fpacc will lie between 7fffh and 8002h.
;
WasPositive:	mov	DecExponent, 0		;Initialize exponent.
;
; Quick test to see if we're already less than 10.
;
WhlBgrThan10:	cmp	fpacc.Exponent, 8002h	;See if fpacc > 10
		jb	WhlLessThan1
		ja	IsGtrThan10
;
; If the exponent is equal to 8002h, then we could have a number in the
; range 8 <= n < 16.  Let's ignore values less than 10.
;
		cmp	byte ptr fpacc.Mantissa [7], 0a0h
		jb	WhlLessThan1
;
; If it's bigger than ten we could perform successive divisions by ten.
; This, however, would be slow, inaccurate, and disgusting.  The following
; loop skips through the positive powers of ten (PotTblP) until it finds
; someone with an exponent *less* than fpacc.  Upon finding such a value,
; this code divides fpacc by the corresponding entry in PotTblN.  This is
; equivalent to *dividing* by the entry in PotTblP.  Note: this code only
; compares exponents.  Therefore, it is quite possible that we will divide
; by a number slightly larger than fpacc (since the mantissa of the table
; entry could be larger than the mantissa of fpacc while their exponents
; are equal).  This will produce a result slightly less than one.  This is
; okay in this case because the code which handles values between 0 & 1
; follows and will correct this oversight.
;
IsGtrThan10:	mov	bx, -13			;Index into PotTblP
		mov	ax, fpacc.Exponent
WhlBgrLp1:	add	bx, 13
		cmp	ax, PotTblP [bx] + 8	;Compare exponent values.
		jb	WhlBgrLp1		;Go to next entry if less.

; Okay, we found the first table entry whose exponent is less than or
; equal to the fpacc exponent.  Multiply by the corresonding PotTblN
; value here (which simulates a divide).


		call	nTbl2FPOP
		mov	ax, PotTblP [bx] + 11	;Adjust DecExponent
		add	DecExponent, ax
		call	sl_fMUL			;Divide by appropriate power.
		mov	ax, fpacc.Exponent
		cmp	ax, 8002h		;See if fpacc > 10
		ja	WhlBgrLp1
		jb	WhlLessThan1

; If the exponent is equal to 8002h, then we could have a number in the
; range 8 <= n < 16.  Let's ignore values less than 10.

		cmp	byte ptr fpacc.Mantissa [7], 0a0h
		jae	WhlBgrLp1

; Once we get the number below 10 (or if it was below 10 to begin with,
; drop down here and boost it up to the point where it is >= 1.
;
; This code is similar to the above-  It successively multiplies by 10
; (actually, powers of ten) until the number is in the range 1..10.
; This code is not as sloppy as the code above because we don't have any
; code below this to clean up the sloppiness.  Indeed, this code has to
; be careful because it is cleaning up the sloppiness of the code above.
;
;
WhlLessThan1:	cmp	fpacc.Exponent, 7fffh	;See if fpacc < 1
		jae	NotLessThan1
;
		mov	bx, -13			;Index into PotTblN
WhlLessLp2:	mov	ax, fpacc.Exponent
WhlLessLp1:	add	bx, 13
		cmp	ax, PotTblN [bx] + 8	;Compare exponent values.
		ja	WhlLessLp1		;Go to next entry if less.
;
; Okay, we found the first table entry whose exponent is greater than or
; equal to the fpacc exponent.  Unlike the code above, we cannot simply
; multiply by the corresponding entry in PotTblP at this point.  If the
; exponents were equal, we need to compare the mantissas and make sure we're
; not multiplying by a table entry which is too large.
;
		jne	OkayToMultiply
;
; If the exponents are the same, we need to compare the mantissas.  The
; table entry cannot be larger than fpacc;  if it is, we'll wind up with
; an endless loop oscillating between a couple of values.
;
		mov	ax, fpacc.Mantissa [6]
		cmp	ax, PotTblN [bx] + 6
		ja      WhlLessLp2
		jb	OkayToMultiply
		mov	ax, fpacc.Mantissa [4]
		cmp	ax, PotTblN [bx] + 4
		ja	WhlLessLp2
		jb	OkayToMultiply
		mov	ax, fpacc.Mantissa [2]
		cmp	ax, PotTblN [bx] + 2
		ja	WhlLessLp2
		jb	OkayToMultiply
		mov	ax, fpacc.Mantissa [0]
		cmp	ax, PotTblN [bx]
		ja	WhlLessLp2
;
;
OkayToMultiply:	call	pTbl2FPOP
		mov	ax, PotTblN [bx] + 11	;Adjust DecExponent
		add	DecExponent, ax
		call	sl_fMUL			;Multiply by appropriate power.
		jmp	WhlLessThan1		;Repeat till in range 1..10.
;
;
; The above code tries to get fpacc in the range 1 <= n < 10.
; However, it doesn't quite accomplish this.  In fact, it gets the value
; into the range 1 <= n < 16.  This next section checks to see if the value
; is greater than ten.  If it is, it does one more division by ten.
;
NotLessThan1:	cmp	fpacc.Exponent, 8002h	;10..15 only if exp = 8002h.
		jb	Not10_15
;
; For fpacc to be in the range 10..15 the mantissa must be greater than or
; equal to 0A000 0000 0000 0000.
;
		cmp	byte ptr fpacc.Mantissa [7], 0a0h
		jb	Not10_15
;
; Okay, the mantissa is greater than or equal to ten.  Divide by ten once
; more to fix this up.
;
		lea	bx, stdgrp:Div10Value
		sub	bx, offset stdgrp:PotTblN
		call	pTbl2FPOP
		call	sl_fMUL			;Multiply by appropriate power.
		inc	DecExponent
;
; Well, we've managed to compute the decimal exponent value and normalize
; the number to the range 1 <= n < 10.
;
; Make sure the upper four bits contain a BCD value.  This may entail
; shifting data to the right.
;
Not10_15:	mov	si, fpacc.Mantissa [0]	;We'll use these a lot, so
		mov	di, fpacc.Mantissa [2]	; put them into registers.
		mov	cx, fpacc.Mantissa [4]
		mov	dx, fpacc.Mantissa [6]
SHRLp:		cmp	fpacc.Exponent, 8002h
		jae	PossiblyRound
		shr	dx, 1
		rcr	cx, 1
		rcr	di, 1
		rcr	si, 1
		inc	fpacc.Exponent
		jmp     SHRLp
;
; May have to round the number if we wound up with a value between 10..15.
;
; Note: 0.5 e -18 is 7fc5 b8xxxxxxxx...   If we adjust this value so that
;	the exponent is 7fffh, we keep only the top five bits (10111).  The
;	following code adds this value (17h) to the mantiss to round as
;	appropriate.
;
PossiblyRound:	add	si, 2h
		jnc	ChkTooBig
		inc	di
		jnz	ChkTooBig
		inc	cx
		jnz	ChkTooBig
		inc	dx
;
; If we fall through to this point, it's quite possible that we will produce
; a value greater than or equal to ten.  Handle that possibility here.
;
ChkTooBig:	cmp	dh, 0a0h
		jb	NoOvrflw
;
; Well, overflow occurred, clean it up.
;
		xor	ax, ax
		mov	si, ax
		mov	di, ax
		mov	cx, ax
		mov	dx, 1000h
		inc	DecExponent
;
; Finally!  We're at the point where we can start stripping off the
; digits from the number
;
NoOvrflw:	lea	bx, stdgrp:DecDigits
		xor	ax, ax
;
StripDigits:	mov	al, dh
		shr	ax, 1
		shr	ax, 1
		shr     ax, 1
		shr	ax, 1
		or	al, '0'
		mov	[bx], al
		inc	bx
		cmp	bx, offset stdgrp:DecDigits+18
		jae	fpdDone
;
; Remove the digit we just stripped:
;
		and	dh, 0fh
;
; Multiply the mantissa by ten (using shifts and adds):
;
		shl	si, 1
		rcl	di, 1
		rcl	cx, 1
		rcl	dx, 1
		mov	fpacc.Mantissa [0], si	;Save *2
		mov	fpacc.Mantissa [2], di
		mov	fpacc.Mantissa [4], cx
		mov	fpacc.Mantissa [6], dx
;
		shl	si, 1			;*4
		rcl	di, 1
		rcl	cx, 1
		rcl	dx, 1
;
		shl	si, 1			;*8
		rcl	di, 1
		rcl	cx, 1
		rcl	dx, 1
;
		add	si, fpacc.Mantissa [0]	;*10
		adc	di, fpacc.Mantissa [2]
		adc	cx, fpacc.Mantissa [4]
		adc	dx, fpacc.Mantissa [6]
		jmp     StripDigits
;
fpdDone:        pop	si
		pop	di
		pop	dx
		pop	cx
		pop	bx
		pop	ax
		pop	ds
		ret
FPDigits	endp
;
;
;
; nTbl2FPOP- BX is an index into PotTbln.  This routine fetches the entry
;	     at that index and copies it into FPOP.
;
nTbl2FPOP	proc	near
		mov	ax, PotTbln [bx] + 8
		mov	fpop.Exponent, ax
		mov	ax, PotTbln [bx]
		mov	fpop.Mantissa [0], ax
		mov	ax, PotTbln [bx] + 2
		mov	fpop.Mantissa [2], ax
		mov	ax, PotTbln [bx] + 4
		mov	fpop.Mantissa [4], ax
		mov	ax, PotTbln [bx] + 6
		mov	fpop.Mantissa [6], ax
		mov	fpop.Sign, 0		;All entries are positive.
		ret
nTbl2FPOP	endp
;
; pTbl2FPOP- Same as above except the data comes from PotTblP.
;
pTbl2FPOP	proc	near
		mov	ax, PotTblp [bx] + 8
		cmp	ax, 7fffh
		jne	DoPTFPOP
		sub	bx, 13			;Special case if we hit 1.0
		mov	ax, PotTblp [bx] + 8
;
DoPTFPOP:	mov	fpop.Exponent, ax
		mov	ax, PotTblp [bx]
		mov	fpop.Mantissa [0], ax
		mov	ax, PotTblp [bx] + 2
		mov	fpop.Mantissa [2], ax
		mov	ax, PotTblp [bx] + 4
		mov	fpop.Mantissa [4], ax
		mov	ax, PotTblp [bx] + 6
		mov	fpop.Mantissa [6], ax
		mov	fpop.Sign, 0		;All entries are positive.
		ret
pTbl2FPOP	endp
;
;
;
;
;
;----------------------------------------------------------------------------
;	       Text => Floating Point (Input) Conversion Routines
;----------------------------------------------------------------------------
;
;
; ATOF-		ES:DI points at a string containing (hopefully) a numeric
;		value in floating point format.  This routine converts that
;		value to a number and puts the result in fpacc.  Allowable
;		strings are described by the following regular expression:
;
;		{" "}* {+ | -} ( ([0-9]+ {"." [0-9]*}) | ("." [0-9]+)}
;				{(e | E) {+ | -} [0-9] {[0-9]*}}
;
; "{}" denote optional items.
; "|"  denotes OR.
; "()" groups items together.
;
;
shl64		macro
		shl	bx, 1
		rcl	cx, 1
		rcl	dx, 1
		rcl	si, 1
		endm
;
		public	sl_ATOF
sl_ATOF		proc	far
		assume	ds:StdGrp, es:nothing
;
		push	ds
		push	ax
		push	bx
		push	cx
		push	dx
		push	si
		push	di
		push	bp
;
		mov	ax, StdGrp
		mov	ds, ax
;
;
; First, skip any leading spaces:
;
		mov	ah, " "
SkipBlanks:	mov	al, es:[di]
		inc	di
		cmp	al, ah
		je	SkipBlanks
;
; Check for + or -.
;
		cmp	al, "-"
		jne	TryPlusSign
		mov	fpacc.Sign, 80h
		jmp	EatSignChar
;
TryPlusSign:	mov	fpacc.Sign, 0		;If not "-", then positive.
		cmp	al, "+"
		jne	NotASign
EatSignChar:	mov	al, es:[di]		;Get char beyond sign
		inc	di
;
; Init some important local vars:
; Note: BP contains the number of significant digits processed thus far.
;
NotASign:	mov	DecExponent, 0
		xor	bx, bx			;Init 64 bit result.
		mov	cx, bx
		mov	dx, bx
		mov	si, bx
		mov	bp, bx
		mov	ah, bh
;
; First, eliminate any leading zeros (which do not count as significant
; digits):
;
Eliminate0s:	cmp	al, "0"
		jne	EndOfZeros
		mov	al, es:[di]
		inc	di
		jmp	Eliminate0s
;
; When we reach the end of the leading zeros, first check for a decimal
; point.  If the number is of the form "0---0.0000" we need to get rid
; of the zeros after the decimal point and not count them as significant
; digits.
;
EndOfZeros:	cmp	al, "."
		jne	WhileDigits
;
; Okay, the number is of the form ".xxxxx".  Strip all zeros immediately
; after the decimal point.
;
Right0s:	mov	al, es:[di]
		inc	di
		cmp	al, "0"
		jne	FractionPart
		dec	DecExponent		;Not significant digit, but
		jmp	Right0s			; affects exponent.
;
;
; If the number is of the form "yyy.xxxx" (where y <> 0) then process it
; down here.
;
WhileDigits:	sub	al, "0"
		cmp	al, 10
		jae	NotADigit
;
; See if we've processed more than 19 sigificant digits:
;
		cmp	bp, 19			;Too many significant digits?
		jae	DontMergeDig
;
; Multiply value in (si, dx, cx, bx) by ten:
;
		shl64
		mov	fpacc.Mantissa [0], bx
		mov	fpacc.Mantissa [2], cx
		mov	fpacc.Mantissa [4], dx
		mov	fpacc.Mantissa [6], si
		shl64
		shl64
		add	bx, fpacc.Mantissa [0]
		adc	cx, fpacc.Mantissa [2]
		adc	dx, fpacc.Mantissa [4]
		adc	si, fpacc.Mantissa [6]
;
; Add in current digit:
;
		add	bx, ax
		jnc     GetNextDig
		inc	cx
		jne	GetNextDig
		inc	dx
		jne	GetNextDig
		inc	si
		jmp	GetNextDig
;
DontMergeDig:	inc	DecExponent
GetNextDig:	inc	bp			;Yet another significant dig.
		mov	al, es:[di]
		inc	di
		jmp	WhileDigits
;
;
; Check to see if there is a decimal point here:
;
NotADigit:	cmp	al, "."-"0"
		jne	NotADecPt
		mov	al, es:[di]
		inc	di
;
; Okay, process the digits to the right of the decimal point here.
;
FractionPart:	sub	al, "0"
		cmp	al, 10
		jae	NotADecPt
;
; See if we've processed more than 19 sigificant digits:
;
		cmp	bp, 19			;Too many significant digits?
		jae	DontMergeDig2
;
; Multiply value in (si, dx, cx, bx) by ten:
;
		dec	DecExponent		;Raise by a power of ten.
		shl64
		mov	fpacc.Mantissa [0], bx
		mov	fpacc.Mantissa [2], cx
		mov	fpacc.Mantissa [4], dx
		mov	fpacc.Mantissa [6], si
		shl64
		shl64
		add	bx, fpacc.Mantissa [0]
		adc	cx, fpacc.Mantissa [2]
		adc	dx, fpacc.Mantissa [4]
		adc	si, fpacc.Mantissa [6]
;
; Add in current digit:
;
		add	bx, ax
		jnc     DontMergeDig2
		inc	cx
		jne	DontMergeDig2
		inc	dx
		jne	DontMergeDig2
		inc	si
;
DontMergeDig2:	inc	bp			;Yet another significant dig.
		mov	al, es:[di]
		inc	di
		jmp	FractionPart
;
; Process the exponent down here
;
NotADecPt:	cmp	al, "e"-"0"
		je	IsExponent
		cmp	al, "E"-"0"
		jne	NormalizeInput
;
; Okay, we just saw the "E" character, now read in the exponent value
; and add it into DecExponent.
;
IsExponent:	mov	ExpSign, 0		;Assume positive exponent.
		mov	al, es:[di]
		inc	di
		cmp	al, "+"
		je	EatExpSign
		cmp	al, "-"
		jne	ExpNotNeg
		mov	ExpSign, 1		;Exponent is negative.
EatExpSign:	mov	al, es:[di]
		inc	di
ExpNotNeg:	xor	bp, bp
ExpDigits:      sub	al, '0'
		cmp	al, 10
		jae	EndOfExponent
		shl	bp, 1
		mov	TempExp, bp
		shl	bp, 1
		shl	bp, 1
		add	bp, TempExp
		add	bp, ax
		mov	al, es:[di]
		inc	di
		jmp	ExpDigits
;
EndOfExponent:	cmp	ExpSign, 0
		je	PosExp
		neg	bp
PosExp:		add	DecExponent, bp
;
; Normalize the number here:
;
NormalizeInput:	mov	ax, si			;See if they entered zero.
		or	ax, bx
		or	ax, cx
		or	ax, dx
		jnz	ItsNotZero
		jmp	ItsZero
;
ItsNotZero:	mov	ax, si
		mov	si, 7fffh+63		;Exponent if already nrm'd.
NrmInp16:	or	ax, ax			;See if we can shift 16 bits.
		jnz	NrmInp8
		mov	ax, dx
		mov	dx, cx
		mov	cx, bx
		xor	bx, bx
		sub	si, 16
		jmp	NrmInp16
;
NrmInp8:	cmp	ah, 0
		jne	NrmInp1
		mov	ah, al
		mov	al, dh
		mov	dh, dl
		mov	dl, ch
		mov	ch, cl
		mov	cl, bh
		mov	bh, bl
		mov	bl, 0
		sub	si, 8
;
NrmInp1:	cmp	ah, 80h
		jae	NrmDone
		shl	bx, 1
		rcl	cx, 1
		rcl	dx, 1
		rcl	ax, 1
		dec	si
		jmp	NrmInp1
;
; Okay, the number is normalized.  Now multiply by 10 the number of times
; specified in DecExponent.  Obviously, this uses the power of ten tables
; to speed up this operation (and make it more accurate).
;
NrmDone:	mov	fpacc.Exponent, si	;Save away the value so far.
		mov	fpacc.Mantissa [0], bx
		mov	fpacc.Mantissa [2], cx
		mov	fpacc.Mantissa [4], dx
		mov	fpacc.Mantissa [6], ax
;
		mov	bx, -13			;Index into POT table.
		mov	si, DecExponent
		or	si, si			;See if negative
		js	NegExpLp
;
; Okay, the exponent is positive, handle that down here.
;
PosExpLp:	add	bx, 13			;Find the 1st power of ten
		cmp	si, PotTblP [bx] + 11	; in the table which is
		jb	PosExpLp		; just less than this guy.
		cmp	PotTblP [bx] + 8, 7fffh	;Hit 1.0 yet?
		je	MulExpDone
;
		sub	si, PotTblP [bx] + 11	;Fix for the next time through.
		call	PTbl2FPOP		;Load up current power of ten.
		call	sl_FMUL			;Multiply by this guy.
		jmp	PosExpLp
;
;
; Okay, the exponent is negative, handle that down here.
;
NegExpLp:	add	bx, 13			;Find the 1st power of ten
		cmp	si, PotTblN [bx] + 11	; in the table which is
		jg	NegExpLp		; just less than this guy.
		cmp	PotTblN [bx] + 8, 7fffh	;Hit 1.0 yet?
		je	MulExpDone
;
		sub	si, PotTblN [bx] + 11	;Fix for the next time through.
		call	NTbl2FPOP		;Load up current power of ten.
		call	sl_FMUL			;Multiply by this guy.
		jmp	NegExpLp
;
; If the user entered zero, drop down here and zero out fpacc.
;
ItsZero:	xor	ax, ax
		mov	fpacc.Exponent, ax
		mov	fpacc.Sign, al
		mov	fpacc.Mantissa [0], ax
		mov	fpacc.Mantissa [2], ax
		mov	fpacc.Mantissa [4], ax
		mov	fpacc.Mantissa [6], ax
;
; Round the result to produce a *halfway* decent number
;
MulExpDone:     cmp	fpacc.Exponent, 0ffffh		;Don't round if too big.
		je	atofDone
		shl	byte ptr fpacc.Mantissa, 1	;Use L.O. bits as guard
		adc	byte ptr fpacc.Mantissa [1], 0	; bits.
		jnc	atofDone
		inc	fpacc.Mantissa[2]
		jne	atofDone
		inc	fpacc.Mantissa[4]
		jne	atofDone
		inc	fpacc.Mantissa[6]
		jne	atofDone
		inc	fpacc.Exponent
;
atofDone:	mov	byte ptr fpacc.Mantissa, 0
		pop	bp
		pop	di
		pop	si
		pop	dx
		pop	cx
		pop	bx
		pop	ax
		pop	ds
		ret
sl_ATOF		endp
;
;
stdlib		ends
		end