Arbeitsgruppe Programmiersprachen und Übersetzerkonstruktion Institut für Informatik Christian-Albrechts-Universität zu Kiel. Seminararbeit. Lua 5.

Transkript

1 Arbeitsgruppe Programmiersprachen und Übersetzerkonstruktion Institut für Informatik Christian-Albrechts-Universität zu Kiel Seminararbeit Lua 5.2 eine Multiparadigma Skriptsprache Niels Matthiessen WS 2012/2013 Betreuer: Fabian Reck

2 Inhaltsverzeichnis 1. Einführung Geschichte der Sprache Entwicklung Paradigma Anwungsgebiet Wofür ist die Sprache beabsichtigt? Wofür wird die Sprache genutzt? Konzepte und Struktur Sprachbeschreibung Funktionen Tabellen Virtuelle Maschine C API Error handling Coroutinen Konzepte anhand von Beispielen Umgebungen Module Metatabellen Objektorientierte Programmierung Lua als funktionale Sprache C API Technische Unterstützung Compiler, Interpreter, Entwicklungsumgebung Werkzeuge und Bibliotheken Portabilität Diskussion und Zusammenfassung Vergleichbare Sprachen Fazit A. Einführung in die Syntax von Lua 21 ii

3 1. Einführung Die Sprache Lua wird seit dem Jahr 1993 an der PUC-Rio, einer Universität in Rio de Jainero, Brasilien, entwickelt. Sie ist die einzige Programmiersprache aus einem Entwicklungsland, die internationale Bedeutung erlangt hat [1, Kap. 1] Geschichte der Sprache Die Notwigkeit, die Sprache Lua zu entwickeln enstand aus einer sehr restriktiven Gesetzgebung in Brasilien, die den Import von Computerhardware und -software einschränkte, mit der Begründung, dass das Land selbst dazu in der Lage sein müsse und es auch sei, diese zu produzieren. Außerdem fanden die Entwickler zum damaligen Zeitpunkt keine Sprache, die ihren Ansprüchen genügte. Lua bildet die Nachfolge der Konfigurationssprache SOL (Simple Object Language), die zur Erstellung von Berichten aus Analysedaten benutzt wurde, aber nicht mehr ausreich für sich ändernde Ansprüche der Benutzer war und erweitert werden musste. Daraufhin wurde das Lua-Team gegründet, das sich seitdem mit der Entwicklung der Sprache befasst. Dieses Team besteht aus den drei Mitgliedern Roberto Ierusalimschy, Luiz Henrique de Figueiredo und Waldemar Celes [1, Kap. 3]. Seit der Version 1.0 aus 1993 hat sich vieles geändert, jedoch nimmt die Häufigkeit der Änderungen ab, man kann sagen, die Sprache hat ihre Kinderkrankheiten überwunden, so wurde die Version 5.0 bereits im Jahr 2003 veröffentlicht. Die aktuelle Version der Sprache ist 5.2.1, vom 14. Juni Auch wenn sich das Aussehen der Sprache und ihre Anwungsgebiete nicht stark geändert haben so hat sich in ihrem Inneren viel verändert. Lua wurde mit jeder Veröffentlichung um mindestens ein Feature erweitert. Einige Konzepte wurden von einer Version zur nächsten komplett überdacht und neuentwickelt [1, Kap. 5] Entwicklung Obwohl die Sprache OpenSource ist und frei verwet werden kann, wird sie nicht wie oft üblich von einer Community entwickelt. Jede Änderung wird von den drei Entwicklern ausgeführt. Das bedeutet aber nicht, dass Lua über keine aktive Community verfügt, die die Entwicklung durch Wünsche und Anregungen vorantreibt, es wird dennoch kein Code aus der Community übernommen, sondern jede Änderung vom Team selbst geschrieben. Viele Anforderungen an die Sprachen kommen auch direkt aus der Industrie, die Lua einsetzt. Durch diese Art der Entwicklung ist die Größe der Sprache, sowohl anhand der Anzahl ihrer vorgefertigten Werkzeuge, als auch der Größe des Codes, sehr klein geblieben. Aber ihre Werkzeuge sind mächtig und wohldurchdacht. 1

4 1. Einführung Eine Besonderheit von Lua ist, dass die einzelnen Versionen nicht zwing abwärtskompatibel sind. Das gibt den Entwicklern die Möglichkeit trotz grundleger Änderungen die Größe der Sprache minimal zu halten [1, Kap. 5]. Bei der Entwicklung wird auf einige Punkte sehr großen Wert gelegt. Mit der Einhaltung dieser selbst gesetzten Qualitätsstandards wir oft auch der Erfolg der Sprache begründet. 1. Effizienz: Die Sprache soll mit einer einfachen Syntax und einer geringen Menge von Programmstrukturen auskommen und dadurch eine möglichst schnelle Compilierund Ausführungsdauer erreichen. 2. Portabilität: Lua soll auf jeglicher Art von Hard- und Software ohne Anpassung des Codes lauffähig sein. Dies gilt sowohl für Lua-Programme, als auch für den Lua-Interpreter. 3. Einbindbarkeit: Ein großes Ziel von Lua ist es, möglichst einfach in andere Programme integrierbar zu sein. Dafür muss die API (application programming interface) klar definiert sein und eine effiziente Kommunikation zwischen Lua und dem Host-Programm ermöglichen. Die Portabilität wird dadurch erreicht, dass der Lua-Interpreter in striktem ANSI-C programmiert ist. Dadurch ist gewährleistet, dass dieser auf nahezu allen Plattformen ohne Anpassung kompiliert. Da in der Regel für neue Hardware C Compiler als erstes entwickelt werden, wird Lua auf dieser sehr früh unterstützt [2, Kap. 2] Paradigma Es ist nicht leicht Lua einem festen Programmierparadigma zuzuordnen. In der Literatur wird Lua oft als Multiparadigma Sprache bezeichnet [3], was aber keine sehr konkrete Aussage ist, außerdem werden einige Paradigmen nicht direkt unterstützt, sondern sind nur durch die Erweiterbarkeit der Sprache leicht zu implementieren. Diese Paradigmen werden Lua aber im Allgemeinen ebenfalls zugeschrieben. Lua ist primär eine prozedurale Programmiersprache und wird auch überwieg als solche genutzt. Sie erfüllt aber auch alle Kriterien der funktionalen Programmierung. Desweiteren ist sie eine Scriptsprache, kann aber auch mit einem Compiler zu Objekt- Code compiliert werden. Die zentrale Datenstruktur in Lua ist ein assoziatives Array, die sogenannte table, über die weitere Paradigmen leicht zu realisieren sind. So werden Module in der Regel über eine Verschachtelung dieser Tabellen dargestellt, worüber auf die Modulfunktionen zugegriffen werden kann. Auch Klassen und Objekte können über Tabellen dargestellt werden, womit es möglich ist, Vererbung per Delegation und Überladung von Funktionen und Variablen zu realisieren. 2

5 2. Anwungsgebiet Die Sprache Lua wird in allen erdenklichen Anwungen für Skriptsprachen benutzt. Die Nutzung beginnt als einfache Konfigurationsdatei, ähnlich wie.ini Dateien aber mit erweiterten Möglichkeiten, die auch der Verhaltenssteuerung in der Robotik, oder in der Webentwicklung als CGI-Skript genügen. Es gibt ebenfalls ganze Programme wie Webserver oder Texteditoren, die in Lua geschrieben sind. Besondere Beliebtheit hat die Sprache in der Spieleentwicklung gewonnen, wo sie zu der meistbenutzten Skriptsprache geworden ist [4] Wofür ist die Sprache beabsichtigt? Lua ersetzte nach ihrer Entwicklung vorerst zwei andere Programmiersprachen die an der PUC genutzt wurden. Die erste Sprache DEL (data-entry language) wurde dazu benutzt, Eingabedateien für andere Programme zu erzeugen. DEL war als sehr einfache, deklarative Sprache konzipiert. Mit Lua war es möglich, Kontrollstrukturen zu benutzen, was die Komplexität der erzeugten Eingabedateien und damit deren Möglichkeiten stark erhöhte. Die zweite Sprache ist die bereits angesprochene SOL. Dieser fehlte es an Unterstützung für prozedurale Programmierung, die für Erweiterungen von zu erstellen Berichtdateien benötigt wurde. Bereits am Anfang der Entwicklung von Lua war klar, dass diese Sprache mehr Potential haben sollte, als SOL und DEL zu ersetzen. Es wurde immer mit dem Blick auf Portabilität, Erweiterbarkeit, kleine Programmgröße und Effizienz entwickelt. Damit sollte sichergestellt werden, dass Lua auch für spätere Projekte ausreich ist [1, Kap. 3]. Von Beginn der Entwicklung wurde auf einige Punkte besonderer Wert gelegt. Lua sollte grundleg einfach zu programmieren sein, denn da sie zuerst vor allem als Konfigurationssprache gedacht war, sollte sie auch von Personen genutzt werden können, die keine Erfahrung im Programmieren haben. Außerdem sollte auch die Umgewöhnung von anderen Sprachen möglichst einfach sein, so kann man unter anderem einen Ausdruck mit einem Semikolon abschließen, wie es beispielsweise in C notwig ist, muss es aber nicht, wie es unter anderem in Fortran gemacht wird [5, Kap. 1.1] Wofür wird die Sprache genutzt? Dem Potential, das Lua letztlich entwickelte, war sich 1993 keiner der Entwickler bewusst. Lua wird innerhalb der PUC heute noch für die Zwecke genutzt, für die sie anfangs entwickelt wurde. Abgesehen davon ist sie fester Bestandteil in großen internationalen Projekten geworden. Durch die Lizenzierung der Sprache mit der MIT-Lizenz 3

6 2. Anwungsgebiet ist es möglich, sie auch in kommerziellen Projekten zu verwen. Beispiele: 1. In Adobe Photoshop Lightroom wird Lua zur Bildbearbeitung und für add-ins eingesetzt. Dadurch ist es dem Benutzer möglich, Skripte zu schreiben und damit das Programm den eigenen speziellen Bedürfnissen anzupassen. 2. Die CryEngine 3 vom deutschen Spielehersteller Crytec benutzt Lua als Skripsprache zur Steuerung der KI und zur Erzeugung von Ereignissen innerhalb des Spielgeschehens. 3. In dem Computerspiel World of Warcraft wird ebenfalls Lua als Skriptsprache verwet. Damit wird es dem Benutzer ermöglicht, sein User Interface frei nach seinen Vorstellungen anzupassen. 4. Xavante ist ein Webserver für HTTP 1.1 der komplett in Lua geschrieben und damit sehr leicht portabel ist, er kann auch als Bibliothek in andere Luaprogramme eingebunden werden. 5. Aber auch die Schadsoftware Flame, die 2012 von Kaspersky Lab auf Rechnern mehrerer Staaten in Nahost entdeckt wurde, benutzt Lua, um unkompliziert effektive Angriffe auszuführen[6]. 4

7 Im Anhang befindet sich eine kurze Einführung in die Syntax von Lua. Diese ist lediglich als Zusammenfassung gedacht und ihr Inhalt wird in diesem Kapitel nicht vorrausgesetzt. Innerhalb des Beispielcodes sind Kommentare, wie in Lua üblich, mit -- gekennzeichnet. Mit --> sind die Ausgaben der Programmzeile gemeint Sprachbeschreibung Lua besitzt die acht verschiedene Datentypen nil, boolean, number, table, string, function, thread und userdata. Dabei ist Lua eine dynamisch getypte Sprache, das bedeutet, dass nicht die Variablen Typen haben, sondern nur die Werte. Der Typ nil besitz nur den Wert nil und ist vergleichbar mit dem Nullpointer in C, er zeigt an, dass keine Daten vorliegen. Als boolean gibt es true und false, wobei in boolschen Ausdrücken nil äquivalent zu false und alles andere äquivalent zu true ist. Zahlen (number) werden als 64 Bit Fließkommazahlen abgespeichert, einen Datentyp vergleichbar zu integer gibt es nicht. Bei der Nutzung von Lua wird ein integer Typ auch nicht benötigt, denn es können alle ganzen Zahlen bis ±2 53 als number exakt dargestellt werden. Die meisten heutigen Systeme bieten eine Hardware Floatingpoint Unterstützung, sodass das Rechnen mit diese genauso schnell abläuft wie mit integern. Der zentrale Datentyp in Lua in die table. Diese ist ein Assoziatives Array, über das sich alle herkömmlichen Datentypen, wie Listen, Objekte, Module oder Strukturen darstellen lassen. Anders als in C ist ein string kein Array von characters, sondern ein abstrakter Datentyp, auf den nur über entspreche String-Funktionen zugegriffen wird. Beim Bearbeiten eines strings wird ein neuer Wert mit entsprechem Inhalt erstellt. Ein string darf anders als in vielen Sprachen beliebige Bytes enthalten. Ein Null-Byte beispielsweise gibt nicht das Ende des strings an, sondern darf im Text vorkommen. Da Funktionen auch Werte erster Klasse sind und in Variablen gespeichert werden, gibt es auch den Datentyp function, den man mit einer Liste von Argumenten aufrufen kann und entspreche Rückgabewerte erhält. Zur parallelen Ausführung von Programmcode verfügt Lua über threads. Dabei handelt es sich aber um eine Lua-eigene Implementierung von Nebenläufigkeit und nicht um Threads des Betriebssystems. Für vorerst unbekannte Daten, wie structs aus C, die von Lua verarbeitet werden sollen, gibt es den Datentyp userdata dessen Inhalt nicht spezifiziert ist. In Lua gibt es keine explizite Deklaration von Variablen. Um eine Variable nutzen zu 5

8 können, muss man ihr lediglich einen Wert zuweisen, die Speicherallozierung wird automatisch durchgeführt. Variablennamen dürfen aus Buchstaben, Ziffern und Unterstrichen bestehen, wobei das erste Zeichen keine Ziffer sein darf. Wird eine Variable genutzt, bevor ihr ein Wert zugewiesen wurde, hat sie den Wert nil. Zuweisungen werden mit dem = Operator durchgeführt. In Lua sind auch Mehrfachzuweisungen möglich, außerdem können Funktionen mehrere Rückgabewerte haben. a = 1 a, b = 1, 2 -- a = 1 und b = 2 a, b = b, a -- tauschen der Werte von a und b a, b = 1 -- a = 1 und b uninitalisiert a, b = 1, 2, 3 -- a = 1, b = 2 und die 3 geht verloren -- Funktion mit mehreren Rückgabewerten, a = 3 und b = 4 a, b = (function () return 3, 4 )() Variablen die mit zwei Unterstrichen oder einem Unterstrich und einem Großbuchstaben beginnen, sind von Lua für bestimmte Zwecke reserviert und sollten nicht anderweitig genutzt werden. Ein Beispiel dafür ist die Tabelle G, in ihr sind alle globalen Variablen hinterlegt. Beim Überschreiben von G wird also der Zugriff auf alle globalen Variablen, also auch die Standardbibliotheken unmöglich. Um nicht mehr referenzierte Daten kümmert sich Lua selbst mit einer Garbage Collection. Es ist nicht möglich, Speicher manuell wieder freizugeben, jedoch kann man Einfluss auf die Ausführung der Garbage Collection nehmen. [7] Funktionen Eine Funktion wird durch den Funktionskonstruktor erstellt und die erstellte Funktion wird von diesem zurückgegeben. Es ist auch möglich, Funktionen so zu definieren, wie man es aus anderen Sprachen wie Java oder C gewohnt ist. function() add1 = function(value) return value + 1 function add1(value) return value einfacher Funktionskonstruktor -- normale Funktionsdefinition -- äquavalent zur vorherigen Definition Funktionen in Lua erinnern sehr stark an Funktionen aus der funktionalen Programmierung. Da die Funktionsnamen Variablen sind, kann man Funktionen auch als Parameter oder Rückgabewert übergeben. Dadurch ist es auch insbesondere möglich Funktionen zu überschreiben. Wir können beispielsweise die standard print Funktion durch eine selbst erstellte ersetzen. print = function(str) print("lua says: ", str) 6

9 Funktionen können auch währ der Programmausführung erzeugt werden, dabei werden closures genutzt. Das bedeutet, dass der Wert lokaler Variablen aus dem Kontext der Funtionserstellung übernommen wird, auch wenn diese zum Zeitpunkt der Funktionsausführung nicht mehr existieren. Diese Prizip ist auch unter dem Begriff lexical scoping bekannt. Beim Aufruf einer Funktion muss die Anzahl der Parameter nicht mit denen in der Funktionsdefinition übereinstimmen. Wird die Funktion mit zu wenig Parametern aufgerufen, werden die restlichen mit nil aufgefüllt. Beim Aufruf mit zu vielen Parametern werden die überflüssigen nicht beachtet. Die Rückgabe einer Funktion ist nicht, wie bei vielen anderen Sprachen üblich, auf einen Wert beschränkt, sondern kann beliebig viele Werte beinhalten. Dafür werden Zuweisungen mit mehreren Variablen unterstützt. Lua unterstützt ebenfalls proper tail calls. Das bewirkt, zum Beispiel bei einer Rekursion, wenn der Aufruf der nächsten Rekursionsebene die letzte Anweisung in der Funktion ist und die Funktion das Ergebnis der weiteren Rekursion zurückgibt, dass das Rekursionsergebnis nicht durch alle Rekursionsebenen durchgereicht, sondern direkt zurückgegeben wird Tabellen Eine Tabelle ist in Lua ein assoziatives Array, das bedeutet, es besteht aus Schlüssel-Wert Paaren. Der Tabellenkonstruktor ist ein Paar geschweifter Klammern. In diesem können mit Kommas getrennte Schlüssel-Wert Paare übergeben werden. Es ist nicht notwig, einen Schlüssel anzugeben. Werte, die ohne Schlüssel in eine Tabelle geschrieben werden, bekommen automatisch als Schlüssel eine noch nicht vergebene natürliche Zahl, begonnen mit eins, zugewiesen. Als Schlüssel und Wert eines Eintrags sind alle Datentypen außer nil erlaubt. Die Angabe der Schlüssel innerhalb des Konstruktors und der Zugriff auf eine Tabelle erfolgen, wie man es aus anderen Sprachen von Arrays gewonht ist. Eine Besonderheit gilt hier für Schlüssel, die den oben genannten Kriterien von Variablennamen entsprechen. Auf diese kann auch per Punktnotation zugegriffen werden und im Tabellenkonstruktor wird die Arrayschreibweise nicht benötig. tabelle = {} -- leere Tabelle tabelle = {key = "value", ["Schlüssel"] = "Wert"} print(tabelle.key, tabelle["schlüssel"]) --> value Wert tabelle = {"Montag", "Dienstag"} print(tabelle[0], tabelle[1], tabelle[2]) --> nil Montag Dienstag Die table ist die zentrale und auch die einzige Datenstruktur in Lua, sie wird zu jeglicher Strukturierung der Programmdaten genutzt. Die interne Implementierung von tables passt die Art der Speicherung an die Daten an, die in der Tabelle liegen. Nutzt man die Tabelle lediglich als Array, so werden die Daten intern so abgelegt, dass die Zugriffszeit, wie bei einem Array, konstant ist. Bei der Nutzung von Strings als Schlüssel, erfolgt der interne Zugriff auf die Werte über Hashtables, sodass die Zugriffszeit ebenfalls gering gehalten wird. Mit Tabellen sind beispielsweise die Module in Lua realisiert. So greift der Befehl io.write("hello World!") auf die Funktion write() über die Tabelle io 7

10 zu, in welcher sich das Modul für die System Ein- und Ausgaben befindet Virtuelle Maschine Die Ausführung von Lua erfolgt auf einer virtuellen Maschine. Daten, welche die Lua Virtual Machine verarbeitet, werden chunks genannt. Ein chunk ist eine Menge von Anweisungen, die auf einmal eingelesen werden. Wird eine Datei mit Lua Sourcecode in ein Lua Programm geladen, so handelt es sich bei dem Inhalt der Datei um einen chunk. Ebenso ist eine Zeile, die man in den Standalone-Interpreter eingibt ein chunk. Zur Verabeitung der chunks werden zuerst die Anweisungen in opcode für die virtuelle Maschine übersetzt und anschließ werden diese ausgeführt. Der opcode ist eine eigene Sprache die sich durch einen Assemblercode darstellen lassen kann. Es gibt 35 Befehle, an die jeweils noch Registeradressen angefügt werden, sodass ein opcode Befehl immer 32 Bit lang ist. Die virtuelle Maschine von Lua ist registerbasiert, im Gegensatz zu den virtuellen Maschinen der meisten anderen Sprachen, die stackbasiert arbeiten. Bei einer stackbasierten virtuellen Maschine werden für die Ausführung eines Befehls alle benötigten Parameter auf den Stack gelegt, dann wird der Befehl ausgeführt, der die Argumente vom Stack liest und das Ergebnis ebenfalls wieder auf den Stack legt. So werden bei einer stackbasierten virtuellen Maschine für eine Addition drei Befehle benötig, zwei um die Werte auf den Stack zu legen und einen um die Addition auszuführen. Eine registerbasierte virtuellen Maschine arbeitet anstatt mit dem Stack mit Registern. Dadurch werden theoretisch anstatt der drei Befehle nur einer benötig um zwei Zahlen zu addieren. Nur theoretisch deshalb, weil die Werte natürlich auch zuerst in die Register geschrieben werden müssen. Es wird jedoch davon ausgegangen, dass mit einem Wert mehr als eine Operation stattfindet, sodass das Laden in das Register vernachlässigt werden kann. Die Vorteile einer registerbasierten virtuellen Maschine ergeben sich daraus, dass durch die geringere Anzahl an Befehlen, die Größe des opcodes sinkt und die Geschwindigkeit der Ausführung steigt. Diese Vorteile sind aber stark umstritten, da bei stackbasierten virtuellen Maschine die Größe der Befehle meist nur 16 oder 8 Bit beträgt und die Dauer der Ausführung eines registerbasierten Befehls unter Umständen länger dauert, als die eines stackbasierten Befehls. Somit ist der Vorteil der Register anwungsabhängig und kann nicht pauschal als dem Stack überlegen bewertet werden. Lua arbeitete vor der Version 5.0 selbst auch mit einer stackbasierten virtuellen Maschine. Im dierekten Vergleich überzeugte die Entwickler dann aber die registerbasierte virtuellen Maschine mit der sie bei einigen Tests die Laufzeit auf bis zu 44% verringern konnten. [2] C API Auch wenn man Lua Skripte im Standaloneinterpreter ausführen kann, ist Lua vor allem dafür konzipiert, als embedded language genutzt zu werden. Dafür ist die Sprache in C geschrieben und kann als Bibliotek in ein C-Programm eingebunden werden. 8

11 Zum Ausführen von Lua Code muss ein lua State erstellt werden, innerhalb dessen die Ausführung von Lua stattfindet. Um die Ausführung von Lua Code zu starten kann man beispielsweise diese Funktion nutzen: int lual dostring(lua State *L, const char *str); Sie interpretiert den String str als Lua Code und führt ihn in dem lua State L aus. In dem lua State ist der Zustand der Ausführung, also alle Variablen, Funktionen, etc. gespeichert. Zur Kommunikation zwischen dem C Teil und dem Lua Teil des Programms gibt es die C API. Diese ermöglicht es vom C Programm auf einen lua State zuzugreifen. Zur Kommunikation zwischen den beiden Teilen wird ein virtueller Stack genutzt. Von C aus ist es möglich Daten auf den Stack zu legen, Daten vom Stack und Variablen aus Lua auszulesen und Funktionen aus Lua auszuführen. Auf dem Stack kann C alles ablegen, womit es arbeiten kann, so können auch Funktionen an Lua übergeben werden. Durch diese Funktionen ist es dann ebenfalls möglich von Lua aus auf den C Teil des Programms zuzugreifen. Für Daten mit denen Lua selbst nichts anfangen kann, wie ein in C selbst erstelltes struct, gibt es in Lua den Datentyp userdata. Dahinter können sich beliebige Daten befinden. Um mit Lua auf diesen Daten arbeiten zu können, müssen die entsprechen Bearbeitungsfunktionen von C aus bereitgestellt werden. Es ist beispielsweise leicht möglich mit diesen Verfahren Lua zur Erstellung von Plugins zu nutzen. Angenommen wir programmieren in C einen Texteditor, den wir mit Lua erweiterbar machen möchten. Es soll mit Lua im speziellen möglich sein, dem Texteditor eine Tastenkombination hinzuzufügen, mit der in einem markierten Text alle Großbuchstaben in Kleinbuchstaben geändert werden. Im C Teil des Programms benötigen wir dafür drei Funktionen, die von Lua aus aufgerufen werden können. Die ersten beiden Funktionen müssen es ermöglichen den Inhalt des im Editor markierten Textes zu lesen und zu schreiben. Mit der dritten Funktion muss es möglich sein auf das Event einer Tastenkombination, die Ausführung einer Lua Funktion zu registrieren. In der Lua Datei wird eine Funktion benötig, die über die C Funktionen den Inhalt des markierten Textes liest, die Änderung durchführt und den geänderten String zurück schreibt. Außerdem benötigen wir von Lua aus einen Aufruf der dritten C Funktion, der die Lua Funktion auf die gewünschte Tastenkombination registriert. Nach dem Ausführen der Lua Datei von C aus ist es sofort möglich die Tastenkombination zu benutzen Error handling In Lua ist es möglich, beim Auftreten eines Laufzeitfehlers eine Exception zu werfen. Diese bewirkt, dass die Ausführung des chunk unterbrochen wird und in das Hostprogramm zurückgesprungen wird. Dann gibt die lual dostring() Funktion, mit der der chunk aufgerufen wurde, false zurück und auf dem Stack der C API liegt der Errorstring der Exception. Die entspreche Fehlerbehandlung muss dann vom Hostprogramm durchgeführt werden. Bei einem Großteil der auftreten Fehler ist es aber gar nicht erwünscht dass die Ausführung komplett unterbrochen wird, sondern es soll innerhalb von Lua auf die Exception reagiert werden. Dafür steht die pcall() Funktion 9

12 zur Verfügung. Mit ihr kann eine Funktion im protected mode ausgeführt werden und sie fängt alle bei der Ausführung entstandenen Exceptions, ohne die Ausführung von Lua zu unterbrechen. Obwohl es die pcall() Funktion gibt, werden in der Praxis Exceptions oft nur dafür eingesetzt, die Ausführung zu been. Wenn ein Fehler aufgetreten ist, auf den innerhalb von Lua reagiert werden soll, wird in der Regel die Funktion, in der der Fehler entstanden ist, über das return einen Errorcode zurückgeben, zum Beispiel als ersten Rückgabewert nil und als weitere Rückgabewerte einen Errorstring, oder eine Tabelle mit weiteren Informationen über den aufgetretenen Fehler, auf den die aufrufe Funktion entsprech reagieren kann Coroutinen In Lua wird kein echtes Multitasking, also das gleichzeitige Ausführen von Anweisungen, unterstützt. Das liegt ganz einfach daran, dass dieses von ANSI-C nicht zur Verfügung gestellt wird. Die Datenstruktur thread steht für einen Ausführungsfaden, wie man es auch von POSIX threads gewohnt ist. Dazu verfügt jeder thread über einen eigenen Program Counter. Der Programmablauf mit Coroutinen funktioniert ähnlich zu dem Prinzip des Monitors. Es gibt nur einen thread der zur Zeit ausführen darf, alle anderen threads warten darauf, dass ihnen signalisiert wird, dass sie ausführen dürfen. Jedoch erfolgt das Warten und Signalisieren anders als im Monitor. Es gibt keine Warteschlangen, sondern der aktuelle thread entscheidet, welcher thread als nächstes ausführen darf. Dazu stehen die Funktionen coroutine.yield(...) zum Warten und coroutine.resume(thread,...) zum Aufwecken eines threads zur Verfügung. Dabei ist es möglich über diese Funktionen auch Werte an die aufgerufene, oder aufrufe Funktion zu sen. Das yield() gibt die Parameter des resume() zurück und andersherum. Echtes Multitasking muss vom Hostprogramm bereitgestellt werden. Dazu muss das Hostprogramm über mehrere lua States verfügen und diese jeweils in einem eigenen POSIX thread laufen lassen. Diese Situation ist dann vergleichbar mit UNIX Prozessen. Sie haben die Möglichkeit, gleichzeitig zu laufen und arbeiten jeweis auf ihrem eigenen Speicher. Für die Kommunikation zwischen den lua States ist das Hostprogramm zuständig, das entspreche Funktionen zu Verfügung stellen muss, die von Lua aus genutzt werden können. Beim Arbeiten mit mehreren POSIX threads muss darauf geachtet werden, dass nicht von mehreren gleichzeitig auf einen lua State zugegriffen wird. Da im lua State unter anderem der aktuelle Program Counter und die Position der Register im Arbeitsspeicher gespeichert sind, würde das Ausführen mehrerer Funktionen, die gleichzeitig auf diesen zugreifen, zu undefiniertem Verhalten führen Konzepte anhand von Beispielen Umgebungen In Lua werden drei Arten von Variablen unterschieden. Diese sind globale, lokale und nicht-lokale Variablen. Bei der Definition von Variablen muss man darauf achten, dass alle Variablen, die nicht anders gekennzeichnet werden, global definiert sind. Jedoch be- 10

13 deutet in Lua global etwas anderes, als man es aus anderen Sprachen gewohnt ist. Fangen wir damit an, was nicht-globale Variablen sind. Lokale Variablen sind, wie gewöhnlich, nur lokal sichtbar, also innerhalb der Funktion, Schleife oder dem Ausdruck in dem sie definiert sind. Dabei haben lokale Variablen die höchste Priorität beim Zugriff. Existieren also lokale und globale Variablen mit dem selben Namen, wird immer auf die lokale Variable zugegriffen. Zur Definition von lokalen Variablen steht das Schlüsselwort local zur Verfügung, außerdem sind Funktionsargumente immer lokal definiert. Nicht-lokale Variablen, oder auch upvalues genannt, sind Variablen, die in einem übergeordneten Closure als lokale Variablen definiert sind. fun = function(a) return function(b) b = b + a local a = 1 b = b + a return b print(fun(2)(3)) --> 6 -- b ist lokal, a ist upvalue -- erstellen eines lokalen a -- b und a sind lokal Kommen wir nun zu den globalen Variablen. Am Anfang dieses Kapitels wurde gesagt, die globalen Variablen stehen in der Tabelle G. Das ist jedoch so nicht unbedingt korrekt. Um das Ganze zu verstehen, betrachten wir an folgem Beispiel, was beim Interpretieren von Lua Code mit globalen Variablen geschieht. -- Ausgangsfunktion -- Funktion aus sicht des Interpreters fun = function() -- fun = function() a = b ENV[a] = ENV[b] Es gibt also eine Variable ENV über die auf globalen Variablen zugegriffen wird. Woher diese Variable kommt und was sie mit der Tabelle G zu tun hat, sieht man, wenn man sich anguckt, was beim Laden eines chunks passiert. Dafür gehen wir davon aus, dass beim Erstellen eines lua State in C, in Lua die Tabelle G erstellt wird. Aus dem folgen Code der Datei example.lua wird beim Lades der Datei beispielsweise in C mit dem Befehl lua loadfile() die folge Lua Funktion erstellt. 11

14 -- example.lua a = 5 -- rest vom Code funktion() local ENV = G -- example.lua ENV[a] = 5 -- rest vom Code Die vorhin bereits angesprochene Funktion lual dostring ist eine Kombination aus lua loadstring() (äquivalent zu lua loadfile() für Strings) und dem ausführen der Funktion. In der Tabelle G werden also alle globalen Variablen eines lua State gespeichert. Wir haben aber dadurch, dass der Zugriff auf G über die Variable ENV läuft, die Möglichkeit, eine neue globale Umgebung zu erstellen und sogar die globale Umgebung einer Funktion an eine andere zu übergeben Module Ein Modul wird in Lua durch eine Tabelle repräsentiert, in der die Funktionen des Moduls liegen. Um ein Modul in Lua zu laden gibt es die require Funktion. Diese funktioniert ähnlich der dofile Funktion, das heißt, sie läd die Datei als chunk und führt diesen aus. Jedoch hat require Besonderheiten. Die Funktion speichert ein geladenes Modul zwischen. Wenn also ein Modul mehrmals geladen wird, wird trotzdem nur einmal auf die Datei zugegriffen. Außerdem sucht die Funktion nach dem Modul nicht nur im aktuellen Verzeichnis, sondern sucht ebenfalls in den Standardbibliotheks Verzeichnissen des Betriebssystems. Die Standardmodule werden in der Regel beim Programmstart folgermaßen geladen string = require("string") io = require("io") -- und so weiter Beim Schreiben von Modulen erstellt man also eine Tabelle mit den Funktionen und gibt diese aus dem chunk zurück. M = {} M.foo = function() return dosomething() return M Das return außerhalb einer Funktion sieht auf den ersten Blick etwas ungewohnt aus, jedoch wird ein chunk beim Laden in Lua als Funktion dargestellt. Dadurch gibt die require Funktion beim Laden des Moduls die Tabelle M zurück. 12

15 Metatabellen Eine besondere Anwung der Tabelle ist die metatable. Diese ermöglicht es, ein bestimmtes Verhalten zu erzeugen. Dazu kann man einem Wert eine metatable zuweisen. Dabei ist es nur bei den Datentypen table und userdata möglich, dass jeder Wert eine eigene metatable besitzt, bei allen anderen Datentypen teilen sich diese jeweils alle Werte des Datentyps. In der metatable befinden sich Funktionen, die als metamethods bezeichnet werden. Diese Funktionen sind dafür gedacht allgemeine Operationen auf den jeweiligen Daten durchzuführen. Beispielweise kann man damit Operatoren überladen oder tostring Methoden definieren. Der Operator + ist für Tabellen nicht definiert. Wir können mit einer passen metatable den Operator so definieren, dass er zu jedem Element der Tabelle, das vom Typ number ist, einen bestimmten Wert hinzuaddiert. Dazu weisen wir dem Schlüssel add der metatable eine Funktion zu, welche die Tabelle und den Wert übergeben bekommt, und diesen auf jedes Element der Tabelle aufaddiert. numbers = {1, "a", 2} meta = { add = function(tab, adder) for k, v in pairs(tab) do if tonumber(v) then tab[k] = v + adder return tab } -- mache meta zur metatable von numbers setmetatable(numbers, meta) n = numbers erhöhe Zahlen in numbers um 3 print(numbers[1], numbers[2], numbers[3]) --> 4 a 5 Es ist nicht möglich, eigene Operatorzeichen zu definieren. Der Operator += der in dem obigen Beispiel passer gewesen wäre, um zu zeigen, dass die Operation Seiteneffekte erzeugt, ist in Lua nicht vorhanden und kann auch nicht definiert werden. Abgesehen von den Operatoren, bieten die metatables noch mehr Möglichkeiten. Der index Schlüssel der metatable beispielsweise, wird aufgerufen, wenn ein Zugriff auf einen nicht vorhandenen Schlüssel einer Tabelle stattfindet. Damit ist es zum Beispiel möglich einer Tabelle einen Standardwert zu geben. Hinter dem index Schlüssel muss keine Funktion liegen, sondern es kann auch eine Tabelle sein. Dann werden die entsprechen Schlüssel aus der hinterlegten Tabelle abgefragt. t = {12} -- t[1] = 12 meta = { index = function(tab, key) return 0 } setmetatable(t, meta) -- Funktion als Referenz print(t[0], t[1], t[2]) --> getmetatable(t). index = {1, 2} -- Tabelle als Referenz print(t[0], t[1], t[2]) --> nil

16 Objektorientierte Programmierung Die wichtigsten Konzepte von objektorientierten Sprachen sind Klassen, Objekte und Vererbung. Diese drei Konzepte stehen in Lua nicht zur Verfügung, sie können aber simuliert werden. Dazu benötigen wir metatables und den : Operator. Wir erstellen eine Klasse, indem wir deren Attribute und Methoden in eine Tabelle speichern. Da es sich bei einer so definierten Klasse genaugenommen selbst schon um eine Instanz handelt, spricht man hier von prototypenbasierter Objektorientierung. Um ein Objekt der Klasse zu erstellen erzeugen wir eine leere Tabelle mit einer metatable, deren Schlüssel index auf die Klasse verweist. Beim Zugriff auf die Methoden benötigen wir dann den : Operator. Dieser bewirkt, dass das Objekt, aus dem die Methode aufgerufen wird, an die Methode übergeben wird. So sind folge Zeilen Äquivalent: a.dosomething(a, args) a:dosomething(args) Wenn wir auf eine der Methoden, oder Attribute der Klasse zugreifen, die in der neu erstellten Tabelle nicht existieren, so werden über die metatable die entsprechen Werte der Klasse abgefragt. Wenn wir ein Attribut überschreiben, wird der neue Wert in dem Objekt gespeichert. Da das Attribut in dem Objekt besteht, wird beim Zugriff auf das Attribut nicht mehr der Wert aus der Klasse abgefragt. Ein einfaches Bankkonto lässt sich wie folgt Implementieren: BankAccount = {balance = 0, new = function(self) -- neues Konto erstellen local object = {} setmetatable(object, { index = self}) return object, deposit = function(self, amount) -- Geld abheben/einzahlen self.balance = self.balance + amount, getbalance = function(self) -- Kontostand abfragen return self.balance } Das Erstellen von und Arbeiten mit Objekten funktioniert dann ganz ähnlich, wie man es aus anderen objektorientierten Sprachen gewohnt ist. acc1 = BankAccount:new() acc2 = BankAccount:new() print(acc1:getbalance(), acc2:getbalance()) --> 0 0 acc1:deposit(100) print(acc1:getbalance(), acc2:getbalance()) -->

17 Eine Unterklasse zu erstellen, funktioniert aufgrund der prototypenbasierten Objektorientierung genauso, wie das Erstellen eines Objekts. Dadurch erbt die Unterklasse automatisch alles der Elternklasse. Um Weitere Attribute und Methoden zu der Unterklasse hinzuzufügen, müssen diese in der Tabelle der Unterklasse abgelegt werden, so können auch Methoden einfach überladen werden. Der hier erstellte SpecialAccount erhöht den Kontostand bei jeder Überweisung um 5, und bietet die Möglichkeit geklont zu werden. SpecialAccount = BankAccount:new() SpecialAccount.deposit = function(self, amount) self.balance = self.balance + amount + 5 SpecialAccount.clone = function(self) local clone = {balance = self:getbalance()} setmetatable(clone, getmetatable(self)) return clone acc3 = SpecialAccount:new() print(acc3:getbalance()) --> 0 acc3:deposit(100) acc4 = acc3:clone() print(acc3:getbalance(), acc4:getbalance()) --> acc3:deposit(100) print(acc3:getbalance(), acc4:getbalance()) --> Auch Mehrfachvererbung lässt sich so realisieren indem man die Metatables der Elternklassen zu einer zusammenfügt. Dazu benötigt man allerdings noch eine Funktion, die bei Vorkommen der gleichen Attribute oder Methoden entscheidet, welche ausgewählt werden soll Lua als funktionale Sprache Eine funktionale Sprache kommt ohne Listen nicht aus, diese sind in Lua recht einfach zu erzeugen. Ein Listenelement wird durch eine Tabelle mit den Schlüsseln value und rest dargestellt. Um das Hinzufügen eines Elements zu einer Liste komfortabel zu gestalten, können wir mit Hilfe der metatables den.. Operator der standardmäßig nur für die Stringkonkatenation genutzt wird, für diesen Zweck überladen. Der.. Operator wird über den Schlüssel concat angesporchen. meta = { concat = function(elem, list) result = {value = elem, rest = list} setmetatable(result, getmetatable(list)) return result } emptylist = {} setmetatable(emptylist, meta) 15

18 Da der Konkatenations-Operator von rechts nach links auswertet, funktioniert dieses auch mit Strings, obwohl der Operator auf diesen bereits definiert ist, ohne deren Funktionalität zu verändern. Die folgen beiden Anweisungen haben also unterschiedliche Bedeutung, da sie den Operator unterschiedlich nutzen. list = "hello".. "world".. emptylist list = ("hello".. "world").. emptylist -- Liste mit zwei Elementen -- Liste mit einem Element Mit diesem recht einfachen Konstrukt kann gearbeitet werden, wie man es von funktionalen Sprachen gewohnt ist. Dabei wird allerding nicht die Komfortabilität anderer funktionaler Sprachen, wie Haskell geboten, wo mit pattern matching oder unlichen Listen gerarbeitet werden kann. Eine einfache map Funktion lässt sich so implementieren. map = function(list, func) if list == emptylist then return emptylist else return func(list.value).. map(list.rest, func) list = emptylist add1 = function(x) return x + 1 list = map(list, add1) -- list = emptylist C API Die C API ermöglicht es Lua in andere Programme einzubinden. Dazu benötigt man innerhalb des C Programms nur die lua.h Header Datei. Sehr hilfreich sind außerdem die Header Dateien lualib.h zum Laden der Standardbibliotheken und lauxlib.h für erweiterte Funktionen zur Arbeit mit Lua. Zur Kommunikation zwischen Lua und C wird ein Stack verwet. Dazu gibt es Funktionen, um von C aus auf diesen Stack zuzugreifen und ihn zu verändern. Diese Funktionen sind recht gewöhnungsbedürftig und schwer zu lesen. Es gibt Funktionen, um etwas von C auf den Stack zu legen und Funktionen, um etwas von Lua auf den Stack zu legen. Genauso gibt es Funktionen, um Werte vom Stack in eine C Variable, oder eine Lua Variable zu schreiben. Von C aus kann auf beliebige Positionen im Stack zugegriffen werden. Der Zugriff erfolgt über einen ganzzahligen Index. Dabei geben positive Zahlen den Index gezählt vom Boden des Stacks und negative Zahlen den Index gezählt von der Spitze des Stack an. Angenommen, wir möchten Lua zur Konfiguration eines Programms nutzen. Es soll möglich gemacht werden, durch die Konfigurationsdatei eine Schriftgröße einzustellen. Dazu benötigen wir in der Lua Datei eine globale Variable mit fesgelegtem Namen (hier im Beispiel font size), in der die Schriftgröße gespeichert ist. Damit haben wir gegenüber einer einfachen Textdatei als Konfigurationsdatei noch nichts gewonnen. Den Vorteil von Lua finden wir, wenn wir das Szenario etwas erweitern. Angenommen, wir möchten die Schriftgröße von der Größe des Fensters abhängig machen. Dazu können wir in C eine Funktion zur Verfügung stellen, mit der die Größe des Fensters abgefragt werden kann. In der Lua Datei kann dann die gewünschte Schriftgröße berechnet und in der Variablen hinterlegt werden. Von C aus kann dann auf diese Variable zugegriffen und die berechnete Schriftgröße ausgelesen werden. 16

19 Inhalt der Datei rc.lua: font size = (get window size() / 20) C Code des Programms: #include <lua.h> #include <lauxlib.h> int window heigth; Die folge Funktion soll von Lua aus Aufgerufen werden und die Fenstergröße zurückgeben. static int get window size(lua State *L) { /* Fenstergröße auf den Stack legen */ lua pushnumber(l, (double)window heigth); return 1; /* Anzahl der return Werte auf dem Stack */ } Diese Funktion läd die Variable font size aus Lua. void run commands(lua State *L, double *font size) { lual dofile("rc.lua"); /* Ausführen der Lua Datei */ /* Variable von Lua auf den Stack legen */ lua getglobal(l, "font size"); /* Variable vom Stack auslesen */ *font size = lua tonumber(l, -1); } In der main Funktion wird ein neuer lua State erstellt und die Funktion get window size Lua zur Verfügung gestellt. int main() { lua State *L = lual newstate(); /* Funktion auf den Stack legen */ lua pushfunction(l, get window size); /* Funktion in globaler Variable hinterlegen */ lua setglobal(l, "get window size"); double font size; run commands(l, &font size); /* Rest des Programms */ /*... */ return 0; } 17

20 4. Technische Unterstützung 4.1. Compiler, Interpreter, Entwicklungsumgebung Lua wird auf der offiziellen Website lua.org als Sourcecode zur Verfügung gestellt. Die aktuelle Version umfasst entpackt 896 KiB und enthält den Code für die Bibliothek, den Standalone Interpreter und Precompiler, sowie die zugehörigen man pages, und das Reference Manual in html. Für diverse Linux Distributionen, und andere UNIX Derivate, sowie Windows gibt es auch vorkompilierte Versionen. Zusätzlich zum offiziellen Lua Paket gibt es auch noch weitere inoffizielle Compiler und Interpreter. Die meisten Compiler sind dafür programmiert worden, um Lua Code für eine andere virtuelle Maschine zu übersetzen. Speziell zu erwähnen ist dabei LuaJIT, ein Just-in-Time Compiler für Lua, der Lua Code direkt in Bytecode für diverse Hardwarearchitekturen übersetzt, sodass die Lua Virtual Machine nicht genutzt werden muss. Dadurch kann die Geschwindigkeit von vielen Lua Programmen um ein Vielfaches erhöht werden. Lua kann man aufgrund seiner einfachen Struktur und Übersichtlichkeit recht komfortabel in einem Texteditor mit Syntax Highlighting schreiben. Es gibt aber auch IDEs die das Programmieren durch Code completition und Anzeige einer Projektstruktur vereinfachen sollen. Jedoch ist deren Unterstützung nicht so hilfreich, da in Lua, wie in anderen Skriptsprachen auch, zur Compilezeit nicht sehr viel über den Zustand von Variablen und deren Werte ausgesagt werden kann. Der einzige große Vorteil einiger Entwicklungsumgebungen ist ein Debuger. Allerdings können die IDEs den Einfluss des C Programms nicht berücksichtigen, was sie für die meisten Lua Programme ebenfalls uninteressant macht. Die am weitesten verbreitete frei verfügbare IDE für Lua ist Lua Development Tools, ein Plugin für Eclipse Werkzeuge und Bibliotheken Lua enthält sieben Standardbibliotheken, diese sind math für mathematische Funktionen, bit32 für bitwise Opearationen auf Zahlen, table zum erweiterten Arbeiten auf Tabellen, string zur manipulation von Zeichenketten, io für Ausgaben in Dateien oder Standardausgabe, os für Datumsfunktionen und Umgabungsvariablen und debug zum erleichterten Analysieren des Programmablaufs. Zusätzlich zu den offiziellen Standardbibliotheken gibt es auch eine Menge an Bibliotheken aus der Lua Community. Beim Suchen nach Bibliotheken hilft das Modulverzeichnis LuaRocks, das außerdem ein Modulmanagement System zum Downloaden und automatischen Aktualisieren der Module bereitstellt. Dort stehen zur Zeit rund 300 Module 18

21 4. Technische Unterstützung zur Verfügung. Ein sehr hilfreiches Werkzeug zum Dokumentieren von Lua Code ist LuaDoc. Dieses erstellt, ähnlich wie Javadoc, automatisch aus speziellen Kommentaren ein html Dokument. Ein LuaDoc Kommentar beginnt mit drei anstatt zwei Minuszeichen. Zur beschreibung von Funktionen und Modulen stehen wie in und noch weitere tags zur Verfügung Portabilität Wie in der Einleitung bereits angesprochen, ist die Portabilität eines der wichtigsten Ziele von Lua. Damit gemeint ist die Möglichkeit, Lua Code auf möglichst allen Hardund Softwaresystemen ausführen zu können. Jedoch gibt es auch noch eine Art der Portabilität, die von Lua nicht so einfach unterstützt wird. Das ist die Möglichkeit Lua auch in andere Programme als C einzubinden. Als einzige weitere Sprache wird C++ offiziell unterstützt, da diese die C Bibliotheken ebenfalls nutzen kann[7]. Für andere Sprachen, wie Java werden Erweiterungen der C Bibliotheken benötigt, die es ermöglichen diese zu nutzen. Da dies für die meisten Sprachen recht schwer zu erreichen ist, gibts es viele Rewrites der Lua Virtual Machine in den entsprechen Sprachen. Mit den Rewrites gibt es jedoch viele Probleme, so werden teilweise nicht alle Funktionalitäten von Lua unterstützt, oder die Rewrites existieren nur für alte Versionen von Lua. Ein sehr gutes Rewrite um Lua in Java nutzen zu können ist Luaj, dieses übersetzt den Lua Code in Java-Bytecode und stellt eine API in Java zur Verfügung, die der C API recht ähnlich ist. 19

22 5. Diskussion und Zusammenfassung 5.1. Vergleichbare Sprachen Es gibt viele Sprachen, die die gleichen oder ähnliche Konzepte wie Lua bieten. Die größte und bekannteste dieser Sprachen ist Python. Wäre Python bereits zur Zeit, in der die Entwicklung von Lua beschlossen wurde, so ausgereift wie heutzutage, wäre die Notwigkeit, Lua zu entwickeln, möglicherweise gar nicht entstanden[1, Kap. 4]. Auch wenn sich Python und Lua ähneln sind ihre Konzepte trotzdem recht unterschiedlich. Python bietet im Gegensatz zu Lua nicht nur eine Datenstruktur, sondern mehrere für unterschiedliche Anwungen. Genauso verhält es sich auch mit anderen Konzepten. Wo Lua eine Flexible und leicht annpassbare Möglichkeit bietet, gibt es bei Python unterschiedliche, spezialisierte Möglichkeiten. Das lässt sich vor allem in der Größe der beiden Programme erkennen. Wär der Source Code von Lua kleiner als ein Megabyte ist, umfasst der von Python mehr als 60 Megabyte. Außerdem wirkt es sich auf die Art der Nutzbarkeit aus, in Python gibt es für viele Anwungsszenarios Standardbibliotheken, in Lua gibt es so etwas nicht. Also muss man in Lua häufiger benötigte Bibliotheken selbst schreiben, die dann meistens auf ein spezielles Problem angepasst sind, was die Wiederverwbarkeit des Codes verringert. [8] 5.2. Fazit Zusammenfass kann man sagen, dass Lua eine leicht einsetzbare Sprache, mit einfach erweiterbaren Konstrukten ist. Sie bietet Möglichkeiten in Projekten jeglicher Größe genutzt werden zu können. Im Vergleich zu anderen Sprachen steht immer die Frage danach im Vordergrund, ob eine einfache leicht erweiterbare Sprache, oder eine große Sprache die etliche Erweiterungen bereits mitbringt, für das Projekt die richtige Wahl ist. In einigen Bereichen, wie in der Spielebranche, geht diese Entscheidung oft zugunsten von Lua aus. Jedoch führt sie im Allgemeinen ein Schattasein neben den größeren bekannten Skriptsprachen. Und das wird vermutlich auch weiterhin so bleiben. Jedoch hat Lua auch weitere Bereiche in denen sie überzeugen kann. Durch die geringe Größe und hohe Portabilität kann Lua sehr gut auf Geräten im Embeded Bereich eingesetzt werden, die nicht über Standard-Hardware und nahezu unbegrenzte Ressourcen verfügen. Auch in der Einfachheit und Ausführungsgeschwindigkeit hat Lua Vorteile gegenüber komplexeren Sprachen. 20

23 A. Einführung in die Syntax von Lua Innerhalb des Beispielcodes sind Kommentare, wie in Lua üblich, mit -- gekennzeichnet. Mit --> sind die Ausgaben der Programmzeile gemeint. Das Klassische Hello World Beispiel ist in Lua sehr schnell abgehandelt. Die Ausgabe von Hello World auf der Standardausgabe erfolgt durch diese Anweisung: print("hello World") Variablennamen dürfen aus Buchstaben, Ziffern und Unterstrichen bestehen, wobei das erste Zeichen keine Ziffer sein darf. Außerdem sind folgen Namen reserviert: and break do else elseif false for function goto if in local nil not or repeat return then true until while Lua ist Case sensitiv, also sind die Variablen var und Var nicht indentisch. Zuweisungen werden mit dem = Operator durchgeführt. In Lua sind auch Mehrfachzuweisungen möglich, außerdem können Funktionen mehrere Rückgabewerte haben. a = 1 a, b = 1, 2 -- a = 1 und b = 2 a, b = b, a -- tauschen der Werte von a und b a, b = 1 -- a = 1 und b uninitalisiert a, b = 1, 2, 3 -- a = 1, b = 2 und die 3 geht verloren -- Funktion mit mehreren Rückgabewerten, a = 3 und b = 4 a, b = (function () return 3, 4 )() Eine Funktion wird erstellt durch den Funktionskonstruktor. Die erstellte Funktion wird von diesem zurückgegeben. Es ist auch möglich, Funktionen so zu definieren, wie man es aus anderen Sprachen wie Java oder C gewohnt ist. function() add1 = function(value) return value + 1 function add1(value) return value einfacher Funktionskonstruktor -- normale Funktionsdefinition -- äquavalent zur vorherigen Definition Für Tabellen und Strings gibt es ebenfalls Konstruktoren: 21

24 A. Einführung in die Syntax von Lua t = {} s = "" -- leere Tabelle -- leerer String Auf den Inhalt von Strings kann man nur mit entsprechen Funktionen zugreifen, ein byteweiser Zugriff, wie in C ist nicht möglich. Auf Tabellen kann man so zugreifen, wie man es aus anderen Sprachen von Arrays gewohnt ist. Als Index sind alle Variablentypen, abgesehen von nil erlaubt. Ist der Index ein String, der den oben genannten Kriterien von Variablennamen entspricht, kann auf ihn auch per Punktnotation zugegriffen werden. t[1] = 12; print(t[1]) --> 12 t["elem"] = "e" print(t["elem"]) --> e print(t.elem) --> e Es gibt vier verschiedene Kotrollstrukturen. Die if then else Abfrage funktioniert folgermaßen: if a > b then r = 1 elseif a < b then r = -1 else r = 0 Dabei sind Angaben von elseif und else optional. Eine while Schleife sieht so aus: while c do c = checksomething() Dabei muss in Lua bei den Bedingungen darauf geachtet werden, dass nur false und nil zum logischen Falsch ausgewertet werden. Alles andere, also auch 0 und der leere String, werden zu wahr ausgewertet. Die repeat until Schleife funktioniert fast analog zur while Schleife, jedoch läuft sie, solange die Abbruchbedingung zu falsch ausgewertet wird. repeat c = checksomething() until c Es gibt außerdem noch die for Schleife, diese kann man auf zwei verschiedene Arten nutzen. Einerseits numerisch, also mit einer Zählervariablen, die von einem Startwert bis zu einem Abbruchwert um eine bestimmte Schrittlänge hochgezählt wird. Andererseits generisch mit einer Zählfunktion, die durch alle Elemente einer Liste durchiteriert. for i = -10, 10, 2 do -- numerisches for mit Schrittweite 2 print(i, ",") --> -10, -8, -6,..., 8, 10, t = {1 = "a", elem = 20} for k, v in pairs(t) do -- generisches for print(k, "=", v, ",") --> 1 = a, elem = 20, 22