anjuta master - en to cs translation catalogue (264 entries)

note: (itstool) path: bookinfo/title
en: Anjuta build tutorial
cs: Výuka sestavování v IDE Anjuta

note: (itstool) path: legalnotice/para
en: Permission is granted to copy, distribute and/or modify this document under the terms of the <citetitle>GNU Free Documentation License</citetitle>, Version 1.1 or any later version published by the Free Software Foundation with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. You may obtain a copy of the <citetitle>GNU Free Documentation License</citetitle> from the Free Software Foundation by visiting <ulink type="http" url="http://www.fsf.org">their Web site</ulink> or by writing to: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
cs: Je povoleno kopírovat, šířit a/nebo upravovat tento dokument za podmínek <citetitle>GNU Free Documentation License</citetitle> ve verzi 1.1 nebo v jakékoli další verzi vydané nadací Free Software Foundation; bez neměnných oddílů, bez textů předních desek a bez textů zadních desek. Kopii licence <citetitle>GNU Free Documentation License</citetitle> můžete získat od organizace Free Software Foundations na <ulink type="http" url="http://www.fsf.org">jejich webových stránkách</ulink>, nebo když si o ni napíšete na adresu: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

note: (itstool) path: legalnotice/para
en: Many of the names used by companies to distinguish their products and services are claimed as trademarks. Where those names appear in any GNOME documentation, and those trademarks are made aware to the members of the GNOME Documentation Project, the names have been printed in caps or initial caps.
cs: Mnoho názvů použitých firmami k zviditelnění produktů nebo služeb jsou ochranné známky. Na místech, kde jsou tyto názvy v dokumentaci použity a členové Dokumentačního projektu GNOME jsou si vědomi skutečnosti, že se jedná o ochrannou známku, je takovýto název psán velkými písmeny celý nebo s velkým písmenem na začátku."

note: (itstool) path: bookinfo/releaseinfo
en: This is version 0.2 of Anjuta build tutorial
cs: Jedná se o verzi 2.0 výuky sestavování v IDE Anjuta

note: (itstool) path: chapter/title
en: Introduction
cs: Úvod

note: (itstool) path: chapter/para
en: If you come from the Windows world, when you first launched <application>Anjuta</application>, you can told yourself : "Hey, that looks like MS Visual C++, as I know it pretty well, understanding <application>Anjuta</application> will be a piece of cake.". <application>Anjuta</application> looks like <application>Microsoft Visual Studio</application> or <application>Borland's C++ Builder</application>. but it has some significative differences essentially in its build system.
cs: Když přicházíte ze světa Windows a poprvé spustíte aplikaci <application>Anjuta</application>, můžete si říct: „Jé, to vypadá jak MS Visual C++, to dobře znám. Takže pochopit <application>Anjutu</application> bude pro mě malina.“ <application>Anjuta</application> opravdu vypadá jak <application>Microsoft Visual Studio</application> nebo <application>Borland's C++ Builder</application>. Jsou zde ale významné rozdíly v samotném sestavovacím systému.

note: (itstool) path: chapter/para
en: If you are starting programming directly on GNU/Linux, you have probably already heard of the <application>Autotools</application>. They are a major and probably a bit intimidating part of the development environment.
cs: Jestli jste s programováním začali z příkazové řádky, nejspíše jste již slyšeli o <application>Autotools</application>. Jedná se o hlavní a pravděpodobně trochu zastrašující část vývojářského prostředí.

note: (itstool) path: chapter/para
en: The goal of <application>Anjuta</application> is to make it easier to use the already existing development tools. <application>Anjuta</application> main build system uses the standard Linux build system: <application>Autotools</application>. This tutorial is an updated version of the <application>Anjuta</application> advanced tutorial from Olivier Pinçon. It explains how the build system is working without <application>Anjuta</application> and how to use it within <application>Anjuta</application>. It assumes that you have only a basic understanding of C or C++ and have been written using <application>Anjuta 2.6 (September 2008)</application>.
cs: Cílem <application>Anjuty</application> je usnadnit používání již existujících vývojářských nástrojů. Její hlavní sestavovací systém používá standardní sestavovací systém Linuxu: <application>Autotools</application>. Tato příručka je aktualizovanou verzí pokročilé příručky k IDE <application>Anjuta</application> od Oliviera Pinçona. Vysvětluje, jak sestavovací systém funguje bez <application>Anjuty</application> a jak se používá s ní. Předpokládá u vás jen základní znalosti C nebo C++ a byla napsán pro použití s verzí <application>Anjuta 2.6 (září 2008)</application>.

note: (itstool) path: listitem/para
en: Fill a bug in <ulink url="http://bugzilla.gnome.org/enter_bug.cgi?product=anjuta"> <application>Anjuta</application> bugzilla database</ulink>.
cs: Vyplnit chybové hlášení do <ulink url="http://bugzilla.gnome.org/enter_bug.cgi?product=anjuta">databáze bugzilla pro projekt <application>Anjuta</application></ulink>.

note: (itstool) path: listitem/para
en: Send a message to <application>Anjuta</application> developer mailing list <email>anjuta-devel@lists.sourceforge.net</email>
cs: Poslat zprávu do vývojářské poštovní konference projektu <application>Anjuta</application> na adrese <email>anjuta-devel@lists.sourceforge.net</email>.

note: (itstool) path: listitem/para
en: Join <application>Anjuta</application> IRC channel <ulink url="irc://irc.gnome.org/anjuta">#anjuta on irc.gnome.org</ulink>
cs: Připojit se ke kanálu IRC projektu <application>Anjuta</application> na adrese <ulink url="irc://irc.gnome.org/anjuta">#anjuta on irc.gnome.org</ulink>

note: (itstool) path: chapter/para
en: If you find errors, need more explanations or have any idea for improvements on this tutorial or <application>Anjuta</application> in general, you can: <_:itemizedlist-1/>
cs: Když najdete chybu, budete potřebovat podrobnější vysvětlení nebo budete mít nápad na vylepšení této příručky nebo <application>Anjuty</application> obecně, můžete: <_:itemizedlist-1/>

note: (itstool) path: chapter/title
en: Building a project
cs: Sestavení projektu

note: (itstool) path: chapter/para
en: This chapter explains how to build a program starting from the most basic tool: the compiler. This order is important to understand how is it working because each tool adds a new layer on top of the previous ones.
cs: Tato kapitola objasňuje, jak sestavit program, počínaje úplně základním nástrojem – kompilátorem. Je důležité začít takto, abyste pochopili, jak to funguje, protože každý další nástroj přidává novou vrstvu nad ten předchozí.

note: (itstool) path: sect1/title
en: Using <application>GCC</application>
cs: Použití <application>GCC</application>

note: (itstool) path: sect1/para
en: Here is a typical command to generate an executable from C source files using <application>GCC</application>:
cs: Zde je typický příkaz pro vygenerování spustitelného souboru ze zdrojových kódů v jazyce C pomocí <application>GCC</application>:

note: (itstool) path: sect1/para
en: This command tells <application>GCC</application> to compile the source files main.c and aux.c, and produce a binary called 'tut_prog' (this stands for 'tutorial program'). The various switches have the following meaning :
cs: Tento příkaz říká <application>GCC</application>, aby zkompiloval zdrojové kódy main.c a aux.c a vytvořil binární soubor nazvaný „tut_prog“ (zkráceni z „tutorial program“ – „výukový program“). Jednotlivé přepínače mají následující význam:

note: (itstool) path: listitem/para
en: tells <application>GCC</application> to include debug information into the binary.
cs: Říká <application>GCC</application>, aby do výsledného programu přidal ladicí informace.

note: (itstool) path: listitem/para
en: Warning all : print every warning. This switch is used by the C compiler only.
cs: „Warning all“, což znamená vypisovat všechna varování. Tento přepínač používá jen kompilátor jazyka C.

note: (itstool) path: varlistentry/term
en: <parameter>-Idir <replaceable>dir</replaceable></parameter>
cs: <parameter>-Idir <replaceable>složka</replaceable></parameter>

note: (itstool) path: listitem/para
en: Look for included header files (like in #include &lt;myheader.h&gt;) in directory <replaceable>dir</replaceable>. This switch is used by the C preprocessor only.
cs: Zajistí, že se hlavičkové soubory (jako je #include &lt;myheader.h&gt;) budou hledat ve složce <replaceable>složka</replaceable>. Tento přepínač používá pouze preprocesor jazyka C.

note: (itstool) path: varlistentry/term
en: <parameter>-llib <replaceable>lib</replaceable></parameter>
cs: <parameter>-llib <replaceable>knihovna</replaceable></parameter>

note: (itstool) path: listitem/para
en: Link to library <replaceable>lib</replaceable>; here <application>libxml2</application>, used by the linker.
cs: Odkaz na <replaceable>knihovnu</replaceable>, zde konkrétně <application>libxml2</application>, pro potřeby linkeru.

note: (itstool) path: sect1/para
en: In fact, <application>GCC</application> does not do the compilation itself. It gets all arguments from the user and calls other programs passing them the needed arguments with some default one to do the four stages involved in the compilation.
cs: Ve skutečnosti kompilaci neprovádí přímo <application>GCC</application>. Jen převezme parametry zadané uživatelem a zavolá jiné programy a předá jim potřebné parametry, případně včetně některých výchozích. Takto se postupně provedou čtyři fáze kompilace.

note: (itstool) path: figure/title
en: <application>GCC</application> compilation stage
cs: Fáze kompilace pomocí <application>GCC</application>

note: (itstool) path: sect2/title
en: Preprocessor
cs: Preprocesor

note: (itstool) path: sect2/para
en: Each C source file goes through the preprocessor, named <application>cpp</application>. In this stage, all include files and macros are expanded to get preprocessed C source code. The resulting file .i is rarely generated but it could be interesting to see how complex macros are expanded. You can do this by calling <application>cpp</application> directly or using the <userinput>-E</userinput> switch of <application>GCC</application>. The later option is better as it allows to run the preprocessor with all default options.
cs: Každý soubor se zdrojovým kódem v jazyce C projde přes preprocesor nazvaný <application>cpp</application>. V této fázy se rozvinou všechny vložené soubory a makra – zdrojový kód se předpřipraví (anglicky preproces). Výsledný soubor s příponou <filename>.i</filename> se generuje jen výjimečně, ale může být zajímavé se podívat, jak složitě a rozsáhle se makra rozvíjejí. Nechast si soubor vytvořit se dá zavoláním <application>cpp</application> přímo nebo zavoláním <userinput>-E</userinput> s přepínačem <application>GCC</application>. Druhé zmíněné je lepší, protože preprocesoru předá navíc některé výchozí hodnoty.

note: (itstool) path: sect2/title
en: Compiler
cs: Kompilátor

note: (itstool) path: sect2/para
en: In this stage each file is compiled into assembler code. The compiler depends on the language of the source file, C here. It is a complex program because there is not a one to one correspondence between C instructions and assembler instructions. By example, requesting the fastest or the smallest program will generate different sequences of assembler instructions. The assembler is the language of your computer, the most common one is called x86. The output is a, human readable, assembler source file ending with '.s'. Like the preprocessor output, the assembler code is not normally written on the hard disk. You can stop the compilation at this stage to look at it by running <application>GCC</application> with the <userinput>-S</userinput> switch.
cs: V této fázi jsou jednotlivé soubory zkompilovány do assemblerového kódu. Použitý kompilátor odvisí od použitého jazyka ve zdrojovém kódu, zde je to C. Jedná se o složitý program, protože neexistuje přepis jedna k jedné mezi instrukcí C a instrukcí assembleru. Například, požadavek na co nejrychlejší a na co nejmenší program vygenerují různou posloupnost assemblerových instrukcí. Assembler je jazyk závislý na použitém počítači, nejčastěji to asi bude x86. Výstupem je pro člověka čitelný zdrojový kód v assembleru v souboru s příponou <filename>.s</filename>. Stejně jako u výstupu z preprocesoru, ani tyto soubory se normálně nezapisují na disk. Jestli se ale chcete na soubory podívat, můžete kompilaci v této fázi zastavit spuštěním <application>GCC</application> s přepínačem <userinput>-S</userinput>.

note: (itstool) path: sect2/para
en: In this stage each file is assembled: the assembler code is transformed to an object file with .o extension. It is much easier than the compilation as each assembler instruction corresponds to an unique code. The object file contains additional information for debugging or linking the program. The object file is a binary format, called ELF on recent Linux machine, you need to use special program to look in it like <application>objdump</application>. It is possible to write directly assembler code and assemble it using the assembler ,<application>as</application>, or <application>GCC</application> if your source file has a .s extension. These object files are commonly written on your hard disk because it depends only of theirs corresponding C source file (with all files included). If you modify only one source file, you need to regenerate only the corresponding object file. You can stop at this stage, without linking by using <userinput>-c</userinput> switch with <application>GCC</application>.
cs: V této fázi jsou jednotlivé soubory zpracovány assemblerem: kód je převeden to objektových souborů s příponou <filename>.o</filename>. To je podstatně jednodušší než kompilace, protože každá instrukce odpovídá jedna k jedné unikátnímu kódu. Objektový soubor obsahuje doplňující informace pro ladění a linkovací program. Objektový soubor má binární formát, na počítačích s novými verzemi Linuxu nazývaný ELF. Abyste si jej mohli prohlédnou, potřebujete speciální program, jako je třeba <application>objdump</application>. Můžete psát programy v assembleru i přímo ručně do souborů s příponou <filename>.s</filename> a pak je převádět programem  <application>as</application>, stejně jako to dělá <application>GCC</application>. Výsledné objektové soubory se běžné zapisují na disk, protože závisí jen na příslušném souboru se zdrojovým kódem C (včetně všech vložených souborů). Když změníte jeden zdrojový soubor, stačí nově vygenerovat jen příslušné objektové soubory. Skončit v této fázi, bez následného slinkování, můžete použitím přepínače <userinput>-c</userinput> pro <application>GCC</application>.

note: (itstool) path: sect2/para
en: This stage is used to combine all the object files and libraries into one executable file. The result is a binary file in a format close to the object file, on Linux it is even the same format.
cs: Tato fáze slouží ke zkombinování všech objektových souborů a knihoven do jednoho spustitelného souboru. Výsledkem je binární soubor ve formátu velmi podobném objektovým souborům, v Linuxu je to dokonce tentýž formát.

note: (itstool) path: sect1/title
en: Using <application>make</application>
cs: Použití <application>make</application>

note: (itstool) path: sect1/para
en: When a program is composed of lots of sources files, it is much faster to keep the object files and recompile each source files only when needed. This can be automated using <application>make</application>. It executes a program written in a makefile, normally named <filename>Makefile</filename>. A sample makefile for the previous tutorial program could be :
cs: V situaci, kdy se program skládá z velkého množství zdrojových souborů, je mnohem rychlejší objektové soubory zachovávat a znovu kompilovat jen ty zdrojové soubory, které je potřeba. To se dá automatizovat pomocí programu <application>make</application>. Ten spouští program napsaný ve formátu makefile, normálně pojmenovaný <filename>Makefile</filename>. Příklad pro předchozí ukázkový program by mohl vypadat takto:

note: (itstool) path: example/title
en: A simple Makefile file
cs: Jednoduchý soubor Makefile

note: (itstool) path: example/programlisting
en: 
    CC=gcc 	# the C compiler is gcc
    CFLAGS=-g -Wall -I/usr/include/libxml2
    LIBS=-lxml2					
    				
    tut_prog: main.o aux.o   # what we need to have 'tut_prog'...
    	$(CC) $(LIBS) main.o aux.o -o tut_prog # ...and how to get it from the ingredients.
    					
    main.o: main.c
    	$(CC) -c $(CFLAGS) main.c
    					
    aux.o: aux.c
    	$(CC) -c $(CFLAGS) aux.c
cs: 
    CC=gcc 	# kompilátor je gcc
    CFLAGS=-g -Wall -I/usr/include/libxml2
    LIBS=-lxml2					
    				
    tut_prog: main.o aux.o   # co je potřeba pro získání „tut_prog“…
    	$(CC) $(LIBS) main.o aux.o -o tut_prog # … a jak jej získat z jednotlivých dílků.
    					
    main.o: main.c
    	$(CC) -c $(CFLAGS) main.c
    					
    aux.o: aux.c
    	$(CC) -c $(CFLAGS) aux.c

note: (itstool) path: sect1/para
en: Makefiles are a kind of program but instead of writing what should be done sequentially to get the result, you define some rules and <application>make</application> uses these rules in whatever order to achieve the result.
cs: Soubory Makefile jsou jistým druhem skriptových programů, ale místo zapsané posloupnosti toho, co se má udělat, aby se dospělo k výsledku, definují určitá pravidla. Program <application>make</application> pak tato pravidla používá v různém pořadí, aby dosáhl žádaného výsledku.

note: (itstool) path: sect2/title
en: Variables
cs: Proměnné

note: (itstool) path: sect2/para
en: Like in any programming language, you can define variables in a make file. All variables contains a string or a list of strings separated by whitespace. A variable is defined using the following syntax: <replaceable>name</replaceable>=<replaceable>value</replaceable>. You can get its value by writing $(<replaceable>name</replaceable>) or ${<replaceable>name</replaceable>}. In the sample above, three variables are defined CC, CFLAGS and LIBS.
cs: Stejně jako v jiných programovacích jazycích, můžete i souborech makefile definovat proměnné. Všechny proměnné obsahují řetězec nebo seznam řetězců oddělených bílými znaky. Proměnná je definovaná pomocí následující syntaxe: <replaceable>nazev</replaceable>=<replaceable>hodnota</replaceable>. Její hodnotu pak můžete získat zápisem $(<replaceable>nazev</replaceable>) nebo ${<replaceable>nazev</replaceable>}. V předchozím příkladu jsou definované tři proměnné – CC, CFLAGS a LIBS.

note: (itstool) path: listitem/para
en: Program for compiling C programs, default 'cc'
cs: Program pro kompilaci z jazyka C; výchozí je „cc“

note: (itstool) path: listitem/para
en: Program for compiling C++ programs, default 'g++'
cs: Program pro kompilaci z jazyka C++; výchozí je „g++“

note: (itstool) path: listitem/para
en: Program for running C preprocessor, default '$(CC) -E'
cs: Program použitý jako preprocesor jazyka C; výchozí je „$(CC) -E“

note: (itstool) path: listitem/para
en: Program for running Fortran compiler, default 'f77'
cs: Program pro kompilaci z jazyka Fortran; výchozí je „f77“

note: (itstool) path: listitem/para
en: Command to remove a file, default 'rm -f'
cs: Program pro odtraňování souborů; výchozí je „rm -f“

note: (itstool) path: listitem/para
en: Extra flags for the C compiler
cs: Doplňující přepínače pro kompilátor jazyka C

note: (itstool) path: listitem/para
en: Extra flags for the C++ compiler
cs: Doplňující přepínače pro kompilátor jazyka C++

note: (itstool) path: listitem/para
en: Extra flags for the C preprocessor
cs: Doplňující přepínače pro preprocesor jazyka C

note: (itstool) path: listitem/para
en: Extra flags for the Fortran compiler
cs: Doplňující přepínače pro kompilátor jazyka Fortran

note: (itstool) path: listitem/para
en: Extra flags for the linker
cs: Doplňující přepínače pro linker

note: (itstool) path: sect2/para
en: Variables can be redefined when calling <application>make</application> in the command line or using values from environment. Moreover <application>make</application> includes some default rules using predefined variables. Here is a list of the most common ones: <_:variablelist-1/>
cs: Proměnné je možné předefinovat, když se volá <application>make</application>, v příkazové řádce nebo pomocí hodnot z proměnných prostředí. Navíc <application>make</application> obsahuje některá výchozí pravidla používající předdefinované proměnné. Zde je seznam nejběžnějších z nich: <_:variablelist-1/>

note: (itstool) path: sect2/title
en: Rules
cs: Pravidla

note: (itstool) path: sect2/para
en: The basic syntax for make rules is:
cs: Základní syntax pro pravidla make je:

note: (itstool) path: sect2/programlisting
en: 
    <replaceable>target</replaceable>: <replaceable>prerequisites</replaceable>
    	<replaceable>commands</replaceable>
    	<replaceable>...</replaceable>
cs: 
    <replaceable>cíl</replaceable>: <replaceable>předpoklady</replaceable>
    	<replaceable>příkazy</replaceable>
    	<replaceable>…</replaceable>

note: (itstool) path: sect2/para
en: The <replaceable>target</replaceable> and the <replaceable>prerequisites</replaceable> are normally files but they could be actions. The rule is interpreted as in order to make the target or update it if it is older than its prerequisites, you need to make all prerequisites and then run all commands.
cs: Údaje <replaceable>cíl</replaceable> a <replaceable>předpoklady</replaceable> jsou normálně soubory, ale mohou to být i akce. Pravidlo je interpretováno, když je potřeba vytvořit cíl, případně jej aktualizovat, pokud je starší než předpoklad. Pro interpretaci je potřeba mít splněné všechny předpoklady a následně jsou pak provedeny všechny příkazy.

note: (itstool) path: sect2/para
en: <application>make</application> starts with the first target of the makefile or the one given in the command line and looks for a rule. If this rules has no prerequisites, the associated commands are run and that's all. Else before running the commands, for each prerequisite, <application>make</application> looks for a rule having it as target and repeats the same process.
cs: <application>make</application> začne s prvním cílem v souboru Makefile, nebo s tím, který je předaný z příkazové řádky, a hledá pro něj pravidlo. Pokud nemá pravidlo žádné předpoklady, provedou se související příkazy a tím vše skončí. Pokud ale existují, před spuštěním příkazů hledá <application>make</application> pravidla, která mají jednotlivé předpoklady jako cíle a pro ně celý postup opakuje.

note: (itstool) path: para/programlisting
en: 
    Search a rule with tut_prog as target
    Found with prerequisites main.o aux.o
    	Search a rule with main.o as target
    	Found with prequisite main.c
    		Search a rule with main.c as target
    		Not found (main.c is a source file)
    	If main.o does not exist or is older than main.c
    		Compile main.c, do not link (-c switch)
    	Search a rule with aux.o as target
    	Found with prequisite aux.c
    		Search a rule with aux.c as target
    		Not found (aux.c is a source file)
    	If aux.o does not exist or is older than aux.c
    		Compile aux.c, do not link (-c switch)
    If tut_prog is older than main.o or aux.o
    	Link main.o, aux.o and libxml2
cs: 
    Hledá pravidlo s cílem tut_prog
    Najde jej s předpoklady mani.o aux.o
    	Hledá pravidlo s cílem main.o
    	Najde jej s předpokladem main.c
    		Hledá pravidlo s cílem main.c
    		Nenajde jej (main.c je zdrojový soubor)
    	Pokud main.o neexistuje nebo je starší než main.c
    		Zkompiluje main.c, bez linkování (-c switch)
    	Hledá pravidlo s cílem aux.o
    	Najde jej s předpokladem aux.c
    		Hledá pravidlo s cílem aux.c
    		Nenajde jej (aux.c je zdrojový soubor)
    	Pokud aux.o neexistuje nebo je starší než aux.c
    		Zkompiluje aux.c, bez linkování (-c switch)
    Pokud je tut_prog starší než main.o nebo aux.o
    	Slinkuje main.o, aux.o a libxml2

note: (itstool) path: sect2/para
en: In the sample above, if you run <userinput>make</userinput> or <userinput>make tut_prog</userinput>. <application>make</application> does the following: <_:programlisting-1/>
cs: Když v příkladu výše spustíte <userinput>make</userinput> nebo <userinput>make tut_prog</userinput>, provede <application>make</application> následující: <_:programlisting-1/>

note: (itstool) path: sect2/para
en: Like for variables, several target names are commonly defined:
cs: Podobně, jako je tomu u proměnných, i u cílů je definováno několik obedně používaných názvů:

note: (itstool) path: listitem/para
en: Do everything
cs: Provést vše

note: (itstool) path: listitem/para
en: Perform some self test after building the program
cs: Po sestavené programu provést automatizované testy

note: (itstool) path: listitem/para
en: Delete all files created by <application>make</application>
cs: Odstranit všechny soubory, které <application>make</application> vytvořil

note: (itstool) path: listitem/para
en: Delete more files than clean, could delete the Makefile itself
cs: Odstranit více souborů, než clean; může odstranit i Makefile samotný

note: (itstool) path: listitem/para
en: Create a distribution package, a compressed tarball by example
cs: Vytvořit distribuční balíček, například komprimovaný tar

note: (itstool) path: listitem/para
en: Install target created by <application>make</application>, need to be run as root to install in system directories
cs: Nainstalovat cíl vytvořený pomocí <application>make</application>; kvůli instalaci do systémových složek je potřeba spustit pod uživatelem root

note: (itstool) path: listitem/para
en: Remove files installed by <application>make</application>
cs: Odstranit soubory, které <application>make</application> nainstaloval

note: (itstool) path: note/para
en: Programs compiled from sources are installed by default in <filename class="directory"> /usr/local</filename>. If you want to install (or uninstall) a program in such system directory, you normally need to log as root using <userinput>su</userinput> or <userinput>sudo</userinput> before running <userinput>make install</userinput>.
cs: Program zkompilovaný ze zdrojových kódů se standardně nainstaluje do <filename class="directory"> /usr/local</filename>. Když chcete to takovéto systémové složky instalovat (nebo z ní naopak něco odinstalovat), musíte být pře spuštěním <userinput>make install</userinput> přihlášení jako uživatel root, nejlépe pomocí <userinput>su</userinput> nebo <userinput>sudo</userinput>.

note: (itstool) path: sect1/title
en: Using <application>Autotools</application>
cs: Použití <application>Autotools</application>

note: (itstool) path: sect1/para
en: If you want to build your program on another system, using <application>make</application> only could be quite difficult. The C compiler could be different. Some common C functions could be missing, have another name, declared in a different header and so on. This can be handled by enabling difference piece of code in your sources using preprocessor directive #if, #ifdef and others. But the user will have to define himself all these tuning which is not easy as there is a lots of systems with a lots of variations.
cs: Pokud chcete sestavit program na jiném systému, mohlo by být použití samotného <application>make</application> poněkud obtížné. Mohl by být potřeba jiný kompilátor jazyka C. Některé funkce C by mohly scházet, mít jiný název, být deklarované s jinou hlavičkou apod. Dalo by se to sice řešit povolováním různých částí kód pomocí direktiv #if, #ifdef a podobných ve zdrojovém kódu, ale uživatel by se musel o vše postarat sám. A takové úpravy nejsou triviální, protože existuje spousta systémů ve spoustě variací.

note: (itstool) path: sect1/para
en: Free softwares are mainly distributed as sources. It is crucial to be able to recompile them on various system without much technical knowledge. <application>Autotools</application> is designed to solve this and you probably have already use it using the magic combination <userinput> "./configure; make; make install"</userinput>. You may have noticed that many files are involved in this build process; globally all that stuff seems very complicated. So what's happening when you compile such software ?
cs: Svobodný software se často šíří v podobě zdrojových kódů. Je podstatné, aby jej bylo možné zkompilovat na různých systémech bez technických znalostí. <application>Autotools</application> jsou navržené k tomu, aby to řešily, a nejspíše jste se již setkali s magickou kombinací <userinput>„./configure; make; make install“</userinput>. Možná jste si všimli, že v sestavovacím procesu figuruje spousta souborů. Celkově se zdá všechno poněkud komplikované. Takže, co se vlastně děje, když kompilujete software?

note: (itstool) path: sect2/title
en: Input files
cs: Vstupní soubory

note: (itstool) path: sect2/para
en: An <application>Autotools</application> project comes at least with a configure script, named <filename>configure</filename>, and a makefile template named <filename>Makefile.in</filename>. There is normally, one <filename>Makefile.in</filename> in each directory of the project. There are several other files used by an <application>Autotools</application> project but they are not stricly necessary or are generated automatically.
cs: Projekt <application>Autotools</application> přichází přinejmenším s konfiguračním skriptem nazvaným <filename>configure</filename> a se šablonou pro Makefile nazvanou <filename>Makefile.in</filename>. Normálně bývá v každé složce projektu jedna šablona. Mimo to bývá v projektu ještě několik dalších souborů používaných <application>Autotools</application>, ale ty nejsou vysloveně nutné, nebo se generují automaticky.

note: (itstool) path: tip/para
en: If you look inside these files, you will see that they are quite complex. Do not worry, these files are generated by <application>Autotools</application> from other templates easier to write as explained in <xref linkend="create-autotools"/>. For the moment, we do not care, we consider these files exist as it is the case when you get a source package.
cs: Když se do těchto souborů podíváte, zjistíte, že jsou trochu komplikovanější. Ale nebojte se, jsou generované automaticky pomocí <application>Autotools</application> ze šablon, které jsou pro napsání mnohem jednoduší, jak je vysvětleno v <xref linkend="create-autotools"/>. V tuto chvíli se jimi nebudeme zabývat a budeme předpokládat, že ve chvíli, kdy stáhneme zdrojový balíček, již existují.

note: (itstool) path: sect2/para
en: In fact, you don't need <application>Autotools</application> to build an autotools package, <application>configure</application> is a shell script running on the most basic shell: <filename>sh</filename>. It probes your system checking each characteristic and writes makefiles from the templates.
cs: Ve skutečnosti na sestavení balíčku založeného na autotools nepotřebujete <application>Autotools</application>, protože <application>configure</application> je shellový skript běžící běžící na nejzákladnějším shellu: <filename>sh</filename>. Zkoumá váš systém pomocí kontroly jednotlivých vlastností a podle šablony zapisuje Makefile.

note: (itstool) path: important/para
en: In order to build a project using a library, you need more information about it, so additional files. For a library used in a C program, you need the corresponding header files. This has to be installed on your system and is typically found in a so called development package. By example for the library <application>libxml2</application>, there are two packages:
cs: Abyste mohli sestavit projekt používající knihovnu, potřebujete o knihovně více informací, tj. další soubory. Pro knihovny, které se používají v programech napsaných v C, potřebujete příslušné hlavičkové soubory. Ty musí být nainstalované v systému a typicky je najdete v tzv. vývojářských balíčcích. Například pro knihovnu <application>libxml2</application> existují dva balíčky:

note: (itstool) path: listitem/para
en: <filename>libxml2</filename> necessary to run a program using it and installed automatically as a dependency of such program.
cs: <filename>libxml2</filename> nutný ke spuštění programu, který jej používá, a instalovaný automaticky jako závislost takového programu.

note: (itstool) path: listitem/para
en: <filename>libxml2-devel</filename> necessary to build a program using it. If you don't have it <application>configure</application> will display an error message.
cs: <filename>libxml2-devel</filename> nutný k sestavení programu, který jej používá. Pokud jej nemáte nainstalovaný, zobrazí <application>configure</application> chybové hlášení.

note: (itstool) path: figure/title
en: Configure process
cs: Zpracování pomocí configure

note: (itstool) path: sect2/para
en: <application>configure</application> creates all files in the directory where it is called. This directory is the <emphasis>build directory</emphasis>. If you run it from the source directory, using <userinput>./configure</userinput>, the build directory will be the same.
cs: <application>configure</application> vytvoří všechny soubory ve složce, ze které je zavolán. Tato složka je pak <emphasis>složkou sestavení</emphasis>. Když jej spustíte ze složky se zdrojovými soubory, pomocí <userinput>./configure</userinput>, bude složka sestavení tamtéž.

note: (itstool) path: sect2/para
en: <application>configure</application> accepts several options in the command line. They are used to install the files in different directories, to disable some parts of the project in order to get a smaller executable or if you haven't one needed library or force a value for some <application>make</application> variable (see <xref linkend="build-make-vars"/>). You can get a list of them by running <userinput>configure --help</userinput>. Here is a list of the most common ones:
cs: <application>configure</application> přijímá na příkazové řádce několik přepínačů. Používají se k instalaci souborů do různých složek, k zakázání některých částí projektu, aby měl menší výslednou velikost a nebo se vynechala nechtěná knihovna, nebo k vynucení hodnot pro některé proměnné <application>make</application> (viz <xref linkend="build-make-vars"/>). Seznam přepínačů získáte spuštěním <userinput>configure --help</userinput>. Zde je seznam nejběžnějších z nich:

note: (itstool) path: listitem/para
en: List all available options
cs: Seznam dostupných voleb

note: (itstool) path: varlistentry/term
en: <parameter>--host <replaceable>host</replaceable></parameter>
cs: <parameter>--host <replaceable>hostitel</replaceable></parameter>

note: (itstool) path: listitem/para
en: Compile to run on another system (cross compilation)
cs: Zkompilovat pro spuštění na jiném systému (tzv. křížová kompilace)

note: (itstool) path: varlistentry/term
en: <parameter>--prefix <replaceable>dir</replaceable></parameter>
cs: <parameter>--prefix <replaceable>složka</replaceable></parameter>

note: (itstool) path: listitem/para
en: Select the root directory for installing the project, default /usr/local
cs: Určí kořenovou složku pro instalaci projektu; výchozí je /usr/local

note: (itstool) path: note/para
en: <application>configure</application> generates a few additional files which are less important. <filename>config.log</filename> is a log file useful when something goes wrong to get more details. <filename>config.status</filename> is another shell script, it can be run to restore the current configuration. <filename>config.h</filename> is a header file generated like <filename>Makefile</filename> from a template <filename>config.h.in</filename> if it exists.
cs: <application>configure</application> vytváří pár dodatečných souborů, které nejsou až tak důležité. <filename>config.log</filename> je záznam, který se může hodit k dohledání podrobností, když je něco špatně. <filename>config.status</filename> je další shellový skript, pomocí kterého se dá obnovit aktuální konfigurace. <filename>config.h</filename> je hlavičkový soubor generovaný podobně jako <filename>Makefile</filename> ze šablony, konkrétně z <filename>config.h.in</filename>, pokud existuje.

note: (itstool) path: sect2/para
en: The makefiles generated by <application>configure</application> are quite complex but are standard makefiles. They define all standard targets needed by GNU standard.
cs: Soubory Makefile vygenerované příkazem <application>configure</application> jsou sice trochu komplikovanější, ale pořád to jsou standardní soubory ve formátu makefile. Definují všechny standardní cíle požadované standardem GNU.

note: (itstool) path: listitem/para
en: <userinput>make</userinput> or <userinput>make all</userinput> builds the program.
cs: <userinput>make</userinput> nebo <userinput>make all</userinput> sestaví program.

note: (itstool) path: listitem/para
en: <userinput>make install</userinput> installs the program.
cs: <userinput>make install</userinput> nainstaluje program.

note: (itstool) path: listitem/para
en: <userinput>make distclean</userinput> removes all files generated by <application>configure</application>, to let the project in the state it was when unpacking the distribution package.
cs: <userinput>make distclean</userinput> odstraní všechny soubory vygenerované příkazem <application>configure</application>, takže dostanete projekt do stavu, jako byl před rozbalení distribučního balíčku.

note: (itstool) path: sect1/title
en: Using <application>Anjuta</application>
cs: Použití IDE <application>Anjuta</application>

note: (itstool) path: sect1/para
en: Now, we will see the <application>Anjuta</application> interface allowing you to run all these commands without using the command line.
cs: Nyní se podíváme na uživatelské rozhraní <application>Anjuty</application>, ve kterém můžete spouštět všechny tyto příkazy bez použití příkazové řádky.

note: (itstool) path: sect2/para
en: As <application>Anjuta</application> is using <application>Autotools</application>, the first step is similar, you need to run configure. Select <menuchoice><guisubmenu>Build</guisubmenu> <guimenuitem>Configure Project...</guimenuitem></menuchoice>, to get the following dialog:
cs: Protože <application>Anjuta</application> používá <application>Autotools</application>, je první krok podobný – potřebujete spustit skript configure. Vyberte <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenuitem>Konfigurovat projekt…</guimenuitem></menuchoice> a objeví se následující dialogové okno:

note: (itstool) path: figure/title
en: Configure dialog
cs: Dialogové okno konfigurace

note: (itstool) path: sect2/para
en: The <guilabel>Regenerate project</guilabel> checkbox will not be described now as it is related to project creation (see in <xref linkend="create-autotools-generate"/>).
cs: Zaškrtávací políčko <guilabel>Přegenerovat projekt</guilabel> v tuto chvíli popisovat nebudeme, protože to patří k tématu vytváření projektu (viz <xref linkend="create-autotools-generate"/>).

note: (itstool) path: sect2/para
en: The <guilabel>Configuration</guilabel> field is an user name used to reference this particular configuration to switch between different ones later. For <application>Anjuta</application> each configuration corresponds to one build directory and a set of configure options. <application>Anjuta</application> already provides some default configurations that you can select here.
cs: Pole <guilabel>Konfigurace</guilabel> slouží pro uživatelský název, podle kterého uživatel danou konfiguraci rozpozná a může se na ni později přepnout. V <application>Anjutě</application> každá konfigurace odpovídá jedné složce sestavení a sadě konfiguračních voleb. <application>Anjuta</application> má připravených několik výchozích konfiguraci, ze kterých si zde můžete zvolit.

note: (itstool) path: note/para
en: It is recommended to use the Debug configuration for debugging. It will compile your program with all optimizations disabled. When optimizations are enabled, some variables and functions are removed, you will not be able to see them with the debugger. Moreover some lines in your source code are re-ordered, so some steps will go backward.
cs: Pro ladění se doporučuje použít konfiguraci Ladění. Zkompiluje váš program s vypnutými veškerými optimalizacemi. Když jsou optimalizace zapnuté, některé proměnné a funkce jsou odstraněny a nemůžete je tak vidět v ladicím programu. Navíc se mění pořadí řádků ve zdrojovém kódu, takže byste pak při krokování posouvali i zpět.

note: (itstool) path: sect2/para
en: The <guilabel>Build Directory</guilabel> field allow to select the directory used to build the project. It must be different for each configuration.
cs: Pole <guilabel>Složka sestavení</guilabel> slouží k výběru složky používané k sestavení projektu. Musí být pro každou konfiguraci jiná.

note: (itstool) path: important/para
en: If you build the project in the source directory (leaving the <guilabel>Build Directory</guilabel> field empty), you cannot create a new configuration. It is a limitation of <application>Autotools</application>. You need to select <menuchoice><guisubmenu>Build</guisubmenu> <guimenuitem>Remove Configuration</guimenuitem></menuchoice> that will run <userinput>make distclean</userinput> in the source directory first.
cs: Když sestavujete projekt ve zdrojové složce (tj. když ponecháte pole <guilabel>Složka sestavení</guilabel> prázdné), nemůžete vytvořit novou konfiguraci. Jde o omezení <application>Autotools</application>. Musíte nejprve použít <menuchoice><guisubmenu>Sestavit</guisubmenu> <guimenuitem>Odstranit konfiguraci</guimenuitem></menuchoice>, čímž se ve zdrojové složce spustí <userinput>make distclean</userinput>.

note: (itstool) path: sect2/para
en: The <guilabel>Configure Options</guilabel> field allow passing different options to the configure script.
cs: Pole <guilabel>Volby příkazu configure</guilabel> umožňuje předat konfiguračnímu skriptu další přepínače.

note: (itstool) path: sect2/para
en: Clicking on <guibutton>Execute</guibutton> will run the configure script. All the output will appears in the message view of <application>Anjuta</application>. If the script runs without error, it will enable all other entries in the <guisubmenu>Build</guisubmenu> menu.
cs: Kliknutím na <guibutton>Spustit</guibutton> se spustí konfigurační skript. Všechny jeho výstupy se objeví v zobrazení zpráv přímo v aplikaci <application>Anjuta</application>. V případě, že skript projde bez chyb, zpřístupní se všechny další položky v nabídce <guisubmenu>Sestavit</guisubmenu>.

note: (itstool) path: sect2/title
en: Menu items
cs: Položky nabídky

note: (itstool) path: sect2/para
en: The build operations in <application>Anjuta</application>, rely on <application>make</application> only like <application>Autotools</application>. It is working for non <application>Autotools</application> project too. The compile command is even working with only a C source file because <application>make</application> has some builtin rules to compile them. Here is the correspondence between the <application>Anjuta</application> menu item and <application>make</application> commands.
cs: Operace sestavení v <application>Ajutě</application> spoléhá pouze na <application>make</application>, stejné jako v <application>Autotools</application>. Funguje to i u projektů, které nejsou založené na <application>Autotools</application>. Příkaz pro kompilaci pak pracuje jen se zdrojovými soubory v jazyce C, protože <application>make</application> má vestavěná pravidla pro jejich kompilaci. Zde je uvedeno, která položka nabídky aplikace <application>Anjuta</application> odpovídá kterému příkazu <application>make</application>.

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Compile</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Zkompilovat</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: make <replaceable>current_file</replaceable>
cs: make <replaceable>aktuální_soubor</replaceable>

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Build</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Sestavit</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: cd <userinput>current_file_directory</userinput>; make
cs: cd <userinput>složka_aktuálního_souboru</userinput>; make

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Build Project</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Sestavit projekt</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: cd <userinput>project_directory</userinput>; make
cs: cd <userinput>složka_projektu</userinput>; make

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Build Tarball</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Sestavit balíček TAR</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: cd <userinput>project_directory</userinput>; make dist
cs: cd <userinput>složka_projektu</userinput>; make dist

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Install</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Nainstalovat</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: cd <userinput>current_file_directory</userinput>; make install
cs: cd <userinput>složka_aktuálního_souboru</userinput>; make install

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Install Project</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Nainstalovat projekt</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: cd <userinput>project_directory</userinput>; make install
cs: cd <userinput>složka_projektu</userinput>; make install

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Clean</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Vyčistit</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: cd <userinput>current_file_directory</userinput>; make clean
cs: cd <userinput>složka_aktuálního_souboru</userinput>; make clean

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Clean Project</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Vyčistit projekt</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: cd <userinput>project_directory</userinput>; make clean
cs: cd <userinput>složka_projektu</userinput>; make clean

note: (itstool) path: varlistentry/term
en: <menuchoice><guisubmenu>Build</guisubmenu><guimenu>Remove Configuration</guimenu></menuchoice>
cs: <menuchoice><guisubmenu>Sestavit</guisubmenu><guimenu>Odstranit konfiguraci</guimenu></menuchoice>

note: (itstool) path: listitem/para
en: cd <userinput>project_directory</userinput>; make distclean
cs: cd <userinput>složka_projektu</userinput>; make distclean

note: (itstool) path: sect2/para
en: The last menu entry not described above ,<menuchoice><guisubmenu>Build</guisubmenu> <guimenuitem>Select Configuration</guimenuitem></menuchoice>, allows you to switch easily between different configurations and so between different build directories.
cs: Poslední položka nabídky <menuchoice><guisubmenu>Sestavit</guisubmenu> <guimenuitem>Vybrat konfiguraci</guimenuitem></menuchoice>, které nebyla výše popsána, umožňuje přepnout mezi různými konfiguracemi a také mezi různými složkami sestavení.

note: (itstool) path: sect2/title
en: Options
cs: Volby

note: (itstool) path: sect2/para
en: A few common build options are available in the preferences page that you can get by selecting <menuchoice><guisubmenu>Edit</guisubmenu> <guimenuitem>Preferences</guimenuitem><guimenuitem>Build autotools</guimenuitem> </menuchoice>.
cs: Pár běžných voleb sestavení najdete na stránce s předvolbami, ke které se dostanete pomocí <menuchoice><guisubmenu>Upravit</guisubmenu> <guimenuitem>Předvolby</guimenuitem> <guimenuitem>Autotools pro sestavení</guimenuitem></menuchoice>.

note: (itstool) path: figure/title
en: Build preferences
cs: Předvolby sestavení

note: (itstool) path: chapter/title
en: Creating a project
cs: Vytvoření projektu

note: (itstool) path: chapter/para
en: This chapter explains how to create a new project. Like the previous, it starts with <application>Autotools</application> before looking at <application>Anjuta</application>.
cs: Tato kapitola vysvětluje, jak vytvořit nový projekt. Obdobně jako v předchozí kapitole, začneme s <application>Autotools</application> a teprve pak se podíváme na <application>Anjutu</application>.

note: (itstool) path: sect1/para
en: In the first chapter, we have not really used the <application>Autotools</application>. It is not need to compile a project from the sources. But all files in the build process are not written by hand but generated from templates using <application>Autotools</application>.
cs: V první kapitole jsme ve skutečnosti nepoužili nástroj <application>Autotools</application>. Při kompilaci ze zdrojových kódů není nutný. Ale všechny soubory v sestavovacím procesu se nepíšou ručně. Generují se ze šablon pomocí <application>Autotools</application>.

note: (itstool) path: sect1/para
en: <application>Autotools</application> is composed of several tools: <filename>aclocal</filename>, <filename>autoconf</filename>, <filename>automake</filename> and other that we will not see here, belonging to two packages: <application>Automake</application> and <application>Autoconf</application>.
cs: <application>Autotools</application> se ve skutečnosti skládají z několika nástrojů: <filename>aclocal</filename>, <filename>autoconf</filename>, <filename>automake</filename> a z dalších, které zde neuvidíme a které patří do dvou balíčků: <application>Automake</application> a <application>Autoconf</application>.

note: (itstool) path: listitem/para
en: <application>Autoconf</application> is used to generate the configure script, from a template named <filename>configure.ac</filename>. The configure script will check all characteristics of the host system and generate the makefiles from Makefile.in templates.
cs: <application>Autoconf</application> se používá ke generování konfiguračního skriptu ze šablony nazvané <filename>configure.ac</filename>. Konfigurační skript zkontroluje všechny vlastnosti hostitelského systému a vygeneruje soubor <filename>Makefile</filename> ze šablony <filename>Makefile.in</filename>.

note: (itstool) path: listitem/para
en: <application>Automake</application> is used to generate complete Makefile.in templates, following GNU standards from very simple Makefile.am templates.
cs: <application>Automake</application> se používá ke generování úplných šablon Makefile.in, které splňují standardy GNU, z velmi jednoduchých šablon Makefile.am.

note: (itstool) path: figure/title
en: <application>Autotools</application> process
cs: Zpracování pomocí <application>Autotools</application>

note: (itstool) path: sect1/para
en: Now let's see a minimal example to start grasping the relationships between the various files.
cs: Nyní se pojďme podívat na minimalistický příklad, abychom pochopili vztahy mezi jednotlivými soubory.

note: (itstool) path: sect2/title
en: Write sources
cs: Psaní zdrojových kódů

note: (itstool) path: listitem/para
en: Create an empty directory called <filename>tut_prog</filename> and enter in it.
cs: Vytvořte prázdnou složku s názvem <filename>tut_prog</filename> a přepněte se do ní.

note: (itstool) path: listitem/para
en: In this new directory, create a new file named <filename>main.c</filename> containing:
cs: V této nové složce vytvořte nový soubor s názvem <filename>main.c</filename>, který bude obsahovat:

note: (itstool) path: sect2/title
en: Run <application>Autoconf</application>
cs: Spuštění <application>Autoconf</application>

note: (itstool) path: listitem/para
en: Write the following in a file named <filename>configure.ac</filename>:
cs: Zapište následující do souboru nazvaného <filename>configure.ac</filename>:

note: (itstool) path: example/title
en: minimal configure.ac:
cs: minimální configure.ac:

note: (itstool) path: note/para
en: The configure template script could be named <filename>configure.in</filename>. It is the name used in older version (before 2001) of <application>Autoconf</application>. Nevertheless, it is recommended to use <filename>configure.ac</filename> because the <filename>.in</filename> extension is already used by files processed by <application>configure</application> and generated by <application>Automake</application>: <filename>Makefile.in</filename> and <application>autoheader</application>: <filename>config.h.in</filename>.
cs: Šablona konfiguračního skriptu by se mohla jmenovat <filename>configure.in</filename>. Tento název se skutečně používal ve starší verzi <application>Autoconf</application> (před rokem 2001). Nicméně doporučujeme použít <filename>configure.ac</filename>, protože přípona <filename>.in</filename> je již používaná soubory zpracovávanými pomocí <application>configure</application> a generovanými pomocí <application>Automake</application> (<filename>Makefile.in</filename>) a pomocí <application>autoheader</application> (<filename>config.h.in</filename>).

note: (itstool) path: sect2/para
en: AC_INIT, AM_INIT_AUTOMAKE, etc... are <application>M4</application> macros. <application>M4</application> is a macro expanding software used by <application>Autotools</application>; we don't need to know about it. When <application>Autoconf</application> will process this configure.in, the macros will be expanded and we will get a fresh huge configure script.
cs: AC_INIT, AM_INIT_AUTOMAKE, atd. jsou makra <application>M4</application>. <application>M4</application> je software pro rozvíjení maker používaný <application>Autotools</application>. V zásadě o něm ani nepotřebujeme vědět. Když <application>Autoconf</application> zpracovává tento configure.in, makra se rozvíjí a nakonec dostaneme čistý dlouhý skript configure.

note: (itstool) path: listitem/para
en: Is the first mandatory macro. We need to indicate the name of the project and its version.
cs: Jedná se o povinné první makro. Musíte mu zadat název projektu a jeho verzi.

note: (itstool) path: listitem/para
en: Initialize environment for <application>Automake</application>. It is needed in all projects using <application>Automake</application>.
cs: Inicializuje prostředí proměnných pro <application>Automake</application>. Je zapotřebí ve všech projektech používajících <application>Automake</application>.

note: (itstool) path: listitem/para
en: Determine the C compiler to use.
cs: Určuje, který kompilátor jazyka C se má použít.

note: (itstool) path: listitem/para
en: Create each file by copying the corresponding template file (with .in extension) and substituting the output variable values.
cs: Vytvoří jednotlivé soubory zkopírováním příslušných šablonových souborů (s příponou .in) a nahrazením hodnot výstupních proměnných.

note: (itstool) path: listitem/para
en: Marks the end of the configure template.
cs: Označuje konec šablony pro skript configure.

note: (itstool) path: note/para
en: The use of some macros has changed between different versions of <application>Autoconf</application>:
cs: Používání některých maker se změnilo mezi jednotlivými verzemi <application>Autoconf</application>:

note: (itstool) path: listitem/para
en: The package name and version was defined as arguments of AM_INIT_AUTOMAKE instead of AC_INIT.
cs: Název balíčku býval definován jako argument AM_INIT_AUTOMAKE namísto AC_INIT.

note: (itstool) path: listitem/para
en: AC_OUTPUT was getting the list of generated files instead of using the additional macro AC_CONFIG_FILES.
cs: AC_OUTPUT přebíralo seznam generovaných souborů namísto použití přídavného makra AC_CONFIG_FILES.

note: (itstool) path: sect2/para
en: <application>Autoconf</application> only knows its own macros but read additional ones in a file named <filename>aclocal.m4</filename>. These macros are used to extend <application>Autoconf</application>, it includes <application>Automake</application> macro (starting with AM_) and other third party macros. For instance, if you develop a library called foo, you might want to write an AC_CHECK_FOR_FOO macro so that developers using your library can check for its presence using <application>Autoconf</application>.
cs: <application>Autoconf</application> zná jen svá vlastní makra, ale čte i další v souboru nazvaném <filename>aclocal.m4</filename>. Tato makra se používají k rozšíření funkčnosti <application>Autoconf</application>. Patří k nim makra z <application>Automake</application> (začínající AM_) a další makra od třetích stran. Například, když vyvíjíte knihovnu foo, můžete chtít napsat makro AC_CHECK_FOR_FOO, aby vývojáři, kteří budou knihovnu používat, mohli pomocí <application>Autoconf</application> kontrolovat její přítomnost v systému.

note: (itstool) path: sect2/para
en: <application>aclocal</application> scans <filename>configure.ac</filename> and create an <filename>aclocal.m4</filename> file which contains the macros mentioned in <filename>configure.ac</filename>. <application>aclocal</application> is part of the <application>Automake</application> package and search by default in <application>Automake</application> macros and in a system path typically <filename>/usr/share/aclocal</filename>.
cs: <application>aclocal</application> prochází <filename>configure.ac</filename> a vytváří soubor <filename>aclocal.m4</filename>, který obsahuje makra použitá v <filename>configure.ac</filename>. <application>aclocal</application> je součástí balíčku <application>Automake</application> a standardně hledá v makrech <application>Automake</application> a v nějaké systémové cestě, typicky <filename>/usr/share/aclocal</filename>.

note: (itstool) path: listitem/para
en: Launch <userinput>aclocal</userinput>. It will create a new file named <filename>aclocal.m4</filename> in the current directory.
cs: Spusťte <userinput>aclocal</userinput>. Vytvoří se tím v aktuální složce nový soubor s názvem <filename>aclocal.m4</filename>.

note: (itstool) path: listitem/para
en: Launch <userinput>autoconf</userinput>. It will create the configure script <filename>configure</filename>.
cs: Spusťte <userinput>autoconf</userinput>. Vytvoří se tím nový konfigurační skript <filename>configure</filename>.

note: (itstool) path: tip/para
en: On my system, I actually get an extra directory called <filename>autom4te.cache</filename>. That is for <application>Autoconf</application> internal purposes. You do not need to care about it.
cs: Ve skutečnosti se vám vytvoří ještě další složka s názvem <filename>autom4te.cache</filename>. Ta je pro interní účely <application>Autoconf</application> a nemusíte se jí zabývat.

note: (itstool) path: sect2/title
en: Run <application>Automake</application>
cs: Spuštění <application>Automake</application>

note: (itstool) path: listitem/para
en: Write the following in a file named <filename>Makefile.am</filename>:
cs: Do souboru s názvem <filename>Makefile.am</filename> zapište následující:

note: (itstool) path: example/title
en: minimal Makefile.am:
cs: minimální Makefile.am:

note: (itstool) path: sect2/para
en: In Makefile.am are the very essential data needed to build the project: the target program, called tut_prog, will be put in a $prefix/bin/ directory; to build it we need main.c. Note that we don't specify <emphasis>how</emphasis> that will be built: <application>Automake</application> will figure it out. We haven't even mentioned the compiler in this pre-makefile.
cs: V Makefile.am jsou nejzákladnější data potřebná k sestavení projektu: cíl programu, nazvaný tut_prog, bude umístěn do složky $prefix/bin/ a k jeho sestavení potřebujeme main.c. Všimněte si, že není řečeno, <emphasis>jak</emphasis> bude sestaven. <application>Automake</application> si to zjistí. V tomto předchůdci Makefile není zmíněn ani kompilátor.

note: (itstool) path: sect2/para
en: Makefile.am will be processed by <application>Automake</application>; the result will be a Makefile.in. This Makefile.in is close to being a real makefile, but it contains variable names which will be replaced when the configure script will run, resulting in a real makefile (called Makefile). For instance, <filename>configure</filename> will write in the final Makefile what compiler to use (it is the compiler it found using the AC_PROG_CC macro).
cs: Makefile.am bude zpracován pomocí <application>Automake</application> a výsledkem bude Makefile.in. Ten už se hodně podobá skutečnému souboru makefile, ale obsahuje názvy proměnných, které budou při spuštění skriptu configure nahrazené, a výsledkem se stane skutečný makefile (nazvaný Makefile). Skript <filename>configure</filename> kupříkladu zapíše do výsledného souboru Makefile, který kompilátor se má použít (což je ten, který nalezlo makro AC_PROG_CC).

note: (itstool) path: listitem/para
en: Run the command <userinput>automake --add-missing --foreign</userinput>. It will create a new file named <filename>Makefile.in</filename> as expected. Moreover, due to the switch <parameter>--add-missing</parameter> you get a few links to scripts necessary for building the project: <filename>depcomp</filename>, <filename>install.sh</filename> and <filename>missing</filename>. The other option <parameter>--foreign</parameter> tells to <application>Automake</application> that you don't want to follow GNU standard and you don't need mandatory documentation files: <filename>INSTALL</filename>, <filename>NEWS</filename>, <filename>README</filename>, <filename>AUTHORS</filename>, <filename>ChangeLog</filename> and <filename>COPYING</filename>. I have used it here to keep the number of created file to a minimum but else it is a good idea to provide these files, you can start with empty files.
cs: Spusťte příkaz <userinput>automake --add-missing --foreign</userinput>. Vytvoří nový soubor nazvaný, podle očekávání, <filename>Makefile.in</filename>. Navíc, díky přepínači <parameter>--add-missing</parameter> získáte několik odkazů na na skripty nutné pro sestavení projektu: <filename>depcomp</filename>, <filename>install.sh</filename> a <filename>missing</filename>. Druhý přepínač <parameter>--foreign</parameter> říká <application>Automake</application>, že se nechcete držet standardů GNU a nepotřebujete povinné dokumentační soubory: <filename>INSTALL</filename>, <filename>NEWS</filename>, <filename>README</filename>, <filename>AUTHORS</filename>, <filename>ChangeLog</filename> a <filename>COPYING</filename>. Zde jsme jej použili, abychom udrželi počet vytvořených souborů na minimu, ale jinak je dobré tyto soubory poskytovat a začít můžete klidně s prázdnými.

note: (itstool) path: sect2/title
en: Build project
cs: Sestavení projektu

note: (itstool) path: listitem/para
en: Run now the new configure script: <userinput>./configure</userinput>. You get the following output and it create the makefile for your program.
cs: Nyní spusťte nový konfigurační skript: <userinput>./configure</userinput>. Objeví se následující výstup a vytvoří se <filename>Makefile</filename> pro váš program.

note: (itstool) path: listitem/para
en: Run now <userinput>make</userinput>, to build your program. You get the following output and a new tut_prog executable
cs: Nyní spusťte <userinput>make</userinput>, aby se váš program sestavil. Objeví se následující výstup a nový spustitelný soubor tut_prog.

note: (itstool) path: listitem/para
en: Now, if you can write in <filename>/usr/local/bin</filename>, run <userinput>make install</userinput> to install your program. Else you need to log as root before or use <application>sudo</application> and run <userinput>sudo make install</userinput>. You should get.
cs: Nyní, za předpokladu, že máte právo zápisu do <filename>/usr/local/bin</filename>, můžete spustit <userinput>make install</userinput>, aby se program nainstaloval. Pokud jej nemáte, musíte se nejprve přihlásit jako uživatel root nebo použít <application>sudo</application> a spustit <userinput>sudo make install</userinput>. Mělo by se objevit:

note: (itstool) path: listitem/screen
en: 
    make[1]: Entering directory `/home/seb/Projects/Tutorial'
    test -z "/usr/local/bin" || /bin/mkdir -p "/usr/local/bin"
      /usr/bin/install -c 'tut_prog' '/usr/local/bin/tut_prog'
    make[1]: Nothing to be done for `install-data-am'.
    make[1]: Leaving directory `/home/seb/Projects/Tutorial'
cs: 
    make[1]: Vstupuje se do složky „/home/seb/Projects/Tutorial“
    test -z "/usr/local/bin" || /bin/mkdir -p "/usr/local/bin"
      /usr/bin/install -c 'tut_prog' '/usr/local/bin/tut_prog'
    make[1]: Pro „install-data-am“ nebude nic uděláno.
    make[1]: Opouští se složka „/home/seb/Projects/Tutorial“

note: (itstool) path: listitem/para
en: Then, if <filename>/user/local/bin</filename> is in your path, you can run your program from everywhere.
cs: Jestliže je <filename>/user/local/bin</filename> součástí prohledávaných cest, můžete svůj program potom spustit odkudkoliv.

note: (itstool) path: sect2/title
en: Clean project
cs: Promazání projektu

note: (itstool) path: listitem/para
en: The program is installed, so you can clean the build directory running <userinput>make clean</userinput>. It removes all object files and the program but not the makefiles.
cs: Program je nainstalovaný, takže složku sestavení můžete klidně promazat spuštěním <userinput>make clean</userinput>. Tím se odstraní všechny objektové soubory a program, ale ne už soubory Makefile.

note: (itstool) path: listitem/para
en: You can still run the program installed in <filename>/user/local/bin</filename>.
cs: Program nainstalovaný v <filename>/user/local/bin</filename> ale můžete samozřejmě nadále spouštět.

note: (itstool) path: listitem/para
en: To remove the installed program, run <userinput>make uninstall</userinput>. Like for the installation, you need to use have the writing right in the directory or use <application>su</application> or <application>sudo</application>.
cs: Pokud byste chtěli odstranit nainstalovaný program, spusťte <userinput>make uninstall</userinput>. Podobně jako u instalace, musíte mít práva zápisu do složky, nebo použít <application>su</application> nebo <application>sudo</application>.

note: (itstool) path: sect2/title
en: Generate project
cs: Vygenerování projektu

note: (itstool) path: sect2/para
en: Running <userinput>aclocal</userinput>, <userinput>automake</userinput> and <userinput>autoconf</userinput> one by one is fine for a tutorial to understand exactly what's happen. But, for a real work, it's a bit tedious especially because there are other tools those could be needed like <userinput>autoheader</userinput>, <userinput>autopoint</userinput> or <userinput>libtoolize</userinput>. After creating the project, the makefiles generated by <application>configure</application> should take care of regenerating <filename>configure</filename> and all <filename>Makefile.in</filename>. Anyway, this lets a room for improvement and there are even two responses to this:
cs: Abyste pochopili, co přesně se děje, je nejlepší si v rámci této výuky spustit jeden po druhém <userinput>aclocal</userinput>, <userinput>automake</userinput> a <userinput>autoconf</userinput>. Při skutečné práci by to ale bylo poněkud únavné, nehledě na další nástroje, které mohou být zapotřebí, jako <userinput>autoheader</userinput>, <userinput>autopoint</userinput> nebo <userinput>libtoolize</userinput>. Po vytvoření projektu by se o přegenerování souboru <filename>configure</filename> a všech souborů <filename>Makefile.in</filename> měly postarat speciální soubory <filename>Makefile</filename> vygenerované aplikací <application>configure</application>. Každopádně tu zůstává prostor k vylepšování a na výzvu existují i dvě odpovědi:

note: (itstool) path: listitem/para
en: It is another tool part of the <application>Autoconf</application> package which is running all scripts in the right order. To start a new project, you can just run <userinput>autoreconf --install</userinput> and it will call all necessary commands.
cs: Jedná se o další nástroj z balíčku <application>Autoconf</application>, který spustí všechny skripty ve správném pořadí. Když chcete začít nový projekt, stačí spustit <userinput>autoreconf --install</userinput> a zavolají se všechny potřebné příkazy.

note: (itstool) path: listitem/para
en: It is a script not part of <application>Autotools</application>, that it doing the same thing. There is one named <filename>gnome-autogen.sh</filename> which comes with GNOME common development package but other project can write their own ones.
cs: Jedná se o skript, který není součástí <application>Autotools</application>, ale dělá stejné věci. Se základním vývojářským balíčkem GNOME je šířen jeden takový, s názvem <filename>gnome-autogen.sh</filename>. Jiné projekty mohou mít napsaný svůj vlastní.

note: (itstool) path: sect1/para
en: Creating a project with <application>Anjuta</application> need just a few clicks but then we will take a look at the created files.
cs: Vytvoření projektu a IDE <application>Anjuta</application> vyžaduje jen pár kliknutí, ale pak si vytvořené soubory probereme.

note: (itstool) path: sect2/title
en: Create a new project
cs: Vytvoření nového projektu

note: (itstool) path: listitem/para
en: Click on <menuchoice><guisubmenu>File</guisubmenu><guisubmenu>New</guisubmenu> <guimenuitem>Project</guimenuitem></menuchoice>. The new project assistant appears.
cs: Klikněte na <menuchoice><guisubmenu>Soubor</guisubmenu> <guisubmenu>Nový</guisubmenu> <guimenuitem>Projekt</guimenuitem></menuchoice>. Objeví se průvodce novým projektem.

note: (itstool) path: listitem/para
en: Click on <guibutton>Forward</guibutton>. The project selection page appears:
cs: Klikněte na <guibutton>Následující</guibutton>. Objeví se stránka pro výběr projektu:

note: (itstool) path: figure/title
en: Project selection page
cs: Stránka pro výběr projektu

note: (itstool) path: listitem/para
en: Select <guilabel>Generic (minimal)</guilabel> project in the <guilabel>C</guilabel> page.
cs: Vyberte <guilabel>Obecný (minimální)</guilabel> projekt na kartě <guilabel>C</guilabel>.

note: (itstool) path: listitem/para
en: Click on <guibutton>Forward</guibutton>.
cs: Klikněte na <guibutton>Následující</guibutton>.

note: (itstool) path: figure/title
en: Project basic information page
cs: Stránka se základními informacemi o projektu

note: (itstool) path: listitem/para
en: Change <guilabel>Project Name</guilabel> to <userinput>tutprog</userinput>, the project name should contains only alpha numeric characters or underscore. Fill the remaining field.
cs: Změňte <guilabel>Název projektu</guilabel> na <userinput>tutprog</userinput>. Název by měl obsahovat jen písmena a číslice, případně podtržítko. Vyplňte zbývající pole.

note: (itstool) path: listitem/para
en: Click on <guilabel>Forward</guilabel>.
cs: Klikněte na <guibutton>Následující</guibutton>.

note: (itstool) path: figure/title
en: Project options page
cs: Stránka s volbami projektu

note: (itstool) path: listitem/para
en: Click on <guilabel>Destination</guilabel> and create a new directory named tutprog for your new project. You need to avoid space in the directory name. Then, keep all other options to their default value to get a minimal project.
cs: Klikněte na <guilabel>Cíl</guilabel> a vytvořte pro svůj nový projekt novou složku nazvanou tutprog. V názvu složky se vyvarujte mezer a diakritiky. Všechny ostatní volby ponechejte na výchozích hodnotách, abychom dostali co nejmenší projekt.

note: (itstool) path: figure/title
en: Project summary page
cs: Stránka se souhrnným přehledem o projektu

note: (itstool) path: listitem/para
en: This is the final page of the assistant, check that everything is right.
cs: Jedná se o poslední stránku průvodce, na které si zkontrolujte, jestli je vše správně.

note: (itstool) path: listitem/para
en: Click on <guibutton>Forward</guibutton>. <application>Anjuta</application> will create all needed files and directories, in the message window, you will see the following:
cs: Klikněte na <guibutton>Použít</guibutton>. <application>Anjuta</application> vytvoří všechny potřebné soubory a složky a v okně zpráv uvidíte následující:

note: (itstool) path: figure/title
en: Project creation messages
cs: Zprávy o vytváření projektu

note: (itstool) path: listitem/para
en: Then, autogen.sh is called and run the configure script. Finally <application>Anjuta</application> open the new project. You can directly build the project, as the main source contains a few lines of C and configure has been run.
cs: Po té je zavolán skript autogen.sh a spuštěn konfigurační skript. Nakonec <application>Anjuta</application> otevře nový projekt. Jelikož hlavní zdrojový kód již obsahuje pár řádků a proběhla konfigurace, můžete projekt přímo sestavit.

note: (itstool) path: sect2/title
en: Looking at configure.ac
cs: Pohled do configure.ac

note: (itstool) path: example/title
en: <application>Anjuta</application> minimal configure.ac:
cs: Nejzákladnější configure.ac v <application>Anjutě</application>:

note: (itstool) path: sect2/para
en: It is still quite simple with a bit more macros. Let's look at all unknown ones:
cs: Stále je to docela jednoduché s pár makry navíc. Pojďme se podívat na ty, co ještě neznáme:

note: (itstool) path: listitem/para
en: It is not a macros, just the marker to start a comment in <application>M4</application>, the language used to write <filename>configure.ac</filename>. It is like '#' is scripts or '//' in C++.
cs: Nejedná se o makro, ale jen o značku začínající komentář v <application>M4</application>, což je jazyk použitý pro psaní <filename>configure.ac</filename>. Je to obdoba „#“ ve skriptech nebo „//“ v C++.

note: (itstool) path: listitem/para
en: The AC_INIT macro uses the new form with package and version but AM_INIT_AUTOMAKE keeps the old one. It is not needed anymore.
cs: Makro AC_INIT používá novou podobu s balíčkem a verzí, zatímco AM_INIT_AUTOMAKE se drží staré a v současnosti již není zapotřebí.

note: (itstool) path: listitem/para
en: This tells <application>Autoconf</application> to pass all defines in a file named <filename>config.h</filename> instead of using several -Dxxxx flags on the command line (see <xref linkend="create-autotools-build"/>). It is easier when there are lots of them. A file named <filename>config.h.in</filename> is created automatically from the <filename>configure.ac</filename> using <application>autoheader</application>. Then <filename>config.h</filename> is created automatically like makefiles by <application>configure</application>. So it is painless for the developer.
cs: Říká nástroji <application>Autoconf</application>, aby předal všechny definice v souboru s názvem <filename>config.h</filename>, místo toho, aby použil několik přepínačů -Dxxxx na příkazové řádce (viz <xref linkend="create-autotools-build"/>). Když je jich hodně, je to jednodušší. Soubor s názvem <filename>config.h.in</filename> se vytvoří automaticky z <filename>configure.ac</filename> pomocí <application>autoheader</application>. Soubor <filename>config.h</filename> je pak vytvořen automaticky pomocí <application>configure</application>, podobně jako soubory makefile. Takže je to pro vývojáře bezbolestné.

note: (itstool) path: listitem/para
en: This is the old form of the AC_OUTPUT, where you specify all output files instead of using AC_CONFIG_FILES.
cs: Jedná se o starou podobu AC_OUTPUT, ve které určujete všechny výstupní soubory, místo aby se použilo makro AC_CONFIG_FILES.

note: (itstool) path: sect2/title
en: Looking at Makefile.am
cs: Pohled do Makefile.am

note: (itstool) path: example/title
en: <application>Anjuta</application> minimal Makefile.am:
cs: Nejzákladní Makefile.am v <application>Anjutě</application>:

note: (itstool) path: sect2/para
en: Not much things in the <filename>Makefile.am</filename> neither:
cs: Moc toho v <filename>Makefile.am</filename> není:

note: (itstool) path: listitem/para
en: It is used to give additional flags to the C preprocessor. Here it defines an additional PACKAGE_DATA_DIR constant set by <application>configure</application>
cs: Používá se k předání dodatečných přepínačů preprocesoru C. Zde definuje dodatečnou konstantu PACKAGE_DATA_DIR nastavenou pomocí <application>configure</application>.

note: (itstool) path: listitem/para
en: It defines some additional flags for the C compiler: all warning and add debugging information that we have already seen at the beginning of this tutorial (see <xref linkend="build-gcc"/>)
cs: Definuje některé dodatečné přepínače pro kompilátor C: zapíná všechna varování a ladicí informace, které jsme již viděli na začátku tohoto výukového materiálu (viz <xref linkend="build-gcc"/>).

note: (itstool) path: listitem/para
en: It adds a places where you can put additional linker options for the tutprog program.
cs: Přidává místo, do kterého můžete doplnit pro program tutprog dodatečné přepínače linkeru.

note: (itstool) path: listitem/para
en: It adds a places where you can put additional libraries for the tutprog program.
cs: Přidává místo, do kterého můžete doplnit pro program tutprog dodatečné knihovny.

note: (itstool) path: chapter/title
en: Adding a library
cs: Přidání knihovny

note: (itstool) path: chapter/para
en: This chapter explains how to add a new library to a project. It starts with <application>Autotools</application> before looking at <application>Anjuta</application>.
cs: Tato kapitola vysvětluje, jak přidat do projektu novou knihovnu. Než se podíváme na <application>Anjutu</application>, začneme s <application>Autotools</application>.

note: (itstool) path: sect1/para
en: Adding a new library in a autotools project could be more or less easy depending on how the library is packaged. To take an example, imagine that we want to read an xml file using <application>libxml2</application> (see its <ulink type="http" url="www.xmlsoft.org">homepage at www.xmlsoft.org</ulink>)
cs: Přidání nové knihovny do projektu založeného na Autotools může být více či méně snadné, záleží na tom, jak je knihovna zabalená. Abychom měli příklad, představte si, že chcete číst soubor XML pomocí <application>libxml2</application> (viz <ulink type="http" url="www.xmlsoft.org">domovská stránka knihovny na www.xmlsoft.org</ulink>).

note: (itstool) path: listitem/para
en: Open the old tutorial project and replace <filename>main.c</filename> by the following.
cs: Otevřete starý projekt z tohoto výukového materiálu a nahraďte <filename>main.c</filename> následujícím:

note: (itstool) path: example/title
en: main.c using <application>libxml2</application>:
cs: main.c používající <application>libxml2</application>:

note: (itstool) path: sect1/para
en: Our goal is now to compile it and make it work correctly. For that purpose, we must tell <application>GCC</application> two things: where to find libxml/parser.h (that is to say, give <application>GCC</application> the right include path) and what library (i.e. shared object) it should link our project against. There are several ways to do that, I will start with the easiest.
cs: Naším cílem je nyní zkompilovat jej a aby správně fungoval. Za tímto účelem musíme říci <application>GCC</application> dvě věci: kde najít libxml/parser.h (tzn. dát <application>GCC</application> správnou cestu k hlavičkovým souborům) a s jakou knihovnu (tj. sdíleným objektem) by se měl náš projekt slinkovat. Je několik způsobů, jak to udělat, tak začneme tím nejjednodušším.

note: (itstool) path: sect2/title
en: With pkg-config
cs: Pomocí pkg-config

note: (itstool) path: sect2/para
en: <application>pkg-config</application> is tools for developers providing a unified interface for querying installed libraries with their version and all options needed to compile and link it. It comes with an <application>Autoconf</application> macro named PKG_CHECK_MODULES allowing to check the existence of the library and set all necessary flags.
cs: <application>pkg-config</application> je nástroj, který se snaží poskytnout vývojářům jednotné rozhraní pro dotazování nainstalovaných knihoven na jejich verzi a všechny přepínače potřebné ke kompilaci a slinkování s nimi. Patří k němu i makro pro <application>Autoconf</application>, nazvané PKG_CHECK_MODULES, pomocí kterého se kontroluje přítomnost knihovny a nastavují všechny potřebné přepínače.

note: (itstool) path: listitem/para
en: Add the following line in <filename>configure.ac</filename>.
cs: Přidejte následujíc řádek do <filename>configure.ac</filename>.

note: (itstool) path: listitem/para
en: This macro will check the existence of <application>libxml2</application> with a version higher or equal to 2.4 and create 2 variable XML_CFLAGS and XML_LIBS containing respectively, the flags for the C compiler and the linker. <userinput>XML</userinput> is an user defined name. <userinput>libxml-2.0</userinput> is the name of the library. You can run <userinput>pkg-config --list-all</userinput> to get a list of all installed libraries.
cs: Toto makro kontroluje přítomnost <application>libxml2</application> ve verzi vyšší nebo rovné 2.4 a vytvoří dvě proměnné, XML_CFLAGS a XML_LIBS, které budou obsahovat přepínače pro kompilátor C, respektive linker. <userinput>XML</userinput> je uživatelem definovaný název. <userinput>libxml-2.0</userinput> je název knihovny. Pro vypsání všech nainstalovaných knihoven můžete spustit <userinput>pkg-config --list-all</userinput>.

note: (itstool) path: listitem/para
en: Add the following lines in <filename>Makefile.am</filename>.
cs: Přidejte následujíc řádek do <filename>Makefile.am</filename>.

note: (itstool) path: listitem/para
en: This will use the options found by <application>configure</application> when the macro PKG_CHECK_MODULES is executed for compiling your program.
cs: Pro kompilaci vašeho programu se použijí přepínače, které našel skript <application>configure</application>, když spustil makro PKG_CHECK_MODULES.

note: (itstool) path: listitem/para
en: That's all. You can run <userinput>make</userinput> again.
cs: Toť vše. Můžete znovu spustit <userinput>make</userinput>.

note: (itstool) path: listitem/para
en: There is no need to rerun <application>Autoconf</application> or <application>Automake</application> because the Makefile generated by it already contains some rules to do it.
cs: Není potřeba znovu spouštět <application>Autoconf</application> nebo <application>Automake</application>, protože vygenerovaný Makefile již obsahuje nějaká pravidla, která to udělají.

note: (itstool) path: tip/para
en: When installed, each library supporting pkg-config copy a small text file, with .pc extension, in a system directory; normally <filename>/usr/lib/pkgconfig</filename>. If you install a library from source it will be by default in <filename>/usr/local/lib/pkgconfig</filename>. You can ask <application>pkg-config</application> to search in this directory too, by defining the environment variable <userinput> PKG_CONFIG_PATH=/usr/local/lib/pkgconfig</userinput>.
cs: Když se instaluje knihovna podporující pkg-config, zkopíruje se spolu s ní do systémové složky, obvykle <filename>/usr/lib/pkgconfig</filename>, malý textový soubor s příponou .pc. Při instalaci ze zdrojových kódů je předvolenou složkou <filename>/usr/local/lib/pkgconfig</filename>. Můžete požádat <application>pkg-config</application>, aby hledal i v této složce, nastavením proměnné prostředí <userinput> PKG_CONFIG_PATH=/usr/local/lib/pkgconfig</userinput>.

note: (itstool) path: sect2/title
en: With an <application>Autoconf</application> macro
cs: S nějakým makrem z <application>Autoconf</application>

note: (itstool) path: listitem/para
en: Check if the library author shipped a <application>M4</application> macro, and use it if present. It is a text file named like the library with a .m4 extension often installed in <filename>/usr/share/aclocal</filename>.
cs: Podívejte se, jestli autor knihovny šíří i makro <application>M4</application>, a pokud ano, použijte jej. Jedná se o textový soubor nazvaný stejně jako knihovna, akorát s příponou .m4, a často je nainstalován v <filename>/usr/share/aclocal</filename>.

note: (itstool) path: listitem/para
en: If your library is a basic one, it might be checked by the standard <application>Autoconf</application> macros (see the list <ulink type="http" url="http://sources.redhat.com/autobook/autobook/autobook_283.html#SEC283"> here</ulink>).
cs: Pokud se jedná o některou ze základních knihoven, může se kontrolovat pomocí standardních maker <application>Autoconf</application> (viz seznam <ulink type="http" url="http://sources.redhat.com/autobook/autobook/autobook_283.html#SEC283">zde</ulink>).

note: (itstool) path: listitem/para
en: Perhaps the <application>M4</application> macro you need has already be programmed by someone else. Look at the contributions <ulink type="http" url="http://www.gnu.org/software/ac-archive/">here</ulink>.
cs: Možná makro <application>M4</application>, které potřebujete, již někdo jiný naprogramoval. Podívejte se na příspěvky <ulink type="http" url="http://www.gnu.org/software/ac-archive/">zde</ulink>.

note: (itstool) path: listitem/para
en: If all that fail, go deeper in <application>M4</application>, make your own macro, and donate it to the library's author!
cs: Pokud všechno selže, zanořte se do <application>M4</application> hlouběji, vytvořte své vlastní makro a přispějte jím autorovi knihovny!

note: (itstool) path: sect2/para
en: If the library does not support <application>pkg-config</application>: it does not appear in the list returned by <userinput>pkg-config --list-all</userinput>. You need a <application>Autoconf</application> macro: <_:itemizedlist-1/>
cs: Pokud knihovna nepodporuje <application>pkg-config</application>, tj. neobjevuje se ve výpise vráceném příkazem <userinput>pkg-config --list-all</userinput>, potřebujete makro z <application>Autoconf</application>: <_:itemizedlist-1/>

note: (itstool) path: sect2/para
en: When, you have this macro, you can copy it in <filename>/usr/share/aclocal</filename>, so <application>aclocal</application> will find it. Then, you just need to look in the macro file to see how to use it. <application>libxml2</application> installs a macro named AM_PATH_XML2 which is in <filename>/usr/share/aclocal/libxml.m4</filename>.
cs: Pokud makro máte, můžete jej nakopírovat do <filename>/usr/share/aclocal</filename>, aby jej <application>aclocal</application> našel. Pak už se jen stačí podívat do souboru s makrem, jak jej použít. <application>libxml2</application> instaluje makro s názvem AM_PATH_XML2, které najdete v <filename>/usr/share/aclocal/libxml.m4</filename>.

note: (itstool) path: listitem/para
en: This macro will check the existence of the library with a version higher or equal to 2.4 and create 2 variable XML_CPPFLAGS and XML_LIBS containing respectively, the flags for the C compiler and the linker. You get these information from the comments in the macro file.
cs: Tohle makro bude kontrolovat přítomnost knihovny s verzí vyšší nebo rovnou 2.4 a vytvoří dvě proměnné, XML_CPPFLAGS and XML_LIBS, které budou obsahovat přepínače pro kompilátor C, respektive pro linker. Tyhle informace získáte z komentářů v souboru s makrem.

note: (itstool) path: listitem/para
en: This will use the options found by configure for compiling your program. Note that the macro defined XML_CPPFLAGS instead of XML_CFLAGS with <application>pkg-config</application>. Using CPPFLAGS makes more sense, because these flags are used by the C preprocessor, most of the time only to setup the path of the include files.
cs: Pro kompilaci programu se použijí přepínače nalezené skriptem configure. Všimněte si, že makro pomocí <application>pkg-config</application> definovalo XML_CPPFLAGS, a ne XML_CFLAGS. Použití CPPFLAGS dává větší smysl, protože tyto přepínače jsou používány preprocesorem C, nejčastěji jen k nastavení cesty k hlavičkovým souborům.

note: (itstool) path: listitem/para
en: That's all. You can run <userinput>make</userinput> again. The generated <filename>Makefile</filename> is almost the same.
cs: Toť vše. Můžete znovu spustit <userinput>make</userinput>. Vygenerovaný <filename>Makefile</filename> je téměř stejný.

note: (itstool) path: sect2/title
en: With hardcoded library path
cs: Pomocí pevně určených cest ke knihovnám

note: (itstool) path: sect2/para
en: It is the approach one could naturally have: let's give <application>GCC</application> the stuff it needs directly ! On my system, <filename>libxml/parser.h</filename> is in <filename class="directory">/usr/include/libxml2</filename>, and the shared object is 'libxml.so', located in <filename>/usr/lib</filename>. (I will assume it's all the same for you).
cs: Jde o přístup, který by člověka přirozeně napadl – přímo <application>GCC</application> předat to, co potřebuje. Například bývá v linuxových systémech <filename>libxml/parser.h</filename> uložený v <filename class="directory">/usr/include/libxml2</filename> a sdílený objekt „libxml.so“ v <filename>/usr/lib</filename>. (Budeme předpokládat, že to máte stejně.)

note: (itstool) path: listitem/para
en: There is no need to change <filename>configure.ac</filename> because you don't check anything and just assume that all host system will have the right library in the same place than you.
cs: Není potřeba měnit <filename>configure.ac</filename>, protože nic nekontrolujete a prostě předpokládáte, že všechny hostitelské systémy budou mít správné knihovny na stejném místě, jako vy.

note: (itstool) path: listitem/para
en: You can run <userinput>make</userinput> and it should work if you have the same system than me.
cs: Můžete spustit <userinput>make</userinput> a pokud to máte v systému stejně, jak bylo zmíněno, mělo by to fungovat.

note: (itstool) path: listitem/para
en: It is not portable to various linuxes: perhaps on other distribution the include path is different.
cs: Není to univerzálně přenositelné na jiné verze linuxu: v jiné distribuci je třeba cesta k hlavičkovým souborům jiná.

note: (itstool) path: listitem/para
en: If the next versions of libxml have different paths, or different needed libraries, we will need to update the project.
cs: Když bude mít příští verze knihovny libxml jiné cesty nebo jiné závislosti na knihovnách, budeme muset projekt aktualizovat.

note: (itstool) path: listitem/para
en: We don't test whether the system of the packager/user has the library.
cs: Netestujeme, jestli má systém balíčkáře/uživatele knihovnu.

note: (itstool) path: listitem/para
en: We cannot check the version of the <application>libxml2</application> we use.
cs: Nemůžeme zkontrolovat, kterou verzi <application>libxml2</application> používáme.

note: (itstool) path: sect2/para
en: I have described this here to show that it is possible to do simple thing using <application>Autotools</application>. But this approach has several drawbacks: <_:itemizedlist-1/>
cs: Tohle jsme si zde popsali, abychom viděli, jak jednoduše se to dá udělat s pomocí <application>Autotools</application>. Tento přístup má ale několik nevýhod: <_:itemizedlist-1/>

note: (itstool) path: sect1/para
en: With <application>Anjuta</application> adding a library supporting <application>pkg-config</application> can be almost done without the keyboard.
cs: Při použití <application>Anjuty</application> jde přidat knihovnu podporující <application>pkg-config</application> téměř bez použití klávesnice.

note: (itstool) path: listitem/para
en: Open the file <filename>main.c</filename> of the <application>Anjuta</application> project created in the previous chapter. Replace it with the following text:
cs: Otevřete soubor <filename>main.c</filename> z projektu, který jsem v <application>Anjutě</application> vytvořili v předchozí kapitole. Nahraďte jeho obsah následujícím textem:

note: (itstool) path: listitem/para
en: Select <menuchoice><guisubmenu>Project</guisubmenu> <guimenuitem>Properties</guimenuitem><guilabel>Packages</guilabel></menuchoice>, to get the package properties dialog.
cs: Vyberte <menuchoice><guisubmenu>Projekt</guisubmenu> <guimenuitem>Vlastnosti</guimenuitem> <guilabel>Balíčky</guilabel></menuchoice> a objeví se dialogové okno s vlastnostmi balíčku.

note: (itstool) path: listitem/para
en: Click on <guibutton>Add module</guibutton> button and Enter a name in the <guilabel>Module/Package</guilabel> column, "XML" by example.
cs: Klikněte na tlačítko <guibutton>Přidat modul</guibutton> a do sloupce <guilabel>Modul/balíček</guilabel> zadejte název, např. „XML“.

note: (itstool) path: listitem/para
en: Click on <guibutton>Add Package</guibutton> button that should be enabled now. You get the a dialog where you can select the library that you want to use. This dialog list all libraries supporting <application>pkg-config</application>. Select <userinput>libxml-2.0</userinput>. Then click on <guibutton>Add</guibutton> button.
cs: Klikněte na tlačítko <guibutton>Přidat balíček</guibutton>, které by teď mělo být přístupné. Objeví se dialogové okno, ve kterém můžete vybrat knihovnu, kterou chcete použít. V tomto dialogovém okně jsou vypsané všechny knihovny podporující <application>pkg-config</application>. Vyberte <userinput>libxml-2.0</userinput>. Pak klikněte na tlačítko <guibutton>Přidat</guibutton>.

note: (itstool) path: listitem/para
en: The package properties dialog should look like the following:
cs: Dialogové okno s vlastnostmi balíčku by mělo vypadat nějak následovně:

note: (itstool) path: figure/title
en: Project package properties dialog
cs: Dialogové okno s vlastnosti projektového balíčku

note: (itstool) path: listitem/para
en: The module XML contains one library named libxml-2.0. You can define a minimum version required by clicking in the version column and writing <userinput>&gt;= 2.4</userinput>. All this operation add the necessary lines in the file <filename>configure.ac</filename>.
cs: Modul XML obsahuje knihovnu s názvem libxml-2.0. Můžete určit minimální požadovanou verzi kliknutím ve sloupci verze a napsáním <userinput>&gt;= 2.4</userinput>. Tím se zapíší potřebné řádky do souboru <filename>configure.ac</filename>.

note: (itstool) path: listitem/para
en: Close the dialog and select <menuchoice><guisubmenu>Project</guisubmenu> <guimenuitem>Refresh</guimenuitem></menuchoice>. This should not be needed but is necessary with the current version of <application>Anjuta</application>. This bug has already been reported (#541694) and will be fixed soon
cs: Zavřete dialogové okno a vyberte <menuchoice><guisubmenu>Projekt</guisubmenu> <guimenuitem>Aktualizovat</guimenuitem></menuchoice>. Nemělo by to být potřeba, ale u aktuální verze <application>Anjuty</application> je to bohužel nutné. Bylo to již nahlášeno jako chyba (#541694) a bude to opraveno.

note: (itstool) path: listitem/para
en: In the project view, select the project target tutprog and click on right button to get a context menu and select Properties. You will get the target properties dialog.
cs: V zobrazení projektu vyberte cíl projektu tutprog a klikněte na něj pravým tlačítkem, aby se objevila kontextová nabídka, ve které vyberte <guilabel>Vlastnosti</guilabel>. Objeví se dialogové okno s vlastnostmi cíle.

note: (itstool) path: listitem/para
en: This dialog will list all modules available in your project, just check the XML module. This will modify the file <filename>Makefile.am</filename> to use the right library.
cs: V dialogovém okně jsou uvedené všechny moduly dostupné ve vašem projektu, takže stačí jednoduše zaškrtnout modul XML. Tím se příslušně změní soubor <filename>Makefile.am</filename>, aby používal správnou knihovnu.

note: (itstool) path: figure/title
en: Target properties dialog
cs: Dialogové okno s vlastnostmi cíle

note: (itstool) path: listitem/para
en: Click on <guibutton>Close</guibutton> and that's all. You can select <menuchoice><guisubmenu>Build</guisubmenu> <guimenuitem>Build</guimenuitem></menuchoice> to rebuild your project.
cs: Klikněte na <guibutton>Zavřít</guibutton> a tím je vše hotovo. Můžete vybrat <menuchoice><guisubmenu>Sestavit</guisubmenu> <guimenuitem>Sestavit</guimenuitem></menuchoice>, aby se váš projekt znovu sestavil.

note: (itstool) path: sect2/title
en: Without pkg-config
cs: Bez pkg-config

note: (itstool) path: sect2/para
en: <application>Anjuta</application> has no real support for library not using <application>pkg-config</application>. You need to edit the <filename>configure.ac</filename> directly to add all necessary macros. For passing flags to each target you can select the <guibutton>Advanced</guibutton> button in the target properties dialog.
cs: <application>Anjuta</application> nemá skutečnou podporu pro knihovny, které nepoužívají <application>pkg-config</application>. Abyste přidali potřebná makra, musíte upravit <filename>configure.ac</filename> přímo. Pro předání přepínačů do jednotlivých cílů můžete použít tlačítko <guibutton>Pokročilé</guibutton> v dialogovém okně s vlastnostmi cíle.

note: (itstool) path: chapter/title
en: Resources
cs: Odkazy

note: (itstool) path: chapter/para
en: Here are some links to reference documents dealing with <application>Autotools</application> in general and <application>Autoconf</application> and <application>Automake</application> in particular.
cs: Zde jsou odkazy na dokumentaci, která se zabývá <application>Autotools</application> obecně a konkrétně pak nástroji <application>Autoconf</application> a <application>Automake</application>.

note: (itstool) path: varlistentry/term
en: English
cs: V anličtině

note: (itstool) path: listitem/para
en: First, you can take a look at the <ulink type="http" url="http://www.gnu.org/software/autoconf/manual/autoconf.html"> Autoconf</ulink>, <ulink type="http" url="http://www.gnu.org/software/automake/manual/automake.html"> Automake</ulink>, <ulink type="http" url="http://www.gnu.org/software/libtool/manual/libtool.html"> Libtool</ulink>, <ulink type="http" url="http://www.gnu.org/software/make/manual/make.html"> make</ulink> and <ulink type="http" url="http://www.gnu.org/software/m4/manual/m4.html"> M4</ulink> manuals.
cs: Pro začátek se můžete podívat do referenčních příruček k <ulink type="http" url="http://www.gnu.org/software/autoconf/manual/autoconf.html">Autoconf</ulink>, <ulink type="http" url="http://www.gnu.org/software/automake/manual/automake.html">Automake</ulink>, <ulink type="http" url="http://www.gnu.org/software/libtool/manual/libtool.html">Libtool</ulink>, <ulink type="http" url="http://www.gnu.org/software/make/manual/make.html">make</ulink> a <ulink type="http" url="http://www.gnu.org/software/m4/manual/m4.html">M4</ulink>.

note: (itstool) path: listitem/para
en: The <ulink type="http" url="http://sources.redhat.com/autobook/autobook/autobook_toc.html"> Autobook</ulink> explains in details how the <application>Autotools</application> work.
cs: V <ulink type="http" url="http://sources.redhat.com/autobook/autobook/autobook_toc.html">Autobook</ulink> je podrobně rozebráno, jak fungují <application>Autotools</application>.

note: (itstool) path: listitem/para
en: Amongst the various GNU development tools you are told about, <ulink type="http" url="http://autotoolset.sourceforge.net/tutorial.html"> here</ulink> are <application>Autoconf</application> and <application>Automake</application>.
cs: Mezi různými vývojářskými nástroji GNU, o kterých jsme mluvili <ulink type="http" url="http://autotoolset.sourceforge.net/tutorial.html">zde</ulink>, jsou <application>Autoconf</application> a <application>Automake</application>.

note: (itstool) path: listitem/para
en: <ulink url="http://www.lrde.epita.fr/~adl/autotools.html">Here</ulink> and <ulink url="http://seul.org/docs/autotut/">here</ulink> are two other tutorials about <application>Autotools</application>.
cs: <ulink url="http://www.lrde.epita.fr/~adl/autotools.html">Zde</ulink> a <ulink url="http://seul.org/docs/autotut/">zde</ulink> jsou dva základní výukové materiály k <application>Autotools</application>.

note: (itstool) path: varlistentry/term
en: French
cs: V češtině

note: (itstool) path: listitem/para
en: <ulink type="http" url="http://www.infres.enst.fr/~dax/polys/configure/slide1.html"> Here</ulink> are some slides by a teacher from Ecole Nationale Supérieure des Télecoms about the <application>Autotools</application>.
cs: Na server ROOT vyšel <ulink type="http" url="https://www.root.cz/serialy/gnu-pomoc-pri-tvorbe-programu/">seriál o nástrojích GNU</ulink> s kapitolami <ulink type="http" url="https://www.root.cz/clanky/gnu-pomoc-pri-tvorbe-programu-autoconf/">Autoconf</ulink> a <ulink type="http" url="https://www.root.cz/clanky/gnu-pomoc-pri-tvorbe-programu-automake/">Automake</ulink>.

note: (itstool) path: varlistentry/term
en: Japanese
cs: Ve slovenštině

note: (itstool) path: listitem/para
en: <ulink type="http" url="http://larse-gtk.hp.infoseek.co.jp/automake.html"> A tutorial about <application>Autoconf</application> and <application>Automake</application> </ulink>.
cs: <ulink type="http" url="https://smnd.sk/anino/programming/tools/automake/automake.html">Zde</ulink> je jeden kratší článek o <application>Automake</application>.

note: (itstool) path: tip/para
en: This tutorial uses <application>Autoconf 2.61 (November 2006)</application> and <application>Automake 1.10.1 (January 2008)</application>. Some of these documentations uses older versions. the syntaxes could have changed quite a bit. These old syntaxes usually still work and are used in old project. It is useful to know them but it is a bad idea to use them in a new project.
cs: Tento výukový materiál používá <application>Autoconf 2.61 (z listopadu 2006)</application> a <application>Automake 1.10.1 (leden 2008)</application>. Některé z těchto dokumentů používají starší verze a syntax se mohla trochu změnit. Starší syntax obvykle stále funguje a používá se ve starších projektech. Je dobré ji znát, ale není dobrý nápad ji používat v nových projektech.
