Lua

Lua est un langage de script libre, réflexif et impératif. Il intègre un ramasse-miettes, et il est conçu de manière à pouvoir être embarqué dans d'autres applications pour les étendre.

Lua (du portugais : Lua [ˈlu.ɐ], au Brésil : [ˈlu.a], signifiant « Lune »), a été développé en 1993 par Luiz Henrique de Figueiredo, Roberto Ierusalimschy (en) et Waldemar Celes, membres du groupe de recherche TeCGraf, de l'université pontificale catholique de Rio de Janeiro au Brésil.

L'interpréteur Lua est écrit en langage C ANSI strict, ce qui le rend compilable sur beaucoup de systèmes. Il est aussi très compact, la version 5.0.2 n'occupant que 95 ko à 185 ko selon le compilateur utilisé et le système cible. L’existence d’interfaces entre C et de nombreux langages facilite l’intégration de Lua dans la plupart des projets.

Sa compacité et son extensibilité le font particulièrement apprécier pour l'embarqué, le développement réseau et les jeux vidéo.

Généralités

Commentaires

En Lua, les commentaires débutent par -- et finissent à la fin de la ligne, comme en Ada. Si la première ligne commence par #! (shebang) elle est aussi traitée comme un commentaire. Les commentaires multilignes sont également disponibles avec la syntaxe

Variables

Une variable peut contenir un booléen, une chaîne de caractères, un nombre (pas de différence entre entier et flottant), une table ou une fonction. Il existe des types plus avancés comme userdata ou thread. Le type userdata correspond à un objet C/C++ défini par l'utilisateur : il est donc possible de créer une structure C ou une classe C++, et d'utiliser des objets de ce type dans un script Lua après avoir attaché à cet objet une métatable pour appeler les fonctions C/C++ appropriées. On pourrait ainsi, par exemple, créer les classes métier de base d'un programme en C++, et coder l'application elle-même en Lua pour développer plus vite grâce aux outils de haut niveau fournis par le langage.

Une variable non définie a la valeur nil. Affecter nil à une variable revient à la supprimer.

En interne on peut aussi rencontrer des proto, une sorte de prototype de fonction: le bytecode de cette fonction est chargé mais ce dernier n'a pas encore été exécuté. On rencontre les proto quand un fichier est chargé (compilé) mais pas exécuté ou bien avec des closures.

Par défaut, une variable déclarée est globale à tout l'environnement d'exécution, sauf si elle est précédée du mot-clef local.

Les chaînes

Les chaînes de caractères sont délimitées par des guillemets simples (') ou doubles ("), voire par des délimiteurs littéraux [[ «de niveau n» où n est un certain nombre de signes =. Une chaîne délimitée ainsi ne s’arrête qu’au délimiteur fermant de même niveau.

L'opérateur de concaténation de chaînes se représente par deux points (..).

Les fonctions

Les fonctions sont considérées comme des variables. On peut donc en créer dans d'autres fonctions, en passer comme paramètre ou comme valeur de retour d'une autre fonction, ou en mettre comme clé ou comme valeur dans une table.

En Lua, une fonction peut recevoir un nombre quelconque de paramètres, et renvoyer un nombre quelconque de valeurs.

Déclarer une fonction

ou

Le return doit être la dernière instruction avant end. Si nécessaire, on le met dans un bloc inconditionnel.

Appeler une fonction

Les paramètres non-précisés à l’appel sont considérés comme nil.

Les valeurs renvoyées en trop sont ignorées.

Les tables, métatables

En Lua, la structure stocke des valeurs indexées par une clé (comme en PHP par exemple). C’est la structure centrale du langage pour représenter tous les objets complexes.

Index et valeurs

Une table peut, entre autres, être utilisée comme :

Une liste (par exemple la syntaxe {a,b,c,…} crée une liste débutant à l’index 1). L’opérateur # donne alors la longueur de la liste.

Une hashtable (pouvant faire office de structure), qui peut prendre en clé et en valeur tout type de variable (sauf nil).

Les index et les valeurs peuvent être de tout type (l’opérateur # fonctionne toujours mais n’a vraiment de sens que pour les listes)

Par convention, on parcourt une liste avec l'itérateur ipairs et une hashtable avec l'itérateur pairs.

La clé nil est interdite. Affecter nil à un index est permis mais revient à le supprimer. Ainsi a={nil,"x",nil,"y"} équivaut à a={[2]="x",[4]="y"}. L’opérateur de longueur # n’a alors plus de sens, l’itérateur pairs saute les nil, et l’itérateur ipairs s’arrête au premier nil.

Métatables et objets

Les tables facilitent la programmation dans un style objet, notamment grâce à deux sucres syntaxiques :

objet.clef équivaut à objet["clef"]

objet:f() passe à objet.f() un argument caché self=objet

Quant aux métatables, introduites dans Lua 2.1, ce sont des tables que l’on associe à un objet, pour introduire une sorte d’héritage. En effet, si un objet x est associé à la métatable m, et si x[c] n’existe pas, Lua cherche m[c] à la place.

Les métatables permettent également une sorte de surcharge des opérateurs, car Lua y cherche les fonctions __add(), __sub(), __call(), __index() … pour exécuter les opérations +, -, (), []….

L’objet Vector ci-dessous illustre ces notions avec un constructeur, une méthode, et deux opérateurs redéfinis:

Déclaration de table

Pour créer une table à indices numériques consécutifs (démarrant à 1):

On peut donner explicitement les indices de la table à créer, entre crochets. Les indices chaînes semblables à un nom de variable peuvent se passer de guillemets et de crochets :

Dans une assignation, la valeur est copiée si c’est un nombre, une chaîne ou un booléen. Sinon seule la référence est copiée. En particulier, si la variable a est une table et si on assigne a à la variable b, alors toute modification dans la table a est visible dans b, et vice-versa :

L’exemple qui suit est une table stockant des variables complexes : autres tables, fonctions, références croisées…

De même que ci-dessus, si un indice n’est ni un nombre, ni une chaîne de caractères, ni un booléen, c’est une référence vers la variable concernée :

Boucles, blocs et conditions

Condition

La structure if ... then ... elseif ... else ... end est semblable à celle de la plupart des langages

Les opérateurs logiques sont and, or et not.

Les booléens sont true et false, mais les expressions conditionnelles concernent tous les types:

une condition est fausse si elle vaut nil ou false, et vraie sinon.

Les opérateurs logiques and et or appliquent une logique de "court-circuit", en renvoyant le premier de leurs opérandes qui suffit à savoir si la formule est vraie ou fausse.

Boucles

Les structures while et repeat rebouclent tant qu’une condition est vraie. La boucle repeat exécute au moins une fois son corps car elle teste sa condition à la fin.

Une boucle for affecte successivement des valeurs données par un départ, une arrivée et un incrément, ou par un énumérateur.

Le dernier exemple montre une instruction break pour quitter la boucle. Elle doit toujours figurer avant un end, ce qui demande parfois de créer un bloc inconditionnel.

Blocs inconditionnels

Les blocs inconditionnels servent par exemple à limiter la visibilité des variables locales :

Les fonctions standard

Les fonctions mathématiques

La valeur math.pi est le nombre pi.La fonction math.min(liste) retourne le plus petit nombre contenu dans une listeLa fonction math.max(liste) retourne le plus grand nombre contenu dans une listeLa fonction math.floor(x) retourne la partie entière de x.La fonction math.abs(x) retourne la valeur absolue de x.La fonction math.pow(x, y) retourne x à la puissance de y. On peut aussi utiliser l'expression x^yLa fonction math.random(x, y) retourne un nombre aléatoire entre la valeur x et la valeur y.La fonction math.sqrt(x) retourne la racine carrée de x.

Les fonctions os

La fonction os.time() retourne le nombre de secondes écoulées depuis le 1er janvier 1970 à 00:00.La fonction os.date() retourne la date actuelleLa fonction os.clock() retourne le temps processeur consommé par le programme.

La fonction type

La fonction type(x) donne le type de x sous forme de chaîne. Pour le type «number», la fonction math.type peut dire s’il s’agit d’un entier ou d’un flottant.

Les fonctions table

En Lua, il existe 9 fonctions table.

La fonction table.insert(x, y, z) insère une valeur y dans un tableau x. On peut lui indiquer la position d’insertion avec un argument z. Si z n'est pas donné, la valeur est mise en dernière position de la table.La fonction table.remove(x, y) retire du tableau x la valeur qui se trouve en position y.La fonction table.sort(x) permet de trier et modifier la position des éléments du tableau x.La fonction table.concat(x, y) concatène les valeurs d'un tableau pour former une chaine de caractères. Le y, facultatif, sert à séparer les valeurs.Voici un exemple d’utilisation du séparateur y:.Les fonction table.foreach(x, z) et table.foreachi(x, y) sont obsolètes depuis la version 5.1 de lua et doivent être remplacées par pairs() et ipairs(). Voir ci-dessous.

La fonction table.getn(x) donne la taille d'un tableau x.

Les fonctions strings

Les fonctions «string.», au nombre de 15, opèrent sur les variables de type string.

Le string.find(x, y) recherche des caractères y dans le string x. Il renvoie nil si rien n’est trouvé. Sinon il indique à partir de quel emplacement les caractères recherchés ont été trouvés.On peut aussi ajouter un argument z pour commencer la recherche à une certaine position.Le string.byte(x, y, z) renvoie le code numérique des caractères (Code ASCII) de la string x.On peut aussi utiliser l'argument y pour définir un début de conversion ainsi que l'argument z pour définir la fin de conversion (numéro de caractère).Le string.char(x) convertit le code numérique x qui est en code ASCII en caractères normaux.Le string.dump(x) convertit la fonction x en une représentation binaire utilisable par la fonction loadString(y).Le string.format() renvoie une chaine de caractères formatée.Le string.gmatch(x, y) renvoie une sous-chaîne de la chaîne principale x.Le string.gsub(x, y, z) remplace les mots y d'une string x par un autre mot z.Le string.upper(x) renvoie le texte d'une string x en changeant les minuscules en MAJUSCULES (sauf caractères spéciaux).Le string.lower(x) renvoie le texte d'une string x en changeant les MAJUSCULES en minuscules.Le string.reverse(x) retourne le texte d'une string x en inversant la chaîne de caractères.Le string.sub(x, y, z) renvoie la sous-chaîne de x formée des caractères allant des indices y à z inclus (ou à la fin si z est absent). Si y ou z est négatif, la position est comptée à partir de la fin de la chaîne x.Le string.rep(x, y) concatène y fois le contenu de la string x.Le string.match(x, y, z) renvoie une sous-chaîne de caractères de la string x conforme au motif indiqué en y, et en cherchant à partir du caractère z (qui est facultatif).

La fonction pairs()

La fonction pairs(x) énumère les index et les valeurs d'un tableau x. Elle replace table.foreach(), obsolète depuis Lua 5.1. A chaque itération, pairs(x) renvoie un index et la valeur associée à cet index dans le tableau. On prend souvent les noms de variables i et v: ainsi dans « for i, v in pairs(x) do …», i est un index dans x, et v est la valeur x[i].On peut aussi utiliser pairs() pour rechercher et retirer une valeur d'un tableau:

La fonction pcall()

La fonction pcall() sert à capturer les erreurs qui surviennent dans une fonction. Dans ce cas, pcall() empêche l’arrêt du script et fournit les informations sur l’erreur.La fonction pcall() renvoie deux valeurs qui renseignent sur une erreur éventuelle :

Extensions de Lua avec l’API C

Comme expliqué dans PIL, la communication entre Lua et un programme C utilise une pile pour surmonter deux difficultés :

l’allocation de mémoire : elle est manuelle en C, alors que Lua a son ramasse-miettes. Les objets sont épargnés par le ramasse-miettes tant qu’ils sont sur la pile.

les types de données : statiques en C, dynamiques en Lua. L’API C offre notamment des fonctions de conversion entre les valeurs sur la pile et les types du C.

L’API C gère aussi la persistance des données par deux mécanismes:

un registre (qui permet à toutes les fonctions C de partager des informations)

les "upvalues" (valeurs de contexte que l’on peut associer à une fonction C). Cela permet entre autres à un programme C de prendre une seule fonction C pour en tirer plusieurs fonctions LUA -- des closures -- qui ne diffèrent que par leur contexte. L’exemple classique est celui des fonctions de comptage dont les compteurs doivent être indépendants.

Exemples

Hello World

Help

Fonction donnant le type d’un objet, et les indices, types et valeurs de ses éléments si c’est un objet table.

Peut servir comme aide-mémoire des fonctions de bibliothèque io, table, string, etc.

Usages

Consoles

Lua a été embarqué dans la PlayStation Portable de Sony, grâce au programme Lua Player, et plus récemment Lua Player HM et Lua Player Euphoria qui permettent de lire des applications écrites avec Lua afin d'étendre les capacités de la console. Viendra plus tard l'XtreamLua Player, destiné à la création de jeux vidéo. Une modification (non officielle) du micrologiciel de la PSP permettait de lancer des programmes non-signés par Sony d'où la création d'un interpréteur Lua adapté pour la PSP.

Lua Player Euphoria reprend la syntaxe du Lua Player original et exécute le script à une vitesse fulgurante comparé au Lua Player HM. Cependant, Lua Player Euphoria est moins complet que son homologue plus ancien.

Lua Player One, un des derniers Lua Player mis à jour pour PSP, est un Lua Player développé au sein d'une communauté de développeurs espagnols ; il permet, entre autres, de gérer la 3D sur PSP. Un jeu de mini-golf dans l'espace a été développé à l'aide de cet outil.

Lua Player Plus (LPP) est sorti sur PlayStation Vita le 16 août 2015. Ce Lua Player permet de créer des jeux pour la console.

Lua est inclus dans la console de poche open-source Pocket Chip (projet Kickstarter). En effet cette dernière embarque le programme de console virtuelle Pico-8 qui permet de jouer et de créer des jeux en Lua.

Extensions de jeux vidéo

Parmi les jeux vidéo de bac à sable qui l'utilisent figurent Garry's Mod, Roblox (et son logiciel de création Roblox Studio), Core, Stormworks (en) et Minecraft. Pour ce dernier, ComputerCraft, un mod du jeu Minecraft, utilise Lua pour concevoir des programmes graphiques ou consoles et des « robots » autonomes à l'intérieur du jeu, permettant d'automatiser de nombreuses tâches répétitives ; Luanti, un jeu sandbox sous licence LGPL similaire à ce dernier, utilise Lua comme langage pour l'écriture d'extensions et à l'intérieur même du jeu (via certains modes) via la programmation de microcontrôleur ou de FPGA. Le jeu scientifique Foldit l'utilise pour la rédaction de "recettes" par les joueurs (plus de 100 000 ont déjà été écrites en 15 ans), leur permettant d'automatiser une série d'actions répétitives et de stratégies, dont certaines ont fait par la suite l'objet de publications scientifiques.

Il existe également un moteur de jeu utilisant Lua comme langage de programmation (une sorte de Pygame pour Lua) : LÖVE.

Beaucoup d'autres jeux vidéo l'utilisent, comme World of Warcraft de Blizzard Entertainment, Far Cry (et le moteur CryEngine en général) de Crytek Studios, le logiciel multijoueurs de GTA:SA Multi Theft Auto, SimCity 4 et Natural Selection 2 de Unknown Worlds Entertainment (qui a entre autres développé Decoda, un IDE pour Lua). Enfin, certains scripts de Zoo Tycoon 2 (Blue Fang Games) sont également présents sous des formes non compilées dans les fichiers du jeu. The Binding of Isaac: Afterbirth+ est un DLC pour le jeu The Binding of Isaac: Rebirth qui permet le support de mods écrits en Lua.

Lua sert aussi dans des jeux comme : Transformice, Roblox, Onset, Multi Theft Auto (mod multijoueur de Grand Theft Auto: San Andreas), FiveM (el) (mod multijoueur de Grand Theft Auto V), Factorio, Project Zomboid, nanos world,Balatro ainsi que les moteurs de jeu vidéo tels que le SourceEngine, LÖVE, Solarus ou encore les Fantasy consoles, tel que Pico-8.

Réseau et Embarqué

Au niveau réseau, Lua sert comme hook sur Apache, lighttpd (par défaut), nginx (via OpenResty), dans les routeurs Cisco, dans l'analyseur de paquets Wireshark,

La compacité de Lua est très appréciée dans des systèmes embarqués tels qu'OpenWrt.

Le PABX Asterisk (autocommutateur téléphonique privé) propose Lua comme alternative pour étendre son plan de numérotation.

L'antispam Rspamd utilise également Lua pour son interface de programmation.

Autres logiciels

Lua est également utilisé pour l'extension des capacités du lecteur multimédia VLC, dans les gestionnaires de fenêtres EFL Edje d'Enlightenment, dans NeoVim pour sa configuration, ainsi que Awesome (comme langage de configuration et de script).

MediaWiki et les sites Wikimedia utilisent Lua comme langage de script pour les modèles (appelés modules).

Le logiciel CraftStudio utilise Lua pour programmer les éléments dynamiques des modèles.

Le logiciel libre d'interface neuronale directe OpenVibe (en) utilise Lua comme langage de script, en particulier pour la gestion de stimuli pour les expériences de neuroscience.

Le robot IRC irccd utilise Lua pour la création de plugins.

Lua est le langage de scripting principalement utilisé pour le système d'exploitation embarqué OpenWrt fonctionnant sur de nombreux routeurs. L'interface graphique d'administration LuCI est entièrement écrite en Lua.

Lua est le langage natif de Domoticz, logiciel de domotique open source. Il permet le scripting avec des fonctionnalités avancées : Domoticz déclenche automatiquement ces scripts sur les changements d’états, en fonction du temps, etc.

Lua est également le langage natif de NSBase, logiciel de gestion de bases données. Le scripting permet de dynamiser les formulaires, rapports. Lua ainsi intégré permet de créer de véritables applications de gestion de bases de données.

Le logiciel de simulation de vol spatial Orbiter et ses add-ons (UCGO, UMmu) utilisent Lua pour permettre la création aisée d'écrans de contrôle (MFD - Multi Function Display), de missions ou de vaisseaux. La création de vaisseaux, en particulier, à la différence de modules DLL, ne nécessite pas la compilation d'un fichier C++.

BeamNG.drive utilise Lua pour compléter ses équations physiques.

Prosody : serveur XMPP léger écrit entièrement en lua.

L'environnement de bureau Awesome (linux) utilise aussi Lua dans ses fichiers de configuration depuis sa version 3.

FreeBSD intègre un interpréteur lua dans son chargeur depuis la version 11.3.

La solution qui associe le montage, l’étalonnage, les effets visuels, les animations graphiques et la post-production audio Davinci Resolve utilise Lua, Py2 et Py3.

Le logiciel de notation musicale professionnel Finale propose un plugin Lua.

Luatex est un des trois moteurs actuels des logiciels de composition TeX et LaTeX. Il a pour but de remplacer pdfTeX. Il permet également d'exécuter des codes écrits en Lua directement dans les documents TeX ou LaTeX, via la macro \directlua{}. Lua a été choisi pour sa légèreté, sa capacité d'intégration et sa facilité de compréhension.

Notes et références

Annexes

Bibliographie

(en) « Lua 5.2 Reference Manual », sur lua.org, Lua.org et université pontificale catholique de Rio de Janeiro (consulté le 14 mai 2014)

(en) Roberto Ierusalimschy, Programming in Lua, Rio de Janeiro, Lua.org et université pontificale catholique de Rio de Janeiro, janvier 2013, 3e éd. (1re éd. 2003), 347 p. (ISBN 978-85-903798-5-0 et 85-903798-5-X)

(en) Roberto Ierusalimschy, Waldemar Celes et Luiz Henrique de Figueiredo, Lua Programming Gems, Rio de Janeiro, Brésil, Lua.org et université pontificale catholique de Rio de Janeiro, 2008, 346 p. (ISBN 978-85-903798-4-3)

Cyril Doillon (dir.), Sylvain Fabre, Philippe Lhoste et Patrick Rapin, Le guide de Lua et ses applications : manuel d'apprentissage, Paris, D-BookeR édition, 2012, 188 p. (ISBN 978-2-8227-0005-4, lire en ligne)

Cyril Doillon (dir.), Sylvain Fabre, Philippe Lhoste et Patrick Rapin, Le guide de Lua et ses applications : manuel de référence, Paris, D-BookeR édition, 2012, 336 p. (ISBN 978-2-8227-0015-3, lire en ligne)

Articles connexes

Plua

LuaTeX

GLua

Liens externes

Sites officiels : (en) www.lua.org et (pt) www.lua.org/portugues.html

(en) Lua Development Tools

(en) Lua embarqué

(fr) Introduction à la programmation avec Lua

Portail de la programmation informatique Portail du jeu vidéo