In most programming languages, a for loop is just a fancy while loop. Its syntax, as mentioned by randomouscrap, is usually as follows:
for (initializer; test; increment)
{
looping code;
}
In this code, all 3 expressions are completely independent:
The initializer can be any expression at all, but normally just sets a variable:
i = 0
The test can be
any boolean expression, but is normally a test of range:
i < 15
The increment can be any expression at all, but normally increments the variable:
i++
It is, for all intents and purposes, the exact same thing as:
initializer;
while(test)
{
looping code;
increment;
}(With the only exception that in this format, the initializer would create variables with a bigger scope than just the while loop)
The important thing to note about this definition of a for loop is that it is always concretely defined for any situation. If you change i inside the loop, there are no anomalies because the loop doesn't expect i to be anything specific - it just executes whatever expression
increment is and checks the boolean result of whatever expression
test is. It doesn't care about anything else.
For SmileBASIC, it's drastically different. The FOR loop is given a specific variable, an initial value, and a final value. The initializer is still quite simple, but the test is not standalone, and the increment is not standalone.
FOR I = 0 TO 9
NEXT
For the above loop, the following questions arise:
1. Is
I saved as an expression, or a specific variable?
2. If we change the value of I inside the loop, will it remember what state it was and jump to the next one at the next loop, or will it increment the new value by 1?
3. Is
9 saved as an expression, or a specific value that's only evaluated once?
The question that you've encountered is 1:
is I saved as an expression. Basically, I is a fairly simple, static expression that can always refer to just one variable. However, if you put in a more complicated expression such as A[J], the value of J can be changed and the resulting target variable (or in this case, array element) is a different one than it was before. A[J] is the expression referring to the Loop Variable, and it is NOT a static one so it can change.
The important thing to understand here is that when you use a FOR loop, it's usually for one of two reasons:
A. You're looping the same code a set number of times, known in advance
B. Same as A, but the code also needs to know how many times it's looped already, causing the code to be run in a slightly different way.
An easy example for A is:
FOR I = 1 TO 5
PRINT "HELLO WORLD!"
NEXT
Which would print HELLO WORLD! to the screen 5 times.
An easy example of B is:
FOR I = 1 TO 5
PRINT "Number "; I
NEXT
Which would print out:
Number 1
Number 2
Number 3
Number 4
Number 5
And a different example of B usage:
DIM A[5]
FOR I = 0 TO 4
A[I] = 40
NEXT
Which would create an array called A and initialize all its elements to the value 40.
In all of these examples, notice that the value of I is ONLY changed by the FOR loop, never by the code inside the loop.
Changing the value of the loop variable inside the loop is called undefined behavior - you're not supposed to do it, but it doesn't cause a crash. It is unknown whether it will do one thing or another - its actual result might be consistent, it might even be useful, but it was never intentionally designed to do that.
This brings us back to your example, which I've simplified below for convenience:
DIM A[5]
I = 0
FOR A[I] = 0 TO 4
PRINT I, A[I]
I = I + 1
NEXT
What are we doing here? Not only are we changing the loop variable - we're actually changing
what the loop variable IS. When we're done changing it, it's not the same array element that it was before - it's a different one altogether, it's a different memory address. This is even more undefined than changing the value of the variable mid-loop.
Again, it might have a consistent result and it might be useful, but it's UNDEFINED. It was never intended to ever encounter this scenario.
This is not a bug. When I read through the code you posted, I expected it to do exactly what you said it ended up doing.
TL;DR as mentioned already, the loop variable is
A[J], and not J. If you want it to be J, you write it as J, not A[J]. I hope I haven't made too much of a mess.
