> 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/ausfuhrliche-artikel/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Wie funktioniert \expandafter: Von den Grundprinzipien bis zur Erkundung des Quellcodes von TeX [Teil 1](/latex/de/ausfuhrliche-artikel/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Teil 2](/latex/de/ausfuhrliche-artikel/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Teil 3](/latex/de/ausfuhrliche-artikel/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Teil 4](/latex/de/ausfuhrliche-artikel/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Teil 5](/latex/de/ausfuhrliche-artikel/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Teil 6](/latex/de/ausfuhrliche-artikel/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Einführung Wir haben nun die Hintergrundthemen behandelt, die für eine vollständige Untersuchung von `\expandafter`: * die Grundlagen der TeX-Tokens und wie sie berechnet werden; * die Prinzipien hinter TeXs Expansionsprozess; * TeXs Verwendung/Erzeugung temporärer Tokenlisten während der Dokumentverarbeitung; * wie TeX mehrere Eingabequellen verwendet und „jongliert“ (einschließlich temporärer Tokenlisten). In diesem Artikel werden wir diese Themen/Konzepte zusammenführen, um die Mechanismen zu erklären, die TeXs `\expandafter` Befehl zugrunde liegen: kurz gesagt, wie er funktioniert. ## Und nun zu \expandafter Die Idee hinter `\expandafter` besteht darin, die Expansion eines Befehls (Tokens) zu erzwingen, bevor TeX dies normalerweise tun würde. Bei zwei Tokens, $$\mathrm{T\_1}$$ und $$\mathrm{T\_2}$$ die Wirkung von `\expandafter` $$\mathrm{T\_1T\_2}$$ führt dazu, dass TeX $$\mathrm{T\_1}\text{<}$$die Expansion von $$\mathrm{T\_2}\text{>}$$, wobei $$\text{<}\dots\text{>}$$ eine Tokenliste bezeichnet. TeX expandiert $$\mathrm{T\_2}$$ vorzeitig, sodass das Token $$\mathrm{T\_1}$$ (z. B. ein Primitive oder ein Makro) die aus der Expansion von $$\mathrm{T\_2}$$entstehenden Tokens sehen oder darauf reagieren kann. Wenn das Token $$\mathrm{T\_2}$$ ein nicht expandierbares Element wie ein nicht-aktives Zeichen oder (die meisten) Primitiven darstellt, bewirkt die Aktion von `\expandafter` keine Änderung: TeX würde weiterhin Tokens $$\mathrm{T\_1T\_2}$$ auf normale Weise verarbeiten. ### Einführung in die Verwendung von \expandafter Falls Sie `\expandafter`, hier ist ein Beispiel für die Verwendung mit dem Primitive `\uppercase{...}`. Angenommen, wir wollten den Namen unserer Haupt- `.tex` Eingabedatei in Großbuchstaben setzen. Wir kennen vielleicht die folgenden TeX-Primitive-Befehle: * `\uppercase`: verwandelt, wie der Name schon sagt, Zeichentokens in ihr Großbuchstaben-Äquivalent (sofern vorhanden); * `\jobname`: wie wir gesehen haben, expandiert zu dem Namen der Haupt- `.tex` -Datei verwendet werden. Angenommen, unsere TeX-Datei heißt `mycode.tex` würden wir vernünftigerweise erwarten `\uppercase{\jobname}` um zu setzen `MYCODE`. Aber nein, es setzt `mycode` in Kleinbuchstaben. Was ist „falsch“ gelaufen? Wenn wir die allgemeine Verwendung von `\uppercase` als ``` \uppercase{} ``` können wir sagen, dass `\uppercase` durchsucht `` und nur auf *Zeichentokens* die es in der ``: alle Nicht-Zeichen-Tokens werden *ignoriert* weil `\uppercase` Nicht-Zeichen-Tokens nicht „hineinschauen“ (sie nicht expandieren), um zu sehen, was sie enthalten oder darstellen. Da ein Token lediglich ein Ganzzahlwert ist, braucht `\uppercase` nur die Tokenliste zu durchsehen, um zu prüfen, ob der numerische Wert jedes Tokens in `` in den Bereich der Werte fällt, die ein Zeichentoken kennzeichnen. Übrigens, `\uppercase` wird auch *die Groß-/Kleinschreibung aktiver Zeichen ändern* um ein aktives Großbuchstabenzeichen zu erzeugen, das, weil es weiterhin aktiv ist, ebenfalls definiert sein muss; andernfalls erzeugt TeX einen Fehler: `Undefinierte Steuersequenz`, aber wir schweifen ab ... Zum Beispiel, selbst wenn wir ein Makro definieren, das nur Text ist ``` \def\foo{some lower-case text} ``` dann `\uppercase{\foo}` setzt weiterhin `etwas Kleinbuchstaben-Text` und nicht `TEXT IN GROSSBUCHSTABEN` wie wir hoffen würden, einfach weil die Aktion von `\uppercase` nicht versucht zu bestimmen, was `\foo` darstellt: Es sieht `\foo` als Befehls-Token und ignoriert es, wie es auch mit `\jobname`. ### Wie können wir das beheben? \expandafter zur Rettung Um eine Großbuchstabenversion des Dateinamens zu setzen, müssen wir `\uppercase{\jobname}` dadurch ändern, dass wir TeX zwingen, `\jobname` durch seine Expansion (eine Folge von Zeichentokens) *bevor* `\uppercase` zu wirken beginnt. Wieder einmal wird die Expansion verwendet, um das `\jobname` Token (den Befehl) zu entfernen und durch das Ergebnis seiner Expansion (eine Tokenliste mit Zeichentokens) zu ersetzen. Wenn wir also schreiben ``` \uppercase\expandafter{\jobname} ``` dann funktioniert es: `MYCODE` würde gesetzt werden. Was geschieht, ist, dass TeX zu verarbeiten beginnt `\uppercase` und sofort nach dem obligatorischen öffnenden geschweiften Klammerzeichen (`{`); TeX erkennt jedoch einen `\expandafter` Befehl, der dazu führt, dass es seine Aufmerksamkeit vorübergehend auf die Verarbeitung von `\expandafter{\jobname}`. Wenn wir `\expandafter` $$\mathrm{T\_1T\_2}$$ mit unserem Beispiel `\expandafter{\jobname}` vergleichen * $$\mathrm{T\_1} =\space$$`{`Token * $$\mathrm{T\_2} =\space$$`\jobname`Token Wobei `{`Token und `\jobname`Token sich auf die von TeX berechneten Tokenwerte beziehen — die Indexschreibweise Token dient dazu, uns daran zu erinnern, dass TeX in der Welt der ganzzahligen Tokens arbeitet. Das Schreiben von `\uppercase\expandafter{\jobname}` funktioniert, weil, grob gesagt (Einzelheiten folgen), `\expandafter` TeX dazu veranlasst, die folgenden Aufgaben auszuführen: 1. das öffnende ... lesen und speichern `{`Token; 2. das nächste Token lesen: `\jobname`Token. TeX erkennt, dass `\jobname`Token einen expandierbaren Befehl darstellt und ihn expandiert. `\jobname`Token wird durch seine Expansion ersetzt — eine Folge von Zeichentokens; 3. nachdem der `\jobname` Befehl expandiert hat, legt TeX das `{`$$\_\mathrm{token}$$ „zurück in die Eingabe“ und verwendet die Tokenliste, die aus der Expansion von `\jobname` sodass TeX `\uppercase{`Token``Tokenliste (Zeichen)`}`, und das erzeugt das gewünschte Ergebnis. Das folgende Diagramm zeigt, wie TeX verarbeitet `\uppercase\expandafter{\jobname}`—lesen Sie die Grafik von unten nach oben, um dem Prozessfluss zu folgen. ![Wie \expandafter funktioniert](/files/2ba8ab11630fb4f7d594898fe76bf7b3af54ebb3) Die folgenden Hinweise erklären die verschiedenen Verarbeitungsstufen. 1. TeX beginnt mit der Verarbeitung von `\uppercase` und prüft auf das obligatorische Zeichen der öffnenden geschweiften Klammer (`{`) erkennt jedoch einen `\expandafter` Befehl zu interpretieren ist. 2. Wenn wir `\expandafter` $$\mathrm{T\_1T\_2}$$ bei unserer Eingabe von `\expandafter{\jobname}` vergleichen $$\mathrm{T\_1} =$$`{`Token und $$\mathrm{T\_2} =$$`\jobname`Token. Beachten Sie, dass wir hier den Index Token verwenden, um anzuzeigen, dass TeX ganzzahlige Tokenwerte verarbeitet. 3. `\expandafter` liest und dann vorübergehend das `{`Token indem es diesen ganzzahligen Tokenwert in einer internen Variable speichert. Später wird TeX dieses Token wieder in die Eingabe einfügen, nachdem es das `\jobname` Befehl zu interpretieren ist. 4. `\expandafter` liest das nächste Token, `\jobname`Token, und expandiert das `\jobname` Befehl zu interpretieren ist. 5. Die Expansion von `\jobname` erstellt eine temporäre Tokenliste, die eine Folge von Zeichentokens enthält, die den `.tex` Dateinamen darstellen. Beachten Sie, dass alle von `\jobname` erzeugten Zeichentokens mit Kategoriecode 12 berechnet werden. 6. Sobald `\jobname` expandiert wurde, fügt TeX das in Schritt 3 gespeicherte Token (`{`Token) wieder ein und fügt es zurück in die Eingabe ein. TeX tut dies, indem es eine weitere Tokenliste erstellt, die das *einzelne* `{`Token 7. TeX hat nun die Verarbeitung von `\expandafter`, wodurch zwei Tokenlisten bereitstehen, die als Quellen für TeX-Eingaben verwendet werden können. TeX kehrt nun zur Verarbeitung von `\uppercase` zurück, hat seine Eingabe jedoch so konfiguriert, dass die zwei von `\expandafter` erstellten Tokenlisten zur Tokenquelle für `\uppercase`—das nun `\uppercase{`Token``Tokenliste (Zeichen)`}`. `\uppercase` nun eine Folge von Zeichentokens sieht und unser gewünschtes Ergebnis erzeugen kann. 8. Nachdem alle von `\jobname`erzeugten Zeichentokens gelesen wurden, kehrt TeX zur Tokengewinnung aus seiner vorherigen Eingabequelle (unserer `.tex` -Datei) zurück, von der aus es das nächste Token liest: die schließende `}` die erforderlich ist, um die Tokenliste zu beenden, die von `\uppercase`. ### \expandafter und interne Tokenlisten Temporäre Tokenlisten sind ein *wesentliches* Element der `\expandafter`-Verarbeitung: Das Verständnis der Verwendung und Existenz dieser Tokenlisten kann helfen zu klären, wie `\expandafter` seine Ergebnisse erzielt, insbesondere wenn man versucht, Makros zu schreiben oder zu verstehen, die mehrere aufeinanderfolgende `\expandafter` Befehle verwenden, um komplexere Formen der Tokenverarbeitung zu erreichen: `\expandafter\expandafter\expandafter...` Ein weiteres Schlüsselelement von `\expandafter`-Verhaltens, insbesondere bei mehreren aufeinanderfolgenden `\expandafter` Befehlen, ist die Verwendung von *Rekursion* (innerhalb der TeX-Software selbst) — ein Thema, das wir später in diesem Artikel behandeln werden. Um unser Verständnis temporärer Tokenlisten weiter zu vertiefen, schauen wir uns noch ein weiteres Beispiel für `\expandafter`, diesmal mit dem `\the` Befehl zu interpretieren ist. #### \expandafter und interne Tokenlisten: Beispiel 2 In diesem Beispiel sehen wir, wie `\expandafter` verwendet werden kann, um Tokens zu beeinflussen, die in einem Token-Register über den `\toks` Befehl gespeichert sind. Hier sind die TeX-Primitiven, die wir verwenden werden: * `**\count** *register*=*number*`: ein TeX-Primitive, das verwendet wird, um den Wert `*number*` an der TeX-Stelle `*register*`; * `**\toks** *register*={*token list*}`: ein TeX-Primitive, das verwendet wird, um `*token list*` in der Token-Register-Stelle zu speichern `*register*`—eine Folge von Tokens für spätere Verwendung zu speichern; * `**\the** *token*`: ein expandierbarer TeX-Primitive-Befehl, der `*token*`, obwohl die genauen Ergebnisse von der Art des `*token*` verarbeiteten Tokens abhängen. `\the` hat eine Reihe von Verwendungen: darunter das Setzen des in einem TeX-Parameter oder einer Variablen (z. B. einem Register) gespeicherten Werts. Weitere Verwendungen von `\the` umfassen das Einfügen einer Kopie von Tokens, die in einem Token-Register gespeichert sind. Hier verwenden wir `\the` um den in einem `\count` Register gespeicherten Wert zu setzen. Wir beginnen mit dem folgenden TeX-Code, um den Wert `12345` in TeXs `\count` Register `99`: ``` \count99=12345 ``` Wenn wir den in `\count99` gespeicherten Wert setzen wollen, können wir `\the\count99` (oder `\number\count99`). Als Nächstes verwenden wir den `\toks` Befehl, um einige Tokens im Token-Register `99`: ``` \toks99={\the\count99 } ``` Die in dem Token-Register gespeicherte Tokenliste `99` würde Folgendes enthalten: | | | | ----------------- | --------------------------------------------------------------------------------------------------------- | | **TeX-Tokenwert** | **Dargestelltes Element** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (Zeichencode 57 mit Kategoriecode 12), was zu einem Tokenwert von $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (Zeichencode 57 mit Kategoriecode 12), was zu einem Tokenwert von $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (Zeichencode 32 mit Kategoriecode 10), was zu einem Tokenwert von $$256 \times 10 + 32 = 2592$$ | Beachten Sie, dass die von `\toks99` nicht *nicht* den tatsächlich in `\count99` weil der `\toks` Befehl keine Expansion ausführt: Er erstellt einfach Tokens und speichert sie. In unserem Beispiel, `\the` wird nicht expandiert, daher verarbeitet es nicht `\count99`; hier wird `\the` nur in ein Token (Wert 5382) umgewandelt und in der Tokenliste gespeichert. Wenn wir wollen, dass die `\toks99` Tokenliste Tokens enthält, die die in `\count99` gespeicherten Daten darstellen, brauchen wir eine Möglichkeit, diese Tokens zu erzeugen (sie verfügbar zu machen), damit der `\toks` Befehl auf sie zugreifen kann. Und natürlich `\expandafter` kann das für uns tun. Wenn wir schreiben: ``` \toks99=\expandafter{\the\count99 } ``` die Aktion/Verarbeitung des `\toks` Befehls wird „angehalten“, während `\expandafter` die Expansion von `\the` bewirkt (erzwingt), `\count` um eine temporäre Tokenliste zu erzeugen, die Zeichentokens enthält, welche die in `\count99`darstellen. Ein kleiner, aber wichtiger Punkt ist das `` Zeichen nach den Ziffern `99`: Dieses `` Zeichen beendet TeXs Scanprozess, wenn es nach einer numerischen Größe sucht. Hier ist die Wirkung von `\expandafter` sehr ähnlich wie im `\jobname` Beispiel. 1. Lies und speichere das öffnende `{`Token. 2. Lies das nächste Token, `\the`Token, das einen expandierbaren Befehl darstellt, also expandiert TeX es. `\expandafter` erzwingt die Expansion von `\the` das dann auf `\count99` wirkt, um die in `\count` Register `99` (die Zahl 12345) gespeicherten Daten in eine temporäre Tokenliste zu konvertieren. Diese Liste enthält Zeichentokens, die die Ziffern `1`, `2`, `3`, `4` und `5`darstellen — Zeichentokens mit Kategoriecode 12. 3. Nachdem `\the`, fügt TeX das `{`Token „zurück in die Eingabe“ ein und verwendet die Tokenliste, die aus `\the\count99` sodass TeX `\toks99={`Token``Tokenliste (Zeichen)`}` und das erzeugt unser gewünschtes Ergebnis. Diese Abfolge von Ereignissen ist im folgenden Diagramm zusammengefasst — lesen Sie die Grafik von unten nach oben, um dem Ablauf zu folgen. ![Wie \expandafter funktioniert](/files/41bd6f01d58d14311fff69ba6a03d05d8fc256b0) 1. TeX beginnt mit der Verarbeitung von `\toks`; es sieht das optionale `=` Vorzeichen und prüft dann auf das obligatorische öffnende geschweifte Klammerzeichen (`{`, oder irgendein Zeichen mit Kategoriecode 1), das den Beginn einer Tokenliste kennzeichnet. TeX erkennt jedoch einen `\expandafter` Befehl und führt stattdessen diesen aus. 2. Wenn wir `\expandafter` $$\mathrm{T\_1T\_2}$$ bei unserer Eingabe von `\expandafter{\the\count99 }` vergleichen $$\mathrm{T\_1} =$$ `{`Token und $$\mathrm{T\_2} =$$ `\theToken`. 3. `\expandafter` liest und dann vorübergehend das `{`Token (TeX speichert diesen ganzzahligen Tokenwert vorübergehend in einer internen Variable). Später fügt TeX dieses Token wieder in die Eingabe ein, nachdem es `\the` 4. `\expandafter` liest das nächste Token, `\the`Token und es expandiert. 5. Die Expansion von `\the` erstellt aus der Verarbeitung von `\count99`—diese Tokenliste enthält eine Folge von Zeichentokens, die den in dem `\count` Register `99`. 6. Sobald `\the` expandiert wurde, fügt TeX das in Schritt 3 gespeicherte Token (`{`Token) und fügt dieses Token wieder in die Eingabe ein. TeX tut dies, indem es eine weitere Tokenliste erstellt, die das *einzelne* Token `{`Token. 7. TeX hat nun die Verarbeitung von `\expandafter` und zwei Tokenlisten erzeugt hat, die als nächste Eingabequellen verwendet werden können. TeX kehrt wieder zur Verarbeitung von `\toks99=` zurück, aber jetzt hat TeX seine Eingabe so konfiguriert, dass die beiden von `\expandafter` erstellten Tokenlisten zur Tokenquelle für `\toks`—das nun `{`Token``Tokenliste (Zeichen)`}`. `\toks` nun auf die Folge von 5 Zeichentokens zugreifen und sie speichern kann, die den Datenwert (`12345`) darstellen, der in `\count99`: unser gewünschtes Ergebnis. 8. Nachdem alle von `\the\count99`erzeugten Zeichentokens gelesen wurden, kehrt TeX zur Tokengewinnung aus seiner vorherigen Eingabequelle (unserer `.tex` -Datei) zurück, von der aus es das nächste Token liest: die schließende `}` erforderlich ist, um die Tokenliste zu beenden, die von `\toks99={...}`. ## Wie \expandafter wirklich funktioniert In diesem Abschnitt werfen wir einen „Low-Level“-Blick in TeX selbst: Wir untersuchen den Quellcode/die Funktionen in TeX, die das Verhalten von `\expandafter`. Die Details sind in Pseudocode-C ausgedrückt, sollten aber für jeden, der mit anderen Programmiersprachen vertraut ist, verständlich sein. Das folgende kommentierte Diagramm erklärt, wie TeX `\expandafter` als Teil einer größeren Funktion namens `expand()`—die Kernfunktion, die TeXs Expansionsverarbeitung steuert. Innerhalb des Abschnitts, der für die Implementierung von `\expandafter` vergleichen [*rekursivem* Verhalten](https://en.wikipedia.org/wiki/Recursion) bei dem ein weiterer Aufruf der `expand()` Funktion verwendet wird, um das zweite eingelesene Token zu verarbeiten, $$\mathrm{T\_2}$$, für diejenigen Fälle, in denen $$\mathrm{T\_2}$$ expandierbar ist. Obwohl dieser Code in Knuths TeX-Engine erscheint, sind die in dieser Grafik dargestellten grundlegenden Prinzipien auf alle TeX-Engines anwendbar. ![Wie \expandafter in TeX funktioniert](/files/937a775383dbf7038ea0cc6021bcd6b97695ef8e) Die erste Aufgabe von `expand()` besteht darin festzustellen, ob der zu expandierende Befehl ein Makro oder ein Primitive ist, da Makros einen spezialisierten Expansionsprozess haben, der von einer Funktion namens `macrocall()`. Wenn der zu expandierende Befehl ein Primitive ist, verwendet die `expand()` Funktion den aktuellen Befehlscodewert (gespeichert in der globalen Variable `curcmd`) um zu bestimmen, welches konkrete Primitive verarbeitet werden muss. Diese Details sehen wir in einer vollständigeren Auflistung von `expand()`: ``` void expand(void) { //curcmd is a global variable if(curcmd != macro) // curcmd < 111 { switch(curcmd) { Fall \expandafter: // Verarbeite den \expandafter T1T2 Befehl { gettoken(); // Lese Token T1 t = curtok; // Speichere Token T1 in der lokalen Variablen t gettoken(); // Lese Token T2 if(curcmd > 100) // Ist Token T2 erweiterbar? expand(); // Ja! T2 ist erweiterbar: // führe die Expansion von T2 durch, indem // ein rekursiver Funktionsaufruf an expand() gemacht wird else backinput(); // T2 ist nicht erweiterbar: lege dieses Token // zurück in die Eingabe, damit es später erneut gelesen wird curtok = t ; // Stelle die globale Variable curtok auf den gespeicherten Wert von T1 zurück backinput() ; // Lege Token T1 wieder in die Eingabe // vor die Tokens, die aus der Expansion von T2 entstehen } break; // Code zur Verarbeitung anderer erweiterbarer Befehle Fall „in Text umwandeln“-Befehl: // Einer von \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Sie haben denselben Wert von curcmd break; Fall \noexpand: // Unterdrücke die Expansion des nächsten Tokens ... break; Fall \csname: // Erzeuge einen Steuersequenznamen. ... break; Fall \the: // Füge einige Tokens ein .... break; Fall „\if... Testbefehl“: // Verarbeite eine von TeXs Konditionalen: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; Fall „\fi oder \else“: // Beende die aktuelle Bedingung ... break; // usw. für alle anderen erweiterbaren primitiven Befehle, die von // der TeX-Engine unterstützt werden } }else // Kein erweiterbares Primitiv: es ist ein Makro { macrocall() } // ... weiterer Code entfernt } ``` ### TeXs Vorliebe für globale Variablen Vielleicht als Spiegel seines Alters und der Epoche, in der es entworfen wurde, verwendet TeXs Quellcode umfangreich sogenannte [globale Variablen](https://en.wikipedia.org/wiki/Global_variable)—tatsächlich gibt es Hunderte davon. Aufgrund ihrer Natur können globale Variablen von überall innerhalb des TeX-Quellcodes geändert/modifiziert werden — der bei Knuths TeX eine einzige monolithische Datei mit über 25.000 Codezeilen und Hunderten von Funktionen ist. Zu verstehen, wie TeX funktioniert, ist nicht immer eine leichte Aufgabe... Um zu verarbeiten `\expandafter`, liest TeX Tokens aus seiner aktuellen Eingabe mithilfe einer Funktion namens `gettoken()` deren Aufgabe es ist, ein Token zu erzeugen und den Wert mehrerer wichtiger globaler Variablen festzulegen, die im gesamten TeX-Quellcode verwendet werden. Zwei solcher Variablen, die durch die Aktion von `gettoken()`, werden bei der Implementierung von `\expandafter`: * `curtok`: (aktuelles Token) der ganzzahlige Wert des soeben gelesenen Tokens; * `curcmd`: (aktueller Befehlscode) der Befehlscode des durch das Token dargestellten Befehls (oder Zeichens) `curtok`. Bei der Verarbeitung von `\expandafter`$$\mathrm{T\_1T\_2}$$ liest TeX Token $$\mathrm{T\_1}$$ und speichert seinen Wert vorübergehend (eine Ganzzahl) in einer lokalen Variablen namens `t`. Dann liest TeX $$\mathrm{T\_2}$$ und prüft, ob dieses Token einen erweiterbaren Befehl darstellt — indem geprüft wird, ob sein Befehlscode (`curcmd`) > 100 ist. Falls ja, muss TeX den durch $$\mathrm{T\_2}$$ und einen weiteren Aufruf der Funktion `expand()`: dies ist ein Beispiel für *Rekursion* weil der `expand()` Funktion ruft sich selbst auf. Das Bewusstsein für die rekursive Natur der Expansion, insbesondere bei der Verwendung von `\expandafter`, kann dabei helfen zu verstehen, wie mehrere aufeinanderfolgende `\expandafter` Befehle — d. h. `\expandafter\expandafter\expandafter...` ihre Wirkungen erzielen. Wenn Token $$\mathrm{T\_2}$$ erweiterbar ist, findet die Expansion statt, und wenn der rekursive Aufruf an `expand()` zurückkehrt, wird Code innerhalb der Implementierung von `\expandafter` Token $$\mathrm{T\_1}$$ wieder in die Eingabe. Die globale Variable `curtok` wird erneut dem Wert des gespeicherten Tokens zugewiesen — der in der lokalen Variablen `t`, gespeichert ist, was dem Wert von Token $$\mathrm{T\_1}$$— entspricht — und es wird ein Aufruf an die Funktion `backinput().` #### Die Funktion backinput() Wie der Name schon andeutet, legt diese Funktion ein Token „zurück in die Eingabe“. Dazu verwendet TeX den aktuellen Wert der globalen Variable `curtok` um eine Tokenliste zu erzeugen, die ein einziges Token enthält (dessen Ganzzahlwert von `curtok`bereitgestellt wird). TeX sorgt außerdem in seiner Eingabebehandlung dafür, dass diese Ein-Token-Liste zu gegebener Zeit von TeX im Rahmen seiner nachfolgenden Eingabeverarbeitung erneut gelesen wird. Beachte sorgfältig, dass das Token $$\mathrm{T\_1}$$ wieder eingefügt wird *nachdem die Expansion abgeschlossen ist*, was sicherstellt, dass TeX dieses wieder eingefügte Token liest *bevor* wenn es die Tokens liest, die aus der Expansion von $$\mathrm{T\_2}$$. ### Makros verarbeiten: die Funktion macrocall() Wie bereits besprochen, sind alle Makros zusammen mit einigen primitiven Befehlen erweiterbar, und die gesamte Expansionsverarbeitung läuft über die `expand()` Funktion. Allerdings `expand()` verwendet `curcmd` (aktueller Befehl)-Wert sorgfältig, um zwischen erweiterbaren Primitiven und Makros zu unterscheiden, da der Makro-Expansionsprozess von einer dedizierten Funktion namens `macrocall()`ausgeführt wird. Makros benötigen einen speziellen Expansionsprozess, da nach Makroargumenten und Trennertokens auf eine sehr bestimmte und strenge Weise gesucht werden muss; folglich wird dieser Prozess an eine dafür entworfene Funktion delegiert: `macrocall()`. #### Makro-Expansion vs. Makro-Ausführung Makro *Expansion* ist nicht derselbe Prozess wie die Makro- *Ausführung*: Die Expansion eines Makros ist der Vor-Ausführungsprozess, den TeX durchführt, um das Makro *für die Ausführung bereit zu machen*. Die „Ausführung“ eines Makros findet statt, wenn TeX aktiv Tokens liest und verarbeitet, die in der Definition dieses Makros (Ersetzungstext) und seinen Argumenten (Parametern) enthalten sind. #### Makro-Expansion Um ein Makro zu expandieren, prüft TeX zunächst, ob das Makro Argumente annimmt; falls ja, `macrocall()` sehr sorgfältig die Eingabe durchsucht, um nach Tokens zu suchen, die zu den Argumenten des Makros werden sollen. Dieser Prozess umfasst das Prüfen der Benutzereingabe auf alle Trennertokens, die in der ursprünglichen Definition des Makros verwendet wurden — das Muster der Tokens in einem Makroaufruf muss exakt dem Muster der Tokens in der gespeicherten Definition entsprechen. Tokens, die als Trennzeichen verwendet werden, werden von TeX jedoch einfach verworfen: Sie sind im Grunde nur eine Form von „Interpunktion“, die TeX verwendet, um die tatsächlichen Tokens zu bestimmen, die zu den Argumenten des Makros werden sollen — also Tokens, die der Benutzer zur Verarbeitung durch das Makro vorgesehen hat. Weitere Informationen zu Trennertokens finden Sie unter [Wie TeX-Makros tatsächlich funktionieren](/latex/de/weitere-themen/22-how-tex-macros-actually-work-part-4.md). Für jeden Parameter (`#1, #2...#9`) in der ursprünglichen Definition des Makros durchsucht TeX den tatsächlichen Makroaufruf, um zu ermitteln, welche vom Benutzer bereitgestellten Tokens für jeden Parameter bestimmt sind (d. h. die Argumente des Makros bilden). Dieser Prozess erzeugt eine oder mehrere kleine Tokenlisten: eine für jedes Makroargument. Nachdem alle Makroargumente erkannt und ihre Tokenlisten vorbereitet wurden, ruft TeX die in seinem Speicher gespeicherte Definition des Makros (Ersetzungstext) ab und richtet seine Eingabeverarbeitung so ein, dass TeX, sobald es bereit ist, weitere Tokens zu lesen/verarbeiten, diese aus dem Ersetzungstext des Makros liest und damit das Makro ausführt. Zum geeigneten Zeitpunkt während der Makroausführung werden Tokenlisten, die die Makroargumente darstellen, an die richtige Stelle innerhalb des Ersetzungstextes des Makros eingefügt. Auch hier bedeutet die Expansion eines Makrobefehls *das Entfernen* dieses Makrobefehls (Tokens) aus der Eingabe und *das Ersetzen* durch die als Ersetzungstext des Makros gespeicherte Tokenliste. Für einen tiefgehenden Blick auf TeXs Makroverarbeitung siehe die sechsteilige Artikelserie [Wie funktionieren TeX-Makros eigentlich?](/latex/de/weitere-themen/01-a-six-part-series-how-do-tex-macros-actually-work.md) [Teil 1](/latex/de/ausfuhrliche-artikel/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Teil 2](/latex/de/ausfuhrliche-artikel/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Teil 3](/latex/de/ausfuhrliche-artikel/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Teil 4](/latex/de/ausfuhrliche-artikel/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Teil 5](/latex/de/ausfuhrliche-artikel/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Teil 6](/latex/de/ausfuhrliche-artikel/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/de/ausfuhrliche-artikel/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.