Flow-control structures: Difference between revisions

{{Task|Control Structures}}

{{Control Structures}}

 

;Task:

===Loops===

11l supports ''L.break'' and ''L.continue'' to exit from a loop early or short circuit the rest of a loop's body and "continue" on to the next loop iteration.

Int result

 

L.was_no_break

result = -1

In addition, as shown in the foregoing example, 11l loops support an ''L.was_no_break'' suite which can be used to handle cases when the loop was intended to search for something, where the code would break out of the loop upon finding its target.

 

===Unconditional Branch (B)===

To perform a 'goto'.

B TESTPX goto label TESTPX

BR 14 goto to the address found in register 14

===Branch and Link (BAL)===

To perform a 'call' to a subroutine. The first register at execution time is the next sequential address to allow a 'return'.

LA 15,SINUSX load in reg15 address of function SINUSX

BALR 14,15 call the subroutine SINUX and place address RETPNT in reg14

...

BR 14 return to caller

 

===Conditional Branch (BC)===

Fistly a compare instruction set the condition code (cc), secondly a conditional branch is performed.

L 4,A Load A in register 4

C 4,B Compare A with B

BNL TESTGE Branch on Not Low if A>=B then goto TESTGE

BNE TESTNE Branch on Not Equal if A<>B then goto TESTNE

===Branch on Count (BCT)===

To perform unconditional loops.

LA 3,8 r3 loop counter

LOOP EQU *

... loop 8 times (r3=8,7,...,2,1)

BCT 3,LOOP r3=r3-1 ; if r3<>0 then loop

===Branch on Index (BX.)===

BXLE to perform loops in old Fortran style with 3 registers.

* do i=1 to 8 by 2

L 3,1 r3 index and start value 1

... loop 4 times (r3=1,3,5,7)

BXLE 3,4,LOOPI r3=r3+r4; if r3<=r5 then loop

BXH to perform backward loops with 3 registers.

* do i=8 to 1 by -2

L 3,1 r3 index and start value 8

... loop 4 times (r3=8,6,4,2)

BXH 3,4,LOOPI r3=r3+r4; if r3>r5 then loop

 

=={{header|6502 Assembly}}==

===JMP===

The jump instruction immediately jumps to any address:

The indirect jump instruction immediately jumps to the address contained in the address:

 

===JSR===

The jump to subroutine instruction pushes the address of the next instruction minus one onto the stack and jumps to any address:

A return from subroutine instruction pops the return address off the stack, adds one, and jumps to that location:

 

===NMI===

 

===goto===

Put_Line("Hello, World");

 

===exit===

loop

exit Outer; -- exits both the inner and outer loops

===asynchronous transfer of control===

A sequence of operation can be aborted with an asynchronous transfer of control to an alternative:

delay 10.0;

Put_Line ("Cannot finish this in 10s");

-- do some lengthy calculation

...

The alternative can be a delay statement or else an entry point call followed by a sequence of operations. The statement blocks at the delay or entry call and executes the sequence of the operation introduced by '''then abort'''. If blocking is lifted before completion of the sequence, the sequence is aborted and the control is transferred there.

 

See also [[Exceptions#ALGOL_68|Exceptions]] to see how '''ALGOL 68''' handles ''transput'' events.

===One common use of a label in '''ALGOL 68''' is to break out of nested loops.===

FOR j TO 1000 DO

FOR i TO j-1 DO

OD;

done: EMPTY

===Multi way jump using labels and '''EXIT''' to return result ===

[]PROC VOID award = (gold,silver,bronze);

 

);

 

===Another use is to implement finite state machines ===

INT condition;

PROC do something = VOID: condition := 1 + ENTIER (3 * random);

"State N"

);

===ALGOL 68G implements a Refinement Preprocessor to aid with top down code development ===

determine first generation;

WHILE can represent next generation

printf (($lz","3z","3z","2z-d$, current,

$xz","3z","3z","2z-d$, previous,

{{out}}

<pre>

=={{header|ALGOL W}}==

As well as structured flow-control structures (loops, if-then-else, etc.) Algol W has a goto statement. A goto can lead out of the current procedure, which can be used for error handling. Goto can be written as "goto" or "go to".

integer i;

integer procedure getNumber ;

writeon( "negative" );

endProgram:

 

=={{header|ARM Assembly}}==

B label ;Branch. Just "B" is a branch always, but any condition code can be added for a conditional branch.

;In fact, almost any instruction can be made conditional to avoid branching.

 

addeq R0,R0,#1 ;almost any instruction can be made conditional. If the flag state doesn't match the condition code, the instruction

 

=={{header|AutoHotkey}}==

Gosub, Label1

MsgBox, Label1 subroutine finished

Label2:

MsgBox, Label2 will not return to calling routine

 

=={{header|AWK}}==

The [awk] programming language is data driven. However, Awk has ''break'' and ''continue'' for loop control, as in C.

 

2

4

6

 

 

=={{header|BASIC256}}==

gosub subrutina

 

return

end

 

 

{{works with|BBC BASIC for Windows}}

BBC BASIC has '''GOSUB''' and '''GOTO''' but they are deprecated.

(loop)

PRINT "In subroutine"

WAIT 100

 

=={{header|Bracmat}}==

In Bracmat, the thing that comes closest to a GOTO construct is evaluation of a variable that contains some code, ending with an evaluation of the same variable. Due to tail recursion optimization this can run forever. Example:

= out$"Hi again!"

& !LOOP

)

& out$Hi!

{{out}}

<pre>Hi!

===goto===

One common use of goto in C is to break out of nested loops.

{

int i,j;

out:

return 0;

 

=={{header|C sharp|C#}}==

===return===

terminates the function and returns control to the caller.

return 5;

===throw===

throws (or rethrows) an exception. Control is transferred to the nearest catch block capable of catching the exception.<br/>

A <code>finally</code> block is always executed before control leaves the <code>try</code> block.

if (someCondition) {

throw new Exception();

} finally {

cleanUp();

===yield return and yield break===

In a generator method, <code>yield return</code> causes the method to return elements one at a time. To make this work, the compiler creates a state machine behind the scenes. <code>yield break</code> terminates the iteration.

foreach (int n in Numbers(i => i >= 2) {

Console.WriteLine("Got " + n);

}

}

{{out}}

<pre>

===await===

is used to wait for an asynchronous operation (usually a Task) to complete. If the operation is already completed when <code>await</code> is encountered, the method will simply continue to execute. If the operation is not completed yet, the method will be suspended. A continuation will be set up to execute the rest of the method at a later time. Then, control will be returned to the caller.

DoSomething();

await someOtherTask;//returns control to caller if someOtherTask is not yet finished.

DoSomethingElse();

}

===break and continue===

<code>continue</code> causes the closest enclosing loop to skip the current iteration and start the next iteration immediately.<br/>

<code>goto Label;</code> will cause control to jump to the statement with the corresponding label. This can be a <code>case</code> label inside a <code>switch</code>.<br/>

Because the label must be in scope, <code>goto</code> cannot jump inside of a loop.

for (int i = 0; i < 10; i++) {

if (conditionB) goto NextSection;

}

}

 

=={{header|C++}}==

=== goto ===

{{works with|GCC|3.3.4}}

 

int main()

std::cout << "Hello, World!\n";

goto LOOP;

 

Note that "goto" may also be used in conjunction with other forms of branching.

 

Exceptions are a way to give control back to a direct or indirect caller in case of an error. Note that throwing exceptions is usually very expensive, therefore they generally should only be used for exceptional situations.

#include <ostream>

 

<< "inside foobar(). Thus this catch-all block never gets invoked.\n";

}

 

=={{header|COBOL}}==

=== GO TO ===

Basic use:

 

PROCEDURE DIVISION.

 

GO TO Foo

 

A <code>GO TO</code> can take a <code>DEPENDING ON</code> clause which will cause program flow to go to a certain paragraph/section depending on a certain value.

DEPENDING ON Thing-To-Do

 

The previous example is equivalent to:

WHEN 1

* *> Do first thing...

WHEN OTHER

* *> Handle invalid thing...

 

=== ALTER ===

 

{{works with|GnuCOBOL}}

identification division.

program-id. altering.

*> fall through to the exit

exit program.

{{out}}

<pre>

=== PERFORM ===

The <code>PERFORM</code> statement can be used to transfer program flow to the specified sections/paragraphs in the subprogram, with control being returned when the end of the last paragraph/section or a relevant <code>EXIT</code> statement is reached.

 

PROCEDURE DIVISION.

Moo.

DISPLAY "Moo"

{{out}}

<pre>

=={{header|Comal}}==

===Call a procedure===

END // End of main program

PROC myprocedure

PRINT "Hello, this is a procedure"

 

===Exit a loop===

PRINT "I'm in a loop!"

EXIT

ENDLOOP

 

===Conditional exit===

LOOP

INPUT "Do you want to exit?":answer$

EXIT WHEN answer$="y"

ENDLOOP

 

===Goto===

GOTO label

PRINT "This line will never be output"

label:

PRINT "This program will end thanks to the evil GOTO statement"

 

=={{header|D}}==

=== goto ===

 

void main() {

writeln("I'm in your infinite loop.");

goto label1;

 

=== Exceptions ===

D supports the try/catch/finally mechanism:

 

class DerivedException : Exception {

writeln("finished (exception or none).");

}

 

=== Scope guards ===

 

For instance:

 

void main(string[] args) {

writeln("Gone, but we passed the first" ~

" chance to throw an exception.");

 

If the exception is thrown, then the only text that is written to the screen is "gone". If no exception is thrown, both calls to writeln occur.

 

[[Category:E examples needing attention]] <!-- Needs runnable examples, description of escape-catch, and maybe links to other flow control pages -->

 

=={{header|Erlang}}==

===CATCH-THROW===

Some Forth implementations have goto, but not the standard. It does have an exception mechanism.

CREATE ( size -- ) DUP , CELLS ALLOT

DOES> ( i -- a+i )

 

: safe-access ( i -- a[i] )

 

=={{header|Fortran}}==

A compiler may offer the "assigned GO TO" facility, with statements such as <code>ASSIGN 120 TO THENCE</code> scattered about: 120 is a statement label, not an integer, and any statement label may be assigned to variable THENCE (which is an integer variable) as execution proceeds. A relatively restrained usage would be to select the label of a suitable FORMAT statement to use in a READ or WRITE statement in place of a fixed label, without affecting the flow of control. But <code>GO TO THENCE</code> will cause a GO TO for the current address held in THENCE... Should you yield to temptations such as <code>THENCE = THENCE - 6</code> (treating it as an ordinary integer), a subsequent <code>GO TO THENCE</code> may end execution with an error message, or something else...

 

ASSIGN 1101 to WHENCE !Remember my return point.

GO TO 1000 !Dive into a "subroutine"

Common code, far away.

1000 do something !This has all the context available.

Since Algol in the 1960s it has been possible to define a routine within a larger routine that has access to all the context of the larger routine and so can be a convenient service routine for it, but Fortran does not allow a subroutine (or function) to be defined within a larger subroutine, except for the arithmetic statement function. One must write separate subroutines and struggle over providing access to context via COMMON and parameters. However, F90 introduced the MODULE arrangement whereby a collection of variables may all be referenced by a group of subroutines in the module without each having COMMON statements in common. Further, it allows a subroutine (or function) to use the CONTAINS feature, after which such a contained routine may be placed. Alas, it may not itself invoke CONTAINS even though Algol allows nesting as desired. And oddly, the contained routine must be at the ''end'' of the containing routine. So much for definition before usage. With such a facility, the possibility arises of perpetrating a GO TO from a contained routine to somewhere in its parent, however the F90 compilers are required to disallow access to outside labels, even those of FORMAT statements - rather a pity for that. Such escapes would have to copy whatever de-allocation steps were needed for a normal exit, which is simple enough on a stack-oriented design such as the B6700. However, its Algol compiler rejected attempts to jump from one routine ''into'' another (!) with the message "Bad GOTO. Too bad." Assembler programmers can do what they want, but for once, Fortran's designers show some restraint.

 

ASSIGN 1103 TO THENCE !Desired return from 2000.

GO TO 1000

So that "subroutine" 1000 would be invoked, which then invokes subroutine 2000, which returns via THENCE. And, instead of using simple variables such as THENCE and WHENCE, one could use an array and treat it like a stack... Those familiar with LISP or FORTH and similar languages will recognise a struggle to create new "verbs" from existing verbs, and their resulting usage in compound expressions. This is Philip Greenspun's "tenth" rule of programming.

 

 

===Deviant RETURN===

...

RETURN !Normal return from FRED.

...

RETURN 2 !Return to the second label.

More delicate souls prefer to see an integer parameter whose value will be set by FRED according to the desired condition, and every call to FRED would be followed by a computed GO TO on that value. Except that this statement is also disapproved of, so one is encouraged to code IF, or CASE, ''etc.'' and enjoy the repetition.

 

Similarly to escaping from a subroutine, within a DO-loop, a GO TO might jump out of the loop(s) - perhaps for good reason. More interesting is the possibility of jumping ''into'' a DO-loop's scope, possibly after jumping out - who knows what its index variable might have been changed to. This is considered poor form by others not writing such code and some compilers will reject any attempts. With the F77 introduction of IF ... THEN ... ELSE ... END IF constructions, jumping out of a block is still acceptable but jumping in is frowned on (even if only from the THEN clause to some part of its ELSE clause) and may be prevented.

 

statements...

NN:DO I = 1,N

statements...

END DO NN

A DO-loop can be given a label such as XX (which is ''not'' in the numeric-only label area of fixed source format Fortran, and the syntax highlghter has missed yet another trick of Fortran syntax) and its corresponding END DO can be given a label also: the compiler checks that they match and some programmer errors might thereby be caught. With such labels in use, the CYCLE and EXIT statements can name the loop they are intended for, so that CYCLE NN steps to the next iteration for <code>I</code> (as if it were a GO TO the END DO having its label as a suffix) while the EXIT XX exits both the numeric DO-LOOP and the DO-WHILE loop - without such labels only the innermost loop is affected and one can lose track. These labels must not be the name of any other entity in the source, and specifically not the name of the variable of the DO-LOOP concerned. Thus, if there are many DO I = 1,N loops, each must have its own label. There is unfortunately no equivalent to <code>NEXT I</code> as in BASIC instead of <code>END DO</code>so as to be clear just which DO-LOOP is being ended and for which index variable.

 

Still, they are available when using the -lang qb dialect.

This dialect provides the best support for the older QuickBASIC code.

'$lang: "qb"

 

Return

Sleep

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=64e4e68b1c6ce73341d08ba2d9333c07 Click this link to run this code]'''

Dim siCount As Short

 

Goto LoopIt

 

Output:

<pre>

===Goto===

Go has goto and labels. The following is an infinite loop:

inf:

goto inf

Gotos can jump forward or backward within a function but they have some restrictions. They cannot jump into any block from outside the block, and they cannot cause any variable to come into scope.

 

 

The defer statement sets a function or method to be executed upon return from the enclosing function. This is useful when a function has multiple returns. The classic example is closing a file:

 

func processFile() {

// more processing

// f.Close() will get called here too

 

===Goroutines===

 

The following program prints a mix of 1’s and 0’s.

 

import "fmt"

fmt.Println("0")

}

 

A goroutine terminates upon return from the function called in the go statement. Unlike with a regular function call however, it cannot return a value--the calling goroutine has long continued and there is nothing waiting for a return value.

 

Goroutines may not be able to communicate by returning values, but they have other ways. Principal is passing data through channels. Channel operations affect execution when they yield the processor, allowing other goroutines to run, but this does not normally alter flow of execution. The one exception is when channel operations are used in a select statement. A simple use,

select {

case <-phone1:

// talk on phone two

}

Syntax is strongly reminiscent of the switch statement, but rules for flow control are very different. Select will block if no channel operation is possible. If one is possible, it will execute that case. If multiple operations are possible, it will pick one at random.

===Process initialization===

 

=={{header|GW-BASIC}}==

20 IF a=2 THEN PRINT "This is a conditional statement"

30 IF a=1 THEN GOTO 50: REM a conditional jump

50 PRINT ("Hello" AND (1=2)): REM This does not print

100 PRINT "Endless loop"

 

=={{header|Haskell}}==

In the context of normal, functional-style code, there are no flow-control statements, because explicit flow control is imperative. A monad may offer flow control; what kinds are available depends on the monad. For example, the [http://haskell.org/haskellwiki/New_monads/MonadExit <code>ExitT</code> monad transformer] lets you use the <code>exitWith</code> function to jump out a block of statements at will.

 

import Control.Monad.Trans

import Control.Monad.Exit

when (x == 3 && y == 2) $

exitWith ()

 

=={{header|HicEst}}==

[http://www.HicEst.com More on HicEst's ALARM function]

 

2 READ(FIle=name, IOStat=ios, ERror=3) something ! on error branch to label 3

8 y = LOG( 0 , *9) ! on error branch to label 9

 

 

=={{header|Icon}} and {{header|Unicon}}==

'''break expr'''<br>

Default value of ''expr'' is the null value ''&amp;null''. This operator breaks out of the enclosing loop, yielding the expression as the result of the loop. Normally loops yield a failure ie no result, so you can write code like this:

if x := every i := 1 to *container do { # * is the 'length' operator

if container[i] ~== y then

else

write("did not find an item")

The expression given to ''break'' can be another ''break'', which effectively lets you break out of two levels of loop. Finally, the expression given to break can be the ''next'' command; for example

break break next

breaks out of two levels of loop and re-enters the top of the third-level enclosing loop.

 

'''fail'''<br>

Causes the the enclosing procedure to terminate without returning value. This is different from returning void or a null value that many other languages do when the code does not return an actual value. For example, in

x := ftn()

The value of x will not be replaced if ftn() issues the ''fail'' command. If ftn fails, then Goal-Directed Evaluation will also fail the assignment, therefore x is not assigned a new value. If the flow of control through a procedure falls off the end, the procedure implicitly fails.

 

'''error trapping'''<br>

The keyword &amp;error is normally zero, but if set to a positive value, this sets the number of fatal errors that are tolerated and converted to expression failure; the value of &amp;error is decremented if this happens. Therefore the now-common TRY-CATCH behaviour can be written as:

&error := 1

mayErrorOut()

handleError(&errornumber, &errortext, &errorvalue) # keyword values containing facts about the failure

}

Various idiomatic simplifications can be applied depending on your needs.

 

'''error throwing'''<br>

Errors can be thrown using the function

runerr(errnumber, errorvalue) # choose an error number and supply the offending value

 

=={{header|IDL}}==

===goto===

 

..some code here

 

(This is almost never used)

===on_error===

 

 

(This resumes at the label <tt>test</tt> if an error is encountered)

===on_ioerror===

 

 

(Same as <tt>on_error</tt>, but for EOFs and read-errors and such)

===break===

 

 

immediately terminates the innermost current loop (or <tt>if</tt> or <tt>case</tt> etc)

===continue===

 

 

immediately starts the next iteration of the current innermost loop

 

For example, here's an example of a program which loops over a sequence of integers, multiplying them by two (j's default prompt is 3 spaces, which makes line-at-a-time copy-and-paste simple, and the result here is displayed on the following line):

 

That said, J's control structures are documented at http://www.jsoftware.com/help/dictionary/ctrl.htm So, if you want to perform this same operation using a while loop, or a goto, you can do so. It's just... often not a good idea (but sometimes they are indispensable).

The <tt>break</tt> statement can be used to terminate a <tt>case</tt> clause in a <tt>switch</tt> statement and to terminate a <tt>for</tt>, <tt>while</tt> or <tt>do-while</tt> loop. In loops, a <tt>break</tt> can be ''labeled'' or ''unlabeled''.

 

case 1:

case 2:

}

...

 

===continue===

The <tt>continue</tt> statement skips the current iteration of a <tt>for</tt>, <tt>while</tt>, or <tt>do-while</tt> loop. As with <tt>break</tt> the <tt>continue</tt> statement can be ''labeled'' or ''unlabeled'' to allow iterating a loop level other than the current one in nested loops.

 

...

if (someCondition) { continue; /* skip to beginning of this loop */ }

}

....

 

=={{header|JavaScript}}==

 

Here is an example from the standard library:

 

=={{header|Julia}}==

Julia provides the @goto and @label macros for goto within functions. In addition, the "break" keyword is used for jumping out of a single loop, throw() of an exception can be used to jump out of a try() statement's code, and the assert() and exit() functions can be used to terminate a program.

function example()

println("Hello ")

println("world")

end

 

=={{header|Kotlin}}==

 

Here are some examples:

 

fun main(args: Array<String>) {

if (args.isNotEmpty()) throw IllegalArgumentException("No command line arguments should be supplied")

println("Goodbye!") // won't be executed

 

{{out}}

=={{header|Lua}}==

Lua has the <code>break</code>-command to exit loops.

while true do

i = i + 1

if i > 10 then break end

===Tail calls as GOTOs===

The following code - though obviously a useless infinite loop - will '''not''' cause a stack overflow:

return func2()

end

end

 

This is because Lua supports proper tail recursion. This means that because something being returned is necessarily the last action in a function, the interpreter treats a function call in this 'tail' position much like a GOTO in other languages and does not create a new stack level.

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

try

% do some stuff

% in case of error, continue here

end

 

=={{header|Maxima}}==

block(..., label, ..., go(label), ...);

 

 

/* error trapping */

 

=={{header|MUMPS}}==

===GOTO / G===

 

===HALT / H===

<p>Halt and Hang have the same abbreviation, i.e. "H" but (as a mnemonic) Halt takes no arguments. Halt stops the current process, and clears all Locks and devices in Use.

On the Cache variant of MUMPS, there is a $HALT special variable that can be set, the value of the $HALT special variable is a routine that is called before cleaning up (in effect, a specialized final error trap).</p>

 

===JOB / J===

 

 

===QUIT / Q===

<p>Exits a loop, or routine. It decreases the stack level. It can return a value to a calling routine if there is a value after it.</p><p>Quit is one of the commands that requires two spaces after it if it is followed in a line by more commands.</p>

===XECUTE / X===

SET I=0

XECUTE A

The above block will output "1".

<math>Insert formula here</math>

The <tt>LEAVE</tt> instruction causes immediate exit from one or more <tt>DO</tt>, <tt>SELECT</tt> or <tt>LOOP</tt> constructs.

 

if xx = 1 then leave -- loop terminated by leave

say 'unreachable'

 

A ''<tt>name</tt>'' parameter can be provided to direct <tt>LEAVE</tt> to a specific end of block (as defined by a <tt>LABEL</tt> option or in the case of a controlled <tt>LOOP</tt> the control variable of the loop.

 

...

loop yy = 1 to 10 -- yy is the control variable

otherwise do; say 'nl selection'; say '...'; end

end selecting

 

===ITERATE===

 

As with <tt>LEAVE</tt> an optional ''<tt>name</tt>'' parameter can be supplied to direct the instruction to a loop level outside the current level.

...

loop xx = 1 to 3

end

...

 

=={{header|Nim}}==

===Labeled Break & Continue===

Break and continue can be used with block labels to jump out of multiple loops:

for i in 0..1000:

for j in 0..1000:

if i + j == 3:

 

===Try-Except-Finally===

try:

var s = readLine f

echo "An error occurred!"

finally:

 

=={{header|OCaml}}==

An OCaml user can simulate flow control using exceptions:

 

 

let () =

print_endline "nothing found"

with Found res ->

 

=={{header|Oforth}}==

 

break allows to break the current loop :

 

continue allows to immediately start a new iteration :

 

perform is a method that transfer execution to the runnable on top of the stack, then returns :

 

=={{header|Oz}}==

 

The <code>case</code> statement can be used for [[Pattern Matching]], but also like a switch statement in C:

of 0 then {Foo}

[] 1 then {Bar}

[] 2 then {Buzz}

 

The Lisp-influenced [http://www.mozart-oz.org/home/doc/loop/index.html for-loop] is very powerful and convenient to use.

As an example for <code>choice</code>, a simple, but stupid way to solve the equation 2*X=18. We assume that the solution is somewhere in the interval 8-10, but we do not quite know what exactly it is.

 

proc {Stupid X}

choice

end

in

 

{{out}}

=={{header|Pascal}}==

===goto===

jumpto;

begin

goto jumpto;

...

 

===exception===

Z := DoDiv (X,Y);

except

on EDivException do Z := 0;

 

===Halt===

Halt stops program execution and returns control to the calling program. The optional argument

Errnum specifies an exit value. If omitted, zero is returned.

 

===Exit===

The optional argument X allows to specify a return value, in the case Exit

is invoked in a function. The function result will then be equal to X.

 

Calls of functions/procedures as well as breaks and continues in loops are described in the corresponding tasks.

Goto is typically looked down upon by most Perl programmers

 

# some code

 

=={{header|Phix}}==

===goto===

In 0.8.4+ Phix finally has a goto statement:

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (no goto in JavaScript)</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">p</span><span style="color: #0000FF;">()</span>

Imposing a self-policed rule that all jumps must be forward (or equivalently all backward, but never mixed) is recommended.

 

 

Previous versions had no hll goto statement, however the following work around was (and still is) available:

#ilASM{ jmp :label }

...

In top level code, label scope is restricted to a single ilASM construct,

but within a routine, the scope is across all the ilasm in that routine.

 

It is also possible to declare global labels, which are superficially similar:

#ilASM{ call :%label }

...

:%label

ret

Global labels cannot be declared inside a routine, and as shown (almost always)

require a skip construct. It is up to the programmer to ensure global labels

Personally I must agree with Douglas Crockford who says "I have never seen a piece of code that was not improved by refactoring it to remove the continue statement".<br>

Causes the next interation of the immediately surrounding loop to begin immediately, with any condition evaluated normally. The following two loops behave identically:

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

 

===exit===

causes immediate termination of the immediately surrounding for or while loop, with control passing to the first statement after the loop, eg:

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

 

===break===

Introduced in PHP 5.3, PHP now has a goto flow-control structure, even though most PHP programmers see it as a bad habbit (may cause spaghetti-code).

 

goto a;

echo 'Foo';

a:

echo 'Bar';

{{out}}

<pre>Bar</pre>

 

=={{header|PL/I}}==

LEAVE

The LEAVE statement terminates execution of a loop.

labelled statements. (This form is superseded by SELECT, above.)

[GO TO can also be spelled as GOTO].

 

=={{header|Pop11}}==

quitloop with argument exits from nested loops:

 

while condition2 do

if condition3 then

endif;

endwhile;

 

above quitloop(2) exits from both loops.

nested loops:

 

while condition2 do

if condition3 then

endwhile;

endwhile;

 

Another use is to implement finite state machines:

 

DO_SOMETHING();

if condition1 then

...

stateN:

 

Pop11 goto is a nonlocal one, so "jump out" from a chain of procedure calls:

 

define inner(n);

if n = 0 then

inner(5);

final:;

 

This is useful to exit early from successful recursive search, and for exception handling.

go_on is a multiway jump

 

 

If expression has value K the above will jump to label labK, if expression is not an integer, or if it outside range from 1 to N, then control passes to label elselab. The else part may be omitted (then out of range values of expression cause an exception).

it is just:

 

 

but it is also possible to specify one or more return values:

 

 

===chain===

chain has effect of "tail call" but is not necessarily in tail position. More precisely inside proc1.

 

 

finishes execution of proc1 and transfers control to the proc2 passing it x1, x2, and x3 as arguments. On return from proc2 control passes to caller of proc1.

===Goto===

Transfers control to the label referenced. It is not a safe way to exit loops.

top:

i = i + 1

Input()

CloseConsole()

===Gosub & Return===

Gosub stands for 'Go to sub routine'. A label must be specified after Gosub where the program execution continues and will do so until encountering a Return. When a return is reached, the program execution is then transferred immediately below the Gosub.

Gosub is useful when building fast structured code with very low overhead.

Gosub Calc

;X will now equal 7

Calc:

X+3*Y

===FakeReturn===

If the command Goto is used within the body of a sub routine, FakeReturn must be used to correct the stack or the program will crash.

 

Lable2:

Goto Lable2

EndIf

 

===OnErrorGoto===

This will transferee the program execution to the defined label if an error accrue.

 

X=1: Y=0

MyExitHandler:

MessageRequester("Error", ErrorMessage())

===OnErrorCall===

Similar to OnErrorGoto() but procedural instead.

;All open files etc can be closed here

MessageRequester("Error", ErrorMessage())

X=1: Y=0

Z= X/Y

 

=={{header|Python}}==

===Loops===

Python supports ''break'' and ''continue'' to exit from a loop early or short circuit the rest of a loop's body and "continue" on to the next loop iteration.

for i in range(n):

if (n%2) == 0:

else:

result = None

In addition, as shown in the foregoing example, Python loops support an ''else:'' suite which can be used to handle cases when the loop was intended to search for something, where the code would break out of the loop upon finding its target. In that situation the ''else:'' suite can be used to handle the failure. (In most other languages one is forced to use a "sentinel value" or a special flag variable ... typically set to "False" before the loop and conditionally set to "True" within the loop to handle situations for which the Python ''else:'' on loops is intended).

 

A custom Exception class is normally declared with the ''pass'' statement as no methods of the parent class are over-ridden, no additional functionality is defined and no attributes need be set. Example:

 

 

One normally would choose the most similar existing class. For example if MyException was going to be raised for some situation involving an invalid value it might be better to make it a subclass of ValueError; if it was somehow related to issues with inappropriate objects being passed around then one might make it a subclass of TypeError.

To create a "virtual base class" (one which is not intended to be directly instantiated, but exists solely to provide an inheritance to it's derived classes) one normally defines the requisite methods to raise "NotImplementedError" like so:

 

def __init__(self):

 

It then becomes necessary for any descendants of this class to over-ride the ''__init__()'' method. Any attempt to instantiate a "MyVirtual" object directly will raise an exception.

 

'''Case 1 - Try, Except'''

temp = 0/0

# 'except' catches any errors that may have been raised between the code of 'try' and 'except'

except: # Note: catch all handler ... NOT RECOMMENDED

print "An error occurred."

 

'''Case 2 - Try, Except'''

temp = 0/0

# here, 'except' catches a specific type of error raised within the try block.

except ZeroDivisionError:

print "You've divided by zero!"

 

'''Case 3 - Try, Except, Finally'''

temp = 0/0

except:

# Output :

# An error occurred

 

Note: Prior to version 2.5 a ''try:'' statement could contain either series of ''except:'' clauses '''or''' a ''finally:'' clause but '''not both.'''

It was thus necessary to nest the exception handling in an enclosing ''try:''...''finally:'' loop like so:

 

try:

pass

except SomeOtherException:

finally:

 

'''Case 4 - Try, Except, Else'''

temp = 1/1 # not a division by zero error

except ZeroDivisionError: # so... it is not caught

print "No apparent error occurred."

# Output :

 

'''Case 5 - Try, Except, break, continue'''

while 1: # infinite loop

try:

# Output :

# You've divided by zero. Decrementing i and continuing...

 

'''Case 6 - Creating your own custom exceptions, raise'''

 

class StupidError(Exception): pass

 

# Output :

 

===continue, else in "for" loop===

for i in range(4): # loop 4 times

print "I will always be seen."

if(__name__ == "__main__"):

 

===The "with" statement===

See [[http://www.python.org/peps/pep-0343.html PEP 0343, The "with" statement]]

 

max = 10

with open("some_file") as myfile:

if exit_counter > max:

raise Quitting

 

The ''with'' statement allows classes to encapsulate "final" (clean-up) code which will automatically be executed regardless of exceptions that occur when working "with" these objects. Thus, for the foregoing example, the file will be closed regardless of whether it's more than 10 lines long. Many built-in and standard library classes have "context managers" which facilitate their use in ''with:'' code. In addition it's possible to define special __enter__() and __exit__() methods in one's own classes which will be implicitly called by the interpreter when an object is used within a ''with:'' statement.

1

 

 

=={{header|Racket}}==

Racket doesn't have a <tt>goto</tt>, but like other implementations of Scheme, it adopts the mantra of "Lambda: the Ultimate GOTO" by having all tail calls optimized. This allows writing code that is no different from your average assembly code -- for example, here's a direct translation of [[Greatest_common_divisor#x86_Assembly]] into a Racket function:

 

#lang racket

 

(return %eax))

(main))

 

=== Exceptions ===

Racket has exceptions which are used in the usual way, and <tt>with-handlers</tt> to catch them. In fact, any value can be raised, not just exceptions. For example:

 

(define (list-product l)

(with-handlers ([void identity])

[(zero? (car l)) (raise 0)]

[else (loop (cdr l) (* r (car l)))]))))

 

=== Continuations ===

Phasers are blocks that are transparent to the normal control flow but that are automatically called at an appropriate phase of compilation or execution. The current list of phasers may be found in [[https://design.raku.org/S04.html#Phasers S04/Phasers]].

===goto===

Labels that have not been defined yet must be enclosed in quotes.

 

=={{header|REBOL}}==

Title: "Flow Control"

URL: http://rosettacode.org/wiki/Flow_Control_Structures

print div 10 2

print div 10 1

 

 

 

(Also, see '''function invocation''' and '''signal''' statement below.)

call routineName 50 /*one argument (fifty) passed. */

call routineName 50,60 /*two arguments passed. */

call routineName ,,,,,,,,,,,,,,,,800 /*17 args passed, 16 omitted. */

call date /*looks for DATE internally first*/

real-life example:

...

n=4

!=!*j

end /*j*/

 

===case===

 

(Also, see the '''return''' statement below.)

 

 

===function invocation===

 

(Also, see the '''call''' statement above.)

...

n=4

!=!*j

end /*j*/

 

===iterate===

 

(All indentations in REXX are merely cosmetic and are used for readability.}

do j=1 to 1000

if j//3==0 | j//7==0 then iterate

end /*m*/

end /*k*/

 

===go to===

===leave===

The '''leave''' statement transfer control to the next REXX statement following the &nbsp; '''end''' &nbsp; statement of the current (active) &nbsp; '''do''' &nbsp; loop in which the '''leave''' statement is located. &nbsp; The '''leave''' statement can also specify which '''do''' loop is to be left (terminated) if the '''do''' loop has a named variable.

say 'j=' j

if j>5 then leave

end /*m*/

end /*k*/

 

===raising conditions===

 

(Also, see the '''signal''' statement below.)

signal on syntax

...

say; say 'error code:' condition('D')

say; say "Moral: don't do that."

{{out}}

<pre>

following the instruction/command where the condition was encountered.

<br>A short example:

Call on halt

Do i=1 To 10000000

End

halt: Say i j

 

===return===

 

(Also, see the '''exit''' statement above.)

 

 

===select===

The '''select''' statement is used to conditionally test for cases to selectively execute REXX statement(s).

prod=1

a=7 /*or somesuch.*/

end /*select*/

 

 

===signal===

 

(Also, see '''raising conditions''' above.)

signal on error

signal on failure

say; say 'REXX variable:' condition('D')

say; say "Moral: shouldn't do that."

{{out}}

<pre>

 

=={{header|Ring}}==

i = 1

while true

i = i + 1

end

 

=={{header|Ruby}}==

=== exceptions ===

Use <code>raise</code> to throw an exception. You catch exceptions in the <code>rescue</code> clause of a <code>begin...end</code> block.

# some code that may raise an exception

rescue ExceptionClassA => a

ensure

# execute this code always

There is also a rescue modifier (example from the [http://www.pragprog.com/titles/ruby/programming-ruby Pickaxe book]):

result = values.map {|v| Integer(v) rescue Float(v) rescue String(v)}

 

=== catch and throw ===

<code>break</code> will only break out of a single level of loop. You can surround code in a catch block, and within the block you can throw a string or symbol to jump out to the end of the catch block (Ruby's GOTO, I suppose):

# ...

if some_condition

end

 

=== yield ===

<code>yield</code> passes control from the currently executing method to its code block.

 

=={{header|SAS}}==

STOP: to stop current data step */

data _null_;

8 44

;

 

=={{header|Scala}}==

{{libheader|Scala}}

import scala.util.continuations._

 

}

 

 

=={{header|Sidef}}==

===goto===

goto :world

say "Never printed"

@:world

{{out}}

<pre>

=== Indirect absolute jump ===

The <tt>000 n to CI</tt> instruction loads the value stored at address <i>n</i> into the Current Instruction register. For instance,

...

loads the number 10 into CI. Since CI is incremented <i>after</i> the instruction has been executed, rather than before, this fragment will cause execution to jump to address 11.

 

=== Indirect relative jump ===

<tt>100 Add n to CI</tt> increases the number in the CI register by the value stored at address <i>n</i>.

...

adds 10 to CI. Once again, CI is incremented <i>after</i> the instruction has been executed: so the machine actually jumps ahead by 11 instructions.

 

As an example, let's find a Pythagorean triple a,b,c such that a+b+c=n, where n is given. Here goto is used to break the two loops when such a triple is found. A '''[https://www.stata.com/help.cgi?m2_return return]''' can be used in such situations, unless one has to do further computations after the loop.

 

function pythagorean_triple(n) {

for (a=1; a<=n; a++) {

 

pythagorean_triple(1980)

 

=={{header|Tcl}}==

at some future time asynchronously, like this

 

 

which will call "<tt>myroutine</tt>" with parameter "<tt>x</tt>" 1000ms from 'now';

The scheduled task can be removed from the scheduler for example with

 

 

(other ways are possible).

whose display is updated once a second:

 

proc update {} {

.clockface configure -text [clock format [clock seconds]]

# now just create the 'clockface' and call ;update' once:

pack [label .clockface]

 

=== loop control ===

=== exception ===

Tcl's <code>catch</code> command can be used to provide a basic exception-handling mechanism:

puts "Error was $result"

} else {

''... process $result ...''

Tcl 8.6 also has a <tt>try</tt>…<tt>trap</tt>…<tt>finally</tt> structure for more complex exception handling.

# Just a silly example...

set f [open $filename]

} finally {

close $f

 

=== custom control structures ===

A novel aspect of Tcl is that it's relatively easy to create new control structures (more detail at http://wiki.tcl.tk/685).

For example, this example defines a command to perform some operation for each line of an input file:

upvar $linevar line ; # connect local variable line to caller's variable

set filechan [open $filename]

}

close $filechan

Now we can use it to print the length of each line of file "mydata.txt":

puts [string length $myline]

 

=={{header|Tiny BASIC}}==

LET N = 0

10 LET N = N + 1

105 PRINT "55555"

LET N = N + 1

 

=={{header|Visual Basic .NET}}==

This skips the line that changes the value of x to 5.

 

Dim x = 0

GoTo label

label:

Console.WriteLine(x)

 

=== On Error Goto ===

 

 

On Error GoTo label

'do something dangerous

label:

Console.WriteLine("Operation Failed")

 

''This style of code is rarely used.''

This performs a sequence of actions. If any action fails, the exception is discarded and next operation is performed.

 

On Error Resume Next

Operation1()

Operation3()

Operation4()

 

''This style of code is rarely used.''

This shows the classical and modern syntax for exiting a sub routine early.

 

If Not WorkNeeded() Then Exit Sub

DoWork()

If Not WorkNeeded() Then Return

DoWork()

 

=== Return value / Exit Function ===

This variable is write-only.

 

Foo3 = CalculateValue()

If Not MoreWorkNeeded() Then Exit Function

If Not MoreWorkNeeded() Then Return result

Return CalculateAnotherValue()

 

=={{header|Wren}}==

 

The following code demonstrates each of the above apart from '''Fiber.suspend''' which simply exits a CLI script.

var i = 1

while (true) {

 

var fiber = Fiber.new {

}

 

for (n in a) {

func.call(n)

var error = fiber.try() // catch any error

System.print("Caught error: " + error)

 

{{out}}

</pre>

 

 

=={{header|Yabasic}}==

{{works with|QuickBasic|4.5}}

gosub subrutina

 

return

end

 

=={{header|Z80 Assembly}}==

===Breaking out of a loop===

A subroutine that loops is often escaped with a conditional return, or, if it needs to unwind the stack frame, a conditional jump to an unconditional return.

ld a,(hl) ;HL is our pointer to the string we want to print

cp 0 ;it's better to use OR A to compare A to zero, but for demonstration purposes this is easier to read.

call PrintChar ;prints accumulator's ascii code to screen - on Amstrad CPC for example this label points to memory address &BB5A

inc hl ;next char

 

In the above example, the stack was never modified (besides the CALL pushing the return address) so <code>RET Z</code> was safe to use. Conditional returns are not safe to use if the stack needs to be unwound prior to exiting, since there's no way to conditionally unwind the stack without conditionally jumping to a section of code that does just that. In which case you don't need the return to be conditional anyway. This contrived example shows this in action.

 

push af

bar:

exit:

pop af

 

===DJNZ===

(Game Boy doesn't have this instruction - you'll have to use a combination of <code>DEC B</code> and <code>JR NZ</code>)

 

;your code goes here

 

===Block Instructions===

 

Essentially it's equivalent to the code below, except in the real <code>LDIR</code> the accumulator isn't actually altered in any way.

ld a,(hl)

ld (de),a

ld a,b

or c ;compare BC to zero

 

There are several others that work in a similar fashion, such as:

 

=={{header|zkl}}==

break; break(n); // break out of nth nested loop

try{ ... }catch(exception){ ... } [else{ ... }]

zkl has state machines for functional style stream processing. There are some special values that machines can return for flow control:

<pre>

</pre>

As an example, decode URL strings:

fcn(c){ if(c=="%")return(Void.Read,2); return(Void.Skip,c) },

has two machines. The second machine only runs if "%" is seen.

{{out}}<pre>http://foo.com/bar</pre>