)Portál AbcLinuxu, 25. dubna 2024 01:37
Po delší časové pauze pokračuji se seriálem. V dnešní lekci si nainstalujeme kompilátor jazyka D, probereme sestavování programů a zkusíme si napsat nějaké ty prográmy na úvod. Potom bude nějaký "domácí úkol" a to by mělo být dost jako příprava na další lekci. Také zopakuji nějaké základní věci. Každý díl seriálu bude zahrnovat tři lekce a bude vycházet jednou týdně.
Ještě než začneme s instalací, chtěl bych dodat, že seriál je napsaný pro platformy FreeBSD/Linux a na systémech typu Mac OS X a Windows se budou jednotlivé kroky mírně lišit, ale počítačově zdatný uživatel (což by čtenář tohoto seriálu měl být) by to měl zvládnout bez problému.
Tak za prvé, pořiďte si kvalitní textový editor. To je naprostý základ, věci jako automatické doplňování, zvýrazňování syntaxe, auto-indent apod. jsou velice užitečné při jakékoliv další práci. Já doporučuji např. Geany, který má i některé funkce IDE, pak samozřejěmě existuje Vim, editory jako gedit, Kate apod. by měly být také dostačující. Nainstalujte tedy váš oblíbený editor přes balíčkovací systém, popř. ze zdrojového kódu.
No, editor máme, jenže kód je třeba taky něčím kompilovat. S jazykem D máme na výběr několik kompilátorů, referenční (dmd) by měl stačit; s ním budeme v tomto seriálu pracovat. Dále je možné použít gdc a ldc, ldc na rozdíl o dmd umí tvořit dynamické knihovny, nicméně s nimi moc pracovat nebudeme. To už si každý zdatný uživatel zjistí sám.
A kromě toho také budeme potřebovat runtime knihovnu a standardní knihovnu. Doporučuji i kvalitní emulátor terminálu (gnome-terminal, konsole, xfce4-terminal, eterm..) a shell (např. zsh). A nezapomeňme na debugger (gdb funguje bez problému).
Celým názvem Digital Mars D, DMD je referenčním kompilátorem jazyka D. Ostatní kompilátory vesměs využívají jeho frontend. Druntime je runtime knihovna pro D, potřebují ji všechny D programy. Obsahuje základní věci jako správu vláken, garbage collector, základní typové aliasy, RTTI, správu výjimek apod. Oproti tomu Phobos je knihovnou volitelnou, obsahující všechno, co nepatří do jádra (např. algoritmy, sockety, streamy...).
Vše dohromady se dá stáhnout pro některé distribuce jako balíček, který se snadno nainstaluje a není to třeba nijak moc vysvětlovat, nicméně my si zkusíme nainstalovat kompilátor a knihovny ručně z git repozitáře. Pokud nemáte git nainstalovaný, nainstalujte jej. Kromě toho budeme potřebovat i C++ kompilátor a Make utilitu (nainstalujte cestou specifickou pro vaši distribuci).
# git clone git://github.com/D-Programming-Language/dmd.git #
naklonujeme si repozitář
# cd dmd/src # odtud budeme kompilovat
# make -f posix.mak # přidejte MODEL=64 pro 64bit dmd, -jN pro
kompilaci s několika vlákny, na FreeBSD použijte gmake místo make
# mkdir -p /usr/local/dmd/{bin,lib,include} # vytvoříme si prefix
# mkdir -p /usr/local/dmd/include/d/dmd/{druntime,phobos}
# cat << EOF > /usr/local/dmd/bin/dmd.conf # konfigurační
soubor pro dmd, nastavuje cesty k importům a knihovnám
[Environment]
DFLAGS=-I/usr/local/dmd/include/d/dmd/phobos
-I/usr/local/dmd/include/d/dmd/druntime/import -L-L/usr/local/dmd/lib
-L--no-warn-search-mismatch -L--export-dynamic
EOF
# cp dmd /usr/local/dmd/bin # zkopírujeme dmd binárku
# # nastavte si $PATH tak, aby v cestě byl i /usr/local/dmd/bin
# cd ../..
Myslím, že nic moc navíc není třeba vysvětlovat. Přejdeme na druntime.
# git clone git://github.com/D-Programming-Language/druntime.git # naklonujeme si repozitář # cd druntime # make -f posix.mak # platí stejná pravidla jako pro dmd # cp -r import /usr/local/dmd/include/d/dmd/druntime # zkopírujeme knihovny # cp lib/libdruntime.a /usr/local/dmd/lib # zkopírujeme knihovnu # cd ..
# git clone git://github.com/D-Programming-Language/phobos.git # cd phobos # make -f posix.mak # viz nahoře # cp -r etc std *.d /usr/local/dmd/include/d/dmd/phobos # cp generated/*/release/*/libphobos2.a /usr/local/dmd/lib # cd ..
Tím je vše nainstalováno. Zkusíme dmd spustit. Měli byste vidět něco jako:
# dmd|head -n3 DMD64 D Compiler v2.057 Copyright (c) 1999-2011 by Digital Mars written by Walter Bright Documentation: http://www.digitalmars.com/d/2.0/index.html
A můžeme se pustit do programování! :)
Zkuste si nainstalovat LDC a GDC. Nebudou potřeba pro začátek, ale možná se budou hodit, pokud to s D myslíte vážně.
LDC lze najít na https://github.com/ldc-developers. GDC najdete na https://bitbucket.org/goshawk/gdc/overview/.
Nainstalovat LDC bude asi snažší, protože gcc je velký balík. Pro instalaci LDC budete muset nainstalovat také CMake a LLVM (momentálně požadována verze 3.0).
Ještě než začneme, doporučuji vytvořit si adresář na své projekty a ten si přehledně organizovat. Bude se to hodit. Začněme tedy s prvním programem.
import std.stdio;
void main()
{
writeln("můj první D program!");
}
Zkusme jej nyní zkompilovat!
# dmd test.d -oftest # ./test můj první D program!
Nyní, co náš program vlastně dělá? :)
První řádek „načte“ modul pojmenovaný std.stdio (std je "balík" modulů poskytovaný standardní knihovnou Phobos, stdio znamená "standard input and output" jakožto standardní vstup a výstup).
Všechny programy v D musí mít hlavní funkci, ve které začíná a končí celý běh programu. Pro ty znalé jazyka C, popř. C++ je to hodně podobné, ale všimněte si: hlavní funkce v D nemusí nic vracet.
Naše „hlavní funkce“ obsahuje pouze jeden řádek, tzn.
writeln(...). Funkce writeln je poskytována
už dříve
načteným modulem
std.stdio. Tato funkce chce jeden nebo více „argumentů“, tzn. hodnot. S
těmito argumenty funkci voláme, v našem případě je argument jen jeden,
a to „můj první D program!“,
což je řetězecový literál (o nich
později). Prozatím o řetězcových literálech musíme vědět, že se
zapistují ve dvojitých uvozovkách. Jednoduché uvozovky znamenají v
jazyce D jeden znak. Funkce writeln ale bere argumenty jakéhokoliv typu.
Všechny se vypíšou na terminál hned za sebou. Na konec se
přidá znak nového řádku.
writeln("tímto tisknu číslo: ", 5, " a tohle je znak: ", 'X', " a tohle je desetinné číslo: ", 3.14);
Můžete si říct, no jo, ale to vypadá dost nepřehledně, a lokalizace taky nebude jednoduchá. A máte samozřejmě pravdu. Z toho důvodu se dají řetězce formátovat, podobně jako v jazyce C.
writefln("tímto tisknu číslo: %d, a tohle je znak: %s, a tohle je desetinné číslo: %f", 5, 'X', 3.14);
Pro Cčkaře, ti ví, že formátovací značky jsou typově specifické;
toto existuje i v D, ale také se dá použít %s pro
jakýkoliv typ a bude
to fungovat; specifické značky jsou spíše pro pokročilejší formátování.
Z rodiny funkcí write jsou zde přítomny:
write writeln writef writefln
Zkuste zjistit, co dělají! :) Nicméně o formátování se budeme bavit
později, a tam si i rozebereme, jak to vše funguje. Pokud chcete
zkoušet dopředu, dokumentace na webu jazyka
(http://d-programming-language.org)
je vám k dispozici )
1) použijte escape sekvence (\n) k vytištění více řádků
pomocí
writeln.
2) použijte funkci write s escape sekvencí \n
tak, aby se chovala
jako writeln.
3) vytiskněte několik řádků pomocí několika volání funkcí write
a
writeln.
4) zkuste napsat řádek kódu za // a několik řádků kódu
mezi /* a
*/. Zjistěte, jaký vliv na běh programu to má.
Toto jsem nakousl už v předchozí lekci. V každém programu je potřeba dělat poznámky, které vysvětlují takový kód, který není na první pohled jasný. K tomu slouží tzv. komentáře. Jazyk D má několik typů komentářů a každý se hodí v jiném případě. S tím hodně souvisí i dokumentace, na kterou se také podíváme.
Často budete potřebovat udělat komentář na jeden řádek, popř.
zakomentovat řádek kódu. K tomu slouží //. Příklad:
// writeln(„toto se nespustí!“);
Kód v komentářích se nebude parsovat. To znamená, že v komentáři může být zapsaný nevalidní kód a kompilátoru to nebude vadit.
Řádkový komentář nemusí často stačit. Občas je třeba zakomentovat
blok kódu a ne jen jeden řádek. V takových případech se kód zapíše
mezi /* a */, např.
/*
writeln("tohle se nespustí.");
writeln("toto se taky nespustí.");
*/
Blokové komentáře mají zásadní nevýhodu v tom, že nemohou obsahovat
vnořené blokové komentáře. To je často problém, když je třeba
zakomentovat kus kódu obsahující takové komentáře. V takových případech
se dá ale použít /+ a +/:
/+
/* vypiš něco */
writeln("něco");
/* toto jaksi nechce fungovat */
writeln("nefunguje);
+/
Oproti /**/, komentáře /++/ mohou
obsahovat
neomezeně vnořených
komentářů všech typů.
S komentáři, jak už jsem dříve zmínil, úzce souvisí i dokumentace. Jazyk D má zabudovanou podporu pro dokumentaci (tzv. DDoc). Dokumentace je spravována také pomocí komentářů.
Jediný rozdíl je v tom, že // se zapíše jako ///,
/* */ jako
/** */ a /+ +/ jako /++ +/.
Několik příkladů:
/// Dokumentační komentář /** Také dokumentační komentář */ /** Několikařádkový dokumentační komentář * Další řádek */ /************* * Další hvězdičky nejsou součástí dokumentace */ /++ Také dokumentace +/
Poslední dokumentační komentář se dá opakovat pomocí slůvka ditto:
/** This has value of 5 */ int a = 5; /** ditto */ int b = 5
Dokumentační komentář Ddoc je rozdělený na sekce. Dvě hlavní sekce jsou Summary (shrnutí) a Description (širší popis). Shrnutí je jednořádkový popis kódu. Širší popis může mít několik řádků.
Shrnutí je volitelné. Tyto sekce jsou nepojmenované. Kromě toho existuje ještě několik standardních sekcí, které je nutné pojmenovat.
/** * Toto je shrnutí, vždy první odstavec * * První odstavec popisu * Druhý řádek prvního odstavce * * Druhý odstavec popisu ..... atd */
Autoři:
/** * Authors: Daniel "q66" Kolesa <quaker66@gmail.com>, Herp J. Derp <herp@derp.com> */
Bugy:
/** * Bugs: This does not work. */
Datum:
/** * Date: February 31, 2000 */
Dále nepodporováno (deprecated):
/** Deprecated: replaced by bar */
deprecated void foo() { ... }
Příklady:
/**
* Examples:
* ------------
* writeln("hello");
* ------------
*/
Historie:
/** * History: * version 1 - blablah * version 2 - foobar */
Licence:
/** * License: MIT */
Návratová hodnota:
/**
* A function
* Returns: string "foo"
*/
string foo() { return "foo"; }
Zdroje:
/** * See_Also: * foo, bar, baz, http://google.com */
Standardy:
/** * Standards: ISO 1337 */
Vrací výjimku:
/**
* Throws: Exception on failure
*/
void foo() { ... }
Verze:
/** * Version: 0.1.3.3.7 */
Některé mají speciální význam a syntaxi:
Copyright:
Tato sekce nastaví makro COPYRIGHT na obsah této sekce, pokud je to komentář k deklaraci modulu.
/** Copyright: 2011 q66 */
Parametry funkce:
/**
* blah
* Params:
* a = first parameter
first parameter doc continued
* b = second
parameter
*/
void foo(int a, float b) { ... }
Makra:
Ty mají vlastní sekci, zapistují se podobně jako parametry. O makrech více o pár řádků později. Mají názvy zapsané velkými písmeny.
/** * Macros: * FOO = this is foo, argument $0 * BAR = this is bar, argument $0 */
Ty se dají zapsat pomocí makra, $(DDOC_COMMENT nějaký
komentář).
Do DDoc komentářů se dá zapsat D kód, mezi řádky ze tří a více pomlček:
/++
+ Some function
+ Example:
+ -----------------
+ foo("bar"); /* results in baz */
+ ---
+/
HTML se dá vnořovat bez nějaké speciální syntaxe:
/** * Some HTML: * <a href="foo">blah</a> */
Makra v DDoc fungují podobně jako např. makra v C. Jsou to v podstatě „šablony“, které se dají zavoláním makra vložit na nějakou pozici v textu.
Mohou mít argumenty, a volají se takto:
$(NAZEVMAKRA arg1 arg2 arg3 arg4 argN)
Mohou být definovány v sekci komentáře (viz nahoře), .ddoc
souborech, mohou být předdefinované, popř. vygenerované přímo DDoc za
běhu. Redefinice makra nahradí starou verzi. Parametry makra se v makru
zapisují jako $ARGNUM (od
nuly do N).
RED = <span style="color:red">$0</span>
Pokud např. funkce foo má argument bar a
slůvko bar se objeví
někde v popisu, tak se automaticky vygeneruje hyperlink. To platí i pro
ostatní definice, nejen argumenty. Pokud je třeba tomuto chování
předejít, je nutné přidat podrtžítko (např. _bar).
Některé znaky (<,
>, &) mají speciální význam, a proto se zapisují jako (<,
> a &). DDoc je možné využít nejen pro vloženou
dokumentaci v kódu, ale i samosatatně,
zapsaný v souborech .ddoc. Tak
je např. vygenerována webová stránka
http://d-programming-language.org.
Kompletní dokumentaci k DDoc lze nalézt zde: http://www.d-programming-language.org/ddoc.html.
To je jednoduché, stačí kompilovat jako obvykle, jen přidat k dmd
volání parametr -D. Je možné specifikovat i výstupní
adresář, pomocí
-Djméno, a výstupní soubor, -Dfjméno.
Použijte parametr -c, aby
kompilátor nevolal linker. Výsledný HTML soubor bude uložený jako nazev_d_souboru.html.
1) Zdokumentujte dříve napsané kusy kódu a vygenerujte HTML.
2) Zkuste si napsat nějaká vlastní makra.
ISSN 1214-1267, (c) 1999-2007 Stickfish s.r.o.