.TITL microFLOAT
;BCPL compatible microcoded FLOATING POINT ROUTINES
; R. Sproull 6/73
; Microcode version: J. Maleson 8/77

;Mu MicroFloatMC.MU
;PackMu MicroFloatMC.MB MicroFloatMC.BR 0 MicroFloatRamImage
;Asm MicroFloat.ASM
;Copy MicroFloat.BR _ MicroFloat.BR MicroFloatMC.BR LoadRam.BR

;Brief description of the routines:
;
;There are a variable number of floating point accumulators,
;numbered 0 to numACs-1
;These accumulators may be loaded, stored, operated on,
;and tested with the following operations.
;The microcode RAM must (obviously) be loaded with the
;appropriate microcode.  This is accomplished by calling
;	LoadRam(MicroFloatRamImage)
;After this call, the memory space used for MicroFloatMC.BR and LoadRam.BR
;can be released.  Microfloat.BR must remain resident, but it
;only takes up about 60 words.  Note that the floating point
;routines can also be invoked as single assembly code instructrions,
;with op codes 70001 through 70021.  The correspondence between
;op codes and floating point operations is:
microFMP=	70001
microFDV=	70002
microFAD=	70003
microFSB=	70004
microFLD=	70005
microFLDV=	70006
microFSTV=	70007
microFLDI=	70010
microFTR=	70011
microFNEG=	70012
microFSN=	70013
;removed for PRESS microFCM=	70014	
microFST=	70015
microFLDDP=70016	
microFSTDP=	70017
;removed for PRESS microDPAD=	70020	
;removed for PRESS microDPSB=	70021	
;removed for PRESS microFEXP=	70022	
;
;Four words of memory are needed for each accumulator
;This memory space must be provided by the user, by calling
;
; FPSetup (workArea)
;	workArea is the block of memory to be used for maintaining the ACs
;	workArea!0 is the number of accumulators to be used
;	The length of workArea must be at least (4*numACs)+1
;	The contents of workArea are not re-initialized, so that
;	reusing a previously used work area will have the effect
;	of restoring the values of the ACs to their previous state.
;	The static FPwork will be set to workArea
;	The call to FPSetup, loading the RAM, and the (shorter) work area
;	format are the only changes from the assembly coded routines.
;
; FLD (acnumber,arg)
;	Load the specified accumulator from source specified
;	by arg. See below for a definition of 'arg'.
;
; FST (acnumber, ptr-to-fp-number)
;	Store the contents of the accumulator into a 2-word
;	packed floating point format.  Error if exponent is too
;	large or small to fit into the packed representation.
;
; FTR (acnumber) ==> integer
;	Truncate the floating point number in the accumu-
;	lator and return the integer value.  Error if number
;	in ac cannot fit in an integer representation.
;
; FLDI (acnumber,integer)
;	Load-immediate of an accumulator with the integer
;	contents (signed 2's complement).
;
; FNEG (acnumber)
;	Negate the contents of the accumulator.
;
; FAD (acnumber,arg)
;	Add the number in the accumulator to the number
;	specified by arg and leave the result in
;	the accumulator. See below for a definition of 'arg'.
;
; FSB (acnumber,arg)
;	Subtract the number specified by 'arg' from the
;	number in the accumulator, and leave the result
;	in the accumulator.
;
; FML (acnumber,arg)  [ also FMP ]
;	Multiply the number specified by 'arg' by the number
;	in the accumulator, and leave the result in the ac.
;
; FDV (acnumber,arg)
;	Divide the contents of the accumulator by the number
;	specified by arg, and leave the result in the ac.
;	Error if attempt to divide by zero.
;
; FCM (acnumber,arg) ==> integer
;	Compare the number in the ac with the number
;	specified by 'arg'. Return
;		-1 IF ARG1 < ARG2
;	 	 0 IF ARG1 = ARG2
;		 1 IF ARG1 > ARG2
;
; FSN (acnumber) ==> integer
;	Return the sign of the floating point number.
;		-1	if sign negative
;		 0	if value is exactly 0 (quick test!)
;		 1	if sign positive and number non-zero
;
; FEXP(acnum,increment)	Adds 'increment' to the exponent of the
;	specified accumulator.  The exponent is a binary power.
;
;For special hackers only:
; FLDV (acnumber,ptr-to-vector)
;	Read the 4-element vector into the internal
;	representation of a floating point number.
;
; FSTV (acnumber,ptr-to-vector)
;	Write the accumulator into the 4-element vector in
;	internal representation.
;
;'ARG' in the above discussion means: if the 16-bit value is
;less than the number of accumulators, then use the
;contents of the accumulator of that number.  Otherwise,
;the 16-bit value is assumed to be a pointer to a packed
;floating-point number.
;
;All of the functions listed above that do not have "==>"
;after them return their first argument as their value.
;
;A word about the packing format:
; The first word is:
;	sign -- 1 bit
;	exponent -- excess 128 format (8 bits)
;		will be complemented if sign negative
;	mantissa -- first 7 bits
; The second word is:
;	mantissa -- 16 more bits
;
;Note this format permits packed numbers to be tested for
;sign, to be compared (by comparing first words first), to
;be tested for zero (first word zero is sufficient), and
;(with some care) to be complemented.
;
;There are also some functions for dealing with 2-word
;fixed point numbers.  The functions are chosen to be
;helpful to DDA scan-converters and the like.
;
;FSTDP(ac,ptr-to-dp-number)
;	Stores the contents of the floating point ac into
;	the specified double-precision number.  First word
;	of the number is the integer part, second is fraction.
;	Two's complement.  Error if exponent too large.
;
;FLDDP(ac,ptr-to-dp-number)
;	Loads floating point ac from dp number.
;
;DPAD(a,b) => integer part of answer
;	a and b are both pointers to dp numbers. The dp
;	sum is formed, and stored in a.
;
;DPSB(a,b) => integer part of answer
;	Same as DPAD, but subtraction.
;
;If you wish to capture errors, put the address of a BCPL
;subroutine in the static FPerrprint.  The routine will be
;called with one parameter:
;	0	Exponent too large -- FTR
;	1	Exponent too large -- FST
;	2	Dividing by zero -- FDV
;	3	Ac number out of range (any routine)
;	4	Exponent too large -- FSTDP


	.BEXT	DoubleAdd,DoubleSub,DoubleShr	;external routines

	.NREL		;MAKE RELOCATABLE

;DISPATCH TABLE
.ENT FLD		;LOAD
.ENT FST		;STORE
.ENT FTR		;TRUNCATE
.ENT FLDI		;LOAD IMMEDIATE
.ENT FNEG		;NEGATE
.ENT FAD		;ADD
.ENT FSB		;SUBTRACT
.ENT FML		;MULTIPLY
.ENT FMP		; (ANOTHER VERSION OF MULTIPLY)
.ENT FDV		;DIVIDE
.ENT FCM		;COMPARE
.ENT FSN		;SIGN
.ENT FLDV		;READ
.ENT FSTV		;WRITE
;removed for PRESS .ENT FEXP		;hack with exponent
.ENT FSTDP		;STORE DP
.ENT FLDDP		;LOAD DP
.ENT DPAD		;DP ADD
.ENT DPSB		;DP SUB
.ENT DPSHR		;DP Shift right
.ENT FPSetup	;set up work area
.ENT FPerrprint		;error printer routine
.ENT FPwork		;work area static

	.SREL		;STATICS FOR ENTRIES, ETC.

FLD:	.FLD
FST:	.FST
FTR:	.FTR
FLDI:	.FLDI
FNEG:	.FNEG
FAD:	.FAD
FSB:	.FSB
FML:	.FMP
FMP:	.FMP
FDV:	.FDV
FCM:	.FCM
FSN:	.FSN
FLDV:	.FLDV
FSTV:	.FSTV
;removed for PRESS FEXP: .FEXP
FSTDP:	.FSTDP
FLDDP:	.FLDDP
DPAD:	77400
DPSB:		77400
DPSHR:	77400

FPSetup:	.FPSetup
FPwork:	0	;user MUST initialize by calling FPSetup

			;POINTERS TO VARIOUS PROCEDURES
FPerrprint: .EPR	;dummy in case user fails to specify
locMicroErr:	microErr

	.NREL

;%%ALTO%%
.DMR CALL =JSRII 0
.DMR JMPII =64000	;ALSO JSRII!!

;ROUTINES TO READ AND WRITE INTERNAL REPRESENTATION.

.FLDV:microFLDV
	jmp 1,3
.FSTV:	microFSTV
	jmp 1,3
.FSN:	microFSN
	jmp 1,3
.FCM:	sta 1,saved1	;FCM(a,b)
	mov 0,1
	lda 0,d32
	microFLD	;FLD(32,a)
	lda 1,saved1
	microFSB	;FSB(32,b)
	microFSN	;FSN(32)
 	jmp 1,3
saved1:	0
d32:	40
.FNEG:	microFNEG
	jmp 1,3
.FTR:	microFTR
	jmp 1,3
.FLD:	microFLD
	jmp 1,3
.FST:	microFST
	jmp 1,3
.FAD:	microFAD
	jmp 1,3
.FSB:	microFSB
	jmp 1,3
.FLDI:	microFLDI
	jmp 1,3
.FMP:	microFMP
	jmp 1,3
.FDV:	microFDV
	jmp 1,3
;removed for PRESS .FEXP:	microFEXP
;removed for PRESS 	jmp 1,3
.FLDDP: microFLDDP
	jmp 1,3
.FSTDP: microFSTDP
	jmp 1,3
.DPAD:	DPAD
.DPSB:		DPSB
.DPSHR:	DPSHR
.DoubleAdd:	DoubleAdd
.DoubleSub:	DoubleSub
.DoubleShr:	DoubleShr

.MERR:	locMicroErr
.FPwork:	FPwork

;FPSetup(FPwork) set up work area
;FPwork!0=number of ACs
;length of FPwork is 1+4*numACs
.FPSetup:
	sta 0,@.FPwork	;save away for user
	lda 1,@.MERR
	70000	;microcode initialization
	lda 0,@.DoubleAdd
	sta 0,@.DPAD
	lda 0,@.DoubleSub
	sta 0,@.DPSB
	lda 0,@.DoubleShr
	sta 0,@.DPSHR
	jmp 1,3

microRet:	0
microErr: sta 3,microRet
	CALL .ERRA	;FPerrprint (initially points to location containing "jmp 1,3")
	1
	lda 3,microRet
	jmp 1,3

;ERROR PRINTING MECHANISM
.ERRA:	FPerrprint
.EPR:	JMP 1,3		;DUMMY ERROR PRINTER

	.END

        

(1270)\1484bi4BI464i65I3i61I