Hlavní navigace

ULua: univerzální distribuce programovacího jazyka Lua

29. 9. 2021
Doba čtení: 19 minut

Sdílet

 Autor: Depositphotos
Představíme si projekt nazvaný ULua, což je distribuce tohoto programovacího jazyka pro všechny tři nejpoužívanější operační systémy, která kromě LuaJITu obsahuje i správce balíčků upkg.

Obsah

1. ULua: univerzální distribuce programovacího jazyka Lua

2. Lua ve funkci univerzálního vestavitelného skriptovacího jazyka

3. Projekt ULua se představuje

4. Instalace nástroje ULua

5. Spuštění interpretru LuaJIT poskytovaného nástrojem ULua

6. Správce balíčků upkg

7. Výpis dostupných balíčků, které lze nainstalovat

8. Ukázka instalace knihovny moses

9. Otestování nainstalované knihovny moses

10. Ukázka instalace knihovny deque

11. Otestování nainstalované knihovny deque

12. Balíček obsahující binární (nativní) kód

13. Spustitelné soubory nainstalované v rámci instalace balíčku

14. Zobrazení stavu ekosystému Lua spravovaného nástrojem ULua

15. Povýšení balíčků na poslední dostupnou verzi

16. Nastavení proměnné PATH

17. Obsah dalšího článku o jazyku Lua

18. Články a seriály o jazyku Lua a souvisejících technologiích na Rootu

19. Odkazy na Internetu

1. ULua: univerzální distribuce programovacího jazyka Lua

S programovacím jazykem Lua jsme se již na stránkách tohoto serveru setkali, a to dokonce již mnohokrát. Většina článků o tomto jazyku je shrnuta do seriálu Programovací jazyk Lua a taktéž jsme se Luou zabývali ve druhém seriálu nazvaném Torch: framework pro strojové učení. Víme již, že se tento programovací jazyk stal oblíbený například mezi tvůrci her, v nichž je použit pro skriptování. To ovšem není zdaleka vše, protože Lua je použita například v systému LuaTeX, v databázi Redis, ve webovém serveru Nginx a v neposlední řadě i v textovém editoru Neovim. Jednoduše použitelná syntaxe a současně i poměrně velká vyjadřovací schopnost jazyka Lua by však pravděpodobně nedostačovala pro jeho masovější rozšíření, a to zejména v situaci, kdy tuto niku programovacích jazyků do značné míry okupuje Python, kterému se již úspěšně podařilo „odstavit“ některé konkurenty.

Hlavním důvodem, proč jsou některé hry, například Escape from Monkey Island, Grim Fandango, Fish Fillets, Neverwinter Nights či MDK2 z menší či větší části naprogramované právě v jazyku Lua, spočívá v tom, že kombinace nízkoúrovňového a skriptovacího jazyka umožňuje soustředit se při vývoji na podstatné věci – herní engine vytvořit co nejefektivnější s využitím všech možností nízkoúrovňového jazyka a naopak herní scénář a logiku hry naskriptovat s co největším urychlením cyklu oprava–překlad–spuštění. V mnoha případech se také využívá další užitečné vlastnosti jazyka Lua – celý překladač i interpret vygenerovaného bajtkódu (popř. pouze interpret) je možné velmi snadno zabudovat do jiné aplikace, přičemž se výsledná velikost spustitelného souboru této aplikace zvětší o cca 70 kB (popř. lze volat dynamickou knihovnu o řádově stejné velikosti), což není mnoho, když si uvědomíme, že dostáváme k dispozici plnohodnotný vysokoúrovňový programovací jazyk (ostatně Lua se díky své malé velikosti používá i pro pouhé zpracování konfiguračních souborů, které díky tomu mohou obsahovat různé konstanty, výrazy atd.).

2. Lua ve funkci univerzálního vestavitelného skriptovacího jazyka

Mnozí programátoři, mezi jinými i John Walker (jeden z vývojářů AutoCADu) se netají tím, že právě zabudování programovacího (skriptovacího) jazyka do jejich aplikací mělo velký význam pro jejich úspěch, protože to umožnilo mnoha dalším vývojářům rozšiřovat funkčnost původní aplikace a tím zvýšit její atraktivitu pro uživatele (a to bez jakékoli snahy či finanční pomoci od tvůrců původní rozšiřitelné aplikace).

Poznámka: původním skriptovacím jazykem AutoCADu byl AutoLISP.

Lua se skutečně, a nejedná se zdaleka pouze o hry, velmi často používá jako vestavěný skriptovací jazyk, takže jeho uživatelé jsou zvyklí na určitou formu minimalismu (pokud bychom totiž měli Luu charakterizovat třemi slovy, zněla by takto: „minimalistický vysokoúrovňový jazyk“). Ovšem důraz na minimalistické pojetí jak samotného jazyka, tak i jeho ekosystému je dvojsečná zbraň. Zejména se to týká právě zmíněného ekosystému, který stále není tak dotažený, jako například ekosystém (částečně) konkurenčního Pythonu. Existuje sice nástroj pro správu balíčků LuaRocks, ovšem ne všechny knihovny pro Luu ho využívají a navíc zabalení tak velkých projektů, jako je výše zmíněný Torch či Sci-lua, je problematické, protože většinou vyžaduje i použití LuaJITu namísto standardního interpretru Luy. Existuje větší množství projektů, které se snaží o vylepšení tohoto stavu. Jeden z nejdotaženějších projektů se nazývá ULua neboli „Univerzální distribuce jazyka Lua“. A právě tímto projektem se budeme zabývat v navazujících kapitolách.

3. Projekt ULua se představuje

Projekt ULua v první řadě obsahuje LuaJIT. Již z názvu tohoto nástroje je zřejmé, že se jedná o takzvaný Just in Time překladač, který je možné použít společně s programovacím jazykem Lua. Překlad do nativního kódu je tedy prováděn při běhu aplikace, a to na základě dynamické analýzy chování za běhu – jen tak je totiž možné zjistit, které cesty v programu se mají přeložit do nativního kódu bez nutnosti použití podmíněných skoků, odvodit skutečně použité datové typy atd. LuaJIT je z velké části dílem jediného programátora, který se jmenuje Mike Pall. To je velmi zajímavá skutečnost, zvláště když si uvědomíme, že LuaJIT je v současné verzi velmi kvalitní produkt podporující větší množství procesorových architektur (na tomto místě je pro porovnání důležité se zmínit o tom, jak dlouho trvalo, než byl JIT pro JVM adaptován například pro procesory ARM či ARM64; u dalších architektur jsme stále odkázáni na Zero a Shark). Přechod na LuaJIT je pro běžného programátora triviální.

Ovšem součástí projektu ULua je i správce balíčků nazvaný upkg. Tento správce balíčků dokáže nainstalovat jeden z 300 v současnosti podporovaných balíčků a to včetně závislých nativních knihoven (a spousta balíčků pro jazyk Lua má i svoji nativní část).

Poznámka: 300 balíčků sice zní jako malé číslo, zvláště v porovnání s Pypi, které se chlubí 320 tisíci balíčky. Skutečně se jedná o malé číslo, ovšem většina z oněch 300 balíčků je poměrně pečlivě vybrána a neobsahuje různé „školní“ projekty nebo výsledky pokusu vývojářů o použití Pypi. Mezi oněmi třemi stovkami balíčků nalezneme i sci a sci-lang, kterými se budeme zabývat v samostatném článku.

4. Instalace nástroje ULua

Průběh instalace nástroje ULua si ukážeme na systému s Fedorou 34, i když ve skutečnosti bude instalace prakticky totožná i na dalších distribucích Linuxu:

$ cat /etc/redhat-release
 
Fedora release 34 (Thirty Four)
Poznámka: instalace se provede nezávisle na tom, zda již v systému máte přítomen interpret jazyka Lua či nikoli.

Nejprve je nutné stáhnout Zip archiv obsahující kostru nástroje ULua nezávislou na použitém operačním systému (lze ho tedy použít i například na Windows atd.):

$ wget https://ulua.io/download/ulua~latest.zip
 
--2021-09-23 08:43:52--  https://ulua.io/download/ulua~latest.zip
Resolving ulua.io (ulua.io)... 2606:4700:3032::6815:2d44, 2606:4700:3030::ac43:d2c0, 104.21.45.68, ...
Connecting to ulua.io (ulua.io)|2606:4700:3032::6815:2d44|:443... failed: No route to host.
Connecting to ulua.io (ulua.io)|2606:4700:3030::ac43:d2c0|:443... failed: No route to host.
Connecting to ulua.io (ulua.io)|104.21.45.68|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 6868561 (6.5M) [application/zip]
Saving to: ‘ulua~latest.zip’
 
ulua~latest.zip                         100%[==============================================================================>]   6.55M  --.-KB/s    in 0.08s
 
2021-09-23 08:43:53 (84.2 MB/s) - ‘ulua~latest.zip’ saved [6868561/6868561]

Ve druhém kroku pochopitelně Zip archiv rozbalíme:

$ unzip ulua~latest.zip
 
Archive:  ulua~latest.zip
   creating: ulua/
   creating: ulua/bin/
 
 
 
  inflating: ulua/serpent/0_28+103/__t/bench.lua
  inflating: ulua/serpent/0_28+103/__t/test.lua
  inflating: ulua/serpent/0_28+103/init.lua

Po rozbalení by měl vzniknout adresář nazvaný ulua, do kterého se přesuneme:

$ cd ulua

Struktura tohoto adresáře ihned po instalaci by měla vypadat následovně:

$ tree -d -L 3
 
.
└── ulua
    ├── bin
    ├── clib_libcurl
    │   └── 7_42_1+3
    ├── cURL
    │   └── 0_3_1+103
    ├── host
    │   ├── init
    │   ├── pkg
    │   └── tmp
    ├── lcurl
    │   └── 0_3_1+103
    ├── lfs
    │   └── 1_6_3+203
    ├── luajit
    │   └── 2_1_head20151128
    ├── pkg
    │   └── 1_0_beta10
    └── serpent
        └── 0_28+103

5. Spuštění interpretru LuaJIT poskytovaného nástrojem ULua

Přímo v adresáři ulua nalezneme interpret programovacího jazyka Lua. Ovšem ve skutečnosti se nejedná o standardní (původní) interpret, ale o LuaJIT zmíněný v úvodních kapitolách (i když jméno spustitelného souboru s interpretrem je stále lua). Před spuštěním LuaJITu je nutné zvolit použitou architekturu, resp. na platformě x86/x86–64 zvolit, zda se má použít 32bitová varianta nebo varianta 64bitová. Volba se provede přes proměnnou prostředí nazvanou BIT, tedy následujícím způsobem:

$ export BIT=64

Nyní je již možné interpret spustit a začít používat:

$ ./lua
 
LuaJIT 2.1.0-beta1 -- Copyright (C) 2005-2015 Mike Pall. http://luajit.org/
JIT: ON SSE2 SSE3 SSE4.1 fold cse dce fwd dse narrow loop abc sink fuse
>
Poznámka: mnohem častěji se pochopitelně setkáme s tím, že se interpretru předá název souboru se skriptem, který se má spustit (interpretovat).

6. Správce balíčků upkg

Dalším důležitým spustitelným souborem, který je součástí projektu ULua, je správce balíčků nazvaný Universal Lua package manager neboli zkráceně upkg. Ten se ovšem nenachází přímo v adresáři ulua ale v podadresáři ulua/bin. Přesuneme se tedy do tohoto podadresáře:

$ cd bin
 
$ pwd
/home/tester/ulua/bin

Nyní je možné tohoto správce balíčků spustit:

$ ./upkg
 
Universal Lua package manager. Usage:
upkg command [-s] [name] [version]
  command : one of "status", "available", "add", "remove", "update"
  -s      : enable searching (only for "status" and "available" commands)
  name    : module name
  version : module version

Vidíme, že jsou podporovány základní příkazy pro manipulaci s balíčky, tedy add, removeupdate. Kromě toho je možné zobrazit seznam dostupných balíčků příkazem available, popř. si nechat zobrazit aktuální stav nainstalovaných balíčků příkazem status.

7. Výpis dostupných balíčků, které lze nainstalovat

Víme již, že systém ULua v současnosti oficiálně podporuje přibližně tři sta balíčků. Tyto balíčky (a jejich verze, typicky sémantické verze) lze zobrazit následujícím příkazem:

$ ./upkg available

Výsledek je v textu článku zkrácen:

Available modules:
+ 30log                     | 30log : 30 lines library for object orientation                                  | 1.3.0-103, 1.0.0-103, 0.9.1-103
+ 30log-clean               | 30log : 30 lines library for object orientation                                  | 1.3.0-103
+ 30log-commons             | 30log : 30 lines library for object orientation                                  | 1.3.0-103
+ 30log-global              | 30log : 30 lines library for object orientation                                  | 1.3.0-103
+ 30log-singleton           | 30log : 30 lines library for object orientation                                  | 1.3.0-103
+ 30logclean                | 30log : 30 lines library for object orientation                                  | 1.0.0-103, 0.9.1-103
+ 30logglobal               | 30log : 30 lines library for object orientation                                  | 1.0.0-103, 0.9.1-103
+ AesFileEncrypt            | aesfileencrypt : A simple file encryption library                                | 0.1.3-103
...
...
...
+ xml                       | xml : Very fast xml parser based on RapidXML                                     | 1.1.3-103
+ xml2lua                   | xml2lua : An XML Parser written entirely in Lua that works for Lua 5.1 to 5.3    | 1.2-403, 1.2-203, 1.0-103, 1.0-3
+ xmlhandler                | xml2lua : An XML Parser written entirely in Lua that works for Lua 5.1 to 5.3    | 1.2-403, 1.2-203, 1.0-103, 1.0-3
+ xssfilter                 | xssfilter : A filter to prevernt cross-site scripting (XSS) attacks              | 10.12.28-103
+ xsys                      | extended Lua system                                                              | 1.0.2
+ xxtea                     | xxtea : XXTEA for Lua.                                                           | 1.0.1-103, 1.0.0-103
+ yaml                      | yaml : Very fast yaml parser based on libYAML by Kirill Simonov                  | 1.1.2-103
+ zmq                       | lzmq-zmq : Wrapper around lzmq library to be compatiable with lua-zmq library    | 0.1.0-103

8. Ukázka instalace knihovny moses

Ukažme si nyní způsob instalace knihovny moses, s níž jsme se již na stránkách Roota setkali ve dvojici článků (viz též osmnáctou kapitolu). Nejprve se přesvědčíme, že je tato knihovna dostupná ve formě balíčku spravovaného nástrojem ULua:

$ ./upkg available |grep moses
 
+ moses                     | moses : Utility-belt library for functional programming in Lua                   | 2.1.0-103, 1.6.1-103, 1.4.0-103
+ moses_min                 | moses : Utility-belt library for functional programming in Lua                   | 2.1.0-103, 1.6.1-103, 1.4.0-103

Samotná instalace proběhne prakticky okamžitě po zadání následujícího příkazu:

$ ./upkg add moses
 
Installing matching module and its requirements:
+ moses     | moses : Utility-belt library for functional programming in Lua | 2.1.0-103
+ moses_min | moses : Utility-belt library for functional programming in Lua | 2.1.0-103
Confirm (y/n)? y
Downloading:
+ /pkg/moses_min/2.1.0-103 | 100% of 93KB
+ /pkg/moses/2.1.0-103     | 100% of 101KB
Done

Nyní by se měla struktura adresáře ulua změnit, protože do něho byly přidány dva podadresáře, které jsou v následujícím výpisu zvýrazněny:

$ tree -d -L 3
 
.
└── ulua
    ├── bin
    ├── clib_libcurl
    │   └── 7_42_1+3
    ├── cURL
    │   └── 0_3_1+103
    ├── host
    │   ├── init
    │   ├── pkg
    │   └── tmp
    ├── lcurl
    │   └── 0_3_1+103
    ├── lfs
    │   └── 1_6_3+203
    ├── luajit
    │   └── 2_1_head20151128
    ├── moses
    │   └── 2_1_0+103
    ├── moses_min
    │   └── 2_1_0+103
    ├── pkg
    │   └── 1_0_beta10
    └── serpent
        └── 0_28+103
 
24 directories
Poznámka: nyní již dává struktura adresáře ulua větší smysl – kromě interpretru LuaJIT a speciálního podadresáře bin obsahuje další podadresáře, z nichž každý obsahuje určitou verzi balíčku určeného pro jazyk Lua. Tyto podadresáře jsou kompletně spravovány nástrojem upkg.

9. Otestování nainstalované knihovny moses

Nyní si můžeme vytvořit jednoduchý skript, na němž si ověříme, zda byla knihovna moses skutečně nainstalována korektně. Tento skript může vypadat následovně:

M = require "moses"
 
 
-- tisk obsahu pole
function printArray(array)
    for index, value in ipairs(array) do
        print(index, value)
    end
end
 
 
-- oddělení obsahu
function printSeparator()
    print("-------------------------------")
end
 
 
-- prázdné pole při neuvedení rozsahu
a0 = M.range()
printSeparator()
print("range()")
printArray(a0)
 
 
-- první pole začínající standardně od jedničky
a1 = M.range(10)
printSeparator()
print("range(10)")
printArray(a1)
 
 
-- druhé pole s explicitní specifikací hodnoty prvního prvku
a2 = M.range(1, 10)
printSeparator()
print("range(1, 10)")
printArray(a2)
 
 
-- třetí pole se specifikací kroku (rozdílu mezi dvěma prvky)
a3 = M.range(1, 10, 2)
printSeparator()
print("range(1, 10, 2)")
printArray(a3)
 
 
-- čtvrté pole s prvky počítanými pozpátku
a4 = M.range(10, 1)
printSeparator()
print("range(10, 1)")
printArray(a4)
 
 
-- páté pole počítané pozpátku s kladným krokem
a5 = M.range(10, 1, 2)
printSeparator()
print("range(10, 1, 2)")
printArray(a5)
 
 
-- šesté pole počítané pozpátku se záporným krokem
a6 = M.range(10, 1, -2)
printSeparator()
print("range(10, 1, -2)")
printArray(a6)
 
 
-- sedmé pole s neceločíselným krokem
a7 = M.range(1, 5, 0.5)
printSeparator()
print("range(10, 5, 0.5)")
printArray(a7)
 
 
-- osmé pole s neceločíselným krokem a počáteční hodnotou typu double
a8 = M.range(1.0, 5, 0.5)
printSeparator()
print("range(10, 5, 0.5)")
printArray(a8)
 
 
-- deváté pole testující vliv problematické hodnoty 0.1
a9 = M.range(0, 1, 0.1)
printSeparator()
print("range(0, 1, 0.1)")
printArray(a9)
 
 
-- desáté pole s počáteční hodnotou typu double
a10 = M.range(0.0, 1, 0.1)
printSeparator()
print("range(0.0, 1, 0.1)")
printArray(a9)

Skript spustíme běžným způsobem, pouze musíme použít lokální interpret jazyka Lua:

$ ulua/lua test1.lua

Skript by se měl spustit a vypsat korektní výsledky:

-------------------------------
range()
-------------------------------
range(10)
1       1
2       2
3       3
4       4
5       5
6       6
7       7
8       8
9       9
10      10
-------------------------------
range(1, 10)
1       1
2       2
3       3
4       4
5       5
6       6
7       7
8       8
9       9
10      10
-------------------------------
range(1, 10, 2)
1       1
2       3
3       5
4       7
5       9
-------------------------------
range(10, 1)
1       10
2       9
3       8
4       7
5       6
6       5
7       4
8       3
9       2
10      1
-------------------------------
range(10, 1, 2)
1       10
-------------------------------
range(10, 1, -2)
1       10
2       8
3       6
4       4
5       2
-------------------------------
range(10, 5, 0.5)
1       1
2       1.5
3       2
4       2.5
5       3
6       3.5
7       4
8       4.5
9       5
-------------------------------
range(10, 5, 0.5)
1       1
2       1.5
3       2
4       2.5
5       3
6       3.5
7       4
8       4.5
9       5
-------------------------------
range(0, 1, 0.1)
1       0
2       0.1
3       0.2
4       0.3
5       0.4
6       0.5
7       0.6
8       0.7
9       0.8
10      0.9
11      1
-------------------------------
range(0.0, 1, 0.1)
1       0
2       0.1
3       0.2
4       0.3
5       0.4
6       0.5
7       0.6
8       0.7
9       0.8
10      0.9
11      1

10. Ukázka instalace knihovny deque

Prakticky stejným způsobem si můžeme nainstalovat i další balíčky, například balíček s knihovnou implementující obousměrnou frontu, resp. přesněji řečeno frontu, do které je možné přidávat prvky jak na začátek, tak i na konec. Balíček s touto knihovnou se jmenuje deque:

$ ./upkg available |grep deq
 
+ deque                     | deque : Implementation of a double-ended queue in Lua.                           | 1.0-103

Průběh instalace je totožný s instalací balíčku moses

$ ./upkg add deque
 
Installing matching module and its requirements:
+ deque | deque : Implementation of a double-ended queue in Lua. | 1.0-103
Confirm (y/n)? y
Downloading:
+ /pkg/deque/1.0-103 | 100% of 3KB
Done

Výsledná struktura adresáře ulua:

$ tree -d -L 3
 
.
└── ulua
    ├── bin
    ├── clib_libcurl
    │   └── 7_42_1+3
    ├── cURL
    │   └── 0_3_1+103
    ├── deque
    │   └── 1_0+103
    ├── host
    │   ├── init
    │   ├── pkg
    │   └── tmp
    ├── lcurl
    │   └── 0_3_1+103
    ├── lfs
    │   └── 1_6_3+203
    ├── luajit
    │   └── 2_1_head20151128
    ├── moses
    │   └── 2_1_0+103
    ├── moses_min
    │   └── 2_1_0+103
    ├── pkg
    │   └── 1_0_beta10
    └── serpent
        └── 0_28+103
 
24 directories

11. Otestování nainstalované knihovny deque

Základní funkce poskytované knihovnou deque, která je dostupná v rámci balíčku se stejným jménem, otestujeme snadno tímto skriptem, který ověří práci s frontou:

local deque = require "deque"
 
local q = deque.new()
print(q)
 
for key,value in pairs(getmetatable(q)) do
    print(key, value)
end
 
q:pushRight("prvni")
q:pushRight("druhy")
q:pushRight("treti")
 
print(q:popRight())
print(q:popRight())
print(q:popRight())

Výsledek po spuštění tohoto skriptu:

Deque containing 0 item(s)
iterLeft        function: 0x407f41e8
new     function: 0x407f5830
peekRight       function: 0x407f4248
iter    function: 0x407f41e8
sendLeft        function: 0x407f4288
__index table: 0x407f2ad0
isEmpty function: 0x407f32d0
peekLeft        function: 0x407f4228
iterRight       function: 0x407f4208
popRight        function: 0x407f41c8
pushLeft        function: 0x407f3358
popLeft function: 0x407f4188
reverse function: 0x407f42a8
sendRight       function: 0x407f4268
pushRight       function: 0x407f3398
__tostring      function: 0x407f2af8
clear   function: 0x407f57f8
getIndex        function: 0x407f3338
treti
druhy
prvni
Poznámka: pochopitelně by bylo vhodné ověřit i další metody objektu typu deque.

12. Balíček obsahující binární (nativní) kód

Mnoho balíčků s knihovnami pro jazyk Lua neobsahuje pouze zdrojové kódy psané přímo v Lue, ale například i části naprogramované v jazyce C popř. závislosti na nativních (céčkových) knihovnách. Příkladem takového balíčku je sci-lua, kterému se budeme podrobněji věnovat v samostatném článku. Nejprve se ujistěme, že je takový balíček vůbec dostupný:

$ ./upkg available |grep sci

S výsledky:

+ adoc_cmd_ext              | adoc_cmd_ext : A library and script to handle AsciiDoc Command language extens.. | 0.1.0-3
+ ascii85                   | lascii85 : An ASCII85 library for Lua                                            | 20120927-103
+ printable_chars           | printable_chars : Functions to get the ascii printable chars from a byte string. | 0.1-403, 0.1-203
+ sci                       | general purpose scientific computing library                                     | 1.0.beta12, 1.0.beta11, 1.0.beta10, 1.0.beta9
+ sci-lang                  | Syntax extensions to LuaJIT for scientific computing                             | 1.0.beta10

Balíček, který hledáme, se jmenuje sci a druhý podpůrný balíček pak sci-lang. Nainstalujeme tedy první z těchto balíčků, a to nám již známým příkazem:

$ ./upkg add sci
 
Installing matching module and its requirements:
+ clib_libopenblas | OpenBLAS : An optimized BLAS library         | 0.2.15
+ sci              | general purpose scientific computing library | 1.0.beta12
+ xsys             | extended Lua system                          | 1.0.2
Confirm (y/n)? y
...
...
...
Poznámka: povšimněte si, že první závislý balíček bude obsahovat binární (nativní) části (viz též stránky tohoto projektu).

Po instalaci je při pohledu na obsah adresáře ulua patrné, že skutečně došlo jak k instalaci požadovaného balíčku, tak i některých nativních knihoven (význam předpony „clib“ je pravděpodobně zřejmý):

$ tree -d -L 2
.
├── bin
├── clib_libcurl
│   └── 7_42_1+3
├── clib_libopenblas
│   └── 0_2_15
├── cURL
│   └── 0_3_1+103
├── deque
│   └── 1_0+103
├── host
│   ├── init
│   ├── pkg
│   └── tmp
├── lcurl
│   └── 0_3_1+103
├── lfs
│   └── 1_6_3+203
├── luajit
│   └── 2_1_head20151128
├── moses
│   └── 2_1_0+103
├── moses_min
│   └── 2_1_0+103
├── pkg
│   └── 1_0_beta10
├── sci
│   └── 1_0_beta12
├── serpent
│   └── 0_28+103
└── xsys
    └── 1_0_2
 
31 directories

Doplňme test, že skutečně došlo k lokální instalaci nativních knihoven:

$ ls -l ulua/clib_libopenblas/0_2_15/Linux/x64
 
total 36812
-rw-r--r--. 1 tester tester    92536 Nov  1  2015 libgcc_s.so
-rw-r--r--. 1 tester tester  1190352 Nov  1  2015 libgfortran.so
-rwxr-xr-x. 1 tester tester 36147837 Nov  1  2015 libopenblas.so
-rw-r--r--. 1 tester tester   257176 Nov  1  2015 libquadmath.so
Poznámka: zde je mimochodem patrné, že OpenBLAS závisí i na Fortranu, což ovšem není v oblasti numerické matematiky větším překvapením.

13. Spustitelné soubory nainstalované v rámci instalace balíčku

Balíček sci navíc obsahuje i spustitelné soubory – jeden pro Unixové systémy, druhý pro Windows. Tyto soubory jsou vytvořeny v podadresáři ulua/bin, o čemž se pochopitelně můžeme velmi snadno přesvědčit:

$ ls -l ulua/bin/
 
total 16
-rwxr-xr-x. 1 tester tester 178 Sep 26 11:58 scilua
-rwxr-xr-x. 1 tester tester 198 Sep 26 11:58 scilua.cmd
-rwxr-xr-x. 1 tester tester 167 Sep 26 11:58 upkg
-rwxr-xr-x. 1 tester tester 187 Sep 26 11:58 upkg.cmd

Příslušný soubor (v mém případě pro Linux) lze snadno spustit a otestovat, že všechny moduly atd. jsou dostupné:

$ ./ulua/bin/scilua
 
LuaJIT Language Toolkit usage: luajit [options]... [script [args]...].
 
Available options are:
  -b ...    Save or list bytecode.
  -c ...    Generate Lua code and run.
            If followed by the "v" option the generated Lua code
            will be printed.

14. Zobrazení stavu ekosystému Lua spravovaného nástrojem ULua

Jednoduchým způsobem lze zjistit i aktuální stav lokálního ekosystému programovacího jazyka Lua spravovaného nástrojem ULua. Nejprve se opět přesuneme do podadresáře ulua/bin:

$ cd ~/ulua/bin
 
$ pwd
/home/tester/ulua/bin

A zadáme příkaz:

$ ./upkg status

V případě, že jste postupovali podle kroků popsaných v předchozích kapitolách, měly by se zobrazit tyto balíčky (a i jejich verze by měly odpovídat níže zobrazeným sémantickým verzím):

Installed modules:
+ cURL             | cURL: Lua binding to libcurl                                         | 0.3.1-103
+ clib_libcurl     | free and easy-to-use client-side URL transfer library                | 7.42.1-3
+ clib_libopenblas | OpenBLAS : An optimized BLAS library                                 | 0.2.15
+ deque            | deque : Implementation of a double-ended queue in Lua.               | 1.0-103
+ lcurl            | cURL: Lua binding to libcurl                                         | 0.3.1-103
+ lfs              | luafilesystem : File System Library for the Lua Programming Language | 1.6.3-203
+ luajit           | LuaJIT: Just-In-Time Compiler (JIT) for Lua                          | 2.1.head20151128
+ moses            | moses : Utility-belt library for functional programming in Lua       | 2.1.0-103
+ moses_min        | moses : Utility-belt library for functional programming in Lua       | 2.1.0-103
+ pkg              | ULua package manager                                                 | 1.0.beta10
+ sci              | general purpose scientific computing library                         | 1.0.beta12
+ sci-lang         | Syntax extensions to LuaJIT for scientific computing                 | 1.0.beta10
+ serpent          | serpent : Lua serializer and pretty printer                          | 0.28-103
+ xsys             | extended Lua system                                                  | 1.0.2

15. Povýšení balíčků na poslední dostupnou verzi

Dalším příkazem poskytovaným nástrojem upkg je příkaz update, kterým je možné povýšit balíčky či zvolený balíček na novou verzi (pochopitelně pokud je nová verze dostupná). Funkci tohoto příkazu si lze snadno otestovat, protože samotný projekt ULua obsahuje starší verzi balíčku lfs, který je možné povýšit:

$ ./upkg update
 
Installing updated modules and their requirements:
+ lfs | luafilesystem : File System Library for the Lua Programming Language | 1.7.0-203
Removing obsoleted modules:
+ lfs | luafilesystem : File System Library for the Lua Programming Language | 1.6.3-203
Confirm (y/n)?

Instalace nové verze je v tomto případě takřka okamžitá:

Downloading:
+ /pkg/lfs/1.7.0-203 | 100% of 73KB
Done

Nová verze balíčku se ihned objeví ve výpisu nainstalovaných balíčků:

$ ./upkg status
 
Installed modules:
+ cURL             | cURL: Lua binding to libcurl                                         | 0.3.1-103
+ clib_libcurl     | free and easy-to-use client-side URL transfer library                | 7.42.1-3
+ clib_libopenblas | OpenBLAS : An optimized BLAS library                                 | 0.2.15
+ deque            | deque : Implementation of a double-ended queue in Lua.               | 1.0-103
+ lcurl            | cURL: Lua binding to libcurl                                         | 0.3.1-103
+ lfs              | luafilesystem : File System Library for the Lua Programming Language | 1.7.0-203
+ luajit           | LuaJIT: Just-In-Time Compiler (JIT) for Lua                          | 2.1.head20151128
+ moses            | moses : Utility-belt library for functional programming in Lua       | 2.1.0-103
+ moses_min        | moses : Utility-belt library for functional programming in Lua       | 2.1.0-103
+ pkg              | ULua package manager                                                 | 1.0.beta10
+ sci              | general purpose scientific computing library                         | 1.0.beta12
+ sci-lang         | Syntax extensions to LuaJIT for scientific computing                 | 1.0.beta10
+ serpent          | serpent : Lua serializer and pretty printer                          | 0.28-103
+ xsys             | extended Lua system                                                  | 1.0.2

16. Nastavení proměnné PATH

Pro zjednodušení spuštění interpretu jazyka Lua popř. správce balíčků a dalších později nainstalovaných utilit si můžete modifikovat proměnnou prostředí PATH, a to následujícím způsobem:

Root školení Linux

$ export PATH=~/ulua/bin:~/ulua:$PATH

Od této chvíle je možné volat všechny výše popsané spustitelné soubory bez uvedení cesty:

$ lua
 
LuaJIT 2.1.0-beta1 -- Copyright (C) 2005-2015 Mike Pall. http://luajit.org/
JIT: ON SSE2 SSE3 SSE4.1 fold cse dce fwd dse narrow loop abc sink fuse
>
 
 
$ upkg
Universal Lua package manager. Usage:
upkg command [-s] [name] [version]
  command : one of "status", "available", "add", "remove", "update"
  -s      : enable searching (only for "status" and "available" commands)
  name    : module name
  version : module version
 
 
$ scilua
 
LuaJIT Language Toolkit usage: luajit [options]... [script [args]...].
 
Available options are:
  -b ...    Save or list bytecode.
  -c ...    Generate Lua code and run.
            If followed by the "v" option the generated Lua code
            will be printed.

17. Obsah dalšího článku o jazyku Lua

V navazujícím článku o programovacím jazyku Lua se začneme věnovat projektu SciLua, jehož domovskou stránku naleznete na adrese https://scilua.org/. Tento projekt můžeme s určitou dávkou zobecnění považovat za obdobu knihoven Numpy a SciPy pro Python – což je velmi užitečné, zejména z toho důvodu, že práce s klasickými poli jazyka Lua není a nemůže být tak efektivní, jako v případě použití nativních knihoven.

18. Články a seriály o jazyku Lua a souvisejících technologiích na Rootu

  1. Seriál Programovací jazyk Lua
    https://www.root.cz/seria­ly/programovaci-jazyk-lua/
  2. Seriál Torch: framework pro strojové učení
    https://www.root.cz/serialy/torch-framework-pro-strojove-uceni/
  3. Skriptovací jazyk Lua v aplikacích naprogramovaných v Go
    https://www.root.cz/clanky/skriptovaci-jazyk-lua-v-aplikacich-naprogramovanych-v-go/
  4. LuaJIT – Just in Time překladač pro programovací jazyk Lua
    https://www.root.cz/clanky/luajit-just-in-time-prekladac-pro-programovaci-jazyk-lua/
  5. Použití nástroje RQ (Redis Queue) pro správu úloh zpracovávaných na pozadí
    https://www.root.cz/clanky/pouziti-nastroje-rq-redis-queue-pro-spravu-uloh-zpracovavanych-na-pozadi/
  6. Proudy (streams) podporované systémem Redis
    https://www.root.cz/clanky/proudy-streams-podporovane-systemem-redis/
  7. Proudy (streams) podporované systémem Redis (dokončení)
    https://www.root.cz/clanky/proudy-streams-podporovane-systemem-redis-dokonceni/
  8. Databáze Redis (nejenom) pro vývojáře používající Python
    https://www.root.cz/clanky/databaze-redis-nejenom-pro-vyvojare-pouzivajici-python/
  9. Databáze Redis (nejenom) pro vývojáře používající Python (dokončení)
    https://www.root.cz/clanky/databaze-redis-nejenom-pro-vyvojare-pouzivajici-python-dokonceni/
  10. Použití databáze Redis v aplikacích naprogramovaných v Go
    https://www.root.cz/clanky/pouziti-databaze-redis-v-aplikacich-naprogramovanych-v-go/
  11. Použití databáze Redis v aplikacích naprogramovaných v Go (2)
    https://www.root.cz/clanky/pouziti-databaze-redis-v-aplikacich-naprogramovanych-v-go-2/

19. Odkazy na Internetu

  1. ULua: Universal Lua Distribution
    https://ulua.io/index.html
  2. deque
    https://github.com/catwell/cw-lua/blob/master/deque/deque.test.lua
  3. Repositář projektu Lua Fun
    https://github.com/luafun/luafun
  4. Lua Functional 0.1.3 documentation
    https://luafun.github.io/re­ference.html
  5. Lua Functional: Getting Started
    https://luafun.github.io/get­ting_started.html
  6. LuaRocks
    https://luarocks.org/
  7. Documentation
    Dokumentace ke správci balíčků LuaRocks
  8. Rockspec knihovny Fun
    https://raw.githubusercon­tent.com/luafun/luafun/mas­ter/fun-scm-1.rockspec
  9. Awesome Lua – A curated list of quality Lua packages and resources.
    https://github.com/LewisJEllis/awesome-lua
  10. LuaJIT
    https://luajit.org/
  11. Running LuaJIT
    https://luajit.org/running.html
  12. LuaJIT na GitHubu
    https://github.com/luajit
  13. Repositář projektu Moses
    https://github.com/Yonaba/Moses/
  14. Návod k použití knihovny Moses
    https://github.com/Yonaba/Mo­ses/blob/master/doc/tutori­al.md
  15. Lambda the Ultimate: Coroutines in Lua
    http://lambda-the-ultimate.org/node/438
  16. Coroutines Tutorial
    http://lua-users.org/wiki/CoroutinesTutorial
  17. Lua Coroutines Versus Python Generators
    http://lua-users.org/wiki/LuaCorouti­nesVersusPythonGenerators
  18. Programming in Lua 9.1 – Coroutine Basics
    http://www.lua.org/pil/9.1.html
  19. How to understand clojure's lazy-seq
    https://stackoverflow.com/qu­estions/44095400/how-to-understand-clojures-lazy-seq
  20. Lua Implementations
    http://lua-users.org/wiki/LuaImplementations
  21. Generator (computer programming)
    https://en.wikipedia.org/wi­ki/Generator_(computer_pro­gramming)
  22. Lua 5.2 Reference Manual: 6.10 – The Debug Library
    http://www.lua.org/manual/5­.2/manual.html#6.10
  23. Issues k projektu LuaFun
    https://github.com/luafun/lu­afun/issues
  24. Archived | Embed Lua for scriptable apps
    https://developer.ibm.com/tutorials/l-embed-lua/
  25. Embedding Lua
    https://www.oreilly.com/li­brary/view/lua-quick-start/9781789343229/3a6f3daf-f74c-4a25-a125–584da58568e4.xhtml

Autor článku

Pavel Tišnovský vystudoval VUT FIT a v současné době pracuje ve společnosti Red Hat, kde vyvíjí nástroje pro OpenShift.io.