Section 2 - Commodore Computers

May. Mav. 1Q82.lssue 1982. Issue 24 2d COMPUTEI COMPUTE! 139
100A=A+I
=
200 IF A>25 THEN Z% = 0
200IFA>25THENZ% = 0
you can save four out of the five byte overhead of
the second line by coding:
100 A=A+ A = A+1:IFA>25 I:IF A>25 THEN Z% = 0
However, no suggestions are free of charge
However, no suggestions are free of charge
and there is also something to watch out for in this
instance. You may freely combine statements for
up to eighty characters, but it is possible that one of
the statements you are combining might be the
object of a GOTO or GOSUB statement, in which
object of a GOTO or GOSUB statement, in which
case you will receive the ""UNDEFINED STATE­
MENT" error message. In the example immediately
above, if there were another statenlent statement in the program
which was "GOTO 200", line number 200
would not be in the program after combiningg the
two lines and you would get the error message. If
youu had a statement that was "GOTO 100", that
would not cause any problems.
Another item to watch for when combining
statements is not to combine a line with a preceding
line that contains an IF statement. The statement
shown above is alright. However, if the two lines
were reversed:
were reversed:
100IFA>25THENZ% = 0
200 A=A+ A = A+11
you would not be able to combine the lines as:
you would not be able to combine the lines as:
100IFA>25THENZ% = O:A 0:A = A+lA + 1
without altering the meaning of the statement. In
this instance, the addition statement would only be
executed if A were greater than twenty-five which
is not the intent of the original.
The last item that returns a little usable memory
at the expense of readability and documentation is
the use of short variable names. Although variable
names may be up to 255 characters, BASIC uses
only the first two characters (pluss the $ and %
suffixes for string and integer variables respectively).
Each character in the variable name occupies
a byte wherever it is used; therefore you should
limit variable names to two characters and one
character would be even more thrifty from a
memory-use point of view. Limiting the names to
two characters could have a side benefit inasmuch
it may eliminate a potential source of programming
error. If you had two variables, one named "TAPE"
and the other named "TASTE," BASIC would
only recognize "TA" as the name and would, in
effect, be dealing with a single variable.
Avoiding a technical discussion as to why it is
so, it is usually more economical to use constants
instead of variables whenever possible. A constant
consists of data stored in the BASIC statement
itself. Constants may require less memory than
variables, especially in cases where the constant is a
relatively short string. As the length of the string
relatively short string. As the length of the string
increases, the amount of savings diminishes because
the repetition of the constant also occupies memory.
The following lines each contain a constant:
100 A = A + 1
("1" is the constant)
100 S$ = D$ + "SUFFIX"
("SUFFIX" is the constant)
100 PRINT "TOTAL= = ";X
("TOT AL=" is the constant)
("TOTAL =" is the constant)
An illustration of the savings that cann be
gained is:
100 T$ = "THIS IS A TEST"
200 PRINTT$
T$
300 PRINTT$
T$
occupies 72 bytes of memory, whereas
100 PRINT ""THIS IS A TEST"
200 PRINT ""THIS IS A TEST"
only occupies 69 bytes of memory. That is not
much of a savings because the string "THIS IS A
TEST" is relatively long; if it were shorter, the
TEST" is relatively long; if it were shorter, the
savings would be more dramatic. The reason for
this is that, when data is assigned to a variable, it
this is that, when data is assigned to a variable, it
requires two areas of memory, but a constant requires
only one (in the instruction itself).
itself}-
BASIC is sometimes very shrewd as far as
memory management is concerned. BASIC is
smart enough to know when you have used a string
and will reuse it rather than recreating it again in
memory. Thus, if you have coded the statement:
PRINT "THIS IS A TEST" and, elsewhere in your
PRINT "THIS IS A TEST" and, elsewhere in your
program you coded A$ = "THIS IS A TEST",
although memory would be required to contain
pointers for the variable "A$", the actual text string
pointers for the variable "A$", the actual text string
'TH "THIS IS A TEST" would not be recreated in
memory (except in the instruction itself). The
original text string would be pointed to by the
variable. This is starting to border on the kind of
technical information that this article has tried to
avoid, but is interesting enough to pass on.
Don't AvoId Avoid Integer Variables
It seems that most people writing BASIC programs
never bother with integer variables and, yet, that is
where a significant ificant savings in memory can be attained.
This is particularly true if the program
contains arrays. Consider that, for each element in
an array, the number of bytes occupied is as follows:
A string array = 3 bytes plus the length of the
string per element
A floating point array = 5 bytes per element.
An integer array = 2 bytes per element.
The contents of-many arrays do not require
the use of decimal points, but it is easier to code
the use of decimal points, but it is easier to code
"DIM A(15)" rather than "DIM A%(15)." A%(I5)." By using
the integer form, you would save 45 bytes of mem-