Avoiding Exit Statements

Proper Use Of The Exit Keyword
The Exit Keyword is properly used when it is not used at all! Exiting spontaneously from a block of code is BAD programming practice because, following this Exit typically comes large areas of unexecuted code. This is almost like having an invisible If statement on the remainder of the procedure that you have to spend time actively searching for or keeping mental tabs on. Even worse cases arise when it is thrown into a series of block structures, making it even harder to find. Worst of all, it makes code harder to maintain/update because code that would normally execute doesn't, leaving you typically with results that you haven't checked. It is almost as bad as using the Goto keyword, except you don't have spaghetti code. In a grammatical analogy, Goto would be a run-on sentence, and Exit would be a fragment. Unfortunately, VB programmers seem to pick up this bad Exit habit a bit too early. The Exit keyword is only excusable for high-speed applications, where they can choke the rules to get every bit of speed gain.
Just like any loop that is formed using Goto can be resolved by using proper loops, any loop escape mechanism utilizing Exit can be restructured so that there is no Exit. There are only five ways to use Exit within VB6:
Exit Do
Exit For
Exit Function
Exit Property
Exit Sub
The last three are all very similar and will be treated as one case. The first two (Exit Do and Exit For) have their own special solutions which I will cover first, and afterwards, I'll cover Exit Function, Sub, and Property.
Resolving The Exit Do
Most of my encounters with Exit Do are within Do Loops that do not have Do or Loop escape conditions, such as:

Do
  Run Stuff, Something
  If Something = SomethingElse Then
    Exit Do
  End If
Loop

At first glance, you'd expect a Do loop with no Do or Loop escape condition to be an infinite loop, which is never good. But, you spot the Exit Do nestled snugly within the If block. This is quite a shame, because this is an easily fixable situation, but it shows complete disregard of built in Do Loop functionality. A Do Loop is designed to loop until or while a certain condition is true, and the escape conditions on the Do and Loop serve that purpose. It makes little sense to omit the escape conditions in favor of an unstructured Exit Do in the midst of the Do Loop. The remedy is simply placing the If condition as the escape condition on Loop:

Do
  Run Stuff, Something
Loop Until Something = SomethingElse

Some VB coders have not discovered the Until keyword, which is the negative of the While keyword. If you find the escape condition of your Loop (or your Do) consisting of While Not something or While somethingnegative, then you can easily do Until something or Until somethingpositive.
Another encounter of the Exit Do kind is similar to the first, except the condition comes first and other statements trail the Exit Do If block.

Do
  If Something = SomethingElse Then
    Exit Do
  End If
  Run Stuff, Something
Loop

This can be fixed by changing the If condition to the Do escape condition.

Do Until Something = SomethingElse Then
  Run Stuff, Something
Loop

The third Do Loop encounter is the most understandable. When the Exit Do lies between necessary code, it may seem that the Exit Do is the only alternative.

Do
  Correspond Stuff, Something
  If Something = SomethingElse Then
    Exit Do
  End If
  Run Stuff, Something
Loop

This can be solved by a technique that I call "loop unfolding" and, if I am not mistaken, compilers using optimization use this to simplify many loops. The principle is that every statement in the loop will be evaluated so you can take out (extract) as many copies from inside as you want and place them before the Do Loop. For our purpose, we only need one. Note that the following is a demonstration, not the steps required.

Correspond Stuff, Something
If Something = SomethingElse Then
  Exit Do
End If
Run Stuff, Something
Do
  Correspond Stuff, Something
  If Something = SomethingElse Then
    Exit Do
  End If
  Run Stuff, Something
Loop

Now, we have an Exit Do outside of the loop. In order to fix this, we need to insert statements back into the loop. We can only insert the statement closest to the Do Loop into the Do Loop. When we insert the statement back into the Do Loop, we get

Correspond Stuff, Something
If Something = SomethingElse Then
  Exit Do
End If
Do
  Run Stuff, Something
  Correspond Stuff, Something
  If Something = SomethingElse Then
    Exit Do
  End If
  Run Stuff, Something
Loop

and the last Run statement can be removed since the loop should return to execute it unless the escape condition is met.

Correspond Stuff, Something
If Something = SomethingElse Then
  Exit Do
End If
Do
  Run Stuff, Something
  Correspond Stuff, Something
  If Something = SomethingElse Then
    Exit Do
  End If
Loop

Next is the Exit Do in the If block. Notice that both Exit Do If blocks lie next to the ends of the Do Loop.
The Exit Do inside of the Do Loop could be turned into an escape condition on the Loop. However, the Exit Do that is outside of the loop would work better as an escape condition on the Do.
So, with the same condition on the Loop and the Do, which one should we keep since we can only keep one. The answer, according to "Escape condition Postulate One" is to keep the condition on the Do. Escape condition Postulate One (mine) states if escape conditions need to be applied to both the Do and the Loop line, then all escape conditions need to be moved to the Do line, because the Do always executes immediately after the Loop.
So, our new loop looks like this:

Correspond Stuff, Something
Do Until Something = SomethingElse
  Run Stuff, Something
  Correspond Stuff, Something
Loop

So, when the Exit Do is between code, the loop's inside needs to be restructured so that the code after the Exit Do comes first, the code before the Exit Do appears again outside of the loop (sometimes loops need to be initialized, as in the For Loop to Do Loop transformation below), and the Exit Do condition appears as the escape condition on the Do.

Do
  Execute Floor, Broom
  If Floor.Dust = 0 Then
    Exit Do
  End If
  Broom.Restore()
Loop

The Broom.Restore moves to the top of the Do Loop, the Execute Sub is added before the Do, and the Exit Do condition is placed on the Do, as corrected below:

Execute Floor, Broom
Do Until Floor.Dust = 0
  Broom.Restore()
  Execute Floor, Broom
Loop

The fourth and final condition is when a Do Loop already has an escape condition and another Exit Do inside of it.
In this case, the Exit Do condition is merely attached to the existing escape condition. If the existing escape condition is an Until condition, then the Exit Do condition only needs to be 'Or' with the escape condition, but if the existing escape condition is a While condition, the Exit Do condition must be 'And Not' with the escape condition. Therefore:

Do
  Run Bull, Cow
  If Cow.Caught Then
    Exit Do
  End If
Loop Until Bull.Tired

becomes:

Do
  Run Bull, Cow
Loop Until Bull.Tired Or Cow.Caught

Therefore:

Do While X > 0
  If Y = 0 Then
    Exit Do
  End If
  X = X / Y
Loop

becomes:

Do While X > 0 And Not Y = 0
  X = X / Y
Loop

Therefore:

Do Until Bull.Tired
  Run Bull, Cow
  If Cow.Caught Then
    Exit Do
  End If
Loop

becomes:

Do Until Bull.Tired And Cow.Caught
  Run Bull, Cow
Loop

according to Escape condition Postulate One.
Last example:

Do
  Z = Z - 1
  Y = Y - Z
  If Y + Z = 0 Then
    Exit Do
  End If
  X = X + X \ (Y + Z)
Loop While X = 50

With lines trailing the Exit Do moved to the top:

Do
  X = X + X \ (Y + Z)
  Z = Z - 1
  Y = Y - Z
  If Y + Z = 0 Then
    Exit Do
  End If
Loop While X = 50

With lines before the Exit Do duplicated before the Do Loop:

Z = Z - 1
Y = Y - Z
Do
  X = X + X \ (Y + Z)
  Z = Z - 1
  Y = Y - Z
  If Y + Z = 0 Then
    Exit Do
  End If
Loop While X = 50

With the Exit Do condition placed on the Do:

Z = Z - 1
Y = Y - Z
Do Until Y + Z = 0
  X = X + X \ (Y + Z)
  Z = Z - 1
  Y = Y - Z
Loop While X = 50

And with Escape condition Postulate One:

Z = Z - 1
Y = Y - Z
Do While X = 50 And Not Y + Z = 0
  X = X + X \ (Y + Z)
  Z = Z - 1
  Y = Y - Z
Loop

And that's it for Exit Do alleviation. If you have a Do Loop that you cannot resolve using any of these methods, challenge me by e-mail.

Resolving the Exit For
Exit For statements are typically used in a For Loop that is actually being used as a Do Loop. So, before we go into the Exit For alleviation, let's discuss the For Do transformation.
A For Loop typically looks like this:

For N = S To F Step W
  Process N
Next

This For Loop can be transformed into a Do Loop like this (for all W > 0):

N = S
Do Until N > F
  Process N
  N = N + W
Loop

And for W < 0:

N = S
Do Until N < F
  Process N
  N = N + W
Loop

The lazy man's catch all looks like this:

N = S
Do Until (N > F And W > 0) Or (N < F And W < 0)
  Process N
  N = N + W
Loop

For W = 0, you have an infinite loop anyway, and either of these conditions will work. If N changes, then one of the above three can be selected based on the value of F relative to the initial value of N.
Now, avoiding the Exit For can be solved using this For Do transformation.
The most common Exit For that I find is something like this:

For i = 0 To UBound(X)
  'optional stuff (one).
  If X(i) = something Then
    Exit For
  End If
  'optional stuff (two).
Next

After a quick For Do transformation, I get:

i = 0
Do Until i > UBound(X)
  'optional stuff (one).
  If X(i) = something Then
    Exit Do
  End If
  'optional stuff (two).
  i = i + 1
Loop

And resolving the Do like we did in the first part, we get:

i = 0
'optional stuff (one).
Do Until i > UBound(X) Or X(i) = something
  'optional stuff (two).
  i = i + 1
  'optional stuff (one).
Loop

That's all it takes to resolve any For Loop with an Exit For.

The Exit For within a For Each Loop is typically unresolvable due to a For Each being the only way to access elements within certain collections in VB6. But, for proper collections, the For Each Loop is transformed into a For Loop and then into a Do Loop. An also valid, but vulgar, alternative to the For Do transform, is to set the value of the loop variable to the end value. But, the idea is that a For Loop should loop through all values for which it is assigned to. That is the nature of the For Loop.

The Exit Function, Exit Sub, and Exit Property
These three are all method Exit statements and are handled identically, by way of large If statement blocks comprised of method code (I will use Exit Sub for demonstration purposes).
The simplest situation for resolving Exit Sub is the single If statement embedded somewhere in the code, as in the following example:

Private Sub TB_Click()
  'Initialization code.
  If MyCondition Then
    Exit Sub
  End If
  'Following code.
End Sub

This can be resolved by restructuring the If statement and the following code so that, when the Exit Sub condition is met, the remainder of code is not executed. This is done by negating the Exit Sub condition and sticking the following code inside of the If block, as shown below:

Private Sub TB_Click()
  'Initialization code.
  If Not MyCondition Then
    'Following code.
  End If
End Sub

If there is no initialization code, then the entire subroutine is inside of an If statement.
The second case, when there is actually some code that should run before the procedure exits.

Private Sub TB_Click()
  'Initialization code.
  If MyCondition Then
    'Exiting code.
    Exit Sub
  End If
  'Following code.
End Sub

Again, the If condition is negated and the following code is moved into the If block. The Exiting code that runs if condition is True will now run if (not condition) is False, that is, in the Else part of the If block.

Private Sub TB_Click()
  'Initialization code.
  If Not MyCondition Then
    'Following code.
  Else
    'Exiting code.
  End If
End Sub

If there is something actually in the Else part of the If statement block containing the Exit Do, then the code in the Else block is better off outside, before the following code. Next are chains of code blocks that need to be broken down in order to extract the Exit Sub. Check the following example:

Private Sub TB_Click()
  'Initialization code.
  If something Then
    'Beginning of If code.
    If MyCondition Then
      'Exiting code.
      Exit Sub
    End If
    'Ending of If code.
  End If
  'Following code.
End Sub

First, the If MyCondition block has to be restructured by way of If negation again, except this time, the following code only goes down to the end of the If something block.

Private Sub TB_Click()
  'Initialization code.
  If something Then
    'Beginning of If code.
    If Not MyCondition Then
      'Ending of If code.
    Else
      'Exiting code.
    End If
  End If
  'Following code.
End Sub

The Following code poses the problem, since it must run unless MyCondition is true, regardless of the value of something. Therefore, it must be in its own If block, made solely of the Exit Sub condition.

Private Sub TB_Click()
  'Initialization code.
  If something Then
    'Beginning of If code.
    If Not MyCondition Then
      'Ending of If code.
    Else
      'Exiting code.
    End If
  End If
  If Not MyCondition Then
    'Following code.
  End If
End Sub

The rule carries over with multiple nested If blocks as well, where all trailing code that is not in the If block that contains the Exit Do If block is placed into its own If block

Private Sub TB_Click()
  'Initialization code.
  If something Then
    'Beginning of If code.
    If somethingelse Then
      'Begin of 2nd If code.
      If MyCondition Then
        'Exiting code.
        Exit Sub
      End If
      'End of 2nd If code.
    End If
    'Ending of If code.
  End If
  'Following code.
End Sub

The somethingelse contains the Exit Do condition, so it will be restructured first.

Private Sub TB_Click()
  'Initialization code.
  If something Then
    'Beginning of If code.
    If somethingelse Then
      'Begin of 2nd If code.
      If Not MyCondition Then
        'End of 2nd If code.    
      Else
        'Exiting code.
      End If
    End If
    'Ending of If code.
  End If
  'Following code.
End Sub

And then, the trailing code in all nesting If blocks is placed into its own If block.

Private Sub TB_Click()
  'Initialization code.
  If something Then
    'Beginning of If code.
    If somethingelse Then
      'Begin of 2nd If code.
      If Not MyCondition Then
        'End of 2nd If code.    
      Else
        'Exiting code.
      End If
    End If
    If Not MyCondition Then
      'Ending of If code.
    End If
  End If
  If Not MyCondition Then
    'Following code.
  End If
End Sub