LDOS 5.3.1 for the Model III - SYS7/SYS Disassembled

SYS7/SYS

Other Navigation

LDOS 5.3.1 SYS7/SYS Disassembly: Library B (Model III)

SYS7/SYS is Library B of LDOS 5.3.1: thirteen members, each a separate program that carries out one or more of the commands typed at LDOS Ready (or passed by a program through 429CH). Fourteen commands are served: AUTO, TIME, DATE, CREATE, VERIFY, DEBUG, FREE, SYSTEM, BUILD, ATTRIB, DUMP, PURGE, FORMS and SETCOM; a fifteenth member header, 1CH, names SYSGEN, the member that SYSTEM (SYSGEN) runs. Every member loads at 5200H, directly above the overlay area 4E00H-51FFH. Only one member is in memory at a time, and the next library command loads its own member over it.

The file is 12423 bytes: a header record (05H) with the name sys7, a copyright record (1FH) with the text (C) 1982-4,6,90 MISOSYS, fifteen member headers (08H), a record 0AH that ends the headers, an empty member 0 (a record 04H alone), then the thirteen members, each ended by a record 04H, and a transfer record (02H) for 0000H. Each member header holds six bytes: the member byte, the entry address, and the record and byte of the file where the member's load blocks begin. Members that serve two commands have one header for each command, both pointing at the same place in the file with different entry addresses. The members hold 11993 loaded bytes.

How a Member Is Run

What the Members Have in Common

What Differs from the Model I File

The Members

About This Page

5200H - Member 1 (AUTO): Entry and AUTO ?

The AUTO command (library member 11H), loaded at 5200H-5351H. SYS1/SYS's command loop issues request 89H (Library B) with Register B = 11H; the overlay loader of SYS0/SYS (4BF4H) loads this member and the supervisor dispatcher calls 5200H with Register Pair HL at the text after AUTO. The AUTO command of a diskette is kept in its granule allocation table, bytes E0H-FFH of the sector (43E0H-43FFH once the sector is read into 4300H); SYS0/SYS's reset runs it after the boot. AUTO ? displays it, AUTO = runs it now (5232H), and AUTO followed by a command stores that command (5261H); AUTO alone stores an empty one (0DH). Each form may name the drive with :d first; drive 0 when not.

522EH - AUTO =: Run the AUTO Command Now

With an equals sign the AUTO command of the diskette is read from its granule allocation table and run at once through 429CH, as the reset runs it after a boot. A leading asterisk (2AH) is passed over and turns BREAK off (bit 4 of SFLAG$), as the reset does for such a command. The command is copied out of the buffer at 4300H first, since loading SYS1/SYS uses that buffer.

5261H - AUTO command: Store a New AUTO Command

Any other text after AUTO (after an optional :d) is stored as the new AUTO command in bytes E0H-FFH of the drive's granule allocation table, up to and with its 0DH; nothing but ENTER stores an empty command. The sector is then written back (52E3H). A command of 32 bytes or more is refused with Command line too long!, a write protected drive with Destination disk is write protected!.

52A1H - Check the Drive and Read Its Granule Allocation Table

Register C gets the drive from the operand at 52A2H. @CKDRV (4209H) checks that the drive is there and ready and sets the CARRY FLAG when its diskette is write protected; that is kept at 5268H for 5267H. A drive that is not ready gives error 20H, a table that cannot be read error 14H; either is reported at 5296H, which ends the command, so a return from here means success.

52B4H - Take an Optional Drive Specification

When the text at Register Pair HL starts with a colon, the character after it is the drive number: it is stored at 52A2H (the operand of LD C at 52A1H), and the spaces after it are passed over. A digit that is not 0-7 gives error 20H. Without a colon nothing is taken, so the drive stays 0.

52D0H - Read and Write the Granule Allocation Table

52D0H reads sector 0 of the directory cylinder of drive Register C (the granule allocation table) into 4300H; 52E3H writes it back from 4300H with the deleted data mark that every directory sector carries and verifies it. Both return the Z FLAG on success; on failure 52D0H returns Register A = 14H (GAT read error) and 52E3H Register A = 15H (GAT write error), with the NZ FLAG. Register Pairs DE and HL are kept.

52FBH - AUTO Data: Messages

The three messages, each ended by 0DH. The LD IX instructions at 5280H and 5284H hold the addresses of the first and the last.

5200H - Member 2 (DATE and TIME): Entries and Name Tables

The DATE command (library member 15H, entry 5203H) and the TIME command (member 16H, entry 5200H), loaded at 5200H-5488H. The supervisor dispatcher calls the entry with Register Pair HL at the text after the command word. DATE shows the system date as, for example, Tue, Jan 1, 1980, or sets it from MM/DD/YY; TIME shows the time as HH:MM:SS, sets it from HH:MM or HH:MM:SS, and with (CLOCK) or (CLOCK=N) starts or stops the clock display at the top right of the screen. The date is kept in DATE$ (421AH-4418H), SVDAT1$ and SVDAT2$ (442FH, 4457H) and the year offset at 4413H; the time in TIME$ (4217H-4219H).

524CH - DATE: Set the Date from MM/DD/YY

Without text DATE goes straight to 528DH to show the date. With text the three fields are read by 53F5H into 52CDH (the month), 52CCH (the day) and 52CBH (the year); the year must be 80-99 (1980-1999) or 00-11 (2000-2011), the month 1-12 and the day within the month (29 days in February of a leap year). The three bytes are then copied into DATE$ at 421AH-421CH (year, day, month).

528DH - DATE: Note the Date for the Reset, Then Show It

Reached with Register Pair DE = 421AH both after a new date and when DATE has no text. The year less 1980 goes to 4413H, bit 7 of 4418H is set for a leap year (it is not cleared otherwise), the day to SVDAT2$ (4457H) and the month OR 50H to SVDAT1$ (442FH), which SYS0/SYS's reset uses to keep the date over a reset. A month of 0 means no date was ever set: Date not in system.

52CEH - TIME: Parameters, Set the Time

The text is searched for an opening bracket: when there is one, @PARAM (4454H) reads (CLOCK) or (CLOCK=N) into the operand at 5321H. Then the text is looked at from its start again: nothing shows the time (53DDH); a bracket alone goes to the clock (5320H); otherwise HH:MM or HH:MM:SS is read (hours 0-23, minutes and seconds 0-59) and stored in TIME$ (4217H-4219H: seconds, minutes, hours).

5320H - TIME (CLOCK): Start or Stop the Clock Display

The CLOCK parameter is the operand at 5321H: 0001H when it was not given, FFFFH for CLOCK, 0000H for CLOCK=N. CLOCK sets bit 0 of 4210H through the ROM's 0298H, so the ROM's clock routine, run by SYS0/SYS's clock task, writes the time at the top right of the screen; CLOCK=N clears it through 02A1H. (The Model I file puts a clock display task of SYS0/SYS into task slot 6 instead.) Five times a second; CLOCK=N takes slot 6 out again through @RMTSK.

5336H - DATE: The Day of the Year, the Day of the Week and the Display

Register A = the month (1-12) from 421CH. The day of the year is the day plus the days of the months before (523FH on, February 29 days in a leap year); it goes to 4417H and bit 0 of 4418H. The day of the week is (day of the year + y + (y + 3) / 4 + 1) mod 7 + 1, y the year less 1980 (1 for Sunday, 1 January 1980 a Tuesday); it goes to bits 3-1 of 4418H. Then the template at 5459H gets the day name, the month name, the day and the year, and the line is displayed.

53DDH - TIME: Show the Time

@TIME writes the time as HH:MM:SS in the eight bytes 5462H-5469H of the template, which the 0DH at 546AH ends; 53D6H then displays it.

53E6H - Copy Name Number B from a Table of Three Letter Names

Register Pair HL = the table, Register B = the name number (1 for the first), Register Pair DE = the destination. The three letters of the name at HL + 3 x (B - 1) are copied to DE, which comes back after them. The tables do not cross a page, so only Register L is added to.

53F5H - Read Three Fields of Two Digits

Reads up to three fields from the text at Register Pair HL, each of exactly two digits, into 52CDH, 52CCH and 52CBH (the first typed at 52CDH). Between two fields one character is taken: a colon, or any character below the value of Register C (30H: a slash, a space, a dash or a period). ENTER after the second field is accepted only when the operand at 5412H is 00H (TIME, 52F9H); then the third field keeps its value. Returns the Z FLAG with Register B = 00H and Register Pair DE = 52CBH when the fields were read, else the NZ FLAG.

541AH - Read Two Decimal Digits

Reads two characters at Register Pair HL; both must be digits. Returns Register A = their value (0-99) with the Z FLAG, or the NZ FLAG when either is not a digit. Register Pair HL comes back after the characters read; Register E is changed.

5437H - Write a Number in Decimal, Right Justified

Register Pair HL = the number, Register Pair DE = the first of five places. The five places are filled with spaces, then the digits are written from the last place backwards until the number is 0. Register Pair DE comes back after the five places; Register Pair HL is 0000H.

5450H - DATE and TIME Data: Parameter Table, Template and Messages

The parameter table of TIME (one keyword), the line that DATE and TIME fill and display, and the two messages.

5200H - Member 3 (CREATE): Entry and the Parameters

The CREATE command (library member 13H), loaded at 5200H-53D2H. It makes a file of a given size ahead of time: SIZE=K (kilobytes, four 256 byte sectors each) or REC=n (records, with LRL=l, 1-256, the record length). The file is opened or created with @INIT, its last record written so that all its space is allocated, and its directory record marked with bit 7 of +01H, which keeps @CLOSE from giving the space back. Without FILL the end of file is put back to what it was, so a new file stays empty; FILL=c writes every record full of the byte c. SHRINK clears the mark again. The file's control block is at 53E2H and its name for the message at 53D3H, above the member; the buffer is 5500H.

5274H - Show the Name and Extend the File

The name is shown after Creating:. A file that already has as many records as asked for, or more, is refused with File exists larger! (it stays as it is). Otherwise the last record wanted is written with E5H bytes, which allocates the whole size, and the directory record gets bit 7 of +01H and the record length.

52D1H - FILL: Write Every Record

The FILL parameter is the operand at 52D2H-52D3H: 0100H in the file (not given). FILL=c stores the byte c in the low byte and 00H in the high byte; FILL alone stores FFFFH (records of FFH). Both 5500H-55FFH (the buffer) and 5600H-56FFH (the record @WRITE takes when the record length is below 256) are filled with the byte, and every record of the file is written. Without FILL the end of file is put back to what it was before (5301H), so the file keeps its space but not its records.

5318H - SHRINK and the Exit

The SHRINK parameter is the operand at 5319H-531AH: 0000H in the file, FFFFH when SHRINK is given. With SHRINK, 5333H turns the SET at 533EH into a RES, so that bit 7 of +01H of the directory record is cleared again: the next close of the file gives back the space beyond its end of file.

5333H - Mark the Directory Record

5333H (SHRINK) changes the second byte of the bit instruction at 533EH from FEH (SET 7,(HL)) to BEH (RES 7,(HL)) and goes on into 5338H. 5338H reads directory record Register B of drive Register C, sets (or clears) bit 7 of its +01H, stores the record length (the operand at 5344H) in its +04H and writes the sector back. An error ends the command at 52F7H.

5358H - CREATE Data: Parameter Table and Messages

Each entry of the parameter table is a keyword of six characters (padded with spaces) and the address where @PARAM stores its value: the operand of the instruction that uses it. The table ends with 00H. Then the three texts.

5200H - Member 4 (DEBUG and VERIFY): Entries and DEBUG

The VERIFY command (library member 1BH, entry 5200H) and the DEBUG command (member 14H, entry 5203H), loaded at 5200H-534DH. DEBUG turns DEBUG on (bit 7 of SFLAG$, so that @RUN enters DEBUG at a program's first instruction, and the BREAK trap at 4405H-4407H set to JP 400FH, so that BREAK enters it) or off with (OFF) or (N). DEBUG (EXT) also loads the extended DEBUG commands (request 8BH, SYS9/SYS) and DEBUG (OFF,EXT) gives their memory back when they are the lowest module above HIGH$. VERIFY (ON) or VERIFY (OFF) points the @WRITE vector at the write with or without the verify of every sector. Both read their parameters through 5296H or 529BH, which return the Z FLAG when OFF (or N) was given.

522FH - DEBUG (OFF): Turn DEBUG Off

Bit 7 of SFLAG$ is cleared and the BREAK trap switch gets C9H. With EXT as well, the extended DEBUG commands are taken out: when 4400H-4401H no longer holds 4876H (the default, a plain return) and points at HIGH$ + 1 (the module is the lowest in high memory), HIGH$ is put back from the module's link word (its +02H-+03H) and 4400H-4401H gets 4876H again.

5262H - DEBUG (EXT): Load the Extended DEBUG Commands

Only at LDOS command level: when @EXIT (402DH) holds a JP (a program has taken it over) or bit 1 of 4758H is set (a command line from a program), the command is refused with Can't -- Only valid at LDOS command level!. Request 8BH loads SYS9/SYS, which installs the extended commands in high memory; its RET comes back to the caller of 5262H.

5275H - VERIFY: Point the @WRITE Vector

VERIFY reads its parameters with the table at 532DH (ON, OFF, Y, N). With OFF or N the @WRITE vector (the JP at 4439H, operand 443AH-443BH) goes to 48CBH, the plain write; otherwise to 48E6H, the write that verifies each sector after writing it. Then the common exit.

5296H - Read the Parameters, Test OFF

5296H uses the DEBUG table (531DH), 529BH the VERIFY table (532DH). The Stack Pointer is saved for the exit (the return address of this CALL is on top, 5289H takes it off). A bad parameter reports error 2CH and ends the command. Returns the Z FLAG when OFF or N was given (FFFFH at 52AAH), the NZ FLAG otherwise: ON and Y are stored at 52B1H, which no code reads.

52B3H - Messages and Errors

52B3H (DEBUG during a JCL job) and 52B8H (EXT not at LDOS command level) display a message; 52C3H reports an error number through @ERROR. All three end the command with Register Pair HL = FFFFH.

52CAH - DEBUG and VERIFY Data: Messages and Parameter Tables

The two messages, then the parameter table of DEBUG; its last four entries (from 532DH) are the parameter table of VERIFY. Each entry is a keyword of six characters and the address where @PARAM stores the value.

5200H - Member 5 (SYSGEN): Entry, the JCL Pause and the Checks

The SYSGEN member (library member 1CH), loaded at 5200H-553FH. No command word leads here: SYSTEM (SYSGEN) (member 7, its 58B7H-58BBH) issues request 89H with Register B = 1CH, Register H = the drive and Register L = FFH to build or 00H to delete. Building writes CONFIG/SYS.CCC:d, a load module that holds the memory above HIGH$ and the resident cells that SYSTEM, SET, ROUTE, LINK and the drivers change, and sets byte 01H of the drive's system information sector to 00H so that SYS0/SYS's reset loads it; deleting sets that byte to C9H and kills the file. A running JCL job is paused first (53A2H) and resumed at the end (53D6H). Only at LDOS command level.

5229H - Build: The Name Record and the Banner

CONFIG/SYS is created with @INIT (records of 256 bytes, buffer 5610H) and written byte by byte through the ROM's @PUT (538BH) as a load module: a name record (05H) with CONFIG, a load block that writes the banner CONFIGURING (with three asterisks each side) on the screen at 3F96H while the file loads, and a load block of one C9H (RET) for 4012H, the interrupt vector, so that no interrupt is served while the file loads (the reset puts the C3H back afterwards).

5262H - Build: The Memory above HIGH$

The top of memory is found by changing a byte and reading it back, from FFFFH down in steps of 4000H (16K). Everything from HIGH$ + 1 to the top is written as load blocks (52EBH): the modules that have installed themselves in high memory. Then 4018H is cleared and the table at 54CEH names the resident cells that are written next, each as load blocks of its current contents.

529AH - Build: The Drive Code Tables, the End and the Flag

The 80 bytes of the drive code tables (DCT$, 4700H-474FH) are written as a load block for 4152H: SYS0/SYS's reset copies them from 4152H to 4700H after loading the file. Two loads of Register Pair HL stand where a load block for 4012H would be written; no block is written there. A load block of 19 spaces then clears the banner, the transfer record (02H 02H, address 0000H) ends the module, and the file is closed. Byte 01H of the drive's system information sector (cylinder 0, sector 2) is set to 00H: the reset loads CONFIG/SYS. Finally the file is made invisible and protected through @CMNDI.

52EBH - Write a Block of Memory as Load Blocks

Register Pair DE = the first byte, Register Pair BC = the number of bytes (not 0). The bytes are written to CONFIG/SYS as load blocks (type 01H, length = count + 2, address low, address high, the bytes) of at most 254 bytes each.

5324H - Write One Load Block from a Buffer

Register Pair HL = the bytes, Register Pair DE = the address they are to be loaded at, Register B = the count (1-254). Writes the type 01H, the length (count + 2), the address and the bytes to CONFIG/SYS. Register Pair DE comes back as 53EDH, the file control block.

5346H - Delete: SYSGEN=OFF

Byte 01H of the drive's system information sector is set to C9H (no configuration file), the sector written back, and CONFIG/SYS.CCC:d killed. When the file is not there, No user configuration found is displayed (the sector has been changed all the same).

5366H - The Exit

5366H loads Register Pair HL with the Stack Pointer that 5200H stored in its operand, and 5369H loads the Stack Pointer with 0000H, the operand that nothing changes: the CALL at 536CH and the RETs below use the stack at 0000H, so their return address is read from 0000H-0001H, the first bytes of the ROM (F3H AFH). The error paths (538FH, 5396H, 539AH) come to 5369H with Register Pair HL = their own value.

537BH - Read the System Information Sector; Write One Byte

537BH reads cylinder 0, sector 2 of the drive (the operand at 5382H) into 4300H. 5389H writes 02H and 538BH the byte in Register A to the file at Register Pair DE through the ROM's @PUT (001BH). An error is reported through @ERROR (538FH) and ends the command at 5369H.

53A2H - Pause and Resume a JCL Job

53A2H keeps SFLAG$ (442BH) in the operand at 53D7H. When bit 5 is set (a JCL job runs) it clears it, copies the six bytes saved at 4065H-406AH (the @EXIT and @ABORT that were in force before the job) back to 402DH-4032H, puts the keyboard driver saved at 42BEH-42BFH (KIJCL$) back into the keyboard's device control block (keeping the job's driver at 53E6H) and sends the keyboard driver a control request. 53D6H undoes this when the kept SFLAG$ had bit 5 set: SFLAG$ back, the six bytes at 406BH-4070H (the job's own stubs, which SYS11/SYS copies from there too, its 4E33H) to 402DH-4032H, and the job's keyboard driver back to 4016H-4017H.

53EDH - SYSGEN Data: The File Control Block, Messages and the Table of Cells

The file control block of CONFIG/SYS (32 bytes, only its first 17 in the file), the messages, the Attrib command, the banner and its blank, and the table of resident cells that 5284H saves into the file.

5200H - Member 6 (FREE): Entry and the Text

The FREE command (library member 22H), loaded at 5200H-55A3H. FREE alone shows one line for each drive that is ready: Drive :d, the diskette's name and date, the cylinders, density and heads, the free and the total space in kilobytes and the free and the total directory records (template at 5512H). FREE :d clears the screen and shows that drive's line followed by a map of its granules, six cylinders to a line: x a granule in use, a period a free one, an asterisk one locked out, D the directory cylinder. (P) sends every line to the printer as well, with no pause at the end of a page. The line is built in the 64 byte buffer at 555AH-5599H (not in the file), which the 03H at 559AH ends.

5228H - FREE: One Line for Each Drive

Drives 0 to 7 are checked with @CKDRV in turn and the line of each one that is ready is shown (52C7H). With P a space and ENTER go to the printer first.

524BH - FREE :d: The Granule Map

The drive must be 0-7 and ready, else error 20H. 53DBH clears the screen and shows the drive's line and a line of dashes; then each line of the map gets its cylinders' label (the first from the template " 0- 5" at 5553H) and, for each of six cylinders, one character per granule in a column of nine (D for every granule of the directory cylinder).

52C5H - Build and Show the Line of a Drive

52C5H takes the drive from its operand (the drive of FREE :d), 52C7H from Register C. The granule allocation table is read into 4300H and the template at 5512H filled: the drive's digit, the free granules as kilobytes (5409H), the cylinders, the density (S, D, or H for a rigid drive) and the heads, the total size, the free and the total directory records (from the hash index table, read into 5600H), and the diskette's name and date from the table (43D0H-43DFH). Index Register IY is left at the drive's code table.

53C6H - The Page: Count the Lines, Pause and Start Again

53C6H is reached after a line has been shown on the screen without P. The operand at 53C7H counts the lines left on a page (15). When it runs out it is set to 15 again and, unless a JCL job runs, the program waits for a key (0049H), clears the screen and shows the drive's line and a line of dashes again (53DBH) before the next line of the map.

53F5H - Show a Line, Then Print It or Count It

53F5H shows the line buffer, 53F8H the text at Register Pair HL (ended by 03H) on the video through @DSPLY. With P (FFFFH at 53FCH) the same text and an ENTER go to the printer; without P the line is counted on the page (53C6H).

5409H - Granules to Kilobytes

Register Pair DE = a number of granules, Register Pair HL = where to write. The granules times the sectors in a granule (the operand at 540EH) give the sectors; a quarter of them are the kilobytes, written in five places; the two bits left over give the digit of the tenths in Register A: 0, 2, 5 or 8.

5435H - Write a Number in Decimal

Register Pair HL = the number, Register Pair DE = where to write. 543DH writes five places, 5439H three (hundreds, tens, units) and 5435H two; leading zeros become spaces, the units are always a digit. Register A carries the character for a zero place from one call of 545DH to the next: a space until the first digit that is not 0, then 30H. No code of the member calls 5435H.

5478H - The Map: Characters for One Cylinder

5478H writes Register A characters at Index Register IX, one for each granule of the cylinder whose allocation table byte is at Register Pair HL: x for a bit set (in use), a period for a bit clear. Then, on a floppy drive (bit 3 of +03H clear), an asterisk replaces the character of each granule whose bit is set in the lock out table (the byte at HL + 60H). The table bytes are rotated in place. 54A9H writes Register A characters D for the directory cylinder. Both leave Index Register IX after the characters; Register Pairs BC and HL are kept.

54B5H - The Map: The Label of the Next Line

Register C = the last cylinder shown. The label of the next line is written at 555AH: the first cylinder (C + 1) in three places, then, unless it is the highest cylinder, a dash and the last cylinder of the line (up to five more, not past the highest). Register Pairs BC and DE are kept.

54E1H - Read the Granule Allocation Table (Not Called)

Reads sector 0 of the directory cylinder of drive Register C into 4300H; returns the Z FLAG, or Register A = 14H (GAT read error) with the NZ FLAG. No code of the member calls it: 52D1H-52D9H read the table themselves.

54F4H - Errors and the Exit

54F4H reports error 2CH, 54F6H the error in Register A, through @ERROR; 5500H is the end of a command carried out.

5512H - FREE Data: The Line Template, the Map Label, the Line Buffer and the Parameter Table

The line of a drive is built over the template at 5512H-5552H; the map's lines in the buffer at 555AH-5599H, which the file does not load.

5200H - Member 7 (SYSTEM): Entry, the Parameters, SLOW and FAST

The SYSTEM command (library member A1H), loaded at 5200H-5D4BH, the largest member. One call of @PARAM reads every parameter in the brackets against the table at 5C63H (29 keywords), and each value goes straight into the operand of the LD BC (or LD HL, LD DE) that tests it. The options are then taken one after the other in a fixed order, each skipped when its keyword was not given: SLOW, FAST, BASIC2, PRTIME, BREAK, DATE, TIME, TRACE, BSTEP, BLINK (LARGE, SMALL), TYPE, SMOOTH, GRAPHIC, ALIVE, SVC, SYSRES, the drive options (DRIVE, WP, CYL, DISABLE, ENABLE, STEP, DELAY), DRIVER, SYSTEM, SWAP and SYSGEN. A keyword alone stores FFFFH, KEY=N 0000H, KEY=value the value; the value in the file (0000H, 0001H or FFFFH) means not given. FAST sets bit 3 of SFLAG$ and bit 6 of the copy of port ECH at 4210H (sent to port ECH) and makes the tick pattern 4762H 55H, so the tasks run on every other clock tick; SLOW clears both bits and puts FFH back.

523EH - BASIC2: Leave LDOS for the ROM's BASIC

BASIC2 starts the Level II BASIC of the ROM without the disk system: the ROM's power-up copy of 4000H-404DH (78 bytes at 36AAH: the restart vectors, the device control blocks and the other vectors) and of 41E5H-4244H (96 bytes at 36F9H) are copied into place, the screen is cleared and the ROM's own start continues at 0075H after its 3042H. It does not return.

5268H - PRTIME: The Printer Time Out of PR/FLT

The printer filter PR/FLT keeps its module address at 4DF6H-4DF7H (0000H when it is not installed: Printer filter not resident!). Byte +19H of the module is taken as the offset of the filter's time out byte; PRTIME=ON stores 1BH there, PRTIME=OFF 00H. In PR/FLT that byte is 38H, the code of a JR C, so the store lands on the POP DE at module +38H (53BDH on the PR/FLT page), and the next byte the filter prints returns to a wrong address.

5288H - BREAK: Allow or Disable the BREAK Key

BREAK=ON clears bit 4 of SFLAG$ and stores 00H (NOP) at 4BEFH; BREAK=OFF sets bit 4 (the interrupt's keyboard scan then ignores BREAK) and stores C8H (RET Z) at 4BEFH, so that request code 01H returns at once with Register A = 00H.

52A1H - DATE and TIME: The Prompts at Boot

DATE=OFF and TIME=OFF store FFH in byte C2H or C3H of drive 0's system information sector, so that the boot does not ask for the date or the time; DATE=ON and TIME=ON store 00H, so that it asks. The sector is read and written through 58CEH and 58DBH.

52CFH - TRACE and BSTEP

TRACE=ON puts SYS0/SYS's task block 4D76H into task slot 11, which shows the address the program is at in the top right of the screen on every tick; TRACE=OFF empties slot 11. BSTEP=n (0-3) stores the step rate the boot uses in bits 1-0 of byte +03H of drive 0's table in the system information sector (always the second block, at 4370H); a larger value shows Boot step out of range.

5307H - BLINK: The Blinking Cursor

The Model III ROM blinks the cursor itself: its clock routine shows the character at 4023H (DODCB$ +06H) and a space in turn while the blink switch at 401CH (KIDCB$ +07H) is 00H. BLINK=OFF stores FFH at 401CH; BLINK, BLINK=ON or BLINK=c store the cursor character (c, or 8FH with LARGE, 88H with SMALL, B0H otherwise) at 4023H and 00H at 401CH. No module is put in high memory, as the Model I file does.

5334H - TYPE: Type Ahead

TYPE=OFF clears bit 1 of DFLAG$ (4289H). TYPE=ON needs KI/DVR (bit 4 of DFLAG$, else TYPE requires KI to be active) and its type ahead buffer (the word at 4DF2H not 0000H, else Type-ahead not resident); then bit 1 is set. The test meant to find type ahead already on reads bit 1 of the message text at 5AAAH, whose bit is clear, so it never finds it.

5371H - SMOOTH and GRAPHIC

SMOOTH=ON stores F3H (DI) and SMOOTH=OFF 00H (NOP) at 46F7H, the spare byte of the floppy driver of SYS0/SYS (between its LD C,F3H and its RET at 46F8H), so DI runs there before each transfer. GRAPHIC=ON sets and GRAPHIC=OFF clears bit 7 of DFLAG$.

5397H - ALIVE: The Alive Indicator Module

ALIVE=ON puts the module $AL (53F9H-5411H, 25 bytes) below HIGH$ (or uses the one already there) and its task block into task slot 3: five times a second it changes the character at the top right of the screen (3C3FH) between the graphics characters 86H and 89H. ALIVE=OFF empties slot 3 and gives the memory back when the module is the lowest in high memory.

53F9H - The $AL Module: The Alive Indicator

Copied to high memory by 53EAH; the addresses in the comments are those of this member. Its task block (+08H) names the routine at +0AH, which SYS0/SYS runs in slot 3 five times a second.

5412H - SVC: The Supervisor Calls below 80H

SVC copies the module $SVC (5460H-5584H, 293 bytes) below HIGH$ and points the supervisor dispatcher's jump for request codes below 80H (the operand at 4BCEH-4BCFH) at the module's dispatcher (+109H): a program then calls a system routine by its number with LD A,n and RST 28H. Bit 0 of SFLAG$ notes that it is installed (a second SVC shows SVC table already implemented).

5460H - The $SVC Module: The Table of Supervisor Calls

Copied to high memory by 544DH; the addresses in the comments are those of this member. After its header comes the table of 128 routine addresses for the supervisor call numbers 0-127 (from +09H), then the dispatcher (+109H) and the routine for number 100 (+11AH). The supervisor dispatcher of SYS0/SYS jumps to the dispatcher for any request code below 80H with the RST 28H's return address still on the stack, so the routine's RET goes back to the program.

5569H - The $SVC Module: The Dispatcher and SVC 100

5569H is entered from 4BCDH with Register A = the supervisor call number (0-127) and the program's registers. It looks the number up in the table and goes to the routine with Register A = the value of Register C (the call's argument) and Register Pair HL as it was. 557AH is supervisor call 100: with Register Pair HL not 0000H it stores HL as HIGH$; in either case it returns HIGH$ in Register Pair HL.

5585H - SYSRES: Keep a System File in Memory

SYSRES=n (1-5 or 8-12) keeps SYSn/SYS in high memory, so that its requests no longer read the diskette. The first SYSRES puts the module $SR (563FH-56A4H) below HIGH$ and points the supervisor dispatcher's CALL (operand 4BDEH-4BDFH) at its hook (+28H). Then the file is loaded through the overlay loader (4BF4H), copied below HIGH$ with its length in front and an 8 byte header named $Sn, and its address noted in the $SR module's table. SYSRES=0, 6, 7 or 13 and up shows Can't SYSRES requested module, a file already kept System module already resident.

563FH - The $SR Module: System Files Kept in Memory

Copied to high memory by 5631H; the addresses in the comments are those of this member. Its table holds one word for each request code's low four bits: the address of the length word in front of a file kept in memory, or a high byte of 00H. The supervisor dispatcher calls the hook (+28H, 5667H) with Register A = the request code (Register B = the library member): a file kept in memory and not already at 4E00H is copied there (its length to 4BC8H, 4E00H as the entry at 4BE4H, the code to OVRLY$); any other request goes on to the overlay loader at 4BF4H.

56A5H - The Drive Options: DRIVE, WP, CYL, DISABLE, ENABLE, STEP, DELAY

With DRIVE=d the options apply to drive d only; without it WP, CYL, ENABLE, STEP and DELAY apply to every drive in turn (DISABLE needs DRIVE). Index Register IY points at the drive's code table in DCT$ (4700H + d x 10), Index Register IX at the same drive's table in drive 0's system information sector at 4300H (the block at 4320H after a boot through a driver, else 4370H), which is read first and written back afterwards when CYL is given: CYL changes only the copy the boot uses. WP sets the software write protect (bit 7 of +03H), DISABLE puts a RET (C9H) and ENABLE a JP (C3H) at +00H, STEP=n the step rate (bits 1-0 of +03H, unless bit 4 of +04H is set), DELAY=ON clears and DELAY=OFF sets bit 2 of +03H (one motor wait less).

5783H - DRIVER: Load a Disk Driver

DRIVER="filespec" loads the driver file (default extension /DCT) with @LOAD and runs it at its transfer address with Register Pair DE = the code table of the drive named by DRIVE (0000H for none) and bit 3 of 4758H set. DRIVER alone asks Enter DCT driver <BREAK=default> : ; BREAK there puts the drive table that the boot uses (from the system information sector) back into the code table, from byte +03H on, for the drive of DRIVE or drive 0.

5820H - SYSTEM and SWAP: Exchange Two Drives

SWAP=d exchanges the code tables of drive d and the drive of DRIVE (drive 0 when DRIVE is not given); SYSTEM=d is SWAP=d with drive 0. Both drives must be 0-7 and different. A drive that becomes drive 0 must hold a system diskette (58F1H). The JCL file of a running job follows its drive (5932H). The ten bytes of each table are exchanged through 4300H.

589CH - SYSGEN and the Exit

SYSGEN (or SYSGEN=OFF) is refused while the spooler is installed (bit 0 of DFLAG$). Otherwise Preparing to alter configuration is shown and Library B member 1CH (SYSGEN, member 5) is run through request 89H with Register H = the drive (DRIVE, 0 when not given) and Register L = FFH to build or 00H to delete; it loads over this member and does not come back here. 58BCH and 58BFH are the exit of every option.

58CEH - Read and Write Drive 0's System Information Sector; Errors

58CEH reads cylinder 0, sector 2 of drive 0 into 4300H, 58DBH writes it back; either reports a failure through @ERROR and ends the command. 58E7H (inside the LD BC at 58E6H) reports error 2CH, a parameter error.

58F1H - A System Diskette in the Drive Register A

The drive must hold a system diskette when it is to become drive 0: it must be ready and directory record 03H (the first record of directory sector 5, SYS1/SYS's) must be in use. Otherwise Insert SYSTEM diskette in drive X! is shown and ENTER makes it look again; BREAK ends the command with Manual <BREAK> abort!. During a JCL job no prompt is possible: Can't prompt for SYSTEM disk during JCL!.

5932H - A JCL Job's File Follows the Swap

During a JCL job the drive in byte +06H of JFCB$ (426BH, the job file's control block at 4265H) is changed to the other drive of the swap when it is one of the two drives exchanged, so that the job reads its file from where its diskette now is.

5954H - Find a Module in High Memory; the Command Level Test; Messages

5954H finds the module whose name is at Register Pair DE through request BCH (SYS10/SYS) and returns the Z FLAG with Register Pair HL = the module and Register Pair DE = its link word (+02H-+03H). 5964H refuses a change of memory when a program owns @EXIT (402DH, or its copy at 4065H during a JCL job, holds a JP) and the command line came from a program (bit 1 of 4758H). 597AH-5995H is a chain of LD IX instructions: each entry after the first is the LD HL hidden after the DDH prefix, so a jump into the chain picks one message for @LOGOT.

599EH - SYSTEM Data: Messages, the Default Extension and the Parameter Table

The messages, each ended by 0DH (the prompt for the driver by 03H), the extension DCT for DRIVER, and the 29 entries of the parameter table: a keyword of six characters (padded with spaces) and the address where @PARAM stores its value, the operand of the instruction that tests it. The text New SYSTEM drive installed (5B0BH) is in the file but no code uses it.

5200H - Member 8 (BUILD): Entry, the File and the Mode

The BUILD command (library member 33H), loaded at 5200H-5402H. It makes a file from lines typed at the keyboard: the default extension is /JCL. The file is opened with @INIT (control block at 5403H, buffer 5500H, both above the member); a new file shows Building: and its name, an existing one is refused with File already exists unless APPEND is given, which goes to its end and shows Appending:, the keyboard's device name, to and the name. A file with the extension KSM (a keystroke file) prompts A=> to Z=> for 26 lines; a /JCL file takes lines of up to 63 characters (255 otherwise); with HEX each line is taken as pairs of hexadecimal digits. The lines are kept from 5600H on and written to the file when BREAK is pressed on an empty line.

5299H - The Lines

Each line is read with @KEYIN (0040H) into the memory at Register Pair HL, from 5600H on: the line and the 0DH after it stay there (or, with HEX, the bytes its digit pairs give). A KSM file gets the prompt letter=> before each line, A to Z, and ends after Z. BREAK with characters typed takes the line as it is; BREAK on an empty line ends the input.

52ECH - Write the File

The bytes from 5600H up to Register Pair HL are written to the file one at a time through the ROM's @PUT (001BH), then the file is closed. A failure is reported through @ERROR.

531DH - The Name of the File or Device

Register A = byte +00H of the control block: with bit 7 set (a file) @FNAME writes NAME/EXT:d at Register Pair DE from Register C (the drive) and Register B (the directory record); for a device the name is an asterisk and the two letters in Register C and Register B. The name ends with 03H.

5330H - One Hexadecimal Digit

Takes the character at Register Pair DE (and moves on): 0-9, A-F or a-f return its value in Register A. Any other character drops the return address and displays Bad hex digit encountered!, ending the command.

536AH - BUILD Data: Messages, the Default Extension and the Parameter Table

The messages, the texts Building: and Appending: with the keyboard's device name (ended by 03H so that the name follows on the line), the extension JCL and the parameter table.

5200H - Member 9 (ATTRIB): Entry and a File's Attributes

The ATTRIB command (library member 51H), loaded at 5200H-56D5H. With a file specification it changes the file's directory record: I (invisible), V (visible), PROT=level, ACC=password and OWNER (or UPDATE)=password; the file is opened first (control block 56D6H, buffer 4300H) and must allow full access (level 0). Without a file specification it works on a diskette (53C5H): NAME, PW (the master password), LOCK and UNLOCK. The options of a file are read here by the member itself, by their first letter; a bad one gives Attribute specification error!.

527BH - PROT=level

The value's first two letters are looked up in the table of eight two letter words at 55FAH: NO, EX, RE, WR, ~~ (never matched), NA, KI, FU; the level is 7 less the word's place (NO 7, EX 6, RE 5, WR 4, NA 2, KI 1, FU 0), and RE followed by N (RENAME) is 2. The level goes into the operand at 5389H and bit 0 of the mask is set.

52D5H - I, V, ACC and OWNER

I and V take no value: they set or clear bit 3 (08H) in the operand at 5391H, the invisible bit to OR into the attribute byte, and bit 3 of the mask. ACC=password (refused on a drive that keeps the time in the record: File has no access password!) and OWNER=password (or UPDATE=password) are hashed through request E4H into 51F7H or 51F5H; they set bit 1 or bit 2 of the mask.

5329H - Passwords and Values

5329H takes a password (54FBH: from a quoted value at Register Pair DE or typed after the prompt at Register Pair HL) and goes on into 532CH, which hashes the eight bytes at Register Pair DE through request E4H (SYS2/SYS): the hash comes back in Register Pair HL. 532FH copies a name (a letter, then letters or digits, at most eight) from Register Pair HL to Register Pair DE. 5349H passes over the rest of a keyword: at the end of the option it returns the Z FLAG; at an equals sign it reads the value (an optional quote) into 51E2H-51E9H, padded with spaces, and returns the NZ FLAG.

5375H - Change the Directory Record

The record of the file (byte +07H of the control block, drive +06H) is read with DIRRD. The mask at 5381H says what changes: bit 0 the protection level (bits 2-0 of +00H), bit 3 the invisible bit (bit 3 of +00H), bit 2 the owner password hash (+10H-+11H, from 51F5H), bit 1 the access password hash (+12H-+13H, from 51F7H). The sector is written back with DIRWR.

53C5H - A Diskette: NAME, PW, LOCK and UNLOCK

Without a file specification the drive comes from :d (drive 0 when not given) and the parameters are read by @PARAM (table 568DH). Without NAME, PW, LOCK or UNLOCK ATTRIB shows -Nothing done-. The diskette's granule allocation table is read into 5800H and its master password checked (54CBH). NAME=name or NAME (asked) puts a new name at 58D0H; PW=password or PW (asked) a new master password hash at 58CEH; the table is written back. LOCK gives every visible file without a password the master password; UNLOCK takes it off every file that has it.

545CH - LOCK and UNLOCK: Every File

The hash index table at 5900H is walked a column at a time: the slots 00H, 20H ... E0H of a column are the eight records of one directory sector (slot n is record n). Each slot in use (not 00H, and not one of the system files' slots 00H-07H and 20H-27H) has its record read with DIRRD (once per sector, the sector number kept at 546DH). A record whose attributes are those of a visible file in use (bits 7-3 = 00010) and whose password hash (+10H-+11H) is the one looked for gets the new hash. After each column the sector is written back with DIRWR.

54CBH - The Allocation Table and the Master Password

Reads the granule allocation table of the drive into 5800H. When its master password (CEH-CFH) is the hash of PASSWORD (43E0H) nothing is asked. Otherwise the password (MPW=, or typed after Master password ?) must hash to the table's, or to 113DH (the hash of the master override password RS0LT0FF); else Invalid master password! ends the command.

54FBH - Get Eight Characters

Register Pair DE = a parameter (0000H not given, FFFFH given alone, else the address of its quoted value), Register Pair HL = a prompt. A quoted value is copied to 5700H up to ENTER, a comma or a quote; otherwise the prompt is displayed (not during a JCL job) and up to eight characters are typed there, BREAK ending the command with ATTRIB aborted!. The eight places are padded with spaces and small letters made capitals. Returns Register Pair DE = 5700H.

554EH - Read or Write the Allocation Table at 5800H

One routine with two entries: 554EH is OR AFH, which leaves the NZ FLAG (read); 554FH is the AFH alone, XOR A, which leaves the Z FLAG (write). Sector 0 of the directory cylinder of drive Register C is read into 5800H (error 14H) or written from it with the deleted data mark and verified (error 15H). Register Pairs DE and HL are kept.

5572H - Not during a JCL Job; the Messages

5572H returns only when no JCL job runs (bit 5 of SFLAG$); otherwise it displays Invalid command during DO processing! and ends the command. 5578H-558FH is a chain of LD IX instructions: each entry after the first is the LD HL hidden after the DDH prefix, so a jump into the chain picks one message for @LOGOT.

559CH - ATTRIB Data: Messages, the Protection Words, the Prompts and the Parameter Table

The texts, ended by 0DH (the prompts by 03H so that the answer is typed on the line), the eight two letter words of the protection levels, and the parameter table for a diskette.

5200H - Member 10 (DUMP): Entry, the Range and the File

The DUMP command (library member 71H), loaded at 5200H-5405H. It writes the memory from START (5500H when not given) to END (54FFH when not given) to a file: as a load module (default extension /CIM: a name record with up to six letters of the file's name, load blocks of at most 254 bytes, and a transfer record for TRA, 402DH when not given), or with ASCII as the bytes alone (default /TXT) followed by the ETX byte (03H when not given). LRL (1-256) sets the record length. The file's control block is at 542CH and its six letter name at 5426H, above the member; its buffer is 5500H.

52D2H - Write the Memory

From START to END in blocks of at most 254 bytes: a load module puts a load block header (01H, the length plus 2, the address) in front of each block; ASCII writes the bytes alone. Then a load module ends with the transfer record (02H, 02H, TRA), an ASCII file with the ETX byte, and the file is closed.

5342H - Write One Byte; Errors

5342H writes 02H, 5344H the byte in Register A, to the file at Register Pair DE through the ROM's @PUT (001BH). A failure is reported through @ERROR; 5352H displays File spec required! and 5355H any message at Register Pair HL. All end the command with Register Pair HL = FFFFH.

535DH - DUMP Data: Messages, Extensions and the Parameter Table

The three messages, the two default extensions, the parameter table (each keyword of six characters with the address of the operand that holds its value) and the text Dumping:, which the name at 5406H follows.

5200H - Member 11 (PURGE): Entry, the Partspec and the Drive

The PURGE command (library member 72H), loaded at 5200H-577CH (5711H-5733H, a work area, are not in the file). PURGE partspec:d deletes the files of drive d whose name and extension match the partspec ($ matches any character; a space, which fills the masks, matches anything); a leading dash deletes the files that do not match. System files need SYS, invisible files INV; DATE="M/D/Y-M/D/Y" limits the files to a range of dates. Unless QUERY=N each file is asked about (Y deletes it); MPW gives the master password when the diskette has one other than PASSWORD. The drive is required.

5263H - DATE: The Range of Dates

DATE="M/D/Y" keeps the files of that date, "M/D/Y-" those from it on, "-M/D/Y" those up to it and "M/D/Y-M/D/Y" those between. Each date is packed by 55F4H as year (less 1980) x 800H + month x 80H + day x 4, the form 5577H gives a directory record's date. Bit 7 of 5710H says a lowest date is kept at 5711H-5712H, bit 0 a highest date at 5713H-5714H.

52BEH - The Walk through the Hash Index Table

The slots are taken a column at a time: 00H, 20H ... E0H are the eight records of directory sector 0, then 01H, 21H ... and so on (slot n is record n). Slots 00H and 01H (the system's own records) and free slots are passed over. BREAK ends the command with Purge aborted between two files.

532EH - The Name, the Date, the Line

The eleven characters of the record's name and extension (+05H-+0FH) are compared with the masks; then the record's date (5577H) with the range. The line name/ext:d is built at 5719H; with questions the MOD mark (+), an opening brace and the date as dd-Mmm-yy follow, and the answer is asked for after the closing brace and a question mark.

546EH - Delete the File

Purging: and the file's name are shown and logged, then a control block is made at 577DH, above the member, as for an open file: +00H 80H (open), +01H 01H (access KILL), +06H the drive and +07H the directory record. @KILL deletes the file; the directory sector at 4300H is then read again (52FDH = FFH). BREAK pressed before the deletion ends the command with Purge aborted.

54ACH - The Master Password

The drive's allocation table is read into 5900H. When its master password (CEH-CFH) is the hash of PASSWORD (43E0H) nothing is asked. Otherwise the password (MPW=, or typed after Master password ?) must hash to the table's or to 113DH (the hash of the master override password RS0LT0FF); else Invalid master password ends the command. During a JCL job without MPW nothing is asked and nothing is checked (54C7H).

54E6H - Get Eight Characters

Register Pair DE = the MPW parameter (0000H not given, FFFFH alone, else the address of the quoted value), Register Pair HL = the prompt. A quoted value is copied to 5800H up to ENTER, a comma or a quote; otherwise, unless a JCL job runs (then the NZ FLAG is returned), the prompt is displayed and up to eight characters are typed, BREAK ending the command with Purge aborted. The eight places are padded with spaces and small letters made capitals. Returns Register Pair DE = 5800H and the Z FLAG.

553FH - Helpers: The Allocation Table, the JCL Test, the Masks, a Record's Date

553FH reads sector 0 of the directory cylinder of drive Register C into 5900H (Register A = 14H on failure). 5552H returns the NZ FLAG while a JCL job runs. 5558H copies up to Register B characters of a partspec from Register Pair HL into a mask at Register Pair DE ($, letters and digits; small letters made capitals). 5577H packs a record's date from +01H (Register Pair HL) into Register Pair DE as year x 800H + month x 80H + day x 4: the year from +13H (bits 4-0, less 1980) on a drive whose bit in 475DH is set, else bits 2-0 of +02H.

55A1H - Read a Date M/D/Y

55A1H reads up to three fields of two digits separated by slashes (Register C = 2FH) into 5717H (the month), 5716H (the day) and 5715H (the year), returning the Z FLAG when all three were read. 55B6H reads two digits into Register A (Z), 55CCH one digit (CARRY for a digit).

55D3H - Errors and Messages

55D3H reports error 2CH and 55D5H the error in Register A through @ERROR. 55DCH-55EBH is a chain of LD IX instructions: each entry after the first is the LD HL hidden after the DDH prefix, so a jump into the chain picks one message for @LOGOT. All end the command with Register Pair HL = FFFFH.

55F4H - Read and Pack a Date

Reads M/D/Y from Register Pair HL: the month must be 1-12 and the day within the month (29 days in February of a leap year; the table's February is counted up for every leap year date read, so a second one allows 30). Years 00-11 count as 2000-2011. Returns Register Pair BC = (year less 1980) x 800H + month x 80H + day x 4 and Register Pair HL after the date; a bad date ends the command with Bad date format.

5642H - PURGE Data: Messages, the Month Table, the Masks and the Parameter Table

The messages (Purge aborted after a line feed), the prompt and the question texts, the days of the months, the month names, the masks of the partspec, the flags of the dates; 5711H-5733H are a work area not in the file; then the parameter table.

5200H - Member 12 (FORMS): Entry and the Exit

The FORMS command (library member B1H), loaded at 5200H-5525H. It shows and changes the settings of the printer filter PR/FLT, which must be in memory as the module $FF (else Forms Filter not Resident). Ten bytes are worked on in a copy at 552BH (above the member, Index Register IY): three from the printer's device control block (+03H the page length, +04H the line count, +05H the lines to print) and seven from the filter's own block (the column, XLATE from and to, INDENT, the flags of ADDLF, FFHARD, TAB and SLINE, CHARS, MARGIN). FORMS alone shows them; FORMS (parameters) changes them, writes them back and shows them.

522DH - Find the Filter and Copy Its Settings

Request BCH finds the module $FF and returns Register Pair DE at its +08H, right after its name (the filter's own device control block). The word at +10H-+11H is the address of the printer's device control block: its +03H-+05H are copied to 552BH-552DH, the module's +12H-+18H to 552EH-5534H. The two addresses are noted in the operands at 52E7H and 52EFH for the write back.

5262H - The Parameters

@PARAM stores each value at the cell the table names (545CH-546DH). DEFAULT copies the factory values (LINES not given, PAGE 66, the others 0) over the cells first. The cells then go into the work copy: CHARS, MARGIN, INDENT, the flags (TAB, FFHARD, ADDLF from the cells; SLINE, bit 3, kept), XLATE (from in the high byte, to in the low byte), PAGE + 1 at +00H, 1 at +01H, 0 for the column, LINES + 1 (or PAGE + 1 when LINES was not given) at +02H; without SLINE the three page values lose the 1 again.

52F8H - Show the Settings

The template at 54A4H is filled from the work copy: ON over OFF for ADDLF, FFHARD and TAB; CHARS (or OFF), INDENT, LINES, MARGIN and PAGE as numbers (without the plus one when SLINE is on); and, when a translation is set (XLATE from and to differ), the two characters in hexadecimal on an extra line (the 0DH at 550CH becomes a line feed). The template is displayed as one text, its lines separated by line feeds.

537BH - Helpers: ON, Numbers, the Lookup

537BH copies ON (5484H) and 537EH the three bytes at Register Pair HL to Register Pair DE. 5384H writes Register A as three right justified decimal places at Register Pair DE (through the five places at 5526H, 539FH), keeping Register Pairs AF, BC and HL. 53B8H looks a module up by its name at Register Pair DE through request BCH.

53BBH - FORMS Data: The Parameter Table, the Cells, the Factory Values and the Texts

The parameter table (each keyword of six characters and the address of its cell), the cells @PARAM fills, the factory values that DEFAULT copies over them, the module name $FF, ON and OFF, the message, and the template of the display, whose lines end with line feeds.

5200H - Member 13 (SETCOM): Entry and the Exit

The SETCOM command (library member B2H), loaded at 5200H-569CH. It shows and changes the settings of the RS-232 driver RS232/DVR, which must be in memory as the module $CL (else RS232/DVR not installed). Index Register IX points at the driver's four setting bytes (the module +08H): +00H the input signals (two bits each for RI 11H, CD 22H, DSR 44H and CTS 88H: 00 IGNORE, the low bit ON, both bits OFF), +01H the line (bit 0 RTS and bit 1 DTR, each clear for ON; bit 2 always set; bit 3 parity off; bit 4 two stop bits; bits 6-5 the word length; bit 7 even parity), +02H the baud rate's index in both halves, +03H the break character; +04H-+05H is the address of the driver's routine that sets the serial port from them. SETCOM alone shows the settings; SETCOM (parameters) changes them, runs that routine and shows them.

522DH - Find the Driver; the Parameters

Request BCH finds the module $CL; Index Register IX gets the module +08H. Without an opening bracket the settings are only shown (54E1H). With one, @PARAM reads the parameters, DEFAULT puts the factory settings in first, 5394H changes the setting bytes, and the driver's routine at +04H-+05H is jumped to; its RET goes to 54E1H, which shows the settings.

5263H - The Display: One Routine for Each Part

The list at 553CH names these routines in the order of the display (5364H calls them): RS232:, Baud=, Word=, Stop=, Parity=, Break=, Output control: DTR= and RTS=, Input control: RI=, DSR=, CD= and CTS=, a comma and a space between items, and ENTER at the end. Each ends with @DSPLY of its text (ended by 03H, so the line goes on) or the ROM's character display.

5364H - The List Walker; the Factory Settings

5364H calls each routine named in the list at 553CH (Index Register IY walks it) until the word 0000H, by pushing the return address 537AH and jumping. 5383H puts the factory settings into the four bytes: 00H (every input signal ignored), A5H (RTS off, DTR on, 7 bits, one stop bit, even parity), 55H (300 baud) and 00H (no break character).

5394H - Change the Settings

5219H is pushed first, so that every RET NZ, RET C or RET NC of a check ends the command with a parameter error; the last instruction takes it off again. BAUD must be one of the sixteen rates of the table at 551CH; WORD 5-8; STOP 1-2; PARITY (or PARITY=ON), PARITY=OFF, PARITY="ODD" or "EVEN", EVEN and ODD; BREAK (03H), BREAK=OFF (01H) or a character; DTR and RTS ON or OFF; RI, DSR, CD and CTS ON, OFF or not given (IGNORE is kept). The line byte is built in Register C and stored at +01H.

5498H - Helpers: A Signal, a Bit Field, Capitals, the Baud Table, Numbers

5498H sets the two bits of one input signal (Register C the low bit, the high bit four places up) from Register Pair HL: not given leaves them, OFF sets both, ON only the low bit. 54B3H puts the bits of Register A under the mask Register B into Register C. 54BCH makes a small letter in Register A a capital. 54C5H finds the rate in Register Pair DE in the baud table. 54E4H writes Register Pair HL in five decimal places at Register Pair DE. 54FDH looks a module up through request BCH.

5500H - SETCOM Data: The Name, the Message, the Baud Rates, the Display List, the Texts and the Parameter Table

The module name $CL, the message for a missing driver, the sixteen baud rates (index 0-15, the value kept in both halves of the baud byte), the list of the display routines walked by 5364H, the texts of the display (each ended by 03H so that the line goes on), and the parameter table of @PARAM (each keyword of six characters and the address of its cell, the operand of an instruction in the code).