This area is between the TOB and the End of Variables address (Actually, this address is called the End of Arrays). The string storage area grows backwards from that location. Low byte and High byte of the Top of BASIC memory address are stored on location 55 and 56 decimal on the Commodore 64. The string storage area is created starting from the Top of BASIC (TOB). It will be not replaced and it will become garbage. No space for it will be reclaimed at this stage. The old string will become unused, but it will be still on memory. On the other hand, if a variable is re-assigned, a new shorter or longer string will be created and the pointer of that variable will make reference to that string. String operators such as CHR$ and STR$ may produce garbage, that is, strings that are created at the moment, stored in the string storage area and no longer used. That’s were the “A” character, the content of B$, will be put. The pointer of B$ will point on a location of a storage area specifically designed to store strings. Instead, if a program has an instruction such as B$= CHR$(65), a string containing the “A” character will be created and stored in memory.
#COMMODORE 64 WORD WRITER 3 DOWNLOAD CODE#
If within a program, we have an instruction such as B$ = “HOME”, the pointer will make reference just to the part of the program code containing the word HOME. Name, length and pointer make together a descriptor. The pointer tells the BASIC interpreter where the content of the string lies in memory.
When a string variable is created, its name, its length and a pointer are stored in the variables storage area. As their length may vary, this is not straightforward. When using dynamic strings, space for them must be carefully allocated. Commodore fixed the issue at some point, and newer versions of BASIC (BASIC 3.5, 4.0 and 7.0) do not suffer from this problem. This is not a Commodore 64 only issue, but it is related to different 8 bit computer models using Microsoft BASIC. This problem is called slow garbage collection. String handling on the Commodore 64 BASIC does have a big design flaw. So, apparently, the use of dynamic strings may seem better than static ones, but this is definetely not always the case. If a string happens to be longer than that limit, it will be truncated. On static string arrays instead, the common maximum length for elements must be carefully selected, so that it allows for shorter and longer strings to be put on the array. On Commodore 64 BASIC, even if an array has already been created, it is still possible to re-assign to any element a new string longer than the old one. The same concept applies to string arrays. But, once it is created, it stays that length. For instance, on Sinclair BASIC, it is possible to create a string variable of virtually any length. That means that strings, once created, have a fixed length. Other BASICs, like Sinclair BASIC or Atari BASIC, use static strings. That allows for flexibility, but it does have a rather important disadvantage, as we will see in a moment. Instead, any string can be from 0 (null string) to 255 characters long, and can be changed at any time within a program. That means, they don’t have a defined fixed length. On Commodore 64 BASIC 2.0, strings are dynamic. This can be done in two ways: either by using static strings or by using dynamic strings. One important part of a BASIC interpreter is string handling.
0 kommentar(er)
