 |
Samedi 20 avril 2024 - 14:10 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
À propos
Lua est un langage de script puissant, rapide, léger et encapsulable, qui est bien intégré à MorphOS. Il gère même la communication par port ARexx sur MorphOS.
Utilisation
L'interpréteur Lua est implémenté dans MorphOS comme une bibliothèque partagée du système (lua.library), qui peut être utilisée en interne par d'autres programmes avec l'API C de Lua.
Lua peut également être utilisé comme un langage autonome en exécutant des scripts avec la commande "LuaX" sur MorphOS. Ses arguments sont les suivants :
- FILE : fichier script Lua à exécuter.
- INTERACTIVE : donne une invite de commandes interactive afin de converser avec l'interpréteur.
- ARGS : arguments pour le script.
Ram Disk:> LuaX S:MultiMeedio.lua NEXT |
...exécute le script "MultiMeedio.lua" trouvé dans "S:" et passe l'argument "NEXT" au script.
Caractéristiques spécifiques de MorphOS
Modules
Les bibliothèques Lua standard sont implémentées comme des modules partagés et, contrairement à la distribution Lua standard, elles doivent être chargées séparément avec la fonction "require()" si nécessaire. Le seul module disponible immédiatement est "package".
Le répertoire MOSSYS:Libs/Lua/ contient tous les modules disponibles. Ceux-ci sont inclus dans le système depuis la version 3.10 :
Par exemple, une ligne "require("io")" est nécessaire avant de pouvoir utiliser la fonction "io.write()".
Communication ARexx
Le module "ipc" contient les fonctions suivantes pour communiquer avec les programmes via leurs ports ARexx :
- ipc.address(port) : définit le nom du port ARexx par défaut pour l'envoi de commandes. "address("COMMAND")" exécute les commandes comme des commandes DOS Shell (bien que "os.execute()" de Lua fasse la même chose).
- ipc.checkport(port) : vérifie si un port ARexx est disponible.
- ipc.rx(command) : envoie une commande ARexx à un port défini avec "ipc.address". Le résultat d'ARexx est renvoyé comme résultat de la fonction. La variable Lua "rc" est également définie sur le résultat "RC" d'ARexx.
- ipc.waitforport(name[, interval]) : attend l'apparition d'un port public. Le script est interrompu si le port n'est pas trouvé après l'intervalle de temps spécifié (l'intervalle par défaut est de 5 secondes).
Exemple :
Chargeons le module dont nous avons besoin :
require("ipc")
-- Si le port OWB est trouvé, ouvrons la page officielle de MorphOS et passons en mode plein écran :
if ipc.checkport("OWB.1") then
address("OWB.1")
rx("OPEN NAME http://www.morphos-team.net/")
rx("FULLSCREEN")
end
|
Si l'exemple précédent est enregistré dans un fichier appelé "test.lua", il peut être exécuté à partir du Shell avec la commande "LuaX test.lua".
Les commandes de base
La bibliothèque de base fournit certaines fonctions essentielles à Lua. Si vous n'incluez pas cette bibliothèque dans votre application, vous devez vérifier soigneusement s'il faut fournir des implémentations pour certaines de ses fonctions.
assert (v [, message])
Émet une erreur lorsque la valeur de son argument "v" est fausse (c'est-à-dire "nil" ou "false") ; sinon, retourne tous ses arguments. "message" est un message d'erreur ; s'il est absent, il prend la valeur par défaut "assertion failed!".
collectgarbage ([opt [, arg]])
Cette fonction est une interface générique pour le récupérateur de mémoire ("garbage collection"). Elle exécute différentes fonctions suivant son premier argument, "opt:".
- "collect" : effectue un cycle complet de récupération de la mémoire. C'est l'option par défaut.
- "stop" : arrête le récupérateur de mémoire.
- "restart" : redémarre le récupérateur de mémoire.
- "count" : retourne la mémoire totale utilisée par Lua (en kilooctets).
- "step" : effectue une étape de récupération de mémoire. La "taille" de l'étape est contrôlée par "arg" (des valeurs plus grandes signifient plus d'étapes) d'une manière non spécifiée. Si vous voulez contrôler la taille de l'étape, vous devez ajuster expérimentalement la valeur de "arg". Retourne "true" (vrai) si l'étape a terminé un cycle de récupération.
- "setpause" : définit "arg" comme nouvelle valeur pour la pause du récupérateur de mémoire. Retourne la valeur précédente pour la pause.
- "settepmul" : définit "arg" comme nouvelle valeur pour le multiplicateur de l'étape du récupérateur de mémoire. Retourne la valeur précédente pour "step".
Ouvre le fichier nommé et exécute son contenu comme un bloc de données ("chunk") Lua. Lorsqu'il est appelé sans arguments, "dofile" exécute le contenu de l'entrée standard (stdin). Retourne toutes les valeurs retournées par le bloc de données. En cas d'erreur, "dofile" propage l'erreur à son appelant (c'est-à-dire que "dofile" ne fonctionne pas en mode protégé).
error (message [, level])
Termine la dernière fonction protégée appelée et renvoie "message" comme message d'erreur. La fonction "error" ne revient jamais. Habituellement, "error" ajoute des informations sur la position de l'erreur au début du message. L'argument "level" spécifie comment obtenir la position de l'erreur. Avec le niveau 1 ("level 1", la valeur par défaut), la position de l'erreur est l'endroit où la fonction "error" a été appelée. Le niveau 2 ("level 2") indique la position de l'erreur à l'endroit où la fonction qui a appelé "error" a été appelée ; et ainsi de suite. Passer un niveau 0 ("level 0") évite l'ajout d'informations sur la position de l'erreur dans le message.
_G
C'est une variable globale (pas une fonction) qui contient l'environnement global (c'est-à-dire, _G._G = _G). Lua lui-même n'utilise pas cette variable ; changer sa valeur n'affecte aucun environnement, et vice-versa (utilisez "setfenv" pour changer d'environnement).
getfenv ([f])
Renvoie l'environnement courant utilisé par la fonction. "f" peut être une fonction Lua ou un nombre qui spécifie la fonction à ce niveau de la pile : le niveau 1 est la fonction appelant "getfenv". Si la fonction donnée n'est pas une fonction Lua, ou si "f" est 0, "getfenv" retourne l'environnement global. La valeur par défaut de "f" est 1.
getmetatable (object)
Si l'objet n'a pas de métatable, retourne "nil". Sinon, si la métatable de l'objet a un champ "__metatable", retourne la valeur associée. Sinon, renvoie la métatable de l'objet donné.
ipairs (t)
Retourne trois valeurs : une fonction "iterator", le tableau "t", et "0", de sorte que la construction...
for i,v in ipairs(t) do body end |
...va itérer sur les paires (1,t[1]), (2,t[2]), ---, jusqu'à la première clé entière absente du tableau.
load (func [, chunkname])
Charge un bloc de données en utilisant la fonction "func" pour obtenir ses blocs. Chaque appel à "func" doit retourner une chaîne qui concatène les résultats précédents. Le retour d'une chaîne vide, "nil", ou aucune valeur signale la fin du bloc.
S'il n'y a pas d'erreur, le bloc de données compilé est retourné sous forme de fonction ; sinon, il retourne "nil" et le message d'erreur. L'environnement de la fonction retournée est l'environnement global.
"chunkname" est utilisé comme nom de bloc de données pour les messages d'erreur et les informations de débogage. Lorsqu'il est absent, il prend la valeur par défaut "=(load)".
loadfile ([filename])
Similaire à "load", mais récupère le bloc de données à partir du nom de fichier ou de l'entrée standard, si aucun nom de fichier n'est donné.
loadstring (strig [, chunkname])
Similaire à "load" mais récupère le bloc de données de la chaîne donnée.
Pour charger et exécuter une chaîne donnée, utilisez l'idiome :
assert(loadstring(s))() |
En l'absence du nom du bloc de données ("chunkname"), la chaîne donnée est utilisée par défaut.
next (table [, index])
Permet à un programme de parcourir tous les champs d'une table. Son premier argument est une table et son second argument est un index dans cette table. "next" retourne l'index suivant de la table et sa valeur associée. Lorsqu'il est appelé avec "nil" comme second argument, "next" renvoie un index initial et sa valeur associée. Lorsqu'il est appelé avec le dernier index, ou avec "nil" dans une table vide, "next" renvoie "nil". Si le second argument est absent, alors il est interprété comme "nil". En particulier, vous pouvez utiliser "next(t)" pour vérifier si un tableau est vide.
L'ordre dans lequel les indices sont énumérés n'est pas spécifié, même pour les indices numériques (pour parcourir un tableau dans l'ordre numérique, utilisez un "for" numérique ou la fonction "ipairs").
Le comportement de "next" est indéfini si, au cours du parcours, vous attribuez une valeur quelconque à un champ inexistant de la table. Vous pouvez cependant modifier les champs existants. En particulier, vous pouvez effacer des champs existants.
pairs (t)
Retourne trois valeurs : la fonction suivante, la table "t", ainsi que "nil", de sorte que la construction...
for k,v in pairs(t) do body end |
...itérera sur toutes les paires clé-valeur du tableau "t".
Voir la fonction "next" pour les avertissements concernant la modification de la table pendant sa traversée.
pcall (f, arg1, ---)
Appelle la fonction "f" avec les arguments donnés en mode protégé. Cela signifie que toute erreur à l'intérieur de "f" n'est pas propagée ; à la place, "pcall" capture l'erreur et renvoie un code d'état. Son premier résultat est le code d'état (un booléen), qui est "true" (vrai) si l'appel réussit sans erreur. Dans ce cas, "pcall" renvoie également tous les résultats de l'appel, après ce premier résultat. En cas d'erreur, "pcall" renvoie "false" (faux) et le message d'erreur.
print (---)
Reçoit un nombre quelconque d'arguments, et affiche leurs valeurs sur "stdout", en utilisant la fonction "tostring" pour les convertir en chaînes de caractères. "print" n'est pas prévu pour une sortie formatée, mais seulement comme un moyen rapide d'afficher une valeur, typiquement pour le débogage. Pour une sortie formatée, utilisez "string.format".
rawequal (v1, v2)
Vérifie si "v1" est égal à "v2", sans invoquer de métaméthode. Retourne un booléen.
rawget (table, index)
Obtient la valeur réelle de "table[index]", sans invoquer de métaméthode. "table" doit être un tableau ; "index" peut être une valeur quelconque.
rawset (table, index, value)
Définit la valeur réelle de "table[index]" à "value" (valeur), sans invoquer de métaméthode. "table" doit être une table, "index" une valeur différente de "nil", et "value" une valeur Lua.
Cette fonction retourne "table".
select (index, ---)
Si "index" est un nombre, renvoie tous les arguments après l'argument numéro "index". Sinon, "index" doit être la chaîne "#", et "select" retourne le nombre total d'arguments supplémentaires qu'elle a reçus.
setfenv (f, table)
Définit l'environnement à utiliser par la fonction donnée. "f" peut être une fonction Lua ou un nombre qui spécifie la fonction à ce niveau de la pile : le niveau 1 ("level 1") est la fonction appelant "setfenv". "setfenv" retourne la fonction donnée.
Dans un cas particulier, lorsque "f" vaut 0, "setfenv" change l'environnement du fil en cours d'exécution. Dans ce cas, "setfenv" ne renvoie aucune valeur.
setmetatable (table, metatable)
Définit la métatable pour la table donnée (vous ne pouvez pas modifier les métatables d'autres types à partir de Lua, seulement à partir du C). Si "metatable" est "nil", supprime les métatables de la table donnée. Si la métatable d'origine possède un champ "__metatable", cela entraîne une erreur.
Cette fonction retourne "table".
tonumber (e [, base])
Essaie de convertir son argument en un nombre. Si l'argument est déjà un nombre ou une chaîne convertible en un nombre, alors "tonumber" retourne ce nombre ; sinon, elle retourne "nil".
Un argument optionnel spécifie la base pour interpréter le nombre. "base" peut être un nombre entier compris entre 2 et 36, inclus. Dans les bases supérieures à 10, la lettre "A" (en majuscule ou en minuscule) représente 10, "B" représente 11, et ainsi de suite, avec "Z" représentant 35. En base 10 (la base par défaut), le nombre peut avoir une partie décimale, ainsi qu'une partie exposant facultative. Dans les autres bases, seuls les entiers non signés sont acceptés.
tostring (e)
Reçoit un argument de n'importe quel type et le convertit en une chaîne de caractères dans un format raisonnable. Pour un contrôle complet de la façon dont les nombres sont convertis, utilisez "string.format".
Si la métatable de "e" a un champ "__tostring", alors "tostring" appelle la valeur correspondante avec "e" comme argument, et utilise le résultat de l'appel comme son résultat.
type (v)
Renvoie le type de son seul argument, codé comme une chaîne de caractères. Les résultats possibles de cette fonction sont "nil" (une chaîne, pas la valeur nil), "number", "string", "boolean", "table", "function", "thread" et "userdata".
unpack (list [, i [, j]])
Retourne les éléments du tableau donné. Cette fonction est équivalente à...
return list[i], list[i+1], ---, list[j] |
...sauf que le code ci-dessus ne peut être écrit que pour un nombre fixe d'éléments. Par défaut, "i" vaut 1 et "j" est la longueur de la liste, telle que définie par l'opérateur "length".
_VERSION
Une variable globale (pas une fonction) qui contient une chaîne de caractères contenant la version actuelle de l'interpréteur. Le contenu actuel de cette variable est "Lua 5.1".
xpcall (f, err)
Cette fonction est similaire à "pcall", sauf que vous pouvez définir un nouveau gestionnaire d'erreurs.
"xpcall" appelle la fonction "f" en mode protégé, en utilisant "err" comme gestionnaire d'erreurs. Toute erreur à l'intérieur de "f" n'est pas propagée ; au lieu de cela, "xpcall" attrape l'erreur, appelle la fonction "err" avec l'objet d'erreur original, et renvoie un code d'état. Son premier résultat est le code d'état (un booléen), qui est "true" (vrai) si l'appel réussit sans erreur. Dans ce cas, "xpcall" renvoie également tous les résultats de l'appel, après ce premier résultat. En cas d'erreur, "xpcall" renvoie "false" (faux) plus le résultat de "err".
Documentation
Il est facile de trouver toutes sortes de documentation et de solutions à vos problèmes pour Lua sur Internet, mais voici quelques recommandations.
Documentation officielle
Tutoriels par des utilisateurs de Lua
Autodocs et exemples MorphOS
- Des Autodocs à jour sont inclus dans la trousse de développement logiciel de MorphOS.
- L'archive Lua, maintenant obsolète, contient de la documentation spécifique à MorphOS, mais n'installez pas de binaires à partir de celle-ci !
Lua Explorador est un débogueur au niveau source basé en MUI pour les programmes Lua.
Exemple simple
Un exemple simple avec des chaînes de caractères :
require("io")
require("string")
local firstvar="MorphOS"
local secondvar="Rulez"
io.write(firstvar)
io.write(" "..string.upper(secondvar).."!\n")
|
Lancé depuis le Shell, cela donne :
Ram Disk:> luax example.lua MorphOS RULEZ! Ram Disk:> |
Exemples de code source
- Quelques scripts spécifiques à MorphOS peuvent être trouvés sur jpv.wmhost.com/morphos.
- La page SampleCode sur lua-users.org.
|
