Trailing-Edge - PDP-10 Archives - cuspbinsrc_1of2_bb-x128c-sb - 10,7/ddt/ddt.kbd
There are no other files named ddt.kbd in the archive.
[*ASCI][*RUNOFF][*title]DDT41A - DDT %41A(324) User's Guide to New Features@
[*ft][*begin]Copyright (C) 1978, 1979, 1982/cDigital Equipment Corporation, Maynard, Massachusetts, U.S.A./c/lThis software is furnished under a license and may be used and copyed only
in accordance with the terms of such license and with the inclusion of the
above copyright notice.  This software or any other copies thereof may not
be provided or otherwise made available to any other person.   No title to
and ownership of the software is hereby transferred./l/lThe information in this software is subject to change  without  notice and
should not be construed as a commitment by Digital Equipment Corporation./l/lDigital  assumes  no  responsibility  for  the  use  or reliability of its
software on equipment which is not supplied by Digital./l[*subttl]Introduction and Overview@[*pg]
[*hl1]Introduction and Overview@
This document is designed as a user's guide to DDT version 41//41A in so far as it has changed from previous versions of DDT. It is not a complete user's guide to all the wonders of DDT, just those new features which have recently been implemented (although directed primarily at new features only in DDT version 41//41A, some documentation is included to describe other aspects of DDT which have been around for a longer period of time, but were never fully understood or otherwise documented)./l/lThroughout this document it is assumed that the reader is already familiar with DDT and the MACRO assembly language in general as well as the appropriate operating system(s)./l/lThis (DDT41A) is the third revision of this document, incorporating the additional changes to DDT version 41A as of edit 324, and completely supersedes all previous versions (DDT41).
DDT version 41A will run on KA-10's, KI-10's, KL-10's, and KS-10's, using no paging, KI-paging, or KL-paging, with or without extended addressing in user or executive mode (user and file DDT's run only in user mode) with no special assembly needed. DDT version 41A must be assembled to run under either the TOPS-10 or the TOPS-20 operating system./L/LIt traditionally has been a goal to maintain one single set of source files from which all flavors of DDT are built. This goal has been maintained./l[*note]Note@TOPS-20 UDDT (and SDDT) now use memory locations 764000 through 777777 (previously 770000 through 777777), but the starting address for DDT continues to be location 770000.@
[*hl1]Memory and Address Control@
The single biggest change to DDT version 41 from earlier versions is in the realm of memory control and how the user addresses memory locations.
[*hl2]Extended addressing@All flavors of DDT except FILDDT will run in any memory section. Full extended addressing is supported, as are "large" addresses - DDT will now accept a full 36-bit expression as an address although obviously only FILDDT can actually handle an address over 30-bits wide. In all cases the actual address must be positive (i.e., effectively a 35-bit address).
[*hl3]Symbol table restrictions@There are certain restrictions however which must be adhered to in order for DDT to function correctly. The first restriction is that the symbol table logic is essentially section-dependent, i.e., the symbol table and its pointers (.JBSYM=116 and .JBUSY=117, also .JBHSM=6 relative to the start of the "high segment") must reside (i.e., be mapped) in the same section as that in which DDT itself is running. Further, the symbol table can be no longer than 128K words in length and must be RADIX-50 format./l/lMuch thought is being given towards the implementation of a totally new symbol table scheme which would address all of these problems, the single biggest one of which is simply how is extended addressing going to be used - as a single fixed address space with one or more "global" symbol tables (like the TOPS-20 monitor currently works), or as a collection of independent sections each of which has section-local symbols//symbol tables (whatever that means), or what?
[*hl3]Breakpoint restrictions@The second restriction of which the user must be aware concerns breakpoints. Since the hardware has no facility to unconditionally transfer control to DDT using only 36-bits, DDT must be mapped into each section (at the same relative address obviously) which contains code into which the user wishes to place breakpoints.
[*hl3]Location examining restrictions@Even if running on an extended addressing machine if DDT is running in section 0, then only locations within section 0 (addresses 0 to 777777) may be manipulated. DDT will make no effort to outsmart the combined efforts of the user and the operating system by sneaking into a non-zero section even momentarily to do the memory reference.
[*note]Note@DDT version 41A, if it has previously been running in
a non-zero section, and is currently entered in section 0, will blindly jump
back into the last non-zero section in which DDT was running. This is
to allow DDT to be able to access non-zero section locations (such as
[*hl2]Effective address calculation@DDT can calculate effective address references using either "local" or IFIW (Instruction Format Indirect Word) or "global" or EFIW (Extended Format Indirect Word) formats. In a normal DDT address-opening command ("//", "/\", /<TAB/>, etc.) a single /<ESC/> delimiting the address expression (e.g., "MOVE 3,/@200(10)$//" or just "$/[") instructs DDT to treat the expression as an IFIW word and calculate the effective address exactly like the hardware would, were the hardware to execute that 36-bit word as an instruction at location "." (whether or not location "." is currently open)./l/lTwo /<ESC/>'s delimiting the address expression instructs DDT to treat the 36-bit expression as an EFIW word and calculate the effective address exactly as the hardware would, were the hardware to indirectly address the 36-bit expression at location "." (whether or not location "." is currently open). A strange case can come up about which the user should be cautioned - there is an ambiguity as to where (i.e., what "section") to start the effective address calculation. DDT assumes the left half of "." (i.e., the last location opened by the user). If for example having opened location 0,,1234 which contains 7,,4321 the user issues the command "$$/[" then DDT will calulate the effective address as the contents of location 4321 in section 0 indexed by the right half of register 7, and if bit 13 is on, treating that word as an IFIW and continuing the address calculation. This, although probably not what was expected, is in fact exactly what the hardware would do since the indirect word came from section 0. Had the user opened location 1,,1234 (containing 7,,4321) then DDT would take the contents of location 7004321 and continue from there./l/lIf no /<ESC/>'s delimit the address expression, then DDT simply uses the full 36-bit expression as the address (e.g., "30,,30//" says open location 30000030 and "-1//" says open location 777777777777). Again, only FILDDT can actually reference an address greater than 30-bits wide (not that anyone has that much disk space, but the hardware will not permit an address space over 30-bits wide), and in any case the address must be a non-negative 36-bit integer./l/lThere is a special case in which DDT does something "kinky" - if a space was typed in entering the address expression, or if no explicit address was typed (i.e., the user is using the "last word typed" by simply typing only (for example) /<TAB/>), DDT will form the 36-bit actual address by using only the right half of the 36-bit address expression plus the left half of "." as the section number. This not-at-all-obvious behavior is so that the user can type in expressions such as "JRST PAT/<TAB/>" and have DDT go to location PAT in the same section as the JRST PAT instruction rather than going to address 254000000000/+(PAT modulo 2**18). Another common usage of this "feature" would be in chaining down linked lists where the link pointer is an 18-bit section-local address in the left half of a word. To do this the user may type "sp$$Q//" (where "sp" means space). This is one of those cases where usefullness outweighs cleanliness of implementation and documentation.
[*hl2]Modifying memory@Two new commands have been added to facilitate DDT's manipulation of the user address space.
[*hl3]Automatic write-enable@The $W or $0W command instructs DDT to, if the user attempts to deposit into a write-protected memory location, automatically attempt to write-enable the memory location, do the memory deposit, then finally re-write-protect the memory location (default for TOPS-10); the $$W or $$0W command instructs DDT to simply give an error indication if the user attempts to change a write-protected memory location (default for TOPS-20). For FILDDT the use of this command is restricted to non-file usage such as "DDT'ing" the running monitor//memory space.
[*hl3]Automatic page-creation@The $1W command instructs DDT to automatically try to create the page the user is trying to deposit into if it doesn't already exist (default for TOPS-20); the $$1W command instructs DDT to simply give an error indication if the user attempts to write into a non-existant page (default for TOPS-10). EDDT and FILDDT doing super I//O or "DDT'ing" an .EXE file will NEVER attempt to create a non-existant page. For FILDDT the user must specify patching the file when he starts FILDDT in order to be able to create new pages (e.g., extend the file or fill in a gap in the middle of the file (TOPS-20 only)).
[*hl2]Page mapping and physical addressing@All flavors of DDT (on TOPS-20, only FILDDT) support page mapping and address relocation as well as register and physical address manipulation. All of these functions use some variation of the $U//$$U DDT command. In general these functions may be mixed together (for example address relocation and page mapping).
[*note]*** Warning ***@The $U command syntax in DDT version 41//41A is totally different (and mainly incompatible) from previous versions of DDT! The user is MOST strongly urged to carefully read this section on memory mapping and addressing!@
[*hl3]Physical addressing@DDT now has the concept of "physical" addressing in addition to its normal "virtual" addressing. The $U command instructs DDT to use normal virtual addressing (what it used to do); the $$U command instructs DDT to manually track down the honest physical address rather than the virtual address space in which DDT finds itself running. Physical addressing is really applicable only to EDDT or to FILDDT looking at running monitor//memory (TOPS-10 only). User mode DDT (including EDDT running in user mode, MDDT (TOPS-20 only), and VMDDT (TOPS-10 only)) and FILDDT looking at a disk all treat $U and $$U identically. In physical addressing location 0 is not register 0 (i.e., DDT's internal copy of user register 0) but rather physical memory location 0 page 0 bank 0 box 0 (that memory location on the hardware memory bus that responds to all address bits = 0)./l/lWhen the $$U DDT command is issued "physical" locations 0 to 17 become "registers" 0 to 17. For user mode DDT this means locations 0 to 17 become DDT's registers rather than the user's registers (although the user's registers will be properly restored on DDT-exit, $$U merely directs DDT not to use the internal "fake" (i.e., user) registers). For FILDDT this means file words 0 to 17 (as mapped by the .EXE directory if used) become locations 0 to 17 (normal for a data file)./l/lSubsequent issuance of the $U DDT command will redirect locations 0 to 17 to being DDT's internal "fake" registers again, except for FILDDT looking at an data file or doing super I//O to a disk./l/lNote that for executive mode EDDT to utilize physical addressing the paging hardware must have been enabled PRIOR to DDT-entry. This requirement exists because EDDT, in order to access all of physical memory, needs to map the desired physical address into its own (executive) virtual address space, which it does by fondling the already-extant page maps. For EDDT to provide physical addressing capability without this restriction would require 2 (3 if KL-paging) more memory pages be dedicated to EDDT for building temporary page maps, plus support code etc./l/lFor FILDDT to examine//modify physical memory a 7.00 or later release of the TOPS-10 monitor is required; no release of TOPS-20 supports FILDDT'ing physical memory.
[*hl3]Page mapping@DDT now supports page mapping in both the KI- and the KL-tradition. EDDT in executive mode will dynamically figure out which style of paging is in effect and operate accordingly. All other flavors of DDT (including EDDT running in user mode) will assume the mode of paging used by the operating system for which DDT was assembled - KI-paging for TOPS-10 and KL-paging for TOPS-20. To select KI-paging emulation the flg$10U command is used; to select KL-paging the flg$11U command is issued; in either case if flg is zero then the paging emulation is disabled, if flg is 1 then the appropriate paging emulation is enabled./l/lIn executive mode EDDT or FILDDT looking at running monitor//memory space DDT will internally utilize physical addressing in order to provide the user the true mapped virtual address space desired.
[*hl4]KI-paging@For KI-paging (TOPS-10 default) the page mapping command for the executive virtual addressing space is /[upt/</]ept$/[0/]U where upt is the optional physical memory page number of the user process table (for setting the "per-process" addressing space - exec virtual addresses 340000 through 377777) and ept is the physical memory page number of the executive process table. The user virtual addressing space is selected by the upt$1U command. The command $U returns DDT to regular unmapped virtual addressing.
[*hl4]KL-paging@For KL-paging (TOPS-20 default) the page mapping command for the executive virtual addressing space is ept$/[0/]U where ept is the physical memory page number of the executive process table, or epx$$/[0/]U where epx is the index into the SPT of the executive process table pointer. To select the user virtual addressing space the command is upt$1U where upt is the physical memory page number of the user process table, or upx$$1U where upx is the index into the SPT of the user process table pointer. The command $U returns DDT to regular unmapped virtual addressing./l/lTo map a single section (256K address space) under KL-paging the command is either sec$2U where sec is the physical memory page number of a KL-paging section map, or sex$$2U where sex is the index into the SPT of the section map./l/lBasically, under KL-paging, $0U selects the ept, $1U selects the upt, and $2U selects a single section. A single $ indicates the physical memory page number and two $'s indicate an SPT index.
[*hl3]Setting the SPT@FILDDT will automatically define the start of the SPT from a disk file (assumed monitor dump) from the symbol "SPT" if it exists (TOPS-20 only). The command spt$6U specifies to DDT that the SPT starts at address spt.
[*hl3]Register addressing@The command acs$5U instructs DDT to use the 20 consecutive locations starting at acs as the registers (DDT maintains an internal copy of the registers so changing "register" 3 will not affect (for example) acs/+3). FILDDT, when reading an .EXE file, will automatically load its internal "fake" registers as though the user had typed CRSHAC$5U if TOPS-10 or BUGACS$5U if TOPS-20. Note that if physical addressing mode has been entered (the user has issued the $$U command) then the internal "fake" registers are ignored; if the user subsequently reenters virtual addressing (via some form of the $U command) then an acs$5U command may also have to be re-issued to get the registers back (this does not affect the saving and restoring of the hardware registers in user or executive DDT, only what DDT will use for typing out locations 0 to 17)./l/lThe command flg$3U explicitly controls the usage of DDT's internal "fake" registers - if flg is 0 then the "fake" registers are ignored (i.e., 0 to 17 are taken from the true current addressing space), if flg is non-zero then addresses 0 to 17 are taken from DDT's internal copies of the registers./l/lThe $U command, except for FILDDT'ing a data file or doing super I//O to a disk, will return DDT to its internal "fake" registers. The selection of registers is completely independent of any page mapping in effect. Changing virtual address spaces does not change the "registers"./l/lIn executive mode EDDT only the command n$4U will switch DDT to use (and thus display) hardware AC block n (available only for KL-10's and KS-10's). The user is warned that 7$4U on a KL-10 will bring rapid and rabid death (the microcode uses AC block 7). On DDT exit DDT will restore the ac block context to the state it was in at DDT entry.
[*hl3]Address relocation and protection@As an aid to looking at data structures which are formed using pointers as offsets rather than pointers as absolute values, DDT will allow the user to set both a base relocation address to be added to all addresses used in location examining commands and a protection address beyond which the user "virtual" (note the use of "virtual" here as meaning pre-relocated) address is illegal. This is (coincidently) exactly analguous to the KA-10 hardware relocation and protection strategy, and in fact could be used as such to "mimic" the $U KI//KL//KS-10 functionality on a KA-10 in executive mode. The form of this command is bas$8U where bas is the base virtual address, and prt$9U where prt is the maximum address the user will be allowed to type in. Note that page mapping and address relocation and protection are independent mechanisms, with address relocation and protection being performed before any mapping is done. The protection address has no effect on the final "physical" address generated by any mapping currently in effect.
[*hl3]$U command summary@All $U//$$U commands take the following form:
[*le]$U	Unmapped virtual addressing
[*le]$$U	Unmapped physical addressing
[*le]ept$/[$/]/[0/]U	Select executive virtual addressing
[*le]upt$/[$/]1U	Select user virtual addressing
[*le]sec$/[$/]2U	Select single section
[*le]flg$3U	Select (deselect) internal fake registers
[*le]acb$4U	Select hardware ac block
[*le]acs$5U	Load internal fake registers
[*le]spt$6U	Select base of SPT
[*le]bas$8U	Set base relocation address
[*le]prt$9U	Set protection address
[*le]flg$10U	Select (deselect) KI-paging
[*le]flg$11U	Select (deselect) KL-paging
[*le]acb :/= integer ac block number
[*le]acs :/= address of 20-word register block
[*le]bas :/= base relocation address
[*le]ept :/= executive process table page number
[*le]flg :/= selection flag, zero to deselect, non-zero to select
[*le]prt :/= protection (maximum allowable) address
[*le]sec :/= section map page number
[*le]spt :/= address of SPT
[*le]upt :/= user process table page number
[*hl3]Address checking (Executive EDDT only)@EDDT, when running in executive mode, now is much more extensive in validity-checking memory references. In particular, EDDT will not cause a NXM (page fault) trap to the resident operating system if the user types in an illegal (non-existent or unmapped) address, but rather will simply type its ubiquitous ?/<DINK/>/<TAB/> error message.
[*hl3]Address breaking@DDT will no longer cause an address break to occur when examining or depositing a location at which an address break condition has been set. This applies only to "user" examines and deposits, an address break set in DDT will still cause an address break to occur.
[*hl1]Specifying the Start Address@
The $G command now expects a 36-bit address (obviously with bits 0 to 5 off) at which to start the user program. This means that the users of programs such as the TOPS-10 monitor which define symbols like "DEBUG=:/<JRST ./>" can no longer go either DEBUG$G or DEBUG$X at the user's whim but must decide on one form or the other (the default obviously being to do nothing - i.e., to settle for the DEBUG$X form)
[*hl1]Symbolic expression typein and typeout@
DDT has expanded the range of both symbolic typein and symbolic typeout.
[*hl2]Symbolic typein@The JSYS opcode (opcode 104) has been added to TOPS-20 DDT, as have all the TOPS-10 UUO's (but not the CALLI's etc.) for debugging programs which run under the compatibility package./l
The "G" format floating point instructions GFMP, GFDV, GFAD, and GFSB have
been added to the opcode table for both typein and typeout.

[*hl2]Multiply-defined symbol typein@If the user types an ambiguous symbol (a symbol defined two or more places outside of the current local symbol table and not in the current local symbol table) DDT will issue an "M" error message.
[*hl2]Selecting no local symbol table@The $: command issued without an explicit module name to use as the local (or "opened") symbol table will deselect any local symbol table. This is the initial state in which DDT starts.
[*hl2]Symbol cache@DDT now has a symbol "cache" of symbols recently used to type out values. This cache is used primarily for typeout; typein will check the symbol cache for a matching symbol from the currently opened or local symbol table, if no match is found the cache is ignored and the regular symbol table is used. The symbol cache is "flushed" on the issuance of any $: command.
[*hl2]Symbolic typeout@DDT now goes to great pains to find any possible user-defined symbol (such as an OPDEF) to match the expression DDT is trying to type out. The order in which DDT searches for a symbol match in symbolic typeout mode for non-I//O instructions is:
[*ls][*le]Full 36-bit match; OP, AC, I, X, and Y fields (e.g., the TOPS-20 monitor calls such as GTJFN)
[*le]OP, I, X, and Y fields (e.g., the TOPS-10 monitor calls such as FILOP.)
[*le]OP and AC fields (e.g., the TOPS-10 monitor calls such as INCHWL or "instructions" such as HALT)
[*le]OP field only (e.g., user UUO's or "OPDEF XMOVEI /[SETMI/]")
[*le]DDT's internal hardware opcode table
The order in which DDT searches for a symbol match in symbolic typeout mode for I//O instructions is:
[*ls][*le]I//O OP and DEV fields (bits 0 to 12 - e.g., KL-10 APRID or KS-10 RDCSB)
[*le]Regular (non-I//O) OP field (e.g., KS-10 UMOVE)
[*hl1]Command typeout@
[*hl2]ASCII typeout@
DDT adds the typeout mode commands $8T and $9T to typeout 8 bit ASCII or 9 bit ASCII respectively (i.e., pick up 8 or 9 bit bytes and "type" them straight as is - which with current TOPS-10 and TOPS-20 operating systems means as 7-bit ASCII)./L
The adr$0T command has been added to type out a 7-bit "ASCIZ" format text
string (i.e., a string of 7-bit ASCII characters terminated by a null
byte) starting at address "adr" or "." if adr is not specified. Upon
issuance of the $0T command, DDT will type out consecutive 7-bit bytes until
either the terminating null is encountered or the user types a character
(similar to stopping a search).
[*hl2]Floating point typeout@
The /[$/]$2F command (TOPS-20 FILDDT//SDDT//UDDT only) selects double-precision floating point
typeout mode; in other respects it is identical to the /[$/]$F command.
[*hl2]Mask and value typeout@
In FILDDT the various masks and internal values (such as $U) may be examined
by issuing the appropriate command without an argument. For example, typing
"$M" to FILDDT will result in the typeout of the current $M mask value.
[*hl1]Command files@The $Y command (TOPS-10 DDT only) has been changed somewhat, both in input and output (logging) functions.
[*hl2]Command input@If the user does not type a 36-bit expression to be used as a file name (such as $""FILNAM"$Y) but just types $Y by itself then DDT will prompt with "File:/f". After the prompt the user can enter a TOPS-10 file specification in the form dev:name.type/[directory/]//switches where /[directory/] can of course contain SFD's./l/l
The echoing of the $Y command input may now be supressed via the TTY control
"mask" - see section 14.2.
[*hl3]//A switch@The //A switch instructs DDT to abort the command file if a DDT-detected command error occurs (such as reference to an undefined symbol).
[*hl2]Command output (logging)@When reading a command file ($Y command) DDT will no longer "log" all output onto device LPT: but rather just type out onto the user terminal.
[*hl1]Automatic patch insertion@
The automatic patch insertion facility ($/< and $/> commands) are basically the same as in version 40 of DDT with only minor differences.
[*hl2]Patch opening@The user may specify patching either by sym$/< where sym is the name of a symbol (which will be automatically updated at the termination of the patch) or via exp$/< where exp is any 36-bit expression representing the address of the resultant patch. If the later form of the patch command is used no symbol will be updated to the end of the patch./L/L
With DDT version 41A, the user can no longer open a patch if one is
already in progress - the currently open patch must be either closed
($n/> command) or aborted ($$0/> command) first.
[*hl2]Default patching symbol@The list and order of default patching symbols which DDT uses when the user does not supply an explicit patching symbol is now:
[*ls][*le]PAT (TOPS-10 EDDT only)
[*le]FFF (TOPS-20 EDDT//KDDT//MDDT only)
[*le]PAT.. (all flavors)
[*le]PATCH (all flavors)
[*hl2]Default patching address@If the user does not supply an explicit patching symbol and DDT is unable to find one of the default patching symbols then the address specified by the right half of location .JBFF (even on TOPS-20) is used. On patch close ($/> command) if the patching address was defaulted via .JBFF, then both the right half of location .JBFF and the left half of location .JBSA are updated to point to the end (/+1) of the patch.
[*hl2]Patch closing@
The patch close command has been expanded to a more general form of $n/>,
where the "n" is used to control "skipness" of the patch close, i.e., how
many JUMPA instructions to insert at the end of the patch to return to the
patched code. If "n" is 0 then no JUMPAs are inserted (usefull for patching
a JRST instruction); if "n" is 1 then one JUMPA instruction is inserted
(as in patching a non-skip instruction); etc.; the default remains 2.
[*hl2]Patch closing confusion and restriction@It no longer matters how (when) the user types the $/> command, either immediately after the final word expression, or after a /<CR/> or /<LF/> to terminate the final word expression - DDT will never generate a 0 word for free./l/lThere is a very obscure restriction however on the use of the # command in conjunction with the $/> command. If the user is referencing an undefined symbol in the expression for the last word of the patch then that expression must explicitly be terminated in such a fashion as to close the location before terminating the patch. For example, "MOVE T1,BLETCH#$/>" is illegal but "MOVE T1,BLETCH#cr$/> (where "cr" indicates a carriage return) is ok.
[*hl2]Patch abortion@
A patch may be aborted with the $$0/> command.
The breakpoint logic in DDT version 41//41A has been extensively revamped in order to support extended addressing. The default number of breakpoints is now 12 (decimal); and can be set (by defining the symbol NBP/=number of breakpoints) arbitrarily high (within memory space limitations) rather than being limited to 9 or 36 (decimal) depending on which code restriction one choose to believe.
[*hl2]Setting breakpoints@DDT can now set a breakpoint in code running in any section with two restrictions:
[*ls][*le]If DDT is currently running in section 0 then breakpoints can only be set in section 0 (see section 3.1.3 above).
[*le]DDT must be mapped in the section containing the code in which breakpoints are to be placed (the logic of this is that since there is no way for DDT to cause unconditional transfer of control to DDT with only 36 bits some portion of the section address space must be devoted to DDT; therefore, given this restriction, one might just as well put all of DDT in that section since it makes for a cleaner and simpler implementation). Note that this does not mean DDT must be running in that section, but merely that DDT must be mapped in that section!
It does not matter into how many different sections the same code is mapped as long as DDT is mapped into the same sections since DDT is "section-independent". For example (taking the TOPS-20 monitor which maps section 0 and section 1 identically) if a breakpoint is set at address 1004567 (or 1,,4567) but the PC was 4567 (or 0,,4567, i.e., in section 0 rather than section 1) when the breakpoint was executed DDT does not care (as long as DDT is mapped in that section, which in the example of the TOPS-20 monitor it is)./l/l
The syntax for setting a breakpoint is now opn/<cmd/>bpt$nB where n is optional and, if specified, declares the breakpoint number to be assigned to that address; bpt is the 36-bit address at which to place a breakpoint; opn is an optional 36-bit address to open and display upon execution of the breakpoint; and
cmd is the address of a DDT command string to execute upon breaking./l/l
The "cmd" string address is the address of an ASCII (7-bit byte) string of
characters terminated by either a ^Z or a null character. This string will
be treated as DDT command input, just as if it came from an $Y command file
(and in fact the $Y command file facility must be enabled - symbol FTYANK
defined non-zero when assembling DDT - for the cmd string to work)./l/l
DDT will no longer assign two different breakpoints to the same address, either accidentally or under user control - if the user attempts to set a breakpoint at a location at which a (different) breakpoint is already set, the old breakpoint is cleared first.
[*hl2]Breakpoint typeout@Upon execution of a breakpoint DDT will now type the user instruction (in instruction format regardless of the permanent typeout mode) at that breakpoint and set "." to the breakpoint address. If, further, opn was specified as in section 9.1 above, then DDT will also display the contents of location opn in the permanently set typeout mode and "." will be updated to opn (with the breakpoint address itself becoming the previous PC sequence and so available via the $/<CR/> etc. commands)./l/l
The breakpoint instruction typeout is under the control of a flag bit
set in the TTY control mask - see section 14.2 for details.
[*hl2]Examining breakpoint locations@The $nB command continues to be the "address" of breakpoint n's database, but $nB is no longer equal to $n-1B/+3. The breakpoint database of interest to the user now has the following format:
[*le]$nB/+0//	If nonzero the address for breakpoint n
[*le]$nB/+1//	The conditional break instruction (break if skips)
[*le]$nB/+2//	The proceed count (break on transition to 0)
[*le]$nB/+3//	If greater than or equal to zero then the address to be displayed
The rest of the breakpoint data base should not be of use to the user.
[*hl2]Unsolicited breakpoints@DDT has a new breakpoint facility - the ability to handle unsolicited breakpoints (i.e., breakpoints that DDT did not itself set). If control passes to location $0BPT/+1 ($0BPT is a global DDT symbol) then DDT will act as if a breakpoint had been set at the address-1 contained in location $0BPT. The address in $0BPT must be setup as if the cpu executed a JSR $0BPT instruction - if in section 0 then flags,,PC otherwise just global 30-bit PC. After "hitting" an unsolicited breakpoint the user can proceed with program execution with the $P command (all arguments to the $P command such as proceed count or auto-proceed ($$P) are ignored)./l/lAlthough this facility gives programs the ability to cause breakpoints at any time (thus getting into DDT with the program state carefully preserved) it is intended to be of most use in conjunction with an as-yet-unimplemented monitor command (such as control-D) to "force" a breakpoint on a program without having to control-C//DDT the program. Then the user could simply continue with the program by typing $P.
[*hl1]Single-stepping the program@
The $X DDT command has been significantly modernized (and sped up in general) with version 41//41A of DDT.
[*hl2]New opcodes@The ADJSP, DADD, DSUB, DMUL, and DDIV instructions have been added to DDT's $X table although double- and quad-word integers (for DADD etc.) are still typed out as two or four single words rather than one big multiple precision integer. All of the extended JRST-class instructions are correctly simulated//traced. A user-UUO being executed in a non-zero section is simply XCT'ed and is not traced.
[*hl2]Byte-manipulation typeout@A rudimentary byte-manipulation-instruction typeout facility was added (to DDT version 40 actually) to display the byte pointer and the contents of the effective address of the byte pointer. The EXTEND-class instructions are not handled.
[*hl2]Effective address calculation@DDT now always calculates the effective address of the instruction being $X'ed rather than just blindly "doing it" in order to both prevent DDT from getting an illegal memory reference as well as to make DDT be independent of the section in which the user PC resides (i.e., DDT does not have to be mapped into the user PC section to handle $X'es although if the user PC is in a non-zero section then DDT must be in a non-zero section). Besides, it's usually faster too!
[*hl2]KS-10 I//O instruction trace@The KS-10 specific I//O instructions which reference the UNIBUS (executive mode only) are not traced, only the contents of the register specified in the AC field are displayed. Since the UNIBUS device registers can be reference-volatile (i.e., merely referencing one can cause it to change - such as the DL-11 data registers) DDT does not typeout the contents of the referenced UNIBUS address. Further, since the effective address of the instruction is not calculated in a standard format (at least as far as DDT is concerned) the effective address itself is not even displayed.
[*hl2]PC skipping@If the user instruction being $X'ed skips then DDT will now typeout "/<SKIP/>" if the PC skips by one location, or "/<SKIP n/>" if the PC skips by n locations, where n is less than or equal to the DDT assembly parameter SKPMAX (by default 3). If the PC changes more drastically than that (e.g., goes to a smaller address) DDT will type "/<JUMP/> instead.
[*hl2]ERCAL//ERJMP@DDT (TOPS-20 only) will now handle instructions followed by either an ERCAL or an ERJMP instruction (which is really just a 72-bit instruction with two effective addresses). If the instruction being executed does not take the error jump then DDT will print "/<ERSKP/>" after the normal instruction trace to indicate to the user that an ERCAL or ERJMP was just skipped (i.e., the PC incremented by 2 rather than 1) and will not display the ERCAL or ERJMP instruction. If the instruction does take the error jump then the ERCAL or ERJMP instruction will be displayed, if an ERCAL instruction then register 17 will also be displayed, and the PC will be changed to the error address./l/lDDT will print "/<ERSKP/>" rather than showing the ERCAL or ERJMP instruction since DDT has no way of telling whether or not the instruction itself caused the skip (as in a SKIPA) or if the PC merely "fell through" the ERCAL or ERJMP instruction (as in a successful MOVE)./l/lUsers of EDDT and MDDT should be cautioned about $Xing instructions followed by an ERCAL or ERJMP in non-zero sections - the monitor has a tendency to transfer control to the error address in section 0, which will cause a BUGHLT because DDT (running in executive mode) does non-zero section things thinking it is still in a non-zero section.
[*hl2]$X'ing an INIT@DDT will now let the user $X an INIT (TOPS-10) monitor call. DDT will print out /<SKIP 2/> if the INIT fails or /<SKIP 3/> if the INIT succeeds.
[*hl2]$X speed up@By building into DDT a table of instructions which can cause the state of the known world to change, and assuming the state of the world does not change if the instruction being $X'ed is not so marked, the time required to $X an instruction is cut by roughly a factor of 10. This results in a dramatic performance increase especially for EDDT on KL-10's where waiting for the console front end to switch between secondary and primary protocol is very time-consuming.
[*hl2]Repetitive $X'es@The $$X command now takes an optional address range. Normally $$X will terminate when the user PC inclusively enters the range ./+1 to ./+SKPMAX (default value of SKPMAX is 3). The user may specify lwr/<upr/>$$X where lwr is the lower address boundary and upr is the upper address boundary which, if the user PC ever inclusively enters the range so specified, terminates the $$X. If only lwr is specified then upr defaults to lwr/+SKPMAX. This command is very useful for recovering from having $X'ed a (for example) PUSHJ instead of having $$X'ed the (for example) PUSHJ.
[*hl2]Fast $$X'es@
The $$X command has been enhanced to allow the user to specify that much of
the $$X "paranoia" be bypassed. The high-speed $$X command is $$1X, which
causes DDT to not "restore the state of the world" prior to each instruction
$Xed. This is usually not a problem unless the code being $$Xed modifies the
PSI system, terminal characteristics, or the like.
[*hl2]$X'ing from instr$X@If the user $X'es a return from a subroutine which was entered by doing an instr$X (for example "PUSHJ P,SUBRTN$X where SUBRTN has a breakpoint in it) then DDT simply "returns" from the original instr$X rather than proceding to $X the internals of DDT itself. This is a very obscure condition so don't worry too much about it.
[*hl2]$$X status@DDT will now respond to a ? character being typed during an $$X sequence by typing "Executing: " followed by the current user "pc" and instruction being executed. Typing any other character terminates the $$X immediately.
[*hl2]$X PC@The $. command now acts like the . command only $. returns the value of the $X PC (i.e., the address of the next instruction to be $X'ed). The $$. command returns the previous $. value (useful for $$./<$$X as in section 10.9 above).
Most of the differences in how DDT handles searches are simply bug fixes, not major changes in the logic of searching.
[*hl2]Non-existant pages@DDT now simply skips over pages which don't exist in the address space being searched, rather than terminating the search as soon as a hole has been found.
[*hl2]Effective address searches@Since almost all address calculations start with an IFIW basis (with the exceptions being such things as interrupt vectors and the like on KL-10's or KS-10's), DDT will assume that each word it examines is an instruction and perform an IFIW effective address calculation. The final result must match in all 30 bits (actually internally DDT will do a full 36-bit compare so the address being searched for had better not contain anything in bits 0 to 5).
[*hl2]Address limit defaults@With the advent of extended addressing and physical addressing the address limits are defaulted somewhat differently than from previous versions of DDT:
[*le]EDDT, MDDT (TOPS-20 only), UDDT, and VMDDT
[*LE]Lower Limit: /<current section/>,,0
[*le]Upper Limit: /<current section/>,,777777
[*le]FILDDT looking at an .EXE file
[*le]Lower Limit: 0
[*le]Upper Limit: highest virtual address mapped
[*le]FILDDT looking at a data file
[*le]Lower Limit: 0
[*le]Upper Limit: highest word written in file
[*le]FILDDT looking at disk structure//unit
[*le]Lower Limit: 0
[*le]Upper Limit: highest word in disk structure//unit
[*le]FILDDT looking at runing monitor
[*le]Lower limit: 0
[*le]Upper limit: 777777
[*le]FILDDT looking at physical memory (TOPS-10 only)
[*le]Lower Limit: 0
[*le]Upper Limit: Highest extant memory address
As with any defaults not all cases will be properly "guessed" by DDT. In particular if the user has mapping or address relocation in effect the virtual address range so produced may have nothing whatsoever in common with the address limit defaults chosen by DDT.
[*hl2]Search matches@DDT will leave each address matched by its search on the "pc stack" available to $/<CR/> etc. commands. When the search is terminated DDT will set "." to the last address searched.
[*hl2]Searching status@DDT will now respond to a ? character being typed during a search by typing "Searching: " followed by the current location and value being searched. Typing any other character terminates the search immediately.
DDT allows the user to "watch" a location, waiting for it to change. Although primarily useful for FILDDT'ing the running monitor, it is present in all flavors fo DDT for completeness. The syntax of the watching command is exp$V, where exp is the address to be watched. If no explicit address is specified the last location opened by the user will be used./l/lUpon initial issuance of the $V command the location is displayed. Thereafter the location is continuously monitored, and will be displayed every time its contents change. In user mode DDTs (and this includes TOPS-20 MDDT as well) the location is checked once a clock tick (approximately 50 to 60 times a second), in exec mode EDDT the location is continuously being monitored - no "pause" is attempted./l/lDDT will respond to a ? character being typed during an $V sequence by typing "Watching: " followed by the current location and contents being watched. Typing any other character terminates the $V immediately.
[*hl1]Zeroing memory@
The algorithm used by DDT previous to version 41//41A has only limited usefulness in today's modern virtual world (especially on TOPS-20). A new command has been implemented - lwr/<upr/>exp$z where lwr is the lowest (starting) address, upr is the highest (ending) address, and exp is the 36-bit quantity to deposit in each word inclusively bounded by lwr and upr. Both lwr and upr must be specified. If exp is not specified then 0 is used as the default. This command completely
supersedes the older $$Z command, which has been removed from DDT version 41A./l/l
A special note: The creation of zeroed pages (which formerly were non-existent) by the $Z command is under the control of the automatic page create flag (i.e, the $1W and $$1W commands - see section 3.3.2)./l/l
DDT will now respond to a ? character being typed during an $Z sequence by typing "Zeroing: " followed by the current location and value being "zeroed". Typing any other character terminates the $Z immediately.
[*hl1]Special masks@
DDT version 41//41A (it actually started with DDT version 40) has several new "masks" (for lack of a better name and//or command) of interest to the user.
[*hl2]$0M - Search mask@The operation of the search mask continues unchanged. The search mask may now be referenced by either the $M (old style) or the $0M commands. The default value remains 777777777777.
[*hl2]$1M - TTY control mask@This mask controls special TTY behavior (primarily TOPS-10 and exec mode EDDT).
[*hl3]$Y command echo@
Bit 15 controls the echoing of command input from $Y command files. A 0 selects
command file echoing (the default case); a 1 supresses command file echoing.
[*hl3]Breakpoint printout@
Bit 16 controls the automatic printing of the breakpoint instruction. A 0
selects the printing of the breakpoint instruction on occurance of a breakpoint
(the default case); a 1 supresses the printing of the breakpoint instruction.
[*hl3]Tab separator display@Bit 17 controls whether DDT will print its usual /<TAB/> or three spaces for the /<TAB/> separator. A 0 (the default) selects three spaces, a 1 selects a /<TAB/>.
[*hl3]Tab simulation@Bit 34 controls tab simulation. A 0 selects literal /<TAB/> characters (i.e., the terminal handles /<TAB/>'s directly, a 1 selects space-fill instead. This condition is automatically set for user mode DDT's (in user mode /<TAB/>s are always output literally) - it is only useful to manually set tab simulation in exec mode EDDT.
[*hl3]Rubout control@Bit 35 controls rubout (and ^W) operation. A 0 selects "hardcopy" operation (DDT will echo a "/\" character and the character being deleted), a 1 will cause rubouts to echo as a backspace, space, backspace sequence. This condition is automatically set for user mode DDT's (if TTY DISPLAY (TOPS-10 only) is set then rubouts echo as /<BS/>/<SP/>/<BS/>) - it is only useful to manually set fancy rubouts in exec mode EDDT.
[*hl2]$2M - Offset range@The 36-bit "mask" in this case is really a value, used as the maximum offset allowable for typing addresses in the form symbol/+offset. The default offset is 1000 (octal).
[*hl2]$3M - Byte mask@This mask is used in conjunction with the $O command for typing bytes in a word that are not necessarily evenly spaced. Whenever an $O command is issued without an explicit byte size the byte boundaries are determined by one-bits in the byte mask - each one bit in the byte mask marks the low order bit of a byte. Bit 35 is always considered on. The default value is 0 (i.e., one 36-bit byte). For example the DDT command 040100200401$3M sets the byte mask for typing right-justified 8-bit bytes (preceded by the leading 4-bit byte).
[*hl1]RADIX-50 symbol typein@
Since prehistoric times DDT has supported RADIX-50 symbol typein, but that fact was never documented. The syntax for using a RADIX-50 symbol as an 36-bit item in an expression is sym$5" where sym is the desired RADIX-50 symbol. For example, to search for all occurences of the symbol PAT.. the DDT commands 37777,,-1$M (only look at low-order 32 bits) and PAT..$5"$W suffice.
[*hl1]New DDT runtime information@
[*hl2]Exec-mode machine state@
Several new words have been added to DDT's runtime table describing the state of the machine upon (executive mode only) DDT-entry. These words are all accessible via the DDT command $I/+offset (not available in FILDDT):
[*le]$I-01//	APR CONI word
[*le]$I/+00//	PI CONI word
[*le]$I/+01//	Mask of PI channels turned off by EDDT
[*le]$I/+02//	Executive virtual address of EPT
[*le]$I/+03//	Executive virtual address of UPT
[*le]$I/+04//	Executive virtual address of CST
[*le]$I/+05//	Executive virtual address of SPT
[*le]$I/+06//	Original AC-block word (DATAI PAG) if acb$4U
[*hl2]Error typeout@
DDT will now sporadically issue a short textual error message for certain
error conditions (e.g., trying to write in a write-locked page)./l/l
The $? command will type out the last DDT error; the $$? command (TOPS-20
only) will type out (ERSTR JSYS) the last process (JSYS) error.
[*hl1]Obsolete commands@
The executive mode paper tape facilities (^R, $J, and $L DDT commands) are no longer supported. The code has been removed from the source file.
[*hl1]New exec-mode support@
The exec-mode support for EDDT has been enhanced in several ways.
The exec-mode user can now typeahead while EDDT is typing out, EDDT will
periodically "poll" the command input terminal to see if anything has been
typed, and will "buffer" any such typeahead internally. Note that this does
not apply to such things as searchs where typeahead will still cause the
search to be aborted (unless "?" is typed).
EDDT now supports the XON//XOFF protocol. Typing XOFF (^S) will cause EDDT
to freeze terminal output; Typing XON (^Q) will cause EDDT to resume terminal
[*hl2]Output suppression@
EDDT now supports output suppression a la ^O. Typing ^O will toggle the
output suppression - the first ^O causes output to be discarded, the second
^O causes output to resume, etc.
[*hl1]FILDDT startup and commands@
FILDDT is a special version of DDT with the facilities for "DDT'ing" address spaces other than its own, such as disk files and in particular .EXE files. FILDDT has existed for years but has always been off in the background as a specialized "tool" for the exclusive use of monitor programmers looking at crash dumps. With DDT version 41 FILDDT is now a general purpose utility for use by the "general public", particularly people who have databases resident in disk files (.REL files for example).
[*hl2]Symbols@Out of efficiency considerations FILDDT builds the symbol table(s) it will actually use at runtime in its own address space. Virgin FILDDT has no symbols (the symbol table (if any) for FILDDT in FILDDT.EXE is completely independent of the address space being FILDDT'ed and does not count). There are special commands to instruct FILDDT to extract (and build internal-to-FILDDT copies of) symbol tables from .EXE files (see below). Once FILDDT has setup its internal symbol table(s), it may then be SAVEd with the internal symbol table(s) for later use by exiting to monitor level (with the ^Z FILDDT command) and typing the "SAVE" command.
[*hl2]TOPS-10@When FILDDT is started it will prompt "File:/f". The user may at this time optionally enter a standard TOPS-10 file specification in the form dev:name.type/[directory/]//switch. At least one function switch is mandatory. SFD's are of course legal in the directory specification.
[*hl3]//D command@The //D command or function switch instructs FILDDT that the file specified is a data file - i.e., do not map the file as an .EXE file and use real file words 0 to 17 for locations 0 to 17.
[*hl3]//F command@The //F command or function switch instructs FILDDT to "DDT this file anyway". It is useful only in conjunction with the //S command or function switch which normally re-prompts for another file specification. Used in conjunction with //S (which implies an .EXE file) FILDDT will use the file from which symbols were extracted as the file to be "DDT'ed".
[*hl3]//H command@The //H command or function switch instructs FILDDT to type out a brief help text, abort the current command, and prompt the user for another command.
[*hl3]//J command@The //J command or function switch is applied to a job number rather than a file specification and instructs FILDDT to "DDT" the address space of the job specified. Since FILDDT uses JOBPEK monitor calls to access the specified job's address space the success or failure of any given memory reference is dependent on the job being resident in main memory - if the job is swapped out or if the memory reference is to a page which is paged out the memory reference will fail. This is a privileged command.
[*hl3]//M command@The //M command or function switch instructs FILDDT to "DDT" the currently running monitor and physical memory address space (controlled by use of the $U and $$U commands). This is a privileged command.
[*hl3]//P command@The //P command or function switch instructs FILDDT to enable for writing as well as reading the specified address space. Note that DDT's internal fake registers are always writable.
[*hl3]//S command@The //S command or function switch instructs FILDDT to only extract the symbol table from the file specified, replacing any symbol table FILDDT may already have. Unless overridden by the inclusion of a //F command FILDDT will, after having read the symbol table, again prompt the user for the next FILDDT command.
[*hl3]//U command@The //U command or function switch is applied to a file structure or disk unit only rather than a complete file specification and indicates to FILDDT that the user wants the entire physical address space represented by that file structure or disk unit name independent of any "file structure mapping" normally imposed by the monitor. This is a privileged command.
[*hl2]TOPS-20@FILDDT on TOPS-20 runs in native mode, and in particular, uses the PMAP monitor call for all regular file access. FILDDT will also type a brief message telling what address space is about to be "DDT'ed" before going into DDT mode.
[*hl3]DRIVE command@The format of the DRIVE command is:/l/l/f/f/fDRIVE (FOR PHYSICAL I//O IS ON CHANNEL) c (CONTROLLER) k (UNIT) u/l/lThe DRIVE command allows examination of the disk unit u on system channel c on channel controller k without regard for whether it is mounted as part of a file structure, or indeed whether it even has the necessary information so that it could be so mounted (as if the HOME blocks were wiped out). If, however, the drive is part of a mounted file structure, FILDDT will type a message indicating the structure to which it belongs. This is a privileged command.
[*hl3]ENABLE DATA-FILE command@The ENABLE DATA-FORMAT command instructs FILDDT to treat the file as pure data, even if a valid .EXE directory is detected, and in particular to use real file words 0 to 17 as locations 0 to 17.
[*hl3]ENABLE PATCHING command@The ENABLE PATCHING command instructs FILDDT to enable any subsequently specified address space for patching (writing). This command is ignored when looking at the running monitor since there is no monitor call to "poke" the running monitor.
[*hl3]EXIT command@The EXIT command instructs FILDDT to return to command level. If FILDDT has an internal symbol table (due to a previous LOAD or GET FILDDT command) then a SAVE command will save FILDDT with the symbols pre-loaded.
[*hl3]GET command@The format of the GET command is:/l/l/f/f/fGET (FILE) filespec (optional switches)/l/lThe GET command instructs FILDDT to set up the disk file filespec as the address space to be "DDT'ed", as modified by the optional switches or previous ENABLE commands. The available switches are:
[*hl4]//DATA@The //DATA switch is equivilent to a previous ENABLE DATA-FILE command.
[*hl4]//PATCH@The //PATCH switch is equivilent to a previous ENABLE PATCHING command.
[*hl4]//SYMBOL@The //SYMBOL switch instructs FILDDT to extract symbols from the specified .EXE file before "DDT'ing" the file, discarding any symbols that FILDDT may already have. This switch is legal only with .EXE files.
[*hl3]HELP command@The HELP command instructs FILDDT to type out a short summary of the available FILDDT commands.
[*hl3]LOAD command@The format of the LOAD command is:/l/l/f/f/fLOAD (SYMBOLS FROM) filespec/l/lThe LOAD command instructs FILDDT to extract symbols from the disk file filespec, which must be an .EXE file, then to return to FILDDT command level. This command is legal only for .EXE files.
[*hl3]PEEK command@The PEEK command instructs FILDDT to use the currently running monitor as the address space to be "DDT'ed". The address space so available is currently limited to monitor executive virtual addresses 0 to 777777, since the PEEK monitor call will only accept 18-bit address arguments for executive virtual addresses. Physical memory addressing is not available. This is a privileged command.
[*hl3]STRUCTURE command@The format of the STRUCTURE command is:/l/l/f/f/fSTRUCTURE (FOR PHYSICAL I//O IS) str:/l/lThe STRUCTURE command instructs FILDDT to use as the address space to be "DDT'ed" the entire disk file structure str independent of any "file structure mapping" normally imposed by the monitor. This is a privileged command.
[*hl2]Defaults@Following is a list of the various defaults supplied by FILDDT:
[*le]DSK: is the default file device unless super I//O is specified (which requires an explicit file structure or disk unit name).
[*le].EXE is the default file type or extension unless either a data file or super I//O is specified, in which case there is no default file type or extension.
[*le]The default directory is the user's default directory.
[*le]The specified address space is read-only.
[*le]If "DDT'ing" an .EXE file and FILDDT does not already have a symbol table, extract the symbol table (if any) from the .EXE file first.
[*le]If "DDT'ing" an .EXE file and the symbol CRSHAC (if TOPS-10) or BUGACS (if TOPS-20) exists, give a "free" CRSHAC$5U or BUGACS$5U command. If the CRSHAC//BUGACS symbol does not exist then use file words 0 to 17 (if any) as mapped by the .EXE directory for locations 0 to 17. For TOPS-20 only, if the symbol SPT exists then also give a free SPT$6U command as well.
[*hl2]Other FILDDT-specific commands@Following are the commands which are unique (or different) to FILDDT.
[*hl3]^E command@The ^E command instructs FILDDT to exit the current address space and prompt the user for a new address space. The ^E command is equivilent to a ^Z, START command sequence.
[*hl3]^Z command@The ^Z command instructs FILDDT to exit to monitor level after having written out any changes to the current file (if any). It is most important that the user exit only via ^Z (or ^E which does an implicit ^Z) in order to guarantee the integrity of the file data (if any) - a ^C can leave a file in an indeterminate state (some changes written out to the disk and some not).
[*hl3]I//O errors@Should FILDDT incur an I//O error reading or writing a disk file, a warning message will be issued but FILDDT will otherwise ignore the error. This is to allow the user the ability to manually fix a file with bad data by rewriting the data correctly (hoping the rewriting operation clears the error condition - if the physical disk surface itself is at fault, then it is probably hopeless).
/l/l/l/[End of DDT41A User's Guide/]/c