Lua

A Wikipédiából, a szabad enciklopédiából
Lua
Lua-logo-nolabel.svg

Paradigma Imperatív
Megjelent 1993
Tervező Roberto Ierusalimschy
Waldemar Celes
Luiz Henrique de Figueiredo
Utolsó kiadás 5.2.0 (2011. december 16.)
Dialektusok Metalua, Idle, GSL Shell
Megvalósítások Lua, LuaJIT, LLVM-Lua, Lua Alchemy
Hatással volt rá C++, CLU, Modula, Scheme, SNOBOL
Befolyásolt nyelvek Io, GameMonkey, Squirrel, Falcon, MiniD
Operációs rendszer többplatformos
Licenc MIT License
Weboldal

A Lua (portugálul: hold) programozási nyelv egy nyílt forráskódú beágyazható szkriptnyelv, amelyet 1993-ban fejlesztettek ki a brazíliai Pontifical Catholic Universityn. 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.

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 | forrásszöveg szerkesztése]

Nyelvi elemek[szerkesztés | forrásszöveg szerkesztése]

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 nagybetűérzékeny.

Típusok[szerkesztés | forrásszöveg szerkesztése]

A Lua beépített típusai:

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

A nil típusnak egyetlen eleme van, a nil. A globális változók alapértelmezett értéke; a változók törölhetők is úgy, hogy értéküket nilre állítjuk. 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 ==, ~=, <, >, <=, >= 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 cukorka 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, legfeljebb 255 karakteres stringek megadhatók egyszeres vagy kétszeres idézőjelek között. Hosszabb stringek megadhatók különböző szintű határolók között. Az n-edik szintű határolók: egy nyitó zárójel, n egyenlőségjel, egy másik nyitó zárójel, majd a string végén egy hasonló jelsorozat, csak csukó zárójelekkel. A hosszú stringek így egymásba ágyazhatók. A hosszú stringek nem értelmeződnek, a bennük 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 a stdio C könyvtárat használja, ami azonban nem garantálja a különféle kódolások megfelelő kezelését. A számok és a stringek automatikusan konvertálódnak.

Az escape sorozatok ugyanazok, mint a C-ben.

A userdata C típusú adatokat 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á.

Táblák[szerkesztés | forrásszöveg szerkesztése]

A table a Lua egyetlen összetett típusa, ami a tömbök és az asszociatív tömbök közös általánosítása. Két részből állnak, a tömb és az asszociatív tömb részből. A ciklusok végigiterálhatnak csak a tömb részen, vagy az egész táblán is. A táblák indexelése a legtöbb nyelvtől eltérően 1-től kezdődik. Explicit lehet értéket adni a nulladik elemnek, de a tömbrészen végigiteráló ciklusok ezt az elemet kihagyják.

Tömb típusú táblák létrehozhatók így:

x={3.14, [[ez egy string]], {}}

Asszociatív tömb esetén az egyes kulcsokhoz egyenként kell értéket rendelni.

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:

local myTable={"a","b"}
table.insert(myTable,"c") --print(unpack(myTable)) --> a   b   c
table.remove(myTable,2) --print(unpack(myTable)) --> a   c

Megjegyzések[szerkesztés | forrásszöveg szerkesztése]

Egysoros megjegyzés:

-- Megjegyzés

Többsoros megjegyzés:

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

Változók[szerkesztés | forrásszöveg szerkesztése]

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: a[i]. Ha a kulcs string, akkor szabad a[i] és a.i alakban is hivatkozni rá; ez azonban különbözik az a[i] értéktől.

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 localnak 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 | forrásszöveg szerkesztése]

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

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

Ciklusok[szerkesztés | forrásszöveg szerkesztése]

Elöltesztelő ciklus:

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

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

Hátultesztelő ciklus:

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 cukorka, nem hoz létre új láthatósági tartományt.

Számlálós ciklus:

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.

delta = 1 esetén a lépésköz elhagyható:

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

Iteráló ciklus:

for elem in lista do
    -- Utasítások
end

A lista összes elemén végigiterál, egészen addig, amíg nil értéket nem kap.

Függvények[szerkesztés | forrásszöveg szerkesztése]

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 addto(x)
  -- Return a new function that adds x to the argument
  return function(y)
    --[[ When we refer to the variable x, which is outside of the current
 scope and whose lifetime is longer than that of this anonymous
 function, Lua creates a closure.]]
    return x + y
  end
end
fourplus = addto(4)
print(fourplus(3))  -- Prints 7

Valahányszor meghívódik az addto, annyiszor új lezárt jön létre az x változóhoz. Így a névtelen függvénymindig 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 | forrásszöveg szerkesztése]

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 nth-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 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.
print(Bill.Name, Bill.Age)             -- A name és az age attributumok kiíratása.

Struktúrák[szerkesztés | forrásszöveg szerkesztése]

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:

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

Névterek[szerkesztés | forrásszöveg szerkesztése]

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

Point = {}
Point.new = function (x, y)
  return {x = x, y = y}
end
Point.set_x = function (point, x)
  point.x = x
end

Tömbök[szerkesztés | forrásszöveg szerkesztése]

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)                    -- A nulladik index nem számítódik bele a hosszba.

Objektumok tömbjeként:

function Point(x, y)        -- A "Point" objektum konstruktora
  return { x = x, y = y }   -- Új objektum létrehozása és visszaadása
end
array = { Point(10, 20), Point(30, 40), Point(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.[1]

Felhasználói modulok[szerkesztés | forrásszöveg szerkesztése]

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 Microsofts .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 | forrásszöveg szerkesztése]

A klasszikus Hello World! program Lua nyelven:

print("Hello World!")

A program futtatása[szerkesztés | forrásszöveg szerkesztése]

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.[2] 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:[3]

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

C API[szerkesztés | forrásszöveg szerkesztése]

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.[4] Kiküszöböli a C kézi hivatkozáskezelését. Az API a nyelvhez hasonó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.

Verem[szerkesztés | forrásszöveg szerkesztése]

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 ésa 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.

Példa[szerkesztés | forrásszöveg szerkesztése]

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 | forrásszöveg szerkesztése]

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 | forrásszöveg szerkesztése]

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.[4]

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

Vannak csomagok a grafikus felülethez, a Perl/POSIX szabályos kifejezésekhez, a titkosításhoz, afá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.[7] A C++ megközelítés sablon alapú, és automatikus generátorokat használ.

Alkalmazásai[szerkesztés | forrásszöveg szerkesztése]

  • A videojá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ó.[8] 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.[9] Egy példa a népszerű Minecraft nevű videojá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 szkript nyelve.
  • 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.[10]
  • A FreePOPs levelezőrendszer webes felülete.
  • A Brazilian Digital Television System Ginga middlewarja 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 nevű videojá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.[11]
  • 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.[12]
  • A MikroTik RouterOS bétája a Lua 4.x-et, a végleges kiadás a Lua 5.x-et támogatja.[13]
  • 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.[14]
  • Az nmap hálózati biztonsági szkenner szkript nyelve, az nse Luán alapul.[15]
  • A Wavecom GSM Open AT OS firmware-ja 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.[16]
  • 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.[17]
  • 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.[18]
  • A Wireshark hálózati csomagelemző protokoll dissectorai és post-dissectorai ismerik a Luát.[19]

Külső hivatkozások[szerkesztés | forrásszöveg szerkesztése]

Jegyzetek[szerkesztés | forrásszöveg szerkesztése]

  1. Lua 5.1 Source Code, 2006. (Hozzáférés: 2011. március 24.)
  2. (2005.) „The implementation of Lua 5.0”. J. Of Universal Comp. Sci. 11 (7), 1159–1176. o.  
  3. Kein-Hong Man: A No-Frills Introduction to Lua 5.1 VM Instructions, 2006
  4. ^ a b Lua 5.1 Reference Manual. Lua.org. (Hozzáférés: 2009. május 24.)
  5. LuaRocks. LuaRocks wiki. (Hozzáférés: 2009. május 24.)
  6. Lua Addons. Lua-users wiki. (Hozzáférés: 2009. május 24.)
  7. Binding Code To Lua. Lua-users wiki. (Hozzáférés: 2009. május 24.)
  8. Why is Lua considered a game language?. Stack Overflow. (Hozzáférés: 2010. április 23.)
  9. Front Line Award Winners Announced
  10. Algorithm discovery by protein folding game players
  11. pbLua
  12. http://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2012-01-30/Technology_report
  13. Manual:Lua. MikroTik Wiki. (Hozzáférés: 2010. április 23.)
  14. http://wiki.nginx.org/HttpLuaModule
  15. Nmap Scripting Engine. (Hozzáférés: 2010. április 10.)
  16. Redis Lua scripting
  17. Lua in Snort 3.0. (Hozzáférés: 2010. április 10.)
  18. Vim documentation: if_lua. (Hozzáférés: 2011. augusztus 17.)
  19. Lua in Wireshark. (Hozzáférés: 2010. április 10.)

Irodalom[szerkesztés | forrásszöveg szerkesztése]