|
Warning: this is an htmlized version!
The original is across this link, and the conversion rules are here. |
;; -*- mode: tp-r2; coding: utf-8; tp-r0-file: "lua50ref.r0" -*-
;; mode: fundamental;
;; (progn (normal-mode) nil)
;; (setq my-r1s (read (buffer-substring (point-min) (point-max))))
(
(";; -*- mode: tp-r0; coding: utf-8; ee-anchor-format: \"*%s*\" tp-r2-file: \"lua50ref.r2\"; -*-
")
("(defun foo-lua-section () (interactive)
(beginning-of-line)
(assert (looking-at \"\\\\([0-9.]+\\\\) - \\\\(.+\\\\)\"))
(insert (format \"*%s*\\n*%s*\\n\" (match-string 1) (match-string 2)))
(next-line))
" fontified t)
("
(defun foo-lua-region (s e) (interactive \"r\")
(let ((str (buffer-substring s e)))
")
(" (beginning-of-line)
(insert (format \"*%s*\\n\" str))
(forward-line 1)))
" fontified t)
("Location: " face w3m-header-line-location-title-face)
("/usr/share/doc/lua50-doc/manual/manual.html" face w3m-header-line-location-content-face mouse-face highlight)
(" " face w3m-header-line-location-content-face)
("
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
")
("Lua " face w3m-anchor-face w3m-href-anchor "http://www.lua.org/home.html" mouse-face highlight w3m-anchor-sequence 1 balloon-help nil)
(" Lua 5.0 Reference Manual" face bold)
("
by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
")
("Copyright" face w3m-anchor-face w3m-href-anchor "http://www.lua.org/copyright.html" mouse-face highlight w3m-anchor-sequence 2 balloon-help nil)
(" Â 2003 Tecgraf, PUC-Rio. All rights reserved.
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
*")
("1*" face bold)
("
*")
("Introduction*" face bold)
("
")
("1 - Introduction" face bold)
("
Lua is an extension programming language designed to support general
procedural programming with data description facilities. It also offers good
support for object-oriented programming, functional programming, and
data-driven programming. Lua is intended to be used as a powerful,
light-weight configuration language for any program that needs one. Lua is
implemented as a library, written in ")
("clean" face bold)
(" C (that is, in the common subset of
ANSI C and C++).
Being an extension language, Lua has no notion of a \"main\" program: it only
works ")
("embedded" face bold)
(" in a host client, called the ")
("embedding program" face bold)
(" or simply the
")
("host" face bold)
(". This host program can invoke functions to execute a piece of Lua code,
can write and read Lua variables, and can register C functions to be called by
Lua code. Through the use of C functions, Lua can be augmented to cope with a
wide range of different domains, thus creating customized programming
languages sharing a syntactical framework.
The Lua distribution includes a stand-alone embedding program, lua, that uses
the Lua library to offer a complete Lua interpreter.
Lua is free software, and is provided as usual with no guarantees, as stated
in its copyright notice. The implementation described in this manual is
available at Lua's official web site, www.lua.org.
Like any other reference manual, this document is dry in places. For a
discussion of the decisions behind the design of Lua, see the papers below,
which are available at Lua's web site.
â R. Ierusalimschy, L. H. de Figueiredo, and W. Celes. Lua---an extensible
extension language. ")
("Software: Practice & Experience" face bold)
(" ")
("26" face bold)
(" #6 (1996) 635-652.
â L. H. de Figueiredo, R. Ierusalimschy, and W. Celes. The design and
implementation of a language for extending applications. ")
("Proceedings of" face bold)
("
")
("XXI Brazilian Seminar on Software and Hardware" face bold)
(" (1994) 273-283.
â L. H. de Figueiredo, R. Ierusalimschy, and W. Celes. Lua: an extensible
embedded language. ")
("Dr. Dobb's Journal" face bold)
(" ")
("21" face bold)
(" #12 (Dec 1996) 26-33.
â R. Ierusalimschy, L. H. de Figueiredo, and W. Celes. The evolution of an
extension language: a history of Lua, ")
("Proceedings of V Brazilian Symposium" face bold)
("
")
("on Programming Languages" face bold)
(" (2001) B-14-B-28.
Lua means \"moon\" in Portuguese and is pronounced LOO-ah.
*")
("2" face bold)
("*
*")
("The Language" face bold)
("*
")
("2 - The Language" face bold)
("
This section describes the lexis, the syntax, and the semantics of Lua. In
other words, this section describes which tokens are valid, how they can be
combined, and what their combinations mean.
The language constructs will be explained using the usual extended BNF, in
which {")
("a" face bold)
("} means 0 or more ")
("a" face bold)
("'s, and [")
("a" face bold)
("] means an optional ")
("a" face bold)
(". Non-terminals are
shown in ")
("italics" face bold)
(", keywords are shown in ")
("bold" face bold)
(", and other terminal symbols are
shown in typewriter font, enclosed in single quotes.
*")
("2.1" face bold)
("*
*")
("Lexical Conventions" face bold)
("*
")
("2.1 - Lexical Conventions" face bold)
("
*")
("Identifiers" face bold)
("*
")
("Identifiers" face bold)
(" in Lua can be any string of letters, digits, and underscores, not
beginning with a digit. This coincides with the definition of identifiers in
most languages. (The definition of letter depends on the current locale: any
character considered alphabetic by the current locale can be used in an
identifier.)
*")
("keywords" face bold)
("*
The following ")
("keywords" face bold)
(" are reserved and cannot be used as identifiers:
and break do else elseif
end false for function if
in local nil not or
repeat return then true until while
Lua is a case-sensitive language: and is a reserved word, but And and AND are
two different, valid identifiers. As a convention, identifiers starting with
an underscore followed by uppercase letters (such as _VERSION) are reserved
for internal variables used by Lua.
The following strings denote other tokens:
+ - * / ^ =
~= <= >= < > ==
( ) { } [ ]
; : , . .. ...
*")
("Literal strings" face bold)
("*
")
("Literal strings" face bold)
(" can be delimited by matching single or double quotes, and can
contain the following C-like escape sequences:
â ")
("\\a" face bold)
(" --- bell
â ")
("\\b" face bold)
(" --- backspace
â ")
("\\f" face bold)
(" --- form feed
â ")
("\\n" face bold)
(" --- newline
â ")
("\\r" face bold)
(" --- carriage return
â ")
("\\t" face bold)
(" --- horizontal tab
â ")
("\\v" face bold)
(" --- vertical tab
â ")
("\\\\" face bold)
(" --- backslash
â ")
("\\\"" face bold)
(" --- quotation mark
â ")
("\\'" face bold)
(" --- apostrophe
â ")
("\\[" face bold)
(" --- left square bracket
â ")
("\\]" face bold)
(" --- right square bracket
Moreover, a `\\")
("newline" face bold)
("Â∧ (that is, a backslash followed by a real newline)
results in a newline in the string. A character in a string may also be
specified by its numerical value using the escape sequence `\\")
("ddd" face bold)
("Â∧, where ")
("ddd" face bold)
("
is a sequence of up to three decimal digits. Strings in Lua may contain any
8-bit value, including embedded zeros, which can be specified as `\\0Â∧.
Literal strings can also be delimited by matching double square brackets [[ Â
  ]]. Literals in this bracketed form may run for several lines, may contain
nested [[ Â Â Â ]] pairs, and do not interpret any escape sequences. For
convenience, when the opening `[[Â∧ is immediately followed by a newline, the
newline is not included in the string. As an example, in a system using ASCII
(in which `aÂ∧ is coded as 97, newline is coded as 10, and `1Â∧ is coded as 49),
the four literals below denote the same string:
(1) \"alo\\n123\\\"\"
(2) '\\97lo\\10\\04923\"'
(3) [[alo
123\"]]
(4) [[
alo
123\"]]
*")
("Numerical constants" face bold)
("*
")
("Numerical constants" face bold)
(" may be written with an optional decimal part and an
optional decimal exponent. Examples of valid numerical constants are
3 3.0 3.1416 314.16e-2 0.31416E1
*")
("Comments" face bold)
("*
")
("Comments" face bold)
(" start anywhere outside a string with a double hyphen (--). If the
text immediately after -- is different from [[, the comment is a ")
("short comment" face bold)
("
, which runs until the end of the line. Otherwise, it is a ")
("long comment" face bold)
(", which
runs until the corresponding ]]. Long comments may run for several lines and
may contain nested [[ Â Â Â ]] pairs.
For convenience, the first line of a chunk is skipped if it starts with #.
This facility allows the use of Lua as a script interpreter in Unix systems
(see ")
("6" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#lua-sa" mouse-face highlight w3m-anchor-sequence 3 balloon-help nil)
(").
*")
("2.2" face bold)
("*
*")
("Values and Types" face bold)
("*
")
("2.2 - Values and Types" face bold)
("
Lua is a ")
("dynamically typed language" face bold)
(". That means that variables do not have
types; only values do. There are no type definitions in the language. All
values carry their own type.
*type:nil*
*type:boolean*
*type:number*
*type:string*
There are eight basic types in Lua: ")
("nil" face bold)
(", ")
("boolean" face bold)
(", ")
("number" face bold)
(", ")
("string" face bold)
(", ")
("function" face bold)
(",
")
("userdata" face bold)
(", ")
("thread" face bold)
(", and ")
("table" face bold)
(". ")
("Nil" face bold)
(" is the type of the value ")
("nil" face bold)
(", whose main
property is to be different from any other value; usually it represents the
absence of a useful value. ")
("Boolean" face bold)
(" is the type of the values ")
("false" face bold)
(" and ")
("true" face bold)
(".
In Lua, both ")
("nil" face bold)
(" and ")
("false" face bold)
(" make a condition false; any other value makes it
true. ")
("Number" face bold)
(" represents real (double-precision floating-point) numbers. (It is
easy to build Lua interpreters that use other internal representations for
numbers, such as single-precision float or long integers.) ")
("String" face bold)
(" represents
arrays of characters. Lua is 8-bit clean: Strings may contain any 8-bit
character, including embedded zeros ('\\0') (see ")
("2.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#lexical" mouse-face highlight w3m-anchor-sequence 4 balloon-help nil)
(").
*type:function*
Functions are ")
("first-class values" face bold)
(" in Lua. That means that functions can be
stored in variables, passed as arguments to other functions, and returned as
results. Lua can call (and manipulate) functions written in Lua and functions
written in C (see ")
("2.5.7" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#functioncall" mouse-face highlight w3m-anchor-sequence 5 balloon-help nil)
(").
*type:userdata*
The type ")
("userdata" face bold)
(" is provided to allow arbitrary C data to be stored in Lua
variables. This type corresponds to a block of raw memory and has no
pre-defined operations in Lua, except assignment and identity test. However,
by using ")
("metatables" face bold)
(", the programmer can define operations for userdata values
(see ")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 6 balloon-help nil)
("). Userdata values cannot be created or modified in Lua, only through
the C API. This guarantees the integrity of data owned by the host program.
*type:thread*
The type ")
("thread" face bold)
(" represents independent threads of execution and it is used to
implement coroutines.
*type:table*
The type ")
("table" face bold)
(" implements associative arrays, that is, arrays that can be
indexed not only with numbers, but with any value (except ")
("nil" face bold)
("). Moreover,
tables can be ")
("heterogeneous" face bold)
(", that is, they can contain values of all types
(except ")
("nil" face bold)
("). Tables are the sole data structuring mechanism in Lua; they may
be used to represent ordinary arrays, symbol tables, sets, records, graphs,
trees, etc. To represent records, Lua uses the field name as an index. The
language supports this representation by providing a.name as syntactic sugar
for a[\"name\"]. There are several convenient ways to create tables in Lua (see
")
("2.5.6" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#tableconstructor" mouse-face highlight w3m-anchor-sequence 7 balloon-help nil)
(").
Like indices, the value of a table field can be of any type (except ")
("nil" face bold)
("). In
particular, because functions are first class values, table fields may contain
functions. Thus tables may also carry ")
("methods" face bold)
(" (see ")
("2.5.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#func-def" mouse-face highlight w3m-anchor-sequence 8 balloon-help nil)
(").
Tables, functions, and userdata values are ")
("objects" face bold)
(": variables do not actually
")
("contain" face bold)
(" these values, only ")
("references" face bold)
(" to them. Assignment, parameter passing,
and function returns always manipulate references to such values; these
operations do not imply any kind of copy.
The library function type returns a string describing the type of a given
value (see ")
("5.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#pdf-type" mouse-face highlight w3m-anchor-sequence 9 balloon-help nil)
(").
*")
("2.2.1" face bold)
("*
*")
("Coercion" face bold)
("*
")
("2.2.1 - Coercion" face bold)
("
Lua provides automatic conversion between string and number values at run
time. Any arithmetic operation applied to a string tries to convert that
string to a number, following the usual rules. Conversely, whenever a number
is used where a string is expected, the number is converted to a string, in a
reasonable format. For complete control of how numbers are converted to
strings, use the format function from the string library (see ")
("5.3" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#format" mouse-face highlight w3m-anchor-sequence 10 balloon-help nil)
(").
*")
("2.3" face bold)
("*
*")
("Variables" face bold)
("*
")
("2.3 - Variables" face bold)
("
Variables are places that store values. There are three kinds of variables in
Lua: global variables, local variables, and table fields.
A single name can denote a global variable or a local variable (or a formal
parameter of a function, which is a particular form of local variable):
var ::= Name
Variables are assumed to be global unless explicitly declared local (see ")
("2.4.7" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#localvar" mouse-face highlight w3m-anchor-sequence 11 balloon-help nil)
("
). Local variables are ")
("lexically scoped" face bold)
(": Local variables can be freely
accessed by functions defined inside their scope (see ")
("2.6" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#visibility" mouse-face highlight w3m-anchor-sequence 12 balloon-help nil)
(").
Before the first assignment to a variable, its value is ")
("nil" face bold)
(".
Square brackets are used to index a table:
var ::= prefixexp `")
("[" face bold)
("Â∧ exp `")
("]" face bold)
("Â∧
The first expression (")
("prefixexp" face bold)
(")should result in a table value; the second
expression (")
("exp" face bold)
(") identifies a specific entry inside that table. The expression
denoting the table to be indexed has a restricted syntax; see ")
("2.5" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#expressions" mouse-face highlight w3m-anchor-sequence 13 balloon-help nil)
(" for details.
The syntax var.NAME is just syntactic sugar for var[\"NAME\"]:
var ::= prefixexp `")
("." face bold)
("Â∧ Name
The meaning of accesses to global variables and table fields can be changed
via metatables. An access to an indexed variable t[i] is equivalent to a call
gettable_event(t,i). (See ")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 14 balloon-help nil)
(" for a complete description of the gettable_event
function. This function is not defined or callable in Lua. We use it here only
for explanatory purposes.)
All global variables live as fields in ordinary Lua tables, called ")
("environment" face bold)
("
")
("tables" face bold)
(" or simply ")
("environments" face bold)
(". Functions written in C and exported to Lua (")
("C" face bold)
("
")
("functions" face bold)
(") all share a common ")
("global environment" face bold)
(". Each function written in Lua
(a ")
("Lua function" face bold)
(") has its own reference to an environment, so that all global
variables in that function will refer to that environment table. When a
function is created, it inherits the environment from the function that
created it. To change or get the environment table of a Lua function, you call
setfenv or getfenv (see ")
("5.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#setfenv" mouse-face highlight w3m-anchor-sequence 15 balloon-help nil)
(").
An access to a global variable x is equivalent to _env.x, which in turn is
equivalent to
gettable_event(_env, \"x\")
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.)
*")
("2.4" face bold)
("*
*")
("Statements" face bold)
("*
")
("2.4 - Statements" face bold)
("
Lua supports an almost conventional set of statements, similar to those in
Pascal or C. This set includes assignment, control structures, procedure
calls, table constructors, and variable declarations.
*")
("2.4.1" face bold)
("*
*")
("Chunks" face bold)
("*
")
("2.4.1 - Chunks" face bold)
("
The unit of execution of Lua is called a ")
("chunk" face bold)
(". A chunk is simply a sequence
of statements, which are executed sequentially. Each statement can be
optionally followed by a semicolon:
chunk ::= {stat [`")
(";" face bold)
("Â∧]}
Lua handles a chunk as the body of an anonymous function (see ")
("2.5.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#func-def" mouse-face highlight w3m-anchor-sequence 16 balloon-help nil)
("). As such,
chunks can define local variables and return values.
A chunk may be stored in a file or in a string inside the host program. When a
chunk is executed, first it is pre-compiled into opcodes for a virtual
machine, and then the compiled code is executed by an interpreter for the
virtual machine.
Chunks may 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.
*")
("2.4.2" face bold)
("*
*")
("Blocks" face bold)
("*
")
("2.4.2 - Blocks" face bold)
("
A block is a list of statements; syntactically, a block is equal to a chunk:
block ::= chunk
A block may be explicitly delimited to produce a single statement:
stat ::= ")
("do" face bold)
(" block ")
("end" face bold)
("
Explicit blocks are useful to control the scope of variable declarations.
Explicit blocks are also sometimes used to add a ")
("return" face bold)
(" or ")
("break" face bold)
(" statement in
the middle of another block (see ")
("2.4.4" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#control" mouse-face highlight w3m-anchor-sequence 17 balloon-help nil)
(").
*")
("2.4.3" face bold)
("*
*")
("Assignment" face bold)
("*
")
("2.4.3 - Assignment" face bold)
("
Lua allows multiple assignment. 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 ::= varlist1 `")
("=" face bold)
("Â∧ explist1
varlist1 ::= var {`")
("," face bold)
("Â∧ var}
explist1 ::= exp {`")
("," face bold)
("Â∧ exp}
Expressions are discussed in ")
("2.5" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#expressions" mouse-face highlight w3m-anchor-sequence 18 balloon-help nil)
(".
Before the assignment, the list of values is ")
("adjusted" face bold)
(" 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" face bold)
("'s as needed. If the list of expressions ends with a function call,
then all values returned by that function call enter in the list of values,
before the adjustment (except when the call is enclosed in parentheses; see
")
("2.5" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#expressions" mouse-face highlight w3m-anchor-sequence 19 balloon-help nil)
(").
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.
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" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 20 balloon-help nil)
(" 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.)
*")
("2.4.4" face bold)
("*
*")
("Control Structures" face bold)
("*
")
("2.4.4 - Control Structures" face bold)
("
The control structures ")
("if" face bold)
(", ")
("while" face bold)
(", and ")
("repeat" face bold)
(" have the usual meaning and
familiar syntax:
stat ::= ")
("while" face bold)
(" exp ")
("do" face bold)
(" block ")
("end" face bold)
("
stat ::= ")
("repeat" face bold)
(" block ")
("until" face bold)
(" exp
stat ::= ")
("if" face bold)
(" exp ")
("then" face bold)
(" block {")
("elseif" face bold)
(" exp ")
("then" face bold)
(" block} [")
("else" face bold)
(" block] ")
("end" face bold)
("
Lua also has a ")
("for" face bold)
(" statement, in two flavors (see ")
("2.4.5" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#for" mouse-face highlight w3m-anchor-sequence 21 balloon-help nil)
(").
The condition expression ")
("exp" face bold)
(" of a control structure may return any value. Both
")
("false" face bold)
(" and ")
("nil" face bold)
(" are considered false. All values different from ")
("nil" face bold)
(" and ")
("false" face bold)
("
are considered true (in particular, the number 0 and the empty string are also
true).
The ")
("return" face bold)
(" statement is used to return values from a function or from a chunk.
Functions and chunks may return more than one value, so the syntax for the
")
("return" face bold)
(" statement is
stat ::= ")
("return" face bold)
(" [explist1]
The ")
("break" face bold)
(" statement can be used to terminate the execution of a ")
("while" face bold)
(", ")
("repeat" face bold)
(",
or ")
("for" face bold)
(" loop, skipping to the next statement after the loop:
stat ::= ")
("break" face bold)
("
A ")
("break" face bold)
(" ends the innermost enclosing loop.
For syntactic reasons, ")
("return" face bold)
(" and ")
("break" face bold)
(" statements can only be written as the
")
("last" face bold)
(" statement of a block. If it is really necessary to ")
("return" face bold)
(" or ")
("break" face bold)
(" 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" face bold)
(" and ")
("break" face bold)
(" are the last
statements in their (inner) blocks. In practice, those idioms are only used
during debugging.
*")
("2.4.5" face bold)
("*
*")
("For Statement" face bold)
("*
")
("2.4.5 - For Statement" face bold)
("
The ")
("for" face bold)
(" statement has two forms: one numeric and one generic.
The numeric ")
("for" face bold)
(" loop repeats a block of code while a control variable runs
through an arithmetic progression. It has the following syntax:
stat ::= ")
("for" face bold)
(" Name `")
("=" face bold)
("Â∧ exp `")
("," face bold)
("Â∧ exp [`")
("," face bold)
("Â∧ exp] ")
("do" face bold)
(" block ")
("end" face bold)
("
The ")
("block" face bold)
(" is repeated for ")
("name" face bold)
(" starting at the value of the first ")
("exp" face bold)
(", until
it passes the second ")
("exp" face bold)
(" by steps of the third ")
("exp" face bold)
(". More precisely, a ")
("for" face bold)
("
statement like
for var = 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
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.
â _limit and _step are invisible variables. The names are here for
explanatory purposes only.
â The behavior is ")
("undefined" face bold)
(" if you assign to var inside the block.
â If the third expression (the step) is absent, then a step of 1 is used.
â You can use ")
("break" face bold)
(" to exit a ")
("for" face bold)
(" loop.
â The loop variable var is local to the statement; you cannot use its value
after the ")
("for" face bold)
(" ends or is broken. If you need the value of the loop
variable var, then assign it to another variable before breaking or
exiting the loop.
The generic ")
("for" face bold)
(" statement works over functions, called ")
("iterators" face bold)
(". For each
iteration, it calls its iterator function to produce a new value, stopping
when the new value is ")
("nil" face bold)
(". The generic ")
("for" face bold)
(" loop has the following syntax:
stat ::= ")
("for" face bold)
(" Name {`")
("," face bold)
("Â∧ Name} ")
("in" face bold)
(" explist1 ")
("do" face bold)
(" block ")
("end" face bold)
("
A ")
("for" face bold)
(" statement like
for var_1, ..., var_n in explist do block end
is equivalent to the code:
do
local _f, _s, var_1 = explist
local var_2, ... , var_n
while true do
var_1, ..., var_n = _f(_s, var_1)
if var_1 == nil then break end
block
end
end
Note the following:
â explist is evaluated only once. Its results are an ")
("iterator" face bold)
(" function, a
")
("state" face bold)
(", and an initial value for the first ")
("iterator variable" face bold)
(".
â _f and _s are invisible variables. The names are here for explanatory
purposes only.
â The behavior is ")
("undefined" face bold)
(" if you assign to var_1 inside the block.
â You can use ")
("break" face bold)
(" to exit a ")
("for" face bold)
(" loop.
â The loop variables var_i are local to the statement; you cannot use their
values after the ")
("for" face bold)
(" ends. If you need these values, then assign them to
other variables before breaking or exiting the loop.
*")
("2.4.6" face bold)
("*
*")
("Function Calls as Statements" face bold)
("*
")
("2.4.6 - Function Calls as Statements" face bold)
("
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.7" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#functioncall" mouse-face highlight w3m-anchor-sequence 22 balloon-help nil)
(".
*")
("2.4.7" face bold)
("*
*")
("Local Declarations" face bold)
("*
")
("2.4.7 - Local Declarations" face bold)
("
Local variables may be declared anywhere inside a block. The declaration may
include an initial assignment:
stat ::= ")
("local" face bold)
(" namelist [`")
("=" face bold)
("Â∧ explist1]
namelist ::= Name {`")
("," face bold)
("Â∧ Name}
If present, an initial assignment has the same semantics of a multiple
assignment (see ")
("2.4.3" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#assignment" mouse-face highlight w3m-anchor-sequence 23 balloon-help nil)
("). Otherwise, all variables are initialized with ")
("nil" face bold)
(".
A chunk is also a block (see ")
("2.4.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#chunks" mouse-face highlight w3m-anchor-sequence 24 balloon-help nil)
("), so local variables can be declared in a
chunk outside any explicit block. Such local variables die when the chunk
ends.
The visibility rules for local variables are explained in ")
("2.6" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#visibility" mouse-face highlight w3m-anchor-sequence 25 balloon-help nil)
(".
*")
("2.5" face bold)
("*
*")
("Expressions" face bold)
("*
")
("2.5 - Expressions" face bold)
("
The basic expressions in Lua are the following:
exp ::= prefixexp
exp ::= ")
("nil" face bold)
(" | ")
("false" face bold)
(" | ")
("true" face bold)
("
exp ::= Number
exp ::= Literal
exp ::= function
exp ::= tableconstructor
prefixexp ::= var | functioncall | `")
("(" face bold)
("Â∧ exp `")
(")" face bold)
("Â∧
Numbers and literal strings are explained in ")
("2.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#lexical" mouse-face highlight w3m-anchor-sequence 26 balloon-help nil)
("; variables are explained in
")
("2.3" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#variables" mouse-face highlight w3m-anchor-sequence 27 balloon-help nil)
("; function definitions are explained in ")
("2.5.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#func-def" mouse-face highlight w3m-anchor-sequence 28 balloon-help nil)
("; function calls are explained
in ")
("2.5.7" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#functioncall" mouse-face highlight w3m-anchor-sequence 29 balloon-help nil)
("; table constructors are explained in ")
("2.5.6" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#tableconstructor" mouse-face highlight w3m-anchor-sequence 30 balloon-help nil)
(".
An expression enclosed in parentheses always results in only one value. Thus,
(f(x,y,z)) is always a single value, even if f returns several values. (The
value of (f(x,y,z)) is the first value returned by f or ")
("nil" face bold)
(" if f does not
return any values.)
Expressions can also be built with arithmetic operators, relational operators,
and logical operators, all of which are explained below.
*")
("2.5.1" face bold)
("*
*")
("Arithmetic Operators" face bold)
("*
")
("2.5.1 - Arithmetic Operators" face bold)
("
Lua supports the usual arithmetic operators: the binary + (addition), -
(subtraction), * (multiplication), / (division), and ^ (exponentiation); and
unary - (negation). If the operands are numbers, or strings that can be
converted to numbers (see ")
("2.2.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#coercion" mouse-face highlight w3m-anchor-sequence 31 balloon-help nil)
("), then all operations except exponentiation
have the usual meaning. Exponentiation calls a global function __pow;
otherwise, an appropriate metamethod is called (see ")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 32 balloon-help nil)
("). The standard
mathematical library defines function __pow, giving the expected meaning to
exponentiation (see ")
("5.5" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#mathlib" mouse-face highlight w3m-anchor-sequence 33 balloon-help nil)
(").
*")
("2.5.2" face bold)
("*
*")
("Relational Operators" face bold)
("*
")
("2.5.2 - Relational Operators" face bold)
("
The relational operators in Lua are
== ~= < > <= >=
These operators always result in ")
("false" face bold)
(" or ")
("true" face bold)
(".
Equality (==) first compares the type of its operands. If the types are
different, then the result is ")
("false" face bold)
(". Otherwise, the values of the operands are
compared. Numbers and strings are compared in the usual way. Objects (tables,
userdata, threads, and functions) are compared by ")
("reference" face bold)
(": Two objects are
considered equal only if they are the ")
("same" face bold)
(" object. Every time you create a new
object (a table, userdata, or function), this new object is different from any
previously existing object.
You can change the way that Lua compares tables and userdata using the \"eq\"
metamethod (see ")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 34 balloon-help nil)
(").
The conversion rules of ")
("2.2.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#coercion" mouse-face highlight w3m-anchor-sequence 35 balloon-help nil)
(" ")
("do not" face bold)
(" apply to equality comparisons. Thus, \"0\"=
=0 evaluates to ")
("false" face bold)
(", and t[0] and t[\"0\"] denote different entries in a
table.
The operator ~= is exactly the negation of equality (==).
The order operators work as follows. If both arguments are numbers, then they
are compared as such. Otherwise, if both arguments are strings, then their
values are compared according to the current locale. Otherwise, Lua tries to
call the \"lt\" or the \"le\" metamethod (see ")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 36 balloon-help nil)
(").
*")
("2.5.3" face bold)
("*
*")
("Logical Operators" face bold)
("*
")
("2.5.3 - Logical Operators" face bold)
("
The logical operators in Lua are
and or not
Like the control structures (see ")
("2.4.4" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#control" mouse-face highlight w3m-anchor-sequence 37 balloon-help nil)
("), all logical operators consider both
")
("false" face bold)
(" and ")
("nil" face bold)
(" as false and anything else as true.
The operator ")
("not" face bold)
(" always return ")
("false" face bold)
(" or ")
("true" face bold)
(".
The conjunction operator ")
("and" face bold)
(" returns its first argument if this value is ")
("false" face bold)
("
or ")
("nil" face bold)
("; otherwise, ")
("and" face bold)
(" returns its second argument. The disjunction operator
")
("or" face bold)
(" returns its first argument if this value is different from ")
("nil" face bold)
(" and ")
("false" face bold)
(";
otherwise, ")
("or" face bold)
(" returns its second argument. Both ")
("and" face bold)
(" and ")
("or" face bold)
(" use short-cut
evaluation, that is, the second operand is evaluated only if necessary. For
example,
10 or error() -> 10
nil or \"a\" -> \"a\"
nil and 10 -> nil
false and error() -> false
false and nil -> false
false or nil -> nil
10 and 20 -> 20
*")
("2.5.4" face bold)
("*
*")
("Concatenation" face bold)
("*
")
("2.5.4 - Concatenation" face bold)
("
The string concatenation operator in Lua is denoted by two dots (`..Â∧). If
both operands are strings or numbers, then they are converted to strings
according to the rules mentioned in ")
("2.2.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#coercion" mouse-face highlight w3m-anchor-sequence 38 balloon-help nil)
(". Otherwise, the \"concat\" metamethod
is called (see ")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 39 balloon-help nil)
(").
*")
("2.5.5" face bold)
("*
*")
("Precedence" face bold)
("*
")
("2.5.5 - Precedence" face bold)
("
Operator precedence in Lua follows the table below, from lower to higher
priority:
or
and
< > <= >= ~= ==
..
+ -
* /
not - (unary)
^
You can use parentheses to change the precedences in an expression. The
concatenation (`..Â∧) and exponentiation (`^Â∧) operators are right associative.
All other binary operators are left associative.
*")
("2.5.6" face bold)
("*
*")
("Table Constructors" face bold)
("*
")
("2.5.6 - Table Constructors" face bold)
("
Table constructors are expressions that create tables. Every time a
constructor is evaluated, a new table is created. Constructors can be used to
create empty tables, or to create a table and initialize some of its fields.
The general syntax for constructors is
tableconstructor ::= `")
("{" face bold)
("Â∧ [fieldlist] `")
("}" face bold)
("Â∧
fieldlist ::= field {fieldsep field} [fieldsep]
field ::= `")
("[" face bold)
("Â∧ exp `")
("]" face bold)
("Â∧ `")
("=" face bold)
("Â∧ exp | Name `")
("=" face bold)
("Â∧ exp | exp
fieldsep ::= `")
("," face bold)
("Â∧ | `")
(";" face bold)
("Â∧
Each field of the form [exp1] = exp2 adds to the new table an entry with key
exp1 and value exp2. A field of the form name = exp is equivalent to [\"name\"]
= exp. Finally, fields of the form exp are equivalent to [i] = exp, where i
are consecutive numerical integers, starting with 1. Fields in the other
formats do not affect this counting. For example,
a = {[f(1)] = g; \"x\", \"y\"; x = 1, f(x), [30] = 23; 45}
is equivalent to
do
local temp = {}
temp[f(1)] = g
temp[1] = \"x\" -- 1st exp
temp[2] = \"y\" -- 2nd exp
temp.x = 1 -- temp[\"x\"] = 1
temp[3] = f(x) -- 3rd exp
temp[30] = 23
temp[4] = 45 -- 4th exp
a = temp
end
If the last field in the list has the form exp and the expression is a
function call, then all values returned by the call enter the list
consecutively (see ")
("2.5.7" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#functioncall" mouse-face highlight w3m-anchor-sequence 40 balloon-help nil)
("). To avoid this, enclose the function call in
parentheses (see ")
("2.5" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#expressions" mouse-face highlight w3m-anchor-sequence 41 balloon-help nil)
(").
The field list may have an optional trailing separator, as a convenience for
machine-generated code.
*")
("2.5.7" face bold)
("*
*")
("Function Calls" face bold)
("*
")
("2.5.7 - Function Calls" face bold)
("
A function call in Lua has the following syntax:
functioncall ::= prefixexp args
In a function call, first ")
("prefixexp" face bold)
(" and ")
("args" face bold)
(" are evaluated. If the value of
")
("prefixexp" face bold)
(" has type ")
("function" face bold)
(", then that function is called with the given
arguments. Otherwise, its \"call\" metamethod is called, having as first
parameter the value of ")
("prefixexp" face bold)
(", followed by the original call arguments (see
")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 42 balloon-help nil)
(").
The form
functioncall ::= prefixexp `")
(":" face bold)
("Â∧ Name args
can be used to call \"methods\". A call v:name(...) is syntactic sugar for
v.name(v,...), except that v is evaluated only once.
Arguments have the following syntax:
args ::= `")
("(" face bold)
("Â∧ [explist1] `")
(")" face bold)
("Â∧
args ::= tableconstructor
args ::= Literal
All argument expressions are evaluated before the call. A call of the form f
{...} is syntactic sugar for f({...}), that is, the argument list is a single
new table. A call of the form f'...' (or f\"...\" or f[[...]]) is syntactic
sugar for f('...'), that is, the argument list is a single literal string.
Because a function can return any number of results (see ")
("2.4.4" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#control" mouse-face highlight w3m-anchor-sequence 43 balloon-help nil)
("), the number of
results must be adjusted before they are used. If the function is called as a
statement (see ")
("2.4.6" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#funcstat" mouse-face highlight w3m-anchor-sequence 44 balloon-help nil)
("), then its return list is adjusted to zero elements, thus
discarding all returned values. If the function is called inside another
expression or in the middle of a list of expressions, then its return list is
adjusted to one element, thus discarding all returned values except the first
one. If the function is called as the last element of a list of expressions,
then no adjustment is made (unless the call is enclosed in parentheses).
Here are some examples:
f() -- adjusted to 0 results
g(f(), x) -- f() is adjusted to 1 result
g(x, f()) -- g gets x plus all values returned by f()
a,b,c = f(), x -- f() is adjusted to 1 result (and c gets nil)
a,b,c = x, f() -- f() is adjusted to 2 results
a,b,c = f() -- f() is adjusted to 3 results
return f() -- returns all values returned by f()
return x,y,f() -- returns x, y, and all values returned by f()
{f()} -- creates a list with all values returned by f()
{f(), nil} -- f() is adjusted to 1 result
If you enclose a function call in parentheses, then it is adjusted to return
exactly one value:
return x,y,(f()) -- returns x, y, and the first value from f()
{(f())} -- creates a table with exactly one element
As an exception to the free-format syntax of Lua, you cannot put a line break
before the `(Â∧ in a function call. That restriction avoids some ambiguities in
the language. If you write
a = f
(g).x(a)
Lua would read that as a = f(g).x(a). So, if you want two statements, you must
add a semi-colon between them. If you actually want to call f, you must remove
the line break before (g).
A call of the form return ")
("functioncall" face bold)
(" is called a ")
("tail call" face bold)
(". Lua implements
")
("proper tail calls" face bold)
(" (or ")
("proper tail recursion" face bold)
("): In a tail call, the called
function reuses the stack entry of the calling function. Therefore, there is
no limit on the number of nested tail calls that a program can execute.
However, a tail call erases any debug information about the calling function.
Note that a tail call only happens with a particular syntax, where the ")
("return" face bold)
("
has one single function call as argument; this syntax makes the calling
function returns exactly the returns of the called function. So, all the
following examples are not tails calls:
return (f(x)) -- results adjusted to 1
return 2 * f(x)
return x, f(x) -- additional results
f(x); return -- results discarded
return x or f(x) -- results adjusted to 1
*")
("2.5.8" face bold)
("*
*")
("Function Definitions" face bold)
("*
")
("2.5.8 - Function Definitions" face bold)
("
The syntax for function definition is
function ::= ")
("function" face bold)
(" funcbody
funcbody ::= `")
("(" face bold)
("Â∧ [parlist1] `")
(")" face bold)
("Â∧ block ")
("end" face bold)
("
The following syntactic sugar simplifies function definitions:
stat ::= ")
("function" face bold)
(" funcname funcbody
stat ::= ")
("local" face bold)
(" ")
("function" face bold)
(" Name funcbody
funcname ::= Name {`")
("." face bold)
("Â∧ Name} [`")
(":" face bold)
("Â∧ Name]
The statement
function f () ... end
translates to
f = function () ... end
The statement
function t.a.b.c.f () ... end
translates to
t.a.b.c.f = function () ... end
The statement
local function f () ... end
translates to
local f; f = function () ... end
A function definition is an executable expression, whose value has type
")
("function" face bold)
(". When Lua pre-compiles a chunk, all its function bodies are
pre-compiled too. Then, whenever Lua executes the function definition, the
function is ")
("instantiated" face bold)
(" (or ")
("closed" face bold)
("). This function instance (or ")
("closure" face bold)
(") is
the final value of the expression. Different instances of the same function
may refer to different external local variables and may have different
environment tables.
Parameters act as local variables that are initialized with the argument
values:
parlist1 ::= namelist [`")
("," face bold)
("Â∧ `")
("..." face bold)
("Â∧]
parlist1 ::= `")
("..." face bold)
("Â∧
When a function is called, the list of arguments is adjusted to the length of
the list of parameters, unless the function is a variadic or ")
("vararg function" face bold)
(",
which is indicated by three dots (`...Â∧) at the end of its parameter list. A
vararg function does not adjust its argument list; instead, it collects all
extra arguments into an implicit parameter, called arg. The value of arg is a
table, with a field n that holds the number of extra arguments and with the
extra arguments at positions 1, 2, ..., n.
As an example, consider the following definitions:
function f(a, b) end
function g(a, b, ...) end
function r() return 1,2,3 end
Then, we have the following mapping from arguments to parameters:
CALL PARAMETERS
f(3) a=3, b=nil
f(3, 4) a=3, b=4
f(3, 4, 5) a=3, b=4
f(r(), 10) a=1, b=10
f(r()) a=1, b=2
g(3) a=3, b=nil, arg={n=0}
g(3, 4) a=3, b=4, arg={n=0}
g(3, 4, 5, 8) a=3, b=4, arg={5, 8; n=2}
g(5, r()) a=5, b=1, arg={2, 3; n=2}
Results are returned using the ")
("return" face bold)
(" statement (see ")
("2.4.4" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#control" mouse-face highlight w3m-anchor-sequence 45 balloon-help nil)
("). If control
reaches the end of a function without encountering a ")
("return" face bold)
(" statement, then
the function returns with no results.
The ")
("colon" face bold)
(" syntax is used for defining ")
("methods" face bold)
(", that is, functions that have an
implicit extra parameter self. Thus, the statement
function t.a.b.c:f (...) ... end
is syntactic sugar for
t.a.b.c.f = function (self, ...) ... end
*")
("2.6" face bold)
("*
*")
("Visibility Rules" face bold)
("*
")
("2.6 - Visibility Rules" face bold)
("
Lua is a lexically scoped language. The scope of variables begins at the first
statement ")
("after" face bold)
(" their declaration and lasts until the end of the innermost
block that includes the declaration. For instance:
x = 10 -- global variable
do -- new block
local x = x -- new `x', with value 10
print(x) --> 10
x = x+1
do -- another block
local x = x+1 -- another `x'
print(x) --> 12
end
print(x) --> 11
end
print(x) --> 10 (the global one)
Notice that, in a declaration like local x = x, the new x being declared is
not in scope yet, and so the second x refers to the outside variable.
Because of the lexical scoping rules, local variables can be freely accessed
by functions defined inside their scope. For instance:
local counter = 0
function inc (x)
counter = counter + x
return counter
end
A local variable used by an inner function is called an ")
("upvalue" face bold)
(", or ")
("external" face bold)
("
")
("local variable" face bold)
(", inside the inner function.
Notice that each execution of a ")
("local" face bold)
(" statement defines new local variables.
Consider the following example:
a = {}
local x = 20
for i=1,10 do
local y = 0
a[i] = function () y=y+1; return x+y end
end
The loop creates ten closures (that is, ten instances of the anonymous
function). Each of these closures uses a different y variable, while all of
them share the same x.
*")
("2.7" face bold)
("*
*")
("Error Handling" face bold)
("*
")
("2.7 - Error Handling" face bold)
("
Because Lua is an extension language, all Lua actions start from C code in the
host program calling a function from the Lua library (see ")
("3.15" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#lua_pcall" mouse-face highlight w3m-anchor-sequence 46 balloon-help nil)
("). Whenever an
error occurs during Lua compilation or execution, control returns to C, which
can take appropriate measures (such as print an error message).
Lua code can explicitly generate an error by calling the error function (see
")
("5.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#pdf-error" mouse-face highlight w3m-anchor-sequence 47 balloon-help nil)
("). If you need to catch errors in Lua, you can use the pcall function (see
")
("5.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#pdf-pcall" mouse-face highlight w3m-anchor-sequence 48 balloon-help nil)
(").
*")
("2.8" face bold)
("*
*")
("Metatables" face bold)
("*
")
("2.8 - Metatables" face bold)
("
Every table and userdata object in Lua may have a ")
("metatable" face bold)
(". This ")
("metatable" face bold)
(" is
an ordinary Lua table that defines the behavior of the original table and
userdata under certain special operations. You can change several aspects of
the behavior of an object by setting specific fields in its metatable. For
instance, when an object is the operand of an addition, Lua checks for a
function in the field \"__add\" in its metatable. If it finds one, Lua calls
that function to perform the addition.
We call the keys in a metatable ")
("events" face bold)
(" and the values ")
("metamethods" face bold)
(". In the
previous example, the event is \"add\" and the metamethod is the function that
performs the addition.
You can query and change the metatable of an object through the set/
getmetatable functions (see ")
("5.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#pdf-getmetatable" mouse-face highlight w3m-anchor-sequence 49 balloon-help nil)
(").
A metatable may control how an object behaves in arithmetic operations, order
comparisons, concatenation, and indexing. A metatable can also define a
function to be called when a userdata is garbage collected. For each of those
operations Lua associates a specific key called an ")
("event" face bold)
(". When Lua performs
one of those operations over a table or a userdata, it checks whether that
object has a metatable with the corresponding event. If so, the value
associated with that key (the ")
("metamethod" face bold)
(") controls how Lua will perform the
operation.
Metatables control the operations listed next. Each operation is identified by
its corresponding name. The key for each operation is a string with its name
prefixed by two underscores; for instance, the key for operation \"add\" is the
string \"__add\". The semantics of these operations is better explained by a Lua
function describing how the interpreter executes that operation.
The code shown here in Lua is only illustrative; the real behavior is hard
coded in the interpreter and it is much more efficient than this simulation.
All functions used in these descriptions (rawget, tonumber, etc.) are
described in ")
("5.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#predefined" mouse-face highlight w3m-anchor-sequence 50 balloon-help nil)
(". In particular, to retrieve the metamethod of a given object,
we use the expression
metatable(obj)[event]
This should be read as
rawget(metatable(obj) or {}, event)
That is, the access to a metamethod does not invoke other metamethods, and the
access to objects with no metatables does not fail (it simply results in ")
("nil" face bold)
(").
â ")
("\"add\":" face bold)
(" the + operation.
The function getbinhandler below defines how Lua chooses a handler for a
binary operation. First, Lua tries the first operand. If its type does not
define a handler for the operation, then Lua tries the second operand.
function getbinhandler (op1, op2, event)
return metatable(op1)[event] or metatable(op2)[event]
end
Using that function, the behavior of the op1 + op2 is
function add_event (op1, op2)
local o1, o2 = tonumber(op1), tonumber(op2)
if o1 and o2 then -- both operands are numeric?
return o1 + o2 -- `+' here is the primitive `add'
else -- at least one of the operands is not numeric
local h = getbinhandler(op1, op2, \"__add\")
if h then
-- call the handler with both operands
return h(op1, op2)
else -- no handler available: default behavior
error(\"...\")
end
end
end
â ")
("\"sub\":" face bold)
(" the - operation. Behavior similar to the \"add\" operation.
â ")
("\"mul\":" face bold)
(" the * operation. Behavior similar to the \"add\" operation.
â ")
("\"div\":" face bold)
(" the / operation. Behavior similar to the \"add\" operation.
â ")
("\"pow\":" face bold)
(" the ^ (exponentiation) operation.
function pow_event (op1, op2)
local o1, o2 = tonumber(op1), tonumber(op2)
if o1 and o2 then -- both operands are numeric?
return __pow(o1, o2) -- call global `__pow'
else -- at least one of the operands is not numeric
local h = getbinhandler(op1, op2, \"__pow\")
if h then
-- call the handler with both operands
return h(op1, op2)
else -- no handler available: default behavior
error(\"...\")
end
end
end
â ")
("\"unm\":" face bold)
(" the unary - operation.
function unm_event (op)
local o = tonumber(op)
if o then -- operand is numeric?
return -o -- `-' here is the primitive `unm'
else -- the operand is not numeric.
-- Try to get a handler from the operand
local h = metatable(op).__unm
if h then
-- call the handler with the operand and nil
return h(op, nil)
else -- no handler available: default behavior
error(\"...\")
end
end
end
â ")
("\"concat\":" face bold)
(" the .. (concatenation) operation.
function concat_event (op1, op2)
if (type(op1) == \"string\" or type(op1) == \"number\") and
(type(op2) == \"string\" or type(op2) == \"number\") then
return op1 .. op2 -- primitive string concatenation
else
local h = getbinhandler(op1, op2, \"__concat\")
if h then
return h(op1, op2)
else
error(\"...\")
end
end
end
â ")
("\"eq\":" face bold)
(" the == operation. The function getcomphandler defines how Lua
chooses a metamethod for comparison operators. A metamethod only is
selected when both objects being compared have the same type and the same
metamethod for the selected operation.
function getcomphandler (op1, op2, event)
if type(op1) ~= type(op2) then return nil end
local mm1 = metatable(op1)[event]
local mm2 = metatable(op2)[event]
if mm1 == mm2 then return mm1 else return nil end
end
The \"eq\" event is defined as follows:
function eq_event (op1, op2)
if type(op1) ~= type(op2) then -- different types?
return false -- different objects
end
if op1 == op2 then -- primitive equal?
return true -- objects are equal
end
-- try metamethod
local h = getcomphandler(op1, op2, \"__eq\")
if h then
return h(op1, op2)
else
return false
end
end
a ~= b is equivalent to not (a == b).
â ")
("\"lt\":" face bold)
(" the < operation.
function lt_event (op1, op2)
if type(op1) == \"number\" and type(op2) == \"number\" then
return op1 < op2 -- numeric comparison
elseif type(op1) == \"string\" and type(op2) == \"string\" then
return op1 < op2 -- lexicographic comparison
else
local h = getcomphandler(op1, op2, \"__lt\")
if h then
return h(op1, op2)
else
error(\"...\");
end
end
end
a > b is equivalent to b < a.
â ")
("\"le\":" face bold)
(" the <= operation.
function le_event (op1, op2)
if type(op1) == \"number\" and type(op2) == \"number\" then
return op1 <= op2 -- numeric comparison
elseif type(op1) == \"string\" and type(op2) == \"string\" then
return op1 <= op2 -- lexicographic comparison
else
local h = getcomphandler(op1, op2, \"__le\")
if h then
return h(op1, op2)
else
h = getcomphandler(op1, op2, \"__lt\")
if h then
return not h(op2, op1)
else
error(\"...\");
end
end
end
end
a >= b is equivalent to b <= a. Note that, in the absence of a \"le\"
metamethod, Lua tries the \"lt\", assuming that a <= b is equivalent to not
(b < a).
â ")
("\"index\":" face bold)
(" The indexing access table[key].
function gettable_event (table, key)
local h
if type(table) == \"table\" then
local v = rawget(table, key)
if v ~= nil then return v end
h = metatable(table).__index
if h == nil then return nil end
else
h = metatable(table).__index
if h == nil then
error(\"...\");
end
end
if type(h) == \"function\" then
return h(table, key) -- call the handler
else return h[key] -- or repeat operation on it
end
â ")
("\"newindex\":" face bold)
(" The indexing assignment table[key] = value.
function settable_event (table, key, value)
local h
if type(table) == \"table\" then
local v = rawget(table, key)
if v ~= nil then rawset(table, key, value); return end
h = metatable(table).__newindex
if h == nil then rawset(table, key, value); return end
else
h = metatable(table).__newindex
if h == nil then
error(\"...\");
end
end
if type(h) == \"function\" then
return h(table, key,value) -- call the handler
else h[key] = value -- or repeat operation on it
end
â ")
("\"call\":" face bold)
(" called when Lua calls a value.
function function_event (func, ...)
if type(func) == \"function\" then
return func(unpack(arg)) -- primitive call
else
local h = metatable(func).__call
if h then
return h(func, unpack(arg))
else
error(\"...\")
end
end
end
*")
("2.9" face bold)
("*
*")
("Garbage Collection" face bold)
("*
")
("2.9 - Garbage Collection" face bold)
("
Lua does automatic memory management. That means that you do not have to worry
about allocating memory for new objects and freeing it when the objects are no
longer needed. Lua manages memory automatically by running a ")
("garbage collector" face bold)
("
from time to time to collect all ")
("dead objects" face bold)
(" (that is, those objects that are
no longer accessible from Lua). All objects in Lua are subject to automatic
management: tables, userdata, functions, threads, and strings.
Lua uses two numbers to control its garbage-collection cycles. One number
counts how many bytes of dynamic memory Lua is using; the other is a
threshold. When the number of bytes crosses the threshold, Lua runs the
garbage collector, which reclaims the memory of all dead objects. The byte
counter is adjusted, and then the threshold is reset to twice the new value of
the byte counter.
Through the C API, you can query those numbers and change the threshold (see
")
("3.7" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#GC-API" mouse-face highlight w3m-anchor-sequence 51 balloon-help nil)
("). Setting the threshold to zero actually forces an immediate
garbage-collection cycle, while setting it to a huge number effectively stops
the garbage collector. Using Lua code you have a more limited control over
garbage-collection cycles, through the gcinfo and collectgarbage functions
(see ")
("5.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#predefined" mouse-face highlight w3m-anchor-sequence 52 balloon-help nil)
(").
*")
("2.9.1" face bold)
("*
*")
("Garbage-Collection Metamethods" face bold)
("*
")
("2.9.1 - Garbage-Collection Metamethods" face bold)
("
Using the C API, you can set garbage-collector metamethods for userdata (see
")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 53 balloon-help nil)
("). These metamethods are also called ")
("finalizers" face bold)
(". Finalizers allow you to
coordinate Lua's garbage collection with external resource management (such as
closing files, network or database connections, or freeing your own memory).
Free userdata with a field __gc in their metatables are not collected
immediately by the garbage collector. Instead, Lua puts them in a list. After
the collection, Lua does the equivalent of the following function for each
userdata in that list:
function gc_event (udata)
local h = metatable(udata).__gc
if h then
h(udata)
end
end
At the end of each garbage-collection cycle, the finalizers for userdata are
called in ")
("reverse" face bold)
(" order of their creation, among those collected in that
cycle. That is, the first finalizer to be called is the one associated with
the userdata created last in the program.
*")
("2.9.2" face bold)
("*
*")
("Weak Tables" face bold)
("*
")
("2.9.2 - Weak Tables" face bold)
("
A ")
("weak table" face bold)
(" is a table whose elements are ")
("weak references" face bold)
(". A weak reference
is ignored by the garbage collector. In other words, if the only references to
an object are weak references, then the garbage collector will collect that
object.
A weak table can have weak keys, weak values, or both. A table with weak keys
allows the collection of its keys, but prevents the collection of its values.
A table with both weak keys and weak values allows the collection of both keys
and values. In any case, if either the key or the value is collected, the
whole pair is removed from the table. The weakness of a table is controlled by
the value of the __mode field of its metatable. If the __mode field is a
string containing the character `kÂ∧, the keys in the table are weak. If __mode
contains `vÂ∧, the values in the table are weak.
After you use a table as a metatable, you should not change the value of its
field __mode. Otherwise, the weak behavior of the tables controlled by this
metatable is undefined.
*")
("2.10" face bold)
("*
*")
("Coroutines" face bold)
("*
")
("2.10 - Coroutines" face bold)
("
Lua supports coroutines, also called ")
("semi-coroutines" face bold)
(" or ")
("collaborative" face bold)
("
")
("multithreading" face bold)
(". A coroutine in Lua represents an independent thread of
execution. Unlike threads in multithread systems, however, a coroutine only
suspends its execution by explicitly calling a yield function.
You create a coroutine with a call to coroutine.create. Its sole argument is a
function that is the main function of the coroutine. The create function only
creates a new coroutine and returns a handle to it (an object of type ")
("thread" face bold)
(");
it does not start the coroutine execution.
When you first call coroutine.resume, passing as its first argument the thread
returned by coroutine.create, the coroutine starts its execution, at the first
line of its main function. Extra arguments passed to coroutine.resume are
given as parameters for the coroutine main function. After the coroutine
starts running, it runs until it terminates or ")
("yields" face bold)
(".
A coroutine can terminate its execution in two ways: Normally, when its main
function returns (explicitly or implicitly, after the last instruction); and
abnormally, if there is an unprotected error. In the first case,
coroutine.resume returns ")
("true" face bold)
(", plus any values returned by the coroutine main
function. In case of errors, coroutine.resume returns ")
("false" face bold)
(" plus an error
message.
A coroutine yields by calling coroutine.yield. When a coroutine yields, the
corresponding coroutine.resume returns immediately, even if the yield happens
inside nested function calls (that is, not in the main function, but in a
function directly or indirectly called by the main function). In the case of a
yield, coroutine.resume also returns ")
("true" face bold)
(", plus any values passed to
coroutine.yield. The next time you resume the same coroutine, it continues its
execution from the point where it yielded, with the call to coroutine.yield
returning any extra arguments passed to coroutine.resume.
The coroutine.wrap function creates a coroutine like coroutine.create, but
instead of returning the coroutine itself, it returns a function that, when
called, resumes the coroutine. Any arguments passed to that function go as
extra arguments to resume. The function returns all the values returned by
resume, except the first one (the boolean error code). Unlike
coroutine.resume, this function does not catch errors; any error is propagated
to the caller.
As an example, consider the next code:
function foo1 (a)
print(\"foo\", a)
return coroutine.yield(2*a)
end
co = coroutine.create(function (a,b)
print(\"co-body\", a, b)
local r = foo1(a+1)
print(\"co-body\", r)
local r, s = coroutine.yield(a+b, a-b)
print(\"co-body\", r, s)
return b, \"end\"
end)
a, b = coroutine.resume(co, 1, 10)
print(\"main\", a, b)
a, b, c = coroutine.resume(co, \"r\")
print(\"main\", a, b, c)
a, b, c = coroutine.resume(co, \"x\", \"y\")
print(\"main\", a, b, c)
a, b = coroutine.resume(co, \"x\", \"y\")
print(\"main\", a, b)
When you run it, it produces the following output:
co-body 1 10
foo 2
main true 4
co-body r
main true 11 -9
co-body x y
main true 10 end
main false cannot resume dead coroutine
*")
("3" face bold)
("*
*")
("The Application Program Interface" face bold)
("*
")
("3 - The Application Program Interface" face bold)
("
This section describes the C API for Lua, that is, the set of C functions
available to the host program to communicate with Lua. All API functions and
related types and constants are declared in the header file lua.h.
Even when we use the term \"function\", any facility in the API may be provided
as a ")
("macro" face bold)
(" instead. All such macros use each of its arguments exactly once
(except for the first argument, which is always a Lua state), and so do not
generate hidden side-effects.
*")
("3.1" face bold)
("*
*")
("States" face bold)
("*
")
("3.1 - States" face bold)
("
The Lua library is fully reentrant: it has no global variables. The whole
state of the Lua interpreter (global variables, stack, etc.) is stored in a
dynamically allocated structure of type lua_State. A pointer to this state
must be passed as the first argument to every function in the library, except
to lua_open, which creates a Lua state from scratch.
Before calling any API function, you must create a state by calling lua_open:
lua_State *lua_open (void);
To release a state created with lua_open, call lua_close:
void lua_close (lua_State *L);
This function destroys all objects in the given Lua state (calling the
corresponding garbage-collection metamethods, if any) and frees all dynamic
memory used by that state. On several platforms, you may not need to call this
function, because all resources are naturally released when the host program
ends. On the other hand, long-running programs, such as a daemon or a web
server, might need to release states as soon as they are not needed, to avoid
growing too large.
*")
("3.2" face bold)
("*
*")
("The Stack and Indices" face bold)
("*
")
("3.2 - The Stack and Indices" face bold)
("
Lua uses a ")
("virtual stack" face bold)
(" to pass values to and from C. Each element in this
stack represents a Lua value (")
("nil" face bold)
(", number, string, etc.).
Whenever Lua calls C, the called function gets a new stack, which is
independent of previous stacks and of stacks of C functions that are still
active. That stack initially contains any arguments to the C function, and it
is where the C function pushes its results to be returned to the caller (see
")
("3.16" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#LuacallC" mouse-face highlight w3m-anchor-sequence 54 balloon-help nil)
(") to be returned to the caller.
For convenience, most query operations in the API do not follow a strict stack
discipline. Instead, they can refer to any element in the stack by using an
")
("index" face bold)
(": A positive index represents an ")
("absolute" face bold)
(" stack position (starting at 1);
a negative index represents an ")
("offset" face bold)
(" from the top of the stack. More
specifically, if the stack has ")
("n" face bold)
(" elements, then index 1 represents the first
element (that is, the element that was pushed onto the stack first) and index
")
("n" face bold)
(" represents the last element; index ")
("-1" face bold)
(" also represents the last element (that
is, the element at the top) and index ")
("-n" face bold)
(" represents the first element. We say
that an index is ")
("valid" face bold)
(" if it lies between 1 and the stack top (that is, if 1
<= abs(index) <= top).
At any time, you can get the index of the top element by calling lua_gettop:
int lua_gettop (lua_State *L);
Because indices start at 1, the result of lua_gettop is equal to the number of
elements in the stack (and so 0 means an empty stack).
When you interact with Lua API, ")
("you are responsible for controlling stack" face bold)
("
")
("overflow" face bold)
(". The function
int lua_checkstack (lua_State *L, int extra);
grows the stack size to top + extra elements; it returns false if it cannot
grow the stack to that size. This function never shrinks the stack; if the
stack is already larger than the new size, it is left unchanged.
Whenever Lua calls C, it ensures that at least LUA_MINSTACK stack positions
are available. LUA_MINSTACK is defined in lua.h as 20, so that usually you do
not have to worry about stack space unless your code has loops pushing
elements onto the stack.
Most query functions accept as indices any value inside the available stack
space, that is, indices up to the maximum stack size you have set through
lua_checkstack. Such indices are called ")
("acceptable indices" face bold)
(". More formally, we
define an ")
("acceptable index" face bold)
(" as follows:
(index < 0 && abs(index) <= top) || (index > 0 && index <= stackspace)
Note that 0 is never an acceptable index.
Unless otherwise noted, any function that accepts valid indices can also be
called with ")
("pseudo-indices" face bold)
(", which represent some Lua values that are
accessible to the C code but are not in the stack. Pseudo-indices are used to
access the global environment, the registry, and the upvalues of a C function
(see ")
("3.17" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#c-closure" mouse-face highlight w3m-anchor-sequence 55 balloon-help nil)
(").
*")
("3.3" face bold)
("*
*")
("Stack Manipulation" face bold)
("*
")
("3.3 - Stack Manipulation" face bold)
("
The API offers the following functions for basic stack manipulation:
void lua_settop (lua_State *L, int index);
void lua_pushvalue (lua_State *L, int index);
void lua_remove (lua_State *L, int index);
void lua_insert (lua_State *L, int index);
void lua_replace (lua_State *L, int index);
lua_settop accepts any acceptable index, or 0, and sets the stack top to that
index. If the new top is larger than the old one, then the new elements are
filled with ")
("nil" face bold)
(". If index is 0, then all stack elements are removed. A useful
macro defined in the lua.h is
#define lua_pop(L,n) lua_settop(L, -(n)-1)
which pops n elements from the stack.
lua_pushvalue pushes onto the stack a copy of the element at the given index.
lua_remove removes the element at the given position, shifting down the
elements above that position to fill the gap. lua_insert moves the top element
into the given position, shifting up the elements above that position to open
space. lua_replace moves the top element into the given position, without
shifting any element (therefore replacing the value at the given position).
All these functions accept only valid indices. (You cannot call lua_remove or
lua_insert with pseudo-indices, as they do not represent a stack position.)
As an example, if the stack starts as 10 20 30 40 50* (from bottom to top; the
`*Â∧ marks the top), then
lua_pushvalue(L, 3) --> 10 20 30 40 50 30*
lua_pushvalue(L, -1) --> 10 20 30 40 50 30 30*
lua_remove(L, -3) --> 10 20 30 40 30 30*
lua_remove(L, 6) --> 10 20 30 40 30*
lua_insert(L, 1) --> 30 10 20 30 40*
lua_insert(L, -1) --> 30 10 20 30 40* (no effect)
lua_replace(L, 2) --> 30 40 20 30*
lua_settop(L, -3) --> 30 40*
lua_settop(L, 6) --> 30 40 nil nil nil nil*
*")
("3.4" face bold)
("*
*")
("Querying the Stack" face bold)
("*
")
("3.4 - Querying the Stack" face bold)
("
To check the type of a stack element, the following functions are available:
int lua_type (lua_State *L, int index);
int lua_isnil (lua_State *L, int index);
int lua_isboolean (lua_State *L, int index);
int lua_isnumber (lua_State *L, int index);
int lua_isstring (lua_State *L, int index);
int lua_istable (lua_State *L, int index);
int lua_isfunction (lua_State *L, int index);
int lua_iscfunction (lua_State *L, int index);
int lua_isuserdata (lua_State *L, int index);
int lua_islightuserdata (lua_State *L, int index);
These functions can be called with any acceptable index.
lua_type returns the type of a value in the stack, or LUA_TNONE for a
non-valid index (that is, if that stack position is \"empty\"). The types
returned by lua_type are coded by the following constants defined in lua.h:
LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION,
LUA_TUSERDATA, LUA_TTHREAD, LUA_TLIGHTUSERDATA. The following function
translates these constants to strings:
const char *lua_typename (lua_State *L, int type);
The lua_is* functions return 1 if the object is compatible with the given
type, and 0 otherwise. lua_isboolean is an exception to this rule: It succeeds
only for boolean values (otherwise it would be useless, as any value has a
boolean value). They always return 0 for a non-valid index. lua_isnumber
accepts numbers and numerical strings; lua_isstring accepts strings and
numbers (see ")
("2.2.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#coercion" mouse-face highlight w3m-anchor-sequence 56 balloon-help nil)
("); lua_isfunction accepts both Lua functions and
C functions; and lua_isuserdata accepts both full and light userdata. To
distinguish between Lua functions and C functions, you can use
lua_iscfunction. To distinguish between full and light userdata, you can use
lua_islightuserdata. To distinguish between numbers and numerical strings, you
can use lua_type.
The API also contains functions to compare two values in the stack:
int lua_equal (lua_State *L, int index1, int index2);
int lua_rawequal (lua_State *L, int index1, int index2);
int lua_lessthan (lua_State *L, int index1, int index2);
lua_equal and lua_lessthan are equivalent to their counterparts in Lua (see
")
("2.5.2" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#rel-ops" mouse-face highlight w3m-anchor-sequence 57 balloon-help nil)
("). lua_rawequal compares the values for primitive equality, without
metamethods. These functions return 0 (false) if any of the indices are
non-valid.
*")
("3.5" face bold)
("*
*")
("Getting Values from the Stack" face bold)
("*
")
("3.5 - Getting Values from the Stack" face bold)
("
To translate a value in the stack to a specific C type, you can use the
following conversion functions:
int lua_toboolean (lua_State *L, int index);
lua_Number lua_tonumber (lua_State *L, int index);
const char *lua_tostring (lua_State *L, int index);
size_t lua_strlen (lua_State *L, int index);
lua_CFunction lua_tocfunction (lua_State *L, int index);
void *lua_touserdata (lua_State *L, int index);
lua_State *lua_tothread (lua_State *L, int index);
void *lua_topointer (lua_State *L, int index);
These functions can be called with any acceptable index. When called with a
non-valid index, they act as if the given value had an incorrect type.
lua_toboolean converts the Lua value at the given index to a C \"boolean\" value
(0 or 1). Like all tests in Lua, lua_toboolean returns 1 for any Lua value
different from ")
("false" face bold)
(" and ")
("nil" face bold)
("; otherwise it returns 0. It also returns 0 when
called with a non-valid index. (If you want to accept only real boolean
values, use lua_isboolean to test the type of the value.)
lua_tonumber converts the Lua value at the given index to a number (by
default, lua_Number is double). The Lua value must be a number or a string
convertible to number (see ")
("2.2.1" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#coercion" mouse-face highlight w3m-anchor-sequence 58 balloon-help nil)
("); otherwise, lua_tonumber returns 0.
lua_tostring converts the Lua value at the given index to a string (const
char*). The Lua value must be a string or a number; otherwise, the function
returns NULL. If the value is a number, then lua_tostring also ")
("changes the" face bold)
("
")
("actual value in the stack to a string" face bold)
(". (This change confuses lua_next when
lua_tostring is applied to keys.) lua_tostring returns a fully aligned pointer
to a string inside the Lua state. This string always has a zero ('\\0') after
its last character (as in C), but may contain other zeros in its body. If you
do not know whether a string may contain zeros, you can use lua_strlen to get
its actual length. Because Lua has garbage collection, there is no guarantee
that the pointer returned by lua_tostring will be valid after the
corresponding value is removed from the stack. If you need the string after
the current function returns, then you should duplicate it or put it into the
registry (see ")
("3.18" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#registry" mouse-face highlight w3m-anchor-sequence 59 balloon-help nil)
(").
lua_tocfunction converts a value in the stack to a C function. This value must
be a C function; otherwise, lua_tocfunction returns NULL. The type
lua_CFunction is explained in ")
("3.16" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#LuacallC" mouse-face highlight w3m-anchor-sequence 60 balloon-help nil)
(".
lua_tothread converts a value in the stack to a Lua thread (represented as
lua_State *). This value must be a thread; otherwise, lua_tothread returns
NULL.
lua_topointer converts a value in the stack to a generic C pointer (void *).
The value may be a userdata, a table, a thread, or a function; otherwise,
lua_topointer returns NULL. Lua ensures that different objects of the same
type return different pointers. There is no direct way to convert the pointer
back to its original value. Typically this function is used for debug
information.
lua_touserdata is explained in ")
("3.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#userdata" mouse-face highlight w3m-anchor-sequence 61 balloon-help nil)
(".
*")
("3.6" face bold)
("*
*")
("Pushing Values onto the Stack" face bold)
("*
")
("3.6 - Pushing Values onto the Stack" face bold)
("
The API has the following functions to push C values onto the stack:
void lua_pushboolean (lua_State *L, int b);
void lua_pushnumber (lua_State *L, lua_Number n);
void lua_pushlstring (lua_State *L, const char *s, size_t len);
void lua_pushstring (lua_State *L, const char *s);
void lua_pushnil (lua_State *L);
void lua_pushcfunction (lua_State *L, lua_CFunction f);
void lua_pushlightuserdata (lua_State *L, void *p);
These functions receive a C value, convert it to a corresponding Lua value,
and push the result onto the stack. In particular, lua_pushlstring and
lua_pushstring make an internal copy of the given string. lua_pushstring can
only be used to push proper C strings (that is, strings that end with a zero
and do not contain embedded zeros); otherwise, you should use the more general
lua_pushlstring, which accepts an explicit size.
You can also push \"formatted\" strings:
const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
const char *lua_pushvfstring (lua_State *L, const char *fmt, va_list argp);
These functions push onto the stack a formatted string and return a pointer to
that string. They are similar to sprintf and vsprintf, but with some important
differences:
â You do not have to allocate the space for the result: The result is a Lua
string and Lua takes care of memory allocation (and deallocation, through
garbage collection).
â The conversion specifiers are quite restricted. There are no flags,
widths, or precisions. The conversion specifiers can be simply `%%Â∧
(inserts a `%Â∧ in the string), `%sÂ∧ (inserts a zero-terminated string,
with no size restrictions), `%fÂ∧ (inserts a lua_Number), `%dÂ∧ (inserts an
int), and `%cÂ∧ (inserts an int as a character).
The function
void lua_concat (lua_State *L, int n);
concatenates the n values at the top of the stack, pops them, and leaves the
result at the top. If n is 1, the result is that single string (that is, the
function does nothing); if n is 0, the result is the empty string.
Concatenation is done following the usual semantics of Lua (see ")
("2.5.4" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#concat" mouse-face highlight w3m-anchor-sequence 62 balloon-help nil)
(").
*")
("3.7" face bold)
("*
*")
("Controlling Garbage Collection" face bold)
("*
")
("3.7 - Controlling Garbage Collection" face bold)
("
Lua uses two numbers to control its garbage collection: the ")
("count" face bold)
(" and the
")
("threshold" face bold)
(" (see ")
("2.9" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#GC" mouse-face highlight w3m-anchor-sequence 63 balloon-help nil)
("). The first counts the amount of memory in use by Lua; when
the count reaches the threshold, Lua runs its garbage collector. After the
collection, the count is updated and the threshold is set to twice the count
value.
You can access the current values of these two numbers through the following
functions:
int lua_getgccount (lua_State *L);
int lua_getgcthreshold (lua_State *L);
Both return their respective values in Kbytes. You can change the threshold
value with
void lua_setgcthreshold (lua_State *L, int newthreshold);
Again, the newthreshold value is given in Kbytes. When you call this function,
Lua sets the new threshold and checks it against the byte counter. If the new
threshold is less than the byte counter, then Lua immediately runs the garbage
collector. In particular lua_setgcthreshold(L,0) forces a garbage collection.
After the collection, a new threshold is set according to the previous rule.
*")
("3.8" face bold)
("*
*")
("Userdata" face bold)
("*
")
("3.8 - Userdata" face bold)
("
Userdata represents C values in Lua. Lua supports two types of userdata: ")
("full" face bold)
("
")
("userdata" face bold)
(" and ")
("light userdata" face bold)
(".
A full userdata represents a block of memory. It is an object (like a table):
You must create it, it can have its own metatable, and you can detect when it
is being collected. A full userdata is only equal to itself (under raw
equality).
A light userdata represents a pointer. It is a value (like a number): You do
not create it, it has no metatables, it is not collected (as it was never
created). A light userdata is equal to \"any\" light userdata with the same C
address.
In Lua code, there is no way to test whether a userdata is full or light; both
have type userdata. In C code, lua_type returns LUA_TUSERDATA for full
userdata, and LUA_TLIGHTUSERDATA for light userdata.
You can create a new full userdata with the following function:
void *lua_newuserdata (lua_State *L, size_t size);
This function allocates a new block of memory with the given size, pushes on
the stack a new userdata with the block address, and returns this address.
To push a light userdata into the stack you use lua_pushlightuserdata (see ")
("3.6" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#pushing" mouse-face highlight w3m-anchor-sequence 64 balloon-help nil)
("
).
lua_touserdata (see ")
("3.5" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#lua-to" mouse-face highlight w3m-anchor-sequence 65 balloon-help nil)
(") retrieves the value of a userdata. When applied on a
full userdata, it returns the address of its block; when applied on a light
userdata, it returns its pointer; when applied on a non-userdata value, it
returns NULL.
When Lua collects a full userdata, it calls the userdata's gc metamethod, if
any, and then it frees the userdata's corresponding memory.
")
("3.9 - Metatables" face bold)
("
The following functions allow you to manipulate the metatables of an object:
int lua_getmetatable (lua_State *L, int index);
int lua_setmetatable (lua_State *L, int index);
lua_getmetatable pushes on the stack the metatable of a given object. If the
index is not valid, or if the object does not have a metatable,
lua_getmetatable returns 0 and pushes nothing on the stack.
lua_setmetatable pops a table from the stack and sets it as the new metatable
for the given object. lua_setmetatable returns 0 when it cannot set the
metatable of the given object (that is, when the object is neither a userdata
nor a table); even then it pops the table from the stack.
*")
("3.10" face bold)
("*
*")
("Loading Lua Chunks" face bold)
("*
")
("3.10 - Loading Lua Chunks" face bold)
("
You can load a Lua chunk with lua_load:
typedef const char * (*lua_Chunkreader)
(lua_State *L, void *data, size_t *size);
int lua_load (lua_State *L, lua_Chunkreader reader, void *data,
const char *chunkname);
The return values of lua_load are:
â 0 --- no errors;
â LUA_ERRSYNTAX --- syntax error during pre-compilation.
â LUA_ERRMEM --- memory allocation error.
If there are no errors, lua_load pushes the compiled chunk as a Lua function
on top of the stack. Otherwise, it pushes an error message.
lua_load automatically detects whether the chunk is text or binary, and loads
it accordingly (see program luac).
lua_load uses a user-supplied ")
("reader" face bold)
(" function to read the chunk. Everytime it
needs another piece of the chunk, lua_load calls the reader, passing along its
data parameter. The reader must return a pointer to a block of memory with a
new piece of the chunk and set size to the block size. To signal the end of
the chunk, the reader returns NULL. The reader function may return pieces of
any size greater than zero.
In the current implementation, the reader function cannot call any Lua
function; to ensure that, it always receives NULL as the Lua state.
The ")
("chunkname" face bold)
(" is used for error messages and debug information (see ")
("4" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#debugI" mouse-face highlight w3m-anchor-sequence 66 balloon-help nil)
(").
See the auxiliary library (lauxlib.c) for examples of how to use lua_load and
for some ready-to-use functions to load chunks from files and strings.
*")
("3.11" face bold)
("*
*")
("Manipulating Tables" face bold)
("*
")
("3.11 - Manipulating Tables" face bold)
("
Tables are created by calling the function
void lua_newtable (lua_State *L);
This function creates a new, empty table and pushes it onto the stack.
To read a value from a table that resides somewhere in the stack, call
void lua_gettable (lua_State *L, int index);
where index points to the table. lua_gettable pops a key from the stack and
returns (on the stack) the contents of the table at that key. The table is
left where it was in the stack. As in Lua, this function may trigger a
metamethod for the \"index\" event (see ")
("2.8" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#metatable" mouse-face highlight w3m-anchor-sequence 67 balloon-help nil)
("). To get the real value of any table
key, without invoking any metamethod, use the ")
("raw" face bold)
(" version:
void lua_rawget (lua_State *L, int index);
To store a value into a table that resides somewhere in the stack, you push
the key and then the value onto the stack, and call
void lua_settable (lua_State *L, int index);
where index points to the table. lua_settable pops from the stack both the key
and the value. The table is left where it was in the stack. As in Lua, this
operation may trigger a metamethod for the \"settable\" or \"newindex\" events. To
set the real value of any table index, without invoking any metamethod, use
the ")
("raw" face bold)
(" version:
void lua_rawset (lua_State *L, int index);
You can traverse a table with the function
int lua_next (lua_State *L, int index);
where index points to the table to be traversed. The function pops a key from
the stack, and pushes a key-value pair from the table (the \"next\" pair after
the given key). If there are no more elements, then lua_next returns 0 (and
pushes nothing). Use a ")
("nil" face bold)
(" key to signal the start of a traversal.
A typical traversal looks like this:
/* table is in the stack at index `t' */
lua_pushnil(L); /* first key */
while (lua_next(L, t) != 0) {
/* `key' is at index -2 and `value' at index -1 */
printf(\"%s - %s\\n\",
lua_typename(L, lua_type(L, -2)), lua_typename(L, lua_type(L, -1)));
lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration */
}
While traversing a table, do not call lua_tostring directly on a key, unless
you know that the key is actually a string. Recall that lua_tostring ")
("changes" face bold)
("
the value at the given index; this confuses the next call to lua_next.
*")
("3.12" face bold)
("*
*")
("Manipulating Environments" face bold)
("*
")
("3.12 - Manipulating Environments" face bold)
("
All global variables are kept in ordinary Lua tables, called environments. The
initial environment is called the global environment. This table is always at
pseudo-index LUA_GLOBALSINDEX.
To access and change the value of global variables, you can use regular table
operations over an environment table. For instance, to access the value of a
global variable, do
lua_pushstring(L, varname);
lua_gettable(L, LUA_GLOBALSINDEX);
You can change the global environment of a Lua thread using lua_replace.
The following functions get and set the environment of Lua functions:
void lua_getfenv (lua_State *L, int index);
int lua_setfenv (lua_State *L, int index);
lua_getfenv pushes on the stack the environment table of the function at index
index in the stack. If the function is a C function, lua_getfenv pushes the
global environment. lua_setfenv pops a table from the stack and sets it as the
new environment for the function at index index in the stack. If the object at
the given index is not a Lua function, lua_setfenv returns 0.
*")
("3.13" face bold)
("*
*")
("Using Tables as Arrays" face bold)
("*
")
("3.13 - Using Tables as Arrays" face bold)
("
The API has functions that help to use Lua tables as arrays, that is, tables
indexed by numbers only:
void lua_rawgeti (lua_State *L, int index, int n);
void lua_rawseti (lua_State *L, int index, int n);
lua_rawgeti pushes the value of the ")
("n" face bold)
("-th element of the table at stack
position index. lua_rawseti sets the value of the ")
("n" face bold)
("-th element of the table at
stack position index to the value at the top of the stack, removing this value
from the stack.
*")
("3.14" face bold)
("*
*")
("Calling Functions" face bold)
("*
")
("3.14 - Calling Functions" face bold)
("
Functions defined in Lua and C functions registered in Lua can be called from
the host program. This is done using the following protocol: First, the
function to be called is pushed onto the stack; then, the arguments to the
function are pushed in ")
("direct order" face bold)
(", that is, the first argument is pushed
first. Finally, the function is called using
void lua_call (lua_State *L, int nargs, int nresults);
nargs is the number of arguments that you pushed onto the stack. All arguments
and the function value are popped from the stack, and the function results are
pushed. The number of results are adjusted to nresults, unless nresults is
LUA_MULTRET. In that case, ")
("all" face bold)
(" results from the function are pushed. Lua takes
care that the returned values fit into the stack space. The function results
are pushed onto the stack in direct order (the first result is pushed first),
so that after the call the last result is on the top.
The following example shows how the host program may do the equivalent to this
Lua code:
a = f(\"how\", t.x, 14)
Here it is in C:
lua_pushstring(L, \"t\");
lua_gettable(L, LUA_GLOBALSINDEX); /* global `t' (for later use) */
lua_pushstring(L, \"a\"); /* var name */
lua_pushstring(L, \"f\"); /* function name */
lua_gettable(L, LUA_GLOBALSINDEX); /* function to be called */
lua_pushstring(L, \"how\"); /* 1st argument */
lua_pushstring(L, \"x\"); /* push the string \"x\" */
lua_gettable(L, -5); /* push result of t.x (2nd arg) */
lua_pushnumber(L, 14); /* 3rd argument */
lua_call(L, 3, 1); /* call function with 3 arguments and 1 result */
lua_settable(L, LUA_GLOBALSINDEX); /* set global variable `a' */
lua_pop(L, 1); /* remove `t' from the stack */
Note that the code above is \"balanced\": at its end, the stack is back to its
original configuration. This is considered good programming practice.
(We did this example using only the raw functions provided by Lua's API, to
show all the details. Usually programmers define and use several macros and
auxiliary functions that provide higher level access to Lua. See the source
code of the standard libraries for examples.)
*")
("3.15" face bold)
("*
*")
("Protected Calls" face bold)
("*
")
("3.15 - Protected Calls" face bold)
("
When you call a function with lua_call, any error inside the called function
is propagated upwards (with a longjmp). If you need to handle errors, then you
should use lua_pcall:
int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
Both nargs and nresults have the same meaning as in lua_call. If there are no
errors during the call, lua_pcall behaves exactly like lua_call. However, if
there is any error, lua_pcall catches it, pushes a single value at the stack
(the error message), and returns an error code. Like lua_call, lua_pcall
always removes the function and its arguments from the stack.
If errfunc is 0, then the error message returned is exactly the original error
message. Otherwise, errfunc gives the stack index for an ")
("error handler" face bold)
("
")
("function" face bold)
(". (In the current implementation, that index cannot be a
pseudo-index.) In case of runtime errors, that function will be called with
the error message and its return value will be the message returned by
lua_pcall.
Typically, the error handler function is used to add more debug information to
the error message, such as a stack traceback. Such information cannot be
gathered after the return of lua_pcall, since by then the stack has unwound.
The lua_pcall function returns 0 in case of success or one of the following
error codes (defined in lua.h):
â LUA_ERRRUN --- a runtime error.
â LUA_ERRMEM --- memory allocation error. For such errors, Lua does not call
the error handler function.
â LUA_ERRERR --- error while running the error handler function.
*")
("3.16" face bold)
("*
*")
("Defining C Functions" face bold)
("*
")
("3.16 - Defining C Functions" face bold)
("
Lua can be extended with functions written in C. These functions must be of
type lua_CFunction, which is defined as
typedef int (*lua_CFunction) (lua_State *L);
A C function receives a Lua state and returns an integer, the number of values
it wants to return to Lua.
In order to communicate properly with Lua, a C function must follow the
following protocol, which defines the way parameters and results are passed: A
C function receives its arguments from Lua in its stack in direct order (the
first argument is pushed first). So, when the function starts, its first
argument (if any) is at index 1. To return values to Lua, a C function just
pushes them onto the stack, in direct order (the first result is pushed
first), and returns the number of results. Any other value in the stack below
the results will be properly discharged by Lua. Like a Lua function, a
C function called by Lua can also return many results.
As an example, the following function receives a variable number of numerical
arguments and returns their average and sum:
static int foo (lua_State *L) {
int n = lua_gettop(L); /* number of arguments */
lua_Number sum = 0;
int i;
for (i = 1; i <= n; i++) {
if (!lua_isnumber(L, i)) {
lua_pushstring(L, \"incorrect argument to function `average'\");
lua_error(L);
}
sum += lua_tonumber(L, i);
}
lua_pushnumber(L, sum/n); /* first result */
lua_pushnumber(L, sum); /* second result */
return 2; /* number of results */
}
To register a C function to Lua, there is the following convenience macro:
#define lua_register(L,n,f) \\
(lua_pushstring(L, n), \\
lua_pushcfunction(L, f), \\
lua_settable(L, LUA_GLOBALSINDEX))
/* lua_State *L; */
/* const char *n; */
/* lua_CFunction f; */
which receives the name the function will have in Lua and a pointer to the
function. Thus, the C function foo above may be registered in Lua as average
by calling
lua_register(L, \"average\", foo);
*")
("3.17" face bold)
("*
*")
("Defining C Closures" face bold)
("*
")
("3.17 - Defining C Closures" face bold)
("
When a C function is created, it is possible to associate some values with it,
thus creating a ")
("C closure" face bold)
("; these values are then accessible to the function
whenever it is called. To associate values with a C function, first these
values should be pushed onto the stack (when there are multiple values, the
first value is pushed first). Then the function
void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
is used to push the C function onto the stack, with the argument n telling how
many values should be associated with the function (lua_pushcclosure also pops
these values from the stack); in fact, the macro lua_pushcfunction is defined
as lua_pushcclosure with n set to 0.
Then, whenever the C function is called, those values are located at specific
pseudo-indices. Those pseudo-indices are produced by a macro lua_upvalueindex.
The first value associated with a function is at position lua_upvalueindex(1),
and so on. Any access to lua_upvalueindex(")
("n" face bold)
("), where ")
("n" face bold)
(" is greater than the
number of upvalues of the current function, produces an acceptable (but
invalid) index.
For examples of C functions and closures, see the standard libraries in the
official Lua distribution (src/lib/*.c).
*")
("3.18" face bold)
("*
*")
("Registry" face bold)
("*
")
("3.18 - Registry" face bold)
("
Lua provides a registry, a pre-defined table that can be used by any C code to
store whatever Lua value it needs to store, specially if the C code needs to
keep that Lua value outside the life span of a C function. This table is
always located at pseudo-index LUA_REGISTRYINDEX. Any C library can store data
into this table, as long as it chooses keys different from other libraries.
Typically, you should use as key a string containing your library name or a
light userdata with the address of a C object in your code.
The integer keys in the registry are used by the reference mechanism,
implemented by the auxiliary library, and therefore should not be used by
other purposes.
")
("3.19 - Error Handling in C" face bold)
("
Internally, Lua uses the C longjmp facility to handle errors. When Lua faces
any error (such as memory allocation errors, type errors, syntax errors) it
")
("raises" face bold)
(" an error, that is, it does a long jump. A ")
("protected environment" face bold)
(" uses
setjmp to set a recover point; any error jumps to the most recent active
recover point.
If an error happens outside any protected environment, Lua calls a ")
("panic" face bold)
("
")
("function" face bold)
(" and then calls exit(EXIT_FAILURE). You can change the panic function
with
lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
Your new panic function may avoid the application exit by never returning
(e.g., by doing a long jump). Nevertheless, the corresponding Lua state will
not be consistent; the only safe operation with it is to close it.
Almost any function in the API may raise an error, for instance due to a
memory allocation error. The following functions run in protected mode (that
is, they create a protected environment to run), so they never raise an error:
lua_open, lua_close, lua_load, and lua_pcall.
There is yet another function that runs a given C function in protected mode:
int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);
lua_cpcall calls func in protected mode. func starts with only one element in
its stack, a light userdata containing ud. In case of errors, lua_cpcall
returns the same error codes as lua_pcall (see ")
("3.15" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#lua_pcall" mouse-face highlight w3m-anchor-sequence 68 balloon-help nil)
("), plus the error object on
the top of the stack; otherwise, it returns zero, and does not change the
stack. Any value returned by func is discarded.
C code can generate a Lua error calling the function
void lua_error (lua_State *L);
The error message (which actually can be any type of object) must be on the
stack top. This function does a long jump, and therefore never returns.
*")
("3.20" face bold)
("*
*")
("Threads" face bold)
("*
")
("3.20 - Threads" face bold)
("
Lua offers partial support for multiple threads of execution. If you have a
C library that offers multi-threading, then Lua can cooperate with it to
implement the equivalent facility in Lua. Also, Lua implements its own
coroutine system on top of threads. The following function creates a new
thread in Lua:
lua_State *lua_newthread (lua_State *L);
This function pushes the thread on the stack and returns a pointer to a
lua_State that represents this new thread. The new state returned by this
function shares with the original state all global objects (such as tables),
but has an independent run-time stack.
Each thread has an independent global environment table. When you create a
thread, this table is the same as that of the given state, but you can change
each one independently.
There is no explicit function to close or to destroy a thread. Threads are
subject to garbage collection, like any Lua object.
To manipulate threads as coroutines, Lua offers the following functions:
int lua_resume (lua_State *L, int narg);
int lua_yield (lua_State *L, int nresults);
To start a coroutine, you first create a new thread; then you push on its
stack the body function plus any eventual arguments; then you call lua_resume,
with narg being the number of arguments. This call returns when the coroutine
suspends or finishes its execution. When it returns, the stack contains all
values passed to lua_yield, or all values returned by the body function.
lua_resume returns 0 if there are no errors running the coroutine, or an error
code (see ")
("3.15" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#lua_pcall" mouse-face highlight w3m-anchor-sequence 69 balloon-help nil)
("). In case of errors, the stack contains only the error message.
To restart a coroutine, you put on its stack only the values to be passed as
results from yield, and then call lua_resume.
The lua_yield function can only be called as the return expression of a C
function, as follows:
return lua_yield (L, nresults);
When a C function calls lua_yield in that way, the running coroutine suspends
its execution, and the call to lua_resume that started this coroutine returns.
The parameter nresults is the number of values from the stack that are passed
as results to lua_resume.
To exchange values between different threads, you may use lua_xmove:
void lua_xmove (lua_State *from, lua_State *to, int n);
It pops n values from the stack from, and puhses them into the stack to.
*")
("4" face bold)
("*
*")
("The Debug Interface" face bold)
("*
")
("4 - The Debug Interface" face bold)
("
Lua has no built-in debugging facilities. Instead, it offers a special
interface by means of functions and ")
("hooks" face bold)
(". This interface allows the
construction of different kinds of debuggers, profilers, and other tools that
need \"inside information\" from the interpreter.
*")
("4.1" face bold)
("*
*")
("Stack and Function Information" face bold)
("*
")
("4.1 - Stack and Function Information" face bold)
("
The main function to get information about the interpreter runtime stack is
int lua_getstack (lua_State *L, int level, lua_Debug *ar);
This function fills parts of a lua_Debug structure with an identification of
the ")
("activation record" face bold)
(" of the function executing at a given level. Level 0 is
the current running function, whereas level ")
("n+1" face bold)
(" is the function that has
called level ")
("n" face bold)
(". When there are no errors, lua_getstack returns 1; when called
with a level greater than the stack depth, it returns 0.
The structure lua_Debug is used to carry different pieces of information about
an active function:
typedef struct lua_Debug {
int event;
const char *name; /* (n) */
const char *namewhat; /* (n) `global', `local', `field', `method' */
const char *what; /* (S) `Lua' function, `C' function, Lua `main' */
const char *source; /* (S) */
int currentline; /* (l) */
int nups; /* (u) number of upvalues */
int linedefined; /* (S) */
char short_src[LUA_IDSIZE]; /* (S) */
/* private part */
...
} lua_Debug;
lua_getstack fills only the private part of this structure, for later use. To
fill the other fields of lua_Debug with useful information, call
int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
This function returns 0 on error (for instance, an invalid option in what).
Each character in the string what selects some fields of the structure ar to
be filled, as indicated by the letter in parentheses in the definition of
lua_Debug above: `SÂ∧ fills in the fields source, linedefined, and what; `lÂ∧
fills in the field currentline, etc. Moreover, `fÂ∧ pushes onto the stack the
function that is running at the given level.
To get information about a function that is not active (that is, not in the
stack), you push it onto the stack and start the what string with the
character `>Â∧. For instance, to know in which line a function f was defined,
you can write
lua_Debug ar;
lua_pushstring(L, \"f\");
lua_gettable(L, LUA_GLOBALSINDEX); /* get global `f' */
lua_getinfo(L, \">S\", &ar);
printf(\"%d\\n\", ar.linedefined);
The fields of lua_Debug have the following meaning:
â ")
("source" face bold)
(" If the function was defined in a string, then source is that
string. If the function was defined in a file, then source starts with a
`@Â∧ followed by the file name.
â ")
("short_src" face bold)
(" A \"printable\" version of source, to be used in error messages.
â ")
("linedefined" face bold)
(" the line number where the definition of the function starts.
â ")
("what" face bold)
(" the string \"Lua\" if this is a Lua function, \"C\" if this is a
C function, \"main\" if this is the main part of a chunk, and \"tail\" if this
was a function that did a tail call. In the latter case, Lua has no other
information about this function.
â ")
("currentline" face bold)
(" the current line where the given function is executing. When
no line information is available, currentline is set to ")
("-1" face bold)
(".
â ")
("name" face bold)
(" a reasonable name for the given function. Because functions in Lua
are first class values, they do not have a fixed name: Some functions may
be the value of multiple global variables, while others may be stored only
in a table field. The lua_getinfo function checks how the function was
called or whether it is the value of a global variable to find a suitable
name. If it cannot find a name, then name is set to NULL.
â ")
("namewhat" face bold)
(" Explains the name field. The value of namewhat can be \"global\",
\"local\", \"method\", \"field\", or \"\" (the empty string), according to how the
function was called. (Lua uses the empty string when no other option seems
to apply.)
â ")
("nups" face bold)
(" The number of upvalues of the function.
*")
("4.2" face bold)
("*
*")
("Manipulating Local Variables and Upvalues" face bold)
("*
")
("4.2 - Manipulating Local Variables and Upvalues" face bold)
("
For the manipulation of local variables and upvalues, the debug interface uses
indices: The first parameter or local variable has index 1, and so on, until
the last active local variable. Upvalues have no particular order, as they are
active through the whole function.
The following functions allow the manipulation of the local variables of a
given activation record:
const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
The parameter ar must be a valid activation record that was filled by a
previous call to lua_getstack or given as argument to a hook (see ")
("4.3" face w3m-anchor-face w3m-href-anchor "/usr/share/doc/lua50-doc/manual/manual.html#sub-hooks" mouse-face highlight w3m-anchor-sequence 70 balloon-help nil)
(").
lua_getlocal gets the index n of a local variable, pushes the variable's value
onto the stack, and returns its name. lua_setlocal assigns the value at the
top of the stack to the variable and returns its name. Both functions return
NULL when the index is greater than the number of active local variables.
The following functions allow the manipulation of the upvalues of a given
function (unlike local variables, the upvalues of a function are accessible
even when the function is not active):
const char *lua_getupvalue (lua_State *L, int funcindex, int n);
const char *lua_setupvalue (lua_State *L, int funcindex, int n);
These functions operate both on Lua functions and on C functions. (For Lua
functions, upvalues are the external local variables that the function uses,
and that consequently are included in its closure.) funcindex points to a
function in the stack. lua_getpuvalue gets the index n of an upvalue, pushes
the upvalue's value onto the stack, and returns its name. lua_setupvalue
assigns the value at the top of the stack to the upvalue and returns its name.
Both functions return NULL when the index is greater than the number of
upvalues. For C functions, these functions use the empty string \"\" as a name
for all upvalues.
As an example, the following function lists the names of all local variables
and upvalues for a function at a given level of the stack:
int listvars (lua_State *L, int level) {
lua_Debug ar;
int i;
const char *name;
if (lua_getstack(L, level, &ar) == 0)
return 0; /* failure: no such level in the stack */
i = 1;
while ((name = lua_getlocal(L, &ar, i++)) != NULL) {
printf(\"local %d %s\\n\", i-1, name);
lua_pop(L, 1); /* remove variable value */
}
lua_getinfo(L, \"f\", &ar); /* retrieves function */
i = 1;
while ((name = lua_getpuvalue(L, -1, i++)) != NULL) {
printf(\"upvalue %d %s\\n\", i-1, name);
lua_pop(L, 1); /* remove upvalue value */
}
return 1;
}
*")
("4.3" face bold)
("*
*")
("Hooks" face bold)
("*
")
("4.3 - Hooks" face bold)
("
Lua offers a mechanism of hooks, which are user-defined C functions that are
called during the program execution. A hook may be called in four different
events: a ")
("call" face bold)
(" event, when Lua calls a function; a ")
("return" face bold)
(" event, when Lua
returns from a function; a ")
("line" face bold)
(" event, when Lua starts executing a new line of
code; and a ")
("count" face bold)
(" event, which happens every \"count\" instructions. Lua
identifies these events with the following constants: LUA_HOOKCALL,
LUA_HOOKRET (or LUA_HOOKTAILRET, see below), LUA_HOOKLINE, and LUA_HOOKCOUNT.
A hook has type lua_Hook, defined as follows:
typedef void (*