Classic Computer Magazine Archive ANTIC VOL. 3, NO. 4 / AUGUST 1984

The toolbox


A programmer-productivity tool


This program creates a sorted list of variables from any SAVEd Atari BASIC program on disk or cassette.  The accompanying article discusses Atari BASIC's structure, and may be difficult for beginning computerists to follow.  The program requires Atari BASIC and 3500bytes of RAM; it works on all Atari computers.

A cross-referenced list of a program's variables and the line numbers in which they appear is useful for finding duplicate or conflicting variable names.  Conflicting variable names often occurs before merging two programs.  The program in Listing 1 produces an alphabetized, cross-referenced list of variables for any Atari BASIC program on diskette or cassette.  The resulting list can be stored on diskette or cassette, or output to screen or printer.
   The program needs two pieces of information to produce a cross-referenced list.  Initially, it asks for the device or file that contains the program to be analyzed.  Here, the cassette user would respond with C:, and press [RETURN] at the beep; the disk user should enter D:FILENAME.BAS. The file should contain a tokenized Atari BASIC program created with the SAVE command.  A cassette file created with the CSAVE command will not work-you must use SAVE "C:".
   Next, the program prompts for the device or file to which the cross-referenced list will be written.  Type C: to store the list on cassette; disk users should type D:FILENAME.CRE Since the program writes the file to the same disk, you should make sure that there is ample free space on the disk to hold the variable table.  Type E: to display the list on the screen, or P: to send the list to the printer.
   At this point, the program begins to construct the cross-referenced list, and a report of the program's progress is displayed on the screen.  As each line of the tokenized program is scanned, its line number is displayed.  When all of the lines have been scanned, the variable names are alphabetically sorted.  Each pass of the sort routine is also displayed on the screen.  Finally, the completed list is written as a text file to the selected device or file.  If you're saving the file on a cassette, the computer will beep twice (through the TV speaker with XL computers).  If you're using cassette, insert a new tape, press RECORD and PLAY on the recorder, then press [RETURN] on the keyboard.
   To access the target file, type in the following program (change the C: to D:FILENAME.CRC if you're using a disk-drive):

10 DIM HOLD$(500)
20 OPEN #2,4,0,"C:"
30 TRAP 50
40 INPUT #2,HOLD$:?
   HOLD$:GOTO 40
50 CLOSE #2

If you wish hard copy, change line 40 from ? HOI.D$ to LPRINT HOLD$.
   To use a cross-referenced list most effectively, you may need to refer back to the program listing.  If you don't own a printer or a full-screen editor, this can be difficult.  In this case, display the cross-referenced list on the screen, freezing the screen (with CTRL-1) at the point of interest.  Earlier portions of the list can be repeated by entering GOSUB 6000 in direct mode.

This program's structure is dictated by the structure of a stored, tokenized Atari BASIC program file.  Each file is divided into four major blocks:

(1) the zero-page pointers
(2) the variable name table
(3) the variable value table
(4) the token program

Zero-page pointers are two-byte values that point into the token file.  The block is fourteen bytes long and consists of seven of the nine zero-pagc pointers that BASIC uses to maintain a token program in RAM.  The pointers are:

Byte    Pointer         Description
0,l     LOMEM     Token-output-buffer pointer
2,3     VNTP      Variable-name-table pointer
4,5     VNTD      End of variable-name-table pointer
6,7     VVTP      Variable-value-table pointer
8,9     STMTAB    Statement-table pointer
10,11   STMCUR    Pointer to the current statement
12,13   STARP     String/Array Area pointer

While the program was in memory (before storage), the value of LOMEM was subtracted from each of these pointers, including LOMEM itself.  Thus, LOMEM in the stored file is always equal to zero, and the values of the other pointers are offsets from LOMEM.
   The zero-page-pointers block is read and used to compute the length of the variable-name table in lines 1000-1060.
   The variable-name table is a list of all the variable names in the program.  They are stored as ATASCII characters in the same order that they were entered into the program.  The high-order bit of the last byte (or character) of each name is set to one.  The program reads the variable-name-table block, saves it in RAM and computes the number of variables in the program.  This occurs in lines 2000-2070.
   The variable-value table provides current information on each variable.  The table reserves eight bytes for each variable in the program.  Since this program does not change the value of any variable in your main program, the values in the table are read, then ignored in lines 3000-3060.
   The token program block is essentially the original BASIC program with its commands, operators, functions and variables replaced by one-byte tokens.  This block is organized into program lines.  Each program line has the following structure:

Bytes     Name        Description
0,1    NUMLINE     The BASIC line number
2      OFFLINE     The offset from the start of the
                   current line to the start of the
                   next line
3      OFFSTATE    The offset from the start of the
                   current line to the start of the
                   next statement
4      OFFSTATE-1  BASIC tokens and constants

The last two entries are repeated for multiple-statement lines.  For example, the BASIC line:


generates the following in the token file:

Bytes        Hex Tokens          Description
0,1          0A 00               Line 10
2            13                  Line offset
3            0F                  Statement offset
4            06                  LET
5            80                  X
6            2D                  =
7            0E                  Numeric constant
8,13         40 01 00 00 00 00   1
14           14                  :
15           13                  Statement offset
16           20                  PRINT
17           80                  X
18           16                  End of line

The immediate-mode line is the last line in a token program block.  It is assigned line number 32768.  The token program block is read and analyzed, line-by-line, in lines 4000-4080.
   A variable's token is determined by its position in the variable name table, with its high-ordered bit set to one.  For example, the first variable in a program is assigned the token value of 128 (80 hex) and the second variable is assigned 129 (81 hex).  Thus, it is fairly simple, as in line 4044, to pick out references to variables-their token values will be greater than 127.  The value of all tokens for commands, operators and functions is less than or equal to 127.
   There are several exceptions to this rule, however.  In string constants (token 0F hex), the high-order bits of characters entered in inverse video are set.  Likewise, inverse-video characters that occur in REM statements (token 00 hex) and DATA statements (token 01 hex) also have the high-order bit set.  Numeric constants (token 0E hex) may contain bytes that have the high-order bit set.  Lines 4041-4043 handle such exceptions.
   Each time a variable is detected, the program makes an entry into both the VREF and LREF arrays.  References to particular variables are recorded indirectly, using a chained approach in the VREF array.  The value of a link in the chain indicates the location of the next link.  The first link is found by examining the element of VREF that corresponds to the variable's token value.  The line number for each reference to a variable is given in the corresponding location in LREF.
   A shell sort algorithm is used in lines 5000-5090 to alphabetize the variable names.  Although the variable-name table remains unchanged, pointers into the table are rearranged with pointers into the variable-reference list to produce the alphabetized cross-reference list.  The list is written to a device or file in lines 6000-6110.
Listing: CROSSREF.BAS Download