Goto Statement

wiki

• A label is visible in the entire block where it is defined (including nested blocks, but not nested functions).
• A goto may jump to any visible label as long as it does not enter into the scope of a local variable. [1]

This rest of this page explores some usages of this new construct.

Nested break

-- 5.2.0-beta-rc2

for z=1,10 do

for y=1,10 do

for x=1,10 do

  if x^2 + y^2 == z^2 then

    print('found a Pythagorean triple:', x, y, z)

    goto done

  end

end end end

::done::

Continue or nested continue

-- 5.2.0-beta-rc2

for z=1,10 do

for y=1,10 do

for x=1,10 do

  if x^2 + y^2 == z^2 then

    print('found a Pythagorean triple:', x, y, z)

    print('now trying next z...')

    goto zcontinue

  end

end end ::zcontinue:: end

See also ContinueProposal.

Perl style redo [2]

-- Lua 5.2.0-beta-rc2

for x=1,5 do ::redo::

  print(x .. ' + 1 = ?')

  local y = tonumber(io.read'*l')

  if y ~= x + 1 then goto redo end

end

Pythonic for-else [3]

-- Lua 5.2.0-beta-rc2

for _, x in ipairs(t) do

  if x % 2 == 0 then

    print 'list has even number'

    goto has

  end

end

print 'list lacks even number'

::has::

-- Lua 5.1 equivalent

local has

for _, x in ipairs(t) do

  if x % 2 == 0 then

    has = true

    break

  end

end

if has then

  print 'list has even number'

else

  print 'list lacks even number'

end

State machine or Markov chain

-- 5.2.0-beta-rc1

::a::

  print 'A'

  if math.random() < 0.3 then goto c end

::b::

  print 'B'

  if math.random() < 0.5 then goto a end

::c::

  print 'C'

  if math.random() < 0.1 then goto a else goto b end

See also code generation discussions [8].

Simulated tail call

Lua already has ProperTailRecursion, but in the hypothetical case it did not, we could simulate tail calls with goto (as some of the C source code of Lua does):

-- 5.2.0-beta-rc2 - factorial with tail recursion simulated with goto's

-- (warning: there's no need to do this)

function fact_(n, ans)

  ::call::

  if n == 0 then

    return ans

  else

    n, ans = n - 1, ans * n

    goto call

  end

end

print(fact_(5, 1)) --> 120

Error handling and cleanup

-- 5.2.0-beta-rc2

function f()

  if not g() then goto fail end

  if not h() then goto cleanup_g end

  if not i() then goto cleanup_h end

  do return true end    -- need do/end?



  ::cleanup_h::

  undo_h()

  ::cleanup_g::

  undo_g()

  ::fail::

  return false

Switch statement

Not possible without computed goto [4]. See also SwitchStatement.

Conventions for Labels

It may help readability for label names to indicate the direction (up or down) that they jump. [10] In the example below, it may be conventionally understood that the names continue and skip will jump down and the name redo will jump up.

-- 5.2.0-beta-rc2

::redo:: for x=1,10 do for y=1,10 do

  if not f(x,y) then goto continue end

  if not g(x,y) then goto skip end

  if not h(x,y) then goto redo end

  ::continue::

end end ::skip::

If you use two such chunks of code in the same scope, you will need to disambiguate the label names (e.g. @redo1: and @redo2:) or wrap each in a do/end block.

Scoping

Here's some examples of the scoping rules for goto:

::a::

goto b  -- valid (forward jump)

goto a  -- valid (backward jump)

::b::

goto c  -- invalid (jump into nested block prohibited because nested label not even visible here)

goto d  -- invalid (jump into nested function prohibited because nested label not even visible here)

do

  ::c::

  goto a  -- valid (backward jump out of nested block)

  goto e  -- valid (forward jump out of nested block)

end

(function()

  ::d::

  goto a  -- invalid (jump out of nested function)

end)()

do ::e:: end  -- valid, but not visible outside the block; above "goto e" sees only next line

::e::  -- valid

goto f  -- invalid (forward jump into scope of local definition)

local x

::f::

goto e  -- valid (backward jump across local definition)

--::e::  -- this would be invalid (duplicate label in same scope)

Note that you can think of

do

  <...>

  --::a::

  goto a  -- invalid (forward jump into scope of local definition)

  goto b  -- valid (jump out of block)

  <...>

  local x

  <...>

  ::a::

  <...>

  --goto a

  ::b::

end

as equivalent to

do

  <...>

  --::a::

  goto a  -- invalid (jump into nested block prohibited because nested label not even visible here)

  goto b  -- valid (jump out of block)

  <...>

  do

    local x

    <...>

    ::a::

    <...>

    --goto a

  end

  ::b::

end

so, in a way, the rule against "jump into scope of local definition" is implied by the rule against "jump into nested block" (but not vice-versa). However, 5.2.0-beta-rc1 doesn't treat scoping between these two forms exactly analogously: if you add another ::a:: before the goto a, the former form will generate an error about duplicate label, whereas the latter will not (though it does in rc2) because the nested ::a:: is never seen by a goto outside the nested block (and any goto inside the nested block will only see the nested ::a::).

The particular treatment of labels at the end of the block (::b::) is what allows a loop continue construct to be implemented (example above) even when the loop block contains locals following the continue.

Efficiency

goto's can sometimes generate the exact same bytecodes and debuginfo as control structures, except for for loops:

-- compare.lua

-- tested 5.2.0rc1



local FS = require 'file_slurp'

  -- https://raw.github.com/gist/1325400/0de9b965af138f2fb3d76fc81d97a863f6f409b3/file_slurp.lua



local function compile(code)

  FS.writefile('luac -o luac.out -', code, 'p')

  local binary = FS.readfile('luac.out')

  local text = FS.readfile('./src/luac -p -l luac.out', 'p'):gsub('0x[0-9a-fA-F]+', '(address)')

  return binary, text

end

  

local a, at = compile [[

  local x = 1

  while not(x > 1e8) do

    x = x + 1

  end

]]

local b, bt = compile [[

  local x = 1

  ::a:: if x > 1e8 then goto e end

  x = x + 1

  goto a; ::e::

]]

assert(a == b)

assert(at == bt)



local a, at = compile [[

  if x then

    f()

  else

    g()

  end

]]

local b, bt = compile [[

  if not x then goto a end

    f()

  goto b; ::a::

    g()

  ::b::

]]

assert(a == b)

assert(at == bt)



local a, at = compile [[

local sum = 0

for i=1,1E8 do

  sum = sum + i

end

]]

local b, bt = compile [[

local sum = 0

local i=1; ::a:: if i > 1E8 then goto b end

sum = sum + i; i=i+1

goto a; ::b::

]]

assert(a ~= b) -- these differ significantly and the latter is about twice as slow.

assert(at ~= bt)



print 'DONE'

(In the earlier 5.2.0beta, when a single goto exists inside a conditional block, some of the JMP's were superfluous [5]).

Changes

In 5.2.0-beta-rc1, labels used the syntax @name: (optionally with spaces, e.g. @ name :). Restrictions on duplicate label names were different.