$A PAGENO=71 $A MARK=2 $A TAB=5, 10, 15 $A JUST=1; LINE=69; PAGE=54; TOP=5; BOTTOM=7 $A NLS=1 $A MARK=2 $A TAB=5, 10 $A JUST=1; LINE=69; PAGE=54; TOP=5; BOTTOM=7 $L3CM APPENDIX 1 USER MANUAL FOR THE FIRST SYSTEM $N $A TAB=5, 10; CAPO=0; CAPSHO=0; INVERT=0 $B20 $L1CM USER MANUAL FOR MUSS11 $B2 $L1CM B. GILMORE $L1CM JUNE 1975 $A INDENT=1 $A INVERT=1 $N $L1CUM CONTENTS $B6 $A INDENT=1 .TITLE $T6 .PAGE $B0 @GENERAL FEATURES $T6 3 $B0 @COMPILING A PROGRAM. $T6 4 $B0 @RUNNING A PROGRAM. $T6 5 $B0 @EXTERNAL ROUTINES. $T6 6 $B0 @INPUT AND OUTPUT TO TERMINALS $T6 7 $B0 @RUNNING .PAL11F PROGRAMS. $T6 8 $B0 @OPERATOR CONTROL OF THE SYSTEM. $T6 9 $B0 @DEVICE HANDLERS. $T6 13 $B0 .UTILITY .PROGRAMS $B0 $A INDENT=2 @EDITOR. $T6 15 $B0 @FILE TRANSFER PROGRAM. $T6 16 $B0 @FILE @NAME PROGRAM $T6 18 $B0 @ARCHIVE PROGRAM. $T6 20 $B0 $I-1 .EXTERNAL .ROUTINE .LIBRARY $B0 .WAIT $T6 22 $B0 .NAME $T6 22 $B0 .DEFN $T6 22 $B0 .WRIT $T6 22 $B0 .COM $T6 23 $B0 .DA $T6 23 $B0 .FIDENT $T6 24 $B0 .RENAME $T6 24 $A INDENT=0 $A INVERT=0 $N $A INVERT=1 $L1CUM GENERAL FEATURES OF MUSS11 $P3 @MUSS11 IS A SYSTEM DESIGNED TO ALLOW MULTI PROGRAMMING AND MULTI USER ACCESS TO .PDP11S WITHOUT MEMORY MANAGEMENT. @IT IS A GENERAL PURPOSE SYSTEM THAT HAS THE CAPABILITY OF RUNNING IN A REAL-TIME ENVIRONMENT. @ALTHOUGH IT WILL RUN ON ANY MEMBER OF THE .PDP11 FAMILY, IT WILL NOT TAKE ADVANTAGE OF THE MEMORY MANAGEMENT/PROTECTION FEATURES OF THE LARGER MACHINES. $P2 @A DISC, OR OTHER FORM OF MASS STORAGE, IS DESIRABLE, BUT IS NOT A NECESSITY. $P2 @THE SYSTEM WILL MULTI-PROGRAM UP TO 128 SEPARATE PROGRAMS, RUNNING ON ONE, OR A NUMBER OF TERMINALS. @ALL PROGRAMS ARE CORE RESIDENT AND MAY RUN AT ONE OF EIGHT PRIORITIES - CORRESPONDING TO THE EIGHT MACHINE PRIORITIES, ALTHOUGH FOR NORMAL PROGRAMS, ONLY THE BOTTOM FOUR ARE USED. @AS A RULE PROGRAMS ARE WRITTEN IN .IMP, BUT .PAL11F PROGRAMS CAN BE RUN WITH CERTAIN RESTRICTIONS (THE RESTRICTIONS ARE LISTED LATER). $P2 @WHEN THE SYSTEM IS RUNNING, THE HIGHEST PRIORITY PROGRAM ABLE TO RUN IS GIVEN THE .CPU. @IF THERE ARE SEVERAL PROGRAMS OF EQUAL PRIORITY ABLE TO RUN, THEY ARE TIME SLICED AT NOT MORE THAN 20 MILLISECONDS EACH. $P2 @THE PRIORITY STRUCTURE ENSURES THAT THE SYSTEM CAN BE USED IN A REAL-TIME ENVIRONMENT WHEN VERY FAST RESPONSES TO INTERRUPTS ARE REQUIRED. @A PROGRAM MAY DYNAMICALLY CHANGE ITS PRIORITY UP OR DOWN IN TIME CRITICAL AREAS TO ENSURE RESPONSE. $P2 @SECTIONS OF CODE ON THE SYSTEM MAY BE SHARED BETWEEN USERS, THEREBY CUTTING DOWN ON THE TOTAL AMOUNT OF CORE REQUIRED. @FOR EXAMPLE, SEVERAL USERS MAY USE THE EDITOR, EACH HAVING HIS OWN PRIVATE STORAGE BUT SHARING ONE COPY OF THE EDITOR CODE. $P2 @AN .ASSEMBLER (TO STAND-ALONE .PAL11F STANDARDS) IS AVAILABLE FOR SYSTEMS WITH AT LEAST 16K WORDS OF STORE, AND IT IS HOPED TO PROVIDE AN .IMP COMPILER ON SYSTEMS WITH 28K WORDS WITHIN THE NEXT FEW MONTHS. @ALTERNATIVLY PROGRAMS CAN BE WRITTEN, COMPILED AND ASSEMBLED ON .EMAS, THEN THE BINARY IS LOADED ON THE SYSTEM. $A INVERT=0 $A INDENT=0 $N $L1CUM Compiling an Imp Program $B2 The Imp program should be compiled and assembled on EMAS (for full details of the language and how to run it see documentation by K. Yarwood ERCC (ext. 2636) - for the assembler see B. Gilmore ERCC (ext. 2636). $A INDENT=1 $B2 $I-1 1) $T1 A program requires a short header to inform the system of its starting address, priority, name etc. The format is (as added into the IMP program):- $B1 *ENDCO $C19 ; !This is the overall length of the code $B0 *.ASCII /xxxx/; !4 character program name $B0 *0 $C19 ; !'subsystem' number (0 is default) $B0 *MAIN+10 $C19 ; !starting address (MAIN is a label $B0 $C19 ; ! $C+3 defined by the compiler) $B0 *40 $C19 ; !priority to run at:- $B0 $C21 ! 0 - Priority level 0 $B0 $C21 ! 40 - Priority level 1 $B0 $C21 ! 100 - Priority level 2 $B0 $C21! 140 - Priority level 3 $B0 *0 $C19 ; !descriptor length (0 is default) $B0 *2000 $C19 ; !stack length ( = space for arrays + 1000 octal) $B1 e.g. $B1 *ENDCO $B0 *.ASCII /SORT/ $B0 *0,MAIN+10,40,0,2000 $B2 $I-1 2) $T1 A control statement is required to force the compiler to $B0 $T2 1) Produce POSITION INDEPENDANT CODE ($%CONTROL 8) $b0 $T2 2) Special code for MUSS11 ($%CONTROL 8192). This control value $b0 $t2 $c+4 effects the code dumped for EXTERNALS, REALS and STRINGS. $b1 This should be put %before the $%BEGIN $B1 $T2 $%CONTROL 8200 $B0 $T2 $%BEGIN $B1 The $%CONTROL statement may be expressed in either octal or Hex in the standard format, e.g. $B1 $T2 $%CONTROL 8200 may be written $%CONTROL 0'20010' or $B0 $T2 $%CONTROL X'2008'. $B1 The standard bits for setting checks on or off may also be used, for a full list see Appendix one. The more useful ones are:- $b0 $T2 1) $c+3 Line number updating ($%CONTROL 1) $B0 $T2 2) $C+3 Array bound checking ($%CONTROL 4). $B2 %Summary: $B1 use $T2 $%CONTROL 0'20015' for checks .on $B0 $T2 $%CONTROL 0'20010' for checks .off $B1 The header for an external routine/fn/map is different and is explained in the section 'using external routines'. $A INDENT=0 $B5 $l1CUM Running the program $B2 The Binary output from the assembler may be 1) punched on tape, 2) punched on cards or 3) sent to the relevant remote. $B1 For tape and cards, the program 'BINY' is used to load the tape/cards to the disc, 'TRANY' is used when a file comes off the line. These two programs are discribed in the section of utility programs. $B1 The file on disc is then 'RUN' - by using the operator command 'RU' in 'OIT' (see command A1 under operator commands). This command instructs the loader to load the file into core, then to set up a system descripter (PSECT) and tell the system to enter it. $B1 The 'sub-system' will then grab space for the programs stack, setting up its 'R1' and its 'SP' and then entering the program at the starting address and priority described in the header. $B1 If the program executes correctly (or has a standard IMP fault) then the message 'STOPPED AT LINE x MIN STK xxxxxx' is output and the program is completely purged from core. (The message 'MIN STK xxxxx' refers to the minum stack the program had while it is executing - this is tied up with the parameter specified on the header). $B1 On the other hand if the program causes an address error or an illegal instruction, then :- $B1 $T2 XXXX TASK ERROR! $B1 is output. The program in this case is not purged from core, allow the cause of the fault to be determined, and so must be allowed to go by giving the command 'PU XXXX' (see operators command A7). (XXXX is its program name). $A INDENT=1 $N $L1U Using External Routines $B3 $I-1 1) $T1 PRINT and READF (real read), if required, should be declared as external routine at the top of the program. $B1 $T2 $%EXTERNALROUTINESPEC PRINT($%REAL X, $%INTEGER A,B) $B0 $T2 $%EXTERNALROUTINESPEC READF($%REALNAME X) $B2 $I-1 2) $T1 To create a new external routine file. $B1 1) $T2 only one external routine per file is allowed. $B0 2) $T2 compile with normal control options. $B0 3) $T2 use the following header (example uses $%EXTERNALROUTINE ABCDEF) $B1 $T2 *ENDCO-. $B0 $T2 *.ASCII /ABCD/ $B0 $T2 0,ABCDEF,,0 $I+4 ( or 0,16,40,0) $B0 $T2 $%CONTROL X'2008' $B0 $T2 $%EXTERNALROUTINE ABCDEF($%INTEGER A,B,C) $B0 $C15 $. $B0 $C15 $. $B0 $C15 $. $B0 $C15 $. $B0 $T2 $%END $B0 $T2 $%ENDOFFILE $B2 $I-1 3) $T1 The routine should be put in a file named ABCDYY (if the name is less than 4 characters then pad out with Y's e.g. AYYYYY). $A INVERT=1 $N $L1CUM INPUT AND OUTPUT TO TERMINALS $P3 @IN GENERAL ON .MUSS11 ALL INPUT/OUTPUT IS LINE ORIENTATED, IE A PROGRAM RECEIVES AN ENTIRE LINE OF INPUT AT ONCE, AND NOTHING IS ACTUALLY OUTPUT UNTIL THE PROGRAM ISSUES A NEWLINE (OR .SELECT .OUTPUT). @HOWEVER AS THE .PDP11 VERSION OF THE .IMP COMPILER DOES NOT CATER FOR .PROMPS IN THE .EMAS SENSE, THE GENERAL EFFECT CAN BE OBTAINED BY USING .'PRINTSYMBOL(0)'. .PRINTSYMBOL(0) EXECUTED BY A PROGRAM WILL IMMEDIATELY SEND THE CURRENT LINE TO THE OUTPUT DEVICE - WITHOUT A TERMINATING NEWLINE. @THE ZERO CHARACTER IS %NOT PRINTED. @FOR EXAMPLE, IF .$%PRINTTEXT'DATA:'; .PRINTSYMBOL(0) IS USED IN A PROGRAM OUTPUTTING TO THE TELETYPE, IT WILL OUTPUT THE .'DATA:', LEAVING THE CARRIAGE POSITIONED PAST IT; THE USER CAN THEN TYPE A REPLY ON THE SAME LINE. @HOWEVER IT WILL NOT REPEAT ITSELF IF THE USER TYPES A NEWLINE AND THE PROGRAM STILL REQUIRES DATA. @THE PROGRAM .MUST RE-ISSUE THE MESSAGE. $P3 @IT IS PERFECTLY REASONABLE TO HAVE TWO OR MORE PROGRAMS OUTPUTTING TO THE SAME TELETYPE. @COMPLETE LINES FROM EACH PROGRAM WILL BE GENERATED AND WILL APPEAR ON THE DEVICE, THE LINES ALTERNATING BETWEEN EACH PROGRAM. @THERE IS A PROBLEM HOWEVER, IN HAVING TWO PROGRAMS SIMULTANEOUSLY INPUTTING FROM ONE TERMINAL. @IT WILL WORK, .BUT ONE LINE OF INPUT WILL GO ALTERNATELY TO EACH PROGRAM AND IT WILL NOT ALWAYS BE POSSIBLE TO DETERMINE WHICH PROGRAM WILL GET THE NEXT LINE OF INPUT. $N $L1CUM RUNNING PAL11F PROGRAMS $P3 .PAL11F PROGRAMS MAY BE RUN ON THE SYSTEM IF THEY CONFORM TO THE FOLLOWING RULES:- $A INDENT=1 $B2 1) @THEY MUST BE %POSITION %INDEPENDANT. $B0 2) @THE .I/O MUST CONFORM TO .MUSS11 .I/O. $B $I+1 @FOR EXAMPLE, THE .TELETYPE MUST NOT BE ACCESSED DIRECTLY, $B0 $I+1 IT CAN ONLY BE USED BY ISSUING THE RELEVANT .SVC. $B1 3) @IN MOST CASES, BECAUSE OF THE DIFFERENCES IN .I/O, A PROGRAM WRITTEN TO RUN UNDER .DOS WILL %NOT RUN UNDER .MUSS11 WITHOUT A MAJOR RE-WRITE (AS IS THE CASE IN SWITCHING BETWEEN .DEC SYSTEMS). $A INDENT=0 $P3 @IF STARTING FROM THE BEGINNING, IT WILL USUALLY BE EASIER TO IMBED THE PROGRAM IN AN .IMP LOOKING HEADER (IN ASSEMBLER). @IN THIS MANNER IT WILL BE FAIRLY EASY TO USE THE .I/O FACILITIES OF .IMP ITSELF, WHILE STILL ALLOWING A FAIRLY FREE USE OF .ASSEMBLER. @FOR FURTHER DETAILS PLEASE CONTACT .B. @GILMORE. $A INVERT=0 $N $A INDENT=0 $L1CUM Operator Control of the System $B3 An operator can control the system by typing the sequence 'CTRL+R' (denoted as ^R) (which echoes OIT:) and a command. $A INDENT=2; TAB=5, 10, 15, 40 $B2 $I-2 Notes: $B0 $I-1 1) $T2 only the first two characters of the command word need to be typed. $B0 $I-1 2) $T2 all parameters should be separated by at least one space. $B0 $I-1 3) $T2 the sequence is terminated by a CR. $B0 $I-1 4) $T2 a program's %identifier may be used instead of its name. $B2 $I-1 Commands:- $A INDENT=4 $B2 $I-4 A) $T2 Program control $B1 $I-3 1) $T2 RU(N) $T4 run a program $B0 $I-3 2) $T2 SU(SPEND) $T4 suspend a program (when it is next awake) $B0 $I-3 3) $T2 CO(NTINUE) $T4 allow a program to continue $B0 $I-3 4) $T2 KI(LL) $T4 kill a program $B0 $I-3 5) $T2 LO(AD) $T4 load a program into core $B0 $I-3 6) $T2 ST(ART) $T4 start up a previously loaded program $b0 $i-3 7) $t2 PU(RGE) $t4 @remove a program from core after it has crashed. $B2 $I-4 B) $T2 System information $B1 $I-3 1) $T2 PS(ECTS) $T4 list all the programs in the system $B0 $I-3 2) $T2 DU(MP) $T4 dump out an area of core $B0 $I-3 3) $T2 EX(AMINE) $T4 dump out a program psect $B0 $I-3 4) $T2 MO(DIFY) $T4 examine a core location $B0 $I-3 5) $T2 NE(XT) $T4 examine the %next core location $B0 $I-3 6) $T2 RE(PEAT) $T4 examine the location again $b0 $i-3 7) SC $t4 @set a word in the communication area. $B2 $I-4 C) $T2 Card reader control $B1 $I-3 1) $T2 CR ASC $T4 tell the card reader to read in ASCII mode $B0 $I-3 2) $T2 CR BIN $T4 tell the card reader to read in binary mode $B0 $I-3 3) $T2 CR EOT $T4 marks the end of a pack of cards. $A INDENT=1 $B3 $V10 $L1C Detailed description of the commands. $B2 $I-1 A1) $T1 RUN $B1 The loader attempts to load the named file, create a descriptor for it (called a %PSECT) and start it executing. $A INDENT=2 $B1 $I-1 1) $T2 if the file does not exist (or the file is not in the correct format) then the message 'EOF!' is put out. $B1 $I-1 2) $T2 If it loads correctly, then the program name, address of the file and its system number is output:- $B1 $T3 PROG
$B1 $I-1 3) $T2 If the loader is busy the 'OIT' types NO! $B1 $I-1 4) $T2 If there is no core the 'OIT' types 'NO CORE!' $B2 $I-2 A2) $T1 SUSPEND $B1 $I-1 A program may be temporarily halted in its execution to allow $B1 $I-1 1) $T2 the debugging program to be run $B1 $I-1 2) $T2 to wait for an operator to put a special (i.e. non-system) device on line. $B1 $I-1 3) $T2 before a program is killed. $B1 This command does not take effect until the program next has a chance to get the CPU. $B2 $I-2 A3) $T1 CONTINUE $A INDENT=1 $B1 This command is the converse of the suspend command, allowing the program to continue its execution. $B1 There are two main occasions this is used $A INDENT=2 $B1 $I-1 1) $T2 after a 'SUSPEND' has been done $B1 $I-1 2) $T2 after a program/system test has issued the 'WAIT' SVC to wait for some operator action e.g. after cards have been put in the hopper, 'CO CR' is typed, or if the line printer was off-line - 'CO LP' is typed after it is put on-line. $A INDENT=1 $B2 $I-1 A4) KILL $B1 A program may be aborted by Killing it. $B1 The following sequence %must be followed. $B1 1) $T2 SU to get it to the 'wait state' $B1 2) $T2 KI instruct the supervisor to kill it $b1 $t2 - the message:- $b0 $t3 n termination req. $b0 $t3 STOPPED AT LINE n MIN STK x $b0 $t3 is output and the program is removed from core . $B2 $I-1 A5) $T1 LOAD $B1 The command does the local phase of the 'Run' command. the loader replies: $B1 $T3 PROG
$B1 The error messages are as in run. $B1 This command may be used to load an external routine in order to put patches in the file before running the main program. $B2 $I-1 A6) $T1 START $B1 This command is used to start up a previously loaded program, the loader outputs $B1 $T3 $b2 $i-1 A7) $t1 PURGE $b1 This command is used to remove a program from core after it has aborted with an address error or similar fault. $B2 $I-1 B1) $T1 PSECTS $B1 This command lists the programs and system tasks in the format:- $B1 $T3 name address state $B0 $T3 name address state $B0 $T3 %. $B0 $T3 %. $B0 $T3 %. $B0 $T3 etc. $B2 $I-1 B2) $T1 DUMP $B1 Areas of core (or device registers) may be dumped out, dumping always starts from a 20 byte boundary. $B1 If an illegal address is specified the 'OUCH!' is output. .a dump can be stopped by hitting ESC. $B2 $I-1 B3) $T1 EXAMINE $B1 The descriptor (PSECT) of a program (its state, prompts system variable, I/O definitions etc.) is dumped out. $B2 $I-1 B4) $T1 MODIFY
$B1 A location (given in octal) may be examined and/or modified by using this command e.g. (system response is underlined) $B1 $T2 M0 1000 (CR) $B0 $T2 %001000 %: %000001 : ^R 123456 $. (CR) $B0 $C38 > $B0 $C38 ^ $B1 If the location is not to be modified then the number is left out. Typing a dot will then examine the %next location, the '>' will use the contents as the address for examine and ^ will go to the previous address. $B2 $I-1 B5) $T1 NEXT $B1 This examines the %next location, responses are the same as for examine. $B2 $I-1 B6) $T1 REPEAT $B1 This %repeats the last location. $b2 $i-1 B7) $t1 Set Communication word. $b1 @this command sets the word 'word' in the communication area to 'cont'. See %EXTERNAL %INTEGER %MAP COM for details of its use. $B3 $I-1 %Card %Reader %Commands $B3 $I-1 C1) $T1 CR ASC $B1 This command switches the mode of sending cards to ASCII (which is the default), it will take effect on the %next card read. $B2 $I-1 C2) $T1 CR BIN $B1 Is similar to CR ASC but switches the mode to binary. $B2 $I-1 C3) $T1 CR EOF $B1 This command tells the card reader handler to signal an 'end-of-file' to the program reading from it. $N $L1CUM Device Handlers $B3 $I-1 1) $T1 LINE PRINTER $B1 The system task which handles the line printer will assume it is on-line and ready. If it is not, or the printer stops (out of paper etc.) then the message:- $B1 $T2 LP OFFLINE! $B1 is output on the main teletype. $B1 The line printer should be put on-line, or fixed, then:- $B1 $T2 ^R CO LP (See operator command A3) $B1 is typed on any console. $B1 The message:- $B1 $T2 LP TASK ERROR! $B1 will appear if the device registers are removed or changed or if there is an error in the handler (rare!). $B2 $I-1 2) $T1 PAPER TAPE READER $B1 On IPL (initial program load), the tape reader will attempt to start up, the message:- $B1 $T2 PR OFFLINE! $B1 will be output if there is no tape (normal condition). This message is also output when the reader reaches the end of a tape. $B1 When a tape is to be read, it is put in the reader and $B1 $T2 ' ^R CO PR' $B1 is typed on any console. The reader should read a section of tape and will then be ready for use. $B1 $T2 'PR TASK ERROR!' $B1 will be output for similar reasons as above. $B1 %Note: an 'EOF' is assumed at the end of each tape. $B2 $I-1 3) $T1 CARD READER $B1 This is similar to the paper tape reader with the difference in the End-of-file handling as described in %operator %commands C1, C2 and C3. $B2 $I-1 4) $T1 DISC AND DEC TAPE $B1 The messages:- $B0 DK OFFLINE! $B0 DF OFFLINE! $B0 DT OFFLINE! - are output if the relevant device is off line, $B1 %or %if %there %is %a %read/write %error %on %a %transfer. $N $A INDENT=0 $L1CUM utility programs $B3 $L1M A) EDITOR $B3 OBJECT FILE: EDITY $B2 This editor is a PDP11 version of the COMPATIBLE CONTEXT EDITOR which runs on EMAS, PDP15S and PDP8S. $B2 OPERATING PROCEDURE: $B2 When started, the editor prompts with:- $B1 EDIT VN.M $B0 # $A INDENT=1 The user responds by typing the input and output file names in the form $B1 $T3 OUTPUT FILE NAME < INPUT FILE NAME $c+5 or $B0 $T3 OUTPUT FILE NAME $A INDENT=2 $B1 $I-1 1) $T2 If the input file does not exist, or is not specified, then a new file is created. $B1 $I-1 2) $T2 A temporary file is created, so, at the end of the editing session the 'old' output file is destroyed and the temporary file is renamed. $B1 $I-1 3) $T2 To edit a file to itself, the form FILE NAME < FILE NAME is used. $B1 $I-1 4) $T2 Editing commands are as in H. Dewar's 'Compatible Context Editor' with the following differences:- $A INDENT=3 $B1 $I-1 A) $T3 '$%T' will close all the files then restart the EDITOR. $B1 $I-1 B) $T3 The EDITOR operates with a 'window' of the file held in core, this will normally be transparent to the user, the command 'M-0' is an exception as it can only move to the top of the 'window'. $B1 $I-1 C) $T3 No secondary stream is implemented. $A INDENT=0 $N $L1M B) FILE TRANSFER PROGRAM $B3 OBJECT FILE: TRANY $B2 This IMP program is a general file/file and file/peripheral transfer program, including transfers to and from a synchronous communications line in IMP 2780 protocol. $B2 OPERATING PROCEDURES: $B2 When TRAN is ready to accept a command it prompts:- $B1 TRAN: $B1 The format for the response is:- $B1 $T2 FILE/DEV < FILE/DEV,FILE/DEV or $B0 $T2 DIRECTIVE $B1 Where $B1 $T2 FILE/DEV is FILE NAME or $B0 $T2 DEVICE NAME $B1 A file name is defined as a group of alphanumeric characters with a length of one to six characters. $B1 $T2 'DEVICE NAME' is defined as:- $B0 $C18 KB: (keyboard input) or $B0 $C18 TT: (teletype output) or $B0 $C18 LP: (line printer) or $B0 $C18 PR: (paper tape reader) or $B0 $C18 CR: (card reader) or $B0 $C18 RJ: (symchronous line) $B1 The following are legal directives: $B1 $T2 ST: - Stop TRAN. $B0 $T2 SI: - Force a signon to the remote machine. $B0 $T2 NS: - Start without a signon. $B0 $T2 EF: - Force an end-of-file to the remote machine. $b0 $t2 BI: - Do the transfer in BINARY mode. $B1 If a command is typed incorrectly, the message 'FORMAT?' is output and the prompt is re-issued. $b1 Using the form 'FILE/DEV,FILE/DEV' causes a concatenation of the two input streams into the output file or device. $B2 SYNCHRONOUS LINE HANDLING $A INDENT=2 $B1 $I-1 1) $T2 TRAN will normally sign-on automatically when the first reference to 'RJ:' is made, the message 'SIGNED ON' is output, then it obeys the request. $B1 $I-1 2) $T2 A number of files may be sent down the line without an end-of-file being sent. An end-of-file is automatically sent on a change of mode to receiving, or may be done explicitly by the directive 'EF:'. $B1 $I-1 3) $T2 In receive mode, non-transparent files (i.e. listing file etc.) are assumed. If a binary file is recieved then TRAN will ignore the current command and request a %file %name to write the binary file to. $B1 $I-1 4) $T2 A file called 'signof' should be transmitted to close down the link. $N $A TAB=5,9,13,16,20 $L1MU C) THE FILE LISTING PROGRAM: FLIST $B3 $T1 This program can be used to perform the following functions: $A INDENT=1 $B2 $I-1 1. $T1 List the disc file directory $B1 a) unordered $B0 b) ordered alphabetically $B2 $I-1 2. $T1 Destroy files $B2 $I-1 3. $T1 Rename files $B2 $I-1 4. $T1 Search for the existence of specific files or groups of files $B2 %COMMANDS $B2 When the program expects a command the symbol '>' is output $B1 E.g. $T3 >A $B1 %Command $C41 %Description $B1 $T2 A $T3 : $T4 Give an alphabetic listing of the file directory $B0 $T2 F $T3 : $T4 Gives an unordered listing of the file directory $B0 $T2 L $T3 : $T4 Look for a file or group of files. Fails if not found $A INDENT=4 $B0 $I-2 D $T3 : $T4 Destroy a file or group of files. Fails if no file or group of files. $A INDENT=1 $B0 $T2 R $T3 : $T4 Rename a file. Fails if new file name exists $B0 $T2 B $T3 : $T4 List size of a file or group of files. $B1 To get a group of files we use the 'wild' character '?' to stand for %any other character. If it is the last character input then it is propagated right $B1 i.e. 'F?' is expanded to 'F?????' $B1 %EXAMPLES $B1 >L $B0 MASK:PRT001 $B0 $T5 Checks if file PRT001 exists $B1 >L $B0 MASK:P? $B0 $T5 Lists all files beginning with P $N >L $B0 MASK:P?T? $B0 $T5 Lists all files beinning with P and third letter is an R $B1 >D $B0 NAME:PRT001 $B0 PRT001?:Y $T5 If a 'Y' is input then file is destroyed otherwise not. $B1 >D $B0 NAME:PRT? $B0 PRT001?N $B0 PRT003?Y $T5 Destroys file 'PRT003' but not 'PRT001' or 'PRT004' $B0 PRT004?N $B0 > $B1 >R $B0 OLD FILE:TEMP $T5 Re-name file 'TEMP' to 'FLIST' $B0 NEW FILE:FLIST $A INVERT=1 $A INDENT=1 $N $A TAB=5, 10, 15, 50 $L1CM D) ARCHIVE PROGRAM $B5 $I-1 .OBJECT .FILE: .ARCHY $P2 @THIS PROGRAM READS AND WRITES FILES TO .DECTAPE IN A FORMAT COMPATIBLE TO THE 'LOCAL' FORMAT USED ON THE .ERCC .PDP15 AND THE .PHYSICS .DEPT. 11/45. $B2 $I-1 .OPERATING .PROCEDURE $B @ARCHIVE INDICATES READYNESS TO ACCEPT A COMMAND BY TYPING:- .'ARCH?' $B1 @THE USER SHOULD MOUNT A .DECTAPE ON %UNIT %0 BEFORE ISSUING THE FIRST COMMAND. $B3 @THE USER BY TYPING THE APPROPRIATE COMMAND ON THE KEYBOARD MAY:- $B0 $A INDENT=2 A) $T+1 @ZERO A .DECTAPE. $B0 B) $T+1 @PRINT OUT THE DIRECTORY OF A TAPE. $B0 C) $T+1 @ARCHIVE A FILE TO .DECTAPE $B0 D) $T+1 @RESTORE A FILE TO DISC FROM .DECTAPE. $B0 E) $T+1 @DELETE A FILE ON THE .DECTAPE $B0 F) $T+1 @STOP THE PROGRAM $A INDENT=1 $B2 @A COMMAND CONSISTS OF:- $B0 $T+1 .DIRECTIVE (CR) $C+20 OR $B0 $T+1 .DIRECTIVE (SPACE) .FILENAMES (CR) $B1 @A .DIRECTIVE CONSISTS OF THE FIRST TWO LETTERS OF THE COMMAND VERB. $B0 .FILENAMES IS ONE OR MORE FILE NAMES SEPERATED BY COMMAS. $B3 $L1C COMMAND DESCRIPTION $I-1 A) $T+1 .ZERO A DECTAPE $B0 .FORMAT: .ZE (CR) $B1 @THIS COMMAND WILL DELETE ALL THE FILES ON A .DECTAPE, RECLAIMING THE SPACE. @IT MUST BE USED WHEN A .DECTAPE IS USED FOR THE FIRST TIME. $B1 $I-1 B) $T+1 .DIRECTORY $B0 .FORMAT: .DI (CR) $B1 @THIS COMMAND GENERATES A LISTING OF THE .DECTAPE DIRECTORY ON THE TELETYPE IN THE FORM:- $B0 $T+1 .FILE .NAME XX NNNNNN MMMMMM $B0 $T+2 $. $B0 $T+2 $. $B1 @WHERE 'XX' IS THE .LENGTH OF THE FILE, 'NNNNNN' IS THE FIRST BLOCK THE FILE OCCUPIES AND 'MMMMMM' IS THE LAST BLOCK. $B1 $I-1 C) $T+1 .ARCHIVE $B0 .FORMAT: .AR (SPACE) .FILENAMES (CR) $B1 @THE FILE(S) IS WRITTEN OUT TO THE .DECTAPE $A INDENT=2 $I-1 1) $T+1 @IF THE FILE DOES NOT EXIST (ON THE DISC), THE MESSAGE .'FILE .DOES .NOT .EXIST' IS OUTPUT. $B0 $I-1 2) $T+1 @IF IT IS ALREADY ARCHIVED ON THE .DECTAPE THE MESSAGE .'FILE .ALREADY .ARCHIVED' IS OUTPUT. $B0 $I-1 3) $T+1 @IF THE .DECTAPE IS FULL, THEN .'DEC .TAPE .FULL' IS OUTPUT. $B1 $A INDENT=1 $I-1 D) $T+1 .RESTORE $B0 .FORMAT: .RE (SPACE) .FILENAMES (CR) $B1 @THE FILE(S) IS WRITTEN FROM THE .DECTAPE ON TO THE DISC (%WITH %THE %SAME %NAME). $B0 $A INDENT=2 $I-1 1) $T+1 @IF THE FILE EXISTS ON THE DISC, IT IS OVERWRITTEN. $B0 $I-1 2) $T+1 @IF THE FILE CAN'T BE FOUND ON THE .DECTAPE, THE MESSAGE .'FILE .NOT .ON .ARCHIVE' IS OUTPUT. $A INDENT=1 $B1 $I-1 E) $T+1 .DELETE $B0 .FORMAT: .DE (SPACE) .FILENAMES (CR) $B1 @THE FILE ON .DECTAPE IS DESTROYED $B0 @THE MESSAGE .'FILE .DOES .NOT .EXIST' IS OUTPUT IF THE FILE CAN'T BE FOUND. $B1 @NOTE: @THIS COMMAND FREES THE DIRECTORY ENTRY, BUT DOES NOT RECLAIM THE FILE SPACE ON THE TAPE UNLESS IT WAS THE LAST FILE TO BE PUT ON THE TAPE. $B1 $I-1 F) $T+1 .STOP $B0 .FORMAT: .ST (CR) $B0 @THE PROGRAM TERMINATES $A INVERT=0 $A INDENT=0 $N $L1CUM External routines available under MUSS11 $B3 A $%SPEC must be given for each routine. $A INDENT=1 $B2 $I-1 1) $T1 $%EXTERNALROUTINESPEC WAIT($%INTEGER ticks) $B1 This routine suspends the program for the given number of ticks (1 tick = 1/50 sec). $B1 If ticks=0 then it is suspended until the operator releases it with 'CO PROG'. $B2 $I-1 2) $T1 $%EXTERNALROUTINESPEC NAME($%BYTEINTEGERARRAYNAME KEY) $B1 This routine reads in a file name from the currently selected input stream [up to 6 chars - '0'-'9' and 'A'-'Z']. $B1 The array should be declared in the form $B1 $T2 $%BYTEINTEGERARRAY KEY (-1:9) $B1 [an immediate return is made if KEY(1)=99]. $B2 $I-1 3) $%EXTERNALROUTINESPEC DEFN($%BYTEINTEGERARRAYNAME BUFFER, NAME, $%INTEGER STREAM) $B1 This routine sets up a STREAM or SQFILE definition. $B1 $%BYTEINTEGERARRAY BUFFER(0:530) is for the internal use of the stream/SQfile $B0 $%BYTEINTEGERARRAY NAME (1:6) is a file name (see $%ROUTINE NAME) $B0 STREAM is the required stream. $B1 This routine should be called prior to using a disc file e.g. $B1 $T2 DEFN(BUFF, KEY, 2) $B0 $T2 SELECT OUTPUT(2) $B0 $T2 WRITE(I,5) etc. $B2 $I-1 4) $T1 $%EXTERNALROUTINESPEC WRIT($%INTEGER X) $B1 This routine writes a positive integer on the current output stream with no leading space. $A INVERT=1 $B5 $V6 $L1C 5) $%EXTERNAL $%INTEGER $%MAP $%SPEC COM($%INTEGER ELEMENT NO) $P2 @WITHIN THE SUPERVISOR THERE IS A COMMUNICATION AREA TO ALLOW PROGRAMS TO PASS INFORMATION TO EACH OTHER AND TO CONTROL THE RUNNING OF CERTAIN 'AUTOMATIC' PROGRAMS. @THE AREA IS 21 WORDS LONG - DESIGNATED AS 0:24 (OCTAL). @THE .MAP .COM ALLOWS VALUES TO BE SET INTO THE ELEMENTS OF THE AREA, AND BE RETRIEVED FROM IT. @ALTHOUGH THE EXACT USE OF EACH WORD WILL BE DIFFERENT IN EACH SYSTEM, THE FOLLOWING WORDS ARE RESERVED:- $A INDENT=3 $B0 $I-2 WORD $T+2 1: - USED FOR CPU TIMING (BY THE PROGRAM .CPU) $I-2 (OCTAL) $T+1 2: - DITTO $B0 3: - HOLDS THE DAY (IF SET BY .SETIM) $B0 4: - HOLDS THE MONTH (DITTO) $B0 5: - HOLDS THE YEAR (DITTO) $B1 $B0 21: - USED BY .ACARD, THE CARD READER SPOOLING PROGRAM. $B0 22: - USED BY .APLOT, THE PLOTTER SPOOLING PROGRAM $B0 23: - USED BY .ALIST, THE LINE PRINTER SPOOLING PROGRAM $B0 24: - USED BY .A2780, THE 2780-EMULATOR SPOOLING PROGRAM. $A INDENT=1 $B2 @THE .MAP MAY BE USED IN A NUMBER OF WAYS, FOR EXAMPLE:- $A INDENT=2 $B0 .$%INTEGER .I $B0 @I = .COM(10); $T4 ! READ THE VALUE OF WORD 10 $B0 .COM(10) = 2; $T4 ! SET WORD 10 TO 2 $B0 $I-1 OR $B .$%INTEGERNAME .COMWORD; .$%INTEGER .I $B0 .COMWORD == .COM(10); $T4 ! POINT .COMWORD AT WORD 10 $B0 .I = .COMWORD; .COMWORD = 2; $C+4 ! GET, THEN SET WORD 10 $B5 $A INDENT=1 $L1C 6) $%EXTERNAL $%ROUTINE $%SPEC DA($%INTEGER MODE, BLOCK, ADDRESS) $P1 @THIS ROUTINE IS USED TO READ OR WRITE BLOCKS TO THE .DISC OR .DECTAPE. $B1 $A INDENT=2 MODE = 0 - .READ A BLOCK FROM THE .DISC. $B0 $C+5 = 1 - .WRITE A BLOCK TO THE .DISC. $B0 $C+5 = 2 - .READ A BLOCK FROM .DECTAPE. $B0 $C+5 = 3 - .WRITE A BLOCK TO .DECTAPE. $B1 .BLOCK $C+4 - DEVICE BLOCK NUMBER. $B0 .ADDRESS $C+2 - ADDRESS OF 256 WORD BUFFER. $B0 $A INDENT=1 $B2 @THE ROUTINE MAY ALSO BE CALLED WITH .'$%INTEGERNAME .ADDRESS', FOR EXAMPLE:- $B $A INDENT=2 .$%INTEGERARRAY .A(0:255) $B0 .DA(0, 500, .A(0)) $A INDENT=1 $B0 @WHICH WILL .READ BLOCK 500 INTO .A. $A INDENT=1 $B5 $V7 $L2C 6) $%EXTERNAL $%ROUTINE $%SPEC FIDENT($%INTEGER TYPE, $%C $%BYTEINTEGERARRAYNAME KEY) $P2 @THIS ROUTINE PROVIDES INFORMATION ABOUT GROUPS OF FILE NAMES. @IT IS USED WHEN IT IS NECESSARY TO AUTOMATICALLY ALLOCATE FILE NAMES OF A GIVEN FORM, OR WHEN GROUPS OF FILE NAMES ARE BEING PROCESSED. $P1 @THE FIRST FOUR LETTERS OF EACH .DISC FILE ARE MATCHED AGAINST THE FOUR LETTERS PROVIDED BY THE CALLER IN .KEY(1), .KEY(2), .KEY(3) AND .KEY(4). @THE FINAL TWO LETTERS OF A MATCHING FILE ARE THEN TREATED AS A NUMBER, FILES IN THE RANGE 0 TO 40 ARE USED, THE ACTUAL USE DEPENDING ON .TYPE. $A INDENT=2 $B1 $B1 .TYPE = 0 - RETURNS THE NAME OF THE FIRST EXISTING FILE $B0 TYPE = 1 - RETURNS THE NEXT FREE FILE NAME. $B2 $A INDENT=1 @THE RESULTANT FILE NAME IS PASSED BACK IN .KEY(1) - .KEY(6). @AN ERROR RETURN .(KEY(0)=-1) IS MADE IF $B0 $A INDENT=2 1) THERE IS NO FILE .(TYPE=0) OR $B0 2) NO FREE FILE NAME EXISTS .(TYPE=1). $A INDENT=1 $P3 @FOR EXAMPLE - ALL FILES OF THE TYPE .'PRITXX' CAN BE OBTAINED BY A PROGRAM, ONE AT A TIME BY CALLING .FIDENT(0, .A) WHERE .A(1) TO .A(4) ARE SET TO .'PRIT'. $P2 @IT SHOULD BE NOTED THAT EACH FILE SHOULD BE 'RENAMED' OR 'DESTROYED' AFTER USE OR .FIDENT WILL PICK IT UP AGAIN WHEN RECALLED. $B2 @THE .ARRAY SHOULD BE DECLARED AT LEAST (0:6), OR IF .RENAME IS GOING TO BE CALLED THEN (-1:6). $A INDENT=1 $B5 $L1C 7) $%EXTERNAL $%INTEGER $%FN $%SPEC RENAME($%BYTEINTEGERARRAYNAME FROM, TO) $P2 @THIS FUNCTION RENAMES THE FILE.'FROM' TO THE FILE .'TO'. $B0 @THE RESULT IS ZERO IF THE RENAME SUCCEEDS, NON-ZERO IF .'FROM' DOESN'T EXIST OR .'TO' DOES EXIST. $B2 @THE .ARRAYS SHOULD BE DECLARED :- $B0 $I+1 .$%BYTEINTEGERARRAY (-1:6) $B0 @THE FIRST TWO ELEMENTS ARE USED BY .'RENAME', THE FILE NAME IS IN ELEMENTS ONE TO SIX. $A INVERT=1 $L3CM APPENDIX 2 PRELIMINARY USER MANUAL FOR THE SECOND SYSTEM $N $A TAB=5,15,25 $B20 $L1CM USER MANUAL FOR DEIMOS $B2 $L1CM B. GILMORE $L1CM AUGUST 1976 $N $L1CUM CONTENTS $B6 $A INDENT=1 .TITLE $T6 .PAGE $B0 @SYSTEM COMMANDS. $T6 4 $B0 @THE .EDITOR. $T6 7 $B0 @THE .IMP COMPILER. $T6 8 $B0 @THE .LINKER. $T6 9 $B0 @LIBRARY MANIPULATION. $T6 11 $B0 @THE DEBUGGING PROGRAM. $T6 12 $A INDENT=0 $N $L1CM SYSTEM COMMANDS $P1 @ALL COMMANDS GIVEN TO THE SYSTEM ARE INTERPRETED BY THE COMMAND LANGUAGE INTERPRETER .(CLI). @THE .CLI INDICATES ITS READINESS TO ACCEPT A COMMAND BY TYPING THE PROMPT '>' AND '<' OVERLAID. @IF A PROGRAM IS RUNNING, THE .CLI CAN BE INVOKED BY TYPING , THE COMMAND PROMPT SHOULD THEN APPEAR. $P1 @THE INPUT TO THE .CLI HAS TWO FORMS, EITHER:- $B0 .A) @A .FILE .NAME, FOLLOWED BY 'STREAM DEFINITIONS' $C+5 OR $B0 .B) @A .COMMAND .VERB, POSSIBLY FOLLOWED BY PARAMETERS $B3 $L1C A) A FILE NAME $P1 @IF A .FILE .NAME IS SPECIFIED, THAT FILE IS LOADED AND THE PROGRAM CONTAINED IN IT IS ENTERED. @IF THE FILE DOES NOT EXIST, OR DOES NOT CONTAIN A PROGRAM, THE MESSAGE .'*NO .FRED', WHERE .FRED IS THE NAME OF THE FILE, IS OUTPUT AND THE COMMAND PROMPT IS RE-ISSUED. $B1 @THE 'STREAM DEFINITIONS' ARE INPUT IN THE FORM:- $B1 $I1 $C+5 ,,/,, $B1 ETC, EACH REPRESENT A 'STREAM DEFINITION'. $B1 @A 'STREAM DEFINITION' IS OF THE FORM:- $A INDENT=1 $B1 .$.TT $T2 - WHICH IS EITHER INPUT OR OUTPUT FROM A TERMINAL. $B0 .$.LP $T2 - OUTPUT TO A LINE PRINTER $B0 $B0 $B1 $I0 @A .FILE .DEFINITION IS IN THE FORM:- $B1 $I2 .() $A INDENT=1 $B1 @THE , CURRENTLY, IS EITHER '0' OR '1' AND REFERS TO THE PHYSICAL DISC DRIVE. @IF NEITHER IS SPECIFIED, '0' IS ASSUMED. $B0 @THE CONSISTS OF AN ALPHANUMERIC STRING, WHICH MUST BE PRECEEDED BY A LETTER, OF UP TO 6 CHARACTERS IN LENGTH $B0 @THE IS THE FILE SYSTEM THAT THE FILE COMES FROM, OR IS CREATED IN. @IF NONE IS SPECIFIED, THE USERS OWN IS USED (SEE THE COMMAND .LOGON) EG $A INDENT=2 $B1 $I1 .FRED $T2 - THE FILE CALLED .FRED ON UNIT 0 IN THE USERS FILE SYSTEM. $I1 .0.FRED $T2 - THE SAME. $I1 .1.FRED $T2 - @THE FILE .FRED IS TAKEN FROM DISC UNIT ONE. $I1 .FRED(0) $T2 - THE FILE .FRED FROM FILE SYS. ZERO (THE SYSTEMS OWN ONE) $I1 .1.FRED(25) $T2 - THE FILE .FRED FROM DISC UNIT ONE AND FILE SYSTEM 25 (OCTAL). $I1 .$.TT $T2 - THE TERMINAL, INPUT IF ON THE LEFT HAND SIDE, OUTPUT IF ON THE RIGHT HAND SIDE. $A INDENT=0 $P1 @THE STREAM DEFINITIONS ARE LINKED INTO THE INPUT AND OUTPUT STREAMS AVAILABLE TO AN .IMP PROGRAM, FOR EXAMPLE, IF THE PROGRAM .FRED IS RUN WITH THE FOLLOWING COMMAND:- $B0 $I2 .FRED .F1$,F2/O1$,O2$,.TT $B0 THEN INPUT STREAM ONE, USED BY CALLING .'SELECT .INPUT(1)' IS MAPPED TO THE FILE .'F1'. @A .'SELECT .OUTPUT(2)' WILL SEND OUTPUT TO THE FILE .O2', AND .'SELECT .OUTPUT(3)' WILL SEND THE OUTPUT TO THE TERMINAL. $P1 @IF A FIELD IS LEFT BLANK, AS WITH IN THE ABOVE EXAMPLE, THE STREAM IS MAPPED TO .'NULL' - WHICH CAUSES AN 'END OF FILE' SIGNAL ON INPUT AND ON OUTPUT, ALL THE OUTPUT IS THROWN AWAY. $B1 @INPUT STREAM ZERO AND OUTPUT STREAM ZERO ARE ALWAYS MAPPED TO THE USERS TERMINAL. $B1 .FURTHER .EXAMPLES $A INDENT=3 $B1 $I1 .PROG .$.TT $T3 - USES ONE INPUT STREAM .'$.TT', NO OUTPUT STREAM (APART FROM ZERO) IS DEFINED. $I1 .PROG .FILE $T3 - WILL READ FROM A FILE CALLED .FILE ON STREAM ONE. $I1 .PROG ./FILE $T3 - NO INPUT STREAMS DEFINED (APART FROM ZERO), WILL WRITE TO A FILE CALLED .FILE AFTER A .'SELECT .OUTPUT(1)'. $I1 .PROG .FILE/FILE $T3 - THIS WILL READ DATA FROM A FILE CALLED .FILE AND CREATE AN OUTPUT FILE CALLED FILE $A INDENT=1 $B1 .NOTE: @WHEN A PROGRAM DOES THE FIRST .'SELECT .OUTPUT(N)', WHERE A FILE IS MAPPED TO THAT STREAM, THE SYSTEM WILL CREATE A TEMPORARY FILE .(FILE# IN THE PREVIOUS EXAMPLE). @WHEN THE PROGRAM STOPS, OR CALLS .'CLOSE .OUTPUT', THE ORIGINAL FILE .(FILE) IS DESTROYED AND THE TEMPORARY FILE .(FILE#) .RENAMED TO THAT NAME .(FILE). $A INDENT=0 $B2 $L1C B) A COMMAND VERB $P1 @THERE ARE CURRENTLY SIX AVAILABLE SYSTEM COMMANDS, THEY ARE:- $A INDENT=1 $B1 $I1 A) .LOGON $T2 - USED TO 'LOGON' TO A FILE SYSTEM. $I1 B) .TASKS $T2 - @LIST THE RUNNING PROGRAMS ON THE SYSTEM. $I1 C) .HOLD $T2 - @STOP A TASK EXECUTING. $I1 D) .FREE $T2 - @RELEASE A .'HELD' TASK. $I1 E) .KILL $T2 - @STOP A PROGRAM IN A CONTROLLED MANNER. $I1 F) .PURGE $T2 - @IMMEDIATELY REMOVE A TASK FROM THE SYSTEM. $B1 $L1C A) LOGON $P1 @THIS COMMAND IS CALLED IN THE FORM: $I2 .LOGON NN $B0 WHERE 'NN' IS A TWO DIGIT OCTAL NUMBER, REPRESENTING THE USERS FILE SYSTEM NUMBER. $V25 $B1 $L1C B) TASKS $P1 @THIS COMMAND HAS NO PARAMETERS, IT LISTS OUT THE TASKS ON THE SYSTEM IN THE FORM:- $B1 $I2 $C+2 $C+2 $B1 @THE STATES OF A TASK ARE AS FOLLOWS:- $A INDENT=1 $B1 $C+1 .STATE $T3 .MEANING $B0 000001 $T3 @TASK IS IN THE .WAIT STATE. $B0 000002 $T3 @TASK HAS EXECUTED A .'POFF'. $B0 000010 $T3 @TASK IS ON A .CPU .QUEUE AWAITING EXECUTION. $B0 000020 $T3 @THE TASK IS IN THE .'RUN' STATE. $B0 000200 $T3 @THE TASK HAS BEEN .'HELD'. $A INDENT=0 $B1 $L1C C) HOLD $P1 @THIS COMMAND IS CALLED IN THE FORM: $I2 .HOLD XXXX $B0 WHERE 'XXXX' REPRESENTS THE NAME OF A TASK RUNNING ON THE SYSTEM. @IF THE TASK IS CURRENTLY EXECUTING, IT IS SUSPENDED. @IF THE TASK IS WAITING FOR A MESSAGE, IT WILL BE SUSPENDED WHEN IT NEXT REQUESTS THE .CPU. $B1 $L1C D) FREE $P1 @THIS COMMAND IS THE CONVERSE OF .HOLD AND IS CALLED: $I2 .FREE XXXX $B0 IT PLACES THE TASK 'XXXX' BACK ON THE .CPU. $B1 $L1C E) KILL $P1 @THIS COMMAND IS CALLED IN THE FORM: $I2 .KILL XXXX $B0 IT HAS THE EFFECT OF SENDING THE TASK CALLED 'XXXX' A MESSAGE TO STOP, THE TASK SHOULD THEN STOP IN A CONTROLLED MANNER TIDYING UP ALL ITS STREAMS. $V10 $B1 $L1C F) PURGE $P1 @THIS COMMAND IS CALLED IN THE FORM: $I2 .PURGE XXXX $B0 IT HAS AN IMMEDIATE EFFECT, COMPLETELY REMOVING THE TASK FROM THE SYSTEM, NO ATTEMPT IS MADE TO TIDY THE OPEN STREAMS. @THIS COMMAND SHOULD NOT NORMALLY BE USED TO STOP A PROGRAM, BUT .MUST BE USED TO CLEAR A PROGRAM FROM THE SYSTEM THAT HAS CRASHED WITH AN .'ADDRESS .ERROR' OR A .'SEG .FAULT'. $B1 .NOTE: @IF A PROGRAM IS STILL RUNNING, .HOLD MUST BE CALLED BEFORE EITHER .KILL OR .PURGE IS USED. $A INDENT=0 $N $A TAB=5,20 $L1CM THE EDITOR $P1 @THE .EDITOR IS A .PDP11 VERSION OF THE .COMPATIBLE .CONTEXT .EDITOR. $P1 @FOR GENERAL INFORMATION ON THE @EDITOR, SEE THE .USER .GUIDE OF THE .COMPATIBLE .CONTEXT .EDITOR BY @H @DEWAR. $P1 @THE COMMAND FOR CALLING THE @EDITOR HAS THREE POSSIBLE FORMS AS ILLUSTRATED BELOW: $A INDENT=2 $B1 $I1 .E ./TEST $T2 - TO PRODUCE A NEW FILE CALLED .TEST. $I1 .E .TEST $T2 - TO EDIT AN EXISTING FILE CALLED .TEST $I1 .E .TEST/TEST2 $T2 - TO PRODUCE A NEW FILE CALLED .TEST2 $I2 $C+2 FROM AN EXISTING FILE CALLED .TEST. $A INDENT=1 $B1 $I0 .NOTES $B0 1) @THE @EDITOR PROMPTS '>' WHEN IT IS READY TO ACCEPT A COMMAND AND ':' WHEN IT EXPECTS A LINE OF INPUT .(COMMAND: .GET). $B1 2) @THIS VERSION OF THE @EDITOR USES A 'WINDOW' OF THE FILE, THIS WILL NOT NORMALLY BE APPARENT, BUT IT DOES MEAN THAT THE COMMAND .'M-*' WILL NOT NECESSARILY RETURN RIGHT TO THE TOP OF THE FILE. $N $A TAB=5,15 $L1CM RUNNING THE IMP COMPILER $P1 @THE .IMP COMPILER IS A THREE PASS COMPILER TO WHICH A FOURTH PASS, A .LINKING PHASE, IS AUTOMATICALLY CALLED FOR .$%BEGIN ... .$%ENDOFPROGRAM PROGRAMS $B1 @THERE ARE FOUR MAIN WAYS OF CALLING IT:- $A INDENT=2 $B1 $I0 .IMP .A/B $T2 - WHICH COMPILES SOURCE FILE .'A' TO OBJECT .'B' $I0 .IMP .A/$,L $T2 - WHICH ONLY DOES ONE PASS AND CREATES A LISTING FILE .'L' (NOTE: .'L' CAN BE EITHER A FILENAME, .'.TT' OR .'.LP'). $I0 .IMP .A/B$,L $T2 - WHICH CREATES BOTH AN OBJECT FILE AND A LISTING FILE. $I0 .IMP .A$,$.TT/B $T2 - THIS FORM IS USED TO CHANGE THE .LINKER DEFAULTS, FOR MORE DETAILS OF THE DEFAULTS, SEE THE SECTION ON THE .LINKER. $A INDENT=0 .NOTES $A INDENT=1 $I0 1) $T1 @AT PRESENT, THE PROGRAM .'IMPX' MUST BE RUN TO AVOID THE LINKING PHASE FOR .$%EXTERNALROUTINE FILES. @IN THIS CASE, THE FILE .'B' ABOVE IS THE COMPILERS THIRD PASS OUTPUT. $I0 2) $T1 @THE TEST COMPILER IS ACCESSED BY RUNNING THE PROGRAM .'NIMP'. $I0 3) $T1 @THE FIRST PASS AUTOMATICALLY USES A FILE OF .'$%SPECS' CALLED .'PRIMS' WHICH IS TAKEN FROM THE SYSTEM FILE SYSTEM. $I0 4) $T1 @THE FIRST PASS CREATES A TEMPORARY OUTPUT FILE .'O' FOR USE WITH THE ECOND PASS. @THE SECOND PASS CREATES .'O2' AND .'O3' AND THE THIRD PASS .'OY'. $I0 5) $T1 @THE OUTPUT FROM THE THIRD PASS .'OY' IS USEFUL. @IT CAN BE USED AS INPUT TO THE PROGRAMS .'RECODE' AND .'VIEW' IF IT IS NECESSARY TO DE-COMPILE THE COMPILER OUTPUT. $B0 @IF THE LINKER IS TO BE RUN AS A SEPERATE 4TH PASS, THE FILE .'OY' IS USED AS ITS INPUT. $N $A TAB=5,25 $A TAB=5,15 $L1CM THE LINKER $P1 @THE .LINKER IS NORMALLY RUN AUTOMATICALLY AS A FOURTH PASS TO THE .IMP COMPILER. @IT IS RUN INDIVIDUALLY BY TYPING ONE OF THE TWO FOLLOWING FORMS OF COMMAND TO THE .COMMAND .LANGUAGE .INTERPRETER. $A INDENT=1 $B0 .LINK .A/B $C+20 OR $B0 .LINK .A$,$.TT/B $A INDENT=0 $P1 @BOTH OF THE ABOVE COMMANDS TAKE THE FILE .'A', WHICH MUST BE THE OUTPUT FROM THE THIRD PASS OF THE COMPILER AND CREATE A RUNNABLE FILE .'B'. $P1 @THE SECOND FORM OF THE COMMAND OVERRIDES THE STANDARD .LINKER DEFAULTS, THE .LINKER PROMPTS FOR THE NEW DATA AS FOLLOWS (DEFAULTS IN BRACKETS):- $A INDENT=2 $I1 .NAME: $T2 - UP TO 4 CHARACTERS ARE TYPED IN AS THE .TASK .NAME FOR THE PROGRAM (THE FIRST FOUR CHARACTERS OF THE OBJECT FILE NAME ARE USED). $I1 .STACK: $T2 - THE DESIRED STACK SIZE (IN OCTAL BYTES), EXCLUDING THE .GLA (DEFAULT: 14000). $I1 .STREAMS: $T2 - THE MAX NUMBER OF INPUT AND OUTPUT STREAMS THAT THE PROGRAM IS GOING TO USE, EXCLUDING .INPUT AND .OUTPUT (0) (DEFAULT: 3). $A INDENT=0 $P1 @IF A PROGRAM HAS EXTERNAL REFERENCES IN IT, THE .LINKER WILL FIRST ATTEMPT TO SATISFY THEN USING .'LIB000' IN THE USERS FILE SYSTEM. @IF THERE ARE STILL UNSATISFIED REFERENCES, THE .LINKER WILL LOOK AT .'LIB000' IN FILE SYSTEM ZERO (THE SYSTEM FILE SYSTEM). @FOR MORE INFORMATION ON .LIBRARIES, SEE THE SECTION ON THEM. $P1 @A SAMPLE .LINKER OUTPUT MAP IS GIVEN BELOW:- $A INDENT=1 $B2 .CODE: 040000 $C+2 .GLA: 140020 $B0 $C+2 .XREF:PON $C+5 .POFF $C+5 .PONOFF $C+5 .MAPVIRT $B0 $C+2 .XDEF: 040000 $C+2 .#GO $B0 .FILE:SHARED $B0 $C+2 .CODE: 046506 $C+2 .GLA: 140752 $B0 $C+2 .XREF: 004000 $C+2 .RUN $B0 $C+2 .XDEF: 022656 $C+2 .PON $B0 $C+2 .XDEF: 022700 $C+2 .POFF $B0 $C+2 .XDEF: 022736 $C+2 .MAPVIRT $B0 $C+2 .XDEF: 023006 $C+2 .MAPABS $B1 .TOTALS: .CODE = 006506 $C+2 .GLA/STACK = 002016 $A INDENT=0 $P1 @THE .TASK .NAME OF THE PROGRAM .(DBUG) IS PRINTED ALONG WITH THE BASE ADDRESS FOR ITS CODE (040000) AND ITS .GLA (140020). @THE .'XREF' REFERS TO 'EXTERNAL REFERENCES' FROM THAT SECTION OF CODE (IN THIS CASE THEY ARE ALL DECLARED BY THE SYSTEM). @THE .'XDEF' IS AN 'EXTERNAL DEFINITION', IN THIS CASE .'#GO' WHICH IS THE ENTRY POINT FOR THE MAIN PROGRAM. $P1 @THE .'FILE:' INDICATES THAT THE .LINKER HAS LOADED AN OBJECT FILE , IT SPECIFIES ITS NAME .(SHARED) AND THE START ADDRESS OF ITS CODE (046506) AND .GLA (140752) SECTIONS. @THE LIST BENEATH THAT IS THE 'EXTERNAL DEFINITIONS', IN THIS CASE ENTRY POINTS THAT THE FILE CONTAINS. $P1 @THE LAST LINE GIVES THE OVERALL CODE LENGTH OF THE PROGRAM (006506) AND THE TOTAL SIZE OF THE .GLA AND THE DECLARED STACK. $P1 @IF ANY REFERENCES ARE LEFT UNDECLARED, THE .LINKER WILL LIST THEM ALONG WITH AN .'UNDEFINED .REFERENCE' MESSAGE. $P1 @IF THE .LINKER ATTEMPTS TO LOAD A FILE THAT CONTAINS AN ENTRY POINT THAT HAS ALREADY BEEN LOADED, THE MESSAGE .'*DOUBLE .DEF' IS OUTPUT AND THE .LINKER STOPS. $N $A TAB=5,20 $L1CM LIBRARY MANIPULATION $P1 @WHEN THE .LINKER FINDS AN .EXTERNAL .REFERENCE IN A PROGRAM FILE IT WILL ATTEMPT TO SATISFY THE REFERENCE BY:- $A INDENT=1 $I0 1) $T1 @SEARCHING THE LIBRARY .'LIB000' IN THE .USER FILE SYSTEM, LOADING OBJECT FILES AS NECESSARY, THEN $I0 2) $T1 @SEARCHING THE LIBRARY .'LIB000' IN THE .SYSTEM FILE SYSTEM (ZERO). $A INDENT=0 $P1 @THERE ARE THREE PROGRAMS CURRENTLY AVAILABLE TO THE USER TO MANIPULATE LIBRARIES, THEY ARE:- $A INDENT=2 $B1 $I1 1) .NEWLIB $T2 - CREATES A NEW LIBRARY FILE. $I1 2) .INSERT $T2 - @INSERTS THE ENTRIES OF AN OBJECT FILE INTO A LIBRARY. $I1 3) .INDEX $T2 - LISTS THE CONTENTS OF A LIBRARY. $A INDENT=1 $B1 .NOTE: @EACH OF THE PROGRAMS WILL MANIPULATE LIBRARIES OTHER THAN .'LIB000', BUT AT PRESENT THE .LINKER WILL NOT LINK THEM. $B2 $L1C 1) NEWLIB @THE COMMAND FOR USING .NEWLIB IS AS FOLLOWS:- $B0 .NEWLIB ./LIB $B0 @THIS COMMAND WILL CREATE A NEW LIBRARY FILE .'LIB', IF IT ALREADY EXISTS THE OLD COPY IS DESTROYRD. $B2 $L1C 2) INSERT @THERE ARE TWO MAIN FORMS OF THIS COMMAND AS FOLLOWS: $B0 .INSERT .TESTY$,LIB/LIB $C+10 AND $B0 .INSERT .TESTY$,LIB/LIB2 $P1 @THE FIRST COMMAND WILL ADD THE ENTRIES OF THE FILE CALLED .TESTY INTO THE LIBRARY CALLED .LIB. $P1 @THE SECOND COMMAND WILL ADD THE CONTENTS OF THE FILE CALLED .TESTY INTO THE LIBRARY CALLED .LIB, CREATING A NEW LIBRARY CALLED .LIB2. $B1 $L1C 3) INDEX @THE FORM OF THIS COMMAND IS AS FOLLOWS:- $B0 .INDEX .LIB $P1 @THIS COMMAND WILL PRINT OUT ALL THE ENTRIES IN THE LIBRARY FILE .'LIB' $N $A TAB=5, 10; CAPO=0; CAPSHO=0; INVERT=1 $L1CM DEBUGGING PROGRAM $B2 $L1C OBJECT: DBUG $A INDENT=1 $P2 @THIS PROGRAM IS USED AS AN AID TO DEBUGGING PROGRAMS, IT WILL MORMALLY BE 'LINKED' TO A RUNNING PROGRAM ON THE SYSTEM USING THE COMMAND .'T' (FOR DETAILS SEE LATER), ALL ACCESSES TO LOCATIONS WILL THEN BE MADE IN THAT PROGRAMS VIRTUAL MEMORY. $B0 @IT MAY BE USED TO:- $A INDENT=2 $B0 1) .SET AND .CLEAR BREAKPOINTS $B0 2) @DUMP OUT THE .PSECT, .REGISTERS AND/OR THE .IMP .STACK. $B0 3) .EXAMINE AND .CHANGE LOCATIONS IN CORE. $B0 4) .DUMP GENERAL AREAS OF CORE. $A INDENT=1 $P2 .DEBUG INDICATES ITS READINESS TO ACCEPT COMMANDS BY TYPING .'DEBUG:'. @THE FOLLOWING COMMANDS MAY BE USED. $A INDENT=2 $B1 $I-1 .T - $T+1 @SET @TASK NUMBER OF PROGRAM TO BE DEBUGGED. $I-1 .B - $T+1 @SET BREAKPOINT. $I-1 .C - $T+1 @CLEAR BREAKPOINT. $I-1 .N - $T+1 @SET A NEW PROGRAM CODE BASE. $I-1 .R - $T+1 @DUMP THE .REGISTERS. $I-1 .P - $T+1 @DUMP THE .PSECT. $I-1 .I - $T+1 @DUMP THE .IMP STACK. $I-1 .A - $T+1 @DO .'P', .'R', AND .'I'. $I-1 .D - $T+1 @DUMP AN AREA OF CORE. $I-1 .O - $T+1 @CHANGE THE OUTPUT DEVICE. $I-1 .W - $T+1 .WAIT .DEBUG. $I-1 .S - $T+1 @STOP .DEBUG. $I-1 .? - $T+1 @PRINT OPTIONS. $A INDENT=1 $P1 @IN ADDITION TO THESE COMMANDS, THERE IS AN IMPLIED COMMAND, ACTIVATED BY TYPING AN OCTAL DIGIT, THAT ENTERS THE LOCATION EXAMINATION/CHANGE PART OF .DEBUG. $P2 @A DETAILED DESCRIPTION OF EACH COMMAND FOLLOWS. $B3 $L1C T - SET TASK NUMBER $P1 @THE PROMPT .'TASK .ID:' IS OUTPUT AND THE (OCTAL) .ID OF THE PROGRAM TO BE DEBUGGED SHOULD BE ENTERED. @THE .TASK .ID OF A RUNNING PROGRAM MAY BE OBTAINED BY TYPING THE COMMAND .'TASKS' TO THE COMMAND LANGUAGE INTERPRETER. $B0 .NOTE: @ONLY THE COMMANDS .'T', .'N', .'O', .'S' AND .'W' MAY BE USED BEFORE .'T' IS USED FOR THE FIRST TIME. $V15 $B3 $L1C B - SET BREAKPOINT $P1 @THE PROMPT .'ADDR:' IS OUTPUT, THE REPLY IS THE .RELATIVE ADDRESS (WRT THE START OF THE PROGRAM) OF THE DESIRED BREAKPOINT. @DEBUG WILL REMEMBER THE CONTENTS AND PLACE A .'BR $.' IN THE LOCATION. @THIS WILL CAUSE THE PROGRAM TO LOOP WHEN IT EXECUTES THAT INSTRUCTION. $P1 @DEBUG REPLIES: $I2 .BP: N .ADDR: N2 .CONT= N3 $B0 - WHERE 'N' IS THE BREAKPOINT NUMBER (BETWEEN 0 AND 20), 'N2' IS THE VIRTUAL ADDRESS, AND 'N3' THE ORIGINAL CONTENTS. $P1 @THE MESSAGE .'BP .TABLE .FULL' IS OUTPUT IF MORE THAN 21 BREAKPOINTS ARE USED. @SEE THE COMMAND .'N' FOR SETTING BREAKPOINTS IN EXTERNAL ROUTINES. $B3 $L1C C - CLEAR BREAKPOINTS $P1 @PROMPTS .'NO?'. @THE BREAKPOINT NUMBER SHOULD BE TYPED. .'A' OR '-1' IS TYPED IF .ALL THE BREAKPOINTS ARE TO BE CLEARED. @IF THE SPECIFIC BREAKPOINT HAS NOT BEEN SET, THE MESSAGE '?' IS OUTPUT. @THE ORIGINAL CONTENTS ARE REPLACED. $B3 $L1C N - SET A NEW PROGRAM CODE BASE $P1 @PROMPTS .'NEW .PROGRAM .CODE:'. @REPLY GIVING THE NEW ADDRESS. @THIS COMMAND IS USEFUL FOR PROGRAMS USING EXTERNAL ROUTINES. @TO SET A BREAKPOINT IN AN EXTERNAL ROUTINE, THE CODE BASE IS SET TO THAT OF THE EXTERNAL ROUTINE, AS PRINTED OUT BY THE .LINKER, AND THE RELATIVE ADDRESS SPECIFIED. @THIS DOES NOT EFFECT ANY PREVIOUSLY SET BREAKPOINTS. $B3 $L1C R - PRINT REGISTERS. $P1 @THIS COMMAND PRINTS THE REGISTERS OF THE NOMINATED TASK. @THE .LOCAL .NAME .BASE .(LNB) FOR THE OUTER LEVEL IS ALSO PRINTED. $V20 $B3 $L1C P - PRINT THE PSECT $P1 @THE .PSECT (OWN SYSTEM VARIABLES) OF THE NOMINATED TASK IS PRINTED. $B0 @THE COMMAND :- $B0 $I+1 1) @PRINTS THE NAME OF THE TASK $B0 $I+1 2) @PRINTS THE STATE OF THE TASK. $B0 $I+1 3) @INDICATES WHETHER THERE ARE MESSAGES QUEUED. $B0 $I+1 4) @CALLS .'REGISTERS' TO DUMP THE REGISTERS OUT. $B0 $I+1 5) @PRINTS THE CONTENTS OF THE SEGMENTATION REGISTERS $B0 $I+1 $C+4 IN THE FORM:- $B1 $I2 . $C+3 .
$C+3 . $C+3 . $V6 $V10 $B3 $L1C I - PRINT THE IMP STACK $P1 @THE ENTIRE .IMP .STACK IS PRINTED ON THE OUTPUT DEVICE. $B0 .NOTE: @THE .GLA OF THE PROGRAM IS HELD AT THE LOW ADDRESS END OF THE STACK, THE .IMP STACK (IE THE .SP STACK) STARTS AT THE HIGH ADDRESS END AND WORKS TOWARDS THE LOW ADDRESS END. IS NOT THE SAME AS THE START OF THE STACK. $B3 $L1C A - PRINT ALL $P1 @THE COMMAND EXECUTES A PRINT PSECT .(P), PRINT REGISTERS .(R) AND THE .IMP STACK .(I). @THIS COMMAND IS USEFUL FOR DUMPING ALL THE RELEVANT INFORMATION ABOUT A PROGRAM ONTO THE LINE PRINTER (SEE COMMAND .'O'). $B3 $L1C D - DUMP AN AREA OF CORE $P1 @PROMPTS .'FROM:' AND .'LENGTH:'. @BOTH NUMBERS SHOULD BE TYPED IN OCTAL AND THE AREA OF CORE FROM .'FROM' TO .'FROM+LENGTH' IS OUTPUT. $B1 .NOTE: 1) @ON ALL THE DUMPS .'ZEROES' IS OUPUT IF ONE OR MORE ENTIRE LINE CONTAINS ZERO. $B0 2) @AN .ISO EQUIVALENT IS PRINTED ON THE .RHS OF THE DUMP. $B3 $L1C O - CHANGE THE OUTPUT DEVICE $P1 @PROMPTS .'STREAM:'. @THE REPLY IS USED IN THE FORM .'SELECT .OUTPUT(N)' FOR THE OUTPUT OF COMMANDS .R,P,I,A AND .D. @BY CALLING .'DBUG' IN THE FORM:- $B0 .DBUG ./L $T+2 OR $B0 .DBUG ./.LP $T+2 ETC $B0 THE OUTPUT MAY BE DIRECTED TO THE FILE .'L' OR TO THE LINE PRINTER. $B3 $L1C W - WAIT DEBUG $P1 @THIS COMMAND IS USED TO SUSPEND .DEBUG IF IT IS NECESSARY TO INPUT TO A PROGRAM ON THE SAME TELETYPE. @IT IS RESTARTED BY $B0 .(ESCAPE) .FREE .DBUG $B3 $L1C S - STOP DEBUG $P1 @DEBUG HALTS. $B0 @NOTE: ALL BREAKPOINTS ARE CLEARED. $V10 $B3 $V15 $L1C IMPLIED COMMAND TO EXAMINE/CHANGE CORE ADDRESSES $P1 @THIS COMMAND ACCEPTS THE FOLLOWING INSTRUCTIONS:- $A INDENT=2 @NOTE .'N' AND .'M' REPRESENT NUMBERS INPUT IN OCTAL. $B0 .N $T4 : PRINTS CONTENTS OF .N. $B0 .N+C $T4 : PRINTS CONTENTS OF .(N+ PROGRAM BASE). $B0 .N+I $T4 : PRINTS CONTENTS OF .(N+ .IMP .STK BASE). $B0 .N+RM $T4 : PRINTS CONTENTS OF .(N+REGISTER .M) $B1 .N(+ OPTIONS)=M $T4 : PUTS .M INTO .N $A INDENT=1 $B2 EG: .DEBUG:100 (CR) - WILL PRINT CONTENTS OF LOCN 100. $B0 $C+4 .DEBUG:100+R5 (CR) - WILL PRINT CONTENTS OF 100 ON FROM REG. 5. $B0 $C+4 .DEBUG:100+R5=200 (CR) - DITTO, EXCEPT PLANTS 200. $B0 .NOTES $A INDENT=1 $B1 @AN .'*N' AT THE END OF THE COMMAND WILL CAUSE THE FOLLOWING .'N' LOCATIONS TO BE DUMPED OUT .('N' MAY BE NEGATIVE). $B1 '+' OR .'+=M' MAY BE ENTERED AS A NEW COMMAND, THIS TAKES THE LAST LOCATION USED AND STEPS IT UP BY 2 (-2 IF '-' IS USED). $N $N $L3CM APPENDIX 3 LISTING OF THE KERNEL OF THE SECOND SYSTEM $A UND=0 $L0C %CONTROL K'100001'; ! 'SYSTEM' ROUTINE ENTRY+MUL+TRUSTED %PERMROUTINESPEC SVC %PERMINTEGERMAPSPEC INTEGER(%INTEGER X); ! USED IN INIT %RECORDFORMAT DUMMY(%INTEGER X) %CONSTRECORD (DUMMY) %NAME NULL=0 %BEGIN %CONSTINTEGER TASK LOW LIMIT=30 %CONSTINTEGER TASK LIMIT=50 %CONSTINTEGER FREE CELLS=50 %CONSTINTEGER NO OF SERVICES=50 %CONSTINTEGER NO OF INTS=10 %CONSTINTEGER FRAG NO=30 %CONSTINTEGER PSECT LENGTH=47 %CONSTINTEGER SVC LIMIT=16 %CONSTINTEGER INT LIMIT=-7 %CONSTINTEGER K SEG LIMIT=50 %CONSTINTEGER TTID=30; ! TASK LO LIMIT %CONSTINTEGER DKID=31; ! " " " +1 %CONSTINTEGER DIRID=32; ! " " " +2 %CONSTINTEGER LOADID=33; ! " " " +2 %CONSTINTEGER MOTHER=34; ! " " " +3 %CONSTINTEGERNAME PS=K'177776'; ! STATUS WORD %CONSTINTEGERNAME STACK LIMIT=K'177774' %RECORDFORMAT EF(%RECORD (EF) %NAME LINK, %INTEGER ID, A1) %RECORDFORMAT QF(%RECORD (EF) %NAME E) %RECORDFORMAT TF(%RECORD (TF) %NAME LINK, %INTEGER ID, T) %RECORDFORMAT KSEGF(%INTEGER USE, DADD, PAR, PDR) %RECORDFORMAT KSEGLF(%RECORD (KSEGLF) %NAME L, %INTEGER B, C, D) %RECORDFORMAT UREGSF(%INTEGER R0, R1, R2, R3, R4, R5, PC, %C PS, SP) %RECORDFORMAT SEGF(%INTEGER PAR, PDR, %RECORD (KSEGF) %NAME KSL, %C %INTEGER USE) %RECORDFORMAT PSECTF(%BYTEINTEGER ID, STATE, %C %BYTEINTEGERARRAY NAME(0:3), %C %BYTEINTEGER PRIO, %RECORD (QF) POFFQ, %C %RECORD (UREGSF) URS, %INTEGER TRAPV, %C %RECORD (SEGF) %ARRAY SEG(0:7)) %RECORDFORMAT PSTF(%RECORD (PSECTF) %NAME P) %RECORDFORMAT PF(%BYTEINTEGER SERVICE, REPLY, %C %INTEGER A1, A2, A3) %RECORDFORMAT P2F(%INTEGER D, A1, A2, A3) %RECORDFORMAT MAINPF(%RECORD (MAINPF) %NAME L, %RECORD (P2F) P) %RECORDFORMAT STOREF(%INTEGER LEN, BLOCK NO) %RECORDFORMAT ADDRFN(%RECORD (ADDRFN) %NAME PSECTA, LAST32, COREA) %CONSTRECORD (ADDRFN) %NAME ADDS=K'120' %RECORDFORMAT D1F(%INTEGER X) %RECORDFORMAT D2F(%RECORD (QF) %NAME X) %RECORD (EF) %NAME E %RECORD (TF) %NAME T, T2, TN, TB %RECORD (PSECTF) %NAME PSECT, PSECT2, PSECTN, PSECT3 %RECORD (SEGF) %NAME SEG1, SEG2 %RECORD (KSEGF) %NAME KS1, KS2 %RECORD (KSEGLF) %NAME KL %RECORD (KSEGLF) %NAME FREE SEGL %RECORD (QF) %ARRAY CPUQ(0:7) !* %RECORD (PF) PX %RECORD (PF) %NAME P, Q %RECORD (P2F) %NAME P2, Q2 %RECORD (MAINPF) %NAME MAINP, MP2 %RECORD (QF) %NAME FREE PARAM %RECORD (QF) TIME Q; ! HEAD OF TIMER LIST %INTEGER QU, SERVICE, TICKS, LEN, I, PT, L2, BLOCK, S, ID %RECORD (D1F) %NAME D1 %RECORD (D2F) D2 %RECORD (PSTF) %ARRAY PSECTA(TASK LOW LIMIT:TASK LIMIT) %RECORD (EF) %ARRAY ONQ(TASK LOW LIMIT:TASK LIMIT) %RECORD (TF) %ARRAY ONTMQ(TASK LOW LIMIT:TASK LIMIT) %RECORD (MAINPF) %ARRAY PARAMS(0:FREE CELLS) %RECORD (STOREF) %ARRAY STORE(0:FRAG NO) %RECORD (STOREF) %NAME ST1 %RECORD (KSEGLF) %ARRAY KSEGL(1:K SEG LIMIT) %RECORD (P2F) %ARRAY LAST THIRTY2(0:31); %OWNINTEGER LAST=0 %OWNBYTEINTEGERARRAY SER MAP(INT LIMIT:NO OF SERVICES)= %C 0, 0, 0, MOTHER, DKID, TTID, TTID, 0, TTID, 0, DKID, DIRID, LOADID, 0, MOTHER, 0(43) %CONSTINTEGER FAULT SER=-4 !! TU 16 INT = -5 !! DQS11 TX INT = -6 !! DQS11 RX INT = -7 %EXTERNALINTEGERFNSPEC RUN(%RECORD (PSECTF) %NAME PSECT) %ROUTINESPEC INITIALISE %ROUTINESPEC FILL SEG(%RECORD (SEGF) %NAME SEG, %C %RECORD (KSEGF) %NAME KS, %INTEGER PAR, PDR) !* %ROUTINESPEC PUSH(%RECORD (QF) %NAME Q, %RECORD (EF) %NAME E) %RECORD (EF) %MAPSPEC POP(%RECORD (QF) %NAME Q) %ROUTINESPEC SCHEDULE %ROUTINESPEC DEALLOCATE(%RECORD (KSEGF) %NAME KS) %ROUTINESPEC FAULT(%INTEGER I) !*********************************************** !* SUPERVISOR STATES * !*********************************************** %CONSTINTEGER IDLE ST=-1 %CONSTINTEGER TASK ST=0 !********************************************** !* TASK STATES * !********************************************** %CONSTINTEGER T WAIT=1 %CONSTINTEGER T POFF=2 %CONSTINTEGER T TIME=4 %CONSTBYTEINTEGER T CPUQ=8 %CONSTBYTEINTEGER T RUN=16 %CONSTBYTEINTEGER T SUSP=K'200' !*********************************************** !* SVC SERVICES (BY EMT VALUE) * !*********************************************** %CONSTINTEGER INTERRUPT=-1 %CONSTINTEGER WAIT=1 %CONSTINTEGER PON R=2 %CONSTINTEGER POFF R=3 %CONSTINTEGER INSERT=4 %CONSTINTEGER DELETE=5 %CONSTINTEGER ALLOCATE CORE=6 %CONSTINTEGER FREESP=7 %CONSTINTEGER SET TIME=8 %CONSTINTEGER SCHEDULE T=9 %CONSTINTEGER MAP VIRT=10 %CONSTINTEGER GET ABS=11 %CONSTINTEGER GET ID=12 %CONSTINTEGER LINKIN=13 %CONSTINTEGER MAP SHARED=14 %CONSTINTEGER MAP HREGS=15 %CONSTINTEGER MAP PSECT=16 !************************************************ !* STATIC CORE LOCATIONS * !************************************************ %CONSTINTEGERNAME INT VALUE=K'40' %CONSTINTEGERNAME SUPER =K'42' %CONSTINTEGERNAME ALARM F=K'44' %CONSTINTEGERNAME S ENTRY=K'46' %CONSTINTEGERNAME PSECT AREA=K'50' %CONSTINTEGERNAME FAULT TYPE=K'52' !************************************************* %SWITCH SER(-1:SVC LIMIT) %OWNINTEGERARRAY PRESET(0:234)= %C 0,M'TT',M' ',4,0,0(6),K'20210',K'140200',K'120200',0,0(32), 0,M'KD',M' ',4,0,0(6),K'20210',K'140200',K'120200',0,0(32), 0,M'ID',M'TR',3,0,0(6),K'20210',K'140140',K'120200',0,0(32), 0,M'OL',M'DA',1,0,0(6),K'20032',K'140040',K'120300',0,0(32), 0,M'OM',M'HT',3,0,0(6),K'20032',K'140040',K'120200',0,0(32) !*************************************************** !* START OF CODE PROPER * !*************************************************** INITIALISE; ! HELD IN DE-ALLOCATABLE SPACE !***************************************************** !* BASIC LOOP IS CPU SCHEDULER * !***************************************************** %CYCLE E==NULL %CYCLE QU = 7, -1, 0 %IF %NOT CPUQ(QU)_E==NULL %START E==POP(CPUQ(QU)) %EXIT %FINISH %REPEAT %IF E==NULL %START; ! IDLE SUPER=IDLE ST; ! MARK SUPERVISOR IN IDLE PS=0; ! SET PRIO=ZERO IDLE LP: *1; ! EXECUTE 'WAIT' ->IDLE LP %FINISH !* FOUND PROCESS, SO SCHEDULE PSECT==PSECTA(E_ID)_P; ! MAP 'PSECT' TO ACTUAL SPACE GO: %IF PSECT_STATE&T SUSP#0 %THENCONTINUE; ! DON'T RUN IT SUPER=TASK ST; ! GOING INTO 'USER' PROCESS PSECT_STATE=T RUN SERVICE=RUN(PSECT); ! EXTERNAL ->SER(SERVICE) %IF SERVICE<=SVC LIMIT FAULT TYPE=5 ERROR: INT VALUE=FAULT SER SER(INTERRUPT): ; ! DEVICE INTERRUPT %IF INT VALUE#FAULT SER %START SCHEDULE %UNLESS SUPER=IDLE ST %ELSE PX_A2=PSECT_ID PX_A3=FAULT TYPE %FINISH ->CLOCKINT %IF INT VALUE=0 ID=SER MAP(INT VALUE) PX_SERVICE=INT VALUE PX_REPLY=0; ! INTERRUPT PX_A1=INT VALUE; ! REMOVE IN DUE COURSE P2==PX; P==P2 !* AND SEND IT !! SEND MESS TO RELEVANT TASK ->DO PON SER(WAIT): PSECT_STATE=T WAIT %CONTINUE; ! FIND SOMETHING ELSE SER(PON R): SCHEDULE P2==PSECT_URS; ! MAP PARAM AREA TO HIS REGS P==P2 !* NOW PLANT ON Q !* AND SCHEDULE PROCESS IF NECESSARY S=P_SERVICE; ! PICK UP THE ROUTING ID=SER MAP(S); ! AND FIND THE OWNING PROCESS DO PON: PSECT3==PSECTA(ID)_P; ! PSECT OF RECEIVING MESSAGE FAULT TYPE=6 %AND ->ERROR %IF PSECT3==NULL %OR ID=0 PSECT==PSECT3 Q==PSECT_URS; Q2==Q %IF PSECT_STATE&T POFF#0 %START; ! WAITING FOR POFF %IF Q_SERVICE=0 %OR Q2_D=P2_D %START PON EXECUTE: Q2 == PSECT_URS Q2 = P2 LAST THIRTY2(LAST)=P2; LAST=(LAST+1)&31 SCHEDULE %CONTINUE %FINISH %FINISH MAINP==FREE PARAM; ! PICK UP NEW PARAM CELL FREE PARAM==MAINP_L; ! RELINK FREE LIST MAINP_P = P2 PUSH(PSECT_POFFQ, MAINP); ! PUT ON TASK POFF Q %CONTINUE SER(POFF R):; ! USER POFF %UNLESS PSECT_POFFQ_E==NULL %START; ! Q NON ZERO MP2==PSECT_POFFQ_E; ! GET LAST ENTRY Q==PSECT_URS; Q2==Q %UNTIL MP2==MAINP %CYCLE; ! CYCLE WHOLE Q MAINP==POP(PSECT_POFFQ) P==MAINP_P; P2==P %IF Q_SERVICE=0 %OR Q2_D=P2_D %START MAINP_L==FREE PARAM; FREE PARAM==MAINP; ! RELINK ON Q ->PON EXECUTE %FINISH PUSH(PSECT_POFFQ, MAINP) %REPEAT %FINISH PSECT_STATE=T POFF %CONTINUE SER(SCHEDULE T): ! R0 IS ID OF TASK TO BE SCHEDULED SCHEDULE; ! RE-SCHEDULE CALLER PSECT==PSECTA(PSECT_URS_R0)_P FAULT(7) %IF PSECT==NULL SCHEDULE %CONTINUE SER(DELETE): ! DELETE THE RUNNING TASK %IF PSECT_ID=LOADID %START SCHEDULE; ! RE-SCHEDULE LOADER PSECT==PSECTA(PSECT_URS_R0)_P %FINISH %CYCLE; ! CLEAR OUT THE POFF Q MAINP==POP(PSECT_POFFQ) %EXITIF MAINP==NULL MAINP_L==FREE PARAM; FREE PARAM==MAINP %REPEAT %CYCLE I=7, -1, 0; ! GO DOWN THE SEGS KS1==PSECT_SEG(I)_KSL %UNLESS KS1 == NULL %START KS1_USE=KS1_USE-1 DEALLOCATE(KS1) %IF KS1_USE=0 %FINISH %REPEAT PSECTA(PSECT_ID)_P==NULL %REPEAT; ! OF MAIN LOOP CLOCKINT: ! CLOCK HAS OVERFLOWED !* SEND MESSAGE TO FIRST TASK ON Q !* SET CLOCK TO NEXT TIME TN==POP(TIME Q) %UNLESS TIMEQ_E==NULL %THEN ALARM F=TIMEQ_E_A1 ID=TN_ID PX_SERVICE=ID; PX_REPLY=0 P2==PX; TN_T=0 ->DO PON SER(SET TIME): ! SET TIMER FOR URS_R0 TICKS ID=PSECT_ID %IF ONTMQ(ID)_T#0 %THEN FAULT(6); ! ON Q ALREADY TN==ONTMQ(ID) TICKS=PSECT_URS_R0; ! NO OF TICKS TB==TIMEQ_E; ! LAST ENTRY ->BOT %IF TB==NULL %IF TB_LINK==TB %THEN T==TB %ELSE T==TB_LINK T_T=ALARM F; ! ADJUST FOR TIME PAST T2==TB %CYCLE; ! CHECK THE LIST %IF TICKSGO; ! IMMEDIATE RESCHEDULE SER(ALLOCATE CORE): PT= -1 %IF PSECT_ID <= LOADID %START LEN=PSECT_URS_R0; ! CORE REQUIRED IN BLOCKS PSECT_URS_R0=0; ! URS_R1 IS THE NEW SEG PT=-1; L2=0 %CYCLE I=FRAG NO, -1, 0 %IF STORE(I)_LEN>LEN %AND STORE(I)_LEN>L2 %THEN %C PT=I %AND L2=STORE(I)_LEN %REPEAT %FINISH %IF PT=-1 %THEN ->GO; ! NO CORE ST1==STORE(PT) BLOCK=ST1_BLOCK NO; ! ADDRESS OF BLOCK (IN BLOCKS) %IF L2>LEN %START; ! EXCESS, SO TRIM ST1_BLOCKNO=ST1_BLOCK NO+LEN ST1_LEN=ST1_LEN-LEN %ELSE E=0 KL==FREE SEGL FAULT(12) %IF KL==NULL; ! NO FREE SEGMENT CELLS FREE SEGL==KL_L KS1==KL; ! MAP THE 'REAL' TYPE ON KS1_USE=0; ! 'SHARED' WILL MAKE IT '1' KS1_PAR=BLOCK; KS1_PDR=(LEN-1)<<8!6 SEG1==PSECTN_SEG(PSECT_URS_R1) PSECT_URS_R0=BLOCK ->DO SHARED; ! FILL HIS SEG ENTRY SER(MAP VIRT): ! MAP USER A TO B ! R0 = TARGET ID ! R1 = TARGET SEG ! R2 = CALLERS SEG ! R1 = -1 SIGNIFIES DROP SEG S=0 %IF PSECT_ID=LOADID %THEN S=6 SEG1==PSECT_SEG(PSECT_URS_R2); ! GET CALLERS SEG %IF PSECT_URS_R1<0 %START; ! DROP SEGMENT KS1==SEG1_KSL %IF KS1==NULL %THEN FAULT(10); ! NO SEG KS1_USE=KS1_USE-1 %IF KS1_USE=0 %THEN DEALLOCATE(KS1) SEG1=0; ! ZERO CALLERS ENTRY %ELSE !! MAP TO DESIRED SEG PSECT2==PSECTA(PSECT_URS_R0)_P FAULT(4) %IF PSECT2==NULL KS1==PSECT2_SEG(PSECT_URS_R1)_KSL DO SHARED: FAULT(13) %IF KS1==NULL SEG1_PAR=KS1_PAR; SEG1_PDR=KS1_PDR!S SEG1_KSL==KS1 KS1_USE=KS1_USE+1 %FINISH ->GO SER(GET ABS): ! GET ABSOLUTE ADDR OF VIRT SEG ! R0 = TARGET ID ! R1 = TARGET SEG ! R2 = 0 (DROP SEG) = 1 (GET SEG) PSECT2==PSECTA(PSECT_URS_R0)_P FAULT(5) %IF PSECT2==NULL SEG1==PSECT2_SEG(PSECT_URS_R1) KS1==SEG1_KSL %IF PSECT_URS_R2#0 %START PSECT_URS_R0=SEG1_PAR PSECT_URS_R1=SEG1_PDR KS1_USE=KS1_USE+1 %ELSE KS1_USE=KS1_USE-1 %IF KS1_USE=0 %THEN DEALLOCATE(KS1) %FINISH ->GO SER(GET ID): ! RETURN ID OF TASK IN R0 PSECT_URS_R0=PSECT_ID ->GO SER(LINKIN): ! R0 IS REQUIRED SERVICE SER MAP(PSECT_URS_R0)=PSECT_ID ->GO SER(MAP SHARED): ! R0 IS ID, R1=SEG, R2=SHARED NO PSECT2==PSECTA(PSECT_URS_R0)_P FAULT(8) %IF PSECT2==NULL SEG1==PSECT2_SEG(PSECT_URS_R1) KS1==PSECT_SEG(1)_KSL; S=2 ->DO SHARED SER(INSERT): ! ALLOCATE A NEW PSECT (AND MAP TO R0?) %CYCLE ID=TASK LOW LIMIT, 1, TASK LIMIT %EXIT %IF PSECTA(ID)_P==NULL %REPEAT D1==D2; ! DUMMY FORMATS TO STUFF ADDRESS D1_X=PSECT AREA+(ID-MOTHER-1)<<7 !! SHOULD BE *(PSECT LENGTH*2) PSECTA(ID)_P==D2_X PSECT2==D2_X; ! MAP TO ARRAY AND PSECT2 PSECT2_ID=ID SEG1==PSECT_SEG(PSECT_URS_R0); ! MAP TO LOADER PSECT SEG1_PAR=D1_X>>6; SEG1_PDR=1<<8!6; ! 2 SEGS, READ/WRITE SER MAP(ID)=ID; ! MAP HIS MAIN SERVICE IN PSECTN==PSECT2; ! FOR USE WITH GET CORE ->GO; ! RESTART LOADER SER(MAP HREGS): ! MAP HARDWARE REGS TO SEG R0 SEG1==PSECT_SEG(PSECT_URS_R0) SEG1_PAR=K'7600'; SEG1_PDR=K'77406'; SEG1_KSL==NULL ->GO SER(MAP PSECT): ! MAP PSECT 'R0' TO SEG IN R1 I=PSECT_URS_R1 ID=PSECT_URS_R0 SEG1==PSECT_SEG(I); SEG1=0 PT=0 %IF PSECT_ID=LOADID %THEN S=2<<8!6 %ELSE S=2<<8!2 D2_X==PSECTA(ID)_P %UNLESS D2_X==NULL %START SEG1_PAR=D1_X>>6; ! MAP TO THE START OF ITS BLOCK SEG1_PDR=S; ! ACCESS DEPENDS ON TASK PT=I<<13!(D1_X&K'77'); ! POINT R0 TO ITS BEGINNING %FINISH PSECT_URS_R0=PT ->GO %ROUTINE PUSH(%RECORD (QF) %NAME Q, %RECORD (EF) %NAME E) %IF Q_E==NULL %THEN E_LINK==E %ELSESTART E_LINK==Q_E_LINK Q_E_LINK==E %FINISH Q_E==E %END %RECORD (EF) %MAP POP (%RECORD (QF) %NAME Q) %RECORD (EF) %NAME E %IF Q_E==NULL %THEN %RESULT==NULL E==Q_E_LINK %IF %NOT E==Q_E %START; ! ONE ITEM ONLY Q_E_LINK==E_LINK %ELSE E==Q_E Q_E==NULL %FINISH %RESULT == E %END %ROUTINE SCHEDULE PSECT_STATE=(PSECT_STATE&T SUSP)!T CPUQ PUSH(CPUQ(PSECT_PRIO), ONQ(PSECT_ID)) %END %ROUTINE DEALLOCATE(%RECORD (KSEGF) %NAME KS) %RECORD (STOREF) %NAME S, S2, S3 %RECORD (KSEGLF) %NAME KSL %INTEGER I, BOT, BLOCK, LEN BLOCK=KS_PAR; LEN=KS_PDR>>8+1 BOT=BLOCK+LEN; S2==NULL %CYCLE I=FRAG NO, -1, 0 S==STORE(I) %IF S_BLOCK NO+S_LEN=BLOCK %START %IF S2==NULL %START S_LEN=S_LEN+LEN; ! ADD IT ON THE BOTTOM S2==S; ! REMEMBER IT %ELSE S_LEN=S_LEN+S2_LEN S2_BLOCK NO=0; S2_LEN=0 %EXIT %FINISH %ELSE %IF S_BLOCK NO=BOT %START %IF S2==NULL %START; ! NOT FOUND THE UPPER HALF S_BLOCK NO=BLOCK; S_LEN=S_LEN+LEN S2==S; ! MARK FOUND %ELSE S_BLOCK NO=S2_BLOCK NO S_LEN=S_LEN+S2_LEN S2_BLOCK NO=0; S2_LEN=0 %EXIT %FINISH %FINISH %FINISH %IF S_BLOCK NO=0 %THEN S3==S; ! REMEMBER EMPTY SLOT %REPEAT %IF S2==NULL %START S3_BLOCK NO=BLOCK; S3_LEN=LEN %FINISH KSL==KS KSL_L==FREE SEGL FREE SEGL==KSL; ! MAP SEG ENTRY BACK TO FREE LIST %END %ROUTINE FAULT(%INTEGER I) *K'016500'; *2; ! MOV 2(LNB),R0 *0 %END %ROUTINE INITIALISE %RECORDFORMAT SF(%INTEGERARRAY SEG(0:7)) %CONSTRECORD (SF) %NAME K PAR=K'172340' %CONSTRECORD (SF) %NAME K PDR=K'172300' %CONSTRECORD (SF) %NAME U PAR=K'177640' %CONSTRECORD (SF) %NAME U PDR=K'177600' %CONSTINTEGERNAME SR0=K'177572' %CONSTINTEGERNAME SR2=K'177576' %CONSTINTEGERNAME CLOCK V=K'177546' %RECORDFORMAT DEDLOC F(%INTEGERARRAY D(0:4)) %CONSTRECORD (DEDLOCF) %NAME DEDLOC=K'60000' %INTEGER I, PT, BASE, TOP CORE, ID, TOP, PERM, PERML, STK, TC %INTEGER KST, STKL %RECORDFORMAT D1F(%INTEGERNAME X) %RECORDFORMAT D2F(%RECORD (QF) %NAME X) %RECORD (D1F) %NAME D1 %RECORD (D2F) D2 K PAR=0; K PDR=0 %CYCLE I=0, 1, 6 K PAR_SEG(I)=I<<7; K PDR_SEG(I)=K'77406' %REPEAT K PAR_SEG(7)=K'7600'; ! MAP TO HARDWARE VECTORS K PDR_SEG(7)=K'77406' UPAR=0; UPDR=0 SR0=1; ! GET IT GOING PS=K'340'; ! ENSUE UNINTERRUPTABLE CLOCKV=K'100' !! STACK LIMIT=K'400' D1==D2 KST=2 CPUQ(I)=0 %FOR I=0, 1, 7 LAST THIRTY2(I)=0 %FOR I=0,1,31 SUPER=IDLE ST ALARM F=0 %FOR I=TASK LOW LIMIT, 1, TASK LIMIT %CYCLE PSECTA(I)_P==NULL ONQ(I)=0; ONQ(I)_ID=I ONTMQ(I)=0; ONTMQ(I)_ID=I %REPEAT ID=TASK LOW LIMIT PERM=DEDLOC_D(3)>>6; ! PICKUP ADDR OF PERM TOP=DEDLOC_D(5)>>6 PERML=((TOP-PERM-1)<<8)&K'177400'!2; ! READ ONLY TOP CORE=DEDLOC_D(0); TC=TOP CORE %CYCLE I=TOP CORE, 2, K'137336' %IF I=K'60000' %THEN I=K'60060' INTEGER(I)=0 %REPEAT PSECT AREA=TOP CORE TOP CORE=TOP CORE+K'200'*10; ! ONLY 10 TASKS????? I=5 %CYCLE %EXITIF DEDLOC_D(I)=TC D1_X==PRESET(PT) PSECTA(ID)_P==D2_X PSECT==D2_X PSECT_ID=ID PT=PT+PSECT LENGTH BASE=DEDLOC_D(I)>>6 STK=DEDLOC_D(I+1)>>6 TOP=DEDLOC_D(I+2)>>6 FILL SEG(PSECT_SEG(2), KSEGL(KST), BASE, (STK-BASE-1)<<8!6) KST = KST+1; ! FILL IN CODE ADDRESS FILL SEG(PSECT_SEG(6), KSEGL(KST), STK, (TOP-STK-1)<<8!6) KST = KST+1; ! FILL IN STACK AREA PSECT_SEG(7)_PAR=K'7600' PSECT_SEG(7)_PDR=K'77406' SER MAP(ID)=ID PSECT_SEG(1)_PAR=PERM; PSECT_SEG(1)_PDR=PERML PSECT_SEG(1)_KSL==KSEGL(1) PSECT_URS_R1=K'140000'; ! VIRT ADD OF TOP OF STK PSECT_URS_SP=K'140000'+(TOP-STK)<<6 %IF ID>=LOADID %START FILL SEG(PSECT_SEG(7), KSEGL(KST), %C TOP CORE>>6, K'13'<<8!6); ! FILL IN I/O SEG TOP CORE=TOP CORE+K'1400'; KST=KST+1 PSECT_URS_R2=2; ! INDICATE LOADER TO PERM INTEGER(STK<<6+4)=X'0A41'; ! A,NL PSECT_URS_R0=K'140004'; ! POINTS TO ABOVE %FINISH SCHEDULE I=I+2; ID=ID+1 %REPEAT I=TOP CORE>>6 STORE(0)_BLOCK NO=I STORE(0)_LEN=K'2000'-I ADDS_PSECTA==PSECTA(TASK LOW LIMIT) ADDS_LAST32==LAST THIRTY2(0) ADDS_COREA==STORE(0) PARAMS(I)_L==PARAMS(I+1) %FOR I=0, 1, FREE CELLS-1 FREE PARAM==PARAMS(0) %CYCLE I=KST, 1, K SEG LIMIT-1 KSEGL(I)=0 KSEGL(I)_L==KSEGL(I+1) %REPEAT FREE SEGL==KSEGL(KST) KS1==KSEGL(1) KS1_PAR=PERM; KS1_PDR=PERML KS1_USE = 10 K PDR_SEG(I)=0 %FOR I=3, 1, 6 %END %ROUTINE FILL SEG(%RECORD (SEGF) %NAME SEG, %RECORD (KSEGF) %NAME KS, %C %INTEGER PAR, PDR) SEG_PAR=PAR; SEG_PDR=PDR; SEG_KSL==KS KS_USE=1 KS_PAR=PAR; KS_PDR=PDR KS_DADD=0 %END %ENDOFPROGRAM $B2 $A TAB=5, 10 $A JUST=1; LINE=69; PAGE=54; TOP=5; BOTTOM=7 $A NLS=2 $L1CM REFERENCES $B1 $A INDENT=1 $I0 1 $T+1 .F$. .J$. @CORBATO, .C$. .T$. @CLINGEN, .J$. .H$. @SALTER, .'MULTICS, @THE @FIRST @SEVEN @YEARS', @PROCEEDINGS OF THE 1972 .AFIPS .SJCC. $I0 2 $T+1 @SOFTWARE @ENGINEERING, @ED$. .P$. @NAUR AND .B$. @RANDELL, 1969. $I0 3 $T+1 .W$. .F$. .C$. @PURSER, '@THE @DESIGN OF A @REAL-TIME @OPERATING @SYSTEM FOR A @MINICOMPUTER', @SOFTWARE @PRACTICE AND @EXPERIENCE, 5, @NO 2, 147-167 (1975) $I0 4 $T+1 @F$. @P$. @BROOKS, '@MYTHICAL @MAN @MONTH' $I0 5 $T+1 @F$. @J$. @CORBATO, .'PL/1 AS A @TOOL FOR @SYSTEMS @PROGRAMMING', @DATAMATION 15 @NO. 6, 68-76 (1969) $I0 6 $T+1 @E$. @I$. @ORGANICK, '@COMPUTER @SYSTEM @ORGANISATION' $I0 7 $T+1 @C$. @ADAMS, '@ARCHITECTURE AND @PERFORMANCE @EVALUATION OF .EMAS', (@TO APEAR IN @SEMINARS ON @MODELLING AND @PERFORMANCE @EVALUATION AT .I$.R$.E$.I$.A$. 1975) $I0 8 $T+1 @FERRANTI, '@ARGUS 700 @REFERENCE @MANUAL' $I0 9 $T+1 @P$. @ROBERTSON, '@ON THE @PRODUCTION OF @OPTIMISED @CODE FROM A @TRANSPORTABLE @COMPILER FOR @HIGH @LEVEL @LANGUAGES', (A @PH$.@D$. @THESIS TO BE PUBLISHED). $I0 10 $T+1 @C$. @ADAMS AND @G$. @E$. @MILLARD, '@PERFORMANCE @MEASURMENT ON THE @EDINBURGH @MULTI @ACCESS @SYSTEM', @PROCEEDINGS @INTERNATIONAL @COMPUTING @SYMPOSIUM @JUNE 1975. $I0 11 $T+1 @P$. @D$. @STEPHENS, '@THE .IMP @LANGUAGE AND @COMPILER', @COMPUTER @JOURNAL @VOL 17 @NO 3. $I0 12 $T+1 @H$. @WHITFIELD, @A$. @S$. @WIGHT, .'EMAS - @THE @EDINBURGH @MULTI @ACCESS @SYSTEM', @COMPUTER @JOURNAL @VOL 16 @NO 4. $I0 13 $T+1 @D$. @J$. @REES, '@THE .EMAS @DIRECTOR', @COMPUTER @JOURNAL $I0 14 $T+1 .PDP 11/40 @HANDBOOK, @DIGITAL @EQUIPMENT @CORPORATION. $I0 15 $T+1 @D$. @L$. @MILLS, '@PROPOSAL FOR A @MULTI @PROGRAMMING @SYSTEM FOR A .PDP 11', (@JUNE 1971). $I0 16 $T+1 @D$. @L$. @MILLS, '@MULTI-PROGRAMMING IN A @SMALL @SYSTEMS @ENVIRONMENT', @UNIVERSITY OF @MICHIGAN, @TECHNICAL @REPORT 19. $I0 17 $T+1 '@THE .UNIX @TIME @SHARING @SYSTEM', @COMM OF THE .ACM, @SYMPOSIUM ON @OPERATING @SYSTEMS, @OCTOBER 15-17 1973. $I0 18 $T+1 @R$. @B$. @JOHN, '@THE DESIGN OF @SYSTEMS FOR @TELECOMMUNICATIONS BETWEEN @SMALL AND @LARGE @COMPUTERS', @PH$. @D$. THESIS, @UNIVERSITY OF @EDINBURGH 1973. $I0 19 $T+1 @P$. @M$. @WOODWARDET$. AL$., '@DEFINITION OF .CORAL 66', @H$. @M$. @S$. @O$.. $I0 20 $T+1 @I$. @C$. @L$., '@SYSTEM .B @ARCHITECTURE', .SID .D100 $I0 21 $T+1 @E$. @W$. @DIJKSTRA, '@CO-OPERATING @SEQUENTIAL @PROCESSES', @PROGRAMMING @LANGUAGES (ED$. @F$. @GENVYS) @ACEDEMIC @PRESS 1968. $I0 22 $T+1 @M$. @M$. @BARRITT ET$. AL$., '@THE .IMP @LANGUAGE @MANUAL', @EDINBURGH @REGIONAL @COMPUTING @CENTRE, 1970 $I0 23 $T+1 .GEC-@ELLIOTT @AUTOMATION @LTD., @BABBAGE @USER @MANUAL 1972 $I0 24 $T+1 @N$. @WIRTH, .'PL360 @A @PROGRAMMING @LANGUAGE FOR THE 360 COMPUTERS', @JOURNAL OF THE .ACM @VOL 5 @NO 1 @JAN 1968 $I0 25 $T+1 @H$. @DEWAR, .'HAL 7502', @DEPARTMENT OF @COMPUTER @SCIENCE, @EDINBURGH @UNIVERSITY, 1975 $N $L1CM ACKNOWLEDGEMENTS $P2 @THERE HAVE BEEN TOO MANY PEOPLE WHO HAVE HELPED IN ONE WAY OR ANOTHER AND IT IMPOSSIBLE TO MENTION THEM ALL INDIVIDUALLY. @HOWEVER, SPECIFIC THANKS ARE DUE TO @DAVE @MILLS, @NICK @SHELNESS AND @PROFESSOR @S$. @MICHAELSON WHO HAVE BEEN VERY PATIENT AND HELPFUL AS SUPERVISORS, ALSO TO @PETER @ROBERTSON FOR HIS .IMP COMPILER, AND FINALLY TO @DR$. .J$. @G$. @BURNS FOR THE ENCOURAGEMENT AND HELP HE GAVE TO THE AUTHOR. $N $E