DOSPLUS 3.5 for the Model I - SYS15/SYS Disassembled

SYS15/SYS

Other Navigation

DOSPLUS 3.5 SYS15/SYS Disassembly - The Library Commands BUILD, CLEAR, CREATE, DUMP, LOAD and RENAME (Model I)

SYS15/SYS is the seventh of the high overlays: it loads at 5200H and holds six library commands, routines 3 to 8 of its table at 5200H with the request codes E3H to E8H: BUILD, CLEAR, CREATE, DUMP, LOAD and RENAME. CMNDI@ takes the codes from SYS1/SYS's table of the library commands and passes them to the overlay request handler, which loads SYS15/SYS and calls the routine with Register Pair HL at the rest of the command line. No file of the diskette requests routine 2 (E2H). The file is a load module of 7 blocks, 1751 bytes, from 5200H to 58D6H, with the transfer address 5200H and no gaps; the work area after the file starts at 58D7H. BUILD, CLEAR, CREATE, DUMP and LOAD share one evaluation block for EVAL@ (57B3H), whose three field blocks are all 58D7H, and each stores the address of its own parameter table into it; RENAME takes its two names by FSPEC@. LOAD requests 12H and 32H (routine 2 of SYS2/SYS and SYS4/SYS, which only bring the overlay in), RENAME 17H and 18H (SYS2/SYS's routines 7 and 8).

The Parts of SYS15/SYS

BUILD

BUILD (5210H) takes one field, a file or a device, and the switch APPEND. The file is opened by INIT@ with the default extension TXT (it is made when it is not there); a device by its control block from LOCDCB% (5747H). With APPEND an open file is first shown on the display to its end, so that what is typed is added after it; without APPEND the new lines are written from the start of the file. The prompt Enter text (63 chars/line) is shown, and every line taken by the ROM's 0040H, up to 63 characters, is written with its carriage return through the ROM's 001BH. BREAK ends BUILD and the file is closed (5788H).

CLEAR

CLEAR (5263H) takes START (5C00H when not given), END (the top of memory, 4049H) and DATA (0000H). Without a field the memory from START to END, both included, is filled with DATA (52ECH): the low byte at START, the high byte at the next address and so on, a value below 0100H in every byte; START below 5C00H, END above the top of memory or START above END is error 2DH. With a field it must be a file name (2CH); the file is opened by OPEN@ and every sector of it, up to its end of file, is written with the 128 words of DATA (52A2H). The file is then left open: CLEAR does not call CLOSE@, so its directory entry is not changed.

CREATE

CREATE (5325H) takes a file name (else error 2FH) and DATA, GRANS, KEEP, KILO, LRL, SIZE and VERIFY. INIT@ opens the file with the record length LRL (256 when LRL is 0 or not given) and must create it: a file that is there already is error 31H. The space (53DAH) is SIZE records of that length, or else GRANS granules (times the sectors per granule of the drive), or else KILO kilobytes (four sectors each); for GRANS and KILO the blocked records flag (bit 7 of FCB+01H) is cleared while the file is positioned, so the count is of sectors whatever the record length. POSN@ goes to the last record or sector of the space and WRITE@ writes it, which gives the file its whole space. DATA then fills every sector (52A2H) and VERIFY reads every record to the end of the file; KEEP sets the non-shrinkable bit (bit 7 of FCB+02H), and CLOSE@ closes the file. Without a size the file is made with no space, and DATA and VERIFY then have nothing to work on.

DUMP

DUMP (540BH) takes one field, a file or a device, and DATA, END, RELO, START and TRA: START is 5C00H, END the top of memory and TRA 402DH (EXIT@) when they are not given. A file name gets the default extension CMD, or CIM with DATA, and is opened by INIT@. START above END is error 2DH; neither is checked against 5C00H or the top of memory. The memory is written in pieces of up to 254 bytes: for a load module each piece gets a block header (01H, the length plus 2, the load address, which is the address plus RELO less START when RELO is given), and the transfer record 02H 02H TRA ends the file. TRA is not moved by RELO. With DATA only the bytes are written, without headers or a transfer record. The bytes go out through the ROM's 001BH (5739H) and an error there is not tested. The file is closed at the end (5788H).

LOAD

LOAD (54DDH) takes a file name (else error 2FH) and PROMPT, RUN, START and TRA (TRA 402DH when not given). No default extension is added. SYS2/SYS is brought in first (request 12H) so that OPEN@ needs no system diskette. With PROMPT the text Insert TARGET diskette (ENTER) is flashed until a key is pressed (55D2H; any key, and nothing is shown while a DO file runs), the file is opened, Insert SYSTEM diskette (ENTER) is asked for while SYS4/SYS is brought in (request 32H), and the target diskette is asked for again. With START the file is a core image: every byte goes to memory from START on, up to the end of the file (55A7H). Otherwise it is a load module (5556H): load blocks (type 01H) are loaded at their addresses, and the transfer record (02H) ends the load. With RUN the program is run; with PROMPT the system diskette is asked for first, also before an error is posted.

RENAME

RENAME (5600H) takes two specifications by FSPEC@ (the words TO and FROM are passed over); a missing one is error 2CH. Two devices (@xx) or two drives (:xx) are renamed in place (56C3H): the old name must be found by LOCDEV@, the new one must not be (error 32H), its two characters may not be wildcards (2BH), and they become the name of the entry in the DCB table (+09H) or in DCTTBL (+02H). A file and a device or drive mixed is error 2CH or 2BH. A file is opened by OPEN@, which checks its password, and an access level of 3 or above is error 25H. The new name may not carry a drive (error 20H): it is given the drive of the old file and must not be found there (31H). The directory entry is read by 490CH, its name and extension replaced by those of the new name, which OPEN@ left in SYS2/SYS's buffer 51E0H (routine 8), and written back by 4915H; then the hash index table (sector 1 of the directory) is read, the entry's byte replaced by the hash code of the new name (routine 7) and written back. The file stays open.

Differences from the Manual

BUILD does not write a line ended by BREAK: the manual says it is stored without its carriage return, but the BREAK exit closes the file at once. LOAD adds no default extension (the manual says CIM). LOAD's TRA is 402DH when it is not given and, with RUN, takes the place of the load module's own transfer address unless it is 0, so LOAD with RUN alone goes back to DOSPLUS instead of running the program (the manual says RUN runs it, like typing its name). In a load module LOAD tests the fourth byte of a record other than 01H and 02H, not its type: when that byte is 1EH or more, as the second character of a module name in a 05H comment record is, LOAD reads one more byte and ends without loading the rest and without an error. PROMPT goes on with any key, not only ENTER. DUMP checks only that START is not above END, not the limits of memory the manual gives; its own example says the transfer address of a dump without TRA is the start of the area, but the bytes give 402DH, as the manual's rule (2) says. CLEAR of a file leaves the file open. CREATE takes DATA=65535 (FFFFH) as no DATA. The GRANS abbreviation is G (the manual's table prints C).

5200H - The Routine Table

Data: SYS15/SYS's table of routines 2-8, one word each, used by SYS0/SYS's overlay request handler (its 49C9H-49DCH) for the request codes E2H-E8H. CMNDI@ takes the codes of the library commands from SYS1/SYS's table: BUILD E3H (51BFH), CLEAR E4H (51C1H), CREATE E5H (51C6H), DUMP E6H (51CBH), LOAD E7H (51D6H), RENAME E8H (51D9H). No file of the diskette requests E2H.

520EH - Routine 2

Nothing to do when SYS0/SYS's record locator brings SYS15/SYS back.

5210H - BUILD

Routine 3, entered from CMNDI@ through the overlay request handler with Register Pair HL at the rest of the command line. APPEND (table 57BCH) starts as 0000H. 5747H takes the field with EVAL@ (block 57B3H) and opens it: a file by INIT@ with the default extension TXT, a device through LOCDCB%; Register Pair DE is then the file control block or the device control block. With APPEND an open file is first shown to its end, so that the new lines follow it. Then the prompt is shown, and every line typed (up to 63 characters, by the ROM's 0040H) is written with its carriage return through the ROM's 001BH. BREAK ends BUILD and closes the file; the characters of a line ended by BREAK are not written.

5263H - CLEAR

Routine 4, entered from CMNDI@ through the overlay request handler with Register Pair HL at the rest of the command line. START (the operand 52EDH) starts as 5C00H, END (52FAH) as the top of memory HMEM$ and DATA (52A9H) as 0000H (table 57C6H). With no field the memory from START to END is filled (52ECH). With a field, which must be a file name (else error 2CH), the file is opened by OPEN@ and every one of its sectors is written with DATA (52A2H); START and END are not used then, and the file is not closed.

52A2H - Fill a File

Used by CLEAR and by CREATE's DATA (53A5H), with Register Pair DE at the open file. The buffer at 5919H is filled with 128 words of the value of DATA (the operand 52A9H; a value below 0100H is used for both bytes of the word). The file is then written sector by sector from its start: bit 7 of FCB+01H, the blocked records flag, is cleared for the writes so that every WRITE@ writes a whole sector, and put back at the end. The count is the file's ending record number at FCB+0CH-0DH, plus one when its end of file byte FCB+08H is not 00H.

52ECH - CLEAR Memory

START must not be below 5C00H, END not above the top of memory, and START not above END, else error 2DH. The bytes from START to END, both included, are filled with DATA: its low byte at START, its high byte at the next address, and so on (a value below 0100H in every byte).

5325H - CREATE

Routine 5, entered from CMNDI@ through the overlay request handler with Register Pair HL at the rest of the command line. GRANS (the operand 53EAH), KILO (53F4H), LRL (536AH), SIZE (53DBH), KEEP (53C8H) and VERIFY (53B4H) start as 0000H, DATA (52A9H) as FFFFH, the mark that it was not given (table 57E2H). The field must be a file name (else error 2FH); INIT@ opens it with the record length LRL (256 when 0) and must create it (a file that is there already is error 31H). The space (53DAH) is SIZE records, or GRANS granules, or KILO kilobytes of 4 sectors, the first of the three that was given; the file is positioned to the last record or sector of the space and that one is written, so that the whole space is given to the file. Then DATA fills it (52A2H), VERIFY reads it to its end, KEEP sets the non-shrinkable bit, and CLOSE@ closes the file.

53DAH - The Size of the Space

Register Pair BC returns the number of records or sectors to give the file, with the NZ FLAG; the Z FLAG when none of SIZE, GRANS and KILO was given. SIZE is a count of records of the file's own length. GRANS is multiplied by the sectors per granule of the drive (DCT+0FH) and KILO by 4, the sectors of a kilobyte; for these two bit 7 of FCB+01H, the blocked records flag, is cleared, so that POSN@ takes the count as sectors whatever the record length. Only the low 16 bits of the product are used.

540BH - DUMP

Routine 6, entered from CMNDI@ through the overlay request handler with Register Pair HL at the rest of the command line. DATA (54DBH) starts as 0000H, RELO (54D9H) as FFFFH, the mark that it was not given, START (54D5H) as 5C00H, END (54D7H) as the top of memory HMEM$ and TRA (54D3H) as 402DH, EXIT@ (table 5822H). 574FH opens the field: a file by INIT@ with the default extension CMD, or CIM with DATA, or a device. START must not be above END (error 2DH); neither is checked against 5C00H or the top of memory. The area is written in pieces of up to 254 bytes: for a load module each piece is a load block (01H, the length with the two address bytes, the address plus the offset RELO less START), and a transfer record (02H, 02H, TRA) ends the file; with DATA only the bytes are written. TRA is not moved by RELO. 5788H closes the file.

54C1H - Write Bytes

54C1H takes the count from the byte at Register Pair HL and writes the bytes after it; 54C3H writes Register B bytes from Register Pair HL. Each byte goes out through 5739H to the control block at Register Pair DE; the flags 5739H returns are not tested, so a write error does not stop DUMP.

54CBH - DUMP's Records and Values

Data: the header of a load block and the transfer record, each after the count of its bytes for 54C1H, and the values of DUMP's parameters, which EVAL@ stores here (table 5822H) and 540BH-5425H set first.

54DDH - LOAD

Routine 7, entered from CMNDI@ through the overlay request handler with Register Pair HL at the rest of the command line. PROMPT (the operand 551CH), RUN (55FEH) and START (55A8H) start as 0000H, TRA (5597H) as 402DH, EXIT@ (table 5850H). The field must be a file name (else error 2FH); no default extension is added. SYS2/SYS is brought in first (request 12H), so that OPEN@ needs no system diskette; with PROMPT the target diskette is asked for, the file is opened, the system diskette is asked for while SYS4/SYS is brought in (request 32H), and then the target diskette again. With START the file is a core image, loaded from START to its end (55A7H); otherwise it is a load module (5556H). With RUN the program is then run; with PROMPT the system diskette is asked for first.

5556H - Loading a Load Module

Each record starts with its type and its length; 5556H reads the type into Register C, the length into Register B and the next two bytes into Register Pair HL (the load address of a load block, the transfer address of a transfer record). Type 01H: the length less 2 bytes are loaded to Register Pair HL on (5587H). Type 02H: the end (5590H). Any other type is passed over (55A0H) only when the fourth byte of the record, still in Register A, is below 1EH: the code compares that byte, not the type. Otherwise the LD A,22H at 5572H runs on into 5574H, which reads one more byte and then RETurns from LOAD without loading the rest or posting an error (so a comment record whose second character is 1EH or more, such as the module name every DOSPLUS load module starts with, ends LOAD there). 5574H gets a byte of the file; on an error the system diskette is asked for (PROMPT) and the error is posted.

55A7H - Loading a Core Image File

With START every byte of the file goes to memory from START on, up to the end of the file (error 1CH; any other error is posted). The address to run is TRA (402DH when it is not given), used only with RUN. The end (55B7H-55D1H, also reached from the load module) asks for the system diskette when PROMPT was given, then RETurns without RUN or jumps to the address with RUN.

55D2H - Ask for a Diskette

Used by LOAD's PROMPT with Register Pair HL at a text that ends with a carriage return. Nothing is shown while a DO file runs (bit 5 of SFLAG1$). Otherwise the line is cleared and the text shown in turn, each for 500 scans of the keyboard (55F1H), until a key is pressed. The key is not tested, so any key goes on, where the text asks for ENTER.

55F1H - Scan the Keyboard

Up to 500 (01F4H) scans of the keyboard by the ROM's 002BH. Returns the NZ FLAG with the key in Register A as soon as one is pressed, or the Z FLAG after 500 scans without a key.

55FEH - RUN's Value

Data: the value of LOAD's switch RUN, which EVAL@ stores here (table 5850H) after 54E4H clears it.

5600H - RENAME

Routine 8, entered from CMNDI@ through the overlay request handler with Register Pair HL at the rest of the command line. RENAME does not use EVAL@: FSPEC@ moves the old name into the file control block 58D7H and the new name into 58F8H (the words TO and FROM are passed over); a specification it cannot take is error 2CH. Two devices or two drives (both with @ or both with a colon) are renamed in their tables (56C3H); a file with a device or a drive is error 2CH or 2BH. A file is opened by OPEN@, which checks its password, and an access level of 3 or above is error 25H. The new name may not have a drive (error 20H): it takes the old file's drive and must not be on it (error 31H). The name and extension of the directory entry are replaced by those of the new name, as OPEN@ left them in SYS2/SYS's buffer 51E0H (routine 8), and the entry's byte in the hash index table by their hash code (routine 7). The file is not closed.

56BDH - Two Requests to SYS2/SYS

56BDH requests SYS2/SYS's routine 8 (18H), which returns Register Pair HL = 51E0H, its buffer of the name and extension; 56C0H requests routine 7 (17H), which returns in Register A the hash code of the 11 characters at Register Pair HL. The overlay request handler discards the address the RST 28H pushes, so each RETurns to the caller of 56BDH or 56C0H.

56C3H - RENAME a Device or a Drive

Both names must be of one kind, @ or colon (else error 2BH). LOCDEV@ must find the old name (its error is posted) and must not find the new one (error 32H). The two characters of the new name (the second a space when there is one) may not be wildcards (error 2BH); they are stored as the name of the device's entry in the DCB table (+09H-+0AH) or of the drive's entry in DCTTBL (+02H-+03H). A third character of the new name is not looked at.

570AH - A Device's or a Drive's Table Entry

Register C: bit 3 set for a drive (bits 0-2 the drive), clear for a device (0-5). Index Register IY returns the entry: DCTTBL 43ABH plus 4 times the drive, or the DCB table 4369H plus 11 times the device. Register Pairs DE and HL are kept.

572AH - A Wildcard

Returns the Z FLAG when the character in Register A is a question mark (3FH), an asterisk (2AH) or an exclamation mark (21H), the wildcards of a wildmask.

5733H - Compare Two Addresses

Sets the flags from Register Pair HL less Register Pair DE (the Z FLAG when they are equal, the C FLAG when Register Pair HL is lower) and keeps Register Pair HL.

5739H - Put a Byte

Puts the byte in Register A to the control block at Register Pair DE through the ROM's 001BH. For a file (type 80H) the flags of 001BH are returned, for a device the Z FLAG. DUMP's 54C5H, the only caller, does not test them.

5747H - Take and Open the Field

5747H calls EVAL@ (Register Pair BC kept); 574FH checks the field it took. No field is error 2FH. A name (bit 6 of the flag byte) is opened by INIT@ with the buffer 5919H and the record length 256, after FEXT@ has added the default extension number Register C (1 TXT, 2 CIM, 3 CMD; 0 none). A drive (bit 3) is error 2BH. Any other field is a device, whose control block address LOCDCB% returns. Register Pair DE returns the file control block or the device control block.

5788H - Close the Output

Used by BUILD and DUMP: a file (type byte 80H at Register Pair DE) is closed by CLOSE@, a device is left as it is. The command then RETurns to the overlay request handler; an error of CLOSE@ is posted.

5793H - The Error Exits

Nine entries, each loading its error code into Register A: 5793H 2CH Illegal filespec, 5796H 2FH I/o field not found, 5799H 2DH Invalid data provided, 579CH 2BH Illegal devicespec, 579FH 25H Illegal access attempted to protected file, 57A2H 20H Improper drive number, 57A5H 2BH again, 57A8H 31H File already exists, 57ABH 32H Device already exists. Each LD A,n after the first is the operand of an LD BC,nn entered from the entry above it. 57ADH posts the error in Register A by ERROR@ with bit 6 set (no frame), and ERROR@ ends with ABORT@.

57B2H - Request an Overlay Routine

LOAD calls 57B2H with a request code in Register A (5518H, 5540H). The overlay request handler discards the address the RST 28H pushes, so the routine RETurns to the caller of 57B2H.

57B3H - The Evaluation Block

Data: the block that Index Register IX points to for EVAL@ (5217H, 5277H, 5340H, 5429H, 54F7H): EVAL@'s flags, the addresses of the source, destination and wildmask blocks, all the one field block 58D7H, and the address of the parameter table, which each command stores before it calls EVAL@. Each table entry is the name (6 characters), the address its value is stored to and a type byte (20H a switch, 40H a number); a 00H ends the table.

57BCH - BUILD's Parameter Table

Data: the one parameter of BUILD, APPEND, and the 00H that ends the table.

57C6H - CLEAR's Parameter Table

Data: START, END and DATA, each a number, and the 00H that ends the table.

57E2H - CREATE's Parameter Table

Data: DATA, GRANS, KEEP, KILO, LRL, SIZE and VERIFY, and the 00H that ends the table. An abbreviation picks the first entry that starts with it, so G is GRANS, K is KEEP and KI is KILO.

5822H - DUMP's Parameter Table

Data: DATA, END, RELO, START and TRA, and the 00H that ends the table. The values go into DUMP's own words 54D3H-54DCH.

5850H - LOAD's Parameter Table

Data: PROMPT, RUN, START and TRA, and the 00H that ends the table.

5875H - The Default Extensions

Data: the three extensions 576FH-5779H picks by number for FEXT@: 1 TXT (BUILD), 2 CIM (DUMP with DATA), 3 CMD (DUMP).

587EH - The Texts

Data: BUILD's prompt and LOAD's two prompts, each ended by a carriage return for DSPLY@.

58D7H - The Work Area

Not in the file: SYS15/SYS uses the memory after its last byte (58D6H) for the field block of EVAL@ and RENAME's two file control blocks, the buffer of a file's sectors and BUILD's line buffer.