>>37<<5552 >>37<<///>>16<< >>37<<5552       44444  s>>37<<0              >>16<<///>>12<< >>16<<///>>16<< >>37<<242>>37<< >>37<<5552 >>17<<000>>17<< 11>>37<<11 >>37<<vv// >>37<<55>>15<<s                                               




                       PDP-1 COMPUTER
             ELECTRICAL ENGINEERING DEPARTMENT
           MASSACHUSETTS INSTITUTE OF TECHNOLOGY
               CAMBRIDGE, MASSACHUSETTS 02139


















                          PDP-23-5

                  INVISIBLE DEBUGGER (ID)

























                     September 24, 1971










                >>13<<u                                
                   ID- Invisible Debugger

   INVISIBLE  DEBUGGER,  commonly referred  to  as ID,  is a
utility program in the PDP-1 time-sharing system written  to
aid in the debugging of programs.


General Essential Preparation

   When  a  time-sharing  user  logs  in  (by  pressing  the
"console" switch on) he is given  an ID.  The ID can not  be
examined  or modified by commands to ID or by execution of a
program.

   The first command the  user types is  usually E to  start
Expensive  Typewriter, (see  memo PDP-22), or  nF (0>>40<<<n>>40<<<3) to
start the  file system  on  tape unit  n (See  memo  PDP-42,
Microtape File System).

   When the user runs any program (either his own program or
a system program  such as Expensive  Typewriter), his ID  is
inactive.   It will be restarted if the program executes any
illegal  instruction  or  the  console's  "call"  button  is
pressed (see the section on breakpoints).

   After  a normal assembly, ID is  started in a special way
by the assembler (see description  of mta 5).  ID loads  the
program  and  obtains  its  symbols.   Typing  P  will begin
execution of the  program at  the address  specified to  the
assembler in the "start" pseudo-instruction.

   For  the  sake  of  accuracy,  descriptions  of  commands
include their  effect,  if  any, on  programs  with  several
processes.   The user unfamiliar with multiprocessing should
assume that only one process exists.






























                >>13<<(                                Fields

   ID allows operations to be carried out on the core fields
of  the user, or  of spheres owned  by the user,  or on drum
fields owned by the user, or absolute drum fields, by making
the field involved the "current field".  Initially ID is set
up so that the user's core 0 is the current field.  This  is
the usual state.

   The  current field is normally  specified by the underbar
command.  Typing>>40<<.

	x>>40<<

causes field x to become the current field.

	?

is typed by ID if the field does not exist, i.e.  the user does  not
own the corresponding core or drum field.

   Typing underbar (>>40<< ) alone will cause the current field to
be printed out.


   The "field" assignment is as follows>>40<<.

	  0-5          core fields
	100-177        drum fields assigned to user
	200-377        absolute drum fields (read only)
	 1MNN          core field M of sphere owned by user at
	               index NN


   This  numbering is used for commands H, O, S, U, V, and Z
(explained later) as  well as  underbar (>>40<<  ).  For  example,
typing>>40<<.

	224V

verifies the current field against absolute drum field 24.

   In  this memo,  "field" always  refers to  this numbering
unless "drum field"  or "core field"  is explicitly  stated.

   The  "current location" is the 12-bit address of the last
register opened by  a command  other than one  of those  few
that  open a register without changing the current location.
The character  point (.)  , when  not part  of a  symbol  or
number, has the value of the current location.

   The  character Q has the value of the last quantity typed
by ID or the user.













                >>13<<
                                Register Examination Commands


Command                        Action

/
          When preceded  by  an argument,  slash  opens  the
          register  in  the current  field whose  address is
          specified by the low 12 bits of the argument, sets
          the  current location to that address, and (unless
          in type-in mode) types the contents of the  regis-
          ter  according to the current type-out mode.  When
          not preceded  by an  argument, slash  (/)  behaves
          just  like Q/, except that  it does not change the
          current location.

|
          Similar to slash (/),  but uses a 15-bit  address.
          In  particular, when  preceded by  an argument, it
          changes  the  current  field  to  the  core  field
          specified  in bits 3-5 of  the argument, then does
          what slash does.  Without an argument, it  behaves
          like  slash (/) except that the field specified in
          bits 3-5  of  Q  will be  used,  rather  than  the
          current  field.  The current field is not changed.

[
          Similar to  slash  (/),  but  types  the  contents
          of  the register as  a positive number, regardless
          of the current type-out mode.  Does not change the
          type-out mode.

]
          Similar  to  [,  but  types  the  contents  of the
          register as an instruction.

(
          Similar to slash (/),but causes ID to enter  type-
          in  mode.  In this mode, contents of registers are
          not typed out at all.  Type-in mode is left when a
          carriage  return is  typed in or  out, except that
          commands ^, backspace and  tab keep ID in  type-in
          mode.   Type-in  mode is  useful for  typing short
          programs directly into core.






















                >>13<<j                                Register Modification Commands

     Fields not  assigned to  the user  cannot be  modified.


Command                       Action

carriage return
          If  an argument was given  and a register is open,
          deposits the argument in the register.  The regis-
          ter becomes closed. Note>>40<<. whenever carriage return
          is typed by ID (after certain commands), any  open
          register  becomes closed>>40<<, however  the register is
          not modified.

backspace
          Same action as  carriage return,  and in  addition
          opens  the next register the  way .+1/ does.  This
          command types a carriage return, the current field
          (unless  zero), the address  (in the address type-
          out mode), a  slash (/), tab,  and (unless in  the
          type-in mode) the contents of the register (in the
          current type-out mode) and another tab.  Note that
          if  .  was 7777,  location 0 of  the current field
          will be opened.

^
          Like backspace except that it opens .-1

tab
          Same action as  carriage return,  and in  addition
          opens a register the way slash (/) does.  That is,
          the low 12-bits of the argument to the tab (or, if
          no  argument, Q) will be used as an address in the
          current  field.   The  address  is  typed  as  for
          backspace.

>
          Without argument, same as slash (/).
          With  an  argument, deposits  the argument  in the
          currently open register (if  any), then does  what
          slash  (/) does  except that  the current location
          (.) is not changed.























                >>13<<>>35<<                                Type-out Mode

Command                      Action

S
          Without argument, sets the  type-out mode to  sym-
          bolic  mode.   This  is  its  initial  state.  The
          contents of registers  will be  typed as  symbolic
          instructions unless the mode is overridden with [,
          ], =, ~,  or >>20<<.   Numbers in the  range 777700  to
          777777 are typed as negative numbers.

C
          Without  argument, sets the  type-out mode to con-
          stants mode.  The  contents of  registers will  be
          typed  as  unsigned  numbers, unless  the  mode is
          overridden.

T
          Without argument, sets the  type-out mode to  text
          mode.  The contents of the registers will be typed
          out as flexo  code characters unless  the mode  is
          overridden.

>>20<<
          Types  the  argument (if  none,  Q) as  a symbolic
          instruction,  regardless  of  the  type-out  mode.
          Neither  opens, closes, nor modifies any register.

=
          Types the  argument (if  none, Q)  as an  unsigned
          number.   Neither opens, closes,  nor modifies any
          register.

~
          Types the  argument (if  none,  Q) as  flexo  code
          characters.   Neither opens,  closes, nor modifies
          any register.

R
          Without argument, sets  the address type-out  mode
          to  symbolic (Relative) mode.  This is its initial
          state.  Addresses (printed by commands  backspace,
          tab, ^, etc.,) will be typed symbolically.

O
          Without  argument, sets the  address type-out mode
          to octal  mode.  Addresses  will be  typed out  as
          numbers.

numR
          Sets  the radix to  num.  Num is  interpreted as a
          decimal number, regardless of the previous  radix.
          The radix is initially 8.

H
          (Hoctal) Without argument, same as 8R

U
          (Unoctal) Without argument, same as 10R






                >>13<<y                                

































































                >>13<<m                                Symbols

          A  symbol is  a string containing  only lower case
letters, numerals  and point  (.), containing  at least  one
letter, and having a value associated with it.

          Initially  the  symbol  table  contains  the PDP-1
instruction mnemonics.   The  most common  way  of  entering
symbols  in the ID symbol table is by executing a mta 5 (see
the section on breakpoints).

Command                     Action

2T
          Reads a  symbol table  in  the user's  core  (left
          by  the assembler) and merges  it with ID's symbol
          table.  The format is>>40<<.

                00100|     first address of symbol table
                00101|     last address of symbol table
                00102|     number of symbols

fH
          (Hoard) Saves  ID's symbol  table (except  initial
          symbols) on field f.  ID prints the lowest address
          occupied by the symbol  table, which extends  from
          there to 7777 on field f.

fO
          (Obtain)  Kills all symbols like K, then reads the
          symbol table stored on field f by an "H"  command.

x<fH
          Like  fH,  except  the  symbol  table  will extend
          from the address printed by ID to x-1,  inclusive.

x<fO
          Like  fO,  except  reads  symbol  table  stored by
          an "x<fH" command.



























                >>13<<6                                val sym)
          Defines symbol sym with value val.

sym,
          Defines symbol  sym  with  the  current  value  of
          the current location counter (.).

sym>>04<<
          Defines  the symbol  sym with  the value  equal to
          the low 12 bits of Q.

symK
          (Kill) Deletes symbol sym  from the symbol  table.

K
          With  no argument, deletes  all symbols except the
          PDP-1 instruction mnemonics.  If these were  rede-
          fined, the original value is restored.

symC
          (Calm)  Half kills the symbol sym.  ID will recog-
          nize it when typed in,  but will not type it  out.

symL
          (Loud)  Undoes  the  effect of  symC,  so  ID will
          type out  the  symbol  in  symbolic  instructions.








































                >>13<<g                                Type-in

     Numbers  are interpreted  in the  current radix, unless
immediately followed by a point (.), in which case they  are
taken as decimal.

     Microprogram  instructions  may  be  typed  in,  but to
distinguish them from commands, they  must be preceded by  a
single quote ('), for example>>40<<.

          'SXXP

     The  special character overbar  (>>56<< ) has  a value of -0.

     If an  undefined  symbol is  typed,  ID types  "U"  and
ignores  everything  typed since  the  last tab  or carriage
return.

Command                      Action

?
          Typing a  question mark  (?) causes  ID to  ignore
          everything  typed since  the last  tab or carriage
          return.

"
          Causes the previous  1, 2, or  3 characters to  be
          taken as their flexo code value.

'
          Causes  the previous 1,  2, or 3  characters to be
          taken as their squoze code value.


     The following  connectives  are performed  in  left-to-
right order.

space
          Same as +

+
          18 bit 1's complement addition

-
          18  bit  1's complement  subtraction.  Unary  - is
          complementation, so -0=777777

>>06<<
          Logical and

>>05<<
          Logical or














                >>13<<>>35<<                                Special Registers

          The following special registers may be referred to
from  any field, and opened and  modified in the same manner
as other registers, except  that [ and ]  do not change  the
current  location.  For example, to examine the accumulator,
type>>40<<.

          A/

          The following registers appear to be  consecutive>>40<<,
i.e.,  backspace, ^, and expressions  like .+3 will work for
them the way they do for ordinary registers.

          These special registers refer to the current  user
process (see centerdot (>>40<< ) command).

          A         Accumulator
          I         In-Out Register
          X         Index Register
          F         Flag Register, which contains

 0   1   2   3   4   5 . . . . . . . 12  13  14  15  16  17
                                          Program Flags
AMD AEF AAL SBM SBH PRL               1   2   3   4   5   6


     bits 0-1 are decoded as the address mode

          00        nam       normal mode
          01        bam       base mode
          10        iam       index mode
          11        dam       defer mode

          G         Program Counter, bit 0 contains overflow,
                                     bit 1 contains extend mode.

          W         W Register, (used for communication
                                 with the supervisor)



























                >>13<<m                                          The  following special registers  are used to con-
trol certain functions within ID.

          x         The location for executes (see x command),
                    normally 7775

          M         The mask for word searches,
                    normally 777777
  
          M+1       The lower limit for word searches, save,
                    unsave, etc., normally 0

          M+2       The upper limit for word searches, save,
                    unsave, etc., normally 7777

Note>>40<<. only the low 12 bits of M+1 and M+2 are used.

          B         Breakpoint locations
          B+1
          B+2
          B+3

  
          When preceded by an  argument, the commands A,  I,
X, and M deposit the argument in the corresponding register.
The command x<yM puts x in M+1 and y in M+2.

          Typing>>40<<.

M>>56<<
          Resets M, M+1, and M+2 to their initial  contents.

B>>56<<
          Resets all breakpoint registers.
































                >>13<<1                                Searches

Command                     Action

W
          (Word)  With  an  argument,  searches  the current
          field between the  limits in M+1  and M+2  (inclu-
          sive)  and prints all registers which are equal to
          the argument when  both are and'ed  with the  mask
          (M).   In  other words,  only those  bit positions
          which are 1 in the mask are compared.

N
          (Non-word) With an argument, searches the  current
          field  between the  limits in M+1  and M+2 (inclu-
          sive) and prints all registers which are not equal
          to  the  argument when  both  are and'ed  with the
          mask. The most frequent use of this command is 0N,
          a search for non-zero locations.

E
          (Effective  address search) Used with an argument,
          searches the current field  between the limits  in
          M+1  and M+2 (inclusive)  and prints all registers
          which effectively  adddress the  argument>>40<<, ID  as-
          sumes  that  instructions are  executed  in extend
          mode, normal  mode, and  not  under aam's.   An  E
          search  never prints  skp, sft, law,  iot, ivk, or
          opr instuctions.  This command is of limited value
          if  the  program being  debugged does  any indexed
          addressing.



     For the  commands W,  N, E,  S,  U, V,  and Z>>40<<,  if  the
current field (or either field f or the current field in the
case of fS, fU, fV, or fZ) is a PRL protected field (core  0
of  a sphere with PRL on),  the lower limit actually used is
the maximum of 100 and the  lower limit specified in M+1  or
an  argument to the command.  In other words, these commands
avoid trying to reference C-lists.

























                >>13<<0                                Miscellaneous

Command                       Action

Z
          With no argument,  sets all of  the current  field
          to zero.

fZ
          Zeros  field  f  between  the  limits  in  M+1 and
          M+2 (inclusive).

x<yZ
          Zeros the current  field between x  and y  (inclu-
          sive).

fU
          (Unsave)  Copies the  contents of  field f between
          the limits in M+1 and  M+2 into the current  field
          between  the same limits.  For example, if M+1 and
          M+2 are  reset to  their initial  contents  (which
          they  usually are), 101U will copy all of the drum
          field  at  user's  capability  index  1  into  the
          current field.

x<fU
          Copies  the contents  of field f  between M+1 plus
          x and M+2  plus x into  the current field  between
          M+1 and M+2 . For example, 0<fU is the same as fU.
          Note that M+1 and M+2 refer to the current  field,
          and addresses in field f are offset by x.

fS
          (Save) Like fU, except data moves from the current
          field to field f.

x<fS
          Similiar to x<fU.  Copies the contents of the cur-
          rent  field between the limits in M+1 and M+2 onto
          field f  between  M+1  plus  x  and  M+2  plus  x.

fV
          Same as 0<fV

x<fV
          For  each  address  j, within  the  limits  in M+1
          and M+2, compares location j in the current  field
          with location j+x in field f. If they differ after
          both are  and'ed with  the  mask (M),  ID  prints>>40<<,
    
          j/    contents of current field,   contents of field f,
                location j                   location j+x














                >>13<<>>16<<                                Commands for Paper Tape

Command                      Action

Y
          (Yank)  Without argument, reads a tape in standard
          binary  format  into  the  current  field.   Words
          outside the limits in M+1 and M+2 are ignored. The
          core modules specified in  the data block  origins
          are ignored. The address in the start block is put
          in the G register (Program Counter).

fY
          Like Y, except reads into field f.

x<yY
          Like Y, except  uses x  and y instead  of M+1  and
          M+2 as limits.

     Note>>40<<.   if a  checksum error  occurs while  reading, ID
types "cksm".   Typing  "d"  will cause  the  blocks  to  be
accepted as read and ID will continue reading. By moving the
tape one block back and typing  "c", ID will read the  block
again.   Typing any other character will cause ID to give up
and accept another command.

L
          (Label)  Letters  typed  after  this  command  are
          punched in readable form on tape.

     There  are three characters  which terminate the label,
having the following effect>>40<<.

carriage return
          Punches the  standard input  routine and  sets  ID
          to punch standard binary blocks.

backspace
          Punches  a "jmp 7752" instead of the input routine
          and sets  ID  to  punch  standard  binary  blocks.

tab
          Sets ID to punch readin mode tapes, i.e.,
          alternate dio instructions and data words.






















                >>13<<4                                D
          (Dump  or Data) Without  argument, same as 0<7777D

x<yD
          Punches the current field from x to y (inclusive).
          in the format set by the L command. If the current
          field is a core field, the data block origins will
          be in the current field. Otherwise they will be in
          core 0.

xD
          Like D, except punches  between the limits in  M+1
          and M+2. The data block origins will be in core x.

xJ
          (Jump) Punches a start block to address x.
          All tapes  must  end  with a  start  (jmp)  block.

















































                >>13<<g                                Process Control

     The  user's  processes  are numbered  starting  with 1.
Registers A, I, X, F, G,  and W always refer to the  current
process.

Command                       Action

>>40<< (Centerdot)
          Types  the current process number.   Types 0 if no
          process exists.

x>>40<<
          Makes process x current.

>>04<<frk
          Creates a process and  makes it current.  Types  ?
          if process can not be created.

>>04<<qit
          Deletes  the  current  process.   Higher  numbered
          processes are  renumbered.  The  process with  the
          same number as the old one becomes current, unless
          it does not exist, in which case process 1 becomes
          current,  unless it does not  exist, in which case
          ID types out "no proc".

xG
          (Go) Puts the low 12 bits of x in the low 12  bits
          of  the  program counter  of the  current process.
          Puts the current field number, if it is less  than
          6, (i.e. a user core) and bits 3-5 of x otherwise,
          in bits  3-5  (the  core module)  of  the  program
          counter of the current process. Bits 0-2 (overflow
          and extend mode) are unchanged. Then ID starts all
          processes  running.   ID releases  control  of the
          typewriter so that  anything typed  in after  this
          time  will be read by the user's program.  Further
          commands to ID can not  be given until ID  regains
          control,  either when a user's process traps to ID
          or the  call  button is  pressed  (see  Breakpoint
          section).
























                >>13<<6                                Breakpoints

     Breakpoints  are the  primary tools  for debugging pro-
grams.  They provide a  convenient means for interrupting  a
program  to examine intermediate results,  trace the flow of
control, etc. The four breakpoint registers B, B+1, B+2, and
B+3  contain  the  addresses of  breakpoints  in  the user's
program.  No breakpoint is indicated by -0.  The command  xB
puts  the low  12 bits of  x in  the low 12  bits of special
register B, and puts the current field number, if less  than
6  (a user core), and  bits 3-5 of x  otherwise, in bits 3-5
(the core module) of register B.  n<xB does the same to B+n.

     Whenever  a process attempts  to execute an instruction
(either directly,  or  through execute  (xct)  instructions)
which  has  a breakpoint  in it,  (except during  a multiple
proceed- see below), ID resumes control.  The instruction at
the  breakpoint  will  not  yet  have  been  executed.   All
processes are stopped, and ID  types the program counter  of
the  process that reached the  breakpoint (which is the same
as the location of the breakpoint unless the breakpoint  was
reached  through xct  instuctions), a close  paren, tab, and
the instuction that was being executed. The current location
is  set to the address in the program counter, that register
is opened, bits 3-5 of the program counter (the core module)
become  the current field, and  the process that reached the
breakpoint becomes the current process. ID resumes listening
for commands from the typewriter.  A breakpoint remains in a
location until either moved by changing the contents of  the
breakpoint  registers, or removed by depositing overbar (>>56<< or
-0) in the breakpoint register,  typing B>>56<< (which clears  all
breakpoints), or by commands E or nF (see below).

     CAUTION>>40<<.  Breakpoints should not be placed at locations
which are  examined or  modified by  the program,  since  ID
saves their contents and substitutes the trap (bpt) instruc-
tion.
     The command  P (Proceed)  is used  to resume  execution
after a breakpoint has been reached.  The instruction at the
breakpoint will  be executed  once, and  the user's  process
will continue running. If the breakpoint is reached again it
will trap again.  xP will  proceed through the breakpoint  x
times  before trapping to ID.   If a different breakpoint is
reached, during a multiple proceed, it will trap immediately
regardless of the proceed count.

     The  P command may be used  even when no breakpoint has
been reached (e.g.  when ID  is entered by hitting the  call
button).   In  this  case, ID  simply  starts  all processes
running, giving  control  of  the typewriter  to  the  user.
















                >>13<<w                                
     The command -nP starts the user running so that after n
instructions have been executed  by the current process  the
program traps to ID as though a breakpoint had been reached.
This command is  used to  closely follow the  progress of  a
program.

     The  command  xx  (x-"cross") may  be  used  to execute
single instructions  or  subroutine calls.   ID  places  the
instruction  x in  the current field  (which must  be a user
core field) at the address specified  by the low 12 bits  of
the  x register, puts that address in the program counter of
the current process, and starts all processes (usually  this
is  the  only  process).  When  the  user's  program counter
becomes equal to the original program counter incremented by
one  or  two, ID  resumes control.   The program  counter is
restored to the contents that  it had before the x  command.
The  effect is to execute  the instruction x, but  if x is a
call to a subroutine, the entire subroutine is executed.  If
the  program counter  was incremented  by one,  ID types two
carriage returns after  the x>>40<<,  if the  program counter  was
incremented  by two, (i.e.,  the instruction skipped), three
carriage returns are typed.

     y<xx  behaves  like  xx  except  the  address  for  the
instruction is specified by y, not the x register.

     The  call button is  used to return  control to ID.  ID
prints and opens  the register  being executed  as though  a
breakpoint had been reached.  If the user has no process, ID
types "no proc".  The instruction printed will not yet  have
been  executed  (except for  certain  types of  ivk instruc-
tions). If the call button is pressed while ID is already in
control,  ID  stops whatever  it was  doing and  listens for
commands.


     When a  user process  executes  a mta  7 (dsm),  ID  is
brought  into  control, all  processes  are stopped,  and ID
types a carriage return and listens for commands.

     When a  mta  5 is  executed,  ID executes  the  command
string pointed to by the AC. The string is in standard 7-bit
format, terminated by the character 14.  The string may  not
be more than 40 (decimal) characters in length.





















                >>13<<i                                Mnemonic Commands

     All  commands in this group  have the following format>>40<<.

                        >>04<<command i n

In each  of  these  commands,  the  ">>04<<"  is  followed  by  a
descriptive  command name, which may  be abbreviated down to
the point of ambiguity.  Each command may take zero, one, or
two parameters. These are the i and n fields of the command.
These parameters are always taken as octal numbers,  regard-
less of the current radix.

     The  parameter i is always a capability index.  If this
parameter  is  required  and  is  missing,  the  first  free
capability  index will  be assumed.   If the  parameter n is
required and is missing, 0 will be assumed.

     For a discussion  of the objects  mentioned below,  see
memo PDP-35, Instruction Manual, Parts 4 and 5.


Command                          Action

>>04<<field i n
              Create a drum field at capability index i.  If
              n is not given, a read/write field is created.
              If  n is given absolute field n (read onl>>34<<y) is
              created.

>>04<<sphere i n
              Create a sphere at capability index i having n
              as its fault entry address.

>>04<<queue i n
              Create  a  queue  at capability  index  i with
              initial population -n.

>>04<<tape i n
              Create microtape unit n at capability index i.

>>04<<button i n
              Create button console n at capability index i.

>>04<<frk
              Create a  process  and make  it  current  (See
              section "Process Control").

>>04<<qit
              Delete the current process.

>>04<<core
              Print memory bound and attachments (See
              PDP-35,  Instruction  Manual,  Part  5  for  a
              discussion of mta 206. This instruction prints
              the  value  that  is  returned  by  mta 206.).










                >>13<<>>14<<                                
>>04<<core n
              Set memory bound to nx10000.

>>04<<delete i
              Delete the capability at index i.

>>04<<wash
              Delete all processes,  reset illegal  instruc-
              tion and illegal memory reference returns, and
              finally create one process.

>>04<<what i
              Print a description of capability i.

>>04<<what
              Print a description of every capability.

















































                >>13<<>>52<<                                Miscellaneous

Command                       Action

x<y<zF
          Executes a mta z with y in the AC and x in the  IO
          on  behalf  of  the  user  (i.e.,  206F  reads the
          user's, not ID's, memory bound).  No registers  of
          any process are changed.  Two carriage returns are
          typed if the  argument did not  skip, three if  it
          did. If x or x and y are omitted, zero is used. If
          the mta  returns  information  in the  AC,  it  is
          printed.

nF
          If  0>>40<<<n>>40<<<3, starts the file  system on tape unit n.

E
          Without  argument,  starts  Expensive  Typewriter.
          Note>>40<<.   These two commands  reset all breakpoints,
          reset the mask  registers, reset  the illegal  in-
          struction  and  illegal memory  reference returns,
          and set the number of processes to 1.











































                >>13<<b                                Error Indications

busy or can't
          An attempt to assign  something failed.  The  user
          must  wait  until  the  device  becomes available.

not free
          An attempt  to  assign  something  failed  because
          the  specified C-list  index is  already occupied.

sym ovf
          ID's symbol table has overflowed.  If this  occurs
          during a 2T, ID will continue reading symbols, but
          will only redefine symbols  already in the  table.
          No new symbols will be added.

?
          General  purpose  error message.   ID can't  do or
          doesn't understand the request typed in.

de
          A parity  error occured  while reading  the  drum,
          or  an attempt  was made  to write  on an absolute
          drum field.

U
          An undefined  symbol has  been typed  in.  ID  has
          ignored  everything  typed since  the last  tab or
          carriage return.

cksm
          A checksum has occured  while reading paper  tape.
          By moving the tape back one block and typing c, ID
          will read the block again.

no proc
          An attempt  has  been  made to  delete  a  process
          when no processes existed.


     When a user process executes an illegal instruction, ID
is brought into control and types the address of the illegal
instruction and the instruction as indicated below.

           Instruction                   Printout

         hlt (mta 4)                   adr^^   inst
         illegal memory reference      adr<<   inst
         IO function busy              adr??   inst
         lock fault                    adr>>04<<>>04<<   inst
         mta 6                         adr>>06<<>>05<<   inst
         any other illegal inst.       adr>>   inst














                >>13<</                                
       SUMMARY OF COMMANDS TO ID      Sept. 24, 1971

A	address of the accumulator
argA	put arg into the accumulator
B	address of first breakpoint
adrB	put first breakpoint at address adr
n<adrB	put nth breakpoint at address adr
B+1	address of second breakpoint
B+2	address of third breakpoint
B+3	address of fourth breakpoint
B>>56<<	clear all breakpoints
C	type out values as constants in current radix
symC	make the symbol sym calm.  sym will not be typed out by ID
D	dump current field on paper tape
fldD	dump field fld
fa<laD	dump current field between addresses fa and la
E	start expensive typewriter
adrE	effective address search
F	address of flag register
nF	enter file system on tape transport n
argF	with one, two or three arguments, execute a mta inst. 
G	address of the program counter
adrG	start a program at adr
H	hoctal radix. Same as 8R.
fldH	hoard symbols on field fld from 7777 down
adr<fldH	hoard symbols on field fld from adr-1 down
I	address of the in/out register
argI	put arg into the IO
adrJ	punch a jump block on tape
K	kill all symbols except initial ones
symK	kill symbol sym
L	listen for name to punch in readable form on paper tape
symL	make symbol sym loud.  ID is allowed to type out sym.
M	address of search mask.
argM	put arg into mask
M+1	address of lower limit of search, yank, verify, save and
	unsave commands
M+2	address of upper limit
fa<laM	puts fa in M+1 and la in M+2
M>>56<<	clear mask and limits. Puts -0 in M, 0 in M+1,
	and 7777 in M+2.
argN	search for all words which when anded with the mask are
	not equal to arg
O	type out addresses as numbers in the current radix
fldO	obtain symbols from field fld from 7777 down
adr<fldO	obtain symbols from field fld from adr-1 down
P	proceed after hitting a breakpoint
argP	proceed through this breakpoint arg times
-argP	proceed through arg instructions
Q	value of last thing typed out by ID
R	type out addresses as symbols
argR	set the radix to arg (always taken as decimal)
S	type out values symbolically
fldS	save the current field on field fld
ofst<fldS	save the current field on field fld with offset ofst










                >>13<<2                                T	type out values as text
2T	read symbols from assembler (on core field)
U	unhoctal (decimal) radix.  Same as 10R.
fldU	unsave field fld into current field
ofst<fldU	unsave field fld with offset ofst
ofst<fldV	verify field fld with offset ofst
W	address of W register
argW	search for all words which when anded with the mask are
	equal to arg
X	address of the index register
argX	put arg into the index register
Y	yank (read) paper tape into current field
fldY	yank onto field fld
fa<laY	yank between addresses fa and la
Z	zero current field
fldZ	zero field fld
fa<laZ	zero current field between adresses fa and la
>>04<<com i n	perform mnemonic command with parameters i and n
0-9	legal digits in any radix. Also, symbol constituents
a-z	symbol constituents
.	the current location. also a symbol constituent
num.	takes the number num as decimal regardless of the current 
	radix
x	address for executes
instx	execute instruction inst
adr<instx	execute instruction inst at address adr
sym,	define the symbol sym as the current location
=	type value of last thing typed by ID as a number in the
	current radix
arg=	type arg as a number in the current radix
/	opens the register addressed by the last thing ID typed,
	but does not change the current location
adr/	types the contents of address adr
?	rubout. ID forgets the last thing you typed
abc"	has the value of the flexo code for abc
'	listen for mpr instruction
abc'	has the value of the squoze code for abc
~	type the last thing typed by ID as three flexo characters
arg~	type arg as three flexo characters
sym>>04<<	define sym as the address part of the last thing typed
	out by ID
>>05<<	18-bit OR
>>06<<	18-bit AND
<	separates arguments for commands using more than one
>	same as slash
adr>	opens address adr without changing the current location
^	similar to .-1/
>>20<<	print the last thing typed by ID symbolically
arg>>20<<	print the value of arg symbolically
( and adr( same as / and adr/ except contents of registers
	aren't printed
sym)	define sym as the address part of the last thing typed
	out by ID
arg sym)	define sym as the value of arg
[	print the contents of the register addressed by the
	last thing typed by ID as a number in the current radix










                >>13<<x                                adr[	print the contents of adr as a number in the current radix
] and adr]  same as [ and  adrr except the printout is symbolic
>>56<< (overbar) has value -0
|  and adr|  same as / and adr/ except the argument is taken as a 
	15-bit extended address
+	arithmetic plus
-	arithmetic minus
space	same as plus
>>40<< (underbar) print out the current field
fld>>40<<	make field fld current
>>40<<	type out number of current process
n>>40<<	set current process to n
tab	open the register addressed by the last thing typed
	by ID and make it current
backspace  similar to .+1/
carriage return  close an open register


















































                >>13<<>>53<<                                                                                   7