*  PROGRAM:  TERM II OVERLAY (TERMOVR.ASM)
*  AUTHOR:  RICHARD CONN
*  VERSION:  4.7
*  DATE:  6 JUL 81
*  PREVIOUS VERSIONS:  1.0 (11 MAY 81)
*			4.4 (15 JUN 81), 4.5 (20 JUN 81), 4.6 (26 JUN 81)

VERS	equ	47	; Version Number

*  THE FOLLOWING EQUATE SHOULD BE CHANGED IF YOU DO NOT HAVE A STANDARD
*    (ORG 0) CP/M SYSTEM

CPM$BASE	EQU	0	; BASE OF CP/M

OVR$START	EQU	CPM$BASE+6000H	; START OF OVERLAY AREA

*
**** Structure of the Overlay ****
*
*    Section	Title/Function
*
*	0	JUMP Tables for Entry into the Main Body of TERM II
*
*	1	Overlay Initialization Routine
*
*	2	Telephone Directory Editor
*		This section contains the program and routines used to perform
*		 the following functions with the Telephone Directory of
*		 TERM II:
*			. Add a number to the directory (up to 10 entries)
*			. Delete a number from the directory
*			. Initialize the directory (delete all numbers)
*			. Quit and exit to the Telephone Subsystem without
*				making a permanent change to the directory
*			. Exit and update the directory on disk; exit is done
*				to the Telephone Subsystem
*		 This section contains one entry point, PH$EDIT.  It contains
*		 the following section-specific routines:
*			PRINT$PHONE$NUMBERS
*				Display the Telephone Directory on CON:
*			PH$EDIT$ABORT
*				Quit and exit to the telephone system; no
*				change to the directory on disk
*			PH$EDIT$EXIT
*				Quit and exit to the telephone system; change
*				the directory on disk
*			WRITE$TERM$TO$DISK
*				Write Binary Image of TERM to Disk
*			TERM$REWRITE
*				Routine to write 128 bytes to disk
*			PH$EDIT$LOAD
*				Read/Write Directory From/To Disk
*			PH$EDIT$INIT
*				Initialize the directory
*			PH$EDIT$DELETE
*				Delete an entry from the directory
*			PH$EDIT$ADD
*				Add an entry to the directory
*
*	3	Status Flag Editor
*			STATUS$BUILDER
*				Status Flag Editor
*			  SB$EXIT
*				Exit and update TERM II on disk
*			  SB$QUIT
*				Exit and do not update TERM II on disk
*			  SB$SET
*				Set specific flags
*
*	4	Translation Table Builder
*			XLATE$BUILD
*				Initialize Workspace and Enter Translation
*				Table Editor
*			XLATE$BUILDER
*				Enter Translation Table Editor
*			  XL$EXIT
*				Exit and update TERM II on disk
*			  XL$QUIT
*				Exit and do no update TERM II on disk
*			  XL$INIT
*				Initialize Workspace
*			  XL$COPY
*				Copy Workspace To/From Translation Tables
*			  XL$SET
*				Change selected entries in workspace
*			    XL$LINE
*				Print an entry
*			    XL$OUTPUT
*				XLATE$BUILDER output routine
*			    XL$INDEX
*				XLATE$BUILDER index table search
*			    XL$INPUT
*				XLATE$BUILDER input routine
*			  XL$DISP
*				Display all of workspace
*			  XL$LOAD
*				Load workspace to/from disk
*			    XL$LOAD$PUT
*				Load workspace to disk
*			    XL$LOAD$GET
*				Load workspace from disk
*			  XL$LOADER
*				Load Translation Tables from Disk
*			    READ$512$FILE
*				Read 512-byte File from Disk to buffer pted
*				to by HL
*			  XL$PUT
*				Load Translation Tables to Disk
*			    CREATE$512$FILE
*				Write 512-byte File to Disk from buffer pted
*				to by HL
*
*	5	Overlay Support Routines
*		  These routines include:
*			PS$ON - Print ON Message
*			PS$OFF - Print OFF Message
*			CRLF - Output CRLF
*			HEX$OUT - Output value in Reg A as two Hex chars
*
*	6	Command Tables
*
*	7	Buffers
*

	ORG	OVR$START


*
*  SPECIAL EQUATES
*
LPS	EQU	24-1	; NUMBER OF LINES ON CRT - 1

*
*  ASCII EQUATES
*
ESC	EQU	1BH
CR	EQU	0DH
LF	EQU	0AH
BEL	EQU	07H
CTRLC	EQU	'C'-'@'

*
*  CP/M EQUATES
*
BDOS	EQU	5
CREAD	EQU	10


*
*: TERM II, Overlay Section 0
*  JUMP Tables for addressing by TERM II and addressing into TERM II

*
*  JUMP TABLE FOR ADDRESSING BY TERM II
*
JMP	OVERLAY$INIT		; INITIALIZE OVERLAY
JMP	XLATE$BUILD		; TRANSLATION TABLE BUILDER
JMP	STATUS$BUILDER		; STATUS FLAG BUILDER
JMP	PH$EDIT			; TELEPHONE DIRECTORY EDITOR

*
*  JUMP TABLE FOR ADDRESSING INTO TERM II
*
BASE	EQU	CPM$BASE+103H	; BASE OF JUMP TABLE

*  TEXIT ENTRIES
TEXIT:
	JMP	BASE
TEXIT0:
	JMP	BASE+3

*  CHARACTER I/O ENTRIES
OUT$CON:
	JMP	BASE+6
IN$CON1:
	JMP	BASE+9
PRINT$CONTROL$CHAR:
	JMP	BASE+12
C1$FLUSH:
	JMP	BASE+15
GET$RESPONSE:
	JMP	BASE+18
IC$MSG:
	JMP	BASE+21
PRINT$MESSAGE:
	JMP	BASE+24
PRINT$ERROR$MESSAGE:
	JMP	BASE+27
CLEAR$ERROR$MESSAGE:
	JMP	BASE+30
SCREEN$MESSAGE:
	JMP	BASE+33
PRINT$CINDEX:
	JMP	BASE+36
SCREEN$CLEAR:
	JMP	BASE+39
PRINT$ID:
	JMP	BASE+42

*  SPECIAL MESSAGES
EXITCHMS:
	JMP	BASE+45
BREAKMS:
	JMP	BASE+48
PR$INIT$CMND:
	JMP	BASE+51
PR$TERM$ENTRY:
	JMP	BASE+54
PRSPDMS:
	JMP	BASE+57
ECHOMS:
	JMP	BASE+60
PRMS:
	JMP	BASE+63
BUFMS:
	JMP	BASE+66
XLATEMS:
	JMP	BASE+69

*  DISK I/O UTILITIES
INIT$FCB:
	JMP	BASE+72
LOAD$FCB:
	JMP	BASE+75
OPEN$FILE:
	JMP	BASE+78
CLOSE$OUT$FILE:
	JMP	BASE+81
ERASE$OLD$FILE:
	JMP	BASE+84
MAKE$NEW$FILE:
	JMP	BASE+87
INIT$WRITE$DATA$BUFFER:
	JMP	BASE+90
WRITE$HL$TO$FILE:
	JMP	BASE+93
INIT$READ$DATA$BUFFER:
	JMP	BASE+96
READ$HL$FROM$FILE:
	JMP	BASE+99
WRITE$TERM$TO$DISK:
	JMP	BASE+102

*  MISCELLANEOUS ENTRY POINTS
TPHONE:
	JMP	BASE+105
PAUSE:
	JMP	BASE+108
IN$CON:
	JMP	BASE+111
STATUS$DISPLAY:
	JMP	BASE+114
SP$END:
	JMP	BASE+117

*
*  OVERLAY BUFFERS
*
BUFFER$START	EQU	BASE+120
INIT$CMND	EQU	BUFFER$START
TERM$ENTRY	EQU	BUFFER$START+1
EXIT$CHAR	EQU	BUFFER$START+2
PROCESSOR$SPEED	EQU	BUFFER$START+3
BREAK$CHAR	EQU	BUFFER$START+4
ECHOFL		EQU	BUFFER$START+5
PRFL		EQU	BUFFER$START+6
BUFLG		EQU	BUFFER$START+7
XLATE$IN$FLAG	EQU	BUFFER$START+8
XLATE$OUT$FLAG	EQU	BUFFER$START+9
MASK$IN$FLAG	EQU	BUFFER$START+10
MASK$OUT$FLAG	EQU	BUFFER$START+11
OUTPUT$MASK	EQU	BUFFER$START+12
XLATE$IN$ACTIVE	EQU	BUFFER$START+13
XLATE$OUT$ACTIVE EQU	BUFFER$START+14
M2$ON		EQU	BUFFER$START+15
CTRLS$FLAG	EQU	BUFFER$START+16
BFL$FLAG	EQU	BUFFER$START+17
AUTO$INIT	EQU	BUFFER$START+18
RFU		EQU	BUFFER$START+19
TABLE$BASE	EQU	BUFFER$START+39
XLATE$IN$TABLE	EQU	TABLE$BASE
XLATE$OUT$TABLE	EQU	TABLE$BASE+256
PHONE$NUMBERS	EQU	TABLE$BASE+512

*
*: TERM II, Overlay Section 1
*  OVERLAY INITIALIZATION ROUTINE

OVERLAY$INIT:
	CALL	PRINT$MESSAGE
	DB	'TERM II Overlay',0
	RET			; RETURN TO CALLER

*
*: TERM II, Overlay Section 2
*
*  PHONE NUMBER EDITOR
*  TPHONE ENTRY POINT
*
PH$EDIT:
	CALL	SCREEN$CLEAR	; CLEAR CRT
	CALL	PRINT$ID
	CALL	SCREEN$MESSAGE
	DB	3,9
	DB	'++ TERM II Telephone Directory Editor ++',0
	CALL	PRINT$CINDEX
	CALL	PRINT$MESSAGE
	DB	CR,LF
	DB	' A  Add Number		 C  Change Entry	 D  Delete '
	DB	'Number',CR,LF
	DB	' I  Initialize Dir	 L  Load/Store Dir	 Q  Quit '
	DB	'(No Changes)',CR,LF
	DB	' R  Reorganize Dir	 X  Exit and Update',0

*  PRINT PHONE NUMBERS
PH$LIST:
	CALL	PRINT$PHONE$NUMBERS

*  PHONE NUMBER EDITOR COMMAND INPUT
PH$EDIT1:
	LXI	SP,STACK
	CALL	SCREEN$MESSAGE
	DB	4,50
	DB	'Editor Command -- ',0
	CALL	PRINT$MESSAGE	; CLEAR OUT LAST CMD
	DB	' ',8,0
	CALL	GET$RESPONSE
	LXI	H,PETAB	; PHONE EDITOR COMMANDS
	CALL	TEXIT0	; PROCESS
	CALL	IC$MSG	; INVALID COMMAND
	JMP	PH$EDIT1

*
*  PRINT PHONE NUMBERS
*
PRINT$PHONE$NUMBERS:
	CALL	SCREEN$MESSAGE
	DB	11,5,'-- Telephone Directory --',0	; PHONE NUMBER LIST
	LXI	H,PHONE$NUMBERS	; PT TO BUFFER
	MVI	B,'0'	; SET INDEX
	MOV	A,M	; EMPTY DIR?
	ORA	A
	JNZ	PH$LIST0
	CALL	PRINT$MESSAGE
	DB	CR,LF,'  No Entries in Directory',0
	RET
PH$LIST0:
	MOV	A,M	; GET BYTE
	ORA	A	; 0=DONE
	RZ
	CALL	PH$LIST$ENTRY
	JMP	PH$LIST0

*  PRINT PHONE NUMBER ENTRY PTED TO BY HL WITH INDEX # IN B
PH$LIST$ENTRY:
	CALL	CRLF
	MOV	A,B	; GET INDEX
	CALL	OUT$CON
	INR	B	; INCR INDEX
	MVI	A,'.'	; DECIMAL
	CALL	OUT$CON
	MVI	A,' '	; <SP>
	CALL	OUT$CON
PH$NUM:
	MOV	A,M	; GET DIGIT
	INX	H	; PT TO NEXT
	ORA	A	; 0=DONE
	JZ	PH$TITLE
	CALL	OUT$CON
	JMP	PH$NUM
PH$TITLE:
	MOV	A,M	; GET CHAR
	INX	H	; PT TO NEXT
	ORA	A	; DONE?
	RZ
	CALL	OUT$CON
	JMP	PH$TITLE

*
*  ABORT TO TPHONE SYSTEM
*  PH$EDIT ENTRY POINT
*
PH$EDIT$ABORT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Are you sure you want to abort (Y/N/<CR>=N)? ',0
	CALL	GET$RESPONSE
	CPI	'Y'	; YES, ABORT
	JZ	TPHONE
	CALL	CLEAR$ERROR$MESSAGE
	JMP	PH$EDIT	; CONTINUE

*
*  EXIT TO TEXIT
*  PH$EDIT ENTRY POINT
*
PH$EDIT$EXIT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Updating Telephone Number Directory to Disk',0
	CALL	WRITE$TERM$TO$DISK
	JMP	TPHONE		; RETURN TO TELEPHONE EDITOR

*
*  INITIALIZE PHONE NUMBERS
*  PH$EDIT ENTRY POINT
*
PH$EDIT$INIT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Are you sure you want to initialize the directory (Y/N/<CR>=N'
	DB	')? ',0
	CALL	GET$RESPONSE
	CPI	'Y'
	JNZ	PH$EDIT
	XRA	A	; A=0
	STA	PHONE$NUMBERS
	JMP	PH$EDIT

*
*  LOAD THE TELEPHONE DIRECTORY FROM DISK OR STORE IT ON DISK
*
PH$EDIT$LOAD:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Load Directory from Disk or Store it on Disk (L/S/^C/<CR>=L)?'
	DB	0
	CALL	GET$RESPONSE
	CPI	CTRLC	; ABORT?
	JZ	PH$EDIT
	LXI	H,PHONE$NUMBERS	; PT TO TELEPHONE DIRECTORY
	CPI	'S'	; STORE?
	PUSH	PSW	; SAVE FLAGS
	CZ	CREATE$512$FILE	; STORE FILE ON DISK
	POP	PSW	; GET FLAGS
	CNZ	READ$512$FILE	; READ FILE FROM DISK
	JMP	PH$EDIT

*
*  DELETE PHONE NUMBER FROM DIRECTORY
*  PH$EDIT ENTRY POINT
*
PH$EDIT$DELETE:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Number to Delete (<CR>=Abort)? ',0
	CALL	GET$RESPONSE
	CPI	' '
	JC	PH$EDIT
	SUI	'0'	; ADJUST TO 0-9
	JC	PH$ENTRY$ERROR
	CPI	10
	JNC	PH$ENTRY$ERROR
	LXI	H,PHONE$NUMBERS	; PT TO LIST
	MOV	B,A	; COUNT IN B
PH$DEL:
	MOV	A,M	; END OF LIST?
	ORA	A	; 0=YES
	JZ	PH$ENTRY$ERROR
	MOV	A,B	; FOUND IT?
	ORA	A	; YES IF ZERO
	JZ	PH$DEL0
	DCR	B	; COUNT DOWN
	CALL	PH$DEL$SKIP	; SKIP OVER ENTRY
	JMP	PH$DEL	; CONT
PH$DEL0:
	PUSH	H	; SAVE PTR
	CALL	PH$DEL$SKIP	; SKIP OVER IT
	POP	D	; HL PTS TO NEXT ENTRY, DE PTS TO DEST
PH$DEL1:
	MOV	A,M	; GET NEXT BYTE
	STAX	D	; PUT BYTE
	ORA	A	; DONE?
	JZ	PH$EDIT	; CONTINUE WITH EDITOR
PH$DEL2:
	MOV	A,M	; COPY NUMBER
	STAX	D
	INX	H	; PT TO NEXT
	INX	D
	ORA	A	; DONE?
	JNZ	PH$DEL2
PH$DEL3:
	MOV	A,M	; COPY TITLE
	STAX	D
	INX	H	; PT TO NEXT
	INX	D
	ORA	A	; DONE?
	JNZ	PH$DEL3
	JMP	PH$DEL1	; CONTINUE
PH$DEL$SKIP:
	MOV	A,M	; GET BYTE -- SKIP NUMBER
	INX	H	; PT TO NEXT
	ORA	A	; DONE?
	JNZ	PH$DEL$SKIP
PH$DELS:
	MOV	A,M	; GET BYTE -- SKIP TITLE
	INX	H	; PT TO NEXT
	ORA	A	; DONE?
	JNZ	PH$DELS
	RET

*  INVALID SELECTION
PH$ENTRY$ERROR:
	CALL	PRINT$ERROR$MESSAGE
	DB	BEL,'Invalid Selection',0
	JMP	PH$LIST

*
*  ADD PHONE NUMBER TO DIRECTORY
*  PH$EDIT ENTRY POINT
*
PH$EDIT$ADD:
	CALL	CLEAR$ERROR$MESSAGE
	MVI	B,10	; DET IF DIRECTORY FULL
	LXI	H,PHONE$NUMBERS
PH$EDITA:
	MOV	A,M	; GET BYTE
	ORA	A	; DONE?
	JZ	PH$EDITA1
	CALL	PH$DEL$SKIP	; SKIP ENTRY
	DCR	B	; COUNT DOWN
	JNZ	PH$EDITA
	CALL	PRINT$ERROR$MESSAGE
	DB	'Directory Full',0
	JMP	PH$EDIT1
PH$EDITA1:
	PUSH	H	; SAVE PTR TO NEXT ENTRY
	CALL	SCREEN$MESSAGE
	DB	20,1
	DB	'Enter Telephone Number (<CR>=Abort) -->',0
	CALL	PDOTS	; 20 DOTS
	CALL	SCREEN$MESSAGE
	DB	20,39,' ',0	; POSITION CURSOR
	CALL	C1$FLUSH
	LXI	D,INPUT$BUFFER
	MVI	C,CREAD	; READ INFO
	CALL	BDOS
	LDA	INPUT$BUFFER+1	; CHECK FOR EMPTY LINE
	ORA	A
	JZ	PH$EDITA2
	MVI	B,20	; 20 CHARS IN PHONE NUMBER
	POP	H	; HL PTS TO ENTRY PLACE
	CALL	PH$TEXT$ENTER
	PUSH	H
	CALL	SCREEN$MESSAGE
	DB	21,1
	DB	'Enter Title for Entry -->',0
	CALL	PDOTS	; 40 DOTS
	CALL	PDOTS
	CALL	SCREEN$MESSAGE
	DB	21,25,' ',0
	CALL	C1$FLUSH
	LXI	D,INPUT$BUFFER
	MVI	C,CREAD	; READ INFO
	CALL	BDOS
	MVI	B,40	; 40 CHARS IN PHONE TITLE
	POP	H
	CALL	PH$TEXT$ENTER
	MVI	M,0	; PLACE LAST ZERO
	JMP	PH$EDIT	; PRINT NEW DIR
PH$EDITA2:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Entry Aborted - Returning to Editor',0
	CALL	PAUSE
	JMP	PH$EDIT

*  INPUT TEXT INTO DIR
PH$TEXT$ENTER:
	LXI	D,INPUT$BUFFER+1	; PT TO CHAR COUNT
	LDAX	D	; GET COUNT INTO C
	MOV	C,A
	INX	D	; PT TO 1ST CHAR
PH$TEXT1:
	LDAX	D	; GET CHAR
	MOV	M,A	; PUT IT
	INX	H	; PT TO NEXT
	INX	D	; PT TO NEXT
	DCR	C	; COUNT DOWN ON CHARS
	JZ	PH$TEXT2
	DCR	B	; COUNT DOWN ON LIMIT
	JNZ	PH$TEXT1
PH$TEXT1A:
	MVI	M,0	; ENDING ZERO
	INX	H	; PT TO NEXT
	RET
PH$TEXT2:
	DCR	B	; COUNT DOWN ON LIMIT
	JZ	PH$TEXT1A
	MVI	M,' '	; STORE <SP>
	INX	H	; PT TO NEXT
	JMP	PH$TEXT2

*
*  CHANGE ENTRY IN DIRECTORY
*
PH$EDIT$CHANGE:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Number to Change (<CR>=Abort)? ',0
	CALL	GET$RESPONSE
	CPI	' '
	JC	PH$EDIT
	SUI	'0'	; ADJUST TO 0-9
	JC	PH$ENTRY$ERROR
	CPI	10
	JNC	PH$ENTRY$ERROR
	LXI	H,PHONE$NUMBERS	; PT TO LIST
	MOV	B,A	; COUNT IN B
PH$EC1:
	MOV	A,M	; END OF LIST?
	ORA	A	; 0=YES
	JZ	PH$ENTRY$ERROR
	MOV	A,B	; FOUND IT?
	ORA	A	; YES IF ZERO
	JZ	PH$EC2
	DCR	B	; COUNT DOWN
	CALL	PH$DEL$SKIP	; SKIP OVER ENTRY
	JMP	PH$EC1	; CONT
PH$EC2:
	PUSH	H	; SAVE PTR TO NEXT ENTRY
	CALL	SCREEN$MESSAGE
	DB	20,1
	DB	'Enter Telephone Number (<CR>=Skip) -->',0
	CALL	PDOTS
	CALL	SCREEN$MESSAGE
	DB	20,39,' ',0	; POSITION CURSOR
	CALL	C1$FLUSH
	LXI	D,INPUT$BUFFER
	MVI	C,CREAD	; READ INFO
	CALL	BDOS
	POP	H
	LDA	INPUT$BUFFER+1	; CHECK FOR EMPTY LINE
	ORA	A
	JZ	PH$EC3
	MVI	B,20	; 20 CHARS IN PHONE NUMBER
	CALL	PH$TEXT$ENTER
	JMP	PH$EC4
PH$EC3:
	MOV	A,M	; SKIP TO TITLE
	INX	H
	ORA	A	; 0=THERE
	JNZ	PH$EC3
PH$EC4:
	PUSH	H
	CALL	SCREEN$MESSAGE
	DB	21,1
	DB	'Enter Title for Entry (<CR>=Skip) -->',0
	CALL	PDOTS	; 40 DOTS
	CALL	PDOTS
	CALL	SCREEN$MESSAGE
	DB	21,37,' ',0
	CALL	C1$FLUSH
	LXI	D,INPUT$BUFFER
	MVI	C,CREAD	; READ INFO
	CALL	BDOS
	POP	H
	LDA	INPUT$BUFFER+1
	ORA	A	; SKIP IT?
	JZ	PH$EDIT
	MVI	B,40	; 40 CHARS IN PHONE TITLE
	CALL	PH$TEXT$ENTER
	JMP	PH$EDIT	; PRINT NEW DIR

*  PRINT 20 DOTS
PDOTS:
	MVI	C,20	; 20 DOTS
PDOTS1:
	MVI	A,'.'	; DOT
	CALL	OUT$CON
	DCR	C	; COUNT DOWN
	JNZ	PDOTS1
	RET

*
*  REORGANIZE (ORDER) TELEPHONE DIRECTORY
*
PH$EDIT$ORDER:
	CALL	SCREEN$CLEAR
	CALL	PRINT$ID
	CALL	SCREEN$MESSAGE
	DB	4,11,'++ Telephone Directory Reorganization Utility ++',0
	MVI	C,0	; SET COUNT OF ENTRIES
	LXI	H,PHONE$NUMBERS
	MOV	A,M	; ANY ENTRIES?
	ORA	A
	JNZ	PH$EDIT$ORDER1
	CALL	PRINT$ERROR$MESSAGE
	DB	'ERROR -- No Entries in Telephone Directory',0
	CALL	PAUSE
	JMP	PH$EDIT
PH$EDIT$ORDER1:
	INR	C	; ADD 1
	CALL	PH$DEL$SKIP
	MOV	A,M	; DONE?
	ORA	A	; 0=YES
	JNZ	PH$EDIT$ORDER1
	LXI	H,ORDER$MARKER	; MARK ALL ENTRIES AS USED
	PUSH	H	; SAVE PTR
	MVI	B,10	; 10 ENTRIES
PH$EDITO1:
	MVI	M,0	; USED
	INX	H
	DCR	B
	JNZ	PH$EDITO1
	POP	H
	PUSH	B	; SAVE C
PH$EDITO2:
	MVI	M,0FFH	; MARK 1ST 'C' ENTRIES AS FREE
	INX	H
	DCR	C
	JNZ	PH$EDITO2
	POP	B	; GET C
	MOV	A,C	; SAVE C
	STA	ORDER$COUNT
	MVI	B,'0'	; ORDER NUMBER
	LXI	H,PHONE$NUMBERS	; PT TO DIRECTORY
PH$EDIT$ORDER2:
	PUSH	H	; SAVE PTR
	PUSH	B	; SAVE VALUES
	CALL	PH$LIST$ENTRY	; PRINT DIRECTORY ENTRY
PH$EDIT$ORDER3:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'	New Directory Number (0-9)? ',0
	CALL	GET$RESPONSE
	SUI	'0'	; CONVERT TO BINARY
	JC	PH$EO3$NERR
	CPI	10	; IN RANGE?
	JNC	PH$EO3$NERR
	MOV	D,A	; VALUE IN D
	LXI	H,ORDER$MARKER	; ENTRY OK?
	ADD	L	; OFFSET INTO TABLE
	MOV	L,A
	MOV	A,H
	ACI	0
	MOV	H,A
	MOV	A,M	; VALID CHOICE?
	ORA	A	; 0=NO
	JNZ	PH$EDIT$ORDER4
	CALL	PRINT$MESSAGE
	DB	CR,LF,'	Directory Number Already Used - Select Another'
	DB	CR,LF,'		Free Directory Numbers Are: ',0
	LXI	H,ORDER$MARKER	; PASS THRU TABLE
	MVI	C,10	; 10 ENTRIES
	MVI	B,'0'-1	; FIRST ONE
PH$EO3$SCAN:
	MOV	A,M	; USED?
	INR	B	; PT TO NEXT
	INX	H	; PT TO NEXT
	ORA	A	; 0=YES
	JZ	PH$EO3$CNT
	MOV	A,B	; GET LETTER
	CALL	OUT$CON	; PRINT LETTER
	MVI	A,' '
	CALL	OUT$CON
PH$EO3$CNT:
	DCR	C	; COUNT DOWN
	JNZ	PH$EO3$SCAN
	CALL	CRLF	; NEW LINE
	JMP	PH$EDIT$ORDER3
PH$EO3$NERR:
	CALL	PRINT$MESSAGE
	DB	'	Selection Not In Range 0-9',CR,LF,0
	JMP	PH$EDIT$ORDER3
*  VALID SELECTION -- COPY INTO DATA$BUFFER
PH$EDIT$ORDER4:
	MVI	M,0	; MARK POSITION AS TAKEN
	LXI	H,0	; COMPUTE TRUE OFFSET
	MOV	B,D	; COUNT IN B
	LXI	D,62	; 62 BYTES/ENTRY
	MOV	A,B	; OFFSET 0?
	ORA	A
	JZ	PH$EDIT$ORDER5
PH$EO4:
	DAD	D	; ADD IN OFFSET
	DCR	B	; COUNT DOWN
	JNZ	PH$EO4
*  HL = OFFSET INTO DATA$BUFFER
PH$EDIT$ORDER5:
	XCHG		; DE=OFFSET
	CALL	SP$END	; HL=DATA$BUFFER
	DAD	D	; HL PTS TO LOCATION
	XCHG		; DE PTS TO LOCATION
	POP	B	; RESTORE BC
	POP	H	; RESTORE HL
	PUSH	B	; SAVE BC
	MVI	B,62	; COPY 62 BYTES
	CALL	MOVE	; HL PTS TO NEXT ENTRY
	POP	B	; GET VALUES
	INR	B	; ADD 1 TO INDEX
	DCR	C	; COUNT DOWN
	JNZ	PH$EDIT$ORDER2
	LDA	ORDER$COUNT	; NUMBER OF ENTRIES IN DIRECTORY
	MOV	C,A	; ... IN C
	CALL	SP$END	; HL=DATA$BUFFER
	LXI	D,62	; 62 BYTES/ENTRY
PH$EDIT$ORDER6:
	DAD	D	; PT TO END OF DIRECTORY
	DCR	C	; COUNT DOWN
	JNZ	PH$EDIT$ORDER6
	MVI	M,0	; STORE ENDING ZERO
	CALL	PRINT$MESSAGE
	DB	CR,LF,'	** Reorganization Complete **',0
	CALL	PAUSE
	CALL	SP$END	; HL=DATA$BUFFER
	LXI	D,PHONE$NUMBERS	; TO PHONE$NUMBERS
	JMP	PH$DEL1	; COPY HL TO DE FOR DIRECTORY
*

*: TERM II, Overlay Section 3
****  STATUS EDITOR AND TRANSLATION TABLE EDITOR  ****
*
*  STATUS ALTERATION
*	THIS SUBSYSTEM ALLOWS THE USER TO DYNAMICALLY SET THE STATUS FLAGS
* OF TERM
*
STATUS$BUILDER:
	LXI	SP,STACK	; RESET SP
	CALL	SCREEN$CLEAR
	CALL	PRINT$ID
	CALL	SCREEN$MESSAGE
	DB	4,9
	DB	'++ TERM II Status Flag Builder ++',0
	CALL	PRINT$CINDEX
	CALL	PRINT$MESSAGE
	DB	CR,LF
	DB	' 1  Set Group 1 Flags	 2  Set Group 2 Flags	 3  Set '
	DB	'Group 3 Flags',CR,LF
	DB	' Q  Quit (No Changes)	 Y  Status Display	 X  Exit '
	DB	'and Update',0
	CALL	PRINT$FLAG$GROUPS	; PRINT FLAGS IN EACH GROUP
	CALL	SCREEN$MESSAGE
	DB	12,11
	DB	'Status Flag Builder Command -- ',0
	CALL	GET$RESPONSE
	LXI	H,STAB		; STATUS COMMANDS
	CALL	TEXIT0		; PROCESS
	CALL	IC$MSG		; INVALID COMMAND
	JMP	STATUS$BUILDER

*
****  DISPLAY STATUS FOR STATUS BUILDER  ****
*  STATUS$BUILDER ENTRY POINT
*
SB$STATUS$DISPLAY:
	CALL	STATUS$DISPLAY
	JMP	STATUS$BUILDER


*
*  PRINT CONTENTS OF FLAG GROUPS
*
PRINT$FLAG$GROUPS:
	CALL	SCREEN$MESSAGE
	DB	14,1,0
	CALL	PRINT$MESSAGE
	DB	'Flag Group 1		Flag Group 2		Flag Group 3'
	DB	CR,LF,LF
	DB	'Exit Char		Echo Status		Input XLATE'
	DB	CR,LF
	DB	'Break Char		Printer Status		Output XLATE'
	DB	CR,LF
	DB	'Initial Command Level	Buffer Load Status	Modem Char '
	DB	'Input Mask',CR,LF
	DB	'Terminal Mode Entry				Modem Char '
	DB	'Output Mask',CR,LF
	DB	'Processor Speed				Output MSB'
	DB	CR,LF,'Auto Init',CR,LF,0
	RET

*
*  SB$EXIT UPDATES TERM TO DISK
*
SB$EXIT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Updating Status Flags to Disk',0
	CALL	WRITE$TERM$TO$DISK
	JMP	TEXIT

*
*  SB$QUIT ALLOWS THE USER TO ABORT
*
SB$QUIT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Are you sure you want to abort (Y/N/<CR>=N)? ',0
	CALL	GET$RESPONSE
	CPI	'Y'
	JZ	TEXIT
	JMP	STATUS$BUILDER

*
*  SB$SET SETS THE FLAGS FOR TERM II
*

*  FLAG GROUP 1
SB$SET1:
	CALL	SCREEN$CLEAR
	CALL	PRINT$ID
	CALL	SCREEN$MESSAGE
	DB	4,11,'++ Flag Group 1 ++',CR,LF,LF,0
	CALL	EXITCHMS	; PRINT EXIT CHAR MSG
	CALL	CHANGEMS
	JNZ	SB$SET1A
	CALL	PRINT$MESSAGE
	DB	'New Exit Character? ',0
	CALL	GET$RESPONSE
	STA	EXIT$CHAR
	CALL	EXITCHMS
SB$SET1A:
	CALL	CRLF
	CALL	BREAKMS	; PRINT BREAK CHAR
	CALL	CHANGEMS
	JNZ	SB$SET1B
	CALL	PRINT$MESSAGE
	DB	'New Break Character? ',0
	CALL	XL$INPUT	; GET RESPONSE WITH PROCESSING
	MOV	A,C
	STA	BREAK$CHAR
	CALL	CRLF
	CALL	BREAKMS
SB$SET1B:
	CALL	PR$INIT$CMND	; PRINT INITIAL COMMAND STATUS
	CALL	CHANGEMS
	JNZ	SB$SET1C
	LDA	INIT$CMND	; TOGGLE FLAG
	CMA
	STA	INIT$CMND
	CALL	PR$INIT$CMND
SB$SET1C:
	CALL	PR$TERM$ENTRY	; PRINT TERMINAL MODE ENTRY STATUS
	CALL	CHANGEMS
	JNZ	SB$SET1D
	LDA	TERM$ENTRY	; TOGGLE FLAG
	CMA
	STA	TERM$ENTRY
	CALL	PR$TERM$ENTRY
SB$SET1D:
	CALL	PRSPDMS		; PRINT PROCESSOR SPEED
	CALL	CHANGEMS
	JNZ	SB$SET1E
	MVI	A,2	; SET 2MHZ DEFAULT
	STA	PROCESSOR$SPEED
SB$SET1D$ERR:
	CALL	PRINT$MESSAGE
	DB	'Please Enter Processor Speed (1-9MHz) (1/.../9/<CR>=2)? ',0
	CALL	GET$RESPONSE
	CPI	CR	; 2MHZ?
	JZ	SB$SET1D$END
	SUI	'0'	; CONVERT TO BINARY
	JC	SB$SET1D$ERROR
	JZ	SB$SET1D$ERROR
	CPI	10	; MUST BE 1-9
	JNC	SB$SET1D$ERROR
	STA	PROCESSOR$SPEED
SB$SET1D$END:
	CALL	PRSPDMS
	JMP	SB$SET1E
SB$SET1D$ERROR:
	CALL	PRINT$MESSAGE
	DB	'Invalid Response -- Must be <CR> or 1-9',CR,LF,0
	JMP	SB$SET1D$ERR
SB$SET1E:
	CALL	AIMS	; PRINT AUTOMATIC INITIALIZATION STATUS
	CALL	CHANGEMS
	JNZ	SB$SET1F
	LDA	AUTO$INIT	; TOGGLE FLAG
	CMA
	STA	AUTO$INIT
	CALL	AIMS	; PRINT MESSAGE AGAIN
SB$SET1F:
SB$SET1Z:
	JMP	SB$SETZ	; DONE

*  AUTOMATIC INITIALIZATION STATUS MESSAGE
AIMS:
	CALL	PRINT$MESSAGE
	DB	'Automatic Interface Initialization is ',0
	LDA	AUTO$INIT	; GET FLAG
	ORA	A	; 0=OFF
	CZ	PS$OFF
	CNZ	PS$ON
	JMP	CRLF

*  FLAG GROUP 2
SB$SET2:
	CALL	SCREEN$CLEAR
	CALL	PRINT$ID
	CALL	SCREEN$MESSAGE
	DB	4,11,'++ Flag Group 2 ++',CR,LF,LF,0
	CALL	CRLF
	CALL	ECHOMS	; PRINT ECHO STATUS
	CALL	CHANGEMS	; ASK FOR CHANGE
	JNZ	SB$SET2A
	LDA	ECHOFL	; FLIP FLAG
	CMA
	STA	ECHOFL
	CALL	ECHOMS
SB$SET2A:
	CALL	CRLF
	CALL	PRMS	; PRINT PRINTER MESSAGE
	CALL	CHANGEMS
	JNZ	SB$SET2B
	LDA	PRFL	; FLIP FLAG
	CMA
	STA	PRFL
	CALL	PRMS
SB$SET2B:
	CALL	CRLF
	CALL	BUFMS	; PRINT BUFFER LOAD MESSAGE
	CALL	CHANGEMS
	JNZ	SB$SET2Z
	LDA	BUFLG
	CMA
	STA	BUFLG
	CALL	BUFMS
SB$SET2Z:
	JMP	SB$SETZ

*  FLAG GROUP 3
SB$SET3:
	CALL	SCREEN$CLEAR
	CALL	PRINT$ID
	CALL	SCREEN$MESSAGE
	DB	4,11,'++ Flag Group 3 ++',CR,LF,LF,0
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Input Translation Table is ',0
	LDA	XLATE$IN$FLAG
	ORA	A	; SET FLAGS
	CZ	PS$OFF
	CNZ	PS$ON
	CALL	CHANGEMS
	JNZ	SB$SET3A
	LDA	XLATE$IN$FLAG
	CMA
	STA	XLATE$IN$FLAG
SB$SET3A:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Output Translation Table is ',0
	LDA	XLATE$OUT$FLAG
	ORA	A	; SET FLAGS
	CZ	PS$OFF
	CNZ	PS$ON
	CALL	CHANGEMS
	JNZ	SB$SET3B
	LDA	XLATE$OUT$FLAG
	CMA
	STA	XLATE$OUT$FLAG
SB$SET3B:
	CALL	XLATEMS	; PRINT TRANSLATION MESSAGES
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Modem Character Input Mask is ',0
	LDA	MASK$IN$FLAG
	ORA	A
	CZ	PS$OFF
	CNZ	PS$ON
	CALL	CHANGEMS
	JNZ	SB$SET3C
	LDA	MASK$IN$FLAG
	CMA
	STA	MASK$IN$FLAG
SB$SET3C:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Modem Character Output Mask is ',0
	LDA	MASK$OUT$FLAG
	ORA	A
	CZ	PS$OFF
	CNZ	PS$ON
	CALL	CHANGEMS
	JNZ	SB$SET3D
	LDA	MASK$OUT$FLAG
	CMA
	STA	MASK$OUT$FLAG
SB$SET3D:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Output MSB is ',0
	LDA	OUTPUT$MASK
	ANI	80H	; LOOK AT BIT
	CZ	PS$OFF
	CNZ	PS$ON
	CALL	CHANGEMS
	JNZ	SB$SET3Z
	LDA	OUTPUT$MASK	; FLIP MSB
	MOV	B,A		; BYTE IN B
	ANI	80H
	CMA
	ANI	80H
	ORA	B
	STA	OUTPUT$MASK
SB$SET3Z:			; FALL THRU TO SB$SETZ
SB$SETZ:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'** Status Flag Set is Complete **',0
	CALL	PAUSE
	JMP	STATUS$BUILDER

*  CHANGE MESSAGE
CHANGEMS:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Change it (Y/N/<CR>=N)? ',0
	CALL	GET$RESPONSE
	CPI	'Y'		; CHECK FOR YES
	RNZ
	CALL	PRINT$MESSAGE
	DB	'** Change **',CR,LF,0
	XRA	A	; SET ZERO FLAG
	RET
*

*: TERM II, Overlay Section 4
*  TRANSLATION TABLE BUILDER
*	THIS SUBSYSTEM ALLOWS THE USER TO DYNAMICALLY DESIGN HIS
* TRANSLATION TABLES
*
XLATE$BUILD:
	CALL	XL$INIT0	; INITIALIZE WORKSPACE
XLATE$BUILDER:
	LXI	SP,STACK	; RESET SP
	CALL	SCREEN$CLEAR
	CALL	PRINT$ID
	CALL	SCREEN$MESSAGE
	DB	4,9
	DB	'++ TERM II Translation Table Builder ++',0
	CALL	PRINT$CINDEX
	CALL	PRINT$MESSAGE
	DB	CR,LF
	DB	' C  Copy T/F Workspace	 D  Display Workspace	 G  Get File'
	DB	CR,LF
	DB	' I  Init Workspace	 L  Load Workspace	 P  Put File'
	DB	CR,LF
	DB	' Q  Quit (No Changes)	 S  Set Entry Values	 X  Exit and '
	DB	'Update',0
	CALL	SCREEN$MESSAGE
	DB	15,11
	DB	'TERM II Translation Table Builder Command -- ',0
	CALL	GET$RESPONSE
	LXI	H,XTAB		; PT TO TRANSLATION TABLE BUILDER COMMANDS
	CALL	TEXIT0		; PROCESS COMMANDS
	CALL	IC$MSG		; INVALID COMMAND
	JMP	XLATE$BUILDER

*
*  EXIT AND WRITE TERM TO DISK
*
XL$EXIT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Updating Translation Tables to Disk',0
	CALL	WRITE$TERM$TO$DISK
	JMP	TEXIT

*
*  INITIALIZE OPTION TO XLATE
*	THIS FUNCTION INITIALIZES THE TRANSLATION WORK SPACE TO
* 0-127, 0-127 (0-7F, 0-7F)
*
XL$INIT:
	CALL	XL$INIT0	; INITIALIZE
	CALL	PRINT$ERROR$MESSAGE
	DB	'Translation Workspace Initialized',0
	CALL	PAUSE
	JMP	XLATE$BUILDER
XL$INIT0:
	LXI	H,XLATE$WORK	; INITIALIZE WORKSPACE
	MVI	B,0		; 256 BYTES
XL$INIT1:
	MOV	A,B		; GET BYTE
	ANI	7FH		; MASK OUT MSB
	MOV	M,A		; PUT BYTE
	INX	H		; PT TO NEXT
	INR	B		; COUNT
	JNZ	XL$INIT1
	RET

*
*  COPY THE TRANSLATION WORK SPACE TO/FROM THE INPUT OR OUTPUT
*	TRANSLATION TABLES
*
XL$COPY:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Please Select Input or Output Table (I/O/^C/<CR>=O)? ',0
	CALL	GET$RESPONSE
	CPI	CTRLC		; ABORT?
	JZ	XLATE$BUILDER
	CPI	'I'		; INPUT?
	JZ	XL$COPYI
	LXI	H,XLATE$OUT$TABLE	; PT TO OUTPUT TABLE
	JMP	XL$COPY1
XL$COPYI:
	LXI	H,XLATE$IN$TABLE	; PT TO INPUT TABLE
XL$COPY1:
	LXI	D,XLATE$WORK		; PT TO WORKSPACE
	CALL	PRINT$MESSAGE
	DB	'Copy To or From System Table (T/F/^C/<CR>=T)? ',0
	CALL	GET$RESPONSE
	MVI	B,0		; 256 BYTES TO COPY
	CPI	CTRLC		; ABORT?
	JZ	XLATE$BUILDER
	CPI	'F'		; FROM?
	JZ	XL$COPY2
	XCHG			; EXCHANGE TO COPY TO
XL$COPY2:
	MOV	A,M		; GET BYTE
	STAX	D		; PUT BYTE
	INX	H		; PT TO NEXT
	INX	D
	DCR	B		; COUNT DOWN
	JNZ	XL$COPY2
	CALL	PRINT$MESSAGE
	DB	'** Copy Complete **',0
	CALL	PAUSE
	JMP	XLATE$BUILDER

*
*  SET ALLOWS THE USER TO DISPLAY AND ALTER CURRENT SETTINGS OF TABLE
*	ENTRIES; A SIMPLE LOOP IS ENTERED IN WHICH THE USER IS ASKED FOR
*	THE CODE TO CHANGE AND THE VALUE TO CHANGE IT TO; ENTERING ^C AS
*	A RESPONSE TO EITHER QUESTION RETURNS THE USER TO THE BUILDER
*
*  VALID INPUT ARGUMENTS TAKE THE FOLLOWING FORMS:
*	HH<CR> - UP TO 2 DIGIT HEXADECIMAL NUMBER FOLLOWED BY A <CR>
*	'<CHAR> - LITERAL VALUE (<CHAR> IS TAKEN LITERALLY)
*	<CR> OR <SP> - NO CHANGE
*	<ESC> - ABORT TO XLATE$BUILDER
*
*  EXAMPLES:
*	Code Index to Change? 'a
*	  Code Index = a   Code Value = a  New Value? 'A
*		-- Changes small a to cap A
*	Code Index to Change? '^C
*	  Code Index = ^C   Code Value = ^C  New Value?<CR>
*		-- No change to ^C
*	Code Index to Change? ff<CR>
*	  Code Index = FFH  Code Value = FFH  New Value?7f<CR>
*		-- Changes FF Hex to 7F Hex
*
XL$SET$ENTRIES:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Set All Workspace Values or Selected Workspace Values?'
	DB	CR,LF,'	(A/S/^C/<CR>=S)? ',0
	CALL	GET$RESPONSE
	CPI	CTRLC
	JZ	XLATE$BUILDER
	CPI	'A'	; ALL?
	JZ	XL$SET$ALL	; FALL THRU TO SELECTED

*  SET SELECTED ENTRIES IN WORKSPACE
XL$SET:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Code Index to Change? ',0
	CALL	XL$INPUT	; GET VALUE
	JZ	XLATE$BUILDER	; ABORT ON <CR>
	CALL	XL$LINE		; PRINT LINE ON VALUE IN REG C
	CALL	PRINT$MESSAGE
	DB	'  New Value? ',0
	CALL	XL$INPUT	; GET VALUE
	CZ	XLATE$NC$MSG	; NO CHANGE MESSAGE
	JZ	XL$SET		; ABORT CHANGE ON <CR>
	MOV	M,C		; PUT NEW ENTRY
	JMP	XL$SET

*  SYSTEMATICALLY SET ALL WORKSPACE ENTRIES
XL$SET$ALL:
	MVI	C,0	; SET ALL ENTRIES
XL$SET$ALL$LOOP:
	PUSH	B	; SAVE C
	CALL	XL$LINE	; DISPLAY CURRENT SETTING
	CALL	PRINT$MESSAGE
	DB	'  New Value (<ESC>=Stop)? ',0
	CALL	XL$INPUT	; GET RESPONSE
	CZ	XLATE$NC$MSG	; NO CHANGE
	JZ	XL$SET$ALL$SKIP
	MOV	M,C	; STORE BYTE
XL$SET$ALL$SKIP:
	POP	B
	INR	C	; NEXT
	JNZ	XL$SET$ALL$LOOP
	JMP	XLATE$BUILDER

*  NO CHANGE MESSAGE
XLATE$NC$MSG:
	PUSH	PSW		; SAVE FLAGS
	CALL	PRINT$MESSAGE
	DB	CR,LF,'  No Change',0
	POP	PSW
	RET
*  OUTPUT LINE FOR XL$SET AND XL$DISP
XL$LINE:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Code Index ',0
	CALL	XL$OUTPUT	; PRINT VALUE
	CALL	XL$INDEX	; FIND ENTRY
	CALL	PRINT$MESSAGE
	DB	'  Maps To ',0
	CALL	XL$OUTPUT	; PRINT VALUE
	RET
*  OUTPUT ROUTINE FOR XL$SET
XL$OUTPUT:
	MOV	A,C		; GET BYTE
	CALL	HEX$OUT		; PRINT AS HEX
	MOV	A,C
	CPI	7EH		; CHECK FOR HEX
	RNC
	MVI	A,'='
	CALL	OUT$CON
	MOV	A,C
	JMP	PRINT$CONTROL$CHAR	; PRINT AS CONTROL CHAR/NORMAL CHAR
*  INDEX ROUTINE FOR XL$SET
XL$INDEX:
	LXI	H,XLATE$WORK	; PT TO ENTRY
	MVI	B,0		; SET MSB TO ZERO
	DAD	B		; INDEX INTO TABLE
	MOV	C,M		; GET BYTE
	RET
*  CHAR INPUT ROUTINE FOR XL$SET
XL$INPUT:
	CALL	PRINT$MESSAGE
	DB	'<EI> ',0
	CALL	IN$CON1		; GET 1ST CHAR
	CALL	CAPS		; CAPITALIZE
	CPI	ESC		; COMPLETE ABORT
	JZ	XLATE$BUILDER
	CPI	CR		; ABORT IF <CR>
	RZ
	CPI	' '		; ABORT IF <SP>
	RZ
	CALL	OUT$CON		; ECHO
	CPI	27H		; CHECK FOR SINGLE QUOTE
	JZ	XL$INPUT$LIT	; LITERAL INPUT IF SO
	MVI	C,0		; INIT VALUE TO ZERO
XL$IN$TO$HEX:
	SUI	'0'		; MUST BE HEX, SO CONVERT
	JC	XL$INPUT$RET
	CPI	10		; CONVERT 0-9
	JC	XL$ITH$OK
	SUI	7		; CONVERT A-F
	CPI	16		; OK?
	JNC	XL$INPUT$RET
XL$ITH$OK:
	MOV	B,A		; VALUE IN B
	MOV	A,C		; GET OLD VALUE
	RLC			; MULT BY 16
	RLC
	RLC
	RLC
	ANI	0F0H		; MASK OUT LOW NYBBLE
	ORA	B		; MASK IN LOW NYBBLE
	MOV	C,A		; RESULT IN C
	MVI	B,0		; B BACK TO ZERO
	CALL	IN$CON1		; GET NEXT
	CALL	CAPS		; CAPITALIZE
	CALL	OUT$CON		; GET NEXT
	JMP	XL$IN$TO$HEX
XL$INPUT$RET:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'  Value = ',0
	MOV	A,C		; GET IT
	CALL	HEX$OUT
	MVI	A,'='
	CALL	OUT$CON
	MOV	A,C
	CPI	7EH
	CC	PRINT$CONTROL$CHAR
	CALL	CRLF
	MVI	A,1		; SET NON-ZERO
	ORA	A		; SET FLAGS
	RET
XL$INPUT$LIT:
	CALL	IN$CON1		; GET CHAR WITHOUT CAPITALIZATION
	MOV	C,A		; CHAR IN C
	MVI	B,0		; B=0
	CALL	PRINT$CONTROL$CHAR	; PRINT WITH CONTROL CHAR PROCESSING
	JMP	XL$INPUT$RET

*
*  XL$DISP DISPLAYS IN PAGED MODE THE CONTENTS OF THE TRANSLATION WORKSPACE
*
XL$DISP:
	CALL	XL$LINECNT	; SET LINE COUNT
	LXI	H,XLATE$WORK	; PT TO TABLE
	MVI	D,0		; COUNT TO 256
	CALL	SCREEN$CLEAR
	CALL	PRINT$MESSAGE
	DB	'Display of Translation Table Workspace',CR,LF,0
	DCR	C		; DECREMENT LINE COUNT
XL$DISP$LOOP:
	PUSH B ! PUSH D
	MOV	C,D		; CHAR IN C
	CALL	XL$LINE		; PRINT LINE OF DATA
	POP D ! POP B
	INR	D		; PT TO NEXT
	JZ	XL$DISP$DONE
	DCR	C		; COUNT LINES
	JNZ	XL$DISP$LOOP
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Page:  Type ^C to abort, any other char to cont - ',0
	CALL	GET$RESPONSE
	CPI	CTRLC
	JZ	XLATE$BUILDER
	CALL	XL$LINECNT
	JMP	XL$DISP$LOOP
XL$DISP$DONE:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'Display Complete: Type any char to cont - ',0
	CALL	IN$CON
	JMP	XLATE$BUILDER
XL$LINECNT:
	MVI	C,LPS		; LINES/SCREEN
	RET

*
*  XL$LOAD LOADS THE TRANSLATION WORKSPACE FROM DISK OR WRITES IT TO DISK
*
XL$LOAD:
	CALL	PRINT$MESSAGE
	DB	CR,LF,'WARNING:  Loaded Files larger than the Workspace will '
	DB	'be truncated'
	DB	CR,LF,'  Get or Put Translation Workspace (G/P/^C/<CR>=P)? ',0
	CALL	GET$RESPONSE
	CPI	CTRLC		; ABORT?
	JZ	XLATE$BUILDER
	CPI	'G'		; GET IT FROM DISK?
	JZ	XL$LOAD$GET	; IF NOT GET, FALL THRU TO PUT

*
*  XL$LOAD$PUT WRITES THE TRANSLATE WORKSPACE TO DISK IN A USER-SPECIFIED FILE
*
XL$LOAD$PUT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Put Translation Workspace on Disk',0
	CALL	LOAD$FCB	; GET FILE NAME AND INIT FCB
	CALL	ERASE$OLD$FILE
	CALL	MAKE$NEW$FILE
	CALL	INIT$WRITE$DATA$BUFFER	; INIT DATA BUFFER
	LXI	H,XLATE$WORK	; COPY WORK SPACE TO BUFF
	CALL	WRITE$HL$TO$FILE
	CALL	WRITE$HL$TO$FILE
	CALL	CLOSE$OUT$FILE
	JMP	XLATE$BUILDER

*
*  XL$LOAD$GET COPIES TRANSLATION TABLE INTO TRANSLATION WORK SPACE
*
XL$LOAD$GET:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Get Translation Workspace from Disk',0
	CALL	LOAD$FCB	; GET FILE NAME AND INIT FCB
	CALL	OPEN$FILE
	CALL	INIT$READ$DATA$BUFFER	; LOAD DATA BUFFER
	LXI	H,XLATE$WORK	; READ INTO WORKSPACE
	CALL	READ$HL$FROM$FILE
	CALL	READ$HL$FROM$FILE
	JMP	XLATE$BUILDER
CAPS:
	ANI	7FH		; MASK MSB
	CPI	61H		; SMALL A?
	RC			; RET IF LESS
	CPI	7BH		; SMALL Z + 1?
	RNC			; RET IF GREATER
	ANI	0DFH		; CAPITALIZE
	RET
MOVE:
	MOV	A,M		; GET BYTE
	STAX	D		; PUT BYTE
	INX	H		; PT TO NEXT
	INX	D
	DCR	B		; COUNT DOWN
	JNZ	MOVE
	RET

*
*  XL$GET LOADS THE TRANSLATION TABLES (BOTH INPUT AND OUTPUT) FROM DISK
*
XL$GET:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Get Translation Tables from Disk',0
	CALL	XL$LOADER	; LOAD TRANSLATION TABLES
	JMP	XLATE$BUILDER

*  UTILITY TO LOAD BOTH TRANSLATION TABLES FROM DISK
XL$LOADER:
	LXI	H,XLATE$IN$TABLE ; READ INTO IN$ AND OUT$TABLE
	CALL	READ$512$FILE
	RET

*
*  READ FILE FROM DISK INTO BUFFER PTED TO BY HL; FILE IS 512 BYTES LONG
*
READ$512$FILE:
	PUSH	H	; SAVE PTR TO BUFFER
	CALL	LOAD$FCB	; INIT FCB
	CALL	OPEN$FILE
	CALL	INIT$READ$DATA$BUFFER	; LOAD BUFFER
	POP	H	; GET PTR TO BUFFER
	CALL	READ$HL$FROM$FILE
	CALL	READ$HL$FROM$FILE
	CALL	READ$HL$FROM$FILE	; XLATE$OUT$TABLE FOLLOWS IN TABLE
	CALL	READ$HL$FROM$FILE
	RET

*
*  XL$PUT WRITES TRANSLATION TABLES TO DISK
*
XL$PUT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Put Translation Tables on Disk',0
	LXI	H,XLATE$IN$TABLE	; COPY INPUT
	CALL	CREATE$512$FILE	; CREATE AND COPY TO FILE
	JMP	XLATE$BUILDER

*
*  CREATE AND STORE 512 BYTES PTED TO BY HL ON DISK FILE
*
CREATE$512$FILE:
	PUSH	H	; SAVE PTR TO BUFFER
	CALL	INIT$FCB
	CALL	ERASE$OLD$FILE
	CALL	MAKE$NEW$FILE
	CALL	INIT$WRITE$DATA$BUFFER	; CLEAR DATA BUFFER
	POP	H	; GET PTR TO BUFFER
	CALL	WRITE$HL$TO$FILE
	CALL	WRITE$HL$TO$FILE
	CALL	WRITE$HL$TO$FILE	; XLATE$OUT$TABLE FOLLOWS
	CALL	WRITE$HL$TO$FILE
	CALL	CLOSE$OUT$FILE
	RET

*
*  XL$QUIT ABORTS EXECUTION OF TRANSLATION TABLE BUILDER
*
XL$QUIT:
	CALL	PRINT$ERROR$MESSAGE
	DB	'Are you sure you want to abort (Y/N/<CR>=N)? ',0
	CALL	GET$RESPONSE
	CPI	'Y'
	JNZ	XLATE$BUILDER
	JMP	TEXIT

*
*: TERM II, Overlay Section 5
*  Overlay Support Routines

*  PRINT ON MESSAGE (PS$ON) AND PRINT OFF MESSAGE (PS$OFF)
PS$ON:
	PUSH	PSW
	CALL	PRINT$MESSAGE
	DB	'ON',0
	POP	PSW
	RET
PS$OFF:
	PUSH	PSW
	CALL	PRINT$MESSAGE
	DB	'OFF',0
	POP	PSW
	RET

*  OUTPUT <CR> <LF>
CRLF:
	MVI	A,CR	; OUTPUT <CR>
	CALL	OUT$CON
	MVI	A,LF
	JMP	OUT$CON

*  CONVERT A TO HEX AND PRINT
HEX$OUT:
	PUSH	PSW	; SAVE
	RLC		; EXCHANGE NYBBLES
	RLC
	RLC
	RLC
	CALL	NYBBLE$OUT	; PRINT HIGH NYBBLE
	POP	PSW	; GET VALUE AND PRINT LOW NYBBLE
	CALL	NYBBLE$OUT
	MVI	A,' '	; PRINT TRAILING <SP>
	JMP	OUT$CON
*  PRINT LOW-ORDER NYBBLE OF A AS HEX DIGIT
NYBBLE$OUT:
	ANI	0FH	; MASK FOR LOW NYBBLE
	CPI	10	; CHAR/DIGIT BOUNDARY
	JC	DEC$OUT
	ADI	'A'-10	; CONVERT CHAR TO ASCII
	JMP	OUT$CON	; PRINT IT
DEC$OUT:
	ADI	'0'	; CONVERT DIGIT TO ASCII
	JMP	OUT$CON

*
*: TERM II, Overlay Section 6
*  Command Tables

*
*  TELEPHONE EDITOR SUBCOMMAND TABLE
*
PETAB:
	DB	'A'	; ADD
	DW	PH$EDIT$ADD
	DB	'C'	; CHANGE
	DW	PH$EDIT$CHANGE
	DB	'D'	; DELETE
	DW	PH$EDIT$DELETE
	DB	'I'	; INITIALIZE
	DW	PH$EDIT$INIT
	DB	'L'	; LOAD DIRECTORY
	DW	PH$EDIT$LOAD
	DB	'Q'	; QUIT
	DW	PH$EDIT$ABORT
	DB	'R'	; REORGANIZE
	DW	PH$EDIT$ORDER
	DB	'X'	; EXIT
	DW	PH$EDIT$EXIT
	DB	0

*
*  STATUS BUILDER COMMAND TABLE
*
STAB:
	DB	'1'	; GROUP 1
	DW	SB$SET1
	DB	'2'	; GROUP 2
	DW	SB$SET2
	DB	'3'	; GROUP 3
	DW	SB$SET3
	DB	'Q'	; QUIT
	DW	SB$QUIT
	DB	'Y'	; STATUS
	DW	SB$STATUS$DISPLAY
	DB	'X'	; EXIT
	DW	SB$EXIT
	DB	0

*
*  TRANSLATE TABLE BUILDER COMMAND TABLE
*
XTAB:
	DB	'C'	; COPY
	DW	XL$COPY
	DB	'D'	; DISPLAY
	DW	XL$DISP
	DB	'G'	; GET TABLE
	DW	XL$GET
	DB	'I'	; INITIALIZE
	DW	XL$INIT
	DB	'L'	; LOAD WORKSPACE
	DW	XL$LOAD
	DB	'P'	; PUT TABLE
	DW	XL$PUT
	DB	'Q'	; QUIT
	DW	XL$QUIT
	DB	'S'	; SET
	DW	XL$SET$ENTRIES
	DB	'X'	; EXIT
	DW	XL$EXIT
	DB	0


*

*: TERM II, Overlay Section 7
*  Buffers

ORDER$MARKER:
	DS	10	; MARKER BUFFER FOR REORGANIZING DIRECTORY
ORDER$COUNT:
	DS	1	; COUNT BUFFER FOR REORGANIZING DIRECTORY

BUFLEN	EQU	100	; 100 BYTES IN INPUT BUFFER
INPUT$BUFFER:
	DB	BUFLEN	; NUMBER OF BYTES IN BUFFER
	DB	1	; RETURN BYTE COUNT
	DS	BUFLEN

	DS	100	; 50-ELT STACK
STACK	EQU	$

XLATE$WORK:
	DS	256	; TRANSLATION TABLE WORK SPACE