Lua supports an almost conventional set of statements,
similar to those in Pascal or C.
This set includes
assignments, control structures, function calls,
and variable declarations.
The unit of execution of Lua is called a chunk.
A chunk is simply a sequence of statements,
which are executed sequentially.
Each statement can be optionally followed by a semicolon:
chunk ::= {stat [`;´]}
There are no empty statements and thus ';; ' is not legal.
Lua handles a chunk as the body of an anonymous function
with a variable number of arguments
(see §2.5.9).
As such, chunks can define local variables,
receive arguments, and return values.
A chunk can be stored in a file or in a string inside the host program.
To execute a chunk,
Lua first pre-compiles the chunk into instructions for a virtual machine,
and then it executes the compiled code
with an interpreter for the virtual machine.
Chunks can also be pre-compiled into binary form;
see program luac for details.
Programs in source and compiled forms are interchangeable;
Lua automatically detects the file type and acts accordingly.
A block is a list of statements;
syntactically, a block is the same as a chunk:
block ::= chunk
A block can be explicitly delimited to produce a single statement:
stat ::= do block end
Explicit blocks are useful
to control the scope of variable declarations.
Explicit blocks are also sometimes used to
add a return or break statement in the middle
of another block (see §2.4.4).
Lua allows multiple assignments.
Therefore, the syntax for assignment
defines a list of variables on the left side
and a list of expressions on the right side.
The elements in both lists are separated by commas:
stat ::= varlist `=´ explist
varlist ::= var {`,´ var}
explist ::= exp {`,´ exp}
Expressions are discussed in §2.5.
Before the assignment,
the list of values is adjusted to the length of
the list of variables.
If there are more values than needed,
the excess values are thrown away.
If there are fewer values than needed,
the list is extended with as many nil's as needed.
If the list of expressions ends with a function call,
then all values returned by that call enter the list of values,
before the adjustment
(except when the call is enclosed in parentheses; see §2.5).
The assignment statement first evaluates all its expressions
and only then are the assignments performed.
Thus the code
i = 3
i, a[i] = i+1, 20
sets a[3] to 20, without affecting a[4]
because the i in a[i] is evaluated (to 3)
before it is assigned 4.
Similarly, the line
x, y = y, x
exchanges the values of x and y ,
and
x, y, z = y, z, x
cyclically permutes the values of x , y , and z .
The meaning of assignments to global variables
and table fields can be changed via metatables.
An assignment to an indexed variable t[i] = val is equivalent to
settable_event(t,i,val) .
(See §2.8 for a complete description of the
settable_event function.
This function is not defined or callable in Lua.
We use it here only for explanatory purposes.)
An assignment to a global variable x = val
is equivalent to the assignment
_env.x = val ,
which in turn is equivalent to
settable_event(_env, "x", val)
where _env is the environment of the running function.
(The _env variable is not defined in Lua.
We use it here only for explanatory purposes.)
The control structures
if, while, and repeat have the usual meaning and
familiar syntax:
stat ::= while exp do block end
stat ::= repeat block until exp
stat ::= if exp then block {elseif exp then block} [else block] end
Lua also has a for statement, in two flavors (see §2.4.5).
The condition expression of a
control structure can return any value.
Both false and nil are considered false.
All values different from nil and false are considered true
(in particular, the number 0 and the empty string are also true).
In the repeat–until loop,
the inner block does not end at the until keyword,
but only after the condition.
So, the condition can refer to local variables
declared inside the loop block.
The return statement is used to return values
from a function or a chunk (which is just a function).
Functions and chunks can return more than one value,
and so the syntax for the return statement is
stat ::= return [explist]
The break statement is used to terminate the execution of a
while, repeat, or for loop,
skipping to the next statement after the loop:
stat ::= break
A break ends the innermost enclosing loop.
The return and break
statements can only be written as the last statement of a block.
If it is really necessary to return or break in the
middle of a block,
then an explicit inner block can be used,
as in the idioms
do return end and do break end ,
because now return and break are the last statements in
their (inner) blocks.
The for statement has two forms:
one numeric and one generic.
The numeric for loop repeats a block of code while a
control variable runs through an arithmetic progression.
It has the following syntax:
stat ::= for Name `=´ exp `,´ exp [`,´ exp] do block end
The block is repeated for name starting at the value of
the first exp, until it passes the second exp by steps of the
third exp.
More precisely, a for statement like
for v = e1, e2, e3 do block end
is equivalent to the code:
do
local var, limit, step = tonumber(e1), tonumber(e2), tonumber(e3)
if not (var and limit and step) then error() end
while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do
local v = var
block
var = var + step
end
end
Note the following:
-
All three control expressions are evaluated only once,
before the loop starts.
They must all result in numbers.
-
var , limit , and step are invisible variables.
The names shown here are for explanatory purposes only.
-
If the third expression (the step) is absent,
then a step of 1 is used.
-
You can use break to exit a for loop.
-
The loop variable
v is local to the loop;
you cannot use its value after the for ends or is broken.
If you need this value,
assign it to another variable before breaking or exiting the loop.
The generic for statement works over functions,
called iterators.
On each iteration, the iterator function is called to produce a new value,
stopping when this new value is nil.
The generic for loop has the following syntax:
stat ::= for namelist in explist do block end
namelist ::= Name {`,´ Name}
A for statement like
for var_1, ···, var_n in explist do block end
is equivalent to the code:
do
local f, s, var = explist
while true do
local var_1, ···, var_n = f(s, var)
var = var_1
if var == nil then break end
block
end
end
Note the following:
-
explist is evaluated only once.
Its results are an iterator function,
a state,
and an initial value for the first iterator variable.
-
f , s , and var are invisible variables.
The names are here for explanatory purposes only.
-
You can use break to exit a for loop.
-
The loop variables
var_i are local to the loop;
you cannot use their values after the for ends.
If you need these values,
then assign them to other variables before breaking or exiting the loop.
To allow possible side-effects,
function calls can be executed as statements:
stat ::= functioncall
In this case, all returned values are thrown away.
Function calls are explained in §2.5.8.
Local variables can be declared anywhere inside a block.
The declaration can include an initial assignment:
stat ::= local namelist [`=´ explist]
If present, an initial assignment has the same semantics
of a multiple assignment (see §2.4.3).
Otherwise, all variables are initialized with nil.
A chunk is also a block (see §2.4.1),
and so local variables can be declared in a chunk outside any explicit block.
The scope of such local variables extends until the end of the chunk.
The visibility rules for local variables are explained in §2.6. |