MEM11 Update

[Guy Sotomayor]

As I mentioned previously, I took some time off from working on the 
MEM11 for the past several months.
I had some time over the past few days, so I spent it working on the 
simulator.

Right now all of the J1 instructions seem to simulate properly. 
Everything related to the basic simulator
also seems to be functional.  I still have work to do to write code for 
the simulated I/O (it's all stubbed
out at the moment).  The way that I'm implementing the I/O, is that it's 
pretty modular.  All of the
fundamental code structures are there, I just have to write the 
"handlers" for the particular I/O devices.

I wrote the majority of the J1 simulator to be H/W agnostic (as far as 
the I/O is concerned), the I/O
at this point will match what I expect to be in the actual MEM11 H/W.

Here's what the simulator currently supports:
   - All command functionality is present and functional.  These are the 
way that one interacts with
     the simulator.  The commands include things like:
        - loading files into J1 memory or FRAM
        - dumping memory locations from J1 memory or FRAM
        - modifying memory locations in J1 memory or FRAM
        - setting, listing and clearing breakpoints
        - starting execution
        - single stepping execution
        - dumping the data & return stacks
        - starting and stopping instruction tracing
    - All of the J1 instructions now seem to execute correctly (lots of 
typo's and other subtle bugs)
    - Exceptions work now.  This allows the J1 program to do something 
"silly" and the simulator
       won't crash (had enough of that already while I was debugging the 
simulator!).
       It'll report what the J1 program did that was "silly" (ie 
unaligned memory accesses, etc).
    - It also contains a reasonable "help" system.

I've written an instruction test program that tests out all of the J1 
instructions and it is "self checking".
That is, it will throw an exception (unaligned address) if the result of 
the instruction test isn't what
was expected.  To determine what failed, I look at the address where the 
exception occurred and
reference the test program listing to determine which test failed. I 
verified that it is indeed operating
correctly by hand checking via the instruction trace file that it was 
doing the "right things".

I had originally started debugging by single stepping through the 
program but after the test program
grew to over a few dozen instructions, it became too tedious for me to 
ensure that I was accurately
verifying the instruction execution.  This is where the instruction 
trace file became invaluable.

The next thing to do is to work on the simulated I/O.  Once I'm 
confident that all of that is working
then I can go about debugging all of the code I've already written for 
the MEM11 itself.  The simulator
should give me a pretty good environment for debugging, especially when 
compared to the actual HW.

Oh, and of course everything (simulator, MEM11 firmware and tools for 
the  build environment) are all
written in forth.  ;-)

TTFN - Guy