;REMSCRN.ASM
;
;WRITTEN 2/28/86 BY JOHN GOTSCHALL
;
;
;
;
; GENERIC SCREEN CONTROL STRING FILTER
; REPLACES OUTBOUND SCREEN COMMAND STRINGS WITH
; STRINGS THAT PERFORM IDENTICLE FUNCTIONS ON A
; REMOTE CONSOLE, THIS PROGRAM WAS DEVELOPED FOR
; USE IN AN APPLICATION WHERE A BUSINESS HAD A CP/M
; MACHINE RUNNING DBASE II, THEY DID NOT WANT TO
; GET A MULTI-USER MACHINE, BUT THEY DID WANT
; SIMULTANEOUS I/O TO A REMOTE HAZELTINE 1500, SO
; THAT WHEN ONE TERMINAL WAS NOT IN USE THE OTHER COULD
; BE USED, VERY SIMILAR IN FUNCTION TO A BYE PROGRAM,
; WITH THE EXCEPTION THAT THERE WAS NO MODEM INVOLVED.
; THE REMOTE IN THIS CASE HAD A DIFFERENT SET OF SCREEN COMMAND
; SEQUENCES THAN THE LOCAL, NECESSITATING CONVERSION
; OF THE LOCAL'S NATIVE COMMAND STRINGS INTO THE REMOTES
; NATIVE TONGUE. THIS MODULE PERFORMS THAT FUNCTION,
; RATHER NICELY.
;
; I WROTE THIS LITTLE THING, AND AS IT IS MY VERY FIRST
; 100% SUCCESSFUL ASSEMBLY PROGRAM WITH PRACTICAL APPLICATION,
; I HAVE MADE IT AVAILABLE TO THE GENERAL PUBLIC AND THUS
; MAY BE USED BY ANY PERSON FOR NON-PROFIT USE. IF YOU
; DO USE IT FOR PROFIT, YOU OWE ME ONE U.S. DOLLAR FOR
; EVERY PERSON THAT USES IT. (PRETTY CHEAP HUH?, THAT'S NOT
; ASKING A HECK OF A LOT.)
;
; IF YOU OWE ME A BUCK SEND IT TO:
;
; JOHN GOTSCHALL
; PO BOX 2475
; SEATTLE WA 98111
;
; ANYWAY, IMPLEMENTATION OF THIS CODE SHOULD BE PRETTY
; OBVIOUS, JUST PATCH THE FIRST TABLE WITH THE VALUES
; FOR YOUR LOCAL TERMINAL, THEN PLACE THE APPROPRIATE
; REPLACEMENT VALUES INTO THE SECOND TABLE, WHEN OUTPUTTING
; TO THE REMOTE, IF THE STRING THAT APPEARS IN THE FIRST
; FOUR BYTES OF THE FIRST TABLE GETS SENT TO THE LOCAL,
; THE CONTENTS OF THE FIRST FOUR BYTES OF THE SECOND
; TABLE WILL BE SENT TO THE REMOTE IN PLACE OF WHAT WAS SENT
; TO THE LOCAL. IF YOU ARE USING A BYE PROGRAM, ALL YOU
; NEED TO DO IS ADD THIS CODE TO YOUR BYE PROGRAM SOURCE
; CODE (MAKING SURE TO FIX ANY DUPLICATED LABELS), THEN HAVE
; YOUR BBS PROGRAM POKE THE VALUES FOR THE REMOTE'S
; COMMAND STRINGS INTO THE SECOND TABLE, THEN YOUR BYE
; MERGED WITH THIS PROGRAM WILL TAKE CARE OF MAKING
; SURE THE REMOTE GETS SCREEN CONTROL SEQUENCES THAT IT CAN
; UNDERSTAND, YET YOUR BBS PROGRAM NEED NOT DO ANYMORE
; THAN PRETEND THAT YOUR LOCAL AND THE REMOTE HAVE THE
; SAME SCREEN COMMAND SET. WORKS PERFECT WITH THE
; BUILT IN COMMANDS LIKE IN DBASE II AND TURBO PASCAL,
; IT EVEN WORKED PERFECT WITH WORDSTAR IN MY APPLICATION.
; WELL, IF YOU HAVE READ ALL OF THIS, I CERTAINLY HOPE YOU
; CAN MAKE USE OF THIS PROGRAM, AS YOU ALREADY HAVE SOME
; TIME INTO IT.
;
; BE FORWARNED, WHILE THIS CODE NEVER USES A STACK,
; IT WILL, WITHOUT A DOUBT DESTROY THE CONTENTS OF
; THE CPU REGISTERS, SO SAVE ANYTHING YOU WANT TO KEEP
; BEFORE CALLING THIS SUBROUTINE!!!!!
;
; DELIVER OUTBOUND CHARACTERS TO THIS ROUTINE IN BOTH
; THE A AND C REGISTERS !!
;
;
;=======================================================
;The following section of code filters the output to the remote,
;checking for the presence of screen command sequences, and when
;encountered, replaces the strings that are native to the local
;with strings that are native to the remote. This is done
;through the use of two look-up tables. The first of the two
;tables contains all of the sequences that are expected to be
;sent out, and are in code that is native to the local screen.
;the second table is where we patch in the corresponding strings,
;but there they are the strings that the remote will recognize
;as they are native to the remote.
;=======================================================
;
;******************************************************
;There are many calls to a routine labeled 'REMOUT',
;you will not find remout in this listing, whenever this
;code calls remout, it thinks that it is delivering a
;single character to the remote... all waiting for status
;for the remote must take place in remout, your version
;of bye should already have a routine to output characters
;to the remote..... THAT routine is the one that this code
;refers to when it calls remout. The character to be sent to the
;renote from this code will be found in the C register whenever remout
;is called.
;********************************************************
;
;
;THE FOLLOWING TWO TABLES ARE 60 BYTES LONG, THEY ARE
;ORGANIZED SO THERE ARE 15 STRINGS OF 4 BYTES. THE FIRST
;TABLE IS SCANNED PRIOR TO ANY OUTPUT TO THE REMOTE, IF
;THE CURRENT OUTBOUND CHARACTER MATCHES ANY OF THE CHARACTERS
;IN THE FIRST POSITIONS OF THE FIRST TABLE, THE CHARACTER IS
;BUFFERED, WHEN THE NEXT CHARACTER COMES THROUGH, A TEST IS
;MADE TO FIND ANY WHOLE MATCHING STRINGS, IF THERE IS A
;POSSIBILITY OF A MATCH ON THE THIRD CHARACTER, THE SECOND
;CHARACTER IS BUFFERED, AND THE ROUTINE WAITS UNTIL THE
;THIRD CHARACTER COMES THROUGH, IT THEN TESTS TO SEE IF
;THERE IS A POSSIBILITY OF A COMPLETE MATCH. ON CHARACTERS
;2, AND 3, CHECKS ARE MADE FOR BOTH PENDING MATCHES, AND
;COMPLETE MATCHES, ANY COMPLETE MATCHES WIN AND ARE IMMEDIATLY
;CONVERTED TO THE REMOTE'S COMMAND SET, AND ARE IMMEDIATLY SENT OUT
;TO THE REMOTE.
;
;IF THERE IS A MATCH IN ANY OF THE STRINGS IN THE FIRST TABLE
;THE STRING IS REPLACED WITH THE CONTENTS OF THE SAME POSITIONS
;IN THE SECOND TABLE... ANY STRINGS MAY BE PUT IN ANY LOCATIONS,
;WITH THE EXCEPTION THAT THE LAST STRING OF 4 IN EACH TABLE IS
;RESERVED FOR THE CURSOR POSITIONING LEAD IN STRINGS, THE
;FOLLOWING THREE BYTES ARE FOR THE X AND Y COORDINATES AND
;THERE IS A FLAG THAT DENOTES WHICH COORDINATE COMES FIRST.
;
;THE MAXIMUM LENGTH FOR ANY COMMAND STRING IS FOUR BYTES!
;
INSTNG EQU $+OFFSET
DB 01BH,045H,01BH,048H ;CLEAR AND HOME CURSOR
DB 01BH,05AH,0,0 ;CLEAR TO EOL
DB 01BH,04AH,0,0 ;CLEAR TO EOS
DB 27,69,0,0 ;ANOTHER STRING THAT IS CL & HME
DB 01BH,048H,01BH,045H ;YET ANOTHER CL & HOME STRING
DB 01BH,'K',0,0 ;IF LESS THAN 4 BYTES LONG,
DB 0,0,0,0 ;LEAVE 0'S TO FILL THE EXTRAS,
DB 0,0,0,0 ;THE ZEROS WON'T BE SENT OUT
DB 0,0,0,0
DB 0,0,0,0
DB 0,0,0,0
DB 0,0,0,0
DB 0,0,0,0
DB 0,0,0,0
DB 27,70,0,0 ;**LEAD-IN** CHARACTERS FOR THE
;LOCAL CONSOLE'S CURSOR POSITIONING
;STRING, IF LESS THAN 4 BYTES LONG,
;LEAVE A '0' TO FILL THE EXTRAS
;
ICCC EQU $+OFFSET
DB 2 ;WHICH COORDINATE CARRIES THE COLUMN DATA?
;THE FIRST OR THE SECOND
;
ICCO EQU $+OFFSET
DB 32 ;VALUE OF COLUMN OFFSET FOR LOCAL
;
ICRO EQU $+OFFSET
DB 32 ;VALUE OF ROW OFFSET FOR LOCAL
;
;
OUTSTNG EQU $+OFFSET
DB 07EH,01CH,0A0H,0 ;REPLACEMENT COMMAND STRINGS
DB 07EH,0FH,0,0 ;THAT ARE TO BE INSERTED IN THE
DB 07EH,018H,0,0 ;DATA FLOW TO THE REMOTE IN
DB 07EH,01CH,0A0H,0 ;IN PLACE OF THE COMMAND STRINGS
DB 07EH,01CH,0A0H,0 ;FOUND IN THE ABOVE TABLE. THE
DB 07EH,0FH,0,0 ;STRINGS IN THE TABLE ABOVE MUST
DB 0,0,0,0 ;MATCH THE STRINGS THAT WILL BE
DB 0,0,0,0 ;SENT TO THE LOCAL CONSOLE, WHILE
DB 0,0,0,0 ;THESE MUST CARRY THE STRINGS FOR
DB 0,0,0,0 ;THE SAME FUNCTIONS, BUT IN THE
DB 0,0,0,0 ;REMOTE'S NATIVE TONGUE.
DB 0,0,0,0 ;IF LESS THAN 4 BYTES LONG,
DB 0,0,0,0 ;LEAVE 0'S TO FILL THE EXTRAS,
DB 0,0,0,0 ;THE ZEROS WON'T BE SENT OUT
DB 07EH,011H,0,0 ;**LEAD-IN** CHARACTERS FOR THE
;REMOTE CONSOLE'S CURSOR POSITIONING
;STRING, IF LESS THAN 4 BYTES LONG,
;LEAVE 0'S TO FILL THE EXTRAS,
; ;THE ZEROS WON'T BE SENT OUT
;
OCCC EQU $+OFFSET
DB 1 ;POSITION IN CURSOR POSITIONING
;STRING THAT CARRIES THE COLUMN
;FOR REMOTE
;
OCCO EQU $+OFFSET
DB 0 ;VALUE OF COLUMN OFFSET FOR REMOTE
;
OCRO EQU $+OFFSET
DB 0 ;VALUE OF ROW OFFSET FOR REMOTE
;
;
;MOVE (HL) TO (DE) LENGTH IN (B)
;
;THE FOLLOWING IS COMMENTED OUT, THIS ROUTINE IS DUPLICATED EXACTLY
;IN MY VERSION OF BYE.COM, SO I DON'T NEED THIS AGAIN, BUT IF YOUR
;VERSION OF BYE.COM DOES NOT HAVE THIS ROUTINE IN IT, USE THIS ONE
;OR IF YOU MAKE AN OVERLAY OF THIS FILE YOU WILL NEED IT
;
;
;MOVE EQU $+OFFSET
; MOV A,M ;GET A BYTE
; STAX D ;PUT IT IN NEW HOME
; INX D ;BUMP POINTERS
; INX H
; DCR B ;DEC BYTE COUNT
; JNZ MOVE ;IF MORE, DO IT
; RET ;IF NOT, RETURN
;
;**************************************************
;**************************************************
;* MAIN PROGRAM SECTION, THIS IS THE PART THAT *
;* DOES ALL THE FILTERING OF CURSOR COMMAND *
;* SEQUENCES....... *
;**************************************************
;
;
;the call to vconout below calls the routine that is already
;in my version of bye. I replaced the call for vconout in
;my version of bye with a call for 'OUTPUT' below, so that the
;program comes here just prior to outputing to the local.
;
OUTPUT EQU $+OFFSET
CALL STRT ;STORE CHAR IN FIRST EMPTY BUFFER LOC
CALL VCONOUT ;SEND IT TO THE LOCAL
;
MT1 EQU $+OFFSET
LDA CLCF ;POINT TO CURSOR LOCATION COMMAND FLG
CPI 1 ;ARE WE AWAITING A CURSOR COMMAND?
JZ CPF ;YES, GOTO CURSOR POS.FILTER
MT2 EQU $+OFFSET
LDA MTSTR ;POINT TO MATCHSTRING
CPI 01H ;IS IT A 1?
JZ MMF ;THERE WAS A PRIVIOUS MATCH, AND NOT A CURSOR
;COMMAND, SO
;LETS TAKE THIS CHAR TO THE MAIN
;MATCH FINDER
MT3 EQU $+OFFSET
JMP QCHK ;NOTHING MATCHED LAST TIME
;WE OUTPUTTED, AND WER'E NOT LOOKIN
;FOR A CURSOR COORDINATE, SO LET'S JUST
;QUICKLY SCAN FOR A FIRST
;CHAR MATCH
;
QCHK EQU $+OFFSET
LXI H,BUFLOC ;GET THE ADDRESS OF THE BUFFER
SHLD BUFPTR ;PUT IT IN THE BUFFERPOINTER
LXI H,INSTNG ;GET THE ADDRESS OF INSTING
SHLD INSPTR ;PUT IT IN THE POINTER
MOV B,C ;SAVE THE CHAR IN B
MVI A,0
STA COUNT
STA COUNT1
LXI H,INSTNG ;POINT TO THE BEGINNING OF THE INSTING
QCHCK1 EQU $+OFFSET
MOV A,M ;GET THE CONTENTS
CMP C ;IS IT THE SAME AS OUR CHAR?
JZ ST1MT ;IT'S A MATCH
QCHK2 EQU $+OFFSET
INX H ;BUMP
INX H ;UP TO THE
INX H ;BEGINNING OF THE NEXT
INX H ;STRING OF FOUR BYTES
LDA COUNT
INR A
STA COUNT ;KEEP TRACK OF WHICH GROUP OF FOUR WERE' ON
CPI 0FH ;PAST 15 YET?, IF SO, THEN THERE IS NO POSSIBLE
JZ DONE ;MATCH SO GO DUMP THE CHARACTER FROM THE BUFFER
JMP QCHCK1
ST1MT EQU $+OFFSET
LXI H,MTSTR ;THERE IS A MATCH IN ONE OF THE FIRST
MVI A,1 ;POSITIONS OF THE INSTRING LINES
MOV M,A ;LEAVE NOTE OF THIS IN THE MTSTR GROUP.
RET ;TO CP/M, WE'LL SEND OUT THIS CHAR LATER..
;
;
;###########################
;
; MMF (MAIN MATCH FINDER,
; ROUTINE CHECKS ENTIRE INSTRING, COMPARES TO THE CONTENTS OF THE
; BUFFER TO THE INSTNG TABLE, MAKES NOTATION TO SHOW POSSIBLE
; PENDING MATCHES, OR PARTIAL BUT IMPOSSIBLE MATCHES, AND MAKES
; THE FINAL DECISION ON WHETHER OR NOT THERE IS A MATCH OF
; AN ENTIRE STRING.
;
;
;
MMF EQU $+OFFSET
LXI H,INSTNG ;GET ADDRESS OF INSTNG INTO (D,E)
SHLD INSPTR ;RESET POINTER
LXI H,BUFLOC ;POINT TO FIRST BUFFER POSITION
SHLD BUFPTR ;RESET BUFPTR
MVI A,0 ;GET A 0
STA POSMTCH ;RESET POSSIBLE MATCH FLAG
STA COUNT ;RESET COUNT FLAG
STA COUNT1
ENT EQU $+OFFSET
LDA COUNT1 ;REACHED END OF INSTNG?
CPI 15
JZ ANT1 ;YEP...GO AND CHECK FOR A PENDING MATCH...
;IT MAY BE THAT WE NEED TO WAIT FOR MORE
;CHARACTERS TO COME THROUGH...
LHLD BUFPTR ;POINT TO THE CURRENT BUFFER ADDRESS
;
;COME INTO ENT1 WITH THE CURRENT BUFFER ADDR IN HL
;
ENT1 EQU $+OFFSET
MOV A,M ;GET VALUE OF CHAR AT BUFFER
LHLD INSPTR ;POINT TO TABLE
CMP M ;DOES BUFFER CHAR MATCH TABLE CHAR?
JNZ ENT7 ;NOPE...
ENT2 EQU $+OFFSET
LDA COUNT ;IF WE ARE AT THE FIRST OF 4,
CPI 0 ;COUNT WILL BE 0
JNZ ENT6 ;NOPE...
ENT3 EQU $+OFFSET
MVI A,1 ;SINCE THERE IS A MATCH IN THE
STA POSMTCH ;FIRST OF 4 IN THE TABLE, MAKE
;A NOTE OF IT
ENT4 EQU $+OFFSET
LXI H,MTSTR ;POINT TO MATCHSTRING
LDA COUNT ;ALSO MAKE NOTE IN THE MATCHSTRING
MOV B,A ;ADD COUNT TO MATCHSTR LOCATION
ENT4A EQU $+OFFSET
MOV A,B ;MAKE SURE WE STILL HAVE IT
CPI 0 ;MATCHING LOCATIONS YET?
JZ ENT4B ;YEP
INX H ;BUMP POINTER
DCR B ;COUNTDOWN
JMP ENT4A
ENT4B EQU $+OFFSET
MVI A,1 ;GET A ONE
MOV M,A ;PUT THE FLAG INTO THE MATCHSTRING
ENT5 EQU $+OFFSET
LDA COUNT ;CECK TO SEE IF THIS IS THE
CPI 3 ;4TH CHAR IN THE STRING
JNZ ENT8 ;NOPE, GO DO SOME MORE....
JMP WHM ;WE HAVE A FULL MATCH FOR A WHOLE
;STRING OF FOUR !!!!!!!
ENT6 EQU $+OFFSET
LDA POSMTCH ;IS THERE A POSSIBLE MATCH?
CPI 1 ;
JZ ENT4
JMP ENT8
ENT7 EQU $+OFFSET
LXI H,POSMTCH ;POINT TO POSMTCH
MVI A,0 ;GET A 0
MOV M,A ;RESET POSMTCH
ENT8 EQU $+OFFSET
LHLD BUFPTR ;GET THE ADDRESS IN THE BUFFER POINTER
INX H ;INCREMENT IT
SHLD BUFPTR ;PUT IT BACK
LHLD INSPTR ;GET THE ADDRESS IN THE INSTRING POINTER
INX H ;INCREMENT IT
SHLD INSPTR ;PUT IT BACK
LDA COUNT ;GET THE COUNT
INR A ;INCREMENT IT
STA COUNT ;PUT IT BACK
ENT9 EQU $+OFFSET
LDA COUNT ;MAKE SURE WE HAVE THE COUNT
CPI 4 ;PAST THE 4TH CHAR YET?
JNZ ENT ;NOPE , GO DO MORE
ENT10 EQU $+OFFSET
MVI A,0 ;WE'RE AT HE 4TH, SO
STA COUNT ;RESET COUNT
LDA COUNT1 ;WERE LOOKING AT THE NEXT
INR A ;STRING IN THE TABLE, SO
STA COUNT1 ;MAKE NOTE OF THAT
LXI H,BUFLOC ;ALSO, ON THE NEXT PASS,
SHLD BUFPTR ;WE WANT TO POINT TO
;THE FIRST CHAR IN THE BUFFER
JMP ENT
;################################################
;
;END OF MATCH FINDER, IF THERE WAS NO EXACT MATCH,
;WE MAY JUST NOT HAVE ALL THE CHARACTERS YET, SO NOW WE CHECK TO
;SEE IF ANY PARTIAL MATCH IS A POSSIBLE MATCH
;
ANT1 EQU $+OFFSET
LXI H,MTSTR ;POINT TO THE FIRST POS OF MTSTR
MOV A,M ;GET THE CONTENTS
CPI 1 ;IS IT A ONE?
JNZ DONE ;NOPE, GO EMPTY BUFFER TO REMOTE,
;THERE IS NO CHANCE OF A MATCH..
ANT2 EQU $+OFFSET
INX H ;POINT TO NEXT LOCATION IN MTSTR
MOV A,M ;IS IT A ONE?
CPI 1 ;NOPE,
JNZ BZ ;GO CHECK BUFFER STRING
ANT3 EQU $+OFFSET
INX H ;POINT TO NEXT LOCATION
MOV A,M ;GET CONTENTS
CPI 1
JNZ BZ1 ;GO CHECK BUFFER STRING
JMP BZ2
BZ EQU $+OFFSET
LXI H,BUFLOC ;POINT TO BUFFER
INX H ;POINT TO 2ND CHAR
MOV A,M ;GET THE CHAR
CPI 0 ;IS THE POSITION IN THE BUFFER EMPTY?
RZ ;YES, THEN RETURN TO CP/M, LEAVE ALL AS IT
;IS, THERE MAY BE MORE CHARACTERS NEEDE TO
;MAKE A MATCHING STRING
JMP DONE ;THERE IS NO POSSIBILITY OF A MATCH,
;SO GO DUMP THE BUFFER
BZ1 EQU $+OFFSET
LXI H,BUFLOC ;POINT TO THE
INX H ;3RD CHAR IN BUFFER
INX H ;THERE WE ARE.....
MOV A,M ;GET THE CHAR, IS IT EMPTY?
CPI 0
RZ ;YEP, SAME AS IN BZ....
JMP DONE
BZ2 EQU $+OFFSET
LXI H,BUFLOC ;SAME AS BZ & BZ1,
INX H
INX H
INX H ;BUT CHECK THE LAST CHAR IN BUFFER
MOV A,M ;GET THE CHAR..
CPI 0 ;IS THE POSITION EMPTY?
RZ ;STILL EMPTY,GO TO CP/M AND TO IT AGIN,
JMP DONE ;BUFFER IS FULL AND NO MATCHES, SO GO EMPTY
;THE BUFFER.
;*****************************************
;END OF MAIN MATCH FINDER.....
;****************************************
;
;
;
;****************************************
;THIS IS WHERE WE GO WHEN WE HAVE A MATCH
;WE NEED TO SEND OUT THE STRING THAT CORRESPONDS TO
;THE STRING THAT MATCHED IN THE TABLE, IF IT WAS THE
;CURSOR POSITIONING STRING, WE WILL HAVE TO HANDLE THAT HERE ALSO.
;
WHM EQU $+OFFSET
LXI H,BUFLOC ;POINT TO BUFFER
XCHG ;MOVE TO DE
WHM1 EQU $+OFFSET
LXI H,COUNT1
MOV B,M ;PUT THE VALUE INTO B:
LXI H,OUTSTNG ;GET THE ADDRESS OF THE TABLE
WHM2 EQU $+OFFSET
MOV A,B ;PUT B INTO A
CPI 0 ;POINTING TO THE CORRECT SUBSTRING?
JZ WHM3 ;YEP
INX H ;MOVE POINTER UP
INX H ;BYE FOUR, THUS
INX H ;POINTING AT
INX H ;THE NEXT SUBSTRING IN THE OUTSTNG
DCR B ;BUMP B DOWN
JMP WHM2 ;LOOP SOME MORE
WHM3 EQU $+OFFSET
MVI B,4 ;4 BYTES TO MOVE
CALL MOVE ;MOVE THE CONTENTS TO THE BUFFER
;******************************
;DONE MOVING THE NEW STRING INTO THE BUFFER, NOW LET'S
;SEE IF IT IS A CURSOR POSITIONING STRING....
;
LDA COUNT1 ;GET THE TABLE STRING POINTER
CPI 14 ;IS IT A CURSOR COMMAND?
JNZ DONE ;NOPE, SO GO EMPTY BUFFER & RESET ALL
MV
I A,1 ;GET A 1
STA CLCF ;SET CURSOR COMMAND FLAG TO TRUE
JMP DONE ;GO EMPTY THE BUFFER TO THE REMOTE....
;********************************
;SINCE WE JUST SET THE CLCF, WE WILL COME HERE ON
;THE NEXT 2 CONSOLE OUTPUT CALLS....
;OUR VALUE IS IN THE BUFFER, BUT IF THE SECOND BUFFER POSITION
;IS EMPTY, THEN WE NEED ONE MORE CHARACTER...
;ALSO, SINCE ONE OR BOTH OF OUR CURSOR AND ROW VALUES
;MAY BE A 0, WE'LL DUMP THE BUFFER HERE INSTEAD OF USING
;THE 'DONE ' ROUTINE....
;WE ARE COUNTING ON GETTING AN OFFSET OF >0 FROM THE LOCAL
;FOR THE FIRST POSITION...
CPF EQU $+OFFSET
LXI H,BUFLOC ;POINT TO THE BUFFER'S
INX H ;SECOND POSITION
MOV A,M ;GET THE CHAR
CPI 0 ;IS THERE A CHAR THERE?
RZ ;NOPE, GOTO CP/M AND AWAIT ANOTHER
CPF1 EQU $+OFFSET ;NOW WE HAVE THE TWO CHARACTERS WE WANT
LXI H,OCCC ;POINT TO THE FIRST BUFFER LOCATION
MOV B,M ;GET THE VALUE INTO B
LDA ICCC ;GET THE OTHER ONE
CMP B ;DO THEY MATCH?
JZ CPF2 ;YEP,DON'T NEED TO REVERSE THE BUFFER CONTENTS
LDA BUFLOC ;GET THE FIRST CHAR
MOV B,A ;SAVE IT IN B
LDA BUFLOC+1 ;GET THE NEXT ONE
STA BUFLOC ;PUT IT WHERE THE FIRST ONE WAS
MOV A,B ;GET THE ONE THAT WAS THE FIRST
STA BUFLOC+1 ;AND PUT IT IN THE SECOND POSITION
;
;NOW MODIFY THE X,Y COORDINATE VALUES
;BY STRIPPING THEM OF THEIR ORIGINAL OFFSET(S)
;
CPF2 EQU $+OFFSET
LXI H,ICCO ;POINT TO VAL OF LOCAL OFFSET
LDA BUFLOC ;GET THE FIRST CHAR
SUB M ;SUBTRACT THE OFFSET
STA BUFLOC ;PUT IT BACK
LXI H,ICRO ;POINT TO VAL OF 2ND LOCAL OFFSET
LDA BUFLOC+1 ;GET 2ND VAL FROM BUFFER
SUB M ;SUBTRACT THE OFFSET
STA BUFLOC +1 ;PUT IT BACK
;
;NOW ADD THE NEW OFFSETS TO THEM
;
CPF3 EQU $+OFFSET
LXI H,OCCO ;POINT TO THE OUTSTNG VALUE
LDA BUFLOC ;GET THE VALUE OF THE 1ST CHAR
ADD M ;ADD THE NEW OFFSET
STA BUFLOC
LXI H,OCRO ;POINT TO THE OTHER ONE
LDA BUFLOC+1 ;GET THE SECOND VAL FROM BUFFER
ADD M ;ADD THE NEW OFFSET
STA BUFLOC+1 ;PUT IT BACK
LDA BUFLOC ;GET 1ST CHAR
MOV C,A ;PUT IT IN C
CALL REMOUT ;SEND IT OUT
LDA BUFLOC+1 ;GET SECOND
MOV C,A ;PUT IT IN C
CALL REMOUT ;SEND IT OUT
MVI A,0 ;NOW KILL THE CHARS IN THE BUFFER
STA BUFLOC
STA BUFLOC+1
CALL DONE2 ;USE DONE'S ROUTINES TO CLEAR THINGS
INIT9 EQU $+OFFSET
LXI H,CLCF ;POINT TO THE FIRST OF THE FLAGS AND BUFFERS
LXI B,BUFPTR-CLCF ;# OF VARIABLES TO CLEAR
MVI A,0 ;GET A ZERO
INIT10 EQU $+OFFSET
MOV M,A ;PUT IT IN THE VAR OR FLAG
DCX B ;BUMP COUNTER
MOV B,A
CPI 0
RZ ;ALLDONE, BACK TO CP/M
INX H ;POINT TO NEXT BYTE
MVI A,0 ;GET THE ZERO BACK
JMP INIT10
;********************************************
;DONE OUTPUTTING ANYTHING THAT COMES ALONG, CONVERTED AS NECESSARY
;******************************************
;
;COME HERE WITH A NEW CHARACTER, BEFORE OUTPUTING IT TO
;THE LOCAL
;
STRT EQU $+OFFSET
MVI A,0
STA COUNT ;ZERO THE COUNTER
LXI H,BUFLOC ;POINT TO THE BUFFER
STRT1 EQU $+OFFSET
MOV A,M ;GET THE CONTENTS
CPI 0 ;IS THERE A 0 THERE?
JZ STRT2 ;YES, BUFFER IS EMPTY
LDA COUNT ;NO? THEN HOW MANY CHAR IN IT?
INR A ;LETS LOOK AT THEM AND COUNT
STA COUNT ;THE CHARACTERS
CPI 6 ;BETTER NOT BE MORE THAN 6
JZ ERRXIT ;OOPS, GOT A PROBLEM
INX H ;POINT TO NEXT POSITION
JMP STRT1 ;MORE CHARS TO CHECK
STRT2 EQU $+OFFSET
MOV M,C ;PUT OUTBOUND CHAR INTO BUFFER
RET
;**************************************
;
;DONE... THIS IS WERE WE END UP WHEN WE WANT TO DUMP THE BUFFER TO
; THE REMOTE.....
;
DONE EQU $+OFFSET
MVI B,0 ;SET COUNT TO 0
LXI H,BUFLOC ;POINT TO THE BUFFER
DONE1 EQU $+OFFSET
MOV A,M ;GET THE CHAR
CPI 0 ;IS IT A 0?
JZ DONE2 ;RETURN IF 0
MOV C,M ;NOT A 0 SO GET THE CHAR
CALL REMOUT ;GO OUTPUT IT
MVI A,0
MOV M,A ;KILL THE BUFFER CHAR
INX H ;POINT TO NEXT CHAR
JMP DONE1
DONE2 EQU $+OFFSET
LXI H,POSMTCH ;POINT TO POSMTCH FLAG
MOV M,A ;PUT A ZERO THERE
LXI H,MTSTR ;POINT TO MATCH STR
MVI B,5 ;SET COUNT
DONE3 EQU $+OFFSET
MOV M,A ;ZERO THE MTSTR ALSO
DCR B
CMP B ;IS B A 0 YET?
JZ DONE4 ;ALL DONE
INX H ;POINT TO NEXT
MVI A,0 ;GET A 0
JMP DONE3 ;
DONE4 EQU $+OFFSET
RET
;
CLCF EQU $+OFFSET
DB 0
POSMTCH EQU $+OFFSET
DB 0
OSPTR EQU $+OFFSET
DB 0,0
INSPTR EQU $+OFFSET
DB 0,0
MTSTR EQU $+OFFSET
DB 0,0,0,0,0,0
COUNT EQU $+OFFSET
DB 0
COUNT1 EQU $+OFFSET
DB 0
BUFLOC EQU $+OFFSET ;LOCATION OF OUTBOUND BUFFERED STRING
DB 0,0,0,0,0,0,0
BUFPTR EQU $+OFFSET
DB 0,0
;==========================================================
;END OF SCREEN COMMAND STRING FILTER SECTION.
;==========================================================
