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

Les chaînes littérales peuvent aussi être définies en utilisant un format long entouré par des crochets longs. Ouvrir un crochet long de niveau n consiste à ouvrir un crochet suivi de n signes égal suivi d'un autre crochet ouvrant. Un crochet long de niveau 0 correspond donc à  et un crochet long de niveau 1 à  … Un crochet long fermant se définit symétriquement :  est ainsi un crochet long fermant de niveau 4.

Une chaîne longue débute avec un crochet long ouvrant − peu importe le niveau − et se termine par un crochet long fermant de même niveau. Entre cette ouverture et fermeture la chaîne peut être sur plusieurs lignes et Lua n'effectue aucune interprétation des caractères comme les séquences d'échappement. De plus Lua ignore les crochets longs de niveau différent.

Pour aider le programmeur quand un crochet long ouvrant est immédiatement suivi d'un retour à la ligne celui-ci n'est pas intégré à la chaîne. Dans l'exemple qui suit et qui utilise le système ASCII (' ' vaut 97, le retour à la ligne vaut 10 et le caractère ' ' vaut 49) les cinq chaînes littérales suivantes correspondent au même contenu :

Une constante numérique peut s'écrire avec une partie décimale optionnelle ainsi qu'un exposant décimal optionnel. Lua accepte aussi les entiers hexadécimaux en les préfixant par. Quelques exemples de constantes numériques correctes :


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

Un commentaire commence par un double tiret (ou « moins ») où que ce soit sauf à l'intérieur d'une chaîne. Si juste après les  il y a un crochet ouvrant long il s'agit d'un commentaire long, qui se continue (éventuellement sur plusieurs lignes) jusqu'au crochet long fermant correspondant. Sinon il s'agit d'un commentaire court qui se termine implicitement à la fin de la ligne.

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

Comme pour les indices les valeurs des éléments d'une table peuvent être de n'importe quel type (sauf nil). En particulier − puisque les fonctions sont des first-class values, les champs d'une table peuvent contenir des fonctions. Il est ainsi possible d'avoir des méthodes dans les tables (voir &sect;2.5.9).

Les tables, les fonctions, les threads et les userdata sont des objets : les variables ne contiennent pas ces valeurs mais uniquement des références vers ces valeurs. Les passer à des fonctions ou les retourner n'implique aucune forme de copie.

La fonction  retourne une chaîne décrivant le type de la valeur passée en paramètre.

Coercition
Lua effectue des conversions automatiques entre les chaînes et les nombres à l'exécution. Toute opération arithmétique sur une chaîne tentera de convertir cette chaîne en nombre. De la même façon toute action qui attend une chaîne et qui reçoit un nombre convertira ce nombre en chaîne, dans un format « raisonnable ». Pour un contrôle complet sur comment les nombres sont convertis en chaînes utilisez la fonction  de la librairie string (voir  ).

Variables
Les variables sont des emplacements pour stocker des valeurs.

Il y a trois types de variables en Lua : les variables globales, les variables locales, et les champs de tables.

Un nom simple peut faire référence à une variable globale ou locale (ou à un paramètre formel de fonction, qui est une forme de variable locale) :

var ::= Name

Name dénote un identifiant, comme défini dans &sect;2.1.

Toute variable est supposée globale à moins qu'elle soit explicitement déclarée locale (voir &sect;2.4.7). Les variables locales ont une portée lexicale : elles peuvent être librement accédées par les fonctions définies à l'intérieur de leur portée (voir &sect;2.6).

Avant la première affectation d'une valeur à une variable celle-ci contient la valeur nil.

Les crochets sont utilisés pour indexer une table :

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

L'accès aux variables globales et aux champs des tables peut être modifié via les méta-tables. L'accès à la variable indexée  est équivalent à un appel à. (voir &sect;2.8 pour une description complête de la fonction . Cette fonction n'est pas définie ni utilisable en Lua, elle est décrite ici uniquement à des fins d'illustration du propos.)

La syntaxe  est une facilité syntaxique pour   :

var ::= prefixexp `.&acute; Name

Toutes les variables globales sont en fait des champs d'une table Lua, appelée table d'environnement ou plus simplement environnement.

Chaque fonction a sa propre référence d'un environnement, donc toute les variables globales dans cette fonction font référence à cette table d'environnement. Quand une fonction est créée elle hérite de l'environnement de la fonction qui l'a créé.

Un accès à la variable globale  est équivalent à , qui est lui même équivalent à

où   est l'environnement de la fonction en cours d'exécution. (Voir &sect;2.8 pour une description complête de la fonction . Cette fonction n'est pas définie ni utilisable en Lua, elle est décrite ici uniquement à des fins d'illustration du propos.)

En Lua natif il est possible d'accéder et de modifier l'environnement d'une fonction. Toutefois ceci n'est pas possible dans MediaWiki.

Instructions (statements)
Lua supporte des instructions relativement conventionnelles, similaires à celles du Pascal ou du C. Ceci inclue les assignations, les structures de contrôle, les appels de fonction et la déclaration de variables.

Morceaux (Chunks)
L'unité d'exécution en Lua est appelée chunk. Un chunk est simplement une séquence d'instructions qui sont exécutées séquentiellement. Chaqua instruction peut être suivie d'un point-virgule optionnel :

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

Il n'existe pas d'instruction vide, ainsi ' ' n'est pas valide.

Lua gère un chunk comme le corps d'une fonction anonyme avec un nombre variable de paramètres (voir &sect;2.5.9). Ainsi les chunks peuvent définir des variables locales, recevoir des paramètres et retourner des valeurs.

Un chunk peut être stocké dans un fichier ou une chaîne dans le programme hôte. Pour exécuter un chunk Lua commence par le pré-compiler en instruction pour sa machine virtuelle, puis exécute le code résultant dans l'interpréteur de cette machine virtuelle.

Les chunks peuvent aussi être pré-compilés sous forme binaire (voir le programme  pour plus de détails). Les programmes sous forme de sources ou compilés sont interchangeables, Lua détectant automatiquement le type de fichier et le traitant de la façon adaptée.

Les blocs
Un bloc est une liste d'instructions. Syntaxiquement un bloc est identique à un chunk :

block ::= chunk

Un bloc peut être délimité explicitement pour en faire une instruction unique (appelés blocs explicites :

stat ::= do block end

Les blocs explicites sont utiles pour contrôler la portée des variables. Les blocs explicites sont également parfois utilisés pour ajouter un return ou un break au milieu d'un autre bloc (voir &sect;2.4.4).

Affectation
Lua autorique des affectations multiples. C'est pourquoi la syntaxe d'une affectation comporte une liste de variables dans sa partie gauche et une liste d'expressions dans sa partie droite. Les éléments de chaque liste sont séparés par des virgules :

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

Les expressions sont détaillées dans &sect;2.5.

Avant l'affectation la liste des valeurs est ajustée à la longueur de la liste des variables. S'il y a plus de valeurs que nécessaire les valeurs en trop sont ignorées. S'il y a moins de valeurs que de variables la liste des valeurs est étendue autant que nécessaire en complétant par des nil. Si la liste des expressions se termine par un appel de fonction alors toutes les valeurs retournées par cet appel sont insérées dans la liste des valeurs, avant que l'ajustement n'ait lieu (sauf si l'appel est entouré de parenthèses, voir &sect;2.5).

L'affectaction commence d'abord par évaluer toutes les expressions et seulement après les affectations sont effectuées. Ainsi le code

met la valeur 20 dans  car   dans   est évalué (à la valeur 3) avant l'assignement qui fixe la valeur de   à 4. De même la ligne

échange les valeurs contenues dans  et  , et

permute cycliquement les valeurs de,  , et.

Le sens d'une affectation à des variables globales ou des tableaux peut être changé via les méta-tables. Une affectation à la variable indexée  est équivalent à . (Voir &sect;2.8 pour une description complête de la fonction . Cette fonction n'est pas définie ni utilisable en Lua, elle est décrite ici uniquement à des fins d'illustration du propos.)

Une affectation à une variable globale  est équivalente à l'affectation , qui est à son tour équivalente à

où   est l'environnement de la fonction en cours d'exécution. (La variable  n'est pas définie en Lua. Elle est utilisée afin d'illustrer le propos)

Structures de contrôle
Les structures de contrôle

if, while, et repeat ont leur sens habituel (dans les langages de programmation impératifs) et une syntaxe similaire :

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

Lua possède également une instruction for en deux versions (voir &sect;2.4.5).

La condition d'une structure de contrôle peut retourner n'importe quelle valeur. Les valeurs false et nil sont considérées comme fausse, toutes les autres valeurs sont vraies (en particulier le nombre 0 et la chaîne vide sont vrais).

Dans la boucle repeat–until le bloc d'instructions ne se termine pas au mot-clé until mais après la condition. Ainsi la condition peut utiliser des variables locales déclarées dans le bloc de la boucle.

Le mot-clé (qui est une instruction) return est utilisé pour retourner une valeur depuis une fonction ou un chunk (qui est une fonction).

Les fonctions et les chunks peuvent retourner plus d'une valeur, ainsi la syntaxe de return est

stat ::= return [explist]

L'instruction break est utilisée pour terminer l'exécution d'une boucle while, repeat, ou for, sautant à l'instruction qui suit la boucle :

stat ::= break

Un break termine la boucle la plus « profonde » dans laquelle il se trouve.

Les instructions return et break peuvent uniquement se trouver en dernière instruction d'un bloc. S'il est réellement nécessaire d'utiliser return ou break au milieu d'un bloc alors un bloc explicite peut être utilisé, comme dans et , car ils sont bien ainsi la dernière instruction de leur bloc.

Instruction for
L'instruction for possède deux formes : l'une numérique et l'autre générique.

La forme numérique répète un bloc d'instruction pendant qu'une variable de contrôle effectue une progression arithmétique. Il a la syntaxe suivante :

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

Le bloc est répété pour name commençant à la valeur de la première exp et jusqu'à ce qu'il dépasse la seconde exp par étapes (ou pas) de la troisième exp. Plus précisément une instruction for de la forme

for v = e1, e2 , e3 do block end

est équivalente au 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

Notez que :



 Toutes les expressions de contrôle ne sont évaluées qu'une seule fois, avant que la boucle ne démarre. Elles doivent toutes générer un nombre. 

 ,, et   sont des variables invisibles. Leur nom est indiqué ici uniquement pour illustrer le propos. 

 Si la troisième expression (l'étape ou pas) est absente alors la valeur 1 est utilisée. 

 Vous pouvez utiliser break pour quitter une boucle for. 

 La variable de boucle  est locale à la boucle. Vous ne pouvez pas utiliser sa valeur après le for. Si vous avez besoin de cette valeur vous devez l'assigner à une autre variable (non locale) avant que la boucle ne se termine ou que vous la quittiez. 



La forme générique du for utilise des fonctions appelées itérateurs. À chaque itération l'itérateur est appelé pour produire une nouvelle valeur, et la boucle s'arrête quand cette nouvelle valeur vaut nil. La syntaxe du for génétique est la suivante :

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

Une instruction for de la forme

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

est équivalente au 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

Notez que :



 est évalué une seule fois. Son résultat est une fonction itérateur, un état , et une valeur initiale pour la première variable d'itération. </li>

 ,, et   sont des variables invisibles. Leur noms sont donnés uniquement pour illustrer le propos. </li>

 Vous pouvez utiliser break pour sortir d'une boucle for. </li>

 La variable de boucle  est locale à la fonction. Vous ne pouvez pas utiliser sa valeur après le for. Si vous avez besoin de cette valeur vous devez l'assigner à une autre variable (non locale) avant que la boucle ne se termine ou que vous la quittiez. </li>

</ul>

Appel de fonctions en tant qu'instruction
Pour permettre des effets de bord (side-effects) les appels de fonctions peuvent être exécutés comme des instructions :

stat ::= functioncall

Dans ce cas les valeurs éventuellement retournées sont toutes ignorées. Les appels de fonctions sont détaillées dans &sect;2.5.8.

Déclarations locales
Les variables locales peuvent être déclarées n'importe où à l'intérieur d'un bloc. La déclaration peut inclure un assignement inital :

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

Si présent l'assignement initial à la même sémantique qu'un assignement multiple (voir &sect;2.4.3). Sinon la variable est initialisée à la valeur nil.

Un chunk est aussi un bloc (voir &sect;2.4.1), ainsi dans variables locales peuvent être déclarées en dehors d'un bloc explicite. La portée d'une telle variable s'étend jusqu'à la fin du chunk.

Les règles de visibilité des variables locales sont détaillées dans&sect;2.6.

Expressions
Les expressions de base en Lua sont :

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;

Les nombres et chaînes littérales sont détaillées dans &sect;2.1, les variables dans &sect;2.3, les fonctions dans &sect;2.5.9, les appels de fonctions dans &sect;2.5.8, les constructeurs de tables dans &sect;2.5.7. Les arguments variables (varargs) notés par trois points (' ') ne peuvent être utilisés que directement à l'intérieur d'une fonction à arguments variables. Ils sont détaillés dans &sect;2.5.9.

Les opérateurs binaires comprennent les opérateurs arithmétiques (voir &sect;2.5.1), les opérateurs de relation (voir &sect;2.5.2), les opérateurs logiques (voir &sect;2.5.3), et l'opérateur de concaténation (voir &sect;2.5.4). Les opérateurs unaires comprennent le moins unaire (voir &sect;2.5.1), le not (négation) unaire (voir &sect;2.5.3), et l' opérateur de longueur unaire (length operator) (voir &sect;2.5.5).

Les appels de fonctions et les arguments variables peuvent retourner des valeurs multiples. Si une expression est utilisée comme instruction (seulement possible avec les appels de fonctions (see &sect;2.4.6)) alors ce qu'elle retourne est ajusté à une liste de zéro éléments, donc toutes les valeurs retournées sont ignorées. Si une expression est utilisée comme dernier (ou seul) élément d'une liste d'expression alors aucun ajustement n'est effectué (sauf si l'appel est entouré de parenthèses). Dans tous les autres contextes Lua ajuste la liste de résultats à un élément, ignorant toutes les valeurs sauf la première.

Quelques exemples :

Toute expression entourée de parenthèses retournera toujours seulement une valeur. Ainsi correspond toujours à une seule valeur, même si  en retourne plusieurs. (la valeur de  est la première retournée par  ou nil si   ne retourne aucune valeur.)

Opérateurs arithmétiques
Lua supporte les opérateurs arithmétiques habituels : le  (addition), (soustraction),  (multiplication), (division),  (modulo), et   (exponentiation), et le  unaire (négation). Les les opérandes sont des nombres ou des chaînes qui peuvent être converties en nombres (voir &sect;2.2.1), alors toutes les opération opèrent de façon classique.

L'exponentiation fonction pour tous les exposants. Par exemple  calcule l'inverse de la racine carrée de. Le modulo est définit comme

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

Opérateurs relationnels
Les opérateurs relationnels en Lua sont

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

Ces opérateurs retournent toujours false ou true (faux ou vrai).

L'égalité compare tout d'abord le type de ses opérandes. Si les types sont différents alors le résultat est false. Sinon les valeurs sont comparées. Les nombres et les chaînes sont comparées de façon classique. Les objets (tables, userdata, threads et fonctions) sont comparés par référence : deux objets sont considérés comme égaux seulement s'ils sont le même objet. Chaque fois que vous créez un nouvel objet celui-ci est différent de tous les objets précédemment créés.

Vous pouvez modifier la façon dont Lua compare les tables et les userdata en utilisant la méta-méthode « eq » (voir &sect;2.8).

Les règles de conversion de &sect;2.2.1 ne s'appliquent pas à l'opérateur d'égalité. Ainsi  est false, et  et   correspondent à des entrées différentes de la table.

L'opérateur  est l'exacte négation de l'opérateur d'égalité.

L'ordre des opérateur fonctionne comme suit. Si les deux arguments sont des nombres ils sont comparés en tant que tel. Sinon si les deux arguments sont des chaînes elles sont comparées en suivant la locale courante. Sinon Lua tente d'appelé les méta-méthodes « lt » ou « le » (pour less-than = « moins-que » et ''less-or-equal-- = « moins-ou-égal ») (voir &sect;2.8). Une comparaison  est convertie en  et   est convertie en.

Opérateurs logiques
Les opérateurs logiques en Lua sont and, or, et not. Comme pour les structures de contrôle (voir &sect;2.4.4) tous les opérateurs logiques considèrent false et nil comme faux et toutes les autres valeurs comme vraies.

L'opérateur de négation not retourne toujours false ou true. L'opérateur de conjonction and retourne son premier argument si celui-ci est faux (false ou nil) et sinon il retourne son deuxième argument. L'opérateur de disjonction or retourne son premier argument si celui-ci est vrai (différent de false ou nil) et sinon il retourne son deuxième argument. Ces deux opérateurs (and et or) utilisent des raccourcis d'évaluation : le second argument n'est évalué que si c'est nécessaire.

Quelques exemples :

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

(ici  indique le résultat de l'expression qui précède)

Concaténation
L'opérateur de concaténation de chaîne en Lua s'eprime avec deux points (' '). Si les deux opérandes sont des chaînes ou des nombres alrs ils sont convertis en chaîne en suivant les règles détaillées dans &sect;2.2.1. Sinon la méta-méthode « concat » est appelée (voir &sect;2.8).

Opérateur de longueur
L'opérateur de longueur s'exprime par l'opérateur unaire. La longueur d'une chaîne correspond à son nombre d'octets (la longueur d'une chaîne quand ses caractères sont codés sur un seul octet). Note : cette longueur ne correspond pas au nombre de caractères si la chaîne contient des caractères UTF-8.

La longueur d'une table  est définit comme étant tout index entier tel que  ne contienne pas nil et que   contienne nil. De plus si  vaut nil,   peut valoir zéro. Pour un tableau régulier, sans valeurs nil entre 1 et un  donné, sa longueur est exactement  , l'index de la dernière valeur. Si le tableau contient des « trous » (des valeurs nil entre des valeurs autres) alors  sera l'indice qui précède la valeur nil dans ce tableau (en pratique cela signifie que pour l'opérateur de longueur la valeur nil désigne la fin du tableau).

Précédence
La précédente entre les opérateurs en Lua suit l'ordre donné dans la table suivante, de la priorité la plus basse à la plus haute :

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

Vous pouvez utiliser les parenthèses pour modifier la précédence d'une expression. La concaténation (' ') et l'exponentiation (' ') sont associatifs à droite. Tous les autres opérateurs binaires sont associatifs à gauche.

Constructeur de tables
Les constructeurs de tables sont des expressions qui créent des tables. Chaque fois qu'un constructeur est évalué une nouvelle table est créée. Un constructeur peut être utilisé pour créer une table vide or une table avec certains champs initialisés. La syntaxe générale des constructeurs est

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

Chaque champs de la forme  ajoute à la nouvelle table une entrée avec pour clé  et pour valeur. Un champs de la forme  est équivalent à . Enfin, les champs de la forme  sont équivalents à , où  correspond à des nombres entiers consécutifs en commençant par 1. Les champs utilisant les autres formats n'affectent pas le comptage de. Par exemple,

est équivalent à

Si le dernier champs dans la liste a la forme et que cette expression est un appel de fonction ou des arguments variables alors toutes les valeurs retournées par cette expression sont insérées dans la liste consécutivement (voir &sect;2.5.8). Pour éviter cela mettez l'appel de fonction ou les paramètres variables entre parenthèse (voir &sect;2.5).

Le dernier élément d'une liste de champs peut avoir un séparateur final optionnel (sans effet), afin de simplifier − par exemple − les cas de code généré par programme.

Appel de fonctions
Un appel de fonction en Lua a la syntaxe suivante :

functioncall ::= prefixexp args

Dans un appel de fonction prefixexp et args sont évalués en premier. Si la valeur de prefixexp est de type function alors cette fonction est appelée avec ses paramètres. Sinon la méta-méthode « call » de prefixexp est appelée, avec prefixexp comme premier paramètre suivi des paramètres de l'appel d'origine (voir &sect;2.8).

La forme

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

peut être utilisé pour appeler une « méthode ». L'appel est une facilité syntaxique pour , hormis que  n'est évalué qu'une seule fois.

Les paramètres (ou arguments) ont la syntaxe suivante :

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

Tous les paramètres sont évalués avant l'appel. Un appel de la forme  est une facilité syntaxique pour, c'est-à-dire que la liste des paramètres est une seule nouvelle table. Un appel de la forme (ou  ou  ) est une facilité syntaxique pour, c'est-à-dire que la liste des paramètres est une seule chaîne littérale.

Il y a une exception à la liberté de syntaxe de Lua : vous ne pouvez pas mettre de retour à la ligne avec le ' ' pour un appel de fonction. Cette restriction permet d'éviter certaines ambiguïtés dans le langage. Si vous écrivez

Lua pourrait voir cela comme une seule instruction :. Donc si vous voulez deux instructions vous aurez à introduire un point-virgule entre elles. Si vous voulez réellement appeler, vous devez enlever le retour à la ligne avant.

Un appel de la forme  functioncall est appelé un appel de queue.

Lua implémente des appels de queue propres (ou récursions de queue propres ) : dans un appel de queue la fonction appelée réutilise la pile de la fonction appelante. Ainsi il n'y a pas de limite au nombre d'appels de ce genre qu'un programme peut exécuter. Toutefois un appel de queue écrase toutes les informations de debug à propos de la fonction appelante. Notez qu'un appel de queue ne se produit qu'avec une syntaxe particulière, où le return a un seul appel de fonction comme paramètre : ceci fait que la fonction considérée retourne exactement ce que retourne la fonction appelée. Ainsi aucun des exemples ci-dessous ne sont des appels de queue :

Définition de fonctions
La syntaxe d'une définition de fonction est

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

Les facilités syntaxiques existent pour simplifier la définition de fonctions :

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

L'instruction

function f body end

se traduit par

f = function body end

L'instruction

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

se traduit par

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

L'instruction

local function f body end

se traduit par

local f; f = function body end

et non par

local f = function body end

(Ceci ne fait de différence que lorsque le corps de la fonction contient des références vers .)

Une définition de fonction est une expression exécutable, qui a le type function. Quand Lua pré-compile un chunk tous les corps de fonctions qu'il contient sont pré-compilées également. Ainsi quand Lua exécute la définition de fonction la fonction est instanciée (or fermée ). Cette instance de fonction (ou fermeture ) est la valeur finale de l'expression. Différentes instances d'une même fonction peuvent faire référence à des variables locales externes différentes et avoir des enviromments différents.

Les paramètres sont traités comme des variables locales qui sont instanciées avec les valeurs des arguments à l'appel :

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

Quand une fonction est appelée sa liste d'arguments est ajustée à la longueur de la liste des paramètres, sauf si la fonction est variadic (avec un nombre non spécifié de paramètres) ou une fonction à paramètres variables ; qui est indiqué par trois points (' ') à la fin de sa liste de paramètres. Une fonction à paramètres variables n'ajuste pas la liste d'argument. Elle récupère tous les arguments additionnels et les passe à la fonction via une expression de paramètres variables, qui se note également par trois points. La valeur de cette expression est une liste contenant les paramètres additionnels, similaire au comportement d'une fonction retournant plusieurs résultats. Si une expression de paramètres variables est utilisé à l'intérieur d'une autre expression ou au milieu d'une liste d'expressions alors son contenu est ajusté à un élément. Si l'expression est utilisée en dernier élément d'une liste d'expression aucun ajustement n'est effectué (sauf si la dernière expression est entourée de parenthèses).

Comme exemple, considérez les définitions suivantes :

Alors nous avons la mise en correspondance suivante entre les arguments et les paramètres (ou expression de paramètres variables) :

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

Les résultats sont retounés en utilisant return (voir &sect;2.4.4). Il l'exécution atteint la fin d'une fonction sans rencontrer de return la fonction se termine sans retourner de résultat.

La syntaxe des deux-points est utilisée pour définir une méthode, c'est-à-dire des fonctions qui ont un paramètre implicite additionnel appelé. Ainsi la déclaration

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

est une facilité syntaxique pour

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

Règles de visibilité
Lua est un langage à portée lexicale. La portée des variables commence à la première instruction qui suit leur déclaration et se termine à la fin du dernier bloc qui inclue cette déclaration. Voez l'exemple suivant :

Notez que dans une déclaration telle que, le nouveau   déclaré est pas encore accessible, ainsi le second  (en partie droite) fait référence à la variable à l'extérieur du bloc (ici la variable globale).

De part les règles de visibilité lexicales une variable local peut être librement accédée par les fonctions définies à l'intérieur de leur portée. Une variable local utilisée dans une fonction définie à l'intérieur de sa portée est appelée une upvalue ou variable locale externe, au sein de cette fonction.

Notez que chaque exécution de l'instruction local une nouvelle variable locale est créée.

Par exemple :

La boucle crée dix fermetures (c'est-à-dire dix instances d'une fonction anonyme). Chacune de ces fermetures utilise une variable  différente, mais elles partagent toutes le même.

Gestion des erreurs
Comme Lua est un embedded extension language (langage à extension intégrées ?), toutes les actions en Lua débutent par du code C dans le programme hôte qui va appeler une fonction de la librairie Lua. Si une erreur se produit durant la compilation ou l'exécution le contrôle revient à la fonction C qui prend les mesures adéquates (comme d'afficher un message d'erreur).

Il est possible de générer explicitement une erreur en appelant la fonction . Si vous avez besoin d'intercepter les erreurs en Lua vous pouvez utiliser la fonction.

Metatables
Chaque valeur en Lua peut avoir une <metatable (méta-table). Cette méta-table est une table Lua ordinaire qui définit le comportement de la valeur d'origine pour certaines opérations particulières. Vous pouvez modifier de nombreux aspects du comportement des opérateurs sur une valeur en modifiant certains champs spécifiques dans sa méta-table. Par exemple quand une valeur non numérique est l'opérande d'une addition Lua regarde s'il existe une fonction dans le champs  de cette méta-table. Si c'est le cas Lua appelle cette fonction pour effectuer cette addition.

Nous appelons les clés d'une méta-tables des évènements et leurs valeurs des méta-méthodes. Dans l'exemple précédent l'évenement est  et la méta-métode est la fonction qui effectue l'addition.

Vous pouvez accéder à la méta-table de n'importe quelle valeur en utilisant la fonction.

Vous pouvez remplacer la méta-table de tables en utilisant la fonction.

Vous ne pouvez pas changer la méta-table des autres types en Lua (à part via la librairie de debug), vous devez passer par l'API C pour cela.

Les tables et les userdata possèdent des méta-tables individuelles (même si plusieurs tables et userdata peuvent partager leur méta-table). Les valeurs de tous les autres types partagent la même et unique méta-table par type : il existe donc une seul méta-table pour les nombre, une seule pour les chaînes…

Une méta-table contrôle la façon dont un objet se compote dans les opérations arithmétiques, les comparaisons, la concaténation, l'opération de longueur, et l'indexation. Une méta-table définit également une fonction à appeler lorsqu'un userdata doit être nettoyé de la mémoire (garbage collection). Pour chacune de ces opérations Lua associe une clé spécifique appelée évenement. Quand Lua effectue l'une de ces opérations sur une valeur il vérifie si cette valeur a une méta-table associée et possédant un évenement correspondant. Si c'est le cas la valeur associée avec cette clé (la méta-méthode) contrôle comment Lua effectue l'opération.

Les méta-tables contrôlent les opérations listées ci-dessous. Chaque opération est identifiée par son nom. La clé de chaque opération est une chaîne préfixée par deux tirets bas (underscore) ' '. Par exemple pour l'opération "addition" ("add") la clé associée est la chaîne. La sémantique de ces opérations est plus simple à expliquer par une fonction Lua décrivant comment l'interpréteur exécute l'opération.

Le code ci-dessous est strictement illustratif : l'interpréteur utilise du code interne pour réaliser cela ce qui est nettement plus efficace. Toutes les fonctions utilisées dans ces descriptions (, , …) sont décrites dans &sect;3.1. En particulier pour retrouver la méta-méthode d'un objet donné nous utilisons l'expression

Ceci doit se lire comme

C'est-à-dire que l'accès à une méta-méthode l'invoque pas d'autres méta-méthodes, et l'accès à des objets sans méta-tables ne provoque pas d'erreur (cela retourne simplement nil).



"add": L'opération.

La fonction  définit comment Lua choisi un gestionnaire (handler) pour une opération binaire. En premier lieu Lua teste le premier opérande. Si son type ne définit pas de gestionnaire pour l'opération alors Lua teste son second opérand.

En utilisant cette fonction le comportement de  est

</li>

"sub": l'opération  (soustraction).

Comportement similaire à l'addition. </li>

"mul": l'opération  (multiplication).

Comportement similaire à l'addition. </li>

"div": l'opération  (division).

Comportement similaire à l'addition. </li>

"mod": l'opération  (modulo).

Comportement similaire à l'addition, avec l'opération comme comportement d'origine. </li>

"pow": l'opération  (exponentiation).

Comportement similaire à l'addition, avec l'opération (de la librairie mathématique du C) comme comportement d'origine. </li>

"unm": L'opération  unaire (négation).

</li>

"concat": l'opération  (concaténation).

</li>

"len": l'opération  (longueur).

Voir &sect;2.5.5 pour plus de détails sur la longueur d'une table. </li>

"eq": L'opérateur  (égalité).

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.

Librairies standards
La librairie standard Lua fournie divers fonctions utiles qui sont directement implémentées via l'API C. Certaines de ces fonctions fournissent essentiellement des services au niveau du langage (exemples,  et  ). D'autres fournissent des services « externes » (par exemple les entrées/sorties). D'autres enfin pourraient être implémentées en Lua mais sont particulièrement utiles ou ont des contraintes de performance nécessitant une implémentation en C (exemples, ).

Toutes les librairies sont implémentées en utilisant l'API C officielle et sont fournies dans des modules séparés. À l'heure actuelle Lua comprend les librairies standards suivantes :

<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;