Lua (programozási nyelv)

programozási nyelv

A Lua (portugálul: hold) egy nyílt forráskódú, beágyazható szkriptnyelv, amelyet 1993-ban fejlesztettek ki a brazíliai Katolikus Teológiai Egyetemen. Készítői fontosnak tartották az együttműködést a C nyelvű programokkal, programkönyvtárakkal. Platformfüggetlen; a programok futás előtt bájtkódra fordulnak. Bár önállóan is használható, de inkább beágyazott nyelvként tartják számon, ahogy a Tcl nyelvet is. Más script nyelvekhez képest nagy sebessége, bővíthetősége és 120 kB-os mérete népszerűvé tette a fejlesztők között.

Lua

ParadigmaImperatív
Jellemző kiterjesztés
  • lua
  • luna
  • lunaire
  • anair
Megjelent1993
TervezőRoberto Ierusalimschy
Waldemar Celes
Luiz Henrique de Figueiredo
FejlesztőRoberto Ierusalimschy
Utolsó kiadás5.4.6 (stabil verzió, 2023. május 14.)[1]
DialektusokMetalua, Idle, GSL Shell
MegvalósításokLua, LuaJIT, LLVM-Lua, Lua Alchemy
Hatással volt ráC++, CLU, Modula, Scheme, SNOBOL
Befolyásolt nyelvekIo, GameMonkey, Squirrel, Falcon, MiniD
Operációs rendszertöbbplatformos
LicencMIT licenc
Weboldal

Az értelmező egy C könyvtárból érhető el, ami API-ként szolgál, ha C programból hívják. Ez lehetővé teszi a két nyelv kevert használatát: a Lua is hívhat C függvényeket, és fordítva, a C is meghívhat Lua függvényeket.

ANSI C-ben készült, és az imperatív és a funkcionális paradigmákat támogatja; az objektumorientáltsághoz nem nyújt nyelvi eszközöket, mégis lehet objektumokat készíteni a tábla adattípus felhasználásával.

Szintaxisa

szerkesztés

Nyelvi elemek

szerkesztés

Az azonosítók betűkből, számokból, aláhúzásjelekből építkezhetnek, ahol az első jel nem lehet szám. A betűkészlet a helyi beállításoktól függ. Egy jel betű volta ellenőrizhető az isalpha, szám volta az isalnum függvénnyel.

A számok tartalmazhatnak törtrészt és decimális exponenst. A tizenhatos számrendszert a 0x előtag jelzi, ahol az x lehet kis- vagy nagybetűs is.

A Lua forráskódban a kis- és nagybetűk nem minősülnek azonosnak.

A Lua beépített típusai:

  • nil
  • boolean
  • number
  • string
  • table
  • function
  • userdata
  • thread

Egy nil típusú változónak egyetlen lehetséges értéke van, a nil. Ez a globális változók alapértelmezett értéke; a változók törölhetők is úgy, hogy értéküket nil-re állítjuk.

Egy logikai változónak két lehetséges értéke van: true és false. Fontos hibaforrás, hogy a Rubyhoz hasonlóan csak a nil és a false hamis, az üres string vagy a nulla nem. A logikai műveletek: and, or, not.

A számok alapértelmezetten dupla pontosságú lebegőpontos számok. Nincs külön egész típus. A számokon végezhető műveletek operátorai: +, -, *, /, és a hatványozás jele, a ^. Az összehasonlításra a ==, ~= (nem egyenlő), <, >, <=, >= operátorok szolgálnak.

A függvények tárolhatók változókban, és átadhatók paraméterként. A C-ben írt programkönyvtárak felhasználásának elősegítésére a C függvények is kezelhetők így. Függvényhíváskor akkor is ki kell tenni a zárójelet, ha nem adunk meg paramétereket. A Javaban megszokott this itt self. Metódusok hívásakor az objektumot is fel kellene sorolni a paraméterek között:

objektum.metódus(objektum, paraméterek)

de létezik egy szintaktikus cukor ennek a lerövidítésére:

objektum:metódus(paraméterek)

A thread a többszálú programozás programszálainak típusa.

A rövid stringek megadhatók egyszeres vagy kétszeres idézőjelek között. Hosszabb stringek megadhatók hosszú szöveg> formában is. A hosszú stringekben levő utasítások, escape sorozatok nem hajtódnak végre. Minden fajta string tárolhat tetszőleges Unicode karaktereket, amik a C fordító char típusára képeződnek le. A fájlokat azonban mindig binárisan érdemes kezelni, mivel a nyelv az stdio C könyvtárat használja, ami azonban nem garantálja a különféle kódolások megfelelő kezelését.

Az escape sorozatok ugyanazok, mint C-ben.

A userdata C-ben megvalósított adattípusokat tárol. Módosítani, rajta műveleteket végrehajtani csak C függvényekkel lehet, a Lua csak értékadást és egyenlőségvizsgálatot biztosít hozzá.

A table a Lua egyetlen összetett típusa, asszociatív tömb. A kulcsok lehetnek számok (ajánlottan csak egészek), stringek, másik táblák vagy függvények. A táblák automatikus indexelése a modernebb nyelvekhez hasonlóan 1-től kezdődik, mivel a 0 index hiánya nem igényel kihasználatlan helyfoglalást.

Bejárásuk kétféle módon lehetséges: csak az egész típusú kulcsokat (és a hozzájuk tartozó értékeket) nézzük végig 1-től az első nem létező kulcsig (ipairs) vagy az összes kulcs-érték párt (pairs).

Táblák létrehozhatók így:

x = {3.14, "ez egy string"}

Ilyenkor az egyes értékeket sorban az 1, 2, 3, ... kulcsokhoz rendeli.

String kulcsokat így lehet használni:

x =
{
  nev = "Kovács János",
  kor = 46,
  fizetes = {ertek = 10000, penznem = "Ft"}
}

A táblák referencia szerint adódnak át:

a_table = {x = 10}  -- Új tábla, egy kulcs-érték pár: "x" kulcs a 10-es számhoz.
print(a_table["x"]) -- A string kulcshoz tartozó érték kiíratása; itt 10.
b_table = a_table
b_table["x"] = 20   -- Az "x"-hez tartozó érték megváltoztatása 20-ra.
print(b_table["x"]) -- Az új érték kiíratása: 20.
print(a_table["x"]) -- ez is 20-at ír, mert az a_table és a b_table ugyanarra a táblára hivatkozik.

Kulcsok, értékek beszúrása, eltávolítása:

myTable = {"a", "b"}
table.insert(myTable, "c")
print(unpack(myTable)) -- eredménye: a   b   c
table.remove(myTable, 2)
print(unpack(myTable)) -- eredménye: a   c

Megjegyzések

szerkesztés

Egysoros megjegyzés:

-- Megjegyzés

Többsoros megjegyzés:

--[[Ide egy
többsoros
megjegyzés
került]]

Változók

szerkesztés

A változók nevükkel hivatkozhatók.

A táblában levő értékek hivatkozhatók a tömböknél megszokott módon, pl. a[4]. Ha a kulcs string, akkor használható az a["nev"] és a.nev alak is.

A változók láthatóság szempontjából háromfélék lehetnek: globális, lokális, és táblamezők. A változók deklarációjuktól kezdve egészen a legkisebb befoglaló blokk végéig láthatók. Egy változó lokálissá tehető, ha local kulcsszóval deklaráljuk. A függvények paraméterei is lokálisnak tekinthetők. Minden más változó globális. A deklarált, de értéket még nem kapott változók értéke nil. A függvények látják hívási helyük lokális változóit.

Elágazás

szerkesztés

A Lua csak a kétirányú elágazást ismeri, a többágú elágazás valójában csak szintaktikus cukor:

if kifejezes then
    blokk
else
    blokk
end
if kifejezes then
    blokk
elseif kifejezes then
    blokk
elseif kifejezes then
    blokk
...
else
    blokk
end

Elöltesztelő ciklus

szerkesztés

Addig hajtja végre a ciklusmagot, amíg a feltétel igaz.

while feltétel do
    -- Utasítások
end

Hátultesztelő ciklus

szerkesztés
repeat
    -- Utasítások
until feltétel

A ciklusmagot egyszer mindenképpen végrehajtja, majd utána addig hajtja végre a ciklust, amíg a feltétel hamis (igazzá nem válik). Az until ciklus valójában csak szintaktikus cukor, nem hoz létre új láthatósági tartományt.

Számláló ciklus

szerkesztés
for index = start, finish, delta do
    -- Utasítások
end

Az index ciklusváltozót kezdetben start-ra állítja, majd minden iteráció után delta lépésközzel megnöveli. Addig fut, amíg a ciklusváltozó kisebb vagy egyenlő, mint a finish.

Ha delta = 1, akkor a lépésköz elhagyható:

for index = start, finish do
    -- Utasítások
end

Iteráló ciklus

szerkesztés

A Luában kétféle iteráló ciklus van. Az ipairs 1-től kezdve a kapott tábla összes egész szám kulcsán sorban végigiterál, egészen addig, amíg nil értéket nem kap. A konvenció szerint ha egy változót kell valahol használni, aminek az értékét soha nem olvassuk (ez esetben a kulcs helyén), akkor az _ nevet adjuk neki.

for _, value in ipairs(lista) do
    -- Utasítások
end

A pairs a kapott tábla összes kulcs-érték párján végigiterál, függetlenül a kulcsok típusától.

for key, value in pairs(lista) do
    -- Utasítások
end

Függvények

szerkesztés

A Luában a függvények átadhatók paraméterként, sőt, visszatérési értékek is lehetnek, ahogy a következő példa mutatja:

do
  local oldprint = print   -- a jelenlegi print függvény eltárolása oldprint néven
  function print(s)        -- a print függvény újradefiniálása, itt lehet a szokásos print függvényt használni
    if s == "foo" then
      oldprint("bar")
    else
      oldprint(s)
    end
  end
end

A régi print függvény csak az új print függvényen keresztül érhető el.

A Lua a lezártakat is támogatja:

function hozzaad (x)
  -- visszatér egy új funkcióval, ami hozzáadja x-et a paraméterhez
  return function(y)
    --[[Amikor az x változóra hivatkozunk, ami kívül van az aktuális láthatósági tartományon
        és az élettartama hosszabb, mint ennek a névtelen függvénynek,
        akkor a Lua egy lezártat (closure)  hoz létre]]
    return x + y
  end
end

negyplusz = hozzaad(4)
print(negyplusz(3))  --> kiirja a 7-et

Valahányszor meghívódik a hozzaad, annyiszor új lezárt jön létre az x változóhoz. Így a névtelen függvény mindig hozzáfér a paraméteréhez. A lezártat, mint minden más objektumot, a szemétszedő gyűjti be.

Metatáblák

szerkesztés

A metatáblák új lehetőségeket nyújtanak a táblák felhasználására. A következő példa egy végtelen táblát mutat be. Minden n-re fibs[n] az n-edik Fibonacci-számot adja a dinamikus programozás és a memorizálás segítségével:

fibs = { 1, 1 }                          -- fibs[1] fibs[2] kezdőértékei.

setmetatable(fibs, {
  __index = function(name, n)            -- Ezt hívja, ha még nincs fibs[n].
    name[n] = name[n - 1] + name[n - 2]  -- Kiszámolja és megjegyzi fibs[n]-et.
    return name[n]
  end
})

Egy másik példa: a __call metametódus az objektumorientáltság érzetét adja:

  newPerson = {}                         -- Új tábla 'newPerson' néven.

  setmetatable(newPerson, {
  __call = function(table,name,age)      -- A newPerson táblát functable-lé teszi.
    local person = {Name = name, Age = age} -- Lokális változó a később létrehozandó person attributumaival
    return person                        -- A person tábla visszaadása, a person tábla változóinak beállítása
  end
})

Bill = newPerson("Bill Raizer", 21)    -- Új Person-t hoz létre
print(Bill.Name, Bill.Age)             -- A name és az age attributumok kiíratása.

Struktúrák

szerkesztés

Bár a Luában nincs adatszerkezet rekordok létrehozására, mint például C-ben a struct, a táblák erre a célra is használhatók. Ezt a használatot a nyelv szintaktikusan támogatja:

pont = { x = 10, y = 20 }   -- Új tábla
print(pont["x"])            -- Az "x" koordináta kiíratása, itt 10
print(pont.x)               -- Ugyanaz, mint az előző sorban, csak másként.

A táblák összetartozó függvényeket is tárolhatnak, ezzel átvehetik a névterek szerepét, objektumorientáltság érzetét adva:

Point = {}                       -- Új névtér létrehozása
Point.new = function (x, y)      -- Konstruktor
  return {x = x, y = y}
end
Point.set_x = function (self, x)
  self.x = x
end
Point.get_x = function (self)
  return self.x
end

A Lua táblák tömbökként is használhatók:

array = { "a", "b", "c", "d" }   -- Az indexek automatikusan számozódnak.
print(array[2])                  -- A "b"-t írja ki. A Lua 1-től kezdi a tömbelemek indexelését.
print(#array)                    -- 4, a tábla hossza. A # operátor adja meg a táblák és a stringek hosszát.
array[0] = "z"                   -- A 0 index használata.
print(#array)                    -- Most is 4, a nulladik index nem számítódik bele a hosszba.

Objektumok tömbjeként:

function newPoint(x, y)          -- A "Point" objektum konstruktora
  return { x = x, y = y }   -- Új objektum létrehozása és visszaadása
end
array = { newPoint(10, 20), newPoint(30, 40), newPoint(50, 60) } -- Pontok tömbje
print(array[2].y)                -- 40-et ír ki

A Lua táblák tömbrésszel és assziociatív tömbrésszel vannak implementálva. Korábban az egészet asszociatív tömbbel valósították meg, de ez az ábrázolás gyorsabb.[2]

Felhasználói modulok

szerkesztés

A Lua lehetővé teszi új modulok létrehozását. A modulok kezelésére rendelkezésre áll a Luarocks modulkezelő.

Néhány modul a leggyakoribbak közül:

Modul Leírás
LuaFileSystem Hozzáférés a könyvtárszerkezethez és a fájlok jogaihoz
LuaDoc Dokumentációs eszköz a Lua-kódhoz.
LuaSocket Lua interfész a hálózati protokollokhoz: HTTP, FTP, SMTP, MIME, URL és LTN12.
LuaSQL Lua interfész a következőkhöz: PostgreSQL, ODBC, MySQL, SQLite, Oracle és az OLE DB.
stdlib Gyakori feladatok programkönyvtára a listákhoz, táblákhoz, a funkcionális és az objektumorientált programozáshoz, meg a reguláris kifejezésekhez.
MD5 Egyszerű kriptográfia
Copas Párhuzamosság támogatása, a korutinok képességeinek bővítése
LuaZip A .zip fájlok kezeléséhez.
LuaInterface Kapcsolatot teremt a Lua és a Microsoft .NET Common Language Runtime (CLR) között.
LuaBitOps C nyelvű kiterjesztés a számokon végzett bitenkénti műveletekhez.
LuaXML Az XML és a Lua társítása.
Lanes Több Lua környezet párhuzamos futtatása
Penlight Táblák, tömbök, stringek, fájlok, könyvtárak, adatok és funkcionális eszközök kezelelésének egyszerűsítése.
Oil Egyszerű és hatékony Object Request Broker (CORBA).

Hello, World!

szerkesztés

A klasszikus Hello World! program Lua nyelven:

print("Hello World!")

A program futtatása

szerkesztés

A virtuális gép nem közvetlenül a Lua szkriptet hajtja végre, hanem futás közben bájtkódra fordítja, és ez fut. A szkriptek futtatás nélkül is fordíthatók. Maga a fordítás átlátható.

A Lua virtuális gép regiszteres, ezért a legtöbb virtuális gépnél jobban hasonlít a hardver felépítéséhez. Ez csökkenti az értékek átmásolásának és a függvényenkénti utasítások számát. A Lua 5 az egyik legrégibb regiszteres virtuális gép.[3] Az Android Dalvikja és a több nyelvre, köztük Perlre tervezett Parrot is ilyen.

Így fordítja a luac 5.1 virtuális gép a faktoriális függvényt:[4]

function <factorial.lua:1,6> (10 instructions, 40 bytes at 003D5818)
1 param, 3 slots, 0 upvalues, 1 local, 3 constants, 0 functions
        1       [2]     EQ              0 0 -1  ; – 0
        2       [2]     JMP             2       ; to 5
        3       [3]     LOADK           1 -2    ; 1
        4       [3]     RETURN          1 2
        5       [5]     GETGLOBAL       1 -3    ; factorial
        6       [5]     SUB             2 0 -2  ; – 1
        7       [5]     CALL            1 2 2
        8       [5]     MUL             1 0 1
        9       [5]     RETURN          1 2
        10      [6]     RETURN          0 1

A Luát alkalmazásokba ágyazott nyelvnek fejlesztették, ezért könnyen használható, robusztus C API-val látták el. Az API két részből áll: ezek a Lua core és a Lua auxiliary library.[5] Kiküszöböli a C kézi hivatkozáskezelését. Az API a nyelvhez hasonlóan minimalisztikus; a funkcionalitás bővítéséért az auxiliary library felelős, ami preprocesszor makrókkal egyszerűsíti a táblakezelést.

A Lua C API verem alapú. A veremműveleteket Lua függvények valósítják meg, továbbá léteznek táblakezelő függvények is, amik a veremből is hívhatók. Ez a verem indexelhető is. A Python tömbökhöz hasonlóan negatív indexek is használhatók; ezek a verem tetejétől (-1 a legfelső elem), a pozitív indexek a verem aljától számítódnak.

A C és a Lua közötti kommunikációt szintén a verem valósítja meg. A Lua függvénynek átadott argumentumok a verembe kerülnek, és az aktuális függvény lua_call utasítással hívható. Ha C függvényt hívunk Luából, akkor az a verem tetejéről veszi a paramétereket.

Lua függvény hívása C-ből:

#include <stdio.h>
#include <stdlib.h>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

int main()
{
    lua_State *L = luaL_newstate();
    if (luaL_dostring(L, "function foo (x,y) return x+y end")) exit(1);
    lua_getglobal(L, "foo");
    lua_pushinteger(L, 5);
    lua_pushinteger(L, 3);
    lua_call(L, 2, 1);
    printf("Result: %d\n", lua_tointeger(L, -1));
    return 0;
}

Fordítás és futtatás:

$ gcc -o hello -llua hello.c
$ ./hello
Result: 8

Speciális táblák

szerkesztés

A C API speciális táblákat is elérhetővé tesz, amik pszeudoindexekkel hivatkozhatók a Lua veremből. A LUA_GLOBALSINDEX tárolja a globális változókat, _G a fő névtér. A LUA_REGISTRYINDEX-ben tárolják a C függvények a Lua értékeket későbbi felhasználásra.

Kiterjesztés és kötés

szerkesztés

Kiterjesztő modulok is készíthetők a Lua API használatával. Ezek a könyvtárak kiterjesztik az értelmező funkcionalitását. A Lua szempontjából ezek névterek, vagyis táblák a maguk változóival és függvényeivel. Ezek a modulok a require kulcsszóval tölthetők be.[5]

A LuaRocks csomagkezelő rendszerből egyre több modul érhető el,[6] a CPANhoz, a RubyGemshez és a Python Eggshez hasonlóan. További források a LuaForge és a lua-users.org wiki Lua Addonsa.[7]

Vannak csomagok a grafikus felülethez, a Perl/POSIX szabályos kifejezésekhez, a titkosításhoz, a fájltömörítéshez és még sok máshoz. A legtöbb népszerű nyelvhez vannak Lua kötések, például más szkript nyelvekhez.[8] A C++ megközelítés sablon alapú, és automatikus generátorokat használ.

Alkalmazásai

szerkesztés

Manapság a videójátékok nagy része rendelkezik Lua scriptelési lehetőséggel, ezen kívüli alkalmazások:

  • A videójátékok fejlesztésében a játékfejlesztők elterjesztették a Luát, mivel gyors, könnyen beágyazható és könnyen tanulható.[9] 2012 januárjában a Game Developer Magazine a Luát hirdette győztesnek a Programming Tools kategóriában, és a Front Line Award 2011-et adományozta neki.[10] Egy példa a népszerű Minecraft videójáték; a hozzá készült Computercraft mod számítógépei is Lua nyelvet használnak.
  • A 3DMLW plugin Luát használ háromdimenziós megjelenítésre és eseménykezelésre.
  • Az Adobe Photoshop Lightroom felhasználói interfésznek.
  • Az Apache HTTP Server a 2.3 verziótól kezdve képes Lua használatára bárhol a lekérési folyamatban.
  • Az Artweaver képszerkesztőben szkriptelésre.
  • Az Awesome ablakkezelő részben Luában íródott. Konfigurációs fájlja is Lua szkript.
  • A The Canon Hack Development Kit (CHDK) nyílt forrású Canon kamerakezelőben a Lua a kettő közül az egyik szkript nyelv.
  • A Celestia csillagászat témájú tanítóprogram szkriptnyelve.
  • A Cisco ezen a nyelven implementálja a Dynamic Access Policiest az Adaptive Security Appliance-ban.
  • A Creative Technology Zen X-Fi2 hordozható médialejátszó beállításai Luában is szerkeszthetők.
  • A Damn Small Linux Luát használ mind az ablakozó rendszer, mind a parancssor kényelmi funkcióihoz.
  • A Dolphin Computer Accessben a SuperNova képernyőolvasó is Lua szkript.
  • A Fusion szerkesztő Luát használ szkriptelésre és plugin prototípushoz.
  • A NES emulator FCE Ultra forkja, a FCEUX lehetővé teszi a játékok szerkesztését Lua szkriptekkel.
  • A Flame, egy hírhedt számítógépes kémkedésre használt program.
  • A Foldit, egy fehérjehajtogató játék, lehetővé teszi a Luában írt felhasználói szkriptek alkalmazását.[11]
  • A FreePOPs levelezőrendszer webes felülete.
  • A Brazilian Digital Television System Ginga middleware-je Luát használ deklaratív környezetének szkript nyelveként.
  • A GrafX2 pixel-art szerkesztő képes Lua szkripteket futtatni képgeneráláshoz és képfeldolgozáshoz.
  • A Garry’s Mod videójátékban lehet a Lua segítségével úgynevezett "szkriptelt fegyvereket" készíteni, de objektumok is létrehozhatók.
  • Az Ipe képszerkesztő szkript és funkcionális kiterjesztései.
  • A Lego Mindstorms NXT és az NXT 2.0 is bírja a Luát.[12]
  • A lighttpd webszerver Luát használ a hook szkriptekhez a Cache Meta Language modern helyetteseként.
  • A Logitech G15 2.01 verziójának profilkezelője.
  • A LuaTeX, a pdfTeX tervezett utóda ismeri a Luát.
  • A MediaWiki új sablonnyelve.[13]
  • A MikroTik RouterOS bétája a Lua 4.x-et, a végleges kiadás a Lua 5.x-et támogatja.[14]
  • A Multimedia Fusion Developer 2 Lua kiegészítője lehetővé teszi, hogy a játékok Lua szkripteket futtassanak.
  • A MySQL Workbench elfogad Lua nyelvű kiterjesztéseket.
  • Az Nginx beágyazott Lua modulja API-t nyújt az Nginx eszközeihez, például a socketkezeléshez.[15]
  • Az nmap hálózati biztonsági szkenner szkript nyelve, az nse Luán alapul.[16]
  • A Wavecom GSM Open AT OS firmware-je elfogad Lua nyelvű felhasználói alkalmazásokat.
  • A Project Dogwaffle Professional Lua nyelvű szűrők létrehozását segíti. Ezt a DogLua szűrő segíti, és a szűrők megoszthatók a Project Dogwaffle, GIMP, Pixarra Twistedbrush és az ArtWeaver között.
  • A Prosody egy keresztplatformos Jabber/XMPP szerver Luában íródott.
  • A Reason Digital Audio Workstationben Luával írhatók le a távoli objektumok.
  • A Redis nyílt forrású adatbázisban a szerveren Lua szkriptek futtathatók, ezzel bővítve annak funkcionalitását.[17]
  • A Rockbox nyílt forrású hanglejátszó támogatja a Lua nyelvű pluginokat.
  • A SciTE új verziója bővíthető Lua szkriptekkel.
  • A Snort a 3.0-tól kezdve tartalmaz Lua értelmezőt.[18]
  • A Logitech Squeezebox zenelejátszója támogat Lua nyelvű pluginokat.
  • A Tarantool/Box NoSQL tárolt eljárásainak nyelve.
  • A TI-Nspire számológépek Lua alkalmazásokat tartalmaz specifikus API-val.
  • A Vim a 7.3-as verziójától kezdve támogatja a Lua szkriptelést.
  • A VLC a Luával segíti a szkriptelést.
  • A WeeChat IRC kliens elfogad Lua szkripteket.
  • A WinGate proxyszerver eseménykezelője és házirendje Luával éri el a belső WinGate objektumokat.[19]
  • A Wireshark hálózati csomagelemző protokoll dissectorai és post-dissectorai ismerik a Luát.[20]
  1. Luiz Henrique de Figueiredo: [ANN Lua 5.4.6 now available] (angol nyelven), 2023. május 14. (Hozzáférés: 2023. május 14.)
  2. Lua 5.1 Source Code, 2006. (Hozzáférés: 2011. március 24.)
  3. (2005) „The implementation of Lua 5.0”. J. Of Universal Comp. Sci. 11 (7), 1159–1176. o.  
  4. Kein-Hong Man: A No-Frills Introduction to Lua 5.1 VM Instructions, 2006. [2010. június 19-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. június 9.)
  5. a b Lua 5.1 Reference Manual. Lua.org. (Hozzáférés: 2009. május 24.)
  6. LuaRocks. LuaRocks wiki. (Hozzáférés: 2009. május 24.)
  7. Lua Addons. Lua-users wiki. (Hozzáférés: 2009. május 24.)
  8. Binding Code To Lua. Lua-users wiki. (Hozzáférés: 2009. május 24.)
  9. Why is Lua considered a game language?. Stack Overflow. [2013. augusztus 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2010. április 23.)
  10. Front Line Award Winners Announced. [2013. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. június 10.)
  11. Algorithm discovery by protein folding game players
  12. pbLua. [2008. december 8-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. december 8.)
  13. https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2012-01-30/Technology_report
  14. Manual:Lua. MikroTik Wiki. (Hozzáférés: 2010. április 23.)
  15. http://wiki.nginx.org/HttpLuaModule
  16. Nmap Scripting Engine. (Hozzáférés: 2010. április 10.)
  17. Redis Lua scripting
  18. Lua in Snort 3.0. [2010. május 27-i dátummal az eredetiből archiválva]. (Hozzáférés: 2010. április 10.)
  19. Vim documentation: if_lua. (Hozzáférés: 2011. augusztus 17.)
  20. Lua in Wireshark. (Hozzáférés: 2010. április 10.)

További információk

szerkesztés