> For the complete documentation index, see [llms.txt](https://overleaf-pro.ayaka.space/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://overleaf-pro.ayaka.space/latex/cs/clanky-do-hloubky/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Jak funguje \expandafter: Od základních principů k prozkoumání zdrojového kódu TeXu [Část 1](/latex/cs/clanky-do-hloubky/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Část 2](/latex/cs/clanky-do-hloubky/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Část 3](/latex/cs/clanky-do-hloubky/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Část 4](/latex/cs/clanky-do-hloubky/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Část 5](/latex/cs/clanky-do-hloubky/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Část 6](/latex/cs/clanky-do-hloubky/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Úvod Nyní jsme probrali základní témata nezbytná pro úplné prozkoumání `\expandafter`: * základů tokenů TeXu a toho, jak se vypočítávají; * principů stojících za expanzním procesem TeXu; * použití/vytváření dočasných seznamů tokenů během zpracování dokumentu TeXem; * jak TeX používá a „žongluje“ s více vstupními zdroji (včetně dočasných seznamů tokenů). V tomto článku tato témata/pojmy spojíme, abychom vysvětlili mechanismy, na nichž stojí TeXův `\expandafter` příkaz: stručně řečeno, jak funguje. ## A tak, k \expandafter Myšlenka za `\expandafter` je vynutit expanzi příkazu (tokenu) dříve, než by to TeX normálně udělal. Máme-li dva tokeny, $$\mathrm{T\_1}$$ a $$\mathrm{T\_2}$$ účinek `\expandafter` $$\mathrm{T\_1T\_2}$$ způsobí, že TeX zpracuje $$\mathrm{T\_1}\text{<}$$expanzi $$\mathrm{T\_2}\text{>}$$, kde $$\text{<}\dots\text{>}$$ označuje seznam tokenů. TeX expanduje $$\mathrm{T\_2}$$ předem, takže token $$\mathrm{T\_1}$$ (např. primitiva nebo makra) uvidí nebo může jednat s tokeny vzniklými expanzí $$\mathrm{T\_2}$$. Pokud token $$\mathrm{T\_2}$$ představuje neexpandovatelnou položku, jako je neaktivní znak nebo (většina) primitiv, účinek `\expandafter` nic nemění: TeX by pokračoval ve zpracování tokenů $$\mathrm{T\_1T\_2}$$ obvyklým způsobem. ### Úvod do používání \expandafter Pokud jste ještě nepoužívali `\expandafter`, zde je příklad jeho použití s primitivem `\uppercase{...}`. Předpokládejme, že chceme vysázet název našeho hlavního `.tex` vstupního souboru, ale velkými písmeny. Mohli bychom znát následující primitivní příkazy TeXu: * `\uppercase`: převádí, jak jeho název napovídá, znakové tokeny na jejich ekvivalent velkými písmeny (kde existuje); * `\jobname`: jak jsme viděli, expanduje na název hlavního `.tex` souboru. Předpokládejme, že náš TeX soubor se jmenuje `mycode.tex` mohli bychom rozumně očekávat `\uppercase{\jobname}` že vysází `MYCODE`. Ale ne, vysází `mycode` malými písmeny. Co se „pokazilo“? Pokud obecné použití `\uppercase` zapíšeme jako ``` \uppercase{} ``` můžeme říci, že `\uppercase` prochází `` a bude působit (měnit velikost písmen) pouze na *znakové tokeny* které v něm detekuje ``: všechny neznakové tokeny jsou *ignorovány* protože `\uppercase` nebude „nahlížet do“ (expandovat) neznakové tokeny, aby zjistil, co obsahují nebo představují. Protože token je jednoduše celočíselná hodnota, vše, `\uppercase` co musí udělat, je projít seznam tokenů a zkontrolovat, zda číselná hodnota každého tokenu v `` spadá do rozsahu hodnot označujících znakový token. Mimochodem, `\uppercase` také *změní velikost písmen aktivních znaků* a vytvoří aktivní znak velkými písmeny, který musí být, protože je stále aktivní, také definován; jinak TeX vyvolá chybu: `Undefined control sequence`, ale odbočujeme... Například i kdybychom definovali makro, které je jen text ``` \def\foo{some lower-case text} ``` pak `\uppercase{\foo}` stále vysází `some lower-case text` a ne `SOME LOWER-CASE TEXT` jak bychom doufali, jednoduše proto, že působení `\uppercase` se nesnaží zjistit, co `\foo` představuje: vidí `\foo` jako token příkazu a ignoruje jej, stejně jako u `\jobname`. ### Jak to můžeme opravit? \expandafter na pomoc Abychom vysázeli verzi názvu souboru velkými písmeny, musíme upravit `\uppercase{\jobname}` tak, že přinutíme TeX nahradit `\jobname` jeho expanzí (sledem znakových tokenů) *dříve, než* `\uppercase` začne pracovat. Znovu se expanze používá k odstranění `\jobname` tokenu (příkazu) a jeho nahrazení výsledkem jeho expanze (seznamem tokenů obsahujícím znakové tokeny). Takže pokud napíšeme ``` \uppercase\expandafter{\jobname} ``` pak to funguje: `MYCODE` by se vysázel. To, co se děje, je, že TeX začne zpracovávat `\uppercase` a okamžitě kontroluje povinný znak otevírací závorky (`{`); nicméně TeX detekuje `\expandafter` příkaz, který způsobí, že dočasně „odvede svou pozornost“ ke zpracování `\expandafter{\jobname}`. Když porovnáme `\expandafter` $$\mathrm{T\_1T\_2}$$ s naším příkladem `\expandafter{\jobname}` můžeme vidět * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\jobname`token Kde `{`token a `\jobname`token odkazují na hodnoty tokenů vypočítané TeXem — zápis s dolním indexem token se používá, aby nám připomněl, že TeX pracuje ve světě celočíselných tokenů. Zápis `\uppercase\expandafter{\jobname}` funguje, protože zhruba řečeno (podrobnosti následují), `\expandafter` způsobí, že TeX provede následující úkoly: 1. přečte a uloží otevírací `{`token; 2. přečte další token: `\jobname`token. TeX rozpozná, že `\jobname`token představuje expandovatelný příkaz a expanduje jej. `\jobname`token je nahrazen jeho expanzí — řadou znakových tokenů; 3. po expanzi `\jobname` příkazu TeX vloží `{`$$\_\mathrm{token}$$ „zpět do vstupu“ a použije seznam tokenů vzniklý expanzí `\jobname` tak, aby TeX četl `\uppercase{`token``seznam tokenů (znaky)`}`, a to přinese náš požadovaný výsledek. Následující diagram ukazuje, jak TeX zpracovává `\uppercase\expandafter{\jobname}`— grafiku čtěte zdola nahoru, abyste sledovali průběh procesu. ![Jak \expandafter funguje](/files/979f477a02615c8e78995805739793f0e7551db8) Následující poznámky vysvětlují jednotlivé fáze zpracování. 1. TeX začne zpracovávat `\uppercase` a kontroluje povinný znak otevírací složené závorky (`{`) ale detekuje `\expandafter` příkaz. 2. Když porovnáme `\expandafter` $$\mathrm{T\_1T\_2}$$ v našem vstupu `\expandafter{\jobname}` můžeme vidět $$\mathrm{T\_1} =$$`{`token a $$\mathrm{T\_2} =$$`\jobname`token. Všimněte si, že zde použijeme dolní index token pro označení, že TeX zpracovává celočíselné hodnoty tokenů. 3. `\expandafter` přečte a pak dočasně uloží `{`token tím, že tuto celočíselnou hodnotu tokenu uloží do interní proměnné. Později TeX tento token znovu vloží do vstupu, po zpracování `\jobname` příkaz. 4. `\expandafter` přečte další token, `\jobname`token, a expanduje `\jobname` příkaz. 5. Expanze `\jobname` vytvoří dočasný seznam tokenů, který obsahuje sekvenci znakových tokenů reprezentujících `.tex` název souboru. Všimněte si, že všechny znakové tokeny generované `\jobname` jsou vypočteny s kategoriovým kódem 12. 6. Jakmile `\jobname` je expandováno, TeX znovu vloží token uložený v kroku 3 (`{`token) a vrátí jej zpět do vstupu. TeX to dělá tak, že vytvoří další seznam tokenů obsahující *jeden* `{`token 7. TeX nyní dokončil zpracování `\expandafter`, takže vzniknou dva seznamy tokenů připravené k použití jako zdroje vstupu TeXu. TeX se nyní vrací ke zpracování `\uppercase` ale nastavil svůj vstup tak, že dva seznamy tokenů vytvořené pomocí `\expandafter` se stanou zdrojem tokenů pro `\uppercase`— které nyní vidí `\uppercase{`token``seznam tokenů (znaky)`}`. `\uppercase` nyní vidí sekvenci znakových tokenů a může vytvořit náš požadovaný výsledek. 8. Po přečtení všech znakových tokenů vytvořených pomocí `\jobname`se TeX vrátí k získávání tokenů z předchozího zdroje vstupu (našeho `.tex` souboru), odkud přečte další token: uzavírací `}` potřebnou k ukončení seznamu tokenů, které má zpracovat `\uppercase`. ### \expandafter a vnitřní seznamy tokenů Dočasné seznamy tokenů jsou *zásadním* prvkem `\expandafter`zpracovacího chování: pochopení použití a existence těchto seznamů tokenů může pomoci objasnit, jak `\expandafter` dosahuje svých výsledků, zejména při snaze psát nebo chápat makra, která používají více po sobě jdoucích `\expandafter` příkazů k dosažení složitějších forem zpracování tokenů: `\expandafter\expandafter\expandafter...` Dalším klíčovým prvkem `\expandafter`chování, zejména při více po sobě jdoucích `\expandafter` příkazech, je použití *rekurze* (přímo v softwaru TeX) — téma, kterému se budeme věnovat později v tomto článku. Abychom lépe porozuměli dočasným seznamům tokenů, podíváme se na ještě jeden příklad `\expandafter`, tentokrát s `\the` příkaz. #### \expandafter a vnitřní seznamy tokenů: příklad 2 V tomto příkladu uvidíme, jak `\expandafter` lze použít k ovlivnění tokenů uložených v tokenovém registru prostřednictvím `\toks` příkazu. Zde jsou primitiva TeXu, která budeme používat: * `**\count** *register*=*number*`: primitivum TeXu používané k uložení hodnoty `*number*` na místě TeXu `*register*`; * `**\toks** *register*={*token list*}`: primitivum TeXu používané k uložení `*token list*` do umístění tokenového registru `*register*`— ukládá sekvenci tokenů pro pozdější použití; * `**\the** *token*`: expandovatelný primitivní příkaz TeXu, který zpracovává `*token*`, ačkoli přesné výsledky závisí na povaze `*token*` zpracovávaného tokenu. `\the` má řadu použití: mimo jiné vysázení hodnoty uložené v parametru nebo proměnné TeXu (např. registru). Další použití `\the` zahrnuje vložení kopie tokenů uložených v tokenovém registru. Zde použijeme `\the` k vysázení hodnoty uložené v `\count` registru. Začneme následujícím kódem TeXu, který uloží hodnotu `12345` v TeXově `\count` registru `99`: ``` \count99=12345 ``` Pokud chceme vysázet hodnotu uloženou v `\count99` můžeme použít `\the\count99` (nebo `\number\count99`). Dále použijeme `\toks` příkaz k uložení některých tokenů do tokenového registru `99`: ``` \toks99={\the\count99 } ``` Seznam tokenů uložených v tokenovém registru `99` by obsahoval následující: | | | | ----------------------- | ----------------------------------------------------------------------------------------------------------- | | **Hodnota tokenu TeXu** | **Reprezentovaná položka** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (znakový kód 57 s kategoriovým kódem 12), což vede k hodnotě tokenu $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (znakový kód 57 s kategoriovým kódem 12), což vede k hodnotě tokenu $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (znakový kód 32 s kategoriovým kódem 10), což vede k hodnotě tokenu $$256 \times 10 + 32 = 2592$$ | Všimněte si, že seznam tokenů vytvořený pomocí `\toks99` ne *ne* obsahuje skutečnou datovou hodnotu uloženou v `\count99` protože `\toks` příkaz neprovádí expanzi: jednoduše vytváří tokeny a ukládá je. V našem příkladu `\the` není expandováno, takže nezpracovává `\count99`; zde `\the` je pouze převedeno na token (hodnota 5382) a uloženo do seznamu tokenů. Pokud chceme, aby `\toks99` seznam tokenů obsahoval tokeny reprezentující data uložená v `\count99` budeme potřebovat nějaký způsob, jak tyto tokeny vytvořit (zpřístupnit je), aby `\toks` příkaz k nim měl přístup. A samozřejmě `\expandafter` to za nás může udělat. Pokud napíšeme: ``` \toks99=\expandafter{\the\count99 } ``` akce/zpracování `\toks` příkazu bude „pozastaveno“, zatímco `\expandafter` způsobí (vynutí) expanzi `\the` která zase působí na `\count` a vytvoří dočasný seznam tokenů obsahující znakové tokeny reprezentující data uložená v `\count99`. Malý, ale důležitý detail je `` znak za číslicemi `99`: ten `` znak ukončuje TeXovo skenování, když hledá číselnou hodnotu. Zde je účinek `\expandafter` velmi podobný `\jobname` příkladu. 1. Přečtěte a uložte otevírací `{`token. 2. Přečtěte další token, `\the`token, který představuje expandovatelný příkaz, takže TeX jej expanduje. `\expandafter` vynutí expanzi `\the` která pak působí na `\count99` a převede data uložená v `\count` registru `99` (číslo 12345) na dočasný seznam tokenů. Ten seznam bude obsahovat znakové tokeny reprezentující číslice `1`, `2`, `3`, `4` a `5`— znakové tokeny s kategoriovým kódem 12. 3. Po expanzi a zpracování `\the`, TeX vloží `{`token „zpět do vstupu“ a použije seznam tokenů vzniklý z `\the\count99` tak, aby TeX četl `\toks99={`token``seznam tokenů (znaky)`}` a to přinese náš požadovaný výsledek. Tato posloupnost událostí je shrnuta v následujícím diagramu — grafiku čtěte zdola nahoru, abyste sledovali tok procesu. ![Jak \expandafter funguje](/files/bbe902546af9bcf3425b1a0fffac5636c1e5c9ab) 1. TeX začne zpracovávat `\toks`; vidí volitelný `=` znak, a pak kontroluje povinný znak otevírací složené závorky (`{`, nebo jakýkoli znak s kategoriovým kódem 1) používaný k označení začátku seznamu tokenů. Nicméně TeX detekuje `\expandafter` příkaz a pokračuje v jeho vykonání místo toho. 2. Když porovnáme `\expandafter` $$\mathrm{T\_1T\_2}$$ v našem vstupu `\expandafter{\the\count99 }` můžeme vidět $$\mathrm{T\_1} =$$ `{`token a $$\mathrm{T\_2} =$$ `\thetoken`. 3. `\expandafter` přečte a pak dočasně uloží `{`token (TeX tuto celočíselnou hodnotu tokenu dočasně uloží do interní proměnné). Později TeX tento token znovu vloží do vstupu po zpracování `\the` 4. `\expandafter` přečte další token, `\the`token a expanduje jej. 5. Expanze `\the` vytvoří dočasný seznam tokenů ze zpracování `\count99`— tento seznam tokenů obsahuje sekvenci znakových tokenů, které představují datovou hodnotu uloženou v `\count` registru `99`. 6. Jakmile `\the` je expandováno, TeX znovu vloží token uložený v kroku 3 (`{`token) a vrátí tento token zpět do vstupu. TeX to dělá vytvořením dalšího seznamu tokenů obsahujícího *jeden* token `{`token. 7. TeX nyní dokončil zpracování `\expandafter` a vytvořil dva seznamy tokenů připravené k použití jako další zdroje vstupu. TeX se vrací ke zpracování `\toks99=` ale nyní TeX nakonfiguroval svůj vstup tak, že dva seznamy tokenů vytvořené pomocí `\expandafter` se stanou zdrojem tokenů pro `\toks`— které nyní vidí `{`token``seznam tokenů (znaky)`}`. `\toks` nyní může přistupovat k sekvenci 5 znakových tokenů, které reprezentují datovou hodnotu (`12345`) uloženou v `\count99`: náš požadovaný výsledek. 8. Po přečtení všech znakových tokenů vytvořených pomocí `\the\count99`se TeX vrátí k získávání tokenů z předchozího zdroje vstupu (našeho `.tex` souboru), odkud přečte další token: uzavírací `}` potřebnou k ukončení seznamu tokenů, které mají být uloženy pomocí `\toks99={...}`. ## Jak \expandafter skutečně funguje V této části se podíváme „nízkoně“ dovnitř samotného TeXu: prozkoumáme zdrojový kód/funkce v TeXu, které implementují chování `\expandafter`. Podrobnosti jsou vyjádřeny v pseudokódu C, ale měly by být srozumitelné každému, kdo zná jiné programovací jazyky. Následující anotovaný diagram vysvětluje, jak TeX implementuje `\expandafter` jako součást větší funkce nazvané `expand()`— hlavní funkce, která řídí expanzní zpracování TeXu. V části odpovědné za implementaci `\expandafter` můžeme vidět [*rekurzivního* chování](https://en.wikipedia.org/wiki/Recursion) kde se další volání `expand()` funkce používá ke zpracování druhého načteného tokenu, $$\mathrm{T\_2}$$, pro případy, kdy $$\mathrm{T\_2}$$ je expandovatelný. Ačkoli se tento kód objevuje v Knuthově TeX enginu, základní principy popsané tímto diagramem platí pro všechny TeX enginy. ![Jak \expandafter funguje uvnitř TeXu](/files/bc1b74a2cec02a0f6cc6320e51097c9be9d503cc) Prvním úkolem `expand()` je určit, zda je příkaz, který má být expandován, makro nebo primitivum, protože makra mají specializovaný proces expanze, který zpracovává funkce nazvaná `macrocall()`. Pokud je příkaz, který má být expandován, primitivum, pak `expand()` funkce použije aktuální hodnotu kódu příkazu (uloženou v globální proměnné `curcmd`) k určení, které konkrétní primitivum je třeba zpracovat. Tyto detaily můžeme vidět v úplnějším výpisu `expand()`: ``` void expand(void) { //curcmd is a global variable if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Zpracujte příkaz \expandafter T1T2 { gettoken(); // Přečte token T1 t = curtok; // Uložte token T1 do lokální proměnné t gettoken(); // Přečte token T2 if(curcmd > 100) // Je token T2 rozšiřitelný? expand(); // Ano! T2 je rozšiřitelný: // proveďte rozšíření T2 pomocí // rekurzivního volání funkce expand() else backinput(); // T2 není rozšiřitelný: vraťte tento token // zpět do vstupu, aby mohl být znovu přečten (později) curtok = t ; // Obnovte globální proměnnou curtok na uloženou hodnotu T1 backinput() ; // Vraťte token T1 zpět do vstupu // před tokeny vzniklými rozšířením T2 } break; // Kód pro zpracování dalších rozšiřitelných příkazů case „příkaz pro převod na text“: // Kterýkoli z \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Sdílejí stejnou hodnotu curcmd break; case \noexpand: // Potlačte rozšíření následujícího tokenu ... break; case \csname: //Vytvořte název řídicí sekvence. ... break; case \the: // Vložte některé tokeny .... break; case „\if... testovací příkaz“ : // Zpracujte jednu z TeXových podmínek: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case „\fi nebo \else“: // Ukončete aktuální podmínku ... break; // atd. pro jakékoli jiné rozšiřitelné primitivní příkazy podporované // jádrem TeXu } }else // Není to rozšiřitelný primitivní příkaz: je to makro { macrocall() } //... další kód odstraněn } ``` ### Láska TeXu ke globálním proměnným Možná v odrazu jeho stáří a doby, ve které byl navržen, zdrojový kód TeXu rozsáhle využívá tzv. [globální proměnné](https://en.wikipedia.org/wiki/Global_variable)—ve skutečnosti jich jsou stovky. Globální proměnné lze ze své podstaty měnit/upravovat odkudkoli ve zdrojovém kódu TeXu — a ten je u Knuthova TeXu jediným monolitickým souborem obsahujícím přes 25 000 řádků kódu a stovky funkcí. Pochopit, jak TeX funguje, není vždy snadný úkol... Ke zpracování `\expandafter`, TeX čte tokeny ze svého aktuálního vstupu pomocí funkce nazvané `gettoken()` jejímž úkolem je vytvořit token a nastavit hodnotu několika klíčových globálních proměnných používaných napříč zdrojovým kódem TeXu. Dvě takové proměnné, které jsou aktualizovány činností `gettoken()`, se používají v implementaci `\expandafter`: * `curtok`: (aktuální token) celočíselná hodnota právě přečteného tokenu; * `curcmd`: (aktuální kód příkazu) kód příkazu (nebo znaku) reprezentovaného tokenem `curtok`. Při zpracování `\expandafter`$$\mathrm{T\_1T\_2}$$ TeX čte token $$\mathrm{T\_1}$$ a jeho hodnotu (celé číslo) dočasně ukládá do lokální proměnné nazvané `t`. TeX poté čte $$\mathrm{T\_2}$$ a zkontroluje, zda tento token představuje rozšiřitelný příkaz — tím, že ověří, zda jeho kód příkazu (`curcmd`) je > 100. Pokud ano, TeX musí rozšířit příkaz reprezentovaný $$\mathrm{T\_2}$$ a znovu zavolá funkci `expand()`: to je příklad *rekurze* protože `expand()` funkce, která volá sama sebe. Povědomí o rekurzivní povaze rozšiřování, zejména při používání `\expandafter`, může pomoci pochopit, jak několik po sobě jdoucích `\expandafter` příkazů — tj., `\expandafter\expandafter\expandafter...` dosahuje svých účinků. Pokud je token $$\mathrm{T\_2}$$ rozšiřitelný, provede se rozšíření a když se rekurzivní volání `expand()` vrátí, kód uvnitř implementace `\expandafter` znovu vloží token $$\mathrm{T\_1}$$ zpět do vstupu. Globální proměnná `curtok` je znovu přiřazena na hodnotu uloženého tokenu — uloženou v lokální proměnné `t`, což je hodnota tokenu $$\mathrm{T\_1}$$—a zavolá se funkce `backinput().` #### Funkce backinput() Jak název napovídá, tato funkce vrací token „zpět do vstupu“. K tomu TeX používá aktuální hodnotu globální proměnné `curtok` k vytvoření seznamu tokenů, který obsahuje jediný token (jehož celočíselnou hodnotu poskytuje `curtok`). TeX také zařídí své zpracování vstupu tak, aby byl tento seznam s jediným tokenem ve vhodný okamžik znovu přečten TeXem jako součást následného zpracování vstupu. Všimněte si pečlivě, že token $$\mathrm{T\_1}$$ je znovu vložen *poté, co je rozšíření dokončeno*, což zajistí, že TeX tento znovu vložený token přečte *dříve, než* až bude číst tokeny vzniklé rozšířením $$\mathrm{T\_2}$$. ### Zpracování maker: funkce macrocall() Jak již bylo řečeno, všechna makra spolu s některými primitivními příkazy jsou rozšiřitelná a veškeré zpracování rozšiřování prochází `expand()` funkcí. Nicméně `expand()` pečlivě používá `curcmd` (aktuální příkaz) hodnotu k rozlišení mezi rozšiřitelnými primitivy a makry, protože proces rozšiřování maker zajišťuje vyhrazená funkce nazvaná `macrocall()`. Makra potřebují specializovaný proces rozšiřování, protože argumenty maker i oddělovačové tokeny se musí vyhledávat velmi specifickým a důsledným způsobem; tento proces je tedy předán funkci určené právě k tomu: `macrocall()`. #### Rozšiřování maker vs. vykonávání maker Makro *rozšiřování* není tentýž proces jako *vykonávání*: rozšiřování makra je předexekuční proces, který TeX provádí, aby makro *připravil k vykonání*. „Vykonání“ makra nastává, když TeX aktivně čte a zpracovává tokeny obsažené v definici (náhradním textu) daného makra a v jeho argumentech (parametrech). #### Rozšiřování makra Aby TeX rozšířil makro, nejprve zkontroluje, zda makro přijímá argumenty; pokud ano, `macrocall()` velmi pečlivě prohledává vstup a hledá tokeny určené k tomu, aby se staly argumenty makra. Tento proces zahrnuje kontrolu uživatelského vstupu na jakékoli oddělovačové tokeny použité v původní definici makra — vzor tokenů použitý při volání makra musí přesně odpovídat vzoru tokenů obsaženému v uložené definici. Tokeny použité jako oddělovače však TeX jednoduše zahazuje: jsou ve skutečnosti jen formou „interpunkce“, kterou TeX používá k určení skutečných tokenů určených jako argumenty makra — tj. tokenů, které uživatel zamýšlí, aby byly makrem zpracovány. Další informace o oddělovačových tokenech viz [Jak makra TeXu skutečně fungují](/latex/cs/dalsi-temata/22-how-tex-macros-actually-work-part-4.md). Pro každý parametr (`#1, #2...#9`) přítomný v původní definici makra TeX prohledá skutečné volání makra, aby určil, které tokeny poskytnuté uživatelem náleží ke kterému parametru (tj. tvoří argumenty makra). Tento proces vytvoří jeden nebo více malých seznamů tokenů: jeden pro každý argument makra. Poté, co jsou jakékoli argumenty makra rozpoznány a jejich seznamy tokenů připraveny, TeX načte definici makra (náhradní text) uloženou v paměti a uspořádá zpracování vstupu tak, že kdykoli je TeX připraven číst/zpracovávat další tokeny, bude je číst z náhradního textu makra, čímž makro vykoná. V příslušném okamžiku během vykonávání makra budou seznamy tokenů představující argumenty makra vloženy na správné místo v náhradním textu makra. Znovu platí, že rozšíření příkazu makra znamená *odstranění* tohoto příkazu makra (tokenu) ze vstupu a *nahrazení* jej tokenovým seznamem uloženým jako náhradní text makra. Podrobný pohled na zpracování maker v TeXu najdete v šestidílné sérii článků [Jak makra TeXu skutečně fungují?](/latex/cs/dalsi-temata/01-a-six-part-series-how-do-tex-macros-actually-work.md) [Část 1](/latex/cs/clanky-do-hloubky/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Část 2](/latex/cs/clanky-do-hloubky/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Část 3](/latex/cs/clanky-do-hloubky/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Část 4](/latex/cs/clanky-do-hloubky/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Část 5](/latex/cs/clanky-do-hloubky/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Část 6](/latex/cs/clanky-do-hloubky/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://overleaf-pro.ayaka.space/latex/cs/clanky-do-hloubky/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.