View source for Control flow

{{Short description |How software progresses through its implementation}}
{{Distinguish |Flow control (data)}}
{{Loop constructs}}<!-- DO NOT remove. Discuss navigation concept at Talk:Do while loop#Helpbox experiment -->
In [[Software|software]], '''control flow''' (or '''flow of control''') describes how [[Execution (computing)|execution]] progresses from one [[Command (computing)|command]] to the next. In many contexts, such as [[Machine code|machine code]] and an [[Imperative programming|imperative]] [[Programming language|programming language]], control progresses sequentially (to the command located immediately after the currently executing command) except when a command transfers control to another point {{endash}} in which case the command is classified as a control flow command. Depending on context, other terms are used instead of ''command''. For example, in machine code, the typical term is ''instruction'' and in an imperative language, the typical term is ''statement''.

Although an imperative language encodes control flow explicitly, languages of other [[Programming paradigm|programming paradigm]]s are less focused on control flow. A [[Declarative programming|declarative]] language specifies desired results without prescribing an order of operations. A functional language uses both [[Language construct|language construct]]s and [[Function (computer programming)|functions]] to control flow even though they are usually not called control flow statements.

For a [[Central processing unit|central processing unit]] (CPU) instruction set, a control flow instruction often alters the [[Program counter|program counter]] and is either an unconditional [[Branch (computer science)|branch]] (a.k.a. jump) or a conditional branch. An alternative approach is [[Predication (computer architecture)|predication]] which conditionally enables instructions instead of branching.

An [[Asynchrony (computer programming)|asynchronous]] control flow transfer such as an [[Interrupt|interrupt]] or a signal alters the normal flow of control to a hander before returning control to where it was interrupted.

One way to attack software is to redirect the flow of execution. A variety of [[Control-flow integrity|control-flow integrity]] techniques, including stack canaries, [[Buffer overflow protection|buffer overflow protection]], shadow stacks, and vtable pointer verification, are used to defend against these attacks.<ref>{{cite web|url=https://nebelwelt.net/blog/20141007-CFICPSCPIdiffs.html|title=On differences between the CFI, CPS, and CPI properties|last1=Payer|first1=Mathias|last2=Kuznetsov|first2=Volodymyr|website=nebelwelt.net|access-date=2016-06-01}}</ref><ref>{{cite web|url=http://www.darkreading.com/vulnerabilities---threats/adobe-flash-bug-discovery-leads-to-new-attack-mitigation-method/d/d-id/1323092|title=Adobe Flash Bug Discovery Leads To New Attack Mitigation Method|website=Dark Reading|date=10 November 2015|access-date=2016-06-01}}</ref><ref>{{cite press release|url=http://www.prnewswire.com/news-releases/endgame-to-present-at-black-hat-usa-2016-300267060.html|title=Endgame to Present at Black Hat USA 2016|last=Endgame|website=www.prnewswire.com|access-date=2016-06-01}}</ref>

==Structure==
Control flow is closely related to code structure. Control flows along lines defined by structure and the execution rules of a language. This general concept of structure is not be confused with [[Structured programming|structured programming]] which limits structure to sequencing, selection and iteration based on [[Block (programming)|block]] organization.

===Sequence===
Sequential execution is the most basic structure. Although not all code is sequential in nature, imperative code is.

===Label===
A label identifies a position in [[Source code|source code]]. Some control flow statements reference a label so that control jumps to the labeled line. Other than marking a position, a label has no other effect.

Some languages limit a label to a number which is sometimes called a [[Line number|line number]] although that implies the inherent index of the line; not a label. None-the-less, such numeric labels are typically required to increment from top to bottom in a file even if not be sequential. For example, in BASIC:

<syntaxhighlight lang="qbasic">
10 LET X = 3
20 PRINT X
30 GOTO 10
</syntaxhighlight>

In many languages, a label is an alphanumeric [[Identifier|identifier]], usually appearing at the start of a line and immediately followed by a colon. For example, the following C code defines a label {{code |Success}} on line 3 which identifies a jump target point at the first statement that follows it; line 4.

<syntaxhighlight lang="c" line>
    if (ok) goto success;
    return;
success:
    printf("OK");
</syntaxhighlight>

===Block===
Most languages provide for organizing sequences of code as a [[Block (programming)|block]]. When used with a control statement, the beginning of a block provides a jump target. For example, in the following C code (which uses curly braces to delimit a block), control jumps from line 1 to 4 if done is false.

<syntaxhighlight lang="c" line>
if (done) {
    printf("All done");
} else {
    printf("Still workin' on it");
}
</syntaxhighlight>

==Control{{anchor |control-statement}}==

Many control commands have been devised for programming languages. This section describes notable constructs; organized by functionality.

===Function===
A function provides for control flow in that when called, execution jumps to the start of the function's code and when it completes, control returns the calling point. In the following C code, control jumps from line 6 to 2 in order to call function {{code |foo()}}. Then, after completing the function body (printing "Hi"), control returns to after the call, line 7.

<syntaxhighlight lang="c" line>
void foo() {
    printf("Hi");
}

void bar() {
    foo();
    printf("Done");
}
</syntaxhighlight>

===Branch===
A branch command moves the point of execution from the point in the code that contains the command to the point that the command specifies.

====Jump====
A jump command unconditionally branches control to another point in the code, and is the most basic form of controlling the flow of code.

In a high-level language, this is often provided as a [[Goto|goto]] statement. Although the keyword may be upper or lower case or one or two words depending on the language, it is like: <code>goto ''label''</code>. When control reaches a goto statement, control then jumps to the statement that follows the indicated label. The goto statement is been [[Considered harmful|considered harmful]] by many computer scientists; notably [[Biography:Edsger W. Dijkstra|Dijkstra]].

====Conditional branch====
A [[Conditional (computer programming)|conditional]] statement jumps control based on the value of a [[Boolean data type|Boolean]] expression. Common variations include:

; if-goto: Jumps to a label based on a condition; a high-level programming statement that closely mimics a similar used machine code instruction

; if-then: Rather than being restricted to a jump, a statement or block is executed if the expression is true. In a language that does not include the {{code |then}} keyword, this can be called an if statement.

; if-then-else: Like if-then, but with a second action to be performed if the condition is false. In a language that does not include the {{code |then}} keyword, this can be called an if-else statement.

; Nested: Conditional statements are often nested inside other conditional statements.

; Arithmetic if: Early [[Fortran]], had an arithmetic if (a.k.a. three-way if) that tests whether a numeric value is negative, zero, or positive. This statement was deemed obsolete in Fortran-90, and deleted as of Fortran 2018.

; Functional: Some languages have a [[Functional programming|functional]] form; for instance [[Lisp (programming language)|Lisp's]] <code>cond</code>.

; Operator: Some languages have an operator form, such as the [[Ternary conditional operator|ternary conditional operator]].

; When and unless: [[Perl]] supplements a C-style {{code |if}} with {{code |when}} and {{code |unless}}.

; Messages: [[Smalltalk]] uses <code>ifTrue</code> and <code>ifFalse</code> messages to implement conditionals, rather than a language construct.

The following [[Pascal (programming language)|Pascal]] code shows a simple if-then-else. The syntax is similar in [[Ada (programming language)|Ada]]:

<syntaxhighlight lang="pascal">
if a > 0 then
  writeln("yes")
else
  writeln("no");
</syntaxhighlight>

In [[C (programming language)|C]]:

<syntaxhighlight lang="c">
if (a > 0) { 
    puts("yes");
} else {
    puts("no");
}
</syntaxhighlight>

In [[Software:Bash (Unix shell)|bash]]:

<syntaxhighlight lang="bash">
if [ $a -gt 0 ]; then
      echo "yes"
else
      echo "no"
fi
</syntaxhighlight>

In [[Python (programming language)|Python]]:

<syntaxhighlight lang="python">
if a > 0: 
    print("yes")
else:
    print("no")
</syntaxhighlight>

In [[Lisp (programming language)|Lisp]]:

<syntaxhighlight lang="lisp">
(princ
  (if (plusp a)
      "yes"
      "no"))
</syntaxhighlight>

====Multiway branch====
A multiway branch jumps control based on matching values. There is usually a provision for a default action if no match is found. A switch statement can allow compiler optimizations, such as [[Lookup table|lookup table]]s. In dynamic languages, the cases may not be limited to constant expressions, and might extend to [[Pattern matching|pattern matching]], as in the [[Shell script|shell script]] example on the right, where the <code>*)</code> implements the default case as a [[Glob (programming)|glob]] matching any string. Case logic can also be implemented in functional form, as in [[SQL]]'s <code>decode</code> statement.

The following [[Pascal (programming language)|Pascal]] code shows a relatively simple [[Switch statement|switch statement]]. Pascal uses the {{code |case}} keyword instead of {{code |switch}}.

<syntaxhighlight lang="pascal">
case someChar of
  'a': actionOnA;
  'x': actionOnX;
  'y','z':actionOnYandZ;
  else actionOnNoMatch;
end;
</syntaxhighlight>

In [[Ada (programming language)|Ada]]:

<syntaxhighlight lang="ada">
case someChar is
  when 'a' => actionOnA;
  when 'x' => actionOnX;
  when 'y' | 'z' => actionOnYandZ;
  when others => actionOnNoMatch;
end;
</syntaxhighlight>

In [[C (programming language)|C]]:

<syntaxhighlight lang="c">
switch (someChar) {
    case 'a': 
        actionOnA; 
        break;
    case 'x': 
        actionOnX; 
        break;
    case 'y':
    case 'z': 
        actionOnYandZ;
        break;
    default: 
        actionOnNoMatch;
}
</syntaxhighlight>

In [[Software:Bash (Unix shell)|Bash]]:

<syntaxhighlight lang="bash">
case $someChar in 
   a)    actionOnA ;;
   x)    actionOnX ;;
   [yz]) actionOnYandZ ;;
   *)    actionOnNoMatch  ;;
esac
</syntaxhighlight>

In [[Lisp (programming language)|Lisp]]:

<syntaxhighlight lang="lisp">
(case some-char
  ((#\a)     action-on-a)
  ((#\x)     action-on-x)
  ((#\y #\z) action-on-y-and-z)
  (else      action-on-no-match))
</syntaxhighlight>

In [[Fortran]]:

<syntaxhighlight lang="fortran">
select case (someChar)
  case ('a')
    actionOnA
  case ('x')
    actionOnX
  case ('y','z')
    actionOnYandZ
  case default
    actionOnNoMatch
end select
</syntaxhighlight>

===Loop{{anchor |loop-statement}}===
[[File:Programmingloops.svg|thumb|basic types of program loops]]
A loop is a sequence of statements, loop body, which is executed a number of times based on runtime state. The body is executed once for each item of a collection (''definite iteration''), until a condition is met (''indefinite iteration''), or [[Infinite loop|infinitely]]. A loop inside the loop body is called a ''nested loop''.<ref>{{Cite web |date=2019-11-25 |title=Nested Loops in C with Examples |url=https://www.geeksforgeeks.org/nested-loops-in-c-with-examples/ |access-date=2024-03-14 |website=GeeksforGeeks |language=en-US}}</ref><ref>{{Cite web |title=Python Nested Loops |url=https://www.w3schools.com/python/gloss_python_for_nested.asp |access-date=2024-03-14 |website=www.w3schools.com |language=en-US}}</ref><ref>{{Cite web |last=Dean |first=Jenna |date=2019-11-22 |title=Nested Loops |url=https://medium.com/swlh/nested-loops-ee1dbb9fc8ab |access-date=2024-03-14 |website=The Startup |language=en}}</ref> Early exit from a loop may be supported via a break statement.<ref>{{cite journal
 |last=Knuth |first=Donald E.
 |year=1974
 |title=Structured Programming with <code>go to</code> Statements
 |journal=[[ACM Computing Surveys|Computing Surveys]]
 |volume=6
 |issue=4
 |pages=261–301
 |doi=10.1145/356635.356640
 |citeseerx=10.1.1.103.6084
 |s2cid=207630080
}}</ref><ref name="roberts">Roberts, E. [1995] "[http://cs.stanford.edu/people/eroberts/papers/SIGCSE-1995/LoopExits.pdf Loop Exits and Structured Programming: Reopening the Debate] {{Webarchive|url=https://web.archive.org/web/20140725130816/http://cs.stanford.edu/people/eroberts/papers/SIGCSE-1995/LoopExits.pdf |date=2014-07-25 }}," ACM SIGCSE Bulletin, (27)1: 268–272.</ref>

In a [[Functional programming|functional programming]] language, such as [[Haskell]] and [[Scheme (programming language)|Scheme]], both [[Recursion (computer science)|recursive]] and iterative processes are expressed with [[Tail recursion|tail recursive]] procedures instead of looping constructs that are syntactic.

====Numeric====
{{main |For loop}}
A relatively simple yet useful loop iterates over a range of numeric values. A simple form starts at an integer value, ends at a larger integer value and iterates for each integer value between. Often, the increment can be any integer value; even negative to loop from a larger to a smaller value.

Example in BASIC:

<syntaxhighlight lang="basic">
FOR I = 1 TO N
   xxx
NEXT I
</syntaxhighlight>

Example in Pascal:

<syntaxhighlight lang="pascal">
for I := 1 to N do begin
   xxx
end;
</syntaxhighlight>

Example in Fortran:

<syntaxhighlight lang="fortran">
DO I = 1,N
    xxx
END DO
</syntaxhighlight>

In many programming languages, only integers can be used at all or reliably. As a floating-point number is represented imprecisely due to hardware constraints, the following loop might iterate 9 or 10 times, depending on various factors such as rounding error, hardware, compiler. Furthermore, if the increment of X occurs by repeated addition, accumulated rounding errors may mean that the value of X in each iteration can differ quite significantly from the commonly expected sequence of 0.1, 0.2, 0.3, ..., 1.0.

 '''for''' X := 0.1 '''step''' 0.1 '''to''' 1.0 '''do'''

====Condition-controlled====
{{main |While loop |Do while loop}}
Some loop constructs iterate until a condition is true. Some variations test the condition at the start of the loop; others test at the end. If the test is at the start, the body may be skipped completely. At the end, the body is always executed at least once.

Example in Visual Basic:

<syntaxhighlight lang="visualbasic">
DO WHILE (test)
    xxx
LOOP
</syntaxhighlight>

Example in Pascal:

<syntaxhighlight lang="pascal">
repeat
    xxx
until test;
</syntaxhighlight>

Example in C family of pre-test:

<syntaxhighlight lang="c">
while (test) {
    xxx
}
</syntaxhighlight>

Example in C family of post-test:

<syntaxhighlight lang="c">
do
    xxx
while (test);
</syntaxhighlight>

Although using the {{code |for}} keyword, the 3-part, c-style loop is condition-based; not a numeric-based construct. The condition, 2nd part, is evaluated before each loop so the loop is pre-test. The 1st part is a place to initialize state and the 3rd part is for incrementing for the next iteration, but both aspects can be performed elsewhere. The following C code implements the logic of a numeric loop that iterates for i from 0 to n-1.

<syntaxhighlight lang="c">
for (int i = 0; i < n; ++i) {
    xxx
}
</syntaxhighlight>

====Enumeration====
{{main |Foreach loop|l1=Foreach}}
Some loop constructs enumerate the items of a collection; iterating for each item.

Example in Smalltalk:

<syntaxhighlight lang="smalltalk">
someCollection do: [:eachElement |xxx].
</syntaxhighlight>

Example in Pascal:

<syntaxhighlight lang="pascal">
for Item in Collection do begin xxx end;
</syntaxhighlight>

Example in Raku:

<syntaxhighlight lang="raku">
foreach (item; myCollection) { xxx }
</syntaxhighlight>

Example in TCL:

<syntaxhighlight lang="tcl">
foreach someArray { xxx }
</syntaxhighlight>

Example in PHP:

<syntaxhighlight lang="php">
foreach ($someArray as $k => $v) { xxx }
</syntaxhighlight>

Example in Java:

<syntaxhighlight lang="java">
Collection<String> coll; 
for (String s : coll) {}
</syntaxhighlight>

Example in C#:

<syntaxhighlight lang="csharp">
foreach (string s in myStringCollection) { xxx }
</syntaxhighlight>

Example in PowerShell where 'foreach' is an alias of 'ForEach-Object':

<syntaxhighlight lang="powershell">
someCollection | foreach { $_ }
</syntaxhighlight>

Example in Fortran:

<syntaxhighlight lang="fortran">
forall ( index = first:last:step... )
</syntaxhighlight>

[[Scala (programming language)|Scala]] has [[Scala (programming language)#For-expressions|for-expressions]], which generalise collection-controlled loops, and also support other uses, such as asynchronous programming. [[Haskell]] has do-expressions and comprehensions, which together provide similar function to for-expressions in Scala.

====Infinite====
{{excerpt |Infinite loop}}

====Loop-and-a-half problem{{anchor |loop-and-a-half-problem}}====
Common loop structures sometimes result in duplicated code, either repeated statements or repeated conditions. This arises for various reasons and has various proposed solutions to eliminate or minimize code duplication.<ref name="c2messy">{{cite web |url=https://wiki.c2.com/?MessyLoopConditions |title=Messy Loop Conditions |work=WikiWikiWeb |date=2014-11-03}}</ref> Other than the traditional unstructured solution of a ''goto'' statement,{{sfn|Knuth|1974|p=278|loc=Simple Iterations}} general structured solutions include having a conditional (''if'' statement) inside the loop (possibly duplicating the condition but not the statements) or wrapping repeated logic in a function (so there is a duplicated function call, but the statements are not duplicated).<ref name="c2messy" />

A common case is where the start of the loop is always executed, but the end may be skipped on the last iteration.{{sfn|Knuth|1974|p=278|loc=Simple Iterations}} This was dubbed by Dijkstra a loop which is performed "''n'' and a half times",<ref>[[Biography:Edsger W. Dijkstra|Edsger W. Dijkstra]], personal communication to [[Biography:Donald Knuth|Donald Knuth]] on 1974-01-03, cited in {{harvtxt|Knuth|1974|p=278|loc=Simple Iterations}}</ref> and is now called the '''''loop-and-a-half''' problem''.<ref name="roberts"/> Common cases include reading data in the first part, checking for end of data, and then processing the data in the second part; or processing, checking for end, and then preparing for the next iteration.{{sfn|Knuth|1974|p=278|loc=Simple Iterations}}<ref name="roberts"/> In these cases, the first part of the loop is executed {{tmath|n}} times, but the second part is only executed {{tmath|n - 1}} times.

This problem has been recognized at least since 1967 by Knuth, with Wirth suggesting solving it via early loop exit.{{sfn|Knuth|1974|p=279}} Since the 1990s this has been the most commonly taught solution, using a ''break'' statement, as in:<ref name="roberts"/>

 '''loop'''
     ''statements''
     '''if''' ''condition'' '''break'''
     ''statements''
 '''repeat'''

A subtlety of this solution is that the condition is the ''opposite'' of a usual ''while'' condition: rewriting '''while''' ''condition'' ... '''repeat''' with an exit in the middle requires reversing the condition: '''loop''' ... '''if not''' ''condition'' '''exit''' ... '''repeat'''. The loop with test in the middle control structure explicitly supports the loop-an-a-half use case, without reversing the condition.{{sfn|Knuth|1974|p=279}}

====Unstructured====
A loop construct provides for structured completion criteria that either results in another iteration or continuing execution after the loop statement. But, various unstructured control flow constructs are supported by many languages.

; Early next iteration{{anchor |continue-statement}}: Some languages provide a construct that jumps control to the beginning of the loop body for the next iteration; for example, <code>continue</code> (most common), <code>skip</code>,<ref>{{cite web |title=What is a loop and how we can use them? |url=http://www.megacpptutorials.com/2012/12/what-is-loop.html |access-date=2020-05-25 |url-status=dead |archive-date=2020-07-28 |archive-url=https://web.archive.org/web/20200728081722/http://www.megacpptutorials.com/2012/12/what-is-loop.html }}</ref> <code>cycle</code> (Fortran), or <code>next</code> (Perl and Ruby).

; Redo iteration: Some languages, like Perl<ref>{{cite web|title=redo - perldoc.perl.org|url=https://perldoc.perl.org/functions/redo.html|access-date=2020-09-25|website=perldoc.perl.org}}</ref> and Ruby,<ref>{{cite web|title=control_expressions - Documentation for Ruby 2.4.0|url=https://docs.ruby-lang.org/en/2.4.0/syntax/control_expressions_rdoc.html|access-date=2020-09-25|website=docs.ruby-lang.org}}</ref> have a <code>redo</code> statement that jumps to the start of the body for the same iteration.

; Restart: Ruby has a <code>retry</code> statement that restarts the entire loop from the first iteration.<ref>{{cite web|title=control_expressions - Documentation for Ruby 2.3.0|url=https://docs.ruby-lang.org/en/2.3.0/syntax/control_expressions_rdoc.html|access-date=2020-09-25|website=docs.ruby-lang.org}}</ref>

=====Early exit{{anchor |early-exit}}=====
Early exit jumps control to after the loop body <ref>Is a common way to solve the loop-and-a-half problem.</ref><ref name="roberts"/> For example, when searching a list, can stop looping when the item is found. Some programming languages provide a statement such as <code>break</code> (most languages), <code>Exit</code> (Visual Basic), or <code>last</code> (Perl).

In the following Ada code, the loop exits when X is 0.

<syntaxhighlight lang="ada">
loop
    Get(X);
    if X = 0 then
        exit;
    end if;
    DoSomething(X);
end loop;
</syntaxhighlight>

A more idiomatic style uses {{code |exit when}}:

<syntaxhighlight lang="ada">
loop
    Get(X);
    exit when X = 0;
    DoSomething(X);
end loop;
</syntaxhighlight>

[[Python (programming language)|Python]] supports conditional execution of code depending on whether a loop was exited early (with a <code>break</code> statement) or not by using an else-clause with the loop. In the following Python code, the <code>else</code> clause is linked to the <code>for</code> statement, and not the inner <code>if</code> statement. Both Python's <code>for</code> and <code>while</code> loops support such an else clause, which is executed only if early exit of the loop has not occurred.

<syntaxhighlight lang="python">
for n in set_of_numbers:
    if isprime(n):
        print("Set contains a prime number")
        break
else:
    print("Set did not contain any prime numbers")
</syntaxhighlight>

======Multi-level breaks======
Some languages support breaking out of nested loops; in theory circles, these are called '''multi-level breaks'''. One common use example is searching a multi-dimensional table. This can be done either via multilevel breaks (break out of ''N'' levels), as in bash<ref>Advanced Bash Scripting Guide: [http://tldp.org/LDP/abs/html/loopcontrol.html 11.3. Loop Control]</ref> and PHP,<ref>PHP Manual: "[http://php.net/manual/en/control-structures.break.php break]"</ref> or via labeled breaks (break out and continue at given label), as in Ada, Go, Java, Rust and Perl.<ref>perldoc: [http://perldoc.perl.org/functions/last.html last]</ref> Alternatives to multilevel breaks include single breaks, together with a state variable which is tested to break out another level; exceptions, which are caught at the level being broken out to; placing the nested loops in a function and using return to effect termination of the entire nested loop; or using a label and a goto statement. Neither C nor C++ currently have multilevel break or named loops, and the usual alternative is to use a goto to implement a labeled break.<ref>comp.lang.c FAQ list · "[http://c-faq.com/misc/multibreak.html Question 20.20b]"</ref> However, the inclusion of this feature has been proposed,<ref>{{Cite web|title=named-loops|url=https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm|website=open-std.org|date=18 September 2024}}</ref> and was added to C2Y.,<ref>{{Cite web|title=Information technology — Programming languages — C|url=https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3550.pdf|website=open-std.org|date=4 May 2025}}</ref> following the Java syntax. Python does not have a multilevel break or continue – this was proposed in [https://www.python.org/dev/peps/pep-3136/ PEP 3136], and rejected on the basis that the added complexity was not worth the rare legitimate use.<ref>[http://mail.python.org/pipermail/python-3000/2007-July/008663.html <nowiki>[</nowiki>Python-3000<nowiki>]</nowiki> Announcing PEP 3136], Guido van Rossum</ref>

The notion of multi-level breaks is of some interest in [[Theoretical computer science|theoretical computer science]], because it gives rise to what is today called the ''Kosaraju hierarchy''.<ref name=kozen>{{cite book |first=Dexter |last=Kozen |date=2008 |chapter=The Böhm–Jacopini Theorem is False, Propositionally |title=Mathematics of Program Construction |series=Lecture Notes in Computer Science |doi=10.1007/978-3-540-70594-9_11 |volume=5133 |pages=177–192 |isbn=978-3-540-70593-2 |url=https://www.cs.cornell.edu/~kozen/papers/BohmJacopini.pdf |citeseerx=10.1.1.218.9241}}</ref> In 1973 [[Biography:S. Rao Kosaraju|S. Rao Kosaraju]] refined the [[Structured program theorem|structured program theorem]] by proving that it is possible to avoid adding additional variables in structured programming, as long as arbitrary-depth, multi-level breaks from loops are allowed.<ref>Kosaraju, S. Rao. "Analysis of structured programs," Proc. Fifth Annual ACM Syrup.
Theory of Computing, (May 1973), 240-252; also in J. Computer and System Sciences, 9,
3 (December 1974), cited by {{harvtxt|Knuth|1974}}.</ref> Furthermore, Kosaraju proved that a strict hierarchy of programs exists: for every integer ''n'', there exists a program containing a multi-level break of depth ''n'' that cannot be rewritten as a program with multi-level breaks of depth less than ''n'' without introducing added variables.<ref name="kozen"/>

In his 2004 textbook, [[Biography:David Watt (computer scientist)|David Watt]] uses Tennent's notion of sequencer to explain the similarity between multi-level breaks and return statements. Watt notes that a class of sequencers known as ''escape sequencers'', defined as "sequencer that terminates execution of a textually enclosing command or procedure", encompasses both breaks from loops (including multi-level breaks) and return statements. As commonly implemented, however, return sequencers may also carry a (return) value, whereas the break sequencer as implemented in contemporary languages usually cannot.<ref name="WattFindlay2004b">{{cite book|author1=David Anthony Watt|author2=William Findlay| title=Programming language design concepts| year=2004| publisher=John Wiley & Sons|isbn=978-0-470-85320-7|pages=215–221}}</ref>

=====Middle test=====
The following structure was proposed by [[Biography:Ole-Johan Dahl|Dahl]] in 1972:<ref>Dahl & Dijkstra & Hoare, "Structured Programming" Academic Press, 1972.</ref>

    '''loop'''                           '''loop'''
        xxx1                           read(char);
    '''while''' test;                    '''while''' '''not''' atEndOfFile;
        xxx2                           write(char);
    '''repeat''';                        '''repeat''';

The construction here can be thought of as a '''do''' loop with the '''while''' check in the middle, which allows clear loop-and-a-half logic. Further, by omitting individual components, this single construction can replace several constructions in most programming languages. If ''xxx1'' is omitted, we get a loop with the test at the top (a traditional '''while''' loop). If ''xxx2'' is omitted, we get a loop with the test at the bottom, equivalent to a '''do while''' loop in many languages. If '''while''' is omitted, we get an infinite loop. This construction also allows keeping the same polarity of the condition even when in the middle, unlike early exit, which requires reversing the polarity (adding a '''not'''),{{sfn|Knuth|1974|p=279}} functioning as '''until''' instead of '''while'''.

This structure is not widely supported, with most languages instead using '''if''' ... '''break''' for conditional early exit.

This is supported by some languages, such as [[Forth (programming language)|Forth]], where the syntax is BEGIN ... WHILE ... REPEAT,<ref>{{Cite web|url=https://www.forth.com/starting-forth/6-forth-do-loops/|title=6. Throw It For a Loop}}</ref> and the [[Shell script|shell script]] languages [[Software:Bourne shell|Bourne shell]] (<code>sh</code>) and [[Software:Bash (Unix shell)|bash]], where the syntax is '''while''' ... '''do''' ... '''done''' or '''until''' ... '''do''' ... '''done''', as:<ref>{{citation |url=https://www.gnu.org/software/bash/manual/bash.html |title=The GNU Bash Reference Manual |section=3.2.5.1 Looping Constructs |section-url=https://www.gnu.org/software/bash/manual/bash.html#Looping-Constructs-1 |date=2025-05-18}}</ref><ref>{{cite web |url=https://langdev.stackexchange.com/questions/1815/how-could-a-language-make-the-loop-and-a-half-less-error-prone/1868#1868 |title=How could a language make the loop-and-a-half less error-prone? |work=Stack Exchange: Programming Language Design and Implementation}}</ref>

<syntaxhighlight lang="bash">
while
  statement-1
  statement-2
  ...
  condition
do
  statement-a
  statement-b
  ...
done
</syntaxhighlight>

The shell syntax works because the '''while''' (or '''until''') loop accepts a list of commands as a condition,<ref>{{citation |url=https://www.gnu.org/software/bash/manual/bash.html |title=The GNU Bash Reference Manual |section=3.2.4 Lists of Commands |section-url=https://www.gnu.org/software/bash/manual/bash.html#Lists |date=2025-05-18}}</ref> formally:

  '''while''' ''test-commands''; '''do''' ''consequent-commands''; '''done'''

The value (exit status) of the list of ''test-commands'' is the value of the ''last'' command, and these can be separated by newlines, resulting in the idiomatic form above.

Similar constructions are possible in C and C++ with the [[Comma operator|comma operator]], and [[Comma operator#Other languages|other languages with similar constructs]], which allow shoehorning a list of statements into the while condition:

<syntaxhighlight lang="c">
while (statement_1, statement_2, condition) {
    statement_a;
    statement_b;
}
</syntaxhighlight>

While legal, this is marginal, and it is primarily used, if at all, only for short modify-then-test cases, as in:<ref>{{cite web |url=https://stackoverflow.com/questions/52550/what-does-the-comma-operator-do/52615#52615 |title=What does the comma operator , do? |work=[[Stack Overflow]]}}</ref>

<syntaxhighlight lang="c">
while (read_string(s), strlen(s) > 0) {
    // ...
}
</syntaxhighlight>

====Loop variants and invariants====
[[Loop variant]]s and [[Loop invariant|loop invariant]]s are used to express correctness of loops.<ref>{{cite book| last=Meyer| first=Bertrand| title=Eiffel: The Language| year=1991| publisher=Prentice Hall|pages=129–131}}</ref>

In practical terms, a loop variant is an integer expression which has an initial non-negative value. The variant's value must decrease during each loop iteration but must never become negative during the correct execution of the loop. Loop variants are used to guarantee that loops will terminate.

A loop invariant is an assertion which must be true before the first loop iteration and remain true after each iteration. This implies that when a loop terminates correctly, both the exit condition and the loop invariant are satisfied. Loop invariants are used to monitor specific properties of a loop during successive iterations.

Some programming languages, such as [[Eiffel (programming language)|Eiffel]] contain native support for loop variants and invariants. In other cases, support is an add-on, such as the [[Java Modeling Language]]'s specification for [http://www.eecs.ucf.edu/~leavens/JML//jmlrefman/jmlrefman_12.html#SEC168 loop statements] in [[Java (programming language)|Java]].

====Loop sublanguage====
Some [[Lisp (programming language)|Lisp]] dialects provide an extensive sublanguage for describing Loops. An early example can be found in Conversional Lisp of [[Interlisp]]. [[Common Lisp]]<ref>{{cite web|title=Common Lisp LOOP macro| url=http://www.lispworks.com/documentation/HyperSpec/Body/m_loop.htm}}</ref> provides a Loop macro which implements such a sublanguage.

====Loop system cross-reference table====

{| class="wikitable"
|-
! rowspan=2 | [[Programming language]]
! colspan=3 | Conditional
! colspan=4 | Loop
! rowspan=2 | Early exit
! rowspan=2 | Loop continuation
! rowspan=2 | Redo
! rowspan=2 | Retry
! colspan=2 | Correctness facilities
|-
! Begin
! Middle
! End
! Numeric
! Collection
! General
! Infinite {{ref_label|loop_infinite|1|a}}
! Variant
! Invariant
|-
| [[Ada (programming language)|Ada]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{partial|arrays}}
| {{no}}
| {{yes}}
| {{yes|deep nested}}
| {{no}}
|
|
|
|
|-
| [[APL (programming language)|APL]]
| {{yes}}
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{partial|deep nested}} {{ref_label|deep_break_c|3|a}}
| {{yes}}
| {{no}}
| {{no}}
|
|
|-
| [[C (programming language)|C]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|loop_for|2|a}}
| {{no}}
| {{yes}}
| {{no}}
| {{partial|deep nested}} {{ref_label|deep_break_c|3|a}}
| {{partial|deep nested}} {{ref_label|deep_break_c|3|a}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|- 
| [[C++]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|loop_for|2|b}}
| {{yes}} {{ref_label|loop_foreach|9|a}}
| {{yes}}
| {{no}}
| {{partial|deep nested}} {{ref_label|deep_break_c|3|b}}
| {{partial|deep nested}} {{ref_label|deep_break_c|3|a}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|-
| [[C Sharp (programming language)|C#]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|loop_for|2|c}}
| {{yes}}
| {{yes}}
| {{no}}
| {{partial|deep nested}} {{ref_label|deep_break_c|3|c}}
| {{partial|deep nested}} {{ref_label|deep_break_c|3|a}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|-
| [[COBOL]]
| {{yes}}
| {{no}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
| {{no}}
| {{partial|deep nested}} {{ref_label|cobol_deep_exit|15|a}}
| {{partial|deep nested}} {{ref_label|cobol_deep_exit|14|a}}
| {{no}}
|
|
|
|-
| [[Common Lisp]]
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{partial|builtin only}} {{ref_label|cl_sequence_type|16|a}}
| {{yes}}
| {{yes}}
| {{yes|deep nested}}
| {{no}}
|
|
|
|
|- 
| [[D (programming language)|D]]
| {{yes}}
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}{{ref_label|DInfinite|14|a}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
|
|
|
|-
| [[Eiffel (programming language)|Eiffel]]
| {{yes}}
| {{no}}
| {{no}}
| {{yes}} {{ref_label|count_loop_eiffel|10|a}}
| {{yes}}
| {{yes}}
| {{no}}
| {{partial|one level}} {{ref_label|count_loop_eiffel|10|a}}
| {{no}}
| {{no}}
| {{no}} {{ref_label|retry_in_eiffel|11|a}}
| {{partial|integer only}} {{ref_label|integer_variant|13|a}}
| {{yes}}
|-
| [[F Sharp (programming language)|F#]]
| {{yes}}
| {{no}}
| {{no}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
| {{no}} {{ref_label|deep_break_e|6|b}}
| {{no}}
| {{no}}
|
|
|
|-
| FORTRAN 77
| {{yes}}
| {{no}}
| {{no}}
| {{yes}}
| {{no}}
| {{no}}
| {{no}}
| {{partial|one level}}
| {{yes }}
| {{no}}
| {{no}}
|
|
|-
| Fortran 90
| {{yes}}
| {{no}}
| {{no}}
| {{yes}}
| {{no}}
| {{no}}
| {{yes}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
| {{no}}
|
|
|-
| Fortran 95 and later
| {{yes}}
| {{no}}
| {{no}}
| {{yes}}
| {{partial|arrays}}
| {{no}}
| {{yes}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
| {{no}}
|
|
|-
| [[Go (programming language)|Go]]
| {{yes}}
| {{no}}
| {{no}}
| {{yes}}
| {{partial|builtin only}}
| {{yes}}
| {{yes}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
|
|
|
|-
| [[Haskell]]
| {{no}}
| {{no}}
| {{no}}
| {{no}}
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|deep_break_e|6|a}}
| {{no}}
| {{no}}
|
|
|
|-
| [[Java (programming language)|Java]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|loop_for|2|d}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
|
| {{unofficial|non-native}} {{ref_label|requires_JML|12|a}}
| {{unofficial|non-native}} {{ref_label|requires_JML|12|a}}
|-
| [[JavaScript]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|loop_for|2|g}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
| {{no}}
| {{no}}
|-
| [[Kotlin (programming language)|Kotlin]]
| {{yes}}
| {{no}}
| {{yes}}
| {{maybe}}
| {{yes}}
| {{no}}
| {{no}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|-
| Natural
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
|
|-
| [[OCaml]]
| {{yes}}
| {{no}}
| {{no}}
| {{yes}}
| {{yes|arrays,lists}}
| {{no}}
| {{no}}
| {{no}} {{ref_label|deep_break_e|6|b}}
| {{no}}
| {{no}}
|
|
|
|-
| Odin
| {{no}} {{ref_label|odin_general_loop|17|a}}
| {{no}}
| {{no}}
| {{no}} {{ref_label|loop_range|5|f}}
| {{partial|builtin only}}
| {{yes}}
| {{no}} {{ref_label|odin_general_loop|17|b}}
| {{yes|deep nested}}
| {{yes|deep nested}}
|
|
|
|
|- 
| [[PHP]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|loop_for|2|e}} {{ref_label|loop_for|5|b}}
| {{yes}} {{ref_label|loop_phpforeach|4|a}}
| {{yes}}
| {{no}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|- 
| [[Perl]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|loop_for|2|f}} {{ref_label|loop_for|5|c}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{yes}}
|
|
|
|-
| [[Python (programming language)|Python]]
| {{yes}}
| {{no}}
| {{no}}
| {{no}} {{ref_label|loop_range|5|a}}
| {{yes}}
| {{no}}
| {{no}}
| {{partial|deep nested}} {{ref_label|deep_break_e|6|c}}
| {{partial|deep nested}} {{ref_label|deep_break_e|6|c}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|-
| [[Rebol]]
| {{no}} {{ref_label|while|7|a}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}} {{ref_label|user|8|a}}
| {{yes}}
| {{partial|one level}} {{ref_label|deep_break_e|6|d}}
| {{no}}
| {{no}}
|
|
|
|-
| [[Ruby (programming language)|Ruby]]
| {{yes}}
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
| {{partial|deep nested}} {{ref_label|deep_break_e|6|e}}
| {{partial|deep nested}} {{ref_label|deep_break_e|6|e}}
| {{yes}}
| {{yes}}
|
|
|-
| [[Rust (programming language)|Rust]]
| {{yes}}
| {{no}}
| {{no}}
| {{no}} {{ref_label|loop_range|5|d}}
| {{yes}}
| {{no}}
| {{yes}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|-
| [[Standard ML]]
| {{yes}}
| {{no}}
| {{no}}
| {{no}}
| {{yes|arrays,lists}}
| {{no}}
| {{no}}
| {{no}} {{ref_label|deep_break_e|6|b}}
| {{no}}
| {{no}}
|
|
|
|-
| [[Swift (programming language)|Swift]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|-
| [[Visual Basic .NET]]
| {{yes}}
| {{no}}
| {{yes}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
| {{partial|one level per type of loop}}
| {{partial|one level per type of loop}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|- 
| [[PowerShell]]
| {{yes}}
| {{no}}
| {{yes}}
| {{no}} {{ref_label|loop_for|2|h}}
| {{yes}}
| {{yes}}
| {{no}}
| {{yes}}
| {{yes}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|-
| [[Zig (programming language)|Zig]]
| {{yes}}
| {{no}}
| {{no}}
| {{no}} {{ref_label|loop_range|5|e}}
| {{partial|builtin only}}
| {{no}}
| {{no}}
| {{yes|deep nested}}
| {{yes|deep nested}}
| {{no}}
| {{no}}
| {{no}}
| {{no}}
|}
# {{note label|loop_infinite|1|a}} <code>while (true)</code> does not count as an infinite loop for this purpose, because it is not a dedicated language structure.
# {{note label|loop for|2|a}}{{note_label|loop_for|2|b}}{{note_label|loop_for|2|c}}{{note_label|loop_for|2|d}}{{note_label|loop_for|2|e}}{{note_label|loop_for|2|f}}{{note_label|loop_for|2|g}}{{note_label|loop_for|2|h}} C's <code>for (''init''; ''test''; ''increment'')</code> loop is a general loop construct, not specifically a counting one, although it is often used for that.
# {{note label|deep_break_c|3|a}}{{note label|deep_break_c|3|b}}{{note label|deep_break_c|3|c}} Deep breaks may be accomplished in APL, C, C++ and C# through the use of labels and gotos.
# {{note label|loop_phpforeach|4|a}} Iteration over objects was [http://www.php.net/manual/en/language.oop5.iterations.php added] in PHP 5.
# {{note label|loop_range|5|a}}{{note label|loop_range|5|b}}{{note label|loop_range|5|c}}{{note label|loop_range|5|d}}{{note label|loop_range|5|e}}{{note label|loop_range|5|f}} A counting loop can be simulated by iterating over an incrementing list or generator, for instance, Python's <code>range()</code>.
# {{note label|deep_break_e|6|a}}{{note label|deep_break_e|6|b}}{{note label|deep_break_e|6|c}}{{note label|deep_break_e|6|d}}{{note label|deep_break_e|6|e}} Deep breaks may be accomplished through the use of exception handling.
# {{note_label|while|7|a}} There is no special construct, since the <code>while</code> function can be used for this.
# {{note_label|user|8|a}} There is no special construct, but users can define general loop functions.
# {{note_label|loop_foreach|9|a}} The [[C++11]] standard introduced the [[C++11#Range-based for loop|range-based for]]. In the [[Standard Template Library|STL]], there is a <code>std::for_each</code> template function which can iterate on STL containers and call a [[Unary function|unary function]] for each element.<ref>[http://www.sgi.com/tech/stl/for_each.html for_each]. Sgi.com. Retrieved on 2010-11-09.</ref> The functionality also can be constructed as [[C preprocessor#Macro definition and expansion|macro]] on these containers.<ref>[https://boost-sandbox.sourceforge.net/libs/foreach/doc/html/ Chapter 1. Boost.Foreach] {{Webarchive|url=https://web.archive.org/web/20100129070613/http://boost-sandbox.sourceforge.net/libs/foreach/doc/html/ |date=2010-01-29}}. Boost-sandbox.sourceforge.net (2009-12-19). Retrieved on 2010-11-09.</ref>
# {{note_label|count_loop_eiffel|10|a}} Numeric looping is effected by iteration across an integer interval; early exit by including an additional condition for exit.
# {{note_label|retry_in_eiffel|11|a}} Eiffel supports a reserved word <code>retry</code>, however it is used in [[Exception handling#Exception handling based on design by contract|exception handling]], not loop control.
# {{note_label|requires_JML|12|a}} Requires [[Java Modeling Language]] (JML) behavioral interface specification language.
# {{note_label|integer_variant|13|a}} Requires loop variants to be integers; transfinite variants are not supported. [http://archive.eiffel.com/doc/faq/variant.html Eiffel: Why loop variants are integers]
# {{note_label|DInfinite|13|a}} D supports infinite collections, and the ability to iterate over those collections. This does not require any special construct.
# {{note_label|cobol_deep_exit|14|a}} Deep breaks can be achieved using <code>GO TO</code> and procedures.
# {{note_label|cl_sequence_type|14|a}} Common Lisp predates the concept of generic collection type.
# {{note_label|odin_general_loop|17|a}}{{note_label|odin_general_loop|17|b}} Odin's general <code>for</code> loop supports syntax shortcuts for conditional loop and infinite loop.

===Non-local===
Many programming languages, especially those favoring more dynamic styles of programming, offer constructs for non-local control flow which cause execution to jump from the current execution point to a [[Predeclared|predeclared]] point. Notable examples follow.

====Condition handling====
The earliest [[Fortran]] compilers supported statements for handling exceptional conditions including <code>IF ACCUMULATOR OVERFLOW</code>, <code>IF QUOTIENT OVERFLOW</code>, and <code>IF DIVIDE CHECK</code>. In the interest of machine independence, they were not included in FORTRAN IV and the Fortran 66 Standard. However, since Fortran 2003 it is possible to test for numerical issues via calls to functions in the <code>IEEE_EXCEPTIONS</code> module.

PL/I has some 22 standard conditions (e.g., ZERODIVIDE SUBSCRIPTRANGE ENDFILE) which can be raised and which can be intercepted by: ON ''condition'' action; Programmers can also define and use their own named conditions.

Like the ''unstructured if'', only one statement can be specified so in many cases a GOTO is needed to decide where flow of control should resume.

Unfortunately, some implementations had a substantial overhead in both space and time (especially SUBSCRIPTRANGE), so many programmers tried to avoid using conditions.

A typical example of syntax:

 '''ON''' ''condition'' '''GOTO''' ''label''

====Exception handling====
Many modern languages support an [[Exception handling|exception handling]] construct that is structured; does not rely on jump semantics (goto). Generally, exceptional control flow starts with an exception object being thrown (a.k.a. raised). Control then proceeds to the inner-most exception handler for the [[Call stack|call stack]]. If the handler handles the exception, then flow control reverts to normal. Otherwise, control proceeds outward to containing handlers until one handles the exception or the program reaches the outermost scope and exits. As control flows to progressively outer handlers, aspects that would normally occur such as popping the call stack are handled automatically.

The following C++ code demonstrates structured exception handling. If an exception propagates from the execution of {{code |doSomething()}} and the exception object type matches one of the types specified in a catch clause, then that clause is executed. For example, if an exception of type {{code |SomeException}} is propagated by {{code |doSomething()}}, then control jumps from line 2 to 4 and the message "Caught SomeException" is printed and then control jumps to after the  {{code |try}} statement, line 8. If an exception of any other type is propagated, then control jumps from line 2 to 6. If no exception, then control jumps from 2 to 8.

<syntaxhighlight lang="cpp" line>
try {
    doSomething();
} catch (const SomeException& e)
    std::println("Caught SomeException: {}", e.what());
} catch (...) {
    std::println("Unknown error");
}
doNextThing();
</syntaxhighlight>

Many languages use the C++ keywords ({{code |throw}}, {{code |try}} and {{code |catch}}), but some languages use other keywords. For example, Ada uses {{code |exception}} to introduce an exception handler and {{code |when}} instead of {{code |catch}}. [[AppleScript]] incorporates placeholders in the syntax to extract information about the exception as shown in the following AppleScript code.<!-- should explain what the keywords ("from", "to", and "partial results") do.-->

<syntaxhighlight lang = "applescript">
try
    set myNumber to myNumber / 0
on error e number n from f to t partial result pr
    if ( e = "Can't divide by zero" ) then display dialog "You must not do that"
end try
</syntaxhighlight>

In many languages (including Object Pascal, D, Java, C#, and Python) a {{code| finally}} clause at the end of a {{code| try}} statement is executed at the end of the try statement; whether an exception propagates from the rest of the {{code| try}} or not. The following C# code ensures that the stream {{code|stream}} is closed.

<syntaxhighlight lang="csharp">
FileStream stream = null;
try
{
    stream = new FileStream("logfile.txt", FileMode.Create);
    return ProcessStuff(stream);
} 
finally
{
    if (stream != null)
    {
        stream.Close();
    }
}
</syntaxhighlight>

Since this pattern is common, C# provides the {{code |using}} statement to ensure cleanup. In the following code, even if ProcessStuff() propagates an exception, the <code>stream</code> object is released. Python's <code>with</code> statement and Ruby's block argument to <code>File.open</code> are used to similar effect.

<syntaxhighlight lang="csharp">
using (FileStream stream = new("logfile.txt", FileMode.Create))
{
    return ProcessStuff(stream);
}
</syntaxhighlight>

====Continuation====
{{excerpt |Continuation}}

====Generator====
{{excerpt |Generator (computer science)}}

====Coroutine====
{{excerpt |Coroutine}}

====COMEFROM====
{{excerpt |COMEFROM}}

====Event-based early exit from nested loop====
[[Zahn's construct]] was proposed in 1974,<ref>Zahn, C. T. [https://cds.cern.ch/record/414919/files/dd-74-6.pdf "A control statement for natural top-down structured programming"] presented at Symposium on Programming Languages, Paris, 1974.</ref> and discussed in {{harvtxt|Knuth|1974}}. A modified version is presented here.
    '''exitwhen''' EventA '''or''' EventB '''or''' EventC;
        xxx
    '''exits'''
        EventA: actionA
        EventB: actionB
        EventC: actionC
    '''endexit''';

'''exitwhen''' is used to specify the events which may occur within ''xxx'',
their occurrence is indicated by using the name of the event as a statement. When some event does occur, the relevant action is carried out, and then control passes just after ''' '''. This construction provides a very clear separation between determining that some situation applies, and the action to be taken for that situation.

'''exitwhen''' is conceptually similar to [[Exception handling|exception handling]], and exceptions or similar constructs are used for this purpose in many languages.

The following simple example involves searching a two-dimensional table for a particular item.

    '''exitwhen''' found '''or''' missing;
        '''for''' I := 1 '''to''' N '''do'''
            '''for''' J := 1 '''to''' M '''do'''
                '''if''' table[I,J] = target '''then''' found;
        missing;
    '''exits'''
        found:   print ("item is in table");
        missing: print ("item is not in table");
    '''endexit''';

==See also==
{{div col}}
* {{Annotated link |Control flow analysis}}
* {{Annotated link |Control-flow diagram}}
* {{Annotated link |Control-flow graph}}
* {{Annotated link |Control table}}
* {{Annotated link |Coroutine}}
* {{Annotated link |Cyclomatic complexity}}
* {{Annotated link |DRAKON}}
* {{Annotated link |Event loop}}
* {{Annotated link |Flowchart}}
* {{Annotated link |Jeroo}}
* {{Annotated link |Recursion}}
* {{Annotated link |Scheduling (computing)}}
* {{Annotated link |Spaghetti code}}
* {{Annotated link |Switch statement}}
* {{Annotated link |Zahn's construct}}
{{div col end}}

== References ==
{{Reflist}}

== Further reading ==
* Hoare, C. A. R. "Partition: Algorithm 63," "Quicksort: Algorithm 64," and "Find: Algorithm 65." Comm. ACM 4, 321–322, 1961.

==External links==
{{wikibooks|Ada Programming|Control}}
{{wikibooks|Computer Programming|Control}}
*[https://web.archive.org/web/20070703050443/http://www.acm.org/classics/oct95/ Go To Statement Considered Harmful]
*[https://web.archive.org/web/20180716171336/http://www.fortran.com/fortran/come_from.html A Linguistic Contribution of GOTO-less Programming]
*{{cite web |url= http://pplab.snu.ac.kr/courses/adv_pl05/papers/p261-knuth.pdf |title= Structured Programming with Go To Statements |url-status= dead |archive-url= https://web.archive.org/web/20090824073244/http://pplab.snu.ac.kr/courses/adv_pl05/papers/p261-knuth.pdf |archive-date= 2009-08-24 }}&nbsp;{{small|(2.88&nbsp;MB)}}
*{{cite web|url= http://www.bitsavers.org/pdf/ibm/704/24-6661-2_704_Manual_1955.pdf |title=IBM 704 Manual }}&nbsp;{{small|(31.4&nbsp;MB)}}

[[Category:Control flow| ]]
[[Category:Iteration in programming]]
[[Category:Programming language comparisons]]
[[Category:Recursion]]
<!-- Hidden categories below -->
[[Category:Articles with example ALGOL 60 code]]
[[Category:Articles with example C code]]
[[Category:Articles with example C Sharp code]]

{{Sourceattribution|Control flow}}