Lua - Debuggen

Lua bietet eine Debug-Bibliothek, die alle primitiven Funktionen zum Erstellen eines eigenen Debuggers bietet. Obwohl es keinen eingebauten Lua-Debugger gibt, haben wir viele Debugger für Lua, die von verschiedenen Entwicklern erstellt wurden, von denen viele Open Source sind.

Die in der Lua-Debug-Bibliothek verfügbaren Funktionen sind in der folgenden Tabelle zusammen mit ihren Verwendungszwecken aufgeführt.

Sr.Nr.	Methode & Zweck
1	debug() Aktiviert den interaktiven Debugging-Modus, der aktiv bleibt, bis wir nur noch cont in eine Zeile eingeben und die Eingabetaste drücken. Der Benutzer kann Variablen in diesem Modus mit anderen Funktionen überprüfen.
2	getfenv(object) Gibt die Umgebung des Objekts zurück.
3	gethook(optional thread) Gibt die aktuellen Hook-Einstellungen des Threads als drei Werte zurück - die aktuelle Hook-Funktion, die aktuelle Hook-Maske und die aktuelle Hook-Anzahl.
4	getinfo(optional thread, function or stack level, optional flag) Gibt eine Tabelle mit Informationen zu einer Funktion zurück. Sie können die Funktion direkt oder eine Zahl als Wert für die Funktion angeben. Dies bedeutet, dass die Funktion, die auf der Ebenenfunktion des Aufrufstapels des angegebenen Threads ausgeführt wird - Ebene 0 ist die aktuelle Funktion (getinfo selbst). Level 1 ist die Funktion, die getinfo aufgerufen hat. und so weiter. Wenn die Funktion größer als die Anzahl der aktiven Funktionen ist, gibt getinfo null zurück.
5	getlocal(optional thread, stack level, local index) Gibt den Namen und den Wert der lokalen Variablen mit dem lokalen Index der Funktion auf der Ebene des Stapels zurück. Gibt null zurück, wenn der angegebene Index keine lokale Variable enthält, und löst einen Fehler aus, wenn eine Ebene außerhalb des Bereichs aufgerufen wird.
6	getmetatable(value) Gibt die Metatabelle des angegebenen Objekts oder Null zurück, wenn keine Metatabelle vorhanden ist.
7	getregistry() Gibt die Registrierungstabelle zurück, eine vordefinierte Tabelle, die von jedem C-Code verwendet werden kann, um den zu speichernden Lua-Wert zu speichern.
8	getupvalue(function, upvalue index) Diese Funktion gibt den Namen und den Wert des Upvalue mit dem Index up der Funktion func zurück. Die Funktion gibt nil zurück, wenn der angegebene Index keinen Aufwert aufweist.
9	setfenv(function or thread or userdata, environment table) Legt die Umgebung des angegebenen Objekts auf die angegebene Tabelle fest. Gibt das Objekt zurück.
10	sethook(optional thread, hook function, hook mask string with "c" and/or "r" and/or "l", optional instruction count) Legt die angegebene Funktion als Hook fest. Die String-Maske und die Anzahl der Nummern beschreiben, wann der Hook aufgerufen wird. Hier werden c, r und l jedes Mal aufgerufen, wenn Lua jede Codezeile in einer Funktion aufruft, zurückgibt und eingibt.
11	setlocal(optional thread, stack level, local index, value) Weist den Wert der lokalen Variablen mit dem Index local der Funktion auf Stapelebene zu. Die Funktion gibt nil zurück, wenn es keine lokale Variable mit dem angegebenen Index gibt, und löst einen Fehler aus, wenn sie mit einer Ebene außerhalb des Bereichs aufgerufen wird. Andernfalls wird der Name der lokalen Variablen zurückgegeben.
12	setmetatable(value, metatable) Legt die Metatabelle für das angegebene Objekt auf die angegebene Tabelle fest (die Null sein kann).
13	setupvalue(function, upvalue index, value) Diese Funktion weist den Wert dem Aufwärtswert mit dem Index der Funktionsfunktion zu. Die Funktion gibt nil zurück, wenn der angegebene Index keinen Aufwert aufweist. Andernfalls wird der Name des Upvalue zurückgegeben.
14	traceback(optional thread, optional message string, optional level argument) Erstellt eine erweiterte Fehlermeldung mit einem Traceback.

Die obige Liste ist die vollständige Liste der Debug-Funktionen in Lua. Wir verwenden häufig eine Bibliothek, die die oben genannten Funktionen verwendet und das Debuggen erleichtert. Die Verwendung dieser Funktionen und das Erstellen eines eigenen Debuggers ist recht kompliziert und nicht vorzuziehen. Wie auch immer, wir werden ein Beispiel für die einfache Verwendung von Debugging-Funktionen sehen.

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

   return 10
end

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

Wenn wir das obige Programm ausführen, erhalten wir den Stack-Trace wie unten gezeigt.

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

Im obigen Beispielprogramm wird der Stack-Trace mithilfe der in der Debug-Bibliothek verfügbaren Funktion debug.trace gedruckt. Die debug.getinfo ruft die aktuelle Tabelle der Funktion ab.

Debugging - Beispiel

Wir müssen oft die lokalen Variablen einer Funktion zum Debuggen kennen. Zu diesem Zweck können wir getupvalue verwenden und um diese lokalen Variablen festzulegen, verwenden wir setupvalue. Ein einfaches Beispiel hierfür ist unten dargestellt.

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

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

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

In diesem Beispiel wird der Zähler bei jedem Aufruf um eins aktualisiert. Mit der Funktion getupvalue können wir den aktuellen Status der lokalen Variablen anzeigen. Wir setzen dann die lokale Variable auf einen neuen Wert. Hier ist n 2, bevor die eingestellte Operation aufgerufen wird. Mit der Setupvalue-Funktion wird sie auf 10 aktualisiert. Wenn wir nun die Zählerfunktion aufrufen, wird 11 anstelle von 3 zurückgegeben.

Debugging-Typen

• Befehlszeilen-Debugging
• Grafisches Debuggen

Befehlszeilen-Debugging

Das Befehlszeilen-Debugging ist die Art des Debuggens, bei der die Befehlszeile zum Debuggen mithilfe von Befehlen und Druckanweisungen verwendet wird. Es gibt viele Befehlszeilen-Debugger für Lua, von denen einige unten aufgeführt sind.

• RemDebug- RemDebug ist ein Remote-Debugger für Lua 5.0 und 5.1. Sie können damit die Ausführung eines anderen Lua-Programms fernsteuern, Haltepunkte setzen und den aktuellen Status des Programms überprüfen. RemDebug kann auch CGILua-Skripte debuggen.

• clidebugger- Ein einfacher Debugger für die Befehlszeilenschnittstelle für Lua 5.1, geschrieben in reinem Lua. Es ist von nichts anderem als den Standard-Lua 5.1-Bibliotheken abhängig. Es wurde von RemDebug inspiriert, verfügt jedoch nicht über Remote-Einrichtungen.

• ctrace - Ein Tool zum Verfolgen von Lua-API-Aufrufen.

• xdbLua - Ein einfacher Lua-Befehlszeilen-Debugger für die Windows-Plattform.

• LuaInterface - Debugger- Dieses Projekt ist eine Debugger-Erweiterung für LuaInterface. Dadurch wird die integrierte Lua-Debug-Oberfläche auf ein höheres Niveau angehoben. Die Interaktion mit dem Debugger erfolgt über Ereignisse und Methodenaufrufe.

• Rldb- Dies ist ein Remote-Lua-Debugger über Socket, der sowohl unter Windows als auch unter Linux verfügbar ist. Es kann Ihnen viel mehr Funktionen bieten als alle vorhandenen.

• ModDebug - Auf diese Weise können Sie die Ausführung eines anderen Lua-Programms fernsteuern, Haltepunkte setzen und den aktuellen Status des Programms überprüfen.

Grafisches Debuggen

Das grafische Debuggen ist mithilfe der IDE möglich, mit der Sie verschiedene Zustände wie Variablenwerte, Stapelverfolgung und andere verwandte Informationen visuell debuggen können. Es gibt eine visuelle Darstellung und schrittweise Steuerung der Ausführung mit Hilfe von Haltepunkten, Step-In, Step-Over und anderen Schaltflächen in der IDE.

Es gibt eine Reihe von grafischen Debuggern für Lua, darunter die folgenden.

• SciTE - Die Standard-Windows-IDE für Lua bietet mehrere Debugging-Funktionen wie Haltepunkte, Schritt, Schritt in, Schritt über, Variablen überwachen und so weiter.

• Decoda - Dies ist ein grafischer Debugger mit Remote-Debugging-Unterstützung.

• ZeroBrane Studio- Lua IDE mit integriertem Remote-Debugger, Stapelansicht, Überwachungsansicht, Remote-Konsole, statischem Analysator und mehr. Funktioniert mit LuaJIT-, Love2d-, Moai- und anderen Lua-Motoren. Windows, OSX und Linux. Open Source.

• akdebugger - Debugger und Editor Lua Plugin für Eclipse.

• luaedit - Dies umfasst Remote-Debugging, lokales Debugging, Syntaxhervorhebung, Liste der Abschlussvorschläge, Parameter-Proposition-Engine, erweiterte Haltepunktverwaltung (einschließlich Bedingungssystem für Haltepunkte und Trefferanzahl), Funktionsliste, globale und lokale Variablenliste, Uhren, lösungsorientierte Verwaltung.