> 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/17-how-does-expandafter-work-a-detailed-macro-case-study.md).
# Wie funktioniert \expandafter: Eine detaillierte Fallstudie zu Makros
[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)
## Fallstudie: \expandafter-Beispiel aus The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Handbuch
Das $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Satz-Engine wurde aus Knuths TeX-Software abgeleitet und ursprünglich als „Zwischenschritt“ auf dem Weg zur Entwicklung des [Neuen Satzsystems](https://en.wikipedia.org/wiki/New_Typesetting_System) (NTS), geschrieben in der Programmiersprache Java. $$\varepsilon\mathrm{\text{-}{\TeX}}$$ wurde Ende der 1990er Jahre erstmals entwickelt, um eine Reihe neuer primitiver Befehle hinzuzufügen, die zusätzliche Funktionalität bereitstellen, die im ursprünglichen Programm von Knuth nicht verfügbar ist. Obwohl $$\varepsilon\mathrm{\text{-}{\TeX}}$$ es seit seiner ersten Veröffentlichung regelmäßig aktualisiert wurde, wird es heute nicht weithin als eigenständige Satz-Engine verwendet, obwohl seine Neuerungen in spätere Generationen von TeX eingeflossen sind: pdfTeX, XeTeX und LuaTeX.
Das [$$\varepsilon\mathrm{\text{-}{\TeX}}$$ Handbuch](http://mirror.ox.ac.uk/sites/ctan.org/systems/doc/etex/etex_man.pdf) enthält ein erhellendes Beispiel für ein Makro, das geschickt `\expandafter`:
```
\def\foo#1#2{\number#1
\ifnum#1<#2,
\expandafter\foo
\expandafter{\number\numexpr#1+1\expandafter}%
\expandafter{\number#2\expandafter}%
\fi}
```
`\foo` implementiert einen Schleifenmechanismus, so dass `\foo{7}{13}` ergibt `7, 8, 9, 10, 11, 12, 13`; allerdings, `\foo` verwendet keine *Zuweisungen an Variablen* um den Schleifenablauf zu steuern – was es zu einem interessanten Makro macht, das man im Detail untersuchen kann.
### Ein wenig Hintergrund: Ausdrücke und Zuweisungen
Ein wichtiges Element von `\foo`s Code ist seine Verwendung des Befehls `\numexpr`eines Satzes von vier verwandten Primitiven, die erstmals eingeführt wurden von $$\varepsilon\mathrm{\text{-}{\TeX}}$$: `\numexpr`, `\dimexpr`, `\glueexpr` und `\muexpr`. Ihr Zweck ist es, sogenannte *Ausdrücke* Wie auf den Seiten 8–9 von The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Manual, ein wichtiges Merkmal von *Ausdrücke* ist, dass ihre Auswertung (Berechnung) nicht erfordert, dass TeX irgendwelche *Zuweisungen*.
In Programmierbegriffen ist eine Zuweisung der Prozess, einer Variablen einen bestimmten Wert zuzuweisen; zum Beispiel durch Zuweisung von `\count` Register `99` den Wert zu enthalten `12345` über `\count99=12345`. Viele andere Arten von Zuweisungen finden während der TeX-Verarbeitung statt – etwa das Zuweisen von Token-Registern, um eine Folge von Tokens zu enthalten, das Zuweisen von Box-Registern, um Boxinhalt zu enthalten, und so weiter.
Um eine Zuweisung wie `\count99=12345`auszuführen, muss TeX den internen Code ausführen, der das Verhalten von `\count` oder eines anderen Primitivs implementiert, das irgendeine Art von Zuweisung ausführt. Es gibt jedoch Zeiten, in denen TeX reine *Expansion* ausführt, und zu diesen Zeiten werden solche Zuweisungen nicht ausgeführt –*zu diesem Zeitpunkt in der TeX-Verarbeitung*. Beispiele für diese Situation sind die folgenden Befehle:
* `\edef\command {*token list*}` der Makrodefinitionsbefehl „erweiterte Definition“, der Tokens in *Token-Liste* und speichert die Ergebnisse als die Definition von `\command`.
* `\write *number* {*token list*}` erweitert Tokens in `*token list*` und schreibt sie in eine Datei, dargestellt durch `*number*`.
* `\directlua {*token list*}` dieser LuaTeX-Primitive-Befehl wird verwendet, um Lua-Code an den eingebauten Lua-Interpreter zu übergeben. Alle Tokens in `*token list*` werden vollständig erweitert, bevor sie zur Ausführung an den Lua-Interpreter übergeben werden.
#### Kurzes Beispiel für \edef
Wenn wir die folgenden grundlegenden Makros schreiben:
```
\def\mycount{\count99=12345}
\edef\mymacro{\mycount}
```
`\edef` wird `\mycount` in seine Bestandstokens expandieren, aber es geht nicht weiter: keine der Befehle, die in der Definition von `\mymacro` wird ausgeführt: d. h. die Zuweisung von `12345` auf `\count99` *geschieht an diesem Punkt nicht*; erst wenn wir `\mymacro` aufrufen, findet diese Zuweisung statt, während TeX den Code zur Verarbeitung des `\count` Primitivs ausführt. Wenn TeX *nur Expansionsvorgänge* ausführt, werden etwaige Zuweisungen erst später in der TeX-Verarbeitung ausgeführt, nicht während des Expansionsprozesses selbst.
#### Warum sind Zuweisungen hier von Interesse?
Wenn man Code schreibt, der eine Schleife ausführt – in jeder Programmiersprache –, ist es üblich, eine Variable als „Schleifenzähler“ vorzusehen: Sie dient dazu, die Anzahl der Ausführungen der Schleife zu steuern. Das Durchlaufen einer Schleife wird typischerweise dadurch gesteuert, dass geprüft wird, ob diese vorgesehene Schleifenzähler-Variable einen bestimmten Wert erreicht hat – diese Variable wird bei jeder Iteration der Schleife inkrementiert (oder dekrementiert). Das Ändern einer Schleifenzähler-Variable bedeutet jedoch, ihr einen neuen Wert zuzuweisen, was in TeX gewöhnlich den primitiven Befehl `\advance` erfordert, um einen in einem `\count` Register gespeicherten Wert zu inkrementieren (oder zu dekrementieren). Wie wir gesehen haben, können solche Zuweisungen während des reinen Expansionsprozesses von TeX (einschließlich des Inkrementierens von Variablen) nicht stattfinden: das Makro `\foo` umgeht diese Beschränkung auf clevere Weise.
### Zurück zur Erklärung von \foo
Das Makro `\foo` kann den Schleifenprozess steuern *ohne* Werte Variablen zuweisen zu müssen: Es steuert, wie oft die Schleife stattfindet, mithilfe von Daten, die aus der Expansion entstehen: Datenwerte, die in temporären Token-Listen gespeichert sind. Mit unserem Wissen über die Verwendung (Erzeugung) temporärer Token-Listen in TeX können wir genauer hinschauen, um genau zu sehen, wie `\foo` seine Ergebnisse erzielt.
**Denken Sie daran**: Wir arbeiten die Ausführung eines Makros durch, nachdem der ursprüngliche Text seiner Definition – enthalten in einer physischen `.tex` Datei – gescannt (von TeX eingelesen) und in eine Token-Liste umgewandelt wurde, die die Makrodefinition repräsentiert. Im Wesentlichen verfolgen wir die Verarbeitung dieser gespeicherten *Tokens* während es Tokens in der Makrodefinition liest und verarbeitet, die irgendwo im Speicher von TeX enthalten ist. Alle ursprünglich im TeX-Code der Makrodefinition vorhandenen Leerzeichen (Text innerhalb der `.tex` Datei) werden beim Scannen dieses Textes nach Befehlen durch TeX absorbiert worden sein (Leerzeichen als Begrenzungszeichen), oder sie wurden in Tokens umgewandelt, wie etwa das Leerzeichen nach dem Komma (`,`) in `\ifnum#1<#2,` das aus der Umwandlung des Zeilenendzeichens (`\r`) in ein Leerzeichen entstanden ist.
Da der TeX-Code in `\foo` mehrere `\expandafter` Befehle verwendet, unterstützen wir unsere Erklärung, indem wir jedem `\expandafter`verarbeiteten Tokens und stellen Tokens dar `\expandafter` auf $$\mathrm{T^i\_1}$$ und $$\mathrm{T^i\_2}$$\expandafter\i\ $$\mathrm{T\_1}$$ und $$\mathrm{T\_2}$$ für `\expandafteri`: `\expandafteri` $$\mathrm{T^i\_1T^i\_2}$$
Hier ist der kommentierte Makro-Code:
```
\def\foo#1#2{\number#1
\ifnum#1<#2,
\expandafter1\foo
\expandafter2{\number\numexpr#1+1\expandafter3}%
\expandafter4{\number#2\expandafter5}%
\fi}
```
`\foo` beginnt mit `\number#1` das den expandierbaren Befehl verwendet `\number` um den Wert des ersten Arguments in seine gesetzte Darstellung umzuwandeln. Der `\number` Befehl funktioniert, indem er eine temporäre Token-Liste erzeugt, die Zeichen-Tokens enthält, welche die einzelnen Ziffern darstellen, aus denen der numerische Wert besteht, auf dem `\number` er arbeitet. Diese Token-Liste wird TeXs nächste Eingabequelle. Hier wird diese Token-Liste gelesen und die Tokens werden ausgegeben, um den Wert von `#1`.
Als Nächstes führt das Makro den Test aus `\ifnum#1<#2` um zu prüfen, ob das Argument für `#1` kleiner ist als das übergebene Argument für `#2`. Falls ja, wird ein Komma (`,`) Token ausgegeben (gesetzt), gefolgt von einem Leerzeichen, das aus dem Token entsteht, welches aus dem Zeilenumbruchzeichen nach dem Komma (`,`). Dieses Leerzeichen wurde erstmals erzeugt, als TeX diese Zeile aus der `.tex` Datei las.
Das Makro fährt mit der Verarbeitung dieses nächsten Codeabschnitts fort, der den Kern seiner Funktionsweise bildet:
```
\expandafter1\foo
\expandafter2{\number\numexpr#1+1\expandafter3}%
\expandafter4{\number#2\expandafter5}%
\fi}
```
Im Wesentlichen erzeugt dieser Code eine Reihe temporärer Token-Listen, die zu mehreren Aufrufen des `\foo` Makros führen und enden, wenn der If-Test `\ifnum#1<#2` nicht mehr wahr ist. Aber *wie* wird die Schleife gesteuert, wenn keine Zuweisungen stattfinden: Wo ist der „Schleifenzähler“?
Beginnen wir mit einem Blick auf den Code `\expandafter1\foo\expandafter2`. Beachten Sie, dass wir die Tiefstellungsnotation `token` (oder `(token)`) verwenden, um uns daran zu erinnern, dass TeX hier numerische (Ganzzahl-)Tokenwerte liest/verarbeitet.
Hier haben wir die folgenden Tokens als Eingabe für `\expandafter1`:
* $$\mathrm{T^1\_1} =$$`\footoken` das eingelesen und für spätere *Wiedereinfügung* zurück in die Eingabe
* $$\mathrm{T^1\_2} =$$`\expandafter2 (token)` das expandiert wird
Für `\expandafter2` haben wir:
* $$\mathrm{T^2\_1} =$$`{token` das für später gespeichert wird *Wiedereinfügung* zurück in die Eingabe
* $$\mathrm{T^2\_2} =$$ `\numbertoken` das expandiert wird
**Hinweis:**`\number` ist ein expandierbarer Befehl, dessen Zweck es ist, „in Tokens umzuwandeln“: d. h. eine numerische Größe in eine Reihe von Zeichen-Tokens umzuwandeln, die diese Größe darstellen. Wenn `\number` er expandiert wird, ist das Erste, was TeX tut, die Eingabe nach Ganzzahlen zu scannen: ein Prozess, der weitere Expansion auslöst.
**Der Schlüssel zur Geschichte:** Hier `\number` wirkt *der Ausdruck* `\numexpr#1+1` der den Wert von `#1+1`. Das Ergebnis dieser Berechnung wird von `\number` verarbeitet, um es in eine temporäre Token-Liste umzuwandeln, die Zeichen-Tokens enthält, welche den Wert von `#1 + 1`. Diese temporäre Token-Liste, erzeugt von `\number`, wird schließlich als erstes Argument eines weiteren Aufrufs von `\foo`. Statt einen Schleifenzähler zu inkrementieren (über `\advance` und Zuweisung), erzeugt die Verwendung von `\numexpr` einen neuen Wert, ohne dass eine Zuweisung erforderlich ist. Durch diesen Mechanismus wird die die Schleife steuernde Variable (`\foo`s Parameter `#1`) inkrementiert und das Durchlaufen der Schleife gesteuert und beendet: ziemlich genial!
Als Nächstes `\expandafter3` wird verarbeitet und ergibt:
* $$\mathrm{T^3\_1} =$$`}token` das für später gespeichert wird *Wiedereinfügung* zurück in die Eingabe
* $$\mathrm{T^3\_2} =$$`\expandafter4 (token)`, das expandiert wird:
Für `\expandafter4` haben wir:
* $$\mathrm{T^4\_1} =$$`{token` das für später gespeichert wird *Wiedereinfügung* zurück in die Eingabe
* $$\mathrm{T^4\_2} =$$`\numbertoken` das expandiert wird und `#2` in eine weitere temporäre Token-Liste umwandelt.
Schließlich`\expandafter5` wird expandiert:
* $$\mathrm{T^5\_1} =$$`}token` das für später gespeichert wird *Wiedereinfügung* zurück in die Eingabe
* $$\mathrm{T^5\_2} =$$`\fitoken`, das ein expandierbarer Befehl ist.
Die Expansion von `\fi` beendet effektiv den `\ifnum` und schließt damit faktisch diese Iteration des Makros. TeX vollendet nun die Wiedereinfügung aller Tokens, die durch die mehreren `\expandafter` Befehle vorübergehend gespeichert wurden: Dadurch entsteht eine Reihe von Token-Listen mit jeweils einem einzelnen Token, die aus den durch jedes `\expandafter`gespeicherten Tokens hervorgehen. Außerdem hat TeX auch Token-Listen durch die Aktion von `\number`.
### Zusammenstellen der Token-Listen
Im Wesentlichen `\foo` Makro erzeugt eine Folge von Token-Listen: Man kann sich `\foo` als eine „Fertigungsanlage“ für Token-Listen vorstellen. Diese Token-Listen werden von TeX gelesen und werden zu den nächsten Eingabequellen. Der clevere Teil steckt in einer der früheren Aktionen von `\foo`:
```
\expandafter1\foo\expandafter2
```
durch die `\foo` veranlasst es, sich erneut selbst aufzurufen, jedoch mit anderen Argumenten, die in von `\number`. `{` und `}` Damit diese Token-Listen gemeinsam wie ein Makroaufruf wirken, werden die Klammern `\expandafter` wurden alle gespeichert und durch die Aktionen von erneut in die Eingabe eingefügt (als einzelne Token-Listen)
[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/17-how-does-expandafter-work-a-detailed-macro-case-study.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.