OPT PAG TTL 6809 DOS VERSION 1.0DD TAVERNIER SYSTEM STTL FROM TSC 6809 DOS VERSION 2.92 PAG * * TSC 6809 DISK OPERATING SYSTEM * * COPYRIGHT (C) 1979 BY * * TECHNICAL SYSTEMS CONSULTANTS, INC. * PO BOX 2570 * WEST LAFAYETTE, INDIANA 47906 * * DISASSEMBLY BY DYNAMITE OF 1.TAVDOS9D.SYS * MODIFICATION FOR DOUBLE DENSITY 15/05/18 PAG STTL TSC 6809 DISK OPERATING SYSTEM * * GLOBAL VARIABLE STORAGE * * STANDARD PRE-NAMED LABEL EQUATES LINBUF EQU $C080 * ASCII CODE EQUATES NUL EQU $00 EOT EQU $04 SI EQU $0F * EXTERNAL LABEL EQUATES L0044 EQU $0044 STACK EQU $C07F LC810 EQU $C810 * HARDWARE LOCATIONS OF THE TAVERNIER 6809 COMREG EQU $E000 TRKREG EQU $E001 SECREG EQU $E002 DATREG EQU $E003 DRVREG EQU $E080 LEB08 EQU $EB08 LEB09 EQU $EB09 LEB0E EQU $EB0E LEFD8 EQU $EFD8 LEFDC EQU $EFDC LEFDE EQU $EFDE LFCF7 EQU $FCF7 LFE05 EQU $FE05 * TAVERNIER COPY PROTECTION * REMOVED IN THIS VERSION ORG $C065 LC065 LDX LFE05 Get BIOS Key CMPX LC07C Compare with TAVDOS BRA LC073 OK Code complies LDX #$8000 LBRA LFCF7 LC073 LDX #INIT Load INIT Address STX COLDS+1 Store at COLDS JMP COLDS And Jump LC07C FDB $9594 Key Code for BIOS TAVBUG1C LBL EQU 128 LINE BUFFER LENGTH ORG $CC00 TTYBS FCB $08 $CC00 BACK SPACE (^H) TTYDEL FCB $18 $CC01 DELETE CHARACTER (^X) TTYEOL FCB $3A $CC02 END OF LINE CHAR (:) TTYDP FCB $00 $CC03 LINES PER SCREEN COLCNT FCB $00 $CC04 COLUMNS PER LINE TTYNL FCB $04 $CC05 LINE PADDING NULLS TTYTB FCB $00 $CC06 TAB CHARACTER TTYBE FCB $08 $CC07 BACK SPACE ECHO TTYEJ FCB $00 $CC08 EJECT LENGTH TTYPS FCB $FF $CC09 PAUSE CONTROL TTYESC FCB $1B $CC0A ESCAPE CHARACTER SYSDRV FCB $00 $CC0B SYSTEM DRIVE WRKDRV FCB $00 $CC0C WORKING DRIVE SYSFLG FCB $00 $CC0D SYSTEM FLAG SYSMTH FCB $00 $CC0E SYSTEM DATE SYSDAY FCB $00 SYSYR FCB $00 LSTTRM FCB $00 $CC11 LAST TERMINATOR USRTBL FCB $00,$00 $CC12 USER COMMAND TABLE BUFPNT FCB $00,$00 $CC14 LINE BUFFER POINTER RETRNR FCB $00,$00 $CC16 ESCAPE RETURN REG CHAR FCB $00 $CC18 CHARACTER PRVCHR FCB $00 $CC19 PREVIOUS CHARACTER LINE FCB $00 $CC1A CURRENT LINE NUMBER OFFSET FCB $00,$00 $CC1B LOADER ADR OFFSET XFR FCB $00 $CC1D TRANSFER FLAG TADR FCB $00,$00 $CC1E TRANSFER ADDRESS ERRTYP FCB $00 $CC20 ERROR TYPE SPCLS FCB $00 $CC21 SPECIAL IO FLAG OUTCHN FCB $00 $CC22 OUTPUT CHANNEL BYTE INCHNL FCB $00 $CC23 INPUT CHANNEL BYTE FILOUT FCB $00,$00 $CC24 OUTPUT FILE ADDRESS FILIN FCB $00,$00 $CC26 INPUT FILE ADDRESS CMFLG FCB $00 $CC28 COMMAND FLAG COLMN FCB $00 $CC29 CURRENT OUTPUT COL. TMRFLG FCB $00 $CC2A TIMER FLAG UNUSED NOW MEMEND FCB $BF,$FF $CC2B MEMORY END ERRVEC FCB $00,$00 $CC2D ERROR NAME VECTOR FILEKO FCB $01 $CC2F FILE INPUT ECHO FMSBSY FCB $00 $CC30 FMS IS BUSY FLAG CP FCB $00,$00 CPUTYP FCB $00 PRCNT FCB $00 PRTADR FCB $00,$00 $CC35 SPARE BYTES PRTLNG FCB $00,$00 PRTDVC FCB $00,$00 * XTEMP RMB 2 $CC3B INDEX TEMP (NU) INDEX RMB 2 $CC3D INDEX TEMP STORAGE CRSAVE RMB 2 $CC3F INDEX SAVE DATPNT RMB 2 $CC41 DATA POINTER (NU) RETADR RMB 2 $CC43 RETURN ADDRESS STKSTR RMB 2 $CC45 STACK STORAGE IOTEMP RMB 2 $CC47 IO TEMP STORE * SET MAPUP TO $FF TO DISABLE MAPPING ORG $CC49 MAPUP FCB $60 $CC49 MAP FILENAMES TO UPPE OUTNUM RMB 1 $CC4A 0 SUPPRESSION FLAG COUNT RMB 1 $CC4B SPARE COUNT REGISTER GOTFIL RMB 1 $CC4C FILE INDICATOR TEMPR RMB 1 $CC4D TEMPORARY REGISTER ORG $CC4E PPRMP FCC "+++",EOT PPRMP1 FCC "???",EOT WHATST FCC "Comment ?",EOT NOTRST FCC "Transfert impossible",EOT NONMST FCC "Fichier introuvable",EOT DSKERS FCC "Erreur disque ",EOT NTRST FCC "Disque non pret",EOT COMTBL FCC "GET",NUL FDB GET $D20F FCC "MON",NUL FDB MEXIT $D34B FCB $00 CONTBL FDB 10000 FDB 1000 FDB 100 FDB 10 ORG $CCC0 PINIT RTS ORG $CCD8 PCHK RTS ORG $CCE4 POUT RTS ORG $CCF8 PR0 FCB $01,$00,$00,$00 PR1 FCB $00,$00,$00,$00 COLDS JMP INIT GO INITIALIZE WARMS JMP ENTRY WARM ENTRY POINT RENTER JMP DOS3 RE-ENTER DOS INCH JMP * INPUT ROUTINE INCH2 JMP * TERMINAL INPUT OUTCH JMP * OUTPUT CHARACTER OUTCH2 JMP * TERMINAL OUTPUT DGETCH JMP GETCHR GET CHARACTER DPUTCH JMP PUTCHR PUT CHARACTER DINBUF JMP INBUF INPUT TO BUFFER DPSTRN JMP PSTRNG PRINT STRING DCLASS JMP CLASS CLASSIFY CHARACTER DPCRLF JMP PCRLF PRINT CR AND LF DNEXTC JMP NXTCH NEXT BUFFER CHAR RSTRIO JMP RESTIO RESTORE IO VECTORS DFILSP JMP GETFIL GET FILE SPEC DLOAD JMP LOAD FILE LOADER DSETEX JMP SETEXT SET NAME EXTENSION DADDBX JMP ADDBX ADD B TO X DOUTDE JMP OUTDEC OUTPUT DECIMAL DOUTHE JMP OUTHEX OUT HEX CHARACTER DRPTER JMP RPTERR REPORT ERROR DGETHX JMP GETHEX GET HEX NUMBER DOUTAD JMP OUTADR OUT HEX ADDRESS DINDEC JMP INDEC GET DECIMAL NUMBER DDOCMD JMP DOCMD DO COMMAND LINE DSTAT JMP * TERMINAL INPUT STATUS JMP RTS JMP RTS * INIT * * INIT IS THE INITIALIZATION ROUTINE. * ALL SYSTEM VARIABLES ARE SET HERE. INIT LDS #STACK SET STACK INIT1 CLR LSTTRM CLEAR TERM BYTE JSR FMSINT INIT SYSTEM CLR CMFLG CLEAR FLAG JSR TSTSTR CHECK FOR STARTUP * ENTRY * * ENTRY IS THE WARM START ENTRY POINT. * THE STACK IS RESET HERE. ENTRY LDS #STACK SET STACK JSR DWARM DO USER WARMSTART ROUTINE LDX #WARMS POINT TO WARM START STX RETRNR SET RETURN REG LDX #CHPR SET SWI3 VECTOR STX [SWIVEC] LDX IHNDLR SET IRQ VECTOR STX [IRQVEC] LDX #PR0 SET PR # 0 STX CP CLR PRCNT SET STATUS CLR GOTFIL CLEAR FILE DESIG. BSR RESTIO RESTORE IO * DOS * * DOS IS THE MAIN DOS LOOP DOS LDA LSTTRM CHECK TERMINATOR CMPA TTYEOL WAS IT EOL? BNE DOS2 INC BUFPNT+1 RESET BUFPNT BRA DOS3 DOS2 TST CMFLG TEST FLAG LBNE RETRN DO CMD RETURN JSR FMSCLS CLOSE ALL BNE INIT1 ERRORS? LDX #PPRMP +++ JSR PSTRNG PRINT BSR INBUF DOS3 JSR SKPSPC SKIP SPACES CMPA #$0D LONE CARRIAGE RET? BEQ DOS2 DOS4 LDX #SYSFCB POINT TO SYSTEM FCB INC SYSFLG SET SYSTEM DRIVE JSR GETFIL GET FILE NAME BCS NFERR ERROR? LDX #COMTBL POINT TO TABLE BSR LKNAM LOOK FOR NAME BEQ DOS6 FIND? LDX USRTBL CHECK USER TABLE BEQ DOS8 IS THERE ONE? BSR LKNAM LOOK FOR NAME BNE DOS8 FIND? DOS6 JMP [1,X] JUMP TO COM ADDRESS DOS8 JSR LGO DO LOAD & GO * NFERR NFERR LDX #WHATST POINT TO STRING LDA #$15 SET ERROR TYPE NFERR1 STA ERRTYP NFERR2 JSR PSTRNG OUTPUT IT NFERR3 CLR LSTTRM CLEAR TERM JMP ENTRY RESTART * RESTIO * * RESTIO RESTORES THE SYSTEM IO JUMP * VECTORS FOR INPUT, OUTPUT, & INIT. RESTIO LDX OUTCH2+1 SET OUTPUT STX OUTCH+1 LDX INCH2+1 SET INPUT STX INCH+1 CLR INCHNL CLR OUTCHN CLEAR OUT CHAN CLR SPCLS SET SPECIALS CLR FILIN CLEAR FILES CLR FILOUT RTS RTS * LKNAM * * LKNAM LOOKS FOR A COMMAND * NAME IN A TABLE * * ENTRY: X POINTS TO TABLE * EXIT: EQ IF FOUND * X+1 POINTS TO ADR LKNAM LDY #SYSFCB+4 SET POINTER LKNAM3 LDA 0,Y+ GET A NAME CHAR CMPA #$5F CHECK IF UPPER CASE BLS LKNAM4 SKIP IF NOT SUBA #$20 MAKE UPPER LKNAM4 CMPA 0,X+ CHECK AGAINST TABLE BNE LKNAM6 BRANCH IF NO MATCH TST 0,X CHECK IF END BNE LKNAM3 LOOP IF NOT TST 0,Y AT END OF NAME BEQ LKNAM8 GOT COMMAND IF SO LKNAM6 TST 0,X+ END OF WORD? BNE LKNAM6 LOOP TIL SO LEAX 2,X BUMP PAST ADDRESS TST 0,X END OF TABLE? BNE LKNAM REPEAT IF NOT ANDCC #$FB CLZ SET NOT EQUAL LKNAM8 RTS * INBUF * * INBUF INPUTS A LINE INTO THE LINE * BUFFER. DELETE AND BACK SPACE * CHARACTERS ARE CHECKED HERE. * * ENTRY: NONE * EXIT: ALL REGISTERS CHANGED INBUF LDX #LINBUF POINT TO BUFFER STX BUFPNT SET POINTER INBUF2 JSR GETCHR GO GET A CHARACTER CMPA TTYDEL IS IT DELETE? BEQ INBUF5 CMPA TTYBS IS IT BACK SPACE? BEQ INBUF6 CMPA #$0D IS IT CARRIAGE RET? BEQ INBUF4 CMPA #$0A IS IT LF? BEQ INBUF7 CMPA #$1F IS IT CONTROL? BLS INBUF2 IGNORE IF SO INBUF3 CMPX #LINBUF+LBL-1 BEQ INBUF2 INBUF4 STA 0,X+ PUT CHAR IN BUFFER CMPA #$0D IS IT RETURN? BNE INBUF2 REPEAT IF NOT RTS INBUF5 LDX #PPRMP1 BSR PSTRNG BRA INBUF INBUF6 CMPX #LINBUF FRONT OF BUFFER? BEQ INBUF5 LEAX -1,X DEC THE POINTER LDA TTYBE GET ECHO CHAR CMPA #8 IS IT ^H ? BNE INBU65 LDA #$20 SETUP SPACE JSR PUTCH6 OUTPUT IT LDA TTYBE GET CHAR INBU65 JSR PUTCH6 OUTPUT IT BRA INBUF2 REPEAT INBUF7 LDA #$0D OUTPUT CR JSR PUTCHR LDA #$20 SETUP SPACE BRA INBUF3 * PSTRNG * * PSTRNG PRINTS THE STRING POINTED * TO BY THE INDEX REGISTER. * * ENTRY: X POINTS TO STRING * EXIT: A & X CHANGED PSTRNG BSR PCRLF OUTPUT CR & LF PDATA1 LDA 0,X GET A CHARACTER CMPA #4 IS IT TERM? BEQ PCRLF8 JSR PUTCHR GO PUT CHAR. LEAX 1,X BUMP THE POINTER BRA PDATA1 REPEAT IT * BREAK * * BREAK CHECKS FOR A CHARACTER ON INPUT CHANNEL, * RETURNS IMMEDIATELY IF NONE OR NOT ESCAPE. * IF ESCAPE, WAITS FOR ANOTHER OR FOR RETURN. BREAK JSR DSTAT ANY INPUT CHARACTER? BEQ PCRLF9 EXIT IF NOT JSR [INCHNE] ELSE, GET THE CHARACTER CMPA TTYESC AN ESCAPE? BNE PCRLF9 EXIT IF NOT BREAK1 CLR LINE CLEAR LINE COUNT BREAK2 JSR [INCHNE] WAIT FOR A CHARACTER CMPA TTYESC AN ESCAPE? BEQ PCRLF9 CONTINUE IF SO CMPA #$0D IS IT A C.R.? BNE BREAK2 LOOP IF NEITHER CLR LSTTRM CLEAR TERMINATOR JMP [RETRNR] JUMP TO RETURN REG * PCRLF * * PCRLF OUTPUTS A CARRIAGE RETURN * AND A LINE FEED COMBINATION. * * ENTRY: NONE * EXIT: A & B CHANGED PCRLF TST SPCLS TEST SPECIALS BNE PCRLF2 BSR BREAK CHECK FOR BREAK LDA TTYDP GET COUNT BEQ PCRLF2 IS IT OFF? CMPA LINE CHECK COUNT BHI PCRL19 CLR LINE CLEAR COUNT TST TTYPS PAUSE ON? BEQ PCRLF1 BSR BREAK1 WAIT FOR ESC PCRLF1 PSHS B SAVE B LDB TTYEJ CHECK COUNT BEQ PCRL18 PCRL15 BSR PCRLF2 OUTPUT CR & LF DECB BNE PCRL15 PCRL18 PULS B RESTORE B PCRL19 INC LINE BUMP LINE COUNT PCRLF2 LDA #$0D SET UP CR BSR PUTCHR OUTPUT IT LDA #$0A SET UP LINE FEED BSR PUTCHR OUTPUT IT PSHS B SAVE B LDB TTYNL CHECK NULLS BEQ PCRLF6 PCRLF4 CLRA SET UP NULL BSR PUTCHR OUTPUT IT DECB DEC THE COUNT BNE PCRLF4 REPEAT? PCRLF6 PULS B RESTORE B PCRLF8 ANDCC #$FE CLC CLEAR ERRORS PCRLF9 RTS * GETCHR * * GETCHR GETS A CHARACTER FROM EITHER * THE STANDARD INPUT OR A FILE. * * ENTRY: NONE * EXIT: A HAS CHARACTER GETCHR TST INCHNL CHECK CHAN BNE GETCH5 TST FILIN FILE INPUT? BEQ GETCH4 BSR FILIO DO FILE INPUT TST FILEKO ECHO CHARACTER? BEQ GETCH6 TST FILOUT OUTPUT FILE? BEQ GETCH6 BSR PUTCH6 ECHO CHARACTER BRA GETCH6 GETCH4 JSR INCH GET CHAR BRA GETCH6 GETCH5 JSR INCH2 TERMINAL INPUT GETCH6 CLR LINE CLEAR COUNTER RTS * FILIO * * FILIO DOSE A FMS CALL FOR CHARACTER * IO TRANSFER. CONTROL RETURNED TO * WARM START UPON ERROR. FILIO STX IOTEMP SAVE INDEX LDX FILIN GET INPUT FCB BRA FILIO4 FILIO2 STX IOTEMP SAVE X LDX FILOUT GET OUTPUT FCB FILIO4 JSR FMS CALL FMS BNE FILIO6 ERROR? LDX IOTEMP RESTORE INDEX RTS FILIO6 CLR FILOUT CLEAR CHAN JSR RPTERR REPORT ERROR JMP WARMS DO WARM START * PUTCHR * * PUTCHR WRITES A CHARACTER TO EITHER * THE STANDARD OUTPUT OR TO A FILE. * * ENTRY: CHARACTER IN A * EXIT: A MAY BE DESTROYED PUTCHR TST SPCLS CHECK SPECIALS BNE PUTCH6 CMPA #$1F IS IT CONTROL? BHI PUTCH2 CLR COLMN CLEAR COL COUNT BRA PUTCH6 PUTCH2 INC COLMN BUMP COUNTER PSHS A SAVE CHARACTER LDA COLCNT GET COUNT BEQ PUTCH4 IS IT 0? CMPA COLMN ENOUGH? BCC PUTCH4 JSR PCRLF OUTPUT CR & LF INC COLMN PUTCH4 PULS A RESTORE CHAR PUTCH6 PSHS A TST OUTCHN TEST CHANNEL BNE PUTCH7 TST FILOUT FILE OUTPUT? BEQ PUTC68 BSR FILIO2 DO FMS CALL BRA PUTC75 PUTC68 TST FILIN BNE PUTC75 FILE INPUT? JSR OUTCH OUTPUT IT BRA PUTC75 PUTCH7 JSR OUTCH2 CHAN 2 OUTPUT PUTC75 PULS A RESTORE CHAR RTS * OUTDEC * * OUTPUT DECIMAL NUMBER POINTED TO * BY X. THE NS ENTRY PRINTS LEADING * ZEROES. * * ENTRY: X POINTS TO NUMBER * EXIT: ALL CHANGED OUTDEC CLR OUTNUM CLEAR FLAG STB XFR SET SUP FLAG LDA #4 SET COUNTER STA TEMPR SAVE IT LDD 0,X GET VALUE LDX #CONTBL POINT TO CONSTANTS OUTDE4 BSR OUTDIG OUTPUT DIGIT LEAX 2,X BUMP TO NEXT CONST. DEC TEMPR DEC THE COUNT BNE OUTDE4 TFR B,A GET LS DIGIT BRA OUTHR OUTPUT IT * OUTDIG * * OUTDIG OUTPUTS THE DIGITS PLACE * OF THE NUMBER IN A & B CORRESPONDING * TO THE CONSTANT POINTED TO BY X. * * ENTRY: A & B CONTAIN NUMBER * X POINTS TO CONSTANT * EXIT: ALL REGISTERS PRESERVED OUTDIG CLR COUNT CLEAR COUNTER OUTDI2 CMPD 0,X COMPARE NUMBER BCS OUTDI5 SUBD 0,X SUB VALUE INC COUNT BUMP COUNTER BRA OUTDI2 REPEAT OUTDI5 PSHS A SAVE A LDA COUNT GET TOTAL BNE OUTDI6 IS IT ZERO? TST OUTNUM SUPRESS ZEROES? BNE OUTDI6 NUMBER YET? TST XFR NULL OR SPACE? BEQ OUTDI8 LDA #$20 SETUP SPACE BSR OUTHR2 OUTPUT IT BRA OUTDI8 OUTDI6 INC OUTNUM SHOW NUMBER BSR OUTHR OUTPUT DIGIT OUTDI8 PULS A,PC RESTORE A & RETURN * OUTADR * * OUTPUT FOUR HEX DIGITS POINTED * TO BY THE INDEX REGISTER. OUTADR BSR OUTHEX OUT 2 DIGITS LEAX 1,X BUMP POINTER * OUTHEX * * OUTHEX OUTPUTS THE BYTE IN HEX * POINTED TO BY X. * * ENTRY: X POINTS TO BYTE * EXIT: B PRESERVED OUTHEX LDA 0,X GET MSB BSR OUTHL OUTPUT IT LDA 0,X DO LSB BRA OUTHR OUTPUT IT OUTHL LSRA GET MSB TO LSB LSRA LSRA LSRA OUTHR ANDA #$0F MASK OFF MSB ADDA #$30 ADD IN BIAS CMPA #$39 OVER NUMBERS? BLS OUTHR2 ADDA #7 FINISH BIAS OUTHR2 JMP PUTCHR OUTPUT IT * CLASS * * CLASS WILL CLASSIFY THE CHARACTER IN A. * * ENTRY: CHARACTER IN A * EXIT: CS IF NOT 0-9 OR A-Z CLASS CMPA #$30 IS IT 0? BCS CLASS2 REPORT CMPA #$39 COMPARE TO 9 BLS CLASS4 IS IT NUMBER? CMPA #$41 COMPARE TO A BCS CLASS2 REPORT CMPA #$5A COMPARE TO Z BLS CLASS4 IS IT LETTER? CMPA #$61 CHECK FOR LOWER BCS CLASS2 REPORT CMPA #$7A UPPER LIMIT BLS CLASS4 CLASS2 ORCC #1 SEC SET FOR NOT STA LSTTRM RTS CLASS4 ANDCC #$FE CLC SHOW ALPHANUMERIC RTS * NXTCH * * NXTCH GETS THE NEXT CHARACTER FROM * THE LINE BUFFER. * * ENTRY: NONE * EXIT: A HAS CHARACTER NXTCH PSHS X LDX BUFPNT GET POINTER LDA CHAR GET OLD CHAR STA PRVCHR SAVE AS PREVIOUS NXTCH3 LDA 0,X+ GET THE CHARACTER STA CHAR SAVE CHAR CMPA #$0D IS IT RETURN? BEQ NXTCH4 CMPA TTYEOL IS IT EOL? BEQ NXTCH4 STX BUFPNT SAVE NEW POSITION CMPA #$20 CHECK FOR SPACE BNE NXTCH4 CMPA 0,X NEXT CHAR SPACE? BEQ NXTCH3 SKIP IF SO NXTCH4 BSR CLASS GO CLASSIFY PULS X,PC RESTORE REG. & RETURN * GETFIL * * GETFIL GETS A FILE SPECIFICATION FROM * THE INPUT STREAM. * * ENTRY: X POINTS TO FCB * EXIT: ALL REGISTERS CHANGED GETFIL LDA #21 SET PRE ERROR STA 1,X LDA #$FF SET DRIVE NEG STA 3,X CLR 4,X CLR 12,X CLEAR EXTENSION JSR SKPSPC SKIP SPACES LDA #8 SET UP COUNT STA COUNT SAVE IT BSR PRTM PROCESS ITEM BCS GETFI5 ERROR? BNE GETFI2 CHECK TERM BSR PRTM PROCESS ITEM BCS GETFI5 ERROR? BNE GETFI2 CHECK TERM CMPX CRSAVE CHECK ERROR? BEQ PRTM6 BSR PRTM PROCESS ITEM BLS PRTM6 ERROR? GETFI2 LDX CRSAVE RESTORE POINTER TST 4,X IS NAME NULL? BEQ PRTM6 TST 3,X CHECK DRIVE NUMBER BPL GETFI4 SET YET? TST SYSFLG SYSTEM DRIVE? BEQ GETFI3 LDA SYSDRV GET SYSTEM DRIVE BRA GETF35 GETFI3 LDA WRKDRV GET WORK DRIVE GETF35 STA 3,X SET DRIVE NUMBER GETFI4 CLR SYSFLG CLEAR FLAG GETFI5 LDX CRSAVE RESTORE FCB RTS * PRTM * * PRTM PROCESSES AN ITEM OF THE FILE SPEC PRTM BSR NXTCH GET NEXT CHAR BCS PRTM6 ERROR? CMPA #$39 CHECK IF NUMBER BHI PRTM2 LDX CRSAVE RESTORE POINTER TST 3,X CHECK FOR DRIVE NO BPL PRTM6 ERROR? ANDA #3 MASK DRIVE STA 3,X SET DRIVE NUM JSR NXTCH GET NEXT CHAR BCC PRTM6 ERROR? PRTM1 CMPA #$2E CHECK TERM ANDCC #$FE CLC CLEAR ERROR RTS PRTM2 LDB COUNT GET COUNT BMI PRTM6 ERROR? PSHS B SAVE COUNT SUBB #5 SET NEW COUNT STB COUNT SAVE IT PULS B RESTORE OLD PRTM3 CMPA MAPUP CHECK FOR LOWER CASE BCS PRTM4 SKIP IF NOT SUBA #$20 CONVERT TO UPPER PRTM4 STA 4,X PUT CHARACTER LEAX 1,X BUMP THE POINTER DECB DEC THE COUNT JSR NXTCH GET NEXT CHAR BCC PRTM5 TERM CHAR? CMPA #$2D IS IT HYPHEN? BEQ PRTM5 CMPA #$5F IS IT UNDER SCORE? BNE PRTM7 PRTM5 TSTB CHECK COUNT BNE PRTM3 REPEAT PRTM6 ORCC #1 SEC SET ERROR RTS PRTM7 TSTB CHECK COUNT BEQ PRTM1 FINISHED? CLR 4,X CLEAR REST LEAX 1,X BUMP POINTER DECB DEC THE COUNT BRA PRTM7 REPEAT * SKPSPC * * SKPSPC SKIPS SPACES IN THE BUFFER * * ENTRY: NONE * EXIT: ALL CHANGED SKPSPC STX CRSAVE SAVE INDEX LDX BUFPNT GET POINTER SKPSP2 LDA 0,X GET CHARACTER CMPA #$20 IS IT SPACE? BNE SKPSP4 LEAX 1,X BUMP TO NEXT BRA SKPSP2 REPEAT SKPSP4 STX BUFPNT SET POINTER LDX CRSAVE RESTORE REGISTER RTS * SETEXT * * SETEXT SETS A DEFAULT NAME EXTENSION * IF THE EXTENSION IS NULL. IT IS SET * ACCORDING TO THE CODE IN A. * * ENTRY: A HAS CODE * X POINTS TO FCB * EXIT: ALL REGISTERS CHANGED SETEXT PSHS X,Y SAVE REGISTERS LDB 12,X GET FIRST EXT BNE SETEX6 NULL? LDY #EXTTBL POINT TO TABLE CMPA #$0B CHECK RANGE BHI SETEX6 LDB #3 GET TO DESIRED EXT. MUL LEAY B,Y LDB #3 GET EXTENSION LENGTH SETEX4 LDA 0,Y+ GET CHAR STA 12,X PUT IN EXT LEAX 1,X BUMP POINTER DECB THE COUNT BNE SETEX4 FINISHED? SETEX6 PULS X,Y,PC RESTORE REGS. & RETURN * EXTTBL * * EXTENSION CODE TABLE EXTTBL FCC "BIN" FCC "TXT" FCC "CMD" FCC "BAS" FCC "SYS" FCC "BAK" FCC "SCR" FCC "DAT" FCC "BAC" FCC "DIR" FCC "PRT" FCC "OUT" * GETHEX * * GETHEX GETS A HEX VALUE FROM THE * INPUT BUFFER. B IS NON ZERO IF * THERE WAS A NUMBER. * * ENTRY: NONE * EXIT: CS IF ERROR * VALUE IN X GETHEX JSR CLROFS CLEAR SPACE & B REG GETHE2 JSR NXTCH GET CHARACTER BCS GETHE8 GRAPHICS? BSR TSTHEX TEST FOR HEX BCS GETHE6 ERROR? PSHS B SAVE IND LDB #4 SET UP COUNT GETHE4 ASL OFFSET+1 SHIFT OVER 4 ROL OFFSET DECB DEC THE COUNT BNE GETHE4 LOOP TIL DONE PULS B RESTORE IND ADDA OFFSET+1 STA OFFSET+1 SET NEW DIGIT INCB SET INDICATOR BRA GETHE2 GETHE6 JSR NXTCH GET CHARACTER BCC GETHE6 WAIT FOR TERM RTS GETHE8 LDX OFFSET GET VALUE GETHE9 ANDCC #$FE CLC CLEAR ERRORS RTS * TSTHEX * * TEST FOR VALID HEX CHARACTER TSTHEX SUBA #$47 REMOVE BIAS BPL TSTHE4 ADDA #6 CHECK RANGE BPL TSTHE3 ERROR? ADDA #7 ADD BACK IN BPL TSTHE4 ERROR? TSTHE3 ADDA #$0A FINAL BIAS BMI TSTHE4 NO ERROR ANDCC #$FE RTS TSTHE4 ORCC #1 ERROR RTS * INDEC * * INPUT DECIMAL NUMBER. * * ENTRY: NONE * EXIT: CS IF ERROR * VALUE IN X * B=0 IF NO NUMBER INDEC JSR CLROFS CLEAR SPACE & B REG. INDEC2 JSR NXTCH GET CHARACTER BCS GETHE8 TERM? CMPA #$39 CHECK FOR NUMBER BHI GETHE6 ANDA #$0F MASK NUMBER PSHS B SAVE COUNT PSHS A SAVE NUMBER LDD OFFSET GET VALUE ASLB ROLA ASLB ROLA ASLB ROLA ADDD OFFSET PLUS TIMES 2 ADDD OFFSET ADDB 0,S+ ADD IN NEW DIGIT ADCA #0 STD OFFSET SAVE RESULT PULS B GET COUNT INCB BUMP COUNT BRA INDEC2 REPEAT * LOAD * * LOAD IS THE SYSTEM BINARY LOADER * * ENTRY: X POINTS TO FCB * EXIT: WARMS IF ERROR * ALL RGISTERS CHANGED LOAD CLR XFR CLEAR TRANSFER FLAG LOAD2 BSR DOFMS DO READ CMPA #2 BEGIN DESIGNATOR? BEQ LOAD4 YES - GET DATA COUNT CMPA #$16 TRANSFER DESIG? BNE LOAD2 BSR DOFMS GET NEXT CHAR STA TADR SET TRANSFER ADR BSR DOFMS GET LSB STA TADR+1 SAVE IT LDA #1 SET NON ZERO STA XFR SET TRANSFER FLAG BRA LOAD2 REPEAT LOAD4 BSR DOFMS GET NEXT CHAR TFR A,B SAVE IT BSR DOFMS GET REST EXG A,B PUT IN ORDER ADDD OFFSET OFFSET + ADDRESS STD INDEX SAVE POINTER BSR DOFMS GET DATA COUNT TFR A,B MOVE TO B TSTA ZERO COUNT? BEQ LOAD2 YES - LOAD6 BSR DOFMS GET CHARACTER LDX INDEX GET POINTER STA 0,X+ SAVE IN MEMORY STX INDEX SAVE POINTER DECB DEC THE COUNT BNE LOAD6 FINISHED? BRA LOAD2 REPEAT * DOFMS * * DOFMS DOES AN IO TRANSFER TO THE * FILE MGMNT SYSTEM. * * ENTRY: NONE * EXIT: SAME AS FMS COMMAND DOFMS LDX #SYSFCB POINT TO FCB JSR FMS DO COMMAND BEQ DOFMS2 ERROR? LDA 1,X GET ERROR CODE CMPA #8 IS IT EOF? BNE DOFMS4 LEAS 2,S FIX STACK DOFMS1 LDA #4 SET CMND STA 0,X JSR FMS CALL FMS BNE DOFMS6 ERROR? DOFMS2 ANDCC #$FE CLC CLEAR ERROR RTS DOFMS4 STA ERRTYP SET TYPE CMPA #4 NO FILE ERROR? BNE DOFMS6 YES - ORCC #1 RTS DOFMS6 BSR RPTERR JMP NFERR3 * GET * * GET IS THE DOS COMMAND USED TO * LOAD BINARY FILES INTO MEMORY. * * ENTRY: NONE * EXIT: ALL REGISTERS CHANGED GET LDA #0 SET DEFAULT CODE BSR GETOPN GET & OPEN FILE BCS TSTNAM NO NAME? BSR CLROFS CLEAR OFFSET INC GOTFIL SET FILE INDIC. BSR LOAD GO DO LOAD BRA GET REPEAT PROCESS * CLROFS * * CLEARS STORAGE LOC. OFFSET CLROFS CLRA CLRB STD OFFSET RTS * TSTNAM * * TSTNAM TESTS TO SEE IF ANY NAMES HAVE * BEEN PROCESSED YET. TSTNAM LDB GOTFIL CHECK FLAG LBEQ NFERR REPORT ERROR JMP WARMS ALL DONE * LGO * * LGO IS THE SYSTEM LOAD AND GO MODULE. * * ENTRY: NONE * EXIT: ALL CHANGED LGO LDA #2 SET DEFAULT CODE BSR GETOP2 OPEN FILE BSR CLROFS CLEAR OFFSET JSR LOAD GO DO LOAD LDB XFR CHECK FOR TRANSFER ADR BEQ LGO2 JMP [TADR] JUMP TO XFR ADR LGO2 LDX #NOTRST POINT TO STRING LDA #$81 SET TYPE JMP NFERR1 REPORT * GETOPN * * GETOPN GETS THE FILES NAME FROM * THE INPUT BUFFER AND OPENS THE FILE * * ENTRY: A HAS DEFAULT CODE * EXIT: ALL CHANGED GETOPN PSHS A SAVE CODE LDX #SYSFCB POINT TO FCB JSR GETFIL GET FILE SPEC PULS A RESTORE CODE BCS GETOP4 ERROR? GETOP2 LDX #SYSFCB POINT TO FCB JSR SETEXT SET EXTENSION LDX #SYSFCB POINT TO FCB LDA #1 SET OPEN CODE STA 0,X SET COMMAND JSR DOFMS GO DO FMS LBCS NONMER REPORT ANY ERROR LDA #$FF SET NEG STA 59,X SET FOR NO SPC COMP RTS GETOP4 LDA LSTTRM GET TERM CMPA #$0D IS TERM CR? BEQ GETOP6 YES - CMPA TTYEOL IS IT EOL? LBNE NFERR ERROR IF NEITHER GETOP6 ORCC #1 SEC SET TERM INDICATOR RTS * RPTERR * * RPTERR REPORTS FMS ERRORS RPTERR PSHS X,Y SAVE REGISTERS LDA 1,X GET ERR NUM STA ERRTYP SAVE IT BEQ RPTE44 JSR RESTIO RESTORE IO LDY ERRVEC GET ERR VECTOR BNE RPTER1 CMPA #$10 NOT READY ERROR BEQ RPTER6 LDY #ERNM POINT TO STRING RPTER1 LDX #SYSFCB POINT TO FCB TST 2,X BEQ RPTER2 LDA #4 CLOSE FILE IN FCB STA 0,X JSR FMS CALL FMS BNE RPTER4 RPTER2 LDX #SYSFCB-8 SET TO FCB LDB #$0B SET COUNT BSR RPTER9 COPY NAME TO FCB LDX #SYSFCB LDA SYSDRV SET ALL DRIVES ** CHANGED TO SYS ** 2-25-79 STA 3,X LDA #1 SET EXTENSION STA 0,X OPEN FOR READ JSR FMS BNE RPTER4 ERROR? LDA ERRTYP GET ERROR NUM DECA CALCULATE REC NUM ASRA ASRA INCA CLR 32,X SET LRN IN FCB STA 33,X LDA #21 STA 0,X DO POSITION JSR FMS BEQ RPTER7 RPTER4 LDX #DSKERS POINT TO STRING JSR PSTRNG OUTPUT IT LDX CRSAVE RESTORE TO FCB LDA ERRTYP GET ERR NUM STA 1,X CLR 0,X CLRB JSR OUTDEC OUTPUT NUMBER RPTE44 PULS X,Y,PC RESTORE REGS. & RETURN RPTER6 LDX #NTRST POINT TO STRING JSR PSTRNG OUTPUT IT BRA RPTE44 RPTER7 JSR PCRLF OUTPUT CR & LF LDX #SYSFCB SET TO FCB LDA ERRTYP GET ERROR DECA FIND RECORD IN FCB ANDA #3 MASK NUMBER LDB #63 GET MESSAGE LENGTH MUL GET TO DESIRED MESSAGE ADDB #4 ADD IN BIAS STB 34,X SET FDI IN FCB RPTE85 JSR FMS GET CHARACTER BNE RPTER4 ERROR? JSR PUTCHR OUTPUT CHARACTER CMPA #$0D IS IT CR? BNE RPTE85 REPEAT LDA #4 CLOSE FILE STA 0,X JSR FMS CALL FMS BRA RPTE44 EXIT RPTER9 PSHS X,Y SAVE REGISTERS JMP SETEX4 GO COPY * NONMER * * REPORT NO NAME ERROR NONMER LDX #NONMST POINT TO STRING JMP NFERR2 REPORT IT * DOCMD * * DO COMMAND LINE DOCMD PULS A,B GET RET ADR STD RETADR SAVE ADDRESS LD32E STS STKSTR SAVE STACK PNTR CLR ERRTYP CLEAR FLAG INC CMFLG SET MODE JMP DOS4 GO DO LINE * RETRN * * RETRN RETURNS FROM DOCMD RETRN CLR CMFLG CLEAR MODE LDS STKSTR RESTORE STACK LDB ERRTYP GET STATUS JMP [RETADR] DO RETURN * ADDBX * ADDS CONTENTS OF B TO X ADDBX ABX RTS * MEXIT * * MONITOR EXIT CHECK MEXIT TST PR1 CHECK PROCESS 1 BNE MEXIT2 JMP [MONITR] JUMP TO MONITOR MEXIT2 LDX #SYSFCB POINT TO FCB LDA #27 STA 1,X SET ERROR JSR RPTERR REPORT ERROR JMP ENTRY GO BACK ERNM FCC "ERREURS",NUL,"SYS" ORG $D3FD TSTSTR JMP STAR PAG STTL FROM TSC 6809 DOS VERSION 2.92 * * TAVERNIER 6809 INITIALIZATION CODE * * COPYRIGHT (C) 1979 BY * * TECHNICAL SYSTEMS CONSULTANTS, INC. * PO BOX 2570 * WEST LAFAYETTE, INDIANA 47906 * * DISASSEMBLY BY DYNAMITE OF 1.TAVDOS9U.SYS * PAG STTL TAVERNIER 6809 INITIALIZATION CODE * * STARTUP ROUTINE * THIS ROUTINE INITIALIZES CERTAIN PARAMETERS, GETS * DATE FROM USER, AND EXECUTES A STARTUP.TXT FILE. ORG $CA00 STAR BRA STAR0 DVECT JSR GDATE vector to date prompt RTS LASTM FDB $C0A0 set default end of ram STAR0 LDA #$39 SET UP RTS STA TSTSTR disable re-entry to this code LDX MEMEND LEAX 161,X STX LASTM set last usable ram JSR [TINIT] ? LDX TIMINE get address of terminal input routine STX INCH+1 set in FLEX in char jump STX INCH2+1 set in FLEX alt in char jump LDX TIMOUT get address of terminal output routine STX OUTCH+1 set in FLEX out char jump STX OUTCH2+1 set in FLEX alternate out char jump LDX TRMCHK get address of terminal status check routine STX DSTAT+1 set in FLEX status check jump LDX #$00A0 start of memory + $A0 LDB #$B9 STAR2 LDA 0,X save memory STB 0,X test for RAM NOP CMPB 0,X BNE STAR3 not ram? STA 0,X restore memory LEAX 1024,X move up 1K CMPX LASTM end of user RAM? BNE STAR2 test some more STAR3 LEAX -161,X move to last good block STX MEMEND Set Memory end LDX #WARMS STX RETRNR LDX #FLEX9 JSR PSTRNG print heading JSR PCRLF BSR DVECT get date JSR PCRLF LDX #SYSFCB point to fcb LDA #1 STA 0,X open for read JSR FMS BEQ STAR4 no error? LDA 1,X get error number JSR DOFMS4 report it JMP ENTRY return to flex STAR4 LDX #LINBUF STAR5 STX BUFPNT set up input buffer LDX #SYSFCB JSR FMS get character from file BEQ STAR6 PSHS X,Y JMP RPTER4 back to flex STAR6 LDX BUFPNT STA 0,X+ put char. in line buffer CMPA #$0D end of line? BNE STAR5 get next character LDX #SYSFCB JSR DOFMS1 close file LDX #LINBUF STX BUFPNT reset line buffer LDX #ENTRY STX RETADR set return address JMP LD32E do command GDATE LDX #DATEQ prompt for date JSR PSTRNG JSR INBUF get date BSR GDATE2 evaluate number BCS GDATE bad number? STA SYSDAY OK so store it BSR GDATE2 evaluate number BCS GDATE bad number? GDATE1 STA SYSMTH OK so store it BSR GDATE2 evaluate number BCS GDATE bad number? STA SYSYR OK so store it RTS GDATE2 JSR INDEC get decimal number BCS GDATE4 any good? LDA OFFSET+1 get lsb of number TSTB test number of digits BEQ GDATE3 nothing input? ANDCC #$FE clear carry RTS GDATE3 ORCC #1 set carry GDATE4 RTS * FLEX startup signon message FLEX9 FCC "TAVDOS 6809 V1.0" FCC " Unlock" FCB $04 * Date prompt DATEQ FCC "DATE (JJ,MM,AA)? " FCB $04 ORG $C840 SYSFCB FCB $FF,$00,$00,$00 FCC "INITIAL" FCB $00 FCC "TXT" FCB $00 PAG STTL FROM TSC 6809 DOS VERSION 2.92 * * TAVERNIER 6809 SPOOLER CODE * * COPYRIGHT (C) 1979 BY * * TECHNICAL SYSTEMS CONSULTANTS, INC. * PO BOX 2570 * WEST LAFAYETTE, INDIANA 47906 * * DISASSEMBLY BY DYNAMITE OF 1.TAVDOS9U.SYS * PAG STTL TAVERNIER 6809 SPOOLER CODE ORG $C700 CHPR JMP LC723 scheduler LC703 JMP LC703 JMP LC747 queue handler LOCK JMP LC785 UNLOCK JMP LC795 JMP LC71F IRQ ISR LC712 FCB $0C TOF character FCB $00,$00,$00,$00 FDB $C810 first queue entry pointer LC719 FDB $C810 current queue entry pointer LC71B FCB $00 queue count LC71C FCB $00 flag LC71D FCB $00 qcheck 'kill' flag LC71E FCB $00 qcheck 'suspend' flag LC71F JMP [IHNDLR] handle IRQ * Scheduler LC723 LDX CP get stack address STS 2,X save current system stack TST PRCNT see if spooling is active BNE LC73F yes - go toggle task LDX #PR1 point to background task stack pointer INC PRCNT bump spooling active flag TST 0,X see if we are printing BEQ LC73F no - clear spooling flag LC738 STX CP set task stack pointer LDS 2,X restore stack pointer RTI return from interrupt * Toggle background and forground tasks LC73F LDX #PR0 load foreground task stack pointer CLR PRCNT set spooling inactive BRA LC738 go set the foreground task active * LC747 ORCC #$10 TST LC71B BEQ LC777 LDX LC719 LDA 0,X PSHS A LDD 1,X LDX #GDATE1 STD 64,X PULS A STA 3,X CLR 0,X LDA #1 STA 2,X CLR 34,X CLR 59,X LC76D TST LC71E BEQ LC79B SWI3 go to scheduler NOP BRA LC76D LC777 ANDCC #$EF LC779 JSR [TMOFF] CLR PR1 say that background task is done SWI3 go to scheduler NOP BRA LC779 LC785 ORCC #$10 TST FMSBSY BEQ LC791 SWI3 go to scheduler NOP BRA LC785 LC791 INC FMSBSY RTS LC795 CLR FMSBSY ANDCC #$EF RTS LC79B TST LC71D kill flag set? BNE LC7C7 yes - set up next queued entry LDX #GDATE1 point to queue FCB JSR FMS read a byte of data BNE LC7C7 error or end of file TST LC71C flag set? BEQ LC7BC no - CLR LC71C yes - clear it and do a linefeed CMPA #$0A was the character already a linefeed? BEQ LC7C3 yes - just do one PSHS A no - save character LDA #$0A and do a line feed BSR LC7F6 output character PULS A restore character LC7BC CMPA #$0D is character a ? BNE LC7C3 no - then just output it STA LC71C yes - set flag LC7C3 BSR LC7F6 output the character and loop BRA LC79B * got to end of file or FMS error - do next queued entry LC7C7 LDA #$0D close output file with a BSR LC7F6 LDA #$0A and line feed BSR LC7F6 LDA LC712 get TOF character BSR LC7F6 output it also CLR LC71D reset kill flag LDX LC719 point to current entry control block TST 3,X see if all copies have been done BEQ LC7E3 yes - do next entry in queue DEC 3,X no - decrement count JMP LC747 loop on queue handler * bump control pointer to next entry LC7E3 LEAX 4,X bump pointer CMPX #SYSFCB overflow? BNE LC7ED no - set pointer to next LDX #$C810 yes - reset queue pointer LC7ED STX LC719 set pointer to next entry DEC LC71B decrement queue count JMP LC747 loop on queue handler * output to printer LC7F6 JSR PCHK printer ready? BMI LC800 Yes, jump SWI3 no - go to scheduler NOP BRA LC7F6 LC800 JMP POUT yes - ouput byte PAG STTL FROM TSC 6809 DOS VERSION 2.92 * * TAVERNIER 6809 DISK FILE MANAGEMENT SYSTEM * * COPYRIGHT (C) 1979 BY * * TECHNICAL SYSTEMS CONSULTANTS, INC. * PO BOX 2570 * WEST LAFAYETTE, INDIANA 47906 * (317) 463-2502 * * NOTE: * AS OF 11/79 THE POINTS IN FMS WHICH LOAD A REGISTER * WITH THE SECTOR LENGTH HAVE BEEN CHANGED TO SIMPLY * CLEAR THE REGISTER (SINCE LDB #256 = LDB #0). * ALL POINTS AFFECTED BY THIS CHANGE ARE FLAGGED WITH * FOUR BACKSLASHES IN THE COMMENT FIELD (\\\\). * * CORRECTED WRITE FILE SECTOR MAP ROUTINE (WTFSM) 2/4/80. * DISASSEMBLY BY DYNAMITE OF 1.TAVDOS9U.SYS * PAG STTL TAVERNIER 6809 DISK FILE MANAGEMENT SYSTEM * * THE FILE MANAGEMENT SYSTEM (FMS) RELIES * ON THE USER DEFINITIONS OF FILE CONTROL * BLOCKS (FCB) FOR EACH FILE OPENED. * THE FCB STRUCTURE IS AS FOLLOWS: * * EACH FCB CONSUMES 320 BYTES OF RAM. * EACH BYTE IS USED AS FOLLOWS: * * NAME OFFSET FUNCTION * ---- ------ -------- FFC EQU 0 FUNCTION OP CODE FES EQU 1 ERROR STATUS BYTE FAS EQU 2 ACTIVITY STATUS FDN EQU 3 DRIVE NUMBER FFN EQU 4 - 11 FILE NAME FNE EQU 12 - 14 NAME EXTENSION FID EQU 15 IDENTIFIER BYTE FNU EQU 16 FILE NUMBER FSA EQU 17 - 18 START DISK ADR. FEA EQU 19 - 20 END DISK ADDRESS FSZ EQU 21 - 22 FILE SIZE FMP EQU 23 - 24 FILE SECTOR MAP FDT EQU 25 - 27 CREATION DATE FLP EQU 28 - 29 FCB LIST POINTER FCS EQU 30 - 31 CURRENT SECTOR FRN EQU 32 - 33 RECORD NUMBER FDI EQU 34 DATA INDEX FRI EQU 35 RANDOM INDEX FWB EQU 36 - 46 NAME WORK BUFFER FCD EQU 47 - 49 CURRENT DIR. ADR. FFD EQU 50 - 52 FIRST DELETED DIR. FLR EQU 53 - 55 LAST RECORD PNTR FNK EQU 56 - 58 NEXT KEY POINTER FSC EQU 59 SPACE COMP. CNTR FSP EQU 60 - 63 SPARE BYTES FSB EQU 64 - 319 SECTOR BUFFER FMX EQU FSP MAX SECTOR NUMBER SBC EQU FLR+2 SEQ. BLOCK COUNT * * ALL DRIVER ROUTINES ARE REFERENCED * THROUGH THIS TABLE. * DREAD EQU $DE00 DISK READ ROUTINE * DWRITE EQU $DE03 DISK WRITE ROUTINE * DRESTOR EQU $DE09 HEAD RESTORE ROUTINE * DVERIFY EQU $DE06 WRITE VERIFY ROUTINE * DDRIVE EQU $DE0C DRIVE SELECT * DCHECK EQU $DE0F CHECK READY * DQUKCHK EQU $DE12 QUICK READY CHECK * DINIT EQU $DE15 INITIALIZE DRIVERS * DWARM EQU $DE18 USER WARMSTART ROUTINE * DSEEK EQU $DE1B SEEK TO TRACK ROUTINE * ALL LOW LEVEL SYSTEM VARIABLES * AND CONSTANTS ARE IN THIS AREA. * * SYSTEM CONSTANTS SL EQU 256 SECTOR LENGTH NL EQU 11 NAME LENGTH RTC EQU 7 RETRY COUNT (Modif from FLEX29=5) RSC EQU 4 SEEK RETRY COUNT (Modif from FLEX29=7) RS EQU 4 RECORD START IRS EQU 16 INFO RECORD START IRL EQU 24 INFO RECORD LENGTH IRFAS EQU $04 INFO MASK LSTFC EQU 22 LAST FUNCTION CODE MAXSP EQU $7F MAX SPACE COUNT SPC EQU $20 ASCII SPACE SCC EQU 9 SPACE COMPRESSION CHAR. DELC EQU $18 DELETE CHARACTER NODR EQU 4 NUMBER OF DRIVES DTRK EQU 0 DIRECTORY START TRACK DSEC EQU 5 DIR. START SECTOR ISEC EQU 3 INFO SECTOR NUMBER TRMSK EQU $7F TRACK MASK SCMSK EQU $7F SECTOR MASK LSTTRK EQU 76 LAST TRACK NUMBER LSTSEC EQU 15 LAST SECTOR NUMBER RNFMSK EQU $10 REC NOT FOUND MASK MAIND EQU $0005 MAIN DIRECTORY ADDRESS * DOS CONSTANTS DATE EQU $CC0E SYSTEM DATA * LOCK EQU $C709 LOCK FMS * UNLOCK EQU $C70C UNLOCK FMS * PR1 EQU $CCFC PROCESS 1 REGISTER * SYSTEM ERROR NUMBER DEFINITIONS * * NAME NUMBER MEANING * ---- ------ ------- NOER EQU 0 NO ERROR ICER EQU 1 ILLEGAL FUNCTION CODE FBER EQU 2 FILE BUSY FEER EQU 3 FILE EXISTS NFER EQU 4 NO SUCH FILE DRER EQU 5 DIRECTORY ERROR TMER EQU 6 TOO MANY FILES DFER EQU 7 DISK FULL EFER EQU 8 END OF FILE RDER EQU 9 READ ERROR (CRC) WTER EQU 10 WRITE ERROR (CRC) WPER EQU 11 WRITE PROTECTED DPER EQU 12 DELETE PROTECTED IFER EQU 13 ILLEGAL FCB DAER EQU 14 ILLEGAL DISK ADDRESS DNER EQU 15 DRIVE NUMBER ERROR NRER EQU 16 NOT READY ADER EQU 17 ACCESS DENIED STER EQU 18 STATUS ERROR IRER EQU 19 INDEX RANGE ERROR FIER EQU 20 FMS INACTIVE INER EQU 21 ILLEGAL FILE NAME CLER EQU 22 CLOSE ERROR FSER EQU 23 FSM OVERFLOW ERROR RRER EQU 24 RECORD RANGE ERROR RMER EQU 25 RECORD MATCH ERROR ORG $D400 * FMS JUMP TABLES * * ALL CALLS TO THE FMS SHOULD ENTER * THROUGH ONE OF THESE THREE POINTS. FMSINT JMP FINIT $D436 FMSCLS JMP EXCLS $D459 FMS JMP CMND * GLOBAL VARIABLE STORAGE BASFCB RMB 2 FCB BASE POINTER $D409 CURFCB RMB 2 CURRENT FCB $D40B TEMP RMB 2 TEMPORARY INDEX $D40D DATAPT RMB 2 DATA POINTER $D40F ETRIES RMB 1 ERROR TRY COUNT $D411 STRIES RMB 1 SEEK TRY COUNT $D412 CLD RMB 2 CURRENT LOOK UP DIR $D413 CUD RMB 2 CURRENT USER DIR $D415 DIRDN RMB 1 DIRECTORY DRIVE NUM $D417 BKLN RMB 2 BACK LINK $D418 SINDIR RMB 1 SINGLE DIR SEARCH $D41A AVLPNT RMB 2 AVAIL POINTER $D41B SECMAP RMB NODR*6 SECTOR MAPS $D41D ORG $D435 VRFYFG FCB $FF VERIFY FLAG * SYSTEM ENTRY ROUTINES * * THE FOLLOWING THREE ROUTINES SHOULD * BE ACCESSED THROUGH THE SYSTEM JUMP * TABLE. * INIT * * INIT IS THE FMS INITIALIZATION ROUTINE. * NO ERRORS CAN OCCUR FROM THIS ROUTINE * AND THE SYSTEM ASSUMES NO FILES ARE OPEN. FINIT JSR DINIT INITIALIZE DRIVERS LDX #BASFCB SET POINTER LDB #10 SET COUNT BSR FINIT4 CLEAR SPACE LDX #MAIND SET MAIN DIRECTORY STX CLD STX CUD CLR SINDIR CLEAR SINGLE DIR FINIT2 LDX #AVLPNT POINT TO FMS SPC LDB #26 SET COUNTER FINIT4 CLR 0,X+ CLEAR BYTE DECB DEC THE COUNT BNE FINIT4 REPEAT? JMP UNLOCK * EXCLS * * EXCLS IS THE FMS EXIT ROUTINE. * EXECUTION OF THIS ROUTINE TELLS THE * SYSTEM TO CLOSE ALL OPEN FILES. EXCLS JSR LOCK LOCK FMS EXCLS1 LDX BASFCB GET LINK BASE BEQ FINIT2 ANY FCBS LEFT? LEAX -FLP,X STX CURFCB SET ACT. FCB PSHS Y SAVE REGISTER JSR CLOSE PULS Y RESTORE REGISTER BCC EXCLS1 REPEAT LDX CURFCB SET TO FCB CLR 2,X CLEAR FAS JSR UNLOCK UNLOCK FMS LDB #$FF SET ERROR RTS * CMND * * CMND IS THE FMS COMMAND INTERPRETER. * ALL COMMAND CALLS TO FMS SHOULD BE * THROUGH THIS ROUTINE. CMND TST PR1 PROCESS ACTIVE? BEQ CMND1 JSR LOCK LOCK FMS CMND1 PSHS B,Y SAVE REGISTERS STX CURFCB SET FCB STORAGE CLR FES,X CLEAR ERRORS LDB FFC,X GET FUNCTION CODE BNE CMND4 IO CODE? LDB FAS,X GET ACTIVITY BYTE BEQ CMND3 CMPB #2 IS IT WRITE? BEQ CMND2 JSR SRDSEQ GO DO READ CMND15 LDX CURFCB RESTORE X BCS CMND7 ERROR? TST PR1 PR 1 ACTIVE? BNE CMND8 CLRB CLEAR ERRORS PULS B,Y RESTORE REGISTERS RTS CMND2 JSR SWTSEQ GO DO WRITE BRA CMND15 CMND3 LDB #STER SET STATUS ERROR BRA CMND7 REPORT ERROR CMND4 CMPB #LSTFC CHECK CODE BLS CMND5 LDB #ICER SET CODE ERROR BRA CMND7 REPORT IT CMND5 DECB DEC THE CODE ASLB CODE TIMES 2 LDX #CODTBL POINT TO TABLE JSR [B,X] GO DO ROUTINE LDX CURFCB RESTORE FCB PNTR BCC CMND8 ERRORS? CMND7 STB FES,X SET ERROR CMND8 JSR UNLOCK TST FES,X TEST FOR ERROR PULS B,Y RESTORE REGISTERS RTS * CODTBL * * CODTBL IS THE SYSTEM TABLE OF * FUNCTION CODE ROUTINE ADDRESSES. CODTBL FDB OPNRD OPNRD OPEN FOR READ FDB OPNWT OPNWT OPEN FOR WRITE FDB OPNRW OPNRW OPEN FOR READ WRITE FDB CLOSE CLOSE CLOSE FILE FDB REWIND REWIND REWIND FILE FDB OPNDIR OPNDIR OPEN DIRECTORY FDB GETIR GETIR GET INFO RECORD FDB PUTIR PUTIR PUT INFO RECORD FDB READSS READSS READ SINGLE SECTOR FDB WRITSS WRITSS WRITE SINGLE SECTOR FDB WRTDIR WRTDIR WRITE DIRECTORY FDB DELETE DELETE DELETE FILE FDB RENAME RENAME RENAME FILE FDB RETRY4 RETRY4 APPEND FILES FDB NEXTS NEXTS NEXT SEQU. SECTOR FDB OPNSIR OPNSIR OPEN SYSTEM INFO FDB GETRAN GETRAN GET RANDOM CHARACTER FDB PUTRAN PUTRAN WRITE RANDOM CHARACTER FDB WTAPP WTAPP OPEN WRITE APPEND FDB NXTRDY NXTRDY FIND NEXT READY DRIVE FDB POSIT POSIT POSITION TO RECORD N FDB BKREC BKREC BACKUP ONE RECORD * * THE FOLLOWING ROUTINES ARE THE SYSTEM * LEVEL ROUTINES USED BY THE FMS. * SETFCB * * SETFCB IS USED TO TELL THE SYSTEM * WHERE THE NEW FCB IS LOCATED. * IT SETS UP A CHAINED STRUCTURE * WITH BASFCB AS THE BASE OF THE CHAIN. * * ENTRY: NONE * EXIT: CS IF FCB EXISTS * ALL REGISTERS CHANGED SETFCB BSR FNDFCB FIND FCB BNE SETFC2 ERROR? LDB #FBER FILE BUSY ORCC #1 SEC SHOW ERROR RTS SETFC2 STD 0,X SET FCB LDX 0,X GET FCB POS CLR 0,X CLEAR LAST LINK CLR 1,X ALSO SHOWS NO ERROR RTS * REMFCB * * REMFCB IS USED TO REMOVE AN ACTIVE * FCB FROM THE SYSTEM FCB LIST. * * ENTRY: NONE * EXIT: CS IF FCB NOT FOUND * ALL REGISTERS CHANGED REMFCB BSR FNDFCB FIND FCB BEQ REMFC2 ERROR? LDB #IFER SET ERROR CODE ORCC #1 SEC SHOW ERROR RTS REMFC2 LDD [0,X] GET NEXT LINK STD 0,X SAVE NEW VALUE ANDCC #$FE CLC CLEAR ERRORS RTS * FNDFCB * * FNDFCB TRIES TO FIND THE FCB IN * CURFCB IN THE SYSTEM TABLE. * * ENTRY: NONE * EXIT: NE IF NOT FOUND * A & B DESTROYED * X POINTS TO FCB FNDFCB LDD CURFCB PICKUP FCB ADDD #FLP SET TO LIST PNTR LDX #BASFCB GET BASE LOC. FNDFC3 LDY 0,X CHECK FOR LIST END BNE FNDFC4 ANDCC #$FB SET NE BIT RTS FNDFC4 CMPD 0,X COMPARE VALUE BNE FNDFC6 RTS RET WITH EQ FNDFC6 LDX 0,X MOVE TO NEXT FCB BRA FNDFC3 REPEAT * CLRFCB * * CLRFCB CLEARS SELECTED SECTIONS OF * THE CURRENT FCB. * * ENTRY: NONE * EXIT: ALL REGISTERS CHANGED CLRFCB LDX CURFCB GET FCB CLRA CLEAR A BYTE CLRB GET SECTOR LENGTH \\\\ BSR CLRFC2 CLEAR OUT LDB #FSB-FSA CLRFC2 STA FSA,X CLEAR BYTE LEAX 1,X BUMP THE POINTER DECB DEC THE COUNT BNE CLRFC2 LOOP TIL DONE RTS * COPNAM * * COPNAM WILL COPY THE NAME (NL BYTES) * FROM FCB AREA FFN (FILE NAME) TO THE * AREA FWB (WORK BUFFER). * * ENTRY: NONE * EXIT: ALL REGISTERS CHANGED COPNAM LDX CURFCB PICKUP FCB LDB #NL SET LENGTH COPNA1 LDA FFN,X GET CHARACTER STA 36,X LEAX 1,X BUMP THE POINTER DECB DEC THE COUNTER BNE COPNA1 REPEAT RTS COPNA3 LDX CURFCB GET FCB LDB #$0B COPNA2 LDA 4,X PSHS A LDA 36,X CMPA 0,S+ COMPARE THEM BNE COPNA4 NOT EQUAL? LEAX 1,X BUMP THE POINTER 1,X DECB DEC THE COUNTER BNE COPNA2 REPEAT COPNA4 RTS * GETRAN * FFC #17 * * * GETRAN GETS A RANDOM CHARACTER FROM * THE CURRENT FSB. * * ENTRY: FRI CONTAINS DESIRED INDEX * EXIT: CS IF FRI OUT OF RANGE * A CONTAINS CHARACTER * B & X CHANGED GETRAN LDX CURFCB GET FCB LDB FAS,X GET STATUS LSRB CHECK IF R OR RW BCC REWIN2 GO SET ERROR LDB FRI,X GET RANDOM INDEX JMP RDSEQ0 * PUTNXT * * PUTNXT PUTS THE CHARACTER IN A INTO * THE NEXT AVAILABLE FSB LOCATION * POINTED TO BY THE FDI. * * ENTRY: A CONTAINS CHARACTER * EXIT: CS IF LAST FSB POS. USED * B & X CHANGED PUTNXT LDX CURFCB PICKUP FCB LDB FDI,X GET DATA INDEX INC FDI,X BUMP FDI ABX ADD IN INDEX STA FSB,X PUT THE CHARACTER INCB BUMP IT BNE PUTRA2 OVER END OF FSB? ORCC #1 SEC OVER END! RTS * PUTRAN * FFC #18 * * * PUTRAN PUTS THE CHARACTER IN A * IN THE FSB LOCATION INDEXED BY * THE FRI. * * ENTRY: A CONTAINS CHARACTER * FRI CONTAINS INDEX * EXIT: CS IF FRI OUT OF RANGE * B & X CHANGED PUTRAN LDX CURFCB GET FCB LDB FAS,X CHECK IF RW ANDB #3 MASK OFF CMPB #3 IS IT RW? BNE REWIN2 SKIP IF ERROR ORB #$80 SET UPDATE BIT STB FAS,X SAVE IT LDB FID,X CHECK WP BITB #$80 BNE PUTRA4 LDB FRI,X GET RANDOM INDEX ABX ADD IN INDEX STA 64,X FSB,X PUT CHARACTER PUTRA2 ANDCC #$FE CLC CLEAR ERROR RTS PUTRA4 LDB #WPER SET WP ERROR ORCC #1 SEC SET ERROR RTS * SRDSEQ * * SRDSEQ IS THE HIGH LEVEL READ * SEQUENTIAL CHARACTER ROUTINE. * CONTROL CHARACTERS AND SPACE * EXPANSION ARE HANDLED HERE UNLESS * FSC IS NEGATIVE. * * ENTRY: NONE * EXIT: CS IF ERROR * B HAS ERROR NUMBER * A & X CHANGED SRDSEQ LDA FSC,X CHECK FOR SP. EXP. BMI RDSEQ CONTROL IGNORE? BEQ SRDSE2 ACTIVE EXPANSION? DEC FSC,X DEC THE SPACE COUNT LDA #SPC SETUP SPACE BRA SRDSE7 FINISH UP SRDSE2 BSR RDSEQ READ NEXT CHAR BCS SRDSE8 ERRORS? CMPA #DELC IS IT DELETED? BHI SRDSE7 SKIP ALL SPECIALS BEQ SRDSE2 CMPA #SCC SPACE COMP CHAR? BNE SRDSE6 BSR RDSEQ GO GET COUNT BCS SRDSE8 ERROR? LDX CURFCB RESTORE POINTER STA FSC,X SAVE COUNT BRA SRDSEQ REPEAT SRDSE6 TSTA IS CHAR NULL? BEQ SRDSE2 IGNORE IF SO SRDSE7 ANDCC #$FE CLC CLEAR ERROR SRDSE8 RTS * REWIND * FFC #5 * * * REWIND WILL LOGICALLY REWIND THE * FILE SPECIFIED IN THE FCB. * * ENTRY: NONE * EXIT: SAME AS RDNEXT REWIND JSR DOSTAT CHECK STATUS BCS REWIN2 ERROR? BITA #1 CHECK FOR R BIT BEQ REWIN2 ERROR? STA FFC,X SET FFC JMP OPNRD1 GO SETUP FILE REWIN2 LDB #STER SET ERROR CODE ORCC #1 SEC SHOW ERROR RTS * RDSEQ * * RDSEQ IS THE LOW LEVEL GET * SEQUENTIAL CHARACTER ROUTINE. * * ENTRY: NONE * EXIT: CHAR IN A * CS IF ERROR * B & X DESTROYED RDSEQ LDX CURFCB PICKUP FCB LDB FDI,X GET DATA INDEX BEQ RDSEQ1 INC FDI,X BUMP DATA INDEX RDSEQ0 ABX ADD IN OFFSET LDA FSB,X GET CHARACTER ANDCC #$FE CLC RTS RDSEQ1 BSR RDNEXT GET NEXT RECORD BCC RDSEQ ERRORS? RTS * RDNEXT * * RDNEXT READS THE NEXT SEQUENTIAL * RECORD IF IT EXISTS. * * ENTRY: NONE * EXIT: CS IF ERROR * B HAS ERROR NUMBER * A & X CHANGED RDNEXT LDX CURFCB PICKUP FCB LDD FSB,X GET TRACK & SECTOR INC FRN+1,X BUMP REC NUM BNE RDNEX1 INC FRN,X RDNEX1 CMPD #$0000 TEST IF 0 LINK BEQ RDNEX4 END OF FILE? RDNEX2 STD FCS,X SET CURRENT ADR. PSHS A LDA #RS SET RECORD START STA FDI,X SAVE IT PULS A BSR READSS GO DO READ BCC RDNEX8 ERRORS? BITB #$80 CHECK NOT READY BEQ RDNEX3 LDB #NRER SET ERROR BRA RDNEX6 RDNEX3 LDB #RDER SET READ ERROR BRA RDNEX6 RDNEX4 LDB #EFER SET EOF ERROR RDNEX6 ORCC #1 SEC SHOW ERROR RDNEX8 RTS * READSS * FFC #9 * * * READSS READS A SINGLE RECORD (SECTOR) * FROM THE DISK. * * ENTRY: NONE * EXIT: CS IF READ ERROR * ALL REGISTERS CHANGED READSS BSR CLRTRY CLEAR TRY COUNTERS LDX CURFCB SET POINTER JSR DDRIVE DO DRIVE SEL BCS READS6 READS2 BSR GETCUR GET DISK ADDRESS JSR DREAD GO READ RECORD BNE READS4 ERRORS? ANDCC #$FE CLC CLEAR ERROR RTS READS4 PSHS B SAVE B BSR RETRY CHECK IF RETRY PULS B RESTORE B BCC READS2 TRY AGAIN? READS6 RTS * GETCUR * * GETCUR GETS THE CURRENT RECORD ADDRESS * (TRACK AND SECTOR) INTO A & B. * IF ILLEGAL ADDRESS, CARRY IS SET. * * ENTRY: NONE * EXIT: CS IF ILLEGAL ADR. * A = TRACK NUMBER * B = SECTOR NUMBER * X POINTS TO FSB GETCUR LDX CURFCB PICKUP FCB LDD FCS,X GET TRACK & SECTOR LEAX FSB,X ADD FSB BIAS RTS * CLRTRY * * CLRTRY CLEARS THE ERROR TRY COUNTERS * * ENTRY: NONE * EXIT: A CLEARED CLRTRY CLRA CLEAR A STA ETRIES CLEAR COUNTERS STA STRIES RTS * RETRY * * RETRY WILL TEST THE TRY COUNTERS * ETRIES AND STRIES TO SEE IF THEY * ARE AT MAXIMUM. * A RESTORE OPERATION IS PERFORMED * IF NECESSARY. * * ENTRY: NONE * EXIT: CS IF NO MORE TRIES LEFT RETRY BITB #$10 CHECK IF SEEK ERROR BNE RETRY2 BITB #$80 CHECK NOT READY BNE RETRY6 LDB ETRIES CHECK ERROR CNTR INCB BUMP IT ONE CMPB #RTC IS IT MAXIMUM? BEQ RETRY2 STB ETRIES SAVE COUNT BRA RETRY4 RETRY2 CLR ETRIES CLEAR COUNTER LDB STRIES CHECK SEEK CNTR INCB BUMP IT CMPB #RSC IS IT MAXIMUM? BEQ RETRY6 STB STRIES SAVE COUNTER LDX CURFCB JSR DRESTOR GO RESTORE RETRY4 ANDCC #$FE CLC CLEAR ERROR RTS RETRY6 ORCC #1 SEC SET ERROR RTS * WRITSS * FFC #10 * * * WRITSS IS THE SYSTEM WRITE SINGLE * SECTOR ROUTINE. * * ENTRY: NONE * EXIT: CS IF WRITE ERROR * ALL REGISTERS CHANGED WRITSS BSR CLRTRY CLEAR TRY COUNTERS LDX CURFCB SET POINTER JSR DDRIVE DO DRIVE SEL BCS WRITS6 WRITS2 LDX CURFCB SET POINTER BSR GETCUR GET CURRENT SEC JSR DWRITE DO ACTUAL WRITE BNE WRITS4 ERRORS? LDA VRFYFG VERIFY SECTOR? BEQ SWTSE6 NO VERIFY JSR DVERIFY GO DO VERIFY BEQ SWTSE6 ERROR? WRITS4 BITB #$40 CHECK IF W.P. BNE WRITS8 PSHS B SAVE STATUS BSR RETRY RETRY? PULS B RESTORE STATUS BCC WRITS2 TRY AGAIN WRITS6 RTS ERROR RETURN LDB #$20 SET ERROR WRITS8 ORCC #1 SHOW ERROR RTS ERROR RETURN * SWTSEQ * * SWTSEQ IS THE HIGH LEVEL WRITE * SEQUENTIAL CHARACTER ROUTINE. * SPACE COMPRESSION IS HANDLED HERE * UNLESS FSC IS NEGATIVE. * * ENTRY: NONE * EXIT: CS IF ERROR * B HAS ERROR NUMBER * A & X CHANGED SWTSEQ LDX CURFCB PICKUP FCB LDB FSC,X GET SPC COUNT BMI WTSEQ WRITE IF NEG. CMPA #SPC IS CHARACTER SPACE? BNE SWTSE4 INCB BUMP THE COUNT STB FSC,X SAVE IT CMPB #MAXSP MAXIMUM? BNE SWTSE6 BRA PUTSPC ** FIX FOR 128 SPACES ** SWTSE2 BSR PUTSPC GO PUT SPACES BCC SWTSEQ ERRORS? RTS SWTSE4 TSTB COUNT ZERO? BEQ WTSEQ BRA SWTSE2 DO SPACES SWTSE6 ANDCC #$FE CLC CLEAR ERRORS RTS * PUTSPC * * PUTSPC IS THE ROUTINE WHICH WRITES * THE SPACE COMPRESSION CODE AND THE * SPACE COUNT. * * ENTRY: B HAS COUNT * EXIT: A PRESERVED PUTSPC PSHS A SAVE CHAR CMPB #1 IS COUNT 1? BNE PUTSP2 LDA #$20 SETUP SPACE BRA PUTSP4 GO WRITE PUTSP2 LDA #SCC SETUP SCC BSR WTSEQ WRITE IT OUT PULS A BCS PUTSP6 ERROR? PSHS A SAVE CHAR LDX CURFCB PICKUP FCB LDA FSC,X GET COUNT PUTSP4 CLR FSC,X CLEAR COUNT BSR WTSEQ WRITE COUNT PULS A RESTORE CHAR PUTSP6 RTS * WTSEQ * * WTSEQ WRITES THE NEXT CHARACTER TO * THE FSB AREA OF THE FCB. * * ENTRY: A HAS CHARACTER * EXIT: CS IF ERROR * B HAS ERROR NUMBER * X CHANGED WTSEQ LDX CURFCB GET FCB POINTER LDB FAS,X GET ACTIVE STATUS CMPB #2 IS IT WRITE? LBNE REWIN2 ERROR IF NOT LDB FDI,X GET INDEX CMPB #RS IS IT BEGINNING? BNE WTSEQ2 PSHS A SAVE CHAR. BSR WTNEXT GO WRITE RECORD PULS A RESTORE CHAR. BCS WTSEQ4 ERRORS? WTSEQ2 JSR PUTNXT PUT CHARACTER BCC WTSEQ4 LAST SPACE USED? LDB #RS SET RECORD START LDX CURFCB POINT TO FCB STB FDI,X SET INDEX ANDCC #$FE CLC CLEAR ERRORS WTSEQ4 RTS * CLRLRN CLRLRN LDX CURFCB GET POINTER CLRA CLRB STD FRN,X CLEAR LRN STD FSB+2,X CLEAR ACTUAL RN BRA WTNEX1 GO WRITE NEXT * WTNEXT * * WTNEXT WRITES THE NEXT RECORD. * * ENTRY: X = FCB * EXIT: CS IF ERROR * REGISTERS CHANGED WTNEXT LDB FSA+1,X FIRST RECORD? BNE WTNEX1 LDB FMP,X CHECK FOR RANDOM BEQ ASNNXT CLR FMP,X CLEAR FLAG BSR ASNNXT GO ASSIGN BCS GETFS2 ERROR? BSR CLRLRN CLEAR LRN BCS GETFS2 ERROR? BSR CLRLRN CLEAR NEXT BCS GETFS2 ERROR? LDX CURFCB GET FCB LDB #2 SET FSM COUNT STB FMP,X LDD FSA,X GET START ADDR JMP UPDF75 GO DO UPDATE WTNEX1 BSR GETFST GET FIRST AVAIL LDX CURFCB SET FCB PNTR STD FSB,X SET FORWARD LINK JSR WRITSS WRITE RECORD BCC ASNNXT ERROR? JMP WRTERR REPORT ERROR * GETFST * * GETFST LOADS THE FIRST AVAILABLE * SECTOR ADDRESS INTO A & B. * * ENTRY: NONE * EXIT: EQ IF FSTAVL = 00 * X UNCHANGED * A & B = FSTAVL H & L GETFST BSR FSECMP FIND SECTOR MAP LDD 0,X GET FIRST AVAIL. GETFS2 RTS * FSECMP * * FSECMP FINDS THE SECTOR MAP * CORRESPONDING TO THE CURRENT * DRIVE SELECTED IN THE FCB. * * ENTRY: NONE * EXIT: EQ IF AVAIL NOT SET * X POINTS TO SECTOR MAP FSECMP LDX CURFCB PICKUP FCB LDB FDN,X GET DRIVE NUMBER LDA #6 MULTIPLY TIMES 6 MUL LDX #SECMAP POINT TO MAPS ABX FIX POINTER STX AVLPNT SET POINTER TST 0,X IS AVAIL EMPTY? RTS * ASNNXT * * ASNNXT ASSIGNS THE NEXT AVAILABLE * RECORD TO THE CURRENT OPEN WRITE * FILE POINTED TO BY THE FCB. * * ENTRY: NONE * EXIT: CS IF ERROR * ALL REGISTERS CHANGED ASNNXT BSR GETFST GET FSTAVL BNE ASNNX2 IS IT ZERO? LDB #DFER DISK FULL! ASNNX1 ORCC #1 SEC SET ERROR RTS ASNNX2 LDX CURFCB GET FCB POINTER STD FEA,X SET END ADDRESS TST FSA+1,X IS THIS FIRST? BNE ASNNX4 JUMP AHEAD IF NOT STD FSA,X SET START ADDRESS ASNNX4 INC FSZ+1,X BUMP FILE SIZE BNE ASNNX6 INC FSZ,X FIX MSB ASNNX6 TST FMP,X CHECK FOR RANDOM BEQ ASNN65 JSR UPDFSM UPDATE FSM ENTRY BCS ASNNX1 ERROR? LDX CURFCB GET FCB LDD FEA,X GET END ADDRESS ASNN65 JSR RDNEX2 READ NEXT RECORD BCS ASNNX1 READ ERROR? LDX CURFCB POINT TO FCB LDD FSB,X GET FOR. LINK PSHS A,B SAVE LINK BSR FSECMP FIND SECTOR MAP PULS A,B RESTORE LINK STD 0,X SET FIRST AVAIL BNE ASNNX7 FULL DISK?? CLR 2,X CLEAR OUT REST CLR 3,X CLR 4,X CLR 5,X BRA ASNNX8 GO AHEAD ASNNX7 LDY 4,X GET SEC COUNT LEAY -1,Y DEC BY 1 STY 4,X SAVE RESULT ASNNX8 CLRA CLEAR REGISTER LDX CURFCB SET POINTER INC FRN+1,X INC LRN BNE ASNN85 INC FRN,X ASNN85 CLRB GET SECTOR LENGTH \\\\ ASNNX9 STA FSB,X CLEAR LOCATION LEAX 1,X BUMP POINTER DECB DEC THE COUNTER BNE ASNNX9 REPEAT? LDX CURFCB GET FCB PNTR LDD FRN,X GET LRN STD FSB+2,X SAVE IN DATA ANDCC #$FE CLC CLEAR ERRORS RTS * OPN - SIR, DIR * * OPNIR OPENS EITHER THE SYSTEM IR * OR THE DIRECTORY IR, DEPENDING ON * THE ENTRY POINT. * * ENTRY: NONE * EXIT: B & X DESTROYED OPNSIR CLRB SET TRACK 0 PSHS B LDB #ISEC GET SECTOR BRA OPNIR * ------- No Path to this code OPNCUD LDX CUD GET CUD STX CLD SAVE AS LOOKUP * ------- OPNCLD LDB CLD GET TRACK PSHS B SAVE IT LDB CLD+1 GET SECTOR OPNDIR EQU OPNCLD OPNIR LDX CURFCB SET FCB POINTER STB FSB+1,X SAVE SECTOR PULS B GET TRACK STB FSB,X SET SECTOR PNTR CLR BKLN CLEAR BACK LINK CLRB GET SECTOR LENGTH \\\\ STB FDI,X SAVE IT RTS * GETIR * * GETIR GETS THE NEXT INFORMATION * RECORD (IR) FROM THE FSB. * * ENTRY: X = FCB * EXIT: CS IF ERROR GETIR LDX CURFCB SET FCB POINTER LDB FDI,X GET DATA INDEX BNE GETIR2 NEXT SECTOR? JSR RDNEXT GET NEXT SECTOR BCS GETIR8 ERROR? LDX CURFCB GET FCB POINTER TST BKLN TEST BACK LINK BNE GETIR1 IS IT SET? * LDD #$0005 FLEX 29FMS Code * LDD FSB+4,X GET NEW BL <- CORRECTED LDD