Atari-Debug/MiniASM v1.11
Nathan Hartwell
12/19/2000

This code is taken directly from the Apple II System Monitor and Apple II
Mini-Assembler sources written by S. Wozniak and A. Baum.  Most of the code
has been left as is found in Apple II ROMs, with the exception of appropriate
keyboard and screen I/O code being added, as well as a few minor modifications
that I made years ago.  Those familiar with Atari-MON v1.x and v2.x will notice
that this code is smaller, yet I have added more functionality to it.  This is
due to the fact that the Atari-MON project was hand ported machine code from a
hex dump of the Apple II ROM with translation and extra code added as I went.  I
recently located documented source for this code and proceeded to clean up the
Atari-MON project.  Finding myself with cleaner code, I was down from 3284 bytes
of code to just under 2k.  So, I added the mini-assembler and brought it back up
to a mere 2281 bytes of code.  I have a version, without the mini-assembler, that
resides in place of the self-test.  But, I'm not quite done with it, so it will be
a later release.

I have assembled this code to reside at $B38F-$BC1F (no cartridge, just before the
display list and screen RAM).  A future version may support auto-relocation of
itself.

Commands:
---------
 Ctrl-B - Run Catridge
 Ctrl-C - Exit to DOS
 Ctrl-E - Dump CPU registers
 Ctrl-K - Null command (future expansion)
 Ctrl-P - Null command (future expansion)
 Ctrl-Y - Execute user defined function (jump vector @ $1C-$1D)
  ENTER - Execute command
          If an address is specified, the contents of that memory location is
          displayed in a hex dump fashion.
          If the input buffer is empty, pressing ENTER will perform a hex dump of
          up to 8 bytes (will only stop at $xxx7 and $xxxf)
      : - Enter hex data at address
          Example:
            $2000:A9 00 60
      . - Hex dump memory block
          Example:
            $E000.E00F
            
            E000- 00 00 00 00 00 00 00 00  (ATASCII representation here)
            E008- 00 18 18 18 18 00 18 00  (ATASCII representation here)
            $
      ! - Enter mini-assembler (see section below)
      ? - Find/Search 
          Example:
            $9B<C000.CFFF? (scan memory from $C000-$CFFF for value $9B)
      + - Single byte addition
          Example:
            $43+20
            =63
            $
      - - Single byte subtraction
          Example:
            $43-20
            =23
            $
      G - Run at address
          Example:
            $E477G (Atari coldstart vector)
      L - Disassemble 20 instructions starting at address
          Example:
            $2000L
            
            2000-   00          BRK
            2001-   00          BRK
            2002-   00          BRK
            2003-   00          BRK
            2004-   00          BRK
            2005-   00          BRK
            2006-   00          BRK
            2007-   00          BRK
            2008-   00          BRK
            2009-   00          BRK
            200A-   00          BRK
            200B-   00          BRK
            200C-   00          BRK
            200D-   00          BRK
            200E-   00          BRK
            200F-   00          BRK
            2010-   00          BRK
            2011-   00          BRK
            2012-   00          BRK
            2013-   00          BRK
            $
      M - Move memory block
          Example:
            $4000<C000.CFFFM (move memory from $C000-$CFFF to block starting at $4000)
      N - Null command (good for separating cmds on a single command line)
      S - Single step execution
          Example:
            $4000S
            
            4000-   A9 FF       LDA   #$FF
             A=FF X=05 Y=01 P=B1 S=FD
            $
          Executes one insctruction at a time, starting at the specified address,
          displaying the register contents after completion.
      T - Trace execution
          Steps through program code, displaying register contents after each step,
          but continuing through until BRK instruction is reached.
      V - Verify/Compare memory range
          Example:
            $4000<C000.CFFFV (verify memory from $C000-$CFFF to block starting at $4000)
      / - Pass command to SpartaDOS

Mini-assembler:
---------------
The mini-assembler is exactly that.  No multi-pass assembly is supported.  No
symbols or line numbers are supported.  You simply enter instruction mnemonics.
There are 2 ways to enter the data.  They are "<address>:<MNEM> [data]" and
" <MNEM> [data]" (note the space at the beginning).  The first, obviously, allows
you to set the address where the machine code is to be stored after asembly.  The
second stores the machine code in the next location.  As I understand the code,
comments (anything starting with ;) are allowed, but since you can only hand enter
the data at this time, I don't see anyone sitting down and typing comments that
won't be stored.  A future version may allow taking input from a file, so I left
the code that supports comments in place.