BASIC09 is an enhanced structured Basic language programming system specially created for the 6809 Advanced Microprocessor. In addition to the standard BASIC language statements and functions, BASIC09 includes many of the useful elements of the PASCAL programming language so that programs can be modular, well-structured, and use sophisticated data structures. It also permits full access to almost all of the OS-9 Operating System commands and functions so it can be used as a systems programming language. These features make BASIC09 an ideal language for many applications: scientific, business, industrial control, education, and more.

BASIC09 is unusual in that it is an Interactive Compiler that has the best of both kinds of language system: it gives the fast execution speed typical of compiler languages plus the ease of use and memory space efficiency typical of interpreter languages. BASIC09 is a complete programming system that includes a powerful text editor, multi-pass compiler, run-time interpreter, high-level interactive debugger, and a system executive. Each of these components was carefully integrated to give the user a friendly, highly interactive programming resource. that provides all the tools and helpful “extra” facilities needed for fast, accurate creation and testing of structured programs.

BASIC09 Features

BASIC09 was conceived in 1978 as a high-performance programming language to demonstrate the capabilities of the 6809 microprocessor to efficiently run high-level languages. BASIC09 was developed at the same time as the 6809 under the auspices of the architects of the 6809. The project covered almost two years, and incorporated the results of research in such areas as interactive compilation, fast floating point arithmetic algorithms, storage management, high-level symbolic debugging, and structured language design. These innovations give BASIC09 its speed, power, and unique flavor.

BASIC09 was commissioned by Motorola, Inc., Austin, Texas, and developed by Microware Systems Corporation, Des Moines, Iowa. Principal designers of BASIC09 were Larry Crane, Robert Doggett, Ken Kaplan, and Terry Ritter. The first release was in February, 1980.

Excellent feedback, thoughtful suggestions, and carefully documented bug reports from BASIC09 users all over the world have been invaluable to the designers in their efforts to achieve the degree of sophistication and reliability BASIC09 has today.

A computer works something like a pocket calculator. With a calculator you push a button, some calculation occurs, and the result is displayed. On some calculators you can write a program which is just a list of the buttons you want pushed, in the order you want them pushed. This is very similar to a computer program, but most computer languages use command names instead of buttons.

To get results from a computer, you must first put into the computer the list of commands you want executed in the order you want them executed. Each command will mean “do this thing” or “do that thing”, but the computer only has certain commands which it will understand. A computer can do things like “add” or “save the result into memory”. Typing “get me a taco” to a computer won't get it; similarly, on a calculator you can't push buttons which aren't there. After you have stored a list of commands into the computer, you can tell it to perform those operations. This is like actually pushing the buttons on a hand calculator. Then, if you remembered to have the computer display your results, you get to see them. Generally, a computer does not automatically display results like a hand calculator. More calculations occur in a computer then in a calculator, and displaying all these results would simply be overwhelming.

You enter a program into a computer by using the computer itself as a “text editor”, to store the commands you type in. Some editors allow you to enter any text you want. Other editors will only store valid computer commands. Even if the computer does store all the text you type in, it can only execute those commands it knows. If during program execution, BASIC09 finds a word which does not correspond to a command it will probably stop and print out an “error message”. Other editors check each command as you enter it (usually after the carriage-return ending each line) and print error messages immediately for invalid commands. After typing in your list of commands, there are ways to display that list, to modify the commands you have typed in, and to insert others. But simply entering a computer program does not get results any more than thinking which buttons to push will get results on a calculator. You store your program by typing it into a computer, but no results are available until after you start the program running.

Even though programming is conceptually simple, it is easy to misspell commands which BASIC09 will not interpret correctly. Unlike humans, BASIC09 does not infer anything: Every command must be perfectly spelled and punctuated or it is wrong. Even after spelling errors are eliminated, it is likely that the sequence of commands you have entered will not do the job you wanted it to do. The meaning of the program to BASIC09 is often quite different than was intended by the programmer, but good intentions just don't push the right buttons. After you get the program to run without obvious error, you must test the program with sample input and see that it produces results which are known correct. If the results are incorrect, the program must be modified and tested until it does produce correct results. This is known as testing and debugging. Computer malfunctions are rare, and if the computer works to store the program, it is probably working perfectly. If the program does not work, you need to puzzle out how the computer is doing something which you didn't realize that you told it to do. Programming can be frustrating, but if you enter the right commands, the computer will do the right things for you.

Probably the easiest way to explain programming is by example. This simple program sometimes keeps kids happy for hours. First, the program asks the user for his name. Then the computer types out “Hi”, then the name, then “see you later”. This may not seem like much, but it is great fun to type in things which are not your name, and see if they will be printed out. They will, of course.

When you turn on the BASIC09 computer it will print some heading information. If the prompt is “OS9: ”, enter the “basic09” (and a carriage-return) to get to the prompt “B:”. When you have the prompt “B:”, it means that the system is in the BASIC09 “command mode”. While in the command mode, you can do several things, like: list, kill, or create programs (called “procedures” in BASIC09). BASIC09 lets you keep several different programs in memory at the same time. Each procedure is identified by a name you give it when you create the procedure.

To create a new procedure you command the system to enter the “edit mode” by typing a simple “e” (in upper or lower case) and a carriage-return (the ENTER or RETURN key). The Editor lets you enter or change programs and actually checks for many common errors as you type in your program. This automatic checking feature is one of the nicest things about BASIC09. Because it's always “looking over your shoulder” to catch mistakes, it saves a lot of debugging time! If you're not 100% sure about how something works - you can go ahead and try it instead of digging through this manual. If you guess wrong BASIC09 will usually show you where and why.

Because you did not specify a particular procedure name, BASIC09 will automatically select the name “PROGRAM” for you, and will respond by printing out “PROCEDURE PROGRAM”; this means that you will be editing a procedure which is named PROGRAM. Later you will see that you can enter many different procedures and give them different names (just type the name you want to use for the program after the “e”). A procedure name may be any combination of alphanumeric characters beginning with a letter.

The computer output so far is a follows:

OS9: basic09
BASIC09
READY
B:e
PROCEDURE PROGRAM
*
E:

The asterisk (*) indicates the “current edit line” in the procedure being edited. In this case the current line is empty since you have not yet entered anything. The asterisk is handy, since you will be moving back and forth between different lines to edit them. Later you will be “opening” existing procedures for modification, and the first line will be displayed automatically, helping identify that you are editing the correct program.

When BASIC09 responds with the edit prompt “E:”, it is in the edit mode. Now you can enter “edit commands” which help us enter the computer program. While in edit mode, BASIC09 always takes the first character of every line as an edit command. Some of the basic edit commands are:

SPACE program statement RETURN  insert line
? RETURN  go to next line down (just RETURN also does the same)
- RETURN  move back to previous line
L RETURN  list current line
d RETURN  delete current line

You must type an edit command at the start of each line. If you forget to type an edit command, BASIC09 will respond with “WHAT?”. The most-important edit command is the (invisible) space character; it means “save the following line of text”. The “space” command is the way most text is entered into the system. If a line is to be entered, you must type a space before the rest of the line. Another useful edit command is “L*” (or “l*”, since the editor accepts either upper or lower case) which will display the whole procedure. This allows you to watch the procedure develop as lines are entered.

You use the “space” command to enter the following line:

E: PRINT "type your name"
*

When BASIC09 executes procedure PROGRAM, this line will tell it to print on the screen all of the characters between the quotes.

As mentioned before, BASIC09 checks for errors at the end of each line and again when the edit is finished. These errors are, in general, anything BASIC09 cannot identify or things that don't conform to the rules of the language. An error could be a bad character, mismatched parenthesis, or one of many other things. BASIC09 will print out an “error code” to identify the error and print an up arrow character under the place in the line where it detected the error. The error codes are listed at the end of this manual. If the error was detected at the end of the edit session, the I-code location of the error will also be printed. This cryptic information is all BASIC09 knows about the problem, hopefully, it will help you to find and fix the error.

In the same way that you entered the first line, enter the following lines. Remember that the first character entered must be a space to get BASIC09 to save the rest of the line. Example:

E: INPUT name$
*
E: PRINT "Hi ";name$;", see you later."
*
E: END
*

The second line (“input name$”), when executed, commands BASIC09 to wait for a line of text to come in from the keyboard (this will happen after the user reads the message printed out in the first line). BASIC09 will accumulate text from the keyboard character-by-character until a carriage-return ends the line. This text is placed in memory corresponding to the variable “name$”. The dollar-sign ($) on the end of the variable tells BASIC09 that you want to store a sequence of characters as opposed to a number.

The third line of procedure PROGRAM (print "Hi ";name$;", see you later."), starts out like the first line. The command “print” causes BASIC09 to print out the various values which come after it. When this line is executed, the characters H, i, and “space” are printed out since the are enclosed in double-quotes. Next, without additional spaces, BASIC09 prints out the line which was typed in by the user and saved in the memory corresponding to “name$” and prints out “ see you later”. When a PRINT statement contains multiple values, it will print them out one after the other. If the separator is a comma, BASIC09 will move to the next 16-column “tab stop” before printing the next value. However, if the separator between print values is a semicolon, absolutely no space will separate the values. The last line of the procedure (“END”) tells BASIC09 to stop executing the program and return to the command mode (B:). You have not yet EXECUTED the procedure, you are just EDITING. If you type in l* the whole program will be listed, as follows:

E:l*
PROCEDURE PROGRAM 
 0000      PRINT "type your name"
 0012      INPUT name$
 0017      PRINT "Hi ";name$;", see you later."
 0035      END
*
E:

Notice that the editor has added some information which you did not type in. You can use this listing to show exactly what to type in to run this program, but the editor only wants the relevant information.

The numbers to the left are “I-code addresses”. These are the actual memory locations relative to the start of the procedure where each line begins. These numbers may look strange because they are in hexadecimal (base 16). These values are important, since the compiler may find errors at some I-code location and will try to convey that information it has to the programmer. I-code addresses are supplied automatically by BASIC09.

The space between the “I-code addresses” and the beginning of the program line is reserved for “line numbers”. Line numbers are required in many versions of BASIC (although not in BASIC09). Notice that although the program was typed in lower case some words are printed in upper case. BASIC09 identifies valid command “keywords” and converts them to upper case automatically.

Now let's run it. First type “q” to quit the editor. We are now back in “command mode” ( B:). Now type “run”. BASIC09 remembers the procedure edited (PROGRAM) and starts to execute it.

E:q
READY
B:run
type your name
? tex
Hi tex, see you later.
READY
B:

The question mark (?) is the normal input prompt to tell the user that the program is waiting for input.

This program is extremely simple, but younger kids can get great fun from it. Its action is especially amusing to young people who are learning a computer language for the first time because a machine is “responding” to them, and because the machine is too easily “fooled” if you do not type in a real name.

Another simple program that most of us can identify with is a program to print out multiplication tables.

PROCEDURE multable
  FOR i=1 TO 9
    FOR j=1 TO 9
      PRINT i*j; TAB(5*j);
    NEXT j
  NEXT i

First, open the editor by typing “e multable”, as follows:

B: e multable
PROCEDURE multable
*
E:

Next, type in the program line-by-line starting with “FOR i=1 TO 9” (lower-case is perfectly fine). If you loose your way, type “L*” to see where you are. This will display the entire procedure and put an asterisk at the left of the current line. If you make a mistake, use “+” or “-” to mode to that line, use “d” to delete the line, and use the space command to enter the line over. Make sure that there are no errors and then type “q”. When you have the program running, try adding a statement before “FOR i=1 TO 9” as follows: “DIM i,j:INTEGER”.

The FOR i=1 TO 9 and NEXT i constitute the start and end of a control structure or “loop”. A control structure is used to cause repeated or conditional execution of the statement(s) it surrounds. A control structure usually has one entry at the top and one exit at the bottom. In this way, the entire structure take on the properties of a single statement. The beginning statement of the FOR...NEXT structure (FOR...) provides a “loop initialization”, places the value 1 in the storage called “i”, and sets up the operation of the following NEXT (every FOR must have a NEXT). When “NEXT i” is executed, the value in “i” is increased by 1 (which is the default STEP size) and compared to the value 9 (which is the ending value for this loop). If the resulting “i” is less than or equal to 9, the statement(s) following that FOR... is (are) executed.

Loops can be “nested” to execute the enclosed statements even more times. For example, the PRINT statement in “multable” is executed 81 times; once for each of 9 values of “j” and this number (9 times) for each of 9 values of “i”. The ability to tremendously increase the number of times some code is executed is at the heart of both computer programming and computer errors. It means that a vary small portion of a program can often be made to do the vast majority of the work. But a few remaining special cases may require individual handling and may consume more programming and code than that which “usually” works. Unfortunately, “usually” is not sufficient. A special case which occurs once in a thousand times may occur once a second, and if the error stops the program, further processing of normal values also stops. Experience has indicated that the programmer should know what is happening in the first and second pass, and the next-to-the-last and last pass through each loop in the program.

The “DIR” command causes BASIC09 to display the names and sizes of all procedures in memory. This command is used so frequently that there is a quick shorthand for DIR: a simple RETURN when in command mode does the same thing. You will see a table of all procedure names and two numbers next to each name. The first column, “proc size”, is the size of the corresponding procedure. The “data size” column shows the amount of memory that the procedure requires for its variables. On the last line this command shows the amount of free bytes of workspace memory remaining. You can use this information to estimate how much memory your program needs to run. You must have at least as much free memory as the data size of the procedure(s) to be run. If a data size number is followed by a question mark, you need more memory.

BASIC09 automatically get 4K of workspace memory from OS-9 when it starts up. There is almost always more than this available, but BASIC09 does not grab it all so other tasks running on your computer can have memory too. If you are not multitasking and need more memory, the MEM command can get it if available. Just type MEM and the amount of memory you want. Depending on your computer and how it is configured, you can usually get at least 24K in OS-9 Level One Systems or 40K in OS-9 Level Two systems. For example:

MEM 20000

requests 20.000 (20K) bytes of memory. BASIC09 will always round the amount you request up to the next highest multiple of 256 bytes. If MEM responds with “WHAT?”, this means that much memory is not available. There is another convenient way to do the same thing when you first call up BASIC09 from OS-9. OS-9 has a “#” memory size option on command lines that let you specify how much memory to give the program. To call BASIC09 with 16K of memory to start with, you can type:

OS9: basic #16k

Nobody wants to retype a whole program every time it is to be run. Two commands, SAVE and LOAD, are used to store programs and recall previously “SAVEd” programs to or from OS-9 disk files. The simple way to use SAVE is by itself. It will store the procedure last edited or run on a disk file having the same name. For example:

B: save

If our procedure name was the default name “PROGRAM”, BASIC09 will create a file called “PROGRAM” to hold it. OS-9 won't let you have two files of the same name because unique names are necessary to identify the specific file you want. Therefore if a file called “PROGRAM” already exists, BASIC09 will ask you:

Overwrite?

If you respond “Y” for YES, it will replace the file previously stored on that file with the program to be saved. This is OK if what you want to save is a never version of the same program. But if not you will permanently erase another program you may have wanted to keep. If this is the case answer “N” for NO. Fortunately, there is a simple way to store the procedure on a file using a different name: just type SAVE, a “>”, and a different file name of your choice. The file can consist of any combination of up to thirty-one letters, numbers, periods, or underscores (“_”). The only restriction is that the name must start with a letter A-Z or a-z. For example:

save >newprogram5

will save the program on a file called “newprogram5”. There are several useful variations of the SAVE command that let you save various combinations of programs on the same file. See the SAVE command description for more information. You should also read Chapter 2 of the OS-9 User's Manual to learn about the OS-9 commands that deal with disk files.

If you exit from BASIC09, it will not automatically save your programs. You must make sure to save them before you quit, or they will be lost unless the were saved at some time before!

The LOAD command, as it's name implies, reads in a previously save program from a file. You must give the name of the file with the command. For example:

load program

If you just started BASIC09 and have not created any procedures, the command is very straightforward. As the procedure(s) stored in the file are loaded, BASIC09 displays their name(s) as they are brought in. Once the program is loaded, you can edit and/or run it. But if you have a procedure in BASIC09 that has the same name as a procedure stored in the file, BASIC09 will replace it with the new version loaded from the file. If this kind of conflict exists you could loose your old program, so be sure to save or RENAME it before loading a new one (remember that BASIC09 can keep several procedures in memory at the same time as long as they have different names). If you want to permanently erase all other procedures before loading new ones, you can type:

B: kill*

This tells BASIC09 to “kill” all procedures in memory and has the same effect as completely resetting BASIC09.

If your computer is equipped with a printer, you will want to make hard-copy listings of your programs. This is easy to do - just type:

B: LIST* /p

This tells BASIC09 to LIST all procedures in memory to the output device “/p” which is the printer device name in most OS-9 systems. Like the SAVE command, LIST has several useful variations. If you want to list just one procedure (if there are more than on in memory) you can type:

B: LIST procedurename >/P

If you want, you can put two or more procedure names (separated by spaces) before the semicolon and those specific procedures will be listed.

Notice that if you omit the “/p” or “>/p” from the commands above, the programs will be listed on your display instead of the printer. This is the same as the “L*” command in Edit Mode. You will also notice that the listing will be automatically “pretty-printed”, e.g. program levels within loops are indented for easy reading.

At any given time, BASIC09 is in one of four modes:

So far, you have been exposed to System Mode (SAVE, LOAD, etc.), Edit Mode (the editor), and Execution Mode (RUN). A section of this manual is devoted to each mode. The chart below shows how various commands in each mode will cause a change to another mode.

   OS-9          SYSTEM MODE           EDIT MODE
----------       ------------         ------------
|        |       |          |         | +        |
|        |       |  $       |         | -        |
|        | <-----+--<eof>   |         | <cr>     |
|        | <-----+--BYE     |         | <line#>  |
|        |       |  CHD     |         | <space>  |
|        |       |  CHX     |         | c        |
|        |       |  DIR     |         | d        |
|        |       |  EDIT----+-------> | l        |
|        |       |  KILL    | <-------+-q        |
|        |       |  LIST    |         | r        |       ------------
|BASIC09-+-----> |  LOAD    |         | s        |       | TRON     |
|        |       |  MEM     |         ------------       | TROFF    |
|        |       |  PACK    | <--------------------------+ END or Q |
|        |       |  RENAME  |                            | DEG/RAD  |
|        |       |  RUN-----+-------> ------------       | STATE    |
|        |       |  SAVE    | <-------+-END      |       | $        |
|        |       |          | <-------+-<CTRL Q> |       | BREAK    |
|        |       ------------ <-------+-STOP     | <-----+-CONT     |
|BASIC09 |                            | PAUSE----+-----> | DIR      |
|AUTORUN-+--------------------------> | ERROR----+-----> | LET      |
|        |                            | <CTRL C>-+-----> | LIST     |
|        | <--------------------------+-BYE      |       | PRINT    |
|        |                            | PROGRAM  | <-----+-STEP     |
----------                            ------------       ------------
                                     EXECUTION MODE       DEBUG MODE

The workspace concept is important because BASIC09 and OS-9 are both highly modular systems, and the workspace is a way to logically group a set of procedures (i.e. modules) which are applicable to a particular line of study or development. Modular software development lets the programmer divide a large and complex project into smaller, more manageable, and individually testable sections. Modularity also lets programmers accumulate and use libraries of commonly used routines.

As the software is written and debugged, BASIC09 makes it easy to deal with the procedures that comprise an overall project, either individually or as a group. For example, you can save all procedures in the workspace to a single mass storage file or load a file containing multiple procedures. Usually all procedures associated with a project exists inside the workspace. However, you can also call library procedures which are “outside” the workspace in OS-9 memory module format. The library procedures can be written in BASIC09 or machine language, can be in RAM or ROM memory, and can even be shared by several users.

BASIC09 always reserves approximately 1.2K bytes of the workspace for internal use. All remaining space is used for storage of procedures and for procedure variable storage during execution. BASIC09 will not run a procedure if there is not enough space for variables. If you run out of workspace area, you can use the MEM command to enlarge the workspace or you can kill procedures in the workspace that are not needed. The “MEM” command can be used at any time to change the size of the workspace. The size of the workspace can be increased (subject to availability of free memory) or decreased (but not below the minimal amount needed to store the present workspace).

A good way to learn BASIC09 is to use it! Try typing in and running some of the example programs in the back of the book. Look up and study the function of each program statement. Read the chapters on the EDIT and DEBUG modes and experiment with more advanced commands. Also, BASIC09 and the OS-9 Operating System are so intimately connected, a basic understanding of OS-9 is important. See Chapter 2 of the OS-9 User's Manual.

$ [text]   (“Shell” Command)

This command calls the OS-9 Shell command interpreter to process an OS-9 command or to run another program. Running the OS-9 command does not cause BASIC09 or its workspace to be disturbed.

If the “$” is followed by text, the Shell is called to process the text as a single OS-9 command line. After the command is executed, BASIC09 is immediately re-entered.

If no text is specified, BASIC09 is suspended, and the OS-9 Shell is called to process multiple command lines individually entered from the keyboard. Control is returned to BASIC09 when an end-of-file character (usually ESCAPE) is entered. The contents of the BASIC09 workspace is not affected. This is a convenient way to temporarily leave BASIC09 to manipulate files or perform other housekeeping tasks.

This command is the “gateway” to OS-9 from inside BASIC09. It allows access to any OS-9 command or to other programs. It also permits creation of concurrent processes and other real-time functions.

Examples:

B: $copy file1 file2          Calls the OS-9 copy command
B: $asm sourcefile&           Calls the assembler as a background task
B: $basic09 fourier(20)&      Starts another concurrent BASIC09 program

BYE (or ESCAPE character)

Exits BASIC09 and returns to OS-9 or the program that called BASIC09. Any procedures in the workspace are lost if not previously saved. The escape key (technically speaking, an end-of-file character condition on BASIC09's standard input path) does the same thing.

CHD pathlist or CHX pathlist

Changes the current OS-9 user Data or Execution Directory to the specified pathlist which must be a directory file. BASIC09 uses the Data Directory to LOAD or SAVE procedures. The Execution Directory is used to PACK or auto-load packed modules.

Example:

CHD /d1/joe/games

DIR [pathlist]

Displays the name, size, and variable storage requirement of each procedure presently in the workspace. The current working procedure has an asterisk before its name. All packed procedures have a dash before their name (see PACK). The available free memory within the workspace is also given. If a pathlist is specified, output is directed to that file or device.

A question mark next to a data storage size means the workspace does not have enough free memory to run that procedure.

Note: This command should not be confused with the OS-9 “DIR” command. They have completely different functions.

EDIT [procname]
E [procname]

Exits command mode and enters the text editor/compiler mode. If the specified procedure does not exist, a new one is created. See the Chapter 4 for a complete description of how edit mode works.

Examples:

E newprog
EDIT printreport

KILL [procname {,procname}]
KILL*

Erases the procedure(s) specified. KILL* clears the entire workspace. The process may take some time if there are many procedures in the workspace.

Examples:

kill formulas
kill prog1, prog2, prog7

LIST [procname {,procname}] [> pathlist]
LIST* [pathlist]

Prints a formatted “pretty printed” listing of one or more procedures. The listing includes the relative I-code storage addresses in hexadecimal format in the first column. The second column is reserved for program line numbers (if line numbers are used).

If a pathlist is given, the listing is output to that file or device. This option is commonly used to print hard-copy listings of programs. The LIST, SAVE and PACK commands all have identical syntax, except that LIST prints on the OS-9 standard error path (#2) if no pathlist is given. The files produced are formatted differently, but the function is similar.

Examples:

list* /p
list prog2,prog3 >/p
list prog5 >temp

LOAD pathlist

Loads all procedures from the specified file into the workspace. As procedures are loaded, their names are displayed. If any of the procedures being loaded have the same name as a procedure already in the workspace, the existing procedures are erased and replaced with the procedure being loaded.

If the workspace fills up before the last procedure in the file is loaded, an error (#32) is given. In this case, not all procedures may have been loaded, and the one being loaded when the workspace became full may not be completely loaded. You should KILL the last procedure, use the MEM command to get more memory or KILL unnecessary procedure(s) to free up space, and then LOAD the file again.

Example:

load quadratics

MEM
MEM [number]

MEM used without a number displays the present total workspace size in (decimal) bytes. If a number is given, BASIC09 asks OS-9 to expand or contract the workspace to that size. A hex value can be used if preceded by a dollar sign. If MEM responds with What?, you either asked for more memory than is available, tried to give back too much memory (there has to be enough to store all procedures in the workspace), or gave an invalid number.

Example:

MEM 18000

PACK [procname {,procname}] [> pathlist]
PACK* [pathlist]

This command causes an extra compiler pass on the procedure(s) specified, which removes names, line numbers, non-executable statements, etc. The result is a smaller, faster procedure(s) that cannot be edited or debugged but can be executed by BASIC09 or by the BASIC09 run-time-only program called “RunB”. If a pathlist is not given, the name of the first procedure in the list will be used as a default pathname. The procedure is written to the file/device specified in OS-9 memory module format suitable for loading in ROM or RAM outside the workspace. The resulting file cannot be loaded into the workspace later on, so you should always perform a regular SAVE before PACKing a procedure!

BASIC09 will automatically load the packed procedure when you try to run it later. Here is an example sequence that demonstrates packing a procedure:

The last step (kill) does not have to be done immediately if you will use the procedure again later, but you should kill it when you are done so its memory can be used for other purposes.

Examples:

pack proc1,proc2 >packed.programs

pack* packedfile

RENAME procname,new procname

Changes the name of a procedure. Can be used to allow two copies of the same procedure in the workspace under different names.

Example:

rename thisproc thatproc

RUN [procname [ ( expr , {expr} ) ]]

Runs the procedure specified. Technically speaking, BASIC09 then leaves Command mode and enters Execution mode.

A parameter list can be used to pass expected parameters to the procedure in the same way a RUN statement inside a procedure calls another procedure except for the restriction that all parameters must be constants or expressions without variables. See the PARAM statement description. Assembly language procedures cannot be run from command mode.

The procedure called can be normal or “packed”. If the procedure is not found inside BASIC09's workspace, BASIC09 will call OS-9 to attempt to LINK to an external (outside the workspace) module. If this fails, BASIC09 attempts to LOAD the procedure from a file of the same name.

Examples:

run getdata

run invert("the string to be inverted")

run power(12,354.06)

run power($32, sin(pi/2))

SAVE [procname {procname} [> pathlist]]
SAVE* [pathlist]

Writes the procedure(s) (or all procedures) to an output file or device in source format. SAVE is similar to the LIST command except the output is not formatted and I-code addresses are not included. If a pathlist is not specified, it defaults to the name of the first procedure listed.

If a file of the same name already exists, SAVE will prompt with:

rewrite?

You may answer “Y” for yes which causes the existing file to be rewritten with the new procedure(s); or “N” to cancel the SAVE command.

Examples:

save proc2 proc3 proc4 >monday.work

save* newprogram

save

save  >testprogram

The Editor includes the following commands. Each command is described in detail later in this chapter.

In order to understand how the editor works it is helpful to have a general idea of what goes on inside BASIC09 while you are editing procedures. BASIC09 programs are always stored in memory in a compiled form called “I-code” (short for “Intermediate Code”). I-code is a complex binary coding system for programs that lies between your original “source” program and the computer's native “machine language”. I-code is relatively compact, can be executed rapidly, and most importantly, can be reconstructed almost exactly back to the original source program. The Editor is closely connected to the “compiler” and “decompiler” systems within BASIC09 that translate source code to I-Code and vice-versa. It is this innovative system that gives BASIC09 its most powerful and unusual abilities.

Whenever you enter (or change) a program line and “return”, the compiler instantly translates this text to the internal I-code form. When BASIC09 needs to display program lines back, it uses the decompiler to translate the I-code back to the original “source” format. These processes are completely automatic and do not require any special action on your part.

This technique has several advantages. First, it allows the text editor to report many (syntax) errors immediately so you can correct them instantly. Secondly, the I-code representation of a program is more compact (by about 30%) than its original form, so you can have have larger programs in any given amount of available memory.

When programs are listed by BASIC09, it is possible they will have a slightly different appearance than the way they were originally typed in, but they will always be functionally identical to the original form. This can happen if the original program had extraneous spaces between keywords, unnecessary parentheses in expressions, etc. BASIC09 keywords are always automatically capitalized.

When you have finished editing the procedure, use the “q” (for “quit”) command to exit edit mode and return to the command mode. When you give the “q” command, the compiler performs another “pass” over the entire procedure again. At this time syntax that extends over multiple lines is checked and errors reported. Examples of these errors are: GOTO or GOSUB to a non-existent line, missing variable or array declarations, improperly constructed loops, etc. These errors are reported using an error code and the hexadecimal I-code address of the error. For example:

01FC ERR #043

This message means that error number 43 was detected in the line that included I-code address 01FC (hexadecimal). The LIST command gives the I-code addresses so you can locate lines with errors reported during the compiler's second pass.

As mentioned previously, the editor has the capability to work on programs with or without line numbers (or both). Line numbers must be positive whole numbers in the range of 1 to 32767.

If you have experience with another version of the BASIC language, this is the kind of editing you probably used. However, well-structured programs seldom really need line numbers. If you don't have to use line numbers, don't. Your programs will be shorter, faster, and easier to read.

The line-number oriented commands are:

To enter or replace a numbered line, simply type in the line number and statement. Numbered lines can be entered in any order, but will be automatically stored in ascending sequence. To move to a numbered line, type the line number followed by a carriage return. The editor will move to that line (or the line with the next higher number if the specified number is not found) and print it. The line may be deleted using the “d” command.

The “r” renumber command will uniformly resequence all numbered lines and lines that refer to numbered lines. Its formats are:

r [ beg line # [,incr ] ] RETURN
r*[ beg line # [,incr ] ] RETURN

The first format renumbers the program starting at the current line and forward. Lines are renumbered using beg line# as the initial line number. incr is added to the previous line number for the next line's number. For example,

r 200,5

will give the first line number 200, the second 205, the third 210, etc. If beg line# and/or incr are not specified, the values 100 and 10, respectively, are assumed. The second form of the command is identical except it renumbers all lines in the procedure.

Most editor commands are string-oriented. This means that you can enter or change whole or partial lines without using line numbers at all. You will find that string-oriented editing is generally faster and more convenient.

Because line numbers are not used, there has to be another way to tell BASIC09 what place in the program to work on. To do this, the editor maintains an “edit pointer” that indicates which line is the present working location within the procedure, and commands start working at this point. The editor shows you the location of the edit pointer by displaying an “*” at the left side of the program line where the edit pointer is presently located.

RETURN
+ RETURN
+1 RETURN

d [number] RETURN
d*

l [number] RETURN
l*

s delim match str [delim] RETURN
s*delim match str [delim] RETURN

CAN'T FIND: "match str"

E:s/counter/             Looks for the string: counter

E:s.1/2.                 Looks for the string: 1/2

E:s?three blind mice?    Looks for the string: three blind mice

c delim match str delim repl str [delim] RETURN
c*delim match str delim repl str [delim] RETURN

c/xval/yval/
c*,GOSUB 5300,GOSUB 5500

To run a BASIC09 procedure, enter:

RUN procname

If the procedure you want to run was the last procedure edited, listed, saved, etc., you can type RUN without giving a procedure name (the “*” shown in the DIR command identifies this procedure).

If the procedure expects parameters (see Chapter 7), they can be given on the same command line, however they must all be constant numbers or strings, as appropriate, and must be given in the correct order. For example:

RUN add(4,7)

is used to call a program that expects parameter, such as

PROCEDURE add
PARAMETER a,b                a,b will receive the values 4,7
PRINT a+b
END

The ability to pass parameters to a program allows you to specifically initialize program variables. Sometimes certain procedures are parts of a larger software system and are designed to be called from other procedures. You can use this feature to individually test such procedures by passing them test values as parameters.

The RUN statement causes BASIC09 to enter Execution Mode, causing the procedure to run until one of the these things happen:

In cases 1 and 2, you will return to system mode. In cases 3 and 4, you will enter DEBUG mode.

The RUN statement is simple and normally you do not need to know what is happening inside BASIC09 when you use it. The technical description of execution mode that follows is given for the benefit of advanced BASIC09 programmers.

Execution mode is BASIC09's state when you run any procedure. It involves executing the I-code of one or more procedures inside or outside the workspace. Many procedures can be in use because they can call each other (or themselves) and nest exactly like subroutines. You can enter execution mode in a number of ways:

The Auto-run feature allows BASIC09 to get the name of a file to load and run from the same command line used to call BASIC09. The file loaded and run can be either a SAVED file (in the data directory), or a PACKED file (in the execution directory). The file may contain several procedures; the one executed is the one with the same name as the file. Parameters may be passed following the pathname specified. For example, the following OS-9 command lines use this feature:

OS9: BASIC09 printreport("Past Due Accounts")
OS9: BASIC09 evaluate(COS(7.8814)/12.075,-22.5,129.055)

One of BASIC09's outstanding features is its set of powerful symbolic debugging commands. What is Symbolic Debugging? Simply stated, it is testing and manipulation of programs using the actual names and program statements used in the program. In this chapter you will learn how Debug Mode can let you watch your program run in slow motion you can observe each statement as it is executed. As a bonus, you will also learn how to use the Debug Mode as a calculator.

Debug mode is entered from execution mode in one of three ways:

When any of the above happen, Debug Mode announces itself by displaying the suspended procedure name like this:

BREAK: PROCEDURE test5
D:

Notice that Debug Mode displays a “D:” prompt when it is awaiting a command. Any debug mode commands can the be used to examine or change variables, turn trace mode on/off, etc. Depending on which commands are used, execution of the program can be terminated, resumed, or executed one source line at a time.

$ text

Calls OS-9's Shell command interpreter to run a program or OS-9 command. Exactly the same as the System Mode “$” command.

BREAK proc name

Sets up a “breakpoint” at the procedure named. This command is used when procedures call each other, and provides a way to re-enter Debug Mode when returning to a specific procedure. To illustrate how BREAK works, suppose there are three procedures in the workspace: PROC1, PROC2, and PROC3. Assume that PROC1 calls PROC2, which in turn calls PROC3. While PROC3 is executing, you type Control+C to enter debug mode. You can now enter:

D: BREAK proc1
ok
D:

Notice that BREAK responds with “ok” if the procedure was found on the current RUN stack. If you wish you can use the STATE command to verify that the three procedures are “nested” as expected. Now, you can resume execution of PROC3 by typing CONT. After PROC3 terminates, control passes back to PROC2, which eventually returns to PROC1. As soon as this happens, the breakpoint you set is encountered, PROC1 is suspended, and Debug Mode is reentered.

There are three characteristics of BREAK you should note:

CONT

The command causes program execution to continue at the next statement. It may resume programs suspended by Control-C, PAUSE statements, BREAK command breakpoints, or after non-fatal run-time errors.

DEG
RAD

These commands select either degrees or radians as the angle unit measure used by trigonometric functions. These commands only affect the procedure currently being debugged or run.

DIR [path]

Displays the workspace procedure directory in exactly the same way as the System Mode DIR command.

END or Q

Terminates execution of all procedures and exits Debug Mode by returning to System Mode. Any open paths are closed at this point.

LET var := expr

This command is essentially the same as the BASIC09 LET program statement, which allows the value of a procedure variable to be set to a new value using the result of the evaluated expression. The variable names used in this command must be the same as in the original “source” program; otherwise, an error is generated. LET does not work on user-defined data structures.

LIST

Displays a formatted source listing of the suspended procedure with I-code addresses. An asterisk is printed to the left of the statement where the procedure is suspended. Only list the current procedure may be listed.

PRINT [#expr,] [USING expr,] expr list

This is exactly the same as the BASIC09 PRINT statement and can be used to examine the present value of variables in the suspended program. All variable names must be the same as in the original program, and no new variable names can be used. User-defined data structures cannot be printed.

STATE

This command lists the calling (“nesting”) order of all active procedures. The highest-level procedure is always shown at the bottom of the calling list, and the lowest-level procedure will always be the suspended procedure. An example:

D:state
PROCEDURE DELTA
CALLED BY BETA
CALLED BY ALPHA
CALLED BY PROGRAM

STEP [number]   or   RETURN

This command allows the suspended procedure to be executed one or more source statements at a time. For example, “STEP 5” would execute the equivalent of the next 5 source statements. A debug command line which is just a carriage return is considered the same as “STEP 1”. The STEP command is most commonly used with the trace mode on, so the original source lines can be seen as they are executed.

Note: because compiled I-code contains actual statement memory addresses, the “top” or “bottom” statements of loop structures are usually executed just once. For example, in FOR...NEXT loops the FOR statement is executed once, so the statement that appears to be the top of the loop is actually the one following the “FOR” statement.

TRON
TROFF

These commands turn the suspended procedure's trace mode on and off. In trace mode, the compiled code of each equivalent statement line is reconstructed to source statements and displayed before the statement is executed. If the statement causes the evaluation of one or more expressions, an equal sign and the expression result(s) are displayed on the following line(s).

Trace mode is local to a procedure. If the suspended procedure calls another, no tracing occurs until control returns back (unless of course, other called procedure(s) have trace mode on).

If your program does not do what you expect it to, it is bound to show one of two symptoms: incorrect results, or premature termination due to an error. The second case will automatically send you into Debug Mode. In the first case, you have to force the program into Debug Mode either by hitting Control+C (assuming you have time to do so), or by using Edit Mode to put one or more PAUSE statements in the program. Once you're in Debug Mode, you can bring its powerful commands to bear on the problem.

Usually the first step after an error stops the program is to place a PAUSE statement at the beginning of the suspected procedure or at a place within it where you think things begin to go amiss, and the you rerun the program. When the program hits the PAUSE statement, and enters DEBUG mode, it is time to turn the trace mode on and actually watch your program run. To do so, just type:

D: TRON

After you have done this, you hit the carriage return key once for every statement. You will see the original source statement, and if expressions are evaluated by the statement, Debug Mode will print an equal sign and the result of the expression. Notice that some statements such as FOR and PRINT may cause more than one expression to be evaluated. Using this technique, you can watch your program run one step at a time until you see where it goes wrong. But what if in the process of tracing, you encounter a loop that works OK, but executes 200 statements repetitively? That's a lot of carriage returns. In this case, turn the trace off (if you want) and use the STEP command to quickly run through the loop. Then, turn trace mode back on, and resume single-step debugging. The command sequence for this example is:

D: TROFF
D: STEP 200
D: TRON

Don't forget that trace mode is “local” to one procedure only. If the procedure under test returns to another procedure you need to use the BREAK command or put a PAUSE statement in the procedure to enter Debug Mode. If you call another procedure from the procedure being debugged, tracing will stop when it is called until it returns. If you also want to trace the called procedure, it will need its own PAUSE statement.

The simple program listed below turns Debug Mode into a powerful desk calculator. It's function is simple: it declares 26 working variables, then goes into Debug Mode so you can use interactive PRINT and LET statements.

PROCEDURE Calculator
DIM a,b,c,d,e,f,g,h,i,j,k,l,m
DIM n,o,p,q,r,s,t,u,v,w,x,y,z
PAUSE
END

Recall that while in debug mode, you cannot create new variables, hence the DIM statements that pre-define 26 working variables for you. If you wish you can add more or fewer variables. The PAUSE statement causes Debug Mode to be entered. Here's a sample session:

B: run calculator
BREAK: PROCEDURE Calculator
D:let x:=12.5
D:print sin(pi/2)
.7071606781
D:let y:=exp(4+0.5)
D:print x,y
12.5   90.0171313
D:Q
B:

Don't forget that the Debug Mode PRINT command can use PRINT USING to produce formatted output (including hexadecimal).

By adding less than a dozen statements to the program, you can make it store its variables on a disk file so they're remembered from session to session. There are also many other enhancement possibilities

A computer program's primary function is to process data. The performance of the computer, and even sometimes whether or not a computer can handle a particular problem, depends on how the software stores data in memory and operates on it. BASIC09 offers many possibilities for organizing and manipulating data.

Complicating matters somewhat is the fact that there are many kinds of data. Some data are numbers used for counting or measuring. Another example is textual data composed of letters, punctuation, etc., such as your name. Seldom can they be mixed (for example multiplication is meaningless to anything but numbers), and they have different storage size requirements. Even within the same general kind of data, it is frequently advantageous to have different ways to represent data. For example, BASIC09 lets you chose from three different ways to represent numbers - each having its own advantages and disadvantages. The decision to use one depends entirely on the specific program you are writing. In order for you to select the most appropriate way to store data variables, BASIC09 provides five different basic data types. BASIC09 also lets you create new customized data types based on combinations of the five basic types. A good analogy is to consider the five basic types to be atoms, and the new types you create as molecules. This is why the five basic types are called atomic data types.

A data structure refers to storage for more than one data item under a single name. Data structures are often the most practical and convenient way to organize large amounts of similar data. The simplest kind of data structure is the array, which is a table of values. The table has a single name, and the storage space for each individual value is numbered. Arrays are created by DIM statements. For example, to create an array having five storage spaces called “AGES”, we can use the statement:

DIM AGES(5):INTEGER

“(5)” tells BASIC09 how many spaces to reserve. The “:INTEGER” part indicates the array's data type. To assign a value of 22 to the third storage space in the array we can use the statement:

LET AGES(3):=22

As you shall see, BASIC09 lets you create complex arrays and even arrays that have different data types combined.

      +--------+--------+--------+--------+--------+
      |exponent|        |        |        |      |S| <- mant. sign
      +--------+--------+--------+--------+--------+
byte:     +0       +1       +2       +3       +4

      +--------+--------+--------+--------+--------+--------+
      |   S    |    A   |    M   |  255   |        |        |
      +--------+--------+--------+--------+--------+--------+
byte:     +0       +1       +2       +3       +4       +5

      +--------+--------+--------+--------+--------+--------+
      |   R    |    O   |    B   |    E   |    R   |    T   |
      +--------+--------+--------+--------+--------+--------+
byte:     +0       +1       +2       +3       +4       +5

Constants are frequently used in program statements and in expressions to assign values to variables. BASIC09 has rules that allow you to specify constants that correspond to the five basic data types.

DIM flag, state: BOOLEAN
flag := TRUE
state := FALSE

"BASIC09 is a new microcomputer language"
"AABBCCDD"
""   (a null string)
"An ""older man"" is wiser"

Each BASIC09 variable is “local” to the procedure where it is defined. This means that it is only known to the program statements within that procedure. You can use the same variable name in several procedures and the variables will be completely independent. If you want other procedures to be able to share a variable, you must use the RUN and PARAM statements to pass the variable when a procedure calls another procedure.

Storage for variables is allocated from the BASIC09 workspace when the procedure is called. It is not possible to force a variable to occupy a particular absolute address in memory. When the procedure is exited, variable storage is given back and the values stored in it are lost. Procedures can call themselves (this is referred to as recursion) which causes another separate storage space for variables to be allocated.

Procedures may pass variables to other procedures. When this occurs, the variables passed to the called procedure are called “parameters”. Parameters may be passed either “by reference”, allowing values to be returned from the called procedure, or “by value”, which protects the values in the calling procedure such that they may not be changed by the procedure which is called.

Parameters are usually passed “by reference”; this is done by enclosing the names of the variables to be sent to the called procedure in parentheses as part of the RUN statement. The storage address of each parameter variable is evaluated and sent to the called procedure, which then associates those addresses with names in a local PARAM statement. The called procedure uses this storage as if it had been created locally (although it may have a new name) and can change the values stored there. Parameters passed by reference allow called procedures to return values to their callers.

Parameters may be passed “by value” by writing the value to be passed as an expression which is evaluated at the time of the call. Useful expression-generators that do not alter values are +0 for numbers or +"" for strings. For example:

RUN inverse(x)                           passes x by reference.
RUN inverse(x+0)                         passes x by value.
RUN translate(word$)                     passes word$ by reference.
RUN translate(word$+"")                  passes word$ by value.

When parameters are passed by value, a temporary variable is created when the expression is evaluated. The result is placed in this new temporary storage. The address of this temporary storage is sent to the called procedure. Therefore, the value actually given to the called procedure is a copy of the result, and the called procedure can't accidentally (or otherwise) change the variable(s) in the calling program.

Notice that expressions containing numeric constants are either of type INTEGER or of type REAL; there is no type BYTE constant. Thus, BYTE-type VARIABLES may be sent to a procedure as parameters; but expressions will be of types INTEGER or REAL. For example, a RUN statement may evaluate an INTEGER as a parameter and send it to the called procedure. If the called procedure is expecting a BYTE-type variable, it uses only the high-order byte of the (two-byte) INTEGER (which, if the value was intended to be in BYTE-range, will probably be zero!).

The DIM statement can create arrays of from 1 to 3 dimensions (a one-dimensional array is often called a “vector”, while a 2 or 3 dimensional array is called a “matrix” ). The sizes of each dimension are defined when the array is typed (e.g., DIM plot(24,80):BYTE) by including the number of elements in each dimension. Thus, a table dimensioned (24,80) has 24 rows (1-24) of 80 columns (1 - 80) when accessed in the default (BASE 1) mode. You may elect to access the elements of an array starting at zero (BASE 0), in which case there are still 24 rows (now 0-23) and 80 columns (now 0-79). Arrays may be composed of atomic data types, complex data types, or other arrays.

The TYPE statement can be used to define a new data type as a “vector” (a one-dimensional array) of any atomic or previously-defined types. For example:

TYPE employee_rec = name:STRING; number(2):INTEGER; malesex:BOOLEAN

This structure differs from an array in that the various elements may be of mixed types, and the elements are accessed by a field name instead of an array index. For example:

DIM employee_file(250): employee_rec
employee_file(1).name := "Tex"
employee_file(20).number(2) := 115

The complex structure gives the programmer the ability to store and manipulate related values that are of many types, to create “new” types in addition to the five atomic data types, or to create data structures of unusual “shape” or size. Additionally, the position of the desired element in complex-type storage is known and defined at “compile time” and need not be calculated at “run time”. Therefore, complex structure accesses may be slightly faster than array accesses. The elements of a complex structure may be copied to another similar structure using a single assignment operator (:= ). An entire structure may be written to or read from mass storage as a single entity (e.g., PUT #2, employee_file). Arrays or complex structures may be elements of subsequent complex structures or arrays.

Many BASIC09 statements evaluate expressions. The result of an evaluation is just a value of some atomic type (e.g., REAL, INTEGER, STRING, or BOOLEAN). The expression itself may consist of values and operators. For example, the expression “5+5” results in an integer with a value of ten.

A “value” can be a constant value (e.g, 5.0, 5 , "5" , or TRUE), a variable name, or a function (e.g, SIN(x) ) which “returns” the result as a value. An operator combines values (typically, those adjacent to the operator) and also returns a result.

In the course of evaluating an expression, each value is copied to an “expression stack” where functions and operators take their input values and return results. If (as is often the case) the expression is to be used in an assignment statement, only when the result of the entire expression has been found is the assignment made. This allows the variable which is being modified (assigned to) to be one of the values in the expression. The same principles apply for numeric, string, and Boolean operators. These principles make assignment statements such as “X=X+1” legal in all cases, even though it would not make sense in a mathematical context.

Any expression evaluates to one of the five “atomic” data types, i.e., real, integer, byte, Boolean, or string. This does not mean, however, that all the operators and operands in expressions have to be of an identical type. Often types are mixed in expressions because the RESULT of some operator or function has a different type than its operands. An example is the “less than” operator. Here is an example:

24 < 100

The “<” operator compares two numeric operands. The result of the comparison is of type BOOLEAN; in this case, the value TRUE.

BASIC09 allows intermixing of the three numeric types because it performs automatic type conversion of operands. If different types are used in an expression, the “result” will be the same type as the operand(s) having the largest representation. As a rule, any numeric type operand may be used in a expression that is expected to produce a result of type REAL. Expressions that must produce BYTE or INTEGER results must evaluate to a value that is small enough to fit the representation. BASIC09 has a complete set of functions that can perform compatible type conversion. Type-mismatch errors are reported by the second compiler pass when leaving Edit mode.

Operators take two operands (except negation) and cause some operation to be performed producing a result, which is generally the same type as the operands (except comparisons). The table below lists the operators available and the types they accept and produce. “NUMERIC” refers to either BYTE, INTEGER, or REAL types.

When comparing strings, the ASCII collating sequence is used, so that 0 < 1 < ... < 9 < A < B< ... < Z < a < b< ... < z

Functions take one or more arguments enclosed in parentheses, perform some operation, and return a value. They may be used as operands in expressions. Functions expect that the arguments passed to them be expressions, constants, or variables of a certain type and return a result of a certain type. Giving a function, an argument of an incompatible type will result in an error.

In the descriptions of functions that follow, the following notation describes the type required for the parameter expressions:

The functions below return REAL results. Accuracy of transcendental functions is 8+ decimal digits. Angles can be either degrees or radians (see DEG/RAD statement descriptions).

The following functions can return any numeric type, depending on the type of the input parameter(s).

The following functions can return results of type INTEGER or BYTE:

The following functions perform bit-by-bit logical operations on integer or byte data types and return INTEGER results. They should not be confused with the BOOLEAN-type operators.

These functions return a result of type STRING:

The following functions return BOOLEAN values:

Each BASIC09 can be a complete program in itself, or several procedures that call each other can be used to create an application program. It is up to the programmer to decide which approach to take. One procedure may suffice for small programs but large programs are easier to write and test if divided into separate modules (procedures) according to the program's natural flow. These suggestions reflect sound structured programming practice. Nonetheless, you can use a single large procedure for your program if you so desire.

A procedure consists of any number of program statement lines. Each line can have an optional line number, and more than one program statement can be placed on the same line if separated by “\” characters. For example, the following statements are equivalent:

The maximum input line length is 255 characters. Line feeds can be used to make a single long line into shorter lines to fit display screens better. This is especially useful when working on hard-copy terminals.

Program statements can be in any order consistent with program logic Program readability is improved if all variables are declared with DIM statements at the beginning of the procedure, but this is not mandatory. The program can be terminated with END or STOP statements, which are also optional.

Line numbers are optional. They can be any integer number in the range of 1 to 32767. Only use line numbers where absolutely necessary (such as with GOSUB). They make programs harder to understand, use additional memory space, and increase compile time considerably. Line numbers are local to procedures. i.e., the same line number can be used in different procedures without conflict.

Assignment statements are used for computing or initializing of variables.

[LET] var := expr
[LET] var = expr
[LET] struct := struct
[LET] struct = struct

A := 0.1

value := temp/sin(x)

DIM array1(100), array2(100)
array1 := array2

LET AUTHOR$ := FIRST_NAME$ + LAST_NAME$

DIM truth,lie:BOOLEAN
lie := 100 < 1
truth := NOT lie

count = total-adjustment
matrix(2).coefficient(n+2) := matrix(1).coefficient(n)

POKE integer expr , byte expr

POKE ADDR(buffer)+5,ASC("A")

POKE 1200,14

POKE $1C00,$FF

POKE pointer,PEEK(pointer+1)

(* alternative to: alphabet$ := "ABCDEFGHIJKLMNOPQRSTUVWXYZ" *)
FOR i=0 to 25
  POKE ADDR(alphabet$)+i,$40+i
NEXT i
POKE ADDR(alphabet$)+26,$FF

This class of statements affect the (usually) sequential execution of program statements. They are used to construct loops or make decisions that alter program flow. BASIC09 provides a selection of looping statements that allow you to create any kind of loop using sound structured programming style.

IF bool expr THEN line #

IF payment < balance then 400

IF bool expr THEN statements
[ ELSE statements ]
ENDIF

IF a < b THEN
  PRINT "a is less than b"
  PRINT "a:";a;" b:";b
ENDIF

IF a < b THEN
  PRINT "a is less than b"
ELSE
  IF a=b THEN
    PRINT "a equals b"
  ELSE
    PRINT "a is greater than b"
  ENDIF
ENDIF

FOR var = expr TO expr [ STEP expr ]
NEXT var

FOR counter = 1 to 100 step .5
  PRINT counter
NEXT counter


FOR var = min-1 TO min+max STEP increment-adjustment
  PRINT var
NEXT var


FOR x = 1000 TO 1 STEP -1
  PRINT x
NEXT x

WHILE bool expr DO
ENDWHILE

WHILE a<b DO     is equivalent to     100 IF a>=b THEN 500
  PRINT a                                 PRINT a
  a := a+1                                a := a+1
ENDWHILE                                  GOTO 100
                                         500 REM

DIM yes:BOOLEAN
yes=TRUE
WHILE yes DO
  PRINT "yes!  ";
  yes := POS<50
ENDWHILE

REM reverse the letters in word$
backward$ := ""
INPUT word$
WHILE LEN(word$) > 0 DO
  backward$ := backward$ + RIGHT$(word$,1)
  word$ := LEFT$(word$,LEN(word$)-1)
ENDWHILE
word$ := backward$
PRINT word$

REPEAT
UNTIL bool expr

x = 0            is the same as        x=0
REPEAT                             100 PRINT x
  PRINT x                              x=x+1
  x=x+1                                IF X <= 10 THEN 100
UNTIL x>10

(* compute factorial: n! *)
temp := 1.
INPUT "Factorial of what number? ",n
REPEAT
  temp := temp * n
  n := n-1
UNTIL n <= 1.0
PRINT "The factorial is "; temp

LOOP
ENDLOOP

EXITIF bool expr THEN statements
ENDEXIT

LOOP                 is equivalent to   100 REM top of loop
  count=count+1                             count=count+1
EXITIF count >100 THEN                      IF COUNT <= 100 then 200
  done = TRUE                               done = TRUE
ENDEXIT                                     GOTO 300
  PRINT count                           200 PRINT count
  x = count/2                               x = count/2
ENDLOOP                                     GOTO 100
                                        300  REM out of loop

INPUT x,y
LOOP
  PRINT
EXITIF x < 0 THEN
  PRINT "x became zero first"
ENDEXIT
  x := x-1
EXITIF y < 0 THEN PRINT "y became zero first"
ENDEXIT
  y := y-1
ENDLOOP

GOTO line #

GOTO 1000

GOSUB line #
RETURN

    FOR n := 1 to 10
      x := SIN(n)
      GOSUB 100
    NEXT n
    FOR m := 1 TO 10
      x := COS(m)
      GOSUB 100
    NEXT m
    STOP

100 x := x/2
    PRINT x
    RETURN

ON int expr GOTO line # {,line #}
ON int expr GOSUB line # {,line #}

   (* spell out the digits 0 to 9 *)
   DIM digit:INTEGER
   A$="one digit only, please"
   INPUT "type in a digit"; digit
   ON digit+1 GOSUB  10,11,12,13,14,15,16,17,18,19
   PRINT A$
   STOP

   (* names of digits *)
10 A$ := "ZERO"
   RETURN
11 A$ := "ONE"
   RETURN
12 A$ := "TWO"
   RETURN
13 A$ := "THREE"
   RETURN
14 A$ := "FOUR"
   RETURN
15 A$ := "FIVE"
   RETURN
16 A$ := "SIX"
   RETURN
17 A$ := "SEVEN"
   RETURN
18 A$ := "EIGHT"
   RETURN
19 A$ := "NINE"
   RETURN

ON ERROR [ GOTO line # ]

   (* List a file *)

   DIM path,errnum: INTEGER, name: STRING[45], line: STRING[80]
   ON ERROR GOTO 10
   INPUT "File name? "; name
   OPEN #path,name:READ
   LOOP
     READ #path, line
     PRINT line
   ENDLOOP

10 errnum=ERR
   IF errnum = 211 THEN
     (* end-of-file *)
     PRINT "Listing complete."
     CLOSE #path
     END
   ELSE
     (* other errors *)
     PRINT "Error number "; errnum
     END
   ENDIF

Execution statements run procedures, stop execution of procedures, create shells, or affect the current execution of the procedure.

RUN proc name [ (param {,param}) ]
RUN string var [ (param {,param}) ]

+----------------------+         ^
|                      |         |
                          higher addresses

|  more parameters     |

|                      |
+----------------------+        ---
|                      |         |
|  size of 1st param   |         |
+  -  -  -  -  -  -  - +      4 bytes
|  addr  of 1st param  |         |
|                      |         |
+----------------------+        ---
|                      |         |
|  parameter count     |      2 bytes
|                      |         |
+----------------------+        ---
|                      |         |
|  return address      |      2 bytes
|                      |         |
+----------------------+        ---  <- 6809 Stack Pointer
                                        Register value

PROCEDURE trig_table
num1 := 0 \ num2 := 0
REPEAT
  RUN display(num1,SIN(num1))
  RUN display(num2,COS(num2))
  PRINT
UNTIL num1 > 1
END

PROCEDURE display
PARAM passed,funcval
PRINT passed;":";funcval,
passed := passed + 0.1
END

  KILL str expr

LET procname$="average"
RUN procname$
KILL procname$

INPUT "Which test do you want to run? ",test$
RUN test$
KILL test$

CHAIN str expr

CHAIN "ex BASIC09 menu"

CHAIN "BASIC09 #10k sort (""datafile"",""tempfile"")"

CHAIN "DIR /D0"

CHAIN "Dir; Echo *** Copying Directory ***; ex basic09 copydir"

SHELL str expr

SHELL "copy file1 file2"            sequential execution

SHELL "copy file1 file2&"           concurrent execution

SHELL "edit document"               calling text editor

SHELL "asm source o=obj ! spool &"  concurrent assembly

N:=5
SHELL "kill "+STR$(N)

file$ := "/d1/batch_jobs"           concurrent execution of a
SHELL file$ + " -p >/p &"           batch procedure file

END [output list]

END

END "I have finished execution"

STOP [output list]

BYE

ERROR(integer expr)

PAUSE [output list]

output BREAK IN PROCEDURE procedure name

PAUSE

PAUSE "now outside main loop"

CHD str expr
CHX str expr

DEG
RAD

BASE 0
BASE 1

TRON
TROFF

REM chars
(* chars [ *) ]

REM this is a comment

(* This is also a comment *)

(* This is another kind of comment

The DIM, PARAM, and TYPE statements are called declarative statements because they are used to define and/or declare variables, arrays, and complex data structures. The DIM and PARAM statements are almost identical, the difference being that DIM are used to declare storage used exclusively within the procedure, and the PARAM statement is used to declare variables received from another calling procedure.

When do you need to use the DIM statement? You don't need to for simple variables of type REAL because this is the default format for undeclared variables. You also don't need to for 32-character STRING type variables (any name ending with a “$” is automatically assigned this type). Even though you don't have to declare variables in these two cases, you may want to anyway to improve your program's internal documentation. Those things you must declare are:

The TYPE statement does not really create variable storage. Its purpose is to describe a new data structure type that can be used in DIM or PARAM statements in addition to the five atomic data types built-in to BASIC09. Therefore, TYPE is only used in programs that use complex data structures.

DIM decl seq {; decl seq}
decl seq := decl {, decl} [: type ]
decl := name [ subscript ]
subscr := ( const [,const [,const]] )
type := BYTE | INTEGER | REAL | BOOLEAN |
 STRING | STRING max len | user defined type
user def := user defined by TYPE statement

DIM logical:BOOLEAN

DIM a,b,c: STRING

DIM a,b,c:INTEGER; n,m:decimal; x,y,z:BOOLEAN

DIM name:STRING[40]; address,city:STRING; zip:REAL

DIM a(10),b(20,30),c:INTEGER; x(5,5,5):STRING[12]

TYPE link_pointers = fwd,back: INTEGER
TYPE element = data: STRING[64]; ptr: link_pointers
DIM list(100): element

(* make a circular list *)
BASE0
FOR index := 0 TO 99
  list(index).data := "secret message " + STR$(index)
  list(index).ptr.fwd := index+1
  list(index).ptr.back := index-1
NEXT index
(* fix the ends *)
list(0).ptr.back := 99
list(99).ptr.fwd := 0

(* Print the list *)
index=0
REPEAT
  PRINT list(index).data
  index := list(index).ptr.fwd
UNTIL index=0
END

TYPE type decl {; type decl}
type decl := field name . decl : type}
decl := name [, subscript ]
subscript := ( const [,const [,const]] )
type := BYTE | INTEGER | REAL | BOOLEAN |
 STRING | STRING [max len] | user defined
user defined := user defined by TYPE statement

TYPE cust_recd := name,address(3):STRING; balance

DIM customer_file(250):cust_recd

name$ = customer_file(35).name
customer_file(N+1).address(3) = "New York, NY"
customer_file(X).balance= 125.98

A file is a logical concept for a sequence of data which is saved for convenience in use and storage. File data may be pure binary data, textual data (ASCII characters), or any other useful information. Hardware input/output (“I/O”) devices used by OS-9 also work like files, so you can generally use any I/O facility regardless of whether you are working with disk files or I/O devices such as printers. This single interface standard for any device and simple communication facilities allow any device to be used with any other device. This concept is known as “unified I/O”. Note that unified I/O can benefit routine programming. For example: file operations can be debugged by communicating with a terminal or printer instead of a storage device, and procedures which normally communicate with a terminal can be tested with data coming from and sent to a storage device.

BASIC09 normally works with two types of files: sequential files and random-access files.

A sequential file sends or receives (WRITE/READ) textual data only in order. It is not generally possible to start over at the beginning of a sequential file once a number of bytes have been accessed (many I/O devices such as printers are necessarily sequential). A sequential file contains only valid ASCII characters; the READ and WRITE commands perform format conversion similar to that done automatically in INPUT and PRINT commands. A sequential file contains record-delimiter characters (carriage return) which separate the data created by different WRITE operations. Each WRITE command will send a complete sequential-file record, which is an arbitrary number of characters terminated by a carriage return. Each READ reads all characters up to the next carriage return.

A random-access file sends and receives (PUT/GET) data in binary form exactly as it is internally represented in BASIC09. This minimizes both the time involved in converting the data to and from ASCII representation, as well as reducing the file space required to store the data. It is possible to PUT and GET individual bytes, or a substructure of many bytes (in a complex structure). The GET structure statement merely recovers the number of bytes associated with that type of structure. It is possible to move to a particular byte in a random-access file (using SEEK) and to begin to PUT or GET sequentially from that point (in general, “SEEK #path,0” is equivalent to the REWIND used in some forms of BASIC). Since the random-access file contains no record-separators to indicate the size of particular elements of the file, the programmer should use the SIZE function to determine the size of a single element, then use SEEK to move to the desired element within the file.

A new file is made on a storage device by executing CREATE. Once a file exists, the OPEN command is used to notify the operating system to set up a channel to the desired device and return that path number to the BASIC09 program. This channel number is then used in file-access operations (e.g., READ, WRITE, GET, PUT, SEEK, etc.). When the programmer is finished with the file, it should be terminated by CLOSE to assure that the file system has updated all data back onto magnetic media.

A “path” is a description of a “channel” through which data flows from a given program outward or from some device inward. In order for data to flow to or from a device, there must be an associated OS-9 device driver — see the OS9 User's Manual. When a path is created, OS-9 returns a unique number to identify the path in subsequent file operations. This “path number” is used by the I/O statements to specify the file to be used. Three path numbers have special meanings because they are “standard I/O paths” representing BASIC09's interactive input/output (your terminal). These are automatically “opened” for you and should not be closed except in very special circumstances. The standard I/O path numbers are:

The table below is a summary of the I/O statements within BASIC09 and their general usage. This reflects typical usage; most statements can be used with any I/O device or file. Sometimes certain statements are used in unusual ways by advanced programmers to achieve certain special effects.

INPUT [#int expr,] ["prompt",] input list

**INPUT ERROR - RETYPE**

INPUT number,name$,location

INPUT #14, "What is your selection", choice

INPUT "What's your name? ",name$

DIM char:STRING[1]
GET #0,char

PRINT output list
PRINT #int expr, output list
PRINT USING str expr, output list
PRINT #int expr, USING str expr, output list

PRINT value,temp+(n/2.5),location$

PRINT #printer_path,"The result is "; n

PRINT "what is " + name$ + "'s age? ";

PRINT "index: ";i;TAB(25);"value:  ";value

PRINT USING "R10.2,X2,R5.3",x,y

PRINT #outpath USING fmt$,count,value

(* print an 80-character line of all dashes *)
REPEAT
  PRINT "-";
UNTIL POS >= 80
PRINT

OPEN #int var,"str expr" [ : access mode ]
access mode := mode ! mode + access mode
mode := READ ! WRITE ! UPDATE ! EXEC ! DIR

DIM printer_path:BYTE; name:STRING[24]
name="/p"
OPEN #printer_path,name:WRITE
PRINT #printer_path,"Mary had a little lamb"
CLOSE #printer_path

DIM inpath:INTEGER
dev$="/winchester/"
INPUT name$
OPEN #inpath,dev$+name$:READ

OPEN #path:userdir$:READ+DIR

OPEN #path,name$:WRITE+EXEC

CREATE #int var,"str expr" [ : access mode ]
access mode := mode ! mode + access mode
mode := WRITE ! UPDATE ! EXEC

CREATE #trans,"transactions":UPDATE

CREATE #spool,"/user4/report":WRITE

CREATE #outpath,name$:UPDATE+EXEC

CLOSE #int expr {,#int expr}

CLOSE #master,#trans,#new_master

CLOSE #5,#6,#9

CLOSE  #1          \(* closes standard output path *)
OPEN #path,"/T1"   \(* Permanently redirects Std Output *)

CLOSE #0            \(* closes standard input path *)
OPEN #path,"/TERM"  \(* Permanently redirects Std Input *)

DELETE str expr

DELETE "/D0/old_junk"

name$="file55"
DELETE name$
DELETE "/D2/"+name$      (deletes file named "/D2/file55")

SEEK #int expr num,real expr

SEEK #path,0

SEEK #fileone,filptr*2

SEEK #outfile,208894

SEEK #inventory,(part_num - 1) * SIZE(inv_rcd)

WRITE #int expr,output list

WRITE #outpath,cat,dog,mouse

WRITE #xfile,LEFT$(A$,n),count/2

READ #int expr num,input list

READ #inpath,name$,address$,city$,state$,zip

PRINT #1,"height,weight? "
READ #0,height,weight

GET #expr,struct name
PUT #expr,struct name

TYPE inv_item=name:STRING[25];list,cost:REAL;qty:INTEGER

DIM inv_array(100):inv_item
DIM work_rec:inv_item

SIZE(name)

PROCEDURE makefile
TYPE inv_item = name:STRING[25]; list,cost:REAL; qty:INTEGER
DIM inv_array(100):inv_item
DIM work_rec:inv_item
DIM path:byte
CREATE #path,"inventory"
work_rec.name = ""
work_rec.list := 0.
work_rec.cost := 0.
work_rec.qty := 0
FOR n = 1 TO 100
  PUT #path,work_rec
NEXT n
END

INPUT "Record number ?",recnum
INPUT "Item name? ",work_rec.name
INPUT "List price? ",work_rec.list
INPUT "Cost price? ",work_rec.cost
INPUT "Quantity? ",work_rec.qty
SEEK #path, (recnum - 1) * SIZE(work_rec)
PUT #path,work_rec

SEEK #path,0 \ (* "rewind" the file *)
FOR k = 1 TO 100
  GET #path,inv_array(k)
NEXT k

SEEK #path,0
GET #path,inv_array

BASIC09 has a powerful output editing capability useful for report generation and other applications where formatted output is required. The output editing uses the PRINT USING statement which has the following syntax:

PRINT [expr#,] USING str expr , output list

The optional path number expression can be used to specify the path number of any output file or device. If it is omitted, the output is written to the standard output path (usually the terminal).

The string expression is evaluated and used as a “format specification” which contains specific formatting directives for each item in the “output list”. The items in the output list can be constants, variables, or expressions of any atomic type. Blanks are not allowed in format strings! As each output item is processed, it is matched up with a specification in the format list. The type of each expression result must be compatible with the corresponding format specification. If there are fewer format specifications than items in the output list, the format specification list is repeated again from its beginning as many times as necessary.

A format string has one or more format specifications which are separated by commas. There are two kinds of specifications: ones that control output editing of an item from the output list, and ones that cause an output function by themselves (such as tabbing and spacing). There are six basic output editing directives. Each has a corresponding one-letter identifier:

The identifier letter is followed by a constant number called the “field width”. This number indicates the exact number of print columns the output is to occupy and must allow for the data and “overhead” character positions such as sign characters, decimal points, exponents, etc. Some formats have additional mandatory or optional parameters that control subfields or select editing options. One of these options is “justification” which specifies whether the output is to “line up” on the left, right side, or center of the output field. Fields are commonly right-justified in reports because it arranges them into neat columns with decimal points aligned in the same position.

The abbreviations and symbols used in the syntax specifications are:

Rw.fj

PRINT USING "R8.2", 12.349  gives    12.35

PRINT USING "R8.2<",5678.123          5678.12
PRINT USING "R8.2>",12.3                   12.30
PRINT USING "R8.2<",-555.9            -555.90
PRINT USING "10.2^",-6722.4599            6722.46-
PRINT USING "R5.1","9999999"            *****

Ew.fj

PRINT USING "E12.3",1234.567               1.235E+03

PRINT USING "E12.6>",-0.001234            -1.234000E-3

Iwj

PRINT USING "I4<",10         10

PRINT USING "I4>",10             10

PRINT USING "I4^",10             010

Hwj

PRINT USING "H4",100               00C4

PRINT USING "H4",-1                FFFF

PRINT USING "H10",1.5              01D0000000

PRINT USING "H8","ABC"             414243

Swj

PRINT USING "S8<","HELLO"         HELLO

PRINT USING "S8>","HELLO"               HELLO

PRINT USING "S8^","HELLO"             HELLO

Bwj

PRINT USING "'addr',X2,H4,X2,'data',X2,H2",1000,100     prints

addr  03E8  data  C4

"2(X2,R10.5)" is the same as  "X2,R10.5,X2,R10.5"

"2(I2,2(X1,S4))" is the same as "I2,X1,S4,X1,S4,I2,X1,S4,X1,S4"
 

The BASIC09 multipass compiler produces a compressed and optimized low-level “I-code” for execution. Compared to other BASIC languages program storage is greatly decreased and execution speed is increased.

High-level language interpreters have a general reputation for slowness which is probably not deserved. Because the BASIC09 I-code is kept at a powerful level, a single, fast I-code interpretation will so that there is often result in many MPU instruction cycles (such as execution of floating-point arithmetic operations). Thus, for complex programs there is little performance difference between execution of I-code and straight machine-language instructions. This is generally not the case with traditional BASIC interpreters that have to “compile” from text as they run or even “tokenized” BASICs that must perform table-searching during execution. BASIC09 I-code instructions that reference variable storage, statements, labels, etc., contain the actual memory addresses so no table searching is ever required. Off course, BASIC09 fully exploits the power of the 6809's instruction set which was optimized for efficient execution of compiler-produced code.

Because the BASIC09 I-code is interpreted, a variety of entry-time tests and run-time tests and development aids are available to help in program development; aids not available on most compilers. The editor reports errors immediately when they are entered, the debugger allows debugging using the original program source statements and names, and the I-code interpreter performs run-time error checking of things such as array bound errors, subroutine nesting, arithmetic errors, and other errors that are not detected (and usually crash) native-compiler-generated code.

Because BASIC09 includes several different numeric representations (i.e., REAL, INTEGER, and BYTE) and does “automatic type conversions” between them, it is easy to write expressions or loops that take at least ten times longer to execute than is necessary. Some particular BASIC09 numeric operators (+, -, *, /) and control structures (FOR..NEXT) include versions for both REAL and INTEGER values. The INTEGER versions, off course, are much faster and may have slightly different properties (e.g., INTEGER divides discard any remainder). Type conversions takes time so expressions whose operands and operators are of the same type are more efficient.

BASIC09's REAL (floating point) math package provides excellent performance. A special 40-bit binary floating point representation designed for speed and accuracy was developed especially for BASIC09 after exhaustive research. The new CORDIC technique is used to derive all transcendental functions (SIN, TAN, LOG, EXP, etc.). This integer shit-and-add technique is faster and more consistently accurate than the commonly used series-expansion approximations.

Nonetheless, INTEGER operations are faster because they generally have corresponding 6809 machine-language instructions. Overall program speed will increase and storage requirements will decrease if INTEGERs are used whenever possible. INTEGER arithmetic operations use the same symbols as REAL but BASIC09 automatically selects the INTEGER operations when working with an integer-value result. Only if all operands of an expression are of types BYTE or INTEGER will the result also be INTEGER.

Sometimes, similar or identical results can be obtained in a number of different ways at various execution speeds. For example, if the variable “value” is an integer, then “value*2” will be a fast integer operation. However, if the expression is “value*2.0” the value “2.0” will be represented as a REAL number, and the multiplication will be a REAL multiplication. This will also require that the variable “value” will have to be transformed into a REAL value, and finally the result of the expression will have to be transformed back to an INTEGER value if it is to be assigned to a variable of that type. Thus a single decimal point will slow this particular operation down by about ten times!

This table can be used to deduce some interesting points. For example, “value*2” is not optimum - “value+value” can produce the same result in less time because multiplication takes longer than addition. Similarly, “value*value” or “SQ(value)” is much faster than the equivalent “value^2”. Another interesting case is “x/2.0”. The REAL divide will cost 3870 cycles, but REAL multiplication takes only 990 cycles. The mathematical equivalent to division by a constant is multiplication by the inverse of the constant. Therefore, using “X*0.5” instead is almost four times faster!

When BASIC09 identifies a FOR..NEXT loop structure with an INTEGER loop counter variable, it uses a special integer version of the FOR..NEXT loop. This is much faster than the REAL-type version and is generally preferable. Other kinds of loops also run faster if INTEGER type variables are used for loop counters.

When writing program loops, remember that statements inside the loop may be executed many times for each single execution outside the loop. Thus, any value which can be computed before entering a loop will increase program speed.

BASIC09 internally uses INTEGER numbers to index arrays and complex data structures. If the program uses subscripts that are REAL type variables or expressions, BASIC09 has to convert them to INTEGERs before they can be used. This takes additional time, so use INTEGER expressions for subscripts whenever you can.

Note that the assignment statement (LET) can copy identically sized data structures. This feature is much faster than copying arrays or structures element-by-element inside a loop.

The PACK command produces a compressed version of a BASIC09 procedure. Depending on the number of comments, line numbers, etc., programs will execute from 10% to 30% faster after being packed. Minimizing use of line numbers will even speed up procedures that are unPACKed.

Consider the expression:

x = x+SQRT(100)/2

is exactly the same as the expression:

x = x+5

The subexpression “SQRT(100)/2” consists of constants only, so its result will not vary regardless of the rest of the program. But every time the program is run, the computer must evaluate it. This time can be significant, especially if the statement is within a loop. Constant expressions or subexpressions should be calculated by the programmer while writing the program (using DEBUG mode or a pocket calculator).

Reading or writing data a line or record at a time is much faster than a character at a time. Also, the GET and PUT statements are much faster than READ and WRITE statements when dealing with disk files. This is because GET and PUT use the exact binary format used internally by BASIC09. READ, WRITE, PRINT, and INPUT must perform binary-to-ASCII or ASCII-to-binary conversions which take time.

One sure way to make a program faster is to use the most efficient algorithms possible. There are many good programming “cookbooks” that explain useful algorithms with examples in BASIC or PASCAL. Thanks to BASIC09's rich vocabulary you can use algorithms written in either language with little or no adaptation.

BASIC09 also eliminates any possible excuse for not using good structured programming style that produces efficient, reliable, readable, and maintainable software. BASIC09 generates optimized code to be executed by the 6809 which is the most powerful 8-bit processor in existence at the time of this writing. But a computer can only execute what it is told to execute, and no language implementation can make up for an inefficient program. An inefficient program is evidence of a lack of understanding of the problem. The result is likely to be hard to understand and hard to update if program specifications change (they always do). The identification of efficient algorithms and their clear, structured expression is indicative of professionalism in software design and is a goal in itself.