Apple Business BASIC

Apple Business BASIC is a dialect of the BASIC programming language for the Apple III with added features for producing business and productivity software. It belongs to the wider group of business BASICs, which first emerged on minicomputers.

The main additions compared to AppleSoft BASIC on the Apple II were 19-digit long integer values in addition to floating point, better control over formatting input and output, and floppy disk commands that allowed file management without having to exit to Apple DOS. It included a rudimentary system to load and save fixed-width records, which made file handling easier. It also allowed programs to be built in parts and loaded on demand to allow the construction of larger applications.

Business BASIC was the standard dialect for the Apple III. The Apple III also offered an expanded version of Microsoft BASIC, Apple III Microsoft BASIC, which ran under CP/M using 3rd party CP/M support.

Description

Program editing

Apple Business BASIC used many of the editing conventions from the earlier AppleSoft BASIC, with the most noticeable change being the command prompt becoming a paren, . This visually indicated you were in Business BASIC, as Integer BASIC used and AppleSoft used . Statements entered without a line number were executed immediately, while those with a line number were instead stored for future execution, which Apple referred to as '' deferred mode''. As was the case for AppleSoft, line numbers were limited to 0 through 63999.

Editing was improved with the ability to enter a full-screen editing mode by pressing the key and then using the cursor keys to move within program text. Most home computers of the era already supported this, but the Apple II predated this becoming a standard feature. Setting the value of the variable, normally defaulted to 2, provided leading spaces in front of the lines inside a loop, while the variable controlled the maximum line length of ed program lines, avoiding it running off the right side of some printers. Finally, the command allowed the mass deletion of program lines, for instance . and could both use , a comma, or a hyphen to separate the starting and ending ranges.

Business BASIC was intended to support large programs, and writing such programs makes debugging difficult using traditional BASIC tools. To address this, Business BASIC added the command, which causes the system to print a followed by the line number as statements are executed. Using this with allows the user to watch as values change and notice the line where it might occur. This can be turned off again with .

Data types and variables

Most BASICs of the era allowed variable names to be a single letter, two letters, or one letter and one digit. A small number, including later versions of Microsoft BASIC, allowed longer variable names to be typed in the source code but only read the first two characters at runtime. This often led to a lack of suitable variable names, especially in long programs where many different variables were being used and spread across hundreds of lines of code. Business BASIC addressed this by allowing variable names up to 64 characters, all of which were significant. A variable name could include most non-space printing characters including basic punctuation, often using the period between individual works in a name, like Names were case insensitive, so and are the same.

Variables were typed, meaning they could hold only one type of data. Most BASICs of the era had two types of data. The default type was a floating point number, or "real", normally stored in a 40-bit format (at least on MOS 6502-based machines). The other was the string, which was indicated by adding a dollar sign, , to the end of the name of the variable. Some dialects, including Business BASIC, added an integer type, normally stored as a 16-bit binary value, indicated by a percent sign, . To these three, Business BASIC added a fourth, the ''long integer'', a 64-bit binary value that allowed up to 19 decimal digits of accuracy. These were denoted with an ampersand, .

Small currency values, like one penny, are represented in decimal by the fraction 0.01. This value cannot be exactly represented in binary floating point, and any manipulations, even simple ones like addition, can lead to the values being rounded incorrectly and producing odd output. Apple Business BASIC used the long integer format to address this issue, by multiplying dollar values by 100 to produce integers. A value like 0.01 would be stored as 1, and the value 10.10 would be stored as 1010. While this format does not eliminate rounding issues, it greatly reduces them in unexpected cases like addition.

The downside is that all numbers have to be converted back to decimal format on output. This can be accomplished by dividing them by 100, but this may introduce the rounding errors that this system is attempting to avoid. Instead, it uses formatted output that placed the decimal point in the correct location, without changing the number itself. That is, 1010 would be printed as 10.10 by inserting the period during output. This was accomplished with the and the statements. The format was represented by a string, which could be typed directly after the , or on a separate line using . If the style was used, the was instead followed by the line number of the statement.

Program statements and reserved variables

The list of supported statements is largely similar to those in AppleSoft BASIC, with a few additions. One is the clause on statements. operated as a separate statement, it could only follow a colon at the end of an IF statement. Another is the , which allowed the text display area to be controlled, for instance, would limit text output to a small rectangle on the right side of the screen. cleared the text area and returned the cursor to the upper left of the window, and and set the text mode. Other new basic functionality was offered through the use of "reserved variables", like . and contained the X and Y location of the cursor, respectively, or could be set to move it, like .

Operators and functions

Infix operators included (addition), (subtraction), (multiplication), (division) and exponent using the character. Binary operators included , and . Binary comparisons included the standard set of , , , , , . Extensions to these standard operators included MOD (remainder), DIV (integer division, dropping any fraction), and the alternate form of logical tests, and . It did not support the alternative for not-equals seen in HP Time-Shared BASIC, which had previously been supported in Integer BASIC.

Mathematical functions were fairly standard, including , , , , , , , , . It also included , which was often left out on systems with limited memory. It added the new functions which converted a number into a four-digit hexadecimal number and which did the opposite, taking a string with a hex value and converting that to an integer. String functions included the standard , , , , , , , , and added to find a string within another and return its index, and which overwrote the characters in one string with another, starting at a given location. User functions could be defined with .

In most BASICs, conversions between types were automatic where possible, meaning that one could use expressions that combined floating point and integer functions and values and the data would be converted between those as needed. Strings could not be automatically converted to numbers, but could be done explicitly using the and functions, which converted a string to a number and vice versa. To address the need to convert long integers to the other types, and to generally improve conversions between types in general, Business BASIC introduced a set of four functions, which returned a value of a specified type no matter what sort of input value was used. For instance, would convert the (short) integer value in into a long integer value. Likewise, one could to convert a long integer value to a string.

File handling

Like most BASICs of the era, Business BASIC offered file handling based on the concept of opening a file, reading and writing to it, and then closing the file. Files were referred to by a number provided when the files are opened. Files were opened with the statement - the hash mark is not normally used in most dialects. similarly added the hash, but in this case there was another variation, , which closed all open files. Once opened, files could be read using or and written to using or .

When reading from files, it is possible that any particular operation will reach the end of file, which would normally return a error. This error could be trapped like any other using the statement, but as these particular errors are expected and commonplace, Business BASIC added the specialized which trapped only that one error and only on the provided file number. This could be turned off using the statement. Additionally, it had a system variable that was assigned the file number that caused the error, so it could be handled in more general error trapping routines.

Business BASIC also provided a rudimentary system for reading and writing files in a random access fashion. This was managed by the statement, which had parameters for the filename, file type, and the length of the records. For instance, one could to create a new random-access file containing byte data where each "record" was 500 bytes long. Once created, all reads and writes to such a file would now always read exactly that number of bytes, so if one were to , the system would print the value of A and then pad out the rest of the line with nulls. When used with a random-access file, the read and write statements allowed an optional "record number" to be added after the file number. For instance would read the 10th record, and then attempt to read the value for A from it. Random-access files also set the value of the system variable to a value indicating the type of variable that would next be read or written, and contained the number of the last record to be read or written.

Files had to be d before they could be written to, whereas most dialects would create the file when it was ed for writing. could also be used to create directories. Additional statements included to produce a directory of files at a given path, to remove files, and and . To make working with directories easier, the system variable could be set to a string containing a path, which would then be pre-pended to any file name reference.

Constructing longer programs

Machines of the era had limited memory, often too little to build useful business programs in BASIC. To address this, a number of dialects added the statement. In Business BASIC, had a required parameter, a filename which was not surrounded by quotes. When encountered in a program, this would load the new program code and start executing it. Unlike a or , using did not clear out the current values in variables, allowing the new code to continue processing data created by the previous one. It also allowed a second optional parameter, a line number, where execution should start in the new code. For instance, would load the program "Fence" in the directory "Chain" and start execution at line 800.

One problem with this approach is that BASIC variables are global, meaning that any values that are changed by the new program will cause them to be changed in the original one, assuming it is loaded again as part of the . For common variables like , often used as the index variable in loops, this can lead to problems when one program changes the value in another. Many dialects that supported had functionality to address this, like , but Business BASIC lacked this ability. This meant authors had to carefully track their use of variables. This was especially true for arrays, as it was possible for two chained programs to both the same variable, which would cause the second to raise a .

The new statement read a named text file and parsed its contents as input into the system. One could use this to place a series of instructions in a text file, like and , and these would be executed one by one when the file was ed. The file could also contain new lines of code, allowing programs to be merged, rather than replaced entirely, although this was a slower process than reading in the already-parsed code which was used by or . The program text could be written into a text file using the statement, which redirected all output, including s, to a numbered file handle previously ed.

Calling external code

Business BASIC also included a number of features to allow external, non-BASIC, code to be used in BASIC programs. loaded machine language code from an external file into memory. Multiple routines could be loaded by comma separating the file names in a single statement.

called a routine previously loaded by , and passed in values in parens like a function call. For unexplained reasons, integer and long values had to be indicated by prefixing the variable name, rather than the normal post-fix notation. For instance, would call the StrangeRights function, passing in a long integer Pennies and a short integer Accountants.

was similar to , but called code that was expected to return a real number (floating point) value to the program. was the same but expected an integer value.

Examples

This program creates a new random-access file containing text, and then writes 10 lines of text to it. As the statement specifies a record length of 16, the lines will be 16 characters long no matter how much text is actually written.

10 REM Program PrintRandom
20 CREATE "RandomText", TEXT, 16
30 OPEN# 1 AS OUTPUT, "RandomText"
40 FOR X=1 TO 10
50 PRINT# 1 ,X; "This is line ";X
60 NEXT X
70 CLOSE# 1
8O END

The following program reads the data back in again, but due to the in line 30, it will print every other line in the file:

10 REM Program InputRandom
20 OPEN# 1 AS INPUT, "RandomText"
30 FOR X=2 TO 10 STEP 2
40 INPUT#1,X; ACCEPT$
50 PRINT ACCEPT$
60 NEXT X
70 CLOSE# 1
80 END

Notes

References

Citations

Bibliography

*
*
*

{{Apple

Programming languages created in 1981
Discontinued BASICs
BASIC interpreters
BASIC programming language family
Articles with example BASIC code