LDOS 5.3.1 for the Model III - SYS6/SYS Disassembled

SYS6/SYS

Other Navigation

LDOS 5.3.1 SYS6/SYS Disassembly: Library A (Model III)

SYS6/SYS is Library A of LDOS 5.3.1: fifteen 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). Twenty commands are served: MEMORY, DIR, KILL, LIB, CLS, TOF, DO, SPOOL, APPEND, COPY, LIST, RENAME, DEVICE, LINK, RESET, ROUTE, SET, FILTER, LOAD and RUN. Fourteen members load at 5200H, directly above the overlay area 4E00H-51FFH; the member of FILTER and SET loads at 5A00H. Only one member is in memory at a time, and the next library command loads its own member over it.

The file is 15625 bytes: a header record (05H) with the name sys6, a copyright record (1FH) with the text (C) 1982-4,6,90 MISOSYS, twenty member headers (08H), a record 0AH that ends the headers, then the fifteen 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 or three commands have one header for each command, all pointing at the same place in the file with different entry addresses. The members hold 15081 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

The Records of the File

The file is 15625 bytes. The overlay loader reads the member headers to find a member, then reads the member's load blocks from the record and byte its header names, up to its record 04H.

File Offset	Contents
0000H	Record 05H, 6 bytes: the file name sys6 and two spaces.
0008H	Record 1FH, 23 bytes: the text (C) 1982-4,6,90 MISOSYS.
0021H-00C0H	Twenty member headers, record 08H of 6 bytes each: the member byte, the entry address, and the record and byte where the member begins.
00C1H	Record 0AH, 1 byte (00H): the end of the member headers.
00C4H	Record 04H, 1 byte (00H): the end of member 0, which has no load blocks.
00C7H-04E1H	Member 1 (MEMORY): 5 load blocks, then record 04H.
04E2H-0EEDH	Member 2 (DIR): 10 load blocks, then record 04H.
0EEEH-1088H	Member 3 (KILL): 2 load blocks, then record 04H.
1089H-1162H	Member 4 (LIB, CLS, TOF): 1 load block, then record 04H.
1163H-1856H	Member 5 (DO): 10 load blocks, then record 04H.
1857H-2014H	Member 6 (SPOOL): 10 load blocks, then record 04H.
2015H-2812H	Member 7 (COPY, APPEND): 10 load blocks, then record 04H.
2813H-2C65H	Member 8 (LIST): 5 load blocks, then record 04H.
2C66H-2E15H	Member 9 (RENAME): 2 load blocks, then record 04H.
2E16H-3306H	Member 10 (DEVICE): 6 load blocks, then record 04H.
3307H-34BCH	Member 11 (LINK): 2 load blocks, then record 04H.
34BDH-37D7H	Member 12 (RESET): 4 load blocks, then record 04H.
37D8H-3A21H	Member 13 (ROUTE): 3 load blocks, then record 04H.
3A22H-3B89H	Member 14 (FILTER, SET): 2 load blocks, then record 04H.
3B8AH-3D04H	Member 15 (RUN, LOAD): 2 load blocks, then record 04H.
3D05H	Record 02H, 2 bytes: the transfer address 0000H, not used, since every member is run through its header.

The Members

The loaded addresses of each member, its load blocks joined where they follow each other. Members 5, 6, 7 and 10 leave gaps between their blocks: work areas whose bytes the file does not load.

Member	File Offset	Loaded	Size	Commands
1	00C7H	5200H-5603H	1028 bytes	MEMORY
2	04E2H	5200H-5BE0H	2529 bytes	DIR
3	0EEEH	5200H-538FH	400 bytes	KILL
4	1089H	5200H-52D2H	211 bytes	LIB, CLS, TOF
5	1163H	5200H-57BBH 580DH-5907H 59A8H-59AAH 59CAH-59D7H 5D00H-5D00H	1737 bytes	DO
6	1857H	5200H-57C5H 57E6H-585BH 5866H-5903H 5906H-59BCH 59E7H-59E8H	1939 bytes	SPOOL
7	2015H	5200H-5985H 59C6H-59C9H 5A25H-5A6DH	2003 bytes	COPY, APPEND
8	2813H	5200H-563BH	1084 bytes	LIST
9	2C66H	5200H-53A4H	421 bytes	RENAME
10	2E16H	5200H-568BH 56B4H-56FDH	1238 bytes	DEVICE
11	3307H	5200H-53AAH	427 bytes	LINK
12	34BDH	5200H-5507H	776 bytes	RESET
13	37D8H	5200H-543AH	571 bytes	ROUTE
14	3A22H	5A00H-5B5CH	349 bytes	FILTER, SET
15	3B8AH	5200H-536FH	368 bytes	RUN, LOAD

Sections of the Disassembly

Member	Address	Contents
1	5200H	Member 1 (MEMORY): Entry, Parameters and CLEAR
1	5224H	The CLEAR Routine, Copied to 4300H and Run There
1	523BH	ADD, WORD and BYTE: Show and Change Memory
1	5294H	HIGH: Reserve Memory below HIGH$
1	52CFH	No HIGH: Show HIGH$, or Start the Directory
1	5308H	The Module Loop: One Line for Each Module above HIGH$
1	5357H	Build the Summary Line and the Column Headings
1	53A4H	Bytes without a Header: Find the Next Module
1	53FFH	Helper: Write X'nnnn' into the Line
1	5411H	Helper: Write a Number in Decimal
1	542AH	Helper: Send the Line, Blank It and Count It against the Page
1	545FH	GO and the Exit
1	547AH	Check for LDOS Command Level
1	54A0H	Parameter Error
1	54A9H	MEMORY Data: the Header of a Reserved Block
1	54B3H	MEMORY Data: Messages
1	54E9H	MEMORY Data: the Parameter Table
1	555AH	MEMORY Data: the High Line and the ADD Line
1	558FH	MEMORY Data: the Directory Texts
2	5200H	Member 2 (DIR): Entry, the File Specification and the Drive
2	5252H	Set Up: SORT, the Sort Buffer, P and DATE
2	52B4H	One Drive: Check It, Read the Allocation Table, Count the Free Granules
2	5308H	The Drive Line: Cylinders, Density, Sides, Total Space and Directory Size
2	53DEH	The Next Directory Record and the End of the Drive
2	541BH	A Drive That Is Not Ready
2	542DH	Read a Directory Record and Decide Whether It Is Shown
2	5509H	Show One File: Name, Extension and Attributes
2	55C5H	The Detail of a File: Access, LRL, Records, EOF, Extents, Size, Date and Time
2	5709H	The Size of a File: the Sorted Key or the Extents
2	577CH	Output Helpers: a Text, a Character, a Space
2	5796H	Granules to Kilobytes
2	57C2H	Copy a Name Field into a Mask
2	57DDH	A Directory Date as One Word
2	5806H	Read a Date Argument MM/DD/YY
2	5856H	Read Three Two Digit Fields
2	5888H	Decimal Output: Three, Five or Two Digits
2	58C7H	BREAK and the Pause Key
2	58F2H	Count a Line against the Page
2	5944H	SORT: Sort the Collected Records by Name and Show Them
2	5997H	The Shell Sort of the Pointer Table
2	5A29H	Errors and the Common Exit
2	5A42H	DIR Data: the Parameter Table
2	5AABH	DIR Data: the Headings, the Access Codes and the Drive Line
2	5B3CH	DIR Data: the Detail Template, the Masks and the Days of the Months
2	5B82H	DIR Data: Messages, Month Names and the Date Mode
3	5200H	Member 3 (KILL): Entry and the Loop over the File Specifications
3	522EH	One File Specification: Open the File, Check the Access, Delete It
3	527DH	Helper: Display the Deleting Line
3	5286H	Remove a Device
3	5321H	Helpers: Clear Six Bytes, Copy a Specification without Its Password
3	533EH	Helper: BREAK
3	5360H	Errors
3	5373H	KILL Data: Messages
4	5200H	Member 4 (LIB, CLS, TOF): the Three Entries
4	5222H	LIB: List the Library Commands
4	52BFH	Helper: Display Spaces
4	52C7H	LIB Data: the Heading
5	5200H	Member 5 (DO): Entry, Open the JCL File and Create SYSTEM/JCL
5	5260H	The Command Tail: Parameters and the Keyin Prompt
5	528BH	Pop an Included File off the Include Stack
5	52A5H	Read the Next Source Line
5	5314H	DO = : Run a Named File without Compiling
5	532BH	DO * : Run the Current SYSTEM/JCL File
5	5330H	Helper: Copy the SYSTEM/JCL Specification
5	533CH	The Parameter List: Tokens and Their Values
5	5384H	Read Lines, Finding the Named Label
5	53B7H	The Compile Loop: Read a Line and Compile It
5	540AH	Helper: A Hexadecimal Digit to Its Value
5	541BH	Substitute a Parameter Value
5	544EH	Directives: the Nesting Check and the Error Line
5	546FH	A Directive Line: // Dispatch
5	549DH	Read One Source Line into 59D8H
5	54CEH	Write the Compiled Line to SYSTEM/JCL
5	54FAH	DO Data: the Conditional Directive Table
5	5510H	DO Data: the Other Directive Table
5	5543H	IF: Evaluate the Condition and Push the Block State
5	556BH	ELSE: Flip the Block State
5	5576H	END: Pop the Block
5	557FH	Evaluate a Term of the Condition
5	5589H	Evaluate One Token
5	55A5H	SET: Give a Token the Value True
5	55B4H	RESET: Give a Token the Value False
5	55C6H	ASSIGN: Give a Token a Character String Value
5	55DFH	INCLUDE: Compile Another File in Place
5	5614H	QUIT: End the Compile
5	5620H	Read a Token or a Value String
5	5667H	The Character Reader of a Token or Value
5	56CDH	Store a Token in the Token Table
5	56DFH	Store a Value String against a Token
5	56EAH	Look for a Token in the Token Table
5	56FBH	Search a Directive Table
5	5716H	The Name Table Search
5	5766H	Helper: Write a Number in Decimal
5	577FH	Helper: Test for a Space or a Comma
5	5785H	Helper: Fold a Small Letter to a Capital
5	578FH	Parameter Error and the Message Selector
5	580DH	DO Data: Launch Stubs and the SYSTEM/JCL Name
5	5825H	DO Data: the Messages
5	5906H	DO Data: Stacks and the Error Line
5	5D00H	DO Data: the Token Table
6	5200H	Member 6 (SPOOL): Entry and an Installed Spooler
6	523FH	Check for LDOS Command Level
6	5259H	Read the Device and the Spool File
6	52C6H	Read the Parameters
6	52EBH	Install: Find the Device
6	533FH	Install: Make the Spool File
6	5392H	Install: Lay Out the Spooler's Memory
6	548DH	Install: Move the Module and Start It
6	5514H	PAUSE and RESUME
6	553EH	OFF: Turn the Spooler Off
6	55ACH	CLEAR: Empty the Queue
6	55F6H	Find a Device Control Block by Name
6	5625H	The Messages and the Exit
6	5672H	SPOOL Data: the Messages
6	57C0H	SPOOL Data: the RESET Line and the Device
6	57E6H	SPOOL Data: Default Names and the Parameter Table
6	5852H	The Spooler Module: Header and Driver Entry
6	5871H	The Spooler Module: Queue a Character
6	5904H	The Spooler Module: the Despool Task
6	594AH	The Spooler Module: the Keyboard Task Part
6	5950H	The Spooler Module: Change the Page Being Sent
6	59BDH	The Spooler Module: the Queue Block
7	5200H	Member 7 (COPY, APPEND): the Two Entries and APPEND
7	52B1H	COPY: Read the Specifications and Parameters
7	533DH	COPY: Open the Source and the Destination
7	53DCH	Copy Whole Sectors through Memory
7	5498H	Write the Last Pages
7	54B8H	Set the Highest Page and Clear the Keys
7	54D4H	Give the Destination Its Space
7	54F4H	COPY with a Device: Open Both Ends
7	5519H	Copy Byte by Byte
7	5564H	Keep a Destination as It Was Typed
7	558EH	Complete the Destination from the Source
7	55FEH	Open a File or Device and Check Its Access
7	56A1H	Display the Banner
7	56BDH	The Record Length of a File
7	56CCH	Keep the Source's Directory Bytes
7	56E9H	BREAK and the Pause
7	570CH	The Diskette Prompts of X
7	576BH	Flash a Prompt until ENTER
7	57C5H	Three Overlay Loads, a Device Test, the Date Layout Test and the GAT Read
7	57FFH	Open the Source or the Destination
7	5810H	Errors and the Message Selector
7	583BH	COPY Data: the Messages
7	5986H	COPY Data: the Control Blocks and the Names
7	5A25H	COPY Data: the Parameter Table
8	5200H	Member 8 (LIST): Entry, Parameters and the File
8	527EH	Record Length, TAB, Device and Mode
8	5309H	List the Text
8	5399H	List in Hexadecimal
8	54A8H	Send a Character and Count the Page
8	5525H	BREAK and the Pause
8	5559H	The Line Number
8	5583H	Errors and the Exit
8	5598H	LIST Data: Texts and the Parameter Table
8	563CH	LIST Data: the Work Areas
9	5200H	Member 9 (RENAME): Read the Two Names
9	52D3H	Keep the New Name as It Was Typed
9	52F0H	Complete the New Name from the Old
9	534BH	Errors and the Messages
9	5368H	RENAME Data
10	5200H	Member 10 (DEVICE): Parameters and the Drives
10	5365H	DEVICE: the Device Control Blocks
10	5427H	Numbers and Names for the Lines
10	5478H	DEVICE: the Options and the System Modules
10	5546H	Show and Print
10	55C8H	DEVICE Data: Texts and the Parameter Table
11	5200H	Member 11 (LINK): Link Two Devices
11	52C7H	The Link Module
11	52F0H	Find a Device Control Block by Name
11	532FH	Errors and the Messages
11	534AH	LINK Data
12	5200H	Member 12 (RESET): Read What to Reset
12	5240H	Reset One Device
12	5298H	Reset the Whole System
12	5386H	Change a File's Directory Record
12	53D3H	Close a Routed File
12	540BH	Find a Device Control Block by Name
12	543AH	DFLAG$ and the Templates
12	548FH	RESET Data: the Parameter Table, Messages and Control Blocks
13	5200H	Member 13 (ROUTE): Read the Two Specifications
13	5255H	Point the Device at Its Destination
13	52A8H	Route a Device to a File
13	531FH	The Device's Control Block
13	53A8H	Find a Device Control Block by Name
13	53D7H	ROUTE Data
14	5A00H	Member 14 (FILTER, SET): Load a Filter or a Driver
14	5AB2H	Find a Device Control Block by Name
15	5200H	Member 15 (RUN, LOAD): Load a Program from Another Diskette
15	5222H	Flash a Prompt until ENTER
15	527CH	RUN
15	5293H	Read X and the File
15	52CCH	Load the Program
15	5302H	RUN and LOAD Data

Routines Outside the File That SYS6/SYS Calls

The routines of the ROM, SYS0/SYS and SYS2/SYS the members call or jump to (4408H is pushed as a return address and 429CH is jumped to), and which members use each. Requests through RST 28H: 84H, 85H and 8AH (SYS2/SYS, SYS3/SYS and SYS8/SYS loaded into the overlay area, function 00H doing nothing) in COPY, 84H in RUN and LOAD, D4H (the name hash of SYS2/SYS) in RENAME, BCH (the module search of SYS10/SYS) in LINK and ROUTE, 9DH (SYS11/SYS runs SYSTEM/JCL) in DO.

Address	Routine	Members
0013H	ROM: @GET, a byte from the device or file at Register Pair DE.	5, 7, 8, 11
001BH	ROM: @PUT, a byte to the device or file at Register Pair DE.	5, 7, 8, 11
0023H	ROM: a control request to the device at Register Pair DE (the printer's status for TOF).	4, 6
002BH	ROM: look at the keyboard once, Register A = the key or 00H.	2, 3, 7, 8, 10, 15
0033H	ROM: display the character in Register A.	2, 4, 5, 7, 8, 10, 15
003BH	ROM: print the character in Register A.	2, 4, 10
0040H	ROM: read a line from the keyboard.	5
0049H	ROM: wait for a key.	1, 2, 6, 8, 10
0060H	ROM: a delay of Register Pair BC counts.	3, 7, 15
01C9H	ROM: clear the screen.	1, 2, 8, 10
4030H	@ABORT: end the command and a JCL job.	1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
403DH	@ADTSK: put a task into a task slot.	6
4040H	@RMTSK: empty a task slot.	6, 12
4209H	@CKDRV: check that a drive is ready.	2, 5, 7, 10
428AH	@LOGOT: display a line and send it to the job log.	1, 2, 3, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15
428DH	@LOGER: send a line to the job log.	5, 12
4293H	@FNAME: the name of a file from its directory entry.	10
429CH	Run a command line through SYS1/SYS (request A3H).	6
4402H	@MSG: send a line to a device.	8
4408H	The RET Z just before @ERROR.	15
4409H	@ERROR: report the error in Register A.	1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
441CH	@FSPEC: a file or device specification into a control block.	3, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15
4420H	@INIT: open a file, making it when it is not there.	5, 6, 13
4424H	@OPEN: open a file or device.	3, 5, 7, 8, 9, 12
4428H	@CLOSE: close a file.	5, 7, 12, 13
442CH	@KILL: delete a file.	3
4430H	@LOAD: load a program file.	14, 15
4433H	@RUN: load and run a program file.	15
4436H	@READ: read a record.	6, 7
4439H	@WRITE: write a record.	6, 7
443FH	@REW: back to the first record.	6, 7
4442H	@POSN: position to a record.	6, 7, 8
4445H	@BKSP: back one record.	7
4448H	@PEOF: position to the end of the file.	7, 13
444BH	@FEXT: give a specification a default extension.	5, 6, 8, 14, 15
444EH	@MULT: multiply Register Pair HL by Register A.	2
4451H	@DIV: divide Register Pair HL by Register A.	1, 2, 5, 8
4454H	@PARAM: read the parameters in brackets.	1, 2, 6, 7, 8, 10, 12, 13, 15
445BH	@WEOF: set the end of the file.	6
445EH	@RREAD: read the current sector again.	5
4467H	@DSPLY: display a line.	1, 2, 3, 4, 5, 7, 10, 12, 15
446AH	@PRINT: print a line.	1, 2, 10
4777H	RDSECT: read a sector.	12
478FH	GETDCT: Index Register IY at a drive code table.	2, 10
4B10H	DIRRD: read the directory sector of a record.	2, 6, 7, 9, 12
4B1FH	DIRWR: write the directory sector back.	6, 7, 9, 12
4B45H	RDSSEC: read a directory sector.	2, 7, 10
4B64H	DIRCYL: the directory cylinder of a drive.	2, 7
4B7AH	DIVEA: divide Register E by Register A (a device block's slot in the table of names).	10, 13, 14
4D82H	Write Register Pair DE as four hexadecimal digits.	1, 8, 10
4D87H	Write Register A as two hexadecimal digits.	8
51BDH	SYS2/SYS: read the hash index table.	9
51BEH	SYS2/SYS: write the hash index table back.	9

Parameter Cells

The operands that @PARAM fills from each member's parameter table. KILL, LIB, DO, RENAME, LINK, FILTER and SET have no parameter table; DO reads its own parameters into the token table at 5D00H.

Address Size	Member	Keyword	Contents
5295H-5296H 2 bytes	1	HIGH or H	The operand of the LD BC at 5294H.
523CH-523DH 2 bytes	1	ADD or A	The operand of the LD HL at 523BH.
525FH-5260H 2 bytes	1	WORD or W	The operand of the LD DE at 525EH.
5266H-5267H 2 bytes	1	BYTE or B	The operand of the LD DE at 5265H (00FFH in the file).
5460H-5461H 2 bytes	1	GO or G	The operand of the LD HL at 545FH (FFFFH in the file).
520EH-520FH 2 bytes	1	CLEAR or C	The operand of the LD DE at 520DH.
542EH-542FH 2 bytes	1	PRINT or P	The operand of the LD DE at 542DH, which sends every line to the printer too.
559AH-559BH 2 bytes	2	A	The operand of the LD DE at 5599H (FFFFH in the file, the full display; A=N gives the short display).
5464H-5465H 2 bytes	2	I or INV	The operand of the LD DE at 5463H: invisible files are shown.
578FH-5790H 2 bytes	2	P	The operand of the LD DE at 578EH: every line is printed too, without pauses.
5456H-5457H 2 bytes	2	S or SYS	The operand of the LD DE at 5455H: system files are shown.
58FFH-5900H 2 bytes	2	N	The operand of the LD DE at 58FEH: the display does not pause after each page.
5274H-5275H 2 bytes	2	DATE or D	The operand of the LD HL at 5273H. DATE stores the address of the text inside its quotes.
546CH-546DH 2 bytes	2	MOD or M	The operand of the LD DE at 546BH: only files with the mod flag are shown.
54CFH-54D0H 2 bytes	2	SORT or O	The operand of the LD DE at 54CEH (FFFFH in the file: sorted; SORT=N shows the files in directory order).
5393H-5394H 2 bytes	6	MEM or M	The operand of the LD BC at 5392H (0001H in the file).
535BH-535CH 2 bytes	6	DISK or D	The operand of the LD BC at 535AH (0004H in the file).
52D0H-52D1H 2 bytes	6	OFF or N	The operand of the LD DE at 52CFH.
52DEH-52DFH 2 bytes	6	PAUSE or P	The operand of the LD DE at 52DDH.
52D7H-52D8H 2 bytes	6	RESUME or R	The operand of the LD DE at 52D6H.
52E5H-52E6H 2 bytes	6	CLEAR or C	The operand of the LD DE at 52E4H.
5359H-535AH 2 bytes	7	LRL or L	The operand of the LD BC at 5358H (FF00H in the file).
544BH-544CH 2 bytes	7	CLONE or C	The operand of the LD DE at 544AH (FFFFH in the file: on).
52D4H-52D5H 2 bytes	7	X	The operand of the LD DE at 52D3H.
5269H-526AH 2 bytes	7	STRIP or S	The operand of the LD DE at 5268H.
5545H-5546H 2 bytes	7	ECHO or E	The operand of the LD DE at 5544H.
5333H-5334H 2 bytes	8	ASCII8 or A8	The operand of the LD DE at 5332H.
521EH-521FH 2 bytes	8	C	The operand of the LD HL at 521DH (FFFFH in the file).
52D5H-52D6H 2 bytes	8	HEX or H	The operand of the LD BC at 52D4H.
53B9H-53BAH 2 bytes	8	LRL or L	The operand of the LD BC at 53B8H (FF00H in the file).
52F0H-52F1H 2 bytes	8	LINE	The operand of the LD BC at 52EFH (0001H in the file).
531EH-531FH 2 bytes	8	NUM	The operand of the LD BC at 531DH.
54F6H-54F7H 2 bytes	8	N	The operand of the LD DE at 54F5H: the listing does not stop at each page.
539AH-539BH 2 bytes	8	REC or R	The operand of the LD BC at 5399H.
52B7H-52B8H 2 bytes	8	P	The operand of the LD BC at 52B6H.
5343H-5344H 2 bytes	8	TAB or T	The operand of the LD DE at 5342H (0008H in the file).
5366H-5367H 2 bytes	10	BYTEIO or B	The operand of the LD HL at 5365H (FFFFH in the file).
5218H-5219H 2 bytes	10	DRIVES or D	The operand of the LD HL at 5217H (FFFFH in the file).
556AH-556BH 2 bytes	10	N	The operand of the LD DE at 5569H, which 5210H overwrites with P.
5559H-555AH 2 bytes	10	P	The operand of the LD DE at 5558H.
5479H-547AH 2 bytes	10	STATUS or S	The operand of the LD HL at 5478H (FFFFH in the file).
53A6H-53A7H 2 bytes	12	LRL or L	The operand of the LD DE at 53A5H (FF00H in the file).
53AFH-53B0H 2 bytes	12	DATE or D	The operand of the LD DE at 53AEH (FF00H in the file).
5223H-5224H 2 bytes	13	NIL	The operand of the LD BC at 5222H.
52E9H-52EAH 2 bytes	13	REWIND or R	The operand of the LD BC at 52E8H.
52BDH-52BEH 2 bytes	15	X	The operand of the LD DE at 52BCH.

Cells Outside the File

Address Size	Contents
4013H-4014H 2 bytes	The operand of the JP at 4012H that the ROM's RST 38H reaches: RESET puts back 44A5H, the interrupt service routine of SYS0/SYS.
4015H-402CH 24 bytes	KIDCB$, DODCB$ and PRDCB$, the device control blocks of KI, DO and PR (8 bytes each, no name in the block; RESET copies the ROM's power-up bytes over them), used by members 3, 6, 10, 11, 12, 13, 14.
4020H-4021H 2 bytes	The cursor position, DODCB$ +03H-+04H: RESET keeps it.
402DH-4032H 6 bytes	@EXIT and @ABORT: their first byte is a JP while a program has taken them over, the test for LDOS command level (members 1, 5, 6, 11, 12, 13, 14); DO puts its own requests over them for a JCL job.
4065H-406AH 6 bytes	The bytes of 402DH-4032H that SYS11/SYS keeps during a JCL job (members 1, 5, 6, 11, 12, 13, 14); DO stores them there.
421DH 1 byte	@ICNFG: RESET stores C9H, a RET.
4225H-4264H 64 bytes	INBUF$, the command line buffer: DO reads a line of up to 63 characters into it for a semicolon in the command line of DO, which asks for more of the line with a question mark.
4265H-4284H 32 bytes	JFCB$, the control block of SYSTEM/JCL (DO).
4285H-4287H 3 bytes	@KITSK, the keyboard task hook: SPOOL makes it a jump into its module.
4289H 1 byte	DFLAG$, the device flags: bit 0 the spooler, 1 TYPE, 2 JKL, 3 PR/FLT, 4 KI/DVR, 5 MiniDOS, 6 KSM, 7 Graphic (members 6, 10, 12).
428DH 1 byte	@LOGER: RESET stores C9H, a RET; DO calls it.
429FH 1 byte	KFLAG$: bit 0 BREAK, bit 1 the pause, bit 2 ENTER, bit 4 despooling on (members 2, 3, 6, 7, 8, 10, 15).
42B8H-42BDH 6 bytes	KISV$, DOSV$ and PRSV$, the drivers of KI, DO and PR that the boot found (RESET).
42BEH-42BFH 2 bytes	KIJCL$, the keyboard driver while a JCL job feeds the keyboard (members 11, 12, 13).
42C2H-42EBH 42 bytes	The second table of device control blocks, six bytes each: JL, SI, SO and four spare blocks from 42D4H, 42B0H + 6 x n for slot n (members 3, 6, 10, 11, 12, 13, 14).
42ECH-42FFH 20 bytes	The table of device names of SYS0/SYS, two letters for each slot: KI, DO, PR, JL, SI, SO and four spare slots (00H 00H when free); members 3, 6, 11, 12, 13, 14 look a device up in it, ROUTE and SET write a new name into it and RESET writes it again.
4300H-43FFH 256 bytes	The system buffer: directory sectors, the allocation table (43CDH-43DFH: the configuration byte, the diskette's password hash, name and date) and the system information sector (members 1, 2, 5, 6, 7, 10, 12).
4400H-4401H 2 bytes	The hook of DEBUG for a key it does not know: RESET puts back 4876H.
4405H 1 byte	The BREAK trap switch: DO stores C9H, the trap off.
4411H-4412H 2 bytes	HIGH$, the highest address free for programs (members 1, 2, 6, 7, 11, 12, 13).
4415H-4416H 2 bytes	The top of memory (MEMORY, RESET).
442BH 1 byte	SFLAG$: bit 5 a JCL job (every member that can fail), bit 2 a program load (FILTER and SET, RUN and LOAD), bit 3 FAST, bit 4 BREAK disabled (DEVICE), bit 0 cleared by RESET.
443AH-443BH 2 bytes	The address of the @WRITE vector: 48E6H when writes are verified (DEVICE).
4485H-44A4H 32 bytes	CFCB$, the control block of a program (RUN and LOAD).
4500H-4517H 24 bytes	The task table, the address of each slot's task block: SPOOL uses slot 9 (4512H), RESET looks at every slot.
46F7H 1 byte	The spare byte of the disk driver, not 00H when SMOOTH is on (DEVICE).
4700H-474FH 80 bytes	DCT$, the eight drive code tables of 10 bytes: DIR and DEVICE read them through GETDCT, RESET copies them from the second block of the system information sector of drive 0.
4758H 1 byte	The command interpreter's status: bit 1 a command line from a program (members 1, 2, 6, 7, 11, 12, 13, 14), bit 3 set by FILTER and SET.
475DH 1 byte	The date stamping flags, bit n for drive n (DIR, COPY).
4BCEH-4BCFH 2 bytes	The operand of the JP P in the supervisor dispatcher: RESET puts back 4BEEH.
4BDEH-4BDFH 2 bytes	The operand of the overlay loader's CALL in the supervisor dispatcher: 4BF4H while no system files are kept in memory (DEVICE, RESET).
4D53H-4D61H 15 bytes	The four route routines of SYS0/SYS (loads of Register Pair HL at 4D53H, 4D57H, 4D5BH and 4D5FH that run on into 4D62H): ROUTE stores a destination in an operand whose low byte is 00H (4D54H on), and KILL, DEVICE, RESET, ROUTE and SPOOL follow a routed device through them.
4DF0H-4DF1H 2 bytes	The address of an installed spooler's parameter block (SPOOL, RESET).
4DF6H-4DF7H 2 bytes	The module address of PR/FLT (SPOOL).
4EC3H 8 bytes an entry	SYS1/SYS's command table, read by LIB.
51E1H, 51EAH-51F4H 12 bytes	Cells of SYS2/SYS: the old name's hash and the new name packed (RENAME).

5200H - Member 1 (MEMORY): Entry, Parameters and CLEAR

The MEMORY command (library member 1EH). SYS1/SYS's command loop issues request 88H with Register B = 1EH; the overlay loader of SYS0/SYS (4BF4H) loads this member at 5200H-5603H and the supervisor dispatcher calls 5200H with Register Pair HL at the command's parameters. The parameters are read by @PARAM (4454H) straight into the operands of the instructions that use them (table at 54E9H). CLEAR (5214H) fills 5200H up to HIGH$ with 00H; ADD, WORD and BYTE (523BH) show and change memory; HIGH (5294H) reserves memory below HIGH$; with neither, MEMORY shows HIGH$ or lists the modules above it (52CFH); GO (545FH) jumps to an address last.

5224H - The CLEAR Routine, Copied to 4300H and Run There

These 23 bytes are copied to 4300H-4316H by 5221H and run there: the addresses in the comments are those of the copy. It fills every byte from 5200H up to HIGH$ (4411H-4412H) with 00H, this member included, and leaves through @EXIT (402DH). The routine has no relative jump, so it runs the same at either address.

523BH - ADD, WORD and BYTE: Show and Change Memory

With ADD=address the member shows the address in hexadecimal and decimal and the two bytes there in the order they lie in memory; WORD= stores a word at the address (low byte first) and BYTE= one byte, and the bytes are then shown again after =>. The line is built in the template at 556BH: X'aaaa' = ddddd ('bbbb' => X'bbbb'). WORD=0 and BYTE=X'FF' cannot be given: those are the values that mean not given.

5294H - HIGH: Reserve Memory below HIGH$

HIGH=address makes the memory from address + 1 up to the current HIGH$ a reserved block: a ten byte module header (the template at 54A9H) is written at address - 9 to address, HIGH$ becomes address - 10, and the header names the block &aaaa after its first address. The address must be below the current HIGH$ (or equal to it) and above the word 5200H holds at this point (73EDH, the first two bytes of this member), else Range error.

52CFH - No HIGH: Show HIGH$, or Start the Directory

When HIGH$ is the top of memory (nothing is above it) the line High = X'nnnn' is all MEMORY shows. Otherwise the High Memory Directory follows: a blank line, the summary line with HIGH$ and the bytes above it, the column headings, and one line for each module or block above HIGH$.

5308H - The Module Loop: One Line for Each Module above HIGH$

Register Pair HL = the address where the next module should start. A module in high memory begins with a header: 18H (a JR over the header), the jump's offset, the link word (the last address of the module), the length of the name and the name. For each module the line shows the name, its first and last address and its length in decimal; bytes that do not begin with a header are shown as <unknown> up to the next header (53A4H). The loop ends after the top of memory.

5357H - Build the Summary Line and the Column Headings

Fills the line buffer at 5200H with High Memory Directory, HIGH$ = X'nnnn' and Length = ddddd (the bytes above HIGH$ up to the top of memory) and sends it; then copies the column headings line (55BAH) into the buffer for the caller to send.

53A4H - Bytes without a Header: Find the Next Module

Register Pair HL = the first byte above the last module, where no 18H header begins. The bytes from here are searched for an 18H that starts a believable header: its link word not below the byte before it, a name length below 16 and a name of printable characters 21H-7AH. The bytes up to that header (or up to the top of memory when none is found) get a line of their own named <unknown>.

53FFH - Helper: Write X'nnnn' into the Line

Register Pair HL = the value, Register Pair DE = where in the line buffer. The four hexadecimal digits go into the template X' ' at 55FDH-5603H and the seven characters are copied to Register Pair DE.

5411H - Helper: Write a Number in Decimal

Register Pair HL = the number (0-65535), Register Pair DE = the first of five places. The places are filled with spaces, then the digits are written from the right, dividing by ten (@DIV) until the number is 0. Returns Register Pair DE after the five places.

542AH - Helper: Send the Line, Blank It and Count It against the Page

Sends the line buffer at 5200H to the printer when PRINT was given and to the video, fills its first 57 bytes with spaces again (5239H keeps the 0DH) and counts the line. After 15 lines it waits for a key: BREAK ends the command, any other key clears the screen and starts a new page with the column headings.

545FH - GO and the Exit

GO=address is carried out last of all: the member jumps to the address with the stack as the command was entered, so the code there can return to LDOS with a RET. Without GO the member ends with Register Pair HL = 0000H (done). The error paths come in at 546BH with Register Pair HL = FFFFH: the stack is put back, and when a JCL job runs (bit 5 of 442BH) the job is ended through @ABORT.

547AH - Check for LDOS Command Level

Returns only when the command may change memory: @EXIT (402DH) is not taken over by a running program (a JP there) and the command did not come from a program through SYS1/SYS's function 20H (bit 1 of 4758H). Otherwise displays Can't -- Only valid at LDOS command level and ends the command. While a JCL job runs, SYS11/SYS keeps the original bytes of 402DH at 4065H, so those are tested instead.

54A0H - Parameter Error

@PARAM rejected the parameters, or BYTE was given a value above 255: error 2CH (parameter error) is reported through @ERROR, which returns, and the command ends with Register Pair HL = FFFFH.

54A9H - MEMORY Data: the Header of a Reserved Block

The ten bytes HIGH writes below the memory it reserves (52CBH): the module header that MEMORY's own directory, and the other programs that walk the module chain from HIGH$, read. The link word and the four characters of the name are filled in before the copy.

54B3H - MEMORY Data: Messages

The two messages of the member, each ended by 0DH, displayed by 5498H.

54E9H - MEMORY Data: the Parameter Table

The table @PARAM reads (5204H): fourteen entries of eight bytes, a keyword of six characters padded with spaces and the address where its value is stored, then 00H. Each address is the operand of an instruction that uses the value; the short form of each keyword names the same address.

555AH - MEMORY Data: the High Line and the ADD Line

The line shown when nothing is above HIGH$ (52E1H), and the template of the ADD line, whose digits are filled in by 5244H-527EH and whose end (5583H or 558EH) is chosen by 5289H.

558FH - MEMORY Data: the Directory Texts

The texts of the High Memory Directory: the summary line's parts (5357H), the column headings (5398H), the name of a block with no header (53E8H) and the template of a hexadecimal address (53FFH).

5200H - Member 2 (DIR): Entry, the File Specification and the Drive

The DIR command (library member 21H), loaded at 5200H-5BE0H. Register Pair HL points at the text after DIR: an optional partspec (name and extension with $ for any character, a leading - to show the files that do not match), an optional drive (:d, or the digit alone), then the parameters in brackets (table at 5A42H). The partspec goes into the masks at 5B6AH (8 bytes) and 5B72H (3 bytes), the drive into 52AEH (the first drive shown) and 53FEH (FFH: no drive given, show every drive).

5252H - Set Up: SORT, the Sort Buffer, P and DATE

A DIR issued by a program (bit 1 of 4758H) is never sorted, since the sort buffer at 5E00H-HIGH$ is memory that program can be using. The highest address a sorted record may end at is HIGH$ - 33 (5BE3H). P implies N. DATE="M1/D1/Y1-M2/D2/Y2" gives a start date (5BE5H, bit 7 of the mode byte 5BE0H) and an end date (5BE7H, bit 0); "M1/D1/Y1" gives the same date for both, "-M2/D2/Y2" only the end and "M1/D1/Y1-" only the start.

52B4H - One Drive: Check It, Read the Allocation Table, Count the Free Granules

The loop over the drives starts here with Register C = the drive. A drive that is not ready is passed over (541BH). The allocation table (sector 0 of the directory cylinder) is read into 4300H and its free granules counted: each cylinder's byte has a bit set for every granule in use, and the granules the cylinder lacks are set too.

5308H - The Drive Line: Cylinders, Density, Sides, Total Space and Directory Size

Fills the drive line at 5AFBH: Drive :d, the diskette's name and date from the allocation table (43D0H, 43D8H), the cylinders and the density letter (S single, D double, H a rigid drive) with the sides or heads, Free=free/total in kilobytes and Fi=free/total directory records, and displays it.

53DEH - The Next Directory Record and the End of the Drive

The slots of the hash index table are taken in the order 00H, 20H, 40H ... E0H, 01H, 21H ...: slot n is record (n AND E0H)/32 of directory sector (n AND 1FH) + 2, so the eight records of one sector are done before the next sector is read. After the last slot the sorted records are shown, the line is ended, and the next drive follows unless a drive was given.

541BH - A Drive That Is Not Ready

@CKDRV found no diskette. When the drive was asked for, error 20H (illegal drive number) is reported; when every drive is being shown it is passed over. When the last drive (7) is not ready, the RET at 542CH ends the command at once: the stack is back at its entry depth, and Register Pair HL is what @CKDRV left, not 0000H.

542DH - Read a Directory Record and Decide Whether It Is Shown

Register Pair HL = the slot's hash byte at 5C00H-5CFFH. A slot with a hash is read with DIRRD (the sector is read only when it is not the one already at 4300H, 5439H). A record is passed over when it is not in use or is an extension record; a system file needs S, an invisible file I; MOD shows only files whose mod flag is set; the name must match the partspec (or must not, after a minus sign); DATE keeps the files whose date lies in the range. A file that passes is shown at once (5509H) or, with SORT, copied to the sort buffer with its size.

5509H - Show One File: Name, Extension and Attributes

Register Pair HL = any byte of the file's directory record. The name and /extension take 13 columns, then five attribute characters: S (system), I (invisible), P (a password with an access level below full), * (bit 5 of the attribute byte: a partitioned data set) and + (the mod flag), each - when off, and a space. With the full display (A, the default) the detail follows (55C5H) and the line ends; in the short display (A=N) three files share a line.

55C5H - The Detail of a File: Access, LRL, Records, EOF, Extents, Size, Date and Time

Fills the detail template at 5B3CH (pr lrl #recs eof de s=sssss.s dd-mmm-yy hh:mm, 45 characters) from the record at Register Pair HL and displays it. pr is the access code (5AEBH; AL when no password protects the file), the records are worked out from the ending record number, the end of file byte and the record length, the size in kilobytes from the granules; s: instead of s= marks a file made by CREATE. The time is shown only for a diskette that carries it (56ACH).

5709H - The Size of a File: the Sorted Key or the Extents

5709H returns Register Pair DE = the file's granules and Register Pair BC = its extents. With SORT the two words stored at +16H-+19H of the copied record (54DEH) are taken; otherwise 571FH adds up the extents of the record at Register Pair HL and of its extension records: each extent is two bytes (the cylinder, then bits 7-5 the first granule and bits 4-0 the granules less one), FEH as a cylinder links to an extension record whose number follows, FFH ends the list. An extension record not in the buffer at 4300H is read into 5D00H.

577CH - Output Helpers: a Text, a Character, a Space

577CH displays the text at Register Pair HL and prints it when P was given (the P parameter at 578FH). 5787H shows a space, 5789H the character in Register A, both also sent to the printer with P; 578EH sends Register A to the printer only.

5796H - Granules to Kilobytes

Register Pair DE = granules, Register Pair HL = the place of five digits. The granules times the sectors in a granule (579BH) give the sectors; four sectors of 256 bytes make one kilobyte. The kilobytes go out as five decimal digits (588CH) and the quarter left over returns in Register A as the tenths digit 0, 2, 5 or 8.

57C2H - Copy a Name Field into a Mask

Register A = the first character, Register Pair HL = the text after it, Register Pair DE = the mask, Register B = the most characters. A $ and the letters and digits are stored, small letters as capitals; any other character ends the field. Returns Register A = the character after the field and Register Pair HL past it.

57DDH - A Directory Date as One Word

Register Pair HL = byte +01H of a directory record. Returns Register Pair DE = the year in bits 15-11, the month in bits 10-7 and the day in bits 6-2, so that dates compare as numbers. The year is the five bit year at +13H on a diskette with this release's dates (56ACH), else the three bits of +02H.

5806H - Read a Date Argument MM/DD/YY

Register Pair HL = the first digit. Three fields of two digits separated by slashes are read into 5BEBH (the month), 5BEAH (the day) and 5BE9H (the year); years 00-11 mean 2000-2011. The day is checked against the days of the month at 5B76H (February gets one more day in a leap year: 581FH adds it to the table itself, so a second leap year date in the same command allows one more). Returns Register Pair BC = the date as one word in the form of 57DDH, Register Pair HL after the date. A bad date goes to Bad date format.

5856H - Read Three Two Digit Fields

Register Pair HL = the text, Register C = the separator. The fields go to 5BEBH, 5BEAH and 5BE9H. Returns the Z FLAG with Register Pair DE = 5BE9H, or the NZ FLAG when a field is not two digits or a separator is not Register C. 586BH reads two digits into Register A (the Z FLAG when both are digits); 5881H takes one character and returns the CARRY FLAG for a digit.

5888H - Decimal Output: Three, Five or Two Digits

Register Pair HL = the number, Register Pair DE = the place for the digits. 5888H writes three digits and 588CH five, with spaces for leading zeros; 58A0H writes two digits with Register A = the character for a leading zero (a space or 0). Each digit is found by 58ACH, which subtracts the power of ten in Register Pair BC as often as it can. Register Pair DE returns after the digits.

58C7H - BREAK and the Pause Key

58C7H returns the Z FLAG to go on and the NZ FLAG for BREAK. During a JCL job (bit 5 of 442BH) nothing is checked. With SHIFT @ held (bit 1 of KFLAG$, 429FH) it waits for a key other than SHIFT @. 58E8H clears the BREAK, pause and ENTER bits of KFLAG$.

58F2H - Count a Line against the Page

Counts down the lines left on the screen (58F3H, 15 a page). At the end of a page, unless N or P was given or a JCL job runs, it waits for a key: BREAK ends the command, C (or c) makes the rest of the display continuous, any key clears the screen; then the column headings are shown again (5921H).

5944H - SORT: Sort the Collected Records by Name and Show Them

The records copied to 5E00H up to the address in 5BE1H are sorted through a table of pointers built right after them, one word for each record: a Shell sort (5997H) compares the eleven characters of name and extension and swaps the pointers, then each record is shown through 5509H in the new order. The room test before the table compares twice the count with the ceiling address itself, not with the room left above the records.

5997H - The Shell Sort of the Pointer Table

N = the number of records (5998H). The gap starts at N/2 and halves until it is 0 (599EH). For each i from 0 below N - gap (59BAH, the limit at 5A1FH), j starts at i (59C0H): when the name of record j + gap is below the name of record j, the two pointers swap and j steps back by the gap while it stays 0 or more. Every count lives in the operand of the instruction that loads it.

5A29H - Errors and the Common Exit

5A29H displays Insufficient memory for SORT buffer!; 5A2DH (inside the LD IX at 5A2CH) displays Bad date format; 5A35H reports error 2CH (parameter error) and 5A37H the error in Register A through @ERROR, which returns. All end the command with Register Pair HL = FFFFH.

5A42H - DIR Data: the Parameter Table

The table @PARAM reads (5249H): thirteen entries of eight bytes, a keyword of six characters padded with spaces and the address its value goes to, then 00H. Every address is the operand of the instruction that uses the value.

5AABH - DIR Data: the Headings, the Access Codes and the Drive Line

The column headings of the full display (5926H), the eight access codes of the detail (55D3H) and the template of the drive line (53C1H), whose fields 5302H-53BEH fill in for each drive.

5B3CH - DIR Data: the Detail Template, the Masks and the Days of the Months

The 45 characters of the detail (filled by 55C5H), the name and extension masks of the partspec, and the days in each month for the date check.

5B82H - DIR Data: Messages, Month Names and the Date Mode

The two messages (5A29H, 5A2DH), the month names of the detail (569CH), the five asterisks of a record count that does not fit (5624H) and the date mode byte, the last byte of the member.

5200H - Member 3 (KILL): Entry and the Loop over the File Specifications

The KILL command (library member 18H), loaded at 5200H-538FH. Register Pair HL points at the text after KILL: one or more file specifications, or device names (*XX). Each is taken in turn: a file is opened to check its access and deleted with @KILL (4424H, 442CH); a device is taken out of its device control block (5286H). Each deletion is shown as Deleting: name:d. BREAK between two specifications ends the command; an error ends it through @ERROR.

522EH - One File Specification: Open the File, Check the Access, Delete It

The specification is read into the control block at 539FH (above the member, not in the file) and copied without its password into 5390H for the message. A device name (*) goes to 5286H. A file must open and its access must be KILL or better (level 0 or 1, else error 25H); the drive is added to the message when the specification has none.

527DH - Helper: Display the Deleting Line

Displays Deleting: followed by the name built at 5390H. Register Pair DE (the control block) is kept.

5286H - Remove a Device

The two letters after the asterisk name the device. Its device control block is looked for in the table of device names of SYS0/SYS (42ECH-42FFH, two letters a slot): slot n of KI, DO and PR (n = 0-2) gives the block 4015H + 8 x n, slot n of JL, SI, SO and the four spare slots (n = 3-9) the block 42B0H + 6 x n (42C2H-42E6H); not found is error 08H. KI, DO, PR and JL cannot be removed (error 28H), nor a device that is assigned (bit 3 of its type clear: error 27H). The six bytes of the block are cleared to 00H; every device routed to it (type bit 4, its +01H-+02H pointing at a routine whose LD HL operand names the block routed to) gets type 08H and the driver 497CH back, and that operand is cleared; then the first six bytes of the control block at 539FH are cleared, and Deleting: with the device's name is shown.

5321H - Helpers: Clear Six Bytes, Copy a Specification without Its Password

5321H stores 00H in the six bytes at Register Pair HL. 5329H copies the text at Register Pair HL to Register Pair DE up to a control character, leaving out a password (from a full stop up to the colon of the drive).

533EH - Helper: BREAK

Returns the Z FLAG when BREAK was not pressed (bit 0 of KFLAG$, 429FH, clear). When it was, the bit is cleared again and again until the key has been let go for a moment, the keyboard is read until no key is down, and the NZ FLAG returns. Every register is kept.

5360H - Errors

5360H reports the error number in Register A through @ERROR, which returns; 536BH displays File spec required. Both end the command with Register Pair HL = FFFFH.

5373H - KILL Data: Messages

The two texts of the member. Deleting: runs on into the name that 523DH copies to 5390H (above the file), ended there by 0DH.

5200H - Member 4 (LIB, CLS, TOF): the Three Entries

One member serves three commands, loaded at 5200H-52D2H: LIB (member 19H) enters at 5200H, CLS (24H) at 5203H and TOF (25H) at 5206H, the entry addresses their member headers in the file give. CLS clears the screen; TOF moves the printer to the top of the next form; LIB lists the library commands (5222H). Each ends with Register Pair HL = 0000H.

5222H - LIB: List the Library Commands

Reads the command table of SYS1/SYS at 4EC3H, which stays in memory while a library command runs: eight bytes an entry (a six character name, the member and the flags), 00H after the last. The first pass shows the entries whose flags have bit 6 clear (Library A, SYS6/SYS), the second those with bit 6 set (Library B, SYS7/SYS; BOOT is listed there, its flags byte 4EH having bit 6 set). Each name shows its first letter as stored and the others XOR 20H (small letters), four names to a line.

52BFH - Helper: Display Spaces

Displays Register B spaces through the ROM at 0033H.

52C7H - LIB Data: the Heading

The heading of each pass; 5271H changes its letter for Library B.

5200H - Member 5 (DO): Entry, Open the JCL File and Create SYSTEM/JCL

The DO command (library member 91H), loaded at 5200H-59D7H (its end is 5D00H, the symbol table reaching above the loaded bytes). It reads a /JCL source file line by line, works out the lines that are kept and the parameter values put into them, writes the result to a file SYSTEM/JCL on the first writable drive, and runs it. An optional control character after DO changes this: * runs the SYSTEM/JCL that is already there (532BH), = runs a named file without compiling it (5314H), $ compiles to SYSTEM/JCL without running it (52C0H, the quiet flag). The source file keeps its default extension /JCL.

5260H - The Command Tail: Parameters and the Keyin Prompt

The text after the source file is scanned: spaces and commas are passed over, an opening bracket starts the parameter list (533CH), a semicolon prompts with a question mark for more text through @KEYIN, and ENTER ends the command line, so that the compile and the run follow (5384H). Any other character is a parameter error.

528BH - Pop an Included File off the Include Stack

When the end of an included file is reached, its saved control block is taken back from the include stack: 5906H holds the address above the top entry, each entry 32 bytes. The entry is copied back to the working source control block at 57BCH and the stack pointer lowered.

52A5H - Read the Next Source Line

While the include stack is not empty (5906H above 5908H, its base), the end of an included file pops it (528BH) and reading goes on in the file that included it. 53BAH reads one line into 59D8H; 5384H and 53B7H come back here for the next line.

5314H - DO = : Run a Named File without Compiling

The equals control character runs a file as the compiled SYSTEM/JCL without a compile: the file specification after it is taken into JFCB$ at 4265H and the member jumps to the reopen and run (52C4H).

532BH - DO * : Run the Current SYSTEM/JCL File

The asterisk control character runs the SYSTEM/JCL file that a previous compile left: its file specification is copied to JFCB$ at 4265H and the member jumps to the reopen and run (52C4H).

5330H - Helper: Copy the SYSTEM/JCL Specification

Copies the 32 bytes of the template at 5818H (SYSTEM/JCL, with the drive digit patched in at 5823H) to JFCB$ at 4265H.

533CH - The Parameter List: Tokens and Their Values

Each item in the brackets is a token of up to eight characters: a plain token is given the logical value true, token=value gives it a character string, and @label names the start the compile is to scan for. 5620H reads the token into 57DCH; a token that begins with @ sets 5343H, so it is kept as the label at 5805H; otherwise 56EAH checks it is not already defined (error Multiply defined parameter) and 56CDH stores it true. 562BH reads a value after =, and 56DFH stores it.

5384H - Read Lines, Finding the Named Label

When a label was given (568EH), the source lines are read without being compiled until a line @label matches the wanted label (5805H): 549DH reads a line into 59D8H, and the lines are passed over until the match, the end of the included files popped on the way (Procedure not found when none match). Without a label, the compile starts at once (53BAH).

53B7H - The Compile Loop: Read a Line and Compile It

549DH reads the next source line into 59D8H; at the end of a file 52A5H pops an included file or finishes. A line is compiled (53C0H) into the buffer at 5200H and written (54CEH): each character is copied, # starts a parameter substitution, % a hexadecimal byte, // a directive, and a line that begins with @ ends the procedure.

540AH - Helper: A Hexadecimal Digit to Its Value

Register Pair HL = the digit character. Returns Register A = the value 0-15, or jumps to 545AH (Invalid JCL format) for a character that is not a hexadecimal digit. Small letters are folded to capitals.

541BH - Substitute a Parameter Value

A #name# field: 5620H reads the name, which must be followed by a hash. The token is looked up (56EAH) and, when it has a value string (its length byte at +08H not 00H), the string is copied into the compiled line. A token that is not defined or has no value string is left as the literal #name# in the line; a name not followed by a hash is Invalid JCL format.

544EH - Directives: the Nesting Check and the Error Line

544EH returns when the condition stack at 59A8H holds at least one //IF (its top below the base 59AAH), so that //ELSE and //END have an open block; otherwise it falls into 545AH. 545AH builds the error line Line nnnnn --> Invalid JCL format, processing aborted! from the line number (545EH) and ends the command.

546FH - A Directive Line: // Dispatch

The name after the two slashes is read (5620H into 57DCH). The conditional directives IF, ELSE and END (table 54FAH) are tried first and run even inside a block being skipped; the other directives SET, RESET, ASSIGN, INCLUDE and QUIT (table 5510H) run only when the block is not being skipped. A // with no name, or an unknown directive, is copied to the compiled line as a comment.

549DH - Read One Source Line into 59D8H

Counts the line at 545EH and reads up to 64 characters from the source file (ROM 0013H, @GET) into 59D8H, ended by 0DH, returning the Z FLAG. The end of the file (error 1CH), and a byte of 00H, return the NZ FLAG with Register A = 1CH (54CAH); a line of 64 characters without 0DH ends the command with Line too long!.

54CEH - Write the Compiled Line to SYSTEM/JCL

When the top of the condition stack (59A8H) holds a skip state, nothing is written. Otherwise the compiled line at 5200H is written to the SYSTEM/JCL file through the ROM (001BH, @PUT), up to its 0DH. A line that begins with two slashes and a full stop (//.) is displayed with @DSPLY instead of written.

54FAH - DO Data: the Conditional Directive Table

The three directives that run even inside a block being skipped: a six character name padded with spaces and the two byte address of the handler, ended by 00H. Searched by 56FBH.

5510H - DO Data: the Other Directive Table

The directives that run only when the block is compiled: an eight character name padded with spaces and the two byte address of the handler, ended by 00H. Searched by 5704H.

5543H - IF: Evaluate the Condition and Push the Block State

The expression after //IF is tokens joined by the operators & (and) and + (or); a token is true when it is defined (set on the DO line, by //SET or by //ASSIGN), and a leading - means not. 557FH evaluates a term of tokens joined by & and returns the Z FLAG for a true term; + starts another term. When a false token is followed by &, the rest of the line is passed over, so the terms after it are not evaluated. The result (00H compile for a true term, FFH skip) is pushed onto the condition stack at 59A8H ORed with the state below it, so a block inside a skipped block is skipped too.

556BH - ELSE: Flip the Block State

Reverses the top of the condition stack, unless an enclosing block is skipped. 544EH makes sure a block is open and returns Register Pair HL at the top state byte. The byte is complemented (compile becomes skip and the other way about) and ORed with the state below it, so an ELSE inside a skipped block stays skipped.

5576H - END: Pop the Block

544EH makes sure a block is open and returns Register Pair HL at the top state byte; the stack pointer is lowered by one to drop it.

557FH - Evaluate a Term of the Condition

A term is one or more tokens joined by & (and): 5589H evaluates one token (with a leading - for not) and returns the NZ FLAG when it is false. A false token makes the whole term false at once; otherwise & joins the next token. Returns the Z FLAG for a true term and Register A = the character after it.

5589H - Evaluate One Token

A leading - means not. 5598H reads the token (5620H) and looks it up (56EAH): the Z FLAG when it is defined (true), the NZ FLAG when it is not. After a minus sign the result is turned round with the OR AFH at 5594H, whose AFH is entered as XOR A. Register A returns the character after the token.

55A5H - SET: Give a Token the Value True

The token after //SET is read (5620H) and stored true (56EAH looks it up, 56CDH stores it when it is new).

55B4H - RESET: Give a Token the Value False

The token after //RESET is read (5620H) and, when it is found (56EAH, Register Pair DE at the entry's length byte), a space is stored over the first character of its name, eight bytes before: the entry can no longer be found, so the token counts as false. A token not already stored is already false.

55C6H - ASSIGN: Give a Token a Character String Value

The token after //ASSIGN is read (5620H) and stored (56EAH, 56CDH); then an equals sign is required, the value string is read (562BH) and stored against the token (56DFH).

55DFH - INCLUDE: Compile Another File in Place

The current source control block at 57BCH is pushed onto the include stack at 5906H (error Too many nested INCLUDEs! when the stack is full, its top at or above 59A8H, the condition stack), the named file is opened in its place, and the compile goes on reading from it.

5614H - QUIT: End the Compile

The SYSTEM/JCL file is closed and the member jumps to the finish (57B3H with the line at 59D8H, which ends the command).

5620H - Read a Token or a Value String

5620H reads a token of up to eight characters at Register Pair HL into the buffer at 57DCH; 562BH reads a value string of up to 32 characters into 57E5H and stores its length at 57E4H (error Symbol string too long! above 32). Both call 5667H, which stores the characters, folds small letters to capitals, keeps the characters inside a pair of quotes whole, sets the label flags on an @, and pads the field with spaces.

5667H - The Character Reader of a Token or Value

Register B = the most characters, Register Pair DE = the buffer, Register Pair HL = the text. Characters are stored until 03H, 0DH or a character not allowed in a token; a pair of quotes keeps whatever is between them; an @ at a token sets the label flags (a second @ is Too many Proc labels!); the field is padded with spaces to Register B characters. Returns the character that ended it in Register A, the Z FLAG when a character was stored.

56CDH - Store a Token in the Token Table

Register Pair DE = the free entry 56EAH found (the 00H that ends the table). The eight character name at 57DCH is copied into it, its length byte (+08H) is set to 00H (no value string), and the first byte of the next entry, 41 bytes on, is cleared to end the table.

56DFH - Store a Value String against a Token

Register Pair DE = the length byte of the token just stored (after its name). The 33 bytes at 57E4H (the length and up to 32 characters) are copied there, so the token carries its value string.

56EAH - Look for a Token in the Token Table

The token name at 57DCH is searched in the table at 5D00H (41 byte entries: eight name, one length, 32 value; 00H ends the table). 5716H returns Register Pair HL at the length byte of the matching entry, or at the 00H free slot. Returns Register Pair DE = that address and the Z FLAG when the token was found.

56FBH - Search a Directive Table

56FBH searches the conditional directive table at 54FAH (7 byte entries), 5704H the other directive table at 5510H (10 byte entries), for the name at 57DCH. 5716H returns Register Pair HL at the two byte handler address after the matched name, which is read into Register Pair DE. The Z FLAG is set when the name was found.

5716H - The Name Table Search

Register Pair HL = the table, Register Pair DE = the name wanted, Register B = the characters compared, Register C = the bytes of an entry. Each entry's name is compared with the wanted name, spaces at the end of either counting as the end; on a match Register Pair HL is left just past the entry's name, on no match it steps on by Register C bytes. A 00H where a name begins ends the table, returning the NZ FLAG.

5766H - Helper: Write a Number in Decimal

Register Pair HL = the number, Register Pair DE = the first of five places. The places are filled with spaces, then the digits are written from the right by dividing by ten (@DIV) until the number is 0.

577FH - Helper: Test for a Space or a Comma

Returns the Z FLAG for a space or a comma in Register A, the NZ FLAG otherwise. Register A is kept.

5785H - Helper: Fold a Small Letter to a Capital

A character a-z (61H-7AH) has 20H taken off to make it a capital; the CARRY FLAG is set for a character that is not a letter a-z. Any other character is left as it is.

578FH - Parameter Error and the Message Selector

578FH reports error 2CH (parameter error) through @ERROR; 5798H and the five entries below it are a chain of LD IX instructions whose DD prefixes make each entry but the one jumped to a dead load, so entering at 5798H, 579CH, 57A0H, 57A4H, 57A8H, 57ACH or 57B0H each loads Register Pair HL with one message. 57B3H displays it and ends the command.

580DH - DO Data: Launch Stubs and the SYSTEM/JCL Name

The stubs copied over the exit and error vectors while the JCL runs, and the file specification SYSTEM/JCL with its drive patched in.

5825H - DO Data: the Messages

The messages the selector at 5798H and the error path at 5469H choose between, each ended by 0DH.

5906H - DO Data: Stacks and the Error Line

The include stack and the condition stack grow in the work area; their pointers are kept here, and the error line holds the line number.

5D00H - DO Data: the Token Table

The table of tokens set on the DO line, by //SET or by //ASSIGN. Each entry is eight name characters, a length byte and a 32 byte value string (41 bytes); a 00H name byte ends it. Built in the work area above the member.

5200H - Member 6 (SPOOL): Entry and an Installed Spooler

The SPOOL command (library member A2H), loaded at 5200H-59E8H. It builds a printer spooler in high memory: a module of 016BH bytes (copied from 5852H), a queue block of 44 bytes (from 59BDH), a table of 4 byte slots, one for each 256 byte memory page and each disk sector of the buffer, and the memory pages. The module takes over the output of the device (its control block's driver address), stores each character in the queue, sends the queue to the device from an interrupt task (slot 9) two characters a tick while the device is ready, and moves pages between memory and the spool file from the keyboard task (@KITSK, 4285H), since a disk transfer cannot run inside the interrupt. The spooler's parameter block (module +0AH, 10 bytes) is addressed by Index Register IY at 585CH while the member runs and by 4DF0H-4DF1H once it is installed. When a spooler was installed before (4DF1H not 00H), its parameter block is copied back here and only OFF, PAUSE, RESUME and CLEAR are accepted.

523FH - Check for LDOS Command Level

A spooler may only be installed at LDOS command level: @EXIT (402DH) must not be taken over by a running program (a JP there), and the command must not come from a program through 429CH (bit 1 of 4758H). While a JCL job runs, SYS11/SYS keeps the original bytes of 402DH at 4065H, so those are tested instead. Otherwise the message Can't -- Valid only at LDOS Command level! ends the command.

5259H - Read the Device and the Spool File

The first specification is the device (an asterisk and two letters; PR when none is given) and goes to the control block at 57C6H. A file specification after it, or one given without a device, names the spool file; it is put together in the queue block at 59BDH, whose first 32 bytes are the spool file's control block. With no file name the name is the two letters of the device; the extension is SPL unless one is given, and a drive alone (:d) is added to that name.

52C6H - Read the Parameters

@PARAM reads the parameters into the operands that use them (table 57F1H: MEM, DISK, OFF, PAUSE, RESUME, CLEAR; or from 5811H for a spooler in memory). OFF, RESUME, PAUSE and CLEAR are tested in that order; each one given goes to its own routine. With none, the spooler is installed.

52EBH - Install: Find the Device

An installed and running spooler (DFLAG$ bit 0) is not installed twice, and KI/DVR must be installed (DFLAG$ bit 4), since the queue is moved between memory and disk from the keyboard task. The device's control block is looked for by its two letters; a routed device (type bit 4) is followed to the control block it is routed to. When PR/FLT is installed (DFLAG$ bit 3) and its saved control block address equals the one found, the spooler is put behind the filter: it takes the filter's own control block copy.

533FH - Install: Make the Spool File

DISK (in K, 4 in the file) is the size of the spool file; DISK= with no value gives 0 and no file. The file is opened or made with records of 256 bytes, its last sector (DISK x 4 - 1) is written so that its space is taken, it is rewound and its end of file is set to its start, and bit 7 of byte +01H of its directory record is set so that the space is kept when the file is closed.

5392H - Install: Lay Out the Spooler's Memory

MEM (in K, 1 in the file) is the memory buffer. HIGH$ less 8100H, divided by 4 and counted in K from its high byte only, must leave room for it. Below the top of the spooler's memory (HIGH$, or the top recorded at an earlier install) come, from the top down: MEM x 4 pages of 256 bytes ending at the page boundary at or below the top, a table of (MEM + DISK) x 4 + 1 slots of 4 bytes, the queue block of 44 bytes and the module of 016BH bytes. A memory slot is 00H 00H, the page, 00H; a disk slot is 00H 00H, the sector number low, the sector number high OR 80H; the last slot is 00H 00H FFH FFH. The first two bytes of a slot are 0000H for a free slot, else the address of the next slot of the queue, the last one pointing at itself.

548DH - Install: Move the Module and Start It

The module's addresses are made to point at its place in high memory, the module is copied there, 4DF0H-4DF1H gets its parameter block, the device's control block gets the module as its driver, the despooler is put into task slot 9, @KITSK is made a jump into the module, and DFLAG$ bit 0 and KFLAG$ bit 4 are set.

5514H - PAUSE and RESUME

Both need the spooler installed and on (DFLAG$ bit 0). PAUSE clears KFLAG$ bit 4, so the despool task sends nothing while characters are still queued; RESUME sets it again. Each says whether the bit was already as asked.

553EH - OFF: Turn the Spooler Off

The spooler is taken out of DFLAG$, the sending stops, @KITSK gets back the three bytes saved in the module, and task slot 9 is emptied. When HIGH$ is still the one the install left, the memory is given back (HIGH$ = the top) and 4DF0H-4DF1H is cleared; otherwise the spooler stays in memory to be turned on again in the same place. Then the device is reset by running the command RESET with its name through 429CH, which ends the member. The spool file is not closed here.

55ACH - CLEAR: Empty the Queue

Needs the spooler on. Every slot of the installed spooler's table is made free, the first slot becomes the whole queue again (pointing at itself, as the first and last slot), and the store and send places are both put at the start of its page, so the characters queued are lost.

55F6H - Find a Device Control Block by Name

Register Pair DE holds the two letters of the name (Register E the first). The name is looked for in the table of device names of SYS0/SYS (42ECH-42FFH): slot n of KI, DO and PR (n = 0-2) gives the block 4015H + 8 x n, slot n of JL, SI, SO and the four spare slots (n = 3-9) the block 42B0H + 6 x n (42C2H-42E6H). Returns the Z FLAG and Register Pair HL at the block, or the NZ FLAG and Register A = 08H (device not available). Register Pair DE is changed.

5625H - The Messages and the Exit

5625H and the six entries below it are a chain of LD IX instructions whose DD prefixes make each entry but the one jumped to a dead load, so entering at 5625H, 5629H, 562DH, 5631H, 5635H, 5639H or 563DH loads Register Pair HL with one message. 5640H displays it and ends the command with Register Pair HL = 0000H; 5646H puts the stack back and, for HL = FFFFH during a JCL job, ends the job through @ABORT. 5655H reports error 2CH (parameter error) through @ERROR, and 565EH, 5662H and 5666H are a second chain for the refusals.

5672H - SPOOL Data: the Messages

The messages of the selectors at 5625H and 565EH, each ended by 0DH, displayed by @LOGOT.

57C0H - SPOOL Data: the RESET Line and the Device

The command line OFF runs (559DH): Reset, then the device's specification, which @FSPEC writes into the control block that follows (an asterisk, two letters and 03H), with 0DH stored after the letters at 57C9H.

57E6H - SPOOL Data: Default Names and the Parameter Table

The default spool file name, the default device and the table @PARAM reads (52C6H): twelve entries of eight bytes, a keyword of six characters padded with spaces and the address where its value is stored, then 00H. Each address is the operand of an instruction that uses the value; the short form of each keyword names the same address. A spooler in memory is read from 5811H on, without MEM and DISK.

5852H - The Spooler Module: Header and Driver Entry

5852H-59BCH (016BH bytes) is copied to high memory by 54CEH and runs there, at the module's start (HIGH$ + 1) plus the distance from 5852H; the rows show it at its place in the member. 548DH-54C6H point every address the module uses inside itself at its new place. It starts with a module header (a JR over the header, a link word holding the top of its memory, the length of the name and SPOOL) and its parameter block. The device's control block points at 5852H as its driver: a character sent to the device (the Z FLAG set) is queued; a status request (Register C = 00H) is answered as ready, and anything else returns Register A = Register C.

5871H - The Spooler Module: Queue a Character

Stores Register C at the store place (queue block +20H-+21H) and moves it on. While the page has room, one character is sent if the device is ready and the page change of 5950H is tried. When the page is full a free slot is looked for in the table: a memory slot becomes the last slot of the queue and its page receives the next characters; a disk slot takes the full page, which is written to that sector of the spool file and linked in before the last slot, so that the same page can be filled again. With no free slot the module sends and changes pages until one is free.

5904H - The Spooler Module: the Despool Task

The task block (module +B2H) put into slot 9 by 54F8H: its word points at 5906H, which runs the send routine twice, so up to two characters go to the device on each tick. 5909H sends nothing while KFLAG$ bit 4 is clear (PAUSE) or the device is not ready, nothing when the page being sent is empty (queue block +23H = 00H) or the send place has reached the store place; after the last byte of a page it sets +23H to 00H, and 5950H chooses the next page outside the interrupt.

594AH - The Spooler Module: the Keyboard Task Part

@KITSK (4285H) jumps here (module +F8H) on each keyboard scan once the spooler is on. The page change runs here, outside the interrupt, since it can read a sector of the spool file; then the three bytes saved from @KITSK carry on as @KITSK did before the install.

5950H - The Spooler Module: Change the Page Being Sent

Does nothing while a page is being sent (queue block +23H not 00H). Otherwise the first slot of the queue is done: when the slot after it is a memory slot, the first slot is made free and that slot becomes the first, its page sent next. When the slot after it is a disk slot, its sector is read into the first slot's page, the disk slot is made free and taken out of the queue, and the first slot's page is sent again. Then one character is sent if the device is ready. Every register is kept.

59BDH - The Spooler Module: the Queue Block

The 44 bytes copied below the slot table by 5432H (the module +016BH in high memory). The first 32 bytes are the spool file's control block; +20H-+2BH are the queue's cells. The member fills it in place (5268H, 5293H, 5354H, 53DCH-541FH) before the copy.

5200H - Member 7 (COPY, APPEND): the Two Entries and APPEND

One member serves COPY (member 32H, entry 5200H) and APPEND (member 31H, entry 5203H), loaded at 5200H-5A6DH. The source's control block is 5986H and the destination's 59DAH. APPEND opens both files (the destination must exist and be a file), refuses files whose directory records give different record lengths, and positions the destination at its end. When its end is at a sector boundary and STRIP is not given, whole sectors are copied (53DCH); otherwise, and for a device as the source, byte by byte (5519H). STRIP backs the destination up one byte first.

52B1H - COPY: Read the Specifications and Parameters

Both specifications are read; a part of a destination (:1, /EXT) is kept as typed. A device at either end copies byte by byte (54F4H). X, the copy on one drive between two diskettes, may not run during a JCL job or with a device: the drive is taken from the source's specification and put into the two prompts, the destination becomes the source's specification, SYS2/SYS is loaded while the system diskette is still in, and the source diskette's name, date and password hash (GAT +CEH-+DFH) are kept to recognise it.

533DH - COPY: Open the Source and the Destination

The source is opened and its directory bytes +00H-+02H and +10H-+13H are kept (56CCH). The record length for the destination's directory record is the LRL parameter, or the source's own. 5466H records the date formats of the two drives (bit set in 475DH: the time and date layout with the time in +12H-+13H). For X the destination diskette is asked for, recognised by its GAT bytes, and refused when it is the source diskette. The destination is opened or made with @INIT; without X a destination that is the source's own directory record on the same drive is refused.

53DCH - Copy Whole Sectors through Memory

The source is read sector by sector into 5B00H and the pages above it, up to the highest page 54B8H set, then the pages are written to the destination; this goes on until the source reports the end of the file (error 1CH or 1DH). Then the pages read last are written, the destination's control block takes the source's end of file byte, and it is closed. For X each batch asks for the source and then the destination diskette.

5498H - Write the Last Pages

Register H is the page where the read of the source stopped. The pages 5B00H up to it are written to the destination; none when it is 5BH.

54B8H - Set the Highest Page and Clear the Keys

For a command typed at LDOS command level the buffer may reach the page below the one that holds HIGH$ + 1; for a command a program passed through 429CH (bit 1 of 4758H) it stays 5B00H-5FFFH, below 6000H, since the program's memory is above. The page goes into the three compares of the copy loops. Then the BREAK, pause and ENTER bits of KFLAG$ are cleared (57B0H).

54D4H - Give the Destination Its Space

Register Pair BC = the sectors the destination is to have. The destination is positioned to its sector BC - 1 and a sector of E5H bytes is written there, so that the space is allocated before the copy starts.

54F4H - COPY with a Device: Open Both Ends

When the source or the destination is a device, both are opened (a device opens as a device), the destination made with @INIT with the record length of LRL (or 256) when it is a file, and the copy goes byte by byte.

5519H - Copy Byte by Byte

Each byte is taken from the source with @GET (0013H) and given to the destination with @PUT (001BH). A file source ends at its end of file (error 1CH); a device source ends with BREAK (01H), and gives 00H while it has no character. ECHO shows each byte of a device on the screen. BREAK or a pause (SHIFT @) are looked at after each byte (56E9H). The end closes the destination (547AH).

5564H - Keep a Destination as It Was Typed

When @FSPEC refuses the destination (a drive alone, /EXT, .PASSWORD), its text is copied into 59DAH as it was typed: from the character @FSPEC stopped at (the one before Register Pair HL), spaces skipped first, small letters made capitals, up to 32 characters, ending at 0DH or a bracket, with 0DH stored after it. 558EH completes it from the source.

558EH - Complete the Destination from the Source

A destination that is missing, or starts with a digit, is refused (Destination spec required). A destination that starts with something other than a letter (/EXT, .PW, :d) gets the source's name put in front of it; then a missing extension (after /) and a missing password (after .) are taken from the source when it has them. The source's characters are put in at the place in the destination text, the rest of it moved up.

55FEH - Open a File or Device and Check Its Access

Register Pair DE = the control block holding a specification, Register Pair HL = the buffer, Register B = the record length, Register A = the low byte of the routine: 24H for @OPEN (4424H), 20H for @INIT (4420H). First the name to show is built at 59A6H: the specification up to its password or drive (a slash with no extension after it left out), then a colon and the drive (filled in after the open, 5679H) and 03H; a device keeps its name alone. After a good @INIT the drive is checked for write protection (@CKDRV). Access: a file opened with @OPEN needs a level below 6 (read), one made or opened with @INIT a level below 5 (write); otherwise it is closed and error 19H (file access denied) is reported.

56A1H - Display the Banner

Copying: (or Appending: for APPEND, 5211H), the source's name (59B6H), " to " and the destination's name (59C6H runs on into 59CAH), then ENTER.

56BDH - The Record Length of a File

Register Pair DE = the control block of a file just opened, whose directory sector is still at 4300H. Its directory record is the 32 byte slot of +07H AND E0H; Register A returns the record's +04H, the record length.

56CCH - Keep the Source's Directory Bytes

Register Pair DE = the source's control block, its directory sector at 4300H. The record's +00H-+02H (attributes, flags and month, day and year) and +10H-+13H (the password hash and the time field) are copied to 5A1EH-5A24H for CLONE. Register Pair HL returns at the record +14H.

56E9H - BREAK and the Pause

During a JCL job nothing is looked at (Z FLAG). Otherwise BREAK (KFLAG$ bit 0) returns the NZ FLAG; a pause (bit 1, SHIFT @) waits until BREAK (NZ) or another key than SHIFT @ (Z, the copy goes on).

570CH - The Diskette Prompts of X

570CH asks for the system diskette, but only for X on drive 0, where the system diskette has to come back for the overlays. 571EH asks for the source diskette and 5740H for the destination diskette until the GAT of the diskette in the drive has the 18 bytes kept for it (59FAH, 5A0CH). Without X each returns at once.

576BH - Flash a Prompt until ENTER

Waits until BREAK and ENTER are let go, then shows the prompt at Register Pair HL (it ends with 1DH, the cursor back to the start of the line) and erases it with 1EH, again and again, while KFLAG$ is watched: BREAK ends the command with Transfer aborted through @ABORT; ENTER clears the keys and returns to the caller of 576EH.

57C5H - Three Overlay Loads, a Device Test, the Date Layout Test and the GAT Read

57C5H, 57C8H and 57CBH each issue one request whose function does nothing (00H): the supervisor loads SYS2/SYS (84H), SYS8/SYS (8AH) or SYS3/SYS (85H) into 4E00H, where the next open, write or close then finds it, which matters while another diskette than the system diskette is in drive 0. The supervisor drops the RST's return address, so each returns to its caller. 57CEH tests for a device; 57DAH for the date layout of a drive; 57EDH reads a GAT.

57FFH - Open the Source or the Destination

57FFH opens the control block at Register Pair DE with @INIT (20H); 5803H the source (5986H) and 5806H the control block at Register Pair DE with @OPEN (24H), at 5B00H; 580CH with the routine named by Register A. Register B = Register L, 00H: records of 256. A failure goes to the error report.

5810H - Errors and the Message Selector

5810H reports the error number in Register A (5816H: error 2CH, parameter error) through @ERROR, after asking for the system diskette back for X on drive 0. 581FH and the four entries below it are a chain of LD IX instructions whose DD prefixes make each entry but the one jumped to a dead load, so entering at 581FH, 5823H, 5827H, 582BH or 582FH loads Register Pair HL with one message. Each ends the command with Register Pair HL = FFFFH.

583BH - COPY Data: the Messages

The two banner words end with 03H so that the name follows on the same line; the error messages end with 0DH; the four prompts start with 1DH 1EH (the cursor to the start of the line, the line erased) and end with 1DH 03H, so that 1EH can erase them again (576BH). The drive digit of the last two is written by 530EH and 5311H.

5986H - COPY Data: the Control Blocks and the Names

The work areas above the code. Only " to " at 59C6H-59C9H is loaded from the file.

5A25H - COPY Data: the Parameter Table

The table @PARAM reads: COPY from 5A25H (52CAH), APPEND from 5A4DH (5232H), so APPEND knows only STRIP and ECHO. Ten entries of eight bytes, a keyword of six characters padded with spaces and the address where its value is stored, then 00H. Each address is the operand of an instruction that uses the value; the short form of each keyword names the same address.

5200H - Member 8 (LIST): Entry, Parameters and the File

The LIST command (library member 41H), loaded at 5200H-563BH. It lists a file on the screen, or with P on the printer, as text (ASCII) or with HEX as records in hexadecimal and characters. The parameters (table 55C2H) are read only when a bracket follows; their values go straight into the operands that use them. The file is opened with the extension TXT added when it has none, and when that file is not found, as typed. Its control block is 564CH (a copy of the specification at 566CH), its buffer 5700H.

527EH - Record Length, TAB, Device and Mode

The record length comes from LRL; the test that would take the file's own from its directory record gives the Z FLAG only for an LRL of FFFEH, so with LRL not given (FF00H) it is 00H, 256. TAB (8 when given alone) must be 1-32. P lists on the printer (PRDCB$) without stopping, else on the screen (DODCB$). HEX goes to 5399H. For text the page is 15 lines and the screen is not cleared between pages; LINE skips to its line first.

5309H - List the Text

Each character is taken with @GET and sent through 54C9H. NUM puts the line number (5 places, from LINE) in front of each line. Without ASCII8 bit 7 of each character is cleared. A tab goes to the next multiple of the TAB width. At the start of each line (and after a character with bit 7 set) BREAK and the pause are looked at. The end of the file (error 1CH or 1DH) ends the listing with ENTER; any other error is reported.

5399H - List in Hexadecimal

From record REC on, each record of the record length (256 when it is 00H) is shown as lines of 16 bytes: the record number and the offset in hexadecimal (rrrr:oo = ), the bytes in hexadecimal, then the characters (a full stop for one below 20H or above 7EH). With C (on when any parameter is given) the bytes follow each other in groups of four and the characters are on the same line; with C off each byte is followed by a space, the groups are of eight and the characters are on a second line under the bytes. On the printer the characters follow on the same line. N or P puts a blank line after each record.

54A8H - Send a Character and Count the Page

54A8H sends a space, 54ACH a byte as a character (a full stop below 20H or from 7FH up), 54B8H a byte as two hexadecimal digits. 54C9H sends Register A to the device of the listing (@PUT) and keeps the column (563BH, 0-63); 03H, 0AH and 0DH put it back to 0. At column 0 on the screen the page is counted: in hexadecimal ENTER is sent first (5520H). When a page is full the listing waits for a key: BREAK ends it, C goes on without stopping, any other key clears the screen (hexadecimal) and lists the next page. 54C9H keeps Register Pair HL, and Register A except at the start of a line.

5525H - BREAK and the Pause

During a JCL job nothing is looked at. BREAK (KFLAG$ bit 0) sends ENTER and ends the command with Register Pair HL = FFFFH. A pause (bit 1, SHIFT @) waits for BREAK or another key than SHIFT @. 5548H clears bits 2-0 of KFLAG$ and returns the Z FLAG.

5559H - The Line Number

5559H writes Register Pair HL in decimal into the five places at Register Pair DE, spaces in front. 5572H counts the decimal number whose last digit is 4 places after Register Pair HL up by one (a space counts as 0); 5573H the one whose last digit is 3 places after it.

5583H - Errors and the Exit

5583H reports error 2CH (parameter error), 5585H the error in Register A, through @ERROR; 558CH displays File spec required!. Each ends the command with Register Pair HL = FFFFH.

5598H - LIST Data: Texts and the Parameter Table

The message, the line number text, the line head of the hexadecimal listing, the default extension, and the table @PARAM reads (5214H): fifteen entries of eight bytes, a keyword of six characters padded with spaces and the address where its value is stored, then 00H. Each address is the operand of an instruction that uses the value; the short form of a keyword names the same address.

563CH - LIST Data: the Work Areas

Above the member: the bytes of a hexadecimal line, the file's control block, the copy of the specification and the file's buffer.

5200H - Member 9 (RENAME): Read the Two Names

The RENAME command (library member 53H), loaded at 5200H-53A4H. The old file's specification goes to the control block at 53C4H, the new name to 53A4H (as typed when @FSPEC refuses it, such as /EXT); the parts the new name leaves out (name, extension, password) are taken from the old one. The old file must allow renaming (access level 0-2, else error 25H). The new name gets the old file's drive (another drive is error 20H) and must not exist. Then the directory record gets the new name and extension, and the hash index table the new name's hash.

52D3H - Keep the New Name as It Was Typed

When @FSPEC refuses the new name (such as /EXT or .PW), its text is copied into 53A4H: from the character @FSPEC stopped at, spaces skipped, small letters made capitals (any character from 61H up has 20H taken off), up to 32 characters, ending at 0DH or a bracket.

52F0H - Complete the New Name from the Old

A new name that starts with something other than a letter gets the old name put in front; then a missing extension (after /) and a missing password (after .) are taken from the old name when it has them. The old name's characters are put in at the place in the new name text, the rest of it moved up.

534BH - Errors and the Messages

534BH reports error 20H (illegal drive number), 534DH the error in Register A, through @ERROR. 5354H and the two entries below it are a chain of LD IX instructions whose DD prefixes make each entry but the one jumped to a dead load, so entering at 5354H, 5358H or 535CH loads Register Pair HL with one message. Each ends the command with Register Pair HL = FFFFH.

5368H - RENAME Data

The three messages, each ended by 0DH, and the two control blocks.

5200H - Member 10 (DEVICE): Parameters and the Drives

The DEVICE command (library member 61H), loaded at 5200H-56FDH. It shows up to three parts, each on unless its parameter is turned off: DRIVES (one line for each drive whose code table starts with a JP, C3H), BYTEIO (the device control blocks) and STATUS (the options and the system modules kept in memory). P sends every line to the printer too. 520DH copies P into the N cell, so the display stops at each page of 14 lines unless P is given. A drive whose diskette can be read shows the diskette's name from its GAT, with WP when it or its code table is write protected.

5365H - DEVICE: the Device Control Blocks

Each device control block that is in use (type not 00H) gets a line: an asterisk and its name, the direction (less than sign for input, bit 0; greater than sign for output, bit 1), then what it points at: the driver address as X'nnnn', Nil for a block with nothing assigned (bit 3), or for a routed block (bit 4) the block it is routed to (the operand of the LD HL of the routine its +01H-+02H point at), followed as far as it goes, or the file it is routed to (an open file's control block, bit 7 of +00H) as <=> and its name. The blocks are KI, DO, PR (4015H-402CH, eight bytes each), then JL, SI, SO and the four spare blocks (42C2H-42EBH, six bytes each).

5427H - Numbers and Names for the Lines

5427H writes Register Pair HL (below 1000) at Register Pair DE as three places, leading zeros as spaces; 543BH writes one place for the power of ten in Register Pair BC, Register A being the character for a zero (a space until a digit has been written, then 0). 5456H puts an asterisk and the two letter name of the block at Register Pair HL at Register Pair DE: the name is found from the block's address in the table of names 42ECH-42FFH.

5478H - DEVICE: the Options and the System Modules

Options: is followed by the options that are on, separated by commas: Smooth (46F7H not 00H, the spare byte of the disk driver that SMOOTH patches), the name of each set bit of DFLAG$ (bit 0 Spool, 1 Type, 2 JKL, 3 PR, 4 KI, 5 MiniDOS, 6 KSM, 7 Graphic), Fast or Slow (SFLAG$ bit 3), and , Verify when the @WRITE vector (4439H) goes to 48E6H, the write with verify. Then, when the word at 4BDEH (the operand of the overlay loader's CALL in the supervisor dispatcher) is not 4BF4H, System modules resident: and the number of each system file whose entry in the table 1FH below that address is not 00H.

5546H - Show and Print

5546H shows the text at Register Pair HL (@DSPLY) and prints it too (@PRINT) when P is on; 5551H a comma and 5553H the character in Register A, on the screen and, with P, the printer. 5560H ends a line: ENTER, then unless the display runs without stopping (P) a page of 14 lines waits for a key (BREAK ends the command, any other clears the screen), then BREAK and the pause are looked at (5587H), unless BREAK is disabled (SFLAG$ bit 4).

55C8H - DEVICE Data: Texts and the Parameter Table

The texts of the three parts (each ended by 03H), the names of the bits of DFLAG$ (the last letter of each with bit 7 set), the table of stepping rates, the line buffer, and the table @PARAM reads (5204H): eight entries of eight bytes, a keyword of six characters padded with spaces and the address where its value is stored, then 00H. Each address is the operand of an instruction that uses the value.

5200H - Member 11 (LINK): Link Two Devices

The LINK command (library member 62H), loaded at 5200H-53AAH: LINK *d1 *d2. Only at LDOS command level. The first device must not be routed (bit 4 of its type). A module of 41 bytes named LK and the four letters of the two devices (52C7H) is put in high memory (HIGH$ lowered by 29H) or over a module of the same name found by request BCH, and the first device's driver address is pointed at it: the module calls the first device's old driver and then gives the result to the second device with @PUT; for input it asks the second device with @GET when the first has no character. For the keyboard during a JCL job the driver word changed is KIJCL$ (42BEH), where SYS11/SYS keeps the keyboard driver.

52C7H - The Link Module

52C7H-52EFH (41 bytes) is copied to high memory by 52AEH and runs there as the first device's driver; its CALL and LD operands are absolute addresses outside the module (the old driver, the second device's block), stored by 5266H-5285H, so nothing in it needs moving. It starts with a module header: a JR over the header, the link word, the length 6 and the name LK with the two devices' letters. An input request (the CARRY FLAG) goes to the old driver and, when it gives 00H, to the second device with @GET. Any other request goes to the old driver, and Register A as that driver returned it is then given to the second device with @PUT; the old driver's result is returned.

52F0H - Find a Device Control Block by Name

Register Pair DE holds the two letters of the name (Register E the first). The name is looked for in the table of device names of SYS0/SYS (42ECH-42FFH): slot n of KI, DO and PR (n = 0-2) gives the block 4015H + 8 x n, slot n of JL, SI, SO and the four spare slots (n = 3-9) the block 42B0H + 6 x n (42C2H-42E6H). Returns the Z FLAG and Register Pair HL at the block, or the NZ FLAG and Register A = 08H (device not available). Register Pair DE is changed. 531FH looks for a module by name through request BCH and returns its link word in Register Pair DE.

532FH - Errors and the Messages

532FH reports the error in Register A through @ERROR. 5336H and the two entries below it are a chain of LD IX instructions whose DD prefixes make each entry but the one jumped to a dead load, so entering at 5336H, 533AH or 533EH loads Register Pair HL with one message. Each ends the command with Register Pair HL = FFFFH.

534AH - LINK Data

The three messages, each ended by 0DH, the name looked for, and the two control blocks.

5200H - Member 12 (RESET): Read What to Reset

The RESET command (library member 63H), loaded at 5200H-5507H. With no specification it resets the whole system (5298H); with a device (an asterisk and two letters) that device (5240H); with a file, its record length (LRL) or its date (DATE) in the directory (5386H). The drivers the system started with (KISV$, DOSV$, PRSV$, saved by the boot) are first put into the templates of KI, DO and PR at 5451H-5468H.

5240H - Reset One Device

The device's control block is looked for; a file it is routed to (at the end of its routes) is closed. The block's type becomes 08H (nothing assigned) and its driver 497CH, the XOR A and RET of SYS0/SYS. For KI, DO and PR (blocks at 40xxH) the template from 5451H is copied over the block: the driver the boot found. PR also clears DFLAG$ bit 3 (PR/FLT), KI clears DFLAG$ bits 1, 2, 4, 5, 6 and empties task slot 10, and DO clears the screen.

5298H - Reset the Whole System

Only at LDOS command level. PR/FLT and the keyboard options are taken out of DFLAG$, and every file a device is routed to is closed. When a task slot (4500H, twelve entries) holds a block above HIGH$, a task in high memory still runs: the message says so, the memory is not given back and only the devices are reset. Otherwise the hooks are put back as the boot left them (the DEBUG hook 4400H = 4876H, no system files kept in memory, 4DF0H-4DFDH cleared, SFLAG$ bit 0 cleared, the requests below 80H to 4BEEH, the job log and @ICNFG RET), the drive code tables are read again from the second block of the system information sector of drive 0 (cylinder 0, sector 2), the RST 38H vector 4012H is pointed at the interrupt service routine 44A5H again, and HIGH$ is set to the top of memory. Then KI, DO and PR, and JL, SI and SO, get their templates, the four spare blocks (42D4H-42EBH) are cleared, the table of device names 42ECH-42FFH is written again, and the screen is cleared.

5386H - Change a File's Directory Record

The file is opened; it must allow writing (access level 0-4, else error 25H). Its directory record is read: LRL= gives +04H a new record length, any DATE= gives +12H-+13H the value 4296H (the hash of a blank password, the older layout with no time). DATE=ON also sets bit 2 of the control block and closes the file, which stamps it with the date and time; the close reads the directory sector again, so the record is then written as the close left it. Then the sector at 4300H is written.

53D3H - Close a Routed File

Register Pair HL = a device control block. Its routes are followed (type bit 4: +01H-+02H point at a route routine of SYS0/SYS (an LD HL,block at 4D53H-4D61H that runs on into 4D62H) whose operand names the next block; the operand is cleared on the way, so the route is undone); when the last is an open file's control block (bit 7 of +00H), it is copied to 5508H and that copy is closed. Then the error exit, the refusal and the search for a block by name (as in 55F6H of SPOOL).

540BH - Find a Device Control Block by Name

Register Pair DE holds the two letters of the name (Register E the first). The name is looked for in the table of device names of SYS0/SYS (42ECH-42FFH): slot n of KI, DO and PR (n = 0-2) gives the block 4015H + 8 x n, slot n of JL, SI, SO and the four spare slots (n = 3-9) the block 42B0H + 6 x n (42C2H-42E6H). Returns the Z FLAG and Register Pair HL at the block, or the NZ FLAG and Register A = 08H (device not available). Register Pair DE is changed.

543AH - DFLAG$ and the Templates

543AH clears DFLAG$ bit 3 (PR/FLT). 5440H keeps only bits 7, 3 and 0 of DFLAG$ (the keyboard options off) and empties task slot 10. Then the screen codes, the device control blocks of KI, DO and PR as the ROM's power-up copy makes them (5451H-5468H, 24 bytes for 4015H-402CH), those of JL, SI and SO (5469H-547AH, 18 bytes for 42C2H-42D3H) and the table of device names (547BH-548EH, 20 bytes for 42ECH-42FFH).

548FH - RESET Data: the Parameter Table, Messages and Control Blocks

The table @PARAM reads (5225H): four entries of eight bytes, a keyword of six characters padded with spaces and the address where its value is stored, then 00H; the two messages; the two control blocks above the member.

5200H - Member 13 (ROUTE): Read the Two Specifications

The ROUTE command (library member 64H), loaded at 5200H-543AH: ROUTE *d1 [TO] *d2 or a file, or ROUTE *d1 (NIL). The first device's control block is found by its name in the table of device names of SYS0/SYS (42ECH-42FFH), or the block of a free slot (named 0000H) is taken for a new device (none free: error 21H, no device space available); a file it was routed to is closed. Routed to a device, its type becomes 10H and its +01H-+02H one of the four route routines of SYS0/SYS (4D53H, 4D57H, 4D5BH, 4D5FH: an LD HL,block that runs on into 4D62H), whose operand gets the other device's block; none free is error 21H. Routed to a file, a module named $R and the device's letters is made in high memory (a 9 byte header and the file's control block, below a buffer of 256 bytes), or one of that name is used again; the file is opened with @INIT and positioned at its end unless REWIND is given, and the route routine's operand is the control block in the module. NIL makes its type 08H and its driver 497CH. The parameters (NIL, REWIND) may follow either specification.

5255H - Point the Device at Its Destination

Register Pair HL (on the stack) is the destination: another device's control block, or the file's control block in the module. 531FH finds the device's block, or the block of a free slot. With the interrupts off, the device's letters go into its slot of the table of device names (5350H), and a free route routine is looked for among the four loads of Register Pair HL at 4D53H-4D61H of SYS0/SYS (an operand whose low byte is 00H is free; none is error 21H). The destination becomes that load's operand, the block's type gets bit 4 (routed) with bit 3 (nothing assigned) cleared, and the block's +01H-+02H point at the load, which runs on into 4D62H: a request to the device goes to the destination's driver or file. For the keyboard (4015H) during a JCL job the address goes into KIJCL$ (42BEH) instead, where SYS11/SYS keeps the keyboard's driver.

52A8H - Route a Device to a File

A module of the name $Rxx found by request BCH is used again in its place (HIGH$ is not lowered, 5301H). Otherwise, only at LDOS command level, the module goes below HIGH$: the page below HIGH$ + 1 is the file's buffer, the module's 41 bytes below it, and HIGH$ just below the module. The file is opened with @INIT (made when it is not there) and, without REWIND, positioned at its end (@PEOF; error 1CH there is the normal end).

531FH - The Device's Control Block

531FH finds the block named by the device's letters, or else the block of a free slot of the table of device names (whose name is 0000H): none is error 21H. A file the device is routed to is closed (536AH). Returns Register Pair HL = the block and Register Pair DE = the letters. 5338H routes the device to nothing (NIL): type 08H, driver 497CH, and its name in its slot. 5350H stores the letters in Register Pair DE in the slot of the block at Register Pair HL.

53A8H - Find a Device Control Block by Name

Register Pair DE holds the two letters of the name (Register E the first). The name is looked for in the table of device names of SYS0/SYS (42ECH-42FFH): slot n of KI, DO and PR (n = 0-2) gives the block 4015H + 8 x n, slot n of JL, SI, SO and the four spare slots (n = 3-9) the block 42B0H + 6 x n (42C2H-42E6H). Returns the Z FLAG and Register Pair HL at the block, or the NZ FLAG and Register A = 08H (device not available). Register Pair DE is changed.

53D7H - ROUTE Data

The two messages, each ended by 0DH, the parameter table @PARAM reads (5211H, 5234H: three entries of eight bytes, a keyword padded with spaces and the address of its value, then 00H), the module's header and the two control blocks.

5A00H - Member 14 (FILTER, SET): Load a Filter or a Driver

One member, loaded at 5A00H-5B5CH, serves FILTER *d filespec (member 66H, entry 5A00H) and SET *d filespec (member 65H, entry 5A01H, the AFH inside the OR AFH, which runs as XOR A). Register A after the entry is not 00H for FILTER and 00H for SET; it is kept at 5A84H. Only at LDOS command level. The file gets the extension FLT or DVR when it has none. FILTER needs the device to exist (else error 08H); SET takes the block of a free slot of the table of device names for a new device (none: error 21H). SFLAG$ bit 2 and bit 3 of 4758H are set, the file is loaded with @LOAD, SET writes the device's name into the block's slot of the table of device names (42ECH-42FFH), and the member jumps to the file's transfer address with Register Pair DE = the device's control block and Register Pair HL = the rest of the command line; the loaded code installs itself and returns to the program that ran the command.

5AB2H - Find a Device Control Block by Name

Register Pair DE holds the two letters of the name (Register E the first). The name is looked for in the table of device names of SYS0/SYS (42ECH-42FFH): slot n of KI, DO and PR (n = 0-2) gives the block 4015H + 8 x n, slot n of JL, SI, SO and the four spare slots (n = 3-9) the block 42B0H + 6 x n (42C2H-42E6H). Returns the Z FLAG and Register Pair HL at the block, or the NZ FLAG and Register A = 08H (device not available). Register Pair DE is changed.

5200H - Member 15 (RUN, LOAD): Load a Program from Another Diskette

One member, loaded at 5200H-536FH, serves RUN (member 82H, entry 5200H) and LOAD (member 81H, entry 5203H): [RUN or LOAD] (X) filespec. The parameter X comes before the file; the file goes to CFCB$ (4485H) with the extension CMD when it has none, and SYS2/SYS is loaded first (request 84H). Without X, RUN hands the file to @RUN and LOAD to @LOAD (which returns through 4408H, the RET Z of SYS0/SYS just before @ERROR (4409H), so that an error falls into @ERROR). With X the source diskette is asked for, the program is loaded with @LOAD, the system diskette is asked for again, and RUN then jumps to the program's transfer address with Register Pair HL at the rest of the command line.

5222H - Flash a Prompt until ENTER

Waits until BREAK and ENTER are let go, then shows the prompt at Register Pair HL (it ends with 1DH, the cursor back to the start of the line) and erases it with 1EH, again and again, while KFLAG$ is watched: BREAK ends the command with Command aborted! through @ABORT, after asking for the system diskette; ENTER clears the keys and returns to the caller of 5225H.

527CH - RUN

Without X the file in CFCB$ is handed to @RUN, which loads and runs it. With X the program is loaded (52CCH), the system diskette is asked for, and the RET at 5221H goes to its transfer address with Register Pair HL at the rest of the command line.

5293H - Read X and the File

The parameters come first (table 5364H: X). A space is passed over, the file's specification goes to CFCB$ (4485H) and must not be a device; CMD is added when it has no extension. SYS2/SYS is loaded (request 84H) while the system diskette is in. With X the source diskette is asked for. The error exits put the Stack Pointer back to the depth of 5293H's own return address, so after a message they RETurn to the instruction after the CALL 5293H with Register Pair HL = FFFFH, or end a JCL job.

52CCH - Load the Program

Sets SFLAG$ bit 2 (a program load: @OPEN lets an execute only file be opened) and loads CFCB$ with @LOAD; Register Pair HL returns the transfer address. A failure asks for the system diskette and reports the error. Then the exits.

5302H - RUN and LOAD Data

The message, the two prompts (they start with 1DH 1EH, the cursor to the start of the line and the line erased, and end with 1DH 03H, so that 1EH can erase them again), the abort message, the parameter table (one entry of eight bytes and 00H) and the default extension.