F_BAR_1#' + c' BACKUPMAN cBACKUPTXT  cBASEREFMAN cBASEREFTXT) cBEDITMAN / cBEDITTXT b cCOPYCMD cDECOMPILTXT , cFILESORTBIN cFILESORTTXT #D c ,ju ,ll 78 BACKUP - MAKE A MIRROR IMAGE OF A DISK BACKUP is a program to create a mirror image of one diskette onto another diskette. It allows copying from any one drive to any other drive or doing a single disk copy to the same drive. Upon executing BACKUP, the program prompts for the drive number to copy data from. Enter a number from 0 - 3. Next, the prompt asks for the drive number to copy the data to. Again, enter a number from 0 - 3. The same drive number may be entered as the from drive number and the operator will be prompted to change diskettes when needed. BACKUP works by reading the SYS INFO record on track 0, sector 3 of the two diskettes to determine if 5 or 8 inch, the number of tracks on the disk and the number of sectors per track. A comparison is made between the two diskettes and an abort is executed if both diskettes are not formatted the same. If allowed to copy a 5 to an 8 inch or visa versa, the links would not be correct on the copied-to diskette, hence that mode is illegal. BACKUP does all copying using the FLEX read and write single sector calls. Each sector on any one track is read individually, saved in a track buffer in memory and re-written, a track at a time, to the 'to' diskette. An error condition will occur if the 'to' diskette has any sectors removed from the link table due to a bad format. Since backup reads each sector individually and writes the same sectors back out, a missing sector will cause an error. The finished copy will produce a copy of the original disk, track for track, sector for sector. No re-formatting of the diskette is made and the copy will contain the same segmentation as the original. BACKUP copies a track in about 1 second, and hence, the copy time fo r a single sided, single density 8 inch disk is about 1 minute, 20 seconds. The inprovement over using the copy command to backup an entire diskette is obvious. Write verification is turned off to improve the speed of the process. It made be re-ena bled by removing the CLR VRFY instruction in the source.  TTL MASTER DISK COPY * * 8,18,81: LAST REVISION DATE * WARMS EQU $CD03 GETCHR EQU $CD15 PUTCHR EQU $CD18 PSTRNG EQU $CD1E PCRLF EQU $CD24 OUTDEC EQU $CD39 RPTERR EQU $CD3F * VRFY EQU $D435 READ EQU 9 READ SINGLE SECTOR FUNCTION CODE WRITE EQU 10 WRITE SINGLE SECTOR FUNCTION CODE FUNC EQU 0 DRV EQU 3 FMS EQU $D406 RESTOR EQU $DE09 RESTORE TO TRK 00 ORG 0 START BRA START1 VN FCB 3 DATE FCB 8,18,81 SINFLG FCB 0 SINGLE DRIVE FLAG TRKMAX FDB 0000 SECMAX EQU TRKMAX+1 RTRKTP FDB 0001 TRK 0, SEC 1 WTRKTP RMB 2 CURMSB FCB 0 CURTRK FCB 0 XTEMP RMB 2 FDRIVE FCB 0 TDRIVE FCB 0 * * CLEAR FIRST 64 BYTES OF FCB BEFORE USING * START1 LEAX FCB2,PCR CLEAR 1ST 64 BYTES LDA #64 SR1 CLR ,X+  DECA BNE SR1 * * If you want faster backups then include this code * and the reset code farther down on line #272 * CLRA * STA VRFY TURN OFF WRITE ERROR CHECKING * * * PROMPT FOR THE DRIVE NUMBER TO COPY FROM * LEAX FDRSTR,PCR PROMPT FOR DISK # TO COPY FROM JSR PSTRNG JSR GETCHR ANDA #$F CMPA #3 ONLY 4 DRIVES SUPPORTED LBHI DERR TSTA LBMI DERR STA FDRIVE,PCR SAVE 'FROM' DRIVE # * * PROMPT FOR THE DRIVE NUMBER TO COPY TO * LEAX TDRSTR,PCR PROMPT FOR DRIVE # TO COPY TO JSR PSTRNG JSR GETCHR ANDA #$F CMPA #3 LBHI DERR TSTA LBMI DERR STA TDRIVE,PCR SAVE 'TO' DRIVE # * * COMPARE THE TWO DRIVE NUMBERS TO SEE IF SINGLE OR * MULTIPLE DISK COPY * CMPA FDRIVE,PCR ARE THEY THE SAVE DRIVE ? BEQ SINGLE IF YES, SINGLE DISK COPY * * MULTIPLE COPY!!! PROMPT TO INSERT DISKETTES THAT ARE TO BE COPIED * LEAX STRTMG,PCR PROMPT TO INSERT DISKS TO USE FOR COPY JSR PSTRNG LDA FDRIVE,PCR TELL OP WHERE TO PUT DISKETTES ORA #$30 JSR PUTCHR LEAX STRTM1,PCR JSR PSTRNG LDA TDRIVE,PCR ORA #$30 JSR PUTCHR LEAX STRTM2,PCR JSR PSTRNG * * WAIT TILL USER HITS ANY KEY * JSR GETCHR WAIT TILL USER READY * * GO READ SYS-INFO RECORDS TO DETERMINE IF BOTH DISKS ARE  THE SAME * BSR START3 GO RESTORE DRIVES * LEAX FCB2,PCR WHERE TO PUT DATA LDD #0003 READ SYS INFO RECORD STD 30,X LDA FDRIVE,PCR FROM 'FROM' DRIVE STA 3,X LDA #9 STA X JSR FMS READ INFO RECORD LBNE ERR * LDD $66,X  FIND OUT TYPE OF DISK STD TRKMAX,PCR SAVE DISK FORMAT INFORMATION LDA TDRIVE,PCR NOW READ OTHER DISK AND COMPARE THE TWO STA 3,X LDA #9 STA X JSR FMS READ SECOND DISK INFO LBNE ERR LDD $66,X GET THIS DISK TYPE CMPD TRKMA X,PCR ARE THEY THE SAME? LBNE TERR BRA SIN1 * SINGLE LEAX FCB2,PCR WHERE TO PUT DATA LDD #0003 SYS INFO RECORD STD 30,X LDA FDRIVE,PCR WHICH DISK TO READ FROM STA 3,X LDA #9 STA X JSR FMS LBNE ERR COM SINFLG,PCR  INDICATE SINGLE DISK COPY LDD $66,X READ TRK, SEC FORMAT FROM DISK SIN1 INCA INCB STD TRKMAX,PCR BRA DOAGN * START3 JSR PCRLF TST SINFLG,PCR BMI SIN6 LEAX TRKMSG,PCR WRITE CURRENT TRACK WORKING ON JSR PSTRNG SIN6 LEAX FCB2 ,PCR LDA FDRIVE,PCR RESTORE 'FROM' DRIVE STA 3,X TST SINFLG,PCR BMI SIN2 JSR RESTOR LDA TDRIVE,PCR RESTORE 'TO' DRIVE STA 3,X SIN2 JMP RESTOR * DOAGN LEAY DBUFER,PCR BUFFER DATA HERE * * READ EACH SECTOR AS THEY ARE CALLED * DOAGN1 LEAX FCB2,PCR LDD RTRKTP,PCR STD 30,X STORE TRACK & SECTOR TO READ LDA #READ STA FUNC,X LDA FDRIVE,PCR STA DRV,X JSR FMS LBNE ERR * BSR MOVFCB LDD RTRKTP,PCR INCB STD RTRKTP,PCR CMPB SECMAX,PCR BNE DOAGN1 BSR WRITBF LDA RTRKTP,PCR INCA CMPA TRKMAX,PCR BNE DOAG1 LEAX FINIMG,PCR JSR PSTRNG JMP WARMS * DOAG1 LDB #1 STD RTRKTP,PCR BRA DOAGN * MOVFCB LEAX FCB2+64,PCR POINT TO DISK DATA CLRB MOVE1 LDA ,X+ STA ,Y+  DECB BNE MOVE1 RTS * WRITBF TST SINFLG,PCR BPL SIN5 LEAX CHGMSG,PCR JSR PSTRNG JSR GETCHR BRA SIN5 * SIN5 LEAX DBUFER,PCR STX XTEMP,PCR LDB #1 LDA RTRKTP,PCR STD WTRKTP,PCR * WRIT1 LDU XTEMP,PCR CLRB LEAX FCB2+64,PCR WR1 LDA ,U+ STA ,X+ DECB BNE WR1 * LEAX FCB2,PCR LDA TDRIVE,PCR STA DRV,X LDA #WRITE STA FUNC,X LDD WTRKTP,PCR STD 30,X JSR FMS BNE ERR * LDX XTEMP,PCR LEAX 256,X STX XTEMP,PCR LDD WTRKTP,PCR INCB STD WTRKTP,PCR CMPB SECMAX,PCR BNE WRIT1 * TST SINFLG,PCR BMI SIN9 LDB #6 LDA #8 * BACK1 JSR PUTCHR DECB BNE BACK1 LDB #$80 LEAX CURMSB,PCR JSR OUTDEC LDA #$20 JSR PUTCHR LDA CURTRK,PCR INCA STA  CURTRK,PCR TST SINFLG,PCR BPL RTS3 * SIN9 LEAX CHG1MG,PCR JSR PSTRNG JSR GETCHR RTS3 RTS ERR JSR RPTERR BRA EXIT2 * EXIT1 JSR PSTRNG * * Include this for faster backups - see line #50 * EXIT2 LDA #$FF * STA VRFY TURN ON ERRO R CHECKING AGAIN * EXIT2 JMP WARMS EXIT LEAX TERMST,PCR BRA EXIT1 * TERR LEAX DIFSTR,PCR BRA EXIT1 * DERR LEAX DRERR,PCR BRA EXIT1 * STRTMG FCC 'Insert disk to be copied from into drive ',4 STRTM1 FCC 'and disk to be copied to into drive ',4 STRTM2 FCC $D,$A,'then hit any key!',4 FINIMG FCC 'Master Copy completed',4 TRKMSG FCC 'Copied track number ',4 TERMST FCC 'Copy completed',4 FDRSTR FCC 'Drive to copy from - ',4 TDRSTR FCC 'Drive to copy to - ',4 DIFSTR FCC $D,$A,'The disk in the "to" drive is formatted' FCC ' differently than',$D,$A,'the disk in the "from"' FCC ' drive; backup aborted.',4 DRERR FCC $D,$A,'Invalid drive number',4 CHGMSG FCC 'Insert disk to copy to, then hit any key ',4 CHG1MG FCC 'Insert disk to copy from, then hit any key ',4 * FCB2 RMB 320 DBUFER EQU * END START ,ju ,ll 78 BASREF - A BASIC Cross Reference Program This program is designed to provide the BASIC user with additional information, besides the listing of the program, to write or make changes to his files. The output of the program lists each line number in the BASIC program and each line number that referenced that line, possibly with a GOTO or GOSUB instruction. Additionally, all variables are printed, along with the line number that referenced them. To use the BASEREF, simply type BASEREF or P BASEREF for a hard-copy printout. .BAS is assumed.  TTL BASIC CROSS REFERENCE * GENERATE CROSS-REFERENCE TABLE OF CONTROL * TRANSFERS FOR BASIC PROGRAMS.... * AND LIST ALL VARIABLES & LINES USED IN... * SYNTAX= BTAB, * Default= Work Drive & .BAS Extension ACROSS EQU 12 COLUMNS ACROSS PAGE FCB1 EQU $C840 WARMS EQU $CD03 PUTCHR EQU $CD18 PSTRNG EQU $CD1E PCRLF EQU $CD24 GETFIL EQU $CD2D SETEXT EQU $CD33 OUTDEC EQU $CD39 RPTERR EQU $CD3F FMSCLS EQU $D403 FMS EQU $D406 ORG 0 START LBRA BEGIN * * TEMPORARY STORAG E BUFFER RMB 144 NAME RMB 80 BUFPTR RMB 2 REFFRM RMB 2 REFFLG RMB 1 COLNUM RMB 1 DECNUM RMB 2 PRENUM RMB 2 TABEND FDB TABLE LARGST FDB 1 LINNUM FDB 0 PASS FCB 0 VARLTR FCC "A" ORG $100 * BEGIN JSR PCRLF LDX #FCB1 JSR GETFI L BCS ERR1 LDA #3 .BAS Ext JSR SETEXT BSR OPEN BSR PTITLE LOOP BSR INLINE INPUT A BASIC LINE LBSR PARSE FIND REFERENCES BRA LOOP OPEN LDX #FCB1 LDA #1 OPEN TO READ STA ,X JSR FMS OPEN FILE BNE ERR1 RTS ERR1 JSR RPTERR DONE JSR PCRLF JSR FMSCLS JMP WARMS PTITLE LEAX TITLE,PCR JSR PSTRNG BSR PNAME JSR PCRLF LEAX TITL2,PCR JMP PSTRNG PNAME LDX #FCB1+4 POINT TO NAME LDB #8 BSR PNAM1 LDA #'. JSR PUTCHR LDB #3 PNAM1 LDA ,X+ JSR PUTCHR DECB BNE PNAM1 RTS * INPUT A BASIC LINE TO BUFFER INLINE LEAX BUFFER,PCR LDA #13 CR LEAU NAME,PCR PSHS U INLIN1 STA ,X+ FILL BUFFER CMPX ,S BNE INLIN1 LEAS 2,S FIX STACK LEAY BUFFER,PCR LDX #FCB1 INLIN2 JSR FMS GET NEXT CHAR BNE ERR2 CMPA #$20 SPACE? BEQ INLIN2 SKIP SPACES CMPA #$61 L.C. A BLT INLIN4 CMPA #$7A L.C. Z BGT INLIN4 SUBA #$20 CONV TO U.C. INLIN4 STA ,Y+ PUT IN BUFFER CMPA #13 CR? BNE INLIN2 RTS ERR2 LDA 1,X CMPA #8 EOF? BNE ERR1 TST PASS,PCR BEQ PTABLE LBRA PRVARS * PRINT THE CROSS-REF TABLE PTABLE LEAX TABLE,PCR CMPX TABEND,PCR ANY REFS? BNE PRTABL LEAX NOREFS,PCR JSR PSTRNG BRA FINISH PRTABL  CLR REFFLG,PCR SET LINE# NOT PRINTED LEAY TABLE,PCR PRT1 LDX ,Y CMPX LINNUM,PCR BEQ PRT3 PRT2 LEAY 4,Y CMPY TABEND,PCR BNE PRT1 LDX LINNUM,PCR CPX LARGST,PCR BEQ FINISH LEAX 1,X STX LINNUM,PCR BRA PRTABL PRT3 TS T REFFLG,PCR BNE PRT4 JSR PCRLF TFR Y,X SET ADDRESS OF NUM LDB #ACROSS+1 STB COLNUM,PCR JSR OUTDEC BSR OUT2S LDA #': JSR PUTCHR INC REFFLG,PCR PRT4 TFR Y,X LEAX 2,X ADRS OF FROM REF BSR SETPST BCS PRT2 LDB  #1 BSR CKCOL BSR OUT1S JSR OUTDEC BRA PRT2 SETPST LDU PRENUM,PCR CMPU ,X BEQ RTS2 LDU ,X STU PRENUM,PCR ANDCC #$FE RTS RTS2 ORCC #1 RTS * FINISH JSR PCRLF LEAX TABCOM,PCR JSR PSTRNG INC PASS,PCR LBRA VAR EAD OUT8S BSR OUT4S OUT4S BSR OUT2S OUT2S BSR OUT1S OUT1S LDA #$20 JMP PUTCHR CKCOL DEC COLNUM,PCR BNE CKCOL2 JSR PCRLF BSR OUT8S LDA #ACROSS STA COLNUM,PCR CKCOL2 RTS GTLNUM LEAX BUFFER,PCR STX BUFPTR,PCR POSITION I N BUFFER BSR INPDEC GET LINE # STX REFFRM,PCR SAVE CURRENT LINE # RTS1 RTS PARSE BSR GTLNUM PARS2 LEAY WORDS,PCR PARS3 LDX BUFPTR,PCR LDA ,X CMPA #13 BEQ RTS1 BRA MATCH * BUMP TO NEXT WORD PARS5 LDA ,Y+ BNE PARS5 BR A PARS3 * BUMP TO NEXT POSN IN BUF PARS6 LEAX 1,X STX BUFPTR,PCR BRA PARS2 * X=POSN IN BUFFERR * Y=POSN IN WORD LIST MATCH LDA ,Y+ BEQ MATCH2 MATCH FOUND CMPA #$FF END OF WORDS? BEQ PARS6 NO MATCH FOUND CMPA ,X+ BEQ MATCH CONTINUE THRU WORD BRA PARS5 MATCH2 STX BUFPTR,PCR SAVE POSITION BSR INPDEC GET LINE # BNE PARS2 NO NUM FOUND MATCH3 LDY TABEND,PCR STX ,Y++ CMPX LARGST,PCR BMI MATCH4 STX LARGST,PCR MATCH4 LDX REFFRM,PCR STX ,Y++ STY TABEND,PCR * CHECK FOR ANOTHER REF FOR "ON GOTO/GOSUB" LDX BUFPTR,PCR LDA ,X CMPA #', BNE PARS2 LEAX 1,X BRA MATCH2 * GET A DECIMAL NUMBER IMBEDDED IN TEXT * IF VALID NUM NOT FOUND, RETURNS 'NOT EQUAL' COND. * AND X=0... INPDEC CLR DECNUM,PCR BSR GETDIG GET 1ST DIGIT BEQ INP2 GET REST LDX #0 LDA #1 RTS INP2 STA DECNUM+1,PCR INP3 BSR NXTDIG BEQ INP3 LEAX -1,X STX BUFPTR,PCR SAVE NEXT POSN LDX DECNUM,PCR CLRA RTS NXTDIG BSR GETDIG BEQ ADDNUM RTS ADDNUM PSHS X,A LDX #9 LDD DECNUM,PCR ADD1 ADDD DECNUM,PCR MULT BY 10 LEAX -1,X BNE ADD1 STD DECNUM,PCR LDD #0 PULS B ADDD DECNUM,PCR ADD NEW DIGIT STD DECNUM,PCR PULS X CLRA RTS GETDIG LDA ,X+ GET CHAR SUBA #'0 BLT GETD1 CMPA #9 BGT GETD1 CLRB VALID DIGIT FOUND RTS GETD1 LDB #$FF NOT A DIGIT RTS * RE-READ FILE & GET ALL VARIABLES VAREAD JSR FMSCLS CLOSE FILE LBSR OPEN OPEN AGAIN LEAX TABLE,PCR STX TABEND,PCR RESET POINTER VARD2 LBSR INLINE GET 1 BASIC LINE LBSR GTLNUM GET LINE # VARD4 LDX BUFPTR,PCR VARD5 LDA ,X CMPA #13 CR? BEQ VARD2 DONE WITH CURRENT LINE BSR TSTREM IS IT REMARK BEQ VARD2 SKIP REST OF LINE LDX BUFPTR,PCR LDA ,X CMPA #34 DOUBLE QUOTE? BEQ SKPQUT CMPA #39 SINGLE QUOTE? BEQ SKPQUT LBSR INPDEC DECIMAL NUMBER? BEQ VARD4 SKIP IT BSR TSTDEL DELIMITER BNE VARD4 SKIP IT BRA TSTKEY KEYWORD? * SKIP BETWEEN QUOTES SKPQUT LEAX 1,X SKPQ2 CMPA ,X+ BNE SKPQ2 BUMP TO NEXT QUOTE STX BUFPTR,PCR SAVE POINTER BRA VARD5 * TEST FOR REMARK TSTREM LEAY REMWRD,PCR TSTRM1 LDA ,Y+ BNE TSTRM2 RTS MATCH FOUND TSTRM2 CMPA ,X+ BEQ TSTRM1 CONTIN THRU WORD RTS  NO MATCH * TEST FOR DELIMITER & SKIP IT TSTDEL LDX BUFPTR,PCR LEAY DELTAB,PCR TSTDL2 LDA ,Y+ BEQ TSTDL4 END OF TAB/NO MATCH CMPA ,X BNE TSTDL2 TRY ANOTHER LEAX 1,X STX BUFPTR,PCR TSTDL4 RTS * FIND KEY WORDS & SKIP THEM TSTKE Y LEAY KEYWRD,PCR TSTKY2 LDX BUFPTR,PCR TSTKY3 LDA ,Y+ BEQ TSTKY5 MATCH FOUND CMPA #$FF END OF TABLE? BEQ VARSTR NOT A KEY WORD CMPA ,X+ BEQ TSTKY3 CONTINUE * BUMP TO NEXT WORD TSTKY4 LDA ,Y+ BNE TSTKY4 BRA TSTKY2 TSTKY5 STX BUFPTR,PCR SKIP WORD BRA VARD5 * SAVE THE VARIABLE NAME & LINE# VARSTR LDX BUFPTR,PCR LDY TABEND,PCR LDA ,X+ STA ,Y+ STX BUFPTR,PCR STY TABEND,PCR BSR TSTDEL BNE VARST2 BRA FNDKEY VARST2 LEAX -1,X STX BUFPTR,PCR BUMP BACK TO DELIM VARST3 CLRA LDY TABEND,PCR STA ,Y+ LDX REFFRM,PCR STX ,Y++ STY TABEND,PCR LBRA VARD4 FNDKEY LEAY KEYWRD,PCR FNDK2 LDX BUFPTR,PCR FNDK3 LDA ,Y+ BEQ VARST3 MATCH FOUND CMPA #$FF END OF TABLE? BEQ VARSTR KEY NOT FOUND CMPA ,X+ BEQ FNDK3 * BUMP TO NEXT KEY FNDK4 LDA ,Y+ BNE FNDK4 BRA FNDK2 NOVARS LEAX NOVFND,PCR JSR PSTRNG LBRA DONE * PRINT VARIABLE TABLE * CHECK 1ST LETTER MATCH PRVARS LEAX TABLE,PCR CPX TABEND,PCR  BEQ NOVARS LDA VARLTR,PCR PRVR2 CMPA ,X+ BEQ PRVR6 FOUND IT * BUMP TO NEXT VAR PRVR4 LDB ,X+ BNE PRVR4 LEAX 2,X SKIP OVER ADDRS CPX TABEND,PCR END? BNE PRVR2 TRY NEXT INC VARLTR,PCR BUMP TO NEXT LTR LDA VARLTR,PCR  CMPA #$5B Z+1? BNE PRVARS DO NEXT LTR LBRA DONE TABLE COMPLETED PRVR6 LEAX -1,X STX BUFPTR,PCR JSR PCRLF * SAVE VAR NAME & PRINT IT LEAY NAME,PCR PRVR8 LDA ,X+ STA ,Y+ BNE PRVR8 LDX BUFPTR,PCR LDB #ACROSS+1 STB COLNUM,PCR LDB #7 ALLOW 7 CHARS PRVR10 LDA ,X+ BEQ PRVR12 JSR PUTCHR DECB BRA PRVR10 PRVR12 ANDB #7 LDA #$20 JSR PUTCHR DECB BNE PRVR12 LDA #': JSR PUTCHR * PRINT REF LINE # PRREF LDX BUFPTR,PCR CLR ,X+ DELETE FROM TABLE PRREF2 LDA ,X+ BNE PRREF2 PSHS X BSR SETPS1 BCS PROUT LDB #1 LBSR CKCOL LBSR OUT1S JSR OUTDEC PROUT PULS X LEAX 2,X STX BUFPTR,PCR BRA SERNAM SETPS1 LDU PRENUM,PCR CMPU X BEQ RTS3 LDU X STU PRENUM,PCR ANDCC #$FE RTS RTS3 ORCC #1 RTS * * SEARCH FOR ANOTHER VAR OF SAME NAME SERNAM LDX BUFPTR,PCR SERN1 CPX TABEND,PCR LBEQ PRVARS SERN2 LEAY NAME,PCR TST ,X DELETED? BEQ SERN6 SERN3 LDA ,X+ BEQ SERN7 END OF VAR  !FOUND CMPA ,Y+ MATCH? BEQ SERN3 * BUMP TO NEXT VAR SERN4 TST ,X+ BNE SERN4 SERN5 LEAX 2,X SKIP LINE# STX BUFPTR,PCR BRA SERN1 SERN6 LEAX 1,X BRA SERN4 SERN7 CMPA ,Y END OF NAME ALSO? BNE SERN5 BRA PRREF TITLE F "CC 'BASIC Cross-Reference Table for---- ',4 TITL2 FCC 'LINE# REFERENCED FROM:',13,10,0,0 FCC '===== =====================================',4 TABCOM FCC '---- VARIABLE REFERENCES ----',13,10,0,0 FCC 'VAR. FOUND IN LINE #',13,10,0,0 FCC '#==== =====================================',4 NOREFS FCC '*** NO REFERENCES FOUND ***',4 NOVFND FCC '*** NO VARIABLES FOUND ***',4 REMWRD FCC 'REM',0 DELTAB FCC '#,;:.=+-*/ ^()<>',13,0 * * TABLE OF KEY WORDS KEYWRD FCC 'ABS',0 FCC 'AND',0 $FCC 'ASC',0 FCC 'AS',0 FCC 'ATN',0 FCC 'CHAIN',0 FCC 'CHR$',0 FCC 'CLOSE',0 FCC 'COS',0 FCC 'CVT$2',0 FCC 'CVT$F',0 FCC 'CVT2$',0 FCC 'CVTF$',0 FCC 'DATA',0 FCC 'DATE$',0 FCC 'DEF',0 FCC 'DIGITS',0 FCC 'DIM%',0 FCC 'DPEEK',0 FCC 'DPOKE',0 FCC 'END',0 FCC 'ERL',0 FCC 'ERROR',0 FCC 'ERR',0 FCC 'EXEC',0 FCC 'EXP',0 FCC 'FIELD',0 FCC 'FN',0 FCC 'FOR',0 FCC 'FRE',0 FCC 'GET',0 FCC 'HEX',0 FCC 'IF',0 FCC 'INCH$',0& FCC 'INPUT',0 FCC 'INSTR',0 FCC 'INT',0 FCC 'KILL',0 FCC 'LEFT$',0 FCC 'LEN',0 FCC 'LET',0 FCC 'LINE',0 FCC 'LOG',0 FCC 'LSET',0 FCC 'MID$',0 FCC 'NEW',0 FCC 'NEXT',0 FCC 'NOT',0 FCC 'OLD',0 FCC 'ON',0 'FCC 'OPEN',0 FCC 'OR',0 FCC 'PEEK',0 FCC 'PI',0 FCC 'POKE',0 FCC 'POS',0 FCC 'PRINT',0 FCC 'PTR',0 FCC 'PUT',0 FCC 'READ',0 FCC 'RECORD',0 FCC 'RENAME',0 FCC 'RESTORE',0 FCC 'RETURN',0 FCC 'RIGHT$',0 FCC '(RND',0 FCC 'RSET',0 FCC 'SGN',0 FCC 'SIN',0 FCC 'SPC',0 FCC 'SQR',0 FCC 'STEP',0 FCC 'STOP',0 FCC 'STR$',0 FCC 'SWAP',0 FCC 'TAB',0 FCC 'TO',0 FCC 'USING',0 FCC 'USR',0 FCC 'VAL',0 * TABLE OF BASIC Control Tra)nsfer Words WORDS FCC 'GOSUB',0 FCC 'GOTO',0 FCC 'RESUME',0 FCC 'THEN',0 FCC 'ELSE',0 FCB $FF * TABLE EQU * * END START ,ll 78 ,ju BEDIT - BASIC LINE EDITOR FOR TSC BASIC The purpose and intent of this program is to provide the BASIC user with a means of making changes in his or her programs, a line at a time, without the need to re-type the entire line. Anyone w ho has used TSC BASIC with any regularity knows how frustrating it can be to enter a line and then realize there exists an error in the second last character position of a 128 character line. Of course, the entire line must be re-typed, with the possi bility of making another error along the way that will not be detected until the carriage return is hit. Also, having to exit BASIC to use an editor when making many changes can also be a tedious and time-consuming chore. This package allows the user  to enter into the edit mode with a selected line number, make the required changes, and send the line back to BASIC without ever leaving BASIC. The normal method of using the editor is to append it to BASIC and have both programs load and run con-cur rently. The editor is completely transparent until the correct key sequence calls it into use. The only requirement is for FLEXS' memend location to contain a valid address, which should be the case anyway. The user should have a terminal capable of at least the following functions: HOME CURSOR HOME CURSOR & CLEAR SCREEN MOVE CURSOR RIGHT MOVE CURSOR LEFT WRAP LINE AROUND AT END OF LINE TO NEXT LINE Upon loading BASIC, assuming BEDIT is appended, the editor reads the memend location, de termines where it can be executed, reserves some room at the top of memory, changes FLEXS' memend pointer, and re-locates itself. At this time, the EDITOR begins execution and another routine searches thru BASIC to locate the I/O vectors. As it finds  each one, it changes the address to point to a routine in the editor package. Upon exiting BASIC, the editor re-allocates the memory it saved for itself, restoring memend to it's original value. For the users with the source code, refer to the tabl  es in the beginning of the program if it is desired to change the key codes, port address or editor command codes for their own preferences. The user without the source code can also make these changes by following the instructions listed below. Th  e editor is origined at HEX 8000 to provide room for BASIC to load. Do a GET BEDIT.BIN to load the editor into memory. Exit FLEX and using some type of display memory command, dump the first 50 HEX bytes starting at HEX 8000. The beginning of the ta  ble can be located by being preceded with four (4) bytes of HEX FF. The end of the table terminates also with four (4) bytes of HEX FF. The following table is defined as follows. 1 - # of byte/function, 2 - function name, 3 - original value, 4 - al lowed to be changed. (1) (2) "(3) (4) --------------------------------------------------------- 2 control port address $E004 Yes 2 terminal cursor right command $1B43 Yes 2 terminal cursor left command $1B44 Yes 2 terminal home cursor & clear screen $1B45 Yes 2 terminal home cursor $1B48 Yes 2 terminal enable wrap-around at EOL $1B76 Yes 2 terminal Re-set command $1B7A Yes 1 lead in char to enter edit mode $1B Yes 1 user move cursor right key 'R Yes 1 user mov e cursor left key 'L Yes 1 user insert key 'I Yes 1 user delete key 'D Yes 1 user overlay key 'O Yes 1 user change string key 'C Yes 1 user re-print line key 'P Yes 1 user abort edit mode key $18 Yes 1 user update BASIC key 'X Ye s 1 user terminate command key $3 Yes 1 user done with edit key $1B Yes 1 user backspace key $8 Yes 1 user terminal line size 80 Yes 1 user Enter edit mode 2nd key 'E Yes It is suggested that the original codes be retained until the user becomes thoroughly familiar with the program and realizes the consequences of changing these codes. The EDITOR may be used without appending to BASIC with this sequence of commands: GET BASIC.CMD, BEDIT.BIN. No key codes are illegal as set, exc ept for the key sequence of ESC E, to enter the editor. These keys may be sent from a BASIC program, but not to a BASIC program, as the editor will be invoked. This single compromise was made due to the fact that the editor is in no way tied into BAS IC, and therefore, the EDITOR should work with any version of TSC BASIC including the first TBASIC. Once becoming familiar with the workings and limitations of the EDITOR, it will become a quick and simple matter to make corrections to the program in memory. A sample session with the EDITOR may be as follows: LIST 10 FOR A=1 TO 5 20 PRINT "NOW IS TEH TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME" 30 NEXT A 40 END READY RUN NOW IS TEH TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME N OW IS TEH TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME NOW IS TEH TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME NOW IS TEH TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME NOW IS TEH TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME READY (Now to make  corrections to line 20, Type ESC E) LIST 20 (The screen will clear & the cursor will home, then) 20 PRINT "NOW IS TEH TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME" (Each new line listed is assumed to be on the top of the page) (type C) 20 P RINT "NOW IS TEH TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME" C/TEH/THE/ 20 PRINT "NOW IS THE TIME FRR ALL GOOD MEN TO COME TI THE AID OF ME" (type R until the cursor is positioned under the first R in FRR, and type O) (now type O & ^C to termi nate the command) 20 PRINT "NOW IS THE TIME FOR ALL GOOD MEN TO COME TI THE AID OF ME" (type R to move the cursor under the I in TI, and type O & ^C) 20 PRINT "NOW IS THE TIME FOR ALL GOOD MEN TO COME TO THE AID OF ME" (all errors in the line h ave now been fixed. Note that the CHANGE command was used for one error and the OVERLAY command for the others. There may often be several ways of correcting the error. It makes no difference which is used. Now we will insert some new characters into  the line) 20 PRINT "NOW IS THE TIME FOR ALL GOOD MEN TO COME TO THE AID OF ME" (type L to move the cursor under the F in FOR, and type I. Then type the new characters) 20 PRINT "NOW IS THE TIME &FOR ALL GOOD MEN TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & FOR ALL GOOD MEN TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & DFOR ALL GOOD MEN TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & DAFOR ALL GOOD MEN TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & DATFO R ALL GOOD MEN TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & DATEFOR ALL GOOD MEN TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & DATE FOR ALL GOOD MEN TO COME TO THE AID OF ME" (now type ^C to terminate the command. it can be seen t hat as each character was typed, the remainder of the line moved over one place to the right and the new character appeared. Now to delete characters, move the cursor to the M in MEN, and type D, 4 times) 20 PRINT "NOW IS THE TIME & DATE FOR ALL GO OD EN TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & DATE FOR ALL GOOD N TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & DATE FOR ALL GOOD TO COME TO THE AID OF ME" 20 PRINT "NOW IS THE TIME & DATE FOR ALL GOOD TO COME TO THE AID OF  ME" (now to update the line in BASIC, type ESC X. when the READY prompt appears, the line has been sent back to BASIC and control has been returned to BASIC. Note that if an error exists in the line, BASIC will report it and reject the line just as though the line had been typed in at the keyboard.) While in the insert or change mode, an error may be corrected by typing the predefined backspace key, normally a ^H (08 HEX). The previous entry will be deleted and the cursor backed up one positi on. Once the seperator character has been typed in the change mode, all preceding data is fixed and cannot be changed. If an error needs to be corrected, a ^X may be typed to terminate the mode and start over. The above example should give an indi !cation of the capabilities of the EDITOR. There are many other ways the changes could have been made and using all possibilities to gain familiarity with them is recommended. The available commands are as follows: R - Move the cursor right one char "acter position Single key command L - Move the cursor left one character position Single key command D - Delete the character over the cursor Single key command I - Insert in front of the character the cursor is positioned under Enters mode #until ^C or CR typed O - Overlay new characters over the old character the cursor is under Enters mode until ^C or CR typed, ^X will abort command P - Re-print the entire line. Useful if the original becomes tainted in order to see exactly what $the line in the buffer looks like. The line pointer and cursor will be started over at the beginning of the line. Single key command C - Change a string to another string or delete the entire string. (Many possibilities, essentially the same a %s TSC'S EDITOR) (The first character typed after the 'C will be used as the seperator and must be used to seperate both strings and optionally the end sequence) (Each string may be up to 32 characters long) (Typing C/OLD-STRING// will delete & the entire string) (Typing C/OLD-STRING/NEW-STRING/ terminates the command with the cursor remaining where it previously was.) (Typing C/OLD-STRING/NEW-STRING terminates the command with the cursor on the beginning of the line) (Typi 'ng C,OLD-STRING,NEW-STRING, used the comma instead of slash as a terminator character.) ^X - Will in the command mode, aborts the edit session, returning to BASIC with no changes being made. ESC X - Sends the edited line to BASIC, and exits, ret (urning control to BASIC. A few hints on some of the other things that may be done with the EDITOR follows: Entering the edit mode with an ESC E, LIST 20 will put line number 20 into the buffer to be worked on. Using the CHANGE or OVERLAY command )to change the line number will cause a new line to be created in BASIC with the given line number. This function can be utilized to duplicate existing lines. Entering the edit mode with an ESC E, LIST XX, where XX is a non-existant line, can be used * to create new lines. When the EDITOR is entered, the word READY will appear on the screen. Enter the insert mode using 'I, type a line number and the data and then exit the insert mode with a ^C. Then, using the 'D, delete command, delete the word +READY and type ESC X. The new line will be sent to BASIC and appear in the program. If at any time, the cursor position becomes lost due to some problem, simply typing a CR will restart the pointer at the beginning of the line buffer and put the cu ,rsor on the beginning of the displayed line, thereby starting fresh. The command key code is not echoed to the screen. After the command key is typed, all other data until a ^C or is typed will appear on the screen. If for any reason, the u -ser has lost track of what he is doing, such as what mode he is in or even if he is in a command mode, typing will terminate whatever is going on, and re-start in the command mode. Hearing the bell ring during an edit session normally indicates . an error was made. Possible error could be the line buffer is full, as a maximum of 128 characters are allowed. Do to the fact that the EDITOR is not tied into BASIC in any way, it was not possible to be able to work on consecutive line numbers wi/thout exiting the EDITOR and calling the next line. This is only a slight inconvience and the possible uses of the EDITOR far outweigh this fact.   TTL RESIDENT BASIC LINE EDITOR * * 8/16/81: LAST REVISION DATE * * THIS PROGRAM INITIALLY LOADS INTO THE BASIC BUFFER AREA. * AFTER DETERMINING THE FLEX MEMEND ADDRESS, IT MOVES * ITSELF TO THE TOP OF MEMORY MINUS 2K FOR ITSELF. FLEXS' * MEMEND IS THEN ADJUSTED AND PROGRAM EXECUTION CONTINUES AT * THE NEW ADDRESS. UPON EXITING BASIC WITH THE "FLEX" COMMAND, * THE MEMEND ADDRESS IS RESTORED TO THE ORIGINAL VALUE. * * CONSIDERING THAT THE SEQUENCE OF COMMAND CODES IN THIS PROGRAM * USE THE ESCAPE  CHAR, EITHER THE EDITOR ESCAPE CHARACTER MUST * BE CHANGED TO ANOTHER OR THE FLEX TTYSET PAUSE CHARACTER MUST * BE OTHER THAN THE ESCAPE CHAR. RECOMMEND THE DELETE (7F) CHAR * FOR FLEXS' TTYSET PAUSE. * * REPLACED VECTORS ARE: (CODE); 7E CD15, 7E CD1 8 * BD CD24 7E CD03 * * EDIT COMMANDS ARE AS FOLLOWS: * * ENTER EDIT MODE - ESC E * EXIT EDIT MODE W/CHANGE - ESC X * CURSOR RIGHT - R * CURSOR LEFT - L * INSERT CHARACTER - U * DELETE CHARACTER - D * OVERLAY CHARACTER - O * RE-PRINT LINE - P  * CHANGE STRING - C * ABORT EDIT MODE - X * * FLEX SUBROUTINE LINKAGES * BCOLDS EQU 0 BASIC COLD START ADDRESS FLEX EQU $CD00 WARMS EQU FLEX+3 GETCHR EQU FLEX+21 PUTCHR EQU FLEX+24 PCRLF EQU FLEX+36 TTYPAU EQU $CC0A FLEX PAUSE CHARACTER MEMEND EQU $CC2B FLEX MEMORY END LOCATION * CR EQU $D CARRIAGE RETURN CODE LF EQU $A LINE FEED CODE ESC EQU $1B ESCAPE CODE BELL EQU 7 RING TERMINAL BELL CODE SPACE EQU $20 SPACE CHARACTER CODE MAXCTL EQU $1F MAX CONTROL CODE MAXASC EQU $7F MAXIMUM ASCII CHAR ALLOWED TO BE ENTERED * MAXSTR EQU 32 MAXIMUM # OF CHARS ALLOWED IN STRING CHANGE MAXLNE EQU 128 MAXIMUM # OF CHARS ALLOWED IN LINE BUFFER * ORG $8000 ONLY NEEDED FOR INITIAL LOAD OF PROGRAM * ******************** INITIALIZATION ROUTINE ************************* * START LDX MEMEND FIND OUT WHERE TO EXECUTE THIS PROGRAM LEAX -$7FF,X MAKE ROOM FOR THIS PROGRAM TFR X,Y TFR X,U LEAU START1-START,U NEW START ADDRESS PSHS U LEAY PEND-START,Y 'Y'  CONTAINS THE END ADDRESS PSHS Y LEAY START,PCR INITIAL PROGRAM LOAD ADDRESS ST1 LDA ,Y+ TRANSFER PROGRAM DOWN STA ,X+ CMPX ,S BNE ST1 LEAS 2,S FIX STACK WHEN FINISHED JMP [,S++] RESTART PROGRAM AT NEW ADDRESS * START1 BSR RE PVEC REPLACE VECTORS LDA TTYPAU GET TTYSET PAUSE CHARACTER STA PAUSE,PCR SAVE FOR FUTURE USE JMP BCOLDS GO TO BASIC COLD START * * THIS CODES ARE XMITTED TO THE TERMINAL * FDB $FFFF HELPFUL TO LOCATE TABLE IN RAM FDB $FFFF PORT FDB $E004 CONTROL PORT ADDRESS (STATUS REG SIDE) CURGHT FDB $1B43 CURSOR RIGHT CONTROLS CURLFT FDB $1B44 CURSOR LEFT CONTROLS HOMCLR FDB $1B45 HOME CURSOR & CLEAR SCREEN HOME FDB $1B48 HOME CURSOR, NO SCREEN ERASE WRPRND FDB $1B76 ENABLE CURS OR WRAP AROUND AT END OF LINE EXIT FDB $1B7A RESET TERMINAL UPON EXIT CODE * * THESE CODES ARE TYPED BY THE USER * LEADIN FCB ESC LEAD-IN CHAR TO SCREEN CRIGHT FCB 'R CURSOR RIGHT COMMAND FROM KEYBOARD CLEFT FCB 'L CURSOR LEFT COMMAND FROM KE YBOARD INSERT FCB 'I INSERT CHARACTER CODE DELETE FCB 'D DELETE CHARACTER CODE OVRLAY FCB 'O OVERLAY CHARACTERS CODE CHANGE FCB 'C CHANGE STRING CODE PRINT FCB 'P PRINT BUFFER CODE ABORT FCB $18 ABORT EDIT CODE CHKTX FCB 'X UPDATE BASIC CODE TERM FCB 3 ^C TO TERMINATE COMMAND MODES DONE FCB ESC ESCAPE CODE PART OF COMMAND BKSPAC FCB $08 BACKSPACE & DELETE CHAR LNEWTH FCB 80 CHARACTER LINE WIDTH OF TERMINAL EDTMOD FCB 'E ESC E TO ENTER EDIT MODE FDB $FFFF END OF ALTER ABLE RAM FDB $FFFF * * THESE FLAGS ARE UTILIZED TO CONTROL PROGRAM FLOW * PAUSE FCB 0 PAUSE CHAR TO STOPPING LISTING OLDMEM FDB 0 CURRENT MEMORY END LOCATION INEDIT FCB 0 IF MINUS, IN EDIT MODE LBUFPT FDB 0 ADDRESS INTO EDITOR LINE BUFFER L BFEND FDB 0 LAST CHARACTER IN LINE BUFFER VALID BUFPTR FDB 0 CURRENT LINE CHAR POINTER EOLFLG FCB 0 LINE BEING SAVED FLAG CHRBUF FCB 0 1ST CHAR OF TWO CHAR COMMAND ASCFLG FCB 0 ASCII RECEIVED EDTFLG FCB 0 GO EDIT UPDATE FCB 0 RE-XMIT LINE TO BASIC ESCFLG FCB 0 SET TILL VALID COMMAND VERIFIED SEPCHR FCB 0 CHANGE COMMAND SEPERATOR CHAR NOPRNT FCB 0 SUPPRESS RE-PRINTING LINE BKFLAG FCB 0 PREVIOUS ERROR FLAG COUNT FCB 0 NUMBER OF CHARS TYPED IN INSERT MODE CHRPOS FCB 0 CHARACTER POSITION ON THE CURRENT LINE ECHO FCB 0 ECHO/NO-ECHO INPUT LNFLG FCB 0 PAUSE AT CR ONLY CHRCNT FCB 0 NUMBER OF CHARS IN BUFFER FCB 1 VERSION * * SEARCH FOR INPUT & OUTPUT VECTORS AND REPLACE WITH * THE APPROPRIATE VECTORS THRU THIS PROGRAM * REPVEC LDX #0 START FROM BASE PAGE 0 CONT LDD ,X+ CHECK TWO BYTES, ONE BYTE AT A TIME CMPX #$FFF LAST LOCATION TO CHECK BEQ CONT1 CMPD #WARMS CHECK FOR EXIT TO FLEX ADDRESS BEQ GOTEXT CMPD #GETCHR CHECK FOR FLEX GETCHR VECTOR ADDRESS BEQ GOTINP IF FOUND CMPD #PCRLF FIND FLEX PCRLF VECTOR BEQ GOTCR CMPD #PUTCHR CHECK FOR FLEX PUTCHR VECTOR ADDRESS BNE CONT IF NO LEAU BPUT,PCR ADDRESS TO REPLACE WITH STU -1,X TO ALLOW FOR AUTO INCREMENT BRA CONT GO TILL END OF SEARCH RANGE * GOTEXT LEAU BOUT,PCR ADDRESS TO REPLACE WITH STU -1,X ALLOW FOR AUTO-INCREMENT BRA CONT * GOTINP LEAU BGET,PCR ADDRESS TO REPLACE WITH STU -1,X ALLOW FOR AUTO INCREMENT BRA CONT * GOTCR LEAU BCRLF,PCR ADDRESS TO REPLACE WITH STU -1,X BRA CONT * CONT1 LEAX LBUFER,PCR SET LBUFPT TO BEGINNING OF BUFFER STX LBUFPT,PCR POINT TO BEGINNING OF BUFFER STX LBFEND,PCR POINT END TO BEGINNING TO SHOW EMPTY LDX MEMEND SAVE OLD MEMORY END LOCATION STX OLDMEM,PCR LEAX START-1,PCR CHANGE FLEX MEMEND LOCATION STX MEMEND RTS * ******************** REPLACEMENT PCRLF ROUTINE ******************** * BCRLF PSHS A SAVE FOR RETURN LDA #-1 STA EOLFLG,PCR TELL CHAR COLLECTOR ROUTINE OF CR/LF LDA #CR LBSR BPUT PRINT IT LDA #LF LBSR OUTCHR PRINT BOTH CR & LF PULS A,PC RESTORE AND RETURN * * EXIT FROM BASIC GOES THRU THIS ROUTINE TO RESTORE MEMEND IN * FLEX, AND RESET TERMINAL. * BOUT LDX OLDMEM,PCR PICK UP O LD MEMEND ADDRESS STX MEMEND LDD EXIT,PCR RE-SET TERMINAL TO POWER UP CONFIG LBSR PUTTWO CLRA BDEL LBRN BDEL LBRN BDEL DECA WAIT TILL TERMINAL CLEARED BNE BDEL JMP WARMS * ****************** REPLACEMENT GETCHR ROUTINE ******** ************** * BGET TST UPDATE,PCR SEE IF LINE SHOULD BE SENT TO BASIC BPL BGET5 IF NO PSHS B,X,Y,U SAVE ALL LBRA DABRT4 YES, CONTINUE SENDING LINE TO BASIC * BGET5 TST ESCFLG,PCR IF MINUS, INVALID COMMAND ENTERED BPL BGET1 CLR ESCFLG,PCR CLEAR FOR NEXT TIME LDA CHRBUF,PCR GET PREVIOUSLY SAVED CHARACTER BRA BGETOT CARRY CHAR BACK TO BASIC * BGET1 LBSR INCHAR USE FLEX TO GET EACH CHARACTER CMPA LEADIN,PCR DO WE WANT EDIT MODE? BEQ DOEDIT IF YES BGETOT RTS * DOEDIT STA CHRBUF,PCR SAVE ESCAPE CHAR IF INVALID COMMAND LBSR INCHAR GET SECOND BYTE FROM FLEX CMPA EDTMOD,PCR MUST BE VALID TO ENTER EDIT MODE BEQ DEDIT1 PASTWO PSHS A,B SAVE B & CURRENT CHAR LDA CHRBUF,PCR GET LAST CHAR SAVED PULS B GET CURRENT CHAR INTO B STB CHRBUF,PCR SWAP WITH PREVIOUS CHAR LDB #-1 STB ESCFLG,PCR SET FOR NEXT GETCHR CALL PULS B,PC RESTORE ORIGINAL CONTENTS OF B * DEDIT1 LDA #-1 STA INEDIT,PCR INDICATE IN EDIT MODE LBRA INCHAR RETURN WITH VALID CHAR FOR BASIC * ****************************************************************** * * THE FOLLOWING ROUTINE OUTPUTS SEVERAL FUNCTION CODES TO SET UP * THE PARTICULAR TERMINAL BEING USED. IF THE FUNCTION DOES NOT * EXIST IN YOUR TERMINAL, SIMPLY ENTER ZEROES IN THE FDB TABLE IN * THE BEGINNING OF THE SOURCE. IF MORE FUNCTIONS ARE NEEDED, THE * SOURCE CAN BE SIMPLY BE RE-EDITED WITH ADDITIONS BEING MADE. * DEDIT5 LDD WRPRND,PCR CURSOR WRAP AROUND AT END OF LINE LBSR PUTTWO LDD  HOMCLR,PCR CLEAR SCREEN & HOME CURSOR LBSR PUTTWO BSR CNTCHR FIND NUMBER OF CHARS IN BUFFER STA CHRCNT,PCR AND SAVE FOR FUTURE REFERENCE LEAX LBUFER,PCR PRINT CONTENTS OF LINE BUFFER CMPX LBFEND,PCR SEE IF ANY CODE TO EDIT BNE DEDIT6! LBSR DOABRT INDICATE ABORTED MODE LDA #CR RETURN WITH CARRIAGE RETURN CHARACTER BEXIT PULS B,X,Y,U,PC RESTORE ALL AND RETURN TO NORMAL BASIC * * * DETERMINE HOW MANY CHARS ARE IN LINE BUFFER TO BE EDITED * AND KEEP TRACK THROUGH-OUT PROGRAM" * CNTCHR LEAX LBUFER,PCR POINT TO FIRST CHAR CLRA EMPTY CHAR COUNTER CNT1 LDB ,X+ TEST FOR CR'S CMPB #CR BEQ CNT2 INCA UPDATE CHAR COUNTER BRA CNT1 CNT2 INCA RTS LEAVE WITH TOTAL INCLUDING CR * DEDIT6 LDA ,X+ CMPA #CR BEQ # DEDIT3 IF END OF LINE LBSR OUTCHR BRA DEDIT6 * DEDIT3 LBSR OUTCHR SEND CURSOR TO BEGINNING OF LINE DED LEAX LBUFER,PCR POINT INDEX TO FIRST CHARACTER LDD HOME,PCR LBSR PUTTWO LBSR RNGBEL INDICATE BEGINNING OF BUFFER CLR CHRPOS $,PCR START WITH CHAR POS 0 DEDIT4 CLR COUNT,PCR LDA #-1 TURN OFF CHAR ECHO STA ECHO,PCR LBSR INCHAR GET COMMAND CHARACTER CLR ECHO,PCR CMPA #CR IF MISTAKEN KEY BEQ DEDIT3 * * DO THE COMPARES FOR EACH CONTROL COMMAND CHARACTER TO *% DETERMINE WHAT NEEDS TO BE DONE * DEDA CMPA CRIGHT,PCR CURSOR RIGHT BEQ DORGHT DO CURSOR RIGHT CMPA CLEFT,PCR CURSOR LEFT LBEQ DOLEFT DO CURSOR LEFT CMPA INSERT,PCR INSERT CHARACTER LBEQ DOINS DO INSERT CMPA DELETE,PCR DELETE C&HARACTER LBEQ DODEL DO DELETE CMPA OVRLAY,PCR OVERLAY CHARACTERS LBEQ DOOVR DO OVERLAY CMPA CHANGE,PCR CHANGE STRING LBEQ DOCHG DO CHANGE CMPA PRINT,PCR RE-PRINT LINE LBEQ DOPRT DO PRINT CMPA ABORT,PCR ABORT EDIT MODE LB'EQ DABRT1 DO ABORT CMPA DONE,PCR TEST FOR ESCAPE LBEQ CHKX GO CHECK FOR AN X TO EXIT WITH UPDATES LBSR RNGBEL INDICATE INVALID COMMAND CODE ENTERED LBRA DEDIT4 INVALID, GO TRY AGAIN * * MOVE THE CURSOR ONE POSITION TO THE RIGHT & BUMP( THE BUFFER POINTER. * IF THE CURSOR IS POINTING TO THE CR AT THE END OF THE LINE, THE * BELL RINGS, AND THE CURSOR REMAINS WHERE IT WAS * DORGHT LDA ,X TEST IF END OF LINE CMPA #CR BNE C1 INDICATE END OF LINE BSR RNGBEL BRA DEDIT4 * C1 )LDD CURGHT,PCR BSR PUTTWO PRINT CHARACTER SEQUENCE FOR TERMINAL LEAX 1,X MOVE POINTER TO NEXT CHARACTER INC CHRPOS,PCR UPDATE POSITION COUNTER LDA CHRPOS,PCR CMPA LNEWTH,PCR IS IT END OF LINE? LBNE DEDIT4 LBSR DOCRLF LBRA *DEDIT4 * * MOVE THE CURSOR ONE POSITION TO THE LEFT & BUMP THE BUFFER POINTER * IF THE CURSOR IS ON THE FIRST POSITION, THE BELL RINGS AND THE * CURSOR REMAINS WHERE IT WAS. * DOLEFT LEAU LBUFER,PCR LOAD ADDR OF BUFFER PSHS U PUT ON STACK TO WORK+ WITH CMPX ,S++ IS IT EQUAL TO X? BNE D1 IF YES BSR RNGBEL LBRA DEDIT4 * D1 LDD CURLFT,PCR PUT OUT CURSOR LEFT CODE TO TERMINAL BSR PUTTWO LEAX -1,X POINT TO PREVIOUS CHARACTER DEC CHRPOS,PCR LBRA DEDIT4 * * PRINT THE TWO ,CHARACTERS IN THE A & B REGISTERS, A 1ST * PUTTWO LBSR OUTCHR TFR B,A LBSR OUTCHR CLRA LBSR OUTCHR PAD WITH TWO NULLS LBRA OUTCHR * * RING THE BELL ON THE TERMINAL TO INDICATE AN ERROR CONDITION * RNGBEL LDA #BELL LBRA OUTCHR * * IN -SERT A CHARACTER INTO THE CURRENT LINE. USER REMAINS IN INSERT * MODE UNTIL THE TERMINATOR COMMAND IS TYPED. AS A CHARACTER IS * TYPED, THE REMAINDER OF THE LINE MOVES ONE POSITION TO THE RIGHT. * THE COMMAND MAY ALSO BE TERMINATED WITH A CR. THIS WI .LL POSITION * THE CURSOR TO THE BEGINNING OF THE LINE AND POINT THE LINE BUFFER * POINTER TO THE FIRST CHARACTER IN THE LINE * DOINS PSHS X TEST FOR END OF BUFFER LEAY LBUFER+MAXLNE,PCR CMPY ,S++ BEQ T3 LDA CHRCNT,PCR SEE IF BUFFER IS F/ULL CMPA #MAXLNE BEQ T3 LBSR INCHAR GET CHAR TO INSERT OR TERMINATOR CMPA #CR LBEQ DED CMPA TERM,PCR TERMINATE WITH CURRENT LINE POINTER POSITION BNE B7 T3 LBSR RNGBEL INDICATE END OF COMMAND LBRA DEDIT4 B7 CMPA BKSPAC,PC0R IF ERROR BNE B1 LDA #-1 STA BKFLAG,PCR BRA B3 * B1 CMPA #MAXCTL TEST FOR CONTROL CODES BLS DOINS CMPA #MAXASC BHS DOINS INC COUNT,PCR UPDATE CHAR ENTERED COUNT B3 LDB CHRPOS,PCR CMPB LNEWTH,PCR ARE WE AT END OF LINE1? BNE U1 IF NOT DEC CHRCNT,PCR U1 BSR DOINSC INC CHRPOS,PCR KEEP TRACK OF CURSOR POSITION INC CHRCNT,PCR UPDATE CHAR TOTAL BRA DOINS * DOINSC TST BKFLAG,PCR BPL B2 TST COUNT,PCR MAKE SURE SOME CHAR HAVE BEEN ENTERED BNE B24 LDD CURGHT,PCR LBSR PUTTWO MOVE CURSOR BACK FORWARD IN COUNT ZERO BSR RNGBEL INDICATE ERROR CLR BKFLAG,PCR RTS * B4 LEAX -1,X FIX BUFFER POINTER BACK ONE CHAR LBSR DODELB DEC COUNT,PCR UP CHAR COUNTER CLR BKFLAG,PCR RTS3 * B2 STX BUFPTR,PCR SAVE POINTER POSITION DOINS2 LDB ,X+ RE-PRINT REST OF LINE STB CHRBUF,PCR SAVE EACH CHAR ONE PASS STA -1,X REPLACE OLD WITH NEW TFR B,A TST NOPRNT,PCR SHALL WE PRINT? BMI A1 LBSR OUTCHR RE-PRINT LINE A1 4LDA ,X SAVE NEXT CHAR TST NOPRNT,PCR BMI A2 LBSR OUTCHR PRINT CHAR IN 'A' A2 CMPA #CR BNE DOINS7 STB ,X+ STORE LAST CHAR BEFORE CR STA X PUT CR IN BUFFER AT END OF STRING BRA DOINS8 * DOINS7 STB ,X+ RESTORE OLD CHAR CMPB5 #CR TEST FOR END OF LINE BNE DOINS2 DOINS8 LDX BUFPTR,PCR CURRENT CURSOR POSITION POINTER LEAX 1,X POINT TO LAST OLD CHAR PSHS X LDD HOME,PCR START CURSOR ON TOP LINE, 1ST POSITION LBSR PUTTWO LEAY LBUFER,PCR DOINS3 CMPY ,S A6RE WE POINTING TO CORRECT POSITION? BEQ DOINS6 IF YES LDD CURGHT,PCR SKIP CURSOR OVER LINE TO POINTER LOCATION TST NOPRNT,PCR BMI A3 LBSR PUTTWO A3 LEAY 1,Y UPDATE BUFFER POINTER BRA DOINS3 * DOINS6 LEAS 2,S FIX STACK BEFORE LE 7AVING RTS * * DELETE A CHARACTER POINTED TO BY THE CURSOR. EACH TIME A 'D' IS * TYPED, THE CHARACTER DISAPPEARS AND THE REMAINDER OF THE LINE * MOVES ONE POSITION TO THE LEFT * DODEL BSR DODELB LBRA DEDIT4 * DODELB DEC CHRCNT,PCR UPDATE LINE  8CHAR TOTAL BPL U2 INC CHRCNT,PCR LBRA RNGBEL IF NO CHARS, RETURN U2 LEAY LBUFER,PCR NEED POINTER TO END OF STRING DODEL1 LDA ,Y+ FIND CR CMPA #CR BNE DODEL1 IF NOT FOUND LEAX 1,X POINT TO NEXT CHARACTER AFTER DEL'D CHAR STX 9BUFPTR,PCR SAVE POINTER POSITION PSHS Y PUSH LINE END POINTER LEAU -1,X DODEL2 LDA ,X+ RE-PRINT REST OF LINE CMPA #CR TEST FOR END OF LINE BNE DODEL4 PSHS A LDA #SPACE ERASE LAST CHAR ON SCREEN TST NOPRNT,PCR SHALL WE PRINT:? BMI A4 IF NO LBSR OUTCHR A4 PULS A DODEL4 STA ,U+ PACK LINE BUFFER DOWN ONE CHAR TST NOPRNT,PCR BMI A5 LBSR OUTCHR A5 CMPX ,S ARE WE AT END OF LINE? BNE DODEL2 DODEL9 LEAS 2,S FIX STACK LDD HOME,PCR START CURSOR ON TOP; LINE, 1ST POSITION LBSR PUTTWO LDY BUFPTR,PCR WHERE TO PUT CURSOR LEAY -1,Y BACK UP ONE CHAR LEAX LBUFER,PCR BEGIN ADDRESS OF BUFFER PSHS Y WHERE TO MOVE TO DODEL3 LDD CURGHT,PCR SKIP CURSOR OVER LINE TO POINTER LOCATION TST NOECOGNIZED AS THE SEPARATOR CHARACTER * AND MUST BE USED TO SEPARATE THE TWO STRINGS AND THE END OF THE * COMMAND. A CR MAY ALSO BE USED TO TERMINATE THE COMMAND * EX: C/OLD/NEW/ OR C/OLD/NEW(CR) * DOCHG LBSR DOCRLF LEAVE ROOM FOR DATA LBSR DOC?RLF  LDA #'C LBSR OUTCHR INDICATE CHANGE MODE X1 LBSR INCHAR INPUT SEPARATOR CHAR CMPA #MAXCTL TEST FOR CONTROL CODES BLS X1 STA SEPCHR,PCR SAVE AWHILE E7 CLRB CHAR INPUTTED COUNTER LEAY OLDBUF,PCR STRING TO REPLACE * * READ @IN STRING TO BE CHANGED * DOCHG1 LBSR INCHAR NOW INPUT STRING TO CHANGE CMPA ABORT,PCR IF WANTS TO END COMMAND BNE T1 LBSR RNGBEL INDICATE TERMINATION LBRA DOPRT * T1 CMPA BKSPAC,PCR IF USER WANTS TO CORRECT ENTRY BNE E1 DECB FI AX CHAR COUNT BPL E8 LDD CURGHT,PCR LBSR PUTTWO LBSR RNGBEL BRA E7 * E8 LDA #SPACE ERASE PREVIOUS ENTRY LBSR OUTCHR LDA BKSPAC,PCR FIX CURSOR LBSR OUTCHR E2 LEAY -1,Y FIX CHAR POINTER BRA DOCHG1 * E1 CMPA #MAXCTL TEST B FOR CONTROL CODES BLS DOCHG1 CMPA #MAXASC TEST FOR HIGHEST VALID CHAR BHS DOCHG1 CMPA SEPCHR,PCR INDICATES END OF STRING TO CHANGE BEQ DOCHG2 * INCB UPDATE CHAR COUNTER CMPB #MAXSTR MAXIMUM ALLOWED LBEQ DOPRT REPRINT LINE ANCD EXIT STA ,Y+ PUT STRING IN BUFFER BRA DOCHG1 * DOCHG2 TSTB MUST HAVE SOME COUNT LBEQ DOPRT IF NOT, ABORT COMMAND PSHS B SAVE CHAR COUNT E6 CLRB PREPARE COUNTER AGAIN LEAU NEWBUF,PCR * * READ IN STRING THAT WILL REPLACE PREVIOUS SDTRING * DOCHG5 LBSR INCHAR NOW INPUT STRING TO CHANGE TO CMPA ABORT,PCR BNE Y1 LBSR RNGBEL INDICATE TERMINATION PULS B FIX STACK LBRA DOPRT * Y1 CMPA BKSPAC,PCR SEE IF ERROR IN ENTRY BNE E4 DECB BPL E10 LDD CURGHT,PCR ELBSR PUTTWO LBSR RNGBEL BRA E6 * E10 LDA #SPACE LBSR OUTCHR ERASE PREVIOUS ENTRY LDA BKSPAC,PCR LBSR OUTCHR FIX CURSOR LEAU -1,U FIX CHAR POINTER BRA DOCHG5 * E4 CMPA #MAXCTL BLS DOCHG5 CMPA #MAXASC TEST FOR HIGHESTF VALID CHAR BHS DOCHG5 CMPA SEPCHR,PCR TEST FOR TERMINATOR BEQ DOCHG3 CMPA #CR CR OK TOO BEQ DOCHG3 * E3 INCB UPDATE CHAR COUNTER CMPB #MAXSTR TEST FOR MAXIMUM LBEQ DOPRT IF TOO MANY, RE-PRINT LINE AND ABORT STA ,U+ BRA GDOCHG5 * DOCHG3 PSHS B SAVE THIS CHAR COUNT TOO LEAX LBUFER,PCR NOW FIND THE FIRST OCCURANCE OF STRING DOCHG7 LEAY OLDBUF,PCR LDB 1,S GET OLD CHAR COUNT DOCHG6 LDA ,X+ SEARCH LINE BUFFER FOR STRING CMPA #CR ARE WE AT END OF BUFFER? BHNE DOCHG4 LBRA DEDIT3 PRINT CR ON EXIT * DOCHG4 CMPA ,Y+ BNE DOCHG7 IF A MATCH FOR ONE CHAR DECB BNE DOCHG6 LDB 1,S FOUND THE STRING, NOW POINT TO IT DECB COMB LDA #-1 LEAX D,X MOVE X BACK TO BEGIN OF STRING CLRA LDB IS TFR D,Y GET NEW CHAR COUNT INTO 'Y' LDB 1,S GET OLD CHAR COUNT INTO 'B' LEAU NEWBUF,PCR POINT TO STRING TO INSERT IN PLACE OF LEAS 2,S FIX STACK NOW THAT FINISHED WITH COUNTERS CMPY #0 IF ONLY DELETING A STRING, NO REPLACEMENT BJEQ DOCHGA DOCHG8 LDA ,U+ STA ,X+ DECB BEQ DOCHG9 LEAY -1,Y BNE DOCHG8 BRA DOCHGA * * OLD STRING HAS BEEN REPLACED. MAY-BE MORE NEW STRING TO INSERT * DOCHG9 LDA #-1 STA NOPRNT,PCR DOCHGZ LEAY -1,Y BNE DOCHGD DOCHGF CLR NOPR KNT,PCR BRA DOPRT * DOCHGD LDA ,U+ GET NEXT CHAR TO INSERT PSHS Y,U,B SAVE ALL FOR RETURN LBSR DOINSC INSERT REST OF NEW STRING INC CHRCNT,PCR UPDATE BUFFER CHAR TOTAL LDA CHRCNT,PCR CMPA #MAXLNE SEE IF LIMIT REACHED BEQ DOCHG LE PULS Y,U,B BRA DOCHGZ DOCHGE LEAS 5,S FIX STACK DEC CHRCNT,PCR BRA DOCHGF * * IF HERE, NEW STRING HAS BEEN INSERTED, BUT MORE OF OLD STRING * MUST BE DELETED. * DOCHGA LDA #-1 STA NOPRNT,PCR DOCHGY PSHS B SAVE CHAR COUNTER LBSR MDODELB DELETE REST OF OLD LINE PULS B DECB BNE DOCHGY CLR NOPRNT,PCR BRA DOPRT RE-PRINT LINE ON EXIT * * THIS COMMAND OVERLAYS AND REPLACES THE CHARACTER UNDER THE CURSOR * WITH THE CHARACTER NOW TYPED. TERMINATE WITH A CR OR TERMINATNOR * CHARACTER. CR RETURNS TO BEGIN OF LINE, TERMINATOR CHAR TERMINATES * MODE AT CURRENT CURSOR POSITION. * DOOVR LBSR INCHAR PICK UP NEW CHARACTER TO REPLACE WITH CMPA #CR CR INDICATES END OF OVERLAY MODE LBEQ DED CMPA TERM,PCR OVERLAYO CHAR WILL TERMINATE BNE T5 LBSR RNGBEL INDICATE COMMAND FINISHED LBRA DEDIT4 * T5 CMPA #MAXCTL BLS DOOVR CMPA #MAXASC BHS DOOVR STA ,X+ AND PUT IN BUFFER INC CHRPOS,PCR UPDATE POSITION COUNTER LDA CHRPOS,PCR CMPA LNEPWTH,PCR IS IT END OF LINE? BNE DOOVR LBSR DOCRLF BRA DOOVR * * THIS COMMAND REPRINTS THE ENTIRE LINE AS IT NOW APPEARS AFTER * CHANGES. * DOPRT LDD HOMCLR,PCR CLEAR THE SCREEN AND HOME CURSOR LBSR PUTTWO LEAX LBUFER,PCR DOPRT1 LDA ,QX+ CMPA #CR IS IT EOL? LBEQ DED LBSR OUTCHR BRA DOPRT1 * * THIS COMMAND TESTS FOR THE END SEQUENCE WHICH WILL XMIT THE * EDITED LINE BACK TO BASIC. * CHKX LDA #$FF TURN OFF CHAR ECHO STA ECHO,PCR LBSR INCHAR GET 2ND COMMAND CHAR R CLR ECHO,PCR RE-ENABLE ECHO CMPA CHKTX,PCR TEST FOR EXIT COMMAND LBNE DEDIT4 BSR DOABRT CHKOUT LDA #-1 STA UPDATE,PCR INDICATE EXITING WITH CHANGES TO BE MADE DABRT4 LDX LBUFPT,PCR LDA ,X+ GET CHARACTER TO RETURN TO BASIC STX SLBUFPT,PCR UPDATE LINE BUFFER POINTER CMPA #CR IS IT END OF LINE? BNE DABRT2 IF NO CLR UPDATE,PCR LEAX LBUFER,PCR RELOAD POINTERS FOR NEXT EDIT SESSION STX LBUFPT,PCR BSR CLRBUF FILL LINE BUFFER WITH NULLS DABRT2 PULS B,X,Y,U,PCT * * THIS COMMAND ABORTS THE EDIT FUNCTION WITH NO CHANGES BEING MADE * DABRT1 BSR DOABRT BSR CLRBUF DABRT3 LDA #CR RETURN TO BASIC WITH CARRIAGE RETURN CHAR PULS B,X,Y,U,PC * DOABRT LEAX LBUFER,PCR RE-SET ALL PARAMETERS STX LBUFPT,PCR  USTX LBFEND,PCR CLR ESCFLG,PCR CLR INEDIT,PCR CLR UPDATE,PCR DON'T WANT NEW DATA CLR EDTFLG,PCR CLEAR EDIT MODE FLAG CLR EOLFLG,PCR CLR ASCFLG,PCR CLR CHRCNT,PCR INDICATE BUFFER EMPTY LDD HOMCLR,PCR EXIT WITH CLEAN SCREEN LB VRA PUTTWO * CLRBUF LEAX OLDBUF+MAXLNE+65,PCR POINT TO END OF BUFFER PSHS X SAVE ON STACK LEAX OLDBUF,PCR POINT TO BEGINNING OF BUFFER CLRB CLR ,X+ FILL BUFFER WITH NULLS CMPX ,S BNE CLRB PULS X,PC * ******************** REPLACEMEWNT PUTCHR ROUTINE ******************** * * THIS ROUTINE ACTS LIKE THE FLEX PUTCHR ROUTINE UNTIL * IT DETECTS THE 'IN EDIT FLAG' (INEDIT) SET. AT THIS POINT * ALL CHARACTERS RECEIVED UNTIL A CR ARE STORED IN A BUFFER * CAPABLE OF HOLDING 128 CHARACTERSX. UPON THE FINAL CR, THE * ROUTINE JUMPS TO THE EDITING PORTION OF THE PROGRAM. * BPUT PSHS B,X,Y,U DON'T DESTROY ANY REGISTERS TST INEDIT,PCR SHALL WE SAVE THIS LINE? BPL BPUT3 LDX LBUFPT,PCR * * TEST FOR CR RECEIVED, BUT NO ASCII CHARS *Y TST EOLFLG,PCR BPL BPUT10 * * TEST FOR PREVIOUS ASCII, NO CR * BPUT12 TST ASCFLG,PCR BPL BPUT10 CLR INEDIT,PCR CLR ASCFLG,PCR CLR EOLFLG,PCR LDB #-1 STB EDTFLG,PCR BRA BPUT1 * * TEST FOR CR IN NOW, BUT ALSO RECEIVED ASCII *Z BPUT10 CMPA #MAXCTL TEST FOR VALID ASCII BLS BPUT3 IF CONTROL CHARS (CR) LDB #-1 STB ASCFLG,PCR CLR EOLFLG,PCR EMPTY CR FLAG FOR NEXT PASS BPUT1 STA ,X+ SAVE EACH LINE AS IT IS ENTERED BPUT2 STX LBUFPT,PCR UPDATE LINE BUFFER POINTE[R STX LBFEND,PCR BPUT3 BSR OUTCHR PRINT THE CHARACTER THRU FLEX TST EDTFLG,PCR LBMI DEDIT5 EXIT TO THE EDITOR PULS B,X,Y,U,PC RESTORE AND RETURN * INCHAR PSHS X,B SAVE FOR LATER LDX PORT,PCR INCHR1 BSR BTESTR BEQ INCHR1 LDA \1,X GET RECEIVED CHAR ANDA #MAXASC STRIP PARITY IF USED INCHR3 CMPA BKSPAC,PCR BNE INCHR4 BSR BAKSPC DO BACK SPACE AND DELETE INCHR4 PULS B,X TST ECHO,PCR SHALL WE ECHO THE CHAR? BPL OUTCHR INCOUT RTS * OUTCHR PSHS B,X LDX POR]T,PCR CMPA #CR TEST FOR CARRIAGE RETURN BNE INOUT7 IF NO TST LNFLG,PCR TEST FOR PAUSE AT EOL BPL INOUT7 IF NO PAUSE PSHS A SAVE RECEIVED CHAR INOUT2 BSR BTESTR WAIT FOR ANOTHER CHAR BEQ INOUT2 LDA 1,X ANDA #MAXASC STRIP P^ARITY CMPA PAUSE,PCR IF NO, CONTINUE LOOPING BNE INOUT2 PULS A IF YES, CONTINUE DISPLAY CLR LNFLG,PCR BRA INOUT1 * INOUT7 BSR BTESTR TEST FOR KEY PRESSED BEQ INOUT1 LDB 1,X ANDB #MAXASC CMPB PAUSE,PCR TEST FOR PAUSE CHARA _CTER BNE INOUT1 LDB #-1 STB LNFLG,PCR SET FOR EOL STOP INOUT1 BSR BTESTX WAIT FOR ACIA BEQ INOUT1 STA 1,X PRINT CHAR PULS B,X,PC AND RETURN * BTESTR LDB X GET STATUS BIT BITB #1 TEST FOR RECEIVED RTS * BTESTX LDB X GET  `STATUS BIT BITB #2 TEST FOR READY TO XMIT RTS * BAKSPC PSHS A LDA BKSPAC,PCR BACK SPACE TO PREVIOUS CHAR BAKSP1 BSR BTESTX BEQ BAKSP1 STA 1,X LDA #SPACE ERASE PREVIOUS CHAR BAKSP2 BSR BTESTX BEQ BAKSP2 STA 1,X PULS A,PC aRESTORE BACKSPACE CHAR FOR OUTPUT * DOCRLF PSHS A,B,X LDX PORT,PCR DOCRL1 BSR BTESTX BEQ DOCRL1 LDA #CR STA 1,X DOCRL2 BSR BTESTX BEQ DOCRL2 LDA #LF STA 1,X PULS B,A,X,PC * OLDBUF RMB MAXSTR NEWBUF RMB MAXSTR LBUFER RMB MAbXLNE PEND EQU * * END START  o0&=@ +,`#   ī%[& @o @-%1ī%C& o -%@m'Dm&~!$A ?  $~@ }'۽$ | Zm&ަC'׾!$.' Ё9# o0Z&.' -% |'% 0Z* oC&{$&cm'e+m+ D }&,DA=='0=ˆAM'&0A @ A% C &~~$00o_9.D. o_~9& 0Z&9 D00Z&9$@&~ˍ ~~m &@L 4  5 @&;m*~L'~X;@4455@m'l@'& 0 H~b'J0 ԶC' `k0&&I'0 }' @&' & 9''~º~9 _Y&*_Y&׎ &$~w!%9".' 4''5_]9 xCOPIED COPY COMPLETE TO DRIVE #NO SUCH FILE FILE EXISTS DELETE ORIGINAL?  ARE YOU SURE? STARTUPTXT TTL DCOMP16 3-5-81 * BASIC DECOMPILER FOR TSC 6809 XBASIC VEREND JMP START1 SFCB EQU $C840 WARMS EQU $CD03 GETCHR EQU $CD15 PUTCHR EQU $CD18 INBUFF EQU $CD1B PCRLF EQU $CD24 GETFIL EQU $CD2D SETEXT EQU $CD33 RPTERR EQU $CD3F FMS EQ U $D406 PSTR EQU $CD1E FLEX PSTRNG O0 RMB 7 OPERAND OP RMB 1 OPER POWER R0 RMB 7 RESULT DECCNT RMB 1 DECIMAL CNT PTENPT RMB 2 POWER OF TEN SAVE EXPON RMB 2 DECIMAL EXPONENT DIGCNT RMB 1 DIGIT CNTR XSAVE RMB 2 DDIGIT RMB 1 OUT DEC SAVE ZFLAG RMB 1 OUTDEC ZERO FLAG DSKFLG RMB 1 DISK FLAG DIGSAV RMB 20 DIGIT SAVE AREA COUNT1 RMB 1 DECODE COUNTER BCOUNT RMB 1 BYTE COUNT OF LINE VEND RMB 2 VARIABLE TABLE END PUTCHX TST DSKFLG BEQ PUTCHY PSHX LDX #WFCB JSR DOFMS PUL X,PC PUTCHY JMP PUTCHR PCRLFX LDA #$D TST DSKFLG BNE PUTCHX JMP PCRLF START1 LDX #LINEIN JSR PSTR CLR DSKFLG CLR COUNT1 LDX #SFCB JSR GETFIL BCS RPTER1 ERROR LDA #8 .BAC EXT JSR SETEXT LDA #1 OPEN READ STA 0,X BSR DOFMS OPEN BSR DOFMS GET START $89 CMPA #$89 BNE CLOSE NOT .BAC LDA #$FF SET BINARY FILE STA 59,X SPACE COMPR FLAG BSR DOFMS STA BCOUNT FIRST BYTE COUNT LDX #ASKDSK JSR PSTR JSR GETCHR CMPA #'Y BNE SCROLL LDX #FILNAM JSR PSTR JSR INBUFF LDX #WFCB JSR GETFIL BCS RPTER1 LDA #3 .BAS DEFAULT JSR SETEXT LDA #2 OPEN WRITE STA 0,X BSR DOFMS INC DSKFLG SCROLL LDX #CRLF JSR PSTR LDX #VTABLE STX VEND NLINE BSR GETLIN BSR OUTLIN BSR PCRLFX TST BCOUNT END? BEQ CLOSE BRA NLINE NEXT LINE DOFMS JSR FMS DO FMS CALL BEQ RTS2 RPTER1 JSR RPTERR CLOSE LDX #SFCB LDA #4 STA 0,X JSR FMS CLOSE FILE LDX #WFCB LDA #4 JSR FMS CLOSE FILE JMP WARMS GETLIN LDY #LINEIN GET LINE LDX #SFCB NCHR BSR DOFMS NEXT CHAR INC COUNT1 SUBA COUNT1 DECODE STA 0,Y+ DEC BCOUNT LDB BCOUNT CMPB #$FF BNE NCHR CLR 0,-Y STA BCOUNT NEW BYT E CNT RTS OUTLIN LDX #LINEIN OUTPUT LINE BSR OUTDC1 LDA #$20 BSR PUTCH1 OUTLN1 BSR ENDLIN LDA 0,X CMPA #$7D EOL? BNE OUTLN1 CONT WITH LINE RTS2 RTS ENDLIN LDA 0,X+ END LINE BEQ RTS2 BMI NUMBER CMPA #$17 DATA? B EQ DATA JMP DECODE DATA JSR DECODE PRINT DATA STATEMENT DATA1 LDA 0,X+ CMPA #$0D BEQ RTS2 BSR PUTCH1 BRA DATA1 OUTDC CLR 0,X OUTDC1 CLR ZFLAG LDY #TENK OUTDCA CLR DDIGIT LDD 0,X OUTDC2 SUBD 0,Y BCS OUTDC3 INC DDI GIT INC ZFLAG STD 0,X BRA OUTDC2 OUTDC3 TST 3,Y BEQ OUTDC4 TST ZFLAG BEQ OUTDC5 OUTDC4 LDA DDIGIT ADDA #'0 BSR PUTCH1 OUTDC5 LEAY 2,Y TST 1,Y BNE OUTDCA LEAX 2,X RTS NUMBER LDU 0,X++ OUTPUT NUMBER OR STRING C MPA #$90 DIM VAR? BEQ VSAVE CMPA #$80 VARIABLE? BEQ VSAVE CMPA #$91 DIM VIRTUAL STRING? BEQ NUMB1 CMPA #$81 STRING VAR? BNE NUMB2 NUMB1 BSR VSAVE LDA #'$ BRA PUTCH1 NUMB2 CMPA #$94 DIM INTEGER? BEQ NUMB2A CMPA #$84 INTEGER VARIABLE? BNE NUMB9 NUMB2A BSR VSAVE LDA #'% PUTCH1 JMP PUTCHX NUMB9 CMPA #$A0 F.P. CONSTANT? BNE NUMB3 PSHX LEAU -2,X JSR DOFPN DO FLOATING POINT PULX LEAX 7,X RTS NUMB3 CMPA #$A1 STRING CONSTANT? BNE NUMB4 TFR U,D NUMB3A LDA 0,X+ BSR PUTCH1 DECB BNE NUMB3A RTS NUMB4 CMPA #$A2 LINE # CONSTANT? BNE NUMB5 LEAX -2,X BRA OUTDC1 NUMB5 CMPA #$A4 INTEGER CONSTANT? BNE BADNUM LEAX -2,X JSR OUTDC1 INX RTS VSAVE PSHX VARIABLE CHK & SAVE LDX #VTABLE STU [VEND] STORE AT END VSAV1 CMPU 0,X++ BNE VSAV1 CPX VEND BLS VSAV2 STX VEND VSAV2 LEAX -2,X TFR X,D SUBD #VTABLE LSRA RORB PSH B,A ANDB #7 ADDB #$31 LDA 1,S LSRA LSRA LSRA ADDA 0,S++ ADDA #$41 CMPA #$5B >Z? BLO VOK SUBA #$1A DOUBLE LETTER VAR ADDB #$10 CMPD #$4946 'IF' BNE VOK LDB #'I VOK BSR PUTCH1 TFR B,A BSR PUTCH1 PUL X,PC DECODE LDY #DTABLE DECODE TABLE OFFSETS DECOD1 TST 0,Y+ BNE DECOD1 DECA BNE DECOD1 BRA PDATA PDATA1 JSR PUTCHX OUTPUT STRING PDATA LDA 0,Y+ BNE PDATA1 RTS BADNUM LDX #NUMERR UNDECODED NUMBER ERRPRC JSR PSTR JMP CLOSE DOFPN JSR CKZERO DO FLOATING POINT NUMBER LDA 7,U POWER EORA #$80 STA 7,U LDX #DIGSAV LDA #20 CLRDS CLR 0,X+ CLEAR DATA SAVE AREA DECA BNE CLRDS LDB 0,U BPL NOSIGN LDA #'- JSR PUTCH2 NOSIGN ORB #$80 STB 0,U PUT LEADING '1' JSR SEARCH LDA 9,X  STA EXPON+1 SAVE EXPONENT CLR DIGCNT NXTDIG STX PTENPT NEXT DIGIT CLR DECCNT JSR MOVXO JSR ALIGN DODIGT JSR SUBUOR DO DIGIT INC DECCNT ADD 1 TO DIGIT LDX #O0 JSR CMPUX BLO DONDIG JSR RTOU BRA DODIGT DONDIG LDA DECCNT DONE DIGIT DECA LDX #DIGSAV+1 LDB DIGCNT STA B,X LDX PTENPT CPX #PTENE POWER TEN END BEQ DONDG1 LEAX 10,X NEXT DIGIT INC DIGCNT LDA DIGCNT CMPA #16 16 DIGITS BNE NXTDIG DONDG1 LDX #DIGSAV+2 DONDG2 LDA 0,X+ CPX #DIGSAV+21 BEQ DONDG3 CMPA #10 ROLLOFF ERROR BNE DONDG2 INC -2,X CLR -1,X MAKE=0 BRA DONDG1 DONDG3 LDX #DIGSAV BSR DODEC FORZ LDA 0,X+ TEST FOR ZERO BEQ FORZ CPX #DIGSAV+21 BHS OUTEX2 LDA #'. BSR PUTCH 2 LDX #DIGSAV+1 BSR DODEC LDX #DIGSAV+2 OUTDG1 CLR 0,X STX XSAVE OUTDG2 LDA 0,X+ BEQ OUTDG2 CPX #DIGSAV+21 BHS OUTEXP LDX XSAVE BSR DODEC LDX XSAVE INX BRA OUTDG1 OUTEXP TST EXPON+1 OUT EXPONENT BEQ RTS3 POWE R=E+0 OUTEX2 LDA #'E BSR PUTCH2 TST EXPON+1 BPL OUTEX1 NEG EXPON+1 LDA #'- BSR PUTCH2 OUTEX1 LDX #EXPON DODEC JMP OUTDC CKZERO LDD 0,U CHECK FOR ZERO BNE RTS3 LDD 2,U BNE RTS3 LDD 4,U BNE RTS3 LDD 6,U BNE RTS3 LEAS 2,S FIX RETURN BSR OUT0 LDA #'. BSR PUTCH2 OUT0 LDA #'0 PUTCH2 JMP PUTCHX MOVXO LDY #O0 MOVE 'X' TO OPERAND LDB #8 MOVXY LDA 0,X+ MOVE 'X' TO 'Y' STA 0,Y+ DECB BNE MOVXY RTS3 RTS ALIGN LDB 7,U ALIGN TO POWER SUBB OP BEQ RTS3 SHIFTR LDA #7 LDX #O0 CLC SHIF1 ROR 0,X+ DECA DEC BC BNE SHIF1 DECB DEC HEX EXP BNE SHIFTR RTS SEARCH LDX #PTENE+10 SEARCH FOR CLOSEST POWER SRCH1 LEAX -10,X LDA 7,U CMPA 7,X BGT SRCH1 BNE BACK1 BSR CMPUX BHS RTS6 BACK1 LEAX 10,X RTS6 RTS CMPUX LDD 0,U COMPARE 'U' TO 'X' SUBD 0,X BNE RTS6 LDD 2,U SUBD 2,X BNE RTS6 LDD 4,U SUBD 4,X BNE RTS6 LDA 6,U CMPA 6,X RTS SUBUOR LDD 5,U SUBTRACT 'U'-OPERAND=RESULT SUBD O0+5 STD R0+5 LDD 3,U SBCB O0+4 SBCA O0+3 STD R0+3 LDD 1,U SBCB O0+2 SBCA O0+1 STD R0+1 LDA 0,U SBCA O0 STA R0 RTS RTOU LDX #R0 RESULT TO 'U' LEAY 0,U LDB #7 BRA MOVXY DTABLE FCC 0,'GOTO ',0,'GOSUB ',0,'RESUME ',0 FCC 'DIGITS ',0,'REM',0,'LET ',0,'PRINT ',0 FCC 'INPUT ',0,0,'SWAP ',0,'FOR ',0 FCC 'POKE ',0,0,'NEXT ',0,'READ ',0,'RETURN',0 FCC 'IF ',0,'DIM ',0,'ON ',0,'DEF ',0,'END',0 FCC 'STOP',0,'DATA ',0,'RESTORE ',0,0 FCC 'OPEN ',0,'CLOSE ',0,'CHAIN ',0,'KILL ',0 FCC 'RENAME ',0,'GET ',0,'PUT ',0,'FIELD ',0 FCC 'LSET ',0,'RSET ',0,'EXEC ',0,'DPOKE ',0 FCC 0,0,0,'RECORD ',0,'OLD ',0,'NEW ',0 FCC ' AS ',0,'USING ',0,'ERROR ',0 FCC 'LINE ',0,' THEN ',0,' ELSE ',0 $31 FCC ' TO ',0,'STEP ',0,'FN ',0,'ABS ',0 FCC 'ATN ',0,'COS ',0,'EXP ',0,'INT',0 FCC 'LOG ',0,'RND',0,'SGN ',0,'SIN ',0 FCC 'SQR ',0,'TAN ',0,'POS ',0 $40 FCC 'PEEK ',0,'USR ',0,'FRE',0,'PTR',0 FCC 'DPEEK ',0,0,'SPC ',0,'TAB',0,'PI',0 FCC 'ERR ',0,'ERL ',0,0,0,'ASC',0,'LEN',0 FCC 'VAL',0,'HEX',0,'INSTR',0,'CVT$%',0 FCC 'CVT$F',0,'DATE$',0,'CHR$',0,'LEFT$',0 FCC 'RIGHT$',0,'MID$',0,'STR$',0,'INCH$',0 FCC 'CVT%$',0,'CVTF$',0,'NOT ',0,' AND ' ,0 FCC ' OR ',0,0,0,0 $63 FCC '<',0,'>',0,'<>',0,'<',0 FCC '>',0,'=',0,0,'^',0,'/',0,'*',0,'+',0 FCC '-',0,0,0,',',0,';',0,'(',0,')',0,'#',0 FCC 0,0,0,0,':',0,' ',0,0,' ',0,0 $7F FDB $9676,$9950,$B50D,$897F,38 FDB $F0BD,$C21A,$BB !48,$DB7B,37 FDB $C097,$CE7B,$C907,$1678,36 FDB $9A13,$0B96,$3A6C,$1175,35 FDB $F684,$DF56,$C3E0,$1C71,34 FDB $C537,$1912,$364C,$E36E,33 FDB $9DC5,$ADA8,$2B70,$B66B,32 FDB $FC6F,$7C40,$4581,$2367,31 FDB $C9F2,$C9CD,$0467,$4F64,30 "FDB $A18F,$07D7,$36B9,$0C61,29 FDB $813F,$3978,$F894,$0A5E,28 FDB $CECB,$8F27,$F420,$0F5A,27 FDB $A56F,$A5B9,$9019,$A657,26 FDB $8459,$5161,$4014,$8554,25 FDB $D3C2,$1BCE,$CCED,$A150,24 FDB $A968,$163F,$0A57,$B44D,23 FDB $8786,$78#32,$6EAC,$904A,22 FDB $D8D7,$26B7,$177A,$8046,21 FDB $AD78,$EBC5,$AC62,$0043,20 FDB $8AC7,$2304,$89E8,$0040,19 FDB $DE0B,$6B3A,$7640,$003C,18 FDB $B1A2,$BC2E,$C500,$0039,17 FDB $8E1B,$C9BF,$0400,$0036,16 FDB $E35F,$A931,$A000,$0032$,15 FDB $B5E6,$20F4,$8000,$002F,14 FDB $9184,$E72A,$0000,$002C,13 FDB $E8D4,$A510,$0000,$0028,12 FDB $BA43,$B740,$0000,$0025,11 FDB $9502,$F900,$0000,$0022,10 FDB $EE6B,$2800,$0000,$001E,9 FDB $BEBC,$2000,$0000,$001B,8 FDB $9896%,$8000,$0000,$0018,7 FDB $F424,$0000,$0000,$0014,6 FDB $C350,$0000,$0000,$0011,5 FDB $9C40,$0000,$0000,$000E,4 FDB $FA00,$0000,$0000,$000A,3 FDB $C800,$0000,$0000,$0007,2 FDB $A000,$0000,$0000,$0004,1 FDB $8000,$0000,$0000,$0001,0 & FDB $CCCC,$CCCC,$CCCC,$CDFD,-1 FDB $A3D7,$0A3D,$70A3,$D7FA,-2 FDB $8312,$6E97,$8D4F,$DFF7,-3 FDB $D1B7,$1758,$E219,$65F3,-4 FDB $A7C5,$AC47,$1B47,$84F0,-5 FDB $8637,$BD05,$AF6C,$6AED,-6 FDB $D6BF,$94D5,$E57A,$42E9,-7 FDB $ABCC,$'7711,$8461,$CFE6,-8 FDB $8970,$5F41,$36B4,$A6E3,-9 FDB $DBE6,$FECE,$BDED,$D5DF,-10 FDB $AFEB,$FF0B,$CB24,$AADC,-11 FDB $8CBC,$CC09,$6F50,$88D9,-12 FDB $E12E,$1342,$4BB4,$0DD5,-13 FDB $B424,$DC35,$095C,$D7D2,-14 FDB $901D,$7CF7,$3AB(0,$ACCF,-15 FDB $E695,$94BE,$C44D,$E1CB,-16 FDB $B877,$AA32,$36A4,$B4C8,-17 FDB $9392,$EE8E,$921D,$5DC5,-18 FDB $EC1E,$4A7D,$B695,$61C1,-19 FDB $BCE5,$0864,$9211,$1BBE,-20 FDB $971D,$A050,$74DA,$7CBB,-21 FDB $F1C9,$0080,$BAF7,$2DB7),-22 FDB $C16D,$9A00,$9592,$8AB4,-23 FDB $9ABE,$14CD,$4475,$3BB1,-24 FDB $F796,$87AE,$D3EE,$C5AD,-25 FDB $C612,$0625,$7658,$9EAA,-26 FDB $9E74,$D1B7,$91E0,$7EA7,-27 FDB $FD87,$B5F2,$8300,$CAA3,-28 FDB $CAD2,$F7F5,$359A,$3BA0,-29  *FDB $A242,$5FF7,$5E14,$FC9D,-30 FDB $81CE,$B32C,$4B43,$FD9A,-31 FDB $CFB1,$1EAD,$4539,$9496,-32 FDB $A627,$4BBD,$D0FA,$DD93,-33 FDB $84EC,$3C97,$DA62,$4B90,-34 FDB $D4AD,$2DBF,$C3D0,$778C,-35 FDB $AA24,$2499,$6973,$9389,-36 FDB $8 +81C,$EA14,$545C,$7586,-37 PTENE FDB $D9C7,$DCED,$53C7,$2282,-38 TENK FDB 10000,1000,100,10,1,0 NUMERR FCC 'NUMERICAL ERROR!!',7,4 WFCB RMB 320 LINEIN FCC 'V1.6 *** DECOMPILER FOR TSC XBASIC ***' CRLF FDB $D0A,4 ASKDSK FCC 'BUILD A DISK FIL,E? (Y/N)',4 FILNAM FCC 'FILENAME? ',4 VTABLE EQU LINEIN+256 END VEREND  ? RWCPlTuDNQEVS}XrFNFEFD FSDNDEDVDDXXFilename Ext Size Date Diskname Ext Vol# Date Page WHAT?===> *** SYNTAX ERROR ***READY? \CHECKING FOR DUPLICATION*** NOT A CATALOG FILE ****** DISK READ ERROR ****** BUFFER OVERFLOW ***Are you sure? 2j0|+"+DV4" +0 0 +O_0் 2-30 "00` '' 0m&0 0D 4 %&$50K %4 5 ' ' ,';' 1! '91?9ЍM&)7%< %!Z&Ħ+)&0 ^$ 0 % Wb 0čύS ;9' ?j 9l @-%H@m & CA TD@  4@' &55\%9 خ\s%y& 4 Z&50 % ކ ڦ0%Ɂ3"ÄC4 4 b0 '"Y&@ '?0 5Z&91O0P !$ @&l@'& զ+'0 0^% 0P[&0l 0A\$>1 _' &\ %o1 %0 ڍQ;\%?&o0 % \m&1 $m' Z&o 0 %99~0Y&9"z"9O_F\'>%r\4W&00 %2b e409XvP0C9:50V$jH&,0c50F9$~$<H}"& FF9 Z&9/~* 4$5 &9ڦ ݦצ4O40 $ _95 & &.Z&9mK9b0940"4졁 '$0' 0m&+큯b"񦠁 & J2dģ\B\ DBZZDVZ&9BZV TTRRZXD4FRD43b7M+101%'"Z& 5p 4Ħ椧j&2aRZ%R& 5pT TVT$ 4? '`b%R'VZ#P0'0m& ==&744090?0Qa::&2 bীZ&2c?,'5 55 ';',99b'5+g턦?9O_40% 9"|4hbiaahbiahbiaa 5d & Z&'9?'-'_'0%9#A%z"99/& /& 9?92e\401df%``%Zo%Ti%NN%HH%BW%<Q%64".."(=""7"@ u""%" "55' 4??&5Z&_9&Z&_94Z'01! 50 ?0 Z&OJ0 OZ&9 TTL FILESORT V6.3C (4-6-80) ORG 0 TRACK EQU 30 FCB TRACK OFFSET DSKNAM EQU 80 DISK NAME OFFSET IN SIR FCB1 EQU $C840 FRMFED EQU $C DP EQU 60 LINBUF EQU $CC14 ESCRET EQU $CC16 OUTFLG EQU $CC22 MEMEND EQU $CC2B WARMS EQU $CD03 GETCHR EQU $CD15 OUT EQU $CD18 INBUFF EQU $CD1B PCRLF EQU $CD24 GETFIL EQU $CD2D OUTDEC EQU $CD39 RPTERR EQU $CD3F DOCMND EQU $CD4B FMSCLS EQU $D403 FMS EQU $D406 BEGPRG EQU * program orgin address FILSRT BRA COLD VER FCB 63 WARM LBRA MNLOOP COLD LBRA INIT * VARBEG RMB 59 space for variables and stack VARBSE EQU VARBEG+14 make use of 5 bit signed offset I EQU -14 sort-index J EQU -12 " " K EQU -10 " " L EQU -8 " " M EQU -6 " " BUFBEG EQU -4 address of start of catalog buffer BUFEND EQU -2 address of end of buffer BUFPTR EQU 0 pointer SIZE EQU 2 size of catalog buffer START EQU 4 starting address for sort PAGENO EQU 6 current page number LINENO EQU 8 line number on current page STACK EQU * SCHTBL RMB 20 sort key table ENDSCH EQU SCHTBL+17 reserved defautl key storage * LO and HI are the lower and upper parameter limit tables LO RMB 32 HI RMB 32 * * CMDTBL CMDTBL FCC 'R' Read catalog from disk FDB CMDR-CMDTBL FCC 'W' Write catalog file to disk FDB CMDW-CMDTBL FCC 'C' Catalog disk FDB CMDC-CMDTBL FCC 'P' Print data FDB CMDP-CMDTBL FCC 'T' Output to terminal FDB CMDT-CMDTBL FCC 'D' Delete one or more catalog entries FDB CMDD-CMDTBL FCC 'N' Clear buffer for new entries FDB CMDN-CMDTBL FCC 'E' End FILESORT FDB CMDE-CMDTBL FCC 'S' Sort buffer FDB CMDS-CMDTBL FCC 'X' Process FLEX command FDB CMDX-CMDTBL FCB 0 * PRMTBL contains the paramater names and associated values * (offset from beginning of catalog entry, length of parameter * and parameter data type. PRMTBL FCC 'FN',0,8,0 FCC 'FE',8,3,0 FCC 'FD',11,3,$FF FCC 'FS',14,2,1 FCC 'DN',16,8,0 FCC 'DE',24,3,0 FCC 'DV',27,2,1 FCC 'DD',29,3,$FF FCC 'XX',$FF,0,0,0 * * MESSAGES STTL FCC $FF,$FF,'Filename Ext Size Date ' FCC ' Diskname Ext Vol# Date Page ',4 NOTFND FCC $FF,'WHAT?',7 PROMPT FCC $FF,$FF,'===> ',4 SYNERR FCC 7,$FF,'*** SYNTAX ERROR ***',4 DRV RDY FCC $FF,'READY? ',4 DUPMSG FCC $FF,'CHECKING FOR DUPLICATION',4 NTCAT FCC $FF,'*** NOT A CATALOG FILE ***',4 DSKNOT FCC 7,$FF,'*** DISK READ ERROR ***',4 OVRMSG FCC 7,$FF,'*** BUFFER OVERFLOW ***',4 SURMSG FCC $FF,'Are you sure? ',4 * * PR OGRAM BEGINS HERE MIDPNT EQU ((ENDPRG-BEGPRG)/2)+BEGPRG Program midpoint INIT LEAS STACK,PCR LEAX MIDPNT,PCR CMPX MEMEND BHI ALL LDD MEMEND LSRA RORB PSHS D CMPX 0,S++ BHI LOWMEM LDD MEMEND LEAX ENDPRG,PCR EXG D, X BRA SETBUF LOWMEM LEAX BEGPRG-1,PCR BRA LOWLIM ALL LDX MEMEND LOWLIM CLRA CLRB SETBUF LEAX -32,X STX BUFEND+VARBSE,PCR STD BUFBEG+VARBSE,PCR STD BUFPTR+VARBSE,PCR * * MAIN PROGRAM LOOP MNLOOP LEAS STACK,PCR LEAU VARBSE,PCR LEAX MNLOOP,PCR STX ESCRET LDA #$FF STA OUTFLG LEAX PROMPT,PCR AGAIN LBSR OUTLN JSR INBUFF LDY LINBUF LEAX CMDTBL,PCR GETCMD LDA 0,Y+ CMPA #$20 BEQ GETCMD CMDLOP CMPA ,X BEQ CMDFND LEAX 3,X TST ,X BNE CMDLOP LEAX NOTFND,PCR BRA AGAIN CMDFND LDD 1,X LEAX CMDTBL,PCR JSR D,X BRA MNLOOP * * CHKPTD Checks the paramater line for 'P' 'T' 'D' CHKPTD BSR DELIM PSHS Y BCS CHKEOL CHKLP LBSR PARSE BNE CHKERR BCC CHKLP CHKEOL PULS Y,PC CHKERR LEAX SYNERR,PCR LBSR OUTLN BRA MNLOOP * CHKRWC Checks the parameter line for 'R' 'W' 'C' CHKRWC BSR DELIM BCS CHKERR PSHS Y BSR CHKPTD PULS Y,PC * DELIM Advances the line pointer to the character after the next * delimiter (space,comma, or semicolon), or to the c/r if at * at the end of line. DELIM LDA 0,Y+ CMPA #$D BEQ DMEOL CMPA #$20 BEQ DLMFND CMPA #', BEQ DLMFND CMPA #'; BEQ DLMFND BRA DELIM SKPSPC LEAY 1,Y DLMFND LDA 0,Y CMPA #$20 BEQ SKPSPC CLC RTS DMEOL LEAY -1,Y SEC RTS * 'R' command reads a catalog file. CMDR BSR CHKRWC BSR OPENRD LBSR READ CMPA #3 BNE NOTCAT RLOOP1 LBSR PARSE BCS XCLOSE NXTFIL LDX BUFPTR,U LDB #32 RLOOP2 LBSR READ BCS RDEOF STA ,X+ DECB BNE RLOOP2 LDX BUFPTR,U LDA ,X BMI RDEOF * NOTE: it is necessary to flag EOF LBSR MATCH BNE NXTFIL LEAX 32,X CMPX BUFEND,U BHS OVRFLW STX BUFPTR,U BRA NXTFIL NOTCAT LEAX NTCAT,PCR  BRA OVRNOT RDEOF LBSR PARSE BCS XCLOSE BSR REWIND BSR READ BRA NXTFIL OVRFLW LEAX OVRMSG,PCR OVRNOT LBSR OUTLN XCLOSE BSR CLOSE LBRA DUPLCT * OPENRD Opens a file for a read. OPENRD BSR FILNAM FMSBIN BSR FMSJMP LDA #$FF   STA 59,X RTS FMSJMP JSR FMS BEQ RDRTN DSKERR JSR RPTERR JSR FMSCLS LBSR DUPLCT LBRA MNLOOP RDRTN RTS * OPENWT Opens a file for a write. OPENWT BSR FILNAM INC ,X BRA FMSBIN * FILNAM Sets up the file FCB. FILNAM STY LINBUF LDX #FCB1 JSR GETFIL LBCS CHKERR LDX #FCB1 TST 12,X BNE NTDFLT LDD #$4341 'CA' STD 12,X LDA #'T STA 14,X NTDFLT LDA #1 STA ,X LBRA DELIM * REWIND Rewinds a file for re-reading. REWIND LDA #5 REWCLS LDX #FCB1 STA ,X BRA FMSBIN * CLOSE Closes a file CLOSE LDA #4 BRA REWCLS * READ Reads one byte from the disk. * WRITE Writes one byte to the disk. READ EQU * WRITE PSHS X LDX #FCB1 JSR FMS BEQ RWRTN LDA 1,X CMPA #8 BNE DSKERR SEC PULS X,PC RWRTN CLC PULS X,PC * CMDW Writes a catalog file to the disk. CMDW LDX BUFBEG,U CMPX BUFPTR,U BLO CMDW1 RTS CMDW1 LBSR CHKRWC BSR OPENWT LDA #3 BSR WRITE CMDW2 LDX BUFBEG,U LBSR PARSE BCS WTDN CMDW3 LBSR MATCH BNE NOWRT PSHS X LDB #32 WTLOOP LDA ,X+ BSR WRITE DECB BNE WTLOOP PULS X NOWRT LEAX 32,X CMPX BUFPTR,U BLO CMDW3 BRA CMDW2 WTDN LDA #$FF BSR WRITE BRA CLOSE * CMDC Reads a disk's catalog and adds the disk and file * attributes to the catalog buffer. CMDC LBSR CHKRWC LDA 0,Y CMPA #'0 LBLO CHKERR CMPA #'3 LBHI CHKERR ANDA #3 STA FCB1+3 LBSR DELIM PSHS Y PSHS Y RDYQ LDD 2,S STD 0,S LEAX DRVRDY,PCR LBSR OUTLN JSR GETCHR CMPA #$D BEQ CMDCDN CMPA #'Y BNE RDYQ LDX #FCB1 LDD #3 STD TRACK,X LDA #9 STA ,X JSR FMS BEQ DSKNM ERR1 JSR RPTERR LEAX DSKNOT,PCR LBSR OUTLN BRA RDYQ CMDCDN LBSR DUPLCT PULS X,Y,PC * COPY Is a block move subroutine. COPY LDA ,X+ STA 0,Y+ DECB BNE COPY RTS * DSKNM Gets the file and disk attributes and saves them in buffer. DSKNM LEAY SCHTBL,PCR LEAX DSKNAM,X LDB #13 BSR COPY * NOTE Dates are stored in the disk catalog as MM/DD/YY; * however they must be stored in the buffer as YY/MM/DD. LDA 8,X STA 0,Y LDD 6,X STD 1,Y CATLOP LDY 0,S LBSR PARSE STY 0,S BCC RDCAT BRA RDYQ RDCAT LDX #FCB1 LDA #6 STA ,X JSR FM S BNE ERR1 INC ,X DSKCAT LDX #FCB1 JSR FMS BEQ GDREAD LDA 1,X CMPA #8 BNE ERR1 BRA CATLOP GDREAD LDA 4,X BMI DSKCAT BEQ CATLOP LDY BUFPTR,U LEAX 4,X LDB #11 BSR COPY LDA 12,X STA 0,Y+ LDD 10,X STD  0,Y++ LDD 6,X STD 0,Y++ LEAX SCHTBL,PCR LDB #16 BSR COPY CMPY BUFEND,U BLO FILCHK LEAX OVRMSG,PCR LBSR OUTLN BSR DUPLCT LBRA MNLOOP FILCHK LDX BUFPTR,U LBSR MATCH BNE DSKCAT LEAX 32,X STX BUFPTR,U BRA DSKCAT * DUPLCT Is a subroutine which checks the catalog buffer for * duplicate entries. It is called after the 'R' & 'C' * commands and deletes any identical entries which could * result from reading catalog files containing the same * enteri  es, from cataloging the same disk twice with the 'C' * command or having one or more files which match several * different sets of parameter limits. DUPLCT LEAX DUPMSG,PCR LBSR OUTLN LDX BUFBEG,U ID1 CMPX BUFPTR,U BHS PACK LEAY 32,X I !D2 CLRB LDA 0,Y BEQ ID4 ID3 LDA B,X CMPA B,Y BNE ID4 INCB CMPB #32 BLO ID3 CLR 0,Y ID4 LEAY 32,Y CMPY BUFPTR,U BLO ID2 LEAX 32,X BRA ID1 * CMDD Is a suboutine to delete all files whick match the * given paramet "er limits. After all matching files have been * flagged as deleted, the remaining files are packed. CMDD BSR SURE LBSR CHKPTD CMDD1 LBSR PARSE LDX BUFBEG,U BCS PACK CMDD2 LBSR MATCH BNE NODEL CLR ,X NODEL LEAX 32,X CMPX BUFP #TR,U BLO CMDD2 BRA CMDD1 PACK LDX BUFBEG,U PK1 TST ,X BNE NXTPCK TFR X,Y PK2 LEAY 32,Y CMPY BUFPTR,U BHS NOMORE TST 0,Y BEQ PK2 LDB #32 MOVLP LDA 0,Y+ STA ,X+ DECB BNE MOVLP CLR -32,Y BRA PK3 NXTPCK LE $AX 32,X PK3 CMPX BUFPTR,U BLO PK1 RTS NOMORE STX BUFPTR,U RTS * CMDN Clears the catalog buffer and restarts FILESORT. CMDN BSR SURE LBRA INIT * CMDE Ends FILESORT and returns to FLEX CMDE BSR SURE JMP WARMS * SURE Is a subrou %tine to prevent the accidentally entering the * 'N' or 'E' command through mistyping and thereby erasing * the entire catalog buffer inadvertanly. SURE LEAX SURMSG,PCR LBSR OUTLN JSR GETCHR CMPA #'Y LBNE MNLOOP RTS * CMDT and CMDP a &re the command subroutines to output the * catalog enteries to the terminal and printer respectively * (NOTE - that the P command assumes that the system print * driver is available; e.g. using 'P,FILESORT' to call this * program) Each file is chec 'ked against the parameter list. CMDP CLR OUTFLG BSR CMDT DEC OUTFLG TDONE RTS CMDT CLRA CLRB STD PAGENO,U LDX BUFBEG,U CMPX BUFPTR,U BEQ TDONE LBSR CHKPTD TLOOP1 LBSR PARSE BCS FMFEED LDX BUFBEG,U PSHS X BSR NE (WPAG TLOOP2 LDX 0,S LBSR MATCH BNE NXTPT BSR OUTFIL NXTPT LDX 0,S LEAX 32,X STX 0,S CMPX BUFPTR,U BLO TLOOP2 LEAS 2,S BRA TLOOP1 OUTFIL LBSR PRTNAM LDB #1 BSR SPC PSHS X LEAX 3,X LDB #$FF JSR OUTDEC L!)DB #1 BSR SPC LDX 0,S BSR PDATE LDB #4 BSR SPC LDX 0,S LEAX 5,X LBSR PRTNAM STX 0,S LDB #1 BSR SPC LDB #$FF JSR OUTDEC LDB #2 BSR SPC PULS X LEAX 2,X BSR PDATE JSR PCRLF DEC LINENO,U BNE O!*LRTN NEWPAG BSR FMFEED LEAX STTL,PCR BSR OUTLN LEAX PAGENO,U LDB #$FF JSR OUTDEC JSR PCRLF JMP PCRLF FMFEED LDB #DP SUBB #5 -5 For 46 entries on a TTY Page of 51 STB LINENO,U .. change this number to suit your paper. T!+ST OUTFLG BNE SKIPFF LDA #FRMFED JSR OUT SKIPFF LDD PAGENO,U ADDD #1 STD PAGENO,U OLRTN RTS SPC LDA #$20 JSR OUT DECB BNE SPC RTS SLASH LDA #'/ OUTBRA JMP OUT OUTLN1 BSR OUTBRA * OUTLN Prints a character string po!,inted to by 'X' and * terminated by a '4'. In order to save space in messages, * a CR,LF, and NULL(S) sequence is replaced by a single * negative byte. This routine then replaces the negative byte * with the CR sequence. OUTLN LDA ,X+ BPL ON1!- PSHS X JSR PCRLF PULS X BRA OUTLN ON1 CMPA #4 BNE OUTLN1 RTS PDATE LDB #1 BSR SPC LDA 1,X BSR DEC BSR SLASH LDA 2,X BSR DEC BSR SLASH LDA ,X DEC PSHS X,A CLRA PSHS A LEAX 0,S LDA 1,X CMPA !.#10 BHS DC1 LDA #$20 BSR OUTBRA DC1 CLRB JSR OUTDEC PULS D,X,PC PRTNAM LDB #11 PM1 LDA ,X+ BNE PM2 LDA #$20 PM2 BSR OUTBRA CMPB #4 BNE PM3 LDA #'. BSR OUTBRA PM3 DECB BNE PM1 RTS * CMDX Calls the FLEX DOCM!/ND subroutine, enabling the use * of FLEX utilities from FILESORT; however, the user is * cautioned against using utilities which may overwrite * FILESORT or its buffer space. CMDX LBSR DELIM STY LINBUF JSR DOCMND RTS * CMDS Establishes !0the sort parameters and then calls 'SORT', the * sorting routine. CMDS LBSR DELIM LEAX ENDSCH,PCR PSHS X LEAX SCHTBL,PCR PSHS X SLOOP1 LDD 0,Y++ CMPA #$D BEQ SORTIT LEAX PRMTBL,PCR SLOOP2 CMPD ,X BEQ SFND LEAX 5,X TST! 1 ,X BNE SLOOP2 SRTERR LBRA CHKERR SFND LDD 2,X LDX 0,S STD ,X++ STX 0,S CMPX 2,S BHI SRTERR LDA 0,Y+ CMPA #$D BNE SLOOP1 SORTIT LDD #$20 STD ,X DECA STA 2,X LEAS 4,S * SORT Is an extremly fast multiple key S! 2HELL-METZNER sort. SORT LDD BUFPTR,U SUBD BUFBEG,U STD SIZE,U LDD BUFBEG,U SUBD #32 STD START,U LDD SIZE,U STD M,U * The SHELL-METZNER algorithm is an extremely fast sorting method * which uses 5 indices (I,J,K,L, and M) to se"3arch and * compare in a binary fashion. LOOPA LDD M,U LSRA RORB ANDB #$E0 STD M,U BNE ST1 RTS ST1 LDD SIZE,U SUBD M,U STD K,U LDD #32 STD J,U LOOPB LDD J,U STD I,U LOOPC LDD I,U ADDD M,U STD L,U ADDD STA"4RT,U PSHS D,U LDD I,U ADDD START,U PSHS D LEAU SCHTBL,PCR SCHLP LDX 0,S LDY 2,S PULU A,B * A = Starting offset for comparison for this key * B = Number of bytes to be compared for this key TSTA BMI LOWER LEAX A,X LEA"5Y A,Y CMPLP LDA ,X+ CMPA 0,Y+ BLO LOWER BHI HIGHER DECB BNE CMPLP BRA SCHLP HIGHER PULS X,Y,U LDB #32 PSHS B HR1 LDA ,X LDB 0,Y STA 0,Y+ STB ,X+ DEC 0,S BNE HR1 LEAS 1,S LDD I,U SUBD M,U BLO LOWE"6R1 STD I,U BNE LOOPC BRA LOWER1 LOWER PULS X,Y,U LOWER1 LDD J,U ADDD #32 STD J,U LDD K,U SUBD J,U BHS LOOPB BRA LOOPA * PARSE Is the subroutine which parses the file specification * limits. The lower file specification"7 limit is stored in the * 32 byte 'LO' area, and the upper file specification limit is * stored in the 32 byte 'HI' area. Flags are set as follows: * End-of-line: Carry set * Syntax error: Zero clear, Carry clear * Normal exit: Zero set, Carry c"8lear * The 'Y' register must point to the line portion to be parsed * on entry. The routine will return when either a C/R (end of * line) or a semicolon (end of parameter) is reached. PARSE PSHS X LBSR DEFLT PARSE1 LDA -1,Y CMPA #$D BEQ "9PRSEOL BSR CHKCHR BCS PRSOK BEQ PRSERR TFR A,B BSR CHKCHR BLS PRSERR EXG A,B LEAX PRMTBL,PCR PE1 CMPD ,X BEQ PE2 LEAX 5,X TST 5,X BNE PE1 BRA PRSERR PE2 LDA 0,Y+ CMPA #'= BNE PRSERR LDD 2,X PSHS D ": LDB 4,X * 0 = alpah * - = calendar form * + = numeric form PSHS B LEAX LO,PCR LEAX A,X BSR PRSDAT LEAX HI,PCR LDB 1,S ABX CMPA #': BNE SAME BSR PRSDAT BRA PRSOK1 SAME LDB 2,S SM1 LDA -32,X STA ,X+ DECB " ; BNE SM1 PRSOK1 LEAS 3,S LDA -1,Y CMPA #', BEQ PARSE1 PRSOK CLC ORCC #4 PULS X,PC PRSERR ANDCC #$FA PULS X,PC PRSEOL ORCC #5 PULS X,PC CHKCHR LDA 0,Y+ CMPA #$D BEQ CREOL CMPA #'; BEQ CR10 CMPA #', CR10 RTS" < CREOL SEC RTS PRSDAT LDA 2,S BEQ NAME BMI DATE BSR GETNUM STD ,X LDA -1,Y RTS GETNUM CLRA CLRB PSHS D NUMLP LDA 0,Y+ CMPA #'0 BLO NOTNUM CMPA #'9 BHI NOTNUM ANDA #$F PSHS A ASL 2,S ROL 1,S LDD #=1,S ASL 2,S ROL 1,S ASL 2,S ROL 1,S ADDD 1,S * NOTE N*10=(N*2*2*2)+(N*2) ADDB 0,S+ ADCA #0 STD 0,S BRA NUMLP NOTNUM PULS D,PC NAME LDB 4,S LTRLP1 BSR CLASFY BNE NOTLTR STA ,X+ DECB BNE LTRLP1 LTRLP2 BSR CL#>ASFY BEQ LTRLP2 NOTLTR RTS CLASFY LDA 0,Y+ CMPA #'? BEQ LTR CMPA #'- BEQ LTR CMPA #$5F BEQ LTR CMPA #'0 BLO NTLTR CMPA #'9 BLS LTR CMPA #'A BLO NTLTR CMPA #'z BHI NTLTR LTR ORCC #4 RTS NTLTR ANDCC ##?$FB RTS DATE BSR DATNUM STB 1,X CMPA #'/ BNE DATERR BSR DATNUM STB 2,X CMPA #'/ BNE DATERR BSR DATNUM STB ,X RTS DATNUM BSR GETNUM LDA -1,Y RTS DATERR LEAS 5,S LBRA PRSERR * MATCH checks the catalog entry #@for limits. MATCH PSHS X,Y LEAY LO,PCR LDB #8 BSR MCHNAM BLO NG LDB #3 BSR MCHNAM BLO NG LDB #3 BSR MCHNUM BLO NG LDB #2 BSR MCHNUM BLO NG LDB #8 BSR MCHNAM BLO NG LDB #3 BSR MCHNAM BLO NG L#ADB #2 BSR MCHNUM BLO NG LDB #3 BSR MCHNUM BLO NG LDX 0,S LDB #8 BSR MCHNAM BHI NG LDB #3 BSR MCHNAM BHI NG LDB #3 BSR MCHNUM BHI NG LDB #2 BSR MCHNUM BHI NG LDB #8 BSR MCHNAM BHI NG LDB #B#3 BSR MCHNAM BHI NG LDB #2 BSR MCHNUM BHI NG LDB #3 BSR MCHNUM BHI NG ORCC #4 PULS X,Y,PC NG ANDCC #$FB PULS X,Y,PC MCHNAM LDA ,X+ CMPA 0,Y+ BEQ DECMCH PSHS CC LDA -1,Y CMPA #'? BNE NH1 PULS #CCC DECMCH DECB BNE MCHNAM CLRB RTS MCHNUM LDA ,X+ CMPA 0,Y+ BNE NOMTCH DECB BNE MCHNUM CLRB RTS NOMTCH PSHS CC NH1 DECB BEQ MTCHDN LEAX 1,X LEAY 1,Y BRA NH1 MTCHDN PULS CC,PC DEFLT LEAX LO,PCR LDB #11 LDDA #'? FILL1 STA 48,X STA 32,X STA 16,X STA ,X+ DECB BNE FILL1 LDB #5 CLRA FILL2 DECA STA 48,X STA 32,X CLRA STA 16,X STA ,X+ DECB BNE FILL2 RTS ENDPRG EQU * * END FILSRT # # $$$$$$$$$ $ %%%%%%%%% % &&&&&&&&& & ''''''''' '