LDOS 5.3.1 for the Model III - PATCH/CMD Disassembled

PATCH/CMD

Other Navigation

LDOS 5.3.1 PATCH/CMD Disassembly - Change, Remove and Yank Patches in a File (Model III)

PATCH changes the bytes of a disk file, or adds load records to a program, from patch lines: PATCH filespec1 [USING] filespec2 (parms) reads the lines from a file (/FIX by default), PATCH filespec (patch lines) takes them from the command line, separated by colons. The file to patch gets /CMD when it has no extension (5200H). The parameters are REMOVE, OPTION=N and YANK.

The file is a load module of 2379 bytes: a copyright record, the code and data 5200H-5AEFH in nine load blocks, and the transfer address 5200H.

The Patch Lines

How It Works

About This Page

5200H - The Start: the Program File

The transfer address, entered with Register Pair HL at the command line after PATCH. The banner is shown; @FSPEC reads the file to patch into the control block at 5AF0H (a device, or no file, gives PROGRAM file name required); it gets /CMD when it has no extension and is opened with the buffer 5E00H and 256 byte records.

5229H - The Patch File and Its Name

A second file specification, when there is one, is the patch file: it goes into the control block at 5B10H with /FIX when it has no extension, and its name (up to the slash) is copied to 5AC1H with its length at 5AC0H: the name the patch gets in the file (5AC0H holds 03H and CLP from the file, the name of a patch from the command line).

525EH - The Parameters or the Patch Lines in Parentheses

After spaces, the end of the line goes on to read the patch file. A left parenthesis must come next (else Parameter error): @PARAM reads REMOVE and OPTION with the table at 5AC9H, and the results go into the operands at 57DBH and 57D5H. When @PARAM can read the parentheses the patch file is read; when it cannot, the text in them is the patch itself: it is copied to 5F00H up to the right parenthesis or the end of the line, a colon becoming 0DH, with 0DH and 03H at the end.

52A5H - Read the Patch File

The patch file (5B10H, buffer 5C00H) is opened, unless its name is empty (PROGRAM file name required), and read byte by byte into 5F00H with bit 7 cleared: a colon outside quotes becomes 0DH, so a line can hold two patch lines; the quote flag (52D1H) flips at each quote and is cleared at the end of each line. The end of the file or a 00H byte ends the text with 03H; the text must end below 72FFH (Fix file too big - partition it).

52FCH - The Patch Lines, Two Passes

The text at 5F00H is gone through twice. Each line starts with its verb; 5897H keeps the start of the line, shown with an error. The first pass (the operand at 530BH is 00H, 57A8H) only checks: R and O are taken, a D line is checked against the F line after it and the bytes in the file, every other line is passed over; at the 03H the operand at 530BH gets 03H and the text is gone through again. The second pass (5311H) does the work: D writes its bytes, X, L and Y change the file, F and comments are passed over, and the 03H closes the file.

5340H - X: a Patch by Load Address

The X lines become load records added to the file just before its transfer record (02H): the file is read from its start (5526H) to that record, the file is moved back one byte onto its type byte, and 555BH builds the records from this line and the X lines after it and puts them in. Every line after the first X must be an X line or a comment.

5375H - The End: Close the File

A new line, the file is closed and the message of the operand at 5384H is shown: Patch(s) successfully installed, or Patch successfully yanked after a yank (5493H); then back to LDOS with @EXIT.

538CH - Pass Over a Line

The rest of the line is passed over, to after its 0DH, and the next line is taken; 52D1H, the quote flag of the reader, is cleared on the way. An 03H ends it too, but then Register Pair HL is past the 03H, past the end of the text: a last line with no 0DH before the 03H.

539DH - D: Change Bytes in the File

Second pass: Drr,bb=data. 53A6H reads the record and byte and reads the record into the buffer; 53D0H writes the data into it and writes the record back.

53A6H - Read rr,bb and Position the File

Register Pair HL = the verb. The record number is one hex byte, or two (then only the second is kept: Register B stays 00H, so a four digit record number loses its first two digits); after the comma the record is read into the buffer of 5AF0H with @POSN and @READ, and the byte (one hex byte) goes into the offset (+05H) of the control block. It RETurns with Register Pair HL after the byte.

53D0H - The Data After the Equals Sign

Register Pair HL = the equals sign. Each data byte is a hex byte followed by one character (a space or a comma), or the characters of a quoted string, which ends the line. In the first pass each byte is compared with the file (5849H, FIND line mismatch); in the second it is written into the buffer and the record is written back with @RWRIT at the end of the line. A semicolon outside quotes starts a comment. It RETurns with Register Pair HL after the line's 0DH.

5409H - R: Remove

From the REMOVE parameter given in the parentheses as a patch line: the operand at 57DBH gets FFH, so the D lines after it are used to take the patch out (581AH), and the line is passed over.

5411H - Y: Yank a Patch

From the YANK parameter (it is not in the table of @PARAM, so it comes as a patch line). The file is read from its start, record by record, for a record of type 07H whose name is the patch's name (5AC0H: the patch file's name, or CLP). Each load record (type 01H) right after it gets the type 10H instead, which the loader passes over; the file is then closed with Patch successfully yanked. No such record gives Can't yank, patch not in load file. The lines after the Y line are not read.

54A4H - O: the Option

O=Y or O=ON puts AFH in the operand at 57D5H: a D line needs its F line to match; O=N, O=OFF, or O= with nothing after it, puts 00H there; anything else is Patch input format error. 54CAH is LD A,AFH; 54CBH, inside it, is XOR A.

54D3H - L: a Member of a Library File

Second pass: Lnn, where nn (hex) is the member byte of a member header (type 08H) of a library file such as SYS6/SYS. The member byte goes into the operand at 5741H; 56BFH finds the header and its start (record and byte), the member is read from there to its end record (04H), the file is moved back onto that 04H, and 555BH puts the records of the X lines after the L line there. 56FEH then moves on by the patch's length the start of every member after it in the headers. Only X lines and comments can follow an L line.

5526H - Read the Load Records to the End

From the file's position, each record's type is read: 02H (transfer), 03H, 04H (end of a member) or 0AH (end of the member headers) RETurns with the type in Register A and the file just after that type byte; a type of 20H or more is Load file format error; any other record is passed over by its length (a load block, 01H, as its address and data: a length of 0, 1 or 2 is 254, 255 or 256 data bytes).

555BH - Build the Patch Records

From 7300H: a record of type 07H with the patch's name (5AC0H, its length and the characters) when it has one, then for each X line a load block (type 01H): its length, the address from X'nnnn' (the byte after the closing quote is passed over without a test) and the data: hex bytes (spaces between them are passed over) or quoted strings, up to the 0DH or a semicolon. Only X lines and comments can follow; at the 03H, 5605H puts the records into the file.

5605H - Put the Records into the File

Register Pair DE = the end of the records built from 7300H; their length goes into the operand at 5769H. A second control block at 5B10H is made from the file's (with the buffer 5D00H) to read the old bytes from the file's position on while the first writes the new ones: each byte read is kept the length of the records further on at 7300H, so the records go in and every old byte after them is moved on by that length. At the end of the file the bytes still kept are written. The area from 7300H holds the rest of the file after the place; no test of the top of memory is made.

5668H - Read a Hex Byte or a Quoted Character

5668H clears the quote flag (5681H, the operand of LD A at 5680H) first; 566CH keeps it. A quote at Register Pair HL sets the flag. With the flag set the character at Register Pair HL is RETurned as it is, the NZ FLAG set; else one or two hex digits are read into Register A (a single digit when the next character is below 30H or is 3AH-40H; any character from 41H up is taken as the second digit). An 03H gives Patch input format error, a bad digit Non-hex digit encountered. Register Pair HL ends after what was read.

56ADH - The Value of a Hex Digit

0-9 and A-F (upper or lower case) give 00H-0FH; a character below 30H, or one whose value after the steps is 10H or more, gives Non-hex digit encountered. The steps also let through 57H-5FH (W to the underline) as 00H-08H and 60H as 09H, as either digit, and 3AH-40H as 03H-09H as the first digit.

56BFH - Find a Member Header

From the file's present position (its first record when nothing has moved it), each record is read: a member header (type 08H: length, member byte, entry address, record, byte) whose member byte is Register C ends the search; 0AH, the end of the headers, gives Library overlay not found; a load block (01H) before it, Invalid library format; any other record is passed over. It RETurns with Register Pair BC = the record and Register A = the byte where the member starts.

56F7H - Read a Byte of the File

The ROM's $GET reads the next byte of the file at Register Pair DE into Register A; an error, the end of the file too, is shown and ends PATCH.

56FEH - The Library Map: Move the Members After the Patch

The records before the end of the headers (0AH) are read from the start of the file into 7300H (types below 04H there, such as a load block, give Invalid library format). The header of the patched member (its member byte at 5741H) gives its start in Register Pairs DE and B; every member header after it whose start is another one gets the length of the patch (5769H) added to its byte and record. Then the records are written back over the old ones. FINDING: from the first header moved, Register Pair DE is 0000H (577AH), not the member's start, so the test at 5758H then keeps only a header whose start is record 0000H and the member's byte.

574CH - The Headers After It

Each header after the patched member's: a start equal to Register Pair DE and Register B (the same member under another member byte) is kept; any other start is moved on by the length of the patch.

577FH - Write the Headers Back

From the start of the file, every record of the copy at 7300H up to the 0AH is written over the old one, with the ROM's $PUT.

57A2H - The Second Pass

Register A = 03H: the operand at 530BH gets it, so the text is gone through again doing the work.

57A8H - The First Pass: Check a Line

Register A = the verb. A comment, F, Y, L and X lines are passed over; R and O are taken now as in the second pass; a D line goes to 57D4H; the 03H starts the second pass (57A2H); any other verb is Patch input format error.

57D4H - The First Pass: a D Line

With the option off (the operand at 57D5H is 00H) a D line is not checked. To remove a patch (the operand at 57DBH not 00H) 581AH is used. Else the D line is kept at 5AEAH, 5834H finds the next line that is not a comment (its F line), and 57ECH checks that it names the same record and byte and that its data is in the file.

57ECH - Check a Find Line

Register Pair HL = the line to check, 5AEAH = the line it belongs to. Their text after the verb must be the same up to the equals sign: the three characters rr, and then three more (bb=) when the third was a comma, else five (for a record of four digits). Then 53A6H positions the file at its record and byte and 53D0H, in the first pass, compares its data with the bytes of the file. FIND line mismatch when anything differs. It RETurns with Register Pair HL after the line.

581AH - The First Pass: Remove a Patch

The D line and its F line change places: the F line (the next line that is not a comment) is checked with the D line's text against the file, so the patch must be in it; the D line becomes a comment (a period) and the F line a D line, so the second pass writes back the bytes the F line names.

5834H - The Next Line That Is Not a Comment

583DH moves Register Pair HL to after the next 0DH; 5834H does that again while the line there starts with a period. 5844H reads the character at Register Pair HL in upper case and steps past it.

5849H - Compare or Write a Data Byte

Register A = a data byte. In the first pass (530BH is 00H) it is compared with the next byte of the file, FIND line mismatch when they differ; in the second it is written there (5863H).

585DH - Small Routines and the Errors

585DH positions the file at Register Pair DE at record Register Pair BC (@POSN); 5863H writes Register A into the file at Register Pair DE (the ROM's $PUT). An error from either goes to 5867H: @ERROR with bit 6 set shows the short message of the error code and ends the program. 586CH is error 2CH, Parameter error.

5870H - The Messages That End PATCH

Each entry loads Register Pair HL with a message; the DDH before the next entry turns its LD HL into LD IX, so only the message entered at counts: 5870H Library overlay not found, 5874H Invalid library format, 5878H Load file format error, 587CH Fix file too big - partition it, 5880H PROGRAM file name required. The message is shown with @LOGOT and PATCH ends with @ABORT. 5889H (Non-hex digit encountered) and 588DH (Patch input format error), and 5890H for FIND line mismatch, first show the patch line at 5897H.

589FH - The Texts

The default extensions, the banner, the status texts (each between 1DH, the cursor to the start of the line, and 1EH, clear to the end of the line, then 1DH and 03H, so each one is shown over the one before), and the messages, each ended by 0DH.

5AC0H - The Name, the Parameter Table and the Cells

The name the patch gets in the file, the table of @PARAM (6 characters and the address of the result, ended by 00H), the D line pointer and the two results. From 5AF0H on is memory the file does not load: the control blocks, the buffers and the patch text.