NEXT in SmileBasic V1 are identical to those in V2.
NEXT are commands that cause the code between them to be run one or more times.
FOR is followed by a variable name, the
= symbol, a numerical expression, the
TO keyword, and another numerical expression (and optionally, the
STEP keyword and a third numerical expression).
NEXT is either a complete command by itself, or it is followed by a variable name.
Most commonly, it is used like the following:
FOR I=1 TO 10 ' Code to be repeated 10 times NEXT I
The interior of the loop is executed once with the variable
I containing the value 1, then it is executed once with
I equal to 2, etc., and on its final loop
I is equal to 10. If the interior of the loop were
PRINT I, the loop as a whole would print all the integers from 1 to 10 inclusive. This makes it easy to initialize an array:
' I want an array with 20 elements. DIM A(20) ' Right after DIM, all elements are essentially initialized to 0. ' I want them all initialized to the value 5. FOR I=0 TO 19 A(I)=5 NEXT I ' The array is now initialized with all elements equal to 5.
If you wish to 'count by' some value other than 1, use the
FOR A=0 TO 10 STEP 2 'Inside this loop, A will have the values 0, 2, 4, 6, 8, 10 NEXT A FOR B=0 TO 2 STEP 0.5 ' Inside this loop, B will have the values 0, 0.5, 1, 1.5, 2 NEXT B
It can also count down, using a negative
FOR X=4 TO -4 STEP -2 ' Inside this loop, X will have the values 4, 2, 0, -2, -4 NEXT X
Technically, when a
FOR is encountered, the location in program memory is added to a stack, the expression before
TO is evaluated, and that value is assigned to the variable.
NEXT is encountered, and there is a variable name after it, the variable name at the
FOR at the top of the stack is compared against it. If there is a mismatch of variable names, the system generates a
FOR without NEXT (FOR) error.
If there is no variable name mismatch, the expression after
TO is evaluated, then the expression after
STEP is evaluated (or if there is no
STEP, the value 1 is used). The
STEP value is added to the variable. If the
STEP value is zero or positive and the variable is not greater than the
TO value, the program goes back to the command just after the
FOR. If the
STEP value is negative and the variable is not less than the
TO value, the program also goes back to the command just after the
FOR. If neither of these conditions apply, the top of the stack is removed, and the program continues at the command after the
It is worth noting that the variable will always contain the value before
TO at least once, at the beginning of the first loop, but there is no guarantee it will ever contain the value after
FOR INT=1 TO 5.5,
FOR ODD=1 TO 10 STEP 2.
It is also worth commenting on the consequences of the
STEP expressions being evaluated each loop. Evaluating the
TO each time means the following code:
B=5 FOR A=1 TO B PRINT A B=B+0.5 NEXT A
will not print 5 times, as you might expect from just looking at the first two lines; it will print 9 times. Evaluating the
STEP each time allows for a neat structure rather like a REPEAT loop - where another dialect of BASIC might have
REPEAT code UNTIL condition
SmileBasic can have
FOR REPEAT=0 TO 0 STEP condition code NEXT REPEAT
Of course, nested loops usually must have unique variable names. For instance, consider the code:
FOR N=1 TO 10 code FOR N=1 TO 5 code NEXT N ' Point A NEXT N
N is otherwise modified in the inner loop, at Point A,
N will always be 6, and the outer loop will never terminate.
The stack space is only 255 elements deep, so at the very beginning of a program, you may have 255 consecutive
FORs, but the 256th will cause an
Out of memory (FOR) error. If a
NEXT is encountered when the
FOR-stack is empty, the system will generate a
NEXT without FOR (NEXT) error.
FOR stack memory is shared with the
GOSUB stack memory... so, if the very start of a program is a
GOSUB, you can only run 254 consecutive
FORs within that subroutine before getting an
Out of memory error. Any additions to the
FOR stack made in a subroutine, that are not removed in the normal way by the execution of a
NEXT ending the loop, are removed by the
RETURN. So, a single
RETURN can free up two or more spaces in the stack memory. In contrast, additions to the call stack made during a
FOR loop are not removed by a
No information on SmileBasic V3.