Documentation for DDT version 1491

Next: , Up: (dir)

Documentation for DDT version 1491

Next: , Previous: Top, Up: Top

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:

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.
<user>^A
prints <user>'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.
<dev>^F
lists directory of device <dev>, using the :PRINT default sname, and sets default :PRINT device (by special dispensation, that isn't done if <dev> is TTY !). Doesn't work if <dev> is also the name of a directory on DSK:. In that case, you get ...
<user>^F
lists user <user>'s directory on device DSK:, and makes <user> the default sname for :PRINT, etc. If <user> isn't a directory, and isn't a device name either, the default sname for :PRINT, ^F, etc. is still set. Thus, <user>^F <dev>^F will show the directory of <dev>:<user>; even if <user> isn't a disk directory.
0^F
is the same as <msname>^F.
$^F:
<dev>$^F
is like <dev>^F but doesn't set :PRINT defaults; just the default for ^F without argument.
<user>$^F
is like <user>^F but doesn't set the :PRINT default.
$$^F:
<arg>$$<n>^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^F	Shows DIR:FIRST FOO and sets FN1 to FOO
     	LISP$$2^F	Shows DIR:SECOND LISP
     	$$2^F		Shows DIR:SECOND BIN
     	$$3^F		Shows DIR:CDATE DOWN
     	UP$$3^F		Shows DIR:CDATE UP
     	PACK13$$6^F	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
<prgm>^H
continues <prgm>, creating one if necessary. If a job named <prgm> exists, it will be $P'd (or $G'd if it was loaded but never started). Otherwise, <prgm>^K is done: a job <prgm> is created, and <prgm> is loaded in and started. Since ^H only loads <prgm> if no job <prgm> already exists, ^H never clobbers anything useful. If the existing job is disowned, it will be reowned before being continued, of course.
$^H:
<prgm>$^H
like <prgm>^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.
<arg>^I
deposits <arg> in the open location if any, then types out and opens the RH of <arg>.
$^I
<arg>$^I
are like ^I, <arg>^I but use the LH rather than the RH.
$$^I
<arg>$$^I
are like ^I, <arg>^I but do an effective address calculation on $Q or <arg> 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 "."'.
<arg>^J
stores <arg> 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.
<arg>$^J
stores <arg> in the open location, if any, then does $^J.
$<n>^J
pops the ring buffer of "." <n> times, then does ^J.
<arg>$<n>^J
stores <arg> in the open location, if any, then does $<n>^J.
^K:
<prgm>^K
creates a job named <prgm>, loads TS <prgm> 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 <prgm> already existed, the newly loaded copy of <prgm> 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)
<prgm>$^K
is like <prgm>^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.
<arg>^M
deposits <arg> 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 .
<arg>$^M
stores <arg> in the open location if any, then does $^M.
$<n>^M
like "$^M", but pops the ring buffer of "." <n> times instead of once.
<arg>$<n>^M
stores <arg> in the open location, then does $<n>^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.
<arg>$$^M
like $$^M but deposits <arg> in the location after unpurifying the page.
^N
proceeds one instruction, then returns to DDT.
<n>^N
proceeds <n> 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>^N
similar but puts the breakpoints <n> words after the insn: at $.+<n>+1 and $.+<n>+2 . Good for calls followed by <n> args. This form of $^N overrides DDT's search for the next "reasonable" instruction by telling it explicitly how many args there are.
<pc>$^N
like $^N but puts the breakpoints at <pc> and <pc>+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.
<p>,$^N
puts the breakpoints at the address in the word pointed to by the RH of accumulator <p>. If you accidentally ^N through a PUSHJ, <p>,$^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.
<p>,$<n>^N
is similar, but puts the breakpoints <n> words later, overriding DDT's search for a reasonable instruction. Good for exiting a subroutine with <n> args after the call.
-<n>(<p>)$^N
uses <n> ( <p> ) as the location of the first of the two breakpoints. Like <p>,$^N except that the return address is assumed to be <n> 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.
<pc>$$^N
is like $$^N but continues till the PC is <pc> or <pc>+1. In general, $$^N takes the same sorts of arguments as $^N.
^O <file>
deletes the specified file. It warns you what it will do, with "(Delete File)" (but see ..DELWARN).
$^O <file1>,<file2>
link <file1> to <file2>. 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 <file1>,<file2>
renames <file1> to the name <file2>, 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 <jname> 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 <file>
is equivalent to ":PRINT <file>" - the specified file is typed on the terminal.
$^R <file1>,<file2>
is equivilent to ":COPY <file1>,<file2>" - 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.
<user>^S
sets the current job's sname to <user>
$^S
like <xuname>$^S; it undoes the effect of <user>$^S.
<user>$^S
causes the next ^K, ^H or :-command, if it runs a program, to run it "as if <user> were running it". Precisely, its .XUNAME variable will be <user> instead of you and its .HSNAME will be set to <user>'s HSNAME. If the program follows the current convention, it will use <user>'s init file, etc. $^S works by setting the ..TUNAME and ..THSNAME variables.
$$^S:
<user>$$^S
sets the master system name (the "msname"), the :PRINT default sname, and the sname for ^F, to <user>. 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:
<flags>^T <file1>,<file2>
creates a translation entry for the current job, translating <file1> to <file2>. The effect will be that if the job tries to open <file1>, it will actually get <file2>. Any of the names in the two files may be *, meaning "translation applies to any name" in <file1>, "translation doesn't alter this name" in <file2>. A translation that specifies only an SNAME in <file1> (aside from *'s) is likely to confuse DDT and screw you. <flags> 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:
<flags>$^T <file1>,<file2>
creates a translation that applies to DDT and all of its inferiors to all levels.
$$^T:
<flags>$$^T <file1>,<file2>
creates a translation for the current job and all of its inferiors to all levels.
^U
removes filename translations:
<flags>^U <file>
deletes any translation the current job may have which says the <file> 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<cr> to see them all.
$^U:
<flags>$^U <file>
removes a translation created by $^T (one which applies to DDT and all its inferiors).
$$^U:
<flags>$$^U <file>
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.
$<n>^X
is like $^X., except that after killing the current job, $<n>J rather than $J is used to select another.
<job>$^X
kills the job named <job>. 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.
<arg>^Y
is similar but uses <arg> instead of $Q.
$^Y
is like ^Y but flushes the symbols DDT already has.
<arg>$^Y
similar to ^Y.
$$^Y:
<addr>$$^Y
puts a copy of the job's symbol table into the job's core. It assumes that <addr> 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 <rubout>. Then deposit the other instructions of the patch, and finish with a ^] (which see). While patching, the pseudo-location ..PATCH contains <location being patched>,,<start of patch>.

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).

<arg>^\
deposits <arg> in the open location, then does ^\. Equivalent to ^\<rubout><arg>, except that with <arg>^\, <arg> 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).
<arg>^]
stores <arg> 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.
<arg>$^]
stores <arg> 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 $$^].
<arg>$$^]
stores <arg> 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 ^^.
<n>^^
like ^^ but will stop after the <n>'th step if nothing stops it earlier.
$^^:
<flags>$^^
like ^^ but first changes the job's stepping flags according to the letters in <flags> (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).

<n> <flags>$^^
combines <flags>$^^ and <n>^^
<flags>$$^^
sets the new-job-default stepping flags according to the letters in <flags>. Does not actually do any stepping.
<flags>$$0^^
sets the current job's stepping flags according to the new-job-default and the letters in <flags>.
$
(altmode-space) separates prefix command arguments, like altmode-comma.
^_
Incluseive or.
!
divides. Priority 2.
$!
floating divides. Priority 2. If unary, reciprocates.
$$!
<arg>$$!
opens a location as / or <arg>/ 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.
<arg>"
retypes <arg> 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/<foo>/ is printed as $0"<foo>$ . ASCII/<foo>/+1 appears as $1"<foo>$ (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.
$<n>"<foo>$
is an ASCII syllable whose value is ASCII/<foo>/+1&<n> (that is, <n> specifies the word's low bit). To put a control character in <foo>, 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.
$$<n>"
is used for multi-word ASCII type-in. It acts just like $<n>" 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 <n>,<sym> types out as $<n>&<sym>
$<n>&<sym>
a syllable whose value is the SQUOZE for <sym>, with <n> in the flags. <n> should be from 0 to 74; the two lowest bits of <n> are ignored.
$$&
specifies & typeout mode as the current mode permanently, so that ^M will not undo it.
'
retypes $Q in ' mode (normally SIXBIT mode).
<arg>'
retypes <arg> in ' mode.
$'
temporarily selects ' typeout mode. This mode, held in ..TPRIME, is initially SIXBIT mode, in which SIXBIT/<foo>/ types out as $1'<foo>$ .
$1'<foo>$
is a SIXBIT syllable whose value is SIXBIT/<foo>/ . Only the first 6 characters of <foo> 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.
(
)
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 (.
$(
$)
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.
<arg>$$)
is equivalent to <arg> <linefeed> $$). It deposits <arg>, 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:
<lh>,,
truncates <lh> to 18. bits and puts it in the left half.
<lh>,,<rh>
halfword type-in format. <lh> is put in the left half, and <rh> in the right half. Each is truncated to 18. bits first.
<insn> <ac>,
a format which adds <ac> into the AC field of <insn>.
<insn> <ac>,<addr>
a format like <insn> <ac>, but adds <addr> to the right half.
<ac>,
a format which results in <ac> in the AC field.
<ac>,<addr>
puts <ac> in the AC field and <addr> 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 .)
<arg>/
opens the location addressed by the RH of <arg>.
$/
<arg>$/
opens the location addressed by the LH of $Q or <arg>.
$$/
<arg>$$/
does a PDP-10-style address calculation on $Q or <arg> to determine what location to open.
:
defines symbols:
<sym>:
defines <sym> 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.
<arg> <sym>:
defines <sym> to have the value <arg>.
$:
selects symbol table blocks:
<block>$:
selects the symbols in block or program <block>.
$$:
<block>$$:
like <block>$: 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.
<arg>;
is similar but retypes <arg>, not $Q.
$;
<arg>$;
are like ; and <arg>; but also reset the temporary mode from the semicolon mode, and don't temporarily SOS ..TTYFLG.
$$;
<arg>$$;
are similar but also set the permanent mode.
>
<
(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).
$<
>
surround an expression to be used as an infix argument in an operator. For example, $<1+1>R is equivalent to $2R
$$<
>
are similar, for operators with two altmodes.
=
retypes $Q as a number in the current radix.
<arg>=
retypes <arg> instead.
$<r>=
retypes $Q as a number in radix <r>.
<arg>$<r>=
retypes <arg> instead.
$=
retypes $Q as a floating point number.
<arg>$=
retypes <arg> instead.
$$=
retypes up to three arguments in the modes used to input them.
$>
when changing part of an instruction, saves typing the unchanged parts:
<arg>$>
takes those parts of <arg> 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, "<arg>,$>" will use <arg> to specify the device code.
?
performs many functions, in different situations:
<sym>?
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 "<symbol>:"), 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).

<arg>?
where <arg> does not end with a symbol (use a space before the "?" to play it safe), retypes <arg> in $H$? mode.
$?
temporarily reselects bit typeout mode, with the details as they were last specified.
<prefix>$?
temporarily specifies bit typeout mode, and sets the main bit name prefix to <prefix>. The alternate prefix is set to the previous main prefix. The pattern associated with the new prefix is the value of <prefix> 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.

$<pattern>?
temporarily selects bit typeout mode, and sets the pattern for the main bit name prefix to <pat>.
<prefix>$<pat>?
the same as <prefix>$? $<pat>?. Like <prefix>$? but uses <pat> as the pattern, rather than the value of <prefix> or 525252,,525252.
$0?
interchanges the main and alternate bit name prefixes. When combined with a <prefix>, this exchange happens first, so
<prefix>$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
$$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.
<loc>$B
sets breakpoint at location <loc>. Up to 8 breakpoints may be set in any one job.
<loc>$<n>B
(where <n> is between 1 and 8) sets breakpoint <n> at <loc>. If breakpoint <n> had been set, it is removed first.
$<n>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 <n>. The first word holds <address to open>,,<address broken>, or 0 if the breakpoint is not set. The 2nd word holds the conditional instruction; the 3rd, the proceed count)
<adr>,,<loc>$B
sets a breakpoint at <loc> that will type out and open <addr> when it is reached by the program.
<loc>$0B
removes any breakpoint set at <loc>.
0$<n>B
removes breakpoint <n>.
$$B
removes all breakpoints from the current job.
<loc>$$B
sets an auto-proceeding breakpoint at <loc>. When an auto-proceeding breakpoint is hit, it prints the usual information, but does not stop the job unless the user types a character.
<loc>$$<n>B
sets breakpoint <n> at <loc> and causes it to be auto-proceeding.
$C
$$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
$$D
temporarily or permanently selects decimal typeout of numbers. See $O.
$E
$$E
temporarily or permanently selects E&S display processor instruction typeout mode. See $S.
<n>$E
searches current program for locations with effective address of <n>. 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.
<loc>$,<n>$E
searches for such locations after <loc>, stopping at RH(..LIMIT).
<loc1>$,<loc2>$,<n>$E
searches for such locations from <loc1> to <loc2>. When such a location <locx> is found, "<locx> / <contents-of-locx>" is typed, and "." is set to <locx> (pushing the "." ring buffer).
$F
$$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.
<loc>$G
starts the program at <loc>.
$<n>G
does <n>^^ 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.
<loc>$<n>G
sets the PC and types the instruction which the new PC points at
$$G:
<loc>$$G
starts the program at <loc>, and make <loc> the default starting address.
<loc>$$<n>G
is analogous to <loc>$<n>G
$H
$$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.
<loc>$I
is the same as <loc>$3I
<loc>$<n>I
sets the MAR at location <loc>. If <n> is 1, a trap will occur on fetching an instruction from <loc>; if <n> is 2, on writing in <loc>; if <n> is 3, on any reference to <loc>. 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.
<name>$J
makes job <name> 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.
$<n>J
pops the job-selection ring buffer <n> times. Whenever a job is selected by any command other than $<n>J, it is also pushed on the job selection ring buffer (which is internal to DDT), so that $<n>J can be used to retrace the recent history of job selection. $<n>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 <commands>, 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.
<name>$$J
set current job's name to <name>. 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:
<sym>$K
half kills symbol <sym> 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.
<sym>$$K
fully kills the symbol <sym>, which will no longer be accepted as input.
$L <file>
loads <file> 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 <file>. 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 <name>$J, the default is initialzed to DSK:<msname>;<name> BIN. When a job is loaded into by <prgm>^K, etc. the default is set to the name of the file loaded.
<arg>$L <file>
loads with an offset of <arg>. That is, anything that should load into <loc> loads into <loc>+<arg>. Doesn't work for :PDUMP'd files.
$0L <file>
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.
<arg>$0L <file>
reads into core starting at <arg>.
$1L <file>
like $L, but doesn't load symbols.
<arg>$1L <file>
loads starting at <arg>, without symbols.
$$L <file>
as $L but does not zero core, kill symbols, or close I/O channels. Can't be done to a running job.
$$0L <file>
analogous.
$M
pertains to word-search comparison masks:
<mask>$M
sets mask number 0 used for $W and $N searches to <mask>. Only those bits that are on in <mask> will be compared. The mask is initially -1.
<mask>$<n>M
sets mask number <n>. <n> 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.
$<n>M
is the pseudo-address of the word in DDT which holds mask number <n> ($M is the same as $0M).
$N:
<word>$N
searches for locations whose contents differ from <word> in one of the bit positions which are selected by <mask>, where <mask> is what is in $M (set by <mask>$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).
<word>$<n>N
where <n> is between 0 and 7, uses mask number <n> (the contents of $<n>M, set by <mask>$<n>M). If <n> is not between 0 and 7, <n> itself is used as the search mask.
<loc>$,<word>$N
searches starting at <loc>.
<loc1>$,<loc2>$,<word>$N
searches from <loc1> to <loc2>. <loc1> and <loc2> may be addresses inside DDT, in which case DDT will search through itself.
<loc2>,,<loc1>$,<word>$N
does the same thing. In <loc2>,,<loc1>$,<loc3>$,<word>$n, <loc3> overrides <loc2>.
$O
$$O
temporarily or permanently selects octal type-out of numbers. See $<n>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.
<n>$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 <n>. ($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)>.
$$<n>Q
is $<n>Q with its halves swapped.
$R
$$R
Temporarily or permanently selects relative address typeout mode, and deselects bit typeout mode. Addresses will be typed as <symbol>+<offset> when possible. The symbol whose value is closest to the address is used. The maximum <offset> allowed is kept in ..SYMOFS; an address requiring a larger <offset> 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.
$<n>R or $$<n>R
temporarily or permanently selects output radix <n>. Input radix is always 8 (or 10. for numbers ending in ".").
$S
$$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
$$T
temporarily or permanently selects typeout as bytes, using the most recently specified byte size or pattern.
$<n>T or $$<n>T
(where <n> is between 1 and 36.) temporarily or permanently selects typeout of words as several bytes of <n> bits each.
$<pattern>T or $$<pattern>T
(where <pattern> is negative) temporarily or permanently selects typeout of words divided into bytes according to <pattern>. The block of consecutive 1's at the front of <pattern> 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
$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 <hsname>;<xuname> LOGIN file, DDT will type –Init– and the file will be :XFILE'd iff the next char you type is a space.
<user>$U
Logs in as <user>. If <user> is logged in elsewhere, <user>0, <user>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.
<user>$0U
is like <user>$U except that it doesn't do a :INTEST. This is useful to avoid running your init file.
<user>$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 <hsname>;<xuname> LOGOUT or <hsname>:* 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<cr> as a default action, and then log out. (In other words, check for running inferiors (see $U.), delete the files <hsname>;<xuname> OMAIL .TEMP.;<runame> SENDS if they exist, and clear the screen).
$$0U
is similar to $$U, but always acts as if there were no <xuname> LOGOUT file. It is always performs $$U's default actions. It is useful when the <xuname> LOGOUT file runs into trouble when it is executed.
$$1U
logs directly out. Does not run the <xuname> 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.
$<n>V
stores the current typeout mode into raid register <n>, without changing the address it is set on.
-1$<n>V
free raid register number <n>.
<addr>$V
set any free raid register on <addr>. If there was already a raid register set on <addr>, it is freed up first. The current typeout mode is remembered in the raid register that is set. <addr> 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 "<addr> -> <e.a.>/ <contents>". <addr> may be a .USET variable such as .PIRQC, or a DDT location such as ..UPI0.
<addr>$0V
free the raid register set on <addr>. If there is more than one, only the lowest-numbered is freed.
<addr>$<n>V
sets raid register <n> on address <addr>. 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: <uname> <jname> <state> <job number> (where <uname> will be omitted if the job is DDT's inferior). The current job will be identified by a "*". <state> is as follows: 
     
     	P => proceedable (after a random interrupt).
     	R => running.
     	W => waiting to return to DDT ("needs attention").
     	- => just loaded.
     	<n>B => broken on breakpoint <n>.

$W:
<word>$W
searches for locations whose contents coincide with <word> 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 <mask>$M) is used. The locations found are opened and typed inthe current mode.
<word>$<n>W
<loc>$,<word>$W
<loc1>$,<loc2>$,<word>$W
<loc2>,,<loc1>$,<word>$W
are analogous to similar uses of $N.
$X
executes a specified instruction:
<ins>$X
executes instruction <ins> in the current job's core image. Not allowed if the job is running. It types "<SKIP>" if the instruction skips. If <ins> 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 <file>
dumps the current job's nonzero core locations as <file>. 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 :<prgm>, they will be changed to DSK:<msname>; 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.
<loc1>$,<loc2>$Y <file>
dumps core from <loc1> to <loc2>
$0Y <file>
writes core out into a file directly, without formatting ($Y dumps as a binary program).
$$^Y:
<loc1>$,<loc2>$$Y <file>
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.
<loc1>$,<loc2>$,<word>$$Z
sets core from <loc1> to <loc2> to <word>.
[
is like / but types out as a number, rather than in the current mode.
<arg>[, $[, <arg>$[, $$[, and <arg>$$[
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 \ .
<arg>\
deposits <arg> in the open location, if any, then opens the location addressed by the RH of <arg> in the same way \ opens a location.
$\ and <arg>$\
are similar, but open the LH of $Q or <arg>.
$$\ and <arg>$$\
do a PDP-10 address calculation on $Q or <arg>.
]
is like / but types out in symbolic mode rather than the current mode.
<arg>], $], <arg>$], $$], <arg>$$]
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.
<arg>^
stores <arg> in the open location, then does ^.
$^
pops the "." ring buffer, then does ^.
<arg>$^
stores <arg>, then does $^.
$<n>^
pops the ring buffer of "." <n> times, then does "^".
<arg>$<n>^
stores <arg>, then does $<n>^.
_
retypes $Q in symbolic mode.
<arg>_
retypes <arg> in symbolic mode.
$_
left-shifts. Like _ in MIDAS. Priority 3.
$$_
floating scales.

Next: , Previous: Command-list, Up: Top

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<cr> is the same as :PRINT BAR<cr>.
  2. :<cr> does nothing but close the open location (There may be a comment between the : and the <cr>).
Anything else runs either a built-in command or a program.

Colon commands to run programs:

  1. :<prgm><cr>
    where <prgm> is not the name of any built-in colon command, tries to run the program named <prgm>. It looks for TS <prgm> on DSK:<hsname>;, 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 <prgm> (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 :<prgm>), :<prgm> can behave either like :NEW <prgm> or like :RETRY <prgm>, depending on ..GENJFL's contents. If ..GENJFL is zero, :RETRY <prgm> is done: the pre-existing job is used for running <prgm>, 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 <prgm> is done; the old job is left alone and another job is created for the purpose of running <prgm>. See :NEW and :RETRY, below.

    In any case, the .XJNAME of the job will be <prgm>. Programs that want to be runnable under many names and do different things according to which name was used should check their .XJNAME.

  2. :<prgm> <text>
    is similar, but provides <text> as an argument to <prgm>. As above, <prgm> must not be the name of a built-in command. Also, <text> must end with a <cr> or "^C" or "^_". <text> is put in DDT's command buffer for the job <prgm> (instead of zeroing the buffer, as :<prgm><cr> does). Programs should read the command buffer with .BREAK 12,[..RJCL,,<loc>] and interpret the contents in a useful way (eg, as commands). For example, :MIDAS FOO<cr> will run MIDAS and tell it to assemble FOO >, giving FOO BIN .
  3. :<dev>:<prgm><cr>
    runs <dev>:<msname>;TS <prgm> in a job named <prgm>, zeroing the command buffer. It does not matter if <prgm> is the name of a built-in command when a device is explicitly specified. The job's $L default filename is set to <dev>:<msname>;TS <prgm>.
  4. :<dev>:<prgm> <text>
    is similar but puts <text> in the job's command buffer. <text> is terminated by a carriage-return or "^C" or "^_".
  5. :<user>;<prgm><cr>
    is like 3) but uses file DSK: <user>; TS <prgm>. 
  6.

    :<user>;<prgm> <text> figure it out.
    :<dev>:<user>;<prgm><cr> "
    :<dev>:<user>;<prgm> <text> "

  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 <prgm><cr>
    is similar to :<prgm><cr>, except in what happens when a job named <prgm> 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<cr> when a job named T existed will create job T0; another :NEW T<cr> will create job T1.

    In any case, the .XJNAME of the job will be <prgm>. 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<cr> 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<cr>

  9. :RETRY <prgm><cr>
    is similar to :<prgm><cr>, except that if a job named <prgm> already exists a clean copy of ts <prgm> will be loaded into it, clobbering any data from the previous invocation of <prgm>. 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<cr>

Next: , Previous: Colon-commands, Up: Top

Built-in colon commands:

(NEVER invoked by altmode-colon or altmode-altmode-colon)

:6TYPE <expression>
will type the expression as sixbit, with no quoting or delimiters. If no <expression> is given, it uses $Q for its arg.
:8TYPE <value>
:8TYPE<cr>
This is a quick-and-dirty crock to aid CHAOSNET hackers and CRTSTY hackers. If used in the :8TYPE<cr> 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 <hr>:<min>:<sec>
(where <hr>, <min> and <sec> are decimal numbers and a <cr> 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 .+<hr>:<min>:<sec>
sets an alarm when the specified time interval has elapsed.
:ALARM<cr>
clears any alarm setting.
:ALSO<cr>
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 <tape>
assigns that microtape. <tape> may be a number or a device name. That microtape becomes the default device, as with <tape>^F.
:ATB <addr>
sets a raid register to display the average time between increments of the contents of <addr>. 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 <newuname>
changes your UNAME to <newuname>. 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 <newuname> HACTRO or run <newuname>'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 <file1>,<file2>
:COPYD <file1>,<file2>
copies <file1> as <file2>, 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 <file2> is set to that of <file1>, as well as the file author. In addition, the real file names of <file1> are used as the defaults for <file2>, so that :COPYD AI:FOO >,ML: will preserve the FN2. If a <cr> is used instead of a comma, the new defaults will be typed out before <file2> is read. After the :COPYD, the defaults are set to <file1>.
:COPYN <file1>,<file2>
is like :COPYD except that the new file's creation date is set to right now, and the defaults for <file2> are the names specified for <file1>, not the real names of <file1>. If <file1> was FOO >, then :COPYD would preserve the version number of FOO, while :COPYN would increment the version number present on the target directory.
:CORBLK <subcommand> <address>
creates, deletes, purifies or unpurifies the current inferior's page containing the address <address>, according to the <subcommand>, which may be FRESH, NONE, PURE or IMPURE.
:CORTYP <loc>
prints information on the type of page that <loc> is on in the current job.
:CORPRT
maps :CORTYP over the existing pages of the current job.
:CWD <directory>
sets the working directory name (MSNAME) to <dir>. Equivalent to <dir>$$^S.
:DATPRT <expression>
:DATPRT was released earlier using $Q for it's argument. if no <expression> is given, it will still use $Q for it's argument.
:DATPRT<cr>
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 <date>
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<cr><cr> will deposit the date word for October 15, 1978, 4:40:25 pm in location 100.
:DDTMODE
leaves monit mode. See :MONMODE
:DDTSYM <sym>
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 <sym> is re-read. Thus, :DDTSYM TTYOPT/ will open location TTYOPT in DDT.
:DELETE <file>
deletes <file> . 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 <tape>
deassigns that microtape. Sets defaults like <tape>^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<cr>
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<cr>
prints out the error message associated with the last IOC error or open or symbolic system call failure in the current job.
:ERR <chnl>
where <chnl> is a channel number, prints out the error message associated with the last error on that channel.
:ERR <code>
prints out the error message associated with the status word <code>, where <code> might be obtained, for example, by opening .IOS+<chnl>.
:EXISTS <file>
returns 0 iff <file> 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 <tape>
flaps that tape; sets defaults like ^F. <tape> 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 <n>
if <n> is 0, tells DDT to stop accepting :SEND's. Anyone who tries to :SEND to you will mail instead. If <n> 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<cr>
starts the current job at its starting address. Same as $G
:GO <addr>
starts the job at the spcified address, like <addr>$G
:GZP<cr>
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 <addr>
similar but starts at <addr>.
: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 <chan>
<chan> is taken to be a channel number (it may be an expression) Status info for that channel in the inferior is printed.
:IF <condit> <arg>
$( <conditionalized stuff> $)
(where <condit> is one of "E", "N", "G", "L", "GE", "LE", and "MORE"; and <conditionalized stuff> 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<cr>
useful when a valret or execute file was pushed; pops back into it.
:INPOP <line>
(where <line> ends with a <cr>) causes <line> to be executed as DDT commands, then pops back to a pushed execute file or valret. eg., :INPOP $P <cr> 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: 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 <chan>$,<control bits>$,<filename>
This opens <filename> with mode <control bits> on channel <chan> in the current job. The resulting TRUENAME is then printed.
:JCL<cr>
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 <line>
(where <line> ends with a <cr> or "^C" or "^_"). puts <line> in the command buffer, including the terminating <cr> or "^C" or "^_". Sets the .OPTION variable's bit 4.6 (OPTCMD bit)
:JCLPRT
prints the JCL of a job
:JOB <name>
like <name>$J except that there may be non-squoze characters in <name>.
:JOBP <name>
is like :JOB <name> except that it sets $Q to 0 if it succeeds, else nonzero.
:JUMP <tag>
jumps to a :TAG <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 <file1>,<file2>
makes a link named <file1> pointing to <file2>. If a file named <file1> 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 <file2> will be <file1>. After the :LINK, the defaults will revert to <file1>. Actually, the names in <file2> are subject to "translation" (see $^T) as if they were being opened, and the translated names are used. If <file2> is on a non-disk device, such as another machine, an error message occurs, unless <file1> 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 <file1>,<file2>
Just like :LINK, except if ..DELWARN is set to 3, it gives warning message rather than being disabled.
:LINKN <file1>,<file2>
is like :LINK, except no check is made that <file1> 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 <n> <addr-to-open>,,<addr-of-bpt> <condit. insn> <count>
:LISTF <dir-spec> <cr>
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 <cr>. 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: 
     
     		<uname> <jname> <state> <job #>
(<uname> will be omitted if the job is DDT's inferior). The current selected job will have a "*" before it. <state> is one of: 
     
     	   P = Proceedable (after a random interrupt)
     	   R = Running
     	   W = Waiting to return to DDT ("needs attention")
     	   - = just loaded.
     	<n>B = Broken on breakpoint <n>

: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 <sym>? ) 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 <file>
loads <file> 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 <name>
identical to <name>$U except that non-squoze chars may appear in <name> , 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 <hsname>;<xuname> LOGOUT or <hsname>;* 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 <hsname>;<xuname> OMAIL and .TEMP.;<runame> SENDS if they exist, and clear the screen).
:LRUN <program> <optional line(s) of JCL>^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<cr> . One might want to put this before a command which clears the screen. A similar, more general feature is ":IF MORE".
:MOVE <old file>,<new file
Copies a file from <old file> to <new file> 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<cr>
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<cr> will see only messages intended for the machine that you are on, even though .MSGS.; will contain all machines' messages. This is because :MSGS<cr> turns itself into :MSGS *AI<cr> when done on AI;, :MSGS *ML on ML, etc.
:MSGS <kwd1>,<kwd2>,<kwd3>,...
is like :MSGS<cr>, 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<cr> 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 <prgm>
is similar to :<prgm> except in what happens when a job named <prgm> 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 <name1>,<name2>,<name3>,...
(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 <n>
if <n> 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). <n>=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 <name1>,<name2>,<name3>,...
(any number of names) removes those names from the search list.
:OFDIR<cr>
disables the sname search feature and clears the list.
:OLOAD <file>
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 <user> <message>^C
** This command is semi-obsolete – use the "MAIL" program ** adds <message> to the front of <user>'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<cr>. 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: 
     
     		"
     		<sender>@@<machine> <date> <time> <message>
     		^_"

:OMAILA <user> <message>^C
** This command is semi-obsolete ** adds to the note this user most recently mailed to <user>; that is, the message etc. is added not at the front of the mail file but just before the ^_ terminating the previous note. If there is no note from this user in <user>'s mail file, the new note is added at the end.
:OMSG <topic> <message>^C
is the old way of mailing a message to all users. :MAIL *ITS, which runs the mail program, should be used instead. :OMSG writes a file .MSGS.;<topic> > containing your runame, the date and time, and <message>. :MSGS will print the file, so every user ought to see the message once. ^_ may be used instead of ^C. Please do not use this.
:OSEND
Always runs DDT's :SEND command even if it has been disabled by ..SNDFLG/-1
:OUTTEST
performs the actions normally associated with logging out. It does not execute the <xuname> LOGOUT file. :OUTTES always does what $$U and :LOGOUT do if there is no LOGOUT file (except that :OUTTES does not actually log out). Specifically, it checks for running inferiors, querying "–Kill Running Inferiors–" if there are any (and causing an error if the query is flushed), deletes the files <hsname>;<xuname> OMAIL and .TEMP.;<runame> SENDS, and clears the screen. Due to an extremely hairy bug in the logout code, if the file <xuname> LOGOUT exists AND BYERUN is set, :OUTTEST will not behave as advertised, but instead will execute the LOGOUT file and log out. In other words it will act the same as $$U. If you have a LOGOUT file and you want a bye message, just put :BYE in your logout file.
:PDUMP <file>
like $Y but does a "pure-dump" - all jobs which have that file loaded will share the pure pages in it. If you quit out of a pdump, a file _DUMP_ OUTPUT will be left. A previous file with the names being dumped under will not be clobbered.
:PDUMPI <file>,<ifile>
like :PDUMP, but writes an indirect symbol table pointer, pointing to <ifile> instead of a regular symbol table. This is useful for dumping programs which map in other files, such as dumped LISP's.
:PMDATE
prints the date of the last message seen. Only messages new than that will be printed
:PRGM
prints the name of the currently selected block of symbols. If it is the global block, that's all. If it is a program, types ", program". Otherwise, prints ", level " and the block's level.
:PRINT <file>
types the file's contents. Uses the same default as :DELETE.
:PRMAIL<cr>
prints your mail file (<hsname>;<xuname> MAIL and renames it as OMAIL . On display terminals, "No mail" is typed if no mail file exists. Depositing 0 in :DDTSYM OMAILF causes :PRMAIL<cr> not to rename the mail file, but only print it. Depositing a positive number causes it to ask if you'd like to delete it.
:PRMAIL <user>
prints <user>'s mail file if it exists; else types "No mail". It is not renamed to OMAIL.
:PRMAIL <user>@<site>
where <site> is one of AI, ML, MC, or DM, forces DDT to look for the mail on that site. Useful for those few people who direct their mail to more than one ITS.
:PROCED
restarts the current job where it last stopped, but DDT keeps the TTY. The job runs, but can't do any I/O on the TTY, and DDT continues to execute the user's commands. Equivalent to ^P.
:PROCEED
same as :PROCED - restarts the current job without giving it the TTY.
:PRSEND<cr>
prints your SENDS file, which contains al the :SEND messages you have received in this session. It is .TEMP.;<uname> SENDS or COMMON;<uname> SENDS if the directory .TEMP.; doesn't exist.
:PRSEND <user>
print's <user>'s SENDS file.
:PRSEND <user>@<site>
where <site> is AI, ML, MC, or DM, prints <user>'s SENDS file from that site.
:RAIDFLUSH
turns off all of the raid registers of the current job. The storage for them is deallocated, so their settings are all forgotten.
:RAIDRP <# secs>
puts DDT in a loop redisplaying the raid registers of the current job every <n> seconds. Typing any character will cause DDT to exit the loop and process the character.
:RATE <addr>
sets a raid register to display the rate of change of the contents of <addr>. Each time the raid register is displayed it will show the average rate of change of the contents since the previous display. See also :ATB which shows the inverse rate.
:REAP <file>
sets <file>'s reference date to long ago, so that if automatic grim reaping is done <file> will be reaped.
:RENAME <file1>,<file2>
renames <file1> to the name <file2>. Uses the same defaults as :PRINT, :DELETE, etc. <file2> defaults to <file1>.
:RETRY <prgm>
is similar to :<prgm> except that if a job named <prgm> already exists, a clean copy of TS <prgm> will be loaded into it, clobbering any data from the previous invocation of <prgm>. Even if ..CLOBRF is nonzero, DDT will not ask for confirmation, since :RETRY is taken to mean that clobbering is desired.
:RUN <program> <optional one line of JCL><return>
(See also :LRUN) <program> can be either a program or a DDT command. If it's a DDT command, it will be performed with one level of ^V turned off.
:SELF
is equivalent to HACTRN$J except works if the JNAME isn't HACTRN This is the right way to select the running DDT in an XFILE.
:SEND <user> <message>^C
If <user> is logged in and has not done :GAG 0, prints "[MESSAGE FROM <your uname> at MIT-xx HH:MMxm]", followed by <message>, on his TTY, and puts it at the head of the file .TEMP.;<user> SENDS . Otherwise, types "(Mail) " as soon as you have typed the space after <user>, and then runs the MAIL program to send mail to <user>. (See .INFO.;QMAIL ORDER for info on the MAIL program.) If the :SEND was able to determine the XUNAME of the user you specified, the MAIL is addressed to that XUNAME. Otherwise, it is addressed to the name you specified. The form
:SEND <user>@<site> <message>^C
where <site> is one of "AI", "ML", "MC", or "DM", will send to the user on that site. While in :SEND, several control characters have special editing meanings: ^W means word kill, ^U = line kill, and ^Y means to unkill. ^Z exits, saving in the kill ring (so that a subsequent ^Y will yank back the saved text). ^R retypes the current line, ^K retypes entire message, ^L clears and retypes entire message. ^_H or [HELP] will give help. If the flag ..SNDFLG is non-zero, this command is disabled, and the program SEND is run instead (SYS2;TS SEND is a link to QSEND). It may still be accessed as :OSEND in this case.
:SFAUTHOR <file>,<name>
sets <file>'s author's name to <name>, which should be the name of some directory in the system.
:SFDATE <file>,<date>
sets <file>'s creation date to <date>. <date> should have the same format as dates in dsk directories as typed by ^F; trailing numbers default to 0 if omitted, except for the year, which defaults to the current year. If the date is null, the current date and time are used. :SFDATE uses the same defaults for <file> as :DELETE.
:SFDUMP <file>,<0 or 1>
sets <file>'s has-been-dumped bit to <0 or 1>. The dumped bit is supposed to mean that the file has been copied onto magnetic tape by the backup system (DUMP). It causes incremental dumps not to copy the file again. "!" in directory listings marks files which "have not been dumped".
:SFREAP <file>,<0 or 1>
sets <file>'s inhibit-reap bit to <0 or 1>. The DUMP program's automatic GFR will not delete files which have this bit set to 1.
:SHOUT <message>^C
sends the specified message to all logged-in users who can receive it. Does not send or mail the message to users who are not logged in or are gagged. Also does not send or mail to the shouting user himself. As each user is sent the message, his name is typed out on the terminal of the DDT which is shouting. The actual message sent is <sender's uname> <time> Everybody: <message> but the automatically supplied parts can be rubbed out.
:SL <file>
Symbol Load - like $L but loads only the symbols, flushing any that are already defined in the current job.
:SLEEP <n>
sleeps <n>/30. seconds.
:SLIST
same as :LISTS - List this job's symbols.
:SMDATE <date>
sets that date. It takes a date in the same format as :SFDATE and friends. (:SMDATE 10/15/78 16:40:25). Notable special cases are :SMDATE 0, which sets it to NOW, and :SMDATE - which sets it to print all of them.
:SNARF <job>
if the current job (say, FOO) has an inferior named <job>, this command takes <job> away from FOO and then does ":JOB <job> ". Thus, <job> becomes a direct inferior of the DDT executing this command, instead of an indirect inferior. FOO is not told that its inferior is gone, but if it is a DDT it will recover after an $J is done to it. This command is most useful when done to a HACTRO that got detached because of a top- level interrupt, but whose inferiors are valuable. (The thing to do is "HACTRO$J :SNARF TECO ", etc.)
:SSTATUS
prints system status info, as is done when DDT starts up. On MC, prints the number of MACSYMA's being run.
:START <addr>
Same as :GO - Start current job at specified address.
:SYMADD <file>
loads the symbols from <file>, without killing the symbols the current job already has.
:SYMLOD <file>
Like $L but loads only the symbols, flushing any that are already defined in the current job. Same as :SL
:SYMTYPE <sym>
returns info on <sym>'s status. Useful in conditionals, since it is 0 iff the symbol is undefined. The character terminating <sym> is re-read. The bits in :SYMTYP's value: 
     
     	 4.9 - sym is half-killed.
     	 4.8 - sym is predefined in DDT.
     	 4.7 - sym defined but not in current block.
     	 4.6 - sym is a DDT-reference (like ..TTYFLG or ..BTAD).
     	 4.5 - sym is a .USET reference (like .SNAME).
the RH has the sym tab entry's addr in DDT (but is 0 for PDP-10 instructions, which have none).
:TAG <tag>
is a label in an execute file or valret string, which a :JUMP can jump to. :TAG is a no-op if executed; its only purpose is to be recognized by a :JUMP.
:TERPRI
will print a CRLF iff the cursor is not already at the left margin. It will do this even with the TTY off, so it can be done in init files without needing a "^V ^W" to turn it on which would cause it to echo a space and thereby always forcing a CRLF.
:TPL <file>
causes <file> to be printed on the LPT: eventually. If <file> is on DSK:, makes a link from the TPL: device to <file> . <file> must exist when the attempt is made to print it; if it doesn't exist when the command is given it is an error (the names in <file> are translated as if it were being opened and the translated names are actually used). If <file> is not on DSK:, it is copied to the TPL:. On MC, device TPL just sends files to ML's TPL; it can't hold links. :TPL on MC will always copy the file.
:TPLN <file>
like :TPL but no error if the file doesn't exist. If it still doesn't exist when the time comes to print it, it will be printed as soon as it is created.
:UINIT
zeroes the directory of the microtape that is ^F default device. Error if that device isn't a microtape. :UINIT is allowed only after :ASSIGN'ing the tape.
:UINIT <tape>
similar but uses the specified microtape. Sets defaults as ^F does.
:UJOB <uname> <jname>
opens the job <uname> <jname>, which presumably belongs to <uname>'s tree instead of your own. The job can be examined only, unless it is reowned when you select it.
:UNPURE <addr>
unpurifies the page of the current job in which <addr> lies (thus, ":UNPURE 2000 " unpurifies page 1).
:UNPURE<cr>
unpurifies all shared and read-only pages of the current job, except absolute pages. See the symbol "..UNPURE" for the automatic unpurification feature.
:V
if read from the TTY, turns on TTY output by zeroing ..TTYFLG. In a valret or file, cancels one ^W, just as a ^V does.
:VERSION
prints the version numbers of ITS and DDT. Also says which machine you're on, and your TTY number. If logged in, DDT prints its UNAME and JNAME on the next line. This command is executed automatically when DDT starts up.
:VK
turns on typeout like :V and types a CRLF and a * (V-Kerchink).
:VP
turns on typeout and proceeds inferior without actually typing anything. Like $P^V .
:WALBEGIN <file>
opens a wallpaper file. If successful, turns on output to it. The default file names are LPT:WALL PAPER <msname>; see ^B and ..LPTFLG
:WALEND
closes the wallpaper file if any. Doesn't change ..LPTFLG but its contents become irrelevant.
:WALLP <file>
opens a wallpaper file. Same as :WALLBEGIN
:XFILE <file>
executes <file> as DDT commands, after which input will revert to its current source. The current input source is pushed as by :INPUSH and input comes from the file; at eof input will pop back into the source the :XFILE was read from. However, if :XFILE is the last command in an execute file, it will be able to loop without input pdl overflow (the CRLF ending the :XFILE must be absolutely the last thing in the file!).

Next: , Previous: Built-in, Up: Top

Reading of filenames:

Some commands take filename arguments. These arguments always follow the command itself. Such commands must always be terminated by a carriage-return.

An ITS filename has four components: the device name, the sname (or user name), and two filenames, called the FN1 and the FN2 (Yes, "filename" is ambiguous). The device name and sname constitute the directory, and the two filenames specify the file in it. A filespec can specify any or all of the components. Those that are not specified will be given default values, which will usually be whatever values were used for those components in a previous command (see Defaulting of filenames, on the next page).

A filespec as understood by DDT is composed of names terminated by delimiters. A name is composed of any SIXBIT characters which are not delimiters, except that delimiters which are SIXBIT characters may be forced into names by preceding them by ^Q.

The significance of a name depends on what the terminating delimiter is. If a name is terminated by a colon, it specifies the device name. A name ended by a semicolon specifies the sname. In addition, it forces the default device name to be DSK:, if the default device was one which does not use the sname (such as PTR:). Names terminated by anything other than colon or semicolon are "normal". The first normal name specifies the FN1. The second specifies the FN2. If there are more normal names, the third becomes the device name and the fourth becomes the sname. Further normal names are ignored.

A normal name is usually separated from what follows by a space, but a space is not needed before these special effect characters:

^X
like typing the default FN1 between spaces. (treats the preceding name if any normally, then treats the default FN1 normally) Thus, if the defaults are FOO BIN, typing TS^X or TS ^X will specify TS FOO. ^XNBIN or ^X NBIN will specify FOO NBIN.
^Y
similar but uses the default FN2. It is never necessary to use ^Y explicitly as the FN2, because simply not specifying any FN2 has the same effect.
, (comma)
ends the file specification. It does not terminate the command, however; only a ^M will do that. Useful in commands that read a file specification and then read something else.
$ (altmode)
Causes the filenames specified or defaulted thus far to be typed out on a new line, followed by a tab, then reads another file specification using the typed-out names as the defaults.
^M (carriage-return)
terminates the file specification and also terminates rubout-processing. Unless the command wants to read more arguments, it will immediately execute.

Next: , Previous: Reading, Up: Top

Defaulting of filenames:

When a filename is read in, defaults are provided for any component of the filename that is not specified. Usually, the names that are specified change the default for the next command of the same class (filenames are "sticky"). The commands are divided into classes as follows:

  1. Loading and dumping commands $L, $$L, $Y, $$Y, :LOAD, :PDUMP, :SL, :SYMADD, etc.

    These commands all remember and update the same filename; however each job has its own. When a job is created, that default is set to DSK: <msname>; <jname> BIN . When a job is loaded into by <prgm>^K or :<prgm>, etc., the default is set to the name of the file loaded. Each command in this class updates the default for the job that it loads or dumps to the file that was loaded or dumped. (that is, the next such command in the same job will use the same filenames unless the names are explicitly re-specified).

    The commands that run system programs (^K, :, :NEW, etc.) set the $L-default filename of the loaded job to the filename of the loaded program. If that program was actually found on SYS;, SYS1;, SYS2;, or SYS3;, a special feature is invoked to prevent accidental overwriting of system programs: although the default is cheerfully set to SYS; or whatever, the first dumping command given will change it to <msname>;. This causes the dumped file to be written on the user's own directory instead of on top of the loaded system program. Of course, if an sname is specified in the dumping command it overrides the change in the default. Also, this feature is activated only by the program-running commands; if SYS; becomes the default via an explicit specification (eg, $L SYS;) DDT will not spontaneously change it.

  2. ^O, :DELETE, $$^O, :RENAME, :LINK, :LINKF, :LINKN, :SFDATE, :PRINT, :COPY, :MOVE, :EXISTS, :TPL, :LISTF, ^F.

    These commands all use and update the same default filenames. There is, however, only one default for these commands rather than one for each job. Logging in sets the default to DSK:<hsname>;.FOO. >

    ^F is slightly special in that TTY^F, XGP^F and <arg>$^F do not set the default for any of the other commands, but do set it for successive ^F's without argument.

  3. ^T, $^T, $$^T, ^U, $^U, $$^U.

    Defaults for these commands are not sticky between commands. The first file's defaults are always *:*;* *. With those commands that read two filenames (^T, $^T, $$^T) the second defaults to the first.

  4. :XFILE remembers and updates its own special default, which starts out as DSK:<hsname>;<xuname> LOGIN. :WALBEG has another default that is initially DSK:<msname>;WALL PAPER.

Setting the msname ($$^S) sets the default sname for :XFILE, :WALLP, :DELETE, etc., but not for $L, etc.

Next: , Previous: Defaulting, Up: Top

DDT's UNAMEs and SNAMEs:

DDT remembers several different "user names", each one with its own significance. They are, in order of decreasing significance and increasing frequency of alteration,

the RUNAME, the XUNAME, the HSNAME, the MSNAME.

The RUNAME

The RUNAME is DDT's best idea of what its .UNAME user variable is (in other words, it represents the fruits of DDT's attempts to keep track of what the system thinks DDT's UNAME is).

DDT uses the RUNAME as the FN1 of the "SENDS" file to put messages from other users in (see "Unsolicited typeouts"), and also as the UNAME that inferiors must be created with.

It is unreasonable to change the RUNAME explicitly. DDT tries hard to detect any change in its .UNAME and update the RUNAME as necessary (see "When DDT determines the RUNAME").

The XUNAME

This is "who you really are", as opposed to "what you are logged in as". It is not infrequent for them to be different. The XUNAME lives in the DDT variable ..XUNAME, and in DDT's .SUSET variable .XUNAME; they are both set by logging in, and by depositing in ..XUNAME. When you log in, the XUNAME is normally set to the name you specify, even if you end up logged in under another name (for example, if you say FOO$U and end up as FOO0 because FOO already existed, your XUNAME will still be FOO). However, if you try to log in as "FOO1", and FOO1 has no directory, DDT init file, or _MSGS_ file while FOO does, the XUNAME will be FOO instead of FOO1.

DDT uses the XUNAME as the name of the default mail file for :PRMAIL, and as the name of the _MSGS_ file for :MSGS. so, after "FOO1$U", you would see FOO's mail and messages. DDT also uses the XUNAME to decide whose init file to use. If you would like to have different initialization performed depending on whether you log in as "FOO" or "FOO1", you can put conditionals in the init file as follows: 

 :DDTSYM RUNAME/
 :IF E $Q-$1'FOO$
 $(  <commands executed only if you log in as FOO> $)
a similar conditional can then specify commands to be executed only if not logged in as FOO - just use "N" instead of "E".

Each inferior job also has a .XUNAME variable. When the job is created, DDT will set its .XUNAME from DDT's XUNAME. After that, DDT will never touch it, but the user can alter it at will by depositing in .XUNAME. In addition, the DDT command $^S can be used to cause the next job created to be given a different .XUNAME. Programs that read init files should use the .XUNAME to decide where to look for one. They should read their own .XUNAME variables, rather than trying to read DDT's .XUNAME, so that the user will be able to fake them out with $^S, etc.

The HSNAME

The HSNAME is your "Home SNAME". It is the same as your normal working directory or MSNAME. However, while you might reasonably select a different working directory temporarily with :CWD or $$^S, you hardly ever want to change your home directory. The home directory is in location ..HSNAME in DDT, and also in the .HSNAME ITS variable of DDT, and copied into the .HSNAME variable of every inferior. However, most programs should use the working directory (which they will find in .SNAME when they are started) rather than the home directory, which is to be used only for things like your RMAIL file which belong to YOU rather than to whatever you are hacking at the moment.

The MSNAME

"MSNAME" is short for "Master SNAME". It is DDT's super-default SNAME. Whenever an inferior is created or reloaded, its .SNAME variable is initted from the MSNAME. Also, when DDT is about to load a program into a newly created job (one not loaded before), the MSNAME is the first directory DDT looks on for the file (see $L, ^K, :).

The MSNAME and HSNAME are set just like the XUNAME at login time. The default init file (which is used if you fdon't have either a directory or an init file of your own) will then run the SETMSN program, which will set the MSNAME and the HSNAME according to your INQUIR entry. The MSNAME may be set explicitly by <name>$$^S, or by depositing in ..MSNAME. Using $$^S or :CWD causes several other default SNAMEs to be set.

XUNAME:
"Who you are". This is what you normally log in as. However, if you log in more than once, the second time you'll be logged in as a slightly different name, but your XUNAME will still be the same. For example, FOO logs in twice, the second time he becomes FOO0, but his XUNAME is FOO in both instances.
HSNAME:
A decoding of the XUNAME into a directory. The directory on which a user's mail and init files go. This is a permanent parameter of a given user. (You don't move your mail file from day to day.) There is no command to change this, it must be done through INQUIR. There is, however, a command to use someone else's HSNAME and XUNAME for the next command. FOO^S will use FOO's XUNAME (FOO, of course) and HSNAME for the next program you run.
MSNAME:
"Master SNAME". This is what directory you are hacking, your "Working directory". I.e. if today you are working on a program kept on LISPM, and tomorrow on a system who's files are on your own directory, the first case you might set your MSNAME to LISPM and the second to your own directory. It's purpose is to tell programs what directory to assume when you don't specify all of a filename. It is subject to whims of convenience, and a command exists to change it: :CWD FOO (or FOO^S) set's the MSNAME to FOO. A program determines the MSNAME from it's SNAME at startup time.

NOTE: Normally, one should have a null FILE DIRECTORY entry in INQUIR. It is only in unusual cases where DDT's default actions are inadaquate that they should be over-ridden by your INQUIR entry.

When you log in, DDT calculates your HSNAME from your XUNAME, by looking in INQUIR. If you have an INQUIR entry, with a non-null FILE DIRECTORY entry, it parses that. It should consist of entries separated by commas, like 

VSDB,SIPB@@MC,BLAH@@MIT-ML
The entries are checked one at a time. An entry with no @ or % is taken to be a directory, and if the directory exists, it is taken as the HSNAME and parsing stops. If there is no such directory, the next is tried. Similarly, in an entry with a @ or %, the part before the % or @ is taken as a directory, and the part after the @ or % is taken as the machine on which it is aplicable. The entry is ignored either if it applies to a different machine or the directory does not exist.

If none of the entries in INQUIR applies, DDT then checks if there is a directory of the same name as the XUNAME. If so, that is used as the HSNAME. So people with their own directories don't need to have INQUIR entries specifying what directory to use.

If none of the above applies, DDT assigns you to one of several public directories, according to your position in the alphabet, and whether or not you are a tourist (MC only). The public directories are called USERS1, USERS2, USERS3, etc. On MC there are also GUEST1 GUEST2 and GUEST3 for tourists. On other machines, no distinction is made.

The mailer uses the same algorithm to find what directory to put your mail on. This is how DDT knows where to find your mail with the :PRMAIL command.

init files and mail files and the like have the following naming convention: <hsname>;<xuname> <program-ID> where <program-ID> is something like MAIL, LISP, LOGIN, LOGOUT, etc. For example

Old regime New Regime


<random>;.LISP. (INIT) <hsname>;<xuname> LISP
(INIT);<xuname> .LISP.
<random>;.DDT. (INIT) <hsname>;<xuname> LOGIN
(INIT);<xuname> .DDT.
<random>;.DDT_ (INIT) <hsname>;<xuname> LOGOUT
(INIT);<xuname> .DDT_

As you can see, the new scheme is simpler conceptually. Also, given a person's XUNAME, if you had a way of calculating the HSNAME, you'd be able to run his init files, no matter where he kept them. This was not true of the old scheme. The way to do this is with the <xuname>^S command. This command has the same meaning as it always did, that is, "for the next program you run, pretend you are <xuname>". Howver, it is smart about HSNAME's and set's the HSNAME as well as the XUNAME, so if the program follows the conventions, it will find FOO's init file if you do FOO^S LISP^K

Group directories:

Often people sharing a single directory wish to share a common init file. This can be done using "*" for the first file name, rather than the XUNAME. "*" means "match any XUNAME". Thus if several people, say A, B, and C, using directory DD, all want the same init file, they can call the file DD;* LISP or DDT;* LOGIN or whatever. If a person F also uses that directory, but wants a different action, he can call his init file DD;F LISP and it will be found in preference to the * LISP.

When DDT determines the RUNAME:

At various times, DDT checks its .UNAME system variable. If it is not equal to the RUNAME, DDT sets the RUNAME, and also initializes the UNAME. This happens just after logging in. Normally it will never happen again, but if the DDT is detached or disowned, and then reowned with a different UNAME, DDT will eventually find out about it and redetermine its RUNAME.

Next: , Previous: UNAMEs, Up: Top

Specially used symbols:

Symbols whose values are variables: (It is reasonable to assemble definitions of these to direct DDT)

PATCH
the address of the start of the ^\ patch area. (If you use MIDAS block structure, you should define PATCH in the global block, by doing ' PATCH": ')
PAT
will be used to initialize PATCH if PATCH isn't defined. It is best to define both PAT and PATCH; as patches are made, PATCH will change, but PAT will not.
..D010
if this is defined, something which looks like an I/O-instruction with device code 010 will be typed out in $S mode as an I/O instruction. If it is undefined, such values will be typed out in halfword mode instead. In general, for something with device code <dev>, the symbol ..D<dev> is used. (Except that for devices APR,PI,TTY,DIS I/O-instruction format will always be used) (also, if there is no job, no symbols, or if the job is SYS, PDP6 or PDP-10, the I/O-instruction format will be used for all device codes less than 740, without searching for ..D!dev)
..U010
if this is defined, it tells DDT what to do about UUO opcode 010 – whether it uses its AC field, whether it addresses memory, etc. This information is relevant when DDT is considering opening the memory locations referenced by a specific instruction (see ..PCPNT). ..U symbols are looked for only for opcodes less than 100 or greater than 700. The value has 3 significant bits: 
     
     	1.1   this UUO refers to the addressed memory location.
     	1.2   this UUO refers to the specified ac, unless the AC field is 0
     	1.3   this UUO always refers to the specified ac.

..BFOO
is one place that DDT looks for the bit pattern, when FOO$? is done. See $? for details.

Special pseudo-locations (.USET variables):

These symbols have values which are the "addresses" of the current job's .USET variables. Those .USET variables are not really in the job's memory, and these "addresses" are not just numbers, but it works to add numbers to them. For more accurate and detailed info on .USET variables, see .INFO.;ITS USETS.

.UPC
holds current job's PC.
.JPC
PC before most recent jump instruction. Unfortunately, proceding from a breakpoint clobbers this variable, and so does hitting a breakpoint which does not break because of its proceed count or conditional instruction. There is unfortunately no easy way to fix this.
.UUOH
PC at last insn that trapped to system's 40 .
.SV40
last UUO that trapped to 40 .
.UTRP
set if system calls should trap to superior instead of normal action (DDT doesn't handle that specially)
.SNAME
job's default SNAME. Initted by DDT from the MSNAME.
.UNAME
job's UNAME.
.XUNAM
job's XUNAME. DDT inits it to your XUNAME (usually, but see $^S), but you can change it to fool the program if you like.
.JNAME
job's name.
.XJNAM
job's "intended" name. Tries to do the same thing for a job's JNAME that .XUNAME does for the tree's UNAME - that is, it claims to be what the JNAME would ideally have been. When a job is created by $J, the XJNAME is set up to be the same as the JNAME. If the JNAME is changed by $$J or :GENJOB, however, the XJNAME is not changed. Also, if a job named FOO0 is created by :NEW FOO, the job's .XJNAME will be FOO, not FOO0. Programs that wish to take different actions depending on the user's command should examine this variable.
.UIND
job's user index (printed by $$J, $$V).
.SUPPRO
the job's superior's user index, or -1 if job is top-level.
.USTP
stop bits, nonzero => job not runnable.
.MASK
mask for 1st-word interrupts.
.IMASK
when read, like .MASK . When written, IOR'ed into .MASK .
.AMASK
similar but ANDCAM'd into .MASK when written.
.PIRQC
pending 1st-word interrupts.
.IPIRQ
, .APIRQ analogous.
.MSK2
mask for 2nd-word interrupts.
.IMSK2, .AMSK2
turn on or off bits in .MSK2
.IFPIR
pending 2nd-word interrupts.
.IIFPI, .AIFPI
analogous.
.DF1
defer-bits for 1st-word interrupts.
.DF2
similar, for 2nd-word interrupts.
.IDF1, .ADF1, .IDF2, .ADF2
also exist.
.PICLR
0 => PI in progress
-1 => PI cleared.
.MEMT
top of user memory (1+ highest legal address).
.MARA
address and bits set in MAR
.MARPC
last PC where MAR stopped program.
.BCHN
# of channel most recently in error. (the one whose status you might want to look at)
.MPVA
address of the 1st word of the page that the most recent MPV tried to refer to.
.RUNT
job's runtime in 4-microsecond units.
.OPTIO
job's option bits. Bit 4.5 (%OPBRK bit) is set by DDT in all inferiors. The intention is that a superior should set it if it is prepared to handle all .BREAK 12's and .BREAK 16's as DDT does. Bit 4.4 (%OPDDT bit) is also set by DDT in all inferiors. No one else should set this bit. It is cleared in a job which is disowned. The system does not use these bit, or bit 4.6 (%OPCMD bit) which DDT will set iff there is a command available for the inferior. Inferiors should try to read a command from their superiors only if this bit is set. That will facilitate running them under programs which can't handle .BREAK 12, at all.
.40ADDR
specifies the addresses of the special core locations used by DDT and ITS The right half points to a block used by I.T.S; the left half points to a block used by DDT.

The RH normally contains 40 . Whenever the system references locations "40", "41" or "42", etc., specifically (eg, giving the user interrupts, or returning UUOs 50-77), the system really references the block that .40ADDR points to. Thus, if .40ADDR is set to 500, the system expects location 502 to contain the address of the interrupt handler.

ITS reserves an 8-word block, but uses only 5 words of it as of now. The words used are (assuming the block starts at the default location, 40): 

     
     	   40	    when a UUO is returned, its value is
     		     placed here.
     	   41	    the address of the returnable UUO handler
     		     should be here.  See ITS UUOS for details.
     	   42	    holds the interrupt handler address or
     		     interrupt table AOBJN pointer,
     		     if there are interrupts enabled.
     	   43	    holds the undo-list for the LOCKS feature
     		     if the feature is turned on.
     	   44	    holds the critical routine table pointer
     		     if the LOCKS feature is turned on.

If the LH is nonzero, it is the address of the 20-word block used by DDT. If it is zero, the block starts at location 20 . The uses of these locations are: 

     
     	   25	    holds "." when a user-defined typeout
     		     mode instruction is run.
     	   26	    holds a breakpoint conditional
     		     instruction being executed.
     	   27, 30   hold .BREAK 16's for getting control
     		     back to DDT after a breakpoint
     		     conditional instruction.
     	   31	    holds an instruction being executed
     		     to proceed from a breakpoint which
     		     didn't break (count not out and
     		     condition, if any, didn't skip).
     	   32, 33   JRSTs back to the program, or
     		     data for the instruction in 31.
     	   34	    holds an instruction being $X'd
     	   35, 36   hold .BREAK 16's to return to DDT
     		     after the $X'd instruction.
     	   37	    holds $Q when a user-defined typeout
     		     mode instruction is run.

.TTY
contains several things uninteresting to examine when the job does not have the TTY, and also contains 
     
     	%TBINT=100000,,	  if set, the job will interrupt on
     			  any attempt to use the TTY when it
     			  doesn't have the TTY.  DDT sets this
     			  bit in all jobs it creates, but will
     			  not object if you alter it.
     	%TBNVR==200000,,  if set, TTY opens will fail when the
     			  job doesn't have the TTY.  DDT initially
     			  zeroes this bit, but you can alter it.
     	%TBDTY==10000,,	  not user settable, this bit is 0 iff
     			  the job has done a .ATTY not undone
     			  by a .DTTY.

.TTST, .TTS1, .TTS2
hold the saved values of the TTYSTS, TTYST1 and TTYST2 variables for the job's console, when the job doesn't own the console.
.TVCREG
holds the job's "console register" that determines what TV it will write on when it deposits in the TV memory, and also what logical operation is used for depositing.
.CNSL
contains the number of the TTY of the job's tree, whether or not the job has the TTY. Also, will be -1 for jobs "in the system tree" and -2 for disowned jobs.
.IOC
+<n> is contents of I/O channel <n>
.IOS
+<n> is contents of I/O status word for channel <n>
.IOP
+<n> is contents of I/O pdl word <n>
.PMAP
+<n> is "page-map word" <n> ; see .INFO.;ITS USETS for its format.

Special per-job pseudo-locations (DDT's user variables):

These symbols have values that are the "addresses" of variables in DDT's memory, pertaining to the current job. The visible numeric part of such an address is in fact the address of the variable in DDT, but there is also a hidden flag.

..UPI0
after the job interrupts DDT, this word says which fatal 1st-wd interrupts the job got to cause DDT to be interrupted.
..UPI1
holds the fatal 2nd-wd ints that the job had. when a job has interrupted DDT, either ..UPI0 or ..UPI1 must contain nonzero (something must have stopped it!).
..PPC
PC to restart job at.
..XECP
holds the PC saved by the last $G or $X command. $X will (presumably) eventually restore that PC.
..UIWD
says why job stopped. 
          	-1 => random interrupt.
          	0 => running.
          	1 thru 8 => that breakpoint.
          	16 => .BREAK 16,
          	21 => never started.

..INCNT
number of insns to 1-proceed.
..OIPC
nonzero in $$^N mode, in which case PC to stop at.
..USCNT
number of times to multi-step, negative => forever.
..USTYPE
holds the job's stepping-flags.
..SAFE
usually zero. If set nonzero by the user, the job is made "protected". Any attempt to kill or reload a protected job will cause DDT to ask for confirmation.
..BTADR
0 => no temp. bpts in this job. else RH is addr of the 1st; the second is in the next wd. If LH is from 0 to 17, it is addr of an AC whose contents should be compared with those of
..BTPDL
, breaking only if they are equal.
$<n>B
(<n> from 1 to 8) (either altmode or dollar sign is okay) 1st word of a 4 word block describing setting of bpt <n>. zero if bpt <n> not set. else, RH as address of bpt, LH if nonzero is location to open when the breakpoint is hit.
$<n>B+1
nonzero if conditional breakpoint, in which case holds conditional instruction (break if insn skips).
$<n>B+2
holds proceed count for breakpoint.
..MARA
holds the MAR status. after <adr>$<n>I, ..MARA contains 4+<n>,,<adr> when there is no MAR set, ..MARA holds 0.
..MARC
the conditional MAR instruction. If this is nonzero, the MAR will break only if this instruction skips when executed in the job.
..MARX
if nonzero, this word is considered to be the address of the first word of an ASCIZ string to be executed as DDT commands whenever the MAR is tripped.
..STARTA
0 if no starting address, else JRST to the address.
..LIMIT
holds <default low search limit>,,<default high search limit>
..PERMIT
-1 => job allowed to execute valret strings, kill itself, or do .BREAK 12,'s that write in DDT. 0 => DDT will stop the job before doing any of those things. $P will make DDT go ahead and do one such attempt, but still stop at the next one.
..SYSUUO
if nonzero causes the job to be stopped before each system call. $P at that point will execute the system call, but the job will stop again at the next one. ..SYSUUO is the location after ..PERMIT.
..TPERCE
holds the % typeout mode for this job. Initialized from ..MPERCE when the job is created. See ..TDOLLA for details.
..TAMPER
holds the & typeout mode for this job. Initialized from ..MAMPER when the job is created. See ..TDOLLA.
..TDOLLA
initialized from ..MDOLLA when the job is created, it holds the job's $ (dollarsign) typeout mode. It is either -1,,<addr of routine in DDT> or an insn to $X. The insn can find the value to type out in 37 (but see .40ADDR). The open location's addr will be in 25 (but see .40ADDR). If the insn is a subroutine call it shouldn't skip; otherwise it should return with .BREAK 16,504000 .
..TPRIME
holds the job's ' typeout mode. Initialized from ..MPRIME.
..TDQUOT
holds the job's " typeout mode. Initialized from ..MDQUOT.
..TNMSGN
holds the job's # typeout mode. Initialized from ..MNMSGN.
..PATCH
0 if not patching; else <patched-from>,,<patch-area>
..LITCNT
in the RH is the id number of the last literal you asked for (with $$( ). In the LH is the number of the last literal which has been defined (its contents specified). If they are not equal, then there are literals which DDT knows must be defined, and DDT will ask you to define one of them as soon as things are in a state where that is possible.
..UFNAME
4-word block holding the name of the last file loaded. 1st wd holds device, then FN1, FN2, SNAME. All 4 wds are left-justified SIXBIT.
..UFILE
a 5-word block containing the default names for loading, dumping etc.
..UNDEFL
an AOBJN pointer to the undefined-symbol-reference table (in DDT's address space) for this job. See "?".
..JOBSYM
an AOBJN pointer to this job's symbol table.
..PRGM
an AOBJN pointer to a final segment of the symbol table, starting at the header for the current block.
..URANDM
is a word containing miscelaneous fields. Some of them are read and written by .BREAK 12,[..RRND,,addr] and .BREAK 12,[..SRND,,addr]. Others are internal to DDT, will be read by .BREAK as 0, and can't be set with .BREAK. When depositing with DDT, be sure not to change bits except those of the field you intend to modify. These fields are now defined for the user: 
     
     	bit 1.5 (20) if 1 means that unsolicited typeouts should
     	   be inhibited when this job has the tty.  When the job
     	   returns to DDT, any postponed messages will be printed.
     	bit 1.6 (40) if 1 means that other jobs, even if $$^P'd,
     	   should be prohibited from typing out while this job
     	   has the tty.  They will wait instead.  When this job
     	   returns to DDT, they will resume typing out.
     	bit 1.7 (100) if 1 means not to print notification of
     	incoming mail while in this job.  This applies only to
     	notifications generated by DDT via the :MAILNT command.

Special pseudo-locations in DDT:

These symbols are like those in the preceding section except that the variables they point at are not per-job.

..DDT
location 0 in DDT. ..DDT+<addr> is location <addr> in DDT.
$M
is the address of the block of 8 words holding the 8 search masks for $N and $W. Their initial values are: -1 ? ,-1 ? -1,, ? 0 17, ? 17,, ? -1 ? -1 ? -1. See the $M command.
..CLOBRF
if this flag is nonzero, the user is protected from himself. <prgm>^K typed when a job named <prgm> already exists queries "–Clobber Existing Job–". A space will tell DDT to go ahead and load a new copy of <prgm> over the old. Anything else aborts the operation. This flag is initially nonzero, but is zeroed by "<name>$U". It is not zeroed by :LOGIN, however. The assumption is that anyone who doesn't know about $U probably needs protection from himself. If the DDT is already logged in when it starts (it is an inferior, or was reloaded by $U.), ..CLOBRF is also zeroed.
..GENJFL
initially -1, if set to zero ..GENJFL causes :<prgm> to behave like :RETRY <prgm> instead of :NEW <prgm>.
..MORWARN
if this flag is nonzero, every unsolicited offer (such as –More–) will say "(Space=yes, Rubout=no)" so the user will know how to respond. ..MORWARN initially holds 1, but it is zeroed by $U and in inferior and reloaded DDT's.
..DELWARN
this determines whether single-character file-handling commands should be verbose. If 0, they are all brief. if 1, only ^O (delete) is verbose. If 2, most are verbose. When a command is verbose, as soon as it is typed it will print out a statement of what it will do (such as "(Delete File)"), and then will pretend the user typed an altmode - it will print out the default filenames. A verbose command does not need any extra type-in as confirmation; it just types more out.

If ..DELWARN is set to 3, it disables the commands :LINK, :LINKN and ^O. These commands are often mistakenly taken as a way to do a com link. The command :LINKF will work even if ..DELWARN is 3, but will print out a warning message first. The default DDT init file on some machines sets this to 3.

The default setting of ..DELWARN is 1.

..CONFRM
iff this is non-zero, $$^X., $^X., and $U. require the ".". If zero, they execute immediately. The default is non-zero.
..MASSCP
iff this flag is non-zero, the $$^X. command is enabled, doing a :MASSACRE. If zero (the default) this is disabled. The theory is that this command is dangerous, and easily type by accident.
..LINKP
If this is >0, $^O will link files, ala :LINKN If it is <0, $^O will link files ala :LINK If it is 0, $^O is an error.
:DDTSYM NFVRBS
This controls :NFDIR verbosity. If DDT must resort to your :NFDIR search list (SNLIST), it will normally print the name of the directory where it found the program. If you do not want such notifications, set this variable to zero.
..SNDFLG
If this is non-zero, :SEND is disabled as a DDT command, and the program SEND will be run instead. This should be a link to the QSEND command. :OSEND will still get the DDT version of the SEND
..UNPUR
iff this word holds nonzero, as it does initially, the automatic unpurification feature is enabled. Whenever DDT tries to deposit in the inferior and can't because the page is pure, DDT will unpurify the page and type out ":UNPURE <addr> " where <addr> is the location being deposited into. Absolute pages will not be unpurified and will still cause "PUR? " errors.
..PCPNT
iff this word is nonzero, it enables the feature which, whenever DDT prints the next instruction to be executed, automatically opens the AC and memory location referenced by that instruction (but returning due to a ^Z is an exception - the locations are never opened in that case). When this feature comes into play, the locations are opened as if by slash. DDT tries to avoid opening any which the instruction doesn't actually use. The user can supply information on which UUOs use their addressed locations and their specified ACs by defining symbols starting with "..U" (see ..U010). If the instruction doesn't refer to memory but is indexed or indirect, DDT will give the effective address. ..PCPNT is initially nonzero iff the terminal is a display.
..RAID
if nonzero, DDT automatically displays the raid registers whenever a job returns. If zero, raid registers are displayed only by $V commands. Initialized to zero on printing consoles, but nonzero on displays.
..RAID+1
holds the number of raid registers to allocate space for. The default is 8. Space for raid registers for a job is allocated the first time a raid register is set in that job. The space is not freed except by a :RAIDFL. increasing the value in ..RAID+1 will not give a job more raid registers if they have already been allocated, unless a :RAIDFL is done to force them to be re-allocated.
..RAID+2
if nonzero (as it is initially), causes raid registers to be displayed at the top of the screen on display consoles. Otherwise, they are just typed out in the normal stream. On printing terminals this flag has no effect.
..MSTYPE
holds the new-job-default stepping flags.
..DOZTIM
holds the number of seconds to wait between multi-steps and before auto-proceeding a breakpoint. The time delay overlaps the printout describing the next instruction. Its purpose is to prevent the multi-stepping from going so fast that the user can't tell when to stop it. ..DOZTIM initially contains 1.
..SENDRP
tells DDT when to print various random typeouts. -1 => if DDT doesn't have the TTY, it waits till it does. 0 => if a random typeout becomes necessary and DDT has given the TTY away, it prints the message immediately, and prints it again when it gets the TTY back. Positive => like 0, but if the TTY is a display, and DDT doesn't have it, DDT repeats the messages at fixed intervals. When DDT gets the TTY back, it prints them one last time. The length of time waited is the contents of ..SENDRP times 1/60 sec. -2 ==> Type each message ONCE as it comes, and if DDT doesn't have the TTY, repeat it when DDT regains the TTY.

..SENDRP initially holds -2

:DDTSYM OMAILF
if negative (as normally) causes :PRMAIL<cr> to rename the mail file as OMAIL after printing. If OMAILF is 0, :PRMAIL<cr> leaves the mail file untouched. If positive, :PRMAIL<cr> asks if you'd like to delete the file.
:DDTSYM PMLFLG
If 0 (the default), $^A just prints your (or some other luser's) mail file. Nonzero means $^A should act like :PRMAIL.
..BELCNT
holds the number of bells for DDT to type out when it has something unsolicited to say to you. The default is 5.
..SMLINS
initially zero, if nonzero it tells DDT to truncate :SEND messages. See "unsolicited typeouts" for details.
..TWAITF
tells DDT how to initialize the .TTY variables of new jobs. If positive, ..TWAITF is copied into the .TTY variable (initializing the %TBINT and %TBNVR bits only). If negative, that says that the default settings - %TBINT on and %TBNVR off - should be used. Initially, ..TWAIT is negative. If a job is created with 0 in ..TWAIT, then even if you ^P the job, thus setting %TBWAT, the job will still do nothing but hang dumbly if it tries to use the TTY and doesn't have it. However, you or the program can alter .TTY in which case ..TWAIT has been overruled. See .INFO.;ITS TTY for what %TBINT, %TBNVR, %TBWAT do and why you might want to use these variables to hack them.
..TWAIT+1
is related to ..TWAIT. It is initially zero. If it is set to -1, the meanings of ^P and $^P are interchanged.
..SYMOFS
gives the largest allowed numeric offset in symbolic typeout mode. Rather than print a value as <sym>+<n> with <n> larger than the maximum, it will print the value numerically.
..SCH
holds the current temporary typeout mode.
..MPERCE
holds the % typeout mode for use when there is no current job. Also used to initialize the ..TPERCE variables of new jobs. Initially set to -1,,..TMS when DDT is loaded.
..MAMPER
similar, for & mode. Initially -1,,..TMSQ (SQUOZE mode) thus, $& will cause typeout in SQUOZE mode, unless you explicitly changed the contents of ..MAMPER before the current job (if any) was created, or changed the job's ..TAMPER variable after it was created.
..MDOLLA
similar, for $ (dollar) typeout mode. Initially -1,,..TMS .
..MPRIME
similar, for ' mode. Initially -1,,..TM6 (SIXBIT typeout)
..MDQUOT
similar, for " mode. Initially -1,,..TMA (ASCII typeout)
..MNMSGN
similar, for # mode. Initially -1,,..TMCH (single-char. ASCII)
..TMS
the address of the symbolic mode typeout routin (in DDT). Put -1,,..TMS in ..TDOLLA to reset it to symbolic mode.
..TMSQ, ..TM6, ..TMA, ..TMCH
are the addresses (in DDT) of the SQUOZE, SIXBIT, ASCII, and single-character ASCII routines.
..TMC, ..TMF, ..TMT, ..TMH
are the addresses (in DDT) of the constant (numeric), floating point, $T, and halfword mode routines.
..TTYFLG
DDT types output on the TTY if this holds zero. Incremented by 1 by ^W; decremented 1 (unless 0) by ^V, :V, :VK or :VP in valret strings or execute files; zeroed by ^V, :V, :VP, :VK when typed on the TTY, and by errors, and abnormal returns from inferiors (the same types of returns that would do a :INPUSH).
..LPTFLG
DDT outputs to wallpaper file if any if this holds 0. ^E adds one to it, thus turning off output. ^B in a valret string or execute file subtracts one from it (but doesn't change it if it's 0), canceling one ^E. ^E typed on the TTY zeroes ..LPTFLG. When a wallpaper file is first opened (with :WALBEG) ..LPTFLG is zero.
..ESSYM
if contents are zero, E&S display instructions will be defined on type-in. Initially 0 except on DM machine.
..MONMOD
if this is nonzero, DDT is in monit mode. DDT generates (and types out) colons, causing input to be treated automatically as :-commands. To leave monit mode temporarily, just rub out one of the colons - DDT will not generate another until there is an error (such as another rubout, when there's nothing to rub). This is initialized to 0 when DDT starts up unless it is on the Dynamod machine and not logged in.
..MSNAME
holds your "MSNAME", in SIXBIT. The MSNAME is used as the default $L SNAME of new jobs, as the initial sname for the new jobs themselves, as the first directory to search for programs being run by ^K or :-commands, etc. See "DDT's UNAMEs".
..DIRFN1
holds the FN1 to be given to the DIR: device by the $$^F command. Initially, it is SIXBIT/FIRST/. Another useful setting is SIXBIT/NAME1/.
..DIRFN1+1
holds the FN2 given to DIR: by $$^F. If it is zero, as it initially is, the current default FN1 is used. Thus, putting $1'CDATE$ in ..DIRFN1, and $1'DOWN$ in ..DIRFN1+1, will make $$^F give a directory sorted by creation date.
..XUNAME
holds your "XUNAME", in SIXBIT. The XUNAME says who the user is, for the sake of looking at mail and messages, and for DDT init files. In addition, the XUNAME will be put in the .XUNAME variables of inferiors to tell them who is running them. For more information, see "DDT's UNAMEs".
:DDTSYM TTYTYP
holds the terminal's TTYTYP word.
:DDTSYM TCTYP
holds the terminal's TCTYP word.
:DDTSYM TTYOPT
holds the terminal's TTYOPT word.
:DDTSYM TTYNUM
holds the terminal's number.
:DDTSYM GETTY
is nonzero if the terminal is a display.
:DDTSYM NOERASE
is nonzero if the terminal is a storage tube display.
:DDTSYM ERASE
is non-zero if the TTY can handle ^PX
:DDTSYM OSPEED
the output speed of the TTY line, in baud.
:DDTSYM ISPEED
the input speed of the TTY line, in baud.
:DDTSYM SMARTS
the SMARTS TTY variable for this TTY.

The above symbols are useful mainly for :IF conditionals in init files. This is the way to test for being on either a dialup line or a TELNET connection (but NOT a SUPDUP connection). A :TCTYP to the parameters of your favorite remote terminal MUST NOT be put in an init file with out such conditionals - otherwise, you will screw up any local terminals you use! 

     
     	:DDTSYM TTYTYP/
     	:IF N $Q&<%TYSTY+%TYDIL>
     	$( :DDTSYM TCTYP/
     	   :IF E $Q
     	   $( :TCTYP LINEL 69. etc.
     	$)$)

..PROMPT
holds the instruction which DDT uses to type out a "*". You can replace it with any other instruction. To use "%" instead of "*", deposit $1#%$> in that location ($> to avoid clobbering the opcode without having to know what it is).
:DDTSYM PRMMCH
if nonzero causes DDT to type the machine name when it prompts. For example, it might say "AI*" or "ML*". People who SUPDUP a lot may find this helps them orient themselves.
..C.ZPRT
initially non-zero, if it is non-zero it prints out the instruction being executed. If zero, it XCT's ..RPRMPT instead
..RPRMPT
holds the instruction to XCT when DDT gets control of the TTY via a ^Z, if ..C.ZPRT is zero.
..DDT+<any .uset-variable>
holds DDT's variable of that name (just opening the .USET variable would give the current job's value)

Next: , Previous: Special-symbols, Up: Top

Unsolicited typeouts:

Unsolicited typeouts are those that occur because of asynchronous conditions detected by DDT, rather than as the response to a user command. They can occur at any time - even if you are in a COM link; even if DDT has given the TTY to an inferior! In that case, on display TTYs, the messages will be repeated every minute until you return to DDT, and then once more immediately. This is to prevent display hacking programs from wiping out the messages by clearing the screen, etc. On printing TTYs, the messages won't be retyped. Those actions are the default. Deposit in ..SENDRP to change them.

  1. Job <jname> interrupted: <interrupts>
    means that an inferior that does not have the TTY has had a fatal interrupt (which may mean a .BREAK 16, or simply that the job attempted to use the TTY which it didn't have) and has interrupted DDT. Since it can't really return to DDT without the TTY, DDT informs you of its desire to return so you can give it the chance if you wish (just type $J at DDT). The job that interrupted is now in a "waiting" state, and will show up with a "W" if $$V is done. $J without argument, or $P, ^P or ^X with that job selected, will make it "return to DDT". Then it will be "stopped" instead of "waiting".
  2. :Forgotten job <jname> interrupting
    means that the job named <jname>, which is DDT's inferior but which you did a :FORGET command on, is trying to return to DDT. It can't do so unless you do :JOB <jname> to make DDT "remember" it again.
  3. Job <jname> wants the TTY
    means that the job tried to use the TTY and couldn't. The job might be waiting for input or for a chance to type out. In either case, $P will start it up again. Just as in case 1), the job is "waiting", and $J, or ^X, will make it return. It will say it got a "DTTY" interrupt, which is true. At this point it will be "stopped", so $P, etc. will work. This case is actually a special case of 1), except that $P has been made more convenient and the message is different.
  4. Job <jname> finished
    means that the job did a .BREAK 16,160000, and is now gone unless it had been the current job, and ^P'd, in which case $P will tell it to die and ^X will stop it.
  5. MESSAGE FROM <sender's-uname> <jname>
    <text (possibly several lines)>
    This means that someone has done a :SEND to you. The texts of all the messages sent to you are saved in .TEMP.;<your-runame> SENDS, but only until you log out. If the text of the message begins with rubout, the "Message from <uname> <jname>" which DDT normally supplies will be suppressed. DDT uses this to give the "[Message from..." line that heads messages sent with :SEND.

    If ..SMLINS is nonzero, then under certain conditions (a display terminal not in COM mode) DDT will stop printing a :SEND after that many lines (however many ..SMLINS says), and either say –More– or say how many lines are left. The whole message always goes in the sends file. This feature needs changes to become a real winner.

  6. <machine name> ITS going down in <rel time>
    means that ITS will stop running in <rel time> from now. When that happens, everyone will be logged off automatically.
  7. <machine name> ITS revived
    means that ITS won't go down after all (we hope). This happens when a request for ITS to go down is cancelled.
  8. ITS being debugged!
    means that ITS is in danger of crashing at any moment.
  9. ITS No longer being debugged!
    means that 8) above no longer applies.
  10. Alarm, type ":ALARM<cr>" to clear
    means that the time mentioned in the last :ALARM command has arrived. This message will repeat every minute, (or however often ..SENDRP requires) regardless of whether an inferior has the TTY, until you give the command mentioned, which clears the alarm.

Next: , Previous: Typeouts, Up: Top

Unsolicited offers:

At times DDT will think that you might want some service (such as printing of mail), or will wonder whether you really want to execute a command which will have drastic effects that it doesn't usually have (such as starting a new copy of a program when you already have one). In those cases, DDT offers to go ahead, and allows the user to say no or abort. DDT prints a message, which will usually start and end with "–", and then reads a character. Space tells DDT to perform the optional service or go ahead with the command. Rubout tells DDT not to perform the service, or to abort the command. Anything else acts as if it were preceded by a rubout, on the theory that explicit orders should override DDT's attempts to guess. Anything but space causes a message (usually "Flushed") to be printed indicating that the offered service was not performed.

For the sake of the naive, if ..MORWARN is nonzero DDT will print "(Space=yes, CR=no)" after every offer.

The offers that can be made now are:

--More--
when a typeout reaches the bottom of the screen, DDT offers to print more. If flushed, not only the printing but the execution of the command will be aborted. This feature is disabled by :TCTYP NOMORE.
--Msgs--
when you log in or do :INTEST or :MSGS, and there are new system messages you have not seen, DDT offers to print one. This offer is unusual in that rubout acts like a space and tells DDT to go ahead; all other characters still tell DDT not to go ahead, but they say "Postponed" instead of "Flushed" since DDT will offer again later.
--Mail--
when you log in or do :INTEST, if you have mail DDT offers to print it. If flushed, it says "Postponed" instead of "Flushed". Rubout flushes, as usual, unlike –Msgs–.
--Attach Your Detached Tree--
when you log in, if you have a detached tree that appears alive enough to be attached to successfully, DDT offers to do so. If you flush this, it goes about logging in in the normal way, and runs your init file, etc. The detached job is left detached, and DDT says so. If there is a detached tree that is to dead to attach, DDT will inform you but not offer to attach it.
You have several attachable detached trees.
--Attach A Detached Tree--
is like –Attach Your Detached Tree– but indicates that you have more than one, and after attaching one the others will still remain, still detached.
--Init--
DDT is offering to run your init file, because either DDT was already logged in when started, or your XUNAME doesn't equal your RUNAME. In either case, a space will tell DDT to run your init file, while anything else will tell it to do nothing.

These offers are essentially requests for confirmation of a command that would make DDT do something drastic.

--Kill Protected Job--
a command has been given which would kill a protected job (one whose ..SAFE variable is nonzero). DDT will go ahead if a space is typed; otherwise, it will err out.
--Reload Protected Job--
a command has been given which would destroy the contents of a protected job (eg, $L).
--Despite Pending :Alarm--
you tried to log out while a :alarm was pending. This is just to keep you from forgetting whatever the alarm was to remind you of.
--No Symbols. Dump Anyway--
you loaded a program without symbols (perhaps with ^K) or killed the symbols, and tried to dump it back out in the same file. If you go ahead, the symbols for the program will be lost, along with the old file you loaded.
--Undefined Symbols--
you tried to start a job (with $G) which contained references to symbols yet to be defined (created using the ? command). Presumably, the existence of such symbol references means that you started but did not finish making some patch.

The following confirmation-type offers are made only if ..CLOBRF is nonzero. If it is zero, DDT goes ahead without asking.

--Kill Running Inferiors--
you attempted to log out or :CHUNAM while some of your inferiors were running. Space causes the command to go ahead, while flushing aborts it (you might :DISOWN the job, or finish using it, and then log out again).
--Clobber Existing Job--
you tried to run a program with ^K, and there was already a job with the same name as that program. Running the program would require clobbering that job's contents.
--Create Additional Job--
you tried to run a program with :, when you already had a job with that name. Running the program would involve creating a new job.
--Reload Running Job--
you tried to $L a running job.

Next: , Previous: Unsolicited, Up: Top

Returning to DDT:

When a job gets a class 1 or disabled class 2 interrupt, DDT is interrupted. If the interrupt was due to a breakpoint or MAR, DDT will use the conditional instruction, if any, and the breakpoint proceed count, to decide whether the job should really be stopped. Any other sort of interrupt always causes DDT to decide the job must be stopped. If the job had the TTY it "returns to DDT" immediately. Otherwise it is waiting ($$V will type "W") and will return to DDT when $J with no argument is given, or an $J specifically to that job, or an $P in the job.

Returning to DDT involves the following actions:

Otherwise something may be printed out, depending on what stopped the job. The possibilities are:
  1. ^Z (and nothing else)
  2. a ^_D or Control-CALL
  3. a breakpoint
  4. a .VALUE with nonzero address
  5. the job tried to use the TTY and didn't have it.
  6. any other interrupts.

DDT's reactions are (case by case):

  1. type <pc>) <next insn>.
    In this case only, the AC and memory location of the instruction are not opened, regardless of ..PCPNT, since the user is probably not debugging.
  2. Type an asterisk.
  3. complicated; see below under "breakpoints".
  4. if the job is returning immediately (because it had the TTY when it executed the .VALUE), or because of an $P, execute the ASCIZ string pointed to by the .VALUE as DDT commands (this is what .VALUE is for. See "instructions that return to or call DDT"). If the job is returning because of an $J with argument, treat this like case 5).
  5. this is impossible if the job is returning immediately. If it is returning because of an $P, give the job the TTY and proceed it. If the job is returning after being $J'd to, treat this like case 5).
  6. print the next insn, and the names of the interrupts:
    <fatal ints> <pc> >> <next insn>
    then (if ..PCPNT is nonzero) open (as if by "/") the AC and memory location referenced by the instruction just typed. If the insn doesn't use the AC, or the memory location, they won't be mentioned. If the insn doesn't use the memory location, but it is indirect or indexed, the effective address will be typed: " E.A. _ <value>". If the instruction is a UUO, DDT looks for a symbol whose name is "..U" followed by the op-code, to tell whether the AC and memory location are used; see ..U010 for details.

    The interrupt names are separated by semicolons. A table listing all the interrupt names appears below.

In any case, if there are pending non-fatal interrupts (which will be handled by the job, rather than by DDT), DDT prints their names in parentheses before the pc.

Breakpoints:

A job that hits a breakpoint won't always return to DDT. Upon encountering a bpt, the bpt's proceed count is decremented, and tested for zero. If it has reached zero, the program returns to DDT, typing $<n>B <pc> >> <insn> (and opening the AC and memory location, if appropriate). (A bpt's proceed count is stored in $<n>B+2 and is set by <count>$p after stopping at that bpt.) Otherwise, if the conditional break instruction (in $<n>B+1) is non-zero, it is executed, and if it skips, then the job returns to DDT typing $<n>B <pc> > <insn> (and opening the AC and memory location, if appropriate). Otherwise, the program is continued without typeout.

When a breakpoint causes a return to DDT, if the bpt has been set to type out a specific location, (LH of $<n>B has address) that location will be opened. Then, if the breakpoint has been set to auto-proceed, an $P will be done, unless a character has been typed in (Any char. will do; it will be read normally). ..DOZTIM holds the # seconds DDT will insist must elapse from the time the bpt is hit till DDT proceeds the job.

A breakpoint is represented by a .BREAK instruction, whose AC field gives the number of the breakpoint. The .BREAK is put into the job when it is started or continued, without changing the address, index or indirect fields of the broken instruction. When the job returns to DDT, for any reason, the .BREAK's are replaced by the remembered original op-codes and AC fields. The index, indirect and address fields, again, are untouched. If DDT finds itself unable to insert a .BREAK, it clears the corresponding breakpoint, typing 0$<n>B to inform you; if a breakpoint is no longer there when DDT tries to remove it (it has been replaced by other than a .BREAK) DDT says "Breakpoint <n> Clobbered".

1st word (.PIRQC) interrupt name table:

(The 1st char on each line is " " for a class 3 int., "?" for a class 2 int, and "-" for a class 1 int) ("Should never be typed" means that DDT handles that interrupt specially. Eg, for the .BREAK int, DDT handles the .BREAK. As a result, you will never see ".BREAK;" mentioned). (The master list that this table reflects is in SYSENG;ITS BITS). 

Code		Meaning				Bit in ..UPI0

 REALTM	  realtime interrupt (rqd by .REALT)		200000,,
 RUNTIM	  run time interrupt (see .RTMR)		100000,,
 <4/6>	  something set int. bit. <4.6>			40000,,
 <4/5>    is analogous.
?^_D	  the job read a ^_D or control-CALL		10000,,
 ATTY	  the job was given back the TTY.
?DTTY	  the job tried to use the TTY and didn't	2000,,
	   have it, when %TBINT was 1 (which is
	   the normal case)
-PARERR   a parity error in the job's core		1000,,
 ARFOV	  floating overflow				400,,
?PURPG	  wrote in pure page				200,,
?PURINS	  insn fetch from impure page			100,,
	 (this causes an int. only if a certain bit in the PC is set)
-SYSUUO	  any trapping insn in user trapping mode	40,,
 SYSDBG	  system being debugged				2,,
-.LOSE 	  .LOSE instruction executed			1,,
 CLI	  core link interrupt				400000
 PDLOV	  push down overflow				200000
 LTPEN	  light pen hit on 340				100000
-MAR	  the MAR (set by $I) was tripped		40000
	(This is special in that the instruction that tripped
	 the MAR is printed after "MAR. " and all the remaining
	 messages come on the next line,
	 along with the next insn to do)
?MPV	  memory protection violation			20000
 SCLOCK	  slow (60cps) clock tick			10000
-1PROC	  1-proceed return (should never be typed)	4000
-.BREAK	  .BREAK executed (should never be typed)	2000
?ILUAD	  I don't think this happens since paging	1000
?IOC	  input-output channel error			400
	(this is special in that it is mentioned on a line
	 by itself, along with the system error message
	 describing the type of error)
-.VALUE	  .VALUE executed (should never be typed)	200
 SYSDED	  system going down				100
?ILOPR	  illegal instruction				40
?DPY	  340 or E&S display got an MPV			20
 AROV	  arithmetic over flow				10
-BADPI	  bad location 42				4
	(job got int. but 42 wasn't set up, eg was 0)
-^Z	  ^Z typed on TTY (should never be typed)	2
 TYPEIN	  any interrupt character typed on console	1
	(this is obsolete - use 2nd-word ints instead)

.VALUE 0. job did a .VALUE 0.				400000,,
	(note that that bit is not set in .PIRQC by the system
	but rather by DDT when it sees that the address is 0)

2nd word (.IFPIR) interrupt name table:

(All these interupts are class 3. They can still be fatal if the job requests it, using the vectoring interrupt scheme) 

Code		Meaning				Bit in ..UPI1

 <4.9>	  shouldn't be seen				400000,,
 <4.8>	  something set bit 4.8 of .IFPIR		200000,,
	(its won't do this itself, but a .SUSET or
	 .USET can do it)
 <4.7>, <4.6>, ... <4.1>, <3.9> are similar.
 INF7	  bit 3.8 - an interrupt from an inferior job	200,,
 INF6, INF5, ... INF0 interrupts from other inferiors.
	(.UTRAN can be used to find what inferior
	 corresponds to a given interrupt bit.
	 Better yet is to read the .INTBIT uset-variable
	 of every inferior when it is created)
 <2.9>	  something set bit 2.9 of .IFPIR		400000
 <2.8>	  something set bit 2.8 of .IFPIR		200000
 IOCH17	  interrupt on I/O channel 17			100000
	(possible reasons depend on the device open
	 examples: TTY input - a character was typed
		   TTY output - bottom of screen was reached)
 IOCH16	  interrupt on I/O channel 16			40000
 IOCH15, ... IOCH0 similar				20000, ...

Previous: Returning, Up: Top

Symbol Table Format:

Symbol Tables Inside DDT:

The symbol table, in DDT, is composed of 0 or more groups of symbols. Each group has one header entry and 0 or more symbol entries, and corresponds to a single relocatable program or a single .BEGIN block (except for one, the "GLOBAL block", which is the "superior" in the hierarchy of everything else). 

	Header Entry

     WD 1	Squoze name, with flags clear.
     WD 2	-<Length in words of the group>,,<level>
	 	 (The level is 0 for the GLOBAL block, 1 for program name,
		  2 or more for a block name.  The length includes 2 for
		  the header itself)

	Symbol Entry

     WD 1	Squoze name & flags:
      4.9	(%SYHKL)  Half killed    (these symbols are not! predefined)
      4.8	(%SYKIL)  Fully killed
      4.7	(%SYLCL)  Local  (either this or 4.6 must be set)
      4.6	(%SYGBL)  Global (all global syms are in the GLOBAL block)
      4.5 and down	  The squoze itself.
     WD 2	Value.

Order of Groups of Symbols

The last group is always the GLOBAL block. Every program name group follows the groups for the program's blocks. Every block group follows the groups of its subblocks. A relocatable block-structured program should have an outermost block whose name is the same as the program name. The program name group itself should be empty; symbols defined outside .BEGIN-.END's should go in the group associated with the program's outermost block. :LISTP prints the names of the groups' headers in the reverse of the order they have in the symbol table.

The Undefined Symbol Table in DDT:

Inside DDT, the "undefined symbol table" records all unsatisfied forward references to undefined symbols that were "deposited" in a job's core image. It contains one 2-word entry per symbol. The first word of each entry contains the symbol name, in squoze. The second word's RH contains the address deposited in. The sign bit of the second word is set iff the symbol was deposited in the left half.

Symbol Table Formats in Files:

The "symbol table" of a binary file contains the DDT symbol table and the DDT undefined symbol table, each divided at arbitrary points into "sections" which should be concatenated again when the file is read, or it contains an indirect pointer to another file whose symbol table should be used. Either one is located in the file immediately after the "start instruction" which terminates the data dumped from core (see AI:ITSDOC;BINFMT >).

Each section of DDT symbol table has a word containing -<# of data words>,,0 at the beginning, followed by as many data words as specified, and a checksum. The checksum of a symbol table section is computed just like that of an SBLK (see ITSDOC;BINFMT >).

Each section of DDT undefined symbol table starts with a word containing -<# of data words>,,1 (not 0!) after which come data words and a checksum.

The two types of sections may be interspersed arbitrarily in the file. After the last section of either type should come a positive word, which should be a second copy of the file's start instruction.

An indirect file pointer looks just like a symbol table section except that its data consists of four filenames. It starts with a word -4,,2 (2 indicates this is an indirect pointer), followed by the device, fn1, fn2 and sname (each as a word of sixbit), followed by the checksum. A file may contain only one such indirect pointer, and it must be the last block present before the duplicate start instruction which ends the file.

In any file dumped by a recent DDT or assembled by a recent MIDAS, the DDT symbol table data (the concatenation of all the DDT symbol table sections) will have exactly the same format as the DDT symbol table proper, described above. Some old files may have that data in a different format. It is not necessary for any new programs to understand such formats, and certainly all new programs should write the correct format. If such an old file is encountered and causes any problem, loading it with DDT and dumping the result should produce a usable new-format file. Some old STINK-loaded files may fail to load with $L. :OLOAD should be used for them.