> 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/wiecej-tematow/21-how-tex-macros-actually-work-part-3.md).
# Jak naprawdę działają makra TeX-a: Część 3
[Część 1](/latex/pl/wiecej-tematow/19-how-tex-macros-actually-work-part-1.md) [Część 2](/latex/pl/wiecej-tematow/20-how-tex-macros-actually-work-part-2.md) [Część 3](/latex/pl/wiecej-tematow/21-how-tex-macros-actually-work-part-3.md) [Część 4](/latex/pl/wiecej-tematow/22-how-tex-macros-actually-work-part-4.md) [Część 5](/latex/pl/wiecej-tematow/23-how-tex-macros-actually-work-part-5.md) [Część 6](/latex/pl/wiecej-tematow/24-how-tex-macros-actually-work-part-6.md)
## Czas na przerwę!
Zanim przejdziemy do następnej części tej opowieści, potrzebujemy podsumowania: przypomnieć sobie, dokąd zmierzamy, i zebrać myśli, aby upewnić się, że wszystkie kluczowe idee są na swoim miejscu. Przypomnienie: nasz opracowany przykład opiera się na założeniu, że TeX odczytał wiersz tekstu zawierający `Hello World \jobname` i że TeX składa to typograficznie, aby zbudować akapit.
### Ostateczny cel
Naszym celem jest wypracowanie lepszego (głębszego) zrozumienia natury makr TeX-a i tego, jak działają. Jednak, aby do tego dojść, najpierw musimy zrozumieć, jak TeX odczytuje plik wejściowy i przetwarza zawarte w nim znaki. Oto podsumowanie dotychczas omówionych tematów.
* TeX odczytuje (skanuje) każdy znak w danych wejściowych i dla każdego znaku ma dwie informacje:
* **kod znaku**: liczba całkowita używana do identyfikacji tego znaku, np. gdy jest przechowywany w pliku wejściowym .tex;
* **kodem kategorii**: inna liczba całkowita, wewnętrzna dla TeX-a, której używa do przypisywania znaczenia każdemu znakowi odczytanemu z wejścia.
* Gdy tylko znak zostanie odczytany przez TeX-a, kod kategorii każdego znaku staje się *na stałe* powiązany z tym pojedynczym znakiem poprzez utworzenie tokenu znaku:
* TeX używa prostej formuły, aby „spakować” kod znaku i odpowiadający mu kod kategorii w liczbę całkowitą zwaną tokenem znaku.
* Możesz zmienić znaczenie dowolnego znaku, którego TeX jeszcze nie odczytał *jeszcze nieodczytanego* przypisując inny kod kategorii dowolnemu znakowi, którego zachowanie chcesz zmienić — tj. modyfikując sposób, w jaki TeX traktuje ten znak.
* Ponowne definiowanie (ponowne mapowanie) kodów kategorii odbywa się za pomocą prymitywu TeX-a `\catcode` polecenie.
* Gdy TeX napotka kod kategorii 0, przełączy się w specjalny tryb skanowania i zacznie szukać polecenia: albo (potencjalnie wieloliterowego) *słowa sterującego* albo jednego znaku *symbolu sterującego*.
Jak dotąd przyjrzeliśmy się procesowi skanowania wejścia przez TeX-a, gdy identyfikuje on pojedyncze znaki i używa kodu kategorii każdego znaku, aby ustalić, co zrobić dalej. Niektóre znaki są po prostu zwykłymi elementami tekstu do składu (np. kod kategorii 11), ale widzieliśmy też znaki odstępu (kod kategorii 10) i znaki ucieczki (kod kategorii 0). Istnieją inne kody kategorii, których dla zwięzłości nie omawialiśmy — takie jak kod kategorii 1 („początek grupy”, np., `{`), kod kategorii 2 („koniec grupy”, np., `}`) i inne. Każdy kod kategorii odgrywa własną rolę w skanowaniu wejścia przez TeX-a i późniejszym przetwarzaniu przez procesy/algorytmy programowe wewnątrz TeX-a.
### Tokeny: szybkie przypomnienie
Pojęcie „tokenów” ma kluczowe znaczenie dla sposobu działania TeX-a: pojęcie to pojawia się lub jest przywoływane w książkach, artykułach i społecznościach internetowych dotyczących TeX-a, dlatego warto krótko je przypomnieć — więcej szczegółów znajdziesz w wcześniej opublikowanym artykule [Czym jest „token TeX-a”?](/latex/pl/artykuly-szczegolowe/53-what-is-a-tex-token.md)
Widzieliśmy już, że TeX przekształca znaki wejściowe w tokeny, łącząc kod znaku i kod kategorii w pojedynczą złożoną liczbę całkowitą. TeX robi coś podobnego w przypadku poleceń: używając nazwy polecenia, oblicza liczbę całkowitą zwaną *tokenem polecenia* (przyjrzymy się temu dokładniej). Jako wskazówkę można traktować tokeny jako sposób TeX-a na „pakowanie” elementów odczytanych z wejścia, przygotowując je do przekazania do następnego etapu przetwarzania przez TeX-a. To, że wszystkie elementy (znaki lub polecenia) są schludnie opakowane w jedną numeryczną reprezentację, ułatwia dalsze przetwarzanie w dalszym ciągu. Na przykład, gdy TeX chce przechować część twojego wejścia do późniejszego użycia, taką jak definicja makra, TeX musi jedynie zapisać definicję makra, jakkolwiek złożoną, jako ciąg liczb całkowitych, gdzie każda liczba całkowita jest tokenem reprezentującym znak lub polecenie, które stanowi część (jest zawarte w) definicji twojego makra.
## Co dalej?
W końcowej części Części 2 widzieliśmy, jak znak ucieczki (kod kategorii 0) przełącza TeX-a w specjalny tryb przetwarzania, w którym szuka nazwy polecenia. W naszym przykładzie TeX wykrył ciąg znaków `jobname` i zakończyliśmy Część 2 w momencie, gdy TeX miał „coś zrobić” z tym ciągiem znaków (nazwą polecenia). W tej części przyjrzymy się szczegółowo temu, co TeX robi dalej.
Gdy TeX zidentyfikuje, że określony ciąg znaków w pliku wejściowym reprezentuje nazwę polecenia (tu, `jobname`) TeX może, w zależności od tego, co robi, potrzebować wykonać to polecenie. Mówimy „może potrzebować”, ponieważ są sytuacje, w których TeX nie będzie od razu próbował wykonać polecenia: na przykład podczas definiowania makra (TeX buduje listy tokenów) — tematy te omówimy później. Jednak będziemy nadal śledzić nasz przykład, w którym TeX składa akapit i *będzie*, w tej sytuacji, musi wykonać `\jobname`.
### Od ciągu znaków do uruchomienia polecenia: jak?
Najpierw wróćmy do Grafiki 5b z Części 2, w której TeX zidentyfikował, że określony ciąg znaków w wejściu stanowi nazwę polecenia: `jobname`. Grafika 5b wskazuje, że TeX musi „sprawdzić wewnętrzne tablice...”. Co to *tak naprawdę oznacza*?
Inny, bardziej szczegółowy opis tego, jak TeX „sprawdza wewnętrzne tablice”, aby przejść od posiadania ciągu znaków (np., `jobname`) do ustalenia dokładnie, czym jest polecenie i co oznacza, można znaleźć we wcześniejszym artykule [Czym jest „token TeX-a”?](/latex/pl/artykuly-szczegolowe/53-what-is-a-tex-token.md) Tutaj podsumujemy kluczowe idee, starając się uniknąć nadmiernego powtarzania.
Zacznijmy od analogii. Załóżmy, że czytasz książkę i natrafiasz na nieznane słowo: co robisz? Dziś prawie na pewno „sięgasz po Google”, ale załóżmy, że wolisz starszą metodę: sięgasz po słownik, który zawiera słowa i podaje ich znaczenie(a). TeX ma analogiczny mechanizm: wewnętrzny „słownik”, który zawiera wszystkie polecenia obecnie znane TeX-owi — oraz „znaczenie” tych poleceń. Przez „znaczenie” rozumiemy, jakiego rodzaju jest to polecenie: co robi, plus wszelkie inne informacje, których TeX może potrzebować do jego uruchomienia. Zauważ też, że termin „polecenie” obejmuje wszelkie makra TeX/LaTeX napisane przez użytkowników/programistów TeX-a oraz [setki wbudowanych poleceń prymitywnych](/latex/pl/wiecej-tematow/46-tex-primitives-listed-by-tex-engine.md).
Kontynuując analogię ze słownikiem. Kiedy my, jako czytelnicy, musimy sprawdzić znaczenie słowa, szukamy go w słowniku, korzystając z alfabetycznego układu słów podanego przez słownik — ale oczywiście TeX nie działa dokładnie w ten sposób. Wracając do naszego pierwotnego `jobname` przykładu, jak TeX znajduje w swoim „słowniku” „znaczenie” `jobname`—i co właściwie to „znaczenie” dostarcza TeX-owi?
Zamiast udostępniać wewnętrzny „alfabetyczny wykaz” wszystkich poleceń, które TeX zna, robi coś nieco innego. TeX przekształca cały ciąg znaków — obecny w nazwie polecenia — w pojedynczą liczbę całkowitą, która zostanie użyta do identyfikacji (reprezentacji) tego polecenia. Wewnątrz TeX utrzymuje dużą „słownikową” bazę wszystkich znanych poleceń, do której zapisuje/przechowuje *liczby całkowite* obliczone na podstawie nazw poleceń — zauważ, że ten słownik nie przechowuje samych rzeczywistych nazw poleceń jako ciągów liter (zwanych *ciągami znaków*). TeX używa tego słownika dla wszystkich swoich wbudowanych poleceń (prymitywów) *i* będzie go używać do przechowywania szczegółów każdego makra (polecenia) utworzonego przez użytkowników: nazwa twojego makra jest przekształcana w liczbę całkowitą i ta liczba jest „rejestrowana” w słowniku TeX-a.
Za każdym razem, gdy TeX wykryje polecenie użyte w twoim wejściu i potrzebuje wiedzieć coś o tym poleceniu, przekształca ciąg znaków w nazwie polecenia w „równoważną” liczbę całkowitą i używa tej liczby do wyszukania polecenia w swoim „dużym słowniku”. Programistów wśród was może zainteresować fakt, że TeX używa pewnej formy [funkcję hash](https://en.wikipedia.org/wiki/Hash_function) do wykonania tej konwersji.
### Grafika 6: Od znaków do znaczenia polecenia
Poniższa grafika pokazuje drogę, jaką przechodzi polecenie, gdy TeX przekształca ciąg znaków w równoważną liczbę całkowitą, którą nazywa **curcs**, i używa tej liczby do wyszukania znaczenia polecenia w „dużym słowniku” TeX-a. Wynik tego wyszukania to dwie informacje: dwie liczby całkowite, zwane **curcmd** i **curchr**, które TeX może wykorzystać, aby ustalić dokładnie, co robi polecenie i jak następnie je wykonać.
Wewnątrz TeX utrzymuje zmienną o nazwie **curcs** (**cur**rent **c**ontrol **s**equence) która służy do przechowywania wartości całkowitej polecenia, nad którym TeX aktualnie pracuje — tj., **curcs** przechowuje liczbę całkowitą obliczoną z nazwy polecenia. To nie jest jeszcze cała historia, ponieważ jest jeszcze jeden szczegół: jeśli TeX właśnie odczytał/przetworzył znak, a nie polecenie, ustawi **curcs** na wartość 0, aby pamiętać, że ostatnią odczytaną rzeczą był znak, a nie polecenie.
### Co polecenia znaczą dla TeX-a
Jeśli spojrzymy na zestaw [wbudowanych poleceń dostarczanych przez silniki TeX-a](/latex/pl/wiecej-tematow/46-tex-primitives-listed-by-tex-engine.md) widać, że niektóre z tych poleceń są ze sobą ściśle powiązane: wykonują podobne zadania; na przykład istnieją 4 polecenia prymitywne, których wszystkie silniki TeX-a używają do definiowania (tworzenia) makr: `\def`, `\gdef`, `\edef`, `\xdef`. Te 4 polecenia wszystkie definiują makra, ale oczywiście każde robi to nieco inaczej. Patrząc na to z punktu widzenia programowania: mamy tutaj 4 polecenia definiujące makra, które ogólnie robią to samo, ale musimy wybierać między nimi, aby uwzględnić ich indywidualne zachowanie.
Aby sobie z tym poradzić, TeX przypisuje każdemu poleceniu dwie wartości i te dwie wartości są tym, co TeX rozumie jako „znaczenie” polecenia (jego rolę/ to, co robi) — te dwie wartości są wewnętrzne dla TeX-a, głęboko w oprogramowaniu, i stanowią część „wewnętrznego mechanizmu”, do którego użytkownicy nie mają dostępu. Każdemu poleceniu TeX, niezależnie od tego, czy jest wbudowanym prymitywem, czy poleceniem zdefiniowanym przez użytkownika, przypisuje się dwie wartości, które dla TeX-a definiują/klasyfikują jego zachowanie — to, co oznacza dla TeX-a. Gdy TeX używa swojego „dużego słownika” do wyszukania polecenia, znajdzie tam te dwie kluczowe informacje:
* **kodem polecenia**: pewnego rodzaju „ogólna klasyfikacja” wskazująca, jakiego „typu” jest to polecenie — na przykład polecenie „definicji makra” (jedno z `\def`, `\gdef`, `\edef`, `\xdef`); polecenie „tworzenia pudełek” (jedno z `\hbox`, `\vbox` lub `\vcenter`) i tak dalej dla setek poleceń obsługiwanych przez silniki TeX-a. Makra (polecenia zdefiniowane przez użytkownika) również otrzymują kod polecenia.
* **modyfikator polecenia**: Jest to informacja pomocnicza, która dostarcza TeX-owi szczegółowych informacji o poleceniu. Makra (polecenia zdefiniowane przez użytkownika) również otrzymują modyfikator polecenia — chociaż w przypadku makr modyfikator polecenia pełni nieco inną rolę niż w przypadku prymitywów (dla makr modyfikator polecenia wskazuje, gdzie definicja makra jest przechowywana w pamięci).
Razem kod polecenia i modyfikator polecenia jednoznacznie identyfikują każde polecenie. Oto kody poleceń i modyfikatory poleceń dla poleceń definiujących makra, jak są używane przez oryginalne oprogramowanie TeX Knutha — zauważ, że inne silniki TeX-a mogą używać innych wartości, ale stosują dokładnie tę samą zasadę:
| | | |
| ------------- | --------------------------------------------------------- | ----------------------------------------------------------------- |
| **Polecenie** | Polecenie
kod
| Polecenie
modyfikator
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Podsumowanie: nadanie sensu wszystkim tym zmiennym/wartościom
Na tym etapie jesteśmy zalani mnóstwem informacji o wartościach, zmiennych, wartościach poleceń i różnego rodzaju szczegółach — łatwo może to stać się mylące, więc uporządkujmy to, co wiemy. Gdy TeX odczytuje coś z twojego wejścia, jest to albo znak, albo polecenie. Za każdym razem, gdy TeX odczytuje coś z wejścia, musi zapisać informacje o tym, co właśnie odczytał (zeskanował):
* Dla **znaki**: musi zapisać kod znaku i kod kategorii. Musi też utworzyć i zapisać wartość tokenu, którą TeX oblicza przy użyciu tych wartości.
* Dla **polecenia**: TeX musi znać równoważnik liczbowy, **curcs**, który obliczył z nazwy polecenia. Może też potrzebować zapisać „znaczenie”, które pobrał, wyszukując polecenie w „słowniku” TeX-a: kod polecenia i modyfikator polecenia. Ponadto TeX będzie musiał też obliczyć wartość tokenu reprezentującą to polecenie.
Tak, to mylące: krąży tu mnóstwo zmiennych i pomysłów na tokeny, więc spróbujmy to uporządkować.
Wewnątrz TeX używa czterech globalnych zmiennych do przechowywania informacji o najnowszym elemencie, który TeX odczytał (lub nad którym aktualnie „pracuje”) — nie będziemy omawiać tych zmiennych bardzo szczegółowo, ale świadomość ich istnienia pomaga dać nieco więcej tła do zrozumienia, co naprawdę się dzieje:
* **curcmd**: (bieżące polecenie) zmienna całkowita. Służy do przechowywania *bieżącego polecenia* wartości dla polecenia, które jest przetwarzane *lub* przechowuje bieżący *kodem kategorii* znak przetwarzanego znaku;
* **curchr**: (bieżący znak) zmienna całkowita, ale to, co przechowuje, zależy od tego, co TeX właśnie odczytał ze swojego wejścia:
* **znaku**: Jeśli ostatnio odczytanym elementem jest znak, **curchr** przechowuje bieżący *kod znaku*.
* **polecenie**: Jeśli ostatnio odczytanym elementem jest polecenie, **curchr** przechowuje *modyfikator polecenia*: dodatkowe informacje, których TeX używa do wspierania/wyjaśniania **curcmd**—ponieważ, jak widzieliśmy powyżej, niektóre polecenia mają tę samą wartość **curcmd**
* **curcs**: (bieżąca sekwencja sterująca) zmienna całkowita, która przechowuje wartość obliczoną z ciągu znaków w nazwie polecenia. **curcs** = 0, jeśli ostatnio odczytanym elementem był pojedynczy znak, a nie nazwa sekwencji sterującej (nazwa polecenia);
* **curtok**: (bieżący token) zmienna całkowita przechowująca wartość bieżącego tokenu — którym jest albo token polecenia, albo token znaku.
Poniżej przedstawiono powyższe informacje w formie tabeli:
| | | |
| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Zmienna globalna używana wewnątrz TeX-a:** | **Gdy TeX skanuje znak:** | **Gdy TeX skanuje polecenie:** |
| **curcmd** | Przechowuje kod kategorii bieżącego znaku | Przechowuje *kodem polecenia*—który identyfikuje „typ” bieżącego polecenia |
| **curchr** | Przechowuje kod znaku bieżącego znaku | Przechowuje dane uzupełniające (zwane *modyfikator polecenia*) które dostarczają dodatkowych informacji o bieżącym poleceniu |
| **curcs** | 0 | Dodatnia liczba całkowita różna od zera, obliczana (za pomocą funkcji skrótu) na podstawie ciągu znaków znajdującego się w nazwie polecenia. Służy do uzyskania dostępu do „słownika” TeX-a w celu wyszukania bieżącego znaczenia polecenia — aby pobrać jego kod polecenia i modyfikator polecenia. |
| **curtok** | W przypadku 8-bitowych silników TeX-a, *tokenem znaku* jest obliczany według wzoru: $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ gdzie $$\text{curcmd}$$ to kod kategorii znaku, a $$\text{curchr}$$ to kod znaku | W przypadku 8-bitowych silników TeX-a, *tokenem polecenia* jest obliczany według wzoru: $$\text{curtok}=4095 + \text{curcs}$$ |
### Dalsze uwagi na temat bieżącego tokenu
Dla znaków maksymalna możliwa wartość tokenu uzyskiwana jest przy użyciu największego kodu kategorii (15) oraz największego kodu znaku, który w 8-bitowych silnikach TeX-a wynosi 255. Teoretycznie (dla 8-bitowych silników TeX-a) maksymalna wartość tokenu znaku, $$\text{curtok}\_{\text{max}}$$, wynosi:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Zaznaczamy „teoretycznie”, ponieważ kod kategorii 15 służy do reprezentowania „nieprawidłowego znaku”, który powoduje wygenerowanie przez TeX błędu: nieprawidłowy znak nigdy nie przejdzie przez proces skanowania wejścia TeX-a, a więc nigdy nie stanie się tokenem znaku.
W przypadku poleceń bieżący token ($$\text{curtok}$$) jest obliczany z $$\text{curtok}=4095 + \text{curcs}$$ ale dla poleceń $$\text{curcs}$$ to *zawsze* jest niezerowy, więc TeX może łatwo ustalić, co reprezentuje token:
* Jeśli $$\text{curtok} > 4095$$ wtedy jest to token polecenia;
* Jeśli $$\text{curtok} < 4095$$ jest to token znaku.
W praktyce TeX używa tokenów, prostych wartości całkowitych, aby „opakować” wszystkie informacje, które musi znać o elemencie odczytanym z wejścia.
## Część 4
W Części 4 przyjrzymy się szeregowi przykładowych makr, aby pokazać rolę i przeznaczenie `` sekcji jako „szablonu tokenów”, który można zbudować przy użyciu tokenów ograniczających.
[Część 1](/latex/pl/wiecej-tematow/19-how-tex-macros-actually-work-part-1.md) [Część 2](/latex/pl/wiecej-tematow/20-how-tex-macros-actually-work-part-2.md) [Część 3](/latex/pl/wiecej-tematow/21-how-tex-macros-actually-work-part-3.md) [Część 4](/latex/pl/wiecej-tematow/22-how-tex-macros-actually-work-part-4.md) [Część 5](/latex/pl/wiecej-tematow/23-how-tex-macros-actually-work-part-5.md) [Część 6](/latex/pl/wiecej-tematow/24-how-tex-macros-actually-work-part-6.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/pl/wiecej-tematow/21-how-tex-macros-actually-work-part-3.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.