* DISASSEMBLY BY DYNAMITE OF 1.PRODOS.SYS
* OPT PAG
 TTL PRODOS 2.4
*
* MC 6809 DISK OPERATING SYSTEM FOR TAVERNIER
*

* EXTERNAL LABEL EQUATES

EOT EQU $04
L0000 EQU $0000
L0001 EQU $0001
L0002 EQU $0002
L0003 EQU $0003
L0004 EQU $0004
L0005 EQU $0005
L0006 EQU $0006
L0007 EQU $0007
L0008 EQU $0008
L000A EQU $000A
L000B EQU $000B
L0010 EQU $0010
L0013 EQU $0013
L0014 EQU $0014
L0016 EQU $0016
L0017 EQU $0017
L0018 EQU $0018
L001B EQU $001B
L001C EQU $001C
L0020 EQU $0020
L0023 EQU $0023
L0024 EQU $0024
L0027 EQU $0027
L0032 EQU $0032
L0035 EQU $0035
L0039 EQU $0039
L003E EQU $003E
L003F EQU $003F
L0041 EQU $0041
L0044 EQU $0044
L0045 EQU $0045
L0046 EQU $0046
L0047 EQU $0047
L0048 EQU $0048
L0049 EQU $0049
L0053 EQU $0053
L0054 EQU $0054
L0064 EQU $0064
L006D EQU $006D
L0070 EQU $0070
L007D EQU $007D
L007E EQU $007E
L007F EQU $007F
L008B EQU $008B
L008D EQU $008D
L008E EQU $008E
L0090 EQU $0090
L0091 EQU $0091
L009E EQU $009E
L00A0 EQU $00A0
L00A1 EQU $00A1
L00A4 EQU $00A4
L00A8 EQU $00A8
L00B4 EQU $00B4
L00BF EQU $00BF
L00C6 EQU $00C6
L00C8 EQU $00C8
L00C9 EQU $00C9
L00CC EQU $00CC
L00D2 EQU $00D2
L00D4 EQU $00D4
L00D7 EQU $00D7
L00DD EQU $00DD
L00DE EQU $00DE
L00DF EQU $00DF
L00E1 EQU $00E1
L00E3 EQU $00E3
L00E4 EQU $00E4
L00E8 EQU $00E8
L00F0 EQU $00F0
L00FE EQU $00FE
L3000 EQU $3000
L39D3 EQU $39D3
L6174 EQU $6174
L6575 EQU $6575
L696F EQU $696F
L6D65 EQU $6D65
L706C EQU $706C
L708A EQU $708A
L7374 EQU $7374
L7E7E EQU $7E7E
L8B8B EQU $8B8B
L9EC5 EQU $9EC5
LA49A EQU $A49A
LA49E EQU $A49E
LA4A2 EQU $A4A2
LA4C5 EQU $A4C5
LA502 EQU $A502
LA503 EQU $A503
LA59B EQU $A59B
LA917 EQU $A917
LA91A EQU $A91A
LBDDE EQU $BDDE

LC0A0 EQU $C0A0
LC0FF EQU $C0FF
LC810 EQU $C810

LC844 EQU $C844
LCAC0 EQU $CAC0
LCBC2 EQU $CBC2
* INDEX EQU $CC3D

* STKSTR EQU $CC45

LCCD6 EQU $CCD6
LD40F EQU $D40F
LD411 EQU $D411
LD412 EQU $D412
LD413 EQU $D413
LD414 EQU $D414
LD415 EQU $D415
LD417 EQU $D417
LD418 EQU $D418
LD41A EQU $D41A
LD41B EQU $D41B
LD41D EQU $D41D
LE000 EQU $E000
LE001 EQU $E001
LE002 EQU $E002
LE003 EQU $E003
LE080 EQU $E080
LEB08 EQU $EB08
LEB0E EQU $EB0E
LEFD8 EQU $EFD8
LEFDE EQU $EFDE
LEFF2 EQU $EFF2

* EXTERNAL LABEL EQUATES

CMDREG EQU $F000 CMDREG
TRKREG EQU $F001 TRKREG
SECREG EQU $F002 SECREG
DATREG EQU $F003 DATREG

*************************************************
*                                               *
*       Flex       initialization code          *
*                                               *
*************************************************

* STANDARD PRE-NAMED LABEL EQUATES

LINBUF EQU $C080
SYSFCB EQU $C840
* RETADR EQU $CC43
BASFCB EQU $D409
CURFCB EQU $D40B



* EXTERNAL LABEL EQUATES

STACK EQU $C07F
* CRSAVE EQU $CC3F
* IOTEMP EQU $CC47
OUTNUM EQU $CC4A
COUNT EQU $CC4B
GOTFIL EQU $CC4C
TEMP EQU $CC4D



 ORG $C700

CMDEND JMP LC723
LC703 JMP LC703
 JMP LC747
LC709 JMP LC785
LC70C JMP LC795
 JMP LC71F
LC712 INC <L0000
 NEG <L0000
 NEG <L00C8
 FCB $10
LC719 EORB #$10
LC71B NEG <L0000
LC71C EQU *-1
LC71D NEG <L0000
LC71E EQU *-1
LC71F JMP [IHNDLR]

LC723 LDX TASKPT
 STS 2,X
 TST FBFLAG
 BNE LC73F
 LDX #PR1
 INC FBFLAG
 TST 0,X
 BEQ LC73F
LC738 STX TASKPT
 LDS 2,X
 RTI
LC73F LDX #PR0
 CLR FBFLAG
 BRA LC738
LC747 ORCC #$10
 TST LC71B
 BEQ LC777
 LDX LC719
 LDA 0,X
 PSHS A
 LDD 1,X
 LDX #LCAC0
 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
 NOP
 BRA LC76D
LC777 ANDCC #$EF
LC779 JSR [TMOFF]
 CLR PR1
 SWI3
 NOP
 BRA LC779
LC785 ORCC #$10
 TST FMSBUS
 BEQ LC791
 SWI3
 NOP
 BRA LC785
LC791 INC FMSBUS
 RTS
LC795 CLR FMSBUS
 ANDCC #$EF
 RTS
LC79B TST LC71D
 BNE LC7CF
 LDX #LCAC0
 JSR FMS
 BNE LC7CF
 PSHS B
 LDB LC71C
 STA LC71C
 CMPD #$0A0D
 BEQ LC7C8
 CMPD #$0D0A
 BEQ LC7C8
 PULS B
 CMPA #$0D
 BNE LC7C4
 LDA #$0A
LC7C4 BSR LC7FD
 BRA LC79B
LC7C8 PULS B
 CLR LC71C
 BRA LC79B
LC7CF LDA #$0D
 BSR LC7FD
 LDA #$0A
 BSR LC7FD
 LDA LC712
 BSR LC7FD
 CLR LC71D
 LDX LC719
 TST 3,X
 BEQ LC7EB
 DEC 3,X
LC7E8 JMP LC747
LC7EB LEAX 4,X
 CMPX #SYSFCB
 BNE LC7F5
 LDX #LC810
LC7F5 STX LC719
 DEC LC71B
 BRA LC7E8
LC7FD JSR PCHK
 BMI LC807
 SWI3
 NOP
 BRA LC7FD
LC807 JMP POUT

 ORG $A500

LA500 FCB $1B ESC
 FCB $3D ESCAPE CODE FOR CURSOR POSITION
* FCB $00
* FCB $00

 ORG $A504

LA504 FCB $8E
LA505 FCB $8B,$8B,$8B,$8B
 FCB $98,$8B,$99,$20
 FCB $8B,$8B,$20,$20
 FCB $8B,$8B,$20,$20
 FCB $8B,$8B,$20,$97
 FCB $8B,$8B,$96,$8B
 FCB $8B,$8B,$8B,$A5
 FCB $A0,$50,$04
LA525 FCB $20
 FCB $97,$8B,$8B,$8B
 FCB $97,$8B,$99,$20
 FCB $98,$8B,$8B,$20
 FCB $20,$20,$8B,$8B
 FCB $20,$20,$20,$8B
 FCB $97,$8B,$8B,$8B
 FCB $8B,$20,$20,$20
 FCB $98,$8B,$96,$20
 FCB $97,$20,$98,$8B
 FCB $8B,$8B,$A6,$DE

LA54A LDX <$0021
 FCB $35,$20,$34,$18
 LDA    #$0C LINE 12
 STA    LA502
 LDA    #$3E COL 62
 STA    LA503
 LDB    #4
 LDX    #LA500
 JSR    LA8E6 MOVE TO POSITION
 PULS   A,X
 ABX
 LDB    #$3B
 JSR    LA8EF
 LBRA   LA78E

 LDA    0,-U

LA56F FCB $97,$8B,$8B,$8B
 FCB $8B,$99,$20,$98
 FCB $8B,$96,$20,$20
 FCB $98,$8B,$8B,$96
 FCB $20,$20,$98,$8B
 FCB $96,$20,$97,$8B
 FCB $8B,$8B,$8B,$99
 FCB $A6,$D3

 ORG $A5A0

 FCB $9E,$BF,$BD,$70
 FCB $8A,$70,$7E,$7E
 FCB $7E,$7E,$7E,$7E
 FCB $7E,$7E,$7E,$7E
 FCB $7E,$7E,$7E,$6B
 FCB $8D,$5D,$8E,$7E
 FCB $7E,$7E,$7E,$7E
 FCB $7E,$7E,$7E,$7E
 FCB $7E,$7E,$7E,$7E
 FCB $7E,$7E,$7E,$7E
 FCB $6B,$8D,$5F,$8E
 FCB $9E,$C5,$BD,$CB
 FCB $C2,$BF,$70,$8A
 FCB $70,$7E,$7E,$7E
 FCB $7E


 ORG $A600

LA600 FCB $0C,$1B,$46
 FCB $1B,$3C
LA605 FCB $55

LA606 PSHS DP SAVES DP
 LDA #$A5
 TFR A,DP LOAD NEW DP
 LDX #LA600
 LDB #5
LA611 JSR LA8E6 PRINT B CHAR FROM X POINTER 
 LDA #2 CODE 2
 LDX #LA505
 LBSR LA883 PRINT 7 TIMES THE CONTENT OF $A500-3 & X
 LDA #$16 CODE $16
 INC LA89A PRINT +1 CHAR
 LDX #LA525
 LBSR LA883 PRINT 7 TIMES THE CONTENT OF $A500-3 & X
 LDA #$2D CODE $2D
LA628 EQU *-1
 DEC LA89A PRINT -1 CHAR
 LDX #LA56F
 LBSR LA883 PRINT 7 TIMES THE CONTENT OF $A500-3 & X
 LDX #LA7A3
 LDB #$2C
 LBSR LA8E6 PRINT B CHAR FROM X POINTER 
 LDA #8
 STA <L0002
 LDA #1
 STA <L0003
 LDX #LA500
 LDB #4
 LBSR LA8E6 PRINT B CHAR FROM X POINTER 
 LDA #$8C
 LDB #$50
LA64E JSR OUTCH2
 DECB
 BNE LA64E
 LDA #$3C
 STA <L0003
 LDA #1
 STA <L0002
 LDY #L0007
LA660 JSR LA8E1
 INC <L0002
 LEAY -1,Y
 BNE LA660
 LDA #$9D
 STA <L0004
 JSR LA8E1
 LDX #LA80E
 LDB #$75
 LBSR LA8E6 PRINT B CHAR FROM X POINTER 
 LDA #$B6
 STA <L0004
 LDA #$0A
 STA <L0002
 LDA #$3D
 STA <L0003
 JSR LA70D
 LDA #$11
 STA <L0002
 LDA #$3D
 STA <L0003
 JSR LA70D
 LDA #$0A
 STA <L0002
 LDA #$3C
 STA <L0003
 LDA #$AF
 STA <L0004
 LDB #5
 LDX #LA500
 JSR LA8E6
 LDA #$50
 STA <L0003
 LDA #$AE
 STA <L0004
 JSR LA8E1
 LDA #$11
 STA <L0002
 LDA #$B0
 STA <L0004
 JSR LA8E1
 LDA #$3C
 STA <L0003
 BRA LA6E6

 STA <L00A1
 ANDA -24925,Y
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 CMPA 0,U
 ORB #$BE
 EORB #$75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 FCB $75
 BITA #$85
 BITA #$8A
 ORA #$75
 FCB $75

LA6E6 LDA #$B1
 STA <L0004
 JSR LA8E1
 DEC <L0002
 LDY #L0006
 LDA #$B7
 STA <L0004
LA6F7 LDA #$3C
 STA <L0003
 JSR LA8E1
 LDA #$50
 STA <L0003
 JSR LA8E1
 DEC <L0002
 LEAY -1,Y
 BNE LA6F7
 BRA LA720
LA70D LDY #L0013
LA711 LDX #LA500
 LDB #5
 JSR LA8E6
 INC <L0003
 LEAY -1,Y
 BNE LA711
 RTS
LA720 LDA #$0A
 STA <L0002
 LDA #$0F
 STA <L0003
 LDA #$D7
 STA <L0004
 LBSR LA8E1
 BSR LA733
 BRA LA73E
LA733 LDB #$1E
 LDA #$92
LA736 EQU *-1
LA737 JSR OUTCH2
 DECB
 BNE LA737
 RTS
LA73E LDA #$D8
 JSR OUTCH2
 LDY #L0006
 LDA #$B7
 STA <L0004
 LDA #$0B
 STA <L0002
LA74F LDA #$0F
 STA <L0003
 LDX #LA500
 LDB #5
 LBSR LA8E6 PRINT B CHAR FROM X POINTER 
 LDA #$2E
 STA <L0003
 LBSR LA8E1
 INC <L0002
 LEAY -1,Y
 BNE LA74F
 LDA #$11
 STA <L0002
 LDA #$0F
 STA <L0003
 LDA #$D9
 STA <L0004
 JSR LA8E1
 LDA #$93
 STA LA736
 BSR LA733
 LDA #$DA
 JSR OUTCH2
 LDX #LA8A6
 LDB #$3B
 LBSR LA8E6 PRINT B CHAR FROM X POINTER 
 JSR LA54A MOVE TO & PRINT @ 
LA78E LBSR LA7CF
LA791 LDA #$12
 STA <L0002
 LDA #1
 STA <L0003
 LDB #4
 LDX #LA500
 LBSR LA8E6 PRINT B CHAR FROM X POINTER 
 PULS DP,PC


LA7A3 FCB $1B,$3D,$07,$07
 FCC "NFORMATIQUE"
 FCB $2E
 FCB $1B,$3D,$07,$1C
 FCC "OMMUNICATION"
 FCB $2E
 FCB $1B,$3D,$07,$32
 FCC "ERVICE"
 FCB $2E
 
LA7CF PULS X
 LDA #$44
 STA LA503
 LDA #$0C
 STA LA502
 LDA #7
 STA LA504
LA7E0 JSR LA8E1
 LDA #$3E
 STA LA503
 LDA LA605
 STA <L0023
 JSR LA8FA
 LDA #$0D
 STA LA502
 JSR LA8E1
 JSR LA901
 LDA #$0F
 STA LA502
 LDA #$47
 STA LA503
LA805 JSR LA8E1
 JSR LA908
 LBRA LA791




LA80E FCB $1B,$3D,$01,$3E LINE 1/COL 66
 FCC "Chemin de la"
 FCB $1B,$3D,$02,$3E LINE 2/COL 66
 FCC "Dourdouille"
 FCB $2E
 FCB $1B,$3D,$03,$3E LINE 3/COL 66
 FCC "31390 - Carbonne"
 FCB $1B,$3D,$05,$3E LINE 5/COL 66
 FCC "Le Bureau & Serveur"
 FCB $1B,$3D,$06,$3E LINE 6/COL 66
 FCC "Tel : 61-87-05-00"
 FCB $1B,$3D,$06,$3E LINE 7/COL 66
 FCC "Tel : 61-87-05-05"

* PRINT 7 TIMES THE CONTENT OF $A500-3 & $A504-7
LA883 PSHS X SAVES X IN STACK
 LDY #L0007 LOAD NUMBER OF LOOPS
LA889 STA <L0003 STORE A IN $A503
 CLR <L0002 CLEAR $A502
LA88C EQU *-1
LA88D LDB #4 LOAD NUMBER OF CHAR TO PRINT
 INC <L0002 
 LDX #LA500
 LBSR LA8E6 PRINT 4 CHAR FROM X POINTER
 PULS X
 LDB #4 LOAD NUMBER OF CHAR TO PRINT
LA89A EQU *-1
 LBSR LA8E6 PRINT B CHAR FROM X POINTER
LA89C EQU *-2
LA89D EQU *-1
 PSHS X
 LEAY -1,Y
 BNE LA88D LOOP 7 TIMES
 PULS X,PC DRESTORE X AND RETURN


LA8A6 FCB $1B
 MUL
 INC <L0014

 FCC "Syst¸me d'exploitation"
 FCB $1B,$3D,$0D,$17
 FCC "Pour MC"
 FCB $2E
 FCC "6809"
 FCB $1B,$3D,$0F,$18
 FCC "Vesion  2.4" 


* END OF TEXT

LA8E1 FCB $8E
 FCB $A5
 NEG <L00C6
 FCB $05

* PRINT B CHAR FROM X POINTER 
LA8E6 LDA 0,X+
 JSR OUTCH2
 DECB
 BNE LA8E6
LA8ED EQU *-1
 RTS

LA8EF LDA 0,X+
 SUBA <L0023
 JSR OUTCH2
 DECB
 BNE LA8EF
 RTS
LA8FA LDX <L008B
 LDB #$0B
LA8FE LBRA LA8EF
LA901 LDX <L006D
 LDB #$11
 LBRA LA8EF
LA908 LDX <L0048
 LDB #8
 LBRA LA8EF


***************************
*                         *
*   START OF CCP PART     *
*                         *
***************************




 ORG $CC00

BSPCHR FCB     $08         $CC00   BACK SPACE (^H)
DELCHR FCB     $7F         $CC01   DELETE CHARACTER (^X) $18
EOLCHR FCB     $3A         $CC02   END OF LINE CHAR (:)
DEPTH  FCB     $18         $CC03   LINES PER SCREEN
WIDTH  FCB     $00         $CC04   COLUMNS PER LINE
NULLS  FCB     $00         $CC05   LINE PADDING NULLS
TABCHR FCB     $09         $CC06   TAB CHARACTER
BSECHR FCB     $08         $CC07   BACK SPACE ECHO
TTYEJ  FCB     $00         $CC08   EJECT LENGTH
PAUSE  FCB     $00         $CC09   PAUSE CONTROL  
ESCCHR FCB     $1B         $CC0A   ESCAPE CHARACTER
SYSDRV FCB     $00         $CC0B   SYSTEM DDRIVE
WRKDRV FCB     $00         $CC0C   WORKING DDRIVE
SYSFLG FCB     $00         $CC0D   SYSTEM FLAG
SYSMTH FCB     $00         $CC0E   SYSTEM DATE
SYSDAY FCB     $01
SYSYR  FCB     $55
LSTTRM FCB     $00         $CC11 LAST TERMINATOR
UCMDTB FDB     $0000       $CC12   USER COMMAND TABLE
BUFPNT FDB     $0000       $CC14   LINE BUFFER POINTER
ESCRET FDB     $0000       $CC16   ESCAPE RETURN REG
CURCHR FCB     $00         $CC18   CHARACTER
PRVCHR FCB     $00         $CC19   PREVIOUS CHARACTER
CURLCT FCB     $00         $CC1A   CURRENT LINE NUMBER
LOADAO FDB     $0000       $CC1B   LOADER ADR OFFSET
XFRFLG FCB     $00         $CC1D   TRANSFER FLAG
XFRADR FDB     $0000       $CC1E   TRANSFER ADDRESS
ERRTYP FCB     $00         $CC20   ERROR TYPE
SPECIO FCB     $00         $CC21   SPECIAL IO FLAG
OUTSWT FCB     $00         $CC22   OUTPUT CHANNEL BYTE
INSWT  FCB     $00         $CC23   INPUT CHANNEL BYTE
OUTFIL FDB     $0000       $CC24   OUTPUT FILE ADDRESS
INFIL  FDB     $0000       $CC26   INPUT FILE ADDRESS
DOCMDF FCB     $00         $CC28   COMMAND FLAG
CURCOL FCB     $00         $CC29   CURRENT OUTPUT COL.
TMRFLG FCB     $00         $CC2A   TIMER FLAG UNUSED NOW  
MEMEND FDB     $0000       $CC2B   MEMORY END
ERRVEC FDB     $0000       $CC2D   ERROR NAME VECTOR
INECHO FCB     $01         $CC2F   FILE INPUT ECHO
FMSBUS FCB     $00         $CC30   FMS IS BUSY FLAG
TASKPT FDB     $0000       $CC31   
CPUTYP FCB     $00         $CC33  
FBFLAG FCB     $00         $CC34   UNUSED NOW
SPARES  FDB     0,0,0       $CC35   SPARE BYTES
XTEMP   RMB     2           $CC3B   INDEX TEMP
INDEX   RMB     2           $CC3D   INDEX TEMP STORAGE
CRSAVE  RMB     2           $CC3F   INDEX SAVE
DATPNT  RMB     2           $CC41   DATA POINTER
RETADR  RMB     2           $CC43   RETURN ADDRESS
STKSTR  RMB     2           $CC45   STACK STORAGE
IOTEMP  RMB     2           $CC47   IO TEMP STORE

 ORG $CC49

ULCFLG FCB $00 $CC49   MAP FILENAMES TO UPPER

 ORG $CC4E

PROMPT FCB $1B,$43
 FCC "+++"
WHATST FCC "Pardon ?",EOT
NOTRST FCC "Adr ?",EOT
NONMST FCC "Inconnu",EOT
DSKERS FCC "Erreur # ",EOT
NTRST FCC "Lect ?",EOT
COMTBL FCC "GET",0
 FDB $D263
 FCC "MON",0
 FDB $CCAA
 FCB $00
CONTBL  FDB     10000
       FDB     1000
       FDB     100
       FDB     10
ERNM FCC "ERREURS",0,"SYS"
LCC9F FCC "EDBUF"
LCCA4 NEG <L0000
 NEG <L0053
 ROLB
 COMB
 TST PR1
 BNE LCCB3
 JMP [MONITR]
LCCB3 LDX #SYSFCB
 LDA #$1B
 STA 1,X
 JSR JRPTER
LCCBD BRA WARMS
LCCBF FCB $00

 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

*************************************************
*                                               *
*       PRODOS entry point after boot             *
*                                               *
*         this must start at $CD00              *
*                                               *
*************************************************

 ORG $CD00

COLDS JMP INIT GO INITIALIZE ($CD65)
WARMS JMP ENTRY WARM ENTRY POINT
RENTER JMP DOS3 RE-ENTER DOS
INCH JMP INCH INPUT ROUTINE
LCD0A EQU *-2
INCH2 JMP INCH2 TERMINAL INPUT
LCD0D EQU *-2
OUTCH JMP OUTCH OUTPUT CHARACTER
LCD10 EQU *-2
OUTCH2 JMP OUTCH2 TERMINAL OUTPUT
LCD13 EQU *-2
GETCHR JMP JGETCH GET CHARACTER
TCHR JMP PUTCHR
INBUFF JMP INBUF INPUT TO BUFFER
PSTRNG JMP JPSTRN PRINT STRING
CLASS JMP JCLASS CLASSIFY CHARACTER
PCRLF JMP JPCRLF PRINT CR AND LF
NXTCH JMP JNXTCH NEXT BUFFER CHAR
RSTRIO JMP RESTIO  DRESTORE IO VECTORS
GETFIL JMP JGETFI GET FILE SPEC
LOAD JMP JLOAD FILE LOADER
SETEXT JMP JSETEX SET NAME EXTENSION
ADDBX JMP JADDBX ADD B TO X
OUTDEC JMP JOUTDE OUTPUT DECIMAL
OUTHEX JMP JOUTHE OUT HEX CHARACTER
RPTERR JMP JRPTER REPORT ERROR
GETHEX JMP JGETHE GET HEX NUMBER
OUTADR JMP JOUTAD OUT HEX ADDRESS
INDEC JMP JINDEC GET DECIMAL NUMBER
DOCMND JMP JDOCMD DO COMMAND LINE
STATUS JMP STATUS TERMINAL INPUT STATUS
LCD4F EQU *-2
 JMP LCE14
 JMP LCE14
              
RETRN CLR DOCMDF CLEAR FLAG
 LDS STKSTR RESET STACK
 LDB ERRTYP LOAD ERROR CODE
 JMP [RETADR] RETURN

 ORG $CD65

* INIT ($CD65)
*
* INIT IS THE INITIALIZATION ROUTINE.
* ALL SYSTEM VARIABLES ARE SET HERE.
              
INIT LDS #STACK SET STACK
INIT1  CLR LSTTRM CLEAR TERM BYTE
 JSR [TINIT] INIT SYSTEM AT $D3E4 (NOTHING)
 JSR FMSINT INIT SYSTEM
 CLR DOCMDF 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 UWARM DO USER WARMSTART ROUTINE
 LDX #WARMS POINT TO WARM START
 STX ESCRET SET RETURN REG
 LDX #CMDEND SET SWI3 VECTOR
 STX [SWIVEC]
 LDX IHNDLR SET IRQ VECTOR
 STX [IRQVEC]
 LDX #PR0 SET PR # 0
 STX TASKPT 
 CLR FBFLAG SET STATUS
 CLR GOTFIL CLEAR FILE DESIG.
 BSR RESTIO RESTORE IO

* DOS
*
* DOS IS THE MAIN DOS LOOP
 
 LDA LSTTRM CHECK TERMINATOR
 CMPA EOLCHR WAS IT EOL?
 BNE DOS2
 INC BUFPNT+1 RESET BUFPNT
 BRA DOS3

DOS2 TST DOCMDF TEST FLAG
 BNE RETRN DO CMD RETURN
 JSR FMSCLS CLOSE ALL
 BNE INIT1 ERRORS ?
 LDX #PROMPT POINT TO PROMPT
 JSR JPSTRN 
 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 DDRIVE
 JSR JGETFI GET FILE NAME
 BCS NFERR ERROR?
 LDX #COMTBL POINT TO TABLE
 BSR LKNAM LOOK FOR NAME
 BEQ DOS6 FIND?
 LDX UCMDTB 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 LDGO DO LOAD & GO

* NFERR

NFERR LDX #WHATST POINT TO STRING
 LDA #$15 SET ERROR TYPE
NFERR1 STA ERRTYP
NFERR2 JSR JPSTRN OUTPUT IT
NFERR4 CLR LSTTRM CLEAR TERM
 BRA ENTRY RESTART

* RESTIO
*
* RESTIO DRESTORES 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 INSWT
 CLR OUTSWT CLEAR OUT CHAN
 CLR SPECIO SET SPECIALS
 CLR INFIL CLEAR FILES
 CLR OUTFIL
LCE14 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
 TST PR1
 BNE LCEA4
 TST INFIL
 BNE LCEA4
 TST LCCBF
 BNE LCEA4
 LDA #$2C
 CMPA LCA01
 BEQ LCE95
 PSHS B,X,Y
 LDX #LCC9F
 LDY #LC844
 LDB #$0B
LCE61 LDA 0,X+
 STA 0,Y+
 DECB
 BNE LCE61
 LDX #SYSFCB
 LDA SYSDRV
 STA 3,X
 LDA #1
 STA 0,X
 JSR FMS
 BEQ LCE7F
 INC LCCBF
 JMP DOFMS6
LCE7F COM 59,X
 JSR CLROFS
 JSR LOAD
 PULS B,X,Y
 LDA #$2C
 CMPA LCA01
 BNE LCE98
 LDA #$0D
 BRA LCEA7
LCE95 JMP LCA00
LCE98 INC LCCBF
 BRA LCEA4
LCE9D LDX #PROMPT
 BSR JPSTRN
 BRA INBUF
LCEA4 JSR JGETCH
LCEA7 CMPA DELCHR
 BEQ LCE9D
 CMPA BSPCHR
 BEQ LCEC5
 CMPA #$0D
 BEQ LCEBE
 CMPA #$1F
 BLS LCEA4
 CMPX #LC0FF
 BEQ LCEA4
LCEBE STA 0,X+
 CMPA #$0D
 BNE LCEA4
 RTS
LCEC5 CMPX #LINBUF
 BEQ LCE9D
 LEAX -1,X
 LDA BSECHR
 CMPA #8
 BNE LCEDB
 LDA #$20
 JSR PUTCH6
 LDA BSECHR
LCEDB JSR PUTCH6
 JMP LCEA4

* PSTRNG
*
* PSTRNG PRINTS THE STRING POINTED
* TO BY THE INDEX REGISTER.
*
*   ENTRY: X POINTS TO STRING
*   EXIT:  A & X CHANGED

JPSTRN BSR JPCRLF OUTPUT CR & LF
PDATA1 LDA 0,X+ GET A CHARACTER
 CMPA #4 IS IT TERM?
 BEQ PCRLF8
 JSR PUTCHR GO PUT CHAR.
 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 STATUS ANY INPUT CHARACTER?
 BCC PCRLF9 EXIT IF NOT
 CMPA ESCCHR
 BNE PCRLF9
BREAK1 CLR CURLCT
BREAK2 JSR [INCHNE]
 CMPA ESCCHR AN ESCAPE?
 BEQ PCRLF9 CONTINUE IF SO
 CMPA #$0D IS IT A C.R.?
 BNE BREAK2 LOOP IF NEITHER
 CLR LSTTRM CLEAR TERMINATOR
 JMP [ESCRET] JUMP TO RETURN REG

* PCRLF
*
* PCRLF OUTPUTS A CARRIAGE RETURN
* AND A LINE FEED COMBINATION.
*
*   ENTRY: NONE
*   EXIT:  A & B CHANGED

JPCRLF TST SPECIO TEST SPECIALS
 BNE PCRLF2
 BSR BREAK CHECK FOR BREAK
 LDA DEPTH GET COUNT
 BEQ PCRLF2 IS IT OFF?

 CMPA CURLCT CHECK COUNT
 BHI PCRL19 
 CLR CURLCT CLEAR COUNT
 TST PAUSE 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 DEC THE COUNT
 BNE PCRL15 

PCRL18 PULS B DRESTORE B
PCRL19 INC CURLCT BUMP LINE COUNT
PCRLF2 LDA #$0A SET UP LINE FEED
 BSR PUTCHR OUTPUT IT
 LDA #$0D SET UP CR
 BSR PUTCHR OUTPUT IT
 PSHS B SAVE B
 LDB NULLS CHECK NULLS
 BEQ PCRLF6  
PCRLF4 CLRA SET UP NULL
 BSR PUTCHR OUTPUT IT
 DECB DEC THE COUNT
 BNE PCRLF4 REPEAT?

PCRLF6 PULS B DRESTORE 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

JGETCH TST INSWT CHECK CHAN
 BNE GETCH5 
 TST INFIL FILE INPUT?
 BEQ GETCH4
 BSR FILIO DO FILE INPUT
 TST INECHO ECHO CHARACTER?
 BEQ GETCH6 
 TST OUTFIL OUTPUT FILE?
 BEQ GETCH6
 BSR PUTCH6 ECHO CHARACTER
 BRA GETCH6

GETCH4 JSR INCH GET CHAR
 BRA GETCH6 

GETCH5 JSR INCH2 TERMINAL INPUT
GETCH6 CLR CURLCT 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 INFIL GET INPUT FCB
 BRA FILIO4 

FILIO2 STX IOTEMP SAVE X
 LDX OUTFIL GET OUTPUT FCB

FILIO4 JSR FMS CALL FMS
 BNE FILIO6 ERROR?
 LDX IOTEMP DRESTORE INDEX
 RTS

FILIO6 CLR OUTFIL CLEAR CHAN
 JSR JRPTER 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 SPECIO CHECK SPECIALS
 BNE PUTCH6
 CMPA #$1F IS IT CONTROL?
 BHI PUTCH2
 CLR CURCOL CLEAR COL COUNT
 BRA PUTCH6 JUMP AHEAD

PUTCH2 INC CURCOL BUMP COUNTER
 PSHS A SAVE CHARACTER
 LDA WIDTH GET COUNT
 BEQ PUTCH4 IS IT 0?
 CMPA CURCOL ENOUGH?
 BCC PUTCH4 
 JSR JPCRLF OUTPUT CR & LF
 INC CURCOL

PUTCH4 PULS A DRESTORE CHAR
PUTCH6 PSHS A
 TST OUTSWT TEST CHANNEL
 BNE PUTCH7
 TST OUTFIL FILE OUTPUT?
 BEQ PUTC68 
 BSR FILIO2 DO FMS CALL
 BRA PUTC75

PUTC68 TST INFIL
 BNE PUTC75 FILE INPUT?
 JSR OUTCH OUTPUT IT
 BRA PUTC75

PUTCH7 JSR OUTCH2 CHAN 2 OUTPUT
PUTC75 PULS A,PC DRESTORE CHAR

* OUTDEC
*
* OUTPUT DECIMAL NUMBER POINTED TO
* BY X. THE NS ENTRY PRINTS LEADING
* ZEROES.
*
*   ENTRY: X POINTS TO NUMBER
*   EXIT:  ALL CHANGED

JOUTDE CLR OUTNUM CLEAR FLAG
 STB XFRFLG SET SUP FLAG
 LDA #4 SET COUNTER
 STA TEMP 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 TEMP DEC THE COUNT
 BNE OUTDE4
 TFR B,A GET LS DIGIT
 TSTA
 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 XFRFLG 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 DRESTORE A & RETURN

* OUTADR
*
* OUTPUT FOUR HEX DIGITS POINTED
* TO BY THE INDEX REGISTER.

JOUTAD BSR JOUTHE
 LEAX 1,X BUMP POINTER

* OUTHEX
*
* OUTHEX OUTPUTS THE BYTE IN HEX
* POINTED TO BY X.
*
*   ENTRY: X POINTS TO BYTE
*   EXIT:  B PRESERVED

JOUTHE 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

JCLASS 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

* NXTCH
*
* NXTCH GETS THE NEXT CHARACTER FROM
* THE LINE BUFFER.
*
*   ENTRY: NONE
*   EXIT:  A HAS CHARACTER

JNXTCH PSHS X
 LDX BUFPNT GET POINTER
 LDA CURCHR GET OLD CHAR
 STA PRVCHR SAVE AS PREVIOUS
NXTCH3 LDA 0,X+ GET THE CHARACTER
 STA CURCHR SAVE CHAR
 CMPA #$0D IS IT RETURN?
 BEQ NXTCH4
 CMPA EOLCHR 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 JCLASS GO CLASSIFY
 PULS X,PC DRESTORE REG. & RETURN

CLASS4 ANDCC #$FE CLC  SHOW ALPHANUMERIC
 RTS

* GETFIL
*
* GETFIL GETS A FILE SPECIFICATION FROM
* THE INPUT STREAM.
*
*   ENTRY: X POINTS TO FCB
*   EXIT:  ALL REGISTERS CHANGED

JGETFI LDA #$15 SET PRE ERROR
 STA 1,X
 LDA #$FF SET DDRIVE 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 DRESTORE POINTER
 TST 4,X IS NAME NULL?
 BEQ PRTM6 
 TST 3,X CHECK DDRIVE NUMBER
 BPL GETFI4 SET YET?
 TST SYSFLG SYSTEM DDRIVE?
 BEQ GETFI3
 LDA SYSDRV GET SYSTEM DDRIVE
 BRA GETF35

GETFI3 LDA WRKDRV GET WORK DDRIVE
GETF35 STA 3,X SET DDRIVE NUMBER
GETFI4 CLR SYSFLG CLEAR FLAG
GETFI5 LDX CRSAVE DRESTORE FCB
 RTS

* PRTM
*
* PRTM PROCESSES AN ITEM OF THE FILE SPEC

PRTM  BSR JNXTCH GET NEXT CHAR
 BCS PRTM6 ERROR?
 CMPA #$39 CHECK IF NUMBER
 BHI PRTM2
 LDX CRSAVE DRESTORE POINTER
 TST 3,X CHECK FOR DDRIVE NO
 BPL PRTM6 ERROR?
 ANDA #3 MASK DDRIVE
 STA 3,X SET DDRIVE NUM
 JSR JNXTCH GET NEXT CHAR
 BCC PRTM6 ERROR?

PRTM1 CMPA #$2E CHECK TERM
 BRA CLASS4 

PRTM2 LDB COUNT GET COUNT
 BMI PRTM6 ERROR?
 PSHS B SAVE COUNT
 SUBB #5 SET NEW COUNT
 STB COUNT SAVE IT
 PULS B DRESTORE OLD

PRTM3 CMPA #$60 CHECK FOR LOWER CASE
 BCS LD10A SKIP IF NOT
 SUBA #$20 CONVERT TO UPPER

LD10A STA 4,X PUT CHARACTER
 LEAX 1,X BUMP THE POINTER
 DECB DEC THE COUNT
 JSR JNXTCH 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

JSETEX 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 FCC "BIN" CODE 0
 FCC "TXT" CODE 1
 FCC "CMD" CODE 2
 FCC "BAS" CODE 3
 FCC "SYS" CODE 4
 FCC "BAK" CODE 5
 FCC "SCR" CODE 6
 FCC "DAT" CODE 7
 FCC "BAC" CODE 8
 FCC "DIR" CODE 9
 FCC "PRT" CODE 10
 FCC "OUT" CODE 11

* 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

JGETHE JSR CLROFS CLEAR SPACE & B REG
GETHE2 JSR JNXTCH GET CHARACTER
 BCS GETHE8 GRAPHICS?

 BSR TSTHEX TEST FOR HEX
 BCS GETHE6 ERROR?

 PSHS B SAVE IND
 LDB #4 SET UP COUNT

GETHE4 ASL LOADAO+1 SHIFT OVER 4
 ROL LOADAO 
 DECB DEC THE COUNT
 BNE GETHE4 LOOP TIL DONE

 PULS B RESTORE IND
 ADDA LOADAO+1 
 STA LOADAO+1 SET NEW DIGIT
 INCB SET INDICATOR
 BRA GETHE2

GETHE6 JSR JNXTCH GET CHARACTER
 BCC GETHE6 WAIT FOR TERM
 RTS

GETHE8 LDX LOADAO GET CHARACTER
 BRA GETH65

* TSTHEX
*
* TEST FOR VALID HEX CHARACTER


TSTHEX SUBA #$47 REMOVE BIAS
 BPL TSTHE4 ERROR?

 ADDA #6 CHECK RANGE
 BPL GETH66

 ADDA #7 ADD BACK IN
 BPL TSTHE4 ERROR?

GETH66 ADDA #$0A FINAL BIAS
 BMI TSTHE4 ERROR?

GETH65 ANDCC #$FE CLC  CLEAR ERRORS
 RTS

* INDEC
*
* INPUT DECIMAL NUMBER.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR
*          VALUE IN X
*          B=0 IF NO NUMBER

JINDEC JSR CLROFS CLEAR SPACE & B REG.
INDEC2 JSR JNXTCH GET CHARACTER
 BCS GETHE8 TERM?
 CMPA #$39 CHECK FOR NUMBER
 BHI GETHE6
 ANDA #$0F MASK NUMBER
 PSHS A,B SAVE COUNT & NUMBER
 LDD LOADAO GET VALUE
 ASLB DO TIMES 8
 ROLA
 ASLB
 ROLA
 ASLB
 ROLA
 ADDD LOADAO PLUS TIMES 2
 ADDD LOADAO
 ADDB 0,S+ ADD IN NEW DIGIT
 ADCA #0
 STD LOADAO SAVE RESULT
 PULS B GET COUNT
 INCB BUMP COUNT
 BRA INDEC2 REPEAT

TSTHE4 ORCC #1
 RTS

* LOAD
*
* LOAD IS THE SYSTEM BINARY LOADER
*
*   ENTRY: X POINTS TO FCB
*   EXIT:  WARMS IF ERROR
*          ALL REGISTERS CHANGED

JLOAD CLR XFRFLG 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 XFRADR SET TRANSFER ADR
 BSR DOFMS GET LSB
 STA XFRADR+1 SAVE IT
 LDA #1 SET NON ZERO
 STA XFRFLG 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 LOADAO 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 LD252 ERROR?

 LDA 1,X GET ERROR CODE
 CMPA #8 IS IT EOF?
 BNE DOFMS4  

 LEAS 2,S FIX STACK

LD249 LDA #4 SET CMND FOR CLOSE
 STA 0,X 
 JSR FMS CALL FMS
 BNE DOFMS6 ERROR?

LD252 ANDCC #$FE CLC  CLEAR ERROR
 RTS 

DOFMS4 STA ERRTYP SET TYPE
 CMPA #4 NO FILE ERROR?
 BNE DOFMS6  YES -
 BRA TSTHE4

DOFMS6 BSR JRPTER REPORT ERROR
 JMP NFERR4 DO WARM START

* GET
*
* GET IS THE DOS COMMAND USED TO
* LOAD BINARY FILES INTO MEMORY.
*
*   ENTRY: NONE
*   EXIT:  ALL REGISTERS CHANGED

GET CLRA SET DEFAULT CODE
 BSR GETOPN GET & OPEN FILE
 BCS TSTNAM NO NAME?
 BSR CLROFS CLEAR OFFSET
 INC GOTFIL SET FILE INDIC.
 BSR JLOAD GO DO LOAD
 BRA GET REPEAT PROCESS

* CLROFS
*
* CLEARS STORAGE LOC. OFFSET

CLROFS CLRA 
 CLRB
 STD LOADAO
 RTS

* TSTNAM
*
* TSTNAM TESTS TO SEE IF ANY NAMES HAVE
* BEEN PROCESSED YET.

TSTNAM LDB GOTFIL CHECK FLAG
 BEQ TSTNA1 
 JMP WARMS ALL DONE
TSTNA1 JMP NFERR REPORT ERROR

* LGO
*
* LGO IS THE SYSTEM LOAD AND GO MODULE.
*
*   ENTRY: NONE
*   EXIT:  ALL CHANGED

LDGO LDA #2 SET DEFAULT CODE
 BSR GETOP2 OPEN FILE
 BSR CLROFS CLEAR OFFSET
 JSR JLOAD GO DO LOAD

 LDB XFRFLG CHECK FOR TRANSFER ADR
 BEQ LGO2 
 JMP [XFRADR] 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 JGETFI GET FILE SPEC
 PULS A RESTORE CODE
 BCS GETOP4 ERROR?

GETOP2 LDX #SYSFCB POINT TO FCB
 JSR JSETEX SET EXTENSION
 LDX #SYSFCB POINT TO FCB
 LDA #1 SET OPEN CODE
 STA 0,X SET COMMAND
 BSR DOFMS GO DO FMS
 BCS NONMER REPORT ANY ERROR
 LDA #$FF SET NEG
 STA 59,X SET FOR NO SPC COMP
 RTS

* NONMER
*
* REPORT NO NAME ERROR

NONMER LDX #NONMST
 JMP NFERR2


GETOP4 LDA LSTTRM GET TERM
 CMPA #$0D IS TERM CR?
 BEQ LD2D1 YES -

 CMPA EOLCHR IS IT EOL?
 BNE TSTNA1 ERROR IF NEITHER

LD2D1 ORCC #1 SEC  SET TERM INDICATOR
 RTS

* RPTERR
*
* RPTERR REPORTS FMS ERRORS


JRPTER 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
 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 #$15
 STA 0,X DO POSITION
 JSR FMS
 BEQ RPTER7 
 
RPTER4 LDX #DSKERS POINT TO STRING
 JSR JPSTRN OUTPUT IT
 LDX CRSAVE RESTORE TO FCB
 LDA ERRTYP GET ERR NUM
 STA 1,X 
 CLR 0,X 
 CLRB
 JSR JOUTDE OUTPUT NUMBER

RPTE44 PULS X,Y,PC RESTORE REGS. & RETURN

RPTER6 LDX #NTRST POINT TO STRING
 JSR JPSTRN OUTPUT IT
 BRA RPTE44

RPTER7 JSR JPCRLF OUTPUT CR & LF
 LDX #SYSFCB SET TO FCB
 LDA ERRTYP GET ERROR
 DECA FIND RECORD IN FCB
 ANDA #3 MASK NUMBER
 LDB #$3F 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

* DOCMD
*
* DO COMMAND LINE

JDOCMD PULS A,B GET RET ADR
 STD RETADR SAVE ADDRESS

DOCMD2 STS STKSTR SAVE STACK PNTR 
 CLR ERRTYP CLEAR FLAG
 INC DOCMDF SET MODE
 JMP DOS4 GO DO LINE

* ADDBX
* ADDS CONTENTS OF B TO X

JADDBX ABX
 RTS



 ORG $D3FD

TSTSTR JMP LCA00


***************************
*                         *
*    END OF CCP PART      *
*                         *
***************************

***************************
*                         *
*   START OF INIT PART    *
*                         *
***************************

*
* STARTUP ROUTINE
* THIS ROUTINE INITIALIZES CERTAIN PARAMETERS, GETS
* DATE FROM USER, AND EXECUTES A STARTUP.TXT FILE.

 ORG $CA00

LCA00 LDA #$39 SET UP RTS
LCA01 EQU *-1
 STA TSTSTR disable re-entry to this code
 JSR [TINIT] SUBROUTINE AT $D3E4 (NOTHING)

 LDX INCHV SET INPUT ROUTINE
 STX INCH+1
 STX INCH2+1

 LDX OUTCHV SET OUTPUT ROUTINE
 STX OUTCH+1
 STX OUTCH2+1

 LDX STATV SET FLEX STATUS ROUTINE
 STX STATUS+1

* LOOK FOR MEMEND

 LDX #$00A0 START TEST AT $00A0
 LDB #$B9 LOAD TEST PATTERN
LCA26 LDA 0,X SAVES THE DATA IN A
 STB 0,X
 NOP
 CMPB 0,X
 BNE LCA3A REACH END OF RAM
 STA 0,X RESTORE THE DATA
 LEAX 1024,X 
 CMPX #LC0A0
 BNE LCA26
LCA3A LEAX -161,X
 STX MEMEND

 LDX #WARMS SET UP ESC ROUTINE ADDRESS
 STX ESCRET

 JSR LA606 PRINT WELCOME SCREEN

 LDA #$0D CLEAR LINE BUFFER
 LDX #LINBUF
 STA 0,X
 STA 1,X

 LDX #SYSFCB LOAD THE FCB WITH
 LDY #INISTR INITIAL.TXT STRING
 LDB #$10
LCA5C LDA 0,Y+
 STA 0,X+
 DECB
 BNE LCA5C

 JSR JPCRLF PRINT CR&LF
 LDX #SYSFCB
 LDA #1 SET FOR READ OPERATION
 STA 0,X
 JSR FMS CALL FMS
 BEQ LCA7A NO ERROR?

 LDA 1,X
 JSR DOFMS4
 JMP ENTRY IGNORE FILE AND PROCEDE

LCA7A LDX #LINBUF INIT LINE BUFFER POINTER
LCA7D STX BUFPNT 
 LDX #SYSFCB
 JSR FMS CALL FMS
 BEQ LCA8D NO ERROR?

 PSHS X,Y
 JMP RPTER4

LCA8D LDX BUFPNT
 STA 0,X+ PUT CHARACTER IN LINE BUFFER
 CMPA #$0D IS IT EOL ?
 BNE LCA7D NO, LOOP

 LDX #SYSFCB
 JSR LD249 CLOSE FMS
 LDX #LINBUF
 STX BUFPNT
 LDX #ENTRY
 STX RETADR
 JMP DOCMD2 CLOSE 

INISTR FCB $FF,$00,$00,$00
 FCC "INITIAL"
 FCB $00
 FCC "TXT"
 FCB $00

***************************
*                         *
*    END OF INIT PART     *
*                         *
***************************


*
* IO ROUTINE
* THIS ROUTINE PERFORMS THE IO
* USING THE STANDARD TAVBUG ADDRESS

 ORG $D390

* INCHNE
LD390 PSHS DP,U
 LDA #$EF
 TFR A,DP
LD396 JSR [LEFD8]
 BCC LD396
 ANDA #$7F
 PULS DP,U,PC

* INCHV
 BSR LD390
 TST LEFF2
 BEQ LD3A8
 RTS

* OUTCH
LD3A8 PSHS B,DP
 LDB #$EF
 TFR B,DP
 JSR [LEFDE]
 PULS B,DP,PC

* STATV
 PSHS B,DP,U
 LDB #$EF
 TFR B,DP
 JSR [LEFD8]
 TFR CC,B
 ANDA #$7F
 TFR B,CC
 ANDB #1
 PULS B,DP,U,PC

* TMINT
 LDA #$82
 STA LEB08
 LDX #L3000
 STX LEB0E
 RTS

* TMON
 LDA #$C2
 BRA LD3DA
LD3D8 LDA #$82
LD3DA STA LEB08
 RTS

* MONITR
 LDA #1
 SWI
 FCB $08
 FCB $20
 FCB $FA

* TINIT
 RTS

 ORG $D3E5

INCHNE FDB $D390
IHNDLR FDB $FE80
SWIVEC FDB $EFC8
IRQVEC FDB $EFCE
TMOFF FDB $D3D8
TMON FDB $D3D4
TMINT FDB $D3C8
MONITR FDB $D3DE
TINIT FDB $D3E4
STATV FDB $D3B4
OUTCHV FDB $D3A8
INCHV FDB $D3A0




***************************
*                         *
*    START OF FMS PART    *
*                         *
***************************


* FMS JUMP TABLES
*
* ALL CALLS TO THE FMS SHOULD ENTER
* THROUGH ONE OF THESE THREE POINTS.
               
 ORG $D400

FMSINT JMP INIFMS FMS INITIALIZATION  $D436
FMSCLS JMP CLOFMS FMS CLOSURE         $D459
FMS JMP JFMS FMS COMMAND ENTRY   $D47B


* 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.

 ORG $D435

VRFYFG FCB $FF
INIFMS JSR DCOLDS
 LDX #BASFCB
 LDB #$0A
 BSR LD451
 LDX #L0005
 STX LD413
 STX LD415
 CLR LD41A
LD44C LDX #LD41B
 LDB #$1A
LD451 CLR 0,X+
 DECB
 BNE LD451
 JMP LC70C

* EXCLS
*
* EXCLS IS THE FMS EXIT ROUTINE.
* EXECUTION OF THIS ROUTINE TELLS THE
* SYSTEM TO CLOSE ALL OPEN FILES.

CLOFMS JSR LC709
LD45C LDX BASFCB
 BEQ LD44C
 LEAX -28,X
 STX CURFCB
 PSHS Y
 JSR LDACC
 PULS Y
 BCC LD45C
 LDX CURFCB
 CLR 2,X
 JSR LC70C
 LDB #$FF
 RTS

* CMND
*
* CMND IS THE FMS COMMAND INTERPRETER.
* ALL COMMAND CALLS TO FMS SHOULD BE
* THROUGH THIS ROUTINE.


JFMS TST PR1
 BEQ LD483
 JSR LC709
LD483 PSHS B,Y
 STX CURFCB
 CLR 1,X
 LDB 0,X
 BNE LD4B0
 LDB 2,X
 BEQ LD4AC
 CMPB #2
 BEQ LD4A7
 JSR LD5B5
LD499 LDX CURFCB
 BCS LD4C4
 TST PR1
 BNE LD4C6
 CLRB
 PULS B,Y
 RTS

LD4A7 JSR LD6D4
 BRA LD499
LD4AC LDB #$12
 BRA LD4C4
LD4B0 CMPB #$16
 BLS LD4B8
 LDB #1
 BRA LD4C4
LD4B8 DECB
 ASLB
 LDX #CODTBL
 JSR [B,X]
 LDX CURFCB
 BCC LD4C6
LD4C4 STB 1,X
LD4C6 JSR LC70C
 TST 1,X
 PULS B,Y
 RTS

* CODTBL
*
* CODTBL IS THE SYSTEM TABLE OF
* FUNCTION CODE ROUTINE ADDRESSES.

CODTBL FDB OPNRD OPNRD   OPEN FOR READ
 FDB LD9E1 OPNWT OPNWT   OPEN FOR WRITE
 FDB LDB02 OPNRW   OPEN FOR READ WRITE
 FDB LDACC CLOSE   CLOSE FILE
 FDB LD5E3 REWIND  REWIND FILE
 FDB LD823 OPNDIR  OPEN DIRECTORY
 FDB LD83F GETIR   GET INFO RECORD
 FDB LD87D PUTIR   PUT INFO RECORD
 FDB LD646 READSS  READ SINGLE SECTOR
 FDB LD6A4 WRITSS  WRITE SINGLE SECTOR
 FDB LD970 WRTDIR  WRITE DIRECTORY
 FDB LDBDF DELETE  DELETE FILE
 FDB LDB35 RENAME  RENAME FILE
 FDB LD6E9 RETRY4  APPEND FILES
 FDB LDA90 NEXTS   NEXT SEQU. SECTOR
 FDB LD816 OPNSIR  OPEN SYSTEM INFO
 FDB LD570 GETRAN  GET RANDOM CHARACTER
 FDB LD591 PUTRAN  WRITE RANDOM CHARACTER
 FDB LDB10 WTAPP   OPEN WRITE APPEND
 FDB LDDC9 NXTRDY  FIND NEXT READY DRIVE
 FDB LDD06 POSIT   POSITION TO RECORD N
 FDB LDCF0 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 FCBBAS AS THE BASE OF THE CHAIN.
*
*   ENTRY: NONE
*   EXIT:  CS IF FCB EXISTS
*          ALL REGISTERS CHANGED

LD4FA BSR LD51C
 BNE LD503
 LDB #2
 ORCC #1
 RTS
LD503 STD 0,X
 LDX 0,X
 CLR 0,X
 CLR 1,X
 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

LD50C BSR LD51C
 BEQ LD515
 LDB #$0D
 ORCC #1
 RTS
LD515 LDD [0,X]
 STD 0,X
 ANDCC #$FE
 RTS

* FNDFCB
*
* FNDFCB TRIES TO FIND THE FCB IN
* FCBSTR IN THE SYSTEM TABLE.
*
*   ENTRY: NONE
*   EXIT:  NE IF NOT FOUND
*          A & B DESTROYED
*          X POINTS TO FCB

LD51C LDD CURFCB
 ADDD #$001C
 LDX #BASFCB
LD525 LDY 0,X
 BNE LD52D
 ANDCC #$FB
 RTS
LD52D CMPD 0,X
 BNE LD533
 RTS
LD533 LDX 0,X
 BRA LD525

* CLRFCB
*
* CLRFCB CLEARS SELECTED SECTIONS OF
* THE CURRENT FCB.
*
*   ENTRY: NONE
*   EXIT:  ALL REGISTERS CHANGED

LD537 LDX CURFCB
 CLRA
 LDB #0
 BSR LD541
 LDB #$2F
LD541 STA 17,X
 LEAX 1,X
 DECB
 BNE LD541
 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

LD54A LDX CURFCB
 LDB #$0B
LD54F LDA 4,X
 STA 36,X
 LEAX 1,X
 DECB
 BNE LD54F
 RTS

* CMPNAM
*
* CMPNAM WILL COMPARE THE NAME (NL
* BYTES LONG) IN THE FCB AREA FWB
* (WORK BUFFER) TO THE CONTENTS OF
* FCB AREA FFN (FILE NAME).
*
*   ENTRY: NONE
*   EXIT:  NE IF NOT EQUAL
*          ALL REGISTERS CHANGED

LD55A LDX CURFCB
 LDB #$0B
LD55F LDA 4,X
 PSHS A
 LDA 36,X
 CMPA 0,S+
 BNE LD56F
 LEAX 1,X
 DECB
 BNE LD55F
LD56F 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

LD570 LDX CURFCB
 LDB 2,X
 LSRB
 BCC LD5F1
 LDB 35,X
 JMP LD601

* 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

LD57E LDX CURFCB
 LDB 34,X
 INC 34,X
 ABX
 STA 64,X
 INCB
 BNE LD5AD
 ORCC #1
 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

LD591 LDX CURFCB
 LDB 2,X
 ANDB #3
 CMPB #3
 BNE LD5F1
 ORB #$80
 STB 2,X
 LDB 15,X
 BITB #$80
 BNE LD5B0
 LDB 35,X
 ABX
 STA 64,X
LD5AD ANDCC #$FE
 RTS
LD5B0 LDB #$0B
 ORCC #1
 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

LD5B5 LDA 59,X
 BMI LD5F6
 BEQ LD5C3
 DEC 59,X
 LDA #$20
 BRA LD5E0
LD5C3 BSR LD5F6
 BCS LD5E2
 CMPA #$18
 BHI LD5E0
 BEQ LD5C3
 CMPA #9
 BNE LD5DD
 BSR LD5F6
 BCS LD5E2
 LDX CURFCB
 STA 59,X
 BRA LD5B5
LD5DD TSTA
 BEQ LD5C3
LD5E0 ANDCC #$FE
LD5E2 RTS

* REWIND   * FFC #5 *
*
* REWIND WILL LOGICALLY REWIND THE
* FILE SPECIFIED IN THE FCB.
*
*   ENTRY: NONE
*   EXIT:  SAME AS RDNEXT

LD5E3 JSR LDABA
 BCS LD5F1
 BITA #1
 BEQ LD5F1
 STA 0,X
 JMP LD9A7
LD5F1 LDB #$12
 ORCC #1
 RTS

* RDSEQ
*
* RDSEQ IS THE LOW LEVEL GET
* SEQUENTIAL CHARACTER ROUTINE.
*
*   ENTRY: NONE
*   EXIT:  CHAR IN A
*          CS IF ERROR
*          B & X DESTROYED

LD5F6 LDX CURFCB
 LDB 34,X
 BEQ LD608
 INC 34,X
LD601 ABX
 LDA 64,X
 ANDCC #$FE
 RTS
LD608 BSR LD60D
 BCC LD5F6
 RTS

* RDNEXT
*
* RDNEXT READS THE NEXT SEQUENTIAL
* RECORD IF IT EXISTS.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR
*          B HAS ERROR NUMBER
*          A & X CHANGED

LD60D LDX CURFCB
 LDD 64,X
 INC 33,X
 BNE LD61B
 INC 32,X
LD61B CMPD #$0000
 BEQ LD641
LD621 STD 30,X
 PSHS A
 LDA #4
 STA 34,X
 PULS A
 BSR LD646
 BCC LD645
 BITB #$80
 BEQ LD639
 LDB #$10
 BRA LD643
LD639 CMPB #$0F
 BEQ LD643
 LDB #9
 BRA LD643
LD641 LDB #8
LD643 ORCC #1
LD645 RTS

* READSS   * FFC #9 *
*
* READSS READS A SINGLE RECORD (SECTOR)
* FROM THE DISK.
*
*   ENTRY: NONE
*   EXIT:  CS IF READ ERROR
*          ALL REGISTERS CHANGED

LD646 BSR LD66D
 LDX CURFCB
 JSR DDRIVE
 BCS LD662
LD650 BSR LD663
 JSR DREAD
 BNE LD65A
 ANDCC #$FE
 RTS
LD65A PSHS B
 BSR LD675
 PULS B
 BCC LD650
LD662 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

LD663 LDX CURFCB
 LDD 30,X
 LEAX 64,X
 RTS

* CLRTRY
*
* CLRTRY CLEARS THE ERROR TRY COUNTERS
*
*   ENTRY: NONE
*   EXIT:  A CLEARED

LD66D CLRA
 STA LD411
 STA LD412
 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

LD675 BITB #$10
 BNE LD68A
 BITB #$80
 BNE LD6A1
 LDB LD411
 INCB
 CMPB #7
 BEQ LD68A
 STB LD411
 BRA LD69E
LD68A CLR LD411
 LDB LD412
 INCB
 CMPB #4
 BEQ LD6A1
 STB LD412
 LDX CURFCB
 JSR DRESTOR
LD69E ANDCC #$FE
 RTS
LD6A1 ORCC #1
 RTS

* WRITSS   * FFC #10 *
*
* WRITSS IS THE SYSTEM WRITE SINGLE
* SECTOR ROUTINE.
*
*   ENTRY: NONE
*   EXIT:  CS IF WRITE ERROR
*          ALL REGISTERS CHANGED

LD6A4 BSR LD66D
 LDX CURFCB
 JSR DDRIVE
 BCS LD6CE
LD6AE LDX CURFCB
 BSR LD663
 JSR DWRITE
 BNE LD6C2
 LDA VRFYFG
 BEQ LD6F4
 JSR DVERFY
 BEQ LD6F4
LD6C2 BITB #$40
 BNE LD6D1
 PSHS B
 BSR LD675
 PULS B
 BCC LD6AE
LD6CE RTS
 LDB #$20
LD6D1 ORCC #1
 RTS

* 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


LD6D4 LDX CURFCB
 LDB 59,X
 BMI LD719
 CMPA #$20
 BNE LD6EF
 INCB
 STB 59,X
 CMPB #$7F
 BNE LD6F4
 BRA LD6F7
LD6EA BSR LD6F7
 BCC LD6D4
 RTS
LD6EF TSTB
 BEQ LD719
 BRA LD6EA
LD6F4 ANDCC #$FE
 RTS

* PUTSPC
*
* PUTSPC IS THE ROUTINE WHICH WRITES
* THE SPACE COMPRESSION CODE AND THE
* SPACE COUNT.
*
*   ENTRY: B HAS COUNT
*   EXIT:  A PRESERVED

LD6F7 PSHS A
 CMPB #1
 BNE LD701
 LDA #$20
 BRA LD711
LD701 LDA #9
 BSR LD719
 PULS A
 BCS LD718
 PSHS A
 LDX CURFCB
 LDA 59,X
LD711 CLR 59,X
 BSR LD719
 PULS A
LD718 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

LD719 LDX CURFCB
 LDB 2,X
 CMPB #2
 LBNE LD5F1
 LDB 34,X
 CMPB #4
 BNE LD733
 PSHS A
 BSR LD750
 PULS A
 BCS LD742
LD733 JSR LD57E
 BCC LD742
 LDB #4
 LDX CURFCB
 STB 34,X
 ANDCC #$FE
LD742 RTS

* CLRLRN

LD743 LDX CURFCB
 CLRA
 CLRB
 STD 32,X
 STD 66,X
 BRA LD777

* WTNEXT
*
* WTNEXT WRITES THE NEXT RECORD.
*
*   ENTRY: X = FCB
*   EXIT:  CS IF ERROR
*          REGISTERS CHANGED


LD750 LDB 18,X
 BNE LD777
 LDB 23,X
 BEQ LD79E
 CLR 23,X
 BSR LD79E
 BCS LD78B
 BSR LD743
 BCS LD78B
 BSR LD743
 BCS LD78B
 LDX CURFCB
 LDB #2
 STB 23,X
 LDD 17,X
 JMP LDC8B
LD777 BSR LD787
 LDX CURFCB
 STD 64,X
 JSR LD6A4
 BCC LD79E
 JMP LDBCA

* 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

LD787 BSR LD78C
 LDD 0,X
LD78B 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

LD78C LDX CURFCB
 LDB 3,X
 LDA #6
 MUL
 LDX #LD41D
 ABX
 STX LD41B
 TST 0,X
 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


LD79E BSR LD787
 BNE LD7A7
 LDB #7
LD7A4 ORCC #1
 RTS
LD7A7 LDX CURFCB
 STD 19,X
 TST 18,X
 BNE LD7B5
 STD 17,X
LD7B5 INC 22,X
 BNE LD7BD
 INC 21,X
LD7BD TST 23,X
 BEQ LD7CD
 JSR LDC4C
 BCS LD7A4
 LDX CURFCB
 LDD 19,X
LD7CD JSR LD621
 BCS LD7A4
 LDX CURFCB
 LDD 64,X
 PSHS A,B
 BSR LD78C
 PULS A,B
 STD 0,X
 BNE LD7EC
 CLR 2,X
 CLR 3,X
 CLR 4,X
 CLR 5,X
 BRA LD7F4
LD7EC LDY 4,X
 LEAY -1,Y
 STY 4,X
LD7F4 CLRA
 LDX CURFCB
 INC 33,X
 BNE LD800
 INC 32,X
LD800 LDB #0
LD802 STA 64,X
 LEAX 1,X
 DECB
 BNE LD802
 LDX CURFCB
 LDD 32,X
 STD 66,X
 ANDCC #$FE
 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

LD816 CLRB
 PSHS B
 LDB #3
 BRA LD82B

* ------- No Path to this code

 LDX LD415
 STX LD413

* -------

LD823 LDB LD413
 PSHS B
 LDB LD414
LD82B LDX CURFCB
 STB 65,X
 PULS B
 STB 64,X
 CLR LD418
 LDB #0
 STB 34,X
 RTS

* GETIR
*
* GETIR GETS THE NEXT INFORMATION
* RECORD (IR) FROM THE FSB.
*
*   ENTRY: X = FCB
*   EXIT:  CS IF ERROR

LD83F LDX CURFCB
 LDB 34,X
 BNE LD864
 JSR LD60D
 BCS LD87C
 LDX CURFCB
 TST LD418
 BNE LD859

 LDD <L0044

 STD LD418
LD859 LDA #$10
 STA 34,X
 LDD 30,X
 STD 47,X
LD864 LDA 34,X
 STA 49,X
 LDB #$18
LD86C PSHS B,X
 JSR LD5F6
 PULS B,X
 STA 4,X
 LEAX 1,X
 DECB
 BNE LD86C
 ANDCC #$FE
LD87C RTS

* PUTIR
*
* PUTIR PUTS THE IR INTO THE FSB.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR

LD87D LDX CURFCB
 LDA 49,X
 STA 34,X
 LDB #$18
LD888 PSHS B,X
 LDA 4,X
 JSR LD719
 PULS B,X
 LEAX 1,X
 DECB
 BNE LD888
 JMP LD6A4

* FNDNAM
*
* FNDNAM TRIES TO FIND THE NAME IN
* FFN IN THE DIRECTORY.
*
*   ENTRY: NAME IN FFN
*   EXIT:  EQ IF FOUND
*          CS IF ERROR ( IN B )
*          REGISTERS CHANGED

LD899 LDX CURFCB
 LDA 3,X
 STA 35,X
 LDA LD417
 TST LD41A
 BNE LD8DA
 STA 3,X
 LDX LD415
 STX LD413
LD8B1 CMPX #L0005
 BEQ LD8C2
 BSR LD8DA
 BLS LD8F1
 LDX LD418
 STX LD413
 BRA LD8B1
LD8C2 LDX CURFCB
 LDA 35,X
 STA 3,X
 BPL LD8DA
LD8CC JSR LDDC9
 BCS LD907
 BSR LD8DA
 BLS LD8F1
 JSR LDDB9
 BRA LD8CC
LD8DA LDX CURFCB
 CLR LD41A
 JSR LD54A
 JSR LD823
LD8E6 JSR LD83F
 BCC LD8F2
 CMPB #8
 BEQ LD907
 ORCC #1
LD8F1 RTS
LD8F2 LDX CURFCB
 LDA 4,X
 BEQ LD905
 BPL LD8FD
 BSR LD90C
LD8FD JSR LD55A
 BNE LD8E6
 ANDCC #$FE
 RTS
LD905 BSR LD90C
LD907 ANDCC #$FB
 ANDCC #$FE
 RTS
LD90C LDA 51,X
 BNE LD91D
 LDD 47,X
 STD 50,X
 LDA 49,X
 STA 52,X
LD91D RTS

* GETAVL
*
* GETAVL SETS THE SECTOR MAP POINTERS
* IF THEY HAVE NOT BEEN SET.
*
*   ENTRY: NONE
*   EXIT:  CS SET IF ERROR
*          REGISTERS CHANGED

LD91E JSR LD78C
 BNE LD93A
 BSR LD93D
 BCS LD93C
 LDB #6
 LDY CURFCB
 LDX LD41B
LD930 LDA 93,Y
 LEAY 1,Y
 STA 0,X+
 DECB
 BNE LD930
LD93A ANDCC #$FE
LD93C RTS

* GETDIS
*
* GETDIS READS IN THE DIS SECTOR.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR
*          REGISTERS CHANGED


LD93D JSR LD816
 JSR LD60D
 BCS LD94D
 LDX CURFCB
 LDB #$10
 STB 34,X
LD94D RTS

* PUTAVL
*
* PUTAVL UPDATES THE DIS SECTOR.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR
*          REGISTERS CHANGED

LD94E JSR LD78C
 BSR LD93D
 BCS LD94D
 LDB #6
 LDY CURFCB
 LDX LD41B
LD95E LDA 0,X+
 STA 93,Y
 LEAY 1,Y
 DECB
 BNE LD95E
 JSR LD6A4
 BCC LD94D
 JMP LDBCA

* WRTDIR
*
* WRTDIR UPDATES THE DISK DIRECTORY.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR

LD970 LDX CURFCB
 LDA #2
 STA 2,X
 LDD 47,X
 STD 30,X
 JSR LD646
 BCS LD98A
 JSR LD87D
 BCC LD98C
 JMP LDBCA
LD98A LDB #$0A
LD98C RTS

* OPNRD
*
* OPNRD IS THE HIGH LEVEL SYSTEM
* ROUTINE WHICH OPENS A FILE FOR
* A READ OPERATION.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR (IN B)
*          REGISTERS CHANGED

OPNRD JSR LD4FA
 BCS LD9D0
 JSR LD899
 BCS LD9D0
 BNE LD9D5
 LDX CURFCB
 TST LD41A
 BEQ LD9A7
 LDA 15,X
 BITA #$20
 BNE LD9D1
LD9A7 JSR LDCCA
 BCS LD9D7
 LDD 17,X
 STD 64,X
 JSR LDA7E
 LDB 23,X
 BEQ LD9CE
LD9BA PSHS B
 JSR LD60D
 PULS B
 BCS LD9D0
 DECB
 BNE LD9BA
 LDX CURFCB
 LDB #0
 STB 34,X
LD9CE ANDCC #$FE
LD9D0 RTS
LD9D1 LDB #$11
 BRA LD9D7
LD9D5 LDB #4
LD9D7 PSHS B
 JSR LD50C
 PULS B
 ORCC #1
 RTS

* OPNWT
*
* OPNWT OPENS A FILE FOR WRITE.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR (IN B)
*          REGISTERS CHANGED

LD9E1 LDX CURFCB
 TST 3,X
 BPL LD9F0
 JSR LDDC9
 BCC LD9F0
 LDB #$10
 RTS
LD9F0 JSR LD4FA
 BCS LD9D7
 JSR LD537
 JSR LD91E
 BCS LD9D7
 JSR LD899
 BCS LD9D7
 BNE LDA08
 LDB #3
 BRA LD9D7
LDA08 JSR LDCCA
 BCS LD9D7
 LDX CURFCB
 LDB #$0A
LDA12 CLR 15,X
 LEAX 1,X
 DECB
 BNE LDA12

 LDX CURFCB
 LDD 50,X
 BEQ LDA48
 STD 47,X
 LDA 52,X
 STA 49,X
 LDD SYSMTH
 STD 25,X
 LDA SYSYR
 STA 27,X

 JSR LDDB9
 JSR LD970
 BCS LD9D7
 BSR LDA7E
 LDA #4
 STA 34,X
 ANDCC #$FE
 RTS

LDA48 LDX CURFCB
 CLR 23,X
 INC 18,X
 LDD 47,X
 JSR LD621
 BCS LDA66
 JSR LD777
 BCS LDA66
 JSR LD6A4
 BCC LDA69
 JSR LDBCA
LDA66 JMP LD9D7
LDA69 LDX CURFCB
 LDD 30,X
 STD 50,X
 LDA #$10
 STA 52,X
 JSR LD94E
 BCS LDA66
 BRA LDA08

* SETST
*
* SETST SETS THE FCB STATUS AFTER
* AN OPEN FILE COMMAND.
*
*   ENTRY: NONE
*   EXIT:  A & X CHANGED

LDA7E LDX CURFCB
 LDA 0,X
 STA 2,X
 CLR 0,X
 CLR 59,X
 LDA #0
 STA 34,X
 RTS

* NEXTS
*
* NEXTS IS THE SYSTEM ROUTINE TO
* ADVANCE TO THE NEXT SECTOR.
*
*   ENTRY: NONE
*   EXIT:  ALL CHANGED

LDA90 BSR LDABA
 BCS LDAA2
 CLR 0,X
 LSRA
 LBCS LD60D
 LDB #4
 STB 34,X
 ANDCC #$FE
LDAA2 RTS

* CHKWT
*
* CHECK FOR WRITE SECTOR NECESSITY
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR

LDAA3 LDX CURFCB
 LDA 2,X
 CMPA #$83
 BNE LDAB7
 LDA #3
 STA 2,X
LDAB0 JSR LD6A4
 LBCS LDBCA
LDAB7 ANDCC #$FE
 RTS

* DOSTAT
*
* DOSTAT DOES FILE STATUS CHECKING
*
*   ENTRY: NONE
*   EXIT:  ALL CHANGED
*          CS IF ERROR

LDABA BSR LDAA3
 BCS LDACB
 LDX CURFCB
 LDA 2,X
 CMPA #3
 BLS LDAB7
 LDB #$12
 ORCC #1
LDACB RTS

* CLOSE
*
* CLOSE A DISK FILE
*
*   ENTRY: NONE
*   EXIT:  ALL CHANGED

LDACC BSR LDABA
 BCS LDB01
 CMPA #2
 BEQ LDADC
LDAD4 LDX CURFCB
 CLR 2,X
 JMP LD50C
LDADC LDA 18,X
 BNE LDAE6
 JSR LDBB0
 BRA LDAFF
LDAE6 BSR LDAB0
 BCS LDB01
 LDX CURFCB
 TST 23,X
 BEQ LDAF7
 JSR LDCA1
 BCS LDB01
LDAF7 JSR LD970
 BCS LDB01
 JSR LD94E
LDAFF BCC LDAD4
LDB01 RTS

* OPNRW
*
* OPNRW OPENS A FILE FOR UPDATE
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR


 JSR OPNRD
 BCS LDB2F
 JSR LD60D
 BCS LDB2F
 LDA #3
 BRA LDB28

* WTAPP
*
* WTAPP IS THE SYSTEM OPEN FILE
* FOR WRITE APPEND. THE FILE MUST
* EXIST AND NEW DATA IS WRITTEN ON
* THE END OF THE FILE.
*
*   ENTRY: NONE
*   EXIT:  CS IF ERROR


LDB10 JSR OPNRD
 BCS LDB2F
 LDX CURFCB
 LDA 15,X
 BITA #$80
 BNE LDB30
 LDD 19,X
 JSR LD621
 BCS LDB2F
 LDA #2
LDB28 LDX CURFCB
 STA 2,X
 ANDCC #$FE
LDB2F RTS
LDB30 LDB #$0B
 ORCC #1
 RTS

* RENAME
*
* RENAME IS THE SYSTEM FILE RENAME
* ROUTINE.  THE NEW NAME MUST BE IN
* FCB+FLR.
*
*   ENTRY: SEE ABOVE
*   EXIT:  CS IF ERROR

LDB35 BSR LDB6C
 JSR LD899
 BCS LDB66
 BEQ LDB62
 LDX CURFCB
 LDB #$0B
LDB43 LDA 36,X
 STA 4,X
 LEAX 1,X
 DECB
 BNE LDB43
 BSR LDB9C
 BCS LDB66
 LDX CURFCB
 LDA 15,X
 BITA #$80
 BNE LDB30
 BITA #$60
 BNE LDB67
 BSR LDB6C
 BRA LDBB7
LDB62 LDB #3
 ORCC #1
LDB66 RTS
LDB67 LDB #$0C
 ORCC #1
 RTS

* SWAP
*
* SWAP THE NAME IN FLR WITH FFN.
* IF FLR HAS NULL EXT SET AS FFN.

LDB6C LDX CURFCB
 LDA #$0B
 STA LD411
LDB74 LDA 4,X
 LDB 53,X
 STA 53,X
 STB 4,X
 LEAX 1,X
 DEC LD411
 BNE LDB74
 LDX CURFCB
 LDA 12,X
 BNE LDB98
 LDB #3
LDB8E LDA 61,X
 STA 12,X
 LEAX 1,X
 DECB
 BNE LDB8E
LDB98 LDX CURFCB
 RTS

* SWPNM
*
* SWAP NAMES AND DO FNDNAM

LDB9C BSR LDB6C
LDB9E JSR LD899
 BCS LDBAA
 BNE LDBAB
 LDX CURFCB
 ANDCC #$FE
LDBAA RTS
LDBAB LDB #4
 ORCC #1
 RTS

* DELNAM
*
* DELETE FILE NAME IN DIR

LDBB0 LDX CURFCB
 LDA #$FF
 STA 4,X
LDBB7 JSR LD970
 LDX CURFCB
 LDA #0
 STA 2,X
 RTS

* WRITIT
*
* WRITIT PUTS AND WRITES NEW
* FORWARD LINK IN SECTOR.

LDBC2 STD 64,X
 JSR LD6A4
 BCC LDBDE
LDBCA BITB #$40
 BNE LDBD6
 BITB #$80
 BEQ LDBDC
 LDB #$10
 BRA LDBDC
LDBD6 LDB #$0B
 BRA LDBDC
* ---- No path to this code
 LDB #$0A
* ----
LDBDC ORCC #1
LDBDE RTS

* DELETE
*
* DELETE A SYSTEM FILE RETURNING ITS
* SECTORS BACK TO THE LIST OF AVAIL.
*
*   ENTRY: NAME IN FFN
*   EXIT:  ALL CHANGED
*          CS IF ERROR

LDBDF JSR LD91E
 BCS LDC42
 BSR LDB9E
 BCS LDC42
 LDX CURFCB
 LDA 15,X
 BITA #$80
 BNE LDC43
 BITA #$60
 BNE LDC47
 JSR LD78C
 LDX LD41B
 LDD 2,X
 BNE LDC0E
 LDX CURFCB
 LDD 17,X
 BEQ LDC3A
 LDX LD41B
 STD 0,X
 BRA LDC22
LDC0E LDX CURFCB
 JSR LD621
 BCS LDC42
 LDX CURFCB
 LDD 17,X
 BEQ LDC3A
 BSR LDBC2
 BCS LDC42
LDC22 LDX CURFCB
 LDD 19,X
 LDX LD41B
 STD 2,X
 LDX CURFCB
 LDD 21,X
 LDX LD41B
 ADDD 4,X
 STD 4,X
LDC3A JSR LDBB0
 BCS LDC42
 JSR LD94E
LDC42 RTS
LDC43 LDB #$0B
 BRA LDC49
LDC47 LDB #$0C
LDC49 ORCC #1
 RTS
LDC4C LDD 30,X
 INCB
 CMPB 60,X
 BLS LDC58
 LDB #1
 INCA
LDC58 CMPD 19,X
 BNE LDC6C
 LDA 55,X
 CMPA #$FF
 BEQ LDC6C
 INCA
 STA 55,X
 ANDCC #$FE
 RTS
LDC6C BSR LDCA1
 BCS LDCA0
 LDX CURFCB
 LDA 58,X
 ADDA #3
 BNE LDC90
 LDD 30,X
 CMPD 17,X
 BEQ LDC88
 LDB #$17
 ORCC #1
 RTS
LDC88 LDD 64,X
LDC8B STD 56,X
 LDA #4
LDC90 STA 58,X
 LDD 19,X
 STD 53,X
 LDA #1
 STA 55,X
 ANDCC #$FE
LDCA0 RTS
LDCA1 LDD 56,X
 JSR LD621
 BCS LDCA0
 LDX CURFCB
 TFR X,Y
 LDB 58,X
 LEAX B,X
 LDB #3
LDCB5 LDA 53,Y
 LEAY 1,Y
 STA 64,X
 LEAX 1,X
 DECB
 BNE LDCB5
 JSR LD6A4
 BCC LDCA0
 JMP LDBCA
LDCCA JSR LD816
 JSR LD60D
 BCS LDD19
 LDX CURFCB
 CLRA
 CLRB
 STD 32,X
 LDA 103,X
 STA 60,X
 LDB #0
LDCE2 CLR 64,X
 LEAX 1,X
 DECB
 BNE LDCE2
 LDX CURFCB
 ANDCC #$FE
 RTS
 LDX CURFCB
 LDA 23,X
 BEQ LDD15
 LDD 32,X
 SUBD #$0001
 BPL LDD03
 JMP LDDA6
LDD03 STD 32,X
 JSR LDABA
 BCS LDD19
 RORA
 BCC LDD15
 CLR 0,X
 LDA 23,X
 BNE LDD1A
LDD15 LDB #$12
 ORCC #1
LDD19 RTS
LDD1A CLR LD411
 LDD 17,X
 LDY 32,X
 BEQ LDD91
 JSR LDDAB
 BCS LDD19
 CLRA
 CLRB
LDD2D TST 2,X
 BEQ LDDA6
 ADDB 2,X
 ADCA #0
 STX LD40F
 LDX CURFCB
 CMPD 32,X
 BCC LDD6D
 LDX LD40F
 LEAX 3,X
 PSHS A
 LDA LD411
 INCA
 STA LD411
 CMPA #$54
 BEQ LDD5B
 CMPA #$A8
 PULS A
 BEQ LDDA6
 BRA LDD2D
LDD5B PSHS B
 LDX CURFCB
 LDD 64,X
 BSR LDDAB
 BCS LDDA6
 PULS B
 PULS A
 BRA LDD2D
LDD6D SUBD 32,X
 LDX LD40F
 LDA 2,X
 PSHS B
 SUBA 0,S+
 DECA
 TFR A,B
 RORA
 LDA 0,X
 ADDB 1,X
 LDX CURFCB
 BCS LDD8B
LDD86 CMPB 60,X
 BLS LDD91
LDD8B SUBB 60,X
 INCA
 BRA LDD86
LDD91 JSR LD621
 BCS LDDAA
 LDX CURFCB
 LDD 66,X
 CMPD 32,X
 BEQ LDDB6
 LDB #$19
 BRA LDDA8
LDDA6 LDB #$18
LDDA8 ORCC #1
LDDAA RTS
LDDAB JSR LD621
 BCS LDDB8
 LDX CURFCB
 LDB #$44
 ABX
LDDB6 ANDCC #$FE
LDDB8 RTS
LDDB9 LDX CURFCB
 LDB #$0B
LDDBE LDA 36,X
 STA 4,X
 LEAX 1,X
 DECB
 BNE LDDBE
 RTS
LDDC9 LDX CURFCB
 LDA 3,X
 INCA
 CMPA #4
 BCC LDDE2
 STA 3,X
 BNE LDDDC
 JSR DCHECK
 BRA LDDDF
LDDDC JSR DQUICK
LDDDF BCS LDDC9
 RTS
LDDE2 LDB #$10
 ORCC #1
 RTS


***************************
*                         *
* START OF DRIVERS PART   *
*                         *
***************************

*
* DISK DRIVER ROUTINE JUMP TABLE
*

 ORG $DE00

DREAD JMP READ  READ      Read a single sector
DWRITE JMP WRITE  WRITE     Write a single sector
DVERFY JMP VERIFY  VERIFY    Verify last sector written
DRESTOR JMP RESTORE  RESTORE   Restore head to track #0
DDRIVE JMP DRIVE  DRIVE     Select the specified drive
DCHECK JMP CHKRDY  CHKRDY    Check for drive ready
DQUICK JMP QUICK  QUICK     Quick check for drive ready
DCOLDS JMP COINIT  INIT      Driver initialize (cold start)
DWARMS JMP UWARM  WARM      Driver initialize (warm start)
DSEEK JMP SEEKIT   SEEK      Seek to specified track
DRVTBL FCB $00 MAX SECTOR PER SIDE
LDE1F FCB $DE,$DD,$DB,$D7 DRIVE PRESENT
LDE23 FCB $00
LDE24 FCB $00 CURRENT DRIVE
LDE25 FCB $00,$00,$00,$00 DRIVE TRACK MEMORY REGISTER
LDE29 FCB $00 COPY OF STATUS REG
LDE2A FCB $00 CURRENT SIDE MASQ
LDE2B FCB $00,$00 STEP RATE

* INIT AND WARM 
* 
* DRIVER INITIALIZATION
COINIT LDX #$DE24 POINT TO VARIABLES 
 LDB #8 NO. OF BYTES TO CLEAR
LDE31 CLR 0,X+ CLEAR THE STORAGE
 DECB
 BNE LDE31
UWARM LDA #$DF SET MASQ
 STA LE080 IN DRIVE REG
 RTS

*   READ    This routine reads the specified sector into memory at the
*           specified address. This routine should perform a seek
*           operation if necessary. A sector is 256 bytes in length.
*
*           ENTRY - (X) = Address in memory where sector is to be placed.
*                   (A) = Track Number
*                   (B) = Sector Number
*
*           EXIT -  (X) May be destroyed
*                   (A) May be destroyed
*                   (B) = Error condition
*                   (Z) = 1 if no error
*                       = 0 if an error
READ BSR SEEKIT
 TST FBFLAG spooling active?
 BEQ LDE45 no - proceed
 SWI3 give spooler opportunity to run
LDE45 ORCC #$50 disable FIRQ and IRQ 
 LDA DATREG load command register (useless)
 LDA #$8C read sector command
 ORA LDE2A CURRENT SIDE MASQ
 STA CMDREG issue command
 JSR DELAY wait for WD2793 to accept command
 CLRB set byte counter
LDE56 LDA CMDREG 
 BITA #2 TEST DATA READY ?
 BNE LDE67 GET IT
 BITA #1 STILL BUSY ?
 BNE LDE56 LOOP
 TFR A,B
 BSR LDE84
 BRA LDE71

LDE67 LDA DATREG 
 STA 0,X+ STORE IN FCB
 DECB 
 BNE LDE56 MORE TO COME ?
 BSR LDE76
LDE71 BITB #$1C
 ANDCC #$AF
 RTS

LDE76 TST FBFLAG spooling active?
 BEQ LDE7D no - proceed
 SWI3 give spooler opportunity to run
LDE7D LDB CMDREG 
 BITB #1 STILL BUSY ?
 BNE LDE7D YES LOOP
LDE84 STB LDE29 SAVES STATUS REG
 BITB #$10 RECORD NOT FOUND ERROR ?
 BEQ LDEAC NO, PROCEED
 LDY #LDE1F 
 LDA LDE24
 LDB A,Y
 BITB #$10
 BEQ LDEB0
 TST LDE23
 BNE LDEA1
 EORB #$20
 STB A,Y

*SET MAX SECTOR BY SIDE
LDEA1 LDA #$0A MAX TRACK SD
 BITB #$20 
 BNE LDEA9
 LDA #$12
LDEA9 STA DRVTBL
LDEAC LDB LDE29
 RTS

LDEB0 LDA #$0F
 BRA LDEA9

*   SEEK    Seeks to the track specified in the 'A' accumulator. In
*           double-sided systems, this routine should also select the
*           correct side depending on the sector number supplied in 'B'.
*
*           ENTRY - (A) = Track Number
*                   (B) = Sector Number
*
*           EXIT -  (X) May be destroyed (See text)
*                   (A) May be destroyed (See text)
*                   (B) = Error condition
*                   (Z) = 1 if no error
*                       = 0 if an error
SEEKIT LBSR LDFB5 WAIT FOR DRIVE READY 
 CLR LDE2A SIDE 1
 CMPB DRVTBL COMPARE TO MAX SECTOR PER SIDE
 BLS LDEC5 SIDE 1, JUMP
 INC LDE2A MASQ FOR CURRENT SIDE
 INC LDE2A
LDEC5 STB SECREG SET SECTOR
 CMPA TRKREG CHECK TRACK
 BEQ LDEE2 CURRENT TRACK ?
 STA DATREG NO, STORE NEW TRACK
 JSR DELAY
 LDA #$18 SET SEEK COMMAND
 ORA LDE2B SET INTERRUPT COMMAND
 STA CMDREG SET COMMAND
 JSR DELAY
 BSR LDE76 CHECK RECORD NOT FOUND ERROR ?
 BITB #$10
LDEE2 JMP DELAY DELAY AND RETURN

*   WRITE   This routine writes the information from the specifed memory
*           buffer area to the disk sector specified. This routine should
*           perform a seek operation if necessary. A sector is 256 bytes
*           in length.
*
*           ENTRY - (X) = Address of 256 memory buffer containing data
*                         to be written to disk
*                   (A) = Track Number
*                   (B) = Sector Number
*
*           EXIT -  (X) May be destroyed
*                   (A) May be destroyed
*                   (B) = Error condition
*                   (Z) = 1 if no error
*                       = 0 if an error
WRITE BSR SEEKIT
 TST FBFLAG
 BEQ LDEEE
 SWI3
LDEEE ORCC #$50
 LDB DATREG
 LDB #$AC
 ORB LDE2A
 LDA 0,X+
 STA DATREG
 STB CMDREG
 JSR DELAY
 LDB #2
LDF05 BITB CMDREG
 BEQ LDF0F
LDF0A STA DATREG
 LDA 0,X+
LDF0F BITB CMDREG
 BNE LDF0A
 BITB CMDREG
 BNE LDF0A
 BITB CMDREG
 BNE LDF0A
 STA LDE29
 LDA #1
 BITA CMDREG
 BEQ LDF32
 LDA LDE29
 BITB CMDREG
 BNE LDF0A
 BRA LDF05

LDF32 JSR LDE76
 BITB #$5C
LDF37 ANDCC #$AF
 RTS

*   VERIFY  The sector just written to the disk is to be verified to
*           determine if there are CRC errors. No seek is required as
*           this routine will only be called immediately after a write
*           single sector operation.
*
*           ENTRY - No entry parameters
*
*           EXIT -  (X) May be destroyed
*                   (A) May be destroyed
*                   (B) = Error condition
*                   (Z) = 1 if no error
*                       = 0 if an error
VERIFY BSR LDFB5
 TST FBFLAG
 BEQ LDF43
 SWI3
LDF43 ORCC #$50
 LDA DATREG
 LDA #$8C
 ORA LDE2A
 STA CMDREG
 JSR DELAY
 JSR LDE76
 BITB #$18
 BRA LDF37


RESTORE PSHS X
 BSR DRIVE
 LDA #8
 ORA LDE2B
 STA CMDREG
 JSR DELAY
 JSR LDE76
 BITB #$D8
 PULS X,PC

*   DRIVE   The specified drive is to be selected. The drive is specified
*           in the FCB pointed to by the contents of the X register. Note
*           that the drive number is the 4th byte of the FCB.
*
*           ENTRY - (X) = FCB address (3,X contains drive number)
*
*           EXIT -  (X) May be destroyed
*                   (A) May be destroyed
*                   (B) = $0F if non-existent drive
*                       = Error condition otherwise
*                   (Z) = 1 if no error
*                       = 0 if an error
*                   (C) = 0 if no error
*                       = 1 if an error
DRIVE LDA 3,X GET DRIVE NUMBER
 CMPA #3 ENSURE IT'S < 4 
 BLS LDF7B BRANCH IF OK 
LDF76 LDB #$0F ELSE SET ERROR VALUE
 ORCC #1
 RTS RETURN
LDF7B LDY #LDE1F DRIVE TRACK MEMORY REGISTER
 LDB A,Y GET CURRENT TRACK OF TARGET DRIVE
 BEQ LDF76 
 JSR LDFE1 FIND TRACK 
 LDB TRKREG GET CURRENT TRACK
 STB 0,X SAVE IT IN REPOSITORY
 STA LDE24 SAVE CURRENT DRIVE 
 LDB A,Y
 STB LDE29 SAVE TARGET TRACK
 JSR LDEA1 SET MAX SECTOR BY SIDE
 CLR LDE2B CLEAR STEP RATE
 BITB #$C0 
 BNE LDFA0
 NOP
 NOP
 NOP
LDFA0 STB LE080 SET NEW DRIVE 
 BSR LDFE1 FIND NEW TRACK 
 LDA 0,X GET IT
 STA TRKREG PUT NEW TRACK IN WD 
 BSR LDFB5 WAIT FOR DRIVE READY 
 LDB CMDREG 
 BMI LDFDE
LDFB1 CLRB
 ANDCC #$FE
 RTS

* WAIT FOR DRIVE READY 
LDFB5 PSHS A,X
 LDX #L0000
LDFBA LEAX -1,X
 BEQ LDFC5
 NOP
 NOP
 LDA CMDREG
 BMI LDFBA
LDFC5 PULS A,X,PC

CHKRDY BSR DRIVE
 BEQ LDFB5
 LDB #$80
 BRA LDFDE
QUICK LDB CMDREG
 BMI LDFDE
 LEAX -1,X
 NOP
 LEAX 1,X
 LDB CMDREG
 BPL LDFB1
LDFDE ORCC #1
 RTS
* FIND TRACK
LDFE1 LDX #LDE25
 LDB LDE24 CURDRV
 BEQ LDFEA
 ABX
LDFEA RTS

DELAY BSR DEL1
DEL1 BSR DEL2
DEL2 BSR DEL3
DEL3 RTS

***************************
*                         *
*  END OF DRIVERS PART    *
*                         *
***************************




 END COLDS