User`s guide

but many programs cheat on safety a bit anel UM ;
800 INPUT#5,NAME$,STREET$,CITY$
810 GOSUB 59990:REM CHECK FOR DISK ERRORS
This is done primarily when top speed in the program is essential, and there is little or no
risk of reading improper data from the file .
MORE ABOUT INPUT# (FOR ADVANCED USERS)
Troublesome Characters
After you begin using data files regularly, you may encounter two Basic error
messages more
or less frequently . They are "STRING TOO LONG ERROR" and "FIL E
DATA ERROR" . Both are likely to halt your program at an Input# statement, but m ay
also have been caused by errors in a Print# statement when the file was written.
"STRING TOO LONG" ERRORS
A Basic string may be up to 255 characters long, although the longest string you c an
enter via a single Input statement is just under 2 lines of text ( 4 on the VIC 20). This lower
limitation
is due to the 88 character size of the Input buffer in Commodore's serial b us
computers. The same limit applies to Input# statements. If a single data element (string or
number) being read from a disk file into an
Input# statement contains more than 87
characters, Basic will halt with a "STRING TOO LONG ERROR". To prevent th is
error, be sure to limit each string to under 88 characters, and separate all file data items
with carriage returns
(See the next section for a cure once the error has occurred.)
"FILE DATA" ERRORS
The other error message "FILE DATA ERROR" is caused by attempting to read a
non-numeric character into a numeric variable. To a computer, a number
is the characters
0 through 9, the"+" ana " - " signs, the decimal point(.), the SPACE character, and
the letter "E" used in scientific notation. If any other character appears in an Input# to a
numeric variable, "FILE DATA ERROR" will be displayed and the program will hal t.
The usual causes of this ,error are a mismatch between the order in which variables are
written to and read from a file, a missing carriage return
.;.,,ithin a Print# statement th at
writes more than one data item, or a data item that includes either a comma or a colon
without a preceding quotation mark.
Once a file data error has occurred, you should
correct it by reading the data item into a string variable, and then converting
it back to a
number with the Basic Val() statement after removing non-numeric characters with the
string functions described in your computer users manual.
COMMAS (,) AND COLONS (:)
As suggested before, commas and colons can cause trouble
in a file, because they
delimit (end) the data element in which they appear and cause any remaining characters
in
the data element to be read into the next Input# variable. (They have the same effect in an
Input statement, causing the common "EXTRA IGNORED" error message.) However,
sometimes we really need a comma
or colon within a data element, such as a name written
as
"Last, First". The cure is to precede such data elements with a quotation mark. After a
50
quotation mark, in either an Input or Input# statement, all other characters except a
carriage return or another quotation mark are accepted as part of the current data element.
EXAMPLES:
To force a quotation mark into a data element going to a file, append a CHR$(34) to
the start of the data element. For example:
PRINT#2,CHR$(34) +
"STRASMA, nM"
or
PRINT#2 ,CHR$(34);''STRASMA, JIM''
If you do this often, some space and time may be saved by previously defining a variable
as equal to·CHR$(34) as we did earlier with CHR$(13):
20 QT$= CHR$(34)
400 PRINT#5 ,QT$,+ NAME$
In each case, the added quotation mark will be stripped out of the data by the Input or
Input# statement, but the comma
or colon will remain safely part of the data.
NUMERIC DATA STORAGE ON DISKETTE
Inside the computer, the space occupied by a numeric variable depends only on its
type.
Simple numeric variables use 7 bytes (character locations) of memory. Real array
variables use
5 byte§ per array element, and integer array elements use 2 bytes- each. In
contrast, when a numeric variable or any type is written to a file, the space it occupies
depends entirely on its length, not its type.
Numeric data is written to a file
in the form of a string, as if the Str$() function had
been performed on it. The first character will be a blank space if the number is positive,
and a minus sign ( - ) if the number is negative. Then comes the number, digit by digit.
The last character
is a cursor right character.
This format allows the disk data to be read back into a string or numeric variable
later. It is, however, somewhat wasteful
of disk space, and it can be difficult to anticipate
the space required by numbers of unknown length. For this reason, some programs
convert all numeric variables into strings before writing them to diskette, and use string
functions to remove any unneeded characters
in advance. Doing so still allows those data
elements to
be read back into a numeric variable by Input# later, although file data errors
~ay be avoided by reading all data in as strings. and converting to numbers after the
Information is inside the computer.
For example,
"N$ = MID$(STR$(N),2)" will convert a positive number N into a
String N$ without the usual leading space for its numeric sign. Then instead of writing
PRINT#5,N , you would use
PRINT#5,N$ .
51