Programmieren in Lua

Roberto Ierusalimschy Programmieren in Lua 3. Auflage Open Source Press

Alle in diesem Buch enthaltenen Programme, Darstellungen und Informationen wurden nach bestem Wissen erstellt. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grunde sind die in dem vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor(en), Herausgeber, Übersetzer und Verlag übernehmen infolgedessen keine Verantwortung und werden keine daraus folgende Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen oder Teilen davon entsteht, auch nicht für die Verletzung von Patentrechten, die daraus resultieren können. Ebenso wenig übernehmen Autor(en) und Verlag die Gewähr dafür, dass die beschriebenen Verfahren usw. frei von Schutzrechten Dritter sind. Die in diesem Werk wiedergegebenen Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. werden ohne Gewährleistung der freien Verwendbarkeit benutzt und können auch ohne besondere Kennzeichnung eingetragene Marken oder Warenzeichen sein und als solche den gesetzlichen Bestimmungen unterliegen. Dieses Werk ist urheberrechtlich geschützt. Alle Rechte, auch die der Übersetzung, des Nachdrucks und der Vervielfältigung des Buches oder Teilen daraus vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlags in irgendeiner Form (Druck, Fotokopie, Mikrofilm oder einem anderen Verfahren), auch nicht für Zwecke der Unterrichtsgestaltung, reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden. Bibliografische Information Der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. Copyright 2013 Open Source Press, München Gesamtlektorat: Dr. Markus Wirtz Übersetzer: Dinu Gherman Satz: Open Source Press & Thomas Schraitle (AsciiDoc/DocBook/XSL-FO/XEP) Englische Originalausgabe: Programming in Lua (3rd edition), Copyright 2012 by Roberto Ierusalimschy Umschlaggestaltung: Olga Saborov ISBN: 978-3-95539-033-4 (E-Book PDF) ISBN: 978-3-95539-020-4 (gedruckte Ausgabe) http://www.opensourcepress.de

Inhaltsverzeichnis Vorwort 19 I Die Sprache 31 1 Einführung 33 1.1 Chunks.............................................. 34 1.2 Einige lexikalische Konventionen.......................... 37 1.3 Globale Variablen...................................... 39 1.4 Der Stand-alone-Interpreter............................. 39 1.5 Übungsaufgaben...................................... 42 2 Typen und Werte 45 2.1 Nil................................................. 46 2.2 Boolesche Werte...................................... 47 Ierusalimschy Programmieren in Lua 5

Inhaltsverzeichnis 2.3 Zahlen.............................................. 47 2.4 Strings.............................................. 49 2.4.1 String-Literale.................................. 50 2.4.2 Lange Strings................................... 53 2.4.3 Umwandlungen................................. 55 2.5 Tabellen............................................. 56 2.6 Funktionen........................................... 61 2.7 Userdata und Threads.................................. 62 2.8 Übungsaufgaben...................................... 63 3 Ausdrücke 65 3.1 Arithmetische Operatoren............................... 65 3.2 Vergleichsoperatoren................................... 67 3.3 Logische Operatoren................................... 68 3.4 Zusammensetzung.................................... 70 3.5 Der Längenoperator.................................... 70 3.6 Vorrang............................................. 73 3.7 Tabellenkonstruktoren.................................. 74 3.8 Übungsaufgaben...................................... 77 4 Anweisungen 79 4.1 Zuweisung........................................... 79 www.opensourcepress.de 6

Inhaltsverzeichnis 4.2 Lokale Variablen und Blöcke............................. 81 4.3 Kontrollstrukturen..................................... 84 4.3.1 if then else................................. 85 4.3.2 while......................................... 86 4.3.3 repeat........................................ 86 4.3.4 Numerisches for................................ 87 4.3.5 Generisches for................................. 89 4.4 break, return und goto................................. 91 4.5 Übungsaufgaben...................................... 96 5 Funktionen 99 5.1 Mehrere Ergebnisse................................... 102 5.2 Variadische Funktionen................................ 108 5.3 Benannte Argumente................................. 112 5.4 Übungsaufgaben..................................... 114 6 Mehr über Funktionen 117 6.1 Closures............................................ 121 6.2 Nicht-Globale Funktionen.............................. 126 6.3 Saubere Tail-Aufrufe.................................. 129 6.4 Übungsaufgaben..................................... 131 7 Iteratoren und das generische for 133 Ierusalimschy Programmieren in Lua 7

Inhaltsverzeichnis 7.1 Iteratoren und Closures................................ 133 7.2 Die Semantik des generischen for........................ 137 7.3 Zustandslose Iteratoren................................ 139 7.4 Iteratoren mit komplexem Zustand....................... 142 7.5 Echte Iteratoren...................................... 144 7.6 Übungsaufgaben..................................... 146 8 Kompilierung, Ausführung und Fehler 149 8.1 Kompilierung........................................ 150 8.2 Vorkompilierter Code.................................. 156 8.3 C-Code............................................. 158 8.4 Fehler.............................................. 160 8.5 Fehlerbehandlung und Ausnahmen....................... 163 8.6 Fehlermeldungen und Tracebacks........................ 165 8.7 Übungsaufgaben..................................... 167 9 Koroutinen 171 9.1 Koroutinen-Grundlagen............................... 172 9.2 Pipes und Filter...................................... 176 9.3 Koroutinen als Iteratoren.............................. 181 9.4 Nicht-Präemptives Multithreading....................... 184 www.opensourcepress.de 8

Inhaltsverzeichnis 9.5 Übungsaufgaben..................................... 191 10 Vollständige Beispiele 193 10.1 Das Acht-Damen-Rätsel............................... 194 10.2 Die häufigsten Wörter................................ 196 10.3 Markov-Ketten-Algorithmus........................... 199 10.4 Übungsaufgaben.................................... 203 II Tabellen und Objekte 205 11 Datenstrukturen 207 11.1 Arrays............................................. 208 11.2 Matrizen und mehrdimensionale Arrays.................. 209 11.3 Verkettete Listen..................................... 212 11.4 Queues und doppelte Queues........................... 213 11.5 Mengen und Multimengen............................. 215 11.6 String-Puffer....................................... 217 11.7 Graphen........................................... 219 11.8 Übungsaufgaben.................................... 222 12 Datendateien und Persistenz 225 12.1 Datendateien....................................... 226 Ierusalimschy Programmieren in Lua 9

Inhaltsverzeichnis 12.2 Serialisierung....................................... 229 12.2.1 Tabellen ohne Zyklen speichern.................... 233 12.2.2 Tabellen mit Zyklen speichern..................... 235 12.3 Übungsaufgaben.................................... 238 13 Metatabellen und Metamethoden 241 13.1 Arithmetische Metamethoden.......................... 243 13.2 Vergleichende Metamethoden.......................... 247 13.3 Bibliotheksdefinierte Metamethoden..................... 249 13.4 Metamethoden für den Tabellenzugriff................... 250 13.4.1 Die Methamethode index...................... 251 13.4.2 Die Metamethode newindex.................... 253 13.4.3 Tabellen mit Vorgabewerten...................... 254 13.4.4 Tabellenzugriffe mitverfolgen..................... 256 13.4.5 Nur-lesbare Tabellen............................ 259 13.5 Übungsaufgaben.................................... 260 14 Die Umgebung 261 14.1 Globale Variablen mit dynamischen Namen................ 262 14.2 Globale Variablendeklarationen......................... 264 14.3 Nicht globale Umgebungen............................ 268 14.4 Anwendung von _ENV................................ 271 www.opensourcepress.de 10

Inhaltsverzeichnis 14.5 _ENV und load...................................... 275 14.6 Übungsaufgaben.................................... 277 15 Module und Pakete 279 15.1 Die Funktion require.................................. 282 15.1.1 Module umbenennen............................ 284 15.1.2 Suchpfade.................................... 285 15.1.3 Suchfunktionen................................ 287 15.2 Der grundlegende Ansatz beim Schreiben von Lua-Modulen....................................... 289 15.3 Umgebungen benutzen............................... 291 15.4 Untermodule und Pakete.............................. 294 15.5 Übungsaufgaben.................................... 297 16 Objektorientierte Programmierung 299 16.1 Klassen............................................ 302 16.2 Vererbung.......................................... 305 16.3 Mehrfachvererbung.................................. 308 16.4 Kapselung.......................................... 312 16.5 Der Einmethoden-Ansatz.............................. 315 16.6 Übungsaufgaben.................................... 316 17 Schwache Tabellen und Finalisierer 319 Ierusalimschy Programmieren in Lua 11

Inhaltsverzeichnis 17.1 Schwache Tabellen................................... 320 17.2 Memoisierungsfunktionen............................. 323 17.3 Objektattribute...................................... 326 17.4 Noch einmal zu Tabellen mit Vorgabewerten............... 328 17.5 Ephemere Tabellen................................... 329 17.6 Finalisierer......................................... 331 17.7 Übungsaufgaben.................................... 337 III Die Standardbibliotheken 339 18 Die mathematische Bibliothek 341 18.1 Übungsaufgaben.................................... 343 19 Die Bitwise-Bibliothek 345 19.1 Übungsaufgaben.................................... 350 20 Die Tabellen-Bibliothek 353 20.1 Einfügen und Entfernen............................... 353 20.2 Sortieren........................................... 355 20.3 Zusammensetzung................................... 357 20.4 Übungsaufgaben.................................... 358 21 Die String-Bibliothek 359 www.opensourcepress.de 12

Inhaltsverzeichnis 21.1 Grundlegende String-Funktionen........................ 360 21.2 Funktionen bei Mustervergleichen....................... 363 21.2.1 Die Funktion string.find.......................... 364 21.2.2 Die Funktion string.match........................ 365 21.2.3 Die Funktion string.gsub......................... 366 21.2.4 Die Funktion string.gmatch....................... 366 21.3 Muster............................................ 368 21.4 Captures........................................... 375 21.5 Ersetzungen........................................ 379 21.5.1 URL-Kodierung................................ 381 21.5.2 Tabulator-Expansion............................ 383 21.6 Tipps und Tricks..................................... 385 21.7 Unicode........................................... 390 21.8 Übungsaufgaben.................................... 394 22 Die Ein-/Ausgabe-Bibliothek 397 22.1 Das einfache Ein-/Ausgabe-Modell...................... 398 22.2 Das vollständige Ein-/Ausgabe-Modell................... 403 22.2.1 Ein kleiner Performance-Trick..................... 405 22.2.2 Binärdateien.................................. 406 22.3 Weitere Datei-Operationen............................ 409 Ierusalimschy Programmieren in Lua 13

Inhaltsverzeichnis 22.4 Übungsaufgaben.................................... 411 23 Die Betriebssystem-Bibliothek 413 23.1 Datum und Zeit..................................... 414 23.2 Weitere Systemaufrufe................................ 419 23.3 Übungsaufgaben.................................... 422 24 Die Debug-Bibliothek 423 24.1 Möglichkeiten der Introspektion........................ 424 24.1.1 Zugriff auf lokale Variablen....................... 428 24.1.2 Zugriff auf nicht-lokale Variablen.................. 430 24.1.3 Zugriff auf andere Koroutinen..................... 432 24.2 Hooks............................................. 433 24.3 Profile............................................. 435 24.4 Übungsaufgaben.................................... 438 IV Die C-API 441 25 Eine Übersicht über die C-API 443 25.1 Ein erstes Beispiel.................................... 446 25.2 Der Stack.......................................... 450 25.2.1 Elemente ablegen.............................. 452 25.2.2 Elemente abrufen.............................. 454 www.opensourcepress.de 14

Inhaltsverzeichnis 25.2.3 Weitere Stack-Operationen....................... 458 25.3 Fehlerbehandlung mit der C-API........................ 460 25.3.1 Fehlerbehandlung in Anwendungscode............. 461 25.3.2 Fehlerbehandlung in Bibliothekscode............... 462 25.4 Übungsaufgaben.................................... 463 26 Erweiterung einer Anwendung 465 26.1 Die Grundlagen..................................... 465 26.2 Tabellenmanipulation................................. 468 26.3 Aufruf von Lua-Funktionen............................ 475 26.4 Eine generische Aufruffunktion......................... 477 26.5 Übungsaufgaben.................................... 481 27 C aus Lua aufrufen 483 27.1 C-Funktionen....................................... 484 27.2 Continuations....................................... 488 27.3 C-Module.......................................... 492 27.4 Übungsaufgaben.................................... 495 28 Techniken zum Schreiben von C-Funktionen 497 28.1 Array-Manipulation.................................. 497 28.2 String-Manipulation.................................. 500 Ierusalimschy Programmieren in Lua 15

Inhaltsverzeichnis 28.3 Zustand in C-Funktionen speichern...................... 506 28.3.1 Das Register................................... 507 28.3.2 Upvalues..................................... 511 28.3.3 Gemeinsam genutzte Upvalues.................... 515 28.4 Übungsaufgaben.................................... 516 29 Benutzerdefinierte Typen in C 519 29.1 Userdata........................................... 521 29.2 Metatabellen....................................... 524 29.3 Objektorientierter Zugriff.............................. 528 29.4 Array-Zugriff....................................... 531 29.5 Leichtgewichtige Userdata............................. 533 29.6 Übungsaufgaben.................................... 535 30 Ressourcen verwalten 537 30.1 Ein Verzeichnisiterator................................ 538 30.2 Ein XML-Parser...................................... 542 30.3 Übungsaufgaben.................................... 555 31 Threads und Zustände 557 31.1 Mehrere Threads..................................... 558 31.2 Lua-Zustände....................................... 565 www.opensourcepress.de 16

Inhaltsverzeichnis 31.3 Übungsaufgaben.................................... 577 32 Speicherverwaltung 579 32.1 Die Allokierungsfunktion.............................. 580 32.2 Die Speicherbereinigung.............................. 583 32.2.1 API der Speicherbereinigung...................... 585 32.3 Übungsaufgaben.................................... 589 Index 591 Ierusalimschy Programmieren in Lua 17

Vorwort Als Waldemar, Luiz und ich 1993 mit der Entwicklung von Lua begannen, konnten wir nicht ahnen, dass sich die Sprache derartig verbreiten würde. Ursprünglich als hausinterne Sprache für zwei spezielle Projekte entwickelt, wird Lua heute in allen möglichen Bereichen eingesetzt, die von einer einfachen, erweiterbaren, portablen und effizienten Scriptsprache profitieren. Dazu gehören z. B. eingebettete Systeme, mobile Geräte, Webserver und natürlich Spiele. Wir haben Lua von Anfang so entworfen, dass es mit Software integriert werden kann, die in C/C++ und anderen konventionellen Sprachen geschrieben ist. Diese Integration hat viele Vorteile. Lua ist eine sehr kleine und einfache Sprache, weil es nicht Dinge versucht, die C bereits gut kann, zum Beispiel bei reiner Performance, Low-Level-Operationen und dem Einbinden der Software von Drittanbietern. Für diese Aufgaben verlässt sich Lua auf C. Lua bietet vielmehr das, was C nicht so gut kann: Lua hat einen vernünftigen Abstand zur Hardware, dynamische Strukturen, keine Redundanzen, einfache Möglichkeiten zum Testen und zur Fehlersuche (Debugging). Dazu bietet es eine sichere Umgebung, automa- Ierusalimschy Programmieren in Lua 19

Vorwort tische Speicherverwaltung und gute Fähigkeiten beim Umgang mit Strings und weiteren Arten von Daten mit dynamischer Größe. Zum Teil verdankt Lua seine Stärke seinen Bibliotheken. Das ist kein Zufall; schließlich ist Erweiterbarkeit eines der wesentlichen Konzepte der Sprache. Die Erweiterbarkeit basiert auf vielen Eigenschaften: Dynamische Typisierung ermöglicht einen hohen Grad an Polymorphie. Automatische Speicherverwaltung vereinfacht Schnittstellen, weil niemand entscheiden muss, wer für die Allokierung und Deallokierung von Speicher oder die Behandlung eines Überlaufs verantwortlich ist. Funktionen höheren Grades und anonyme Funktionen ermöglichen einen hohen Grad an Parametrisierung, was die Funktionen vielseitiger macht. Lua ist nicht nur eine erweiterbare Sprache, sondern darüber hinaus auch eine Klebesprache (Glue Language). Es unterstützt einen komponentenorientierten Ansatz bei der Softwareentwicklung, bei dem eine Anwendung durch die Kombination existierender High-Level-Komponenten entsteht. Diese Komponenten werden in einer kompilierten, statisch typisierten Sprache wie C oder C++ geschrieben. Lua ist der Klebstoff, mit dem wir diese Komponenten zusammezustellen und miteinander verbinden. Normalerweise stellen die Komponenten (bzw. Objekte) konkretere Low- Level-Konzepte (wie Widgets und Datenstrukturen) dar, die sich während der Programmentwicklung kaum noch verändern und die im fertigen Programm den Großteil der CPU-Zeit verbrauchen. Lua bestimmt die endgültige Form der Anwendung, die sich vermutlich über den Lebenszyklus des Produkts hinweg stark verändern wird. Aber im Gegensatz zu anderen Klebetechnologien ist Lua zugleich selbst eine vollständige Sprache. Darum lässt es sich nicht nur benutzen, um Komponenten zu verbinden, sondern auch um sie anzupassen und umzugestalten und um völlig neue Komponenten zu erstellen. www.opensourcepress.de 20

Vorwort Natürlich ist Lua nicht die einzige verfügbare Scriptsprache. Es gibt weitere Sprachen, die Sie für den mehr oder weniger gleichen Zweck benutzen können. Dennoch bietet Lua eine Reihe von Eigenschaften, die es in vielen Fällen zur besten Wahl machen: Erweiterbarkeit Die Erweiterbarkeit von Lua ist so beachtlich, dass es von vielen nicht als Sprache betrachtet wird, sondern als Baukasten zur Erstellung domänenspezifischer Sprachen. Wir haben Lua von Grund auf so entworfen, dass die Sprache sowohl durch Lua-Code als auch externen C-Code erweitert werden kann. Als Beweis implementiert Lua das meiste der eigenen Grundfunktionalität mit Hilfe externer Bibliotheken. Es ist sehr leicht, eine Schnittstelle zwischen Lua und C/C++ zu benutzen, und Lua wurde auch mit mehreren anderen Sprachen integriert, darunter Fortran, Java, Smalltalk, Ada, C# und sogar anderen Scriptsprachen wie Perl und Python. Einfachheit Lua ist eine einfache und kleine Sprache. Es hat wenige (aber mächtige) Konzepte. Diese Einfachheit macht Lua leicht erlernbar und trägt zu seinem geringen Umfang bei. Eine vollständige Distribution (Quellcode, Manual sowie Binärdateien für einige Plattformen) findet auf einer Floppy Disk ausreichend Platz. Effizienz Lua hat eine sehr effiziente Implementierung. Unabhängige Benchmarks zeigen, dass Lua eine der schnellsten Sprachen in der Kategorie der Scriptsprachen ist. Ierusalimschy Programmieren in Lua 21

Vorwort Portabilität Wenn wir von Portabilität sprechen, meinen wir damit, dass Lua auf sämtlichen Plattformen läuft, von denen wie je gehört haben: sämtliche UNIX- und Windows-Varianten, PlayStation, Xbox, Mac OS X und ios, Android, Kindle Fire, NOOK, Haiku, QUALCOMM Brew, IBM Mainframes, RISC OS, Symbian OS, Rabbit-Prozessoren, Raspberry Pi, Arduino und viele andere. Der Quellcode für all diese Plattformen ist nahezu identisch. Lua kommt ohne bedingte Kompilierung aus, um seinen Code an verschiedene Rechner anzupassen. Stattdessen hält es sich an Standard-ANSI (ISO) C. Darum müssen Sie Lua normalerweise nicht an eine neue Umgebung anpassen: Steht Ihnen ein ANSI C- Compiler zur Verfügung, müssen Sie Lua einfach nur kompilieren. Zielgruppe Lua-Benutzer lassen sich grob in drei Gruppen unterteilen: jene, die Lua bereits eingebettet in einem Anwendungsprogramm nutzen, jene, die Lua als eigenständige Sprache benutzen, und jene, die Lua zusammen mit C benutzen. Viele benutzen Lua eingebettet in einem Anwendungsprogramm, z. B. Adobe Lightroom, Nmap oder World of Warcraft. Diese Anwendungen verwenden die Lua-C-API, um neue Funktionen zu registrieren, neue Typen zu erstellen und um das Verhalten einiger Operationen in der Sprache zu ändern, wenn sie Lua für ihre speziellen Bereiche anpassen. Manche Entwickler von Lightroom-Plugins kennen beispielsweise keinen anderen Einsatzzweck der Sprache; Nmap-Nutzer halten Lua oftmals für die Sprache der Nmap Scripting Engine; Spieler von World of Warcraft mögen Lua für eine Sprache halten, die es nur in diesem Spiel gibt. www.opensourcepress.de 22

Vorwort Lua ist auch als alleinstehende Sprache nützlich, nicht nur für die Textbearbeitung und kleine Einmalprogramme, sondern zunehmend auch für mittelgroße bis große Projekte. In solchen Fällen stammt die Hauptfunktionalität von Lua aus Bibliotheken. Die Standardbibliotheken bieten z. B. Mustervergleiche und weitere Funktionen für die Behandlung von Strings. Weil Lua die Unterstützung von Bibliotheken permanent verbessert, sind zahlreiche externe Pakete entstanden. Lua Rocks, ein Deployment- und Management-System für Lua-Module, umfasst derzeit mehr als 150 Pakete. Und schließlich gibt es jene Programmierer, die auf dem anderen Ende der Bank arbeiten und Anwendungen schreiben, die Lua als C-Bibliothek benutzen. Diese werden mehr in C als in Lua programmieren, benötigen aber ein gutes Verständnis von Lua, um Schnittstellen zu erstellen, die einfach sind, leicht zu benutzen und gut mit der Sprache integriert. All jenen hat dieses Buch manches zu bieten. Der erste Teil behandelt die Sprache selbst und zeigt, wie Sie ihr ganzes Potential erschließen. Wir konzentrieren uns auf verschiedene Sprachkonstrukte und verwenden zahlreiche Beispiele, um zu zeigen, wie man sie für praktische Aufgaben einsetzt. Einige Kapitel in diesem Teil behandeln grundlegende Konzepte wie Kontrollstrukturen, während sich andere auch fortgeschrittenen Themen wie Iteratoren und Koroutinen widmen. Der zweite Teil befasst sich ausschließlich mit Tabellen, der einzigen Datenstruktur in Lua. In den Kapiteln geht es um Datenstrukturen, Persistenz, Pakete und objektorientiertes Programmieren. An dieser Stelle enthüllen wir die wirkliche Macht der Sprache. Der dritte Teil stellt die Standardbibliotheken vor. Dieser Teil ist besonders für jene von Interesse, die Lua als alleinstehende Sprache verwenden, auch wenn viele andere Anwendungen ebenfalls alle Standardbibliotheken oder Teile davon enthalten. Jedes Kapitel dieses Teils behandelt eine Ierusalimschy Programmieren in Lua 23

Vorwort Standardbibliothek: die mathematische Bibliothek, die bitweise Bibliothek, die Tabellen-Bibliothek, die String-Bibliothek, die I/O-Bibliothek, die Betriebssystem-Bibliothek und die Debug-Bibliothek. Der letzte Teil des Buchs behandelt schließlich die API zwischen Lua und C und ist hilfreich für alle, die C einsetzen, um die gesamten Fähigkeiten von Lua zu nutzen. Der Stil dieses Teils unterscheidet sich notwendigerweise sehr von dem des übrigen Buchs. Hier werden wir in C programmieren, nicht in Lua wir setzen uns also einen anderen Hut auf. Manche Leser werden sich nur am Rande für die C-API interessieren, während andere darin den wichtigsten Teil dieses Buchs sehen werden. Über die dritte Auflage Dieses Buch ist eine aktualisierte und erweiterte Fassung der zweiten Auflage von Programming in Lua (auch als PiL 2 Buch bekannt). Auch wenn die Struktur des Buchs nahezu unverändert geblieben ist, enthält diese neue Auflage sehr viel neues Material. Erstens habe ich das gesamte Buch auf Lua 5.2 aktualisiert. Von besonderer Bedeutung ist das Kapitel über Umgebungen, das weitgehend neu geschrieben wurde. Außerdem habe ich mehrere Beispiele umgeschrieben, um zu zeigen, wie man die neuen Merkmale in Lua 5.2 nutzt. Ich habe aber die Unterschiede zu Lua 5.1 deutlich kenntlich gemacht, damit Sie das Buch auch für diese Version nutzen können. Zweitens was noch wichtiger ist habe ich in allen Kapiteln Beispiele ergänzt: von einfachen Fragen zur Sprache bis hin zu vollständigen kleinen Projekten. Einige illustrieren wichtige Aspekte der Lua-Programmierung und sind ebenso wichtig wie jene, die Ihren Werkzeugkasten nützlicher Techniken erweitern. www.opensourcepress.de 24

Vorwort Wie schon die erste und zweite Auflage haben wir auch die dritte Auflage der englischen Originalausgabe Programming in Lua selbst herausgebracht. Trotz der Einschränkungen beim Marketing bringt dies einige Vorteile mit sich: Wir haben vollkommene Kontrolle über den Inhalt des Buches; wir behalten alle Rechte, das Buch auch in anderer Form anzubieten; wir haben die Freiheit zu entscheiden, wann eine neue Ausgabe erscheint; und wir stellen sicher, dass die Druckfassung lieferbar bleibt. Weitere Quellen Das Lua 5.2 Reference Manual ist ein Muss für jeden, der eine Sprache wirklich lernen möchte. Dieses Buch ist kein Ersatz für dieses Manual. Ganz im Gegenteil, beide ergänzen einander. Das Manual beschreibt Lua nur, aber es enthält weder Beispiele noch Grundprinzipien hinter den Sprachkonstrukten. Auf der anderen Seite beschreibt es die gesamte Sprache, während dieses Buch die selten vorkommenden, dunklen Ecken von Lua übergeht. Auch ist das Manual das maßgebliche Dokument über Lua. Überall, wo dieses Buch vom Manual abweicht, sollten Sie dem Manual vertrauen. Um das Manual und weitere Information über Lua zu erhalten, sollten Sie die Lua-Website besuchen.¹ Nützliche Information finden Sie auch auf der Website der Lua-Community.² Unter anderem finden Sie dort ein Tutorial, eine Liste von Paketen und Dokumentation von Drittanbietern sowie ein Archiv der offiziellen Lua-Mailingliste. ¹ http://www.lua.org ² http://lua-users.org Ierusalimschy Programmieren in Lua 25

Vorwort Dieses Buch beschreibt Lua 5.2, auch wenn ein Großteil ebenso für Lua 5.1 und Lua 5.0 gilt. Die wenigen Unterschiede zwischen Lua 5.2 und älteren Versionen von Lua 5 sind im Text deutlich markiert. Sollten Sie eine neuere Version verwenden (die nach diesem Buch erschienen ist), sollten Sie im entsprechenden Manual nachsehen, welche Unterschiede es zwischen den Versionen gibt. Wenn Sie eine Version einsetzen, die älter als 5.2 ist, wäre nun ein guter Zeitpunkt für eine Aktualisierung. Einige typografische Konventionen In diesem Buch werden String-Literale, einzelne Zeichen wie a, Strings, die als Muster verwendet werden (z. B. [%w_]*), kurze Codebrocken wie auch Bezeichner im Fließtext mit einer anderen Schrift hervorgehoben. Längere Codebeispiele werden bildschirmähnlich dargestellt: -- program "Hello World" print("hello World") --> Hello World Die Notation --> zeigt die Ausgabe einer Anweisung oder manchmal das Ergebnis eines Ausdrucks: print(10) --> 10 13 + 3 --> 16 Da zwei Minuszeichen (--) in Lua einen Kommentar einleiten, gibt es kein Problem, falls Sie diese Anmerkungen in Ihren Programmen einbauen. Und schließlich wird in diesem Buch die Notation <--> benutzt, um anzuzeigen, dass etwas äquivalent zu etwas anderem ist: dies <--> jenes www.opensourcepress.de 26

Vorwort Mit anderen Worten: In Lua macht es keinen Unterschied, ob Sie dies oder jenes schreiben. Beispiele ausführen Sie benötigen einen Lua-Interpreter, um die Beispiele in diesem Buch auszuführen. Idealerweise nutzen Sie Lua 5.2, doch laufen die meisten Beispiele auch ohne Änderungen mit Lua 5.1. Die Lua-Webseite³ verwaltet den Sourcecode des Interpreters. Haben Sie einen C-Compiler und wissen, wie man C-Code kompiliert, sollten Sie Lua aus den Quellen installieren; es ist wirklich einfach. Die Website Lua Binaries (suchen Sie nach luabinaries) bietet vorkompilierte Lua- Interpreter für die bekanntesten Plattformen. Nutzen Sie Linux oder ein anderes UNIX-ähnliches System, werden Sie vielleicht auch im Repository Ihrer Distribution fündig; einige Distributionen bieten bereits Lua-Pakete an. Unter Windows ist Lua for Windows (suchen Sie nach luaforwindows) eine gute Option, eine Starten-und-loslegen-Umgebung für Lua. Sie umfasst den Interpreter, einen integrierten Texteditor und zahlreiche Bibliotheken. Wenn Sie Lua eingebettet in einer Anwendung nutzen, wie etwa WoW oder Nmap, sollten Sie sich das Handbuch der Applikation ansehen oder einen local guru befragen, wie Sie Ihre Programme zum Laufen bringen. Immer jedoch ist Lua dieselbe Sprache; das meiste von dem, was Sie in diesem Buch sehen, gilt unabhängig davon, wie sie Lua einsetzen. Dennoch empfehle ich Ihnen, Ihre Lua-Studien mit dem eigenständigen Lua-Inter- ³ http://www.lua.org Ierusalimschy Programmieren in Lua 27

Vorwort preter zu beginnen und damit erste Beispiele und Experimente laufen zu lassen. Danksagung Die erste Ausgabe dieses Buches liegt beinahe 10 Jahre zurück. Einige Freunde und Institutionen haben mir während dieser Reise geholfen. Wie immer gaben Luiz Henrique de Figueiredo und Waldemar Celes, die Koautoren von Lua, alle erdenkliche Hilfe. André Carregal, Asko Kauppi, Brett Kapilik, Diego Nehab, Edwin Moragas, Fernando Jefferson, Gavin Wraith, John D. Ramsdell und Norman Ramsey gaben wertvolle Hinweise und nützliche Einblicke für verschiendene Ausgaben des Buches. Luiza Novaes, Leiterin des Bereichs Arts & Design der PUC-Rio, fand trotz ihres vollen Terminkalenders die Zeit, das ideale Cover für die englische Ausgabe zu entwerfen. Lightning Source, Inc. erwies sich als verlässliche und effiziente Möglichkeit für Druck und Vertrieb des englischen Buches. Ohne sie wäre das Self-Publishing keine Option gewesen. Das Center for Latin American Studies der Stanford University gewährte mir die notwendigen Pausen von meiner regulären Tätigkeit und eine anregende Umgebung für die Hauptarbeit an dieser dritten Auflage. Ebenfalls danken möchte ich der Pontifícia Universidade Católica do Rio de Janeiro (PUC-Rio) und dem Conselho Nacional de Desenvolvimento Científico e Tecnológico (CNPq) für die kontinuierliche Unterstützung meiner Arbeit. www.opensourcepress.de 28

Vorwort Zuletzt möchte ich Noemi Rodriguez meine tiefe Dankbarkeit ausdrücken, für alle Formen der Hilfe (technischer und nicht-technischer Art) und dass sie mein Leben erhellt. Zur deutschen Ausgabe der 2. Auflage Freudig überrascht war ich, als ich Anfang 2006 eine E-Mail von Dr. Markus Wirtz von Open Source Press erhielt, in der er vorschlug, eine deutsche Ausgabe meines Buches Programming in Lua herauszubringen. Zu dieser Zeit beendete ich gerade die zweite Auflage (was Markus nicht wissen konnte), und die Rechte für die deutsche Ausgabe waren verfügbar. Meine Freude hatte mehrere Gründe: Erstens war der Vorschlag selbst schon ein Zeichen für den Erfolg des Buches, zweitens tut es dem Lebenslauf gut, und drittens ist eine deutsche Ausgabe eine große Hilfe bei der Verbreitung von Lua. Immerhin gibt es in Deutschland die zweitgrößte Lua-Community nach der englischsprachigen, und viele Spitzenleute auf den Lua-Mailinglisten kommen aus Deutschland. Für die Überraschung gab es auch einige Gründe: Ich muss gestehen, meine Erfahrungen mit Verlagen waren nicht besonders erfreulich. (Letztlich entschied ich mich, die englische Ausgabe im Selbstverlag herauszugeben.) Darum fühlte ich mich nicht nur geschmeichelt, sondern dachte auch: Das funktioniert nicht. Gut, ich habe mich geirrt. Deshalb muss ich Markus Wirtz von Open Source Press danken; die Partnerschaft erwies sich als sehr produktiv. Außerdem danke ich meinem Übersetzer Dinu Gherman und dem Verlag für die sorgfältige Übersetzung und Bearbeitung. Ich verstehe zwar nicht genug Deutsch, um die Qualität zu beurteilen, aus den präzisen Fragen war aber zu entnehmen, dass sie mit Ierusalimschy Programmieren in Lua 29

Vorwort Engagement bei der Sache waren. Letztendlich hat sich also auch die Überraschung in Zufriedenheit verwandelt. Zur deutschen Ausgabe der 3. Auflage Wieder habe ich die Freude, die Neuauflage von Programming in Lua in deutscher Übersetzung zu begrüßen. Und wieder ist es mir eine Freude, mit Open Source Press und Dr. Markus Wirtz zu arbeiten. Wir hatten über all die Jahre eine fruchtbare Zusammenarbeit, und ich bin sicher, dass sie noch viele Jahre fortdauern wird. Lua hat seit der letzten Auflage deutlich an Popularität gewonnen (und die deutsche Übersetzung hat sicher dazu beigetragen), doch die Sprache selbst hat ihren minimalistischen Charakter bewahrt. Darum ist diese Neuauflage nicht viel umfangreicher als die letzte. Doch sie enthält viel neues Material, einschließlich der Updates auf die Lua-Version 5.2 und Übungen in allen Kapiteln, die Ihnen helfen, das Gelesene zu wiederholen, und die einige neue Konzepte einführen. Ich hoffe, es gefällt Ihnen! www.opensourcepress.de 30

Teil I Die Sprache