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