ITS DDT Guide
From Computer History Wiki
ITS DDT is the command processor for ITS; it is actually a debugger.
Taken from http://victor.se/bjorn/its/ddtord.1462
Documentation for DDT version 1491 - Table of contents:
(For users searching for command names with EMACS,
each heading is the second line of its own page.
The first line of each page is blank.
There are no actual altmodes in this file; dollar signs are
used instead. There are no non-formatting control characters;
uparrow and a non-control character are used instead)
(The DDTDOC program also searches this file, and knows that it
uses dollar signs and uparrows rather than altmodes and control
characters. So don't change this unless you fix DDTDOC first!)
List of DDT commands
Colon commands
Built-in colon commands
Reading of filenames
Defaulting of filenames
DDT's UNAMEs and SNAMEs
Specially used symbols
Unsolicited typeouts
Unsolicited offers
Returning to DDT
Symbol table format
�
List of DDT commands.
Note that angle brackets are used to delimit meta-variables.
Each of the following commands that takes a prefix arg
does so in one of two ways:
If the arg is called <name>, <dev>, <user>, <prgm>, <flags>, <fn1>,
it is the syllable immediately preceding the operator.
If it is a symbol, the symbol's name is used;
otherwise it is considered to be SIXBIT for the desired name.
eg. FOO$J and $1'FOO$$J are equivalent.
All other commands evaluate all the preceding syls and ops
to get 1 to 3 arguments (separate them with $,).
^@ will terminate an execute file or valret string.
^A prints the default user's sends file.
<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� Shows DIR:FIRST FOO and sets FN1 to FOO
LISP$$2� Shows DIR:SECOND LISP
$$2� Shows DIR:SECOND BIN
$$3� Shows DIR:CDATE DOWN
UP$$3� Shows DIR:CDATE UP
PACK13$$6� Shows DIR:ONLY PACK13
As an additional feature, if you set the DDT variable DIRDIR
to -1, $$^F (without a numeric argument) sets your default
:PRINT SNAME and otherwise ignores the argument. This lets
you look at other directories.
Examples:
$$0^F Does DIR:NAME1 UP
$$^F Still does DIR:NAME1 UP
FOOBAR$$^F Changes default dir to FOOBAR and does DIR:NAME1 UP
DOWN$$0^F Changes no defaults (now FOOBAR), does DIR:NAME1 DOWN
^G is a special interrupt level character that aborts any DDT
command. It is so powerful that it can leave DDT's data bases
in inconsistent states if typed at the wrong instant, so it
should be used only when DDT appears to be hung.
^H (back-space)
is equivalent to $J $P
<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 and <arg>$^I
are like ^I, <arg>^I but use the LH rather than the RH.
$$^I and <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.
$$! or <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.
( and )
are used for putting a value in an instruction's index field,
or, more generally, for swapping the halves of a word-long
value. DDT treats the value inside the parentheses just as
MIDAS does: if the ( is preceded by an arithmetic operator,
the parentheses and all between them act like one syllable
whose value is the value of that word with its right and left
halves interchanged. Otherwise, the two halves of that word
are added into the opposite halves of the word within which
the parentheses occur, in an otherwise invisible manner. That
is, the argument evaluator's state is the same after the ) as
it was before the (.
$( and $)
these are ignored completely (they can't even be rubbed out).
useful with conditionals (see :IF)
$$( starts a literal. Use this when typing in an expression to
stand for the address of a literal whose data you will specify
later. DDT will type out a symbol name and a closeparen;
the expression you are typing will contain a forward reference
to that symbol, which will become the address of the literal.
As soon as it is safe (no location is open, and no literal or
patch is being defined), DDT will assign that symbol the
address of the patch area and open it, so you can fill in the
data of the literal. Deposit the last word of the literal
with a $$), which will update PATCH and set "." to what it
was before DDT opened the literal. This scheme causes
recursive literals to work fine - the inner literal will
not be opened until you close the outer one, since DDT
can't tell where to start a literal while another literal
is being typed in. When you have a delay between the $$(
and the opening of the literal, the symbol assigned by DDT
will allow you to match the definitions up with the uses.
$$) Closes a literal. Defines PATCH to be the open location,
or, if none is open, to .+1.
Says that no literal is in progress, which may cause DDT
to ask for the definition of some other literal.
<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>.
$/ or <arg>$/
opens the location addressed by the LH of $Q or <arg>.
$$/ or <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.
$; and <arg>$;
are like ; and <arg>; but also reset the temporary mode from
the semicolon mode, and don't temporarily SOS ..TTYFLG.
$$; and <arg>$$;
are similar but also set the permanent mode.
> and < (angle brackets)
are like algebra's parentheses. > can be used to terminate
an expression read in by a colon command (as can a carriage
return).
$< and >
surround an expression to be used as an infix argument in an
operator. For example, $<1+1>R is equivalent to $2R
$$< and >
are similar, for operators with two altmodes.
= retypes $Q as a number in the current radix.
<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 or $$A
temporarily or permanently selects absolute address typeout
mode; that is, addresses will be typed as numbers (see $R).
Temporarily or permanently deselects bit typeout mode.
$B and variants manipulate breakpoints:
$B legal if the current job is stopped at a breakpoint;
removes that breakpoint.
<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 or $$C
temporarily or permanently selects Constant typeout mode.
When a location is opened, its contents will be typed out as a
number in the current radix. See $S.
$D or $$D
temporarily or permanently selects decimal typeout of numbers.
See $O.
$E or $$E
temporarily or permanently selects E&S display processor
instruction typeout mode. See $S.
<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 or $$F
temporarily or permanently selects floating point typeout
mode. The contents of locations opened will be printed as
floating point numbers.
$G starts the program at the starting address (which is contained
in ..STARTA). The previous PC is put in ..XECP (a DDT
location) in case the program wishes to examine it.
<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 or $$H
temporarily or permanently selects half-word typeout mode.
The contents of locations opened will be typed as two
addresses separated by ",,", each address being the contents
of one half-word.
$I turns off the current job's MAR.
<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 or $$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 or $$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 or $$S
temporarily or permanently selects symbolic typeout mode.
Locations that are opened will have their contents printed in
the way DDT thinks is most reasonable (usually as an
instruction or in halfword format.) When an address is typed,
it may be numeric or symbolic according to the $A vs $R
selection.
$T or $$T
temporarily or permanently selects typeout as bytes, using the
most recently specified byte size or pattern.
$<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 or $U.
(point required if ..CONFRM is non-zero) reloads and
re-initializes DDT. All inferiors are destroyed. If there
are any running inferiors, DDT will type
"--Kill Running Inferiors--", and read a character
from the TTY. If it is a space, DDT will go ahead;
otherwise it will type "Flushed" and do nothing. If
you were logged in, you remain so, and if you have a
<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 and <loc>$,<word>$W and <loc1>$,<loc2>$,<word>$W
and <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.
�
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>
�
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> or
: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:
If your home directory is not the same as your <xuname>,
DDT will inform you by saying "[Home dir=<hsname>]"
If a job <runame> HACTRO exists, and if running,
DDT types "--Attach Your Detached Tree--" and does so
if the reply is a space.
Otherwise, DDT looks for an initialization file (in
<hsname>;<xuname> LOGIN, or in <hsname>;* LOGIN if
that is not found.) If DDT succeeds in finding one of
those files, it considers :XFILE'ing it: if <xuname>
equals <runame>, DDT just types "INIT" and :XFILE's it
unconditionally, but otherwise it asks "--Init--" and
:XFILE's the init file only if the user types a space.
However, if the init file which would be run is one of
GUEST1;* LOGIN or USERS1;* LOGIN, it is run without
asking, so that naive users can always get the "safe"
switch settings.
Otherwise, if a file <hsname>;<xuname> MAIL exists, DDT
types "--Mail--" and reads a character from the TTY.
If the character is space, DDT prints the file and
renames it to <xuname> OMAIL.
Also if there is no init file: if the user has a date entry
in the :MSGS database (i.e. if he has ever done a :MSGS),
or if he has a directory, a :MSGS command will be executed
a :MSGS command will be executed to print any new system
messages. If there are any new messages, "--Msgs--" will
be typed before each one, and if the user's response is
other than space or rubout, DDT will leave the messages
for later.
If the automatic :MSGS is not done (user has no dir and
no database entry), the user will be informed of the
existance of the :MSGS command in case he is a new user.
A special hack causes a :INTEST given in an execute file
or valret string to pretend that there is no init file;
it will always try to print mail and messages. It is
a useful thing to put in an init file to print mail
and messages in the default manner, in addition to the
ideosyncratic things the init file is needed for.
:INTPRT
analyses the value of $Q as a word of
interrupt bits, printing out the names of the bits that
are set, using the same names used when a job returns
to DDT. If the sign is set, the word is interpreted as
2nd word interrupts; otherwise, as 1st word interrupts.
:IOPEN <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!).
�
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.
�
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.
�
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.
1) 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").
2) 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.
3) 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.
4) 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.
* ..RHSNAME (16) --- Translate an XUNAME into an HSNAME
This performs the lookup function of ^S, plus being generalized to inquire
about on other ITS's The RH points to a two word block. The first is only read
by DDT, not written. If it is zero, the HSNAME of the ITS on which it is
running is read. If it isn't zero, it is expected to contain an ITS, and the
HSNAME for that site is used. The second word should contain the XUNAME to
look up, and DDT will return the HSNAME in that location.
* ..RMAIL (17) --- Find a user's mail file. This performs the function of
^A. The RH points to a 3-word block of info. The first is the ITS name,
the second is the XUNAME, just like ..RHSNAME. The third is used only
to return a value. The value's returned are 1) ITS his mail file would be
on. If an ITS was explicitly specified, it will, of course, be the same
as specified. The XUNAME is clobbered to be the XUNAME mailed to. If the
FOO has a BAR@MC Network Address in INQUIR, the ITS returned would be MC,
and the XUNAME would be BAR. BAR's HSNAME would be returned in the third
word. The third word is always the HSNAME corresponding to the XUNAME
returned in the second word, regardless of whether a XUNAME translation is
made because of the Network Address entry.
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.
�
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)
�
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.
8a) ITS No longer being debugged!
means that 8) above no longer applies.
9) 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.
�
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.
�
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:
Breakpoints are removed from the job.
If the job stopped with a .BREAK 16, requesting
death, it will die, saying ":KILL ".
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, ...
�
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.
