Welcome to the first installment of my new column, Allen’s Old CoCo Notebook. I will be sharing scans of pages from my original notebook I used during my earliest days with the Color Computer, and hopefully figuring out what all the stuff on them means.
Today’s installment deals with this page of hand written 6809 assembly:
If memory serves, seeing the use of greater than “>” and less than “<” tells me this was a disassembly of some code, most likely done via Radio Shack’s EDTASM+ (either the cartridge that I started out with, or the disk version that I used when I got a disk drive).
But what does it do? First, let me try to transcribe it, hopefully without typos.
CLRA COMB NEG <0 LDU #16A PULA A,X STA >263C STX >263D LDX #261D STX >16B LDD <8A STD >2600 JMP >AC7C CLR <70 STX ,S LDX >263F LDA ,X+ STX >263F TSTA BNE 3F3A LDA >263D STA >16A STX >16B LDA #0D PULS X,PC NEG <0 NEG <27 …
The lack of memory addresses prevents me from knowing if this was a disassembly of a routine in the Color BASIC ROMs, but there are at least a few addresses that might offer some clues. I will consult the Color BASIC Unravelled book series and see what is at those locations.
CLRA COMB NEG <0 LDU #16A
Address $16a is indeed an addressed used by Color BASIC. It is an entry inside the RAM vector table At that location are three bytes which point to the “CONSOLE IN” input routine. Where it goes depends on what level and version of BASIC is installed. It seems to be loading that address into the U (user stack?) register of the 6809.
PULA A,X STA >263C STX >263D
PULA A,X is pulling whatever is on the stack (pointed to by U) into the A and X register. I believe this would load the 8-bit value at $16A into A, and the following two bytes into the 16-bit X register. At the CONSOLE IN location should be a “JMP $xxxx” instruction, so this seems to be loading the JMP and address into registers.
It then stores them at $263c (JMP) and $263d. These locations are in the lower 32K address space so this is likely memory being used by some machine language program loaded into RAM — possibly its own dispatch table. That location should low look like:
…where $xxyy is the address for CONSOLE IN in the ROM. This code is saving the current vector, likely so it can be restored when the program ends or, more likely, used for something else later.
LDX #261D STX >16B
Next it loads the address $261d into register X. This is likely the address of some routine in the above-mentioned machine language program.
It stores that address at $16b, which is the address portion of the 3-byte CONSOLE IN vector entry. Thus, originally that looked like:
…and it is replaced with:
This code is preserving where CONSOLE IN currently goes, then pointing it to a new routine. I am guessing that after this routine does whatever it does, it then calls the saved ROM CONSOLE IN code to complete the task.
I am now guessing that this may be part of a remote terminal driver — a program like REMOTE from a 1983 Rainbow magazine that would patch the input/output of BASIC to the serial port and allow for running a BBS.
LDD <8A STD >2600 JMP >AC7C
In the Color BASIC Unravelled book, the entry for memory location $8a says “PV DUMMY – THESE TWO BYTES ARE ALWAYS ZERO.” The same comment is found in Extended Color BASIC Unravelled, and Disk Extended Color BASIC Unravelled. But, for whatever reason, this code is loading these two bytes and saving them at location $2600.
It then jumps to $ac7c, which is in ROM space. That location says “THIS IS THE MAIN LOOP OF BASIC WHEN IN DIRECT MODE.” It looks like we have patched CONSOLE IN and then returned control to BASIC.
The next bit of code is an an unknown address, but since it is after a JMP it is probably the start of a new routine.
CLR <70 STX ,S LDX >263F
This code sets the byte at $70 to zero. Or something. The comment for that location is “PV START OF STRING STORAGE (TOP OF FREE RAM)”.
It then saves X on the stack (or wherever the S stack pointer is pointing?), then loads X (indirect) with whatever two bytes are pointed to by $263f. Earlier we saved the CONSOLE IN entry at $263c to $263e, so this seems to be directly after those three bytes.
LDA ,X+ STX >263F TSTA BNE 3F3A
Here it is loading A with a byte from X, which currently points to $263f. It then increments X by one. X must be a pointer to the next byte to be processed.
TSTA will see if A is zero. If it is not equal, it will branch (BNA) to $3f3a. This appears to be some kind of loop that goes through that memory until it finds a zero, updating the pointer along the way. I am betting this is some kind of buffer routine.
If A is zero, we continue to this next bit of code:
LDA >263D STA >16A STX >16B LDA #0D PULS X,PC NEG <0 NEG <27
A is loaded with an 8-bit value that $263d points to, which is the saved address of BASIC’s CONSOLE IN routine. It stores it at >16A, the first byte of the RAM vector for CONSOLE IN.
It then stores X at $16b and $16c. That restores the CONSOLE IN RAM vector back to what it was. This must be shutdown code.
The code that follows is probably cleanup code — though loading A with #0d (13, a carriage return) looks interesting.
…and then I stopped disassembling.
But why was I doing this? If it was code from Rainbow (REMOTE), I would have had a copy and not need to disassemble.
A quick check through the issue of Rainbow where REMOTE first appeared shows that it loaded at $3f00. The disassembly shows a branch to $3f3a, which is this in REMOTE:
REMOUT JSR RSOUT
Ah, this looks promising. And RSOUT is defined as:
RSOUT EQU $8E0C
And that address is somewhere in Extended Color BASIC. Turning to the Extended BASIC Unravelled book shows that to be “SEND CHAR IN ACCA OUT OVER RS232 OUTPUT.”
Bingo! The branch in my disassembly ends up at the CoCo ROM’s serial output routine.
It looks like I may have been disassembling REMOTE by Dan Downard. I believe it was the original version because of the date (1983) and because the next update (REMOTE2) moved its location to $7d00, requiring 32K.
Now I can look through the published source for REMOTE and find what they code was.
Unfortunately, I cannot find any matches for this code in the tiny ~130 byte REMOTE program. It looks like the branch location that matched up with REMOTE may have been a coincidence, or this code might have been a modified version of REMOTE. I recall at some point I customized one of the later versions (maybe after 1986) for some reason, but I had a printer by then and was not using this notebook.
Well, mystery not solved.
Do you recognize this code? Any clue what it goes to? Can you correct some of the things in my interpretation I did not understand?
Until next time…
Doesn’t the < character mean the following 8-bit value is an address in the direct page?
Note that “>” means “extended addressing”. “<” means “direct addressing”.
“PULA” is almost certainly supposed to be “PULU”. There’s no such thing as “PULA”.
Address 8A is used as a shortcut for loading a 16 bit register with zero. It’s one byte shorter (8 bit address in the direct page vs. 16 bit immediate value) even if it executes slower. You’ll find it used all over the ROM for just that purpose.
Regarding 70, you’ve misread something. 70 is used by “console in” to indicate whether EOF was reached or not. Basically, you call “console in” then test that value to determine if there was anything to read. The “start of string space” value is at 21, not 70.
The “LDX >263F” instruction is not indirect. 263F almost certainly contains a buffer pointer of some kind.
That “BNE 3F3A” instruction is almost certainly an error. It’s probably supposed to be 263A which I’m guessing is the PULS instruction.
It would be particularly helpful if you would have recorded what address that code started at, of course. However, those first two instructions (CLRA and COMB) are actually ASCII “OS” so I’d guess that code was being loaded from track 34 with the DOS command, which would load at 2600. That “NEG <0” instruction right after is odd, though. 00 is the “stop/end” flag and is only relevant to STOP, END, or a program exiting. But NEG <0 is also just two NUL bytes, too. Still, the DOS command would be jumping to that NEG <0 instruction.
Curious. I wonder if this was some software I had that did a DOS boot… maybe a BBS?
What’s the point of having code after a PUL* that includes PC?
Is it like doing a PUL then an RTS or something?