> 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/de/weitere-themen/21-how-tex-macros-actually-work-part-3.md).
# Wie TeX-Makros eigentlich funktionieren: Teil 3
[Teil 1](/latex/de/weitere-themen/19-how-tex-macros-actually-work-part-1.md) [Teil 2](/latex/de/weitere-themen/20-how-tex-macros-actually-work-part-2.md) [Teil 3](/latex/de/weitere-themen/21-how-tex-macros-actually-work-part-3.md) [Teil 4](/latex/de/weitere-themen/22-how-tex-macros-actually-work-part-4.md) [Teil 5](/latex/de/weitere-themen/23-how-tex-macros-actually-work-part-5.md) [Teil 6](/latex/de/weitere-themen/24-how-tex-macros-actually-work-part-6.md)
## Zeit zum Innehalten!
Bevor wir mit dem nächsten Teil dieser Geschichte weitermachen, brauchen wir eine kurze Zusammenfassung: uns in Erinnerung rufen, wohin wir gehen, und unsere Gedanken ordnen, um sicherzustellen, dass alle wichtigen Ideen vorhanden sind. Nur zur Erinnerung: Unser durchgerechnetes Beispiel basiert auf der Annahme, dass TeX eine Textzeile gelesen hat, die `Hello World \jobname` und dass TeX dies setzt, um einen Absatz zu bilden.
### Das letztendliche Ziel
Unser Ziel ist es, ein besseres (tieferes) Verständnis für die Natur von TeX-Makros und ihre Funktionsweise zu entwickeln. Um dorthin zu gelangen, müssen wir jedoch zunächst verstehen, wie TeX eine Eingabedatei liest und die darin enthaltenen Zeichen verarbeitet. Hier ist eine Zusammenfassung der bisher behandelten Themen.
* TeX liest (scannt) jedes Zeichen in Ihrer Eingabe und hat für jedes Zeichen zwei Informationen:
* **Zeichencode**: eine ganze Zahl, die verwendet wird, um dieses Zeichen zu identifizieren, z. B. wenn es in einer .tex-Eingabedatei gespeichert ist;
* **Kategoriencode**: eine weitere ganze Zahl, intern für TeX, die es verwendet, um jedem aus der Eingabe gelesenen Zeichen eine Bedeutung zuzuweisen.
* Sobald ein Zeichen von TeX eingelesen wurde, wird der Kategoriecode jedes Zeichens *dauerhaft* diesem einzelnen Zeichen durch die Erstellung eines Zeichentokens zugeordnet:
* TeX verwendet eine einfache Formel, um einen Zeichencode und den entsprechenden Kategoriecode zu einer ganzen Zahl zusammenzufassen, die als Zeichentoken bezeichnet wird.
* Sie können die Bedeutung jedes Zeichens ändern, das TeX *noch nicht eingelesen hat* indem Sie jedem Zeichen, dessen Verhalten Sie ändern möchten, einen anderen Kategoriecode zuweisen – d. h. die Art und Weise ändern, wie TeX dieses Zeichen behandelt.
* Das Neudefinieren (Neuzuordnen) von Kategoriecodes erfolgt mit TeXs primitivem `\catcode` Befehl zu interpretieren ist.
* Wenn TeX einen Kategoriecode von 0 sieht, wechselt es in einen speziellen Scanmodus und beginnt, nach einem Befehl zu suchen: entweder nach einem (möglicherweise) mehrbuchstabigen *Kontrollwort* oder einem einzeichenigen *Kontrollsymbol*.
Bisher haben wir TeXs Eingabescanning-Prozess betrachtet, wenn er einzelne Zeichen identifiziert und den Kategoriecode jedes Zeichens verwendet, um herauszufinden, was als Nächstes zu tun ist. Manche Zeichen sind einfach gewöhnliche Textbestandteile für den Schriftsatz (z. B. Kategoriecode 11), aber wir haben auch Leerzeichen (Kategoriecode 10) und Escape-Zeichen (Kategoriecode 0) gesehen. Es gibt noch andere Kategoriecodes, die wir der Kürze halber nicht betrachtet haben – etwa Kategoriecode 1 („Gruppenanfang“, z. B., `{`), Kategoriecode 2 („Gruppenende“, z. B., `}`) und andere. Jeder Kategoriecode spielt seine eigene Rolle beim Eingabescanning von TeX und bei der anschließenden Verarbeitung durch die Softwareprozesse/Algorithmen innerhalb von TeX.
### Token: eine kurze Wiederholung
Das Konzept der „Token“ ist zentral für die Arbeitsweise von TeX: In TeX-bezogenen Büchern, Artikeln und Online-Communities werden Sie überall auf „Token“ stoßen oder darauf verwiesen werden, daher lohnt es sich, dieses Thema kurz zu wiederholen – mehr dazu finden Sie in einem zuvor veröffentlichten Artikel [Was ist ein „TeX-Token“?](/latex/de/ausfuhrliche-artikel/53-what-is-a-tex-token.md)
Wir haben bereits gesehen, dass TeX Eingabezeichen in Tokens umwandelt, indem es den Zeichencode und den Kategoriecode zu einer einzigen zusammengesetzten ganzen Zahl kombiniert. Bei Befehlen macht TeX etwas Ähnliches: Unter Verwendung des Befehlsnamens berechnet es eine ganze Zahl, die als ein *Befehlstoken* bezeichnet wird (wir werden dies noch genauer untersuchen). Als Orientierung können Sie sich Tokens als TeXs Methode vorstellen, die aus der Eingabe gelesenen Elemente zu „verpacken“ und sie so für den nächsten Verarbeitungsschritt von TeX bereitzustellen. Dass alle Elemente (Zeichen oder Befehle) ordentlich in einer einzigen numerischen Darstellung zusammengefasst sind, erleichtert die weitere Verarbeitung in der Kette. Wenn TeX beispielsweise etwas von Ihrer Eingabe speichern möchte, um es später zu verwenden, etwa eine Makrodefinition, muss TeX Ihre Makrodefinition – so komplex sie auch sein mag – einfach als eine Folge von ganzen Zahlen speichern, wobei jede ganze Zahl ein Token darstellt, das ein Zeichen oder einen Befehl repräsentiert, der Teil der Definition Ihres Makros ist (in ihr enthalten ist).
## Also, was kommt als Nächstes?
Im letzten Abschnitt von Teil 2 haben wir gesehen, wie ein Escape-Zeichen (Kategoriecode 0) TeX in einen speziellen Verarbeitungsmodus versetzt, in dem es nach dem Namen eines Befehls sucht. In unserem Beispiel erkannte TeX die Zeichenfolge `jobname` und wir haben Teil 2 an dem Punkt beendet, an dem TeX mit dieser Zeichenfolge (dem Namen eines Befehls) „etwas tun“ wollte. In diesem Teil werden wir im Detail betrachten, was TeX als Nächstes tut.
Sobald TeX erkannt hat, dass eine bestimmte Zeichenfolge in Ihrer Eingabedatei den Namen eines Befehls darstellt (hier, `jobname`) könnte TeX, je nachdem, was es gerade tut, diesen Befehl ausführen müssen. Wir sagen „könnte ausführen müssen“, weil es Situationen gibt, in denen TeX einen Befehl nicht sofort ausführen wird: zum Beispiel, wenn es ein Makro definiert (TeX baut Tokenlisten auf) – Themen, die wir später besprechen werden. Wir folgen jedoch weiterhin unserem Beispiel, in dem TeX einen Absatz setzt und *würde*, in dieser Situation, `\jobname`.
### Von einer Zeichenfolge zur Ausführung eines Befehls: wie?
Zunächst wollen wir Grafik 5b aus Teil 2 noch einmal betrachten, in der TeX erkannt hat, dass eine bestimmte Zeichenfolge innerhalb der Eingabe den Namen eines Befehls darstellt: `jobname`. Grafik 5b zeigt, dass TeX „interne Tabellen überprüfen...“ muss. Was bedeutet das *eigentlich*?
Eine weitere, detailliertere Beschreibung davon, wie TeX „interne Tabellen überprüft“, um von einer Zeichenfolge (z. B., `jobname`) dazu überzugehen, genau herauszufinden, was der Befehl ist und was er bedeutet, finden Sie in einem früheren Artikel [Was ist ein „TeX-Token“?](/latex/de/ausfuhrliche-artikel/53-what-is-a-tex-token.md) Hier fassen wir die wichtigsten Ideen zusammen und versuchen dabei, übermäßige Wiederholungen zu vermeiden.
Beginnen wir mit einer Analogie. Stellen Sie sich vor, Sie lesen ein Buch und stoßen auf ein unbekanntes Wort: Was tun Sie? Heute ist es fast sicher, „Google zu bemühen“, aber nehmen wir an, Sie bevorzugen eine ältere Methode: Sie greifen zu einem Wörterbuch, das Wörter auflistet und ihre Bedeutung(en) angibt. TeX hat einen analogen Mechanismus: ein internes „Wörterbuch“, das alle TeX derzeit bekannten Befehle – und die „Bedeutung“ dieser Befehle – auflistet. Mit „Bedeutung“ meinen wir: Um welche Art von Befehl handelt es sich, was tut er, plus alle weiteren Informationen, die TeX eventuell benötigt, um diesen Befehl auszuführen. Beachten Sie auch, dass der Begriff „Befehl“ alle von Benutzern/TeX-Programmierern geschriebenen TeX/LaTeX-Makros sowie die [Hunderte eingebauter primitiver Befehle](/latex/de/weitere-themen/46-tex-primitives-listed-by-tex-engine.md).
Fahren wir mit unserer Wörterbuch-Analogie fort. Wenn wir als menschliche Leser die Bedeutung eines Wortes nachschlagen müssen, suchen wir im Wörterbuch anhand der alphabetischen Auflistung der Wörter – aber natürlich funktioniert TeX nicht ganz so. Zurück zu unserem ursprünglichen `jobname` Beispiel: Wie findet TeX in seinem „Wörterbuch“ die „Bedeutung“ von `jobname`– und was liefert diese „Bedeutung“ TeX eigentlich?
Anstatt eine interne „alphabetische Auflistung“ aller TeX bekannten Befehle bereitzustellen, macht TeX etwas etwas anders. TeX wandelt die gesamte Zeichenfolge – die im Namen eines Befehls vorhanden ist – in eine einzige ganze Zahl um, die zur Identifizierung (Repräsentation) dieses Befehls verwendet wird. Intern pflegt TeX ein großes „Wörterbuch“ aller bekannten Befehle, in das es die *ganzen Zahlen* speichert, die aus Befehlsnamen berechnet werden – beachten Sie, dass dieses Wörterbuch nicht die eigentlichen Befehlsnamen selbst als Zeichenfolgen speichert (genannt *Strings*). TeX verwendet dieses Wörterbuch für alle seine eingebauten Befehle (Primitiven) *und* und es wird es auch verwenden, um Details jedes von Benutzern erstellten Makros (Befehls) zu speichern: Der Name Ihres Makros wird in eine ganze Zahl umgewandelt, und diese ganze Zahl wird in TeXs „Wörterbuch“ „registriert“.
Jedes Mal, wenn TeX in Ihrer Eingabe einen verwendeten Befehl erkennt und etwas über diesen Befehl wissen muss, wandelt es die Zeichenfolge im Befehlsnamen in eine „äquivalente“ ganze Zahl um und verwendet diese ganze Zahl, um den Befehl in seinem „großen Wörterbuch“ nachzuschlagen. Programmierer unter Ihnen werden vielleicht wissen wollen, dass TeX dazu eine Form von [Hash-Funktion](https://en.wikipedia.org/wiki/Hash_function) verwendet.
### Grafik 6: Von Zeichen zur Befehlsbedeutung
Die folgende Grafik zeigt den Weg, den ein Befehl durchläuft, wenn TeX die Zeichenfolge in eine äquivalente ganze Zahl umwandelt, die **curcs**genannt wird, und diese ganze Zahl verwendet, um die Bedeutung des Befehls in TeXs „großem Wörterbuch“ nachzuschlagen. Das Ergebnis dieses Nachschlagens sind zwei Informationen: zwei ganze Zahlen, genannt **curcmd** und **curchr**, die TeX verwenden kann, um genau herauszufinden, was der Befehl tut und wie er anschließend auszuführen ist.
Intern verwaltet TeX eine Variable namens **curcs** (**cur**rent **c**ontrol **s**equence), die dazu verwendet wird, den ganzzahligen Wert des Befehls zu speichern, an dem TeX gerade arbeitet – d. h., **curcs** speichert die aus dem Namen des Befehls berechnete ganze Zahl. Das ist noch nicht die ganze Geschichte, denn es gibt noch ein weiteres Detail: Wenn TeX gerade ein Zeichen und nicht einen Befehl gelesen/verarbeitet hat, setzt es **curcs** auf den Wert 0, um sich daran zu erinnern, dass das zuletzt Eingelesene ein Zeichen und kein Befehl war.
### Was Befehle für TeX bedeuten
Wenn wir uns die Menge der [von TeX-Engines bereitgestellten eingebauten Befehle](/latex/de/weitere-themen/46-tex-primitives-listed-by-tex-engine.md) ansehen, erkennen wir, dass einige dieser Befehle eng miteinander verwandt sind: Sie erfüllen ähnliche Aufgaben; beispielsweise gibt es 4 Primitive, die alle TeX-Engines verwenden, um Makros zu definieren (zu erstellen): `\def`, `\gdef`, `\edef`, `\xdef`. Diese 4 Befehle definieren alle Makros, aber natürlich tut jeder dies etwas anders. Wenn wir das aus programmiertechnischer Sicht betrachten: Hier haben wir 4 Makrodefinitionsbefehle, die im Großen und Ganzen dasselbe tun, aber wir müssen zwischen ihnen auswählen, um ihrem jeweiligen Verhalten gerecht zu werden.
Um damit umzugehen, weist TeX jedem Befehl zwei Werte zu, und genau diese beiden Werte versteht TeX als die „Bedeutung“ eines Befehls (seine Rolle/was er tut) – diese beiden Werte sind intern in TeX verankert, tief im Inneren der Software, und Teil des „inneren Mechanismus“, auf den Benutzer keinen Zugriff haben. Jedem TeX-Befehl, ob eingebautes Primitive oder benutzerdefinierter Befehl, werden zwei Werte zugewiesen, die für TeX sein Verhalten definieren/klassifizieren – was er für TeX bedeutet. Wenn TeX mit seinem „großen Wörterbuch“ einen Befehl nachschlägt, findet es diese zwei entscheidenden Informationen:
* **Befehlscode**: eine Art „allgemeine Klassifikation“, die angibt, um welchen „Typ“ von Befehl es sich handelt – etwa einen Befehl zur „Makrodefinition“ (einer von `\def`, `\gdef`, `\edef`, `\xdef`); einen Befehl zum „Erzeugen von Boxen“ (einer von `\hbox`, `\vbox` oder `\vcenter`) und so weiter für die Hunderte von Befehlen, die TeX-Engines unterstützen. Makros (benutzerdefinierte Befehle) erhalten ebenfalls einen Befehlscode.
* **Befehlsmodifikator**: Dies sind zusätzliche Informationen, die TeX spezifische Angaben zu einem Befehl liefern. Makros (benutzerdefinierte Befehle) erhalten ebenfalls einen Befehlsmodifikator – allerdings spielt der Befehlsmodifikator bei Makros eine etwas andere Rolle als bei Primitiven (bei Makros gibt der Befehlsmodifikator an, wo die Makrodefinition im Speicher abgelegt ist).
Zusammengenommen identifizieren Befehlscode und Befehlsmodifikator jeden Befehl eindeutig. Hier sind die Befehlscodes und Befehlsmodifikatoren für die Makrodefinitionsbefehle, wie sie in Knuths ursprünglicher TeX-Software verwendet werden – beachten Sie, dass andere TeX-Engines andere Werte verwenden können, aber dem exakt gleichen Prinzip folgen:
| | | |
| ---------- | ------------------------------------------------------- | -------------------------------------------------------------- |
| **Befehl** | Befehl
Code
| Befehl
Modifikator
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Zusammenfassung: all diese Variablen/Werte verstehen
An diesem Punkt sind wir von einer Fülle an Informationen über Werte, Variablen, Befehlswerte und allerlei Details umgeben – das kann schnell verwirrend werden, also verschaffen wir uns einen Überblick über das, was wir wissen. Wenn TeX etwas aus Ihrer Eingabe liest, ist es entweder ein Zeichen oder ein Befehl. Wann immer TeX etwas aus der Eingabe liest, muss es Informationen darüber speichern, was es gerade gelesen (gescannt) hat:
* Für **Zeichen**: Es muss den Zeichencode und den Kategoriecode festhalten. Außerdem muss es den Tokenwert erzeugen und speichern, den TeX mithilfe dieser Werte berechnet.
* Für **Befehle**: TeX muss das numerische Äquivalent, **curcs**, kennen, das es aus dem Befehlsnamen berechnet hat. Möglicherweise muss es auch die „Bedeutung“ speichern, die es durch das Nachschlagen des Befehls in TeXs „Wörterbuch“ ermittelt hat: den Befehlscode und den Befehlsmodifikator. Darüber hinaus muss TeX auch einen Tokenwert berechnen, der diesen Befehl repräsentiert.
Ja, es ist verwirrend: viele Variablen und Token-Ideen schweben herum, also versuchen wir, das Ganze verständlich zu machen.
Intern verwendet TeX vier globale Variablen, um Informationen über das neueste Element zu speichern, das TeX eingelesen hat (oder an dem es gerade „arbeitet“) – wir werden diese Variablen nicht im Detail besprechen, aber ihre Existenz zu kennen, hilft dabei, etwas mehr Hintergrund zu liefern, um zu verstehen, was wirklich passiert:
* **curcmd**: (aktueller Befehl) eine Ganzzahlvariable. Sie wird verwendet, um den *aktuellen Befehl* Wert für den gerade verarbeiteten Befehl *oder* zu speichern; sie speichert den den aktuellen *Kategoriencode* des verarbeiteten Zeichens;
* **curchr**: (aktuelles Zeichen) eine Ganzzahlvariable, deren gespeicherter Wert jedoch davon abhängt, was TeX gerade aus seiner Eingabe gelesen hat:
* **Zeichen**: Wenn das zuletzt eingelesene Element ein Zeichen ist, **curchr** speichert den aktuellen *Zeichencode*.
* **Befehl**: Wenn das zuletzt eingelesene Element ein Befehl ist, **curchr** speichert *Befehlsmodifikator*: zusätzliche Informationen, die TeX verwendet, um **curcmd**zu unterstützen/zu verdeutlichen – denn, wie wir oben gesehen haben, teilen manche Befehle denselben Wert von **curcmd**
* **curcs**: (aktuelle Kontrollsequenz) eine Ganzzahlvariable, die den aus der Zeichenfolge im Namen eines Befehls berechneten Wert speichert. **curcs** = 0, wenn das zuletzt gelesene Element ein einzelnes Zeichen und nicht der Name einer Kontrollsequenz (eines Befehlsnamens) war;
* **curtok**: (aktuelles Token) eine Ganzzahlvariable, die den Wert des aktuellen Tokens speichert – also entweder eines Befehlstokens oder eines Zeichentokens.
Hier sind die obigen Informationen in einer Tabelle dargestellt:
| | | |
| ----------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Globale Variable, die innerhalb von TeX verwendet wird:** | **Wenn TeX ein Zeichen scannt:** | **Wenn TeX einen Befehl scannt:** |
| **curcmd** | Speichert den Kategoriecode des aktuellen Zeichens | Speichert den *Befehlscode*– der den „Typ“ des aktuellen Befehls bestimmt |
| **curchr** | Speichert den Zeichencode des aktuellen Zeichens | Speichert Zusatzdaten (genannt der *Befehlsmodifikator*), die zusätzliche Informationen über den aktuellen Befehl liefern |
| **curcs** | 0 | Eine von Null verschiedene positive ganze Zahl, die mithilfe einer Hash-Funktion aus der Zeichenfolge berechnet wird, die im Befehlsnamen vorhanden ist. Sie wird verwendet, um auf TeXs „Wörterbuch“ zuzugreifen und die aktuelle Bedeutung eines Befehls nachzuschlagen – also seinen Befehlscode und Befehlsmodifikator abzurufen. |
| **curtok** | Für 8-Bit-TeX-Engines wird ein *Zeichen-Token* mit der Formel berechnet: $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ wobei $$\text{curcmd}$$ ist der Kategoriecode des Zeichens und $$\text{curchr}$$ ist der Zeichencode | Für 8-Bit-TeX-Engines wird ein *Befehlstoken* mit der Formel berechnet: $$\text{curtok}=4095 + \text{curcs}$$ |
### Weitere Hinweise zum aktuellen Token
Bei Zeichen erhält man den maximal möglichen Tokenwert, wenn man den größten Kategoriecode (15) und den größten Zeichencode verwendet, der für 8-Bit-TeX-Engines 255 beträgt. Theoretisch (für 8-Bit-TeX-Engines) ist der maximale Zeichentokenwert, $$\text{curtok}\_{\text{max}}$$, also:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Wir sagen „theoretisch“, weil der Kategoriecode 15 dazu verwendet wird, ein „ungültiges Zeichen“ darzustellen, das TeX einen Fehler erzeugen lässt: Ein ungültiges Zeichen wird den Eingabescanning-Prozess von TeX nie passieren und kann daher niemals zu einem Zeichentoken werden.
Bei Befehlen wird das aktuelle Token ($$\text{curtok}$$) berechnet aus $$\text{curtok}=4095 + \text{curcs}$$ aber bei Befehlen ist $$\text{curcs}$$ ist *immer* nicht Null, sodass TeX leicht bestimmen kann, was ein Token darstellt:
* Wenn $$\text{curtok} > 4095$$ dann ist es ein Befehls-Token;
* Wenn $$\text{curtok} < 4095$$ ist es ein Zeichen-Token.
Im Effekt verwendet TeX Tokens, einen einfachen Ganzzahlwert, um alle Informationen zu „verpacken“, die es über ein aus der Eingabe gelesenes Element wissen muss.
## Teil 4
In Teil 4 untersuchen wir eine Reihe von Beispielmakros, um die Rolle und den Zweck von `` Abschnitts als eine „Token-Vorlage“ zu zeigen, die durch die Verwendung von Trennertokens konstruiert werden kann.
[Teil 1](/latex/de/weitere-themen/19-how-tex-macros-actually-work-part-1.md) [Teil 2](/latex/de/weitere-themen/20-how-tex-macros-actually-work-part-2.md) [Teil 3](/latex/de/weitere-themen/21-how-tex-macros-actually-work-part-3.md) [Teil 4](/latex/de/weitere-themen/22-how-tex-macros-actually-work-part-4.md) [Teil 5](/latex/de/weitere-themen/23-how-tex-macros-actually-work-part-5.md) [Teil 6](/latex/de/weitere-themen/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/de/weitere-themen/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.