DO...LOOP
WHILE...WEND

DO
 .
 . (statements)
 .
LOOP UNTIL condition

WHILE condition
 .
 . (statements)
 .
WEND

To create a conditional loop.

There are several ways to make statements loop in QBasic, and two of them are the DO...LOOP and WHILE...WEND statements. The only significant difference between these two looping structures is that WHILE...WEND checks the condition before running the loop, and DO...LOOP checks the condition only after the loop has executed once:

 WHILE x < 3
 x = x + 1
 PRINT x
 WEND

 DO
 x = x - 1
 PRINT x
 LOOP UNTIL x <= 0

Output:

 1
 2
 3
 2
 1
 0

In the example, the WHILE...WEND structure would run only as long as x was less than 3. Since x was being incremented inside the loop, the loop does not repeat again after the "x = x + 1" assignment that set x to 3. Then in the DO...LOOP structure, the variable "x" is decremented each cycle. In the first cycle, the value of x is changed from 3 to 2 and printed. Since x = 2 which is not less <= 0, the program will repeat the loop.

Notice that the form of the condition is inverted for these two loops. In the WHILE...WEND statement, the loop executes as long as the condition is true. In the DO....LOOP statement, the loop executes as long as the condition is false, exiting only when the condition is true. The WHILE...WEND condition could be said to be keeping the loop going, and the DO...LOOP condition could be said to be trying to find an exit.

At some time you may need to use a WHILE of DO loop, but the condition is inverse to what you want. Simply use the NOT keyword to adjust the condition. For example, if you want a WHILE...WEND to execute until a condition is met put a "NOT" in front of it:

 WHILE NOT (a = 5)
 a = a + 1

FOR...NEXT

FOR variable = range1 TO range2 [STEP interval]
 .
 .
 .
NEXT variable

To execute statements multiple times, causing the variable used to cycle through values as specified.

One of the most time saving commands (both programming time and processing time) is the FOR...NEXT command. A single FOR...NEXT loop executes a group of statements multiple times as specified. For each loop, the variable used holds the value of the state of the loop:

Output:

The variable `T' was put into a loop, increasing by 1 (default) for each time the cycle was run. Any commands inside the FOR...NEXT loop that depend on the variable `T' are affected. In the above example when the PRINT command displayed the value of `T' it had incremented by one for each time around the loop.

The loop does not always have to start at 1. The increment value does not have to be 1 either, nor does it have to be positive or even an integer. The following example shows the different abilities of FOR...NEXT loops:

The value of the variable does not have to be used by the statement within the loop, as demonstrated by the last FOR...NEXT loop example. Loops may be placed within each other, as long as different variables are used. This is called "nesting".

The loops must be resolved with NEXT in the reverse order that they are used in. Remember that FOR...NEXT loops are statements as any other, so more commands than just another loop may exist in a FOR...NEXT nested loop situation:

Many loops can be nested within eachother in any combinations, as long as a loop is terminated before the loop in which it is nested terminates. In other words:

 WEND

For a very interesting reason about which I'm not going to tell you here, you must have the condition in parentheses if you wish to have "NOT" in front of it.

GOTO

GOTO linenumber | linelabel

Manual branching from one location fo a program to another.

The GOTO statement has been the maker and breaker of programs since the beginning of programming. Used incorrectly, they make a mess of code and tourbleshooting becomes almost impossible. Used properly (meaning, very seldom in QBasic) and they save lots of brainpower at figuring a better program flow scheme.

More simply put, GOTO makes QBasic run lines of commands in an order different from how they are written. GOTO requires that a line label be implemented at some point in the code as a destination. This line label MUST be within the same subroutine, funtion, or main program. GOTO cannot branch from a subroutine to the main program or another subroutine or function, and vice-versa. In QBasic, the line label can be either a number, a word, or a combination of the two as long as it is unique within the program.

 PRINT "Line of text #1"
 GOTO 10
 PRINT "This line gets skipped"
 10:
 PRINT "Line of text #2"
 PRINT
 GOTO abcd
 PRINT "QBasic will not execute this line either"
 abcd:
 PRINT "Line of text #3"

Output:
 Line of text #1
 Line of text #2

 Line of text #3

ON ERROR GOTO
ERROR
RESUME

ON ERROR GOTO linelabel
RESUME linelabel | NEXT
ERROR number

ON ERROR GOTO is used to trap error events when the occur. RESUME tells where to resume the program flow once the error is handled. ERROR manually causes a simulation of a specific error, used mainly for troublshooting the error trapping code.

In most simple QBasic programs, there is no need for error handling code as long as potential errors are foreseen and protected against. Some examples of avoidable errors are: LOCATE x, y when x or y are 0 or too big, divisions by zero, and input past end of file. The the values of x and y can be checked before being used in LOCATE, the divisor can also be checked for the same thing, and the EOF() function signals that there is no more data in a file.

Some of the notoriously unpredictable errors are related to file input and output. For example, file not found, disk full, file already exists, and disk-media error are all errors that are unavoidablly caused by human error or hardware failure. To do a complete job as a programmer, any program that risks these errors must have error handling code.

To initiate error handling, the ON ERROR GOTO statement indicated where the program flow will go if there is any error during run-time of the program.

 ON ERROR GOTO Handle

When there is an error, program flow will be sent to the line lable "Handle", which must be located within the main program body (not a subroutine or function). The error handling code will the decide what will be done about the error. The response may need to be different for the different errors that happen. The ERR variable contains a code for the error last error that occurred. This variable can be used to run conditionals for the error handler:

 Handle:
 SELECT CASE ERR
 CASE 53: PRINT "That file does not exist"
 CASE 71: PRINT "Disk is not ready"
 CASE 76: PRINT "That path does not exist"
 .
 .
 .
 CASE ELSE: PRINT "Unrecoverable error. Ending program."
 END
 END SELECT 
 RESUME NEXT

In the above error handler, certain error codes are recognized, appropriate error messages are given for them, and the program continues. If the error code is not one that is recognized by the error handler, the "unrecoverable error" message is printed and the program ends.

A problem arises when the program flow is returned to the point of the error. When the program is trying to open a file and the File Not Found error happens, there is nothing that will signal to the lines after the error that there is something wrong. An easy way to deal with this is to have a flag set that can be checked after a potential error causing command:

 'In the handler have the line...
 errorflag = 1

 'In the normal code...
 OPEN filename$ for INPUT AS #1
 IF errorflag = 1 then 
 errorflag = 0
 ELSE
 INPUT #1, variable
 .
 .
 .
 END IF

In the above code, the reading from the opened file only continues if the errorflag variable is not set. In the case that it is set, the code resets it to zero for its next use. In the above code, the errorflag variable must be a COMMON SHARED variable.

Sometimes you may need to cause an error manually in order to check your error code, or in some cases, just cause a fake error event to happen. The ERROR statement does just that.

 ERROR 53

This causes a "File Not Found" error. If there is event trapping, ERR will be equal to 53 and the code will execute. If there is no error trapping, the QBasic program will stop and the QBasic editor will display the error dialog box with "File not found".

There is one "error" code in QBasic that does not produce and actual error, but merely trips the error trapper. The error code is 97. You could simply use another error code, such as 53, for your manual interrupt, but then what if there is a real error 53? ERROR 97 is an error code that nothing in your program will cause, except for the ERROR statement. The use for ERROR 97 is good for cases where you want some code to execute from no matter where you are in the program. It is mmore powerful than a subroutine, because you can have the progrma return to the place where ERROR 97 ocurred with RESUME NEXT, OR you could have it proceed to set linelable with RESUME linelable. The application for this can be very handly, since you can then trigger a manual jump to the main program code without having to care about exiting through multiple levels of subroutines.

Now QBasic recognizes the command. In addition, it changed the word "input" to all capital letters because INPUT, like CLS, is a QBasic keyword. However, just because QBasic can now make sense of the line doesn't mean the line is correct. It only means that the line follows QBasic's syntax rules. You still have two misspelled words: "Whatis" and "yourr."

QBasic's text editor enables you to correct typing mistakes easily. First, use the arrow keys to position the flashing text cursor under the space between the words "yourr" and "name." Now press the Backspace key. Presto! The extra letter vanishes, and the rest of the line moves to the left to fill in the space you deleted.

You still have a mistake in the line, though. There should be a space between the words "What" and "is." Luckily, you can add characters to a line as easily as you can delete them. Use the arrow keys to position the blinking text cursor under the "i" in the word "Whatis" and then press the spacebar. When you do, a space character appears at the text cursor's position, and the rest of the line moves to the right.

Finish typing the program by adding the following lines. Remember to type them exactly as they're shown. To indent the line that starts with the word PRINT, start by typing two spaces.

FOR X = 1 TO 200
 PRINT Name$; " ";
NEXT X

Error Codes and Messages

    When error handling becomes important in your programs, you need to know which error codes are generated for each error. When an error occurrs and the ON ERROR event is trapped, the ERR variable contains the error code. Following is the list of what each error code means.

Error Code	Error Message
1	NEXT without FOR
2	Syntax Error
3	RETURN without GOSUB
4	Out of DATA
5	Illegal function call
6	Overflow
7	Out of memory
8	Label not defined
9	Subscript out of range
10	Duplicate definition
11	Division by zero
12	Illegal in direct mode
13	Type mismatch
14	Out of string space
16	String formula too complex
17	Cannot continue
18	Function not defined
19	No RESUME
20	RESUME without error
24	Device timeout
25	Device Fault
26	FOR without NEXT
27	Out of paper
29	WHILE without WEND
30	WEND without WHILE
33	Duplicate label
35	Subprogram not defined
37	Argument-count mismatch
38	Array not defined
39	CASE ELSE expected
40	Variable required
50	FIELD overflow
51	Internal error
52	Bad file name or number
53	File not found
54	Bad file mode
55	File already open
56	FIELD statment active
57	Device I/O error
58	File already exists
59	Bad record length
61	Disk full
62	Input past end of file
63	Bad record number
64	Bad file name
67	Too many files
68	Device unavailable
69	Communication-buffer overflow
70	Permission denied
71	Disk not ready
72	Disk-media error
73	Advanced feature unavailable
74	Rename across disks
75	Path/File access error
76	Path not found
97	(no error message)