$A JUST=1; LINE=76; PAGE=58; TOP=3; BOTTOM=4; MARK=2
$A PAGENO=1
$A TAB=5,15,25
$B20
$L2CM
USER MANUAL FOR DEIMOS
AN OPERATING SYSTEM FOR THE PDP 11
$B2
$L1CM
B. GILMORE 
$L2CM
AUGUST 1976
REVISED MAY 1978
$N
$L1CUM
CONTENTS
$B6
$A INDENT=1
.%TITLE $T6 .%PAGE
$B1 @GENERAL FEATURES $T6 3
$B1 @SYSTEM COMMANDS. $T6 7
$B1 @GENERAL @PURPOSE @PROGRAMMES
$A INDENT=2
$B0 @THE .EDITOR. $T6 10
$B0 @THE .IMP COMPILER. $T6 11
$B0 @THE .LINKER. $T6 12
$B0 @LIBRARY MANIPULATION. $T6 14
$B0 @THE DEBUGGING PROGRAM. $T6 15
$A INDENT=1
$B1 @SYSTEM @FAULT @MESSAGES. $T6 19
$A INDENT=0
$N
$L1CM
GENERAL FEATURES
$B3
%@DESIGN %@AIMS
$P1 .DEIMOS WAS DESIGNED FOR OPERATION IN A MEDIUM
SIZED .PDP 11. @AT LEAST 16K WORDS OF CORE, A MEMORY MANAGEMENT UNIT,
A DISC OR SIMILAR FAST MASS STORAGE DEVICE, A TERMINAL AND A CLOCK ARE
REQUIRED.
$P1 @THE SYSTEM WAS DESIGNED WITH SIX MAIN AIMS:
$A INDENT=1
$B1
%@RUNNING %USER %PROGRAMS
$P0 @THE SYSTEM IS DESIGNED TO RUN GENERAL USER
PROGRAMS. @NORMALLY,
 ABOUT TWENTY SIMULTANEOUS PROGRAMS ARE SUPPORTED,
BUT THIS FIGURE IS A PARAMETER AT SYSTEM
GENERATION. @EACH PROGRAM
RUNS IN ITS OWN VIRTUAL MEMORY ENVIRONMENT .(VM), NOT
NECESSARILY LIMITED TO THE HARDWARE'S MAPPING LIMIT OF 32K WORDS. @THE
SYSTEM, AND OTHER USER PROGRAMS, SHOULD BE FULLY PROTECTED FROM
THE FAILURE OF A USER PROGRAM.
$B1
%@MULTIPLE %TERMINAL %SUPPORT
$P0 @THE SYSTEM  SUPPORTS
MULTIPLE TERMINALS, EACH TERMINAL CAN, OPTIONALLY, BE LINKED TO A
COMMAND LANGUAGE INTERPRETER WHICH WILL ENABLE THE USER TO INITIATE AND
CONTROL PROGRAMS FROM THE TERMINAL.
$B1
$V6
%@PERIPHERAL %SUPPORT
$P0 @THE SYSTEM SUPPORTS A WIDE RANGE
OF PERIPHERALS, EG, LINE PRINTER, CARD READER, PAPER TAPE READER AND 
PUNCH, VARIOUS DISCS, MAGNETIC TAPE,
GRAPH PLOTTER, ASYNCHRONOUS COMMUNICATION LINES
 AND A SYNCHRONOUS COMMUNICATION LINE
RUNNING UNDER 
THE .HDLC PROTOCOL.
@NEW PERIPHERALS CAN BE ADDED WITH MINIMUM
DISTURBANCE TO THE REST OF THE SYSTEM.
$B1
%@SELF %@SUPPORTING
$P0 @THE SYSTEM IS SELF SUPPORTING ON A MEDIUM CORE CONFIGURATION
(APPROX 28K WORDS). @THIS SIZE IS REQUIRED IN ORDER TO RUN THE COMPILER
$B1
%@SWAPPING
$P0 @THE NUMBER AND SIZE OF USER PROGRAMS IS CURRENTLY LIMITED TO
THE PHYSICAL STORE SIZE OF THE MACHINE, A LIMITED SWAPPING
STRATEGY
WILL BE IMPLEMENTED TO SUPPORT A VIRTUAL STORE
SIZE OF TWO TO THREE TIMES THE PHYSICAL STORE SIZE.
$B1 %@MINIMAL %RESIDENT %SECTION
$P0 @THE SIZE OF THE RESIDENT SYSTEM IS KEPT SMALL
TO ALLOW AS MUCH STORE AS POSSIBLE FOR USER PROGRAMS.
$A INDENT=0
$B3
%@CONSTRAINTS
$P1 @THE RESIDENT PART OF THE SYSTEM
HAS BEEN KEPT REASONABLY SMALL
TO ENABLE THE SYSTEM TO RUN IN SMALLER
CORE CONFIGURATIONS. @THIS CONSTRAINT EFFECTS THE OVERALL DESIGN,
DISTINGUISHING IT FROM  SYSTEMS WITH A LARGE SET OF
FACILITIES LIKE .UNIX AND .RSX11D
WHICH REQUIRE AT LEAST 48K WORDS OF CORE TO DO USEFUL WORK.
$B3 $V10 
%@STRUCTURAL %@OVERVIEW
$P1
@THE SYSTEM IS BASED ON THE CONCEPT OF A NUMBER OF TASKS, EACH
OF WHICH MANAGES EITHER A RESOURCE OR A USER PROGRAM,
WHICH COMMNNICATE AND SYNCHRONISE WITH EACH OTHER USING 'MESSAGES'.
@THE CONCEPT OF MESSAGES COMES FROM .EMAS, THE .GEC 4080
AND OTHERS.
$P1 @THE USER INTERFACE IS HEAVILY INFLUENCED BY A NUMBER OF MACHINES
RUNNING IN THE @COMPUTER @SCIENCE DEPARTMENT.
$P1 @THE SYSTEM HAS TWO MAIN SECTIONS, A RESIDENT
SECTION AND A POTENTIALLY SWAPPABLE SECTION.
$B1 @THE RESIDENT SECTION CONSISTS OF A KERNEL AND THE
MASS STORAGE DEVICE HANDLER WHICH RUNS AS AN OTHERWISE STANDARD
SYSTEM TASK.
$B1 $V7 @THE KERNEL PROVIDES THE FOLLOWING SERVICES:
$A INDENT=1
$B0 1) @CONTROLS THE .CPU ALLOCATION.
$B0 2) @PASSES INTERRUPTS TO THEIR DEVICE HANDLERS.
$B0 3) @PASSES MESSAGES BETWEEN TASKS, STORING THEM IF NECESSARY.
$B0 4) @SUPPORTS THE VIRTUAL MEMORIES, INCLUDING MAPPING BETWEEN THEM.
$B0 5) @PROVIDES CLOCK AND TIMER FUNCTIONS.
$B0 6) @CONTROLS CORE ALLOCATION CONTROL.
$A INDENT=0
$P1 @ALL PERIPHERALS AND OTHER SYSTEM FUNCTIONS, E. G.,
 THE FILE STORAGE HANDLER,
COMMAND LANGUAGE INTERPRETER AND LOADER - ARE HANDLED BY SYSTEM
TASKS. @THE SYSTEM TASKS ARE 'PRIVILEGED', THIS ENTITLES THEM TO
ACCESS PARTS OF THE REAL MACHINE AND OTHER TASKS.
$P1 @A NEW TASK IS CREATED WHEN A USER PROGRAM IS RUN AND
IS DELETED ON ITS TERMINATION.
@A TASK CONSISTS OF A VIRTUAL MEMORY ENVIRONMENT AND A 'TASK DESCRIPTOR
BLOCK', HELD WITHIN THE KERNEL. @A TASK 
ON THIS SYSTEM DOES NOT HAVE A 'TASK
MONITOR';
ALL INTERRUPTS AND MESSAGES ARE PROCESSED BY THE TASK IN ITS 'USER'
STATE.
$A INDENT=1
$P1 @THE VIRTUAL MEMORY ENVIRONMENT OF A TASK CONSISTS
OF A NUMBER OF SEGMENTS, THESE SEGMENTS ARE USED TO HOLD
THE PROGRAM CODE, DATA AREAS AND SHARED SYSTEM CODE.
@THE HARDWARE OF THE .PDP11 ALLOWS EIGHT SEGMENTS TO BE MAPPED 
ONTO REAL STORE AT ANY GIVEN TIME, GIVING A VIRTUAL MEMORY ADDRESS
SPACE OF 32K WORDS. @THE NUMBER OF SEGMENTS OWNED BY A TASK IS
NOT LIMITED TO EIGHT.
@A SEGMENT MAY BE MAPPED IN A READ
ONLY OR A READ/WRITE MODE WHICH ALLOWS PROTECTION OF CODE AREAS.
$P1 @THE 'TASK DESCRIPTOR BLOCK' CONTAINS THE REGISTERS
(WHEN THE TASK IS NOT ACTUALLY EXECUTING) AND OTHER INFORMATION
SUCH AS THE STATE, PRIORITY LEVEL AND MESSAGE QUEUE THAT
CONSTITUTES THE CONTEXT OF THE TASK.
$A INDENT=0

$P1 
@THE LIST OF SEGMENTS USED BY ALL TASKS IS
HELD IN A .GLOBAL .SEGMENT .TABLE WITHIN THE
KERNEL, WITH 
THE CORE OR DISC ADDRESS, ACCESS PERMISSION AND
THE NUMBER OF TASKS USING THE SEGMENT. @THIS TABLE
ENABLES THE KERNEL TO MAINTAIN CONTROL OVER THE
USAGE OF SEGMENTS AND CAN EASILY DETERMINE
WHAT PARTS OF TASKS MAY BE SWAPPED OUT. @THE CORE ADDRESS,
ACCESS PERMISSION AND A POINTER INTO THE GLOBAL
SEGMENT TABLE ARE ALSO MAINTAINED WITHIN THE TASK DESCRIPTOR
TO OPTIMISE THE CONTEXT SWITCH.
$P1 @IF A TASK FAILS WITH EITHER A HARDWARE FAULT (EG, AN
ADDRESS ERROR OR MEMORY PROTECTION VIOLATION), OR WITH
A FAULT DETECTED BY SOFTWARE(EG. AN ILLEGAL SUPERVISOR CALL
OR MESSAGE), THE KERNEL GENERATES A MESSAGE TO A 'SYSTEM ERROR
TASK'; TO ALLOW LATER INVESTIGATION
THE FAILED TASK IS PREVENTED FROM CONTINUING.
@THE 'ERROR TASK' INFORMS THE USER
OF THE TASK FAILURE AND THE REASON FOR IT.
@THE 'ERROR TASK' IS ALSO USED BY SOME SYSTEM TASKS TO INFORM THE
OPERATOR ABOUT THE STATE OF DEVICES.
$P1 @ALL COMMUNICATION IN THE SYSTEM IS DONE BY SENDING MESSAGES.
@THESE MESSAGES ARE QUEUED BY THE KERNEL, IF NECESSARY, UNTIL THEY
ARE REQUESTED. @INTERRUPTS ARE HANDLED SIMILARLY, THE KERNEL
GENERATES AND QUEUES A MESSAGE FOR THE APPROPRIATE TASK. @A TABLE

IS USED TO DETERMINE WHICH TASK A MESSAGE (OR INTERRUPT)
IS FOR. @A SUPERVISOR CALL IS PROVIDED TO ENABLE TASKS
TO 'LINK' THENSELVES TO A PARTICULAR MESSAGE NUMBER. @THIS
IS SLIGHTLY LESS EFFICIENT THAN DIRECT OWNERSHIP BUT 
ENABLES DEVICE HANDLERS TO BE CONFIGURED INTO THE SYSTEM DYNAMICALLY.
$P1 @THE ADDRESS OF A DATA AREA MAY BE PASSED BY A MESSAGE.
@THE SEGMENT
CONTAINING THIS AREA MAY THEN BE MAPPED FROM THE CALLERS .VM
TO THE RECEIVERS .VM. @CURRENTLY THIS MECHANISM IS ONLY USED TO
SHARE SEGMENTS, WHICH ARE EVENTUALLY RETURNED TO THE CALLER. @THERE
IS NO RESTRICTION TO STOP SEGMENTS ACTUALLY BEING TRANSFERRED
BY THIS METHOD.
$P1 @INPUT/OUTPUT ON THIS SYSTEM USES A SEPARATE
SEGMENT IN EACH USER'S TASK TO HOLD ITS .I/O BUFFERS. @THIS 
WILL ALLOW THE KERNEL TO SWAP THE MAJOR PART OF A TASK
WHILEST SLOW .I/O IS IN PROGRESS. @THE SHARING OF SEGMENTS, AS 
DESCRIBED ABOVE, IS USED BY THE DEVICE HANDLERS TO PROCESS THE
BUFFERS, THE SEGMENT BEING RELEASED AND A REPLY SENT ON COMPLETION.
$B3
$V10
%@IMPLEMENTATION
$P1 @THIS SYSTEM WAS WRITTEN IN .IMP. .IMP WAS CHOSEN FOR A
VARIETY OF REASONS:
$A INDENT=1
$I0 1) $T+1 A DELIBERATE DECISION WAS MADE TO WRITE THE SYSTEM
IN A HIGH LEVEL LANGUAGE FOR EASE OF EXPANSION AND MAINTAINABILITY.
$I0 2) $T+1 .IMP IS A PROVEN SYSTEMS IMPLEMENTATION LANGUAGE, FOR EXAMPLE
IT WAS USED TO WRITE BOTH THE @SYSTEM @FOUR AND 2900 VERSIONS
OF .EMAS.
$I0 3) $T+1 @A NEW IMPLEMENTATION OF .IMP WAS AVAILABLE
ON THE .PDP11, THAT WAS OF A HIGH ENOUGH STANDARD TO CONSIDER
USING IT FOR SYSTEMS IMPLEMENTATION.
$A INDENT=0
$P1 @TWO MODULES OF THE SYSTEM HAVE BEEN WRITTEN IN ASSEMBLER. @THE FIRST
MODULE IS AT THE LOWEST LEVEL OF THE SYSTEM, LOADING UP THE REGISTERS
ON CONTEXT SWITCHING. @SINCE THERE ARE NO EXPLICIT REGISTER
MANIPULATIONS IN .IMP, IT FORCED THIS MODULE TO BE IN ASSEMBLER.
@THE SECOND ASSEMBLER MODULE PROVIDES THE RUN TIME SUPPORT FOR .IMP
PROGRAMS. @THIS MODULE COULD PROBABLY BE CONVERTED TO .IMP LATER,
BUT WAS WRITTEN IN ASSEMBLER FOR BOOTSTRAPPING REASONS. @FORTUNATELY,
THESE TWO SECTIONS ARE CHANGED INFREQUENTLY AS THEY HAVE PROVED TO BE A
DISPROPORTIONATE SOURCE OF PROBLEMS IN RELATION TO THEIR SIZE.
$P1 @THE REST OF THE SYSTEM CONSISTS OF SIX .IMP MODULES, COMPRISING
THE KERNEL AND THE SYSTEM TASKS. @THESE MODULES ARE COMPILED SEPARATELY
AND THEN 'LINKED' BY A PURPOSE BUILT LINKER WHICH ALSO SETS UP
THE BOOTSTRAPPING AREA.
$P1 @APPLICATION PROGRAMS, WITH THE EXCEPTION OF THE EDITOR - WHICH
WAS BROUGHT FROM THE PREVIOUS SYSTEM - HAVE BEEN WRITTEN IN .IMP. @THE
SOURCES ARE HELD AND COMPILED ON THE SYSTEM.
$B2
$V10 
%@OPERATION
$P1 @THE FIRST SYSTEM, OPERATIONAL SINCE @MAY 1976,
IS USED FOR A LARGE SPOOLING .RJE SYSTEM WITH THE USUAL PERIPHERALS
PLUS A MAGNETIC TAPE DRIVE AND A GRAPH PLOTTER. @THE SECOND SYSTEM,
ALSO OPERATIONAL IN @MAY 1976, IS PART OF .ERTE (@EDINBURGH
@REMOTE @TERMINAL @EMULATION - SEE ???).
@THE THIRD SYSTEM, ON A .PDP 11/34 USED AS THE FRONT END FOR
THE .ERCC 2970 RUNNING .EMAS BECAME OPERATIONAL IN @DECEMBER 1977;
THE  FOURTH AND FIFTH SYSTEMS ARE
USED PART TIME AS THE DRIVERS FOR AN
INTERACTIVE BENCHMARK OF TWO .ICL 2900S RUNNING .VME/K AND.VME/K.
 @AT THIS STAGE SWOPPING
HAS STILL
TO BE IMPLEMENTED, THOUGH MOST OF THE NECESSARY KERNEL
FEATURES ARE ALREADY PRESENT.
$N 
$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
<ESCAPE>, THE COMMAND PROMPT SHOULD THEN APPEAR.
$P1 @THE INPUT TO THE .CLI HAS TWO FORMS, EITHER:-
$B2 .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 <INPUT 1>,<INPUT 2>,<INPUT 3>/<OUTPUT 1>,<OUTPUT 2>,<OUTPUT 3>
$B1 <INPUT 1> 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 <ANY OTHER DEVICES ON THE SYSTEM, SPECIFIED IN THE SAME WAY.>
$B0 <A .FILE .DEFINITION>
$B1 $I0 @A .FILE .DEFINITION IS IN THE FORM:-
$B1 $I2  <UNIT NUMBER>.<FILE NAME>(<FILE SYSTEM NUMBER>)
$A INDENT=1
$B1 @THE <UNIT NUMBER>,
A DIGIT IN THE RANGE '0' TO '4', AND REFERS TO THE
PHYSICAL DISC DRIVE. @IF NEITHER IS SPECIFIED, '0' IS ASSUMED.
$B0 @THE <FILE NAME> CONSISTS OF AN ALPHANUMERIC STRING, WHICH
MUST BE PRECEEDED BY A LETTER, OF UP TO 6 CHARACTERS IN LENGTH
$B0 @THE <FILE SYSTEM NUMBER> 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 <INPUT 3> 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 SEVEN 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.
$I1 G) .ABORT $T2 - @USED TO ABORT A DEVICE HANDLER TRANSFER.
$B3
$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
 <TASK NAME> $C+2 <TASK NUMBER> $C+2 <TASK STATE>
$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.
$L1C
G) ABORT
$P1 @THIS COMMAND IS USED IN THE FORM:
$I0 $T3 .ABORT XXXX
$I0 @THE COMMAND IS USED WHEN A DEVICE HANDLER HAS ATTEMPTED A
TRANSFER WHICH FAILS, EG THE DISC HANDLER HAS A 'HARD' CHECKSUM
ERROR, OR IS ATTEMPTING TO ACCESS A NON-EXISTENT DRIVE. @THE
EFFECT OF THE COMMAND IS TO INSTRUCT THE DEVICE HANDLER TO PASS
A FAILURE FLAG BACK TO THE TASK WHICH CALLED IT - THIS WILL
PRODUCE DIFFERENT EFFECTS DEPENDING ON WHO SENT THE ORIGINAL 
MESSAGE, IE IF A USER PROGRAM IS ATTEMPTING A TRANSFER OF A BLOCK
TO THE DISC, IT WILL STOP WITH A .FAULT 27.
$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 FOUR 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.
$I1 .E .TEST/$.TT $T2 - USED TO EXAMINE, WITHOUT MODIFICATION,
THE FILE .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.
$B2 $L1C
WARNING
$P1 @IF YOU WISH TO ABNORMALLY TERMINATE THE @EDITOR, %ALWAYS
USE THE COMMAND .'PURGE' RATHER THAN .'KILL'. @FOR EXAMPLE, IF
YOU ARE EDITING A FILE TO ITSELF AS IN EXAMPLE TWO ABOVE, A .KILL
WILL DELETE THE FILE .TEST, AND REPLACE IT WITH THE TEMPORARY
EDITOR FILE WHICH MAY WELL BE EMPTY.
$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, AN EXTERNAL ROUTINE FILE WILL CAUSE 
A .'FAULT 100'
ON EXIT FROM THE THIRD PASS WHICH INHIBITS THE ENTRY TO THE LINKER.
@THE OBJECT FILE IN THIS CASE IS %ALWAYS CALLED .'OY'.
$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 FOUR FOLLOWING
FORMS OF COMMAND TO THE .COMMAND .LANGUAGE .INTERPRETER.
$A INDENT=1
$B1 .LINK .A/B $C40 OR
$I0 .LINK .A$,$.TT/B $C40 OR
$I0 .LINK .A/B,C $C40 OR
$I0 .LINK .A,$.TT/B,C
$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 @IF THE OPTIONAL SECOND OUTPUT PARAMETER IS SPECIFIED, A LINK
MAP (SEE EXAMPLE BELOW) IS OUTPUT TO IT. @IN THE ABOVE EXAMPLES
THIS WOULD BE IN A FILE CALLED .C. .$.TT OR .$.LP COULD ALSO
BE SPECIFIED.
$B2 @SAMPLE .LINKER @OUTPUT @MAP
$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 .(TEST)
 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 INVERT=0; INVO=0
$A LINE=72
$A CAP=0; CAPO=0; CAPSH=0; CAPSHO=0
$L1M
COMPILER LISTINGS WITH CODE ADDRESSES
$A INDENT=0
$P2A program called ALIST is available to generate an IMP listing 
along with the address of the generated code.
$P1It can either be run using the output from the third pass of 
the compiler (File OY) or by using the final object program which 
is usually more convenient.
$B1$T0example:
$B1$T3ALIST TESTS,TEST/L
$B1which takes the %source file 'TESTS', is associated 
%object file 'TEST' and creates the %listing in file 'L'.  It is 
of course possible to specify .TT or .LP instead of file 'L'.
$N
$N
$L1M
CHECKING THE COMPILED OBJECT CODE
$P2A program called 'RECODE' exists to take either the output 
from the 3rd pass of the compiler, or the final object program and 
recode it back into assembler and merge it with the source program.
$B1$T0example:
$B1$T3RECODE TESTS,TEST/L
$B1which takes the %source file 'TESTS', is associated %object file 
'TEST', and creates the %listing in file 'L'.  It is of course 
possible to specify .TT or .LP instead of file 'L'.
$N
$B2$L1M
TRANSFER PROGRAM
$P1A program called 'T' exists to allow source or object files to be 
copied from file to file, device to file, file to device, or device 
to device.  It can also be used to concatenate two files by 
specifying a second input parameter.
$B1example:
$A INDENT=6
$B1$T0T FRED/2.FRED(20)$T6$C-2- copies the file 'FRED' on disc drive 0 - 
users current file system, to file system 20 on disc unit 2
$B1$T0T FRED/.LP$T6$C-2- lists file 'FRED' on the line printer
$B1$T0T .PR/FRED$T6$C-2- transfers a file from the paper tape 
reader to file 'FRED'
$B1$T0T FRED,JIM(21)/FRED$T6$C-2- takes the file 'FRED' and appends 
the file 'JIM' on file system 20 on to the end of it
$B1$T0T .TT/FRED$T6$C-2- reads a 'file' from the terminal and 
creates a file 'FRED'.
$B1$T6To terminate the transfer, it is necessary to 'HOLD' and then 'KILL' T.
$B1$T6NB:$C+2The preferred way is to use the editor.
$A INDENT=0
$N
$N
$L1M
FILE SYSTEM INTERROGATOR
$P1A file system interrogator program called F exists to enable a user to 
examine the contents of directories it has the following facilities:-
$A INDENT=4
$B1$T0A$t4$C-2: Lists all files in the current directory along 
with the start block, protect code and number of blocks in the file.
$B1$T0B Filename$T4$C-2: Gives data for specific file as in A.
$B1$T0C$T4$C-2: Get current L values
$B1$T0D Filename$t4$C-2: Delete file, D ? lists all files and 
requests Y to delete, N to keep, unless answer to automatic 
request is 'Y'.
$B1$T0F$T4$C-2: Lists filenames in current directory
$B1$T0G Filename$T4$C-2: Search all directories for file
$B1$T0L X,YY$T4$C-2: Alter current directory to disc X, and file 
system YY(octal).L CR returns to current logon.
$B1$T0R$T4$C-2; Rename file, prompts for old and 
new filenames.
$B1$T0S$T4$C-2: Stop
$B1$T0T Filename$T4$C-2: Transfer file, prompts for 
destination disc, FSYS or .TT or .LP.
$B1$T0U$T4$C-2: Lists all files for all users
$A INDENT=0
$P1The program assumes the current logon file system on disc 0 
on entry, A ? in a file name means do the command to all 
files starting with letters up to the ?.
$P1Unwanted output can be interrupted by sending A to task 
'F' using the INT mechanism.
$B1$T4example: INT A  F
$N
$A INVERT=0; INVO=0
$A LINE=72; MARK=2
$A CAP=0; CAPO=0; CAPSH=0; CAPSHO=0
$A TAB=4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64
$A INDENT=0
$B0$T0Magnetic Tape Support
$P1Currently the system supports a TU16 controller and tape 
drive, which enables either 800bpi or 16bpi tapes to be read 
or written.  The older version of tape drive (TU10) is not 
currently supported, although it is reasonably 
similar to the TU16 and hence would not be a 
major job to implement.
$P1The following general purpose programs exist to use the TU16.  
$A INDENT=4
$B1$T1ARCHDK$T4$C-2- archives a complete RK05 disc pack to 
1600 bpi tape in 4K word blocks.
$B0$T1RESTDK$T4$C-2- restores tapes written by ARCHDK.
$B0$T1START$t4$C-2- standard labelled Tape Archive and Restore.
$B0$T1STAN$T4$C-2- standard labelled Tape Analysis.
$B0$T1TAUL$T4$C-2- Tape Analysis for unlabelled tapes.
$B0$T1INSL$T4$C-2- standard Tape labeller.
$A INDENT=2
$B1$T0Note:$T2In systems where the page device handler (TU167) is not 
loaded by the system initialisation program LOADUP, it is necessary 

to 'RUN TU167' before running a tape program.
$A INDENT=0
$P1A description or a reference for each program follows.
$N$T0ARCHDK
$P1This program prompts:
$B1$T2DRIVE?
$B1when it is loaded.  The user then types in the unit number 
of the drive to be archived and the program will then write the 
entire contents of the disc up to tape sector by sector in 4K blocks.  
An entire RK05 disc takes approximately 45 seconds.  The existing 
program writes the tape at 1600 bpi but it is a simple 
modification to change this to 800 bpi.
$P1In systems where there is a double density pack and the 
system treats both 'units' as one unit, the entire disc i.e. 5.4Mb is 
written to Tape.
$P1The program is run by typing:
$B1$T2ARCHDK (carriage return)
$B1in response to the system prompt.
$N$T0RESTDK
$P1This program takes a tape with a disc image written by 
ARCHDK and transfers the tape contents back onto a RK05 pack.  
When the program is loaded it prompts:
$B1$T2DRIVE?
$B1and the user responds with the drive number that contains the disc pack to be overwritten.  As a sensible precaution
 the user is advised to 'write protect' all other drives.
$P1The program then asks for confirmation, thus:
$B1$T2CONFIRMATION?
$B1If any reply other than 'Y(carriage return)' is given the 
program stops.
$N$T0STAR - Standard labelled Tape Archive and Restore
$P1This program is generally used to create archives from disc to 
tape.  It creates a standard IBM labelled tape and 
%files are written to, and read from, it.
$P1For full documentation see the document by C$. McArthur (ERCC) 
11.AUGUST.76.
$B3$T0STAN - Standard Labelled Tape Analysis
$P1This is an interactive tape analysis program driven by 
commands from a console or a file, bytes of data on the 
tape can be identified and dumped on the printer.
$P1For full documentation see the document by C$. McArthur (ERCC)
4.OCT.76.
$b1$T0TAUL - Tape Analysis for Unlabelled Tapes
$P1This program is the same as STAN, but no assumptions are 
made about the format.
$P1See document by C$. McArthur (ERCC) 19.AUGUST.76.
$B1$T0INSL - Standard Tape Labeller
$P1This program is used to create (or overwrite an old) a 
standard IBM label in a magnetic tape.
$P1See the document by C.D$. McArthur (ERCC) ?
$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 .<REGISTER .NUMBER> $C+3 .<ADDRESS> $C+3 .<LENGTH> $C+3 .<ACCESS>
$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
$A INVERT=0; INVO=0
$A CAP=0; CAPO=0; CAPSH=0; CAPSHO=0
$A TAB=4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68
$L1M
SYSTEM FAULT MESSAGES
$B2
$P1There are three main classes of fault messages output by 
DEIMOS, they are
$A INDENT=3
$B1$T3$C-3 1)$T3 Compiler run time messages
$B0$T3$C-3 2)$T3Loader error messages
$B0$T3$C-3 3)$T3System detected error messages.
$A INDENT=1
$B2$T0 1)$T1 %Compiler  %run  %time  %messages.
$P1These messages are produced when the compiler run time support
 code detects an error.  The program is stopped and the error number 
is returned to the %task$ which$ started$ the$ program$ up.  This task will 
normally be the  loader and the error message is produced in the form:
$B1$T2F A U L T n
$B1$T1where 'n' has the following values.
$A INDENT=3
$B1$T1 'n' $T3Meaning
$B0$T1$C+1 1$T3Excess Blocks.  NB: only produced inside string 
handling routine
$B0$T1$C+1 2$T3Symbol in Data.  'READ' routine.
$B0$T1$C+1 3$T3String inside out.
$b0$T1$C+1 4$T3Not used

$B0$T1$C+1 5$T3No switch label.
$B0$T1$C+1 6$T3Capacity exceeded.  Strings only.
$B1$T1 25$T3An input file does not exist.
$B0$T1 26$T3Syntax fault on the Input/Output definitions 
string.
$B0$T1 27$T3Read or Write a block to the disc failed (e.g. illegal 
block, aborted transfer etc).
$B0$T1 28$T3The Disc is full or the users directory is full.
$A INDENT=1
$B2$T0 2)$T1 %Loader  %error  %messages.
$P1These messages are produced when the loader attempts to load a 
file and fails.
$B1The format is:-
$B1$T3fault n
$B1where 'n' has the following meanings.
$A INDENT=3
$B1$T1'n'$T3Meaning
$B0$T1$C+1 1$T3The free core is insufficient to load the program.
$B0$T1$C+1 2$T3Format of the initial block of the program is wrong - it 
is too short.
$B0$T1$C+1 3$T3Ditto - but is too long.
$B0$T1$C+1 4$T3The checksum on a block is wrong.  NB: This can also be 
generated when the end of a file is reached prematurely.
$B0$T1$C+1 5$T3Out of Range.  The program is attempting to load into 
a non-existent part of its VM.
$B0$T1$C+1 6$T3End of file.  EOF is reached before the final binary 
block is seen.
$B0$T1$C+1 7$T3System Full.  The maximum number of tasks is already 
loaded.
$A INDENT=1
$B1In addition the following messages are also output.
$B1ERROR MESSAGES
$A INDENT=5
$B1$T2no FRED$T6$C-2 - an attempt was made to load the file 'FRED' 
but it didn't exist or wasn't Binary.
$B0$T2TASK?$T6$C-2 - a command has been issued to a Task which doesn't exist.
$B2$T1INFORMATION MESSAGES
$B1$T2STOPPED $T6$C-2 - a program, under the control of the loader, has 
stopped normally.
$A INDENT=3
$B2$T1NB. This message will only appear when this is more than one user 
task running in the System.  When only one task is running and it stops 
the system prompt is issued.
$A INDENT=5
$B2$T2F A U L T n $T6$C-2 - See the earlier section.
$B0$T2TERM REQ.  $T6$C-2 - a 'KILL' has been given to a task and it has 
stopped.
$B0$T2XXXX PURGED$T6$C-2 - a 'PURGE' has been issued to a TASK and has been 
carried out.
$A INDENT=1
$B2$T0 3)$T1System Detected Error Messages.
$P1These messages are issued when the system notices that 
A TASK has misbehaved in some way.  The format in each case is the same:-
$B1$t4<TASK NAME>:<ERROR MESSAGE>
$B1The following messages are used:
$A INDENT=2
$B1$T2BAD SEGMENT a b
$P1The named task has caused a segmentation trap by writing or 
reading outside its virtual memory.  The two octal numbers 'a' 
and 'b' are the value of the error register and the PC at the time of 
the trap.  This Message is fatal, the TASK cannot run any more and should 
be investigated (using DEBUG) or PURGEa to remove it.
$B1$T2ADDRESS ERROR
$P1This is the same as BAD SEGMENT, except that an address error was 
seen by the hardware (e.g. addressing a word on a non-word aligned 
boundary, or an illegal stack pointer).  It is also fatal to the 
task.
$B1$T2ILLEGAL INSTRUCTION
$P1Same as above except the task attempted to execute an illegal 
instruction.  It is also fatal to the task.
$B1$T2ILLEGAL SVC
$P1The task has called a SVC that is not recognised by the system.  It 
will normally be fatal.
$B1$T2BAD SER n
$P1The task has sent a message to a non-existent process.  This is 
%not fatal, the task will continue to run but if it 
was expecting a reply it will never receive it.
'n' is the service number that failed.
$B1$T2TIME FAULT
$P1The task has attempted to request the clock to kick it more than 
once.  It is not fatal but indicates problems with the code.
$B1$T2NOT READY! n
$P1This message is issued when a peripheral wants operator action, 
when this is done, a FREE or ABORT command should be sent to the task. 
The octal number 'n' is device dependant,
but will normally contain the contents of the peripheral's error
register @(see the @peripheral @handbook).
$N
$E
$E