> 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/53-what-is-a-tex-token.md).
# Co je „TeXový token“?
## Motivace pro sérii o tokenech TeXu a souvisejících pojmech
V tomto článku je rozebrána motivace i použitá metodika pro vytvoření série článků o tokenech TeXu a souvisejících pojmech [Nová série článků: tokeny TeXu a související pojmy — ale proč (a jak)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Jak bylo v onom článku uvedeno, opíráme se v celé této sérii o poznatky získané díky vlastní sestavené verzi Knuthova původního programu TeX — používáme ji k vytvoření série článků, která si klade za cíl poskytovat jednoduché popisy a snadno sledovatelná vysvětlení klíčových pojmů TeXu.
## Úvod: jaký je náš cíl?
V tomto článku přesně zjistíme, co je token TeXu, tím že sledujeme cestu zpracování od znaků ve vstupním souboru až po samotné vytvoření tokenů TeXu. V praxi je to poměrně složité, proto jsme proces zredukovali na jeho jádro a snažíme se, aby byl snadno sledovatelný a srozumitelný, přičemž zachováváme technickou přesnost.
Začneme představením několika důležitých vnitřních pojmů TeXu: *primitivy*, *kódy příkazů* a *modifikátory příkazů*. Odtud použijeme velmi jednoduchý příklad makra, abychom přesně viděli, jak TeX zpracovává příkaz `\def` a výsledný token, který TeX vytvoří, aby tento příkaz reprezentoval.
Na závěr se krátce podíváme na to, jak TeX vytváří tokeny reprezentující znaky a jak se hodnota znaku `\catcode` skutečně stane trvale přiřazenou znakové tokenu — něco, co je v knihách o TeXu často zmiňováno, ale zde přesně uvidíme, jak toho je dosaženo.
Následující grafika ukazuje cestu, kterou shrneme — od vstupního textu k tokenům TeXu:
## Nejprve ale: primitiva a kódy příkazů
Každý engine TeXu (Knuthův TeX, pdfTeX, XeTeX, LuaTeX) rozumí řadě vestavěných příkazů: takzvaným *primitivy*—základním stavebním příkazům, na nichž stojí programovatelnost TeXu. Říká se jim „primitiva“, protože na rozdíl od uživatelsky definovaných maker nejsou složena z jiných příkazů a nelze je dále rozložit na jednodušší instrukce. V Knuthově TeXu je přibližně 320 primitiv — je však třeba poznamenat, že jiné enginy TeXu, jako jsou pdfTeX, XeTeX a LuaTeX, do původního Knuthova programu přidaly nové příkazy a obsahují primitiva, která v Knuthově softwaru TeX nejsou.
Interně TeX přiřazuje číselný *kód příkazu* všem příkazům — ať už jde o uživatelsky definovaná makra nebo vestavěná primitiva. Tyto kódy příkazů nejsou pro uživatele TeXu dostupné; jsou jednoduše součástí vnitřního mechanismu zpracování TeXu, ale je užitečné o nich vědět pro pozdější diskusi o tokenech TeXu.
Skupiny příkazů se související funkcionalitou sdílejí stejný kód příkazu. Například `\def`, `\gdef`, `\edef` a `\xdef` všechna primitiva slouží k definování maker a sdílejí kód příkazu 97 (v Knuthově TeXu). Je zřejmé, že ta čtyři příkazová primitiva pro definici maker vytvářejí makra poněkud odlišným způsobem; TeX proto během zpracování potřebuje způsob, jak je od sebe odlišit.
Sám o sobě kód příkazu (například 97) neřekne, který příkaz pro vytváření maker je právě zvažován; jak se dalo čekat, každému příkazu TeXu je proto přiřazena další informace nazývaná jeho *modifikátor příkazu* (viz níže uvedené příklady).
### Modifikátory příkazů: dva typy
Modifikátory příkazů spadají do dvou kategorií, které zde budeme nazývat „typ 1“ a „typ 2“ — TeX tuto terminologii nepoužívá, je to tu jen pohodlné:
* **Typ 1**: Jednoduché celočíselné hodnoty, které TeX může v případě potřeby použít k odlišení příkazů sdílejících stejný kód příkazu.
* **Typ 2**: Celočíselná hodnota, která je číselným umístěním v paměti TeXu a říká TeXu, kam má jít, aby vyhledal informace pro daný příkaz. To například platí pro uživatelsky definované příkazy (makra), kde modifikátor příkazu TeXu říká, kde je v paměti uložena definice makra.
#### Modifikátory příkazů typu 1 (příklad)
Jak již bylo uvedeno, v Knuthově TeXu mají čtyři primitivní příkazy pro definici maker: `\def`, `\gdef`, `\edef`, `\xdef` všechny mají kód příkazu 97; odlišují se svými modifikátory příkazů, které jsou uvedeny v následující tabulce:
| Příkaz | Kód
příkazu
| Modifikátor
příkazu
|
| ------- | --------------------- | ----------------------------- |
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
Jako druhý příklad se Knuth rozhodl implementovat příkazy `\openout`, `\write`, `\closeout`, `\special`, `\immediate` a `\setlanguage` jako „rozšíření“ TeXu, čistě proto, aby ukázal, jak lze do TeXu přidávat nová primitiva. V tomto případě tyto příkazy ve skutečnosti nesdílejí „podobnou funkcionalitu“, kromě toho, že se Knuth rozhodl je seskupit pro účely vysvětlení rozšiřování TeXu. Těchto 6 příkazů je klasifikováno jako „rozšíření“ a seskupeno s hodnotou kódu příkazu 59, ale každý z nich má příslušný modifikátor příkazu, který jej odlišuje od ostatních:
| Příkaz | Kód
příkazu
| Modifikátor
příkazu
|
| -------------- | --------------------- | ----------------------------- |
| `\openout` | 59 | 0 |
| `\write` | 59 | 1 |
| `\closeout` | 59 | 2 |
| `\special` | 59 | 3 |
| `\immediate` | 59 | 4 |
| `\setlanguage` | 59 | 5 |
#### Modifikátory příkazů typu 2 (stručné vysvětlení)
Ačkoli všechny modifikátory příkazů jsou celá čísla, modifikátory typu 2 vyžadují trochu více vysvětlení. V TeXu se na tyto modifikátory odkazuje jako na „ukazatele“, protože ukazují na místo v paměti, kde může TeX najít další informace pro daný příkaz. To může znít poněkud vágně, ale způsob, jakým TeX tyto ukazatele používá k vyhledávání informací, je dost rozmanitý a podrobnější vysvětlení by odvádělo pozornost od hlavního cíle tohoto článku. Jeden příklad může pomoci: makra. Když je definován příkaz makra, TeX bude muset někde v paměti uložit náhradní text. Jak uvidíme níže, uživatelsky definovaná makra mají kódy příkazů mezi 111 a 114 a jejich modifikátor příkazu je ukazatel do paměti, který TeXu říká, kde je uložen jejich náhradní text (definice makra).
### Kódy příkazů: rozšiřitelné a nerozšiřitelné
V Knuthově zdrojovém kódu TeXu se kódy příkazů pohybují od 0 do 120 — je třeba poznamenat, že některé kódy v tomto rozsahu jsou určeny čistě pro specializované interní použití a nejsou přiřazeny příkazům přístupným uživateli. Stojí za zmínku, že jiné enginy TeXu, jako jsou pdfTeX, XeTeX a LuaTeX, do původní Knuthovy sady přidaly nové příkazy a budou obsahovat více primitivit i odpovídajících kódů příkazů; zde uvedené principy jsou však jádrem všech enginů založených na TeXu, odvozených ze zdrojového kódu Knutha.
Soubor kódů příkazů je rozdělen do dvou hlavních sad:
* *nerozšiřitelné příkazy*: mají kódy příkazů menší nebo rovny 100;
* *rozšiřitelné příkazy*: mají kódy příkazů větší než 100, až do maximální hodnoty 120. Rozsah 101 až 120 zahrnuje uživatelsky definovaná makra i příkazy jako `\csname`, `\expandafter` a `\the`.
Nerozšiřitelné příkazy obvykle provádějí přiřazení hodnoty vnitřnímu parametru nebo přímo vytvářejí materiál, který lze vysázet. Rozšiřitelné příkazy obvykle „vkládají“ tok tokenů do aktuální činnosti zpracování TeXu nebo mění pořadí zpracování tokenů.
Jak bylo uvedeno výše, všechna makra (uživatelsky definované příkazy) dostávají kódy příkazů mezi 111 a 114: různé hodnoty odrážejí, zda bylo makro definováno jako `\long`, `\outer`, obojí, nebo ani jedno. Zde je příklad:
| Typ makra | Příklad | Komentář |
| ----------------------- | ------------------------------ | ------------------------- |
| Není dlouhé, není outer | `\def\ohyeah{....}` | `\ohyeah` kód příkazu=111 |
| Dlouhé, ne-outer | `\long\def\ohyeah{....}` | `\ohyeah` kód příkazu=112 |
| Není dlouhé, outer | `\outer\def\ohyeah{....}` | `\ohyeah` kód příkazu=113 |
| Dlouhé outer | `\long\outer\def\ohyeah{....}` | `\ohyeah` kód příkazu=114 |
Připomeňme si modifikátory příkazů: když je makro definováno, TeX uloží jeho definici na nějaké místo v paměti; toto místo (ukazatel) se stane modifikátorem příkazu pro příkaz makra, který bude uložen s kódem příkazu 111 až 114 podle toho, jak byl definován. Samotné jméno přiřazené uživatelsky definovanému makru vlastně není důležité: po zpracování vstupu jim bude všem přiřazen kód příkazu v rozsahu 111–114 a nakonec se všechny příkazy, které TeX čte z vašeho vstupu, ať už jde o primitiva nebo uživatelsky definovaná makra, nakonec převedou na číselnou reprezentaci nazývanou *token*.
## Cesta od vstupního textu k tokenům TeXu
V této části použijeme velmi jednoduchý příklad makra, abychom přesně viděli, jak TeX zpracovává příkaz `\def` a vytvořil token, který reprezentuje `\def` příkaz. Podrobná činnost zpracování v TeXu může být extrémně složitá, proto nepoužíváme parametry maker ani oddělovače, protože by to přidalo složitost a odvedlo pozornost od naší cesty.
Předpokládejme, že váš vstupní soubor TeXu obsahuje následující řádek:
```latex
\def\ohyeah{Overleaf is cool!}
```
Když TeX začne zpracovávat tento řádek vstupu, zkontroluje `\catcode` každého znaku a zjistí, že první znak je `\` (první znak `\def`). Zjistí (vyhledá to ve vnitřní tabulce), že `\` má `\catcode` 0, což znamená, že uvádí začátek *řídicí sekvence*. Samozřejmě můžete libovolný znak předefinovat tak, aby měl `\catcode` 0, ale budeme předpokládat, že se používají běžné definice plain TeXu nebo LaTeXu.
Přesně vzato má pojem *řídicí sekvence* dva podtypy: *řídicí slovo* a *řídicí symbol*:
* *řídicí slovo*: posloupnost znaků s `\catcode` písmenem (11);
* *řídicí symbol*: jediný znak, jehož `\catcode` je *ne* kód je „písmeno“ (11).
V této chvíli `\` znak splnil svou úlohu a tím pro něj vše končí. Po zjištění řídicího znaku TeX začne číst všechny následující znaky ve vstupu s cílem rozpoznat řídicí slovo nebo řídicí symbol.
Po úvodním `\`, TeX okamžitě rozpozná `d`: znak, jehož `\catcode` je 11, což TeXu říká, že našel první písmeno *řídicí slovo*. Pokračuje ve skenování následujících znaků, dokud nakonec nenajde znak, který *ne* uvádějí `\catcode` písmeno (11). Všechny následující znaky (po úvodním `\`) s `\catcode` 11 (písmeno) se považují za název řídicího slova: tj. název příkazu — možná makra nebo primitiva, ale TeX zatím netuší, o jaký typ příkazu jde. V tuto chvíli je to jednoduše řetězec znaků.
Takže v našem příkladu TeX spokojeně prochází text, kontroluje každý znak, dokud nedojde k úvodnímu `\` pro `\ohyeah` který má také `\catcode` 0. TeX rozpozná, že přečetl příliš daleko, a zdvořile vrátí ten `\` zpět do textového proudu, aby se stal dalším znakem, který bude při dalším procházení textu viděn. V této chvíli TeX identifikoval řetězec (`def`) o němž ví, že tvoří text řídicího slova skládajícího se ze tří znaků, z nichž každý má `\catcode` 11 (`d`, `e` a `f`). Co TeX nyní potřebuje udělat, je zjistit, co `def` znamená: co má udělat? Jak jste možná uhodli, TeX potřebuje najít kód příkazu a identifikátor příkazu pro `def` aby mohl určit, co má s tímto příkazem dělat.
## Vytvoření hash hodnoty
Poté, co TeX rozpozná řídicí slovo (`def`), první věc, kterou TeX udělá, je „převést“ řetězec znaků (`def` v našem příkladu) na celé číslo pomocí něčeho, co se nazývá hashovací funkce. Nemusíme se zabývat podrobnostmi, postačí nástin. V podstatě TeX vezme každý znak v řídicím slově, které právě rozpoznal, a použije hodnotu ASCII kódu (nebo hodnotu Unicode u XeTeX/LuaTeX) každého znaku k výpočtu čísla nazývaného hash hodnota: je to prosté celé číslo.
Jako součást tohoto procesu výpočtu hashe TeX také zkontroluje, zda mu řetězec znaků v nově rozpoznaném řídicím slově už není znám. Text všech příkazů čitelný pro člověka, ať už jde o primitiva nebo uživatelsky definovaná makra, je uložen ve vnitřní paměťové oblasti nazývané *zásobník řetězců*. TeX to musí dělat, protože možná bude potřebovat vypsat lidsky čitelný název příkazu — například když TeX potřebuje ohlásit chybu a uvést název problematického příkazu. Například naše makro `\def\ohyeah{Overleaf is cool!}` definuje nový příkaz nazvaný `\ohyeah` a TeX bude (v pozdější fázi) muset nejen vypočítat hash hodnotu pro `ohyeah` (*bez* úvodní `\` znak), ale také uložit textový řetězec (čitelný pro člověka) pro případ, že jej bude potřebovat pro hlášení chyb (nebo jiné úlohy).
Pokud chcete více podrobností o zpracování řetězců v TeXu, psal jsem o tom na svém [osobním blogu](http://www.readytext.co.uk/?p=3590).
Konečným výsledkem je, že řetězec znaků reprezentující příkaz `def` se převede na číselnou hodnotu 1218 (to je skutečná hodnota vypočtená TeXem). V této chvíli jednotlivé znaky `d`, `e` a `f` už nejsou součástí hlavního příběhu — byly přečteny ze vstupu a splnily svou úlohu: od této chvíle jde už jen o celá čísla a *tokeny*—brzy uvidíme, co token vlastně je! Interně TeX na tato čísla hash hodnot odkazuje jako na *aktuální řídicí sekvenci* ale ve zdrojovém kódu je tento termín zkrácen na proměnnou nazývanou `curcs`. Zdrojový kód TeXu je plný velmi krátkých, často poněkud záhadných názvů proměnných.
Ale co TeX *vlastně dělá* s touto čerstvě vytvořenou celočíselnou hodnotou 1218? Jak TeX zjistí, že původní řetězec `def`, nyní reprezentovaný celým číslem 1218, ve skutečnosti odkazuje na instrukci k definování makra? Odpověď je, že TeX má jakousi vnitřní „kartotéku“, kde ukládá aktuální význam a hodnotu každého příkazu, který právě zná — ať už jde o uživatelsky definované makro nebo vestavěné primitivum. Důvod, proč se TeX namáhal s převodem `def` na hash hodnotu 1218 (nyní uloženou v proměnné nazývané `curcs`) je ten, že ji použije pro vyhledání *významem* pro `def`. TeX bude samozřejmě tento výpočet hashe opakovat pro všechna řídicí slova, která ve vstupu rozpozná — samozřejmě různá řídicí slova dávají z hashovací funkce různé celočíselné hodnoty: o to právě jde.
TeXova vnitřní „kartotéka“ se nazývá *tabulka ekvivalentů* a je tématem následující části.
### Nahlédnutí do tabulky ekvivalentů
Pro shrnutí si připomeňme, co jsme se dosud naučili:
* `\` uvádí začátek řídicí sekvence (buď *řídicí symbol* nebo *řídicí slovo*).
* Pokud první znak po `\` má `\catcode` 11 (písmeno), pak je to začátek *řídicí slovo*.
* Pro *řídicích slov* TeX prochází vstup a kontroluje všechny následující znaky, které mají `\catcode` 11, a přestane skenovat, jakmile najde první znak, který nemá *ne* má `\catcode` hodnotu 11.
* Řetězec vstupních znaků (následujících po `\`), které mají `\catcode` 11, se považuje za *řídicí slovo* který uživatel napsal: příkaz žádající TeX, aby „něco udělal“.
* Aby TeX zahájil proces „něco dělat“, převede řetězec znaků v řídicím slově na celé číslo. Dělá to pomocí takzvané hashovací funkce, která vrací celé číslo.
* Toto celé číslo (vypočtená hash hodnota) se označuje jako *aktuální řídicí sekvenci*, ale TeX mu dává kratší název `curcs`.
* V našem příkladu se řídicí slovo `def` převede na hodnotu 1218 — ta je uložena v proměnné nazývané `curcs`: tj., `curcs=1218`.
TeX nyní potřebuje zjistit, co nově rozpoznané *aktuální řídicí sekvenci* doopravdy znamená — co s ním TeX udělá?
#### Poznámka ke seskupování: potřeba ukládat a obnovovat informace
Zde si uděláme malou odbočku, abychom si připomněli, že TeX má schopnost ukládat a obnovovat informace: tedy má jakousi vestavěnou „paměť“.
Každý, kdo napsal byť jen to nejjednodušší makro, by měl znát seskupovací mechanismus TeXu — například použitím `\def` k vytváření maker uvnitř skupiny. Pokud nepoužijete `\global` prefix `\def`u maker vytvořených uvnitř skupiny, hodnota nebo význam daného makra přetrvává pouze v této skupině (a jejích podskupinách): jeho definice se ztratí po ukončení skupiny. Například pokud definujete jednoduché makro uvnitř skupiny, takto:
```latex
{\def\foo{Hello}}
```
a pokusíte se použít `\foo` mimo skupinu
```latex
{\def\foo{Hello}}% \foo definováno uvnitř skupiny (poznámka: bez použití \global)
\foo %<--- již není definováno, nyní nedefinováno
```
pak dostaneme ten dobře známý chybový výpis: `Nedefinovaná řídicí sekvence`. `\foo` má význam pouze uvnitř skupiny (a jejích podskupin), ve které bylo definováno. Navíc když uvnitř skupiny předefinujete makro, nová hodnota se po skončení skupiny může ztratit a obnoví se předchozí význam (který existoval mimo skupinu).
```latex
\def\foo{Goodbye}
\foo\par% Vypíše Goodbye
{\def\foo{Hello}% Předefinováno uvnitř skupiny:
{Uvnitř skupiny druhé úrovně: \foo\par}}% Použito uvnitř skupiny druhé úrovně: \foo vypíše Hello
Mimo skupinu obnovena stará hodnota: \foo\par% Vypíše Goodbye
```
Účelem těchto jednoduchých příkladů je naznačit, že TeX má jakýsi „úložný mechanismus“ nebo „paměť“, která ukládá a obnovuje „význam“ příkazů — a samozřejmě má. Naznačili jsme to už v předchozí části: ten „úložný mechanismus“ neboli „kartotéka“ je velká vnitřní tabulka nazývaná *tabulka ekvivalentů*. Právě tam TeX ukládá aktuální význam nebo hodnoty všech příkazů, které právě zná — vestavěných primitiv i uživatelsky definovaných maker.
### Tabulka ekvivalentů: pomocí analogie
Abychom vysvětlili tabulku ekvivalentů, budeme postupovat pomocí analogie. Budeme dál používat představu kartotéky s tisíci malými zásuvkami, z nichž každá je označena jedinečným celým číslem. V této fázi zpracování TeX v podstatě říká:
„Dobře, mám tuhle celočíselnou hodnotu 1218, kterou jsem právě vypočítal a uložil do proměnné nazývané `curcs`. Teď potřebuji zjistit, co znamená: abych to udělal, půjdu se podívat do zásuvky číslo 1218 své kartotéky, abych zjistil, co je v ní napsáno.“
TeX použije 1218 k nalezení správné zásuvky a tam najde malý lístek, který obsahuje tři informace, jejichž názvy jsou ty, které se používají ve zdrojovém kódu TeXu:
* **`eq_level:`** úroveň seskupení, ve které byla tato položka definována (úroveň 1 = definováno globálně). Výsledky seskupování jsme viděli výše v praxi: právě zde, v tabulce ekvivalentů, je tato informace o úrovni seskupení uložena;
* **`eq_type:`** kód příkazu pro tuto položku;
* **`equiv:`** aktuální „hodnota“ této položky — může to být prosté celé číslo, například modifikátor příkazu zmíněný výše, nebo ukazatel na oblast v paměti; například na paměťové místo pro soubor tokenů reprezentujících definici makra.
Takže naše hash hodnota 1218 (uložená v proměnné `curcs`) byla ve skutečnosti použita jako *klíč* pro přístup k zásuvce, která obsahuje aktuální význam a hodnotu příkazu, který jsme původně zadali jako řetězec písmen `\def`.
Ve zdrojovém kódu programu TeX se `eq_type` pro libovolný příkaz ukládá do proměnné nazývané `curcmd` a hodnota `equiv` se ukládá do proměnné nazývané `curchr`.
### Co říká tabulka ekvivalentů pro def?
Jak bylo uvedeno, hash hodnota vypočtená pro libovolný příkaz se ukládá do proměnné nazývané `curcs`; tedy pro `def` máme `curcs=1218`. Při pohledu na místo 1218 v tabulce ekvivalentů TeX najde následující informace:
* `curcmd`=97. To je kód příkazu pro `\def`;
* `curchr`=0. To je modifikátor příkazu pro `\def`.
`\def` je primitivum (vestavěný příkaz) TeXu a pokud nebyl někde předefinován, třetí a poslední informace by měla být `eq_level=1` což značí, že význam `\def` je definován globálně a není omezen na nějakou nižší úroveň seskupení. Interně hodnota `eq_level` připojená k příkazu hraje v mechanismu seskupování TeXu mimořádně důležitou roli, ale dále ji už nebudeme rozebírat.
Následující grafika shrnuje vysvětlení, kterým jsme prošli:
## Tokeny TeXu pro příkazy
Po projití výše uvedených vysvětlení se ukazuje, že skutečný výpočet tokenů TeXu pro řídicí sekvence je opravdu velmi jednoduchý. TeX používá hodnotu `curcs` (1218) z hashovací funkce k vytvoření jednoduchého celého čísla, které nazývá *token*. Výpočet pro vytvoření tokenu z hodnoty `curcs` je:
```c
curtok = 4095 + curcs
```
TeX ukládá hodnotu aktuálního tokenu (naposledy vypočteného) do proměnné nazývané `curtok`.
Takže závěrem: token TeXu reprezentující `\def` příkazu je `4095 + 1218 = 5313`. A to je vše k tokenům TeXu, které reprezentují sekvence příkazů: jsou to jednoduše celá čísla vypočtená z hodnoty hash tabulky plus 4095.
## Tokeny TeXu pro znaky
Když TeX potřebuje vytvořit token představující znak, použije následující, stejně jednoduchý výpočet:
```c
curtok = 256*catcode + (ASCII hodnota znaku)
```
Všimněte si, že pro enginy podporující Unicode, jako je LuaTeX, se používají mírně odlišné výpočty.
Například token TeXu reprezentující znak mezery s `\catcode` 10 a ASCII hodnotou 32 je:
```c
256*10 + 32 = 2592
```
### Seznamy tokenů obsahující znaky
Když vytvoříte jednoduchý seznam tokenů například pomocí
```latex
\toks100={Hello}
```
TeX vytvoří následující seznam tokenů a uloží je do paměti pro pozdější použití:
* H→ 256 × 11 + 72 = 2888
* e→ 256 × 11 + 101 = 2917
* l→ 256 × 11 +108 = 2924
* l→ 256 × 11 +108 = 2924
* o→256 × 11 + 111 = 2927
Hluboko v paměti TeXu poskytne registr tokenů 100 přístup k úložnému místu „Hello“, uloženému jako 5 hodnot tokenů: 2888, 2917, 2924, 2924, 2927. Všimněte si, že tyto tokeny kombinují ASCII kód každého znaku a hodnotu jeho `\catcode`v okamžiku, kdy jsou převedeny na tokeny (tokenizovány). Jakmile jsou znaky převedeny na znakové tokeny, je `\catcode` hodnota k nim připojená trvalá a je uložena v tokenech pro pozdější použití, když uživatel například řekne `\the\toks100`.
Jak bylo uvedeno, znakový token se vypočítá z `256*catcode + (ASCII hodnota)` zatímco token řídicí sekvence se vypočítá z `4095 + curcs` kde `curcs` je hash hodnota řídicího slova (textového řetězce příkazu zadaného uživatelem), kterou TeX rozpoznal ve vstupu. Stojí za zmínku, že znakové tokeny jsou vždy menší než 4095. TeX tak může snadno určit, zda konkrétní token představuje řídicí sekvenci (příkaz) nebo znak, a poté zjistit, která řídicí sekvence nebo který znak a `\catcode` dvojice je do daného tokenu zakódována.
---
# 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/53-what-is-a-tex-token.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.