Trailing-Edge - PDP-10 Archives - klu2_442 - extexp.mic
There are 5 other files named extexp.mic in the archive. Click here to see a list.


102:	R,	B/0,	J/EDFLOT	;GFAD
103:	R,	B/2,	J/EDFLOT	;GFSB
106:	R,	B/4,	J/EDFLOT	;GFMP
107:	R,	B/6,	J/EDFLOT	;GFDV

	FM[E0]_AR, ARX_ARX*2, B DISP	;mem high to E0, do instruction

EDFL1:	SKP AR0, CALL [ISOEXP]		;save mem high word in E0.
	FM[T2]_AR, J/EF1		;save mem exp in T2.
	AR_-AR LONG			;subtract now same as add.
	FM[E0]_AR, J/EDFL1		;save "positive" exponent
=100	SKP AR0, CALL [ISOEXP]		;isolate mem exp in AR.
	BR/AR, GEN ARX, SKP AD NE,	;start test for sticky bits.
=110	BR/AR, GEN AR, SKP AD0, 	;save mem high in br.
		CALL [ISOEXP]		;get mem exp
	FM[T2]_AR, AR_0S, J/EFDV0	;save mem exp in T2. No sticky bits.
EF1:	AR_AC0, SKP AD0, CALL [ISOEXP]	;get AC op
	FM[E1]_AR, BR/AR		;save AC exp in E1
;Now have positive mem exponent in T2, pos AC exp in E1.
;Save larger exp in T2 and exp diff if less than 340 in SC.
	[AR]_[AR]*FM[T2], AD/A-B,	;AR gets exp diff.
		SKP AD0			;AR get exp diff, BRX gets exp.
=00	SC_#, #/3, CALL [EXPDIF]	;test for exp diff >72.
	BR/AR, J/EF3A			;mem op larger.
	AR_BR, J/EF5			;restore exp to AR.
	[AR]_FM[E1], CLR FE, J/ACNORM	;exp diff too large, norm AC op.
EF3A:	AR_-BR, SC_#, #/3, CALL [EXPDIF];mem larger, get positive diff.
=10	AR_BR, J/EF3B			;restore exponent to AR.
	[AR]_FM[T2], CLR FE, J/MEMNRM	;exp diff > 72. norm mem op.
EF3B:	AR_AR*8				;move exp difference into AR0-8.
	FE_AR0-8,			;mem larger, op doable.
		AR_AC0			;save smaller AC op in T0,T1
=0	FM[T0]_AR, CALL [EF5B]
	[AR]_FM[E0]			;save larger mem op in AC0,AC1
	AC1_AR, J/EF5A			;all set to shift and add.

EF5:	AR_AR*8				;move exp difference into AR0-8.
	FE_AR0-8, [AR]_FM[E0]		;smaller mem op to T0,T1
=0	FM[T1]_AR, CALL [EF5B]
	AC1_AR				;we expect AC1*2 to be saved.
	[AR]_FM[E1]			;save larger AC exp in T2
	FM[T2]_AR, J/EF5A


;EXPDIF determines if the exponent difference is too large-ie >110 oct.
;The largest allowed value for shifting is 72 decimal. This is 110 octal.
;Since the exponent is in AR1-11, 110 octal has the value 11 in AR1-8.
;It expects the exponent difference in AR0-8.
;It uses AR0-8 and the BR.
;Returns 2 if the difference is ok (<=110).
;Returns 3 if the difference is too large (>110).
EXPDIF:	BR/AR, CLR AR			;zero all of those bits.
	AR0-8_#, #/10			;put in 100 in AR0-11.
	GEN AR-BR, SKP AD0, RETURN2	;<max diff>-<actual diff>

;We now have:
; AC0	/ larger op high
; AC1	/ larger op low
; T0	/ smaller op high
; T1	/ smaller op low
; T2	/ larger exponent
; FE	/ exp difference
;We must now sign extend both high ops.
EF5A:	AR_AC0, SKP AD0, CALL [SGNEXT]	;get larger high op
	AC0_AR				;save larger extended op in AC0
=0	[AR]_FM[T0], SKP AD0,		;get smaller high op
		CALL [SGNEXT]		; and sign extend into AR1-11.
	FM[T0]_AR			;save smaller extended op in T0
;We are now set to shift the smaller op to align it with the larger op.
	[AR]_FM[T0], ARX_AR, SC_FE	;move diff to SC for next line.
	SC_#-SC, #/36., SKP SCAD0
=0	ARX_AR, AR_SIGN, J/EF10		;FE < 37.
	SC_#-SC, #/72.
	ARX_SHIFT			;high is sign, low is sign,,high.
=01	AR_BR LONG, BR/AR, BRX/ARX,	;save new stuff in BR long.
		CALL [EF12]		;MQ gets lowest word.
	FM[E1]_AR			;save sticky bits.
	AR_AC1, J/EF11			;now prepare to add.
EF10:	AR_SHIFT, [ARX]_FM[T1]		;shift high op, load low word.
	BR/AR, [AR]_FM[T0]		;shift low op, load high word.
	AR_ARX (AD), ARX_SHIFT		;get shifted low word into ARX.
=01	BRX/ARX, CLR ARX, CALL [EF12]	;save low word, shift end bits.
	FM[E1]_AR			;save sticky bits. (word 4 of sum).
	AR_AC1, J/EF11			;prepare to add.
	BR/AR, BRX/ARX, AR_AC1		;get larger op in AR,ARX
EF11:	ARX_AR, AR_AC0, FE_#, #/0	;smaller op in BR,BRX
	AR_AR+BR, ARX/ADX, SC_#, #/3,	;operation done, now normalize.

.IF/GFTCNV		;[273]
EFMP:	CLR AR, J/EFMP1			;mem low op is zero, no sticky bits.
	AR_AC1*2, SKP AD NE		;is AC low op non-zero as well ?
=0	CLR AR				;yes, no sticky bits today.
EFMP1:	FM[E1]_AR, AR_0S		;set sticky bits.
	AR0-8_#, #/200			;subtract 200.
	BR/AR, AR_BR			;swap around exp and 2000.
	AR_AR-BR, CLR SC		;done, and SC is cleared.
=0	BR/AR, AR_AC0, SKP AD0,		;save exp-2000 in BR.
		CALL [ISOEXP]		;get AC high and isolate exp.
	AR_AR+BR			;add exponents together.
	FM[T2]_AR			;and store the sum in T2.
=0	[AR]_FM[E0], SKP AD0,		;get mem high op sign extended.
	FE_#, #/-18.			;
	BR/AR, BRX/ARX, AR_AC1		;move mem ops to BR!BRX.
=000	MQ_AR, AR_0S, ARX_0S,		;multiply by low word.
=100	AR_AR+BR LONG			;low sign was set, add results.
=110	MQ_AR, AR_AC0, FE_#, #/-13.,	;now continue with high part.
		SKP AD0, CALL [SGNEXT]	;sign extend the ac high op.
	FM[T0]_AR			;save sign extended AC op.
;	SKP AR0				;test sign bit to adjust FE.
	FE_FE+1, J/EFMPP1		;inc the FE if number is neg.
EFMPP2:	AD/0S, FE_FE+1, DISP/MUL,	;now multiply by the high word.
		MQ/MQ*.25, CALL [MULP]
;Since our last multiply step used 2 signs bits instead of a sign bit
;and the MSB, our answer is too low by a power of two for positive numbers
;and too low by a power of 4 for negative numbers.
=100	(AR+ARX+MQ)*2, J/EFMPP3		;try this correction factor.
=101	(AR+ARX+MQ)*.25, J/EFMPP3	;shouldn't ever get here.
=110	(AR+ARX+MQ)*2			;and this for postive numbers.
EFMPP3:	BR_AR LONG, AR_0.C, ARX_1S	;result to BR!BRX. Build mask.
=01	SC_#, #/10.,			;load SC with shift count.
		CALL [SHIFT]		;Now have mask of 0,,1777
	AR_BR LONG, BR_AR LONG		;mask to BR, result TO AR!ARX.
	MQ_MQ*BR, AD/ANDCB		;clear the last 10 MQ bits.
	GEN AR, SC_#, #/3,		;generate NORM bits.
		NORM, J/ENORM		;conditions set for EE norm.
EFDV0:	FM[E1]_AR			;no sticky bits on divide.
=0	AR_BR, SKP AD0, CALL [SGNEXT]	;sign extend mem high.
	GEN AR*AC0, AD/XOR, SKP AD0,	;determine sign of result.
		BR_AR LONG		;mem op to BR!BRX.
=000	AR_AC1*2, CALL [EFDV1]		;start division.
	SR_1, AR_AC1*2, CALL [EFDV1]	;note result if negative.

=011	AC1_AR, AR_MQ, ARL/AD, FE_FE+1,	;set step count to 35-2.
		MQ_0.M, CALL [DIV+]	
=101	AC1_AR, AR_MQ, ARL/AD, FE_FE+1,
		MQ_0.M, CALL [DIV-]
=111	CLR AR, CLR FE			;exp must be adjusted-
	AR0-8_#, #/200			;  it is currently 2000 too low
	[AR]_[AR]*FM[T2], AD/A+B	;add in the correction.
	FM[T2]_AR			;store the corrected exp in T2.
	AR_AC1, ARX/MQ, SC_#, #/3,	;get answer ready for norm.

EFDV1:	ARX_AR, AR_AC0, SKP AD0, FE_#,	;AC low*2 to ARX, AC high to AR.
		#/23., CALL [EDVCHK]
	SET FL NO DIV, J/IFNOP		;no division this time.

EDVCHK:	MQ_AR, J/EDVCH1			;go to an even address.
	AR_-AR LONG, J/EDVCHK		;make ac op positive.

EDVCH1:	SKP AR0, CALL [ISOEXP]		;op saved in MQ, get exp in AR.
	[AR]_[AR]*FM[T2], AD/A-B,	;subtract exponents.
		SKP AD0			;did this cause an underflow ?
	SET SR2 			;no, let SR2 denote this.
EDVCH2:	FM[T2]_AR			;yes, save exponent in T2 for ENORM.

EDVCH3:	AR_MQ, SKP AD0, CALL [SGNEXT]	;now sign extend the op.
;Normalization is done here.
;	The are 8 addresses the can be reached when doing a
;	NORM dispatch. The following table describes the
;	dispatching and how to normalize the fraction and
;	exponent.
;	=000	AR=0			AR is zero, check ARX,MQ
;	=001	AR00=1			sign bit on, complement
;	=010	MSB in AR 1-6		shf 4 rt.(a guess)
;	=011	MSB in AR07		sht 2 rt.
;	=100	MSB in AR08		sht 3 rt.
;	=101	MSB in AR09		right on!
;	=110	MSB in AR10		sht 1 lf.
;	=111	MSB in AR 11-35		sht 4 lf.(a guess)
;The normalization routine for double precision assumes that
;	the exponent can be found in the FE. As it goes through
;	the normalization process, it adjusts the fraction and
;	the FE by the correct amounts to normalize the number.
;	In GFLT numbers, the exponent may not fit
;	into the FE, so it has to be saved in an accumulator.
;	However, if one assumes initially that the exponent is
;	zero and that it is in the FE, then the same normalization
;	algorithm can be used as in double precision numbers
;	with the realization that at the end of the normalization
;	process the FE contains the correction (EC)  that must be
;	added into the saved exponent (ES)  to produce a 'bit-9'
;	normalized number. Once this correction value is obtained,
;	the 'bit-12' normalized exponent (EN)  is given by
;			EN = ES + EC + 3

MEMNRM:	FM[T2]_AR			;save larger exponent.
	[AR]_FM[E0], SKP AD0, J/ACNRM1	;get high word, sign extend it

ACNORM:	FM[T2]_AR			;save larger exponent.
	AR_AC1*2, CLR FE		;get low word*2 into AR.
	ARX_AR, AR_AC0, SKP AD0		;get high word, sign extend it.
ACNRM1:	[AR]_[AR]*FM[EXPMSK], AD/AND,	;sign extend with 0's.
	[AR]_[AR]*FM[EXPMSK], AD/ORCB,	;sign extend with 1's.
		NORM			;fall into the normalize routine.

ENORM:	SKP ARX+MQ NE, SC_#, #/35.,	;AR=0,check ARX,+MQ.
	BR/AR, BRX/ARX, AR_MQ COMP,	;result neg, complement.
		SET SR3, J/ENNEG	;flag negative seen.
	AR_AR*.25 LONG, MQ_MQ*.25,	;MSB in AR 1-6.
		FE_FE+#, #/4, J/ENHI
	AR_AR*.25 LONG, FE_FE+#,	;MSB in AR07.
		#/2, J/EROUND		;
	AR_AR*.5 LONG, FE_FE+1		;MSB in AR08.
EROUND:	BR_AR LONG, AR+MQ_0.S,	 	;MSB in AR09, where we want it.
		J/ERND1			;put result in BR!BRX.
	(AR+ARX+MQ)*2, FE_FE-1,		;MSB in AR10.
	AR_SHIFT, FE_FE-SC		;MSB somewhere in AR 11-35.

ENSHFT:	BR/AR, AR_ARX, ARX/MQ		;shift everyone.
	MQ_SHIFT, ARX/MQ, AR_BR,	;go aroung again.
		SC_#, #/10.,

ENNEG:	GEN E1, SKP AD NE		;any sticky bits left around?
=0	AR_AR+1, SKP CRY0, J/ENNEG1	;no, 2's comp MQ.
		NORM, J/ENORM		;one's complement to finish.
		NORM, J/ENORM		;one's complement to finish.
	MQ_AR, AR_-BR, ARX/ADX,		;carry happened, do two's comp.

ENHI:	(AR+ARX+MQ)*.25, J/ENTRY	;go try again after setting SC.
ENZERO:	SR_0,AR_0S,ARX_0S,I FETCH,J/DLOAD;[413] result 0, store in AC,AC+1
	AR_SHIFT, FE_FE-SC, J/ENSHFT	;not zero, try next 35 bits.

ERND1:	ARX_2+MQ0			;[407] build rounding constant.
	ARX_ARX*4			;gen a 10 in the ARX for rounding.
	AR_AR+BR, ARX/ADX, NORM		;do the rounding and test norm.
=110	AR_AR*.5 LONG, FE_FE+1		;rounding blew norm, correct it.

; When we get here the number is 'bit-9' normalized
; in the AR,ARX.  Add the FE + 3 to the exponent
; saved in T2.
; At this point the Extended Exponent must be put
; into the AR after everything is shifted right 3 bits.
; The double precision norm routine does this by:

ERND2:	AR_AR*.25 LONG,		;shift everything 2 bits right.
		MQ_MQ*.25,	;	"	"	"
		SC_#, #/3	;add in correction to FE.
	AR_AR*.5 LONG,		;now shift the final bit position.
		SC_FE+SC	;total exponent correction.
	BR/AR, BRX/ARX, CLR AR	;save answer in BR,BRX.
	EXP_SC.MS		;get exp corr in AR.
	ARX_AR, AR_SIGN,	;get exp into ARX 1-8.
		SC_#,#/33.	;prepare to shift 3 places.
	ARX_SHIFT,		;move exponent into ARX 1-11.
		[AR]_FM[EXPMSK]	;prepare to build mask in AR.
	AR0-8_#, #/400		;include AR00 in EXPMSK==>400077,,-1
	AR_AR*BR, AD/AND,	;zero AR1-11 to make room for exp.
		SC_#, #/35.

; I am sure a few lines of code can be saved around here.

	[AR]_FM[T2], BR/AR	;save high word in BR, load larger exp.
	AR_BR, BR/AR		;swap around so we can add.
	AR_ARX+BR, BR/AR,	;have final exponent, check for problems.
	SH DISP			;any exponent problems ?
=0011	ARX_AR, SC_#, #/35.,	; no problems.
ENFNL0:	ARX_AR, SC_#, #/35.,	; no problems.
	SET FLOV,  J/EEOV	; an overflow occurred.
	SR DISP			;floating underflow - is it real ?
=1101	;test SR2.
	SET FXU, J/EEOV		;yes, it is a real underflow.
	SET FLOV		;no, GFDV saw an overflow before.

EEOV:	P_P AND #, #/37,	;turn off AR00.

ENFNL1:	AR_ARX*BR, AD/OR	;AR now has high word, BRX has low.
	ARX_1, MQ_0.M, SR DISP	;incase negation of lower word needed.
=10	AC0_AR, AR_SHIFT,	;store high word,
		ARX_BRX,	;move low word to ARX.
		I FETCH, J/STD1	;prepare to store low word and exit.
	ARX_ARX*BRX, AD/ANDCA,	; clear rounding bit.
		SR_0,J/CDBLST	;negate result and store double result.

ENTRY:	SC_#, #/3, GEN AR, NORM, J/ENORM; go normalize again.
.IF/GFTCNV		;[273]

;ETXIX routine is used when converting extended exponent data to
;single/double precision integers with rounding/truncation.
;This routine assumes that the AR/ARX contain the extended exponent
;data. It also assumes that the maximum exponent value + 1 of either
;36 or 70 (decimal) are already in the FE. This is the positive exponent
;maximum; the code adjusts for the fact that a negative number can have
;an exponent one greater than a positive number. 
;It uses all of the registers in the EBOX and returns 4 if the
;result is positive and returns 5 if the result is negative
;with the AR/ARX containing the double word integer. It is the
;responsibility of the calling routine to determine whether
;rounding or truncation should be performed and how many words
;to store.

ETXIX:	ARX_ARX*2		;get low word*2 into ARX.
=0	MQ_AR, SKP AR0,		; get a positive exp in AR.
	CLR AR, BR/AR		;clear extraneous bits, save exp.
	AR0-8_#, #/200		;test for positive exp.
	GEN AR+BR, SKP AD0,	;skip on positive exponent(sum has AD0 on).
		AR_0.M		;so exponent test has a clean register.
=0	MEM/ARL IND, CLR/AR+ARX,;exponent must be positive.
		RETURN4		;return to caller.
	AR0-8_#, #/212, J/ET1	;start range check of positive exponent

;At this point the exponent is in BR 1-11 and it is positive.
;Now we must determine if it is a small enough positive number
;to make the conversion to integer meaningful.
ET1:	GEN AR-BR, SKP AD0	;do the exponent test.
=0	AR_BR*4, J/ET2		;exp fits in AR0-8, now for final test!
	SET AROV, I FETCH, J/NOP;exponent out of range.
ET2:	AR_AR*2			;finish moving exponent into AR0-8.
	SC_AR0-8, GEN MQ,	;exponent to SC.
		SKP AD0		;max neg exponent is 1 gtr than max pos exp.
ET2A:	AR_MQ, GEN FE-SC,	;shift low word into ARX00-34, caller
		SKP SCAD0,	;put max exponent+1 in FE. range check.
	FE_FE+1, J/ET2A		;max neg exp is 1 gtr than max pos exp.
ET2B:	FE_SC, J/ET3		;save exp in FE.
	SET AROV, I FETCH, J/NOP;exponent is too large.
ET3:	SC_#, #/12.		;prepare to map AR12 into AR00.

;We now have the high word in the AR and
;the low word*2 in the ARX. The SC has 12 (dec) to let the
;shifter strip off the sign and exponent of the high word.
	AR_SIGN, MQ_SHIFT	;put high 36 integer bits into MQ.
	AR_ARX, BR/AR, CLR ARX	;generate low 36 integer bits and
	AR_BR, ARX/MQ, MQ_SHIFT,;  put in MQ. High bits to ARX.
		SC_FE-#, #/36.,	;check the size of the exponent.
		SKP SCAD0	;if exp<36. then high result is sign.
=0	GEN SC, SKP SCAD NE,	;is exponent gtr or geq to 36 ?
	SC_#+SC, #/37., J/ET5	;exponent less than 36.
ET3A:	(AR+ARX+MQ)*2, J/ET3B	;must shift left 1 bit.
	BRX/ARX, SC_#+SC, #/1,	;adjust exp, save low word in BRX.
ET3B:	BR_AR LONG, AR_ARX,	;high and low to BR!BRX
		SC_#, #/35.,	;get a good exponent for final shifting.
		ARX/MQ, J/ET4A	;rest of fraction to ARX.
ET4:	AR_ARX (AD), ARX/MQ,	;exp gtr 36. High result has integer bits.
		MQ_SHIFT	;high result to MQ.
	AR_MQ, ARX_SHIFT	;put integer bits into ARX.
	BR_AR LONG, AR_ARX (AD),;now compute fraction.
		CLR ARX		;low integer to AR, pad with zeros in ARX.
ET4A:	AR_BR LONG, MQ_SHIFT,	;restore integer to AR!ARX, fraction to MQ.
		SC_#, #/35.,	;low word must have bit 0 same as high.
		SKP AD0, RET[4]	;  and return on sign of integer.
ET5:	FM[T0]_AR, AR_ARX (AD),	;sign is high 36 bit result. Save in T0.
		ARX/MQ,		;high 36 bits of frac to AR, low 23 to ARX.
		MQ_SHIFT,	;low integer result to MQ.
		CALL [SHIFT]	;high half of fraction to AR.

;Now we have the high 36 bits of mantissa in AR, the low 23 bits if mantissa
;in the ARX, the high 36 bit result (the sign bits) in T0 and the low 36 bit
;result in the MQ. Now we compute the fraction to store.
	BR/AR, AR_ARX, CLR ARX	;high frac to BR. Now gen low fraction bits.
	ARX_SHIFT,		;low fraction bits to ARX.
		SC_#, #/35.	;low word must have same sign as high.
	GEN ARX*BR, AD/OR,	;gen composite OR of fraction into 1 word.
		MQ_AD,		;put this funny fraction in the MQ.
		ARX/MQ		;low integer result to ARX.
	[AR]_FM[T0], SKP AD0,	;get high result (Sign) back in AR.
		RET[4]		;and return to caller.
;ISOEXP will isolate the exponent in an extended exponent data word.
;It will return the positive representation of the exponent.
;Call with AR containing high order word with "SKP AR0" to do
;correct things with one's complemented exponent in negative numbers.
;It returns 1 with the positive exponent in the AR.
ISOEXP:	[AR]_[AR]*FM[EXPMSK],AD/ANDCB,RET[1] ;isolate pos exp in AR1-11.
	[AR]_[AR]*FM[EXPMSK],AD/NOR,RET[1]   ;isolate neg exp in AR1-11.

;SGNEXT will extend the sign bit of the AR into AR1-11. Call with
;SKP AR0 so the correct actions are taken for negative numbers.
;It will do a return 1 with either ones or zeroes in AR1-11.
SGNEXT:	[AR]_[AR]*FM[EXPMSK], AD/AND, RET[1]  ;extend 0s into AR1-11.
	[AR]_[AR]*FM[EXPMSK], AD/ORCB, RET[1] ;extend ones into AR1-11.

;OVTEST will determine if the high order word of a double integer,
;as stored in the AR is all sign bits, ie either it is all zeroes
;or all ones. The call is via "GEN AR, SKP AD NE, J/OVTEST".
;It assumes that the double integer is in the AR/ARX and the SC
;contains 35 decimal.
;OVTEST will store the ARX*.5 and exit if the AR is all sign bits. 
;It will set AROV and jump to NOP if it finds some data bits.
OVTST1:	AR_MQ, SKP AD NE		;get the sign bits from the MQ.
OVTEST:	AR_SHIFT, I FETCH, J/OVTST2	;the high word is all zeros - ok.
	GEN AR+1, SKP AD NE		;check to see if it is all ones.
=0	AR_SHIFT, I FETCH, J/OVTST2 	;this is simply a negative number.
	SET AROV, I FETCH, J/NOP	;sorry, we found some data bits.
OVTST2:	AC0_AR, J/NOP			;finish the store.

021:	EA,	AC,	J/L-GTPI	;GSNGL--Must mate with EXTEND
024:	EA,	B/2,	J/L-GTSI	;GFIX

3116:	[AR]_FM[E1], J/L-GTSP	; -21-	GSNGL
3114:	[AR]_FM[E1], J/L-EDBL	; -22-	GDBLE
.IF/GFTCNV		;[273]
3105:	[AR]_FM[E1], J/L-GTIN	; -23-	DGFIX
3106:	[AR]_FM[E1], J/L-GTIN	; -24-	GFIX
3107:	[AR]_FM[E1], J/L-GTIN	; -25-	DGFIXR
3110:	[AR]_FM[E1], J/L-GTIN	; -26-	GFIXR
3111:	[AR]_FM[E1], J/L-FLTR	; -27-	DGFLTR
3112:	[AR]_FM[E1], J/L-DFLT	; -30-	GFLTR
3113:	[AR]_FM[E1], J/L-DFSC	; -31-	GFSC

	AR_MEM, MQ_0.S		;load high word into AR.
	GEN AR, SKP AD NE	;check for zeroes.
=0	I FETCH, J/STORAC	;high word zero, store it.
	VMA_VMA+1		;point to mem low word.
=0	ARX_AR, SKP AR0,	;save high word in ARX.
		CALL [ISOEXP]	;get the excess-2000 exponent.
	CLR AR, BR/AR		;exp to BR.
	AR0-8_#, #/220		;largest exponent allowed is 2200.
	GEN AR-BR-1, SKP AD0	;range check exponent.
=0	AR0-8_#, #/157, J/L-GTS1;do lower range check now.(actually too low)
L-GTS1:	BR/AR, AR_BR		;swap values around for next subtract.
	GEN AR-BR, SKP AD0	;do lower range check.
=0	BR/AR, CLR AR, J/L-GTS6	;passed. 10 bit path to do last checks.
	SET FXU, I FETCH, J/NOP	;too low.
L-GTS6:	AR0-8_#, #/160		;subtract 1600 to get excess 200 exp.
	AR_BR, BR/AR		;swap around to do subtract.
	AR_AR-BR		;got it.
	AR_AR*8			;move excess-200 exponent over.
	FE_AR0-8, AR_ARX,	;put some exponent in FE. High word to AR.
		LOAD ARX	;low word to ARX.
;This next test determines the relative size of the exponent. If the expo-
;nent is less than 401 then it is a positive exponent and all will be well.
;If the exponent is greater than 400 (actually 700), then the exponent is
;really negative but bit 0 of the FE is off. To correct the sign of the
;exponent and to prevent undeserved FXU later because of the incorrect sign
;bit, we must examine the value of the exponent so as to always get the
;correct sign during normalization.
	ARX_MEM, GEN FE-#,	;undeserved FXU happens when FE00 should be
		#/500, SKP SCAD0;set from previous subtract of 1600.
=0	FE_FE+#, #/777,		;set FE00. Later add will clear it.
		ARX_ARX*2,	;low word * 2.
		J/L-GTS7	;continue.
	FE_FE-1, ARX_ARX*2	;adjust FE so later add gets right exp.
L-GTS7:	SKP AR0, CALL [SGNEXT]	;sign extend high word.
	AR_AR*.25 LONG,		;prepare for normalization
		FE_FE+#, #/6,	;adjust exponent.
		NORM, J/SNORM	;finish up.

	SC_EXP, ARX_AR, CLR AR	;correct the expoent, save a copy in the ARX
	FM[E1]_AR		;no sticky bits here.
	EXP_SC			;put the "positive" exponent back IN THE AR.
	AR_AR*.5		;must move exponent into AR4-11
	AR_AR*.25		;  done.
	BR/AR, CLR AR		;exp to BR.
	AR0-8_#, #/160		;put 1600 in the AR for exp conversion
	AR_AR+BR, FE_#, #/-3	;convert exp, set initial exp correction
	FM[T2]_AR, AR_ARX	;save exp for ENORM, frac to AR
	EXP_SIGN.C, ARX_0.M	;get rid of exp, clear low word
	GEN AR, SC_#, #/3, NORM,;normalize an extended exponent number
.IF/GFTCNV		;[273]
L-GTIN:	VMA_AR, LOAD AR		;23-26. fetch high word.
	AR_MEM, MQ_0.S,		;word in AR, init MQ.
		VMA_VMA+1	;prepare to fetch low word.
	GEN AR, SKP AD NE	;is high word all zeroes ?
=0	CLR ARX, EXIT DBL	;high word zero, store zeroes.
	LOAD ARX, B DISP	;fetch low word, call appropriate routine.

=000	ARX_MEM, J/L-G23	;do GDP to DP integer, truncate.
=010	ARX_MEM, J/L-G24	;do GDP to SP integer, truncate.
=100	ARX_MEM, J/L-G25	;do GDP to DP integer, rounded.
=110	ARX_MEM, J/L-G26	;do GDP to SP integer, rounded.
=				;terminate this dispatch block.

;DGFIX needs the sticky bit fix.
L-G23:	FE_#, #/70.,		;-23- DGFIX GDP to double integer, truncate.
		CALL [ETXIX]	;do the conversion
=0110	EXIT DBL		;store results.
=0111	BR_AR LONG, AR_ARX,	;save high 2 words in BR!BRX, MSB of
		ARX/MQ,		;fraction to AR35. Rest of fraction to ARX.
		SC_#, #/35.,	;get fraction all together.
		CALL [EF12A]
=1111	GEN AR, SKP AD NE,	;any fraction bits on ?
		MQ_0.S		;[240]CLEAR MQ00 FOR ARX_2 MACRO.
=0	AR_BR LONG, J/ST2AC	;no, leave answer alone.
	CLR AR, ARX_2		;yes, add 1 to integer part.
	AR_AR+BR LONG, J/ST2AC	;store result.

;GFIX needs the sticky bit fix.
L-G24:	FE_#, #/35.,		;-24- GFIX GDP to single integer, truncate.
		CALL [ETXIX]	;do the conversion
L-GTS2:	SKP AR NE, J/OVTEST	;test for sign bits in AR and store.
=0111	BR_AR LONG, AR_ARX,	;save in BR!BRX.
		ARX/MQ,		;add one to integer part of negative number
		SC_#, #/35.,	;if fraction is not zero.
		CALL [EF12A]
=1111	GEN AR, SKP AD NE,	;is fraction zero ?
		MQ_0.S		;[240]CLEAR MQ00 FOR ARX_2 MACRO.
=0	AR_BR LONG, SKP AD NE,	;yes, try to store the result.
	CLR AR, ARX_2		;no, add one to integer part.
	AR_AR+BR LONG, SKP AD NE,; do the add and test that the high
		J/OVTEST	;word is all sign bits.

L-G25:	FE_#, #/70.,		;-25- DGFIXR GDP to double integer, rounded.
		CALL [ETXIX]	;do the conversion
=111	BR_AR LONG, CLR AR,	;save in BR!BRX, round by adding one half
		ARX_1,		;to result. Remember that the MSB of the
		SC_#, #/35.	;store routine expects this.
	AR_AR+BR LONG, AD FLAGS	;fraction is on ARX35.  Do the rounding and
;=0	; replace SKP CRY0 with AD FLAGS. Eliminates extra word.
	EXIT DBL		;  store the double result.
;	SET AROV, I FETCH, J/NOP;rounding caused an overflow - too bad!

L-G26:	FE_#, #/35.,		;-26- GFIXR GDP to single integer, rounded.
		CALL [ETXIX]	;do the conversion.
=111	BR_AR LONG, CLR AR,	;save in CR!BRX, round by adding one half
		ARX_1,		;to result. MSB of the fraction is in ARX35.
		SC_#, #/35.	;store routine expects this.
	AR_AR+BR LONG, SKP AD NE,;do the rounding.
		J/OVTEST	;figure out what, if any, to store.
		FE_#, #/137	;inital fugde factor for exp
	AR_MEM, MQ_0.S		;get high word into the AR.
=0*	VMA_VMA+1, LOAD ARX,	;get the low word into the ARX,
		BR/AR, CALL [XFERW]; and save the high word in the BR.
=1*	ARX_ARX*2, CLR AR	;ignore the sign copy.
	FM[E1]_AR		;no sticky bits here.
	AR0-8_#, #/200		;ENORM expects the exponent in T2.
	FM[T2]_AR, AR_BR,	;and save it in T2.
		ARX/AD, MQ_ARX	;sign to AR, high to ARX, low to MQ.
	AR_SIGN 		;
	GEN AR, NORM, J/ENORM	;restore high word and normalize.
		FE_#, #/4	;initial fudge factor for exp.
	AR_MEM, CLR MQ		;get the single precision op.
	AR_SIGN, ARX_AR		;build a dummy high word of all sign.
	BR/AR, CLR AR		;save sign, prepare for exponent.
	FM[E1]_AR		;no sticky bits here.
	AR0-8_#, #/207		;build an initial exp of 207 for ENORM
	FM[T2]_AR, AR_BR,	;save exp for ENORM, restore sign word.
		NORM, J/ENORM	;and normalize it.

		CALL [ISOEXP]	;get the exponent into the AR.
	BR/AR, AR_BR		;put exp in BR, scale factor to AR.
	AR_AR SWAP, GEN AC0,	;put scale in left half of AR.
		SKP AD NE	;is high word zero ?
=0	AR+ARX+MQ_0.M, J/ST2AC	;yes, store zero as double result.
	AR_SIGN, ARX_AR, SC_#,	;no, move sign and scale factor together.
	AR_SHIFT, CLR FE	;sign now in AR00, scale in AR 9-19.
	EXP_SIGN		;scale sign is in AR00; extend it.
	SC_#, #/8.		;move scale factor into AR 1-11 and
	AR_SHIFT, ARX_AC1	; put the sign to left of scale factor.
	AR_AR+BR, CLR MQ	;add exponent and scale factor.
	SH/AR, DISP/SH0-3	;check for over and under flovs.
L-FSC2:	[AR]_[AR]*FM[EXPMSK],	;clear out non-exponent bits.
		AD/ANDCB,	;and AR00 in the over or under flow case.
		J/L-FSC3	; and continue
=0111	[AR]_[AR]*FM[EXPMSK],	;clear out non-exponent bits.
		J/L-FSC3	; and continue
=1011	SET FLOV, J/L-FSC2	;you lose
=1111	SET FXU, J/L-FSC2	;ditto

L-FSC3:	FM[T2]_AR, ARX_ARX*2	;save new exponent fofr ENORM.
=0	AR_AC0, SKP AD0,	;get the high word.
		SC_#, #/3,	;for ENORM.
		CALL [SGNEXT]	;and sign extend it for ENORM as well.
	GEN AR, NORM, J/ENORM	;put the result back together.