From rs@eddie.mit.edu Sun May 13 07:11:04 1990 From: rs@eddie.mit.edu (Robert E. Seastrom) Subject: HACTRN (LONG!) (was: Yet Another Proposed New Feature for INTERCAL) > From: bzs@world.std.com (Barry Shein) > Someone should post some of the ITS HACTRN manual...oops, there was no > manual. You were discouraged from understanding it, users were > considered a nuisance and tolerated only for their tax advantages. > Well, imagine a cross between TECO and Unix's ADB (really, DDT, but > that's a little circular) as the only command shell for an O/S. Sure there was a manual. I found two files. The one you probably want is INFO;DDT ORDER (remember that DDT and HACTRN are just different names for the same thing). There was also INFO;DDT DOC. Enjoy... ---Rob --------- Documentation for DDT version 1491 - Table of contents: (For users searching for command names with EMACS, each heading is the second line of its own page. The first line of each page is blank. There are no actual altmodes in this file; dollar signs are used instead. There are no non-formatting control characters; uparrow and a non-control character are used instead) (The DDTDOC program also searches this file, and knows that it uses dollar signs and uparrows rather than altmodes and control characters. So don't change this unless you fix DDTDOC first!) List of DDT commands Colon commands Built-in colon commands Reading of filenames Defaulting of filenames DDT's UNAMEs and SNAMEs Specially used symbols Unsolicited typeouts Unsolicited offers Returning to DDT Symbol table format List of DDT commands. Note that angle brackets are used to delimit meta-variables. Each of the following commands that takes a prefix arg does so in one of two ways: If the arg is called , , , , , , it is the syllable immediately preceding the operator. If it is a symbol, the symbol's name is used; otherwise it is considered to be SIXBIT for the desired name. eg. FOO$J and $1'FOO$$J are equivalent. All other commands evaluate all the preceding syls and ops to get 1 to 3 arguments (separate them with $,). ^@ will terminate an execute file or valret string. ^A prints the default user's sends file. ^A prints 's sends file, and sets the default for ^A and friends. 0^A print your own sends file, and set the default to you. $^A like ^A but for MAIL files. (but see :DDTSYM PMLFLG) $$^A like $^A but for RMAIL, BABYL or OMAIL files. (tries both). ^B is a special interrupt-level character, which turns on output to the wallpaper file if there is one, by zeroing ..LPTFLG. In files and valret strings, one ^B merely counteracts one ^E, by decrementinging ..LPTFLG unless it is zero. When a wallpaper file is open and output to it is on, every character DDT outputs goes to it, as does every character that DDT reads and echoes. ^B, ^E, ^V and ^W are interpreted at interrupt level when typed on the TTY; when present in execute files and valret strings, they are interpreted when read. They will not be seen at any higher level (eg. ASCII type-in); in files and valrets, they will be ignored within :IF conditionals that fail. ^C types a CRLF but doesn't close the open location, terminate an expression, reset the temporary mode, etc. The CRLF will be typed even if ^W has turned off TTY output. ^C being the ITS end-of-file character, it terminates execute files. $$^C half-kills the last symbol typed out (not counting index fields of instructions), then retypes $Q in the current mode (after DDT types JRST FOO(A) , $$^C will half-kill FOO). ^D is a special character which types "XXX?" and flushes any incompletely typed in command. If typed while a $E, $N or $W search is in progress, the search is stopped. ^E is a special interrupt-level character which turns off output to the wallpaper file (if any) but does not close it. Specifically, it increments ..LPTFLG. See ^B. ^F lists the last directory referenced. ^F lists directory of device , using the :PRINT default sname, and sets default :PRINT device (by special dispensation, that isn't done if is TTY !). Doesn't work if is also the name of a directory on DSK:. In that case, you get ... ^F lists user 's directory on device DSK:, and makes the default sname for :PRINT, etc. If isn't a directory, and isn't a device name either, the default sname for :PRINT, ^F, etc. is still set. Thus, ^F ^F will show the directory of :; even if isn't a disk directory. 0^F is the same as ^F. $^F: $^F is like ^F but doesn't set :PRINT defaults; just the default for ^F without argument. $^F is like ^F but doesn't set the :PRINT default. $$^F: $$^F this is a hairy command which uses the DIR: device to print the current default directory. The display is controlled by the table of two-word sixbit entries beginning at DIRFN1 (and DIRFN2) inside your DDT. For numeric argument n, the nth FN1 and FN2 are used as DIR: arguments. If the numeric arg is omitted it is assumed to be zero (and DDT uses the arguments at DIRFN1+0 and DIRFN2+0). If a DIRFN2 slot is zero: if there is no argument, we use the default :PRINT FN1; else if there is an argument we use it and set the default :PRINT FN1. If the DIRFN2 slot has something in it: if there is an argument, we use that argument instead. Here follow the DIR: arguments provided in DIRFN1. You can patch them with :SELF if you have another preference. DIRFN1: SIXBIT /NAME1/ ;Table of $$^F DIR: search options. DIRFN2: SIXBIT /UP/ SIXBIT /FIRST/ ;$$1^F finds FN1 0 SIXBIT /SECOND/ ;$$2^F finds FN2 SIXBIT /BIN/ SIXBIT /CDATE/ ;$$3^F ascending in creation age SIXBIT /DOWN/ SIXBIT /SIZE/ ;$$4^F descending in size SIXBIT /DOWN/ SIXBIT /NOT/ ;$$5^F not backed up SIXBIT /DUMPED/ SIXBIT /ONLY/ ;$$6^F just link pointers SIXBIT /LINKS/ Examples of use: FOO$$1 Shows DIR:FIRST FOO and sets FN1 to FOO LISP$$2 Shows DIR:SECOND LISP $$2 Shows DIR:SECOND BIN $$3 Shows DIR:CDATE DOWN UP$$3 Shows DIR:CDATE UP PACK13$$6 Shows DIR:ONLY PACK13 As an additional feature, if you set the DDT variable DIRDIR to -1, $$^F (without a numeric argument) sets your default :PRINT SNAME and otherwise ignores the argument. This lets you look at other directories. Examples: $$0^F Does DIR:NAME1 UP $$^F Still does DIR:NAME1 UP FOOBAR$$^F Changes default dir to FOOBAR and does DIR:NAME1 UP DOWN$$0^F Changes no defaults (now FOOBAR), does DIR:NAME1 DOWN ^G is a special interrupt level character that aborts any DDT command. It is so powerful that it can leave DDT's data bases in inconsistent states if typed at the wrong instant, so it should be used only when DDT appears to be hung. ^H (back-space) is equivalent to $J $P ^H continues , creating one if necessary. If a job named exists, it will be $P'd (or $G'd if it was loaded but never started). Otherwise, ^K is done: a job is created, and is loaded in and started. Since ^H only loads if no job already exists, ^H never clobbers anything useful. If the existing job is disowned, it will be reowned before being continued, of course. $^H: $^H like ^H but loads symbols if a new job is made. ^I (tab) goes to the next line, and then "types and opens the RH of $Q", which involves typing the RH of $Q as an address, typing a slash, and then printing the contents of the address typed (in the current type-out mode), just as if the "/" command had been used. ^I deposits in the open location if any, then types out and opens the RH of . $^I and $^I are like ^I, ^I but use the LH rather than the RH. $$^I and $$^I are like ^I, ^I but do an effective address calculation on $Q or to determine the address to type and open. ^J (line-feed) Types out and opens location .+1 (remember that "." is always the last location opened). Unlike ".+1/", ^J does NOT push the old value of "." onto the 'ring buffer of "."'. ^J stores in the open location, if any, then does ^J. $^J pops the ring buffer of point, then does ^J. After " 100/ 200/ ", $^J would open 101 . See $^M. $^J stores in the open location, if any, then does $^J. $^J pops the ring buffer of "." times, then does ^J. $^J stores in the open location, if any, then does $^J. ^K: ^K creates a job named , loads TS into it without symbols (looking for the file on your directory, the SYS directory, the SYS1, SYS2, and SYS3 directories, the dirs. in the sname search list), and the connected directory, and starts it, giving it the TTY. The program is given a null :JCL command string. If a job named already existed, the newly loaded copy of overwrites it. Since that can be a screw, if the job was disowned, or if ..CLOBRF is nonzero, DDT will ask the user "--Clobber Existing Job--". After such a query, type a space to tell DDT to go ahead and clobber the job; type anything else to abort. DDT will query "--Reload Protected Job--" if the job is "pro- -tected" (its ..SAFE variable has been set nonzero). $^K loads the current job's symbols from the file which was loaded (eg by ^K) $^K is like ^K but loads the symbols. $$^K disowns the current job. The job becomes a "disowned job" and is no longer DDT's inferior. Anyone who wishes to can "reown" it with $J, making it his inferior. In the mean time, since it is no longer DDT's inferior, it will not be harmed if DDT is logged out or killed. An infix argument is used as the control-bits for the DISOWN system call. Each bit controls a separate option. The meaningful bits are these: $$10^K disowns the job and arranges that if it ever remains stopped or blocked for an hour without being reowned or attached, the system will kill it. $$4^K disowns the current job and starts it, simultaneously (as far as it can tell). $$2^K makes the current job be a disowned job scheduled as part of the system (ie sharing the system job's resource word). It is antisocial to use the "1" and "2" bits for private purposes. $$1^K makes the current job into a non-disowned, top level job (but not console-controlled). Useful for resurrecting dead system demons. $$3^K makes the current job be a non-disowned top level job with the system job's resource word. ^L is a special character that tells DDT to type out any input characters that if been read but not yet fully processed, after first typing a CRLF or clearing the screen. ^L is ignored entirely in execute files and valret strings. ^M (carriage-return) closes the open location if any, without changing it. Resets the temporary (or "current") typeout mode to the permanent mode. ^M deposits in the open location if any, and closes it. Resets the current typeout mode. $^M pops the ring buffer of ".", then types and opens the new ".", tab-style, on a new line. Does not reset the current typeout mode to the permanent mode. After "30/ 100/ 200/", $^M would pop the ring buffer once, opening location 100 and leaving 30 on the top of the ring buffer. A second $^M would open 30 . $^M stores in the open location if any, then does $^M. $^M like "$^M", but pops the ring buffer of "." times instead of once. $^M stores in the open location, then does $^M. $$^M does nothing if no location is open. Otherwise, it unpurifies the page containing the open location (by replacing it with an impure copy). $$^M is superfluous unless ..UNPURF has been zeroed. $$^M like $$^M but deposits in the location after unpurifying the page. ^N proceeds one instruction, then returns to DDT. ^N proceeds instructions, then returns to DDT. In "care" mode, UUOs will be treated specially - the whole UUO handler will be executed. See $^^ command, Y flag. $^N steps the current job one instruction, using breakpoints. If the next instruction is a subroutine call, the whole subroutine is executed. $^N works by putting temporary breakpoints in the two words following the next instruction to be executed, and then restarting the job. The temporary breakpoints go away when either one of them is hit. If the instruction to be executed next is a PUSHJ, the AC used and its contents are remembered and the breakpoints will be conditional on the AC's having the same contents. Thus, if the PUSHJ is a recursive call all the inner recursions will execute and return without stopping on the breakpoint. Actually, the breakpoints don't always go immediately after the instruction to be executed next; they start on the first "reasonable" instruction after it ("reasonable" here means "nonzero op-code field"). This makes it possible sometimes to step over calls taking following arguments without taking any special care. $^N similar but puts the breakpoints words after the insn: at $.++1 and $.++2 . Good for calls followed by args. This form of $^N overrides DDT's search for the next "reasonable" instruction by telling it explicitly how many args there are. $^N like $^N but puts the breakpoints at and +1 and does no special hacking for PUSHJ instructions. Also, DDT will not be insubordinate by looking for reasonable instructions, since it has been told explicitly what to do.

,$^N puts the breakpoints at the address in the word pointed to by the RH of accumulator

. If you accidentally ^N through a PUSHJ,

,$^N will proceed until after the subroutine POPJ's. This is not considered to be an explicit specification of where to break, so DDT looks for a reasonable instruction.

,$^N is similar, but puts the breakpoints words later, overriding DDT's search for a reasonable instruction. Good for exiting a subroutine with args after the call. -(

)$^N uses @- (

) as the location of the first of the two breakpoints. Like

,$^N except that the return address is assumed to be words down in the stack instead of at the top. $$^N executes one instruction at a time until the PC gets to be 1 or 2 larger than it was when the command was given. $^N is usually equivalent, and much faster; $$^N's only advantage is that it does not have to put breakpoints in the program. $$^N is like $$^N but continues till the PC is or +1. In general, $$^N takes the same sorts of arguments as $^N. ^O deletes the specified file. It warns you what it will do, with "(Delete File)" (but see ..DELWARN). $^O , link to . Whether or not this will delete the file if it exists is controled by ..LINKP (q.v.) if ..DELWARN is 3, or ..LINKP is 0, it is disabled. $$^O , renames to the name , just like :RENAME. ^P proceeds the job without giving it the TTY. If it's running, does nothing. If it's waiting, lets it return and doesn't start it. Normally, clears the job's %TBWAT bit, so if it tries to use the TTY, it will interrupt and say "Job wants the TTY". However, this feature can be overridden - see ..TWAITF $^P is like ^P except that %TBWAT is set instead of cleared, so that if the job tries to use the TTY it will hang dumbly until it is $P'd. You can interchange the meaning of ^P and $^P - see ..TWAITF $$^P is like ^P except that the job's %TBOUT is set, giving it permission to type out even though it can't use the TTY for input. ^Q This is the same as ^ and is somewhat easier to type on some terminals. ^R is equivalent to ":PRINT " - the specified file is typed on the terminal. $^R , is equivilent to ":COPY ," - the contents of the first file are copied into the second file, writing over it if it already exists. ^S is the "shut up" character. It turns off typeout at interrupt level, but turns it on again when read. Thus it turns off typeout for the remainder of the command currently being processed, not permanently. ^S sets the current job's sname to $^S like $^S; it undoes the effect of $^S. $^S causes the next ^K, ^H or :-command, if it runs a program, to run it "as if were running it". Precisely, its .XUNAME variable will be instead of you and its .HSNAME will be set to 's HSNAME. If the program follows the current convention, it will use 's init file, etc. $^S works by setting the ..TUNAME and ..THSNAME variables. $$^S: $$^S sets the master system name (the "msname"), the :PRINT default sname, and the sname for ^F, to . The master system name is used: To initialize the snames of newly created jobs. To initialize their $L-default snames. Is searched last for ^K and : commands ^T makes filename-translations: ^T , creates a translation entry for the current job, translating to . The effect will be that if the job tries to open , it will actually get . Any of the names in the two files may be *, meaning "translation applies to any name" in , "translation doesn't alter this name" in . A translation that specifies only an SNAME in (aside from *'s) is likely to confuse DDT and screw you. should contain any subset of "A", "I", "O". "A" means don't retranslate the result of applying this translation. "I" means translate on input, "O" output. If neither I nor O is specified, both are assumed. Example: I^T FOO:*;* * , DSK:FOO;* * will make any attempt by the current job to read a file from device FOO: to read it from the disk directory named FOO; instead. Since all four names default to *, I^T FOO:,DSK:FOO; is a valid abbreviation. $^T: $^T , creates a translation that applies to DDT and all of its inferiors to all levels. $$^T: $$^T , creates a translation for the current job and all of its inferiors to all levels. ^U removes filename translations: ^U deletes any translation the current job may have which says the should be translated. I^U will only remove a translation for input, and won't affect translations for output. It will change a bidirectional translation into an output-only translation. Note that ^U *:FOO;* * removes any translation made on *:FOO;* *. It does NOT remove all translations made on names containing FOO;. It would NOT undo the effect of a ^T *:FOO;A B,C D. If you are not sure what translations you made, do :PEEK T to see them all. $^U: $^U removes a translation created by $^T (one which applies to DDT and all its inferiors). $$^U: $$^U removes a translation created by $$^T (one which applies to the current job and all its inferiors). ^V is a special interrupt-level (see ^B) character that turns on output to the TTY by zeroing ..TTYFLG . In valrets and execute files, merely decrements ..TTYFLG by 1 (unless it is already 0). Thus, one ^V in a valret or file cancels one ^W. ^W special interrupt-level character that turns off typeout on the TTY by AOSing ..TTYFLG . See ^B. ^X is used to stop a job running without the TTY (after being ^P'd). ^X normally does what ^Z would do if the job had the TTY. If the job is waiting to return, it is allowed to do so, but if it is waiting for a chance to commit suicide it will be stopped instead. ^X does nothing to a stopped job, except print out the instruction where it is stopped (and tell you it's stopped). $^X or $^X. (the point is required unless ..CONFRM is zero) deletes ("kills") the current job. All the data in it is lost. The $J command is then used to select another job to be current (if there are any); that job's name is typed out, followed by "$J". If the job to be killed is "protected" (its ..SAFE variable has been set nonzero), DDT will ask for confirmation before killing it. $^X is like $^X., except that after killing the current job, $J rather than $J is used to select another. $^X kills the job named . It asks for confirmation by typing "--Kill--"; a space tells it to go ahead. Whether you confirm the killing or not, the current job afterward is the same as it was before (unless it was the one you killed). $$^X or $$^X. kills all jobs. The "." is required, unless ..CONFRM is zero. Since this command is easily typed by accident instead of $^X., it is normally disabled, but may be turned on by ..MASSCP/-1 ^Y uses $Q as an AOBJN pointer to a symbol table in the current job's core, which should be appended to DDT's symbol table. Make sure that every symbol has either the local bit or the global bit (4.8 or 4.7) set; otherwise, a "DDT bug" message may result (exceptions are allowed if the symbol table being set up contains valid DDT-style block structure, but don't be surprised to find that you made a mistake). See Symbol table format. ^Y is similar but uses instead of $Q. $^Y is like ^Y but flushes the symbols DDT already has. $^Y similar to ^Y. $$^Y: $$^Y puts a copy of the job's symbol table into the job's core. It assumes that is the location of an AOBJN pointer to an old symbol table, which is to be replaced by DDT's current one. The new symbol table is stored in core so that it ends at the same place as the old one; expansion or contraction occurs at the low end in core. The AOBJN pointer is updated to record the new size. These actions are such that DDT-2$$^Y will give the symbols to a non-timesharing DDT in the job. ^Z is not a DDT command. If given as a command to DDT, it is an error. ^Z IS a command to ITS to give the job that owns the TTY a fatal interrupt, if it is not a top-level job. If the interrupted job's superior is a DDT, it will take control of the TTY and begin reading commands as a response, but the ^Z itself is never seen by the DDT. ^[ is altmode, which is a prefix-modifier for DDT commands. ^\ begins a patch at the location open (the location "being patched"). It is a convenient way to replace one instruction (at the open location) by several (the patch). The instructions in the patch are stored in the job's "patch area", a spare area allocated specifically to such use. Every program should allocate one. The beginning of the patch area is the value of PATCH if it is defined, or the value of PAT if it is defined, or 50 . As patches are made, PATCH will be redefined to point to the next free location in the patch area. A patch started with ^\ must be terminated with some variety of ^] command, which will store first the JUMPAs back from the patch to the patched routine (two of them, in case the patch skips), and then a JUMPA from the location being patched to the patch itself. This order of actions guarantees that the patch will never appear to be "half made" in any way that that might cause trouble in a running program. ^\ begins by typing and opening the first location of the patch area. Then the contents of the location being patched are typed out and left as the argument to the next command. If you wish to include that instruction as the first instruction of the patch, type ^J. If you wish to get rid of it, type . Then deposit the other instructions of the patch, and finish with a ^] (which see). While patching, the pseudo-location ..PATCH contains ,,. NOTE to users of relocatable programs, and MIDAS or FAIL block structure: PATCH is redefined in the same symbol block that it was found in. This permits some obscure hackery, but normally the whole program will have only one patch area, and it must be visible to ^\ no matter which symbol block is currently selected for type in. That can be guaranteed by defining PATCH as a global symbol (eg, using PATCH": in MIDAS). ^\ deposits in the open location, then does ^\. Equivalent to ^\, except that with ^\, will be present in the location being patched while the patch is being made. $$^\ unmakes the patch previously made to the open location. $$^\ uses the JUMPA to the patch to find the instruction that the patch replaced. This works only for patches made by ^\, which were either closed by $^], or closed by ^] and having the old instruction as the first instruction of the patch. ^] ends a patch started by ^\. Two JUMPAs back to the locations following the one being patched are stored in the two words starting with the open location (or in location .+1 if no location is open). Then in the location being patched is stored a JUMPA to the beginning of the patch. Finally, PATCH is redefined to point at the word after the second JUMPA back (the first free location of the patch area). ^] stores in the open location, opens the next location, then does ^]. $^] is like ^] but first stores the contents of the place the patch was made from in the open location and linefeeds. It is useful for putting a patch "before" an existing instruction. $^] stores in the open location, opens the next location, then does $^]. $$^] is like $^] but omits the JUMPAs back to the place that the patch was made from. It is useful when a patch is put on top of a JRST or POPJ - it will store an identical JRST or POPJ, and nothing else. $$^\ (unpatch) can't work after $$^] because necessary information isn't there; it can however figure out that it can't win and will complain. If this is important, use $^] instead of $$^]. $$^] stores in the open location, if any, then moves down one word and does $$^]. ^^ begins multi-stepping according to the job's stepping flags, and continues indefinitely. Multi-stepping involves printing the next instruction and executing it, repeatedly. Each step is done with a ^N or an $^N depending on the type of instruction and the settings of the stepping flags. Other flags cause stepping to stop before certain kinds of instructions. Errors, breakpoints, and .VALUE 0's will stop stepping. So will typing any character while DDT is typing the next instruction to step over. ..DOZTIM holds the number of seconds that ^^ will insist must elapse between steps, to give the user a chance to decide whether to type a character and stop things. While multi-stepping, the SETAI instruction (a no-op) invokes a special kludge for making specific subroutines appear to be single instructions during multi-stepping. If the first instruction of a subroutine is an appropriately coded SETAI instruction (rules follow below), then after multi-stepping steps through the call to the subroutine, it will see the SETAI and immediately proceed (with $^N) to the subroutine's return address. Note that there is a stepping flag (see $^^ below) that causes ALL subroutine calls to be treated as single instructions; the purpose of the SETAI crock is to make only some subroutines act that way. One might assemble a program with a SETAI at every entry point and patch the SETAI's of some subroutines into JFCL's, when they are themselves being debugged. The SETAI instruction should address a word which contains the subroutine's return address. For subroutines called by PUSHJ P, use SETAI (P). For subroutines called by JSP T, use SETAI T. For subroutines called by JSR use SETAI .-1. Note that SETAI is not special with ^N - only with ^^. ^^ like ^^ but will stop after the 'th step if nothing stops it earlier. $^^: $^^ like ^^ but first changes the job's stepping flags according to the letters in (which must be 6 chars or less). The letters that mean something are: B step over a subroutine call in one step with $^N. C stop before a subroutine call. (subroutine calls are PUSHJ, JSP, JSR, JSA) D step over subroutine calls with ^N and then step through the subroutine. J stop before jump instructions. K ^N over jumps. M stop before monitor calls. N ^N over monitor calls, but $^N over a .VALUE P print each insn before stepping over it (normal state) Q print insn only when stepping stops before it. R stop before subroutine returns (POPJ and JRA). S ^N over subroutine returns. U treat user UUOs as subroutine calls. V $^N over user UUOs. W stop before user UUOs. X ^N thru user UUOs (and step thru UUO handler). Y enter "care" mode in which ^N'ing thru a UUO whether or not as a result of a ^^, will cause the saved PC in the UUO handler to have its 1-proceed flag set, and the whole UUO handler to be executed as if it were one instruction, returning whenever the UUO handler restores the flags (with JRST 2,). Z leaves "care" mode. Each job has its flags, which are updated by $^^ and used by ^^. The flags are initialized when the job is created, from the new-job-default flags, which are initially 'BPUZ' but may be changed with $$^^ (which might well go in an INIT file). $^^ combines $^^ and ^^ $$^^ sets the new-job-default stepping flags according to the letters in . Does not actually do any stepping. $$0^^ sets the current job's stepping flags according to the new-job-default and the letters in . $ (altmode-space) separates prefix command arguments, like altmode-comma. ^_ Incluseive or. ! divides. Priority 2. $! floating divides. Priority 2. If unary, reciprocates. $$! or $$! opens a location as / or / would, but doesn't type the contents. $Q is set, however. Future ^J, ^, and ^I commands will also not type the contents of the locations they open, until a /, [ or ] command is used. " retypes $Q in the " typeout mode, initially ASCII mode. " retypes in " typeout mode. $" selects the " typeout mode temporarily. The " mode is controlled by the per-job variable ..TDQUOT. Unless explicitly changed, it is full-word ASCII typeout: ASCII// is printed as $0"$ . ASCII//+1 appears as $1"$ (the digit is the word's low bit). ^Q and ^ are typed out with an extra ^Q in front. Other control characters are typed out as an uparrow followed by the un-controlified character. Rubout is typed out as "^?". See the section on typeout modes. $"$ is an ASCII syllable whose value is ASCII//+1& (that is, specifies the word's low bit). To put a control character in , use uparrow (eg. uparrow and A for control-A), or preceded the control character with a ^Q. To put in an uparrow or altmode, precede it by ^Q. A rubout typed in immediately after a ^Q will be quoted, but a ^Q will be rubbed out if other characters were typed in and rubbed out in between. Rubout may be typed in as uparrow-questionmark. $$" specifies " typeout mode as the current mode permanently, so that ^M will not undo it. $$" is used for multi-word ASCII type-in. It acts just like $" if 5 or fewer characters are typed. When the sixth character is typed, the first five are deposited in the open location and the location after it is opened. This is repeated for as many words as it takes to store the whole string of characters. # if there is anything before the #, it means exclusive-or; otherwise, it retypes $Q in # mode. $# temporarily selects the # typeout mode, This mode is controlled by the per-job variable ..TNMSGN. Unless it has been explicitly changed, it is single-character ASCII typeout mode. A value types out as $1# followed by the ASCII character in the low 7 bits. Thus MIDAS's "A is typed as $1#A. MIDAS's ^A (uparrow-a) is typed out as $1#^A . Rubout comes out as uparrow-questionmark. If the number to be typed out goes over the bottom 7 bits, the bottom 7 bits are typed as a character and the rest as an instruction; MOVEI B,101 comes out as "MOVEI B, $1#A". $1# used for single character type-in. Follow it by the character (uparrow and ^Q quote as with $1"). The result is a syllable whose value is the ASCII for that character. Thus, "$1#A" means 101 . $$# specifies # typeout mode as the current mode permanently, so that ^M will not undo it. $ (dollarsign) is not a DDT command in itself, since it is a symbol constituent (just like letters). $$ (altmode dollarsign) temporarily selects $ typeout mode. That mode, held in ..TDOLLA, is initially symbolic mode (same as $S). This command is useful only if the $ mode is changed to a user defined typeout mode. $$$ (altmode altmode dollarsign) specifies $ typeout mode as the current mode permanently, so that ^M will not undo it. % is not a DDT command in itself, since it is a symbol constituent (just like letters). $% temporarily selects the % typeout mode. That mode is kept in the current job's ..TPERCE variable and is initially symbolic mode (same as $S). This command is useful only if the % mode is changed to a user defined typeout mode. $$% specifies % typeout mode as the current mode permanently, so that ^M will not undo it. & if not first thing typed, does logical-and, Priority 3. If not preceded by args, retypes $Q in & mode. $& temporarily selects & typeout mode. This mode, held in the current job's ..TAMPER, is initialized to SQUOZE mode in each new job. In SQUOZE mode, SQUOZE , types out as $& $& a syllable whose value is the SQUOZE for , with in the flags. should be from 0 to 74; the two lowest bits of are ignored. $$& specifies & typeout mode as the current mode permanently, so that ^M will not undo it. ' retypes $Q in ' mode (normally SIXBIT mode). ' retypes in ' mode. $' temporarily selects ' typeout mode. This mode, held in ..TPRIME, is initially SIXBIT mode, in which SIXBIT// types out as $1'$ . $1'$ is a SIXBIT syllable whose value is SIXBIT// . Only the first 6 characters of are significant. $$' specifies ' typeout mode as the current mode permanently, so that ^M will not undo it. $$1' is used for multi-word SIXBIT type-in. A cross between $1' and $$1". Uparrow is not special. ( and ) are used for putting a value in an instruction's index field, or, more generally, for swapping the halves of a word-long value. DDT treats the value inside the parentheses just as MIDAS does: if the ( is preceded by an arithmetic operator, the parentheses and all between them act like one syllable whose value is the value of that word with its right and left halves interchanged. Otherwise, the two halves of that word are added into the opposite halves of the word within which the parentheses occur, in an otherwise invisible manner. That is, the argument evaluator's state is the same after the ) as it was before the (. $( and $) these are ignored completely (they can't even be rubbed out). useful with conditionals (see :IF) $$( starts a literal. Use this when typing in an expression to stand for the address of a literal whose data you will specify later. DDT will type out a symbol name and a closeparen; the expression you are typing will contain a forward reference to that symbol, which will become the address of the literal. As soon as it is safe (no location is open, and no literal or patch is being defined), DDT will assign that symbol the address of the patch area and open it, so you can fill in the data of the literal. Deposit the last word of the literal with a $$), which will update PATCH and set "." to what it was before DDT opened the literal. This scheme causes recursive literals to work fine - the inner literal will not be opened until you close the outer one, since DDT can't tell where to start a literal while another literal is being typed in. When you have a delay between the $$( and the opening of the literal, the symbol assigned by DDT will allow you to match the definitions up with the uses. $$) Closes a literal. Defines PATCH to be the open location, or, if none is open, to .+1. Says that no literal is in progress, which may cause DDT to ask for the definition of some other literal. $$) is equivalent to $$). It deposits , then sets PATCH to .+1. * multiplies. Priority 2. $* floating multiplies. Priority 2. + adds. Priority 1. $+ floating adds. Priority 1. , (comma) is used to separate fields in a word. Space also does so. The significance of the fields in a word depend on the pattern of spaces and commas. Usually the value of the word is that of the first field, with all the other fields added into the RH. However, if the first field is followed by two commas, it is put in the left half, and otherwise if followed by one comma, it is put in the AC field. If a space separates the first two fields and a comma ends the second the second is added into the AC field rather than the RH. Examples: ,, truncates to 18. bits and puts it in the left half. ,, halfword type-in format. is put in the left half, and in the right half. Each is truncated to 18. bits first. , a format which adds into the AC field of . , a format like , but adds to the right half. , a format which results in in the AC field. , puts in the AC field and in the address field. $, separates multiple args to one operator. - subtracts. Priority 1. If unary, negates. $- floating subtracts. Priority 1. Or, floating negates. .. is a symbol whose value is usually the last location opened (except that \, etc., open but don't set ). Whenever "." is randomly changed, the old value is saved in a ring buffer with 8 slots. $^M, $^J and $^ reopen the previous value of ., (plus or minus one for $^J or $^) ^J and ^ increment and decrement the current value of ., rather than pushing the old value. $. has as its value the current job's user mode PC. / opens the location addressed by the RH of $Q. This means that various commands including ^M will store into that location. More immediately, it means that the location's contents will be typed out in the current mode and will be the new value of $Q. Also, the location itself will be "pushed onto the ring buffer of ." meaning that .'s value is now that location, but $^M, etc. can reopen the previous value of ".". (This will not be done if the location just opened is the same as the previous value of .) / opens the location addressed by the RH of . $/ or $/ opens the location addressed by the LH of $Q or . $$/ or $$/ does a PDP-10-style address calculation on $Q or to determine what location to open. : defines symbols: : defines to have the same value "." currently has. If the symbol is already defined in the current block or any containing block, it will be redefined in the same block. Otherwise it will be defined in the current block. : defines to have the value . $: selects symbol table blocks: $: selects the symbols in block or program . $$: $$: like $: but insists on finding a block directly inferior to the currently selected one. Useful for resolving the ambiguity, when several blocks or programs have the same name. ; retypes $Q in the "semicolon mode", temporarily decrementing ..TTYFLG by 1, so it takes two ^W's to suppress the printout. (Useful in execute files that shouldn't echo their contents, but want to type stuff). The semicolon mode is the most recently specified temporary or permanent typeout mode, even if it was only a temporary mode which was later reset to the permanent mode, e.g., $S sets the temporary mode and the semicolon mode to symbolic. A carriage return will reset the temporary mode to the permanent mode but the semicolon mode will remain symbolic. ; is similar but retypes , not $Q. $; and $; are like ; and ; but also reset the temporary mode from the semicolon mode, and don't temporarily SOS ..TTYFLG. $$; and $$; are similar but also set the permanent mode. > and < (angle brackets) are like algebra's parentheses. > can be used to terminate an expression read in by a colon command (as can a carriage return). $< and > surround an expression to be used as an infix argument in an operator. For example, $<1+1>R is equivalent to $2R $$< and > are similar, for operators with two altmodes. = retypes $Q as a number in the current radix. = retypes instead. $= retypes $Q as a number in radix . $= retypes instead. $= retypes $Q as a floating point number. $= retypes instead. $$= retypes up to three arguments in the modes used to input them. $> when changing part of an instruction, saves typing the unchanged parts: $> takes those parts of that are nonzero, or which are known to have been explicitly specified; takes the other parts of a word from $Q, and returns the sum. The parts of a word used are: op code 777000,, ac-field 740,, indirect bit 20,, index-field 17,, address right half. The $> may actually appear anywhere within the argument, because it does nothing but set a flag when the evaluation happens. If an undefined symbol is used (with "?") in either half of the argument, it overrides that halfword of $Q. The fields which $> can tell have been explicitly specified are the AC field, the indirect bit ("@@" specs it explicitly as 0), the left half (eg, "0,,$>"), and the right half (eg ",0$>"). some fields may be explicitly zeroed magically: "0$>" zeroes the address field; "0 $>", the op-code field; and "()$>", the index field. If $> can determine that the quantity is an I/O instruction (CONI, etc.) a different set of fields is used: op-code 700340,, device code 77400,, The address, index and indirect fields are the same as usual. In this situation, ",$>" will use to specify the device code. ? performs many functions, in different situations: ? used in expressions to refer to a symbol currently undefined which will be defined later. Attempting to do any arithmetic but addition on such objects, or to put them in the AC field, will lose. However, putting one before a ",," will succeed in putting it in the left half. Only two such objects may appear in an expression and they may be used only to deposit in a location. When an undefined-reference is deposited in core, what really happens is that an entry is made in the "undefined symbol table". When a symbol is defined (with ":"), the undefined symbol table is searched, and the value is added to the locations that need it. The table entries for those locations are then removed. The undefined symbol table is dumped by $Y, loaded by $L, and merged by $$L. It can be listed by :LISTU. ? right after a "?U?" (undefined symbol) error message creates a reference to that undefined symbol, just as if the "?" had been typed right after the symbol with no other intervening operator. For example, if FOO is an undefined symbol, and "FOO+BAR" is typed, a "?U?" error will occur after the "+". At that point, "?+BAR" will recover, producing an ultimate result equivalent to "FOO?+BAR". ? when there is no current job, types a basic help text. In other circumstances, retypes $Q in $H$? mode (bit typeout mode). ? where does not end with a symbol (use a space before the "?" to play it safe), retypes in $H$? mode. $? temporarily reselects bit typeout mode, with the details as they were last specified. $? temporarily specifies bit typeout mode, and sets the main bit name prefix to . The alternate prefix is set to the previous main prefix. The pattern associated with the new prefix is the value of in the symbol table, if it is defined; otherwise, if "..B" followed by the prefix is defined, its value is used; otherwise, the pattern defaults to 525252,,525252. How those settings are used is described in the special section "bit typeout mode". Note that symbols defined for use as prefixes are also good as masks for $T typeout mode. Especially useful prefixes predefined in DDT are .R, .S, ..R, and ..S. If you have a .SUSET or .USET word that is positive (reading), just do .R$?? to see what variable is being read. For a writing .SUSET or .USET, use .S$??. ..R and ..S are good for .BREAK 12's. $? temporarily selects bit typeout mode, and sets the pattern for the main bit name prefix to . $? the same as $? $?. Like $? but uses as the pattern, rather than the value of or 525252,,525252. $0? interchanges the main and alternate bit name prefixes. When combined with a , this exchange happens first, so $0? sets the main bit name prefix, without changing the alternate one. $$? permanently selects bit typeout mode. $$? interprets arguments otherwise the way $? does. @ complements the indirect bit in the word in which it appears. Is otherwise invisible (see parentheses not preceded by operator). $A or $$A temporarily or permanently selects absolute address typeout mode; that is, addresses will be typed as numbers (see $R). Temporarily or permanently deselects bit typeout mode. $B and variants manipulate breakpoints: $B legal if the current job is stopped at a breakpoint; removes that breakpoint. $B sets breakpoint at location . Up to 8 breakpoints may be set in any one job. $B (where is between 1 and 8) sets breakpoint at . If breakpoint had been set, it is removed first. $B is the "address" of the location inside DDT which begins the 3-word block holding the information about the current setting of breakpoint number . The first word holds

,,
, or 0 if the breakpoint is not set. The 2nd word holds the conditional instruction; the 3rd, the proceed count) ,,$B sets a breakpoint at that will type out and open when it is reached by the program. $0B removes any breakpoint set at . 0$B removes breakpoint . $$B removes all breakpoints from the current job. $$B sets an auto-proceeding breakpoint at . When an auto-proceeding breakpoint is hit, it prints the usual information, but does not stop the job unless the user types a character. $$B sets breakpoint at and causes it to be auto-proceeding. $C or $$C temporarily or permanently selects Constant typeout mode. When a location is opened, its contents will be typed out as a number in the current radix. See $S. $D or $$D temporarily or permanently selects decimal typeout of numbers. See $O. $E or $$E temporarily or permanently selects E&S display processor instruction typeout mode. See $S. $E searches current program for locations with effective address of . Starts at addr in lh of ..LIMIT . Stops at addr in RH of ..LIMIT . Typing a ^D will stop the search, leaving "." set to the last location found. $,$E searches for such locations after , stopping at RH(..LIMIT). $,$,$E searches for such locations from to . When such a location is found, " / " is typed, and "." is set to (pushing the "." ring buffer). $F or $$F temporarily or permanently selects floating point typeout mode. The contents of locations opened will be printed as floating point numbers. $G starts the program at the starting address (which is contained in ..STARTA). The previous PC is put in ..XECP (a DDT location) in case the program wishes to examine it. $G starts the program at . $G does ^^ starting from the job's starting address. However, the 1st insn to be stepped through is printed and might be stopped before if the stepping flags say so (^^ would not print the 1st insn or stop before it). Note that $0G merely sets the PC and prints the first instruction to be executed - it executes nothing. $G sets the PC and types the instruction which the new PC points at $$G: $$G starts the program at , and make the default starting address. $$G is analogous to $G $H or $$H temporarily or permanently selects half-word typeout mode. The contents of locations opened will be typed as two addresses separated by ",,", each address being the contents of one half-word. $I turns off the current job's MAR. $I is the same as $3I $I sets the MAR at location . If is 1, a trap will occur on fetching an instruction from ; if is 2, on writing in ; if is 3, on any reference to . DDT will print MAR; pc>>instruction showing the instruction that tripped the MAR, before printing the next instruction to be executed. (as always). They may or may not be the same, since the MAR may or may not abort the instruction that trips it. Note that the MAR may be made conditional by putting a nonzero instruction in ..MARCON. When the MAR'ed location is referenced, the conditional instruction will be executed in the job's core, and DDT will stop the job if the instruction skips. Otherwise, DDT will rearm the MAR and restart the job. Subroutine calls are often useful conditional instructions. An arbitrary string of commands may be executed whenever the MAR is tripped by putting the string in the job's core and its address in ..MARXCT. Both ..MARCON and ..MARXCT are cleared by the $I command to prevent confusion. Each job has its own MAR, and its own copy of all the related DDT variables. $J switches the current job in a "convenient" way. If there is a job that wants attention from the user (is waiting to return to DDT), it is selected and allowed to return. If no job needs attention, $J chooses from the existing jobs in an arbitrarily chosen cyclic order, so that successive $J's will find all of DDT's jobs. In any case, the name of the newly selected job is typed out, followed by "$J". If the job reached is another user's job that was being examined and which went away in the meanwhile, DDT will purge itself of the memory of the job, type :KILL and try to open the next job in order. $J makes job the new current job. If no such job exists, one is created (In that case, "!" is typed out). If a disowned job exists, it is reowned, and ":$Reowned$" is typed. $J pops the job-selection ring buffer times. Whenever a job is selected by any command other than $J, it is also pushed on the job selection ring buffer (which is internal to DDT), so that $J can be used to retrace the recent history of job selection. $J is most useful in valret strings which wish to reselect the job which did the valret after temporarily selecting other jobs, without having to make any assumption about the jname of the valretting job. For example, one could do DEBUG$J, hack around, and return with $1J. One could also create a new job with :NEW TECO , and on exiting from the teco do :KILL $2J to return. The "2" is because the :NEW TECO pushes once, and the :KILL pushes again. $1J $1J could not be used, since the first $1J would try to pop to the no-longer-existing TECO, which is an error condition. $$J types the current job's UNAME, JNAME, state, and job number. $$J prints the info on the current job that $$V prints about each job. $$J set current job's name to . This doesn't switch jobs; it gives the same job a new name. The job's XJNAME is not altered. $K is used for killing symbols: $K half kills symbol in the current job's symbol table. When a symbol is half-killed, DDT will no longer use it for type out, but it is still recognized when typed in. $$K kills the entire symbol table of the current job. $$K fully kills the symbol , which will no longer be accepted as input. $L loads into the current job's core image. Returns the job's core, kills the symbol table, and closes I/O channels before loading. Temporary breakpoints set by $^N are flushed but ordinary breakpoints set by $B are not. DDT remembers the name of the last file loaded or dumped in each job, and uses it to default any names not given explicitly in . The name specified becomes the new default for the next command. $L, $$L, $Y, $$Y, :LOAD, :PDUMP, :PDUMPI, :SL, :SYMLOD, :SYMADD and $^K all use this default. when a job is created by $J, the default is initialzed to DSK:; BIN. When a job is loaded into by ^K, etc. the default is set to the name of the file loaded. $L loads with an offset of . That is, anything that should load into loads into +. Doesn't work for :PDUMP'd files. $0L like $L but rather than loading a binary program simply reads the contents of the file directly into core. "." is set to the first location not read into, so that "^" will open the last word read. $0L reads into core starting at . $1L like $L, but doesn't load symbols. $1L loads starting at , without symbols. $$L as $L but does not zero core, kill symbols, or close I/O channels. Can't be done to a running job. $$0L analogous. $M pertains to word-search comparison masks: $M sets mask number 0 used for $W and $N searches to . Only those bits that are on in will be compared. The mask is initially -1. $M sets mask number . must be from 0 to 7. Each search may speecify any one of the 8 masks. Thus, after (17)$1M 17,$2M, $1W will compare the index field and $2W will compare the AC field. Initially, $1M is 777777; $2M, 777777,,; $3M, 17,; $4M, (17); $5M, (777000); $6M and $7M are -1, like $0M=$M. $M is the pseudo-address of the word in DDT which holds mask number ($M is the same as $0M). $N: $N searches for locations whose contents differ from in one of the bit positions which are selected by , where is what is in $M (set by $M). Locations found are opened in the current mode and pushed on the "." ring buffer. The range searched starts at LH(..LIMIT), and stops at RH(..LIMIT) (see the $E command). $N where is between 0 and 7, uses mask number (the contents of $M, set by $M). If is not between 0 and 7, itself is used as the search mask. $,$N searches starting at . $,$,$N searches from to . and may be addresses inside DDT, in which case DDT will search through itself. ,,$,$N does the same thing. In ,,$,$,$n, overrides . $O or $$O temporarily or permanently selects octal type-out of numbers. See $R. $P proceeds the current job, giving it the TTY. If it is running, gives it the TTY. If it is waiting to return, allows it to return. If its reason was that it needed the TTY or that it wanted to valret, it is proceeded. $P unless the current job is stopped at a breakpoint, identical to $P. Otherwise, sets the proceed count for the breakpoint that stopped the job to . ($P sets it to 1 in that case) $$P like $P but if job was stopped at a breakpoint, sets that breakpoint to auto-proceed. $Q this has the value of the last quantity which either 1) DDT deposited in a location or 2) DDT found in a location that was opened or 3) DDT was specifically told to type out (by =, $=, ', ", ;, $;, $$;, _, etc.) $0Q identical to $Q. $1Q next-to-last value of $Q (and so on up to $7Q). $$Q is $Q with its halves swapped; <($Q)>. $$Q is $Q with its halves swapped. $R or $$R Temporarily or permanently selects relative address typeout mode, and deselects bit typeout mode. Addresses will be typed as + when possible. The symbol whose value is closest to the address is used. The maximum allowed is kept in ..SYMOFS; an address requiring a larger is typed numerically. Symbols in current or containing blocks and programs are preferred to symbols in other blocks or programs if they have the same value. The alternative is absolute mode ($A) in which addresses are always typed out as numbers. $R or $$R temporarily or permanently selects output radix . Input radix is always 8 (or 10. for numbers ending in "."). $S or $$S temporarily or permanently selects symbolic typeout mode. Locations that are opened will have their contents printed in the way DDT thinks is most reasonable (usually as an instruction or in halfword format.) When an address is typed, it may be numeric or symbolic according to the $A vs $R selection. $T or $$T temporarily or permanently selects typeout as bytes, using the most recently specified byte size or pattern. $T or $$T (where is between 1 and 36.) temporarily or permanently selects typeout of words as several bytes of bits each. $T or $$T (where is negative) temporarily or permanently selects typeout of words divided into bytes according to . The block of consecutive 1's at the front of determines the first byte; the block of 0's following, the second; the next block of 1's occupies the third, etc. Each word to be typed out is divided up in that way and each byte is typed in the current radix. $U or $U. (point required if ..CONFRM is non-zero) reloads and re-initializes DDT. All inferiors are destroyed. If there are any running inferiors, DDT will type "--Kill Running Inferiors--", and read a character from the TTY. If it is a space, DDT will go ahead; otherwise it will type "Flushed" and do nothing. If you were logged in, you remain so, and if you have a ; LOGIN file, DDT will type --Init-- and the file will be :XFILE'd iff the next char you type is a space. $U Logs in as . If is logged in elsewhere, 0, 1, etc. are tried until one succeeds. Then, a :INTEST (which see) is done to initialize things. $U puts 0 in ..CLOBRF and in ..MORWARN, on the theory that anyone who uses $U (as opposed to :LOGIN) must be a winner. $0U is like $U except that it doesn't do a :INTEST. This is useful to avoid running your init file. $1U Logs in without running any init file or read messages or anything. Super-fast login. $$U logs out (you need not be logged in). Console becomes free. If a file ; LOGOUT or :* LOGOUT exists, it will be :XFILE'd before logging out. The file need not have in it a command to log out. If there is no such file, DDT will do a :OUTTEST as a default action, and then log out. (In other words, check for running inferiors (see $U.), delete the files ; OMAIL .TEMP.; SENDS if they exist, and clear the screen). $$0U is similar to $$U, but always acts as if there were no LOGOUT file. It is always performs $$U's default actions. It is useful when the LOGOUT file runs into trouble when it is executed. $$1U logs directly out. Does not run the LOGOUT file, and does not do the default actions (:OUTTEST) either. $V manipulates the current job's "raid registers" (also redisplays them): Each job has several "raid registers", each of which may be used to display automatically the contents of one location. Each time the job returns to DDT, its raid registers are displayed at the top of the screen. Each raid register remembers one typeout mode and always displays its location that way (each location is also displayed as a constant in the remembered output radix). See also :RAIDFL which turns off all of a job's raid regs, and ..RAID, which starts a block of 3 words that are global parameters controlling raid registers. See also :RATE and :ATB which set up special sorts of raid registers for observing real-time rates of incrementation of counters, etc., and :RAIDRP which redisplays the raid registers continually with a fixed time interval. $V redisplays the raid registers without changing them. Normally, only raid registers which have changed are updated on the screen. But $V with no arguments forces them all to be updated. This is useful if other typeout has overwritten some of them. $0V toggles the switch ..RAID, which controls whether the raid registers are displayed automatically when the job returns. ..RAID is initially zero, enabling automatic display, except on printing terminals. When it is zero, the raid registers are displayed only by $V commands. $V stores the current typeout mode into raid register , without changing the address it is set on. -1$V free raid register number . $V set any free raid register on . If there was already a raid register set on , it is freed up first. The current typeout mode is remembered in the raid register that is set. may be indexed or indirect, in which case when the raid register is displayed the effective address will be calculated and the addressed location opened, displaying as " -> / ". may be a .USET variable such as .PIRQC, or a DDT location such as ..UPI0. $0V free the raid register set on . If there is more than one, only the lowest-numbered is freed. $V sets raid register on address . With this command it is possible to have more than one raid register set on a single location. $$V lists jobs that DDT knows about, along with their states. For each job, one line is typed as follows: (where will be omitted if the job is DDT's inferior). The current job will be identified by a "*". is as follows: P => proceedable (after a random interrupt). R => running. W => waiting to return to DDT ("needs attention"). - => just loaded. B => broken on breakpoint . $W: $W searches for locations whose contents coincide with in those bits that are set in the mask. Since the number of the mask is not specified, mask number 0 (the contents of $M, which may be set by $M) is used. The locations found are opened and typed inthe current mode. $W and $,$W and $,$,$W and ,,$,$W are analogous to similar uses of $N. $X executes a specified instruction: $X executes instruction in the current job's core image. Not allowed if the job is running. It types "" if the instruction skips. If is a DDT-reference (eg. SETZM ..TTYFLG or SETZM :DDTSYM TTYFLG) the insn is executed in DDT. While the instruction is executing, the PC before the $X is remembered in ..XECPC. $Y dumps the current job's nonzero core locations as . Uses and updates the same default as $L (but if the default directory was SYS:, DSK:SYS1;, DSK:SYS2; or SYS3; because the job was loaded by a ^K or :, they will be changed to DSK:; before the filespec in the $Y is processed. This will not be done if SYS:, SYS1;, SYS2; or SYS3; is explicitly specified by the user). If you quit out of a dump, a file _DUMP_ OUTPUT will be left. A previous file with the names being dumped under will not be clobbered. $,$Y dumps core from to $0Y writes core out into a file directly, without formatting ($Y dumps as a binary program). $$^Y: $,$$Y and other combinations of the above are analogous to $^Y. $$Z zeroes core of this job. If the job's ..SAFE is nonzero, asks "--Zero Protected Job--" before zeroing. $,$,$$Z sets core from to to . [ is like / but types out as a number, rather than in the current mode. [, $[, $[, $$[, and $$[ are like the corresponding / commands, but type the word opened as a number. \ opens the location addressed by $Q's RH except: does not set "." or push the "." ring buffer. Thus, linefeed will open 1 + the last location opened other than by \ . \ deposits in the open location, if any, then opens the location addressed by the RH of in the same way \ opens a location. $\ and $\ are similar, but open the LH of $Q or . $$\ and $$\ do a PDP-10 address calculation on $Q or . ] is like / but types out in symbolic mode rather than the current mode. ], $], $], $$], $$] are all analogous to the corresponding forms of /. ^ types the value of and opens .-1, on a new line. Sort of the opposite of linefeed. ^ stores in the open location, then does ^. $^ pops the "." ring buffer, then does ^. $^ stores , then does $^. $^ pops the ring buffer of "." times, then does "^". $^ stores , then does $^. _ retypes $Q in symbolic mode. _ retypes in symbolic mode. $_ left-shifts. Like _ in MIDAS. Priority 3. $$_ floating scales. Colon commands: The DDT operators ":", "$:", and "$$:", when not preceded by symbols, are prefixes that begin mnemonically named "colon-commands". After the colon comes the command name, followed by the arguments, if any. The command may be built into DDT, or it may run a system program. In fact, if DDT does not recognize the command name as a built in command, it runs the system program with that name. Note that many programs usually run in this way are popularly thought of as "DDT commands". However, only the actual built-in DDT commands are specifically described in this file (on the next page). The general workings of colon commands that run programs are described on this page, but for the format of their arguments the documentation of the individual programs must be consulted. There are the following special hacks: 1) an altmode after a colon starts a comment. Everything from the altmode to the next altmode, inclusive, is ignored. For example, :$ FOO $PRINT BAR is the same as :PRINT BAR. 2) : does nothing but close the open location (There may be a comment between the : and the ). Anything else runs either a built-in command or a program. Colon commands to run programs: 1) : where is not the name of any built-in colon command, tries to run the program named . It looks for TS on DSK:;, on SYS;, then on SYS1;, then on SYS2;, then on SYS3; and then on all the user directories in the sname search list if it is enabled (see :NFDIR), and then on the connected dir. If the file is found, it is loaded without symbols into the job named (which will be created if necessary) and started at its normal starting address. The job's command buffer will be cleared. If the job already existed (was not created fresh by :), : can behave either like :NEW or like :RETRY , depending on ..GENJFL's contents. If ..GENJFL is zero, :RETRY is done: the pre-existing job is used for running , thus overwriting any data that was in that job already. However, before doing this, if ..CLOBRF is nonzero, DDT will ask for confirmation by saying "--Clobber Existing Job--". A space means "yes". If ..GENJFL is nonzero, as it is by default, :NEW is done; the old job is left alone and another job is created for the purpose of running . See :NEW and :RETRY, below. In any case, the .XJNAME of the job will be . Programs that want to be runnable under many names and do different things according to which name was used should check their .XJNAME. 2) : is similar, but provides as an argument to . As above, must not be the name of a built-in command. Also, must end with a or "^C" or "^_". is put in DDT's command buffer for the job (instead of zeroing the buffer, as : does). Programs should read the command buffer with .BREAK 12,[..RJCL,,] and interpret the contents in a useful way (eg, as commands). For example, :MIDAS FOO will run MIDAS and tell it to assemble FOO >, giving FOO BIN . 3) :: runs :;TS in a job named , zeroing the command buffer. It does not matter if is the name of a built-in command when a device is explicitly specified. The job's $L default filename is set to :;TS . 4) :: is similar but puts in the job's command buffer. is terminated by a carriage-return or "^C" or "^_". 5) :; is like 3) but uses file DSK: ; TS . 6) :; figure it out. ::; " ::; " 7) $: and $$: may be used instead of just : in all the patterns described above. They suppress built-in commands, and always try to run a program. In addition, $: causes the program to be loaded with symbols. $$: suppresses even the commands :NEW and :RETRY, but $: causes them to load the programs specified to them with symbols. 8) :NEW is similar to :, except in what happens when a job named already existed. In that case, instead of destroying its old contents, a new job with an incremented (with :GENJOB) name will be created. Thus, :NEW T when a job named T existed will create job T0; another :NEW T will create job T1. In any case, the .XJNAME of the job will be . Programs that want to be runnable under many names and do different things according to which name was used should check their .XJNAME. :NEW suppresses built-in commands, so that, for example, :NEW START would load a new copy of a program names START whereas :START by itself is a built-in command. :NEW may be combined with the other options, as in $:NEW MC:SYS;MACSYM command-string 9) :RETRY is similar to :, except that if a job named already exists a clean copy of ts will be loaded into it, clobbering any data from the previous invocation of . Even if ..CLOBRF is nonzero, DDT will not ask for confirmation, since the :RETRY is taken to mean that clobbering is desired. :RETRY suppresses built-in commands like :NEW (see above). :RETRY may be combined with the other options, as in $:RETRY MC:SYS;MACSYM command-string Built-in colon commands: (NEVER invoked by altmode-colon or altmode-altmode-colon) :6TYPE will type the expression as sixbit, with no quoting or delimiters. If no is given, it uses $Q for its arg. :8TYPE or :8TYPE This is a quick-and-dirty crock to aid CHAOSNET hackers and CRTSTY hackers. If used in the :8TYPE form, it uses the value of $Q, otherwise it uses the given value, and prints it if it were a word of 8 bit characters. If the 200 bit is on, the character is proceeded by a ~. The characters are separated by spaces. At some point in the future this should be re-done as a typeout mode that you can put on & or % or such. Also, there should be a way to type this stuff in. Suggestions for exactly what it should do are welcome, in the meantime, I offer this crock as a way of getting it into this version. :? prints the file .INFO.;DDT :CMNDS, which is a condensation of the info on this page of DDT orders. :ALARM
:: (where
, and are decimal numbers and a instead of a colon causes all the following fields to be taken as 0) sets an alarm at the time specified. DDT will type bells and a message every 20 seconds from that time on until the alarm is cleared. :ALARM clears any alarm setting. :ALSO is a conditional which succeeds if the previous conditional succeeded. It should be followed by conditionalized commands, surrounded by a $( - $) pair, just like :IF. :ASSIGN assigns the microtape which is the current ^F default device. If that device isn't a microtape, it is an error. microtapes must be assigned to be used. :ASSIGN assigns that microtape. may be a number or a device name. That microtape becomes the default device, as with ^F. :ATB sets a raid register to display the average time between increments of the contents of . Each time the raid register is displayed it will show the average over the time since the previous display. See also :RATE, which will show the average rate of change. :RAIDRP is likely to be useful with this command. :ATTACH makes the current job replace DDT in the job tree. DDT and its other inferiors cease to exist, and the inferior attached takes on DDT's JNAME. :CHUNAME changes your UNAME to . Kills all jobs (typing "$$^X." if there are any jobs to be killed). Then, resets all user-options by reloading DDT Then, does a :INTEST, to attach HACTRO or run 's init file or whatever. :CLEAR clears the screen on graphics TTYs. Useful in files and valrets since ^L is ignored in them. Although when the TTY is in scroll mode DDT usually forbears to clear the screen, :CLEAR forces the clear to be done even in scroll mode. :CONTINUE restarts the current job where it last stopped, giving it the TTY. Equivalent to $P. :COPY , :COPYD , copies as , I/O is done in ASCII block mode. For DSK, AI, ML, MC, DM and archive devices, that is the same as image block mode, so :COPY will work for any files on those devices.) The creation date of is set to that of , as well as the file author. In addition, the real file names of are used as the defaults for , so that :COPYD AI:FOO >,ML: will preserve the FN2. If a is used instead of a comma, the new defaults will be typed out before is read. After the :COPYD, the defaults are set to . :COPYN , is like :COPYD except that the new file's creation date is set to right now, and the defaults for are the names specified for , not the real names of . If was FOO >, then :COPYD would preserve the version number of FOO, while :COPYN would increment the version number present on the target directory. :CORBLK
creates, deletes, purifies or unpurifies the current inferior's page containing the address
, according to the , which may be FRESH, NONE, PURE or IMPURE. :CORTYP prints information on the type of page that is on in the current job. :CORPRT maps :CORTYP over the existing pages of the current job. :CWD sets the working directory name (MSNAME) to . Equivalent to $$^S. :DATPRT :DATPRT was released earlier using $Q for it's argument. if no is given, it will still use $Q for it's argument. :DATPRT retypes $Q as a date. I.e. it assumes that Q is an ITS disk-format date word, and types it in human-readable format. :DATWRD has as a value the ITS disk-format date word corresponding to date, in the same format taken by :SMDATE, :SFDATE, and friends. 100/ :DATWRD 10/15/78 16:40:25 will deposit the date word for October 15, 1978, 4:40:25 pm in location 100. :DDTMODE leaves monit mode. See :MONMODE :DDTSYM evaluates one of DDT's own symbols (NOT one of the current job's symbols. That needs no special command). The value is returned as a pointer into DDT. The character terminating is re-read. Thus, :DDTSYM TTYOPT/ will open location TTYOPT in DDT. :DELETE deletes . Uses and updates the same default name as :PRINT, etc. See "filename reading" and "filename defaulting". :DESIGN deassigns the microtape which is the current ^F default device. If that device isn't a microtape, error. :DESIGN deassigns that microtape. Sets defaults like ^F. :DETACH detaches the entire tree from the console, which becomes free. The tree becomes disowned. It can be reconnected to a terminal with the REATTACH program, or it can be reowned with $J. If the same user logs in again, DDT will automatically offer to attach the detached tree. If the JNAME of the top-level job being detached is HACTRN, it will be incremented at least once, and again until it is unique; thus, it will become HACTRO or HACTRP, etc. :DETACH is illegal if not logged in. :DISOWN turns the current inferior job into a disowned job. It can be reowned later by you or anyone else using the $J or :UJOB commands. Until then, it can continue to run (if it was running when it was disowned) but cannot use the terminal since it does not have one. See the $$^K command. :ELSE is a conditional which succeeds if the previous conditional failed. It should be followed by conditionalized commands, surrounded by a $( - $) pair, just like :IF. :ERR prints out the error message associated with the last IOC error or open or symbolic system call failure in the current job. :ERR where is a channel number, prints out the error message associated with the last error on that channel. :ERR prints out the error message associated with the status word , where might be obtained, for example, by opening .IOS+. :EXISTS returns 0 iff can be opened, else the I/O status word containing the open failure code. Uses the same defaults as :PRINT, etc. Useful with conditionals (:IF). :FJOB FOO is like :JOB FOO, but will never reown the job. The job is marked as permenently foreign, and subsequent $J's to it will not reown. To reown it, do :FORGET and :JOB FOO :FJOB FOO BAR is like a combination of :UJOB FOO BAR and :FJOB :FLAP flaps a microtape if it's the ^F default device. :FLAP flaps that tape; sets defaults like ^F. may be either the microtape number or its device name. :FORGET tells DDT to forget about the current job. If it is a foreign job, this is equivalent to :KILL (this is stated backwards). For an inferior job, the job remains DDT's inferior, but DDT no longer knows it is there. If it had been $$^P'd, it can still type out. The job can't be killed while forgotten, unless you log out. To make DDT know about the job once again, simply select it explicitly with $J. :GAG if is 0, tells DDT to stop accepting :SEND's. Anyone who tries to :SEND to you will mail instead. If is not 0, DDT will resume accepting messages. :GENJOB rename the current job to a gensymmed name. Programs may wish to valret a :GENJOB when they start up, to make sure that running the program a second time doesn't interfere with the first invocation. :GENJOB does not print the new name. The new name is computed from the current name as follows: the first space in the name, or the last character if there is no space, is the incrementing position. First, put a zero in that position; if that name is in use put a 1 in that position, etc. Loop incrementing that character until a name is obtained that is not in use. That name is the new name of the job. The .XJNAME variable is NOT changed. :GO starts the current job at its starting address. Same as $G :GO starts the job at the spcified address, like $G :GZP starts the job at its starting addr without giving it the TTY. like $0G ^P. Equivalent to an "instantaneous" sequence of $G, ^Z, ^P (whence the name of the command). :GZP similar but starts at . :HELP prints out some very basic information on how to stay alive on ITS (tells what ^S does, lists a few :-commands, where to get more help, etc) :ICHAN is taken to be a channel number (it may be an expression) Status info for that channel in the inferior is printed. :IF $( $) (where is one of "E", "N", "G", "L", "GE", "LE", and "MORE"; and is balanced in parens) skips up to the $) if the condition is false. ^B, ^E, ^V, ^W are ignored in what is skipped. All the conditions except "MORE" compare the arg to 0. "MORE" enters a --More-- state waiting for a char to be typed in, and succeeds if the --More-- isn't flushed. (--More-- is not typed by this command. If such a message is desired it should be typed before the :IF). The "MORE" conditional needs an arg but ignores it. To conditionalize something not balanced in parens, such as $1#(, use extra $('s and $)'s to make the parens match (since $( and $) are conveniently ignored by everything except false conditionals). Actually, a false conditional skips until the close-paren that matches the first open-paren. The parens need not be part of $( and $); doing that is only to make sure they're ignored if condition is true,which is usually right. :INFLS flushes any pushed execute files and valret strings. :INPOP useful when a valret or execute file was pushed; pops back into it. :INPOP (where ends with a ) causes to be executed as DDT commands, then pops back to a pushed execute file or valret. eg., :INPOP $P will proceed the current job and pop into a valret or xfile. :INPUSH useful in a valret or execute file; pushes that input source and allows input from the TTY, until a :INPOP command is given, after which input from the valret or file will resume. An :INPUSH command is executed automatically on any error in DDT, and whenever an inferior returns to DDT in any way that .RESET's TTY input (The only things which don't are: .BREAK 16,'s which specifically say not to, return from a ^N, return from $X, and a .VALUE with nonzero arg, which will cause the file or valret in progress to be pushed while the new valret string is executed) When that happens, DDT will type ":INPUSH ". At those times, DDT will also turn on the typeout flag and type "^V " if it had been off. :INTEST performs the same actions that a $U command which succeeds in logging in takes, except that it doesn't log in. Those actions are: If your home directory is not the same as your , DDT will inform you by saying "[Home dir=]" If a job HACTRO exists, and if running, DDT types "--Attach Your Detached Tree--" and does so if the reply is a space. Otherwise, DDT looks for an initialization file (in ; LOGIN, or in ;* LOGIN if that is not found.) If DDT succeeds in finding one of those files, it considers :XFILE'ing it: if equals , DDT just types "INIT" and :XFILE's it unconditionally, but otherwise it asks "--Init--" and :XFILE's the init file only if the user types a space. However, if the init file which would be run is one of GUEST1;* LOGIN or USERS1;* LOGIN, it is run without asking, so that naive users can always get the "safe" switch settings. Otherwise, if a file ; MAIL exists, DDT types "--Mail--" and reads a character from the TTY. If the character is space, DDT prints the file and renames it to OMAIL. Also if there is no init file: if the user has a date entry in the :MSGS database (i.e. if he has ever done a :MSGS), or if he has a directory, a :MSGS command will be executed a :MSGS command will be executed to print any new system messages. If there are any new messages, "--Msgs--" will be typed before each one, and if the user's response is other than space or rubout, DDT will leave the messages for later. If the automatic :MSGS is not done (user has no dir and no database entry), the user will be informed of the existance of the :MSGS command in case he is a new user. A special hack causes a :INTEST given in an execute file or valret string to pretend that there is no init file; it will always try to print mail and messages. It is a useful thing to put in an init file to print mail and messages in the default manner, in addition to the ideosyncratic things the init file is needed for. :INTPRT analyses the value of $Q as a word of interrupt bits, printing out the names of the bits that are set, using the same names used when a job returns to DDT. If the sign is set, the word is interpreted as 2nd word interrupts; otherwise, as 1st word interrupts. :IOPEN $,$, This opens with mode on channel in the current job. The resulting TRUENAME is then printed. :JCL clears the current job's command buffer. (the one that .BREAK 12, can read) Turns off the job's .OPTION variable's bit 4.6 (OPTCMD). :JCL (where ends with a or "^C" or "^_"). puts in the command buffer, including the terminating or "^C" or "^_". Sets the .OPTION variable's bit 4.6 (OPTCMD bit) :JCLPRT prints the JCL of a job :JOB like $J except that there may be non-squoze characters in . :JOBP is like :JOB except that it sets $Q to 0 if it succeeds, else nonzero. :JUMP jumps to a :TAG in an execute file or valret string. A conditionalized :JUMP to a :TAG which precedes it makes a loop. :JUMP is not allowed to be typed from the terminal unless you are inside a :INPUSH from a valret string or execute file. In that case, :JUMP pops out to the file or valret and jumps to the tag in it. Aside from this case, nonlocal :JUMP's are not allowed. :KILL kills the current job, like $^X. If the job is "protected" (its ..SAFE variable has been set nonzero), DDT will ask for confirmation before killing it. :LFILE prints the name of the last file loaded into the current job (.BREAK 12, can also read this info). :LINK , makes a link named pointing to . If a file named exists, :LINK will type an error message rather than delete the file. :LINK uses the same defaults that :PRINT, :DELETE, etc. use. (see defaulting of filenames) the defaults for will be . After the :LINK, the defaults will revert to . Actually, the names in are subject to "translation" (see $^T) as if they were being opened, and the translated names are used. If is on a non-disk device, such as another machine, an error message occurs, unless is on the same device. Thus, it is possible to make links on job devices provided the job device handles the call correctly. The AI:, DM:, MC:, and ML: devices do win. ** This command is disabled with warning if ..DELWARN is set to 3 :LINKF , Just like :LINK, except if ..DELWARN is set to 3, it gives warning message rather than being disabled. :LINKN , is like :LINK, except no check is made that does not already exist. Thus, :LINKN may be used to replace an existing file or link. ** This command is disabled with warning if ..DELWARN is set to 3 :LISTB lists all breakpoints set in the current job as follows ,, :LISTF lists the specified directory. A dir-spec may contain a device name followed by ":" and/or an sname optionally followed by ";". It is terminated by "," or . Altmode may be used as in file-specs. The specified directory becomes the default one for :PRINT, :DELETE, etc. :LISTJ lists all the jobs that DDT knows about, along with their states. For each job, one line as typed as follows: ( will be omitted if the job is DDT's inferior). The current selected job will have a "*" before it. is one of: P = Proceedable (after a random interrupt) R = Running W = Waiting to return to DDT ("needs attention") - = just loaded. B = Broken on breakpoint :LISTP prints the block-structure of the current job's symbol table. Each program is indented one space; each block, 2 or more according to its level. The entry for the global block comes first. Every block or program precedes its subblocks. :LISTS lists the names of all the symbols in the current job's symbol table. Block and program names are flush against the left margin. All others are in rows that start with two spaces. :LISTU lists all undefined symbol references (created by ? ) in the current job. :LJCL allows you to give the current job arbitrary length JCL, ended with a control-C, so carriage returns can be included in the JCL. This is useful for mail from init files, for example. It provides the same editing that :SEND does. See also :LRUN :LOAD loads into the current job's core image. Returns the job's core, kills the symbol table, and closes I/O channels before loading. See the $L command for more info. :LOGIN identical to $U except that non-squoze chars may appear in , and does not clear ..CLOBRF and ..MORWRN (ie, a user of :LOGIN is assumed to be naive). :LOGOUT logs you out (you needn't be logged in) -- Console becomes free. If a file ; LOGOUT or ;* LOGOUT exists, it will be :XFILE'd before logging out. The file need not have in it a command to logout. If there is no such file, DDT will do a :OUTTEST as a default action, and then log out. (In other words, check for running inferiors (see $U), delete the files ; OMAIL and .TEMP.; SENDS if they exist, and clear the screen). :LRUN ^C is not new, but should now work properly, so is being anounced. It is like a cross between :LJCL and :RUN. The editing features of :SEND are also present. :MAILNT <-2, -1, 0, 1, or 2> -- Mail notify This command is only useful if you have already told COMSAT not to bother telling you of mail arivals (or if you gag yourself, but that's not really useful). To turn off COMSAT's notifications, make a NAMES entry of the form: (CSTACY (R-OPTION NO-CLI)) The advantage of :MAILNT is that you can turn off mail notification, but not higher priority :SENDS while in EMACS (see ..SENDRP/-2 and ..URANDM/ %URMAL), and then get the notification of arrival of mail when you return to DDT, while getting your SENDS immediatly. Also, DDT will do a better job (I think) of telling you who sent the mail than COMSAT will with (R-OPTION SMALL-CLI). :MAILNT 0 -- The default, do not notify. :MAILNT -1 -- Beep on arrival of mail, but print nothing. :MAILNT 1 -- Print who the message is from and how long it is. Assumes the message will be the first one in the file. :MAILNT 2 or -2 are like 1 and -1 except mail is deferred while in any inferior. Mail notification can be inhibited while in a specific inferior by doing ..URANDM/ $Q^_100 from DDT or a valret string or by setting the URANDM word with a .BREAK 12, :MASSACRE kills all jobs, like 8 :KILL's. :MONMODE enters monit mode, in which DDT generates a colon whenever it wants input at top level, except in valret strings and execute files. This causes input to be taken as colon-commands. Note that if you rub out one of those colons DDT will not replace it - you will thus leave monit mode temporarily, but any error will make DDT start generating colons again (for example, rubout when there's nothing to rub). :MORE useful in execute files and valrets. First, it turns on typeout by zeroing ..TTYFLG. Then, it reads (and echoes on the TTY) a line from the file, then reads a character from the TTY. If it is a space, continues with the file; otherwise does a :INPOP . One might want to put this before a command which clears the screen. A similar, more general feature is ":IF MORE". :MOVE , to and deletes the old copy. It does a delete-while-open, so there is no danger of it deleting the new file if it displaces the old, as in :MOVE FOO;BAR BAZ,SECOND: :MSGS prints system messages. It uses a file SYS:^Q:MSGS TIMES to store a database of login names and the date of the most recent message they have seen, and prints only such messages as have appeared since that time. The messages are printed in chronological order. Before each message, DDT will type "--Msgs--", and read a character from the TTY. Space or rubout will tell DDT to clear the screen and begin the message; anything else tells DDT to stop, and the remaining messages will not be seen until the next :MSGS command. DDT begins to print a message by printing its filenames, followed by the first line of text. After the first line of the message, if there is more, "--More--" will be typed, and a character read. Space will type the rest of the message, rubout will flush the rest and continue with the next message, if there are more. Anything else will be as after "--Msgs--". "^S" typed in while DDT is printing a message will throw away the rest of that message only. ^G'ing out of a :MSGS is safe and will cause all the messages to be seen again. This command is automatically executed by :INTEST and on login unless you have an init file or don't have an entry in the date database. NOTE that :MSGS will see only messages intended for the machine that you are on, even though .MSGS.; will contain all machines' messages. This is because :MSGS turns itself into :MSGS *AI when done on AI;, :MSGS *ML on ML, etc. :MSGS ,,,... is like :MSGS, but prints only messages which have at least one of the specified keywords in the "distrib" field. Messages with no distrib field are for everyone, so :MSGS with keywords will see all of them, too. The keywords so far defined are *AI, *ML, *DM, and *MC. A message's distrib field shows which machines it is "intended" for; messages mailed to *ITS will have all four keywords. Thus, :MSGS will see only the messages intended for the machine it is done on, but :MSGS *AI,*ML will see all messages intended for AI or ML, and can be run on any machine (even MC!). Someday additional keyword conventions may be implemented. :MSGS * shows all messages, no matter which machine they are for. :NEW is similar to : except in what happens when a job named already exists. In that case, instead of destroying its old contents, a new job with an incremented (with :GENJOB) name will be created. Thus, :NEW T when a job named T already exists will create job T0; another :NEW T will make job T1, etc. :NEWTTY informs DDT that its TTY may have changed its characteristics. DDT will reinitialize all its info on what type of TTY it is using. If the %TOROL bit is on (scroll mode is the default), DDT will enter scroll mode. When in scroll mode, DDT never clears the screen unless it is given an explicit :CLEAR command. :NFDIR ,,,... (any number of names) enables the sname search list feature if not enabled, and puts the specified names, in reverse order, at the front of the list, which is searched front to back. A name appears only once in the list, which holds 8 names. When the feature is enabled, ^K, etc., and $L on device DSK with no directory specified look on all the directories in the list if the file isn't found on the default directory. If it is found on a directory in the list, the sname of that directory will be typed out, followed by a semicolon. (This can be silenced by zeroing the NFVRBS variable in DDT.) A separate list of the 8 most recently used snames is also searched. :NOMSG if is 0, turns off all unsolicited typeouts by DDT, including alarms, sends, ITS revived messages, and even system going down messages unless the system is going down in less than 15 minutes. The effect of :GAG 0 is implicit (and the :GAG setting is ignored when :NOMSG 0 is in effect). =1 leaves this mode, and prints out the pending typeouts (a list of waiting jobs, etc.) that couldn't be printed before. Note that if a job sets bit 20 in its ..URANDM word, then :NOMSG 0 is temporarily in effect whenever that job has the tty. :OFDIR ,,,... (any number of names) removes those names from the search list. :OFDIR disables the sname search feature and clears the list. :OLOAD loads certain files whose symbol tables are incorrectly formatted, because they were made by old versions of STINK and had data loaded above 400000. Files produced by recent versions of STINK and MIDAS never have this problem. :OMAIL ^C ** This command is semi-obsolete -- use the "MAIL" program ** adds to the front of 's mail file; he will see it when he logs in (unless he has an init file which doesn't print his mail) or when he does :PRMAIL. When typing in the message, rubout deletes and echoes one character; ^G and ^D cancel the message; ^L causes the characters typed in so far to be printed (after clearing the screen); ^C and ^_ end the message and cause it to be sent. (^_ is useful in xfiles since ^C terminates them). in the mail file, each note looks like: " @