> 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/pl/artykuly-szczegolowe/53-what-is-a-tex-token.md).
# Czym jest „token TeX-a”?
## Motywacja do serii o tokenach TeX-a i pokrewnych pojęciach
W tym artykule omawiamy motywację oraz metodologię użyte do przygotowania serii artykułów o tokenach TeX-a i pokrewnych pojęciach [Nowa seria artykułów: tokeny TeX-a i pokrewne pojęcia — ale dlaczego (i jak)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Jak zauważono w tamtym artykule, w całej tej serii opieramy nasze omówienia i wyjaśnienia na spostrzeżeniach uzyskanych dzięki niestandardowej kompilacji oryginalnego programu TeX Knutha — wykorzystując ją do przygotowania serii artykułów, której celem jest dostarczenie prostych opisów i łatwych do śledzenia wyjaśnień kluczowych pojęć TeX-a.
## Wprowadzenie: jaki jest nasz cel?
W tym artykule dowiemy się dokładnie, czym jest token TeX-a, śledząc drogę przetwarzania od znaków w pliku wejściowym do faktycznego utworzenia tokenów TeX-a. W praktyce jest to dość złożone, więc sprowadziliśmy ten proces do jego najważniejszych elementów, starając się uczynić go łatwym do śledzenia i zrozumienia, a jednocześnie zachować techniczną poprawność.
Zaczynamy od wprowadzenia kilku ważnych wewnętrznych pojęć TeX-a: *prymitywów*, *kody poleceń* i *modyfikatory poleceń*. Stamtąd użyjemy bardzo prostego przykładu makra, aby zobaczyć dokładnie, jak TeX przetwarza polecenie `\def` i jaki token TeX tworzy, aby reprezentować to polecenie.
Kończymy krótkim spojrzeniem na to, jak TeX tworzy tokeny reprezentujące znaki i jak atrybut znaku `\catcode` rzeczywiście zostaje trwale przypisany do tokenu znaku — coś często wspominane w książkach o TeX-ie, ale tutaj widzimy dokładnie, jak to jest osiągane.
Poniższy diagram pokazuje drogę, którą podsumujemy — od tekstu wejściowego do tokenów TeX-a:
## Ale najpierw: prymitywy i kody poleceń
Każdy silnik TeX-a (TeX Knutha, pdfTeX, XeTeX, LuaTeX) rozumie pewną liczbę wbudowanych poleceń: tzw. *prymitywów*—fundamentalne polecenia-„cegiełki”, które stanowią podstawę programowalności TeX-a. Nazywa się je „prymitywami”, ponieważ, w przeciwieństwie do makr zdefiniowanych przez użytkownika, nie są zbudowane z innych poleceń i nie można ich dalej sprowadzić do prostszych instrukcji. W TeX-ie Knutha istnieje około 320 prymitywów — choć należy zauważyć, że inne silniki TeX-a, takie jak pdfTeX, XeTeX i LuaTeX, dodały do oryginalnego programu Knutha nowe polecenia i zawierają prymitywy, których nie ma w oprogramowaniu TeX Knutha.
Wewnętrznie TeX przypisuje numeryczny *kodem polecenia* kod polecenia wszystkim poleceniom — niezależnie od tego, czy są to makra zdefiniowane przez użytkownika, czy wbudowane prymitywy. Te kody poleceń nie są dostępne dla użytkownika TeX-a; są po prostu częścią wewnętrznego mechanizmu przetwarzania TeX-a, ale warto o nich wiedzieć na potrzeby późniejszego omówienia tokenów TeX-a.
Grupy poleceń o pokrewnej funkcjonalności mają ten sam kod polecenia. Na przykład `\def`, `\gdef`, `\edef` i `\xdef` wszystkie prymitywy służą do definiowania makr i w TeX-ie Knutha mają wspólny kod polecenia 97. Oczywiście te 4 polecenia definiujące makra tworzą makra na nieco różne sposoby; w konsekwencji podczas przetwarzania TeX potrzebuje sposobu na ich rozróżnienie.
Sam kod polecenia (na przykład 97) nie może powiedzieć, które z poleceń tworzących makra jest rozpatrywane; więc, jak można się spodziewać, każdemu poleceniu TeX-a przypisuje się dodatkową informację zwaną jego *modyfikator polecenia* (zob. przykłady poniżej).
### Modyfikatory poleceń: dwa typy
Modyfikatory poleceń dzielą się na dwie kategorie, które będziemy nazywać „Typem 1” i „Typem 2” — TeX nie używa tej terminologii, jest ona tu po prostu wygodna:
* **Typ 1**: Proste wartości całkowite, których TeX może, jeśli trzeba, użyć do rozróżnienia poleceń o tym samym kodzie polecenia.
* **Typ 2**: Wartość całkowita będąca numeryczną lokalizacją w pamięci TeX-a, mówiącą TeX-owi, dokąd ma się udać, aby odszukać informacje dla tego polecenia. Na przykład dotyczy to poleceń zdefiniowanych przez użytkownika (makr), gdzie modyfikator polecenia mówi TeX-owi, gdzie w pamięci przechowywana jest definicja makra.
#### Modyfikatory poleceń typu 1 (przykład)
Jak wspomniano, w TeX-ie Knutha cztery prymitywne polecenia służące do definiowania makr: `\def`, `\gdef`, `\edef`, `\xdef` wszystkie mają wspólny kod polecenia 97: są rozróżniane przez swoje modyfikatory poleceń, które wymieniono w poniższej tabeli:
| Polecenie | Kod
polecenia
| Modyfikator
polecenia
|
| --------- | ----------------------- | ------------------------------- |
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
Jako drugi przykład, Knuth zdecydował się zaimplementować polecenia `\openout`, `\write`, `\closeout`, `\special`, `\immediate` i `\setlanguage` jako „rozszerzenia” TeX-a, wyłącznie po to, aby pokazać, jak można dodawać nowe prymitywy do TeX-a. W tym przypadku te polecenia tak naprawdę nie mają „podobnej funkcjonalności”, poza tym, że Knuth postanowił zgrupować je razem na potrzeby wyjaśnienia, jak rozszerzać TeX-a. Te 6 poleceń jest klasyfikowanych jako „rozszerzenia” i grupowanych razem z wartością kodu polecenia 59, ale każde z nich ma odpowiedni modyfikator polecenia, który odróżnia je od pozostałych:
| Polecenie | Kod
polecenia
| Modyfikator
polecenia
|
| -------------- | ----------------------- | ------------------------------- |
| `\openout` | 59 | 0 |
| `\write` | 59 | 1 |
| `\closeout` | 59 | 2 |
| `\special` | 59 | 3 |
| `\immediate` | 59 | 4 |
| `\setlanguage` | 59 | 5 |
#### Modyfikatory poleceń typu 2 (krótkie wyjaśnienie)
Chociaż wszystkie modyfikatory poleceń są liczbami całkowitymi, modyfikatory typu 2 wymagają nieco więcej wyjaśnienia. W TeX-ie modyfikatory te nazywane są „wskaźnikami”, ponieważ wskazują na lokalizację w pamięci, gdzie TeX może znaleźć dodatkowe informacje dla danego polecenia. Może to brzmieć nieco mgliście, ale sposób, w jaki TeX używa tych wskaźników do wyszukiwania informacji, jest dość zróżnicowany, a pełniejsze wyjaśnienie odciągałoby od głównego celu tego artykułu. Jeden przykład może pomóc: makra. Gdy polecenie makra jest definiowane, TeX będzie musiał gdzieś w pamięci przechować tekst zastępczy. Jak zobaczymy poniżej, makra zdefiniowane przez użytkownika mają kody poleceń od 111 do 114, a modyfikator polecenia jest wskaźnikiem do pamięci, mówiącym TeX-owi, gdzie przechowywany jest tekst zastępczy (definicja makra).
### Kody poleceń: rozwijalne i nierozwijalne
W kodzie źródłowym TeX-a Knutha kody poleceń mieszczą się w zakresie od 0 do 120 — zauważ, że niektóre kody z tego zakresu są przeznaczone wyłącznie do specjalistycznego użytku wewnętrznego i nie są przypisane do poleceń dostępnych dla użytkownika. Warto zauważyć, że inne silniki TeX-a, takie jak pdfTeX, XeTeX i LuaTeX, dodały do oryginalnego zestawu Knutha nowe polecenia i zawierają więcej prymitywów oraz odpowiadające im kody poleceń; jednak zasady opisane tutaj są podstawowe dla wszystkich silników opartych na TeX-ie wywodzących się z kodu źródłowego Knutha.
Zbiór kodów poleceń dzieli się na dwa główne zestawy:
* *polecenia nierozwijalne*: mają kody poleceń mniejsze lub równe 100;
* *polecenia rozwijalne*: mają kody poleceń większe niż 100, aż do maksymalnej wartości 120. Zakres od 101 do 120 obejmuje makra zdefiniowane przez użytkownika oraz polecenia takie jak `\csname`, `\expandafter` i `\the`.
Polecenia nierozwijalne zwykle przypisują wartość do wewnętrznego parametru lub bezpośrednio wytwarzają materiał, który można składać. Polecenia rozwijalne zwykle „wstrzykują” strumień tokenów do bieżącej aktywności przetwarzania TeX-a lub modyfikują kolejność przetwarzania tokenów.
Jak wspomniano powyżej, wszystkie makra (polecenia zdefiniowane przez użytkownika) otrzymują kody poleceń od 111 do 114: różne wartości odzwierciedlają, czy makro zostało zdefiniowane jako `\long`, `\outer`, oba albo żadne. Oto przykład:
| Typ makra | Przykład | Komentarz |
| ------------------------ | ---------------------------------- | ---------------------------- |
| Niedługie, niezewnętrzne | `\\def\\ohyeah{....}` | `\\ohyeah` kod polecenia=111 |
| Długie, niezewnętrzne | `\\long\\def\\ohyeah{....}` | `\\ohyeah` kod polecenia=112 |
| Niedługie, zewnętrzne | `\\outer\\def\\ohyeah{....}` | `\\ohyeah` kod polecenia=113 |
| Długie, zewnętrzne | `\\long\\outer\\def\\ohyeah{....}` | `\\ohyeah` kod polecenia=114 |
Dla przypomnienia na temat modyfikatorów poleceń: gdy makro jest definiowane, TeX przechowa definicję makra w jakiejś lokalizacji w pamięci: ta lokalizacja (wskaźnik) stanie się modyfikatorem polecenia dla polecenia makra, które zostanie zapisane z kodem od 111 do 114, zależnie od tego, jak zostało zdefiniowane. Właściwa nazwa przypisana makru zdefiniowanemu przez użytkownika nie ma tak naprawdę znaczenia: po przetworzeniu danych wejściowych wszystkie otrzymają kod polecenia z zakresu 111–114 i ostatecznie wszystkie polecenia, które TeX odczytuje z danych wejściowych — niezależnie od tego, czy są to prymitywy, czy makra zdefiniowane przez użytkownika — są ostatecznie przekształcane w reprezentację liczbową zwaną *token*.
## Droga od tekstu wejściowego do tokenów TeX-a
W tej sekcji użyjemy bardzo prostego przykładu makra, aby zobaczyć dokładnie, jak TeX przetwarza polecenie `\def` aby utworzyć token reprezentujący `\def` polecenie. Szczegółowa aktywność przetwarzania TeX-a może być niezwykle złożona, więc nie używamy parametrów makra ani ograniczników, ponieważ dodałoby to złożoności i odciągnęło nas od naszej drogi.
Załóżmy, że Twój plik wejściowy TeX-a zawiera następującą linię:
```latex
\\def\\ohyeah{Overleaf is cool!}
```
Gdy TeX zaczyna przetwarzać tę linię danych wejściowych, sprawdza `\catcode` kategorii `\` (pierwszy znak `\def`). Wykrywa (sprawdza w wewnętrznej tabeli), że `\` ma `\catcode` 0, co oznacza, że wprowadza początek *sekwencji kontrolnej*. Oczywiście można przedefiniować dowolny znak tak, aby miał `\catcode` 0, ale założymy, że używane są konwencjonalne definicje plain TeX-a lub LaTeX-a.
Ściśle rzecz biorąc, termin *sekwencji kontrolnej* ma dwie podkategorie: *słowa sterującego* i *symbolu sterującego*:
* *słowa sterującego*: ciąg znaków z `\catcode` kategoria litera (11);
* *symbolu sterującego*: pojedynczy znak, którego `\catcode` to *nie* kategoria to litera (11).
W tym momencie `\` znak ucieczki spełnił już swoje zadanie i jest już niepotrzebny. Po wykryciu znaku ucieczki reakcją TeX-a jest rozpoczęcie odczytywania wszystkich kolejnych znaków w danych wejściowych w celu wykrycia słowa kontrolnego lub symbolu kontrolnego.
Po początkowym `\`, TeX natychmiast wykrywa `d`: znak, którego `\catcode` wartość to 11, co mówi TeX-owi, że znalazł pierwszą literę *słowa sterującego*. Kontynuuje skanowanie kolejnych znaków, aż ostatecznie wykryje znak, który *nie* zgłaszali, że wersja 3 działa wolno `\catcode` litera (11). Wszystkie kolejne znaki (po początkowym `\`) z `\catcode` 11 (litera) są uznawane za tworzące nazwę słowa kontrolnego: tj. nazwę polecenia — może makra albo prymitywu, ale TeX nadal nie wie, jakiego typu jest to polecenie. Na tym etapie jest to po prostu ciąg znaków.
Tak więc w naszym przykładzie TeX spokojnie skanuje dalej, sprawdzając każdy znak, aż dociera do początkowego `\` o wartości `\\ohyeah` który również ma `\catcode` 0. TeX rozpoznaje, że zaszedł za daleko, i uprzejmie zwraca ten `\` z powrotem do strumienia tekstu, tak aby stał się następnym znakiem widocznym podczas dalszego skanowania tekstu. W tym momencie TeX zidentyfikował ciąg (`def`) o którym wie, że tworzy tekst słowa kontrolnego składającego się z trzech znaków, z których każdy ma `\catcode` 11 (`d`, `e` i `f`). Teraz TeX musi ustalić, co `def` oznacza: co ma z tym zrobić? Jak się zapewne domyślasz, TeX musi znaleźć kod polecenia i identyfikator polecenia dla `def` aby mógł ustalić, co zrobić z tym poleceniem.
## Zrobienie z tego skrótu
Po wykryciu słowa kontrolnego (`def`), pierwszą rzeczą, jaką robi TeX, jest „przekształcenie” ciągu znaków (`def` w naszym przykładzie) na liczbę całkowitą przy użyciu czegoś, co nazywa się funkcją haszującą. Nie musimy zagłębiać się w szczegóły, wystarczy zarys. Zasadniczo TeX przygląda się każdemu znakowi w właśnie wykrytym słowie kontrolnym i używa wartości kodu ASCII (lub wartości Unicode w przypadku XeTeX/LuaTeX) każdego znaku do obliczenia liczby zwanej wartością skrótu: to po prostu zwykła liczba całkowita.
W ramach tego procesu obliczania skrótu TeX sprawdzi także, czy ciąg znaków w nowo wykrytym słowie kontrolnym jest już mu znany. Czytelny dla człowieka tekst wszystkich poleceń, niezależnie od tego, czy są to prymitywy, czy makra zdefiniowane przez użytkownika, jest przechowywany w wewnętrznym obszarze pamięci zwanym *pulą ciągów znaków*. TeX musi to robić, ponieważ może potrzebować wypisać czytelną dla człowieka nazwę polecenia — na przykład, gdy TeX musi zgłosić błąd i podać nazwę polecenia, które go spowodowało. Na przykład nasze makro `\\def\\ohyeah{Overleaf is cool!}` definiuje nowe polecenie o nazwie `\\ohyeah` i TeX będzie (na późniejszym etapie) musiał nie tylko obliczyć wartość skrótu dla `ohyeah` (*bez* początkowego `\` znaku), lecz także przechować tekstowy (czytelny dla człowieka) zapis na wypadek, gdyby trzeba go było użyć do raportowania błędów (lub innych zadań).
Jeśli chcesz więcej szczegółów o procesach obsługi ciągów znaków w TeX-ie, pisałem o tym na moim [osobistym blogu](http://www.readytext.co.uk/?p=3590).
Końcowym rezultatem jest to, że ciąg znaków reprezentujący polecenie `def` zostaje przekształcony w wartość liczbową 1218 (to jest rzeczywista wartość obliczona przez TeX-a). W tym momencie poszczególne znaki `d`, `e` i `f` nie są już częścią głównej opowieści — zostały odczytane z danych wejściowych i spełniły swoje zadanie: odtąd chodzi już tylko o liczby całkowite i *tokeny*—już wkrótce zobaczymy, czym token właściwie jest! Wewnętrznie TeX nazywa te liczby będące wartościami skrótu *bieżącą sekwencją kontrolną* ale w kodzie źródłowym termin ten jest skrócony do zmiennej o nazwie `curcs`. Kod źródłowy TeX-a jest pełen bardzo krótkich, często dość tajemniczych nazw zmiennych.
Ale co TeX *tak naprawdę robi* z tą świeżo utworzoną wartością całkowitą 1218? Skąd TeX wie, że oryginalny ciąg `def`, teraz reprezentowany przez liczbę całkowitą 1218, rzeczywiście odnosi się do polecenia definiującego makro? Odpowiedź brzmi: TeX ma rodzaj wewnętrznego „archiwum kartotekowego”, w którym przechowuje bieżące znaczenie i wartość każdego polecenia, które aktualnie zna — niezależnie od tego, czy jest to makro zdefiniowane przez użytkownika, czy wbudowany prymityw. Powodem, dla którego TeX zadał sobie trud przekształcenia `def` na wartość skrótu 1218 (obecnie przechowywaną w zmiennej o nazwie `curcs`) polega na użyciu jej do wyszukania *znaczenie* o wartości `def`. TeX oczywiście powtórzy to obliczanie skrótu dla wszystkich słów kontrolnych, które wykryje w danych wejściowych — chociaż oczywiście różne słowa kontrolne dają różne wartości całkowite z funkcji haszującej: na tym właśnie polega cały pomysł.
wewnętrzna „szafka na akta” TeX-a nazywa się *tabela ekwiwalentów* i jest tematem następnej sekcji.
### Konsultowanie tabeli ekwiwalentów
Dla przypomnienia, zobaczmy, czego dotąd się nauczyliśmy:
* `\` wprowadza początek sekwencji kontrolnej (czy to *symbolu sterującego* lub *słowa sterującego*).
* Jeśli pierwszy znak po `\` ma `\catcode` 11 (litera), to jest to początek *słowa sterującego*.
* Dla *słów kontrolnych* TeX skanuje, aby sprawdzić wszystkie kolejne znaki wejściowe, które mają `\catcode` 11 i przestanie skanować, gdy tylko znajdzie pierwszy znak, który nie *nie* ma `\catcode` wartość 11.
* Ciąg znaków wejściowych (po `\`) które mają `\catcode` 11 są uważane za *słowa sterującego* wpisany przez użytkownika: polecenie proszące TeX-a, aby „coś zrobił”.
* Aby rozpocząć proces „robienia czegoś”, TeX przekształca ciąg znaków w słowie kontrolnym na liczbę całkowitą. Robi to, używając tak zwanej funkcji haszującej, która zwraca liczbę całkowitą.
* Liczba całkowita (obliczona wartość skrótu) jest określana jako *bieżącą sekwencją kontrolną*, ale TeX nadaje jej krótszą nazwę `curcs`.
* W naszym przykładzie słowo kontrolne `def` jest przekształcane w wartość 1218 — która jest przechowywana w zmiennej o nazwie `curcs`: tzn., `curcs=1218`.
TeX musi teraz ustalić, co nowo wykryta *bieżącą sekwencją kontrolną* tak naprawdę oznacza — co TeX z tym robi?
#### Uwaga na temat grupowania: potrzeba zapisywania i przywracania informacji
Tutaj zrobimy mały objazd, aby przypomnieć sobie, że TeX ma zdolność zapisywania i przywracania informacji: innymi słowy, ma pewną formę wbudowanej „pamięci”.
Każdy, kto napisał choćby najprostsze makro, powinien znać mechanizm grupowania TeX-a — na przykład używając `\def` do tworzenia makr wewnątrz grupy. Jeśli nie zastosujesz prefiksu `\global` do `\def`-utworzonych makr zdefiniowanych wewnątrz grupy, wartość lub znaczenie tego makra utrzymuje się tylko w tej grupie (i w grupach poniżej niej): jego definicja ginie, gdy grupa się kończy. Na przykład, jeśli zdefiniujesz proste makro wewnątrz grupy, tak jak tutaj:
```latex
{\\def\\foo{Hello}}
```
i spróbujesz użyć `\foo` poza grupą
```latex
{\\def\\foo{Hello}}% \\foo zdefiniowane wewnątrz grupy (uwaga: bez użycia \\global)
\\foo %<--- nie jest już zdefiniowane, teraz niezdefiniowane
```
otrzymujemy wówczas znany błąd: `Niezdefiniowana sekwencja kontrolna`. `\foo` ma znaczenie tylko wewnątrz grupy (i jej podgrup), w której zostało zdefiniowane. Ponadto, gdy przedefiniujesz makro wewnątrz grupy, nowa wartość może zostać utracona po zakończeniu grupy, a poprzednie znaczenie (istniejące poza grupą) zostaje przywrócone.
```latex
\\def\\foo{Goodbye}
\\foo\\par% Wypisuje Goodbye
{\\def\\foo{Hello}% Przedefiniowane wewnątrz grupy:
{Wewnątrz grupy 2. poziomu: \\foo\\par}}% Użyte wewnątrz grupy 2. poziomu: \\foo wypisuje Hello
Poza grupą przywrócono starą wartość: \\foo\\par% Wypisuje Goodbye
```
Celem tych prostych przykładów jest pokazanie, że TeX ma jakiś rodzaj „mechanizmu przechowywania” lub „pamięci”, który zapisuje i przywraca „znaczenie” poleceń — i oczywiście tak właśnie jest. Zasugerowaliśmy to w poprzedniej sekcji: ten „mechanizm przechowywania” lub „szafka na akta” to duża wewnętrzna tabela zwana *tabela ekwiwalentów*. To właśnie tam TeX przechowuje bieżące znaczenie lub wartości wszystkich poleceń, które aktualnie zna — wbudowanych prymitywów i makr zdefiniowanych przez użytkownika.
### Tabela ekwiwalentów: przez analogię
Aby wyjaśnić tabelę ekwiwalentów, posłużymy się analogią. Nadal będziemy używać wyobrażenia szafki z tysiącami małych szuflad, z których każda jest oznaczona unikalną liczbą całkowitą. Na tym etapie przetwarzania TeX mówi w istocie:
„OK, mam tę wartość całkowitą 1218, którą właśnie obliczyłem i zapisałem w zmiennej o nazwie `curcs`. Teraz muszę ustalić, co ona oznacza: żeby to zrobić, pójdę i zajrzę do szuflady numer 1218 w mojej szafce na akta, aby zobaczyć, co tam jest napisane.”
TeX używa 1218, aby odnaleźć właściwą szufladę, a tam znajduje małą notatkę zawierającą trzy elementy informacji, których nazwy są takie, jakich używa kod źródłowy TeX-a:
* **`eq_level:`** poziom grupowania, na którym ten wpis został zdefiniowany (poziom 1 = zdefiniowany globalnie). Widzieliśmy już wyżej działanie grupowania: to właśnie tutaj, w tabeli ekwiwalentów, przechowywana jest informacja o poziomie grupowania;
* **`eq_type:`** kod polecenia dla tego wpisu;
* **`equiv:`** bieżąca „wartość” tego wpisu — może to być zwykła liczba całkowita, taka jak wspomniany wyżej modyfikator polecenia, albo wskaźnik do obszaru w pamięci; na przykład lokalizacja pamięci dla zbioru tokenów reprezentujących definicję makra.
Tak więc nasza wartość skrótu 1218 (zapisana w zmiennej `curcs`curcs *klucz* do uzyskania dostępu do szuflady zawierającej bieżące znaczenie i wartość polecenia, które pierwotnie wpisaliśmy jako ciąg liter `\def`.
W kodzie źródłowym programu TeX `eq_type` dla dowolnego polecenia jest przechowywana przy użyciu zmiennej o nazwie `curcmd` a wartość `equiv` jest przechowywana w zmiennej o nazwie `curchr`.
### Co tabela ekwiwalentów mówi o def?
Jak zauważono, wartość skrótu obliczona dla dowolnego polecenia jest zapisywana w zmiennej o nazwie `curcs`; stąd dla `def` mamy `curcs=1218`. Przyglądając się lokalizacji 1218 w tabeli ekwiwalentów, TeX znajdzie następujące informacje:
* `curcmd`=97. To jest kod polecenia dla `\def`;
* `curchr`=0. To jest modyfikator polecenia dla `\def`.
`\def` jest prymitywnym (wbudowanym) poleceniem TeX-a i, chyba że zostało gdzieś przedefiniowane, trzeci i ostatni element informacji powinien być `eq_level=1` co wskazuje, że znaczenie `\def` jest zdefiniowane globalnie i nie jest ograniczone do jakiegoś niższego poziomu grupowania. Wewnętrznie wartość `eq_level` dołączona do polecenia odgrywa niezwykle ważną rolę w mechanizmie grupowania TeX-a, ale nie będziemy tego dalej rozważać.
Poniższy rysunek podsumowuje omówione wyjaśnienie:
## Tokeny TeX-a dla poleceń
Po przedarciu się przez powyższe wyjaśnienia okazuje się, że faktyczne obliczanie tokenów TeX-a dla sekwencji kontrolnych jest naprawdę bardzo proste. TeX używa wartości `curcs` (1218) z funkcji haszującej, aby utworzyć zwykłą liczbę całkowitą, którą nazywa *token*tokenem `curcs` jest:
```c
curtok = 4095 + curcs
```
TeX przechowuje wartość bieżącego tokenu (ostatnio obliczonego) w zmiennej o nazwie `curtok`.
Tak więc, podsumowując, token TeX-a reprezentujący `\def` polecenia to `4095 + 1218 = 5313`. I to wszystko, jeśli chodzi o tokeny TeX-a reprezentujące sekwencje poleceń: są one po prostu liczbą całkowitą obliczaną jako wartość z tablicy haszującej plus 4095.
## Tokeny TeX-a dla znaków
Gdy TeX musi utworzyć token reprezentujący znak, używa następującego, równie prostego, obliczenia:
```c
curtok = 256*catcode + (ASCII value of character)
```
Zauważ, że w przypadku silników obsługujących Unicode, takich jak LuaTeX, używa się nieco innych obliczeń.
Na przykład token TeX-a reprezentujący znak spacji z `\catcode` kodem kategorii 10 i wartością ASCII 32 to:
```c
256*10 + 32 = 2592
```
### Listy tokenów zawierające znaki
Gdy tworzysz prostą listę tokenów, na przykład za pomocą
```latex
\\toks100={Hello}
```
TeX utworzy następującą listę tokenów i zapisze ją w pamięci do późniejszego użycia:
* 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
Głęboko w pamięci TeX-a rejestr tokenów 100 zapewni dostęp do miejsca przechowywania „Hello”, zapisanego jako 5 wartości tokenów: 2888, 2917, 2924, 2924, 2927. Zauważ, że tokeny te łączą kod ASCII każdego znaku i wartość jego `\catcode`w momencie, gdy są zamieniane na tokeny (tokenizowane). Gdy znaki zostaną przekształcone w tokeny znakowe, `\catcode` przypisana im wartość jest trwała i zostaje zapisana w tokenach do późniejszego użycia, gdy użytkownik wpisze na przykład `\\the\\toks100`.
Jak zauważono, token znaku jest obliczany na podstawie `256*catcode + (ASCII value)` natomiast token sekwencji kontrolnej jest obliczany na podstawie `4095 + curcs` gdzie `curcs` jest wartością skrótu słowa kontrolnego (ciągu tekstowego polecenia wpisanego przez użytkownika) wykrytego przez TeX w danych wejściowych. Warto zauważyć, że tokeny znakowe są zawsze mniejsze niż 4095. Dzięki temu TeX może łatwo określić, czy dany token reprezentuje sekwencję kontrolną ( `\catcode` polecenie) czy znak, a następnie ustalić, która sekwencja kontrolna lub który znak i para są zakodowane w tym tokenie.
---
# 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/pl/artykuly-szczegolowe/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.