Extension:Scribunto/Lua reference manual/fr

'This is a translation (in french) of the Extension:Scribunto/Lua reference manual page. Work in progress. Please let me know if it is not the right place for it.' 'Ceci est une traduction (en français) de la page Extension:Scribunto/Lua reference manual page. Travail en cours. Merci de m'indiquer si ce n'est pas la bon endroit pour ça.'

Introduction
Ce manuel documente Lua dans son utilisation dans Mediawiki à traverts l'extension Scribunto. The manuel est inspiré de Lua 5.1 reference manual, qui est publié sous licence MIT. Ce travail dérivé doit donc être copié en conservant cette même licence.

Copyright © 1994–2012 Lua.org, PUC-Rio.

« ''Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.'' »

Débuter
Sur un wiki utilisant Mediawiki et Lua activé, créez une page dont le titre commence par « Module: », par exemple « Module:Banane ». Dans cette page copiez le texte suivant :

Sauvegardez puis, dans une autre page (qui ne soit pas un module) écrivez :

Vous pouvez remplacer « Banane » par le nom de module de votre choix. Ceci va appeler la fonction « hello » exportée par ce module. Le code sera remplacé par le texte que cette fonction retourne, dans cet exemple « Hello, world! ».

Le langage
Cette section détaille le lexique, la syntaxe et la sémantique de Lua. Elle décrit donc quels mot-clés sont valides, comment les combiner et ce que leurs combinaisons signifie.

La construction du langage sera expliquée en utilisant la notation extended Backus–Naur Form (EBNF), dans laquelle : { a } signifie 0 ou plus a, et [ a ] signifie un a optionnel. Les éléments non terminaux sont affichés comme non terminaux, les mot-clés sont affichés en gras, les autres symboles terminaux sont affichés sous la forme `=&acute;. La syntaxe complête se trouve à la fin de ce manuel.

Conventions lexicales
Les Noms (aussi appelés identifiants ) dans Lua peuvent être formés de n'importe quelle séquence de lettres, chiffres et tirets bas (underscore) à l'exception du premier caractère qui ne peut être un chiffre. Ceci correspond à la définition des noms dans la plupart des langages. (la définition de « lettre » dépend de la locale courante: tout caractère considéré comme alphabétique dans la locale courante peut être utilisé dans un identifiant). Les identifiants sont utilisés pour nommer les variables et les champs des tables.

Les mot-clés suivants sont réservés et ne peuvent servir de nom:


 * and
 * break
 * do
 * else
 * elseif
 * end
 * false
 * for
 * function
 * if
 * in
 * local
 * nil
 * not
 * or
 * repeat
 * return
 * then
 * true
 * until
 * while

Lua est un langage sensible à la casse: est un mot-clé réservé mais  et   sont deux noms différents et valides. Par convention les mot-clés commençant pas un tiret bas et suivis de lettres capitales sont réservés comme variables globales internes à Lua (exemple : ).

Les séquences de caractères suivantes correspondent à d'autres mot-clés de Lua :


 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * ]
 * ]

Les chaînes constantes (ou textes ) peuvent être délimitées par une paire de guillemets (version anglaise : ") ou une paire d'apostrophe (version anglaise : '), et peuvent contenir les séquences d'échappement (similaires à celles utilisées en C) suivantes : ' ' (bell), ' ' (backspace), ' ' (form feed), ' ' (nouvelle ligne), ' ' (retour en début de ligne), ' ' (tabulation horizontale), ' ' (tabulation verticale), ' ' (barre oblique inversée (backslash)), ' ' (guillement), et ' ' (apostrophe). De plus un backslash suivi par un vrai retour à la ligne correspond à un retour à la ligne dans la chaîne. Un caractère dans une chaîne peut aussi est spécifié par sa valeur numérique en utilisant la séquence d'échappement, avec ddd une séquence comprenant jusqu'à trois chiffres (note : si cette séquence est utilisée directement suivie d'un chiffre il faut obligatoirement fournir trois chiffres). Les chaînes dans Lua peuvent contenir n'importe quelle valeur codée sur un octet, y compris la valeur 0 qui peut être insérée avec ' '.

Literal strings can also be defined using a long format enclosed by long brackets. We define an opening long bracket of level n as an opening square bracket followed by n equal signs followed by another opening square bracket. So, an opening long bracket of level 0 is written as , an opening long bracket of level 1 is written as , and so on. A closing long bracket is defined similarly; for instance, a closing long bracket of level 4 is written as. A long string starts with an opening long bracket of any level and ends at the first closing long bracket of the same level. Literals in this bracketed form can run for several lines, do not interpret any escape sequences, and ignore long brackets of any other level. They can contain anything except a closing bracket of the proper level.

For convenience, when the opening long bracket is immediately followed by a newline, the newline is not included in the string. As an example, in a system using ASCII (in which ' ' is coded as 97, newline is coded as 10, and ' ' is coded as 49), the five literal strings below denote the same string:

A numerical constant can be written with an optional decimal part and an optional decimal exponent. Lua also accepts integer hexadecimal constants, by prefixing them with. Examples of valid numerical constants are


 * 3
 * 3.0
 * 3.1416
 * 314.16e-2
 * 0.31416E1
 * 0xff
 * 0x56

A comment starts with a double hyphen anywhere outside a string. If the text immediately after  is not an opening long bracket, the comment is a short comment , which runs until the end of the line. Otherwise, it is a long comment , which runs until the corresponding closing long bracket. Long comments are frequently used to disable code temporarily.

Types et valeurs
Lua est un langage typé dynamiquement. Cela signifie que les variables n'ont pas de type, seules les valeurs en ont. Il n'y a aucune définition de type dans ce langage, chaque valeur transportant son propre type.

Toutes les valeurs dans Lua sont des first-class values (traduction correcte ?). Cela signifie que toute valeur peut être stockée dans une variable, passée à des fonctions ou retournée comme résultat.

Il y a huit types de base en Lua : nil, boolean , number , string, function , userdata , thread, et table. nil est le type de la valeur nil, dont le rôle est d'être différent de toutes les autres valeurs possibles, et qui représente en général l'absence de valeur. boolean est le type des valeurs vraies ou fausses (false et true). Les valeurs nil et false sont toutes les deux considérées comme fausses pour les tests, toute autre valeur étant considérée comme vraie. number correspond aux nombres réels (double-précision). (Il est facile de créer un interpréteur Lua utilisant d'autres représentations internes pour les nombres, voir ) string représente les tableaux de caractères (ou chaînes de caractères, ou chaînes, ou textes).

Les chaînes peuvent contenir n'importe quel caractère codé sur 8 bits (un octet) y compris la valeur zéro (' ') (voir &sect;2.1).

Lua peut appeler (et manipuler) des fonctions écrites en Lua et en C (voir &sect;2.5.8).

Le type userdata permet de construire des structures de données C arbitraires et de les stocker dans des variables Lua. Ce type correspond à un bloc brut de mémoire et Lua ne possède aucune opération pré-définie qui s'y applique, à par l'assignement et la comparaison d'égalité. Toutefois en utilisant les metatables le programmeur peut définir les opérations applicables aux valeurs userdata (voir &sect;2.8). Ces valeurs userdata ne peuvent être créées ni modifiées depuis Lua mais seulement à travers l'API C. Ceci est une garantie de l'intégrité des données fournies par le programme hôte.

Le type thread représente des threads d'exécution indépendants et est utilisé pour implémenter les co-routines (qui ne sont actuellement pas supportées dans MediaWiki). Ne confondez-pas les threads de Lua avec les threads des systèmes d'exploitation. Lua supporte les co-routines sur tous les systèmes, y compris ceux n'ayant pas de support pour les threads.

Le type table implémente des tableaux associatifs c'est-à-dire des tableaux qui peuvent être indexés avec n'importe quelle valeur Lua (à part nil). Les tables peuvent être hétérogènes et donc contenir des valeurs de types différents (à part nil). Les tables sont le seul mécanisme de structuration de l'information dans Lua, elles peuvent servir pour représenter des tableaux classiques, des tables de symboles, des graphes, des arbres… Pour représenter des enregistrements Lua utilise le champs comme index. Le langage support cette représentation en fournissant  qui est un raccourci syntaxique pour. Il existe de nombreuses méthodes pour créer des tables en Lua (voir &sect;2.5.7).

Like indices, the value of a table field can be of any type (except nil). In particular, because functions are first-class values, table fields can contain functions. Thus tables can also carry methods (see &sect;2.5.9).

Tables, functions, threads, and (full) userdata values are objects : variables do not actually contain these values, only references 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  returns a string describing the type of a given value.

Coercion
Lua provides automatic conversion between string and number values at run time. Any arithmetic operation applied to a string tries to convert this string to a number, following the usual conversion 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 over how numbers are converted to strings, use the  function from the string library (see ).

Variables
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 function's formal parameter, which is a particular kind of local variable):

var ::= Name

Name denotes identifiers, as defined in &sect;2.1.

Any variable is assumed to be global unless explicitly declared as a local (see &sect;2.4.7). Local variables are lexically scoped : local variables can be freely accessed by functions defined inside their scope (see &sect;2.6).

Before the first assignment to a variable, its value is nil.

Square brackets are used to index a table:

var ::= prefixexp `[&acute; exp `]&acute;

The meaning of accesses to global variables and table fields can be changed via metatables. An access to an indexed variable  is equivalent to a call. (See &sect;2.8 for a complete description of the function. This function is not defined or callable in Lua. We use it here only for explanatory purposes.)

The syntax  is just syntactic sugar for :

var ::= prefixexp `.&acute; Name

All global variables live as fields in ordinary Lua tables, called environment tables or simply environments. Each function has its own reference to an environment, so that all global variables in this function will refer to this environment table. When a function is created, it inherits the environment from the function that created it.

An access to a global variable is equivalent to , which in turn is equivalent to

where  is the environment of the running function. (See &sect;2.8 for a complete description of the function. This function is not defined or callable in Lua. Similarly, the   variable is not defined in Lua. We use them here only for explanatory purposes.)

In plain Lua, it is possible to get and set the environment of a function, however this is not possible in MediaWiki.

Statements
Lua supports an almost conventional set of statements, similar to those in Pascal or C. This set includes assignments, control structures, function calls, and variable declarations.

Chunks
The unit of execution of Lua is called a chunk. A chunk is simply a sequence of statements, which are executed sequentially. Each statement can be optionally followed by a semicolon:

chunk ::= {stat [`;&acute;]}

There are no empty statements and thus ' ' is not legal.

Lua handles a chunk as the body of an anonymous function with a variable number of arguments (see &sect;2.5.9). As such, chunks can define local variables, receive arguments, and return values.

A chunk can be stored in a file or in a string inside the host program. To execute a chunk, Lua first pre-compiles the chunk into instructions for a virtual machine, and then it executes the compiled code with an interpreter for the virtual machine.

Chunks can also be pre-compiled into binary form; see program  for details. Programs in source and compiled forms are interchangeable; Lua automatically detects the file type and acts accordingly.

Blocks
A block is a list of statements; syntactically, a block is the same as a chunk:

block ::= chunk

A block can be explicitly delimited to produce a single statement:

stat ::= do block end

Explicit blocks are useful to control the scope of variable declarations. Explicit blocks are also sometimes used to add a return or break statement in the middle of another block (see &sect;2.4.4).

Assignment
Lua allows multiple assignments. Therefore, the syntax for assignment defines a list of variables on the left side and a list of expressions on the right side. The elements in both lists are separated by commas:

stat ::= varlist `=&acute; explist varlist ::= var {`,&acute; var} explist ::= exp {`,&acute; exp}

Expressions are discussed in &sect;2.5.

Before the assignment, the list of values is adjusted to the length of the list of variables. If there are more values than needed, the excess values are thrown away. If there are fewer values than needed, the list is extended with as many nil's as needed. If the list of expressions ends with a function call, then all values returned by that call enter the list of values, before the adjustment (except when the call is enclosed in parentheses; see &sect;2.5).

The assignment statement first evaluates all its expressions and only then are the assignments performed. Thus the code

sets  to 20, without affecting because the  in   is evaluated (to 3) before it is assigned 4. Similarly, the line

exchanges the values of  and  , and

cyclically permutes the values of,  , and.

The meaning of assignments to global variables and table fields can be changed via metatables. An assignment to an indexed variable  is equivalent to. (See &sect;2.8 for a complete description of the function. This function is not defined or callable in Lua. We use it here only for explanatory purposes.)

An assignment to a global variable is equivalent to the assignment , which in turn is equivalent to

where  is the environment of the running function. (The  variable is not defined in Lua. We use it here only for explanatory purposes.)

Control Structures
The control structures if, while, and repeat have the usual meaning and familiar syntax:

stat ::= while exp do block end stat ::= repeat block until exp stat ::= if exp then block {elseif exp then block} [else block] end

Lua also has a for statement, in two flavors (see &sect;2.4.5).

The condition expression of a control structure can return any value. Both false and nil are considered false. All values different from nil and false are considered true (in particular, the number 0 and the empty string are also true).

In the repeat–until loop, the inner block does not end at the until keyword, but only after the condition. So, the condition can refer to local variables declared inside the loop block.

The return statement is used to return values from a function or a chunk (which is just a function).

Functions and chunks can return more than one value, and so the syntax for the return statement is

stat ::= return [explist]

The break statement is used to terminate the execution of a while, repeat, or for loop, skipping to the next statement after the loop:

stat ::= break

A break ends the innermost enclosing loop.

The return and break statements can only be written as the last statement of a block. If it is really necessary to return or break in the middle of a block, then an explicit inner block can be used, as in the idioms and , because now return and break are the last statements in their (inner) blocks.

For Statement
The for statement has two forms: one numeric and one generic.

The numeric for loop repeats a block of code while a control variable runs through an arithmetic progression. It has the following syntax:

stat ::= for Name `=&acute; exp `,&acute; exp [`,&acute; exp] do block end

The block is repeated for name starting at the value of the first exp, until it passes the second exp by steps of the third exp. More precisely, a for statement like

for v = e1, e2 , e3 do block end

is equivalent to the code:

do      local var, limit , step = tonumber( e1 ), tonumber( e2 ), tonumber( e3 ) if not ( var and limit and step ) then error end while ( step &gt; 0 and var &lt;= limit ) or ( step &lt;= 0 and var &gt;= limit ) do        local v = var block var = var + step end end

Note the following:



 All three control expressions are evaluated only once, before the loop starts. They must all result in numbers. 

 ,, and   are invisible variables. The names shown here are for explanatory purposes only. 

 If the third expression (the step) is absent, then a step of 1 is used. 

 You can use break to exit a for loop. 

 The loop variable  is local to the loop; you cannot use its value after the for ends or is broken. If you need this value, assign it to another variable before breaking or exiting the loop. 



The generic for statement works over functions, called iterators. On each iteration, the iterator function is called to produce a new value, stopping when this new value is nil. The generic for loop has the following syntax:

stat ::= for namelist in explist do block end namelist ::= Name {`,&acute; Name}

A for statement like

for var_1, &middot;&middot;&middot;, var_n in explist do block end

is equivalent to the code:

do      local f, s , var = explist while true do        local var_1, &middot;&middot;&middot;, var_n = f ( s , var ) var = var_1 if var == nil then break end block end end

Note the following:



 is evaluated only once. Its results are an iterator function, a state , and an initial value for the first iterator variable. </li>

 ,, and   are invisible variables. The names are here for explanatory purposes only. </li>

 You can use break to exit a for loop. </li>

 The loop variables  are local to the loop; you cannot use their values after the for ends. If you need these values, then assign them to other variables before breaking or exiting the loop. </li>

</ul>

Function Calls as Statements
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 &sect;2.5.8.

Local Declarations
Local variables can be declared anywhere inside a block. The declaration can include an initial assignment:

stat ::= local namelist [`=&acute; explist]

If present, an initial assignment has the same semantics of a multiple assignment (see &sect;2.4.3). Otherwise, all variables are initialized with nil.

A chunk is also a block (see &sect;2.4.1), and so local variables can be declared in a chunk outside any explicit block. The scope of such local variables extends until the end of the chunk.

The visibility rules for local variables are explained in &sect;2.6.

Expressions
The basic expressions in Lua are the following:

exp ::= prefixexp exp ::= nil | false | true exp ::= Number exp ::= String exp ::= function exp ::= tableconstructor exp ::= `...&acute; exp ::= exp binop exp exp ::= unop exp prefixexp ::= var | functioncall | `(&acute; exp `)&acute;

Numbers and literal strings are explained in &sect;2.1; variables are explained in &sect;2.3; function definitions are explained in &sect;2.5.9; function calls are explained in &sect;2.5.8; table constructors are explained in &sect;2.5.7. Vararg expressions, denoted by three dots (' '), can only be used when directly inside a vararg function; they are explained in &sect;2.5.9.

Binary operators comprise arithmetic operators (see &sect;2.5.1), relational operators (see &sect;2.5.2), logical operators (see &sect;2.5.3), and the concatenation operator (see &sect;2.5.4). Unary operators comprise the unary minus (see &sect;2.5.1), the unary not (see &sect;2.5.3), and the unary length operator (see &sect;2.5.5).

Both function calls and vararg expressions can result in multiple values. If an expression is used as a statement (only possible for function calls (see &sect;2.4.6)), then its return list is adjusted to zero elements, thus discarding all returned values. If an expression is used as the last (or the only) element of a list of expressions, then no adjustment is made (unless the call is enclosed in parentheses). In all other contexts, Lua adjusts the result list to one element, discarding all values except the first one.

Here are some examples:

Any expression enclosed in parentheses always results in only one value. Thus, is always a single value, even if  returns several values. (The value of  is the first value returned by  or nil if   does not return any values.)

Arithmetic Operators
Lua supports the usual arithmetic operators: the binary  (addition), (subtraction),  (multiplication), (division),  (modulo), and   (exponentiation); and unary  (negation). If the operands are numbers, or strings that can be converted to numbers (see &sect;2.2.1), then all operations have the usual meaning. Exponentiation works for any exponent. For instance,  computes the inverse of the square root of. Modulo is defined as

That is, it is the remainder of a division that rounds the quotient towards minus infinity.

Relational Operators
The relational operators in Lua are

<div style="column-width: 10em; -moz-column-width: 10em; -webkit-column-width: 10em; font-family: monospace">
 * &lt;
 * &gt;
 * &lt;=
 * &gt;=
 * &lt;=
 * &gt;=

These operators always result in false or true.

Equality first compares the type of its operands. If the types are different, then the result is false. 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 : two objects are considered equal only if they are the same object. Every time you create a new object (a table, userdata, thread, or function), this new object is different from any previously existing object.

You can change the way that Lua compares tables and userdata by using the "eq" metamethod (see &sect;2.8).

The conversion rules of &sect;2.2.1 do not apply to equality comparisons. Thus,  evaluates to false, and  and   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 &sect;2.8). A comparison  is translated to  and   is translated to.

Logical Operators
The logical operators in Lua are and, or, and not. Like the control structures (see &sect;2.4.4), all logical operators consider both false and nil as false and anything else as true.

The negation operator not always returns false or true. The conjunction operator and returns its first argument if this value is false or nil; otherwise, and returns its second argument. The disjunction operator or returns its first argument if this value is different from nil and false; otherwise, or returns its second argument. Both and and or use short-cut evaluation; that is, the second operand is evaluated only if necessary. Here are some examples:

10 or 20           --&gt; 10 10 or error      --&gt; 10 nil or "a"         --&gt; "a" nil and 10         --&gt; nil false and error  --&gt; false false and nil      --&gt; false false or nil       --&gt; nil 10 and 20          --&gt; 20

(In this manual, indicates the result of the preceding expression.)

Concatenation
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 &sect;2.2.1. Otherwise, the "concat" metamethod is called (see &sect;2.8).

The Length Operator
The length operator is denoted by the unary operator. The length of a string is its number of bytes (that is, the usual meaning of string length when each character is one byte).

The length of a table  is defined to be any integer index such that  is not nil and   is nil; moreover, if  is nil,   can be zero. For a regular array, with non-nil values from 1 to a given , its length is exactly that , the index of its last value. If the array has "holes" (that is, nil values between other non-nil values), then  can be any of the indices that directly precedes a nil value (that is, it may consider any such nil value as the end of the array).

Precedence
Operator precedence in Lua follows the table below, from lower to higher priority:

or    and &lt;    &gt;     &lt;=    &gt;=    ~=    == ..    +     -     *     /     %     not   #     - (unary) ^

As usual, you can use parentheses to change the precedences of an expression. The concatenation (' ') and exponentiation (' ') operators are right associative. All other binary operators are left associative.

Table Constructors
Table constructors are expressions that create tables. Every time a constructor is evaluated, a new table is created. A constructor can be used to create an empty table or to create a table and initialize some of its fields. The general syntax for constructors is

tableconstructor ::= `{&acute; [fieldlist] `}&acute; fieldlist ::= field {fieldsep field} [fieldsep] field ::= `[&acute; exp `]&acute; `=&acute; exp | Name `=&acute; exp | exp fieldsep ::= `,&acute; | `;&acute;

Each field of the form  adds to the new table an entry with key  and value. A field of the form  is equivalent to. Finally, fields of the form  are equivalent to, where   are consecutive numerical integers, starting with 1. Fields in the other formats do not affect this counting. For example,

is equivalent to

If the last field in the list has the form and the expression is a function call or a vararg expression, then all values returned by this expression enter the list consecutively (see &sect;2.5.8). To avoid this, enclose the function call or the vararg expression in parentheses (see &sect;2.5).

The field list can have an optional trailing separator, as a convenience for machine-generated code.

Function Calls
A function call in Lua has the following syntax:

functioncall ::= prefixexp args

In a function call, first prefixexp and args are evaluated. If the value of prefixexp has type function , then this function is called with the given arguments. Otherwise, the prefixexp "call" metamethod is called, having as first parameter the value of prefixexp, followed by the original call arguments (see &sect;2.8).

The form

functioncall ::= prefixexp `:&acute; Name args

can be used to call "methods". A call is syntactic sugar for , except that  is evaluated only once.

Arguments have the following syntax:

args ::= `(&acute; [explist] `)&acute; args ::= tableconstructor args ::= String

All argument expressions are evaluated before the call. A call of the form  is syntactic sugar for  ; that is, the argument list is a single new table. A call of the form (or  or  ) is syntactic sugar for ; that is, the argument list is a single literal string.

As an exception to the free-format syntax of Lua, you cannot put a line break before the ' ' in a function call. This restriction avoids some ambiguities in the language. If you write

Lua would see that as a single statement,. So, if you want two statements, you must add a semi-colon between them. If you actually want to call , you must remove the line break before.

A call of the form  functioncall is called a tail call. Lua implements proper tail calls (or proper tail recursion ): 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 has one single function call as argument; this syntax makes the calling function return exactly the returns of the called function. So, none of the following examples are tail calls:

Function Definitions
The syntax for function definition is

function ::= function funcbody funcbody ::= `(&acute; [parlist] `)&acute; block end

The following syntactic sugar simplifies function definitions:

stat ::= function funcname funcbody stat ::= local function Name funcbody funcname ::= Name {`.&acute; Name} [`:&acute; Name]

The statement

function f body end

translates to

f = function body end

The statement

function t.a.b.c.f body end

translates to

t.a.b.c.f = function body end

The statement

local function f body end

translates to

local f; f = function body end

not to

local f = function body end

(This only makes a difference when the body of the function contains references to .)

A function definition is an executable expression, whose value has type function. 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 (or closed ). This function instance (or closure ) is the final value of the expression. Different instances of the same function can refer to different external local variables and can have different environment tables.

Parameters act as local variables that are initialized with the argument values:

parlist ::= namelist [`,&acute; `...&acute;] | `...&acute;

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 , 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 and supplies them to the function through a vararg expression , which is also written as three dots. The value of this expression is a list of all actual extra arguments, similar to a function with multiple results. If a vararg expression is used inside another expression or in the middle of a list of expressions, then its return list is adjusted to one element. If the expression is used as the last element of a list of expressions, then no adjustment is made (unless that last expression is enclosed in parentheses).

As an example, consider the following definitions:

Then, we have the following mapping from arguments to parameters and to the vararg expression:

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, ... --&gt; (nothing) g(3, 4)         a=3, b=4,   ... --&gt; (nothing) g(3, 4, 5, 8)   a=3, b=4,   ... --&gt; 5  8 g(5, r)       a=5, b=1,   ... --&gt; 2  3

Results are returned using the return statement (see &sect;2.4.4). If control reaches the end of a function without encountering a return statement, then the function returns with no results.

The colon syntax is used for defining methods , that is, functions that have an implicit extra parameter. Thus, the statement

function t.a.b.c:f ( params ) body end

is syntactic sugar for

t.a.b.c.f = function (self, params ) body end

Visibility Rules
Lua is a lexically scoped language. The scope of variables begins at the first statement after their declaration and lasts until the end of the innermost block that includes the declaration. Consider the following example:

Notice that, in a declaration like , the new  being declared is not in scope yet, and so the second  refers to the outside variable.

Because of the lexical scoping rules, local variables can be freely accessed by functions defined inside their scope. A local variable used by an inner function is called an upvalue, or external local variable , inside the inner function.

Notice that each execution of a local statement defines new local variables. Consider the following example:

The loop creates ten closures (that is, ten instances of the anonymous function). Each of these closures uses a different  variable, while all of them share the same.

Error Handling
Because Lua is an embedded extension language, all Lua actions start from C code in the host program calling a function from the Lua library. Whenever an error occurs during Lua compilation or execution, control returns to C, which can take appropriate measures (such as printing an error message).

Lua code can explicitly generate an error by calling the function. If you need to catch errors in Lua, you can use the  function.

Metatables
Every value in Lua can have a metatable. This metatable is an ordinary Lua table that defines the behavior of the original value under certain special operations. You can change several aspects of the behavior of operations over a value by setting specific fields in its metatable. For instance, when a non-numeric value is the operand of an addition, Lua checks for a function in the field  in its metatable. If it finds one, Lua calls this function to perform the addition.

We call the keys in a metatable events and the values metamethods. In the previous example, the event is  and the metamethod is the function that performs the addition.

You can query the metatable of any value through the  function.

You can replace the metatable of tables through the function. You cannot change the metatable of other types from Lua (except by using the debug library); you must use the C API for that.

Tables and full userdata have individual metatables (although multiple tables and userdata can share their metatables). Values of all other types share one single metatable per type; that is, there is one single metatable for all numbers, one for all strings, etc.

A metatable controls how an object behaves in arithmetic operations, order comparisons, concatenation, length operation, and indexing. A metatable also can define a function to be called when a userdata is garbage collected. For each of these operations Lua associates a specific key called an event. When Lua performs one of these operations over a value, it checks whether this value has a metatable with the corresponding event. If so, the value associated with that key (the metamethod) 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. The semantics of these operations is better explained by a Lua function describing how the interpreter executes the 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 (, , etc.) are described in &sect;3.1. In particular, to retrieve the metamethod of a given object, we use the expression

This should be read as

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).



"add": the  operation.

The function  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.

By using this function, the behavior of the  is

</li>

"sub": the  operation.

Behavior similar to the "add" operation. </li>

"mul": the  operation.

Behavior similar to the "add" operation. </li>

"div": the  operation.

Behavior similar to the "add" operation. </li>

"mod": the  operation.

Behavior similar to the "add" operation, with the operation as the primitive operation. </li>

"pow": the  (exponentiation) operation.

Behavior similar to the "add" operation, with the function  (from the C math library) as the primitive operation. </li>

"unm": the unary  operation.

</li>

"concat": the  (concatenation) operation.

</li>

"len": the  operation.

See &sect;2.5.5 for a description of the length of a table. </li>

"eq": the  operation.

The function  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.

The "eq" event is defined as follows:

is equivalent to. </li>

"lt": the  operation.

is equivalent to. </li>

<li>"le": the  operation.

is equivalent to. Note that, in the absence of a "le" metamethod, Lua tries the "lt", assuming that  is equivalent to. </li>

<li>"index": The indexing access.

</li>

<li>"newindex": The indexing assignment.

</li>

<li>"call": called when Lua calls a value.

</li>

</ul>

Garbage Collection
Lua performs automatic memory management. This means that you have to worry neither about allocating memory for new objects nor about freeing it when the objects are no longer needed. Lua manages memory automatically by running a garbage collector from time to time to collect all dead objects (that is, objects that are no longer accessible from Lua). All memory used by Lua is subject to automatic management: tables, userdata, functions, threads, strings, etc.

Lua implements an incremental mark-and-sweep collector. It uses two numbers to control its garbage-collection cycles: the garbage-collector pause and the garbage-collector step multiplier. Both use percentage points as units (so that a value of 100 means an internal value of 1).

The garbage-collector pause controls how long the collector waits before starting a new cycle. Larger values make the collector less aggressive. Values smaller than 100 mean the collector will not wait to start a new cycle. A value of 200 means that the collector waits for the total memory in use to double before starting a new cycle.

The step multiplier controls the relative speed of the collector relative to memory allocation. Larger values make the collector more aggressive but also increase the size of each incremental step. Values smaller than 100 make the collector too slow and can result in the collector never finishing a cycle. The default, 200, means that the collector runs at "twice" the speed of memory allocation.

You can change these numbers by calling. With this function you can also control the collector directly (e.g., stop and restart it).

Garbage-Collection Metamethods
Using the C API, you can set garbage-collector metamethods for userdata (see &sect;2.8). These metamethods are also called finalizers. 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).

Garbage userdata with a field  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:

At the end of each garbage-collection cycle, the finalizers for userdata are called in reverse 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. The userdata itself is freed only in the next garbage-collection cycle.

Weak Tables
A weak table is a table whose elements are weak references. 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 this 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 field of its metatable. If the  field is a string containing the character ' ', the keys in the table are weak. If  contains ' ', the values in the table are weak.

After you use a table as a metatable, you should not change the value of its  field. Otherwise, the weak behavior of the tables controlled by this metatable is undefined.

Standard Libraries
The standard Lua libraries provide useful functions that are implemented directly through the C API. Some of these functions provide essential services to the language (e.g.,  and  ); others provide access to "outside" services (e.g., I/O); and others could be implemented in Lua itself, but are quite useful or have critical performance requirements that deserve an implementation in C (e.g., ).

All libraries are implemented through the official C API and are provided as separate C modules. Currently, Lua has the following standard libraries:

<ul>

<li>basic library, which includes the coroutine sub-library;</li>

<li>package library;</li>

<li>string manipulation;</li>

<li>table manipulation;</li>

<li>mathematical functions (sin, log, etc.);</li>

<li>input and output;</li>

<li>operating system facilities;</li>

<li>debug facilities.</li>

</ul>

Except for the basic and package libraries, each library provides all its functions as fields of a global table or as methods of its objects.

Basic Functions
The basic library provides some core functions to Lua. If you do not include this library in your application, you should check carefully whether you need to provide implementations for some of its facilities.

Issues an error when the value of its argument  is false (i.e., nil or false); otherwise, returns all its arguments. is an error message; when absent, it defaults to "assertion failed!"

This function is a generic interface to the garbage collector. It performs different functions according to its first argument, :

<ul>

<li>"collect": performs a full garbage-collection cycle. This is the default option. </li>

<li>"stop": stops the garbage collector. </li>

<li>"restart": restarts the garbage collector. </li>

<li>"count": returns the total memory in use by Lua (in Kbytes). </li>

<li>"step": performs a garbage-collection step. The step "size" is controlled by (larger values mean more steps) in a non-specified way. If you want to control the step size you must experimentally tune the value of. Returns true if the step finished a collection cycle. </li>

<li>"setpause": sets  as the new value for the pause of the collector (see &sect;2.10). Returns the previous value for pause. </li>

<li>"setstepmul": sets  as the new value for the step multiplier of the collector (see &sect;2.10). Returns the previous value for step. </li>

</ul>

Terminates the last protected function called and returns  as the error message. Function  never returns.

Usually,  adds some information about the error position at the beginning of the message. The  argument specifies how to get the error position. With level 1 (the default), the error position is where the function was called. Level 2 points the error to where the function that called  was called; and so on. Passing a level 0 avoids the addition of error position information to the message.

A global variable (not a function) that holds the global environment (that is, ). Lua itself does not use this variable; changing its value does not affect any environment, nor vice-versa.

If  does not have a metatable, returns nil. Otherwise, if the object's metatable has a  field, returns the associated value. Otherwise, returns the metatable of the given object.

Returns three values: an iterator function, the table, and 0, so that the construction

for i,v in ipairs(t) do body end

will iterate over the pairs, , &middot;&middot;&middot;, up to the first integer key absent from the table.

Allows a program to traverse all fields of a table. Its first argument is a table and its second argument is an index in this table. returns the next index of the table and its associated value. When called with nil as its second argument, returns an initial index and its associated value. When called with the last index, or with nil in an empty table, returns nil. If the second argument is absent, then it is interpreted as nil. In particular, you can use  to check whether a table is empty.

The order in which the indices are enumerated is not specified, even for numeric indices. (To traverse a table in numeric order, use a numerical for or the  function.)

The behavior of  is undefined if, during the traversal, you assign any value to a non-existent field in the table. You may however modify existing fields. In particular, you may clear existing fields.

Returns three values: the  function, the table , and nil, so that the construction

for k,v in pairs(t) do body end

will iterate over all key–value pairs of table.

See function  for the caveats of modifying the table during its traversal.

Calls function  with the given arguments in protected mode. This means that any error inside  is not propagated; instead,  catches the error and returns a status code. Its first result is the status code (a boolean), which is true if the call succeeds without errors. In such case,  also returns all results from the call, after this first result. In case of any error,  returns false plus the error message.

This function is only available in code executed from the debug console, available in some MediaWiki installations when editing a module. It is equivalent to mw.log.

Checks whether  is equal to  , without invoking any metamethod. Returns a boolean.

Gets the real value of , without invoking any metamethod. must be a table; may be any value.

Sets the real value of  to  , without invoking any metamethod. must be a table, any value different from nil, and  any Lua value.

This function returns.

If  is a number, returns all arguments after argument number. Otherwise,  must be the string  , and  returns the total number of extra arguments it received.

Sets the metatable for the given table. (You cannot change the metatable of other types from Lua, only from C.) If  is nil, removes the metatable of the given table. If the original metatable has a  field, raises an error.

This function returns.

Tries to convert its argument to a number. If the argument is already a number or a string convertible to a number, then  returns this number; otherwise, it returns nil.

An optional argument specifies the base to interpret the numeral. The base may be any integer between 2 and 36, inclusive. In bases above 10, the letter ' ' (in either upper or lower case) represents 10, ' ' represents 11, and so forth, with ' ' representing 35. In base 10 (the default), the number can have a decimal part, as well as an optional exponent part (see &sect;2.1). In other bases, only unsigned integers are accepted.

Receives an argument of any type and converts it to a string in a reasonable format. For complete control of how numbers are converted, use.

If the metatable of  has a   field, then  calls the corresponding value with  as argument, and uses the result of the call as its result.

Returns the type of its only argument, coded as a string. The possible results of this function are " " (a string, not the value nil), " ", " ", " ", " ", " ", " ", and " ".

Returns the elements from the given table. This function is equivalent to

except that the above code can be written only for a fixed number of elements. By default,  is 1 and   is the length of the list, as defined by the length operator (see &sect;2.5.5).

A global variable (not a function) that holds a string containing the current interpreter version. The current contents of this variable is " ".

This function is similar to , except that you can set a new error handler.

calls function  in protected mode, using  as the error handler. Any error inside  is not propagated; instead,  catches the error, calls the  function with the original error object, and returns a status code. Its first result is the status code (a boolean), which is true if the call succeeds without errors. In this case,  also returns all results from the call, after this first result. In case of any error, returns false plus the result from.

Modules
The package library provides basic facilities for loading and building modules in Lua. It exports the  function directly in the global environment. Everything else is exported in a table.

Loads the given module. The function starts by looking into the  table to determine whether  is already loaded. If it is, then  returns the value stored at. Otherwise, it tries to find a loader for the module.

To find a loader, is guided by the  array. By changing this array, we can change how  looks for a module.

A table used by  to control which modules are already loaded. When you require a module  and is not false, simply returns the value stored there.

A table used by  to control how to load modules.

Each entry in this table is a searcher function. When looking for a module, calls each of these searchers in ascending order, with the module name (the argument given to ) as its sole parameter. The function can return another function (the module loader ) or a string explaining why it did not find that module (or nil if it has nothing to say). Lua initializes this table with four functions.

The first searcher simply looks for a loader in the table.

The second searcher calls back to MediaWiki. MediaWiki provides several built-in modules, and allows modules on the local wiki to be loaded by using a "Module:" prefix.

A table to store loaders for specific modules (see ).

String Manipulation
This library provides generic functions for string manipulation, such as finding and extracting substrings, and pattern matching. When indexing a string in Lua, the first character is at position 1 (not at 0, as in C). Indices are allowed to be negative and are interpreted as indexing backwards, from the end of the string. Thus, the last character is at position -1, and so on.

The string library provides all its functions inside the table . It also sets a metatable for strings where the  field points to the   table. Therefore, you can use the string functions in object-oriented style. For instance, can be written as.

The string library assumes one-byte character encodings.

Returns the internal numerical codes of the characters , , &middot;&middot;&middot;,. The default value for  is 1; the default value for  is.

Receives zero or more integers. Returns a string with length equal to the number of arguments, in which each character has the internal numerical code equal to its corresponding argument.

Looks for the first match of in the string. If it finds a match, then  returns the indices of  where this occurrence starts and ends; otherwise, it returns nil. A third, optional numerical argument  specifies where to start the search; its default value is 1 and can be negative. A value of true as a fourth, optional argument turns off the pattern matching facilities, so the function does a plain "find substring" operation, with no characters in  being considered "magic". Note that if  is given, then   must be given as well.

If the pattern has captures, then in a successful match the captured values are also returned, after the two indices.

Returns a formatted version of its variable number of arguments following the description given in its first argument (which must be a string). The format string follows the same rules as the  family of standard C functions. The only differences are that the options/modifiers ,,  ,  ,  , and   are not supported and that there is an extra option,. The  option formats a string in a form suitable to be safely read back by the Lua interpreter: the string is written between double quotes, and all double quotes, newlines, embedded zeros, and backslashes in the string are correctly escaped when written. For instance, the call

will produce the string:

The options,  ,  ,  ,  , ,,  ,  ,  ,  , and   all expect a number as argument, whereas  and   expect a string.

This function does not accept string values containing embedded zeros, except as arguments to the  option.

Returns an iterator function that, each time it is called, returns the next captures from  over string. If  specifies no captures, then the whole match is produced in each call.

As an example, the following loop

will iterate over all the words from string , printing one per line. The next example collects all pairs  from the given string into a table:

For this function, a ' ' at the start of a pattern does not work as an anchor, as this would prevent the iteration.

Returns a copy of in which all (or the first , if given) occurrences of the  have been replaced by a replacement string specified by , which can be a string, a table, or a function. also returns, as its second value, the total number of matches that occurred.

If  is a string, then its value is used for replacement. The character  works as an escape character: any sequence in  of the form  , with n between 1 and 9, stands for the value of the n -th captured substring (see below). The sequence  stands for the whole match. The sequence  stands for a single.

If  is a table, then the table is queried for every match, using the first capture as the key; if the pattern specifies no captures, then the whole match is used as the key.

If  is a function, then this function is called every time a match occurs, with all captured substrings passed as arguments, in order; if the pattern specifies no captures, then the whole match is passed as a sole argument.

If the value returned by the table query or by the function call is a string or a number, then it is used as the replacement string; otherwise, if it is false or nil, then there is no replacement (that is, the original match is kept in the string).

Here are some examples:

Receives a string and returns its length. The empty string  has length 0. Embedded zeros are counted, so  has length 5.

Receives a string and returns a copy of this string with all uppercase letters changed to lowercase. All other characters are left unchanged. The definition of what an uppercase letter is depends on the current locale.

Looks for the first match of in the string. If it finds one, then  returns the captures from the pattern; otherwise it returns nil. If  specifies no captures, then the whole match is returned. A third, optional numerical argument  specifies where to start the search; its default value is 1 and can be negative.

Returns a string that is the concatenation of  copies of the string.

Returns a string that is the string  reversed.

Returns the substring of  that starts at   and continues until  ; and  can be negative. If  is absent, then it is assumed to be equal to -1 (which is the same as the string length). In particular, the call  returns a prefix of  with length  , and  returns a suffix of  with length.

Receives a string and returns a copy of this string with all lowercase letters changed to uppercase. All other characters are left unchanged. The definition of what a lowercase letter is depends on the current locale.

Character Class:
A character class is used to represent a set of characters. The following combinations are allowed in describing a character class:

<ul> <li> x : (where x is not one of the magic characters ) represents the character x itself.</li> <li> : (a dot) represents all characters.</li> <li> : represents all letters.</li> <li> : represents all control characters.</li> <li> : represents all digits.</li> <li> : represents all lowercase letters.</li> <li> : represents all punctuation characters.</li> <li> : represents all space characters.</li> <li> : represents all uppercase letters.</li> <li> : represents all alphanumeric characters.</li> <li> : represents all hexadecimal digits.</li> <li> : represents the character with representation 0.</li> <li> : (where x is any non-alphanumeric character) represents the character x. This is the standard way to escape the magic characters. Any punctuation character (even the non magic) can be preceded by a ' ' when used to represent itself in a pattern. </li>

<li> : represents the class which is the union of all characters in set. A range of characters can be specified by separating the end characters of the range with a ' '. All classes x described above can also be used as components in set. All other characters in set represent themselves. For example,  (or  ) represents all alphanumeric characters plus the underscore, represents the octal digits, and  represents the octal digits plus the lowercase letters plus the ' ' character.

The interaction between ranges and classes is not defined. Therefore, patterns like  or  have no meaning. </li>

<li> : represents the complement of set , where set is interpreted as above. </li>

</ul>

For all classes represented by single letters (, , etc.), the corresponding uppercase letter represents the complement of the class. For instance,  represents all non-space characters.

The definitions of letter, space, and other character groups depend on the current locale. In particular, the class  may not be equivalent to.

Pattern Item:
A pattern item can be

<ul>

<li> a single character class, which matches any single character in the class; </li>

<li> a single character class followed by ' ', which matches 0 or more repetitions of characters in the class. These repetition items will always match the longest possible sequence; </li>

<li> a single character class followed by ' ', which matches 1 or more repetitions of characters in the class. These repetition items will always match the longest possible sequence; </li>

<li> a single character class followed by ' ', which also matches 0 or more repetitions of characters in the class. Unlike ' ', these repetition items will always match the shortest possible sequence; </li>

<li> a single character class followed by ' ', which matches 0 or 1 occurrence of a character in the class; </li>

<li> , for n between 1 and 9; such item matches a substring equal to the n -th captured string (see below); </li>

<li> , where x and y are two distinct characters; such item matches strings that start with x, end with y , and where the x and y are balanced. This means that, if one reads the string from left to right, counting +1 for an x and -1 for a y , the ending y is the first y where the count reaches 0. For instance, the item  matches expressions with balanced parentheses. </li>

</ul>

Pattern:
A pattern is a sequence of pattern items. A ' ' at the beginning of a pattern anchors the match at the beginning of the subject string. A ' ' at the end of a pattern anchors the match at the end of the subject string. At other positions, ' ' and ' ' have no special meaning and represent themselves.

Captures:
A pattern can contain sub-patterns enclosed in parentheses; they describe captures. When a match succeeds, the substrings of the subject string that match captures are stored ( captured ) for future use. Captures are numbered according to their left parentheses. For instance, in the pattern , the part of the string matching  is stored as the first capture (and therefore has number 1); the character matching " " is captured with number 2, and the part matching " " has number 3.

As a special case, the empty capture  captures the current string position (a number). For instance, if we apply the pattern  on the string, there will be two captures: 3 and 5.

A pattern cannot contain embedded zeros. Use  instead.

Table Manipulation
This library provides generic functions for table manipulation. It provides all its functions inside the table.

Most functions in the table library assume that the table represents an array or a list. For these functions, when we talk about the "length" of a table we mean the result of the length operator.

Given an array where all elements are strings or numbers, returns. The default value for  is the empty string, the default for  is 1, and the default for  is the length of the table. If  is greater than , returns the empty string.

Inserts element  at position   in  , shifting up other elements to open space, if necessary. The default value for  is  , where  is the length of the table (see &sect;2.5.5), so that a call  inserts   at the end of table.

Returns the largest positive numerical index of the given table, or zero if the table has no positive numerical indices. (To do its job this function does a linear traversal of the whole table.)

Removes from  the element at position  , shifting down other elements to close the space, if necessary. Returns the value of the removed element. The default value for  is  , where  is the length of the table, so that a call  removes the last element of table.

Sorts table elements in a given order, in-place , from  to  , where  is the length of the table. If  is given, then it must be a function that receives two table elements, and returns true when the first is less than the second (so that  will be true after the sort). If  is not given, then the standard Lua operator  is used instead.

The sort algorithm is not stable; that is, elements considered equal by the given order may have their relative positions changed by the sort.

Mathematical Functions
This library is an interface to the standard C math library. It provides all its functions inside the table.

Returns the absolute value of.

Returns the arc cosine of  (in radians).

Returns the arc sine of  (in radians).

Returns the arc tangent of  (in radians).

Returns the arc tangent of  (in radians), but uses the signs of both parameters to find the quadrant of the result. (It also handles correctly the case of  being zero.)

Returns the smallest integer larger than or equal to.

Returns the cosine of  (assumed to be in radians).

Returns the hyperbolic cosine of.

Returns the angle  (given in radians) in degrees.

Returns the value ex.

Returns the largest integer smaller than or equal to.

Returns the remainder of the division of  by  that rounds the quotient towards zero.

Returns  and   such that x = m2e , is an integer and the absolute value of  is in the range [0.5, 1) (or zero when   is zero).

The value , a value larger than or equal to any other numerical value.

Returns m2e ( should be an integer).

Returns the natural logarithm of.

Returns the base-10 logarithm of.

Returns the maximum value among its arguments.

Returns the minimum value among its arguments.

Returns two numbers, the integral part of  and the fractional part of.

The value of pi.

Returns xy. (You can also use the expression  to compute this value.)

Returns the angle  (given in degrees) in radians.

This function is an interface to the simple pseudo-random generator function  provided by ANSI C. (No guarantees can be given for its statistical properties.)

When called without arguments, returns a uniform pseudo-random real number in the range [0,1) . When called with an integer number ,  returns a uniform pseudo-random integer in the range [1, m] . When called with two integer numbers   and  ,  returns a uniform pseudo-random integer in the range [m, n].

Sets  as the "seed" for the pseudo-random generator: equal seeds produce equal sequences of numbers.

Returns the sine of  (assumed to be in radians).

Returns the hyperbolic sine of.

Returns the square root of. (You can also use the expression  to compute this value.)

Returns the tangent of  (assumed to be in radians).

Returns the hyperbolic tangent of.

The Debug Library
This library provides the functionality of the debug interface to Lua programs. You should exert care when using this library. The functions provided here should be used exclusively for debugging and similar tasks, such as profiling. Please resist the temptation to use them as a usual programming tool: they can be very slow. Moreover, several of these functions violate some assumptions about Lua code (e.g., that variables local to a function cannot be accessed from outside or that userdata metatables cannot be changed by Lua code) and therefore can compromise otherwise secure code.

All functions in this library are provided inside the table. All functions that operate over a thread have an optional first argument which is the thread to operate over. The default is always the current thread.

Returns a string with a traceback of the call stack. An optional  string is appended at the beginning of the traceback. An optional  number tells at which level to start the traceback (default is 1, the function calling ).

The table
The  table contains some general utility functions. It is always available.

Returns an independent copy of the specified value. Tables in Lua are assigned and passed to functions by reference, which means that if you change a table via one reference, the underlying table will immediately appear to have changed in the other references as well. For example:

mw.clone recursively copies all table elements, and also any metatable attached to the table value or its elements.

Cloning a table that contains a circular reference gives a table copy with an equivalent circular reference. For example:

Appends the specified message to the log buffer, with a newline automatically added. In the Scribunto debug console, any log messages added to the buffer in this way during console execution will be displayed on the screen after execution completes.

The object
When you call a Lua function from wikitext with, the Lua function will be passed a   object with the following properties and methods:

frame.args is a table with an "index" metamethod providing access to the arguments to. Suppose named arguments to  are specified, for example

Then the following Lua code in Module:Test will produce "bar":

If unnamed arguments are specified, then the unnamed arguments are given numbers starting with 1, with 1 being the first unnamed argument after the function name. For example with the wikitext:

And with Lua code:

This will also return "foo".

As in MediaWiki template invocations, named arguments will have leading and trailing whitespace removed from both the name and the value before they are passed to Lua, whereas unnamed arguments will not have whitespace stripped.

If a named argument has a name which is numeric and conflicts with the number assigned to an unnamed argument, then whichever argument appears rightmost in the invocation will take precedence. For example:

This will return "bar". Similarly, if two named parameters have the same name, then the rightmost one will be seen by Lua.

For performance reasons, frame.args is a metatable, not a real table of arguments. Argument values are requested from MediaWiki on demand. This means that you can't use  to iterate over all arguments. Instead, to iterate over all arguments, use the  method.

If preprocessor syntax such as template invocations and triple-brace arguments are included within an argument to, they will be expanded before being passed to Lua. If certain special tags written in XML notation, such as,  ,   and  , are included as arguments to #invoke, then these tags will be converted to "strip markers" &mdash; special strings which begin with a delete character (ASCII 127), to be replaced with HTML after they are returned from.

returns an iterator function. Each time the iterator function is called, it will return the name and value of an argument passed to. For example:

This will return the string "1=x, 2=y, 3=z".

runs MediaWiki's wikitext preprocessing stage on the string, returning the result. Templates and parser functions in the string will be expanded. Certain special tags written in XML-style notation, such as,  ,   and  , will be replaced with "strip markers" &mdash; special strings which begin with a delete character (ASCII 127), to be replaced with HTML after they are returned from.

Note that the arguments to, accessible with  , are already preprocessed. Care must be taken when passing such arguments into, since the effect of double-preprocessing can be undesirable. For example:

will have the  template expanded, conventionally to a single pipe character "|". So attempting to include this argument as a single parameter to a template is likely to fail:

To avoid this problem, and to improve performance, frame:expandTemplate should be used instead where possible.

expands a MediaWiki template, with the name of the template and the arguments of the invocation given as Lua variables. No preprocessing is done on these variables before they are passed to the template.

accepts a single table as its parameter. The table contains named arguments. Such a function may be called using Lua's special syntax for named arguments, with parentheses omitted:

The  argument is required. It contains a string naming the template to be called. As in a normal MediaWiki template invocation, if no colon character is present, a "Template:" prefix will be added to the start of the title. If there is a colon character, then it is taken to be the fully specified page name.

The  argument is optional. It contains a table of arguments to be passed to the template. If it is omitted, then no arguments will be passed to the template.

The Complete Syntax of Lua
Here is the complete syntax of Lua in extended BNF. (It does not describe operator precedences.)

chunk ::= {stat [`;&acute;]} [laststat [`;&acute;]] block ::= chunk stat ::= varlist `=&acute; explist | functioncall | do block end | while exp do block end | repeat block until exp | if exp then block {elseif exp then block} [else block] end | for Name `=&acute; exp `,&acute; exp [`,&acute; exp] do block end | for namelist in explist do block end | function funcname funcbody | local function Name funcbody | local namelist [`=&acute; explist] laststat ::= return [explist] | break funcname ::= Name {`.&acute; Name} [`:&acute; Name] varlist ::= var {`,&acute; var} var ::= Name | prefixexp `[&acute; exp `]&acute; | prefixexp `.&acute; Name namelist ::= Name {`,&acute; Name} explist ::= {exp `,&acute;} exp exp ::= nil | false | true | Number | String | `...&acute; | function | prefixexp | tableconstructor | exp binop exp | unop exp prefixexp ::= var | functioncall | `(&acute; exp `)&acute; functioncall ::= prefixexp args | prefixexp `:&acute; Name args args ::= `(&acute; [explist] `)&acute; | tableconstructor | String function ::= function funcbody funcbody ::= `(&acute; [parlist] `)&acute; block end parlist ::= namelist [`,&acute; `...&acute;] | `...&acute; tableconstructor ::= `{&acute; [fieldlist] `}&acute; fieldlist ::= field {fieldsep field} [fieldsep] field ::= `[&acute; exp `]&acute; `=&acute; exp | Name `=&acute; exp | exp fieldsep ::= `,&acute; | `;&acute; binop ::= `+&acute; | `-&acute; | `*&acute; | `/&acute; | `^&acute; | `%&acute; | `..&acute; | `&lt;&acute; | `&lt;=&acute; | `&gt;&acute; | `&gt;=&acute; | `==&acute; | `~=&acute; | and | or unop ::= `-&acute; | not | `#&acute;