Lua - Débogage

Lua fournit une bibliothèque de débogage, qui fournit toutes les fonctions primitives pour que nous puissions créer notre propre débogueur. Même s'il n'y a pas de débogueur Lua intégré, nous avons de nombreux débogueurs pour Lua, créés par divers développeurs, dont beaucoup sont open source.

Les fonctions disponibles dans la bibliothèque de débogage Lua sont répertoriées dans le tableau suivant avec ses utilisations.

N ° Sr.	Méthode et objectif
1	debug() Entre en mode interactif pour le débogage, qui reste actif jusqu'à ce que nous tapions uniquement cont dans une ligne et appuyez sur Entrée. L'utilisateur peut inspecter les variables pendant ce mode en utilisant d'autres fonctions.
2	getfenv(object) Renvoie l'environnement de l'objet.
3	gethook(optional thread) Renvoie les paramètres de hook actuels du thread, sous forme de trois valeurs: la fonction de hook actuel, le masque de hook actuel et le nombre de hook actuel.
4	getinfo(optional thread, function or stack level, optional flag) Renvoie une table avec des informations sur une fonction. Vous pouvez donner la fonction directement, ou vous pouvez donner un nombre comme valeur de function, ce qui signifie que la fonction s'exécutant au niveau de la fonction de la pile d'appels du thread donné - le niveau 0 est la fonction courante (getinfo elle-même); le niveau 1 est la fonction qui a appelé getinfo; etc. Si function est un nombre plus grand que le nombre de fonctions actives, alors getinfo renvoie nil.
5	getlocal(optional thread, stack level, local index) Renvoie le nom et la valeur de la variable locale avec l'index local de la fonction au niveau de la pile. Renvoie nil s'il n'y a pas de variable locale avec l'index donné et déclenche une erreur lorsqu'elle est appelée avec un niveau hors limites.
6	getmetatable(value) Renvoie la métatable de l'objet donné ou nil si elle n'a pas de métatable.
sept	getregistry() Renvoie la table de registre, une table prédéfinie qui peut être utilisée par n'importe quel code C pour stocker la valeur Lua qu'il doit stocker.
8	getupvalue(function, upvalue index) Cette fonction renvoie le nom et la valeur de la valeur up avec index up de la fonction func. La fonction renvoie nil s'il n'y a pas de valeur positive avec l'index donné.
9	setfenv(function or thread or userdata, environment table) Définit l'environnement de l'objet donné sur la table donnée. Renvoie l'objet.
dix	sethook(optional thread, hook function, hook mask string with "c" and/or "r" and/or "l", optional instruction count) Définit la fonction donnée comme un crochet. Le masque de chaîne et le nombre de nombres décrivent quand le hook sera appelé. Ici, c, r et l sont appelés à chaque fois que Lua appelle, retourne et entre chaque ligne de code dans une fonction respectivement.
11	setlocal(optional thread, stack level, local index, value) Affecte la valeur à la variable locale avec l'index local de la fonction au niveau de la pile. La fonction renvoie nil s'il n'y a pas de variable locale avec l'index donné et génère une erreur lorsqu'elle est appelée avec un niveau hors limites. Sinon, il renvoie le nom de la variable locale.
12	setmetatable(value, metatable) Définit la métatable pour l'objet donné sur la table donnée (qui peut être nulle).
13	setupvalue(function, upvalue index, value) Cette fonction affecte la valeur à la valeur up avec index up de la fonction func. La fonction renvoie nil s'il n'y a pas de valeur positive avec l'index donné. Sinon, il renvoie le nom de la valeur positive.
14	traceback(optional thread, optional message string, optional level argument) Génère un message d'erreur étendu avec une trace.

La liste ci-dessus est la liste complète des fonctions de débogage dans Lua et nous utilisons souvent une bibliothèque qui utilise les fonctions ci-dessus et facilite le débogage. Utiliser ces fonctions et créer notre propre débogueur est assez compliqué et n'est pas préférable. Quoi qu'il en soit, nous verrons un exemple d'utilisation simple des fonctions de débogage.

function myfunction ()
   print(debug.traceback("Stack trace"))
   print(debug.getinfo(1))
   print("Stack trace end")

   return 10
end

myfunction ()
print(debug.getinfo(1))

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons la trace de la pile comme indiqué ci-dessous.

Stack trace
stack traceback:
	test2.lua:2: in function 'myfunction'
	test2.lua:8: in main chunk
	[C]: ?
table: 0054C6C8
Stack trace end

Dans l'exemple de programme ci-dessus, la trace de pile est imprimée à l'aide de la fonction debug.trace disponible dans la bibliothèque de débogage. Le debug.getinfo obtient la table actuelle de la fonction.

Débogage - Exemple

Nous avons souvent besoin de connaître les variables locales d'une fonction pour le débogage. Pour cela, nous pouvons utiliser getupvalue et pour définir ces variables locales, nous utilisons setupvalue. Un exemple simple de ceci est présenté ci-dessous.

function newCounter ()
   local n = 0
   local k = 0
	
   return function ()
      k = n
      n = n + 1
      return n
   end
	
end

counter = newCounter ()

print(counter())
print(counter())

local i = 1

repeat
   name, val = debug.getupvalue(counter, i)
	
   if name then
      print ("index", i, name, "=", val)
		
      if(name == "n") then
         debug.setupvalue (counter,2,10)
      end
		
      i = i + 1
   end -- if
	
until not name

print(counter())

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons la sortie suivante.

1
2
index	1	k	=	1
index	2	n	=	2
11

Dans cet exemple, le compteur se met à jour à chaque fois qu'il est appelé. Nous pouvons voir l'état actuel de la variable locale en utilisant la fonction getupvalue. Nous définissons ensuite la variable locale sur une nouvelle valeur. Ici, n vaut 2 avant que l'opération set ne soit appelée. En utilisant la fonction setupvalue, il est mis à jour à 10. Maintenant, lorsque nous appelons la fonction de compteur, il retournera 11 au lieu de 3.

Types de débogage

• Débogage de la ligne de commande
• Débogage graphique

Débogage de la ligne de commande

Le débogage en ligne de commande est le type de débogage qui utilise la ligne de commande pour déboguer à l'aide de commandes et d'instructions d'impression. Il existe de nombreux débogueurs de ligne de commande disponibles pour Lua, dont quelques-uns sont répertoriés ci-dessous.

• RemDebug- RemDebug est un débogueur distant pour Lua 5.0 et 5.1. Il vous permet de contrôler l'exécution d'un autre programme Lua à distance, de définir des points d'arrêt et d'inspecter l'état actuel du programme. RemDebug peut également déboguer les scripts CGILua.

• clidebugger- Un débogueur d'interface de ligne de commande simple pour Lua 5.1 écrit en pure Lua. Il ne dépend de rien d'autre que des bibliothèques standard Lua 5.1. Il a été inspiré par RemDebug mais n'a pas ses installations distantes.

• ctrace - Un outil de suivi des appels d'API Lua.

• xdbLua - Un débogueur de ligne de commande Lua simple pour la plate-forme Windows.

• LuaInterface - Debugger- Ce projet est une extension de débogage pour LuaInterface. Il élève l'interface de débogage intégrée de Lua à un niveau supérieur. L'interaction avec le débogueur se fait par des événements et des appels de méthode.

• Rldb- Il s'agit d'un débogueur Lua distant via socket, disponible sous Windows et Linux. Il peut vous offrir beaucoup plus de fonctionnalités que n'importe quel existant.

• ModDebug - Cela permet de contrôler l'exécution d'un autre programme Lua à distance, de définir des points d'arrêt et d'inspecter l'état actuel du programme.

Débogage graphique

Le débogage graphique est disponible à l'aide de l'EDI où vous êtes fourni avec le débogage visuel de divers états tels que les valeurs de variable, la trace de pile et d'autres informations connexes. Il existe une représentation visuelle et un contrôle pas à pas de l'exécution à l'aide de points d'arrêt, de pas à pas, de pas à pas et d'autres boutons dans l'EDI.

Il existe un certain nombre de débogueurs graphiques pour Lua et il comprend les éléments suivants.

• SciTE - L'EDI Windows par défaut pour Lua fournit plusieurs fonctionnalités de débogage telles que les points d'arrêt, l'étape, l'entrée, l'étape, les variables de surveillance, etc.

• Decoda - Il s'agit d'un débogueur graphique avec prise en charge du débogage à distance.

• ZeroBrane Studio- Lua IDE avec débogueur distant intégré, vue de la pile, vue de la montre, console distante, analyseur statique, etc. Fonctionne avec LuaJIT, Love2d, Moai et d'autres moteurs Lua; Windows, OSX et Linux. Open source.

• akdebugger - Débogueur et éditeur du plugin Lua pour Eclipse.

• luaedit - Cela comprend le débogage à distance, le débogage local, la coloration syntaxique, la liste de propositions d'achèvement, le moteur de proposition de paramètres, la gestion avancée des points d'arrêt (y compris le système de conditions sur les points d'arrêt et le nombre de hits), la liste des fonctions, la liste des variables globales et locales, les montres, la gestion orientée solution.