> 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/22-how-does-expandafter-work-the-meaning-of-expansion.md). # Wie funktioniert \expandafter: Die Bedeutung von Expansion [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 in TeXs Konzept der „Expansion“ Nachdem wir behandelt haben [TeX-Tokens und Tokenlisten](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true), steht als Nächstes auf unserer Liste der Hintergrundthemen für `\expandafter` TeXs Konzept der *Expansion*: der zentrale TeX-Prozess `\expandafter` ausgelegt ist, um damit zu arbeiten. ### Über die Schwierigkeit, Expansion zu erklären... Für die meisten von uns können TeXs Konzept der Expansion und die Gründe/Mechanismen dahinter verwirrend sein – sie sind nicht leicht *vollständig* auf einfache, knappe Weise zu erklären. Viele von TeXs internen Operationen/Prozessen sind auf ziemlich komplexe Weise miteinander verknüpft, was das „Zerlegen“ bestimmter Aspekte von TeXs Operationen erschweren kann: also der Versuch, sie isoliert vom Programm als Ganzes zu betrachten. Expansion ist sicherlich ein Konzept, das in diese Kategorie fällt, denn es ist ein *grundlegender* Element von TeXs Verhalten und tief in TeXs interne Prozesse eingebettet. Dieser Artikel versucht jedoch, eine Erklärung der Expansion aufzubauen und eine Grundlage zu bieten, auf der Leser aufbauen können. Um TeXs Expansionsmechanismus zu erklären, gehen wir schrittweise vor, betrachten eine Reihe verwandter/relevanter Themen und setzen sie zusammen, um ein Verständnis für dieses entscheidende Element von TeXs Verhalten zu entwickeln. Später im Artikel und für den eher wagemutigen Leser, der Details schätzt, werfen wir einen Blick in TeX selbst und fassen den wichtigsten Quellcode zusammen, der den Expansionsprozess steuert. ### Wichtige Punkte zu TeX-Tokens Während der folgenden Diskussion ist es wichtig, sich daran zu erinnern, dass TeX sein nächstes Eingabeelement aus zwei Quellen beziehen kann: 1. **physische Textdateien**: erzeugt *neuer Tokens* durch Lesen/Scannen von Zeichen und Befehlen innerhalb dieser Dateien, oder 2. **Tokenlisten**: Eingabe durch Lesen aus einer Liste vorhandener, *vorbereiteter*Tokens, die im Speicher von TeX gespeichert sind. Denken Sie auch daran, dass TeX Tokens als bequeme Möglichkeit verwendet, Informationen über jedes eingelesene Element (Zeichen oder Befehl) ordentlich zu „verpacken“. Wenn TeX *neuer Tokens* erzeugt, *zum Zeitpunkt der Token-Erzeugung*hat es sofortigen Zugriff auf Informationen über das Element, dessen Tokenwert es berechnet. Wenn TeX zum Beispiel neue Befehlstokens erzeugt, berechnet es zunächst einen Wert namens `curcs` der es TeX ermöglicht, Informationen über den Befehl nachzuschlagen, dessen Token es gerade erzeugen will. Wenn TeX jedoch aus Tokenlisten liest (Sequenzen von *gespeicherten Tokens*), müsste es zunächst jedes Token in dieser Liste „entpacken“, bevor es bestimmen könnte, was jedes Token darstellt. TeX könnte zum Beispiel Tokens lesen, die als Teil einer Makrodefinition gespeichert sind: Diese Tokens wären aus Text erzeugt worden, der längst eingelesen, in Tokens umgewandelt und abgelegt worden ist. Der Tokentyp (Zeichen oder Befehl) bestimmt, was TeXs „Entpacken“ tatsächlich bedeutet: * für *Befehlstokens* (Tokenwert ist > 4095): berechnen `curcs` über $$\text{curcs}=\text{token value}-4095$$ und verwenden `curcs` um Informationen über den Befehl nachzuschlagen; * für *Zeichen-Tokens* (Tokenwert < 4095): das Zeichen-Token in sein zusammengesetztes Paar aus (Zeichencode, Kategoriencode) aufteilen. ### Am Anfang... Um unsere Untersuchung der Expansion zu beginnen, sehen wir uns an, wie TeX-Engines die Menge der Befehle klassifizieren oder kategorisieren, die sie verarbeiten können. Für den Moment nehmen wir an, dass „erweiterbar“ einfach eine, noch nicht erklärte, „Eigenschaft“ eines TeX-Befehls ist. ### Der Begriff „erweiterbarer“ Befehle Alle auf TeX basierenden Schriftsatzprogramme (TeX-„Engines“) verstehen zwei Haupt-„Klassen“ von Befehlen: * Befehle, die in die ausführbare Engine selbst eingebaut sind: die sogenannten *Primitiven*; * vom Benutzer definierte Befehle: sogenannte *Makros*. TeX-Engines verwenden außerdem das „erweiterbar Sein“, eine Art von Befehls-„Verhalten“, als Mechanismus, um alle Befehle in zwei Gruppen einzuteilen: * erweiterbare Befehle; * nicht erweiterbare Befehle. Wir können also davon ausgehen, dass die Menge aller Befehle (Primitiven plus Makros) wie in der folgenden Grafik gezeigt klassifiziert werden kann: ![Diagramm, das die Klassifizierung aller TeX-Befehle zeigt](/files/5149880017284015d5e6a8d9a172cc62d0382056) Obwohl wir noch nicht wissen, was Expansion/erweiterbar eigentlich bedeutet, lässt sich erkennen, dass: * alle Makros als erweiterbare Befehle klassifiziert werden; * einige primitive (eingebaute) Befehle ebenfalls als erweiterbar klassifiziert werden (die überwältigende Mehrheit jedoch nicht). **Hinweis zu aktiven Zeichen**: Zusätzlich zu Primitiven und Makros gibt es eine dritte Klasse von „erweiterbaren“ Elementen: aktive Zeichen – alle Zeichen, denen der Kategoriencode 13 zugewiesen ist, gelten ebenfalls als „erweiterbar“, weil sie als „Miniatur-Makros“ verarbeitet werden. #### Woher weiß TeX, ob ein Befehl „erweiterbar“ ist? Aus unserer [Diskussion über TeX-Tokens](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) wissen wir, dass Tokens nichts weiter als ganze Zahlen sind, die TeX berechnet und verwendet, um Informationen über ein Eingabeelement zu „verpacken“: ein Zeichen oder ein Befehl. Wir haben auch festgestellt, dass TeX bei jedem Tokenwert (ganze Zahl), falls/wenn erforderlich, den Tokenisierungsprozess umkehren kann, um ein Token zu „entpacken“ und Daten über den Befehl oder das Zeichen offenzulegen, das es darstellt. Anhand von Daten, die bei der Erzeugung eines neuen Tokens durch TeX entstehen, oder von Daten, die aus einem vorhandenen Token extrahiert werden – z. B. einem in einem Makro oder einer anderen Tokenliste gespeicherten –, kann TeX seine internen Datenspeichertabellen überprüfen, um detaillierte Informationen über den durch dieses Token dargestellten Befehl (oder das Zeichen) zu finden. Die folgende Grafik fasst den Prozess der Erzeugung eines Befehlstokens („Verpacken“) und anschließend, wenn TeX Informationen benötigt, die Umkehrung des Prozesses („Entpacken“ des Tokens) zusammen, um Daten über den durch einen bestimmten Tokenwert dargestellten Befehl zu erhalten. ![Diagramm, das zeigt, wie TeX Tokens verpackt/entpackt](/files/b064029619264bb241962e70a926f9402caf611e) ### Befehlscodes Ein Teil der Informationen, die TeX über jeden Befehl (Primitiv oder Makro) speichert, ist etwas, das sein *Befehlscode*genannt wird: ein Integerwert, den TeX-Engines (intern) verwenden, um Befehle zu klassifizieren – Befehle mit ähnlichem Verhalten/Funktionalität teilen sich denselben Befehlscode. **Hinweis**: Für ein einzelnes, *nicht aktives*Zeichen ist sein Befehlscode der *Kategoriencode* der ihm zugewiesen wurde, als es von TeX eingelesen (gescannt) wurde. Beachten Sie außerdem, dass Befehlscodes – mit Ausnahme von Zeichen – rein intern für TeX sind: Sie sind über Makros oder primitive Befehle nicht zugänglich – für diese Details müssen Sie TeXs Quellcode lesen! Hier sind einige Beispiele für Befehlscodes: * `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (und andere) werden alle als „Box-Erzeugungs“-Befehle klassifiziert und teilen sich den Befehlscode 20; * `\def`, `\edef`, `\gdef`, `\xdef` sind alles „Makrodefinitions“-Befehle und teilen sich den Befehlscode 97; * alle Makros werden mit einem der Befehlscodes 111, 112, 113 oder 114 klassifiziert: Die verschiedenen Befehlscodes werden durch die Verwendung von `\long` oder `\outer` bei der Definition des Makros bestimmt: * 111: Befehlscode für ein nicht-langes, nicht-äußeres Makro (z. B. `\def\foo{...}`) * 112: Befehlscode für ein langes, nicht-äußeres Makro (z. B. `\long\def\foo{...}`) * 113: Befehlscode für ein nicht-langes, äußeres Makro (z. B. `\outer\def\foo{...}`) * 114: Befehlscode für ein langes, äußeres Makro (z. B. `\long\outer\def\foo{...}`) TeX verwendet Befehlscodes auch, um die Teilmenge der Befehle zu identifizieren, die als „erweiterbar“ klassifiziert sind. Dazu ordnet TeX erweiterbaren Befehlen Befehlscodewerte zu, die den Schwellenwert von 100 überschreiten (der von Knuths ursprünglichem TeX, e-TeX und pdfTeX verwendet wird). Folglich: * *nicht erweiterbare* Befehle (die große Mehrheit) haben einen Befehlscode <= 100 * *erweiterbare* Befehle haben einen Befehlscode > 100 Wenn TeX also die Details für einen bestimmten Befehl nachschlägt und einen Befehlscode > 100 feststellt, weiß TeX sofort, dass er erweiterbar ist. Allen Makros und einer kleinen Anzahl von Primitiven (eingebauten Befehlen) wird ein Befehlscode zugewiesen, der anzeigt, dass sie erweiterbar sind: Aber warum macht TeX sich überhaupt die Mühe mit dieser Klassifizierung „erweiterbar“? Wie Sie vielleicht vermuten, bedeutet das einfach, dass diese Befehle etwas „Besonderes“ sind; d. h. sie können TeXs Prozess der *Expansion*. **Hinweis (Zeichen)**: Sofern ein Zeichen nicht als aktiv definiert wurde (Kategoriencode 13), sind alle Zeichen nicht erweiterbar. Aktive Zeichen kann man sich als einbuchstabige „Mini-Makros“ vorstellen. ## Ja, ja, aber was ist Expansion??? Wir haben festgestellt, dass Tokenwerte größer als 4095 verwendet werden, um Befehle darzustellen; folglich kann TeX dieses Token bei Bedarf „entpacken“, um auf Informationen über den durch dieses Token dargestellten TeX-Befehl zuzugreifen. TeX kann den Befehlscode dieses Befehls nachschlagen, um festzustellen, ob er in die spezielle Kategorie der Erweiterbarkeit fällt. Aber was macht TeX mit diesen Informationen und was bedeutet „erweiterbar sein“, also Expansion, *eigentlich*? ### Expansion: Ein allgemeiner Begriff für eine Menge von Operationen Zu bestimmten Zeitpunkten während TeXs Verarbeitung muss es wissen, ob ein Token einen erweiterbaren Befehl darstellt: * **Nein**: Wenn dieses Befehls-Token *nicht* nicht in die erweiterbare Kategorie fällt, reicht TeX es einfach an die nächste Verarbeitungsstufe weiter. * **Ja**: Wenn dieses Befehls-Token *nicht* in die erweiterbare Kategorie fällt, kann man sich vorstellen, dass TeX Maßnahmen ergreifen muss, die dazu führen, dass dieses bestimmte Token „herausgefiltert“ wird, indem es einen Prozess ausführt, den TeX als „dieses Token expandieren“ bezeichnet, oder Expansion durchführt. Im Wesentlichen umfasst Expansion, dass TeX *dieses Token* aus seiner Eingabe entfernt und *es ersetzt* durch Tokens, die aus dem für diesen Befehl oder die Gruppe von Befehlen mit demselben Befehlscode spezifischen „Expansionsprozess“ entstehen. Es erfordert Übung und Erfahrung zu wissen, wann TeX Token-Expansion durchführt und wann nicht – auf Seite 215 des TeXbook sind die Situationen aufgeführt, in denen erweiterbare Tokens nicht expandiert werden. In Wirklichkeit ist TeXs Prozess der Expansionsausführung komplex und nuanciert. #### Welche Befehle sind erweiterbar? Wenn man sich eine Liste primitiver (eingebauter) Befehle ansieht, die TeX-Engines als erweiterbar klassifizieren (z. B. Seiten 212–215 des TeXbook), wird deutlich, dass Expansion in der Praxis ein recht allgemeiner Begriff ist, den TeX verwendet, um das Verhalten einer ziemlich eklektischen Gruppe von Befehlen zu beschreiben. Die Ergebnisse der Expansion eines bestimmten (erweiterbaren) Befehls variieren tatsächlich, und das lässt sich sehen, wenn man eine Menge erweiterbarer Befehle auflistet – gruppiert nach ihrer Funktionalität. Die genaue Semantik einzelner Befehle ist hier nicht wichtig; von größtem Interesse sind die allgemeinen Folgen ihrer Aktionen – was ihre Expansion tatsächlich *tut oder bewirkt*. | **Befehl** | **Beschreibung** | **Expansionsverhalten** | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | Eine gespeicherte Sequenz aus Befehls-/Zeichen-Tokens |

Im Effekt bedeutet Makro-Expansion, dass eine Tokenliste zum Lesen durch TeX eingefügt wird. Dazu gehört:

Faktisch entfernt die Expansion das Makro-Token aus der Eingabe entfernt und ersetzt es durch die in der Definition enthaltenen Tokens.

| | | Die Reihenfolge der Expansion ändern | Token-Filterung/-Umordnung | | | Expansion verhindern (ja, überraschenderweise wird es als erweiterbarer Befehl klassifiziert) | Expansion verzögern (eine Art Token-Filterung) | | | Bezieht sich auf das Einlesen einer neuen Tokenquelle über Quelldateien – ja, `\scantokens` in dieser Kategorie aufgrund der Verwendung sogenannter „Pseudo-Dateien“ | als Quelle neuer Tokens dienen | | | Einen bedingten Ausdruck beginnen | Mit der Token-„Filterung“ beginnen: entscheiden, welche der folgenden Tokens verarbeitet werden sollen. | | | Einen bedingten Ausdruck beenden | Die Token-„Filterung“ beenden: entscheiden, welche Tokens verarbeitet werden sollen | | | Einen Befehls-Token konstruieren/erzeugen | Eine Folge von Tokens in einen einzelnen Befehls-Token umwandeln | | | Etwas in eine Sequenz von Tokens umwandeln | Einige Tokens erzeugen (die eine interne Größe oder einen Wert darstellen) | | | `\the` hat verschiedene Verwendungen, einschließlich des Einfügens von Tokens; `\detokenize` wandelt eine Tokenliste in eine Liste von Zeichen-Tokens um; `\unexpanded` verhindert die Expansion von Tokens | Einige Tokens einfügen/erzeugen oder die Expansion steuern | | | Befehle zum Zugriff auf Tokenlisten, die spezielle Verwendungszwecke haben | Auf eine Quelle gespeicherter Tokens (Tokenlisten) zugreifen | Lässt sich anhand der obigen Liste irgendein „allgemeines Verhalten“ aus dieser Sammlung von Befehlen herausarbeiten, um unser Verständnis von Expansion weiter zu verfeinern? Näherungsweise führen die Ergebnisse der Expansion eines Befehls auf einige wenige Kernaktivitäten zurück: * Token-Erzeugung * Token-Einfügung * Token-Filterung * die Expansion des nächsten Tokens ändern/steuern ### Und schließlich: die Bedeutung von Expansion? Wir können davon ausgehen, dass die Expansion eines Befehls-Tokens (einschließlich aktiver Zeichen) umfasst, dass TeX **dieses Token** dieses Befehls-Token aus der Eingabe entfernt und **es ersetzt** dieses Token durch andere Tokens ersetzt, die aus seinem Expansionsverhalten entstehen: Tokens erzeugen/einfügen, Tokens filtern oder die Expansion des nächsten Tokens ändern/steuern. Sobald ein Token expandiert wurde, würde TeX weiterhin alle Tokens lesen/verarbeiten, die aus dem Expansionsprozess entstehen könnten. Genau wann oder wo TeX Expansion durchführt, ist eine ganz andere Frage: Aufgrund der Feinheiten und Komplexitäten von TeXs Verarbeitung können wir sie in diesem Artikel nicht vollständig behandeln, aber wir können einen Überblick über TeXs wichtigstes Eingabeverhalten geben. ## Expansion und die Struktur von TeX Wahrscheinlich ist es der beste Weg zu sehen, wie/wo TeX zwischen erweiterbaren und nicht erweiterbaren Befehlen unterscheidet, sich TeXs Quellcode anzusehen. Intern ist TeX ein äußerst komplexes Stück Software; folglich ist es unpraktisch, eine vollständige Beschreibung der vielen nuancierten Verhaltensweisen zu versuchen, die TeXs Funktionsweise innewohnen. Wie erwähnt, ist genau der Zeitpunkt oder Ort, an dem TeX beim Lesen von Tokens tatsächlich Expansion durchführt, „etwas komplex“; daher geht die folgende Diskussion davon aus, dass TeX sich in einem Zustand befindet, der das Stattfinden von Expansion erfordert. Situationen, in denen TeX Tokens lesen/erzeugen würde, aber keine Expansion durchführt, umfassen das Erzeugen/Speichern von Tokens für den `\def` Makrodefinitions-Befehl oder das Speichern von Tokens in einem `\toks` Register. Das folgende Diagramm gibt einen vereinfachten Überblick über die zentralen Teile von TeXs Struktur, die sich mit Eingabe und Verarbeitung von Tokens befassen: Ziel ist es, die Art und Weise hervorzuheben, wie erweiterbare und nicht erweiterbare Tokens während TeXs Eingabeverarbeitung „gefiltert“ werden. Die Programmiersprache C wird verwendet, um die verschiedenen Schlüsselfunktionen zu beschreiben, aber hoffentlich sollte die grundlegende Struktur auch dann klar sein, wenn Sie mit der C-Sprache nicht vertraut sind. ![](/files/4b64c96d9c4490b1e449209679123048add73e3d) ### Erläuterung des TeX-Strukturdiagramms Im Überblick wird TeXs Verarbeitung von einer Funktion namens `maincontrol()` gesteuert, die Knuth im Quellcode von TeX als den „chief executive“ bezeichnet und wie folgt beschreibt: > „Wir kommen nun zur `maincontrol` Routine, die den Hauptschalter enthält, der alle verschiedenen Teile von TeX dazu bringt, ihre Aufgaben in der richtigen Reihenfolge zu erledigen … dies ist der große Höhepunkt des Programms … Wir sind nun am Knotenpunkt des Netzes, dem zentralen Nervensystem, das die meisten anderen Teile berührt und sie miteinander verbindet.“ Die folgende Beschreibung ist etwas vereinfacht, gibt aber einen Eindruck von der zugrunde liegenden Struktur von TeX-basierter Software: wie erweiterbare Befehle während TeXs Eingabeverarbeitung erkannt („abgefangen“) und herausgefiltert werden. Im Wesentlichen verwendet TeX in der frühesten Phase seiner Eingabeverarbeitung den Befehlscodewert des aktuellen Befehls (Tokens), um erweiterbare Befehle zu erkennen (Makros, erweiterbare Primitive und aktive Zeichen); wenn einer identifiziert wird, werden solche Befehle „abgefangen“ und „vorverarbeitet“ – indem sie expandiert werden. Durch diesen Filterungsprozess (Expansion) entfernt TeX erweiterbare Befehle aus der Eingabe und ersetzt sie durch Tokens, die aus ihrem jeweiligen Expansionsverhalten entstehen. Sobald der Expansionsprozess abgeschlossen ist, liest TeX alle Tokens, die aus dieser Expansion hervorgegangen sind. Nur nicht erweiterbare Elemente werden an die nächste Stufe von TeXs Verarbeitung weitergegeben: den „großen Schalter“, wo TeX alle nicht erweiterbaren primitiven Befehle ausführt und Zeichen setzt. ### maincontrol() verstehen Die `maincontrol()` Funktion enthält einen großen sogenannten [switch-Anweisung](https://en.wikipedia.org/wiki/Switch_statement)—Knuth nennt sie den „großen Schalter“—, den TeX verwendet, um alle *nicht erweiterbare* primitiven Befehle auszuführen: diejenigen mit einem Befehlscode <=100. Um einen bestimmten Befehl (oder ein Zeichen) auszuführen, verwendet diese „große Schalter“-Anweisung eine Kombination aus TeXs aktuellem Modus: * internem/äußerem Vertikalmodus, oder * eingeschränktem/Absatz-Horizontalmodus, oder * Inline-/Display-Math-Modus *plus* dem Wert des Befehlscodes für jeden Primitiv oder jedes Zeichen – der Befehlscode eines *nicht aktives* Zeichens ist sein *Kategoriencode* Wert. Der Vollständigkeit halber sei erwähnt, dass alle 6 Modi von TeX einen Integerwert zugewiesen bekommen, den TeX verwenden kann, um seinen aktuellen Modus zu speichern und wiederherzustellen, während es zwischen dem Satz verschiedener Konstrukte wechselt – Mathematik, Absätze, Boxen und so weiter. Hier sind die Integerwerte, die TeXs verschiedenen Modi zugeordnet sind: | | | | | ------------------------------- | ---------------------------------------- | ------------- | | **Modus** | **Bedeutung** | **Moduswert** | | Äußerer Vertikalmodus | Zwischen Absätzen (Seitenaufbau) | 1 | | Innerer Vertikalmodus | Unmittelbar innerhalb einer `\vbox{...}` | -1 | | Horizontalmodus | Beim Setzen/Aufbauen von Absätzen | 102 | | Eingeschränkter Horizontalmodus | Unmittelbar innerhalb eines `\hbox{...}` | -102 | | Display-Math | Satz *Display-* von Gleichungen/Formeln | 203 | | Inline-(Formel-)Mathematik | Satz *Inline-* von Gleichungen/Formeln | -203 | Beachten Sie die Verwendung negativer Werte für die Ergänzung der verschiedenen Modi, etwa innerer vs. äußerer Vertikalmodus. Bei der Verarbeitung von Befehlen in `maincontrol()`verwendet TeX den Absolutwert des aktuellen Modus – d. h. es ignoriert das Minuszeichen. Wenn sich TeX also in einem seiner Horizontalmodi befindet und ein Zeichen mit Kategoriencode 11 verarbeiten muss, würde es die Summe $$102 + 11 = 113$$ in seinem „großen Schalter“ verwenden, um zu dem Code abzuzweigen, der diese Zeichen in einem der beiden Horizontalmodi verarbeitet (beim Aufbau von Absätzen oder innerhalb eines `\hbox`). #### Das nächste Token holen Die `maincontrol()` Funktion ruft die Funktion `getxtoken()` auf, um das nächste Eingabetoken zu erhalten; wiederum `getxtoken()` ruft die unterste Eingabefunktion auf `getnext()`. Nachdem `getnext()` seine Arbeit abgeschlossen hat und den Wert wichtiger *globaler Variablen*, `getxtoken()` prüft, ob das gerade eingelesene Element ein Makro oder ein erweiterbares Primitiv darstellt. Einige Anmerkungen zu `getnext()` und `getxtoken()`: * **`getnext()`**: dies ist TeXs zentrale Eingabefunktion. Sie liest und verarbeitet Zeichen, die aus einer physischen Datei eingegeben werden, oder liest Tokens aus einer Tokenliste. Beachten Sie, dass `getnext()` eigentlich keine Tokenwerte berechnet, aber mehrere wichtige *globale* Variablen (z. B. den Befehlscode und `curcs`) setzt, die später in der Verarbeitung verwendet werden. * **`getxtoken()`**: „get expanded token“ verwendet `getnext()` um das nächste Eingabeelement zu lesen. Anschließend prüft es den Befehlscode des gerade eingelesenen Elements, um zu überprüfen, ob dieses Element einen erweiterbaren Befehl darstellt: Wenn ja, wird es expandiert oder das Makro wird aufgerufen. Bei nicht erweiterbaren Elementen `getxtoken()` berechnet einen Tokenwert und diese Details werden an die nächste Verarbeitungsstufe weitergegeben: den „großen Schalter“, wo nicht erweiterbare Primitive ausgeführt und Zeichen gesetzt werden. Im Wesentlichen ist es über `getxtoken()` dass alle erweiterbaren Elemente „herausgefiltert“ werden, bevor sie in `maincontrol()`verarbeitet werden: Das führt dazu, dass TeXs „großer Schalter“ nur nicht erweiterbare primitive Befehle verarbeitet. Noch einmal betonen wir, dass das obige Diagramm eine Vereinfachung ist, da auch andere Bereiche von TeXs Verarbeitung dazu führen, dass Tokens expandiert werden; zum Beispiel: * wenn TeX nach numerischen Werten sucht (scannt), löst es bei seiner Suche nach ganzen Zahlen Expansion aus (indem es `getxtoken()`) ; * den primitiven Befehl `\romannumeral` veranlasst Expansion – siehe den Artikel [Expansion mit `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) für eine nuancierte Verwendung dieser Tatsache; * Die `\edef` („erweiterte Definition“) Makrodefinitions-Befehl erzwingt vollständige Expansion; * TeX expandiert Tokens an bestimmten Stellen bei der Verarbeitung des Vorspanns eines `\halign` oder `\valign` (beide Befehle stehen mit TeXs Tabellen-Setzalgorithmen in Zusammenhang). [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/22-how-does-expandafter-work-the-meaning-of-expansion.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.