Le guide de Lua et ses applications

Manuel d'apprentissage

Écrit sous la direction de Sylvain Fabre

par

Pierre Chapuis

Etiene Dalcol

Cyril Doillon

Sylvain Fabre

Philippe Lhoste

Hisham Muhammad

Patrick Rapin

Aperçu général de l'ouvrage

Le Guide de Lua et ses applications est constitué de deux volumes indépendants : Le Manuel d'apprentissage et le Manuel de référence. Si vous découvrez Lua, commencez par le premier. Si vous lisez ce livre dans sa version HTML et que vous avez acheté l'intégrale, vous pouvez naviguer de l'un à l'autre via les hyperliens.

Si vous n'avez acquis qu'une partie du livre, ce schéma vous aidera à vous situer dans l'ouvrage général.

Le guide de Lua et ses applications - Manuel d'apprentissage

par Pierre Chapuis, Etiene Dalcol, Cyril Doillon, Sylvain Fabre, Philippe Lhoste, Hisham Muhammad, Patrick Rapin

écrit sous la direction de Sylvain Fabre

ISBN (EPUB) : 978-2-8227-0430-4

Copyright © 2016 Éditions D-BookeR

Tous droits réservés

Conformément au Code de la propriété intellectuelle, seules les copies ou reproductions strictement réservées à l'usage privé du copiste et non destinées à une utilisation collective ainsi que les analyses et les courtes citations dans un but d'exemple et d'illustration sont autorisées. Tout autre représentation ou reproduction, qu'elle soit intégrale ou partielle, requiert expressément le consentement de l'éditeur (art L 122-4, L 122-5 2 et 3a).

Publié par les Éditions D-BookeR, 5 rue Delouvain, 75019 Paris

www.d-booker.fr

contact@d-booker.fr

Ce module fait partie de l'ouvrage global intitulé : Le guide de Lua et ses applications

ISBN (HTML) : 978-2-8227-0436-6

Les exemples (téléchargeables ou non), sauf indication contraire, sont propriété des auteurs.

Conception de la couverture : Marie Van Der Marlière (www.marie-graphiste.com)

Mise en page : générée sous Calenco avec des XSLT développées par la société Neo⁠Doc (www.neodoc.biz)

Date de publication : 22/04/2016

Édition : 2

Version : 2.00

À propos des auteurs

Pierre Chapuis

Pierre Chapuis est ingénieur en télécommunications de formation. Il a travaillé pour Moodstocks, société spécialisée dans la reconnaissance d'images sur terminaux mobiles, où il a introduit Lua et LuaJIT. Il est aujourd'hui développeur au sein de la startup Lima. Il est l'auteur du site Lua Toolbox.

Etiene Dalcol

Etiene Dalcol est la créatrice du framework web MVC Sailor, facilitant le développement d'applications en Lua. Elle contribue au projet Lua Ladies, pour encourager les vocations de développeuses au sein de la communauté Lua.

Cyril Doillon

Cyril Doillon est un ingénieur en informatique spécialisé en "interactions, images et réalité virtuelle". Il a participé au développement de différents jeux vidéo (Fairytales Fights sur Xbox 360, Funky Lab Rat sur Playstation 3, Kinect Héros : Une aventure Disney-Pixar sur Xbox 360).

Sylvain Fabre

Sylvain Fabre est le cofondateur de la société InPixal spécialisée dans les produits de vision artificielle. Il utilise Lua (LuaJIT) tous les jours dans le cadre du développement de systèmes de vision artificielle au sein de sa société, notamment en tant que moteur d'exécution des algorithmes internes de traitement d'images.

Philippe Lhoste

Philippe Lhoste est ingénieur logiciel. Il a développé des applications temps réel en C et assembleur, des interfaces graphiques pour Windows, des applications web en C et dernièrement en Swing/Java. Il a contribué à l'éditeur de texte SciTE en C++ (son éditeur favori, qui intègre Lua) et utilise Lua pour des projets personnels.

Hisham Muhammad

Hisham Muhammad est le développeur principal du gestionnaire de paquets LuaRocks facilitant l'installation de modules Lua. Il fait son doctorat à Université pontificale catholique de Rio de Janeiro (PUC-Rio) et a créé plusieurs projets de logiciels libres, notamment GoboLinux et htop.

Patrick Rapin

Patrick Rapin a travaillé 14 ans comme programmeur chez Olivetti Engineering, y développant toutes sortes d'outils logiciels, notamment en Lua, permettant de contrôler les fonctions des imprimantes Olivetti. Il est l'auteur des librairies LuaGenericCall et LuaClassBasedCall, permettant respectivement d'appeler du code Lua depuis C et C++. Il travaille maintenant pour Xample SàRL, qui développe des applications mobiles principalement pour l'aéronautique.

Préface

par Roberto Ierusalimschy

Coinventeur du langage Lua

C'est un plaisir d'accueillir cette nouvelle édition du Guide de lua et ses applications

.

L'événement majeur de ces trois années, depuis la première édition, a été la sortie de la version 5.3 de Lua. Globalement compatible avec Lua 5.2, Lua 5.3 n'en apporte pas moins quelques nouveautés importantes, parmi lesquelles l'introduction dans le langage des nombres entiers. Il introduit également des opérateurs bit à bit et fournit une meilleure prise en charge des données binaires et un support de base de l'UTF-8.

Cette version avait deux principaux objectifs. Le premier était de permettre à Lua de s'adapter aux machines 64 bits, en supportant nativement les entiers 64 bits et leurs valeurs associées (handles par exemple). Cela peut sembler paradoxal, mais le second objectif était d'optimiser Lua pour adresser également des machines embarquées plus petites.

L'emploi du type double pour tous les nombres est en effet problématique pour les processeurs sans unité de calcul flottant et/ou avec des accès mémoires restreints. L'utilisation de flottants pour tous les nombres représente en général un obstacle bloquant, car la représentation de toutes les valeurs sur 32 bits n'est pas garantie. En raison de ces limitations, Lua était souvent utilisé avec le type entier 32 bits pour tous ses nombres. Cette solution n'était naturellement pas satisfaisante, étant donné que le langage s'en trouvait modifié radicalement. Avec les entiers intégrés nativement dans le langage, Lua offre désormais l'option que nous appellons Small Lua, c'est-à-dire un Lua compilé avec des flottants 32 bits et des entiers 32 bits. Small Lua se différencie donc de Lua uniquement dans la précision et l'échelle de ses nombres.

Après plus de 20 ans, voilà où nous en sommes, toujours fidèles aux objectifs initiaux de Lua : simple à utiliser par des non-informaticiens, portable, flexible, svelte et facilement embarquable. Et avec une nouvelle édition du Guide de Lua et ses applications, pour vous aider à tirer le meilleur parti de Lua.

Rio de Janeiro, 12 janvier 2016

Préface de la première édition

par Roberto Ierusalimschy

En 2013, Lua fêtera ses vingt ans. Au cours de toutes ces années, il est passé du projet maison à un langage de renommée mondiale.

Nous nous sommes lancés dans le développement de Lua avec des objectifs très précis. Nous avions besoin d’un langage léger pour assurer la configuration de certaines applications. Les principaux utilisateurs du langage étaient ceux de ces applications : géologues, ingénieurs en mécanique et autres techniciens sans véritables connaissances en programmation. Il devait donc être facile à utiliser. Les applications concernées étaient hautement portables ; l'une d'elles était installée sur des micro-ordinateurs aux ressources limitées (c'était en 1993) à bord de plates-formes maritimes. Le langage devait donc également être portable et peu gourmand en ressources. Enfin, les applications existaient déjà et étaient en service ; l’ajout d’une possibilité de configuration ne devait pas entraîner de grosses modifications. Le langage devait donc être facile à intégrer et à adapter à d'autres programmes.

Notre première tentative s’est orientée vers un langage de description de données, dans l'esprit de XML. Nous l'avons appelé SOL (soleil en portugais), pour "Simple Object Language" ou "Langage objet simple". Très rapidement, nous avons réalisé qu'un langage de ce type était trop restrictif pour nos utilisateurs. Ils avaient besoin d'expressions arithmétiques, d’instructions conditionnelles et parfois même de mécanismes d'abstraction (pour éviter une trop grande redondance dans les fichiers de configuration). Bref, il leur fallait un véritable langage de programmation. Alors que nous abandonnions SOL, quelqu'un a proposé le nom Lua, qui signifie "lune" en portugais et a l’avantage de commencer par la lettre "L", comme "Langage" !

Après 20 ans, voilà où nous en sommes, toujours fidèles à nos objectifs initiaux et devant un langage Lua de plus en plus répandu.

C'est toujours un réel plaisir d'accueillir un nouvel ouvrage sur Lua, d'autant que ce n'est pas si fréquent. En raison de sa conception, Lua est un langage très simple, à tel point que des enfants apprennent aujourd'hui à l’utiliser. Vous pouvez commencer à programmer en Lua très rapidement, avec très peu de documentation. C'est pourquoi le nombre d'ouvrages sur Lua est réduit. Toutefois, ne vous laissez pas tromper par sa simplicité. Certes Lua est simple, mais c'est également un langage très puissant pour peu qu’on le maîtrise. Pendant ces vingt années, le langage a évolué au sein d’une certaine culture : l’exploration des multiples combinaisons de mécanismes simples mais puissants. Pour apprendre le langage et en comprendre la culture, un bon ouvrage se révèle indispensable.

Voici donc le premier livre exhaustif en français sur Lua. Son organisation modulaire est audacieuse et s'articule autour de trois parties autonomes : un manuel d'apprentissage, un manuel de référence et des études de cas. (Il est en quelque sorte comparable à l'architecture de Lua, avec le noyau, les bibliothèques standards et les bibliothèques tierces.) Tous les utilisateurs de Lua, quel que soit leur niveau, y trouveront leur compte. Les auteurs sont depuis longtemps membres de la communauté Lua. J'en connais certains personnellement, quant aux autres, j'ai l'impression de les connaître après tant d'années d’échanges. Je suis sûr que cet ouvrage sera une étape importante dans la diffusion de Lua au sein du monde francophone.

Bonne lecture !

Rio de Janeiro, 24 septembre 2012.

Préliminaires

Compact, élégant, rapide, puissant, facile à mettre en œuvre, supporté par de nombreux outils et librairies : on en vient à manquer de qualificatifs lorsque l'on a pratiqué Lua. Découvrez avec cette partie les multiples facettes du langage.

Introduction

Lua. Lors de discussions avec d'autres collègues du monde informatique, ce simple mot n'évoque en général strictement rien ou au mieux de vagues mentions d'un langage de développement. Cette méconnaissance par la communauté informatique est d'autant plus curieuse que Lua possède d'indéniables atouts, comme cet ouvrage se propose de vous le démontrer.

1. Un ouvrage, deux manuels, des modules

Compact, élégant, rapide, puissant, facile à mettre en œuvre, supporté par de nombreux outils et librairies, Lua est un langage multifacette et multiusage. Chaque développeur se l'approprie à sa manière et le complète des librairies externes dont il a besoin. Si bien qu'entre deux utilisateurs de Lua, les exigences seront extrêmement différentes.

Cet ouvrage, par sa structure modulaire, tente de répondre à cette diversité : constitué de deux livres autonomes et complémentaires, le manuel d'apprentissage (que vous avez sous les yeux) et le manuel de référence, il vise à la fois à vous former aux différents usages du langage et vous accompagner dans son emploi quotidien en vous apportant des réponses précises aux problématiques les plus courantes.

Une première partie préliminaire, incluse dans le manuel d'apprentissage, vous présente l'histoire du langage depuis sa création en 1993 et ses principes généraux. Vous y trouverez également de nombreux exemples d'utilisation de Lua, notamment dans le développement de jeux vidéo.

Le manuel d'apprentissage à proprement parler est constitué par les parties suivantes. Composé lui-même d'une suite de modules, il vous amènera à pratiquer tous les aspects du langage, au travers d'un thème applicatif concret et conçu par des utilisateurs professionnels de Lua, depuis la rédaction de scripts simples jusqu'à la conception d'une application complète. Selon votre niveau de compétences et vos besoins, vous pouvez choisir de n'aborder qu'un aspect en particulier.

Une partie Utilitaires Lua a été ajoutée à cette seconde édition pour élargir votre connaissance de l'écosystème Lua à des outils d'aide au développement Lua, eux-mêmes écrits en Lua. Deux d'entre eux, LuaRocks et Sailor, sont présentés par leurs créateurs en personne : Hisham Muhammad et Etiene Dalcol. L'ensemble est complété par une annexe technique détaillant les étapes d'installation ainsi qu'un glossaire expliquant les principaux termes difficiles.

Parallèlement au manuel d'apprentissage, le manuel de référence vous permet d'avoir toujours sous la main des exemples précis et pratiques pour résoudre les problèmes les plus fréquents du développement sous Lua. En complément des solutions directement issues du langage, vous y trouverez des conseils pour utiliser au mieux les extensions les plus stables et les plus couramment utilisées. Ce manuel de référence est donc plus qu'une référence du langage, c'est un panel le plus complet possible de l'univers de Lua.

2. Public visé

Au travers de cette approche modulaire et de ces deux outils que sont les manuels d'apprentissage et de référence, chacun pourra apprendre, progresser, piocher ou encore s'améliorer. Ainsi, l'étudiant en informatique – débutant ou confirmé – aura l'opportunité d'apprendre un langage original et peu connu, notoirement recherché par exemple dans le domaine du jeu vidéo (voir Chapitre Tour d'horizon). Le développeur, pratiquant déjà d'autres langages dans sa vie professionnelle, trouvera ici le kit complet pour démarrer son développement ou en parler au sein de son équipe. Le chef de projet ou le responsable technique pourra appréhender les avantages du langage par rapport aux outils déjà utilisés, et, sur les éventuels conseils d'un membre de l'équipe, adopter le langage pour un prochain projet. Enfin, l'amateur éclairé ou le bidouilleur de génie sera fin prêt à intégrer Lua au sein de ses développements personnels, ou à en tirer parti dans son programme favori utilisant ce langage pour ses scripts et extensions.

3. Prérequis

En termes de prérequis, la pratique – même succincte – d'un autre langage de développement constituera une aide évidente. Vous trouverez ainsi régulièrement des encadrés comparant Lua avec des langages connus (C, C++, Perl, PHP, etc.). Toutefois l'ouvrage est conçu de sorte qu'un débutant en programmation puisse également se former, notamment en suivant pas à pas les étapes du manuel d'apprentissage. Un développeur confirmé pourra lui par contre piocher dans l'un des chapitres du manuel d'apprentissage pour appréhender un nouvel aspect de Lua ou bien se rappeler rapidement les techniques et méthodes à utiliser pour un problème concret via le manuel de référence.

4. Réglage de la largeur de l'écran

Cet ouvrage de programmation contient de nombreux exemples de code, formatés dans une police à chasse fixe. Afin d'éviter des retours à la ligne inopportuns à l'intérieur d'une ligne de code, la longueur maximale des lignes de code a été fixée à 65 caractères, une valeur suffisamment basse pour être affichée sur la plupart des supports, tout en étant suffisante pour que le code puisse être correctement formaté.

Toutefois, il est possible que sur votre support la largeur maximale affichable soit inférieure à la limite fixée. Le paragraphe test ci-dessous permet de vérifier votre affichage. Il doit tenir sur deux lignes exactement :

00000000001111111111222222222233333333334444444444555555555566666
01234567890123456789012345678901234567890123456789012345678901234

Si ce n'est pas le cas, regardez si vous pouvez agrandir la taille de la fenêtre, diminuer la taille des marges ou diminuer la taille de la police d'affichage. Sur un téléphone portable, placez-le plutôt en mode paysage. Si vous n'y arrivez pas, ne vous inquiétez pas pour autant, la plupart des lignes de code sont inférieures à 65 caractères.

5. Encore un mot...

Sans plus attendre, ni prolonger outre mesure cette introduction, je vous invite à découvrir le monde – parfois insoupçonné – de Lua et de prendre autant de plaisir à apprendre ce langage que les auteurs ont à vous le faire découvrir.

Tour d'horizon

1. Usages de Lua

Aucun langage de programmation n'est adapté à tous les développements informatiques. Lua ne fait nullement exception à cette règle. Toutefois, il peut être utilisé dans des situations fort diverses. Ce chapitre cherche à énumérer les avantages et inconvénients de Lua, comparé à d'autres langages de programmation courants.

Le slogan de Lua, traduit de l'anglais, était naguère : Un langage d'extension extensible. Cela résume bien le positionnement de Lua dans le domaine de la programmation. Si vous y réfléchissez, vous pourrez constater que les avantages et inconvénients de Lua vis-à-vis des autres langages ont presque tous pour origine cette orientation.

1.1. Points forts

Lua ne manque pas d'atouts. Certains points forts du langage sont presque uniques et peuvent justifier à eux seuls l'adoption de Lua dans un nouveau développement.

Sveltesse

Une caractéristique très importante de Lua est sa toute petite taille. Si, sur des ordinateurs de bureau actuels, il n'est pas rare de voir des logiciels occuper plusieurs centaines de mégaoctets d'espace disque, les capacités de stockage et de mémoire sont beaucoup plus faibles dans les produits électroniques embarqués. Le compilateur, l'interpréteur et les librairies standards de Lua n'occupent qu'environ 150 kilo-octets une fois compilés. C'est facilement dix fois moins qu'un environnement Perl ou Python réduit à son strict minimum, ou cent fois moins qu'un compilateur C++ moderne en ligne de commande.

Portabilité

Le code source en C est portable. Beaucoup de programmes se targuent d'être portables sous prétexte qu'ils peuvent tourner à la fois sur Windows, Mac OS et Linux. Lua va beaucoup plus loin dans sa définition de portabilité, car il peut être compilé sur toute plate-forme possédant un compilateur C respectant la norme ANSI. Le code source respecte même la norme C++98 en plus de C89, ce qui fait qu'il peut être compilé au choix comme un programme C ou C++.

Ainsi, Lua peut être utilisé dans presque tout appareil électronique intégrant un microprocesseur, qu'il soit de type ARM, MIPS, PowerPC ou autre. La taille des mots (32 ou 64 bits), l'ordre des octets dans les mots, le système d'exploitation (voire son absence) sont tout à fait indifférents pour Lua. Bien que normalement le type double soit utilisé pour représenter toute valeur numérique, Lua peut être configuré pour utiliser float ou int comme type numérique, rendant alors possible son utilisation sur un DSP par exemple.

Intégration en C/C++

Lua est écrit sous forme de librairie C et ne contient pas de fonction main. Ce qui veut dire que Lua est fondamentalement conçu pour être embarqué à l'intérieur d'une application ou d'un micrologiciel et appelé comme une extension du programme principal. Certes, il existe un programme indépendant nommé lua qui permet en apparence d'exécuter des scripts en dehors de toute application. Mais il faut comprendre que cet interpréteur est également une petite application en C (lua.c) qui utilise Lua sous forme de librairie.

L'interface de programmation en C est fondamentale pour Lua. Elle ne constitue pas un ajout fait sur le tard comme dans d'autres langages avec leurs différents bindings, elle en est son moteur initial. Les librairies standards de Lua s'appuient sur elle, comme d'ailleurs (dans une certaine mesure) la machine virtuelle de l'interpréteur. L'API est donc particulièrement bien pensée et facile à utiliser depuis une application tierce.

Licence libérale

Lua est entièrement gratuit et libre. Il est distribué depuis la version 5.0 sous la licence particulièrement libérale MIT, qui permet d'intégrer ce langage dans tous les types d'applications, qu'elles soient propriétaires, commerciales ou sous licence libre GPL. Il vous est également permis de modifier les sources comme bon vous semble, sans obligation de publier les modifications apportées. L'association Lua.org à Rio conserve toutefois la propriété intellectuelle pleine et entière de Lua. Ce point est particulièrement important en milieu industriel où les licences libres sont souvent considérées comme dangereuses pour le logiciel interne : avec Lua, aucun problème de ce type.

Rapidité

Lua est probablement le langage de programmation interprété le plus rapide. Il tourne nettement plus vite que Perl ou Python par exemple. Certes, les langages compilés comme le C ou C++ sont encore nettement plus performants, mais leur usage est différent. Le compilateur de Lua, à savoir la partie du langage chargée de traduire le code source en bytecode, est aussi très efficace. Lua n'aura aucun mal à exécuter des scripts composés de plusieurs dizaines de mégaoctets de données.

Mieux encore : il existe depuis quelques années une implémentation de Lua nommée LuaJIT qui est incroyablement rapide ! Grâce à son génial compilateur en temps réel et à sa puissante interface FFI, elle peut parfois battre un code équivalent écrit en C ! Développé par Mike Pall de façon indépendante de Lua, LuaJIT est certes nettement plus gros et moins portable que l'original. Mais il est compatible avec Lua 5.1 aussi bien sur le plan syntaxique que de l'API et sa rapidité bat tous les records.

Simplicité

La syntaxe de Lua est très simple. Comme vous pourrez vous en rendre compte dans les prochains chapitres, l'essentiel du langage peut être appris en une seule journée. Le nombre d'opérateurs est environ la moitié de celui du C, et il n'y a qu'un minimum de structures grammaticales. Il y a exactement huit types de données que l'on peut affecter à toute variable ou argument de fonction. Parmi ceux-ci, deux types, à savoir table et userdata sont très versatiles et permettent de construire pratiquement n'importe quelle structure de données. Même les concepts les plus avancés de Lua, comme ceux utilisés pour la programmation modulaire, fonctionnelle ou orientée objet, n'utilisent que des briques élémentaires comme des tables et des fonctions.

Extensibilité

Grâce à son API très bien pensée et aux structures de données versatiles introduites plus haut, Lua est conçu pour être lui-même étendu afin de satisfaire les besoins d'intégration dans une application. L'extension la plus courante est d'exporter vers Lua des fonctions de l'application (en général écrites en C ou C++), empaquetées dans une table. Les fonctions de cette librairie pourront alors être appelées depuis Lua exactement comme des fonctions standards.

Il est aussi possible de modifier certains fonctionnements apparemment internes au langage. Par exemple, il est facile de modifier la manière dont Lua charge un module optionnel ou de changer le fonctionnement de la fonction élémentaire print. Il est aussi assez simple de créer un environnement d'exécution sécurisé (ou sandbox).

1.2. Points faibles

La plupart des points faibles de Lua sont le revers de sa portabilité et de sa petite taille. Le langage ne peut rivaliser en fonctionnalités avec des environnements aussi complets que Java par exemple.

Peu de librairies standards

Comme Lua n'utilise strictement que des fonctions normalisées dans ANSI C, la plupart des fonctions des systèmes d'exploitation ne sont pas disponibles. Il n'y a notamment pas de notion de répertoire dans Lua, ni de socket ou d'environnement graphique. Ce qui fait qu'il est difficile de réaliser un projet informatique réel en se basant exclusivement sur la distribution officielle. Vous devrez certainement ajouter des modules externes, ou exporter des fonctions de votre application dans Lua.

Librairies tierces éparpillées

Il existe bien de nombreuses librairies et outils pour Lua. La plupart de ces logiciels ont la même licence libérale que Lua lui-même. Mais, contrairement à CPAN pour Perl, il n'existe pas de site centralisant et classant tous les modules Lua. Votre meilleur atout si vous avez besoin d'une librairie Lua reste un moteur de recherche.

Heureusement pour vous, toute une partie du livre est consacrée à exposer les librairies tierces que nous avons jugées les plus intéressantes. Nous ferons fréquemment référence à certaines d'entre elles dans des exemples.

Et une certaine avancée a quand même été réalisée ces dernières années. L'outil LuaRocks permet de décrire des paquets de distribution Lua sous forme de sources, qui sont automatiquement compilés lors de l'installation, un peu comme avec CPAN. Un nombre croissant de modules Lua supportent ce protocole. De plus, des distributions comme LuaDist et LuaForWindows cherchent à pouvoir permettre au programmeur novice d'avoir rapidement un environnement de développement complet.

Il existe aussi un site de type wiki nommé lua-users.org, qui est ouvert à tout contributeur. Vous y trouverez de nombreux conseils et des extraits de code fort utiles.

Petite communauté

Le nombre de programmeurs utilisant Lua est bien plus faible que celui utilisant Java, C ou C# par exemple. En dehors de l'industrie du jeu vidéo dans laquelle Lua s'est largement imposé, la plupart des informaticiens n'ont jamais entendu parler de ce langage. Cela signifie pour vous qu'il n'existe pas beaucoup de littérature sur Lua, et notamment en français. L'ouvrage que vous avez dans les mains cherche à combler un peu ce manque.

Il est à relever que certains titres de jeux à succès, notamment World of Warcraft (WoW), utilisent Lua comme langage d'extension. Tous les joueurs souhaitant ajouter des niveaux à leur jeu favori vont donc se frotter à Lua, bien que souvent ils ignorent que le langage existe pour lui-même en dehors du jeu !

1.3. Exemples d'utilisation

Vous l'aurez compris, Lua se destine clairement comme un langage embarqué. Cela peut être tout aussi bien dans une application serveur sur un gros ordinateur, dans un jeu vidéo pour téléphone portable comme dans le micrologiciel d'une imprimante. Les prochains chapitres montrent quelques usages divers et variés pour lesquels Lua est particulièrement intéressant, avec chaque fois un petit exemple pour illustrer la situation.

Comme fichier de configuration

Classiquement, sous Unix, la configuration d'un programme se fait sous la forme de fichiers texte qu'il convient de décoder et d'interpréter correctement. À l'origine, sous Windows, les fichiers .ini étaient largement utilisés dans ce but. De nos jours, les fichiers au format XML et la base de registre de Windows notamment ont largement supplanté le format texte pur. Néanmoins, utiliser un langage de programmation complet à la place d'un format de données pur comme le XML offre des possibilités de flexibilité largement supérieures. À noter que Lua a été créé, à l'origine, dans ce but : décrire des configurations complexes de façon flexible.

-- Configuration d'un client web
server = { host="www.lua.org", port=80, protocol="http" }
basedir = "c:/MyClientSoftware/"
userdir = basedir.."data/"..os.getenv("USERNAME")

Comme base de données

Pour des grandes quantités de données, ou si l'application nécessite une forte sécurité contre la corruption de celles-ci, un moteur de base de données s'impose. Par contre, dans de nombreux autres cas, une base de données pourra être éditée à la main ou générée par un outil externe. Un format texte sera alors privilégié. Comme dans l'exemple précédent, un fichier en texte pur, séparé par des virgules, ou du XML sont des solutions satisfaisantes. Mais Lua est bien meilleur, grâce à la grande flexibilité de sa syntaxe ainsi qu'à l'extrême rapidité de son compilateur.

-- Liste des auteurs de ce livre
authors = {
  { first="Cyril", last="Doillon" },
  { first="Sylvain", last="Fabre" },
  { first="Philippe", last="Lhoste" },
  { first="Patrick", last="Rapin" },
}

Comme langage dédié

Dans certains cas, il est préférable d'utiliser un langage de programmation dédié à une application, au lieu d'un langage généraliste. Imaginons par exemple que l'on souhaite piloter un robot à l'aide d'une ligne de commande. On aimerait alors une syntaxe courte, du genre marche "1.2m" tourne "90°". Eh bien, cet extrait de code est syntaxiquement correct en Lua ! Et même s'il ne l'était pas, il serait beaucoup plus facile de l'interpréter correctement à l'aide d'un langage de script existant plutôt que d'écrire un nouvel interpréteur à partir de zéro.

-- Affiche un rectangle et un texte
rectangle { position = { 30, 20 },
  size = { 40, 50 } }
text { text = "Hello World",
  size = { 80, 20 },
  position = { 40, 80} }

Comme langage de prototypage

De nombreux programmes utilisent Lua pour accélérer leur développement. Car ainsi, il n'est pas nécessaire de recompiler l'application pour essayer une nouvelle fonctionnalité. Dans les jeux vidéo, la programmation des différents niveaux de jeu se fait généralement avec un langage de script. Les personnes qui imaginent des niveaux supplémentaires ne sont pas nécessairement des programmeurs confirmés. Lua est donc apprécié dans la branche car c'est un langage facile à apprendre, qui de plus est rapide et simple à interfacer dans le jeu.

if player:lifeLevel() > 0.3 then
  player:run()
else
  player:walk()
end

Comme langage d'extension

Il est naturel d'utiliser Lua pour écrire des greffons à une application. Les applications qui ont opté pour des greffons écrits en C ou C++, même en Java, nécessitent que le développeur de ceux-ci installe un environnement de compilation ad hoc. Pire : pour être vraiment portable, une telle application impose même à l'utilisateur final d'avoir un compilateur pour sa plate-forme pour installer des greffons. Lua permet de s'affranchir d'une telle dépendance : il suffit d'un éditeur de texte ou de copier un fichier dans un certain répertoire pour obtenir une nouvelle fonctionnalité dans l'application.

-- Ajoute un menu dans WireShark
register_menu("Lua/Tester serveur Web", function()
    browser_open_url("http://localhost:8080")
  end, MENU_TOOLS_UNSORTED)

Comme langage économique

Dans des environnements embarqués restreints en mémoire et en puissance de calcul, dans lesquels on souhaite quand même avoir la flexibilité d'un langage de script complet, Lua est presque un choix incontournable. Aucun autre interpréteur ne rivalise en taille et en vitesse pour un nombre équivalent de fonctions avec une syntaxe aussi facile à utiliser. C'est pourquoi Lua se retrouve dans des appareils électroniques en tous genres. Il existe aussi des versions minimalistes de Linux qui utilisent des scripts Lua pour remplacer des applications graphiques, normalement écrites en C.

-- Convertit en majuscules STDIN vers STDOUT
for L in io.lines() do
  print(L:upper())
end

2. Genèse du langage

2.1. Contexte

Lua est entièrement développé à l'Université pontificale catholique de Rio de Janeiro (PUC-Rio), dans le groupe Tecgraf traitant de l'informatique graphique. Étonnamment, il se trouve que Lua n'aurait probablement jamais vu le jour sans la politique très protectionniste du Brésil à cette époque. Les compagnies ne pouvaient pas importer de produit informatique, que ce soit logiciel ou matériel, sans apporter de preuves au gouvernement que ce produit ne pouvait pas être fourni par des Brésiliens. Dans ce contexte, Petrobras, la compagnie pétrolière brésilienne, s'est logiquement adressée à l'université pontificale de Rio, renommée, pour leur fournir les logiciels somme toute assez simples dont ils avaient besoin.

2.2. DEL

En 1993, Petrobras utilisait un logiciel de simulation fort ancien, qui nécessitait des données dans un format précis et inflexible. Il était très peu pratique pour les utilisateurs d'entrer manuellement toutes les données. La compagnie a alors mandaté Tecgraf pour qu'elle développe toute une série d'outils graphiques pour l'aider dans cette tâche. Après analyse de la situation, Tecgraf conclut qu'il était judicieux d'écrire un langage de données intermédiaire qui serait commun à tous les outils. Ainsi est né DEL, pour Data-Entry Language. C'est un langage assez primitif basé uniquement sur des entités de données, soit l'équivalent de structures, intégrant l'information sur ce qu'elles représentent.

Une seule application graphique basée sur DEL a finalement été développée, qui a pu remplacer l'ensemble des outils demandés par Petrobras. Le langage a tellement plu aux utilisateurs qu'ils ont alors demandé des fonctionnalités plus avancées, d'abord des expressions booléennes, puis des structures de contrôle comme des boucles.

2.3. SOL

Simultanément, une autre équipe de Tecgraf travaillait sur un générateur flexible de rapport, aussi pour Petrobras. Ces rapports consistaient surtout à dessiner des graphiques en prenant des colonnes de chiffres comme valeurs d'entrée. Si vous avez déjà utilisé un logiciel comme MATLAB pour dessiner des graphes non triviaux, vous savez combien d'options il faut gérer pour satisfaire les divers cas de figure.

L'équipe à PUC décida d'écrire un nouveau langage pour décrire les objets graphiques du rapport, ce sera SOL (Simple Object Language). SOL permet de spécifier des types d'objets (l'équivalent de la définition d'une structure en C), puis de l'instancier en passant à son constructeur les valeurs des différents champs. Avant même d'être fourni à Petrobras, il parut évident qu'il manquait à SOL la possibilité de programmer les objets de façon procédurale.

2.4. Lua

Un beau jour de 1993, trois programmeurs travaillant sur DEL et SOL se rencontrèrent pour parler de leurs problèmes respectifs. Il ressortit rapidement de la discussion que les deux langages embryonnaires feraient mieux de fusionner dans un système plus puissant. C'est ainsi qu'est né officiellement Lua, un langage qui restait à implémenter. Ces trois développeurs, Roberto Ierusalimschy, Luiz Henrique de Figueiredo et Waldemar Celes, formèrent l'équipe initiale de développement de Lua. Il est à relever que toutes les évolutions écrites jusqu'à ce jour, soit pendant près de vingt ans, l'ont été par cette même petite équipe !

Le nom du langage vient d'un jeu de mot en portugais : SOL signifiant Soleil dans cette langue, un collaborateur imagina que son successeur devrait s'appeler Lua, c'est-à-dire Lune !

Note > Puisque Lua n'est pas une abréviation mais le nom d'un astre, seule sa première lettre est en majuscule. Beaucoup de développeurs Lua sont sensibles à ce détail : n'écrivez surtout pas LUA si vous posez une question à la communauté, vous seriez corrigé !

Note > Comme il s'agit d'un mot portugais, Lua se prononce comme le verbe louer à la troisième personne du passé simple, soit loua.

2.5. Évolution

Il est assez remarquable de constater que la syntaxe de Lua a très peu changé au cours du temps. Un script écrit pour Lua 2.1, sorti en février 1995, a toutes les chances de compiler encore sans erreur dans la version actuelle 5.3 ! En revanche, il y a bien peu de chance qu'il s'exécute sans générer d'erreur, car la collection des librairies standards a, elle, bien évolué au cours des versions.

L'interface de programmation C (API) change encore plus fréquemment que les librairies. Entre chaque version de Lua, il y a des incompatibilités dans l'API qui peut rendre la migration au sein d'une application un peu délicate. Entre Lua 3.2 et 4.0, sorti fin 2000, l'interface a même été complètement réécrite, afin de gérer plusieurs instances simultanées de l'interpréteur. Le changement a d'ailleurs été dramatique, car aucune des applications utilisant Lua 3.2 à Tecgraf n'a finalement migré vers 4.0 ! Cela a quelque peu déçu les auteurs de Lua ; mais la satisfaction des nouveaux utilisateurs du langage a largement compensé le sacrifice.

Cet épisode illustre bien le modèle d'évolution de Lua. Contrairement à bien des langages, qui cherchent à garantir la compatibilité à tout prix, Lua peut introduire des incompatibilités à chaque changement de version. Rarement dans la syntaxe, souvent parmi les librairies standards, et presque toujours dans l'API en C. Toutefois, il y a des options de compilation (enclenchées par défaut) qui permettent de continuer temporairement à utiliser les fonctionnalités dépréciées.

Attention > N'utilisez jamais de fonctions dépréciées dans de nouveaux scripts, car votre code ne fonctionnera plus lors de la prochaine version de Lua. Ce mode de compatibilité ne supporte que les changements depuis la version précédente (5.2 dans le cas de 5.3), et pas les incompatibilités antérieures. De plus, certaines applications utilisant Lua désactivent ces options de compatibilité.

3. Lua et les jeux vidéo

3.1. Les besoins du secteur

...