DOSPLUS 3.5 for the Model III - PATCH/CMD Disassembled

PATCH/CMD

Other Navigation

DOSPLUS 3.5 PATCH/CMD Disassembly - Patching Load Modules (Model III)

PATCH/CMD changes a program file in load module form, run from the DOS command level as PATCH filespec1 filespec2 (the patch lines from a patch file), PATCH filespec1 (the lines from the keyboard) or PATCH filespec1 patname (KILL) (a patch taken out again); its heading reads PATCH - DOSPLUS Patch Utility - 3.50. It is a load module of 6 blocks, 1236 bytes, at 5200H-56C9H and 59D1H-59DAH, with the transfer address 5200H, after the two comment records (the name PATCH and the copyright notice). PATCH/CMD is on the Model III master only.

PATCH never changes a byte of the program's own records. Each patch line A=address,F=find,C=change becomes a type 01H load record of the new bytes at the address; the records of one run are written in front of the transfer record, behind a type 07H record that holds the patch's 8 character name, and a new transfer record follows. When the program loads, the new bytes come last and lie over the old ones. To take a patch out, KILL drops its 07H record and the 01H records after it, and the program loads as before. The second block of the file, at 59D1H, is the 07H record itself with the name used for keyboard patches; the records of the patch are built on from 59DBH.

The Parts of PATCH/CMD

How PATCH Works

The module (the first field, which must be a file name) is opened with records of one byte, so that BKSP@ can step back over single bytes (521DH). With a second field the patch file is opened, and its name up to a slash, a period or a colon becomes the patch's name; without one the lines are typed after an asterisk, BREAK ending them, and the name stays NONAME between two asterisks (5494H). A line from the file may be 64 bytes, a typed one 63 characters; a line starting with a period is a comment.

In a line, A=, F= and C= may stand in any order: each is found by scanning the whole line for the letter directly followed by the equal sign (54FBH). The address is a number whose last letter picks the base, B, O, H, or decimal for D or none (555EH); F and C are strings in single or double quotation marks, or pairs of hexadecimal digits with spaces allowed between pairs (5511H). For each line the module is read from its start, byte by byte with the load address of each (5428H), until the byte that loads at the address: none, and Address not found ends PATCH; then the bytes from there must equal F (an empty F tests nothing), else String not found. Either message ends PATCH by ABORT@ before anything is written, so the patch is installed whole or not at all. The new record is added in memory (52C9H).

After the last line the module is read to its transfer record, set back onto its four bytes, and the name record, the new records and the transfer record are written there; CLOSE@, Patch(es) installed (52EFH). With KILL the second field names the patch (5342H): its 07H record is looked for up to the transfer record (53D8H), Patch not found otherwise. A second file control block reads on from after the name record while the first, set back ten bytes onto it, writes: the 01H records that follow are dropped, and everything from the next record on is copied down; CLOSE@, Patch removed.

Differences from the Manual

The manual gives KILL alone; the parameter table has five names for the same switch, PULL, REMOVE, KILL, OUT and YANK. It does not say that a patch run with no patch line is the error Terminated, that a line longer than 64 bytes is Invalid data provided, that an odd last hexadecimal digit is dropped, that the F test follows the bytes as the module loads them without looking at where a new record starts, or that KILL removes the first patch of the name, taking all the 01H records up to the next other record with it. The manual's own example line C =760000, with a space before the equal sign, is refused as Invalid parameter, and its address 7E3D, with no H, is the decimal 7.

A C string that is empty (C=) makes a count of 0000H for the LDIR that copies the new bytes into the record (52E6H), and LDIR with a count of 0000H copies 65536 bytes, over the whole of memory. The patch is built upwards from 59DBH with no test of its size.

5200H - PATCH

PATCH/CMD's transfer address, entered from the DOS command level with Register Pair HL at the command line after the word PATCH: PATCH filespec1 [filespec2], or PATCH filespec1 patname (KILL). PATCH changes a load module without touching its own records: each patch line (A=address,F=find,C=change) becomes a type 01H record with the new bytes, and the set of them is written before the transfer record behind a type 07H record that names the patch, so the loader puts the new bytes over the old ones. KILL removes a named patch by dropping its 07H record and the 01H records after it.

521DH - Open the Module

The first field must be a file specification (bit 6, a name), else the error 2CH. The module is opened with records of one byte, so that BKSP@ moves back one byte. KILL (or PULL, REMOVE, OUT, YANK) goes to 5342H; with a second field the patch file is opened and its name, up to 8 characters before a slash, period or colon, becomes the name of the patch at 59D3H; without one the lines come from the keyboard and the name stays NONAME between two asterisks.

527CH - Each Patch Line

5494H takes the next line (from the patch file or the keyboard) and its A, F and C values; the C FLAG ends the lines. The module is read again from its start, byte by byte with the load address of each (5428H), until the address A; the transfer record first is Address not found. The bytes from there must equal the F string, else String not found; both end PATCH by ABORT@, with nothing written. Then a type 01H record with the C bytes at address A is added to the patch at (56C7H).

52EFH - Write the Patch

No line at all is the error 30H. The module is read to its transfer record, whose address goes into the record at 56C3H, and set back four bytes onto it; the patch (the 07H name record at 59D1H and the 01H records) and then the transfer record are written there, and CLOSE@ ends the module: Patch(es) installed.

5342H - KILL, Remove a Patch

The second field is the patch's name: its text is cut at a slash, period or colon and padded with spaces to 8 characters in place. 53D8H finds its 07H record; not found is Patch not found. A second file control block (57B1H, with its own buffer 58D1H holding a copy of the first's) reads on from after the name record, while the first is set back the 10 bytes of the record and writes: the 01H records of the patch are dropped, and the rest of the file, from the next record on, is copied down. Patch removed.

53D8H - Find a Patch Record

Reads the records of the module at Register Pair DE: a 07H record is compared byte for byte with the 8 character name at Register Pair HL (the Z FLAG when equal); the transfer record (02H) returns the NZ FLAG; other records are passed over.

5414H - Compare, Write and Read a Byte

5414H compares Register Pair HL with Register Pair DE (the Z FLAG when equal). 541AH writes Register A to the control block at Register Pair DE by 001BH, 5421H reads one by 0013H; an error goes to 55DBH.

5428H - The Next Byte of the Load Module

Index Register IX = 56C9H: +00H the flags (bit 0 inside a record, bit 1 a load or transfer record, bit 2 the transfer record), +01H the bytes left, +02H-+03H the address of the next byte. At the start of a record its type (20H or more is the error 22H), length and the two bytes after it are read. Returns the C FLAG with Register A = the next byte and Register Pair HL = its load address (0000H in a record that is not loaded), or at the transfer record the NC FLAG with Register Pair HL = the transfer address.

5494H - The Next Patch Line

From the patch file (57B1H is 80H once it is open): up to 64 bytes into 56CDH, to the 0DH (longer is the error 2DH); the end of the file returns the C FLAG. From the keyboard: an asterisk and up to 63 characters; BREAK returns the C FLAG. A line starting with a period is a comment. Then A= (a number), F= and C= (strings) are found, each anywhere in the line, and taken into 570DH, 570FH and 574FH; a missing one is the error 2EH.

54FBH - Find a Letter and the Equal Sign

Register B = the letter: scans the line for it, upper case or lower case, directly followed by =; Register Pair HL returns after the equal sign. Reaching the 0DH is the error 2EH, Invalid parameter.

5511H - A String

Register Pair HL = the value, Register Pair DE = the place: a string in single or double quotation marks is copied as it is up to the closing mark or the 0DH (5545H); otherwise pairs of hexadecimal digits make bytes, spaces between pairs passed over, up to the first other character (a single last digit is dropped). The count goes to the first byte at Register Pair DE.

555EH - A Number

Register Pair HL = the number: its last character before a space, a comma or the end picks the base (B binary, O octal, H hexadecimal, anything else decimal), then the digits are taken from the start into Register Pair DE.

55CDH - The Errors

55CDH the error 2EH, Invalid parameter; 55D0H, 55D3H, 55D6H and 55D9H, each inside an LD BC, the errors 2DH Invalid data provided, 22H Attempted to use non program file as a program, 30H Terminated and 2CH Illegal filespec; 55DBH any error code in Register A. Each is posted with bit 6 set (no frame) and bit 7 clear, so ERROR@ ends through ABORT@.

55E0H - The Texts, the Parameters and the Variables

Data: the heading and the messages, the evaluation block and its parameter block (five names, PULL, REMOVE, KILL, OUT and YANK, all storing into 5233H, type 20H), the transfer record to write, the end of the patch, the reader's flags; then, not loaded, the line, the address and the strings, the two file blocks and buffers; and the second block of the file, the 07H record of the default patch name at 59D1H.