2BA6			  ; ********************************************************************:
2BA6			  ; THE 'L_ENTER' SUBROUTINE
2BA6			  ; THIS SHORT SUBROUTINE IS USED TO PASS EITHER A NUMERIC VALUE , FROM
2BA6			  ; THE CALCULATOR STACK , OR A STRING , FROM THE WORK SPACE , TO ITS
2BA6			  ; APPROPRIATE POSITION IN THE VARIABLES AREA.
2BA6			  ; THE SUBROUTINE IS THEREFORE USED  FOR ALL EXCEPT 'NEWLY DECLARED'
2BA6			  ; SIMPLE STRINGS AND 'COMPLETE & EXISTING' SIMPLE STRINGS.
2BA6			  ;
2BA6 EB 		  L_ENTER:	EX    DE,HL		      ; CHANGE THE POINTERS OVER.
2BA7 78 				LD    A,B		      ; CHECK ONCE AGAIN THAT THE
2BA8 B1 				OR    C 		      ; LENGTH IS NOT ZERO.
2BA9 C8 				RET   Z 		      ;
2BAA D5 				PUSH  DE		      ; SAVE THE DESTINATION POINTER.
2BAB EDB0				LDIR			      ; MOVE THE NUMERIC VALUE OR THE
2BAD					;			      ; STRING.
2BAD E1 				POP   HL		      ; RETURN WITH THE HL REGISTER
2BAE C9 				RET			      ; PAIR POINTING TO THE FIRST
2BAF					;			      ; BYTE OF THE NUMERIC VALUE OR
2BAF					;			      ; THE STRING.
2BAF			  ;
2BAF			  ; THE LET SUBROUTINE CONTINUES HERE
2BAF			  ; WHEN HANDLING A 'COMPLETE & EXISTING' SIMPLE STRING THE NEW STRING IS
2BAF			  ; ENTERED AS IF IT WERE A 'NEWLY DECLARED' SIMPLE STRING BEFORE THE
2BAF			  ; EXISTING VERSION IS 'RECLAIMED'.
2BAF			  ;
2BAF 2B 		  L_ADDS:	DEC   HL		      ; MAKE HL POINT TO THE LETTER
2BB0 2B 				DEC   HL		      ; OF THE VARIABLE'S NAME.
2BB1 2B 				DEC   HL		      ; I.E. 'DEST-3'.
2BB2 7E 				LD    A,(HL)		      ; PICK UP THE LETTER.
2BB3 E5 				PUSH  HL		      ; SAVE THE POINTER TO THE
2BB4					;			      ; 'EXISTING  VERSION'.
2BB4 C5 				PUSH  BC		      ; SAVE THE 'LENGTH' OF THE
2BB5					;			      ; 'EXISTING STRING'.
2BB5 CDC62B				CALL  L_STRING		      ; USE 'L_STRING' TO ADD THE
2BB8					;			      ; NEW STRING TO THE VARIABLES
2BB8					;			      ; AREA.
2BB8 C1 				POP   BC		      ; RESTORE THE 'LENGTH'.
2BB9 E1 				POP   HL		      ; RESTORE THE POINTER.
2BBA 03 				INC   BC		      ; ALLOW ONE BYTE FOR THE LETTER
2BBB 03 				INC   BC		      ; AND TWO BYTES FOR THE LNGTH.
2BBC 03 				INC   BC		      ;
2BBD C3E819				JP    RECLAIM_2 	      ; EXIT BY JUMPING TO 'RECLAIM_2'
2BC0					;			      ; WHICH WILL RECLAIM THE WHOLE
2BC0					;			      ; OF THE EXISTING VERSION.
2BC0			  ;
2BC0			  ; 'NEWLY DECLARED' SIMPLE STRINGS ARE HANDLED AS FOLLOWS:
2BC0			  ;
2BC0 3EDF		  L_NEWS:	LD    A,0DFH		      ; PREPARE FOR THE MAKING OF
2BC2					;			      ; THE VARIABLES LETTER.
2BC2 2A4D5C				LD    HL,(DEST) 	      ; FETCH THE POINTER TO THE
2BC5					;			      ; LETTER.
2BC5 A6 				AND   (HL)		      ; MARK THE LETTER AS REQUIRED.
2BC6					;			      ; 'L_STRING IS NOW USED TO ADD
2BC6					;			      ; THE NEW STRING TO THE VARIABLES
2BC6					;			      ; AREA.
2BC6			  ;
2BC6			  ; **********************************************************************
2BC6			  ; THE 'L_STRING' SUBROUTINE
2BC6			  ; THE PARAMETERS OF THE 'NEW' STRING ARE FETCHED , SUFFICIENT ROOM IS
2BC6			  ; MADE AVAILABLE FOR IT  AND THE STRING IS THEN TRANSFERRED.
2BC6			  ;
2BC6 F5 		  L_STRING:	PUSH  AF		      ; SAVE THE VARIABLE'S LETTER.
2BC7 CDF12B				CALL  STK_FETCH 	      ; FETCH THE START AND THE
2BCA					;			      ; 'LENGTH' OF THE 'NEW' STRING.
2BCA EB 				EX    DE,HL		      ; MOVE THE 'START' TO  HL.
2BCB 09 				ADD   HL,BC		      ; MAKE HL POINT 'ONE-PASS' THE
2BCC					;			      ; STRING.
2BCC C5 				PUSH  BC		      ; SAVE THE 'LENGTH'.
2BCD 2B 				DEC   HL		      ; MAKE HL POINT TO THE END OF
2BCE					;			      ; STRING.
2BCE 224D5C				LD    (DEST),HL 	      ; SAVE THE POINT BRIEFLY.
2BD1 03 				INC   BC		      ; ALLOW ONE BYTE FOR THE LETTER
2BD2 03 				INC   BC		      ; AND TWO BYTES FOR THE LENGTH.
2BD3 03 				INC   BC		      ;
2BD4 2A595C				LD    HL,(E_LINE)	      ; MAKE HL POINT TO THE
2BD7 2B 				DEC   HL		      ; '80-BYTE' AT THE END OF
2BD8					;			      ; VARIABLES AREA.
2BD8 CD5516				CALL  MAKE_ROOM 	      ; NOW OPEN UP THE VARIABLES AREA.
2BDB					;			      ; NOTE: IN EFFECT 'BC' SPACES ARE
2BDB					;			      ; MADE BEFORE THE DISPLACED
2BDB					;			      ; '80-BYTE'.
2BDB 2A4D5C				LD    HL,(DEST) 	      ; RESTORE THE POINTER TO THE
2BDE					;			      ; END OF THE NEW STIRNG.
2BDE C1 				POP   BC		      ; MAKE A COPY OF THE LENGTH
2BDF C5 				PUSH  BC		      ; OF THE 'NEW' STRING.
2BE0 03 				INC   BC		      ; ADD ONE TO THE LENGTH IN CASE
2BE1					;			      ; THE 'NEW' STRING IS A 'NULL'
2BE1					;			      ; STRING.
2BE1 EDB8				LDDR			      ; NOW COPY THE 'NEW' STRING +
2BE3					;			      ; ONE BYTE.
2BE3 EB 				EX    DE,HL		      ; MAKE  HL  POINT TO THE BYTE
2BE4 23 				INC   HL		      ; THAT IS TO HOLD THE HIGH-LENGTH.
2BE5 C1 				POP   BC		      ; FETCH THE LENGTH.
2BE6 70 				LD    (HL),B		      ; ENTER THE HIGH-LENGTH.
2BE7 2B 				DEC   HL		      ; BACK ONE.
2BE8 71 				LD    (HL),C		      ; ENTER THE LOW-LENGTH.
2BE9 F1 				POP   AF		      ; FETCH THE VARIABLES LETTER.
2BEA			  ;
2BEA			  ; ********************************************************************
2BEA			  ; THE 'L_FIRST' SUBROUTINE
2BEA			  ; THIS SUBROUTINE IS ENTERED WITH THE LETTER OF THE VARIABLE ,SUITABLE
2BEA			  ; MARKED , IN THE A REGISTER. THE LETTER  OVERWRITES THE 'OLD 80-BYTE'
2BEA			  ; IN THE VARIABLES AREA. THE SUBROUTINE RETURNS WITH THE  HL	REGISTER
2BEA			  ; PAIR POINTING TO THE 'NEW 80 - BYTE'.
2BEA			  ;
2BEA 2B 		  L_FIRST:	DEC   HL		      ; MAKE HL POINT TO THE 'OLD
2BEB					;			      ; 80-BYTE'.
2BEB 77 				LD    (HL),A		      ; IT IS OVERWRITTEN WITH THE
2BEC					;			      ; LETTER.
2BEC 2A595C				LD    HL,(E_LINE)	      ; MAKE HL POINT TO THE 'NEW
2BEF 2B 				DEC   HL		      ; 80-BYTE'.
2BF0 C9 				RET			      ; FINISHED WITH ALL THE
2BF1					;			      ; 'NEWLY DECLARED VARIABLES'.
2BF1			  ;
2BF1			  ; ********************************************************************
2BF1			  ; THE 'STK_FETCH' SUBROUTINE
2BF1			  ; THIS  IMPOTANT  SUBROUTINE	 COLLECTS   THE  'LAST VALUE'  FROM  THE
2BF1			  ; CALCULATOR STACK. THE  FIVE BYTES  CAN  BE	EITHER	A FLOATING POINT
2BF1			  ; NUMBER. IN 'SHORT'	OR  'LONG'  FORM , OR  A SET OF  STATEMENT  THAT
2BF1			  ; DEFINE A STRING.
2BF1			  ;
2BF1 2A655C		  STK_FETCH:	LD    HL,(STKEND)	      ; GET 'STKEND'.
2BF4 2B 				DEC   HL		      ; BACK ONE.
2BF5 46 				LD    B,(HL)		      ; THE FIFTH VALUE.
2BF6 2B 				DEC   HL		      ; BACK ONE.
2BF7 4E 				LD    C,(HL)		      ; THE FOURTH VALUE.
2BF8 2B 				DEC   HL		      ; BACK ONE.
2BF9 56 				LD    D,(HL)		      ; THE THIRD VALUE.
2BFA 2B 				DEC   HL		      ; BACK ONE.
2BFB 5E 				LD    E,(HL)		      ; THE SECOND VALUE.
2BFC 2B 				DEC   HL		      ; BACK ONE.
2BFD 7E 				LD    A,(HL)		      ; THE FIRST VALUE.
2BFE 22655C				LD    (STKEND),HL	      ; RESET 'STKEND' TO
2C01					;			      ; ITS NEW POSITION.
2C01 C9 				RET			      ; FINISHED.
2C02			  ;
2C02			  ; ********************************************************************
2C02			  ; THE  'DIM'	COMMAND  ROUTINE
2C02			  ; THIS ROUTINE ESTABLISHES NEW ARRAYS IN THE VARIABLES AREA. THE
2C02			  ; ROUTINE STARTS BY SEARCHING THE EXISTING VARIABLES AREA TO DETERMINE
2C02			  ; WHETHER THERE IS AN EXISTING ARRAY WITH THE SAME NAME. IF SUCH
2C02			  ; AN ARRAY IS FOUND THEN IT IS 'RECLAIMED' BEFORE THE NEW ARRAY IS
2C02			  ; ESTABLISHED.
2C02			  ; A NEW ARRAY WILL HAVE ALL ITS ELEMENTS SET TO ZERO,IF IT IS A
2C02			  ; NUMERIC  ARRAY, OR TO SPACES IF IT IS A N ARRAY OF STRINGS.
2C02			  ;
2C02 CDB228		  DIM:		CALL  LOOK_VAR		      ; SEARCH THE VARIABLES AREA.
2C05 C28A1C		  D_RPORT_C:	JP    NZ,REPORT_C	      ; GIVE REPORT C AS THERE HAS
2C08					;			      ; BEEN AN ERROR.
2C08 CD3025				CALL  SYNTAX_Z		      ; JUMP FORWARD IF IN
2C0B 2008				JR    NZ,D_RUN		      ; 'RUN-TIME'.
2C0D CBB1				RES  6,C		      ; TEST A SYNTAX FOR STRING ARRAYS
2C0F					;			      ; IF THEY WERE NUMERIC.
2C0F CD9629				CALL  STK_VARS		      ; CHECK THE SYNTAX OF THE
2C12					;			      ; PARENTHESISED EXPRESSION.
2C12 CDEE1B				CALL  CHECK_END 	      ; MOVE ON TO CONSIDER THE
2C15					;			      ; NEXT STATEMENT AS THE SYNTAX
2C15					;			      ; WAS STATISFACTORY.
2C15			  ;
2C15			  ; AN 'EXISTING ARRAY' IS RECLAIMED.
2C15			  ;
2C15 3808		  D_RUN:	JR    C,D_LETTERS	      ; JUMP FORWARD IF THERE IS NO
2C17					;			      ; 'EXISTING ARRAY'.
2C17 C5 				PUSH  BC		      ; SAVE THE DISCRIMINATOR BYTE.
2C18 CDB819				CALL  NEXT_ONE		      ; FIND THE START OF THE NEXT
2C1B					;			      ; VARIABLE.
2C1B CDE819				CALL  RECLAIM_2 	      ; RECLAIM THE 'EXISTING ARRAY'.
2C1E C1 				POP   BC		      ; RESTORE THE DISCRIMINATOR BYTE.
2C1F			  ;
2C1F			  ; THE INITIAL PARAMETERS OF THE NEW ARRAY ARE FOUND.
2C1F			  ;
2C1F CBF9		  D_LETTERS:	SET  7,C		      ; SET BIT 7 IN THE DISCRIMINATOR
2C21					;			      ; BYTE.
2C21 0600				LD    B,0		      ; MAKE THE DIMENSION SIZE COUNTER
2C23					;			      ; ZERO.
2C23 C5 				PUSH  BC		      ; SAVE THE COUNTER AND THE
2C24					;			      ; DISCRIMINATOR BYTE.
2C24 210100				LD    HL,00001H 	      ; THE HL REGISTER PAIR IS TO
2C27 CB71				BIT  6,C		      ; HOLD THE SIZE OF THE ELEMENTS
2C29 2002				JR    NZ,D_SIZE 	      ; IN THE ARRAY, '1' FOR A STRING
2C2B 2E05				LD    L,005H		      ; ARRAY, '5' FOR A NUMERIC ARRAY.
2C2D EB 		  D_SIZE:	EX    DE,HL		      ; ELEMENT SIZE TO DE.
2C2E			  ;
2C2E			  ; THE FOLLOWING LOOP IS ACCESSED FOR EACH DIMENSION THAT IS SPECIFIED
2C2E			  ; IN THE PARENTHESISED EXPRESSION OF THE DIM STATEMENT. THE TOTAL
2C2E			  ; NUMBER OF BYTES REQUIRED FOR THE ELEMENTS OF THE ARRAY IS BUILT UP
2C2E			  ; IN THE  DE	REGISTER PAIR.
2C2E			  ;
2C2E E7 		  D_NO_LOOP:	RST   GET_NBT		      ; ADVANCE 'CH_ADD' ON EACH PASS.
2C2F 26FF				LD    H,0FFH		      ; SET A 'LIMIT-VALUE'.
2C31 CDCC2A				CALL  INT_EXP1		      ; EVALUATE A PARAMETER.
2C34 DA202A				JP    C,REPORT_3	      ; GIVE AN ERROR IF 'OUT OF RANGE'.
2C37 E1 				POP   HL		      ; FETCH THE DIMENSION-COUNTER
2C38					;			      ; AND THE DISCRIMINATOR BYTE.
2C38 C5 				PUSH  BC		      ; SAVE THE PARAMETER ON EACH
2C39					;			      ; PASS THROUGH LOOP.
2C39 24 				INC   H 		      ; INCRREASE THE DIMENSION-COUNTER
2C3A					;			      ; ON EACH PASS ALSO.
2C3A E5 				PUSH  HL		      ; RESTACK THE DIMENSION-COUNTER
2C3B					;			      ; AND THE DISCRIMINATOR BYTE.
2C3B 60 				LD    H,B		      ; THE PARAMETER IS MOVED TO THE
2C3C 69 				LD    L,C		      ; HL REGISTER PAIR.
2C3D CDF42A				CALL  GET_HL_DE 	      ; THE BYTE TOTAL IS BUILT UP
2C40 EB 				EX    DE,HL		      ; IN HL AND THEN TRANSFERRED
2C41					;			      ; TO  DE.
2C41 DF 				RST   GET_BT		      ; GET THE PRESENT CHARACTER
2C42 FE2C				CP    ','		      ; AND GO AROUND THE LOOP AGAIN.
2C44 28E8				JR    Z,D_NO_LOOP	      ; IF THERE IS ANOTHER DIMENSION.
2C46			  ;
2C46			  ; NOTE : AT THIS POINT THE  DE  REGISTER PAIR INDICATES THE NUMBER
2C46			  ; REQUIRED FOR THE ELEMENTS OF THE NEW ARRAY AND THE SIZE OF EACH
2C46			  ; DIMENSION IS STACKED, ON THE MACHINE STACK.
2C46			  ; NOW CHECK THAT THERE IS INDEED A CLOSING BRACKET TO THE
2C46			  ; PARENTHESISED EXPRESSED.
2C46			  ;
2C46 FE29				CP    029H		      ; IS IT A ')' ?
2C48 20BB				JR    NZ,D_RPORT_C	      ; JUMP BACK IF NOT SO.
2C4A E7 				RST   GET_NBT		      ; ADVANCE CH_ADD PAST IT.
2C4B			  ;
2C4B			  ; ALLOWENCE IS NOW MADE FOR THE DIMENSION SIZES.
2C4B			  ;
2C4B C1 				POP   BC		      ; FETCH THE DIMENSION-COUNTER
2C4C					;			      ; AND THE DISCRIMINATOR BYTE.
2C4C 79 				LD    A,C		      ; PASS THE DISCRIMINATOR	BYTE
2C4D					;			      ; TO THE A REGISTER FOR LATER.
2C4D 68 				LD    L,B		      ; MOVE THE COUNTER TO  L.
2C4E 2600				LD    H,0		      ; CLEAR THE A REGISTER.
2C50 23 				INC   HL		      ; INCREASE THE DIMENSIN-COUNTER
2C51 23 				INC   HL		      ; BY TWO AND DOUBLE THE REZULT
2C52 29 				ADD   HL,HL		      ; AND FORM THE CORRECT  OVERALL
2C53 19 				ADD   HL,DE		      ; LENGTH FOR THE VARIABLE BY
2C54					;			      ; ADDING THE ELEMENT BYTE TOTAL.
2C54 DA151F				JP    C,REPORT_4	      ; GIVE THE REPORT 'OUT OF MEMORY'
2C57					;			      ; IF REQUIRED.
2C57 D5 				PUSH  DE		      ; SAVE THE ELEMENT BYTE TOTAL.
2C58 C5 				PUSH  BC		      ; SAVE THE DIMENSION COUNTER
2C59					;			      ; AND THE DISCRIMINATOR BYTE.
2C59 E5 				PUSH  HL		      ; SAVE THE OVERALL LENGTH ALSO.
2C5A 44 				LD    B,H		      ; MOVE THE OVERALL LENGTH TO  BC.
2C5B 4D 				LD    C,L		      ;
2C5C			  ;
2C5C			  ; THE REQUIRED AMOUNT OF ROOM IS MADE AVAILABLE FOR THE NEW ARRAY
2C5C			  ; AT THE END OF THE VARIABLES AREA.
2C5C			  ;
2C5C 2A595C				LD    HL,(E_LINE)	      ; MAKE THE HL REGISTER PAIR
2C5F 2B 				DEC   HL		      ; POINT TO THE '80-BYTE'.
2C60 CD5516				CALL  MAKE_ROOM 	      ; THE ROOM  IS MADE AVAILABLE.
2C63 23 				INC   HL		      ; HL IS MADE TO POINTTO THE
2C64					;			      ; FIRST NEW LOCATION.
2C64			  ;
2C64			  ; THE PARAMETERS ARE NOW ENTERED.
2C64			  ;
2C64 77 				LD    (HL),A		      ; THE LATTER, SUITABLE MARKED,
2C65					;			      ; IS ENTERED FIRST.
2C65 C1 				POP   BC		      ; THE OVERALL LENGTH IS FETCHED
2C66 0B 				DEC   BC		      ; AND DECREASED BY '3'.
2C67 0B 				DEC   BC		      ;
2C68 0B 				DEC   BC		      ;
2C69 23 				INC   HL		      ; ADVANCE  HL.
2C6A 71 				LD    (HL),C		      ; ENTER THE LOW LENGTH.
2C6B 23 				INC   HL		      ; ADVANCE  HL.
2C6C 70 				LD    (HL),B		      ; ENTER THE HIGH LENGTH.
2C6D C1 				POP   BC		      ; FETCH THE DIMENSION COUNTER.
2C6E 78 				LD    A,B		      ; MOVE IT TO THE A REGISTER.
2C6F 23 				INC   HL		      ; ADVANCE HL.
2C70 77 				LD    (HL),A		      ; ENTER THE DIMENSION COUNT.
2C71			  ;
2C71			  ; THE ELEMENTS OF THE NEW ARRAY ARE NOW 'CLEARED'.
2C71			  ;
2C71 62 				LD    H,D		      ; HL IS MADE TO POINT TO THE
2C72 6B 				LD    L,E		      ; LAST LOCATION OF THE ARRAY.
2C73 1B 				DEC   DE		      ; AND  DE  TO THE LOCATION BEFORE
2C74					;			      ; THAT ONE.
2C74 3600				LD    (HL),0		      ; ENTER A ZERO INTO THE LAST
2C76 CB71				BIT  6,C		      ; LOCATION BUT OVERWRITE IT
2C78 2802				JR    Z,DIM_CLEAR	      ; WITH A 'SPACE' IF DEALING WITH
2C7A 3620				LD    (HL),020H 	      ; AN ARRAY OF STRINGS.
2C7C C1 		  DIM_CLEAR:	POP   BC		      ; FETCH THE ELEMENT BYTE TOTAL.
2C7D EDB8				LDDR			      ; CLEAR THE ARRAY + ONE EXTRA
2C7F					;			      ; LOCATION.
2C7F			  ;
2C7F			  ; THE 'DIMENSION_SIZE' ARE NOW ENTERED.
2C7F			  ;
2C7F C1 		  DIM_SIZES:	POP   BC		      ; GET A DIMENSION-SIZE.
2C80 70 				LD    (HL),B		      ; ENTER THE HIGH BYTE.
2C81 2B 				DEC   HL		      ; BACK ONE.
2C82 71 				LD    (HL),C		      ; ENTER THE LOW BYTE
2C83 2B 				DEC   HL		      ; BACK ONE.
2C84 3D 				DEC   A 		      ; DECREASE THE DIMENSION
2C85					;			      ; SIZE.
2C85 20F8				JR    NZ,DIM_SIZES	      ; REPEAT THE OPERATION UNTILL
2C87					;			      ; THE DIMENSIONS HAVE BEEN
2C87 C9 				RET			      ; CONSIDERED; THEN RETURN.
2C88			  ;
2C88			  ; ********************************************************************
2C88			  ; THE  'ALPHANUM' SUBROUTINE
2C88			  ; THIS SUBROUTINE RETURNS WITH THE CARRY FLAG SET IF THE PRESENT
2C88			  ; VALUE OF  A  REGISTER DENOTES A VALID DIGIT OR LETTER.
2C88			  ;
2C88 CD1B2D		  ALPHANUM:	CALL  NUMERIC		      ; TEST FOR A DIGIT; CARRY WILL
2C8B					;			      ; BE RESET FOR A DIGIT.
2C8B 3F 				CCF			      ; COMPLEMENT THE CARRY FLAG.
2C8C D8 				RET   C 		      ; RETURN IF A DIGIT; OTHERWISE
2C8D					;			      ; CONTINUE ON INTO 'ALPHA'.
2C8D			  ;
2C8D			  ; ********************************************************************
2C8D			  ; THE 'ALPHA' SUBROUTINE
2C8D			  ; THIS SUBROUTINE RETURNS WITH THE CARRY FLAG SET IF THE PRESENT
2C8D			  ; VALUE OF THE  A  REGISTER DENOTES A VALID LETTER OF THE ALPHABET
2C8D			  ;
2C8D FE41		  ALPHA:	CP    'A'		      ; TEST AGAINST 041 HEX, THE CODE
2C8F					;			      ; FOR 'A'.
2C8F 3F 				CCF			      ; COMPLEMENT THE CARRY FLAG.
2C90 D0 				RET   NC		      ; RETURN IF NOT A VALID CHARACTER
2C91					;			      ; CODE.
2C91 FE5B				CP    'Z'+1		      ; TEST AGAINST  05B HEX, IF MORE
2C93					;			      ; THEN THE CODE FOR 'Z'.
2C93 D8 				RET   C 		      ; RETURN IF AN UPPER CASE LETTER.
2C94 FE61				CP    'A'+20H		      ; TEST AGAINST 061 HEX, THE CODE
2C96					;			      ; FOR  LITTLE 'A'.
2C96 3F 				CCF			      ; COMPLEMENT THE CARRY FLAG
2C97 D0 				RET   NC		      ; RETURN IF NOT A VALID CHARACTER
2C98					;			      ; CODE.
2C98 FE7B				CP    'Z'+20H+1 	      ; TEST AGAINST 07B HEX, IF MORE
2C9A					;			      ; THEN THE CODE FOR 'Z'.
2C9A C9 				RET			      ; FINISHED.
2C9B			  ;
2C9B			  ; ********************************************************************
2C9B			  ; THE  'DECIMAL TO FLOATING POINT'  SUBROUTINE
2C9B			  ; AS PART OF SYNTAX CHECKING DECIMAL NUMBERS THAT OCCUR IN A BASIC
2C9B			  ; LINE  ARE CONVERTED TO THEIR FLOATING-POINT FORMS. THIS SUBROUTINE
2C9B			  ; READS THE DECIMAL NUMERIC DIGIT BY DIGIT AND GIVES ITS REZULT AS
2C9B			  ; A 'LAST VALUE' ON CALCULATOR STACK. BUT FIRST IT DEALS WITH
2C9B			  ; THE ALTERNATHE NOTATION BIN , WICH INTRODUCES A SEQUENCE OF '0'S
2C9B			  ; AND  '1'S  GIVING THE BINARY  REPRESENTATION  OF THE REQUIRED  NUMBER.
2C9B			  ;
2C9B FEC4		  DEC_TO_FP:	CP    0C4H		      ; IS THE CHARACTER A 'BIN' ?
2C9D 2019				JR    NZ,NOT_BIN	      ; JUMP IF IT IS NOT 'BIN'.
2C9F 110000				LD    DE,0		      ; INITIALISE RESULT TO ZERO IN DE.
2CA2 E7 		  BIN_DIGIT:	RST   GET_NBT		      ; GET THE NEXT CHARACTER.
2CA3 D631				SUB   031H		      ; SUBSTRACT THE CHARACTER CODE FOR
2CA5					;			      ; '1'.
2CA5 CE00				ADC   A,0		      ; 0 NOW GIVES 0 WITH CARRY SET; 1
2CA7					;			      ; GIVES 0 WITH CARRY RESET.
2CA7 200A				JR    NZ,BIN_END	      ; ANY OTHER CHARACTER CAUSES
2CA9					;			      ; A JUMP TO BIN-END AND WILL
2CA9					;			      ; BE CHECKED FOR SYNTAX DURING
2CA9					;			      ; OR AFTER SCANNING.
2CA9 EB 				EX    DE,HL		      ; REZULT SO FAR TO HL NOW.
2CAA 3F 				CCF			      ; COMPLEMENT THE CARRY FLAG.
2CAB ED6A				ADC   HL,HL		      ; SHIFT THE REZULT LEFT, WITH THE
2CAD					;			      ; CARRY GOING TO BIT 0.
2CAD DAAD31				JP    C,REPORT_6	      ; REPORT OVERFLOW IF MORE THEN
2CB0					;			      ; 65535.
2CB0 EB 				EX    DE,HL		      ; RETURN THE REZULT SO FAR TO DE.
2CB1 18EF				JR    BIN_DIGIT 	      ; JUMP BACK FOR NEXT 0 OR 1.
2CB3 42 		  BIN_END:	LD    B,D		      ; COPY REZULT TO BC FOR STACKING.
2CB4 4B 				LD    C,E		      ;
2CB5 C32B2D				JP    STACK_BC		      ; JUMP FORWARD TO STACK THE REZULT.
2CB8			  ;
2CB8			  ; FOR OTHER NUMBERS , FIRS ANY INTEGER PART ARE CONVERTED; IF THE NEXT
2CB8			  ; CHARACTER IS A DESIMAL, THEN THE DECIMAL FUNCTION IS CONSIDERED.
2CB8			  ;
2CB8 FE2E		  NOT_BIN:	CP    02EH		      ; IS THE FIRST CHARACTER A '.' ?
2CBA 280F				JR    Z,DECIMAL 	      ; IF SO, JUMP FORWARD.
2CBC CD3B2D				CALL  INT_TO_FP 	      ; OTHERWISE, FORM A 'LAST VALUE'
2CBF					;			      ; OF THE INTEGER.
2CBF FE2E				CP    02EH		      ; IS THE NEXT CHARACTER A '.'  ?
2CC1 2028				JR    NZ,E_FORMAT	      ; JUMP FORWARD TO SEE IF IT IS
2CC3					;			      ; AN 'E'.
2CC3 E7 				RST   GET_NBT		      ; GET THE NET CHARACTER.
2CC4 CD1B2D				CALL  NUMERIC		      ; IS IT A DIGIT ?
2CC7 3822				JR    C,E_FORMAT	      ; JUMP IF NOT (E.G. 1.E4 IS
2CC9					;			      ; ALLOWED).
2CC9 180A				JR    DEC_STO_1 	      ; JUMP FORWARD TO DEAL WITH THE
2CCB					;			      ; DIGITS AFTER THE DECIMAL ROINT.
2CCB E7 		  DECIMAL:	RST   GET_NBT		      ; IF THE NUMBER STARTED WITH A
2CCC CD1B2D				CALL  NUMERIC		      ; DECIMAL, SEE IF THE NEXT
2CCF					;			      ; CHARACTER IS A DIGIT.
2CCF DA8A1C		  DEC_RPT_C:	JP    C,REPORT_C	      ; REPORT THE ERROR IF IT IS NOT.
2CD2 EF 				RST   28H		      ; USE THE CALCULATOR TO STACK
2CD3 A0 				DEFB 0A0H		      ; ZERO AS THE INTEGER PART OF
2CD4 38 				DEFB 038H		      ; SUCH NUMBERS.
2CD5 EF 		  DEC_STO_1:	RST   28H		      ; USE THE CALCULATOR AGAIN.
2CD6 A1 				DEFB 0A1H		      ; FIND THE FLOATING-POINT FORM
2CD7 C0 				DEFB 0C0H		      ; OF THE DECIMAL NUMBER '1',AND
2CD8 02 				DEFB 002H		      ; SAVE IT IN THE MEMORY AREA.
2CD9 38 				DEFB 038H		      ;
2CDA DF 		  NXT_DGT_1:	RST   18H		      ; GET THE PRESENT CHARACTER.
2CDB CD222D				CALL  STK_DIGIT 	      ; IF IT IS A DIGIT THEN STACK IT.
2CDE 380B				JR    C,E_FORMAT	      ; IF NOT ???? FORWARD.
2CE0 EF 				RST   28H		      ; NOW USE THE CALCULATOR.
2CE1 E0 				DEFB 0E0H		      ; FOR EACH PASSAGE OF THE LOOP,
2CE2 A4 				DEFB 0A4H		      ; THE NUMBER SAVED IN THE MEMORY
2CE3 05 				DEFB 005H		      ; IS FETCHED, DIVIDED BY 10
2CE4 C0 				DEFB 0C0H		      ; AND RESTORED : I.E. GOING FROM
2CE5					;			      ; .1 TO .01 TO .001  ETC.
2CE5 04 				DEFB 004H		      ; THE PRESENT DIGIT IS MULTIPLIED
2CE6 0F 				DEFB 00FH		      ; BY THE 'SAVED NUMBER' AND
2CE7 38 				DEFB 038H		      ; ADDED TO THE 'LAST VALUE'.
2CE8 E7 				RST   20H		      ; GET THE NEXT CHARACTER.
2CE9 18EF				JR    NXT_DGT_1 	      ; JUMP BACK (ONE MORE BYTE THEN
2CEB					;			      ; NEEDED) TO CONSIDER IT.
2CEB			  ;
2CEB			  ; NEXT CONSIDER  ANY 'E NOTATION', IS THE FORM  *EM  OR EM (LITTLE)
2CEB			  ; WHERE  'M' IS A POSITIVE OR NEGATIVE INTEGER.
2CEB			  ;
2CEB FE45		  E_FORMAT:	CP    'E'		      ; IS THE PRESENT CHARACTER AN 'E' ?
2CED 2803				JR    Z,SIGN_FLAG	      ; JUMP FORWARD IF IT IS.
2CEF FE65				CP    'E'+20H		      ; IS IT AN LITTLE 'E' ?
2CF1 C0 				RET   NZ		      ; FINISHEND UNLESS IT IS SO.
2CF2 06FF		  SIGN_FLAG:	LD    B,0FFH		      ; USE B AS THE SIGN FLAG.
2CF4					;			      ; FF  FOR  '+'.
2CF4 E7 				RST   GET_NBT		      ; GET THE NEXT CHARACTER.
2CF5 FE2B				CP    '+'		      ; IS IT A '+' ?
2CF7 2805				JR    Z,SIGN_DONE	      ; JUMP FORWARD.
2CF9 FE2D				CP    '-'		      ; IS IT A '-' ?
2CFB 2002				JR    NZ,ST_E_PART	      ; JUMP IF EITHER	'+' NOT '-'.
2CFD 04 				INC   B 		      ; CHANGE THE SIGN OF THE FLAG.
2CFE E7 		  SIGN_DONE:	RST   GET_NBT		      ; POINT TO THE FIRST DIGIT.
2CFF CD1B2D		  ST_E_PART:	CALL  NUMERIC		      ; IS IT INDEED A DIGIT ?
2D02 38CB				JR    C,DEC_RPT_C	      ; REPORT THE ERROR IF NOT.
2D04 C5 				PUSH  BC		      ; SAVE THE FLAG IN B BRIEFLY.
2D05 CD3B2D				CALL  INT_TO_FP 	      ; STACK ABS M, WHERE M IS THE
2D08					;			      ; EXPONENT.
2D08 CDD52D				CALL  FP_TO_A		      ; TRANSFER  ABS M  INTO  A.
2D0B C1 				POP   BC		      ; RESTORE THE SIGN FLAG TO B.
2D0C DAAD31				JP    C,REPORT_6	      ; REPORT THE OVERFLOW NOW IF
2D0F A7 				AND   A 		      ; ABS M IS GREATER THEN 255 OR
2D10 FAAD31				JP    M,REPORT_6	      ; INDEED GREATER THEN 127
2D13					;			      ; (OTHER VALUES GREATER THAN
2D13					;			      ; ABOUT 39 WILL BE DETECTED LATER).
2D13 04 				INC   B 		      ; TEST THE SIGN FLAG IN B;'+'
2D14					;			      ; (I.E. +FF) WILL NOW SET THE ZERO
2D14					;			      ; FLAG.
2D14 2802				JR    Z,E_FP_JUMP	      ; JUMP IF SIGN OF  M  IS	'+'.
2D16 ED44				NEG			      ; NEGATE	M  IF  SIGN IS	'-'.
2D18 C34F2D		  E_FP_JUMP:	JP    E_TO_FP		      ; JUMP TO ASSIGN TO THE 'LAST VALUE'
2D1B					;			      ; THE REZULT  OF	X*10^M.
2D1B			  ;
2D1B			  ; ********************************************************************
2D1B			  ; THE ' NUMERIC '  SUBROUTINE
2D1B			  ; THIS SUBROUTINE RETURNS WITH THE CARRY FLAG RESET IF THE PRESENT
2D1B			  ; VALUE OF THE  A  REGISTER DENOTES A VALID DIGIT.
2D1B			  ;
2D1B FE30		  NUMERIC:	CP    '0'		      ; TEST AGAINST 030 HEX, THE CODE
2D1D					;			      ; FOR '0'
2D1D D8 				RET   C 		      ; RETURN IF NOT A VALID CHARACTER
2D1E					;			      ; CODE.
2D1E FE3A				CP    '9'+1		      ; TEST AGAINST THE UPPER LIMIT.
2D20 3F 				CCF			      ; COMPLEMENT THE CARRY FLAG.
2D21 C9 				RET			      ; FINISHED.
2D22			  ;
2D22			  ; ********************************************************************
2D22			  ; THE  'STK-DIGIT'  SUBROUTINE
2D22			  ; THIS SUBROUTINE SIMPLY RETURNS IF THE CURRENT VALUE HELD IN  A
2D22			  ; REGISTER DOES NOT REPRESENT A DIGIT BUT IF IT  DOES THEN
2D22			  ; FLOATING-POINT FORM FOR THE DIGIT BECOMES THE ' LAST VALUE ' ON
2D22			  ; THE CALCULATOR STACK.
2D22			  ;
2D22 CD1B2D		  STK_DIGIT:	CALL  NUMERIC		      ; IS THE CHARACTER A DIGIT ?
2D25 D8 				RET   C 		      ; RETURN IF NOT IN RANGE.
2D26 D630				SUB   30H		      ; REPLACE THE CODE BY THE ACTUAL
2D28					;			      ; DIGIT.
2D28			  ;
2D28			  ; ********************************************************************
2D28			  ; THE  ' STACK_A ' SUBROUTINE
2D28			  ; THIS SUBROUTINE GIVES THE FLOATING POINT FORM FOR THE ABSOLUTE
2D28			  ; BINARY VALUE CURRENTLY HELD IN THE	A  REGISTER.
2D28			  ;
2D28 4F 		  STACK_A:	LD    C,A		      ; TRANSFER  THE VALUE  TO  THE
2D29					;			      ; C  REGISTER.
2D29 0600				LD    B,0		      ; CLEAR THE  B  REGISTER.
2D2B			  ;
2D2B			  ; ********************************************************************
2D2B			  ; THE  ' STACK_BC ' SUBROUTINE
2D2B			  ; THIS SUBROUTINE GIVES THE FLOATING-POINT FORM FOR ABSOLUTE BINARY
2D2B			  ; VALUE CURRENTLY HELD IN THE BC REGITER PAIR.
2D2B			  ; THE FORM USED IN THIS AND HENCE  IN TWO PREVIOUS SUBROUTINES AS WELL
2D2B			  ; IS THE ONE RESERVED IN THE SPECTRUM  FOR SMALL INTEGERS  N , WHERE
2D2B			  ; -65535 <= N <= 65535. THE FIRST AND FIFTH BYTES ARE ZERO; THE THIRD
2D2B			  ; AND THE FOURTH BYTES ARE THE LESS SIGNIFICANT AND MORE SIGNIFICANT
2D2B			  ; BYTES OF THE 16 BIT INTEGER  N  IN TWO'S  COMPLEMENT FORM ( IF N IS
2D2B			  ; NEGATIVE , THESE TWO BYTES HOLD  65536+N ); AND THE SECOND BYTE IS
2D2B			  ; A SIGN BYTE , 00 FOR '+' ,FF FOR '-' .
2D2B			  ;
2D2B FD213A5C		  STACK_BC:	LD    IY,YBASE		      ; RE-INITIALISE IY TO 'ERR_NR'
2D2F AF 				XOR   A 		      ; CLEAR THE A REGISTER.
2D30 5F 				LD    E,A		      ; AND THE  E  REGISTER,
2D31					;			      ; TO INDICATE '+'.
2D31 51 				LD    D,C		      ; COPY THE LESS SIGNIFICANT
2D32					;			      ; BYTE TO  D.
2D32 48 				LD    C,B		      ; AND THE MORE SIGNIFICANT
2D33					;			      ; BYTE TO  C.
2D33 47 				LD    B,A		      ; CLAER THE B REGISTER.
2D34 CDB62A				CALL  STK_STORE 	      ; NOW STACK THE NUMBER.
2D37 EF 				RST   28H		      ; MAKE  HL  POINT TO
2D38 38 				DEFB  038H		      ; 'STKEND'-5.
2D39 A7 				AND   A 		      ; CLEAR THE CARRY FLAG.
2D3A C9 				RET			      ; FINISHED.
2D3B			  ;
2D3B			  ; ********************************************************************
2D3B			  ; THE  ' INTEGER TO FLOATING-POINT '	SUBROUTINE
2D3B			  ; THIS SUBROUTINE RETURNS A ' LAST  VALUE '  ON THE  CALCULATOR  STACK
2D3B			  ; THAT IS REZULT OF CONVERTING AN INTEGER IN A BASIC LINE , I.E.
2D3B			  ; THE INTEGER PART OF THE DECIMAL NUMBER OR THE LINE NUMWER , TO ITS
2D3B			  ; FLOATING-POINT  FORM.
2D3B			  ; REPEATED CALLS TO CH-ADD+1 FETCH EACH DIGIT OF THE INTEGER IN TURN.
2D3B			  ; AN EXIT  IS MADE WHEN A CODE THAT DOES NOT REPRESENT A DIGIT HAS
2D3B			  ; BEEN  FETCHED.
2D3B			  ;
2D3B F5 		  INT_TO_FP:	PUSH  AF		      ; SAVE THE FIRST DIGIT - IN A.
2D3C EF 				RST   28H		      ; USE THE CALCULATOR.
2D3D A0 				DEFB 0A0H		      ; THE 'LAST VALUE' IS NOW ZERO.
2D3E 38 				DEFB 038H		      ;
2D3F F1 				POP   AF		      ; RESTORE THE FIRST DIGIT.
2D40			  ;
2D40			  ; NOW  LOOP  IS  SETUP. AS LONG AS THE CODE REPRESENTS A DIGIT THEN
2D40			  ; THE FLOATING-POINT FORM IS FOUND AND STACKED UNDER THE 'LAST VALUE'.
2D40			  ; THE 'LAST VALUE' IS THEN MULTIPLIED BU DECIMAL 10 AND ADDED TO
2D40			  ; THE 'DIGIT' TO FORM A NEW 'LAST VALUE' WICH IS CARRIED BACK TO
2D40			  ; THE START  OF  THE LOOP.
2D40			  ;
2D40 CD222D		  NXT_DGT_2:	CALL  STK_DIGIT 	      ; IF THE CODE REPRESENTS A DIGIT
2D43 D8 				RET   C 		      ; THEN STACK THE FLOATING-POIT
2D44					;			      ; FORM.
2D44 EF 				RST   28H		      ; USE THE CALCULATOR.
2D45 01 				DEFB 001H		      ; 'DIGIT' GOES UNDER 'LAST VALUE'
2D46 A4 				DEFB 0A4H		      ; DEFINE DECIMAL 10.
2D47 04 				DEFB 004H		      ; 'LAST VALUE'='LAST VALUE'*10.
2D48 0F 				DEFB 00FH		      ; 'LAST VALUE'='LAST VALUE'+
2D49					;			      ; 'DIGIT'.
2D49 38 				DEFB 038H		      ;
2D4A CD7400				CALL  CH_ADD_1		      ; THE NEXT CODE GOES INTO A.
2D4D 18F1				JR    NXT_DGT_2 	      ; LOOK BACK WITH THIS CODE.
2D4F			  ;
2D4F			  ; ********************************************************************
2D4F			  ; *								       *
2D4F			  ; *	      THE   ARIFMETIC	  ROUTINES			       *
2D4F			  ; *								       *
2D4F			  ; ********************************************************************
2D4F			  ;
2D4F			  ; THE 'E-FORMAT TO  FLOATING-POINT' SUBROUTINE
2D4F			  ; ( OFFSET  3C - SEE	CALCULATE  BELOW  'E TO FP' )
2D4F			  ; THIS SUBROUTINE GIVES THE 'LAST VALUE' ON THE TOP OF THE CALCULATOR
2D4F			  ; STACK  THAT IS  THE REZULT OF CONVERTING A NUMBER GIVEN IN THE FORM
2D4F			  ; X.E+M , WHERE M IS A POSITIVE OR A NEGATIVE INTEGER. THE SUBROUTINE
2D4F			  ; IS ENTERED WITH  X	AT  THE TOP  OF THE  CALCULATOR STACK  AND M IN
2D4F			  ; THE  A  REGISTER.
2D4F			  ; THE METHOD	USED  IS TO FIND  THE ABSOLUTE VALUE  OF M ,SAY P , AND
2D4F			  ; TO	 MULTIPLY  OR  DIVIDE  X  BY  10^P  ACCORDING TO  WHETHER  M IS
2D4F			  ; POSITIVE  OR  NEGATIVE.
2D4F			  ; TO ACHIVE THIS , P	IS  SHIFTED  RIGHT  UNTILL IT IS ZERO , AND X
2D4F			  ; IS	MULTIPLIED  OR	DIVIDED  BY 10^(2^N)  FOR  EACH  SET  BIT  B(N)
2D4F			  ; OF P. SINCE  P  IS	NEVER  MUCH  MORE  THEN DECIMAL 39 , BITS 6 & 7
2D4F			  ; OF	P  WILL  NOT  NORMALLY	BE  SET.
2D4F			  ;
2D4F 07 		  E_TO_FP:	RLCA			      ; TEST THE SIGN OF M BY ROTATING
2D50 0F 				RRCA			      ; BIT 7 OF A A INTO THE CARRY
2D51					;			      ; WITHOUT CHANGING  A.
2D51 3002				JR    NC,E_SAVE 	      ; JUMP IF  M  IS POSITIVE.
2D53 2F 				CPL			      ; NEGATE	M  IN  A  WITHOUT
2D54 3C 				INC   A 		      ; DISTRIBUTING THE CARRY FLAG.
2D55 F5 		  E_SAVE:	PUSH  AF		      ; SAVE  M  IN  A	BRIEFLY.
2D56 21925C				LD    HL,MEMBOT 	      ; THIS IS A 'MEMBOT': A SIGN FLAG
2D59 CD0B35				CALL  FP_0_1		      ; IS NOW STORED IN THE FIRST BYTE
2D5C					;			      ; OF MEM-0, I.E  00  FOR '+', AND
2D5C					;			      ; 1  FOR '-'.
2D5C EF 				RST   28H		      ; THE STACK HOLDS  X.
2D5D A4 				DEFB  0A4H;		      ;  STK_TEN      ; X,10(DECIMAL).
2D5E 38 				DEFB  038H;		      ;  END_CALC     ; X,10.
2D5F F1 				POP   AF		      ; RESTORE  M  IN	A.
2D60 CB3F		  E_LOOP:	SRL   A 		      ; IN THE LOOP, SHIFT OUT THE NEXT
2D62					;			      ; BIT OF M, MODIFYING THE CARRY
2D62					;			      ; AND THE ZERO FLAG APPROPRIATELY;
2D62 300D				JR    NC,E_TST_END	      ; JUMP IF CARRY RESET.
2D64 F5 				PUSH  AF		      ; SAVE THE REST OF  M  AND THE FLAGS.
2D65 EF 				RST   28H		      ; THE STACK HOLDS  X' AND
2D66					;			      ; 10^(2^N), WHERE  X' IS AN
2D66					;			      ; INTERIM STAGE IN THE MULTIPLICATION
2D66					;			      ; OF THE	X  BY  10^M, AND N=
2D66					;			      ; 0,1,2,3,4 OR 5
2D66 C1 				DEFB 0C1H		      ; (10^(2^N) IS COPIED TO MEM-1).
2D67 E0 				DEFB 0E0H		      ; X',10^(2^N).(1/10)
2D68 00 				DEFB 000H		      ; X',10^(2^N)
2D69 04 				DEFB 004H		      ; X',10^(2^N)
2D6A 04 				DEFB 004H		      ; X',10^(2^N)=X"
2D6B 33 				DEFB 033H		      ; X"
2D6C 02 				DEFB 002H		      ; X"
2D6D 05 				DEFB 005H		      ; X',10^(2^N)=X"(X" IS N'*10^
2D6E					;			      ; (2^N) OR X'/10^(2^N)
2D6E					;			      ; ACCORDING AS  M  IS '+' OR '-').
2D6E E1 				DEFB 0E1H		      ; X",10^(2^N)
2D6F 38 				DEFB 038H		      ; X",10^(2^N)
2D70 F1 				POP   AF		      ; RESTORE THE REST OF M IN A, AND
2D71					;			      ; THE FLAGS.
2D71 2808		  E_TST_END:	JR    Z,E_END		      ; JUMP IF M  HAS BEEN REDUCED TO
2D73					;			      ; ZERO.
2D73 F5 				PUSH  AF		      ; SAVE THE REST OF  M  IN A.
2D74 EF 				RST   28H		      ; X",10^(2^N)
2D75 31 				DEFB 031H		      ; DUPLICATE     X",10^(2^N),10^(2^N)
2D76 04 				DEFB 004H		      ; MULTIPLY      X",10^(2^(N+1))
2D77 38 				DEFB 038H		      ; END_CALC      X",10^(2^(N+1))
2D78 F1 				POP   AF		      ; RESTORE  THE REST OF M	IN A.
2D79 18E5				JR    E_LOOP		      ; JUMP BACK FOR ALL BITS OF M.
2D7B EF 		  E_END:	RST   28H		      ; USE THE CALCULATOR TO DELETE
2D7C 02 				DEFB 002H		      ; DELETE	      FINAL POWER OF 10 REACHED.
2D7D 38 				DEFB 038H		      ; END_CALC      LEAVING THE 'LAST VALUE'
2D7E C9 				RET			      ; X'*10^M ON THE STACK.
2D7F			  ;
2D7F			  ; ********************************************************************
2D7F			  ; THE  'INT_FETCH'  SUBROUTINE
2D7F			  ; THIS SUBROUTINE COLLECTS IN  DE  A SMALL INTEGER N ( 65535<N<-65536)
2D7F			  ; FROM  THE  LOCATION  ADDRESSED BY  HL : I.E. N IS NORMALLY THE FIRST
2D7F			  ; (OR SECOND) NUMBER ON THE TOP OF THE CALCULATOR STACK; BUT	HL  CAN
2D7F			  ; ALSO  ACCESS  (BY EXCHANGE WITH  DE) A NUMBER WICH HAS BEEN DELETED
2D7F			  ; FROM THE STACK.
2D7F			  ; THE  SUBROUTINE  DOES  NOT ITSELF DELETE  THE NUMBER  FROM THE STACK
2D7F			  ; OR FROM MEMORY; IT RETURNS HL POINTING TO THE FOURTH BYTE  OF
2D7F			  ; THE NUMBER IN ITS ORIGINAL POSITION.
2D7F			  ;
2D7F 23 		  INT_FETCH:	INC   HL		      ; POINT TO THE SIGN BYTE OF THE
2D80					;			      ; NUMBER.
2D80 4E 				LD    C,(HL)		      ; COPY THE SIGN BYTE TO C.
2D81			  ;
2D81			  ; THE FOLLOWING MECHANISM WILL TWO'S	COMPLEMENT THE NUMBER IF IT IS
2D81			  ; NEGATIVE (C IS FF) BUT LEAVE IT UNALTERED IF IT IS POSITIVE
2D81			  ; (C IS 00).
2D81			  ;
2D81 23 				INC   HL		      ; POINT TO THE LESS SIGNIFICANT
2D82					;			      ; BYTE.
2D82 7E 				LD    A,(HL)		      ; COLLECT THE BYTE IN A.
2D83 A9 				XOR   C 		      ; ONES COMPLEMENT IT IF NEGATIVE.
2D84 91 				SUB   C 		      ; THIS ADDS 1 FOR NEGATIVE
2D85					;			      ; NUMBERS: IT SETS CARRY UNLESS
2D85					;			      ; THE BYTE WAS  00.
2D85 5F 				LD    E,A		      ; LESS SIGNIFICANT TO E NOW.
2D86 23 				INC   HL		      ; POINT TO THE MORE SIGNIFICANT
2D87					;			      ; BYTE.
2D87 7E 				LD    A,(HL)		      ; COLLECT IT IN A.
2D88 89 				ADC   A,C		      ; FINISH TO COMPLEMENTING IN
2D89 A9 				XOR   C 		      ; THE CASE OF THE NEGATIVE
2D8A					;			      ; NUMBER :  NOTE THAT THE CARRY
2D8A					;			      ; IS ALWAYS LEFT RESET.
2D8A 57 				LD    D,A		      ; MORE SIGNIFICANT BYTE TO D NOW.
2D8B C9 				RET			      ; FINISHED.
2D8C			  ;
2D8C			  ; ********************************************************************
2D8C			  ; THE  'INT_STORE'  SUBROUTINE
2D8C			  ; THIS SUBROUTINE STORES  A  SMALL INTEGER  N ( -65535<=N<=+65536 ) IN
2D8C			  ; THE  LOCATION  ADDRESSED  BY  HL  AND THE FOUR  FOLLOWING LOCATION :
2D8C			  ; I.E.  N  REPLACES  THE FIRST FOR THE SECOND NUMBER AT THE TOP OF THE
2D8C			  ; CALCULATOR	STACK.
2D8C			  ; THE SUBROUTINE RETURNS  HL	POINTING TO THE FIRST BYTE OF N ON
2D8C			  ; THE  STACK.
2D8C			  ;
2D8C 0E00		  P_INT_STO:	LD    C,0		      ; THIS ENTRY POINT WOULD STORE
2D8E					;			      ; A NUMBER KNOWN TO BE POSITIVE.
2D8E E5 		  INT_STORE:	PUSH  HL		      ; THE POINTER TO THE FIRST
2D8F					;			      ; LOCATION IS SAVED.
2D8F 3600				LD    (HL),0		      ; THE FIRST BYTE IS SET TO ZERO.
2D91 23 				INC   HL		      ; POINT TO THE SECOND LOCATION.
2D92 71 				LD    (HL),C		      ; ENTER THE SIGN BYTE.
2D93			  ;
2D93			  ; THE SAME MECHANISM IS NOW  USED AS IN 'INT_FETCH' TO TWO'S COMPLEMENT
2D93			  ; NEGATIVE NUMBERS. THIS IS NEEDED  E.G. BEFORE AND AFTER THE
2D93			  ; MULTIPLICATION OF SMALL INTEGERS. ADDITION IS HOWEVER PERFORMED
2D93			  ; WITHOUT ANY FURTHER  TWO'S	COMPLEMENTING  BEFORE OR AFTERWARDS.
2D93			  ;
2D93			  ;
2D93 23 				INC   HL		      ; POINT TO THE THIRD LOCATION.
2D94 7B 				LD    A,E		      ; COLLECT THE LESS SIGNIFICANT
2D95					;			      ; BYTE.
2D95 A9 				XOR   C 		      ; TWO'S COMPLEMENT IT IF THE
2D96 91 				SUB   C 		      ; NUMBER IS NEGATIVE.
2D97 77 				LD    (HL),A		      ; STORE THE BYTE.
2D98 23 				INC   HL		      ; POINT TO THE FOURTH LOCATION.
2D99 7A 				LD    A,D		      ; COLLECT THE MORE SIGNIFICANT
2D9A					;			      ; BYTE.
2D9A 89 				ADC   A,C		      ; TWO'S COMPLEMENT IT IF THE
2D9B A9 				XOR   C 		      ; NUMBER IS NEGATIVE.
2D9C 77 				LD    (HL),A		      ; STORE THE BYTE.
2D9D 23 				INC   HL		      ; POINT TO THE FIRST LOCATION.
2D9E 3600				LD    (HL),0		      ; THE FIFTH BYTE IS SET TO ZERO.
2DA0 E1 				POP   HL		      ; RETURN WITH HL POINTING TO THE FIRST BYTE
2DA1 C9 				RET			      ;   OF N ON THE THE STACK.
2DA2			  ;			      ;
2DA2			  ; ********************************************************************
2DA2			  ; THE  'FLOATING-POINT TO  BC'  SUBROUTINE
2DA2			  ; THIS SUBROUTINE IS CALLED FROM FOUR DIFFERENT PLACES FOR VARIOUS
2DA2			  ; PURPOSES  AND IS USED TO COMPRESS THE FLOATING-POINT 'LAST VALUE'
2DA2			  ; INTO THE  BC  REGISTER  PAIR.
2DA2			  ; IF THE RESULT IS TOO LARGE, I.E. GREATER THEN 65535 DECIMAL,THEN
2DA2			  ; THE SUBROUTINE RETURNS WITH THE CARRY FLAG SET. IF THE 'LAST VALUE'
2DA2			  ; IS NEGATIVE , THEN	THE ZERO FLAG IS RESET.
2DA2			  ; THE LOW BYTE OF THE RESULT IS ALSO COPIED TO THE A REGISTER.
2DA2			  ;
2DA2 EF 		  FP_TO_BC:	RST   28H		      ;   USE THE CALCULATOR TO MAKE HL
2DA3 38 				DEFB 038H		      ;  POINT TO STKEND-5.
2DA4 7E 				LD    A,(HL)		      ;   COLLECT THE EXPONENT BYTE
2DA5 A7 				AND   A 		      ;  OF THE 'LAST  VALUE' ; JUMP IF IT IS
2DA6 2805				JR    Z,FP_DELETE	      ; ZERO , INDICATING A 'SMALL INTEGER'.
2DA8 EF 				RST   28H		      ;      NOW USE THE CALCULATOR TO ROUND THE 'LAST
2DA9 A2 				DEFB 0A2H		      ; STK_HALF     VALUE' TO THE NEARIST INTEGER, WHICH ALSO
2DAA 0F 				DEFB 00FH		      ; ADDITION     CHANGES IT TO 'SMALL INTEGER' FORM ON
2DAB 27 				DEFB 027H		      ; INT	     THE CALCULATOR STACK
2DAC 38 				DEFB 038H		      ; END_CALC     IF THAT IS POSSIBLE,I.E. IF
2DAD EF 		  FP_DELETE:	RST   28H		      ;       -65535<=X<= 65535  USE THE CALCULATOR
2DAE 02 				DEFB  02H		      ; DELETE	      STACK TO DELETE THE  INTEGER FROM THE
2DAF 38 				DEFB 038H		      ; END_CALC     CALCULATOR STACK; DE STILL POINTS TO IT
2DB0					;			      ;       IN MEMORY  ( AT STKEND).
2DB0 E5 				PUSH  HL		      ;  SAVE BOTH STACK POINTERS.
2DB1 D5 				PUSH  DE		      ;
2DB2 EB 				EX    DE,HL		      ; HL NOW POINTS TO THE NUMBER.
2DB3 46 				LD    B,(HL)		      ; COPY THE FIRST BYTE IN B
2DB4 CD7F2D				CALL  INT_FETCH 	      ; COPY BYTES 2,3 AND 4 TO C,E,D
2DB7 AF 				XOR   A 		      ; CLEAR A REGISTER
2DB8 90 				SUB   B 		      ; THIS SET CARRY UNLESS B IS ZERO
2DB9 CB79				BIT   7,C		      ; THIS SET THE ZERO FLAG IF THE NUMBER IS
2DBB					;			      ; POSITIVE  (NZ DENOTE NEGATIVE)
2DBB 42 				LD    B,D		      ; COPY THE HIGH BYTE TO B
2DBC 4B 				LD    C,E		      ; AND THE LOWER BYTE TO C.
2DBD 7B 				LD    A,E		      ; COPY THE LOWER BYTE TO A TOO.
2DBE D1 				POP   DE		      ; RESTORE THE STACK POINTERS.
2DBF E1 				POP   HL		      ;
2DC0 C9 				RET			      ; FINISHED.
2DC1			  ;				  ;
2DC1			  ; ********************************************************************
2DC1			  ; THE  'LOG(2^A)'  SUBROUTINE
2DC1			  ; THIS SUBROUTINE IS CALLED BY THE 'PRINT-FP' SUBROUTINE  TO CALCULATE
2DC1			  ; THE APPROXIMATE NUMBER OF DIGITS BEFORE THE DECIMAL IN X, THE NUMBER
2DC1			  ; TO BE PRINTED , OR , IF THERE ARE  NO  DIGITS  BEFORE  THE	DECIMAL,
2DC1			  ; THEN  THE APPROXIMATE NUMBER OF LEADING ZEROS AFTER THE  DECIMAL.
2DC1			  ; IT IS ENTERED WITH THE A REGISTER  CONTAINING  E', THE TRUE EXPONENT
2DC1			  ; OF X , OR E'-2, AND CALCULATES  Z=LOG TO THE BASE 10 OF (2^A). IT
2DC1			  ; THEN SETS  A  EQUAL TO ABS INT (X+0.5), AS REQUIRED , USING FP_TO_A
2DC1			  ; FOR THIS PURPOSE.
2DC1			  ;
2DC1 57 		  LOG_2A:	LD    D,A		      ; THE INTEGER A IS STACKED. , EITHER
2DC2 17 				RLA			      ; AS 00 00 A 00 00 (FOR POSITIVE A) OR
2DC3 9F 				SBC   A,A		      ; AS 00 FF A FF 00 ( FOR NEGATIVE A).
2DC4 5F 				LD    E,A		      ; THESE BYTES ARE FIRST LOADED INTO A,E,D,C,B
2DC5 4F 				LD    C,A		      ; AND THEN STK_STORE IS CALLED TO PUT THE
2DC6 AF 				XOR   A 		      ; NUMBER ON THE CALCULATOR STACK.
2DC7 47 				LD    B,A		      ;
2DC8 CDB62A				CALL  STK_STORE 	      ;
2DCB EF 				RST   28H		      ; FP_CALC
2DCC 34 				DEFB 034H		      ; STK_DATA	   LOG 2 TO THE BASE 10 IS NOW STACKED
2DCD EF 				DEFB 0EFH		      ; EXPONENT 7F	   STACK NOW HOLDS A,LOG 2
2DCE 1A209A85				DEFB 01AH, 020H, 09AH, 085H
2DD2 04 				DEFB 004H		      ; MULTIPLY	   A*LOG 2 I.E. LOG  (2**A)
2DD3 27 				DEFB 027H		      ; INT		   INT LOG(2**A)
2DD4 38 				DEFB 038H		      ; ENL_CALC
2DD5			  ;
2DD5			  ; THE SUBROUTINE CONTINUES ON INTO FP_TO_A TO COMPLETE
2DD5			  ; THE CALCULATION.
2DD5			  ;
2DD5			  ; ********************************************************************
2DD5			  ; THE  'FLOATING-POINT TO  A	'  SUBROUTINE
2DD5			  ; THIS SHORT BUT VITAL SUBROUTINE IS CALLED AT LEAST 8 TIMES FOR
2DD5			  ; VARIOUS PURPOSES. IT USES  THE LAST, BUT ONE SUBROUTINE, FP_TO_BC,
2DD5			  ; TO GET THE	'LAST VALUE' INTO THE  A  REGISTER  WHERE  THIS IS
2DD5			  ; POSSIBLE. IF  THEREFORE TESTS WHETHER THE MODULUS OF THE NUMBER,
2DD5			  ; ROUNDS  TO MORE  THEN 255 AND IF IT DOES THE SUBROUTINE RETURNS
2DD5			  ; WITH THE CARRY FLAG SET. OTHERWISE IT RETURNS WITH THE MODULUS OF
2DD5			  ; THE NUMBER , ROUNDED TO THE NEREST INTEGER, IN THE A REGISTER, AND
2DD5			  ; THE ZERO FLAG  SET	TO  IMPLY  THAT THE NUMBER WAS POSSIBLE, OR
2DD5			  ; RESET TO IMPLY THAT THE NUMBER WAS POSITIVE,OR RESET TO IMPLY THAT
2DD5			  ; IT WAS NEGATIVE.
2DD5			  ;
2DD5 CDA22D		  FP_TO_A:	CALL  FP_TO_BC		      ; COMPRESS THE "LAST VALUE" INTO BC
2DD8 D8 				RET   C 		      ; RETURN IF OUT OF RANGE ALREADY
2DD9 F5 				PUSH  AF		      ; SAVE THE RESULTS AND THE FLAGS
2DDA 05 				DEC   B 		      ; AGAIN IT WILL BE OUT OF RANGE IF THE B
2DDB 04 				INC   B 		      ; REGISTER DOES NOT HOLDS ZERO.
2DDC 2803				JR    Z,FP_A_END	      ; JUMP IF IN RANGE.
2DDE F1 				POP   AF		      ; FETCH THE RESULT AND THE FLAGS.
2DDF 37 				SCF			      ; SIGNAL THE RESULT OUT OF RANGE.
2DE0 C9 				RET			      ; FINISHED UNSUCCESSFUL.
2DE1 F1 		  FP_A_END:	POP   AF		      ; FETCH THE RESULT AND FLAGS
2DE2 C9 				RET			      ; FINISHED SUCCESSFUL.
2DE3			  ;
2DE3			  ; ********************************************************************
2DE3			  ; THE  'PRINT A FLOATING-POINT NUMBER' SUBROUTINE
2DE3			  ; THIS  SUBROUTINE IS CALLED BY THE  'PRINT'	COMMAND ROUTINE AT 2039
2DE3			  ; AND BY STR$ AT 3630, WICH CONVERTS TO A STRIG THE NUMBER AS IT WOULD
2DE3			  ; BE PRINTED. THE SUBROUTINE PRINTS X, THE 'LAST VALUE' ON THE
2DE3			  ; CALCULATOR STACK. THE PRINT FORMAT NEVER OCCUPIES MORE THEN 14
2DE3			  ; SPACES.
2DE3			  ; THE  8  MOST  SIGNIFICANT DIGITS OF X, CORRECTLY ROUNDED, ARE STORED
2DE3			  ; IN	AN  AD HOC PRINT BUFFER IN MEM-3 AND MEM-4. SMALL NUMBERS,
2DE3			  ; NUMERICALLY LESS THEN 1, AND LARGE NUMBERS NUMERICALLY  GREATE,THAN
2DE3			  ; 2^27,ARE DEALT WITH SEPARATLY. THE	FORMER	ARE  MULTIPLIED BY 10^N,
2DE3			  ; WHERE N IS APPROXIMATE NUMBER OF LEADING ZEROES AFTER THE DECIMAL,
2DE3			  ; WHILE THE LATTER ARE DIVADED BY 10^(N-7), WHERE N IS THE APPROXIMETE
2DE3			  ; NUMBER OF DIGITS  BEFORE THE DECIMAL. THIS BRINGS ALL NUMBERS INTO
2DE3			  ; THE MIDDLE RANGE, AND THE NUMBERS OF DIGITS REQUIRED BEFORE
2DE3			  ; THE DECIMAL IS BUILT UP IN THE SECOND BYTE OF THE MEM-5. FINALLY
2DE3			  ; THE PRINTING IS DONE, USING  E-FORMAT  IF THERE  ARE  MORE THAN 8
2DE3			  ; DIGITS  BEFORE THE DECIMAL OR, FOR SMALL NUMBERS, MORE THEN 4
2DE3			  ; LEADING  ZEROES  AFTER THE DECIMAL.
2DE3			  ;   THE FOLLOWING PROGRAM SHOWS THE RANGE OF PRINT FORMATS:
2DE3			  ;
2DE3			  ;	 10 FOR A=-11 TO 12 : PRINT SGN A*9^A : NEXT A
2DE3			  ;
2DE3			  ; 1. FIRST THE SIGN OF X IS TAKEN CARE OF:
2DE3			  ;    IF X IS NEGATIVE, THE SUBROUTINE JUMPS TO PF_NEGATIVE, TAKES
2DE3			  ; ABS X AND PRINT THE MINUS AGAIN.
2DE3			  ;    IF X IS ZERO, X IS DELETED FROM THE CALCULATOR STACK, A '0' IS
2DE3			  ; PRNTED, AND A RETURN IS MADE FROM THE SUBROUTINE.
2DE3			  ;    IF X IS POSITIVE, THE SUBROUTINE JUST CONTINUES;
2DE3			  ;
2DE3 EF 		  PRINT_FP:	RST   28H		      ;  USE CALCULATOR.
2DE4 31 				DEFB 031H		      ; DUPLICATE	X,X
2DE5 36 				DEFB 036H		      ; LESS_0		X,(1/0) LOGICAL VALUE OF X
2DE6 00 				DEFB 000H		      ; JUMP_TRUE	X
2DE7 0B 				DEFB PF_NEGTVE-$	      ;        X
2DE8 31 				DEFB 031H		      ; DUPLICATE	X,X
2DE9 37 				DEFB 037H		      ; GREATER_0	X,(1/0)
2DEA 00 				DEFB 000H		      ; JUMP_TRUE	X
2DEB 0D 				DEFB PF_POSTVE-$	      ;        X HEREAFTER X'=ABS X
2DEC 02 				DEFB 002H		      ; DELETE
2DED 38 				DEFB 038H		      ; END_CALC
2DEE 3E30				LD   A,'0'		      ;  ENTER	ASCII CODE OF '0'
2DF0 D7 				RST  PRINT_A_1		      ;  PRINT '0'
2DF1 C9 				RET			      ;  FINISHED AS THE LAST VALUE IS ZERO
2DF2 2A 		  PF_NEGTVE:	DEFB 02AH		      ; ABS		X', X'=ABS X
2DF3 38 				DEFB 038H		      ; END_CALC	X'
2DF4 3E2D				LD   A,'-'		      ;  ENTER ASCII CODE '-'
2DF6 D7 				RST  PRINT_A_1		      ;  PRINT '-'
2DF7 EF 				RST  028H		      ;  USE THE CALCULATOR AGAIN
2DF8 A0 		  PF_POSTVE:	DEFB 0A0H		      ; STK_ZERO	THE 15 BYTES OF MEM_3, MEM_4,
2DF9 C3 				DEFB 0C3H		      ; ST_MEM_3	 AND MEM_5 ARE NOW INITIALISED TO
2DFA C4 				DEFB 0C4H		      ; ST_MEM_4	 ZERO TO BE USED FOR A PRINT
2DFB C5 				DEFB 0C5H		      ; ST_MEM_5	 BUFFER AND TWO COUNTERS.
2DFC 02 				DEFB 002H		      ; DELETE		 THE STACK IS CLEARED, EXCEPT FOR X'.
2DFD 38 				DEFB 038H		      ; END_CALC	 X'
2DFE D9 				EXX			      ; 	H' L' WHICH IS USED TO HOLD
2DFF E5 				PUSH  HL		      ; 	CALCULATORS OFFSETS (E.G. FOR 'STR$')
2E00 D9 				EXX			      ;        IS SAVED ON THE MACHINE STACK.
2E01			  ;
2E01			  ; 2.	THTS IS THE START OF A LOOP WHICH DEALS WITH LARGE NUMBERS.
2E01			  ; HOWEVER EVERY NUMBER X IS FIRST SPLIT INTO ITS INTEGER PART I AND
2E01			  ; THE FRACTIONAL PART  F. IF I IS A SMALL INTEGER , I.E. IF
2E01			  ; -65535 <= I <= +65536 , IT IS STORED  IN  D'E'  FOR INSERTION INTO
2E01			  ; THE PRINT BUFFER;
2E01			  ;
2E01 EF 		  PF_LOOP:	RST   28H		      ; USE THE CALCULATOR AGAIN
2E02 31 				DEFB  031H		      ; DUPLICATE	 X',X'
2E03 27 				DEFB  027H		      ; INT		 X', INT (X') =  I
2E04 C2 				DEFB  0C2H		      ; ST_MEM_2	 (I IS STORED IN MEM_2)
2E05 03 				DEFB  003H		      ; SUBSTRACT	 X'-I=F
2E06 E2 				DEFB  0E2H		      ; GET_MEM_2	  F,I
2E07 01 				DEFB  001H		      ; EXCHANGE	  I, F
2E08 C2 				DEFB  0C2H		      ; ST_MEM_2	  F IS STORED IN MEM_2
2E09 02 				DEFB  002H		      ; DELETE		  I
2E0A 38 				DEFB  038H		      ; END_CALC	  I
2E0B 7E 				LD    A,(HL)		      ; IS I A SMALL INTEGER (FIRST BYTE ZERO)
2E0C A7 				AND   A 		      ;  I.E. IS ABS  I <= 65535   ?
2E0D 2047				JR    NZ,PF_LARGE	      ;  JUMP IF IT IS NOT.
2E0F CD7F2D				CALL  INT_FETCH 	      ;  I IS COPIED TO DE (I LIKE X'>=0)
2E12 0610				LD    B,010H		      ;  B IS SET TO COUNT 16 BITS.
2E14 7A 				LD    A,D		      ;  D IS COPIED TO A FOR TESTING:
2E15 A7 				AND   A 		      ;  IS IT ZERO?
2E16 2006				JR    NZ,PF_SAVE	      ;  JUMP IF IT IS NOT ZERO.
2E18 B3 				OR    E 		      ;  NOW TEST E.
2E19 2809				JR    Z,PF_SMALL	      ;  JUMP IF DE ZERO: X IS A PURE FRACTION.
2E1B 53 				LD    D,E		      ;  MOVE E TO D AND SET B FOR 8 BITS :
2E1C 0608				LD    B,8		      ;  D WAS ZERO AND E WAS NOT.
2E1E D5 		  PF_SAVE:	PUSH  DE		      ;  TRANSFER DE TO D'E' , VIA THE MACHINE
2E1F D9 				EXX			      ;  STACK, TO BE MOVED INTO THE PRINT BUFFER
2E20 D1 				POP   DE		      ;  AT PF_BITS.
2E21 D9 				EXX			      ;
2E22 1857				JR    PF_BITS		      ; JUMP FORWARD.
2E24			  ;
2E24			  ;  3.  PURE	FRACTIONS   ARE   MULTIPLYED   BY  10^N  ,  WHERE  N  IS
2E24			  ; APPROXIMATE  NUMBER OF LEADING ZEROES  AFTER  THE  DECIMAL ; AND  -N
2E24			  ; IS	ADDED TO  THE SECOND BYTE  OF  MEM-5, WHICH  HOLDS THE NUMBER OF
2E24			  ; DIGIT BEFORE  THE DECIMAL; A NEGATIVE NUMBER  HERE INDICATES LEADING
2E24			  ; ZEROES  AFTER  THE DECIMAL ;
2E24			  ;
2E24 EF 		  PF_SMALL:	RST   28H		      ;        I (I=ZERO HERE)
2E25 E2 				DEFB  0E2H		      ; GET_MEM_2      I,F
2E26 38 				DEFB  038H		      ; END CALC
2E27			  ; !!!???!!!
2E27			  ; NOTE THAT THE STACK IS NOW UNBALANCED. AN EXTRA BYTE  DEFB 02H-DELETE
2E27			  ; IS PLACED AT 2E25,IMMIDIATELY AFTER THE RST 0028. NOW AN EXPRESSION
2E27			  ; LIKE  "2" + STR$ 0.5 IS EVALUATED INCORRECTLY AS 0 5; THE ZERO LEFT
2E27			  ; ON THE  STACK REPLACES THE "2" AND IS USED AS A NULL STRING.SIMILARY ALL
2E27			  ; THE STRING COMPARISONS WILL GIVE INCORRECT VALUES IF THE SECOND STRING TAKE
2E27			  ; FORM STR$ X WHERE X IS NUMERICALLY LESS THEN 1; E.G. THE EXPRESSION
2E27			  ; "50" < STR$0.1 YIELDS THE LOGICAL VALUE 'TRUE' , ONCE AGAIN "" IS USED
2E27			  ; INSTEAD OF "50".
2E27			  ;
2E27 7E 				LD    A,(HL)		      ;  THE EXPONENT BYTE OF F IS COPIED TO A
2E28 D67E				SUB   07EH		      ;   A BECOMES E-126 DEC I.E ??-2 WHERE
2E2A					;			      ; E' IS THE TRUE EXPONENT OF F.
2E2A CDC12D				CALL  LOG_2A		      ; THE CONSTRUCTION A=ABS INT (LOG(2**A)) IS
2E2D					;			      ; PERFORMED (LOG IS TO BASE 10) ,I.E. A=N
2E2D 57 				LD    D,A		      ; N IS COPIED FROM A TO D
2E2E 3AAC5C				LD    A,(MEMBOT+1AH)	      ; THE CURRENT COUNT IS COLLECTED
2E31 92 				SUB   D 		      ; FROM THE SECOND BYTE OF MEM_5
2E32 32AC5C				LD    (MEMBOT+1AH),A	      ; AND N IS SUBSTACTED FROM IT.
2E35 7A 				LD    A,D		      ; N IS COPIED FROM D TO A
2E36 CD4F2D				CALL  E_TO_FP		      ; 10**N IS FORMED AND STACKED.
2E39 EF 				RST   28H		      ;
2E3A 31 				DEFB  031H		      ; DUPLICATE     ?  Y
2E3B 27 				DEFB  027H		      ; INT		 Y Y
2E3C C1 				DEFB  0C1H		      ; ST_MEM_1	 INT(Y) = I2
2E3D 03 				DEFB  003H		      ; SUBSTRACT
2E3E E1 				DEFB  0E1H		      ; GET_MEM_1	  I2 I2
2E3F 38 				DEFB  038H		      ; END_CALC	      F2=Y*I2
2E40					;			      ;
2E40 CDD52D				CALL  FP_TO_A		      ; I2 IS TRANSFERED FROM THE STACK TO A
2E43 E5 				PUSH  HL		      ; THE POINTER TO F2 IS SAVED
2E44 32A15C				LD    (MEMBOT+0FH),A	      ; I2 IS STORED IN THE FIRST BYTE OF MEM_3:
2E47					;			      ; A DIGIT FOR PRINTING.
2E47 3D 				DEC   A 		      ; I2 WILL NOT COUNT AS A DIGIT FOR PRINTING
2E48 17 				RLA			      ; IF IT IS ZERO ; A IS MANIPULATED SR THAT
2E49 9F 				SBC   A,A		      ; ZERO WILL PRODUCE ZERO BUN NON-ZERO
2E4A 3C 				INC   A 		      ; PRODUCE 1.
2E4B 21AB5C				LD    HL,MEMBOT+19H	      ; ZERO OR ONE IS INSERTED THE FIRST BYTE OF MEM_5
2E4E 77				LD    (HL),A		      ; (NO DIGITS FOR PRINTING) AND ADDED
2E4F 23 				INC   HL		      ; TO THE SECOND BYTE Om MEM_5
2E50 86 				ADD   A,(HL)		      ; (THE NUMBER OF DIGITS BEFORE THE DECIMAL)
2E51 77 				LD    (HL),A		      ;
2E52 E1 				POP   HL		      ; THE POINTER TO F2 IS RESTRORED.
2E53 C3CF2E				JP    PF_FRACTN 	      ; JUMP TO STORE F2 IF BUFFER (HL NOW POINTS
2E56					;			      ; TO F2 , DE TO I2.
2E56			  ;
2E56			  ; 4.	NUMBERS GREATER THAN 2^27 ARE SIMILARY MULTIPLIES BY  2^(-N+7),
2E56			  ; REDUCIING  THE NUMBER OF DIGITS BEFORE THE DECIMAL TO 8, AND
2E56			  ; THE  LOOP  X  RE-ENTERED  AT  PF-LOOP.
2E56			  ;
2E56 D680		  PF_LARGE:	SUB   080H		      ; A-80H=E': THE TRUE EXPONENT OF 1.
2E58 FE1C				CP    01CH		      ; E' LESS THAN 28 DECIMAL ?
2E5A 3813				JR   C,PF_MEDIUM	      ;  JUMP IF IT IS LESS
2E5C CDC12D				CALL  LOG_2A		      ;  N IS FORMED IN A
2E5F D607				SUB   007H		      ;  N REDUCED TO N-7
2E61 47 				LD    B,A		      ; THEN COPIED TO B
2E62 21AC5C				LD    HL,MEMBOT+1AH	      ; N-7 IS ADDED IN TO THE SECOND BYTE OF
2E65 86 				ADD   A,(HL)		      ; OF MEM_5, THE NUMBER LF DIGITS REQUARED
2E66 77 				LD    (HL),A		      ; BEFORE THE DECIMAL IN X.
2E67 78 				LD    A,B		      ; THE I IS MULTIPLIED BY 10**(-N+7).
2E8 ED44				NEG			      ; THIS WILL BRING IT INTO MEDIUM RANGE
2E6A CD4F2D				CALL  E_TO_FP		      ; FOR PRINTING.
2E6D 1892				JR    PF_LOOP		      ;  ROUND THE LOOP AGAIN TO DEAL WITH THE
2E6F					;			      ; NOW MEDIUM-SIZED NUMBER.
2E6F			  ;
2E6F			  ; 5.	THE  INTEGER PART OF X IS NOW STORED IN THE PRINT BUFFER IN
2E6F			  ; MEM-3  AND	MEM-4.
2E6F			  ;
2E6F EB 		  PF_MEDIUM:	EX    DE,HL		      ;  DE NOW POINTS TO I , HL TO F
2E70 CDBA2F				CALL  FETCH_TWO 	      ; THE MANTISSA OF I IS NOW IN D',E', D, E.
2E73 D9 				EXX			      ; GET THE EXCHANGE REGISTERS.
2E74 CBFA				SET  7,D		     ; TRUE NUMERICAL BIT 7 TO D'.
2E76 7D 				LD    A,L		      ; EXPONENT  BYTE E OF I TO A.
2E77 D9 				EXX			      ; BACK TO THE MAIN REGISTERS.
2E78 D680				SUB   080H		      ; TRUE EXPONENT E' = E-80H TO A
2E7A 47 				LD    B,A		      ; THIS GIVES THE	REQUARED BIT COUNT.
2E7B			  ;				    ;
2E7B			  ; NOTE THAT THE CASE WHERE I US A SMALL INTEGER (LESS THEN 65535)
2E7B			  ; RE-ENTERED HERE.
2E7B			  ;
2E7B CB23		  PF_BITS:	SLA   E 		      ; THE MANTISSA OF I NOW ROTATED LEFT AND
2E7D CB12				RL    D 		      ; ALL THE BITS OF I ARE THUS SHIFTED INTO
2E7F D9 				EXX			      ; MEM_4 AND EACH BYTE OF MEM_4 IS DECIMAL
2E80 CB13				RL    E 		      ; ADJUSTED AT EACH SHIFT.
2E82 CB12				RL    D 		      ; ALL FOUR BYTES FOR I.
2E84 D9 				EXX			      ; BACK TO THE MAIN REGISTERS.
2E85 21AA5C				LD    HL,MEMBOT+18H	      ;  ADDRESS OF 5TH BYTE OF MEM_4 TO HL;
2E88 0E05				LD    C,005H		      ; COUNT OF 5 BYTES TO C.
2E8A 7E 		  PF_BYTES:	LD    A,(HL)		      ; GET THE BYTE OF MEM_4.
2E8B 8F 				ADC   A,A		      ; SHIFT IT LEFT , TAKING IN THE NEW BIT.
2E8C 27 				DAA		      ; DECIMAL ADJUST THE BYTE.
2E8D 77 				LD    (HL),A		      ; RESTORE IT TO MEM_4
2E8E 2B 				DEC   HL		      ; POINT TO THE NEXT BYTE OF MEM_4.
2E8F 0D 				DEC   C 		      ; DECREASE BYTE COUNT BY 1.
2E90 20F8				JR    NZ,PF_BYTES	      ;  JUMP FOR EACH BYTE OF MEM_4.
2E92 10E7				DJNZ  PF_BITS		      ;  JUMP FOR EACH BIT OF INT(X).
2E94			  ;
2E94			  ; DECIMAL  ADJUSTING	EACH BYTE  OF MEM-4  GAVE  2  DECIMAL DIGITS PER
2E94			  ; BYTE, THERE  BEING	AT  MOST  9  DIGITS.  THE  DIGITS  WILL  NOW  BE
2E94			  ; RE-PACKED, ONE TO A  BYTE, IN MEM-3 AND MEM-4, USING THE INSTRUCTION
2E94			  ; RLD.
2E94 AF 				XOR   A 		      ; A IS CLEARED TO RECEIVE THE DIGITS.
2E95 21A65C				LD    HL,MEMBOT+14H	      ; SOURCE ADDRESS : FIRST BYTE OF MEM_4.
2E98 11A15C				LD    DE,MEMBOT+0FH	      ; DESTINATION: FIRST BYTE OF MEM_3.
2E9B 0609				LD    B,009H		      ; THERE ARE AT MOST 9 DIGITS.
2E9D ED6F				RLD			      ; THE LEFT NIBBLE OF MEM_4 IS DISCARDED.
2E9F 0EFF				LD    C,0FFH		      ; FF IN C WILL SIGANL A LEADING ZERO ,
2EA1					;			      ; 0  WILL SIGNAL A NON-LEADING ZERO.
2EA1 ED6F		  PF_DIGITS:	RLD			      ; LEFT NIBBLE OF (HL) TO A, RIGHT NIBBLE
2EA3					;			      ; OF (HL) TO LEFT.
2EA3 2004				JR    NZ,PF_INSERT	      ; JUMP IF DIGIT IN A IS NOT ZERO.
2EA5 0D 				DEC   C 		      ; TEST FOR A LEADING ZERO :
2EA6 0C 				INC   C 		      ; IT WILL NOW GIVE ZERO RESET.
2EA7 200A				JR    NZ,PF_TEST_2	      ; JUMP IF IT WAS A LEADING ZERO.
2EA9 12 		  PF_INSERT:	LD    (DE),A		      ;  INSERT THE DIGIT NOW.
2EAA 13 				INC   DE		      ; POINT TO NEXT DESTINATION.
2EAB FD3471				INC   (IY+MEMBOT+19H-YBASE)   ; ONE MORE DIGIT FOR PRINTING ,
2EAE FD3472				INC   (IY+MEMBOT+1AH-YBASE)   ;AND ONE MORE BEFORE THE DECIMAL.
2EB1 0E00				LD    C,0		      ; CHANGE THE FLAG FROM LEADING
2EB3					;			      ; ZERO TO OTHER ZERO.
2EB3 CB40		  PF_TEST_2:	BIT  0,B		      ; THE SOURCE POINTER NEEDS TO BE
2EB5 2801				JR    Z,PF_ALL_9	      ; INCREMENTED ON EVERY SECOND
2EB7 23 				INC   HL		      ;  PASSAGE THROUGHT THE LOOP, WHEN B IS ODD.
2EB8 10E7		  PF_ALL_9:	DJNZ  PFDIGITS 	      ; JUMP BACK FOR ALL 9 DIGITS.
2EBA 3AAB5C				LD    A,(MEMBOT+19H)	      ; GET COUNTER : WERE THERE 9 DIGITS.
2EBD D609				SUB   009H		      ; EXCLUDING LEADING ZEROS?
2EBF 380A				JR    C,PF_MORE 	      ; IF NOT , JUMP TO GET MORE DIGITS.
2EC1 FD3571				DEC   (IY+MEMBOT+19H-YBASE)   ;  PREPARE TO ROUND : REDUCE COUNT
2EC4					;			      ; TO 8.
2EC4 3E04				LD    A,004H		      ; COMPRARE 9 DIGIT, BYTE 4 OF MEM_4, WITH 4
2EC6 FDBE6F				CP    (IY+MEMBOT+17H-YBASE)   ; TO SET CARRY FOR ROUNDING UP.
2EC9 1841				JR    PF_ROUND		      ; JUMP FORWARD TO ROUND UP.
2ECB EF 		  PF_MORE:	RST   28H		      ;  USE THE CALLCULATOR AGAIN.
2ECC 02 				DEFB 002H		      ; DELETE		 (I IS NOW DELETED)
2ECD E2 				DEFB 0E2H		      ; GET_MEM_2	  F
2ECE 38 				DEFB 038H		      ; EN_CALC 	  F
2ECF			  ;
2ECF			  ; 6.	THE  FRACTIONAL  PART  OF  X IS NOW STORED IN THE PRINT  BUFFER.
2ECF			  ;
2ECF EB 		  PF_FRACTN:	EX    DE,HL		      ;  DE NOW POINTS TO F.
2ED0 CDBA2F				CALL  FETCH_TWO 	      ;  THE MANTISSA OF F IS NOW IN
2ED3					;			      ; D', E', D, E.
2ED3 D9 				EXX			      ; GET THE EXCHANGE REGISTERS.
2ED4 3E80				LD    A,80H		      ; THE EXPONENT OF F IS REDUCED TO
2ED6 95 				SUB   L 		      ; ZERO , BY SHIFTING THE BITS OF F
2ED7 2E00				LD    L,0		      ; 80H -E PLACES RIGHT, WHERE L'
2ED9					;		      ; CONTAINED E.
2ED9 CBFA				SET  7,D		      ; TRUE NUMERICAL BIT TO BIT 7 OF	D'
2EDB D9 				EXX			      ; RESTORE THE MAIN REGISTERS.
2EDC CDDD2F				CALL  SHIFT_FP		      ; NOW MAKE THE SHIFT.
2EDF FD7E71		  PF_FRN_LP:	LD    A,(IY+MEMBOT+19H-YBASE);; GET THE DIGIT COUNT .
2EE2 FE08				CP    008H		      ; 	    ; ARE THERE ALREADY 8 DIGITS ?
2EE4 3806				JR    C,PF_FR_DGT	      ; IF NOT , JUMP FORWARD.
2EE6 D9 				EXX			      ; IF 8 DIGIST , JUST USE F TO ROUND I
2EE7 CB12				RL    D 		      ; UP ROTATING D' LEFT TO SET THE CARRY
2EE9 D9 				EXX			      ; RESTORE THE MAIN REGISTERS AND JUMP
2EEA 1820				JR    PF_ROUND		      ; FORWARD TO ROUND UP.
2EEC 010002		  PF_FR_DGT:	LD    BC,00200H 	      ; INITIAL ZERO TO C, COUNT OF 2 TO B.
2EEF 7B 		  PF_FR_EXX:	LD    A,E		      ; D'E'DE IS MULTIPLIED BY 10 IN 2
2EF0 CD8B2F				CALL  CA_10A_C		      ; STAGES,FIRST DE THEN D'E', EACH
2EF3 5F 				LD    E,A		      ; BYTE BY BYTE IN 2 STEPS, AND THE
2EF4 7A 				LD    A,D		      ; INTEGER PART OF THE RESULT IS
2EF5 CD8B2F				CALL  CA_10A_C		      ; OBTAINED IN C TO BE PASSED INTO
2EF8 57 				LD    D,A		      ; THE PRINT BUFFER .
2EF9 C5 				PUSH  BC		      ; THE COUNT AND THE RESULT ALTERNATE
2EFA D9 				EXX			      ; BETWEEN BC AND B'C'.
2EFB C1 				POP   BC		      ;
2EFC 10F1				DJNZ  PF_FR_EXX 	      ; LOOK BACK ONCE THROUGH THE EXCHANGE
2EFE					;			      ; REGISTERS.
2EFE 21A15C				LD    HL,MEMBOT+0FH	      ; THE START 1ST BYTE  OF MEM_3.
2F01 79 				LD    A,C		      ; RESULT TO A FOR STORING.
2F02 FD4E71				LD    C,(IY+MEMBOT+19H-YBASE);; COUNT OF DIGITS SO FAR IN NUMBER
2F05					;			      ; TO C.
2F05 09 				ADD   HL,BC		      ; ADDRESS THE FIRST EMPTY BYTE.
2F06 77 				LD    (HL),A		      ; STORE THE NEXT DIGIT.
2F07 FD3471				INC   (IY+MEMBOT+19H-YBASE)   ; STEP UP THE COUNT OF DIGITS.
2F0A 18D3				JR    PF_FRN_LP 	      ; LOOP BACK UNTIL THERE ARE 'B'
2F0C					;			      ; DIGITS.
2F0C			  ;
2F0C			  ; 7.	THE DIGITS STORED IN THE PRINT BUFFER  ARE  ROUNDED TO A MAXIMUM
2F0C			  ; OF 8 DIGITS FOR PRINTING.
2F0C			  ;
2F0C F5 		  PF_ROUND:	PUSH  AF		      ; SAVE THE CARRY FLAG FOR THE
2F0D					;			      ; ROUTINING.
2F0D 21A15C				LD    HL,MEMBOT+0FH	      ; BASE ADDRESS OF NUMBER: MEM-3,
2F10					;			      ; BYTE 1.
2F10 FD4E71				LD    C,(IY+MEMBOT+19H-YBASE) ; OFFSET (NUMBER OF DIGITS IN
2F13 0600				LD    B,0		      ; NUMBER ) TO 'BC'.
2F15 09 				ADD   HL,BC		      ; ADDRESS THE LAST BYTE OF THE
2F16					;			      ; NUMBER.
2F16 41 				LD    B,C		      ; COPY 'C' TO 'B' AS THE COUNTER.
2F17 F1 				POP   AF		      ; RESTORE THE CARRY FLAG.
2F18 2B 		  PF_RND_LP:	DEC   HL		      ; THIS IS THE LAST BYTE OF THE
2F19					;			      ; NUMBER.
2F19 7E 				LD    A,(HL)		      ; GET THE BYTE INTO 'A'.
2F1A CE00				ADC   A,0		      ; ADD IN THE CARRY I.E. ROUND UP.
2F1C 77 				LD    (HL),A		      ; STORE THE ROUNDED BYTE IN THE
2F1D					;			      ; BUFFER.
2F1D A7 				AND   A 		      ; IF THE BYTE IS 0 OR 10.'B' WILL BE
2F1E 2805				JR    Z,PF_R_BACK	      ; DECREMENTED AND THE FINAL ZERO
2F20 FE0A				CP    00AH		      ; (OR THE 10) WILL NOT BE COUNTED
2F22					;			      ; FOR PRINTING.
2F22 3F 				CCF			      ; RESET THE CARRY FOR A VALID DIGIT.
2F23 3008				JR    NC,PF_COUNT	      ; JUMP IF CARRY RESET.
2F25 10F1		  PF_R_BACK:	DJNZ  PF_RND_LP 	      ; JUMP BACK FOR MORE ROUNDING
2F27					;			      ; OR MORE FINAL ZEROS.
2F27 3601				LD    (HL),001H 	      ; THERE IS OVERFLOW TO THE  LEFT;
2F29 04 				INC   B 		      ; AN EXTRA 1 IS NEEDED HERE.
2F2A FD3472				INC   (IY+MEMBOT+1AH-YBASE)   ; IT IS ALSO AN EXTRA DIGIT
2F2D					;			      ; BEFORE DECIMAL.
2F2D FD7071		  PF_COUNT:	LD    (IY+MEMBOT+19H-YBASE),B ; 'B' NOW SETS THE COUNT OF THE
2F30					;			      ; DIGITS TO BE PRINTED (FINAL ZEROS
2F30					;			      ; WILL NOT BE PRINTED.)
2F30 EF 				RST   28H		      ; 'F' IS TO BE DELETED.
2F31 02 				DEFB 002H		      ; DELETE
2F32 38 				DEFB 038H		      ; END-CALC
2F33 D9 				EXX			      ; THE CALCULATOR OFFSET SAVED ON
2F34 E1 				POP   HL		      ; THE STACK IS RESTORED TO 'H'L'.
2F35 D9 				EXX
2F36			  ;
2F36			  ; 8.	THE NUMBER  CAN  NOW  BE PRINTED.  FIRST  C WILL BE SET TO HOLD
2F36			  ; THE NUMBER OF DIGITS  WILL BE  PRINTED, NOT COUNTING  FINAL  ZEROES,
2F36			  ; WHILE  B WILL HOLD THE NUMBER OF DIGITS REQUIRED BEFORE THE DECIMAL.
2F36			  ;
2F36 ED4BAB5C				LD    BC,(MEMBOT+19H)	      ; THE COUNTERS ARE SET.
2F3A 21A15C				LD    HL,MEMBOT+0FH	      ; THE SART OF THE DIGITS.
2F3D 78 				LD    A,B		      ; IF MORE THAN 9, OR FEWER THAN
2F3E FE09				CP    009H		      ; MINUS 4, DIGITS ARE REQUIRED
2F40 3804				JR    C,P_NOT_E 	      ; BEFORE THE DECIMAL,THEN 'E-FORMAT'
2F42					;			      ; WILL BE NEEDED.
2F42 FEFC				CP    0FCH		      ; FEWER THAN 4 MEANS MORE THAN
2F44 3826				JR    C,PF_E_FRMT	      ; 4 LEADING ZEROS AFTER THE DECIMAL.
2F46 A7 		  P_NOT_E:	AND   A 		      ; ARE THERE NO DIGIT BEFORE THE
2F47 CCEF15				CALL  Z,OUT_CODE	      ; DECIMAL? IF SO,PRINT AN INITIAL
2F4A					;			      ; ZERO.
2F4A			  ;
2F4A			  ; THE NEXT ENTRY POINT IS ALSO USED TO PRINT THE DIGITS NEEDED FOR
2F4A			  ; E-FORMAT  PRINTING.
2F4A			  ;
2F4A AF 		  PF_E_SBRN:	XOR   A 		      ; START BY SETTING 'A' TO ZERO.
2F4B 90 				SUB   B 		      ; SUBTRCT 'B' MIUS WILL MEAN
2F4C FA522F				JP    M,PF_OUT_LP	      ; THERE ARE DIGITS BEFORE THE
2F4F					;			      ; DECIMAL;JUMP FORWARD TO PRINT
2F4F					;			      ; THEM.
2F4F 47 				LD    B,A		      ; 'A' IS NOW REQUIRED AS A COUNTER.
2F50 180C				JR    PF_DC_OUT 	      ; JUMP FORWARD TO PRINT THE
2F52					;			      ; DECIMAL PART.
2F52 79 		  PF_OUT_LP:	LD    A,C		      ; COPY THE NUMBER OF DIGITS TO BE
2F53 A7 				AND   A 		      ; PRITED TO 'A'.IF 'A' IS 0 THERE ARE
2F54 2803				JR    Z,PF_OUT_DT	      ; STILL FINAL ZEROS TO PRINT ('B' IS
2F56					;			      ; NON-ZERO),SO JUMP.
2F56 7E 				LD    A,(HL)		      ; GET A DIGIT FROM THE POINT BUFFER.
2F57 23 				INC   HL		      ; POINT TO THE NEXT DIGIT.
2F58 0D 				DEC   C 		      ; DECREASE THE COUNT BY ONE.
2F59 CDEF15		  PF_OUT_DT:	CALL  OUT_CODE		      ; PRINT THE APPROPRIATE DIGIT.
2F5C 10F4				DJNZ  PF_OUT_LP 	      ; LOOP BACK UNTIL 'B' IS ZERO.
2F5E 79 		  PF_DC_OUT:	LD    A,C		      ; IT IS TIME TO PRINT THE DECIMAL,
2F5F A7 				AND   A 		      ; UNLESS 'C' IS NOW ZERO; IN THAT
2F60 C8 				RET   Z 		      ; CASE, RETURN - FINISHED.
2F61 04 				INC   B 		      ; ADD 1 TO 'B' - INCLUDE THE
2F62					;			      ; DECIMAL.
2F62 3E2E				LD    A,02EH		      ; PUT THE CODE FOR '.' INTO 'A'.
2F64 D7 		  PF_DEC_0S:	RST   WR_SCRN		      ; PRINT THE '.'.
2F65 3E30				LD    A,030H		      ; ENTER THE CHARACTER CODE FOR '0'.
2F67 10FB				DJNZ  PF_DEC_0S 	      ; LOOP BACK TO PRINT ALL NEEDED
2F69					;			      ; ZEROS.
2F69 41 				LD    B,C		      ; SET THE COUNT FOR ALL REMAINING
2F6A					;			      ; DIGITS.
2F6A 18E6				JR    PF_OUT_LP 	      ; JUMP BACK TO PRINT THEM.
2F6C 50 		  PF_E_FRMT:	LD    D,B		      ; THE COUNT OF DIGITS IS COPIED
2F6D					;			      ; TO 'D'.
2F6D 15 				DEC   D 		      ; IT IS DECREMENTED TO GIVE THE
2F6E					;			      ; EXPONENT.
2F6E 0601				LD    B,001H		      ; ONE DIGIT IS REQUIRED BEFORE THE
2F70					;			      ; DECIMAL IN 'E-FORMAT'.
2F70 CD4A2F				CALL  PF_E_SBRN 	      ; ALL THE PART OF THE NUMBER
2F73					;			      ; BEFORE	THE 'E' IS NOW PRINTED.
2F73 3E45				LD    A,045H		      ; ENTER THE CHARACTER CODE FOR 'E'.
2F75 D7 				RST   WR_SCRN		      ; PRINT THE 'E'.
2F76 4A 				LD    C,D		      ; EXPONENT TO 'C' NOW FOR PRINTING.
2F77 79 				LD    A,C		      ; AND TO 'A' FOR TESTING.
2F78 A7 				AND   A 		      ; ITS SIGN IS TESTED.
2F79 F2832F				JP    P,PF_E_POS	      ; JUMP IF IT IS POSITIVE
2F7C ED44				NEG			      ; OTHERWISE, NEGATE IT IN 'A'.
2F7E 4F 				LD    C,A		      ; THEN COPY IT BACK TO 'C' FOR
2F7F					;			      ; PRINTING.
2F7F 3E2D				LD    A,02DH		      ; ENTER THE CHARACTER CODE FOR '-'.
2F81 1802				JR    PF_SIGN		      ; JUMP TO PRINT THE SIGN.
2F83 3E2B		  PF_E_POS:	LD    A,02BH		      ; ENTER THE CHARACTER CODE FOR '+'.
2F85 D7 		  PF_SIGN:	RST   WR_SCRN		      ; NOW PRINT THE SING:'+' OR '-'.
2F86 0600				LD    B,0		      ; 'BC' HOLDS THE EXPONENT FOR
2F88					;			      ; PRINTING.
2F88 C31B1A				JP    OUT_NUM1		      ; JUMP BACK TO PRINT IT AND FINISH.
2F8B			  ;
2F8B			  ; THE ' CA=10*A+C ' SUBROUTINE
2F8B			  ; THIS  SUBROUTINE IS CALLED BY THE 'PRINT_FP' SUBROUTINE  TO MULTIPLY
2F8B			  ; EACH BYTE OF   D'E'DE   BY	10 AND RETURN THE INTEGER  AND RETURN
2F8B			  ; THE INTEGER PART OF THE REZULT IN THE  C  REGISTER. ON ENTRY,
2F8B			  ; THE  A  REGISTER CONTAINS THE BYTE TO BE MULTIPLIED BY  10 AND
2F8B			  ; THE C REGISTER CONTAINS THE CARRY OVER FROM THE PREVIOUS BYTE.
2F8B			  ; ON RETURN, THE A REGISTER CONTAINS THE REZULTING BYTE AND THE C
2F8B			  ; REGISTER  THE CARRY FORWARD TO THE NEXT BYTE.
2F8B			  ;
2F8B D5 		  CA_10A_C:	PUSH  DE		      ; SAVE WHICHEVER 'DE' PAIR IS IN USE.
2F8C 6F 				LD    L,A		      ; COPY THE MULTIPLICAND FROM 'A'
2F8D 2600				LD    H,0		      ; TO 'HL'.
2F8F 5D 				LD    E,L		      ; COPY IT TO 'DE' TOO.
2F90 54 				LD    D,H
2F91 29 				ADD   HL,HL		      ; DOUBLE 'HL'.
2F92 29 				ADD   HL,HL		      ; DOUBLE IT AGAIN.
2F93 19 				ADD   HL,DE		      ; ADD IN 'DE' TO GIVE 'HL'=5'A.
2F94 29 				ADD   HL,HL		      ; DOUBLE AGAIN: NOW 'HL'=10'A.
2F95 59 				LD    E,C		      ; COPY 'C' TO 'DE' (D IS ZERO)FOR
2F96					;			      ; ADDITION.
2F96 19 				ADD   HL,DE		      ; NOW 'HL'=10'A+C.
2F97 4C 				LD    C,H		      ; 'H' IS COPIED TO 'C'.
2F98 7D 				LD    A,L		      ; 'L' IS COPIED TO 'A',COMPLETING
2F99					;			      ; THE TASK.
2F99 D1 				POP   DE		      ; THE 'DE' REGISTER PAIR IS RESTORED.
2F9A C9 				RET			      ; FINISHED.
2F9B			  ;

                                        