Jump anywhere: Difference between revisions

You may also defer to more specific tasks, like [[Exceptions]] or [[Generator]].

<br><br>

 

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

===Direct Jump===

This is strictly a one-way trip, just like GOTO in BASIC. The program counter will be set to the specified address or label. This technique is limited to constants. In other words, a direct jump cannot be altered at runtime (self-modifying code notwithstanding)

 

===Indirect Jump===

This method is a form of the "computed GOTO" and lets you jump to an address stored in a pair of memory addresses. The least effective way to do this is as follows:

sta $00

lda #>PrintChar ;load into A the high byte of the address that PrintChar references.

sta $01 ;these need to be stored low then high because the 6502 is a little-endian cpu

 

The above example is just the same as a direct jump but more complicated for no added benefit. To actually use an indirect jump correctly, the input needs to be variable. Here's one way to do that:

 

JumpTable_Hi: db >PrintChar, >WaitChar, >ReadKeys, >MoveMouse ;each is the high byte of a memory address

 

lda JumpTable_Hi,x

sta $11

 

Depending on the value of x, you will be taken to a different procedure. Once again, this is a one-way jump and you can't return.

Another way to do this is with a "jump block."

 

JMP PrintChar

JMP WaitChar

JMP ReadKeys

JMP MoveMouse

 

Each jump instruction on the 6502 takes up 3 bytes: one for the JMP command itself, and two for the destination. Knowing this, we can use a variable that is a multiple of 3 to take us to the desired location. Let's pretend X is such a variable, and this routine lets us JMP to the "next" routine.

sta $21

txa

adc #$03

sta $20

 

If X was 0, the JMP takes us to WaitChar.

The 65c02, which was used in the Apple II and the Atari Lynx, can perform an indirect jump offset by X. This can be used to perform the above technique with much less setup.

 

word PrintChar

word PrintString

 

ldx #$02

 

Your index needs to be a multiple of 2 for this to work, most of the time you'll use <code>ASL A</code> then <code>TAX</code>to double your index prior to performing the indirect jump.

 

Unfortunately, you cannot simply replace "JMP" in the above example with "JSR" as that is not a valid command. What you have to do instead is a bit trickier. One way to accomplish this is with a "Return Table." Let's rewrite JumpTable_Lo and JumpTable_Hi in that format.

 

For this example, assume that all of those labels are subroutines that end in an RTS instruction. This method won't work otherwise. Once your return table is defined, you need some sort of variable that allows you to index into that table (i.e. select a subroutine to use).

We'll assume for the code below that the accumulator contains such a variable right now.

 

;execution is currently here

JSR UseReturnTable ;the address just after this label is pushed onto the stack.

RTS ;this "RTS" actually takes you to the desired subroutine.

;The top two bytes of the stack are popped, the low byte is incremented by 1,

 

Now all of that was a bit confusing wasn't it? Essentially this "abuses" the following concepts:

 

This is all very complicated, and luckily if you're programming for the 16-bit 65816 you don't have to do this. The 65816 (which was used in the Super Nintendo) has a special command just for doing this. <code>JSR ($####,x)</code> can be used for selecting from a list of functions to call.

 

=={{header|68000 Assembly}}==

In addition, for nearby subroutines, <code>BSR</code> can be used in place of <code>JSR</code> to save data. There is also <code>BRA</code> (branch always) for unconditional local jumping, which the original 6502 didn't have.

 

nop ;execution will never reach here

foo:

BGE D1_Is_Greater_Than_Or_Equal_To_D0

; your code for what happens when D1 is less than D0 goes here

 

===Absolute Jumps===

The 68000 has <code>JMP</code> and <code>JSR</code> for absolute jumping and function calls, respectively. When you <code>JSR</code>, the next <code>RTS</code> you encounter will return the program counter to just after the <code>JSR</code> statement you came from, provided that the return address is still on top of the stack when the <code>RTS</code> is executed. The CPU assumes that the top 4 bytes of the stack are the correct return address, and has no way of knowing if it's wrong. A sequence like this will likely result in a crash or otherwise undefined behavior:

 

; this is somewhere far away from the JSR above

foo:

MOVE.L D0,(SP)+

 

This can be abused for our benefit, allowing the programmer to select a subroutine from a list of functions. This trick goes by many names, some of the more common ones are "RTS Trick" or "Ret-poline" (a portmanteau of x86's <code>RET</code> and trampoline. <code>RET</code> is called <code>RTS</code> on the 6502 and 68000)

 

MOVE.W D0,#1

JSR Retpoline

 

SubroutineTable:

 

===Indirect Jumps===

 

<code>JCXZ</code> will jump only if the <code>CX</code> register equals 0. This is useful for skipping a loop if <code>CX</code> (the loop counter) is already zero.

foo:

LOOP foo ;subtract 1 from CX, and if CX is still nonzero jump back to foo

 

<code>LOOP label</code> is the equivalent of <code>DEC CX JNZ label</code> and, as the name implies, is used for looping. You might have heard that <code>DEC CX JNZ label</code> should always be used over <code>LOOP label</code> for better performance. This is only true on later x86-based CPUs - the reasons for <code>LOOP</code>'s poor performance weren't present on the 8086, and as such it's better to use there.

 

Although <code>JMP</code> was referred to as "unconditional" before, it does ''not'' have access to the entire address space of the CPU, unlike the 6502, Z80, and 68000. The 8086 uses a segmented memory model, where it uses 20-bit addresses despite being a 16-bit CPU. The other 4 bits are the "segment," and a <code>JMP</code> or <code>CALL</code> cannot exit that segment.

 

=={{header|Ada}}==

procedure Goto_Test is

begin

end Goto_Test;

 

 

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

ARM is very unique in that the program counter can be directly loaded as well as influenced by branching. You need to be very careful when doing this, because loading a value into <code>PC</code> that isn't a multiple of 4 will crash the CPU.

 

 

This sequence of commands can store registers onto the stack, retrieve them, and return all at once. For this to work properly the only difference in the choice of registers can be that you push <code>LR</code> and pop <code>PC</code>.

 

If you don't have access to unified syntax, the above will only work in THUMB mode. For 32-bit ARM, you may have to use

 

=={{header|Arturo}}==

 

=={{header|AutoHotkey}}==

function()

{

Suspended

 

 

=={{header|BASIC}}==

 

Some versions of basic allow line labels to be used. Here we jump to a label:

{{works with|BaCon}}

{{works with|QuickBASIC}}

==={{header|Applesoft BASIC}}===

caveat: http://www.u.arizona.edu/~rubinson/copyright_violations/Go_To_Considered_Harmful.html

100 GOTO 110 : REM JUMP TO A SPECIFIC LINE

110 RUN 120 : REM START THE PROGRAM RUNNING FROM A SPECIFIC LINE

280 STOP : REM BREAK THE PROGRAM

290 END : REM END THE PROGRAM

 

BASIC256 supports both <code>goto</code> and <code>gosub</code>.

{{works with|QBasic}}

{{works with|Yabasic}}

gosub sub1

print "Fifth line."

Finished:

print "... with goto and gosub, thankfully."

{{out}}

<pre>Igual que la entrada de FutureBasic.</pre>

 

=={{header|C}}==

C has <code>goto LABEL</code> keyword.

else goto negative;

 

 

both:

The label must be literal, not computed at run time. This won't work:

<!-- Except if you're using GCC extensions, when you can do something that's very similar to that. Scary stuff! -->

for (j = 0; ...) {

if (condition_met) goto finish;

}

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

danger: /* unless you jumped here with i set to a proper value */

printf("%d\n", i);

For unwrapping call stack and go back up to a caller, see [[Exceptions#C|longjmp example]]; more powerful, but more expensive and complicated, is POSIX [[Exceptions/Catch an exception thrown in a nested call#C|ucontext]].

The best application for goto is error handling, this simplifies the resource clean up of a large function.

 

 

char *str;

int *array;

...// read in the csv file and convert to integers

 

 

 

char *str;

int *array;

exit:

return;

 

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

Like C, C# also has a <code>goto LABEL</code> keyword. This section is partly copied from the section on C, since both languages share common syntax.

else goto negative;

 

 

both:

The label must be literal, not computed at run time. This won't work:

 

You can <code>goto</code> ''almost'' anywhere inside the same method, but can't go across method boundaries. It's sometimes used to break out of nested loops:

for (j = 0; ...) {

if (condition_met) goto finish;

}

The label must be in scope, so you cannot jump into a loop. This will not compile:

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

danger:

Console.WriteLine(i);

 

In C#, you can also <code>goto</code> a label from within any section of a try .. catch block. However, it is not permitted to jump out of a finally block.

tryAgain:

try {

finally {

//goto end; //Error

 

Another usage of <code>goto</code> is to jump between <code>case</code> labels inside a <code>switch</code> statement:

int result = 0;

switch (n) {

}

return result;

 

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

Like C, C++ also has a <code>goto LABEL</code> statement which can be used to jump within a function.

 

#include <utility>

 

cout << "k = " << k << "\n"; // k was never initialized, accessing it is undefined behavior

 

{{out}}

 

=={{header|COBOL}}==

* Nobody writes like this, of course; but...

* You can jump anywhere you like.

* That's right, folks: we don't just have GO TOs, we have GO TOs whose

* destinations can be changed at will, from anywhere in the program,

* at run time.

* But bear in mind: once you get there, the GO TO no longer goes to

* where it says it goes to.

* You think that's bad? You ain't seen nothing.

{{out}}

<pre>Edsger who now?

'''COBOL''' also supports computed go to phrases, given a list of labels (paragraph names) and an integer index into that list.

 

 

=={{header|Common Lisp}}==

In Common Lisp you can jump anywhere inside a tagbody.

(tagbody

beginning

(sleep 1)

(go middle))

{{out}}

<pre>

=={{header|Computer/zero Assembly}}==

A <tt>JMP</tt> (jump) instruction can transfer control to any point in memory. Its target can be modified at run time, if required, by using instruction arithmetic:

SUB somewhere

ADD somewhereElse

STA goto

By the time execution reaches the instruction labelled <tt>goto</tt>, that instruction has become <tt>JMP somewhereElse</tt>. (This kind of coding does not, however, necessarily make the flow of control easier to follow.)

 

 

=={{header|DCL}}==

$

$ if p1 .eqs. "" then $ goto main

$ sub4: subroutine

$ exit

{{out}}

<pre>$ @jump_anywhere

Déjà Vu supports continuations:

 

!print "First part"

yield

local :continue example

!print "Interrupted"

{{out}}

<pre>First part

Every function/procedure must have your own labels, globals labels won't work in local functions.

The label must be literal, not computed at run time.

var

x: Integer = 5;

readln;

end.

Although you can (not that you should) jump into a loop, too. If you use a loop variable, it will start with its value.

If the loop variable has a value out range loop limits, then you cause a intinity loop.

label

inloop, outloop;

readln;

end.

{{out}}

<pre>

This won't work.

 

label

tryAgain, finished;

readln;

end.

=={{header|Erlang}}==

Jumps are limited to [[Exceptions]].

=={{header|ERRE}}==

ERRE has a GOTO statement in the form GOTO <label>. <label> is a numercic string and must be declared. ERRE GOTO is local only: you can jump only within the same procedure or within the main program. In the following example there are two errors:

PROGRAM GOTO_ERR

 

IF J<>0 THEN GOTO 100 END IF

END PROGRAM

You can't jump from procedure P1 to procedure P2 or from main to procedure P2 (label 99). Jump to label 100 is allowed (within main program).

 

A continuation is conceptually simple in Factor. It is a tuple consisting of slots for the five stacks that make up the entire execution context: data stack, call stack, retain stack, name stack, and catch stack. To create a continuation from the current execution context, use <code>current-continuation</code>.

 

 

{{out}}

<pre>

Following is a simple example where we reify a continuation before attempting to divide 1 by 0. Note the current execution context (a <code>continuation</code> object) is placed on the top of the data stack inside the <code>callcc0</code> quotation which <code>continue</code> then reifies.

 

 

{{out}}

<pre>

 

We can even reify a continuation while taking an object back with us.

 

 

{{out}}

 

=={{header|Forth}}==

\ words 'proc1' and 'proc2'. gotos are used here to jump

\ into and out of the two words at various points, as well

 

5 1 proc2

 

Output:

line 2 --> item6 item1 item7 item2 item8 item3 item9 item4 item10 item5

line 3 --> item6 item1 item7 item2 item8 item3 item9 item4 item10 item5

line 4 --> item6 item1 item7 item2 item8 item3 item9 item4 item10 item5

 

 

\ a data structure to store goto/jump addresses instead of

\ separate variables, and two additional words 'mark_goto' and

 

: go 5 1 6 goto ; go

 

Output:

line 2 --> item6 item1 item7 item2 item8 item3 item9 item4 item10 item5

line 3 --> item6 item1 item7 item2 item8 item3 item9 item4 item10 item5

line 4 --> item6 item1 item7 item2 item8 item3 item9 item4 item10 item5

 

 

\ swiftforth may crash, iforth does not function.

 

5 1 go

 

 

Output:

iteration 2 --> goto1 goto3 goto5 goto7 goto9 goto2 goto4 goto6 goto8

iteration 3 --> goto1 goto3 goto5 goto7 goto9 goto2 goto4 goto6 goto8

iteration 4 --> goto1 goto3 goto5 goto7 goto9 goto2 goto4 goto6 goto8

 

 

Although Forth was designed to be a structured programming language it is simple to add a generic jump anywhere.

The Forth dictionary of WORDs is essentially a linked list of labels. We can find the execution token for any label in the dictionary with the ['] operator and jump to it with the keyword EXECUTE.

 

TEST

: HELLO ." Hello" ;

 

GOTO CR GOTO HELLO GOTO SPACE GOTO WORLD

 

=={{header|Fortran}}==

The following program demonstrate the use of the various 'Goto' constructs in the -lang fb dialect only:

 

 

' compiled with -lang fb (the default) and -e switches

Print

Print "Pres any key to quit"

 

{{out}}

 

All that said, don't use spaghetti code -- use functions. You can still by spark plugs for a 1985 Yugo, but why?

 

print "First line."

"Outa here"

print "... with goto and gosub, thankfully."

Output:

<pre>

 

For example:

 

import "fmt"

k++

fmt.Println(k)

 

{{out}}

4

</pre>

 

import "fmt"

func init() {

fmt.Println("run first")

 

=={{header|Harbour}}==

 

First some boilerplate, where we define labels and goto "operator".

 

data LabelT r m = LabelT (ContT r m ())

 

runProgram :: Monad m => ContT r m r -> m r

 

Here is example of using labels in IO:

do

start <- label

then do lift $ putStrLn "Name can't be empty!"

goto start

 

{{Out}}

 

We can build tiny EDSL to get rid of explicit lifting and to add refferences:

 

readInt = lift $ readLn >>= newIORef

get ref = lift $ readIORef ref

set ref expr = lift $ modifyIORef ref (const expr)

 

and implement famous Euclid's algorithm as an imperative program:

do -- |

start <- label -- <-----+ |

when (n > m) $ set nr (n - m) -- |

when (m > n) $ set mr (m - n) -- |

 

{{Out}}

In native Haskell such flow jumps are done by function calls:

 

where

start = do

| n == m = n

| n < m = loop n (m-n)

 

Or without explicit recursion and branching:

 

import Control.Monad.Trans.Maybe

 

process = gcd <$> (lift readLn >>= exitOn 0) <*> lift readLn

 

 

=={{header|i}}==

concept there() {

print("Hello there")

//Move to the code contained in the 'there' function.

there()

 

=={{header|J}}==

 

For example:

smoutput 'Now we are in F'

G''

F''

Now we are in F

 

 

smoutput 'a'

label_b.

c

g

 

=={{header|Java}}==

The closest thing that Java has to a "goto" is labelled loops:

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

loop3: do {

}

//loop1 calculations executed after loop2 is done or if the break is executed, skipped if the continue is executed

 

It's frowned upon to use exceptions for non-exceptional paths, so get ready to frown at this fizz-buzz player that makes use of <tt>try/catch/finally</tt> to jump to the right places for printing:

public class FizzBuzzThrower {

public static void main( String [] args ) {

}

}

 

=={{header|jq}}==

jq supports named labels ("label $NAME") and break statements ("break $NAME"). Usage

follows the pattern:

 

When, during program execution, a "break" statement is encountered, the program

Break statements are used to interrupt a generator. For example, to emit

the least positive integer satisfying sin(1/N) == (1/N) using IEEE 64-bit arithmetic:

 

Here, the "while" filter is an unbounded generator. The answer is 46530688.

Indeed, a better way to solve the type of problem mentioned above is by using one of the jq-provided control structures.

For example, the above problem can be solved more succinctly and transparently using until/2:

 

=={{header|Julia}}==

 

Julia provides the @goto and @label macros for goto within functions but these cannot be used at the global level or to jump from one function to another. The macros can however be used for a typical use of @goto -- jumping out to a specific level from nested loops within a function.

function example()

println("Hello ")

println("world")

end

 

=={{header|Kotlin}}==

 

For example:

 

fun main(args: Array<String>) {

}

}

 

{{out}}

 

* Lingo supports "unwinding the call stack" via the abort command that exits the current call stack:

abort()

end

foo()

put "This will never be printed"

 

* Rarely used, but Lingo supports saving a continuation via the play ... play done construct:

 

-- Start some asynchronous process (like e.g. a HTTP request).

-- The following will be executed only after 'play done' was called in the asynchronous process code

put "Done. The asynchronous process returned the result:" && _global.result

 

=={{header|Logtalk}}==

=={{header|Lua}}==

Lua 5.2 introduced a <code>goto</code> statement along with labels. It was somewhat controversially implemented instead of a <code>continue</code> keyword, but it is more flexible and supports other types of jumps as well. <code>goto</code> only supports statically-defined labels.

goto skip_print

print "won't print"

end

print "not found"

 

=={{header|M2000 Interpreter}}==

After Else and Then we can place number to jump (same as Goto number). Goto can't take variable. We can use On Goto to use an expression to choose label (we can place numbers or named labels)

===Using GOTO and GOSUB===

Module Checkit {

Module Alfa {

}

Checkit

 

===Simulate Run Basic Entry===

Module LikeRunBasic {

for i = 1 to 10

}

LikeRunBasic

 

===Simulate Go Entry===

 

Module LikeGo {

\\ simulate Go for

LikeGo_No_Labels

 

 

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

=={{header|MBS}}==

 

 

=={{header|МК-61/52}}==

 

 

'''XX''' is any address.

* &nbsp; <code>jal 0xNNNNNNNN</code> sets the program counter equal to <code>0xNNNNNNNN</code>, and moves the old program counter plus 8 into register <code>$ra</code>.

* &nbsp; <code>jalr $NN,0xNNNNNNNN</code> sets the program counter equal to <code>0xNNNNNNNN</code> and moves the old program counter plus 8 into register <code>$NN</code>.

 

Branches apply a signed offset to the current program counter. They are limited only by distance; scope does not exist in assembly. Typically you do not have calculate this offset yourself. The assembler will abstract this out of the hardware and let you use a label like you would with a <code>j</code>. The actual offset is calculated during the assembly process, which means you don't have to measure it yourself by counting bytes.

 

Some interpreters will allow you jump between blocks of the same depth. Others will let you leave, but not enter, a block.

Goto Label

;Go to a line below a label

. Goto Out

Out Quit

 

=={{header|Neko}}==

Neko supports colon terminated labels, and a builtin '''$goto(label)'''. This builtin is special in that the label argument is not dereferenced as a normal Neko expression, but specifically as a label.

 

$goto(skip)

$print("Jumped over")

skip:

 

The NekoVM keeps exception and call stacks in sync when jumping across boundaries to code blocks, but may not include some initiating side effects. For instance, jumping past a '''try''' phrase into the middle of the code block (where the try is not evaluated) will not catch the '''catch''' of the try catch pair. There are other cases where '''$goto()''' can cross semantic boundaries; a practice best avoided.

=={{header|Nim}}==

Nim has exceptions and labelled breaks:

block outer:

for i in 0..1000:

for j in 0..1000:

if i + j == 3:

 

=={{header|Oforth}}==

 

Some portion of code can be restarted (as recursion) and skipped (as continuation).

; recursion:

(let loop ((n 10))

 

(print "ok.")

 

=={{header|PARI/GP}}==

=={{header|Perl}}==

Perl's <code>goto LABEL</code> and <code>goto EXPR</code> are a little too powerful to be safe. Use only under extreme duress (actually, not even then). <code>goto &SUB</code> is esoteric but much more innocuous and can occasionally be handy.

print "In outer, calling inner:\n";

inner();

 

print "\nCalling inner:\n";

 

=={{header|Phix}}==

Using this 'baroque' syntax is viewed as an effective means of dissuading novices from adopting goto as a weapon of choice.

Note that pwa/p2js does not support #ilASM{} at all. <!--(notonline)-->

...

The above shows a global label, which can only be declared in top-level code, not inside a routine, and can be referenced from anywhere.

 

Local labels are declared with a double colon (::) and referenced with a single colon

...

They can only be referenced at the top level from within the same #ilASM construct, or anywhere within the routine where they are defined.

Phix also supports anonymous local labels

...

@@:

...

There are also optional (global) labels:

[32]

pop eax

push qword[rsp]

[]

These are obviously more useful when the reference and declaration are in separate files: if the file containing the declaration is not included, the reference quietly resolves to 0.

The above code shows how to duplicate the return address and discard on return, so that execution carries on at the next instruction if the definition is not present.

 

Lastly (for completeness) there are init labels, defined using

These are used by the VM (eg builtins\VM\pStack.e declares :>initStack) to specify initialisation code which must be run at startup. They can also be called like a normal global label.

 

 

There is no 'go' or 'goto' function in PicoLisp, but it can be emulated with normal list processing functions. This allows "jumps" to arbitrary locations within (the same or other) functions. The following example implements a "loop":

(prinl "This is 'foo'")

(printsp N)

Test:

<pre>: (foo 7)

<br>In structured programming, the only place where a <code>goto</code> can be is inside <code>on</code> units to handle exceptions without recursion.

 

 

=={{header|PL/SQL}}==

PL/SQL supports both GOTOs and structured exception handling:

i number := 5;

divide_by_zero EXCEPTION;

DBMS_OUTPUT.put_line( 'Finally' );

END;

{{out}}

<pre>startLoop

current loop. The syntax for a label is as follows (this example shows a

label in a While loop):

:myLabel while (<condition>) { <statement list>}

The label is a colon followed by a name that you assign. The label must be

the first token in a statement, and it must be followed by the looping

This schematic example has a While statement with a For statement:

:myLabel while (<condition 1>)

{

}

$a = $c # A statement after the labeled While-loop

 

If condition 2 evaluates to True, the execution of the script skips down

You can nest many labeled loops, as shown in the following schematic

example.

:red while (<condition1>)

{

}

# After "red" loop

If the $b variable evaluates to True, execution of the script resumes

after the loop that is labeled "red". If the $c variable evaluates to

 

=={{header|PureBasic}}==

OpenConsole()

Gosub label4

 

ErrorHandler:

{{out}}

<pre>eins zwei eins zwei eins zwei - drei -</pre>

 

The "goto" module was an April Fool's joke, published on 1st April 2004. Yes, it works, but it's a joke nevertheless. Please don't use it in real code! For those who like computer languages with a sense of humour it can be downloded [http://entrian.com/goto/goto-1.0.tar.gz here]. It is well documented and comes with many examples. My favorite:

# Example 2: Restarting a loop:

from goto import goto, label

goto .start

print output, "\n"

It goes the extra mile and adds a <code>comefrom</code> keyword. This should be used only if you are evil and proud of it. It is reported to have caused maintenance programmers to have so strongly believed themselves insane that it became so. They are now under strong medication in padded cells. Basically whenever the code passes a label it jumps to the comefrom point. For best results I advise writing the comefrom code as far as possible from the label and using no comments near the label.

 

{{works with|BASIC256}}

{{works with|Yabasic}}

PRINT "First line."

GOSUB sub1

Finished:

PRINT "... with goto and gosub, thankfully."

{{out}}

<pre>Igual que la entrada de FutureBasic.</pre>

 

=={{header|QB64}}==

' Jumps in QB64 are inherited by Qbasic/ QuickBasic/ GWBasic

' here a GOTO demo of loops FOR-NEXT and WHILE-WEND

Q = Q + 1

GoTo 2

 

=={{header|Quackery}}==

Quackery is an assembler insomuch as there is a direct, one to one, left to right correspondence between Quackery source code and the contents of the resultant nest, which is convenient. (There are a few simple-to-understand exceptions, and of course because the assembler is extensible, you can add more of those if you like, but generally it's easy to figure out where a specific item is in the nest.

 

 

To achieve this, <code>]'[</code> advances the offset on top of the return stack, like <code>]else[</code>, but also puts a copy of the item skipped over on the stack. (i.e. the nest following <code>jump-into</code> in the example) It puts this, with an offset of 0, onto the call stack (with <code>]do[</code>. Then it uses <code>' ]else[ swap of</code> to build a nest of the specified number of instances of <code>]else[</code>, and puts that on the call stack, so that it will be evaluated after exiting <code>jump-to</code>, and increment the offset of the top of the call stack (i.e. the nest following <code>jump-to</code>) that number of times.

 

 

5 jump-into

( 0 1 2 3 4 offsets of each item )

( 5 6 7 8 9 from start of nest )

 

{{out}}

 

As a little example:

(define (never-divides-by-zero return)

(displayln "I'm here")

; I'm here

; "Leaving" (because that's what the function returns)

 

Here, return is the program continuation being passed to the function, when it is called, the string "Leaving" i the result of the function and the following code is never executed.

Where we generate elements of a list one at a time:

 

;; [LISTOF X] -> ( -> X u 'you-fell-off-the-end-off-the-list)

(define (generate-one-element-at-a-time a-list)

;; time to return the generator

generator)

 

=={{header|Relation}}==

Retro allows the user to jump to any address.

 

 

When executed, the stack will contain 20; control does not return to the '''foo''' function.

 

===Label-based jumps===

inner-loop: loop {

# NYI # goto inner-loop if rand > 0.5; # Hard goto

LEAVE { say "Leaving outer loop block" }

LAST { say "Ending outer loop" }

Produces random output, but here's a representative run:

 

 

Continuations in Raku are currently limited to use in generators via the gather/take model:

if $i.is-prime {

say "Taking prime $i";

}

This outputs:

 

 

Exceptions are fairly typical in Raku:

Will walk up the stack until either some `CATCH` block intercepts the specific exception type or we exit the program.

 

But if a failure should be recoverable (e.g. execution might reasonably continue along another path) a failure is often the right choice. The fail operator is like "return", but the returned value will only be valid in boolean context or for testing definedness. Any other operation will produce the original exception with the original exception's execution context (e.g. traceback) along with the current context.

my $failure = foo;

say "Called foo";

say "foo not true" unless $failure;

say "foo not defined" unless $failure.defined;

Produces:

 

 

However, an exception can `.resume` in order to jump back to the failure point (this is why the stack is not unwound until after exception handling).

if $i == 0 {

die "Are you sure you want /0?";

CATCH {

when ~$_ ~~ m:s/Are you sure/ { .resume; #`(yes, I'm sure) }

This code raises an exception on a zero input, but then resumes execution, divides be zero and then raises a divide by zero exception which is not caught:

 

<br>as long as the '''END''' or the '''DO''' loop isn't executed.

<br>The following used PC/REXX to illustrate this example.

say 'starting...'

signal aJump

cJump: say 'and here we are at cJump.'

exit

{{out}}

<pre>

As mentioned above some implementations may have restrictions on that.

This Signal jumps into a Do loop inside a Procedure:

signal label

say 'This is never executed'

End

Return

Without the 'Signal real_start' which leads us out of the control structure the program would end with a syntax error when encountering the End correponding to the Do.

 

I recommend to use Signal only for condition handling and 'global' jumps to labels that are not within some structured constructs such as Do...End

An example:

* 12.12.2012 Walter Pachl

**********************************************************************/

Say 'argument must be a or b or omitted'

Exit

This can be useful when the different parts of the program span a few pages.

Also a Signal eoj in order to Exit from any point in the program to some final activities can be useful.

====Simple====

A simple example of labels and goto:

. "The label 'touch' is used to let the player touch the robot"

. "to execute the following"

* "Label B was reached"

end

 

It prints "Label B was reached", skipping "label_a" entirely.

====Conditional====

This will jump to a given label, depending on the condition of "local1":

set "local1" to 2

end

* "Label B was reached"

end

 

Since "local1" equals 2, it prints "Label B was reached".

When you goto a label, it chooses the top-most label name in the code.

However, with the use of "zap" and "restore", we can use the same label name multiple times in our code:

end

: "touch"

restore "label_a" 1

end

 

When the first label is reached, it zaps "label_a" once. This allows us to reach the second label below. Conversely, restoring "label_a" allows us to go back to the first label once more.

With subroutines, we can jump to a given label and come back to where we left off after we called the inital "goto" statement.

To use these, the labels and the string supplied in the "goto" statements must have a number sign (#):

. "The 'wait' statements are used to demonstrate what is happening"

set "local1" to 1

* "Label D was reached"

goto "#top"

 

The following is printed out in order:

Label A was reached

Done with Label A

Label D was reached

Skipped finishing Label B and C

 

Using "#return", we go back up to the last "goto" statement called. However, using "#top" will ignore all the other subroutines called previously and go straight back to the first "goto" statement that started it all (in this case, goto "#label_b").

The next example abuses a continuation to solve [[FizzBuzz#Ruby]]. It is slower and more confusing than an ordinary loop.

{{libheader|continuation}}

 

if a = callcc { |c| [c, 1] }

puts

c[c, i + 1]

 

This code uses the Continuation object <code>c</code> to jump to the top of the loop. For the first iteration, <code>callcc</code> creates <code>c</code> and returns <code>[c, 1]</code>. For later iterations, <code>callcc</code> returns <code>[c, i + 1]</code>. For the last iteration, <code>callcc</code> returns <code>nil</code> to break the loop.

 

 

=={{header|SPL}}==

In SPL jumps can be non-conditional and conditional.

This is an example of non-conditional jump to label "myLabel":

...

This is an example of conditional jump to label "4", which is done if a=0:

...

In SPL it is possible not only jump, but also visit a label. "Visiting" a label means that program execution can be returned back to the place from where label was visited.

This is an example of visiting label "label 55":

#.output("1")

:label 55

#.output("2")

and output is:

{{out}}

=={{header|SSEM}}==

The SSEM provides two jump instructions: the absolute jump <tt>000 <operand> to CI</tt> and the relative jump <tt>100 Add <operand> to CI</tt>. The operand in both cases is a memory address, whose contents are to be either loaded into the CI (Current Instruction) register or else added to it. Since CI is incremented <i>after</i> an instruction is executed, not before, the value stored at the operand address must be one less than the value we actually want. For example, this code accomplishes a jump to absolute address 20:

and this accomplishes a relative jump forward by five words:

 

=={{header|Tcl}}==

Tcl has both [[Exceptions#Tcl|exceptions]] and (from 8.6 onwards) [[Generator#Tcl|generators/coroutines]] but no unstructured goto ability. However, the main case where it might be desired, coding a general state machine, can be handled through metaprogramming (as discussed at some length on [http://wiki.tcl.tk/8363 the Tcler's Wiki]) so the absence is not strongly felt in practice.

 

=={{header|VBA}}==

Debug.Print "VBA only allows"

GoTo 1

two:

Debug.Print "On <n> GoSub let you jump to the n-th label": Return

<pre>VBA only allows

jumps in procedures with GoTo

=={{header|VBScript}}==

In VBScript, there is no <code>goto</code> statement. It is a good thing for structured programming.

 

=={{header|VTL-2}}==

If the expression does not evaluate to a line number present in the program, the program continues with the next highest line number or stops if there is no line with a number higher that the expression.<br>

The following program demonstrates this - prompiting the user for a label to goto. (In an expression, <code>?</code> indicates a value should be read from the console, assigning to <code>?</code> prints the assigned value)<br>

1020 #=?

1030 ?="@1030"

1060 #=1010

2000 ?="@2000"

{{out}}

<pre>

 

The Fiber class also has a ''try'' method for catching errors (which won't be described here) and a static ''abort'' method which (unless caught) exits the script altogether if an error occurs.

for (i in 1..10) {

if (i == 1) continue // jumps to next iteration when 'i' equals 1

System.print("yielding")

fiber.call() // resumes the fiber

 

{{out}}

resuming

aborting

</pre>

 

{{works with|QBasic}}

{{works with|BASIC256}}

gosub sub1

print "Fifth line."

Finished:

print "... with goto and gosub, thankfully."

{{out}}

<pre>Igual que la entrada de FutureBasic.</pre>

<code>JR</code> adds a signed displacement byte to the program counter. This takes one less byte to encode than a <code>JP</code> but cannot jump more than 127 bytes forward or 128 bytes backward. The programmer can either specify a constant value as the operand or a labeled section of code. If a label is used, the assembler will calculate the number of bytes between the <code>JR</code> instruction and that label, and will refuse to assemble the code if the label is too far away.

 

jr z,SkipOddCode

;whatever you want to do when the accumulator is odd goes here, but it must be 127 bytes or fewer.

SkipOddCode:

 

 

A similar command called <code>DJNZ</code> is often used for looping. It decrements the B register and jumps if and only if B is nonzero. If B is zero, the <code>DJNZ</code> will do nothing and execution will move past it. Like all other jumping commands discussed so far, <code>DJNZ</code> will not alter the processor flags in any way. The same distance restriction of <code>JR</code> also applies to <code>DJNZ</code>. This is the equivalent of the <code>LOOP</code> instruction in [[x86 Assembly]].

 

loop:

 

 

<code>JR</code>,<code>JP</code>,<code>CALL</code>, and <code>RET</code> can be made conditional based on which flags are set. Essentially these are like <code>if</code> statements in a high-level language. If the condition specified by the command is not met, the command will have no effect; otherwise it will result in a jump.

 

call c, foo ;call "foo" if and only if the carry is set.

jp m,&ABCD ;jump to address &ABCD if the last operation resulted in a negative value.

jr z,25 ;jump 25 bytes forward if the last operation resulted in a zero. (Some assemblers such as VASM make you type "$+25")

 

The Game Boy is more limited than the Z80 in this regard, as it has no sign or overflow flags! It can only use the zero and carry flags for jumps.

<code>JP (HL)</code> can be used to create a "trampoline," which lets you indirectly call a subroutine, provided that subroutine doesn't take <code>HL</code> as an argument. (Otherwise you'll get some unwanted results.) To do this, you need to know the address of the subroutine you wish to call, load it into HL, then <code>CALL</code> any address that contains either <code>JP (HL)</code> or the byte 0xE9. (<code>JP (HL)</code>'s bytecode is 0xE9). Once you do this, execution will effectively "call" the desired routine. For this to work, the desired routine must end in a <code>RET</code>, and balance the stack properly. That way, when it does <code>RET</code>, it will <code>RET</code> to where you were just after the <code>CALL</code>.

 

ld hl,foo ;rather than directly specifying "foo", you would normally retrieve it by indexing a table.

;This was done only to keep the example as simple as possible.

foo:

ld a,0

 

''NB: If your hardware allows you to define the <code>RST</code> calls to whatever you like, you can speed this up even more by setting one of them to <code>JP (HL)</code>, and invoking that RST as your trampoline rather than the call. The only downside is that you can't conditionally execute an <code>RST</code>, but if you were using a trampoline it likely wasn't going to be conditional anyway.''

{{omit from|Oberon-2}}

{{omit from|UNIX Shell|Does not have goto or line labels, but can break from nested loops}}