TRS-80 DOS - LDOS 5.3.1 for the Model I - TED/CMD Disassembled

TED/CMD

Other Navigation

LDOS 5.3.1 TED/CMD Disassembly - the MISOSYS Text Editor (Model I)

TED is the full screen text editor supplied on the LDOS 5.3.1 distribution disk. It is not part of the operating system: it is an ordinary transient utility, and nothing else on the disk depends on it. The manual describes it as "a full screen quick text editor with typical word-processing type features" that "was not designed to be a full featured word processor", and the code bears that out. There is no word wrap, no formatting, no printer control and no undo. What there is, is a text buffer that fills all of free memory, four-directional cursor movement, insert and overstrike entry, five kinds of deletion, six block operations, search and replace, a directory query, and disk LOAD and FILE, all driven from single keystrokes.

The banner the program puts on the status line reads TED 1.2 - (c) 1991 MISOSYS, Inc, while the copyright string that precedes the code in the load module reads Copyright (c) 1987 MISOSYS, Inc., All rights reserved. The command is TED [filename[/TXT]]; a file named on the command line is loaded automatically, because initialisation copies the filespec into the prompt buffer and queues a CTRL L keystroke for the main loop to find. A command line beginning with an asterisk suppresses the clearing of the text buffer, so TED * re-enters the editor over whatever the previous run left in memory.

TED will not run without KI/DVR, the DOS v5 keyboard driver installed with SET *KI TO KI/DVR. The very first thing the transfer address does is test bit 4 of DFLAG$ at 441FH and abort with TED requires KI/DVR! if the driver is absent. The reason is the command key table: initialisation sets bit 6 of KFLAG$ at 4423H to select the driver's special-key translation table, and the whole command set is built around the codes that table returns. The bit is reset again at 530DH on the way out.

The screen is divided in three. Video rows 0 to 13, 3C00H to 3F7FH, are the text area, fourteen lines of 64 characters. Video row 14, 3F80H to 3FBFH, is a rule of underscores. Video row 15, 3FC0H to 3FFFH, is the status line, which carries the sign-on banner when nothing else is happening and every prompt, query and error message when something is. Alongside the display TED keeps a line table at 5B96H holding the text address of the first character of each of the fourteen text rows, rebuilt by every redraw, and it is that table rather than any calculation that turns a cursor row and column back into a text address.

The text buffer starts at 5D00H and runs to HIGH$, which TED reads once at start-up and never lowers, so it does not protect itself and the buffer is simply everything above the image. Text is stored as a plain run of characters ending in a zero byte, with 0DH for a newline. The two block markers the operator plants with CTRL B B and CTRL B E are stored in the text as ordinary characters, 0FEH and 0FFH, which is why the manual warns that they occupy text positions, can be deleted or overstruck, and will be written to the disk file if they are still there when the text is filed. The display translates all three: a newline is shown as the small graphics block 84H, a begin marker as the graphic left bracket 0B7H and an end marker as the graphic right bracket 0BBH.

Six of the module's instructions carry their working values in their own operand fields instead of in variables. The main loop alone holds the saved stack pointer at 540EH, the cursor row and column at 5422H, the pending keystroke at 5426H and the text address of the cursor at 5438H; the end-of-text pointer lives at 58C2H and the buffer ceiling at 58C5H. The end-of-text pointer is the interesting one, because the image loads with zero in that field and the value is first put there by the line display routine at 5828H, which records the address of the terminating zero byte every time a redraw reaches the end of the text.

There are ten places where a branch lands one byte inside another instruction so that an FDH index prefix, an 06H, an 01H, an 11H, a 3EH or an 0F6H is stepped over and the bytes that follow read as a different instruction. Three message setters are packed into eleven bytes that way at 5324H, the "this is a move" and "this is a delete" flags at 5361H are one instruction, the two block marker constants at 5393H are another, and both the CTRL L/CTRL F pair at 5642H and the CTRL N entry at 5638H are reached through the trick from the command key table itself. Every one of them is shown on this page twice, once as it reads on the fall-through path and once as it reads when it is entered.

Two fragments in the image are unreachable. The three bytes at 5508H form a LD (5423H),A that no branch names and that the unconditional jump above it cannot fall into, and the nineteen bytes at 5831H are a complete subroutine, converting a video address into a row and a column, that nothing calls; it loads its divisor into Register C while the resident @DIV routine at 44C4H takes the divisor in Register A.

File Format and Load Map

TED/CMD is a single LDOS load module. The header string Copyright (c) 1987 MISOSYS, Inc., All rights reserved precedes the code and is not executable. The image is one contiguous run of 2365 bytes from 5259H to 5B95H with no gaps and no byte loaded twice, and the transfer address is 529FH, not the first byte of the image; the two-byte jump at 5259H exists so that a caller entering at the front of the image reaches the same place. Every hex byte on this page has been verified against the module.

The program uses three areas of memory outside its own image. Below it, 5200H to 5258H is the workspace addressed through Register Pair IX, which is loaded with 5200H at 52C4H and never changed again. Above it, 5B96H to 5CCBH holds the line table, the prompt reply buffer and the buffer a DOS error message is returned into. Above that, 5D00H to HIGH$ is the text buffer.

The Command Key Table (525DH-529EH)

Twenty-two three-byte entries, each a key code followed by the address of its handler, scanned by the dispatcher at 5449H. The high-bit codes are what KI/DVR returns with its special-key translation table selected. On the Model I keyboard the DOS 5 control prefix is SHIFT with the down arrow, so the manual's CTRL Z is that prefix followed by Z.

Key Code	Key	Handler	Action
81H	Left arrow	554FH	Move the cursor one position left. In column 0 it wraps to the end of the previous line.
84H	Right arrow	553DH	Move the cursor one position right. At a newline or at column 63 it wraps to the start of the next line.
88H	Down arrow	5529H	Move the cursor one display line down, scrolling the screen up when it is on the bottom line.
82H	Up arrow	5553H	Move the cursor one display line up, scrolling the screen down when it is on the top line.
91H	SHIFT left arrow	54CCH	Move the cursor to column 0, or in DELETE mode delete back to the beginning of the line.
94H	SHIFT right arrow	54A9H	Move the cursor to the end of the line, or in DELETE mode delete to the end of the line.
92H	SHIFT up arrow	53DCH	Move the cursor to the top of the text, or in DELETE mode delete from the top down to the cursor.
1AH	CTRL Z	556DH	Move the cursor to the end of the text, or in DELETE mode delete from the cursor to the bottom.
0DH	ENTER, CTRL M	5467H	Enter a 0DH newline into the text.
01H	CTRL A	55CEH	Toggle between overstrike and insert entry, changing the cursor character with it.
02H	CTRL B	5320H	BLOCK. The next keystroke is read as one of the sub-commands B, E, C, D, M or P.
04H	CTRL D	55F3H	Delete the character under the cursor and set DELETE mode for one further keystroke.
06H	CTRL F	5643H	FILE the text buffer to disk.
07H	CTRL G	559FH	GO on to the next occurrence of the current search string.
0CH	CTRL L	5642H	LOAD a text file, appending it to the buffer.
0EH	CTRL N	5639H	Display the next video page.
10H	CTRL P	53BCH	PRINT the whole text buffer.
11H	CTRL Q	5715H	QUERY a disk directory.
12H	CTRL R	592EH	REPLACE the search string at the cursor with the replacement string.
13H	CTRL S	558DH	SEARCH for a string.
15H	CTRL U	5626H	Go up to the previous video page.
BDH	CLEAR SHIFT =	5313H	EXIT the editor, confirming first if the buffer is not empty.

Variables, Buffers and Self-Modifying Operand Cells

Address Range	Purpose
5200H-5203H 4 bytes	Part of the workspace addressed through Register Pair IX but never referenced by any instruction in the module.
5204H 1 byte	The mode flag byte, IX+04H. Bit 0 insert entry mode, bit 1 DELETE mode, bit 2 BLOCK mode, bit 6 a status message is queued at 5208H, bit 7 a status message is on the screen. Bits 1, 2, 6 and 7 are cleared by 58FFH on the keystroke after the one that set them.
5205H 1 byte	The current cursor character, IX+05H. 5FH, the underscore, in overstrike mode and 0BFH, the solid graphics block, in insert mode. Written by 55DCH from the pair of constants at 525BH.
5206H 1 byte	The length of the search string, IX+06H. Zero until a SEARCH has been answered, and the search loop at 55BBH returns at once while it is.
5207H 1 byte	The length of the replacement string, IX+07H.
5208H-5209H 2 bytes	The address of the status message queued by 532FH, IX+08H, read back by 58F6H when the main loop displays it.
520AH-5229H 32 bytes	The File Control Block, IX+0AH. The three fields the module reaches directly are 520DH and 520EH, FCB+03H and FCB+04H, the buffer address whose high byte is walked up the text buffer a page per record; 5212H, FCB+08H, the end-of-file byte offset; and 5216H, FCB+0CH, the ending record number.
522AH-5241H 24 bytes	The search string, copied here from the prompt reply buffer by 559DH.
5242H-5258H 23 bytes	The replacement string, copied here by 593EH. It runs up to the first byte of the loaded image.
540EH-540FH 2 bytes	The stack pointer as it stood when 5304H called the editor, saved by 53D8H. It is the operand of the LD SP,nnnn at 540DH, so the main loop resets the stack simply by executing that instruction.
5422H-5423H 2 bytes	The cursor position: 5422H the column 0 to 63 and 5423H the video row 0 to 13. The operand of the LD HL,nnnn at 5421H.
5426H 1 byte	The pending keystroke. The operand of the LD A,nn at 5425H. Initialisation puts 0CH there when a filespec was given on the command line, and 564BH reads it and 564CH clears it.
5438H-5439H 2 bytes	The text address of the character under the cursor. The operand of the LD DE,nnnn at 5437H, so every command routine is handed it in Register Pair DE.
5670H 1 byte	The LOAD or FILE selector, 00H for FILE and 0AFH for LOAD. The operand of the LD B,nn at 566FH.
58C2H-58C3H 2 bytes	The end-of-text pointer, the address of the terminating zero byte. The operand of the LD DE,nnnn at 58C1H. The image loads with 0000H here and the value is first established by the line display routine at 5828H, which records the address whenever a redraw reaches the end of the text.
58C5H-58C6H 2 bytes	The text buffer ceiling, HIGH$ as it stood when TED started, written once by 52D8H. The operand of the LD HL,nnnn at 58C4H, so 58C1H followed by 58C4H is the buffer-full test.
5B96H-5BB1H 28 bytes	The line table: fourteen two-byte text addresses, one for each video row 0 to 13, rebuilt by every redraw. A row that lies past the end of the text holds 0000H. 5B94H and 5B95H, the last two bytes of the image padding, act as the guard entry below row 0.
5BB4H-5BCBH 24 bytes	The filespec buffer and the reply buffer for every prompt. Initialisation copies 24 bytes of the command line here at 52FCH.
5BCCH-5CCBH 256 bytes	The buffer SYS4/SYS builds a DOS error message into when 56B1H calls @ERROR. 56BEH converts the carriage return that ends it into TED's own bit 7 terminator.
5D00H upwards to HIGH$	The text buffer. A plain run of characters terminated by a zero byte, with 0DH for a newline, 0FEH for a block begin marker and 0FFH for a block end marker.

Major Routines

Address	Name and Purpose	Entry	Exit
529FH	Transfer Address Tests DFLAG$ 441FH bit 4 and refuses to run without the DOS v5 keyboard driver.	None	Aborts to @ABORT 4030H if KI/DVR is absent
52C4H	Initialisation Sets Register Pair IX to 5200H, selects KI/DVR's special-key translation table, saves HIGH$ as the buffer ceiling, draws the screen furniture and queues a LOAD if the command line names a file.	Register Pair HL = the command line tail	Falls into the editor
540DH	Main Command Loop Resets the stack, refreshes the status line, blinks the cursor, reads a key and dispatches it as a block sub-command, a table command or a text character.	None	Never returns; every command re-enters it
5449H	Command Key Lookup Linear scan of the twenty-two entry table at 525DH.	Register A = the key code	Jumps to the handler, or returns if the key is unknown
5469H	Text Entry Overstrike or insert according to bit 0 of 5204H, growing the text and refusing with No room! at HIGH$.	Register A = the character, Register Pair DE = the cursor text address	Cursor moved right, screen updated
55BBH	String Search Compares the string at 522AH at every position from one past the address given.	Register Pair HL = the text address to search from	Z FLAG set and Register Pair HL on the match
57B6H	Screen Refresh Fourteen calls to the line display routine, then blanks whatever is left of the text area.	Register Pair HL = the text address of the first row, Register A = the first row at 57B7H	Text area redrawn, line table rebuilt
580AH	Display One Text Line Up to 64 characters, stopping at a newline or the terminator, and the routine that establishes the end-of-text pointer at 5828H.	Register Pair HL = the text, Register Pair DE = the video address	Register A zero at the end of the text
5852H	Start of a Display Line Counts back to the previous newline and strips whole multiples of 64.	Register Pair DE = any text address	Register Pair DE = the first character of its display line
5892H	Text Address from Row and Column Looks the row up in the line table at 5B96H and adds the column.	Register H = the row, Register L = the column	Register Pair DE = the text address
58CDH	Confirmation Prompt Displays Press <ENTER> to confirm.	None	Returns only on ENTER, otherwise discards the caller's return address
58E8H	Prompt and Reply Writes the prompt on the status line and reads an edited reply.	Register Pair HL = the message	Register Pair HL = 5BB4H, Register B = the reply length
590AH	Write the Status Line Homes the cursor to video row 15, erases the line and displays until a character with bit 7 set.	Register Pair HL = the message	Register C = the message terminator
598CH	Insert Text at the Cursor Opens the gap with a backwards block move and copies the source down into it. Used by block copy, block move and replace.	Register Pair HL = the last source byte, Register Pair DE = one below the first	Text inserted, or No room!
59CEH	Find the Marked Block Searches forward for 0FFH and then backwards for 0FEH.	Register Pair DE = where to search from	Register Pair HL = the begin marker, Register Pair DE = the end marker
5A0DH	Prompt Line Input Echoes and edits a reply, accepting ENTER, BREAK, the left arrow and CTRL X.	Register Pair HL = the buffer	Register B = the length, CARRY FLAG set if abandoned
5A71H	Cursor Primitives Read the cell, write the cell, set the hardware cursor, or return the current row and column.	Register B = 1 to 4, Register Pair HL = the row and column	Depends on the function code
5ABFH	BREAK Key Test Clears KFLAG$ 4423H bit 0 and looks again, so holding the key holds the program.	None	NZ FLAG set if BREAK was pressed

Cross-Reference Notes

What TED calls
Twelve resident LDOS vectors and seven Level II ROM routines. The DOS vectors are @ABORT 4030H when KI/DVR is missing, @ERROR 4409H to turn a disk error code into text, @FSPEC 441CH to parse a filespec into the File Control Block, @INIT 4420H to create the file a FILE writes, @OPEN 4424H to open the file a LOAD reads, @CLOSE 4428H, @READ 4436H, @WRITE 4439H, @DODIR 4463H for the directory query, @FEXT 4473H to apply the default /TXT extension, and @LOGOT 447BH for the one message TED displays before the screen belongs to it. @DIV 44C4H is named only by the unreachable routine at 5831H. The ROM entries are $CTL 0023H, $KBD 002BH, $DSP 0033H, $PRT 003BH, $KEY 0049H, PAUSE 0060H and CLS 01C9H.

Resident bytes TED reads or writes directly
DFLAG$ 441FH bit 4, tested once to prove KI/DVR is installed; KFLAG$ 4423H bit 6, set at 52CCH to select the driver's special-key translation table and reset at 530DH, and bit 0, the BREAK flag, cleared and re-tested by 5ABFH; HIGH$ 4049H, read once at 52D5H to fix the top of the text buffer; the SYS1 status byte 4758H, whose bit 7 is set at 56AFH so that SYS4/SYS builds an error message without displaying it; the *KI Device Control Block at 4015H, handed to the ROM $CTL entry at 5ADAH; and 4020H, the ROM display driver's cursor position cell, which is the only place TED keeps the hardware cursor.

Which overlays a TED session loads
TED issues no RST 28H request of its own; every service it uses is a resident vector, so the overlays are reached indirectly. LOAD and FILE bring in SYS2/SYS through @OPEN and @INIT and SYS3/SYS through @CLOSE, a FILE that extends a file will bring in SYS8/SYS through the resident allocate path, the directory query brings in SYS12/SYS through @DODIR, and any disk error brings in SYS4/SYS through @ERROR. Nothing else on the LDOS 5.3.1 disk calls TED, and TED is the only file on the distribution disk that is an application rather than part of the operating system.

5259H - Image Head, Cursor Character Pair and the Command Key Table

The first three bytes of the loaded image are not the transfer address. TED/CMD declares its transfer address as 529FH, so 5259H is entered only if something jumps to the front of the image, and the two-byte jump at 5259H sends that caller to the same place. 525BH and 525CH hold the two cursor characters, and 525DH-529EH is the command key table that decides what every non-text keystroke does.

The table is twenty-two three-byte entries: one key code followed by the address of the routine that services it. The dispatcher at 5449H walks it with Register B set to 16H, which is exactly twenty-two, so the table ends at the byte before the transfer address. The high-bit key codes are the values the KI/DVR keyboard driver returns when its special-key translation table is selected, which is what initialisation switches on at 52CCH by setting bit 6 of KFLAG$ 4423H. TED refuses to run without that driver, which is why the codes can be relied on.

529FH - Transfer Address: the KI/DVR Requirement Test

The transfer address of the load module. TED reads its keyboard through the DOS v5 keyboard driver KI/DVR rather than through the ROM, because only that driver produces the shifted-arrow and control-letter codes the command key table at 525DH is built around. The first thing the program does is prove the driver is installed, and it abandons the run if it is not.

52C4H - Initialisation and the Return to the DOS

Everything TED needs set up before the editor runs: the index register that addresses its low workspace, the keyboard translation table, the text buffer ceiling, the screen furniture, the initial text entry mode, and the optional filespec taken from the command line. The tail of this section, from 5307H, is where the editor returns when the operator exits, and it puts the keyboard back the way it found it.

Register Pair IX is loaded with 5200H and is never changed again, so every (IX+nn) in the file addresses TED's workspace in the 89 bytes below the image: 5204H the mode flag byte, 5205H the current cursor character, 5206H the search string length, 5207H the replace string length, 5208H the pending status message pointer, 520AH-5229H the File Control Block, 522AH the search string and 5242H the replace string.

5313H - The EXIT Command

Reached from the command key table when the operator presses CLEAR with SHIFT and =, key code BDH. An empty buffer leaves without comment; anything else has to be confirmed, because exiting is what throws the text away.

5320H - The BLOCK Command and the Three Status Message Setters

CTRL B does not act on the text. It sets the BLOCK flag, puts the word Block on the status line, and returns to the main loop; the next keystroke is then routed to the block sub-command dispatcher at 537AH instead of being treated as text.

The three instructions at 5324H, 5327H and 532BH are a deliberate overlap. Entering at 5324H loads Register Pair HL with the address of Block and then executes two harmless LD IY,nnnn instructions on the way to 532FH. Entering one byte later, at 5328H or 532CH, strips the FDH prefix so the same bytes read as LD HL,nnnn and select a different message. That is how three message setters are packed into eleven bytes, and it is why 5328H and 532CH are branch targets that sit inside another instruction.

533CH - Block Move

The M sub-command of BLOCK. A move is a copy followed by a delete: 5981H does the whole of the copy, including the room test and the error checks, and this routine then finds the original block a second time and removes it through the block delete code at 5363H. The cursor has to be adjusted first, because deleting the original pulls everything after it down.

5354H - Block Delete

The D sub-command of BLOCK, and the common tail that Block Move also uses to take the original block out. Unlike copy and move, delete requires the cursor to be inside the marked block, which is how the operator says which of several marked blocks is meant, and it always asks for confirmation first.

537AH - The Block Sub-Command Dispatcher

Reached from the main loop at 543EH when the BLOCK flag, bit 2 of 5204H, is set, so this is the keystroke immediately after CTRL B. The six sub-commands are ordinary letters, not control codes, and either case is accepted. Anything else is ignored and the flag byte is cleared by the main loop on the next pass.

53A7H - Block Copy

The C sub-command of BLOCK. All the work is in 5981H; what is left here is to put the cursor back on the screen. The markers themselves are not copied and the original block is left where it was.

53B1H - Block Print and the PRINT Command

Two entry points into one output loop. 53B1H is the P sub-command of BLOCK and prints only the marked text, without its markers; 53BCH is CTRL P and prints the whole buffer. Both send raw text bytes to the ROM printer driver, so the newlines in the text are the only line structure the printer sees, and BREAK stops the listing.

53D8H - Editor Entry, and SHIFT UP: Top of Text or Delete to Top

Two routines share this space. 53D8H is the editor proper, called once from 5304H, and its first act is to record the stack pointer so that the main loop can throw the stack away on every keystroke. 53DCH is the handler for key code 92H, SHIFT with the up arrow, which means "go to the top of the text" normally and "delete everything above the cursor" when DELETE mode is in force; on the ordinary path it falls straight through into the main loop set-up at 53FEH, which is exactly what going to the top of the text amounts to.

The end-of-text pointer at 58C2H is deliberately not adjusted when text is deleted here. It is re-established by the redraw at 5404H, because the line display routine records the address of the terminating zero byte at 5828H as soon as it reaches it.

53FEH - The Main Command Loop

The heart of the editor. 53FEH is the full restart, used at start-up and whenever the whole screen has to be rebuilt from the top of the text; 540DH is the per-keystroke entry that every command routine returns to. Because 540DH reloads the stack pointer from the value saved at 53D8H, a command routine may be several calls deep when it decides to give up and can simply jump here.

Four of the instructions in this loop carry their working values in their own operand fields rather than in variables: 540DH holds the saved stack pointer at 540EH, 5421H holds the cursor row and column at 5422H, 5425H holds the pending keystroke at 5426H, and 5437H holds the text address of the cursor at 5438H. Register H of the 5422H pair is the video row 0 to 13 and Register L the column 0 to 63.

5449H - The Command Key Lookup and the No Room Message

A straight linear scan of the twenty-two entry table at 525DH. A key that is not in the table is thrown away, exactly as the manual says. The tail of the section, 5459H, is the common "buffer full" exit that the text entry and block copy routines jump to.

5467H - Text Entry: ENTER and Every Displayable Character

The routine that puts a character into the text. 5467H is the ENTER handler, which does nothing but choose 0DH as the character; 5469H is the entry the main loop uses for any key between 20H and 7FH, and the block marker inserter at 539EH uses it too. In overstrike mode the character replaces what is under the cursor unless the cursor is at the end of the text, in which case the text has to grow and the insert path is taken anyway.

54A9H - SHIFT RIGHT: End of Line, or Delete to End of Line

Key code 94H. In DELETE mode this is the "delete to eol" sub-command the manual lists, and it asks for confirmation first; otherwise it just parks the cursor in the last used column of the current display line.

54CCH - SHIFT LEFT: Beginning of Line, or Delete to Beginning of Line

Key code 91H, the mirror of the routine above. In DELETE mode it removes everything from the start of the display line up to the cursor, which is the manual's "delete to bol"; otherwise it moves the cursor to column 0.

54E5H - The Common Deletion Tail

Where both of the line deletions above and the block delete at 54BFH end up. The end-of-text pointer is not adjusted arithmetically; the text is scanned from the front for its terminating zero, which costs nothing noticeable and cannot get out of step. 54FCH onwards is the tail the text entry routine uses when the shape of the display has changed.

5508H - An Unreachable Fragment

Three bytes that form a complete instruction but that nothing in the module reaches. The instruction before them, at 5506H, is an unconditional jump, and no branch anywhere in the file names 5508H. It would store Register A into 5423H, the cursor row half of the position word at 5422H.

550BH - Recomputing the Text Address of the Cursor

Called whenever the cursor row or column has been changed, to bring the text address at 5438H back into step with it. 550EH is a second entry used when the caller already has the row and column in Register Pair HL.

5516H - Column Wrap and the Newline Line-Table Repair

5516H is the "move one position right" that text entry uses. When the cursor is already in the last column, or when a newline has just been typed over an existing character, the following row has to be told where it now starts, which is what 551BH writes into the line table at 5B96H before the cursor is dropped onto it.

5529H - Cursor Down

Key code 88H, the down arrow, and the tail of the column wrap above. The row number is simply incremented unless the cursor is already on the bottom text line, in which case the display is scrolled up one line first and the cursor stays where it is. The column is then clamped to the length of the line it has landed on.

553DH - Cursor Right

Key code 84H, the right arrow. The cursor stops at the end of the text, and steps to the start of the following row when it is on a newline or has reached column 63.

554FH - Cursor Left, Cursor Up and the Column Clamp

Two handlers that run into one another on purpose. Key code 81H, the left arrow, decrements the column; if that takes it below zero the code drops straight into the up-arrow handler with the column left at 0FFH, and the clamp at 5561H then pulls it back to the length of the line above. That is how the left arrow wraps to the end of the previous line without any code of its own.

556DH - CTRL Z: End of Text, or Delete to Bottom

Key code 1AH. On the Model I keyboard the DOS 5 control prefix is SHIFT with the down arrow, so this is the key sequence the TED manual writes as SHIFT down arrow then Z. In DELETE mode it is the manual's "delete to bottom"; otherwise it puts the last line of the text on the top row of the screen and parks the cursor at the very end.

558DH - SEARCH and FIND NEXT

558DH is CTRL S, which prompts for the string and then searches; 559FH is CTRL G, which searches again for whatever is already in the search buffer. Answering the prompt with a bare ENTER keeps the previous string, so the two commands share everything below 559FH.

55A8H - Bringing a Text Address to the Top of the Screen

Given a text address in Register Pair HL, redraw the text area so that the display line containing it is row 0, and leave the cursor on it. Every command that jumps somewhere in the text ends here: search, find next, block copy, block move, block delete and replace.

55BBH - The String Search Loop

Walks the text one character at a time from the address in Register Pair HL, comparing the search string at 522AH against each position. The first position tested is one past the address supplied, which is what makes find-next move on rather than finding the same match again; the replace command compensates by handing in the address one below the cursor.

55CEH - CTRL A: Toggle Overstrike and Insert

Key code 01H. Flipping bit 0 of the mode flag byte is the whole of the command; the cursor character is changed with it so that the operator can see which mode is in force. 55DFH is a second entry used by the block marker inserter, and 55D3H a third used by the BREAK handling in 55EFH.

55E3H - Waiting for a Keystroke

Called once per pass round the main loop. The cursor is blinked over whatever character it is sitting on until a key is pressed. BREAK is intercepted here rather than in the command table: it clears the DELETE and BLOCK modes and puts the overstrike cursor back, which is how the operator gets out of a half-typed command.

55F3H - CTRL D: Delete the Character Under the Cursor

Key code 04H. The character under the cursor goes, everything after it is pulled back one place, and DELETE mode is left set so that the next keystroke can turn the command into one of the four larger deletions.

5611H - Redrawing from the Cursor Row Down

The cheap redraw. Nothing above the cursor row can have changed, so only the rows from the cursor down are rebuilt, and the line table entries above the cursor keep their existing values. 5614H is the entry used when the caller already has the row and column in Register Pair HL.

5626H - CTRL U: Page Up, and CTRL N: Page Down

The two paging commands. Page up steps the top-of-screen pointer back thirteen display lines, one at a time, because a display line is only known by walking the text; page down simply takes the text address of the bottom row and redraws from there, which is why the manual says the previous page overlaps by one line and the next page starts on the last line displayed.

The four bytes at 5638H are another deliberate overlap. Read from 5638H they load Register Pair IY and do nothing useful; entered at 5639H, which is where the command key table sends CTRL N, the FDH prefix is skipped and the same operand loads Register Pair HL with the line table entry for row 13.

5642H - LOAD and FILE: the Filespec, the File and the Write

Both disk commands come through here. 5642H is CTRL L, LOAD, and 5643H is CTRL F, FILE; the only difference is the byte planted at 5670H, which is the operand of the LD B,nn at 566FH and decides which of the two paths is taken once the file has been named. A filespec taken from the command line at 52F6H skips the prompt, which is what makes TED filename load the file at start-up.

The File Control Block is at 520AH, which is IX+0AH. The three indexed references in this section reach the standard LDOS FCB fields through it: IX+0EH is FCB+04H, the high byte of the buffer address, IX+12H is FCB+08H, the end-of-file byte offset, and IX+16H is FCB+0CH, the ending record number. Bumping the high byte of the buffer address by one between records is what walks the transfer up the text buffer a page at a time.

56A5H - Reporting a Disk Error

Every failure from @INIT, @OPEN, @WRITE and @READ ends up here. Rather than let the DOS display the error, which would destroy the editing screen, TED has SYS4/SYS build the message text into a buffer and then puts it on the status line in its own format. The message SYS4 returns is terminated by a carriage return, so the last character has to be given bit 7 to match the convention the status line writer at 590AH uses.

56C3H - LOAD: the Room Test and the Read Loop

The size of the file is known before a byte is read, because the directory gives the ending record number and the end-of-file byte offset, so TED can refuse a file that will not fit without disturbing the text already in the buffer. That is the manual's "if the file is too large to fit into the available text buffer, the error message No room! will be displayed and no text will be loaded".

5715H - CTRL Q: Directory Query

Puts a disk directory on the screen through the DOS @DODIR service and then rebuilds the editing display. The reply may be a bare drive number, a drive number preceded by a colon, or a slash and a three character extension mask followed by the drive, which is what selects @DODIR's masked function code 2.

5751H - Blinking the Cursor and Waiting for a Key

The only place TED reads the keyboard. The character the cursor is sitting on and the cursor character from 5205H are written alternately over the same screen cell, and the keyboard is scanned 180 times between each change, which is what produces the blink. The exit is unusual: when a key is found, 5773H throws away the return address of the inner call so that the routine falls into the character writer at 5775H and returns straight to whoever called 5751H, with the real character restored on the screen and the key in Register A.

577FH - The Two Cursor Cell Primitives

Two three-byte stubs and the wrapper they share. Both go to the cursor primitive dispatcher at 5A71H, which works out the video address from the row and column in Register Pair HL; the only difference is the function code, 1 to read the cell and 2 to write it.

578BH - Display-Form Translation

Three characters in the text are not shown as themselves. A newline appears as the small graphics block 84H, the block begin marker 0FEH as the graphic left bracket 0B7H and the block end marker 0FFH as the graphic right bracket 0BBH. Everything else is displayed unchanged. The CARRY FLAG set on the newline is used by the line display routine at 5819H to decide that the line has ended.

579DH - Comparing the Search String Against the Text

A plain byte for byte comparison of the search string held at 522AH against the text at the address in Register Pair HL. The Z FLAG on return means the whole string matched.

57ABH - Scrolling the Display Down One Line

Works out the display line before the one currently at the top of the screen and redraws from it. The four bytes at 57B2H are the last of the module's overlaps: read from 57B2H they load Register Pair IY and do nothing that matters, while entering at 57B3H makes the same operand load Register Pair HL with the line table entry for row 1, which is what scrolls the display the other way.

57B6H - The Screen Refresh

Redraws the fourteen line text area from the text address in Register Pair HL and rebuilds the line table at 5B96H as it goes, so that after a redraw every row of the screen has a known text address. 57B6H starts at row 0; 57B7H is the entry that starts at the row number in Register A, which is what makes a change near the bottom of the screen cheap.

The line table is fourteen two-byte entries at 5B96H through 5BB1H, one per text row. A row that lies past the end of the text gets a zero entry, which is what the page down command tests at 563DH. Register Pair IY is set to 5B94H, one entry below the table, because the stepping loop always runs at least once.

580AH - Displaying One Text Line

Writes one video line of up to 64 characters from the text at Register Pair HL to the screen at Register Pair DE. It stops on a newline, on the terminating zero, or when the line is full, and blanks whatever is left of the line. Register A on return is zero only when the end of the text was reached, and that is also the moment the end-of-text pointer at 58C2H is refreshed.

5831H - An Uncalled Video Address Converter

Nineteen bytes that form a complete subroutine which nothing in the module calls: no instruction anywhere in the image names 5831H, and the instruction before it is a RETurn. It would convert a video address in Register Pair HL into a row in Register H and a column plus one in Register L. It loads the divisor into Register C, while the resident @DIV routine at 44C4H takes the dividend in Register Pair HL and the divisor in Register A.

5844H - Finding the Previous Display Line

Given the text address of the first character of a display line in Register Pair DE, return in Register Pair HL the text address of the display line before it. There are two cases. If the byte just below the line is not a newline then the line is the continuation of a logical line that wrapped, and the previous display line begins exactly 64 characters earlier. If it is a newline then the previous logical line ends there and its last display line has to be found by walking back to the newline before that, which is what 5852H does.

5852H - Finding the Start of a Display Line

Rounds the text address in Register Pair DE down to the first character of the display line it falls on. A logical line runs from one newline to the next and is broken into display lines every 64 characters, so the routine counts backwards to the previous newline, or to the start of the text, and then discards whole multiples of 64 from that count.

The count is kept as a negative number in Register Pair BC, and the multiple of 64 is stripped by adding 64 repeatedly until the value goes positive rather than by dividing, which on a Z80 is both shorter and faster for the short counts involved.

5879H - Measuring the Current Display Line

Returns in Register A the number of characters on the display line the cursor row names, and in Register Pair DE the address of the character that ended it. The count stops at 63, so the highest column the cursor can be clamped to is 63 and a line that fills the screen width reports 63 with Register Pair DE addressing its sixty-fourth character.

5892H - Text Address from Row and Column

Turns a cursor row in Register H and column in Register L into the text address of that screen position, using the line table at 5B96H. A row whose line table entry is zero lies past the end of the text; in that case the entry for the row above is used and 64 is added, which puts the address just past the last line of text and lets the cursor be moved into the blank area below it.

58ADH - Addressing a Line Table Entry

The line table at 5B96H is fourteen two-byte entries, one per text row, so the entry for a row is found by doubling the row number and adding it to the base. Register Pair IY is used because the callers want to reach the entry above and below as well as the entry itself.

58B9H - Pointer Comparison and the Two Operand Cells

A sixteen bit comparison with four entry points. The two instructions at 58C1H and 58C4H are not really instructions that the module executes in sequence; their operand fields at 58C2H and 58C5H are the end-of-text pointer and the text buffer ceiling, written by the rest of the program and read back by executing the instruction that contains them. Calling 58C1H therefore compares the end of the text against the ceiling, which is the buffer-full test the insert code uses.

58CDH - The Confirmation Prompt

Used by every command that throws text away. It puts Press <ENTER> to confirm on the status line and waits. Only ENTER lets the caller carry on; any other key makes the routine discard the caller's return address, so the command is abandoned without the caller having to test anything. That is the manual's "any other character entry (including a Y) will cause TED to ignore the request".

58E5H - Prompting for a Reply

Puts a message on the status line and reads a reply into the buffer at 5BB4H. 58E5H is the entry that supplies the String? message for the search and replace commands; 58E8H is the entry used when the caller has already chosen the message. An abandoned reply is dealt with the same way as an unconfirmed delete: the caller's return address is thrown away.

The 17H loaded into Register B here as a reply length limit never takes effect, because the input routine's first instruction, at 5A0DH, replaces it with Register C. Register C is left by the message writer at 590AH holding the message's own terminator byte, and since every prompt in the file ends with a space that has bit 7 set, the limit that is actually used is 0A0H, 160 characters.

58F6H - Writing the Status Line

Video line 15 is the status line, and every message TED shows goes through here. 58F6H displays the message queued at 5208H, 58F9H displays the message addressed by Register Pair HL and records that a message is on the screen, and 58FFH puts the sign-on banner back and clears the mode flags. A message ends at the first character with bit 7 set, and the character 1EH sent before the message erases the rest of the line.

5928H - The Guarded Block Move

A block move that does nothing when the count is zero, instead of moving 65536 bytes as the Z80 instruction would on its own. Every deletion in the file goes through it.

592EH - CTRL R: Replace

Key code 12H. The replacement string is prompted for and kept at 5242H with its length at 5207H, exactly as the search string is kept at 522AH with its length at 5206H. The search then starts one character below the cursor rather than one above it, so that the occurrence the cursor is sitting on, which is where a preceding SEARCH or FIND NEXT left it, is the one replaced.

5981H - Locating the Marked Block and Copying It

Shared by block copy and block move. The first marked block in the text is found, the cursor is checked to be outside it, and 598CH then opens a gap at the cursor and copies the marked characters into it. The two markers themselves are left where they are and are not copied, which is the manual's "the successful block copy operation only copies the marked text; the markers are not copied as well".

598CH - Opening a Gap and Copying Text Into It

Given the last byte of a run of source text in Register Pair HL and the byte before its first in Register Pair DE, insert that run into the text at the cursor. Used both by block copy and move, where the source is the marked text itself, and by replace, where it is the replacement string in the workspace at 5242H. The text after the cursor is pushed up first and the run is then copied down into the hole, both with backwards block moves so that overlapping source and destination cannot corrupt the text.

59C5H - Folding a Letter to Upper Case

Used only by the block sub-command dispatcher, so that the six letters may be typed in either case as the manual promises. Anything that is not a lower case letter is left alone.

59CEH - Finding the Marked Block

Searches forward for the block end marker 0FFH and then backwards from it for the block begin marker 0FEH, so that a stray begin marker earlier in the text cannot be picked up. 59CEH searches from the start of the text, which is what copy, move and print use to find "the first block marked in the text"; 59D1H searches from the cursor, which is what block delete uses to find the block the cursor is standing in.

59F5H - Testing Whether the Cursor Is Inside the Block

Called with Register Pair HL addressing the block begin marker and Register Pair DE the end marker. The CARRY FLAG comes back set when the cursor is outside the pair. Block delete needs it clear, because the cursor identifies which marked block is meant; copy and move need it set, because a block cannot be copied into itself.

5A04H - Distance to the End of the Text

Two entries. 5A04H loads the end-of-text pointer from 58C2H first; 5A07H works on whatever is already in Register Pair HL. Both leave the difference in Register Pair BC as well as in Register Pair HL, because almost every caller wants it as a block move count.

5A0DH - The Prompt Line Input Routine

Reads a reply to a status line prompt into the buffer at 5BB4H, echoing each character as it is typed. Four keys are special: ENTER accepts the reply, the BREAK code 01H abandons it and returns with the CARRY FLAG set, the left arrow backspaces over the last character, and 18H, CTRL X, backspaces over all of them. Everything below 20H or at 80H and above is ignored.

The loop is built by planting 5A1BH on the stack as the return address at 5A26H, so that every path through the body simply RETurns to go round again; the two exits pop that address and the saved buffer start together and return to the real caller. The reply is terminated in the buffer with 03H and the number of characters is returned in Register B.

The length limit in Register B comes from Register C, which the caller has not set. The status line writer at 590AH leaves Register C holding the terminating byte of the prompt it has just displayed, and every prompt in the module ends with a space carrying bit 7, so the limit is always 0A0H, 160 characters, into a 24-byte buffer.

5A71H - The Cursor Primitives

A four-way dispatcher on the function code in Register B: 1 reads the character at the cursor into Register A, 2 writes the character in Register C there, 3 sets the hardware cursor position from the row in Register H and the column in Register L, and 4 returns the current row and column in Register Pair HL. Register B is counted down rather than compared, so any code of 5 or above simply falls out of the bottom and returns having done nothing, which is the exit the screen refresh uses at 57E6H.

5A9DH - Video Address from Row and Column

The screen is 16 lines of 64 characters based at 3C00H, so the address of a cell is 3C00H plus 64 times the row plus the column. The routine builds it by putting the low two bits of the row into the top two bits of the low byte and the high two bits of the row into the low two bits of 3CH, which costs four rotates and no multiplication.

5AADH - Ruling Off the Text Area and Clearing the Status Line

The screen is divided into fourteen lines of text on video rows 0 to 13, a rule of underscores on video row 14 and the status line on video row 15. This routine draws the rule and blanks the status line, and is called at start-up and again after a directory listing has scrolled the screen.

5ABFH - The BREAK Key Test

The DOS keyboard driver records a BREAK by setting bit 0 of KFLAG$ at 4423H rather than returning it as a character. This routine clears that bit and then looks again a moment later, so that holding BREAK down holds the program here; it is called at the top of the main loop and between characters while the buffer is being printed. The NZ FLAG on return means BREAK was pressed, which is what stops a listing at 53D2H.

5AE2H - Text Constants and Messages

Every string in the module ends with a character whose bit 7 is set, which is what the status line writer at 5922H tests, and none of them carries a length byte. Two of them overlap on purpose: 5B4FH is Load Filespec? and 5B54H is the same text five characters in, Filespec? , which is how one string serves both the LOAD and the FILE prompt.

The three bytes at 5AE2H are not a message at all. They are the default file extension handed to the resident @FEXT vector at 5669H, and they carry no terminator because @FEXT always takes exactly three characters. The 0FH at 5AE5H is the video control code that turns the ROM cursor off and is displayed as the first character of the sign-on banner.

5B76H - Padding

Thirty-two zero bytes that round the image out. They are loaded, so they are part of the file, and the last two of them are read as data: the screen refresh sets Register Pair IY to 5B94H at 57BEH, one entry below the line table, and the routine at 58A4H reads the entry below the one it is given, so a request for the row above row 0 lands on 5B94H and 5B95H and finds zero there.