Section 2 - Commodore Computers

May, May.1982, Issue 24 COMPUTEI ,.,
COMPUTE!
preter for ROM Applesoft which works in much
preter for ROM Applesoft which works in much
the same way as an &-interpreter ^--interpreter would, except
that it does not require the &. 8c.
How The Applesoft Interpreter Works
Rather than storing the literal characters of BASIC
commands, and of many other key words and
symbols, Applesoft represents these internally in a
tokenized format. Each key word is replaced by a
number, between $80 and $EA SEA (see the Applesoft
Reference Manual, p. 121), and can thus be stored in
a single byte of memory. This is an extremely space
efficient storage system. However, Applesoft now
requires an interpreter to decode these tokens, in
orderr to act on the commands, or to evaluate the
functions which they represent. All key words are
first tokenized, then interpreted, whether the
machine is in Immediate Mode, responding to
commands as you type them in, , or in Deferred
Mode, running a program. Our interpreter mimics
the Applesoft interpreter. For this reason, and also
because we thinkk it would be helpful l for anyone
writing modifications to Applesoft, we will describe
the behavior of the Applesoft interpreterr in some
detail.
The Flow Of Control
The Applesoft interpreter starts at location $D805.
The Applesoft interpreter starts at location $D805.
We cannOt cannot list this copyrighted routine here, but
you can see it for yourself if you jump to the
yo u can see it for yourself if yo u jump to the
MONITOR (via CALL --151) lSI) aand then type in
"D805L". Having the routine in front of you may
clarify the flow of control described below.
clarify the flow of control described below.
This program begins, at $D805, by determining
whether the TRACE command is in effect
(flagged by the contents of $F2). If so, and if a
Deferred Mode program is being run (flagged by
Deferred Mode program is being run (flagged by
contents of $76), then, before each command is
executed, , the "#"" sign is printed, followed by the
line number. The first location following g this printout
is $ $D81D, 0 8 10 , which is branched to directly if the
printing is not to be done.
At $D81D, lD, the CHRGETH routine ($B1-$C8) I-$C8) is
called. This subroutine fetches the next character
of the program and sets the Zero flag if that character
signals an "end of line," that is, if the character
is a carriage return or a colon, ":". The routine
then calls, via a JJSR, the actual interpretation subroutine,
which starts at $0828. $D828. This returns immediately,
via the RTS at $ $D857, 0 if an eend off line is
encountered. Otherwise, the program will return
from this subroutine later, in a more indirect way.
When this subroutine is returned from, the interpreter
exits by jumping to a routine called
NEWSTT (NEW STaTement) at $D702, $D7D2, which
will execute the next program statement, falling
back into this interpreter in the process.
IfCHRGET did not find an end of line, the
If CHRGET did not find an end of line, the
$D828 subroutine expects to find a command of
some sort. If the character fetched by CHRGET is
not a token, the interpreter assumes the programmer
intended a LET command (eg X = 100) and
mer intended a LET command (eg X= 100) and
jumps to the LET subroutine at $OA46. $DA46. The inter
r­
preter determines whether it has a token by subtracting
$80, the value of the smallest token, from
the Accumulator (A), which holds the character. If
the Accumulator (A), which holds the character. If
A is still positi ve, we have a token. This token may
A is still positive, we have a token. This token may
represent a command ($80 through $BF), or it
may be some non-command key word ($CO ($C0 through
$EQ). $EQ)- Since we have alreadyy subtracted $80 from
A, we have a command onlyy if A is less than $40
($40 + $80 = $CO), which is checked by a CMP
P
(compare) instruction. If A is not less than $40, we
do not have a command, which is what should be
do not have a command, which is what should be
here, so the interpreter jumps to $D846, thence to
here, so the interpreter jumps to $D846, thence to
$DEC9, which produces a "? SYNTAX ERROR".
The Command Table
I Iff we are dealing with a command, the next job of
the interpreter is to determine where to go to
execute it. There is an address table, beginning at
$0000, $D000, (Applesoft Ha: lla: $0800) which contains this
information. In this table, the staning starting address of
every command, , less 1, I , is stored in order of magnitude
of the command's token. Thus the address of
tude of the command's token. Thus the address of
END, whose token is $80, is stored first, from
$D000 to $D001. FOR's token is next, and the
$0000 to $000 I. FOR's token is next, and the
address of the FOR ro utine, less I , is stored from
address of the FOR routine, less 1, is stored from
$D002 to $0003. $D003. Since $80 was subtracted from A,
A now stores a number between $00 and $3F.
Double this number, by rotating A left, add it to
Double this number, by rotating A left, add it to
$ $D()00. DOOO, and you get the location of the twO two byte
address of the command.
The addition is accomplished by indexing
$000 $D001I and $0000 $D000 with register Y, after Y is loaded
with the doubled contents of A. The command's
address, less I, 1, is then pushed onto the stack. When
the next RTS is encountered, the program will
"return" control to the last address on the stack,
after adding 1I to that address. Thus, the next RTS
we encounterr will force ajump a to the correct
stanin startingg address of the command to be executed.
The actual location of the interpreter's RTS is
hidden. The final instruction of the interpreter is a
JMP, rather than a JSR, to CHRGET, which will
fetch the first character following the command.
fetch the first character following the command.
The RTS from CHRGET is the one which takes us
to the command itself.
to the command itself.
Note that the next address on the stack is the
address of the routine which called this interpreter.
We have already seen what happens when this one
is returned to: the interpretation process stops aand
the program jumps to NEWSTT. As soon as the
RTS at the end of the command we will execute is
encountered, the program will effectively branch
Note that the next address on the stack is the
address of the routine which called this interpreter.
encountered, the program will effectively branch