LDOS 5.3.1 for the Model III - SYS11/SYS Disassembled

SYS11/SYS

Other Navigation

LDOS 5.3.1 SYS11/SYS Disassembly - Running a JCL Job (Model III)

SYS11/SYS carries out the execution phase of the Job Control Language. The DO command (SYS6/SYS) compiles a job into the file SYSTEM/JCL, opens it in JFCB$ (4265H), saves the six bytes of @EXIT and @ABORT (402DH-4032H) at 4065H-406AH, puts LD A,ADH / RST 28H and LD A,BDH / RST 28H at 406BH-4070H and issues request 9DH. The job is a list of the lines the operator would type: SYS11/SYS makes the job file the keyboard, so that the command interpreter and every program read their lines from it, and carries out the directive lines (those that start with //) on the way. The manual says SYS11/SYS may be removed from working disks when no JCL is used, and is of no use without SYS6/SYS, which holds DO.

The file is a load module of 1095 bytes: a record of type 1FH with the text Copyright 1991 MISOSYS, Inc., All rights reserved, load blocks for 4E00H-5180H and 5187H-51FBH (5181H-5186H are not loaded), a load block for the two bytes 4BC8H-4BC9H (03FCH, the 1020 bytes that SYS11/SYS takes up in the overlay area) and the transfer address record for 4E00H.

The Requests

The Job File as the Keyboard

The Directives

The End of a Job

About This Page

4BC8H - The Overlay Length (Data)

Every system file from SYS1/SYS to SYS12/SYS carries a load block for the two bytes 4BC8H-4BC9H in the resident area of SYS0/SYS. They hold the length of the file's part in the overlay area: for SYS11/SYS 03FCH, the 1020 bytes 4E00H-51FBH (5181H-5186H among them, which the file does not load). In the file this block is the last load block, after the blocks of 4E00H-5180H and 5187H-51FBH and before the transfer address record (4E00H). The two bytes are data, not instructions.

4E00H - The Five Requests

The supervisor dispatcher loads SYS11/SYS into 4E00H and calls it with the request code in Register A; it drops the return address of the RST itself, so the stack above holds the chain of calls that issued the request. Bits 6-4 select the function. 9DH (10H): DO (SYS6/SYS) starts the job file it has compiled. ADH (20H) and BDH (30H): while a job runs, @EXIT (402DH) and @ABORT (4030H) issue these, so a command that ends comes back here. CDH (40H): @DOKEY (42B5H), the keyboard driver while a job runs, asks for a key. DDH (50H): @DOKEY while the INPUT directive hands the keyboard to the operator. Every entry first clears bit 2 of KFLAG$ (429FH), the ENTER key held, so that a directive waits for a new press.

4E1EH - Start the Job

Request 9DH from DO, with the compiled job file open in JFCB$ (4265H). Bit 5 of SFLAG$ (442BH) is set while a job runs. Unless a job already runs (a DO inside a job), the keyboard driver address (4016H-4017H) is kept in KIJCL$ (42BEH) and the six bytes that DO left at 406BH-4070H (LD A,ADH / RST 28H and LD A,BDH / RST 28H) are copied over @EXIT and @ABORT (402DH-4032H); DO has already saved the six bytes it found there at 4065H-406AH. The first line of the job is read with 4E5AH as the keyboard driver, which takes each byte straight from the job file, and run through @CMNDI; from then on the keyboard driver is @DOKEY (42B5H), so every key a command asks for comes to 4ECFH.

4E60H - A Command of the Job Has Ended: the Next Line

Request ADH from @EXIT. The stack is set back to 41E5H. BREAK pressed (bit 0 of KFLAG$) ends the job with Job aborted, unless BREAK is disabled (bit 4 of SFLAG$). At the end of the job file the job ends with Job done; otherwise the next line is read into INBUF$ and run through @CMNDI. The line is read by the ROM's line input routine through @DOKEY, so its bytes come from 4ECFH, which also carries out the directive lines it meets on the way.

4E8AH - End the Job

4E8AH (ABORT, request BDH, BREAK) ends the job with Job aborted and goes on to @ABORT; 4EA3H (EXIT, the end of the job file) with Job done and @EXIT. The message is shown and sent to the job log (@LOGOT), bit 5 of SFLAG$ is cleared, JFCB$ +00H is cleared (the job file is closed), the keyboard driver kept in KIJCL$ is put back and given a control call, and the six bytes of @EXIT and @ABORT saved at 4065H-406AH are put back. The RET then goes to the vector pushed first, with interrupts off. 4E92H is the test the waiting directives make: BREAK ends the job here; it returns the NZ FLAG while ENTER is held. 4EC6H is the copy of six bytes at Register Pair HL to 402DH that the start uses too.

4ECFH - Answer a Key Request from the Job File

Request CDH from @DOKEY. The stack holds the chain that asked for the key: the dispatcher's call to 4E00H, the four words the ROM's device routine pushes, the Register Pair BC that the ROM's input routine at 0013H saved, and the return address of the call that asked. When the word at the Stack Pointer +0EH is 05E3H, the request comes from the CALL 0049H at 05E0H in the ROM's line input routine, and the job answers it; Register Pair BC at +0AH is then that routine's count, Register C the length of the line allowed and Register B the room left, equal while no character of the line is taken. Any other request goes to the keyboard driver kept in KIJCL$ with the CARRY FLAG set (a byte is asked for). In the middle of a line the next byte of the job file is the key. At the start of a line the job file's sector is read again (@RREAD) and its first byte taken: 00H ends the job; a byte other than / is the key; a line that starts with / is read whole into INBUF$ (4225H) and carried out here (4F0AH), and the next line is taken in the same way.

4F65H - The STOP, DELAY and PAUSE Directives

STOP ends the job without a message and gives the pending key request to the keyboard, so that the command that asked finishes from the operator's keys. DELAY n waits n times the time unit of 504CH (n counted in its low byte: 0 waits 256 units). PAUSE shows the line and waits for ENTER (or BREAK, which ends the job).

4F89H - The KEYIN Directive and the Labels

KEYIN shows its line, waits for a key from the keyboard (KEYIN's request does not come from the line input routine, so 4ECFH passes it to the keyboard driver) and keeps it at 4FC9H, the operand of the CP at 4FC8H. Then the lines of the job file are read into INBUF$ and passed over up to a line of two slashes followed by that key, or by a third slash, which matches any key; that line is sent to the job log and the job goes on after it. A label line met in the normal course of the job comes to 4FC8H (two slashes and a digit, with Register A = 39H less the digit) or 4FCCH (three slashes, Register A = 00H): Register A is compared with the key kept, and when they differ the lines are passed over in the same way. The key kept becomes 00H at a line of three slashes.

4FD6H - The ALERT Directive

ALERT n,n,... plays tones on the cassette output: the numbers stand in turn for a tone (tone n AND 7, 501FH) and a silence (n time units, 5044H), starting with a tone; the byte at 5006H, the operand of LD A at 5005H, is flipped between FFH and 00H for each number. Spaces and commas separate the numbers. A ( keeps the place after it at 4FF7H, the operand of the LD HL at 4FF6H, and a ) goes back there, so the numbers between them repeat until ENTER is held; a ) with no ( before it (4FF7H still 0000H, the value in the file) is Bad JCL. ENTER held ends ALERT after the number being played; 0DH ends it at the end of the line.

501FH - Tones and Time Units

501FH plays tone Register B AND 07H on the cassette output port FFH: the table at 5187H gives for each tone the count of a half period and the number of periods. With interrupts off, the port is set to 01H and then 02H for the half period each, the two output levels, as many times as the table says. 5044H waits Register B time units (none for 0). 504CH waits one time unit, the ROM's delay at 0060H with Register Pair BC = 199BH, and a second one when bit 3 of SFLAG$ (FAST) is set.

505DH - The FLASH Directive

FLASH n shows the directive line, keeps it on the screen for 4000H turns of the test 4E92H, then moves the cursor up a line (1BH) and erases it (1EH) and waits one time unit; n times (n counted in its low byte: 0 gives 256). ENTER held ends it at once.

5088H - The WAIT Directive

WAIT hh:mm:ss shows its line, then waits until TIME$ (4217H-4219H: seconds, minutes, hours) holds that time exactly, the three numbers kept at 5181H-5183H (hours, minutes, seconds). Each number ends at a character that is not a digit; the second and third must follow a colon. The instruction at 5092H is JP NZ,0AFEH; after @DSPLY the Z FLAG is always set, so it is not taken, and its last two bytes, entered from the DJNZ at 50A0H, are CP 0AH: the separator before the second and third numbers is tested against the colon (3AH less 30H). While it waits, BREAK ends the job; ENTER does not end WAIT.

50B7H - The INPUT Directive

INPUT shows its line and hands the keyboard to the operator for the rest of the key request: the keyboard driver kept in KIJCL$ goes into the CALL at 50C8H, and the request code at 42B6H, @DOKEY's operand, becomes DDH, so the keys come through 50C8H from the keyboard until ENTER (0DH) or BREAK (01H), which put CDH back. The first key answers the request that brought the directive line.

50DCH - Copy the Directive's Name

Register Pair HL = the first byte of the name in the line, Register Pair DE = 5181H. Letters and digits are copied, small letters made capitals, up to eight of them (more are passed over); the name ends at 03H, 0DH, an opening bracket or any other character that is not a letter or a digit, and 03H is stored after it. The buffer 5181H-5186H has room for five letters and the 03H; a name of six to eight characters runs on over the first bytes of the tone table at 5187H. The byte at 5113H, the operand of LD A at 5112H, starts as 08H and becomes 00H when a character is stored: the NZ FLAG on return means no name. Register A comes back as the character that ended the name.

5125H - Find the Directive in the Table

Register Pair DE = the name (5181H, ended by 03H), Register Pair BC = the table at 51B5H: ten entries of seven bytes, five characters (padded with spaces) and the address of the directive's routine, then 00H. The first character picks the entries to compare; the next four must be the same, and a name that ends early matches when the table has a space at that place. Found: the Z FLAG and Register Pair DE = the routine. Not found: the NZ FLAG. Register Pair HL is kept.

5167H - Read a Decimal Number

Register Pair HL = the first digit. The digits are read into Register Pair BC (times ten plus the digit, as 16 bits) until a character that is not a digit; Register Pair HL is left on it and Register A = that character less 30H, with the CARRY FLAG when it was below 0.

5181H - The Name Buffer, the Tones, the Messages and the Directives

5181H-5186H are not in the file: the name of a directive (50DCH) or the three numbers of WAIT. Then the table of the eight tones of ALERT, the three messages (the second starts inside the first), and the table of the ten directives, 00H at its end.