This month we will continue our discussion of software resources available in the C64 ROMs by beginning coverage of the BASIC 2.0 ROM. First we will examine the structure of BASIC programs as they are stored in memory. For demonstration purposes the simple program below was created. Following the program is a memory dump of the start of BASIC program memory, made with a monitor program.
The link uses two bytes and is a link to the next program line. For example, the link in line 10 contains $080d, which is the start address of line 20. The link in line 20 contains $0826, the start address of line 30. The link in line 30, the last line in the program, contains $0832. At address $0832 is two 0s or nulls. When BASIC finds a 0 as the high byte of a line link it interprets this as the end of a program, and executes the END command. This is why the END command is usually not required in Commodore BASIC programs. The link is never referenced when BASIC is RUNning a program, except to check for a 0 in the high byte. Only the LIST command needs the line link. For this reason the link is sometimes used in simple protection schemes to prevent a program from being listed.
Following the link is two bytes containing the line number, stored in normal 6502 format with the the low byte first. For example, the line number for line 10 is stored at address $0803 and contains, naturally enough, $000a or 10. The line number is used by LIST, and also by RUN, GOTO, THEN and GOSUB.
Following the line number comes the BASIC text. The text contains commands like PRINT or GOTO, functions like TAN() or MID$(), variables like A1 or ZQ$, certain types of punctuation such as commas, semi-colons and colons, string literals like "Abcd" and numeric literals like 123.45.
Commands and functions are 'tokenized.' This means for example that the PRINT command is not held as the letters P R I N T, but as a single byte of value $99. This value is known as the 'token' for PRINT. All commands and functions have their respective tokens. This both saves memory and allows the interpreter to execute faster. Tokens are always of value greater than 127, with the 7-bit set. This allows the interpreter to very quickly and easily determine whether a byte is a token or not.
Examine line 20 in the memory dump and find the PRINT token. Notice in lines 10 and 30 that keywords such as PRINT are not tokenized if they follow a REM or DATA statememnt. Keywords which are part of string literals are also not tokenized. Try to find the REM token in line 10, and the DATA token in line 30.
Numeric literals and variables are composed of normal PETSCII characters of value less than 128. Variables must begin with an alphabetic character in order to easily distinguish variables from numbers. The second character of a variable may be alphabetic or numeric. String literals can contain characters of any value, including graphics and upper case characters which normally have values of $a0 to $bf and $c0 to $df respectively.
The below table illustrates the tokens that BASIC uses to store program keywords. Notice that * / + - ^ < = > each have their own respective tokens.
{SHIFT-@}c{CBM-Z}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{CBM-E}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{SHIFT-*}{CBM-W}cb GO {SHIFT--}
BASIC makes use of several important zero-page storage locations, including the below ones:
{SHIFT-@}cTXTTAB = $2b
{SHIFT-@}cVARTAB = $2d
{SHIFT-@}cARYTAB = $2f
{SHIFT-@}cSTREND = $31
{SHIFT-@}cFRETOP = $33
{SHIFT-@}cMEMSIZ = $37
These variables define the memory usage of the BASIC program area. Txttab contains the address of the start of the BASIC program area. Interestingly, address (TXTTAB)-1 must contain a zero or RUN and NEW will give SYNTAX ERRORs. Normally TXTTAB contains $0801. Therefore address $0800 must contain a 0. Try POKEing a non-zero value there and try to use RUN or NEW. [Editor's note: POKE a 0 back to $0800 to restore RUN and NEW's normal operation.]
Variables in BASIC 2.0 are stored immediately after the BASIC program text. VARTAB contains the address of the start of the BASIC variable storage area. In our example program given above, BASIC text runs from address $0801 to $0833. In that case VARTAB would contain the value $0834.
Following simple variables in memory is storage for array variables. ARYTAB contains the address of the start of the array storage area. STREND contains the address of the end of the array storage area plus one. For example if the last byte of memory used for array storage was at address $0932, then STREND would contain the value $0933.
MEMSIZ defines the highest byte plus one which is usable by BASIC. For example, if the value $7000 was POKEd into MEMSIZ the highest address usable by BASIC would be $6fff. The memory from FRETOP to MEMSIZ is used for storage of strings, not string variables but string data. For example, if we execute this piece of BASIC:
{SHIFT-@}cA$ = "SOME " + "TEXT"
a string variable named A$ would be created and stored in the simple variable storage area. Any existing arrays would be moved up higher in memory to make room for the new variable, and the values in ARYTAB and STREND would be adjusted.
The string assigned to A$, namely "SOME TEXT" would be stored at the top of memory, growing downwards toward the array storage area. FRETOP is adjusted downwards as more strings are put into the string storage area. If enough strings are created, eventually the string storage area and the array storage area collide. BASIC will try to recover unused memory in the string storage area by performing the infamous garbage collection. BASIC 2.0 garbage collection is infamous because it takes a very long time if large string arrays are being used. If garbage collection cannot recover enough memory then an 'Out Of Memory Error' occurs.
Next month we will continue our discussion of BASIC internals.
