home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / PROG / ASSEMBLY / V20BOOT.ZIP / MEDLEY.ZIP / NDDT.DOC < prev    next >
Encoding:
Text File  |  1990-01-02  |  4.9 KB  |  162 lines
  1.  
  2.     ------------------------------------------------------
  3.  
  4.                DDT(8080)/ICUAP
  5.         Universidad Autonoma de Puebla
  6.                August 30, 1983
  7.  
  8.     Harold  V.  McIntosh
  9.     ------------------------------------------------------
  10.  
  11.  
  12.     A = assemble
  13.     B = bitmap
  14.     D = display
  15.     F = fill
  16.     G = go
  17.     H = hex sum, difference
  18.     I = initialize CCP command line
  19.     L = list program
  20.     M = move
  21.     R = read file
  22.     S = store
  23.     T = type registers
  24.     V = single step w/ call as 1 step
  25.  
  26.  
  27.  
  28.     (A) Assemble 8080 code. <nAx> will assemble n lines
  29.     of code beginning at address x. Defaults are x=lorg,
  30.     while no limit is set if n is missing or zero.
  31.  
  32.     (B)  Generate a bitmap of all bytes in the range
  33.     100H - (pmax) which could possibly be the address
  34.     of an instruction.
  35.  
  36.  
  37.     (D) Display the memory in groups of 16 bytes, both as
  38.     pairs of hexadecimal nibbles and as ASCII characters,
  39.     when the latter is appropriate. The command <nDa,b>
  40.     will display n lines, or else the interval between
  41.     hexadecimal addresses a and b; the interval takes
  42.     precedence but if a or b or both are null, the line
  43.     count helps determine the interval. When a is null the
  44.     display will usually continue from where it last ended,
  45.     but nD,b will display b-n up to b. In general:
  46.         nDa,b    a through b-1, n lines of 16 bytes
  47.          Da,b   a through b-1, DP lines of 16 bytes
  48.         nDa,    a through a+n
  49.         nD,b    b-n through b
  50.         nD,    PC through PC+n
  51.          Da,    a to the end
  52.          Da    just line containing a
  53.          D,b    PC through b
  54.          D,    PC to the end
  55.          D    just line beginning at PC
  56.  
  57.  
  58.     (F) Fill an interval. <Fx,y,a> will fill the interval
  59.     from x to y with the hexadecimal value a.
  60.  
  61.  
  62.     (G)  Go to the program for execution. The form <nG,a,b,c>
  63.     allows the insertion of up to two breakpoints, b and c,
  64.     before jumping to the address a. If a count n is also
  65.     included, the breakpoints will be traversed n times
  66.     before control is t returned to DDT. If the field a is
  67.     null, the program will continue from the point where
  68.     control was surrendered to DDT (or 100H if it is an
  69.     initial call.
  70.  
  71.  
  72.  
  73.  
  74.     (H) Display a hexadecimal sum and difference. <Hx,y>
  75.     will result in typing '+'x+y '-'x-y. Mainly used to
  76.     help patch CP/M during system generation.
  77.  
  78.  
  79.     (I) Input a command line, according to the same
  80.     criteria used by CCP; in other words a parameter
  81.     list can follow the file name.
  82.  
  83.  
  84.     (L) List the memory as 8080 operation codes. The
  85.     command <nLa,b> will list n lines of code between
  86.     the hexadecimal addresses a and b, with the interval
  87.     taking precedence over the number of lines, unless
  88.     either a or b is missing.
  89.  
  90.  
  91.     (M) Move part of the memory from one place to another.
  92.     <Mx,y,z> will move the interval x,y to begin at z. The
  93.     direction of movement compensates for possible overlap.
  94.  
  95.  
  96.     (R) Read into memory the file specified by TFCB.
  97.     It was probably defined by a preceding I command,
  98.     but might still be the program defined in the DDT
  99.     command line. <Rx> will start loading at TORG+x.
  100.  
  101.  
  102.  
  103.     (S) Store hexadecimal bytes. <nSx> will store
  104.     n bytes starting at address x, read one by one
  105.     from the console. Missing n means indefinite
  106.     repetition, missing x means TORG. Confirmation
  107.     and progression is automatic while hexadecimal
  108.     bytes are being received; however, for
  109.          -  go back one byte,
  110.         'x  deposit ASCII x,
  111.         ^x  deposit ctl x,
  112.         CR  go on to next byte.
  113.     Any other input terminates the cycle.
  114.  
  115.  
  116.     (T)  Type the register status line while single-stepping
  117.     through the program. <nT> runs through n steps typing
  118.     each one, while <nT/> executes without typing. The option
  119.     V, with the same alternatives <nV> and <nV/> treats a
  120.     call or a conditional call as a single step, avoiding a
  121.     detailled examination of the interior contents of each
  122.     subroutine.
  123.  
  124.  
  125.  
  126.     (V) A variant of T.
  127.  
  128.  
  129.     (X) Examine registers. Any one of the registers or
  130.     register pairs A, BC, HL, DE, SP, PC may be examined,
  131.     or one of the five flag bits C, Z, M, E, I, by typing
  132.     Xr, with r = czmeiabhdsp*, or =xxxx with a hexadecimal
  133.     address xxxx. The latter defines the register * at
  134.     first. A display line is typed, of the form
  135.     r=xxxx  xx ...  xx  ... xx  +++++  + +++++  ooo ooooo
  136.     where xxxx is the contents of register r, xx etc is
  137.     a window of hexadecimal bytes centered on xxxx, ++ etc
  138.     is a similar window of ASCII characters, and finally
  139.     ooo ooooo is the instruction, if meaningful, at xxxx.
  140.  
  141.     Once an examination is underway, the window may be
  142.     moved by various operators:
  143.  
  144.         *      indirect from window
  145.         ^      indirect from instruction address
  146.         !      save value
  147.         ?      recover value
  148.         /      next instruction
  149.         +      1 byte forward
  150.         -      1 byte backward
  151.         #      forward, stop at nonzero
  152.         @      backward, stop at nonzero
  153.         =xx    search for byte xx ('x or ^x also)
  154.         |xxxx  search for pair xxxx
  155.         >      forward half-window
  156.         <      backward half-window
  157.         .      type crlf - make new line
  158.  
  159.  
  160.  
  161.  
  162.