Use buffer #0 ($0300+), find T/S in $06/7

Use buffer #1 ($0400+), find T/S in $08/9

Use buffer #2 ($0500+), find T/S in $0A/B

Use buffer #3 ($0600+), find T/S in $0C/D

Use buffer #4 ($0700+), find T/S in $0E/F

Use buffer #5 (no RAM), find T/S in $10/1

Track/sector for job in $0000 (buffer 0)

Track/sector for job in $0001 (buffer 1)

Track/sector for job in $0002 (buffer 2)

Track/sector for job in $0003 (buffer 3)

Track/sector for job in $0004 (buffer 4)

Track/sector for job in $0005 (buffer 5)

Master copy of disk ID. This is the ID specified when the disk was formatted. It is updated whenever a SEEK job is performed (see ROM patch $EF25) . The initialize command performs a seek and therefore updates the master ID.

$0012 first ID character
$0013 second ID character

Unused - Disk ID for drive #1

Image of the most recent header read. The characters appear here in the same sequence that Commodore's manual says they are recorded onto the disk surface,

$0016 first ID character
$0017 second ID character
$0018 track number
$0019 sector number
$001A header checksum

Note: They are actually recorded onto
      disk in the opposite sequence.

Not used

Flag to indicate that there has been a change in the write protect status.

Unused (WPSW for drive #1)

Last state of the write protect switch

UNUSED (LWPT for drive #1) Set to $01 on power-up

Disk drive status

Bit 4    shut down drv motor?  1=yes 0=no
Bit 5    drive motor           1=on  0=off
Bit 6    head stepping         1=on  0=off
Bit 7    drive ready?          1=no  0=yes

Unused (DRVST for drive #1)

Track currently under R/W head

Unused (DRVTRK for drive #1)

Work area for doing interconversions of binary data and its GCR write images.

Temporary storage of pointers

Pointer to currently active buffer

Pointer to active values in header table

Pointer to last character converted

Not used

Byte counter for GCR/binary conversions

Not used

Data block ID character ($07)

Header block ID character ($08)

Storage of data or header checksum

Unused

Unused

Always $00 on 1541

Currently active drive ($FF if inactive)

Position of last job in job queue (0-5)

Byte counter for GCR/binary conversions

Position of next job in job queue (0-5)

Next track to move head to

Sector counter. Used by format routine

Temporary workspace

Temporary storage of job code

Unused

Data block ID code. Set on reset to $07. This may be changed to write or read data blocks with different data block ID codes. However, the first nybble of the data block ID code should always be a zero ($0-). Otherwise, the controller will have difficulty detecting the end of the sync mark and the start of DBID. If you try to read a sector whose DBID is different from the value stored here, the disk controller will put an error code of $04 in the job queue and the drive will report a #22 error (DATA BLOCK NOT FOUND) .

Timer for acceleration of head

Temporary save of the stack pointer

The number of steps to move the head to get to the desired track. To move the head over 1 track, requires XX steps. Values between and 127 move the head out (to lower track numbers) . Values over 128 move the head (256-value) steps in (to higher track numbers)

Temporary storage

Last sector read

Next sector to service

Hi byte of a pointer to the next buffer of GCR bytes to be changed into binary. The GCR bytes in the overflow buffer are translated first. This points to the buffer that holds the rest of them.

Lo byte of a pointer to the next GCR byte location that is to be translated

Flag to indicate whether the data in the currently active buffer has been left in binary (0) or GCR (1) form.

Used by the formatting routine to store the number of the track currently being formatted. Set on reset to $FF.

Staging area for the four binary bytes being converted to GCR by PUT4BG ($F6D0) or from GCR by GET4GB ($F7E6) .

Staging area for the five GCR bytes being converted from binary by PUT4BG ($F6D0) or to binary by GET4GB ($F7E6) .

Number of steps to use to accelerate or decelerate when stepping the head ($04)

Acceleration/deceleration factor ($04)

Number of steps left to accelerate or decelerate when stepping the head

Number of steps left to step the head in fast stepping (run) mode.

Pointer to the appropriate head stepping routine. Normally $FA05 (not stepping)

Minimum number of steps for the head to move to make the use of fast stepping mode useful ($C8). If fewer steps needed, use the slow stepping mode.

Pointer to start of NMI routine ($EB2E) . Set on power up or drive reset.

Flag to indicate whether NMI in progress

Flag to enable (0) or disable (1) the auto initialization of a disk (read BAM) if ID mismatch detected.

Sector increment for use by SEQ routine. Set on reset to ($0A) .

Counter for error recovery (number of attempts so far) Set on reset to $05

Pointer to the start of the user jump table ($FFF6) . Set on power up or reset.

Pointer to the start of the bit map ($0400). Set when a disk is initialized.

Temporary work area ($6F on reset)

Temporary work area

Temporary work area

Temporary work area ($FF on reset)

Temporary work area

Temporary work area

Indirect pointer variable ($0100) Set on power up or reset.

Listener address ($28 on reset)

Talker address ($48 on reset)

Active listener flag

Active talker flag

Addressed flag

Attention pending flag

6502 in attention mode

Last program accessed

Current drive number (always in 1541)

Current track number ($00 after use)

Current sector number ($00 after use)

Logical index (current channel#)

Current secondary address

Original secondary address

Temporary data byte

Temporary result

Temporary result

Temporary result

Temporary result

Temporary result

Result area ($008B-$008E)

Accumulator ($008F-0093)

Directory buffer ($0094-0095) $05/$02

IEEE command in (not used on 1541)

MY PA flag $00

Bit counter for serial $00

Points to next byte in buffer #0 ($0300)

Points to next byte in buffer #1 ($0400)

Points to next byte in buffer #2 ($0500)

Points to next byte in buffer #3 ($0600)

Points to next byte in buffer #4 ($0700)

Points to next byte in CMD buffer ($0200)

Points to next byte in ERR buf f er ($02D6 )

Table of channel#'s assigned to each of the buffers. $FF is inactive buffer.

Table of channelt's assigned to each of the buffers. $FF is inactive buffer.

Table of lo bytes of record numbers for each buffer

Table of hi bytes of record numbers for each buffer

Table of next record numbers for buffers

Table of record size for each buffer

Table of side sectors for each buffer

File stream 1 pointer

Pointer to start of record

Number of side sector

Index to side sector

Relative file pointer to track

Sector of directory entries

Index of directory entries

Default flag, drive # (all on 1541)

Pattern, replace, closed-flags, type

Channel file type

Channel status

Temporary for EOI

Current job number

Least recently used table

No drive flag for drives and 1

DOS version taken from track 18 sector for drives 0 and 1

Unused

Command buffer ($0200-$0229)

Disk commands such as: N0:GAMES #1,G1 that are sent to the disk drive from the computer over the serial bus are stored here. The command is parsed to locate special characters such as ':' ','

Once the command has been interpreted, ROM routines are executed to do it.

Command code number

SA:LINDX table ($022B-$023D)

This table indicates the current status of each data channel (secondary address) Each" position represents one channel, channel 0=$022B; 1=$022C; 2=$022D; etc.

Possible channel status values are:
$FF - inactive
$81 - open for write
$41 - read/write
$01 - open for read

Channel data byte ($023E-$0243) The most recent byte read or written for each channel

Channel last character pointer

Points to the last character read or written in the buffer for each channel

Active file type

Length of the string

Temporary secondary address

Temporary job command

Work area for finding best sector to do

Buffer allocation

BAM dirty flag (drives 0/1)

Directory entry found flag

Directory listing flag

Command waiting flag

LINDX use word

Last buffer used

Record size. Used by directory routines

Side sector track. Used by dir routines

Side sector sector. Used by dir routines

Last job by buffer ($025B/C/D/E/F)

Sector of directory entry by buffer

Index of directory entry by buffer

Error word for recovery

Error LED mask for flashing

Last program drive

Last program sector

Write LINDX

Read LINDX

# blocks temp

Command string size

Character under the parser

PTR limit in comparison

File stream 1 count

File stream 2 count

File stream 2 pointer

Table of filename pointers

First file link (Track)

First file link (Sector)

Pattern presence flag

File stream image

Number of drive searches

Drive search flag

Last drive w/o error. Used as the default drive number.

Found flag in directory searches

Directory sector

Sector of first available entry

Index of first available entry

=0 if last block

Current index in buffer

Counter of file entries

Match by type of flag

Active file mode (R,W)

Job return flag

Pointer for recovery

Total track offset

Last BAM update pointer

Track # of BAM image (drive 0/1)

BAM images ($02A1-02B0)

Directory buffer ($02B1-$02D4 )

Error message buffer ($02D5-$02F8)

Don't write BAM flag. Set to at start and end of any disk command.

# of disk blocks free (lo byte 0/1)

# of disk blocks free (hi byte 0/1)

Current phase of head stepper motor

Data buffer #0 ($0300-$03FF)

Data buffer #1 ($0400-$04FF)

Data buffer #2 ($0500-$05FF)

Data buffer #3 ($0600-$06FF)

Data buffer #4 ($0700-$07FF) BAM ONLY!

Data port B - Serial data I/O

Bits for serial handshake:

Name   Bit Hex  Connect
DATIN  0   $01  Data in line
DATOUT 1   $02  Data out line
CLKIN  2   $04  Clock in line
CLKOUT 3   $08  Clock out line
ATNA   4   $10  Attention acknowledge line
ATN    7   $80  Attention in line

Data port A - Unused

Data direCtion for port B

Data direCtion for port A - Unused

Timer 1 low counter

Timer 1 high counter

Timer 1 low latch

Timer 1 high latch

Timer 2 low counter

Timer 2 high counter

Shift register

Auxiliary control register

Peripheral control register

Interrupt flag register

Interrupt enable register

Data port B - Disk controller I/O

Bit Hex     Connect
0/1 $01/$02 Bits & 1 are cycled to step the head
2   $04     Motor on (1) or off (0)
3   $08     Drive active LED on/off
4   $10     Write protect sense
5   $20     Density select (0)
6   $40	    Density select (1)
7   $80     SYNC detect line

Data port A - GCR data I/O to diskette

Data direction for port B

Data direction for port A

Timer 1 low counter

Timer 1 high counter

Timer 1 low latch

Timer 1 high latch

Timer 2 low counter

Timer 2 high counter

Shift register

Auxiliary control register

Peripheral control register

Interrupt flag register

Interrupt enable register

Checksum of $Cxxx and $DXXX ROM

Unused

Set bit 3 of DSKCNT ($1C00) to turn on LED for the current drive (DRVNUM; $7F).

Set bit 3 of DSKCNT ($1C00) to turn on drive active LED for drive 0.

Store $00 in ERWORD ($026C) and in ERLED ($026D) to clear any error status and turn off drive-active/error LED.

Store $80 in ERWORD ($026C) to ensure LED will continue to flash and set bit 3 of DSKCNT to turn the LED on using the LED mask from LEDMSK ($FECA).

Clear the "don't write BAM" flag, WBAM ($02F9) and move the drive number of the last successful job from LSTDRV ($028E) to DRVNUM ($7F). This makes the last used drive the default drive.

JSR to OKERR ($E6BC) to clear any errors and move the OK error message into the error buffer.

Check if the command's secondary address (ORGSA; $84) was $0F (command channel).

If it was not $0F, exit with a JMP to OPEN ($D7B4).

If the secondary address was $0F, JSR to CMDSET ($C2B3) to interpret the command and set up the necessary variables and registers (on return .Y=0).

Move first character of command from the command buffer ($0200) to CHAR ($0275).

Search the command table (CMDTBL; $FE89) for this character. If not found, exit by loading .A with a #$31 (BAD COMMAND) and jumping to the command level error handler (CMDERR; $C1C8).

If found, store the command's position in the table (the command number) into CMDNUM ($022A).

Check if this command must be parsed by comparing the command number with $09. If parsing is required (NEW, RENAME, SCRATCH, COPY, & LOAD),

JSR to TAGCMD ($C1EE) to set tables, pointers and patterns.

Move the address of the appropriate ROM routine from the tables, CJUMPL ($FE95) and CJUMPH ($FEA1) into $6F/$70 (TEMP).

Exit with an indirect JMP to the routine via the vector at TEMP ($6F).

Clear the "don't write BAM" flag, WBAM ($02F9).

Load .A with the error status from ERWORD ($026C).

If non-zero, an error has occurred so exit with a JMP to CMDERR ($C1C8) .

If command completed with no errors, set TRACK ($80). SECTOR ($81), and the pointer into the command buffer, CB($A3) to $00.

JSR to ERRMSG ($E6C7) and ERROFF ($C123) to clear any error status.

Move current drive number from DRVNUM ($7F) to last used drive number, LSTDRV ($028E).

Set the drive-busy flag, NODRV ($FF) to $00 to indicate that the drive is inactive.

JSR to CLRCB ($C1BD) to zero the command buffer. JMP to FREICH ($D4DA) to clear the internal channel.

Clear the command buffer ($0200-$0228) Erase any old command information by overwriting the old command with $00.

Set TRACK ($80) and SECTOR ($81) to $00 and JMP to CMDER2 ($E645) .

Initialize .X and the file table pointer FILTBL ($027A) to $00. Load .A with a $3A (:) and JSR to PARSE ($C268) to scan the command string for a colon.

On return Z=1 if ":" found and .Y points to its position in the command. If not found, leave FILTAB=$00 and exit. If ":" was found, set FILTAB=(":" position-1) and exit. All exits are with a JMP to SETANY ($C368) to set the drive number.

Load .X and .Y with $00 and. A with $3A (:) and JMP to PARSE ($C268).

JSR to PRSCLN ($C1E5) to locate the position of the colon (:) that is a necessary part of all these commands, e.g. R0:NEWNAME=OLDNAME (Rename)

If no colon was found, load .A with $34 to indicate a bad command and exit with a JMP to CMDERR ($C1C8).

If a colon was found, set FILTAB to the colon position-1.

Check if a comma was found before the colon (.X > on return from PARSE).

If a comma was found, the syntax is bad so exit via TC25 ($C1F3).

Load .A with $3D (=) and JSR to PARSE ($C268). On return .X=0 indicates that no wild-card characters (? or *) were found.

If any were found, set bit 6 (G1) of IMAGE ($028B) to indicate that the command applies to more than one file.

In all cases, set bit 5 (Dl) of IMAGE to indicate that a drive # is present and set bit (N2) to indicate that a second file name is given (fixed later).

Increment .X and use it to set the lengths of filenames 1 and 2, F1CNT and F2CNT ($0277/8).

Filename 2 will default to the same length as filename 1.

Check if PARSE found any wild cards by loading PATFLG ($028A). If any found, set bit 7 (PI) of IMAGE ($028B).

Set pattern flag, PATFLG ($028A) to $00 to prepare for parsing the rest of the command.

Check if there is any command left to parse by checking the value of .Y set by PARSE.

If .Y=0, nothing left so branch to TC75 ($C254) to check structure.

Store value from .Y in filetable, FILTBL ($027A),X. Set the pointer to the start of filename #2, F2PNT ($0279) from the current value of F1CNT ($0277).

Load .A with $8D (shifted CR) and JSR to PARSE ($C268) to parse the rest of the command.

On return increment .X so it points to the end of the string and put the value into F2CNT ($0278). Decrement the value of .X to restore its former value.

Check if any wild cards were found by PARSE in filename 2 by checking the pattern flag, PATFLG ($028A).

If any were found, set 3 (P2) of IMAGE ($028B).

Check if there was a second filename by checking if .X = F1CNT. If second file name is only 1 chr long, branch to TC70.

Set bit 2 to indicate that the command implies more than one second file name.

Set bit 1 to indicate that a second drive is specified and bit to indicate that a second file name is given.

EOR this with IMAGE (clears bit 0) and store the result back into IMAGE ($028B) .

Check IMAGE against the entry for that command (CMD number from CMDNUM, $022A) in the structure table, STRUCT ($FEA5+)

If match, syntax is OK; exit with an RTS

Store IMAGE in ERWORD ($026C).

Load .A with a $30 to indicate a bad syntax and exit with a JMP to CMDERR ($C1C8) .

Store the desired character in CHAR ($0275) .

Start of loop using .Y as a counter to scan the command string. If .Y is greater than or equal to the length of the command string, CMDSIZE ($0274) , branch to PR30 ($C29E) .

Load command string character into .A and increment .Y counter. Check if it is the desired character. If it is, branch to PR35 ($C2A0) .

Check if it is a wild card ("*" or "?"). If not, branch to PR25 ($C283).

Increment the pattern flag, PATFLG ($028A) to count the # of wild cards.

Check if it is a comma (","). If not, branch back to PR10 to get next command string character.

Transfer character count from .Y to .A and store in the file table, FILTAB+1,X ($027B,X) to indicate where the file name ends. Load .A with the pattern flag PATFLG and AND it with $7F. If the result is zero (no wild cards found) , branch to PR28.

Wild cards were present, so store $80 in PATTYP,X ($E7,X) to indicate this. Also store $80 into PATFLG to zero the count of wild cards but indicate that there are wild cards in the string.

Increment .X (counts number of files & points into FILTAB) and compare it to $04 (the maximum number of file names allowed in a command string). If the maximum has not been exceeded, branch back to PR10 to continue the scan.

Load .Y with $00 to indicate that the desired character was not found.

Store a copy of the command size, CMDSIZ ($0274) into the file table, FILTAB+1,X ($027B,X). Load the pattern flag, PATFLG and AND it with $7F. If the result is 0, no wild cards have been found so branch to PR4 0.

Wild cards were present, so store $80 in PATTYP,X ($E7,X) to indicate this.

Transfer character count from .Y to .A. This sets the Z flag if the desired character has not been found.

Load .Y from BUFTAB+CBPTR ($A3). This is the length of the command that was sent from the computer. If .Y=0, branch to CS08 ($C2CB) .

Decrement .Y and if .Y=0, branch to CS07 ($C2CA) .

Load .A with the character from the command buffer, CMDBUF,Y ($0200, Y) and see if it is a carriage return ($0D). If it is, branch to CS08 ($C2CB) .

Decrement .Y and load the next character from the command buffer. If this is a carriage return ($0D). branch to CS08 ($C2CB). If not, increment .Y

Increment .Y pointer into command buffer

Store length of command (.Y) in CMDSIZ ($027B). Compare length (.Y) with the maximum allowable length ($2A) to set the carry flag. Load .Y with $FF. If command length was OK, branch to CMDRST.

Command over-size so set command number ($022A) to $FF, load .A with $32 to indicate a TOO LONG ERROR and exit with a JMP to CMDERR ($C1C8).

Zero all important variables & pointers:

BUFTAB+CBPTR ($A3)
FILTBL 	($027A-7F)
ENTSEC 	($00D8-DC)
ENTIND 	($00DD-E1)
FILDRV 	($00E2-E6)
PATTYP 	($00E7-EB)
FILTRK 	($0280-84)
FILSEC 	($0285-89)
REC 	($0258)
TYPE	($024A)
TYPFLG 	($0296)
F1PTR	($00D3)
F2PTR	($0279)
PATFLG 	($028A)
ERWORD	($026C)

Change pointer to end of the first file name (F1CNT; $0277) to point to the end of the second file name (use value from F2CNT; $0278). Store $01 in F2CNT and in F2PTR ($0279) to clear these variables

Set up all drives from F2CNT: Load .Y with last drive used from LSTDRV ($028E) and .X with $00.

Save .X into F1PTR ($D3). Load .A from FILTAB,X ($027A,X) so it points to the start of the Xth file specified in the command string.

JSR to SETDRV ($C33C) to set drive #. On return .Y contains the drive number specified in the command or the default. NOTE: Bits represent drives (If bit 7 set, use default. Bit = drive #0/1)

Recover .X pointer from F1PTR. Store .A in FILTAB,X ($027A,X). Move drive # from .Y to .A and store in FILDRV, X ($027A,X)

Increment .X pointer and compare it to F2CNT ($0278) to see if any more files were specified. If more, branch back to AD10 to do the next one. If not, RTS

Move pointer into command buffer from .A to .X

Load .Y with $00 to ensure that the 1541' s default drive is ALWAYS DRIVE #0

Load .A with $3A (:) to prepare to hunt for a colon (drive # is just before :).

Check for colon in command string at CMDBUF+1,X ($0201, X). Picks up syntax: X#: FILENAME as in SO: JUNK If found, branch to SD40.

Check for colon in command string at CMDBUF,X ($0200, X). Picks up default drive syntax as in S:JUNK If colon NOT found, branch to SD40.

Colon found so increment pointer (.X) so it points to the first character in the filename.

Transfer .Y to .A to set up the default drive

AND .A with $01 to ensure drive number in ASCII form ($30 or $31) is converted to $00 or $01.

Transfer .A to .Y to restore drive #. Transfer .X to .A to restore index into command string and exit with an RTS.

Load .A with the drive number (in ASCII) from CMDBUF,X ($0200, X).

Increment .X twice so it points to the first character in the file name.

Compare .A (drive number) to $30 (dr#0) . If equal, branch back to SD22 ($C34D)

Compare .A (drive number) to $31 (dr#l) . If equal, branch back to SD22 ($C34D) If not equal, must be default drive so branch back to SD20 ($C34C) .

Set drive # from command string with the syntax: X#,FILE or xx=FILE. Transfer the drive number from .Y to .A.

OR .A with $80 to set the default drive bit and then AND the result with $81 to mask off any odd bits. Branch back to SD24 ($C34F) to terminate routine.

Set IMAGE ($028B) to $00.

Load .Y from FILTBL ($027A) .

Load .A with the (CB) ,Y character from the command string and JSR to TST0V1 to test for a "0" or "1" .

On return .A contains $00 or $01 if the drive was specified. If not specified, .A is $80 or $81. If the drive number was given, branch to SA20 ($C388) .

Increment the pointer into the command string (.Y). Compare the pointer value to the command length (CMDSIZ; $0274) to see if we are at the end. If we are, branch to SA10 ($C383) .

If not "0" or "1", set the pointer (.Y) to the end of the command less one (so it points to the last character before the RETURN to pick up things like V0) and loop back to SA05 ($C370).

Decrement IMAGE (becomes $FF) to flag a default drive status and load .A with a $00 to ensure default to on the 1541.

AND the drive number in .A with $01, and store the result in the current drive number, DRVNUM ($7F) .

Exit with a JMP to SETLDS ($C100) to turn on the drive active light.

Load .A with current drive number from DRVNUM ($7F). EOR it with $01 to flip bit #0, AND it with $01 to mask off the bits 1-7, and store the result back in DRVNUM ($7F) .

Zero .Y and load .A with the pointer to the end of file name 1 (F1CNT; $0277) .

Compare .A to the pointer to the end of file name 2 (F2CNT; $0278). If equal, there is no second file so branch to FS15 ($C3B8).

Decrement F2CNT and load .Y with its value. Load .A with the pointer to the filetype in the command string from FILTAB,Y ($027A,Y). Transfer this value to .Y and use it to load the file type into .A from the command string (CB) ,Y.

Load .Y with $04 (the number of file types less 1) .

Loop to compare the file type in .A to the list of possible file types ,TYPLST,Y When a match occurs, branch to FS15 ($C3B8). If no match found this time, decrement .Y and, if there are any file types left, loop back to FS10. NOTE: if no match occurs, file assumed to be DEL.

Transfer file type from .Y to .A and store in TYPFLG ($0296).

Compare .A to ASCII "0" ($30) and then to ASCII "1" ($31). If a match in either case, branch to T0V1. OR .A with $80 to set bit 7 to indicate no match was found.

AND .A with $81 to convert ASCII to HEX and preserve bit 7.

Zero TEMP ($6F) and DRVFLG ($028D) and push $00 onto the stack. Load .X with value from F2CNT ($0278). Note: TEMP is the drive mask.

Pull .A from the stack and OR it with the value in TEMP ($6F). Push the result back onto the stack.

Load .A with $01 and store this value in TEMP. Decrement .X (pointer into file table).

If no files left (.X=$FF), branch to $OS30.

Load .A with the drive for the file from FILDRV,X ($E2,X).

If this file uses the default drive (bit 7 set), branch to OS15. Do two ASL's on TEMP ($6F).

Do one LSR on .A. If drive number in .A was 1, the carry bit is set so branch back to OS10.

Since drive number was 0, do one ASL on TEMP ($6F) and branch back to OS10.

Pull .A from the stack and transfer this value to .X. Use this value as an index and load .A with a value from the search table, SCHTBL-1,X ($C43F,X).

Push this value onto the stack, AND it with $03, and store the result in DRVCNT ($028C).

Pull the original value off the stack and do an ASL. If bit 7 is not set, branch to OS40.

If bit 7 was set, load A. with the value from FILDRV ($E2) .

AND .A with $01 and store the result in DRVNUM ($7F). Load .A with DRVCNT ( $028C) and if $00, only one drive is addressed so branch to OS60.

JSR to AUTOI ($C63D) to check the drive status and initialize it if necessary. On return, branch to OS70 if the drive is ready (. A=0) .

Drive is not ready so load .A with $74 to indicate the drive is not ready and JSR to CMDERR ($C1C8).

JSR to TOGDRV ($C38F) to switch drives and JSR to AUTOI ($C63D) to check this drive's status and init it if necessary. On return, save the processor status on the stack. JSR to TOGDRV to switch back to the first drive. On return, pull the status back off the stack. If the second drive is active, branch to OS70.

Since second drive is not active, set DRVCNT ($020C) to $00 to indicate only one drive addressed and branch to OS70.

JSR to AUTOI ($C63D) to check the drive status and initialize it if necessary. On return, branch to OS45 if the drive is NOT ready (.AO0) .

Teminate routine with a JMP to SETLDS ($C100) to turn on the drive active LEDs

Do a ROL on the value in .A and JMP to OS35 ($C400).

Search Table

BYTES $00, $80, $41
BYTES $01, $01, $01, $01
BYTES $81, $81, $81, $81
BYTES $42, $42, $42, $42

JSR to OPTSCH to find optimal search pattern and turn on drive active LEDs.

Store $00 in DELIND ($0292). to indicate that we are NOT looking for a deleted or unused directory entry. But, for one or more specific file names. JSR to SRCHST ($C5AC) to start the search process.

On return, branch to LK25 if a valid file name was found (Z flag =0)

Since no file name was found, decrement DRVCNT ($028C). the number of drive searches to be made. If any more left (DRVCNT >= 0), branch to LK15.

Since there are no more drive searches to be done, exit with an RTS.

Store $01 in DRVFLG ($028D) and JSR to TOGDRV ($C38F) to switch drives. JSR to SETLDS ($C100) to turn on the other LED. Then JMP back to LK05 to begin the search on the other drive.

JSR to SEARCH ($C617) to read the next valid file name in the directory.

On return, branch to LK30 to abandon the search if a valid file name was NOT found (Z flag = 1) .

JSR to COMPAR ($C4D8) to compare the list, of files found with list of those required. On return, FOUND ($028F) is if all files have NOT been found.

Load .A with the value from FOUND. If not all the files have been found yet, branch to LK26 to continue the search.

All files have been found so exit from the routine with an RTS.

Load .A with the value from ENTFND ($0253) to check if the most recent compare found a match. If not (.A=$FF), branch to LK20 to search directory for another valid file name. If a match was found, branch back to LK25 to try again.

Load .A with the value from FOUND. If not all the files have been found yet, branch to LK10 to continue the search.

All files found so exit with an RTS.

JSR to SRRE ($C604) to set up and read in the next block of directory entries.

If no files found, branch to FF10.

If files were found, branch to FF25.

Store $01 in DRVFLG ($028D) and JSR to TOGDRV ($C38F) to switch to the other drive. JSR to SETLDS ($C100) to turn on the new drive active light.

Store $00 in DELIND ($0292),to indicate that we are NOT looking for a deleted or unused directory entry. But, for one or more specific file names. JSR to SRCHST ($C5AC) to start the search process.

On return, branch to FF25 if a valid file name was found (Z flag = 0)

Store .A value in FOUND ($028F) .

Load .A from FOUND ($028F) .If non-zero, all files found so branch to FF40 & exit

Since there is nothing more on this drive, decrement DRVCNT by 1. If any more drives left, branch to FF15 to try the other drive. If none left, do an RTS

JSR to SEARCH ($C617) to retrieve the next valid file name from the directory.

On return, branch to FF10 if no more entries available on this drive.

JSR to COMPAR ($C4D8) to see if any of the names found match the ones needed.

On return, load .X from ENTFND ($0253). If a match on a name was found (.X<128), branch to FF30 to check the file type. If no match found (.X>127), load .A with the value from FOUND ($028F) to check if all files have been found. If not(.A=0), branch back to FNDFIL to load another name from the directory.

If .AO0, all files have been found so branch to FF40 and exit with an RTS.

Check the file type flag, TYPFLG ($0296) . If it is $00, there is no file type restriction so branch to FF40 and exit.

Load the file pattern type from PATTYP,X ($E7,X), AND it with the file type mask#$07, and compare it to the value in TYPFLG ($0296). If the file types do not match, branch back to FNDFIL to continue the search.

Terminate the routine with an RTS.

Set the found-entry flag, ENTFND ($0253) to $FF and zero the pattern flag PATFLG (S028A).

JSR to CMPCHK ($C589) to check the file table for unfound files. If there are unfound files (Z flag = 1), branch to CP10 to begin comparing.

Terminate routine with an RTS.

JSR to CC10 ($C594) to set F2PTR ($0279) to point to the next file needed on this drive. On return, branch to CP02 to exit if no more files needed on this drive.

Load .A with the current drive number from DRVNUM ($7F) and EOR it with the drive number specified for the file, FILDRV,X ($E2,X). LSR the result. If the carry flag is clear, the drive number is correct for this file so branch to CP20 to find the name in the directory list.

AND the value in .A with $40 to check if we are to use the default drive (NOTE: $40 rather than $80 because of the LSR) . If we can not use the default drive, branch back to CP05 to set up the next file name on our list of files needed.

Compare DRVCNT ($028C) with $02. If equal. don't use default drive so branch back to CP05.

Load .A with the pointer to the position of the required file name from FILTBL,X ($027A,X) and transfer this value to .X.

JSR to FNDLMT to find the end of the command string. On return, load the pointer into the directory buffer (.Y) with $03 (so it points past the file type, track and sector) and JMP to CP33.

Compare the .Xth character in the command string (the required filename) with the .Yth character in the directory buffer (the directory entry). If equal , branch to CP32 to set up for the next character.

No exact match so check if the command buffer character is a "?" which will match any character. If not, branch to to CP05 to try the next file name.

Compare the character we just used from the directory buffer with $A0 to see if we've reached the end of the name. If we have, branch to CP0 5 to try the next file name.

Increment .X and .Y

Compare .X with the length of the command string, LIMIT ($0276). If we are at the at the end, branch to CP34.

Check if the new character in the file name, CMDBUF,X ($0200, X) is a "*". If it is, it matches everything so branch to CP40 to tabulate this match.

If not a "*", branch to CP30 to keep on matching.

Compare .Y to $13 to see if we are at the end of the name in the directory. If we are, branch to CP40 to tabulate.

If not at the limit, check the character in the directory entry name. If it isn't an $A0, we did not get to the end of the name so branch back to CP05 to try again

The filenames match so keep track of it by storing the pointer to the entry from F2PNT ($0279) intoENTFND ($0253).

Get the file type pattern ($80. $81 , etc) from PATTYP,X ($E7,X), AND it with $80, and store it in PSTFLG.

Get the pointer to the directory entry from INDEX ($0294) and store it in the entry index, ENTIND,X ($DD,X) .

Get the sector on track 18 on which the entry is stored from SECTOR ($81) and store it in, ENTSEC,X ($D8,X).

Zero .Y and load .A with the file type of this directory entry from (DIRBUF) ,Y ($94) ,Y. Increment .Y. Save the type on the stack. AND the type with $40 to see if this is a locked file type, and store the result in TEMP ($6F). Pull the file type off the stack and AND it with $DF ($FF-$20). If the result is > 127 (the replacement bit not set). branch to CP42

OR the result with $20.

AND the result with $27 and OR it with the value stored in TEMP ($6F) and store the final result back in TEMP.

Load .A with $80, AND .A with the file pattern type from PATTYP,X ($E7,X), OR the result with the value in TEMP ($6F) , and store the final result back in PATTYP,X.

Load .A with the file's drive number from FILDRV,X ($E2,X). AND it with $80 to preserve the default drive bit, OR it with the current drive number, DRVNUM ($7F) and store the result back into FILDRV,X ($E2,X) .

Move the file's first track link from (DIRBUF) ,Y(.Y=1) to FILTRK,X ($0280) and increment .Y.

Move the file's first sector link from (DIRBUF) ,Y(.Y=2) to FILSEC,X ($0285).

Check the current record length, REC ($0258). If NOT $00, branch to CMPCHK.

Set .Y to $15 and move the file entry's record size from (DIRBUF) ,Y to REC.

Set all-files-found flag, FOUND ($028F) to $FF. Move the number of files to test from F2CNT ($0278) to F2PTR ($0279).

Decrement the file count, F2PTR ($0279). If any files left, branch to CC15. If none left, exit with an RTS.

Load .X with the number of the file to test from F2PTR. Load .A with the file's pattern type from PATTYP,X ($E7,X). If file has not been found yet (bit 7 is still set) abort search by branching to CC20. Load .A with the file's first track link from FILTRK,X ($0280, X). If non-zero, the file has been found. so branch back to CC10 to test the next file.

Load .A with $00 and store it in the all-files-found flag, FOUND ($028F) to indicate that all files have NOT been found and exit with an RTS.

Returns with valid entry (DELIND=0) or with the first deleted entry (DELIND=1) Load .Y with $00 and store it in DELSEC. ($0291). Decrement .Y to $FF and store it in the f ound-an-entry flag, ENTFND ($0253) .

To start search at the beginning of the directory, set TRACK ($80) to $12 (#18) (from $FE79) and SECTOR ($81) to $01. Also store $01 in last-sector-in-f ile flag, LSTBUF ($0293) .

JSR to OPNIRD ($D475) to open the internal channel (SA=16) for a read and to read in the first one or two sectors in the file whose T/S link is given in TRACK ($80) and SECTOR ($81).

Test LSTBUF ($0293) to see if we have exhausted the last sector in the directory file. If not (LSTBUF <> $00), branch to SR15.

Exit with an RTS.

Set the file count, FILCNT ($0295) to $07 to indicate that there are 8 entries (0-7) left to examine in the buffer.

Load .A with $00 and JSR to DRDBYT to read the first byte in the sector (the track link). On return store this value into LSTBUF ($0293). This sets LSTBUF to $00 if there are no more blocks left in in the directory file.

JSR to GETPNT ($D4E8) to set the directory pointer, DIRBUF ($94/5) to the data that was just read into the active buffer, BUFTAB,X ($99/A,X).

Decrement the entry count, FILCNT and load .Y with $00 to begin examination of the first directory entry.

Test the entry's file type in (DIRBUF) ,Y If non-zero, this is NOT a deleted or blank entry so branch to SR30.

Process a scratched or blank entry Test DELSEC ($0291) to see if a deleted entry has already been found. If it has (DELSEC <> $00), branch to SEARCH ( $C617 )

This is first deleted entry so JSR to CURBLK ($DE3B) to set up the current sector in SECTOR ($81). Save the sector number in DELSEC ($0291) .

Load .A with the low byte of the pointer to the start of this entry (its position in the data buffer) from DIRBUF ($94) . Load .X with the current value of DELIND ($0292). This sets the Z flag to 1 if only valid entries are desired. Store the pointer in .A into DELIND.

If the Z flag is set, we need valid entries, not deleted ones, so branch to SEARCH to continue the search.

We wanted a deleted entry and we found one so terminate routine with an RTS.

We have found a valid entry. Check if we are looking for one by comparing DELIND ($0292) to $01. If not equal, we want a valid entry so branch to SR50.

If DELIND = 1, we want a deleted entry, not a valid one, so branch to SEARCH to continue the quest!

Set TRACK ($80) to $12 (#18) from $FE85 Set SECTOR ($81) from the last directory sector used, DIRSEC ($0290) .

JSR to OPNIRD ($D475) to open the internal channel (SA=16) for a read and to read in the first one or two sectors in the file whose T/S link is given in TRACK ($80) and SECTOR ($81).

Load .A with the pointer INDEX ($0294) that points to the start of the last entry we were examining and JSR to SETPNT ($D4C8) to set the DIRPNT ($94/5) to point to the start of the entry.

Set found-entry flag, ENTFND ($0253) to $FF. Load .A with number of entries left in the buffer from FILCNT ($0295). If none left, branch to SR40 to get the next buffer of directory entries.

There is at least one more entry left in this buffer so load .A with $20 (the # of characters in each entry) and JSR to INCPTR ($D1C6) to set DIRPTR ($94/5) to point to the start of the next entry. JMP to SR20 ($C5D7) to process it.

JSR to NXTBUF ($D44D) to read in the next directory sector and JMP to SR10 to begin processing it.

We have found a valid entry so save how far we got and return. Save low byte of the pointer to the entry, from DIRBUF($94) in INDEX ( $0294 ) .

JSR to CURBLK ($DE3B) to store the sector we are checking in SECTOR ($81) .

Save the current sector number from SECTOR ($81) in DIRSEC ($0290) and RTS.

Test auto-initialization flag, AUTOFG ($68). If AUTOFG <> 0, auto-init is disabled so branch to AUT02 ($C669).

Load .X with the current drive number from DRVNUM ($7F). Test whether the diskette has been changed by doing an LSR on the wr ite-protect-change flag for the current drive, WPSW,X ($1C/D). If the carry flag, C, is clear, the disk has not been changed so branch to AUT02 .

Load .A with $FF. Store this value as the job return code in JOBRTN ($0298) .

JSR to ITRIAL ($D00E) to do a SEEK to the current drive to determine if a diskette is present.

Load .Y with $FF (default to true) .

Compare the value in return job code in .A with $02. If equal, NO SYNC was found so branch to AUTO1 to abort.

Compare the value in return job code in .A with $03. If equal, NO HEADER was found so branch to AUTO1 to abort.

Compare the value in return job code in .A with $0F. If equal, NO DRIVE was found so branch to AUTO1 to abort.

Seems OK so load .Y with $00.

Load .X with the current drive number DRVNUM ($7F). Transfer the value of .Y into .A ($00 if OK;$FF if BAD) and store in the current drive status, NODRV,X ($FF,X). If status is bad (not $00), branch to AUT02 to abort.

JSR to INITDR ($D042) to initialize the current drive.

Load .A with the current no-drive status and terminate routine with an RTS.

Note: Z flag set if all is OK.

On entry, .A=string size; .X=starting index in command string; .Y=buffer # Save .A (string size) on the stack.

JSR to FNDLMT ($C6A6) to find the limit of the string in the command buffer that is pointed to by .X.

JSR to TRCMBF ($C688) to transfer the command buffer contents from .X to LIMIT to the data buffer whose number is in .Y

Restore the string size into .A from the stack. Set the carry flag and subtract the maximum string size, STRSIZ ($024B) .

Transfer the result from .A to .X. If the result is or negative, the string does not need padding so branch to TN20.

String is short and needs to be padded so load .A with $A0 .

Loop to pad the string in the directory buffer with .X $A0 ' s.

Terminate routine with an RTS.

.X=index to first chr in command buffer LIMIT=index to last chr+1 in CMD buffer . Y=buffer#. Uses current buffer pointer. Multiply .Y by 2 (TYA; ASL; TAY) .

Use current buffer pointers, BUFTAB,Y ($99/A,Y) to set the directory buffer pointers, DIRBUF ($94/5). Zero .Y (index into directory buffer)

Move character from CMDBUF,X ($0200, X) to (DIRBUF) ,Y ; ($94) ,Y.

Increment .Y. If .Y equals $00, branch to TR20 to abort.

Increment .X. If .X < LIMIT ($0276) branch back to TRIO to do next character

Terminate routine with an RTS.

Zero the string size, STRSIZ ($024B). Transfer the starting pointer from .X to .A and save it on the stack.

Load .A with the Xth command string character, CMDBUF,X ($0200, X).

Compare the character to a ". ". If they match, we're at the end. Branch to FL10.

Compare the character to a "=". If they match, we* re at the end. Branch to FL10.

Increment STRSIZ ($024B) and .X

Check if the string size, STRSIZ, has reached the maximum size of $0F (#15) . If it has, branch to FL10 to quit.

Compare .X to the pointer to the end of the command string, CMDSIZ ($0274). If we're NOT at the end. Branch to FL05.

Store the .X value (the last character plus 1) into LIMIT ($0276).

Pull the original .X value off the stack into .A and transfer it to .X

Terminate routine with an RTS.

Save secondary address, SA ($83) on the stack.

Save the current channel*, LINDX ($82) on the stack.

JSR to GNSUB ($C6DE) to get a directory entry using the internal read channel SA=$11(#17)\

Pull the original SA and LINDX values from the stack and reset these variables

Terminate the routine with an RTS.

Set current secondary address, SA ($83) to $11 (internal read secondary address)

JSR to FNDRCH ($D0EB) to find an unused read channel.

JSR to GETPNT ($D4E8) to set the directory buffer pointer, DIRBUF ($94/5) from the pointer to the currently active buffer using values from BUFTAB ($30/1) .

Test the found entry flag, ENTFLG ($0253 ) to see if there are more files. If there are more (ENTFLG > 127), branch to GN05.

No more entries so test DRVFLG ($028D) to see if we have the other drive to do. If DRVFLG <> 0, branch to GN050 to do the other drive. GN0 5

JSR to MSGFRE ($C806) to send the BLOCKS FREE message.

Clear carry bit and exit with an RTS.

Test drive flag, DRVFLG ($028D). If $00, branch to GN10.

Decrement drive flag, DRVFLG ($028D). If not $00, branch to GN0 51 to do a new directory.

Decrement drive flag, DRVFLG ($028D) .

JSR to TOGDRV ($C38F) to switch drives.

JSR to MSGFRE ($C806) to send the BLOCKS FREE message.

Set the carry flag and exit with a JMP to TOGDRV ($C3 F) to switch drives. 8

Load .A with $0and zero the hi byte of the number of blocks counter, NBTEMP+1 ($0273) and thedrive flag DRVFLG ($028D)

JSR to NEWDIR ($C7B7) to begin a new directory listing.

Set the carry flag and exit with an RTS.

Load .X with $18 (#24), the length of an entry in a directory listing e.g.' 114 "PROGRAM FILENAME" PRG

Load .Y with $1D, the position of the hi byte of the # of blocks in the file,

Load .A with the hi byte of the # of blocks in the file. Store this into the hi byte of the block counter, NBTEMP+1 ($0273). If zero, branch to GN12.

Load .X with $16 (#22) the directory length less 2.

Decrement Y so it points to the position of the lo byte of the # of blocks in the file.

Load .A with the lo byte of the # of blocks in the file. Store this into lo byte of the block counter, NBTEMP the ($0272).

Compare .X to $16 (#22) the directory length less 2. If they are equal, branch to GN14.

Compare .A (the lo byte of the blocks) with $0A (#10). If .A<10 branch to GN14

Decrement .X (we will need less padding since # of blocks is at least 2 digits.

Compare .A (the lo byte of the blocks) with $64 (#100). If A<100 branch to GN14

Decrement .X (we will need less padding since # of blocks is at least 3 digits).

JSR to BLKNB ($C7AC) to clear the name buffer for the next entry. On return Y=0

Load .A with the file type from the directory buffer (DIRBUF) ,Y and save the file type onto the stack.

Do an ASL of the value in .A to set the carry bit if this is a valid file that has not been closed, (see BCS $C764)

If .A<128, branch to GN15. NOTE: The branch at $C742 and the code following is what produces the PRG<. SEQ< , etc. file types. Note that these file types are LOCKED and can't be SCRATCHED! The locking and unlocking of files is NOT supported by any Commodore DOS. To lock a file, change its file type in its directory entry from $80, $81, etc to $C0, $C1, etc. Reverse the process for unlocking

Load .A with a $3C (a "<").

Store this value into the name buffer NAMBUF+1,X ($02B1,X) .

Pull the file type off the stack and AND it with $0F to mask off the higher bits. Transfer it to .Y to use as an index.

Move last character in file type name from TP2LST,Y ($FEC5,Y) to the name buffer, NAMBUF,X ($02B1,X).

Decrement .X

Move middle character in file type name from TP1LST,Y ($FEC0,Y) to the name buffer, NAMBUF,X ($02B1,X).

Decrement .X

Move first character in file type name from TYPLST,Y ($FEBB,Y) to the name buffer, NAMBUF,X ($02B1,X).

Decrement .X twice

If carry bit is set (indicates valid entry; see $C742) branch to GN20.

Load .A with $2A (a "*") to indicate an improperly closed file.

Store the "*" in NAMBUF+1,X ($02B1,X).

Store a shifted space, $A0 in the buffer (between name & type) and decrement .X

Load .Y with $12 (#18) so it points to the end of the name in the dir buffer.

Loop to transfer the 16 characters in the file name from the directory buffer to the name buffer.

Load .A with $22 (a ' " ' )

Store quotation mark before the name.

Loop to scan up the name looking for a quote mark($22) or a shifted space ($AO). When either character is found or the end of the name is reached, store a $22 (quote mark) at that location. Then AND any remaining characters in the name with $7F to clear bit 7 for each one.

JSR to FNDFIL ($C4B5) to find the next entry. On return, set the carry bit.

Terminate the routine with an RTS.

Load .Y with $1B, the length of the name buffer, and .A with $20, a space.

Loop to store $20 's in all locations in the name buffer, NAMBUF ($02B1-CB)

Terminate the routine with an RTS.

JSR to BAM2X ($F119) to set BAM pointer in buffer 0/1 tables and leave in .X

JSR to REDBAM ($F0DF) to read in the BAM to $0700-FF if not already present.

JSR to BLKNB ($C7AC) to blank the name buffer, NAMBUF ($02B1-CB).

Set TEMP ($6F) to $FF

Set NBTEMP ($0272) to the current drive number from DRVNUM ($7F)

Set NBTEMP+1 ($0273) to $00

Load .X with the position of the read BAM job in the queue from JOBNUM ($F9) .

Set high byte of the pointer to the directory buffer, DIRBUF ($94/5) using a value (3,4,5,6,7,7) from BUFIND,X ( $FEE0 )

Set low byte of the pointer to the directory buffer, DIRBUF ($94/5) using the value ($90) from DSKNAM ($FE88). DIRBUF now points to the start of the disk name in the BAM buffer ($0x90)

Load .Y with $16 (#22). the name length.

Load .A with character, (DIRBUF) ,Y and test if it is a shifted blank ($A0) . If not, branch to ND20.

Since it is not a shifted blank, load .A with a $31 (ASCII "1") for version #1.

BYTE $2C here causes branch to ND20.

Load .A with character, (DIRBUF) ,Y and test if it is a shifted blank ($A0) . If not, branch to ND20.

Since it is not a shifted blank, load .A with a $20 (ASCII space).

Store the character in .A into the name buffer, NAMBUF+2,Y ($02B3,Y).

If more characters left (.Y>=0) branch back to ND15.

Store a $12 (RVS on) in NAMBUF ($02B1)

Store a $22 (quote) in NAMBUF+1 ($02B2)

Store a $22 (quote) in NAMBUF+18 ($02C3 )

Store a $20 (space) in NAMBUF+19 ($02C4)

Terminate routine with an RTS.

JSR to BLKNB ($C7AC) to clear the name buffer.

Load .Y with $0B (message length -1) .

Loop using .Y as index to move message from FREMSG, Y ($C817,Y) to NAMBUF, Y ($02B1,Y) .

Terminate routine with a JMP to NUMFRE ($EF4D) to calculate the number free.

Message "BLOCKS FREE"

JSR to FS1SET ($C398) to set up for one file stream.

JSR to ALLDRS ($C320) to all drives needed based on F2CNT.

JSR to OPTSCH ($C3CA) to determine best sequence of drives to use.

Zero file counter, R0 ($86)

JSR to FFST ($C49D) to find the first directory entry. If not successful, branch to SC30.

JSR to TSTCHN ($DDB7) to test for active files from index table.

If file active (carry clear). branch to SC25.

Load .Y with $00.

Load .A with file type from (DIRBUF) ,Y ($94, Y).

AND the file type with $40 to test if it is a locked file (bit 6 of filetype set)

If a locked file, branch to SC25.

JSR to DELDIR ($C8B6) to delete the directory entry. Stores $00 as the file type and rewrite the sector on disk.

Load .Y with $13 (#19) .

Test whether this is a relative file by loading .A with 19th character of the entry (the track of the side-sector pointer for a REL file) from (DIRBUF) ,Y

If $00, not a REL file so branch to SC17

Store trackpointer into TRACK ($80) .

Increment Y and move sector pointer from (DIRBUF) ,Y into SECTOR ($81).

JSR to DELFIL ($C87D) to free the side sectors by updating and writing the BAM

Load .X with the directory entry counter ENTFND ($0253) and .A with $20.

AND .A with the file pattern type in PATTYP,X ($E7,X) to check if this is an opened but unclosed file.

If unclosed file, branch to SC20.

Move initial track link from FILTRK,X ($0280, X) into TRACK ($80).

Move initial sector link from FILSEC,X ($0285, X) into SECTOR ($81).

JSR to DELFIL ($C87D) to free the file blocks by updating and writing the BAM

Increment the file counter, R0 ($86).

JSR to FFRE ($C48B) to match the next filename in the command string.

If a match found, branch to SC15

All done. Store number of files that have been scratched, R0 ($86) into TRACK ($80)

Load .A with $01 and .Y with $00

Exit with a JMP to SCREND ($C1A3)

JSR to FRETS ($EF5F) to mark the first file block as free in the BAM.

JSR to OPNIRD ($D475) to open the internal read channel (SA=17) and read in the first one or two blocks.

JSR to BAM2X ($F119) to set BAM pointers in the buffer tables

Load .A from BUF0,X ($A7,X) and compare it to $FF to see if buffer inactive. If inactive (.A=$FF, branch to DEL2 ) Load write BAM flag, WBAM ($02F9). OR it, with $40 to set bit6 and store it back in WBAM to indicate both buffers active.

Zero .A and JSR to SETPNT ( $D4C8 ) to set pointers to the currently active buffer.

JSR to RDBYT ($D156) to direct read one byte (the track link from the buffer)

Store track link into TRACK ($80)

JSR to RDBYT ($D156) to direct read one byte (the sector link from the buffer)

Store sector link into SECTOR ($81)

Test track link. If not $00 (not final sector in this file). branch to DELI

JSR to MAPOUT ($EEF4) write out the BAM.

Exit with a JMP to FRECHN ($D227) to free the internal read channel.

JSR to FRETS ($EF5F) to de-allocate (free) specified in TRACK ($80) & SECTOR ($81) in the BAM.

JSR to NXTBUF ($D44D) to read in the next block in the file (use T/S link) .

JMP to DEL2 to de-allocate the new block

Load .Y with $00 (will point to the 0th character in the entry; the file type) .

Set the file type, (DIRBUF) ,Y; ($94) ,Y to $00 to indicate a scratched file.

JSR to WRTOUT ($DE5E) to write out the directory block.

Exit with a JMP to WATJOB ($D599) to wait for the write job to be completed.

Load .A with a $31 to indicate a bad command and JMP to CMDERR ($C1C8).

Store JMP $FABB ( $4C. $BB, $FA) at the start of buffer ($0600/1/2).

Load .A with $03 and JSR to SETH ($D6D3) to set up header of active buffer to the values in TRACK ($80) and SECTOR ($81) .

Load drive number, DRVNUM ($7F). EOR it with $E0 (execute job code) and store the result in the job queue ($0003) .

Load .A from the job queue ($0003). If .A > 127, the job has not been finished yet so branch back to FMT105.

Compare .A with $02. if .A < 2, the job was completed OK so branch to FMT110.

Error code returned by disk controller indicates a problem so load .A with $03 and .X with $00 and exit with a JMP to ERROR ($E60A).

Job completed satisfactorily so exit with an RTS.

Store $E0 in BUFUSE ($024F) to kill the BAM buffer.

JSR to CLNBAM ($F0D1) to settrack and sector links in BAM to $00.

JSR to BAM2X ($F119) to return the BAM LINDX in .X.

Store $FF in BUF0,X ($A7,X) to mark the BAM as out-of-memory .

Store $0F in LINUSE ($0256) to free all LINDXs.

JSR to PRSCLN ($C1E5) to parse the command string and find the colon,

If colon found (Z flag =0) ,branch to DX0000.

Colon not found in command string so command must be CX=Y. This command is not supported on the 1541 soexit with a JMP to DUPLCT ($C8C1).

JSR to TC30 ($C1F8) to parse the command string.

JSR to ALLDRS ($C320) to put the drive numbers into the file table.

Load .A with the command pattern image as determined by the parser from IMAGE ($028B). AND the image with %01010101 ($55). If the result is not $00, the command must be a concatenate or normal copy so branch to DX0020.

Check for pattern matching in the name (as in cl:game=0 :*) by loading .X from FILTBL ($027A) and then loading .A from the command string, CMDBUF,X ($0200, X).

The value in .A is compared to $2A ("*") If there is no match, there is no wild so branch to DX0020.

Load .A with the $30 to indicate a syntax error and JMP to CMDERR ($C1C8) .

Load .A with the command pattern image as determined by the parser from IMAGE ($028B). AND the image with %11011001 ($D9). If the result is not $00, the syntax is bad so branch to DX0010 and abort.

JMP to COPY ($C952) to do the file copy, syntax error and JMP to CMDERR ($C1C8).

Subroutine used to set up for copying entire disk (C1=0). Not used on 1541.