TRS-80 DOS - Percom MicroDOS 2.20 for the Model I - Main File Disassembled

Main File

Other Navigation

4400H - The Start of the Main File

The boot sector copies the data bytes of 19 sectors to 4400H-55FFH and jumps to 4400H. The first instruction jumps over the texts and variables that fill 4403H-4726H to the initialization at 4727H. The eight characters MICRODOS that follow are what the boot sector checks for in the first sector.

440BH - Sign-On Text Buffer (440BH-448BH)

The text the boot sector displays when it has checked MICRODOS (its 4226H displays the first sector from 430CH, which is 440BH here), up to a 00H byte. CMD"H",A$ (4802H) replaces it with the first 128 characters of a string, a down arrow (0AH) in the string becoming 0DH, and a 00H after it (4851H); CMD"M" must follow to put the new text on the diskette. The buffer is 129 bytes, 440BH-448BH; the bytes after the 00H are not used.

448CH - Variables of the Disk Routines

The drive, track and sector of the next transfer, the length byte and data pointer of the sector, the size of a diskette, the stepping rate, the last error status, the format count, the track each drive's head is on and the sector order of a formatted track. 4492H and 4494H are the two bytes the manual tells owners of 35 track or slower drives to POKE before CMD"M" (POKE 17554,35 and POKE 17556,3).

44A5H - Auto-Type Buffer (44A5H-4525H) and Its Pointer

The characters the keyboard driver at 478FH hands to Level II BASIC as if typed, one each time BASIC asks for a key, up to a 00H byte. The initialization points 4526H at the first one (476DH). CMD"K",A$ (482BH) replaces them with the first 128 characters of a string, a down arrow (0AH) becoming ENTER (0DH), and a 00H after it (4851H); CMD"M" must follow. 129 bytes, 44A5H-4525H; the bytes after the 00H are not used.

4528H - Texts: Version and LAST SECTOR USED

The two texts of the main file that the code displays itself through the ROM's 28A7H: the version text at initialization (4761H) and the end of SAVE (4957H).

4594H - Boot Sector Image (4594H-4693H, Runs at 4200H)

A copy of the boot sector, written by CMD"M" (and CMD"I") as track 0, sector 0 of a diskette (491BH): the byte at 4594H is the length byte FEH and 4595H-4692H are its 254 data bytes; 4693H is not written from here. The rows show the code as it runs: the ROM reads the sector into 4200H-42FFH at a reset and jumps to 4200H, so every address in the comments is 394H below the address of the row (4200H for 4594H). Nothing in the main file runs these bytes where they are. The boot sector checks track 0, sector 1 for MICRODOS, loads the main file from sectors 1-19 into 4400H-55FFH and jumps to 4400H.

45A9H - Boot Sector Image: Check for MICRODOS (Runs at 4215H)

The first sector of the main file carries the eight characters MICRODOS at bytes 4-11 (its byte 0 is the length byte FFH and bytes 1-3 are the JP 4727H that becomes 4400H-4402H of the main file). They are compared with the same eight characters in the boot sector; a diskette that does not have them gets NO MICRODOS.

45BAH - Boot Sector Image: Sign-On Text and Load of the Main File (Runs at 4226H)

The text after MICRODOS in the first sector is displayed, then the data bytes of the first sector and of each sector after it are copied to 4400H upward. A sector whose length byte is FFH (255 data bytes) means more sectors follow; a sector with any other length is the last one, and the boot jumps to 4400H. On this diskette the main file is 19 sectors, track 0 sectors 1-9 and track 1 sectors 0-9, the last with the length 12H: 18 x 255 + 18 = 4608 bytes, 4400H-55FFH.

45E0H - Boot Sector Image: Read One Sector (Runs at 424CH)

Reads the sector of drive 0 named by 42DDH (track) and 42DEH (sector) into the buffer 4300H-43FFH, taking each byte from the data register when the controller shows DATA REQUEST. It returns only after a read without error, with the alternate set holding 4300H, 37ECH and 37EFH again; an error goes to DISK ERROR at 42A2H and does not return.

4609H - Boot Sector Image: Select Drive 0 and Seek (Runs at 4275H)

Selects drive 0. If the drive was not ready before the select (its motor was off), waits about one second for the motor to come up to speed. Then puts the track from 42DDH in the data register and the sector from 42DEH in the sector register and gives the Seek command with verify. Returns when the seek had no error; with an error it falls into DISK ERROR at 42A2H.

4636H - Boot Sector Image: Disk Error and No MicroDOS (Runs at 42A2H)

The two ways the boot can fail. A read or seek error displays DISK ERROR; a diskette without MICRODOS in track 0, sector 1 displays NO MICRODOS. Either way the screen is cleared, the text is displayed on the second line, and a key press resets the computer, which boots from drive 0 again.

464DH - Boot Sector Image: Give the Controller a Command (Runs at 42B9H)

Entered with the command in Register A (88H Read Sector from 4251H, 17H Seek from 4299H). Waits until the controller is not busy, writes the command and waits until the controller shows BUSY, so that the next status read belongs to the new command.

465BH - Boot Sector Image: Wait While the Controller Is Busy (Runs at 42C7H)

Reads the status until BUSY is off, selecting drive 0 again on every pass so that its motor keeps running for as long as the command lasts. Returns the last status in Register A.

4668H - Boot Sector Image: Display a Text (Runs at 42D4H)

Displays the text at Register Pair HL through the ROM, one character at a time, up to the 00H byte that ends it. Used for the sign-on text from the first sector (4226H) and for the two error texts (42ADH).

4671H - Boot Sector Image: Track and Sector Numbers and Texts (Runs at 42DDH)

The two variables of the load and the texts of the boot. The bytes up to 42FEH are the 254 data bytes the length byte at 4200H counts; 42FFH is the last byte of the sector.

4694H - Level II BASIC Vectors (Copied to 4152H-41E4H)

Level II BASIC sends the disk statements and functions and a set of hooks through 3 byte vectors at 4152H-41E4H, which the ROM fills with JP 012DH (error 23) for the 28 statements and functions and with RET for the 21 hooks. The initialization copies these 49 jumps over them (4741H-474AH). CMD, GET, PUT, LOAD, MERGE and SAVE go straight to their code; the other statements and functions MicroDOS has, and the & of a constant, go through the jump table at 4E19H; EOF, TIME$, OPEN, CLOSE, NAME and KILL keep JP 012DH. Four hooks are used (the error message hook 41A6H, USR 41A9H, NEW and END 41BBH, MID$ 41D9H) and the rest jump to the ROM's RET at 0043H. The rows run at 4152H-41E4H; nothing runs them here.

4727H - Initialization

The boot sector jumps here through 4400H. The initialization does what the ROM's own BASIC start-up (0075H-00B2H) does, without its clear screen (00B2H), with 40A0H set to 5A64H for the stack, and with three changes: the 49 vectors at 4152H-41E4H get MicroDOS's jumps; BASIC programs start at 5A01H instead of 42E9H, which leaves 5600H-59FFH for the four field buffers; and the keyboard driver is MicroDOS's auto-type driver at 478FH. It displays the version text, sets the disk variables and jumps into the ROM's MEMORY SIZE? question at 00B5H, which the first auto-typed character (ENTER) answers.

478FH - Auto-Type Keyboard Driver

The ROM calls this as the keyboard driver (4016H), through its 03C2H, each time it wants a key. It hands out the characters of the auto-type text one at a time, from the address at 4526H, as if they were typed. When it reaches the 00H that ends the text, it puts MicroDOS's keyboard scan at 47A3H in the control block in its place and reports no key; from then on the keyboard works normally. The ROM saves Register Pair BC (its 0013H), Register Pairs HL and DE and Index Register IX (its 03C2H) around the driver, so it may use them.

47A3H - Keyboard Scan with Debounce

The keyboard driver after the auto-type text is finished. It is the ROM's keyboard scan (03E3H-03FAH) with a debounce added: when a key is newly found down, it waits 1250 counts of the ROM's delay (about 18 ms) and reads the key's row again, and takes the key only when it is still down. Then it goes on in the ROM's driver at 03FBH, which works out the character. ROM version 1.3 has its own debounce at 03FBH (JP 011CH: a wait of 0500H counts and the same test), so on that ROM a key is tested twice; in the earlier Model I ROMs 03FBH goes straight on to the character (LD A,D).

47C9H - CMD Statement

Level II sends CMD (token 85H) here through its vector at 4173H, with Register Pair HL pointing past the token. CMD takes a string of one character, the letter of the command: F (format, 47F2H), I (format and write MicroDOS, 4818H), H (set the sign-on text, 4802H), K (set the auto-type text, 482BH) or M (write MicroDOS, 4841H). Any other letter gives ILLEGAL FUNCTION CALL; a string of another length gives SYNTAX ERROR. Each command needs a comma and its argument after the string.

47F2H - CMD"F": Format a Diskette

CMD"F",D formats every track of the diskette in drive D (0-3) and checks every sector (4870H). Register Pair HL points past the string "F" when the dispatcher at 47DDH jumps here.

4802H - CMD"H": Set the Sign-On Text

CMD"H",A$ copies the first 128 characters of A$ to the sign-on buffer at 440BH (4851H), where the boot sector finds it when it reads the first sector of the main file. Only the copy in memory changes; CMD"M" writes it to a diskette.

4818H - CMD"I": Format a Diskette and Write MicroDOS on It

CMD"I",D does CMD"F",D and then CMD"M",D: it formats the diskette in drive D (4870H) and writes the boot sector image and the main file to sectors 0-19 (491BH).

482BH - CMD"K": Set the Auto-Type Text

CMD"K",A$ copies the first 128 characters of A$ to the auto-type buffer at 44A5H (4851H), a down arrow (0AH) becoming ENTER (0DH). At the next boot the auto-type driver at 478FH types them. Only the copy in memory changes; CMD"M" writes it to a diskette.

4841H - CMD"M": Write MicroDOS on a Diskette

CMD"M",D writes the boot sector image (4594H) to sector 0 and MicroDOS as it is in memory, 4400H-55FFH, to sectors 1-19 of the diskette in drive D (491BH). The diskette must be formatted.

4851H - Copy a String to a Text Buffer

Used by CMD"H" (DE = 440BH) and CMD"K" (DE = 44A5H). Entered with Register Pair HL pointing at a string's descriptor (length, then address). Copies at most 128 characters to Register Pair DE, changing each 0AH (down arrow) to 0DH, and ends the copy with a 00H byte. An empty string leaves only the 00H.

4870H - Format and Check a Diskette

Used by CMD"F" and CMD"I". Formats every track of the drive at 448CH (4C91H), track 0 to (4492H) - 1, then reads every sector of every track back (48BCH). A track with sectors that do not read is stepped off and back and formatted again, then restored, sought and formatted a third time; the sectors that still do not read are added to the count at 4496H, which LOC(3) returns. A track that 4C91H cannot write at all in three tries ends the statement with CAN'T FORMAT DISK. On return 448DH-448EH hold the last track and its last sector.

48BCH - Read Every Sector of a Track

Used by the format at 4870H, entered with Register Pair HL = 448DH and Register D = the number of sectors of a track. Reads sectors 0 to D - 1 of the track at 448DH (4C6DH, which reads a sector without keeping its data) and counts those that do not read. Returns with Register Pair HL = 448DH again, 448EH = the number of sectors, Register A = the number of sectors that failed and the Z flag set when none did. Register Pair BC is kept.

48DAH - Disk Error Exits

Each entry loads Register E with a Level II error code (the error number less 1, times 2) for the ROM's error handler at 19A2H, which displays the message through MicroDOS's message list (52DEH). The first three report at once; the others first keep the controller's status (48F4H). The numbers are the ones in MicroDOS's message list at 52F1H.

491BH - Write MicroDOS to Sectors 0-19

Used by CMD"M" and CMD"I". Writes the boot sector image at 4594H as track 0, sector 0 (its first byte, FEH, as the length byte), then the main file 4400H-55FFH, 4608 bytes, as a chain of sectors starting at track 0, sector 1 (4968H): 18 sectors of 255 bytes and one of 18 bytes, sectors 1-19.

4941H - SAVE Statement

Level II sends SAVE (token ADH) here through its vector at 41A0H. SAVE DSSSS writes the BASIC program, from the start of the program (40A4H) to the start of the variables (40F9H), as it is in memory, as a chain of sectors from drive D, sector SSSS (4968H): every sector but the last holds 255 bytes, the last fewer (none when the program is a multiple of 255 bytes long). Nothing checks what the sectors held before. Then it displays LAST SECTOR USED = and the DSSSS number of the last sector written.

4968H - Write a Chain of Sectors

Used by SAVE (4954H) and by the write of MicroDOS (493DH). Entered with Register Pair DE = the address of the data and Register Pair HL = its length, and with 448CH-448EH naming the first sector. Writes full sectors of 255 bytes, stepping to the next sector after each one (498FH), while 255 or more bytes are left; then writes the last sector with the bytes that are left (fewer than 255, or none) and returns from 559EH through 4977H. The length byte of each sector tells the boot sector, LOAD and MERGE whether another sector follows (FFH) or not.

4977H - Write the Last Sector of a Chain

Reached from 559EH (55A4H) with Register Pair HL = the bytes left, fewer than 255, after that routine has taken its own return address off the stack, so the RET here returns to the caller of 4968H.

497DH - Write One Sector of a Chain

Entered with Register C = the number of data bytes (the length byte), Register Pair DE = their address and Register Pair BC = the same number (B = 00H). Writes the sector at 448CH-448EH (4BF6H). Returns with Register Pair HL reduced by Register Pair BC and Register Pair DE moved on by it.

498FH - Step to the Next Sector

Moves 448DH-448EH to the next sector: the next sector of the same track, or sector 0 of the next track after the last sector of a track. Register Pairs HL and DE are kept. It was meant to report DISK OVERFLOW past the last track, but the test at 49A0H compares the wrong value: Register A still holds the number of sectors of a track (0AH), which is always below the number of tracks (28H), so the track number goes on past the last track and the error at 49A3H is not reached.

49AEH - LOAD Statement

Level II sends LOAD (token A7H) here through its vector at 4188H. LOAD DSSSS or LOAD DSSSS,R reads the chain of sectors that starts at drive D, sector SSSS into memory from the start of the BASIC program (40A4H) up, after a NEW; ,R then runs the program. Before each sector the address is checked against the stack (558CH): a program that does not fit gives OUT OF MEMORY after another NEW, so no part of it stays in memory.

49F6H - MERGE Statement

Level II sends MERGE (token A8H) here through its vector at 418BH. MERGE DSSSS reads a program saved by SAVE from the chain at drive D, sector SSSS, one line at a time (4A4AH), and puts each line into the program in memory the way the ROM does with a line typed in: a line with the same number is replaced. It ends at the 00H 00H that ends the saved program, in the ROM's READY. A line that does not fit gives OUT OF MEMORY (the ROM's 1955H); the lines merged up to then stay.

4A4AH - Read One Line of a Saved Program

Used by MERGE. Takes the bytes of the saved program one at a time from the chain of sectors (4A6CH): the link (2 bytes), and when it is 0000H the end of the program (returns Z); otherwise the line number (2 bytes, into Register Pair DE) and the text of the line up to and including its 00H byte, into the keyboard input buffer at (40A7H). Returns NZ with Register Pair BC = 4 + the number of text bytes with the 00H, the length the line takes in memory.

4A6CH - Fetch the Next Byte of a Chain

Used by MERGE through 4A4AH. Returns the next data byte of the chain of sectors in Register A, reading the next sector (4A82H) when the one in the buffer is used up. 448FH counts the bytes left in the buffer; 4490H points at the next one. Register Pair HL is kept.

4A82H - Read the Next Sector of a Chain

Used by 4A6CH. If the sector last read was a full one (its length byte at 4300H is FFH), reads the sector at 448CH-448EH into 4300H-43FFH, sets 448FH to its length byte and 4490H to 4301H, and when it is full itself steps 448DH-448EH on to the next sector (498FH). If the last sector read was not full, the chain has no more sectors: it stores 00H at 4301H and returns 01H, so that one more byte is fetched from wherever 4490H points. A last sector with the length 00H does not come here when it is read: it is read through 4A8BH (the sector before it was full), 4A9FH returns 00H, and 4A73H makes the bytes left FFH, so the next 255 fetches take the old bytes of the buffer from 4301H on. Returns the number of bytes now in the buffer in Register A. Register Pairs HL, DE and BC are kept.

4AAEH - GET Statement

Level II sends GET (token A4H) here through its vector at 417FH. GET A$,DSSSS reads drive D, sector SSSS into the string variable A$, which gets the sector's data bytes and their number as its length; GET #N,DSSSS reads it into field buffer N (1-4), whose first byte takes the length. A string that is shorter than the data is given new string space first.

4AE4H - PUT Statement

Level II sends PUT (token A5H) here through its vector at 4182H. PUT A$,DSSSS writes the characters of A$, with its length as the length byte, to drive D, sector SSSS; PUT #N,DSSSS writes field buffer N (1-4) with its length, the first byte of the buffer, as the length byte.

4AFBH - Evaluate a DSSSS Expression

Used by SAVE, LOAD, MERGE, GET and PUT. Evaluates the expression at Register Pair HL, makes it an integer, and splits it (4B10H) into the drive (the ten thousands, 0-3) and the sector number, which becomes a track and a sector of that track. Register Pairs DE and BC are kept; Register Pair HL comes back past the expression.

4B10H - Split a DSSSS Number

Entered with the DSSSS number in Register Pair HL. The ten thousands are the drive (4B49H stores its select bit at 448CH); the rest, SSSS, is divided by the sectors of a track (4493H) into a track (448DH) and a sector (448EH). A track past the last one ((4492H) tracks) gives INVALID SECTOR NUMBER. A number from -22768 to -1 is taken as drive 0, track 0 and sector (the low byte of the number). For -32768 to -22769 the subtraction of 10000 overflows to a positive result, so the loop counts on (-30000 gives drive 3 with 5536 left, INVALID SECTOR NUMBER); the sector loop overflows the same way for -32768 to -32759.

4B3FH - Evaluate a Drive Number

Used by CMD"F", CMD"I" and CMD"M". Evaluates the expression at Register Pair HL as a number 0-255 (INVALID DRIVE NUMBER above 255 or below 0), then 4B49H checks it and stores the drive's select bit at 448CH.

4B49H - Store the Drive's Select Bit

Entered with a drive number in Register A (from 4B1DH or 4B48H). A drive above 3 gives INVALID DRIVE NUMBER; otherwise its select bit (01H, 02H, 04H or 08H for drives 0-3) is stored at 448CH.

4B59H - Find the Data of GET and PUT

Used by GET (4AAEH) and PUT (4AE4H). Entered with the first character after the token in Register A and Register Pair HL on it. For #N (a field buffer, 1-4) it returns Register Pair DE = the buffer's address (5600H, 5700H, 5800H or 5900H, whose first byte is its length), 4490H = the address after it and Register C = FFH, the room in a buffer. For a string variable it returns Register Pair DE = its descriptor, 4490H = the address of its characters and Register C = its length.

4B7FH - Read a Sector and Copy Its Data

Used by LOAD (49D0H). Reads the sector at 448CH-448EH (4B8CH) and copies its data bytes to the address at 4490H (4BB4H). Register Pairs HL, DE and BC are kept.

4B8CH - Read a Sector

Reads the sector at 448CH-448EH into the buffer 4300H-43FFH and stores its length byte (byte 0) at 448FH. Three reads (4BC4H) are tried; if all fail, the head is stepped in and back out and three more are tried; if those fail, the head is restored to track 0, the track is sought again and three more are tried. If those fail too, DISK READ/WRITE ERROR.

4BB4H - Copy a Sector's Data

Copies the data bytes of the sector in the buffer, as many as its length byte at 4300H says, from 4301H to the address at 4490H. A length of 00H copies nothing.

4BC4H - Read a Sector, Three Tries

Gives the Read Sector command up to three times (4BCDH). Returns with the Carry flag clear after a read without error, set when all three failed.

4BCDH - Read a Sector Once

Gives the Read Sector command to the drive selected and sought by 4D44H and stores each byte in the buffer through Register Pair BC' (4300H), taking it from the data register whenever the status shows DATA REQUEST. Returns with the Carry flag clear when the status has no error bit (NOT READY, RECORD NOT FOUND, CRC ERROR, LOST DATA); otherwise stores the status at 4495H and returns with the Carry flag set.

4BF6H - Write a Sector

Writes the sector at 448CH-448EH: byte 0 is the length byte from 448FH, then that many data bytes from the address at 4490H, all put in the buffer at 4300H first. The whole 256 byte buffer is written, so the bytes past the data are whatever the buffer held. The test for a write protected diskette reads bit 6 of the status at 37ECH: it is WRITE PROTECT only when 4D44H has just given a Restore or Seek. When the head was already on the track, the status is that of the last command (usually the read that checked the last write, whose bit 6 is a data mark bit), and a protected diskette then fails every write and ends in DISK READ/WRITE ERROR instead. Three writes, each followed by a read to check it, are tried (4C36H); if all fail, the head is stepped in and back out and three more are tried; then the head is restored to track 0, the track sought again and three more tried. If those fail too, DISK READ/WRITE ERROR. Register Pairs HL, DE and BC are kept.

4C36H - Write a Sector, Three Tries

Writes the buffer to the sector (4C44H) and reads the sector back (4C6DH) up to three times. Returns with the Carry flag clear when a write and the read after it were both without error, set when all three tries failed.

4C44H - Write a Sector Once

Gives the Write Sector command to the drive selected and sought by 4D44H and writes the bytes of the buffer through Register Pair BC' (4300H), one each time the status shows DATA REQUEST. Returns with the Carry flag clear when the status has no error bit (NOT READY, WRITE PROTECT, WRITE FAULT, LOST DATA); otherwise stores the status at 4495H and returns with the Carry flag set.

4C6DH - Read a Sector Back to Check It

Used after each write (4C3DH) and by the check of a formatted track (48C9H). Gives the Read Sector command and takes every byte from the data register without keeping it. Returns with the Carry flag clear when the status has no error bit (NOT READY, RECORD NOT FOUND, CRC ERROR, LOST DATA); otherwise stores the status at 4495H and returns with the Carry flag set.

4C91H - Format One Track

Used by the format at 4870H. Selects the drive at 448CH and seeks the track at 448DH (4D44H); bit 6 of the status then gives DISK WRITE PROTECTED, when 4D44H has given a Restore or Seek (otherwise the status is the last command's, as at 4BFFH). Then gives the Write Track command and feeds the controller the whole track, one byte each time it shows DATA REQUEST: a gap of 14 FFH, and for each of the (4493H) sectors, in the order of the table at 449BH: six 00H, the ID mark FEH, the track, side 00H, the sector number, size code 01H (256 bytes), the CRC (F7H), 12 FFH, six 00H, the data mark FBH, the length byte 00H (an empty sector) and 255 E5H, the CRC and 12 FFH; then FFH until the track ends. The controller ends the command at the index hole; a track that ends early or a status with any bit set is written again, three times in all, and then gives CAN'T FORMAT DISK. Register Pairs HL, DE and BC are kept. The main register set keeps the tries (C), the sectors left (B) and the pointer into the sector table (HL); the alternate set sends the bytes (B' count, C' byte, DE' 37ECH, HL' 37EFH).

4D44H - Select, Seek and Set the Sector

Used before every sector transfer and before formatting a track. Finds the drive's entry in the table of head positions at 4497H-449AH (INVALID DRIVE NUMBER when no select bit is set), loads the alternate set with 4300H, 37ECH and 37EFH, selects the drive (4DF6H), puts the drive's head position in the track register, restores the head first when it is not known (FFH), seeks the track at 448DH when the head is elsewhere, and puts the sector at 448EH in the sector register. Returns with Register Pair HL = 4300H, Register Pair DE = the data pointer from 4490H and 00H at 4495H.

4D89H - Seek the Track, With a Restore if Needed

Seeks the track at 448DH (4D97H). If the seek fails, restores the head to track 0 and seeks again; if that fails too, DISK SEEK ERROR.

4D97H - Seek the Track

Gives the Seek command to the track at 448DH, with the stepping rate bits from 4494H and without verify, and waits until it is done (4DBCH). Returns the Carry flag clear when the status after it has none of the bits 7 (NOT READY), 4 (SEEK ERROR) and 3 (CRC ERROR), set otherwise; without verify only NOT READY can be set.

4DACH - Restore the Head to Track 0

Gives the Restore command with the stepping rate bits from 4494H and waits until it is done (4DBCH). It succeeds when the status after it shows TRACK 0 (bit 2) and none of the bits 7 (NOT READY), 4 (SEEK ERROR) and 3 (CRC ERROR); otherwise DISK SEEK ERROR.

4DBCH - Give a Command and Wait Until It Is Done

Entered with a command in Register A: gives it (4DE3H) and then waits until the controller is not busy (4DBFH). Returns the last status in Register A.

4DBFH - Wait Until the Controller Is Not Busy

Reads the status through Register Pair DE' (37ECH) until BUSY is off, selecting the drive at 448CH again on every pass so that its motor keeps running, and storing each status at 4495H. After 65536 passes with BUSY still on, it ends the command (D0H) and reports DISK MISSING OR DOOR OPEN. Returns the last status in Register A; Register Pair BC is kept.

4DE3H - Give the Controller a Command

Entered with a command in Register A. Selects the drive (4DF6H), waits until the controller is not busy (4DBFH), writes the command to 37ECH through Register Pair DE' and waits until the controller shows BUSY, so that the next status read belongs to the new command.

4DF6H - Select the Drive

Writes the drive select bit from 448CH to the latch at 37E1H. If the status read before that showed NOT READY (the motor was off), it waits about 0.59 second for the motor to come up to speed (65536 passes of a two instruction loop), then selects the drive again. On that path a select bit of 00H gives INVALID DRIVE NUMBER (4D52H catches it first in practice). Register Pair BC is kept.

4E19H - MicroDOS Jump Table

Most of the vectors at 4152H-41E4H (copied from 4694H) that MicroDOS uses jump into this table, which jumps on to the code (CMD, GET, PUT, LOAD, MERGE and SAVE go straight to theirs); 4E46H and 4E52H are entries the main file itself uses (4B5DH, 495DH). One JP per entry.

4E5BH - Empty the Four Field Buffers

Reached through the hook at 41BBH, which the ROM calls from 1B8CH and 1DB0H: after NEW, RUN, CLEAR, END, CLOAD, every program line typed in or deleted (1AEFH), and MicroDOS's own LOAD and MERGE (49C3H, 49E6H, 4A42H). Sets the length byte of each field buffer (5600H, 5700H, 5800H, 5900H) to 00H; the data in them stays.

4E66H - Evaluate a Field Buffer Number

Used by GET and PUT (through 4E46H), DEF FIELD (4E7FH) and FIELD (4ECBH). Entered with Register A = the character at Register Pair HL. Skips a # if there is one, evaluates the number (1-4) and returns Register Pair DE = the address of that field buffer, 5600H + (number - 1) x 100H. A number outside 1-4 gives INVALID FIELD BUFFER NUMBER; one above 255, ILLEGAL FUNCTION CALL. LOF enters at 4E6EH with the number in Register A.

4E7EH - DEF FIELD Statement

DEF FIELD #N,W1 AS V1$,W2 AS V2$,... (reached from DEF at 5081H with Register Pair HL on the FIELD token). Points the string variables at consecutive pieces of field buffer N: each variable's descriptor gets the width as its length and the address in the buffer. The widths may add up to 255 at most (FIELD OVERFLOW). When they add up to more than the buffer's length byte, the length byte is raised to their sum.

4EC0H - FIELD LOAD and FIELD SAVE Statements

Level II sends FIELD (token A3H) here through its vector at 417CH, with Register A = the character after it. FIELD LOAD #N USING S$ (LOAD token A7H) copies the string S$ (any string expression) into field buffer N and sets the buffer's length to the string's length. FIELD SAVE #N USING V$ (SAVE token ADH) copies field buffer N, as many bytes as its length, into the string variable V$, giving V$ new string space when it is shorter. The string is the data itself: nothing is read from or written to the diskette. Anything else after FIELD is a SYNTAX ERROR.

4F12H - MKI$, MKS$ and MKD$

Level II sends MKI$, MKS$ and MKD$ here (vectors 416AH, 416DH, 4170H) with the argument in the ROM's accumulator. The number is made the type of the function (integer, single or double precision) and its 2, 4 or 8 bytes become the characters of a new string, the function's result.

4F2DH - CVI, CVS and CVD

Level II sends CVI, CVS and CVD here (vectors 4152H, 4158H, 415EH) with a string in the ROM's accumulator. Its first 2, 4 or 8 characters are taken as the bytes of an integer, a single or a double precision number, the function's result. A string shorter than that gives ILLEGAL FUNCTION CALL; a longer one is accepted, its first bytes used.

4F4CH - LSET and RSET Statements

Level II sends LSET and RSET here (vectors 4197H, 419AH). LSET V$=S$ and RSET V$=S$ copy S$ into the characters V$ already has (a field of a buffer, after DEF FIELD), without changing V$'s length or address: LSET puts S$ at the left and fills the rest with spaces, RSET puts spaces first and S$ at the right. A longer S$ is cut to V$'s length.

4F8FH - LSET: Spaces After the Characters

Entered with Register B = the number of spaces, Register C = the target's length, Register Pair DE = the target's characters. When there are spaces, sets Register C to the number of characters to copy (the length less the spaces) and stores the spaces at the end of the target; Register Pair DE still points at its start. Returns at once with Register C unchanged when there are none.

4FA6H - RSET: Spaces Before the Characters

Entered like 4F8FH. When there are spaces, sets Register C to the number of characters to copy and stores the spaces at the start of the target, leaving Register Pair DE after them, where the characters go. Returns at once when there are none.

4FB4H - LOC Function

Level II sends LOC here through its vector at 4164H, with the argument in the ROM's accumulator. LOC(0): the DSSSS number of the last sector used; LOC(1): the highest sector number of a diskette, (4492H) x (4493H) - 1 = 399; LOC(2): the last controller status kept at 4495H (the wait at 4DD0H stores it after every command, so after a disk error it is the error's status, and after a good transfer that transfer's final status); LOC(3): the number of sectors the last format could not verify (4496H). Any other argument gives ILLEGAL FUNCTION CALL. The result is an integer.

5010H - LOF Function

Level II sends LOF here through its vector at 4167H. LOF(N) returns the length byte of field buffer N (1-4): set by GET (the bytes read), by FIELD LOAD (the string's length), raised by DEF FIELD to the sum of its widths, and set to 00H by the hook at 41BBH (4E5BH).

501DH - LINE INPUT Statement

Level II sends LINE (token 9CH) here through its vector at 41A3H. LINE INPUT "prompt";V$ displays the prompt, if there is one, reads a whole line from the keyboard, commas and quotes included, and assigns it to the string variable V$. BREAK stops the program.

503EH - Hexadecimal Constants (&H)

The ROM's expression evaluator sends a & here (24C8H, through the vector at 4194H) with Register Pair HL on it. &H followed by hexadecimal digits (0-9, A-F) gives an integer from the low 16 bits: FFFFH is -1. Digits that would go past 16 bits give OVERFLOW. The constant ends at the first character that is not a hexadecimal digit.

507AH - DEF Statement: DEF FN

Level II sends DEF (token B0H) here through its vector at 415BH, with Register A = the token or character after it. DEF USR goes to 518FH and DEF FIELD to 4E7EH. Otherwise this is DEF FNname(parameters)=expression: the definition is kept by storing the address of its text in a variable whose name is the function's name with bit 7 of its first letter set, so it cannot clash with an ordinary variable; FN (5092H) finds it there. The rest of the statement is skipped. DEF FN is not allowed as a direct command (ILLEGAL DIRECT).

5092H - FN: Call a DEF FN Function

Level II sends the FN token here from its expression evaluator (2524H, vector 4155H), with Register Pair HL on the token. Finds the definition (FUNCTION DEFINITION ERROR when there is none). When it has parameters, their variables are saved on the stack (50F0H), the arguments of the call are assigned to them (514CH), the expression of the definition is evaluated, and the variables get their old values back (5130H). The result is made the type of the function's name. For a string result the code copies the string's descriptor to 40D3H (50D0H-50D8H), but the accumulator (4121H) still points at the result's own descriptor, so nothing uses the copy: when the result is a parameter's string (DEF FNA$(X$)=X$, say), giving X$ its old value changes the result.

50E4H - Find a Function's Variable

Used by DEF FN (5087H) and FN (5092H). Checks for the FN token at Register Pair HL and finds (or makes) the simple variable whose name is the function's name with bit 7 of the first letter set. Returns Register Pair DE = the address of its value and Register Pair HL past the name.

50F0H - Save the Parameters of a Function

Called from 50AAH with Register Pair HL on the ( of the definition. For each parameter name it finds (or makes) the variable and pushes its value on the stack: a number's 2, 4 or 8 bytes a word at a time, then the address after them, then the type; a string's descriptor is copied to the temporary descriptors (the ROM's 2888H) and its address and type are pushed. A 00H mark goes first and a 29H mark last. Because it leaves these on the stack, it takes its return address into Index Register IX and returns with JP (IX).

5130H - Give the Parameters Their Old Values

Called from 50DDH with the parameters' saved values on the stack (50F0H). Pops them one parameter at a time, restoring each number's bytes and each string's descriptor, until the 00H mark. Register Pair HL (the text pointer) is kept in the alternate set meanwhile; returns with JP (IX).

514CH - Assign the Arguments to the Parameters

Called from 50ADH. Takes the arguments of the call (the text at 40F3H, after the name) and the parameter names of the definition (the text at 40D8H, after the () in step, and assigns each argument to its parameter through the ROM's LET (1F2BH), changing its type as needed. Returns with Register Pair HL on the expression of the definition (past its = token) and the text pointer of the call, past its ), on the stack.

517BH - Take the Last Temporary String Descriptor

Entered with Register Pair HL = where a descriptor goes (40D3H, or a parameter's descriptor). Takes the last of the temporary descriptors (the ROM's 29F5H finds it at (40B3H) - 3), removes it from the list by lowering 40B3H, and copies its length and address to Register Pair HL.

518AH - FUNCTION DEFINITION ERROR

Reached from FN when the function was never defined (50A2H) or its definition has no ( (5158H, which cannot be reached: 514CH is only called after 50A6H has found the ( at 40D8H).

518FH - DEF USR Statement

DEF USRn=address (from DEF at 507CH): stores the address in the entry of USRn (n = 0-9, 0 when no digit follows) of the table at 5578H, which USR (519EH) jumps through.

519EH - USR: Call a Machine Language Routine

Reached through the USR hook at 41A9H, which the ROM calls at 27FEH with Register Pair HL on the USR token. Takes the ROM's return address off the stack, so the ROM's own USR does not run. Evaluates the argument in parentheses and jumps to the address in the table entry of USRn (5578H), with Register A = the argument's type, Register Pair DE = 4121H (the accumulator) or, for a string, the address of its descriptor, and Register C = n. The routine returns to the ROM's 26E7H, which restores the text pointer. An entry never set holds 1E4AH: ILLEGAL FUNCTION CALL.

51C9H - Find the USR Table Entry

Used by DEF USR and USR. Fetches the character after the USR token; a digit selects that entry, anything else entry 0. Returns Register Pair DE = 5578H + the digit times 2 and Register Pair BC = the digit times 2.

51DBH - MID$ Statement

The ROM's statement dispatcher sends a statement that starts with a token of BCH or above to 2AE7H (its 1D67H), which checks for MID$ (FAH) and jumps through the hook at 41D9H (its 2AECH), with Register Pair HL on the token. MID$(V$,N,M)=S$ replaces characters of V$ from position N on with characters of S$: at most M (when M is given) and at most as many as S$ has; V$ keeps its length, and the replacement stops at its end. N must be 1 to the length of V$, and M 1 to the characters left from N; otherwise ILLEGAL FUNCTION CALL. Before changing V$, the code meant to make sure its characters lie in string space, and copies them there otherwise; the test reads the wrong bytes (51E6H), two bytes of the BASIC text after the comma. With a digit or a letter there it copies, which does no harm. When the second byte is a token of 80H or above (MID$(A$,X+1,...): CDH) and string space starts below that address, the copy is skipped, and a V$ that still points into the program text is changed in place.

5257H - INSTR Function

Level II sends INSTR (token C5H) here from its expression evaluator (2506H, vector 419DH), with Register Pair HL on the token. INSTR(N,S1$,S2$) or INSTR(S1$,S2$) returns the position of the first S2$ in S1$ at or after position N (1 when N is left out), or 0 when there is none, when S2$ is empty, when N is past the end of S1$ or when S2$ is longer than what is left of S1$. N = 0 gives ILLEGAL FUNCTION CALL.

52DEH - Error Messages

The ROM calls the hook at 41A6H (its 19ECH) before it displays an error as a question mark and a two letter code. MicroDOS takes that path over: it finds the full message for the error number in its list at 52F1H and jumps into the ROM at 1A01H, which displays it, then IN and the line number for an error in a program line, and READY. So every error, those of BASIC too, is displayed in words, without the question mark and without the word ERROR the ROM would add after the code.

52F0H - Error Message List

The messages of errors 1-35, each ended by a 00H byte, in the order of the Level II error codes (code = (number - 1) x 2): 1-23 are Level II BASIC's own errors, 24-35 MicroDOS's. 52DEH counts 00H bytes from 52F0H to find a message.

5578H - USR Address Table

Ten addresses, one for each of USR0-USR9, which DEF USRn stores (518FH) and USR jumps through (519EH). As written by CMD"M" they all hold 1E4AH, the ROM's ILLEGAL FUNCTION CALL, so a USR that was never defined reports that error.

558CH - LOAD: Set the Data Pointer and Check Memory

Called by LOAD (49CDH) before each sector, with Register Pair HL = where the sector's data goes. Stores it at 4490H and checks that it lies at least 256 bytes below the stack. If it does not, the program does not fit: NEW clears what was loaded so far and OUT OF MEMORY is reported, so no part of the program stays in memory. Register Pair DE is kept.

559EH - Chain Write: Is This the Last Sector?

Called by the chain write at 4969H with Register A = the high byte of the bytes left and Register Pair HL = the bytes left. Returns when 255 or more are left, so that a full sector is written. Otherwise it drops its own return address and jumps to 4977H, which writes the last sector with the bytes left and returns to the caller of 4968H.

55A7H - GET: New String Space for the Variable

Called by GET (4ACDH) with Register A = the number of data bytes and Register Pair DE = the variable's descriptor, when the variable is shorter than the data. Sets the variable's length to 00H, so that the garbage collection the ROM may do while finding space does not keep its old characters, and gets new string space for Register A bytes through the ROM's 2857H.

55AEH - LOAD: Out of Memory

Reached from 559AH when a program does not fit.

55B4H - Bytes Not Used (55B4H-55FFH)

The last 76 bytes of the main file: 55B4H-55EDH come from the 18th sector, 55EEH-55FFH from the 19th. No code reads or runs them. On this diskette they are a piece of assembler source text.