142,143



     coded decimal numbers (BCD) while string characters use one
     bye each. The address of the strings in the table are the same as
     those returned by the BASIC ADR function. Always use this
     function under program control, since the addresses in the table
     change according to your program size. Try:

     10   DIM A$(10),B$(10)
     20   A$ = "*": A$(10) = A$: A$(2) = A
        $
     30   B$ = "&": B$(10) = B$: B$(2) = B
        $
     40   PRINT ADR(A$), ADR(B$)
     50   PRINT PEEK(140) + PEEK(141) * 25
        6: REM ADDRESS OF A$
     60   PRINT PEEK(140) + PEEK(141) * 25
        6 + 10: REM ADRESS OF A$ + 10 BYTE
        S = ADDRESS OF B$

     This table is expanded as each dimension is processed by
     BASIC, reducing available memory. A ten-element numeric
     array will require 60 bytes for storage. An array variable such as
     DIM A(100) will cost the program 600 bytes (100 * six per
     dimensioned number equals 600). On the other hand, a string
     array such as DIM A$(100) will only cost 100 bytes! It would save
     a lot of memory to write your arrays as strings and retrieve the
     array values using the VAL statement. For example:

     10   DIM A$(10): A$ = "1234567890"
     20   PRINT VAL(A$)
     30   PRINT VAL(A$(4,4))
     40   PRINT VAL(A$(3,3))+VAL(A$(8,9))

     See COMPUTE!, June 1982, for a discussion of STARP and
     VVTP. See De Re Atari for a means to SAVE the string/array area
     with your program.

142,143        8E,8F          RUNSTK
     Address of the runtime stack which holds the GOSUB entries	
     (four bytes each) and the FOR-NEXT entries (16 bytes each). The
     POP command in BASIC affects this stack, pulling entries off it
     one at a time for each POP executed. The stack expands and
     contracts as necessary while the program is running.

     Each GOSUB entry consists of four bytes in this order: a zero to
     indicate a GOSUB, a two-byte integer line number on which the
     call occurred, and an offset into that line so the RETURN can
     come back and execute the next statement.

     Each FOR-NEXT entry contains 16 bytes in this order: first, the
     limit the counter variable can reach; second, the step or counter