> 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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md). # Wie funktioniert \expandafter: Eine Einführung in TeX-Tokens [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) ## Hintergrund zu \\\expandafter: TeX-Tokens und Tokenlisten Als ersten Schritt zum Verständnis, wie `\\expandafter` es wirklich funktioniert, werfen wir einen Blick auf zwei Komponenten von TeX, die für die Funktionsweise von `\\expandafter`: TeX-Tokens (Ganzzahlen) und Tokenlisten (Listen von Ganzzahlen). Leser, die diese Themen viel genauer erkunden möchten, könnten an den folgenden von Overleaf veröffentlichten Artikeln interessiert sein: * [Was ist ein TeX-Token?](/latex/de/ausfuhrliche-artikel/53-what-is-a-tex-token.md) * [Was ist eine TeX-Tokenliste?](/latex/de/ausfuhrliche-artikel/54-what-is-a-tex-token-list.md)-[Wie funktionieren TeX-Makros eigentlich?](/latex/de/weitere-themen/01-a-six-part-series-how-do-tex-macros-actually-work.md) ### Woher stammen die Tokendaten? Im gesamten Artikel verwenden wir tatsächliche Tokenwerte, die von TeX berechnet wurden — Daten, die für Benutzer normalerweise nicht zugänglich sind. Leser, die neugierig sind, wie diese Tokenwert-Daten ermittelt wurden, sollten wissen, dass Overleaf benutzerdefinierte Builds mehrerer TeX-Engines hat, die wir für Forschungszwecke verwenden. Diese Engines wurden so modifiziert, dass sie Informationen über TeXs interne Verarbeitungsaktivitäten ausgeben — dies hilft, für einige der von uns erstellten Artikel zusätzliches Hintergrundmaterial bereitzustellen. Indem wir numerische Tokenwerte zeigen/erörtern, möchten wir Details einbeziehen, die hoffentlich den Lesern helfen, „TeX-Tokens“ besser zu verstehen und dieses wichtige Konzept etwas weniger undurchsichtig erscheinen zu lassen. ## TeX-Tokens 101 (und Begriffe der Expansion) Wenn TeX Ihre Eingabedatei verarbeitet, liest es den Text und wandelt einzelne Zeichen und Zeichenfolgen (Befehle) in sogenannte *Tokens*. Ein TeX-Token ist einfach ein von TeX berechneter Ganzzahlwert, der verwendet wird, um Daten zu „kodieren“, die TeX über ein aus seiner aktuellen Eingabequelle eingelesenes Element speichern muss. Stellen Sie sich Tokens als kleine Informationspakete vor, die die Daten zusammen „verpacken“, die TeX festhalten muss, damit sie an die nächste Verarbeitungsstufe weitergegeben werden können. Intern arbeitet TeX mit diesen ganzzahligen Tokenwerten — es verwendet nicht die tatsächlichen Buchstaben, Symbole, Ziffern usw., die ursprünglich in Ihrer Eingabedatei enthalten waren: Alles wird in ein Token (eine Ganzzahl) umgewandelt, und TeX arbeitet mit diesen. ## Wie TeX Tokenwerte berechnet Hier betrachten wir die Tokenberechnungen, die in Knuths originalem TeX, e-TeX und pdfTeX verwendet werden; bei anderen TeX-Engines, insbesondere XeTeX und LuaTeX, müssen ihre Tokenberechnungen etwas anders sein, um die Verwendung von Unicode zu berücksichtigen, aber die Berechnungsmethoden sind ähnlich wie die unten beschriebenen. ### Zeichentokens (inaktive Zeichen) Die Berechnung der Tokenwerte für inaktive Zeichen ist unkompliziert: $$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$ **Beispiel**: Der Buchstabe A mit [Kategoriecode](/latex/de/weitere-themen/43-table-of-tex-category-codes.md) 11, Zeichencode 65 wird von TeX als der Zeichentokenwert dargestellt $$256\times 11 + 65 = 2881$$. Möglicherweise begegnen Ihnen in der TeX-Literatur Beschreibungen, die darauf hinweisen, dass, sobald TeX ein Zeichen eingelesen hat, sein Kategoriecode „permanent“ mit diesem Zeichen verknüpft wird: Die obige Berechnung des Tokenwerts zeigt, warum das stimmt. Später in TeXs Verarbeitung kann es jedoch Zeichentokens „entpacken“ und tut dies auch, um das zugrunde liegende (Zeichencode, Kategoriecode)-Paar offenzulegen, aus dem der Token konstruiert wurde — wenn TeX dieses „Entpacken“ vornimmt, ändert es den Kategoriecode dieses Zeichens dennoch nicht, sondern verwendet diese Information lediglich bei der weiteren Verarbeitung. ### Befehlstokens TeXs Eingabeverarbeitung und Token-Erzeugung erkennen zwei Arten von Befehlen: * Befehle, die aus einem oder mehreren Zeichen mit Kategoriecode 11 aufgebaut sind; * Einzeichenbefehle, bei denen der Kategoriecode dieses Zeichens nicht 11 ist, wie z. B. `\\$` oder `\\#`. In beiden Fällen lässt TeX das führende `\` Zeichen weg und verwendet den Zeichencode jedes verbleibenden Zeichens, um eine Ganzzahl zu berechnen, die TeX `curcs` (**cur**rent **c**ontrol **s**equence). TeX verwendet dann den Wert von `curcs` zur Berechnung eines Tokenwerts für den Befehl. #### Befehle aus Zeichen mit Kategoriecode 11 Angenommen, unser Befehl (ohne das führende `\` Zeichen) besteht aus einer Zeichenfolge: $$\mathrm{C\_1C\_2C\_3...C\_N}$$ wobei $$\mathrm{C}\_i$$ ist der Zeichencode jedes Zeichens — z. B. ist der Zeichencode von A 65. TeX verwendet alle Zeichencodes $$\mathrm{C}\_i$$ zur Berechnung der Ganzzahl `curcs` (mithilfe einer [Hashfunktion](https://en.wikipedia.org/wiki/Hash_function)). Sobald TeX den Wert von `curcs` berechnet hat, addiert es einfach 4095 zu diesem Wert, um den Tokenwert zu erhalten: $$\text{command token} = \text{curcs + 4095}$$ Beachten Sie, dass die Variable `curcs` eine äußerst wichtige Rolle in TeXs internen Verarbeitungsabläufen spielt. #### Einzeichenbefehle Tokens zur Darstellung von Befehlen wie `\\$`, `\\#` usw. unterliegen einer etwas anderen Berechnung: Die Ganzzahl `curcs` ist nun die einfachere Berechnung: $$\text{curcs} = 257 + \text{character (ASCII) code}$$ Zum Beispiel gilt mit `\\$`, $$\text{curcs}=257 + 36 = 293$$. TeX addiert erneut 4095 zu diesem Wert (unter Verwendung von $$\text{command token} = \text{curcs} + 4095$$) was zu `\\$` mit einem Tokenwert $$293 + 4095 = 4388$$. Im Vergleich zu Befehlen, die aus Zeichen mit Kategoriecode 11 bestehen, besteht der einzige Unterschied hier darin, wie TeX den Wert für `curcs`. **Hinweis**: die Ganzzahl `curcs` wird für Zeichentokens nicht berechnet: Sie wird immer auf 0 gesetzt, wenn TeX Zeichentokens erzeugt oder mit ihnen arbeitet. #### Tokens aktiver Zeichen TeX kennt das Konzept der sogenannten *aktiven Zeichen*: jedes Zeichen, dem Kategoriecode 13 zugewiesen ist. Tokens für diese spezielle Zeichenklasse unterliegen im Vergleich zu regulären Zeichen einer anderen Berechnung. Der Mechanismus für aktive Zeichen ermöglicht es TeX, im Grunde Einzeichenmakros zu erstellen, die Sie verwenden können *ohne* zu müssen, das aktive Zeichen mit einem Escape-Zeichen (typischerweise `\`): Das isolierte Zeichen löst sein Makroverhalten aus. Das klassische Beispiel ist das Tilde-Zeichen (\~), das TeX/LaTeX für geschützte Leerzeichen verwenden und das wie folgt definiert/aktiviert werden kann: ``` \\catcode`~=13 %Kategoriecode 13 zu ~ zuweisen \\def~{\\penalty100000\\ } % ~ als Makro definieren ``` Wenn TeX anschließend ein `~` Zeichen liest, erkennt es, dass sein Kategoriecode 13 ist, und verarbeitet es als „Mini-Makro“. Zur Berechnung eines Tokens, der ein aktives Zeichen darstellt, verwendet TeX eine weitere Variante zur Berechnung von `curcs`: $$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$ Das \~-Zeichen hat beispielsweise den Zeichencode 126, was bedeutet, dass seine Darstellung des Tokens für aktive Zeichen wie folgt berechnet wird: $$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$ Beachten Sie, dass Tokens, die aktive Zeichen darstellen, wie Befehle > 4095 sind. ### Folgen/Hinweise * Jeder Token, dessen Wert 4095 übersteigt, ist sofort als Befehlstoken erkennbar — daher kann TeX sehr leicht feststellen, ob ein bestimmter Token ein Zeichen oder einen Befehl darstellt. * Für jeden Tokenwert kann TeX bei Bedarf diesen Token „entpacken“, um das Zeichen (und seinen Kategoriecode) oder den Befehl offenzulegen, der ursprünglich in Ihrer `.tex` Datei, in einer Makrodefinition gespeichert oder in einer anderen Tokenliste enthalten war. * Die „Zwischengröße“ namens `curcs`— die TeX zur Berechnung von Befehlstokenwerten verwendet — spielt eine wichtige Rolle in TeXs Low-Level-Verarbeitung. `curcs` dient als „Indexwert“, den TeX verwendet, um die aktuelle Bedeutung eines Befehls zu speichern/nachzuschlagen. Bei jedem Befehlstoken $$\mathrm{T}$$, zieht TeX einfach 4095 ab, um auf den Wert von `curcs`: $$\text{curcs} = \mathrm{T}-4095$$ Nebenbei bemerkt speichert TeX die menschenlesbare Zeichenfolge, aus der ein Befehlstoken erzeugt wird — dies ist für die Fehlerausgabe und andere Befehle wie `\\string` dessen Expansion die menschenlesbare Version eines Tokenwerts ist. Diese in TeX gespeicherten menschenlesbaren Zeichenketten werden jedoch nur bei Bedarf verwendet/ausgegeben: Für alle anderen Verarbeitungsschritte wird der ganzzahlige Tokenwert verwendet. ## Ein Blick auf einige echte Tokens Um das Konzept der Tokens etwas weniger undurchsichtig erscheinen zu lassen, definieren wir das folgende einfache Makro und schauen uns die Tokens an, die TeX erzeugt: ``` \\def\\hello{Grüße von \\TeX. \\hskip 10pt} ``` Für das `\\hello` Makro verwendet TeX die Zeichen `h`, `e`, `l`, `l`, `o` zur Berechnung eines Werts von 3745 für `curcs`; TeX addiert dann 4095, um einen Tokenwert von $$3745 + 4095 = 7840$$ (für Knuths TeX, e-TeX oder pdfTeX). Nachdem ein Token zur Darstellung von `\\hello`, müssen die `\\def` Befehl erzeugt wurde, liest TeX die folgenden Tokens und verwendet sie, um eine Tokenliste zu erstellen, die als *Definition* des `\\hello` Befehls gespeichert wird. Diese gespeicherte Definition (Tokenliste) kann dann jederzeit abgerufen werden, wenn Sie TeX anweisen, das `\\hello` Befehls. Die folgende Tabelle listet die tatsächlichen Tokenwerte auf, die für jedes Element (Zeichen, Makro oder Primitive) erzeugt wurden, das in der `\\hello` Makrodefinition enthalten ist — diese Liste von Tokens (Ganzzahlen) ist das, was TeX in seinem Speicher ablegt (als Datenstruktur bekannt als eine [verkettete Liste](https://en.wikipedia.org/wiki/Linked_list)). Leser, die Tokenlisten genauer verstehen möchten, seien auf den Overleaf-Artikel verwiesen [Was ist eine TeX-Tokenliste?](/latex/de/ausfuhrliche-artikel/54-what-is-a-tex-token-list.md) | | | | ----------------- | ------------------------- | | **TeX-Tokenwert** | **Dargestelltes Element** | | 2887 | G | | 2930 | r | | 2917 | e | | 2917 | e | | 2932 | t | | 2921 | i | | 2926 | n | | 2919 | g | | 2931 | s | | 3116 | , | | 2592 | | | 2918 | f | | 2930 | r | | 2927 | o | | 2925 | m | | 2592 | | | 5235 | \TeX | | 3118 | . | | 2592 | | | 7943 | \\\hskip | | 3121 | 1 | | 3120 | 0 | | 2928 | p | | 2932 | t | In der obigen Tokenliste haben die Zeichen Kategoriecodes von 10, 11 oder 12. Zum Beispiel: * Zeichen haben Kategoriecode 10 und Zeichencode 32, was einen Tokenwert von $$256\times 10 + 32 = 2592$$ * `,` und `.` haben Kategoriecode 12 und Zeichencodes 44 bzw. 46, was die Tokens ergibt: * Token für `,` $$= 256 \times 12 + 44 = 3116$$ * Token für `.` $$= 256\times 12+ 46 = 3118$$ Immer wenn TeX anschließend auf den Tokenwert 7840 (der `\\hello`darstellt) stößt, kann es bei Bedarf diesen Token mithilfe der einfachen Berechnung `curcs` entpacken, um $$\text{curcs} = \text{token value} - 4095$$ siehe oben. Unter Verwendung des Werts von `curcs` TeX kann seine internen Datentabellen abfragen, um festzustellen, dass Befehlstoken 7840 ein Makrobefehl darstellt. Außerdem kann TeX wiederum über `curcs`die gespeicherte Definition von `\\hello`. Wenn TeX Token 7840 vollständig verarbeiten muss, d. h. das `\\hello` Makro auszuführen, benötigt es Token 7840 nicht mehr: Dieser Token hat *seine Aufgabe erfüllt*— d. h., er hat TeX dazu veranlasst, das Makro auszuführen `\\hello`. TeX kann nun Token 7840 verwerfen und die Tokens abrufen, die die in Speicher abgelegte Definition (Tokenliste) darstellen. Tatsächlich wurde der `\\hello` Makrobefehl (Token 7840) *aus* TeXs aktueller Eingabequelle entfernt und *ersetzt* durch Tokens, die in der Definition von `\\hello`. Was wir gerade beschrieben haben, ist eine Form von *Token-Expansion*. Die `\TeX` Befehls (oben aufgeführter Tokenwert 5235), der innerhalb von `\\hello` selbst ein Makro ist, das aus weiteren Tokens konstruiert wurde — daher wird seine Definition ebenfalls als Tokenliste gespeichert: | | | | ----------------- | ------------------------- | | **TeX-Tokenwert** | **Dargestelltes Element** | | 2900 | T | | 19598 | \\\kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3126 | 6 | | 3126 | 6 | | 3127 | 7 | | 2917 | e | | 2925 | m | | 19597 | \\\lower | | 3118 | . | | 3125 | 5 | | 2917 | e | | 2936 | x | | 6175 | \\\hbox | | 379 | { | | 2885 | E | | 637 | } | | 19598 | \\\kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3122 | 2 | | 3125 | 5 | | 2917 | e | | 2925 | m | | 2904 | X | Wenn wir den `\\hello` Befehl durch die vollständige Liste von Tokens ersetzen würden, aus denen er aufgebaut ist, einschließlich des `\TeX` Makros, wäre es eine ziemlich lange Liste — d. h., wenn wir auch das *expandieren* dem `\TeX` Makro expandieren würden, sähen wir: ![Eine Liste von Tokens, die in einem TeX-Makro gespeichert sind](/files/f21328eb109ebb046b2ed94938793afeaeeba222) Im Wesentlichen würde der einzelne Tokenwert 7840 (für `\\hello`) bei vollständiger Expansion insgesamt 51 Tokens (Ganzzahlen) erzeugen, die Zeichen und primitive Befehle darstellen. In der folgenden Liste steht das durch jedes Token dargestellte Zeichen bzw. der Befehl in Klammern „(...)“ — diese werden nicht direkt in TeXs Tokenlisten gespeichert und sind zur Orientierung des Lesers angegeben: ``` 2887 (G), 2930 (r), 2917 (e), 2917 (e), 2932 (t), 2921 (i), 2926 (n), 2919 (g), 2931 (s), 3116 (,), 2592 (), 2918 (f), 2930 (r), 2927 (o), 2925 (m), 2592 (), 2900 (T), 19598 (\\kern), 3117 (-), 3118 (.), 3121 (1), 3126 (6), 3126 (6), 3127 (7), 2917 (e), 2925 (m), 19597 (\\lower), 3118 (.), 3125 (5), 2917 (e), 2936 (x), 6175 (\\hbox), 379 ({), 2885 (E), 637 (}), 19598 (\\kern), 3117 (-), 3118 (.), 3121 (1), 3122 (2), 3125 (5), 2917 (e), 2925 (m), 2904 (X), 3118 (.), 2592 (), 7943 (\\hskip), 3121 (1), 3120 (0), 2928 (p), 2932 (t) ``` Für einen menschlichen Leser ist dies nur eine Reihe von Ganzzahlen, aber für TeX kodiert es eine große Menge an Informationen. ## Tokens jetzt lesen und für später speichern Beim Lesen Ihrer Eingabe kann es Zeiten geben, in denen TeX das vollständige Verarbeiten eines bestimmten Token-Satzes verzögern muss (oder dazu angewiesen wird). Wenn es dazu angewiesen wird, wird TeX, bis es angewiesen wird aufzuhören, weiterhin Tokens aus der Eingabe erzeugen, sie aber für die spätere Verwendung speichern — und sie anschließend im Rahmen seiner Satzarbeiten abrufen und verarbeiten. Diese gespeicherten Tokens werden als sogenannte *Tokenlisten* die im Grunde TeXs einziger (interner) Mechanismus zur Speicherung von Tokendaten sind. Wir haben bereits Beispiele für Tokenlisten gesehen — die `\\hello` und `\TeX` oben aufgeführten Makros: Die Definitionen dieser Makros werden in TeXs Speicher als Listen von Tokens gespeichert. TeX verarbeitet solche Tokenlisten nur dann (führt sie aus), wenn Sie sich entscheiden, diese Makros aufzurufen. Denken Sie auch daran, dass jeder Token (Ganzzahlwert) genügend Informationen enthält, damit TeX leicht feststellen kann, ob jeder in einer Makrodefinition gespeicherte Token ein Zeichen oder einen Befehl darstellt. ### Tokens mit Tokenregistern speichern Ein weiteres Beispiel für die Tokenspeicherung ist die explizite Erstellung von Tokenlisten, die in sogenannten *Tokenregistern*: spezielle interne Speicherbereiche, die TeX Benutzern zum Speichern von Tokenlisten bereitstellt. Das TeX-Primitive `\\toksdef` ist eine Möglichkeit, Tokenregister zu verwenden; zum Beispiel, um Tokenregister `100` zu verwenden und sie mit dem Befehl `\\mylist`: ``` \\toksdef\\mylist=100 \\mylist={einige \\TeX{}-Tokens hier} ``` `\\mylist` ist im Grunde nur ein Name, den Sie einer Tokenliste zuweisen, die an der Registerstelle `100`. Ähnlich wie bei einer Makrodefinition, `\\mylist` enthält es die folgende Tokenliste: | | | | ----------------- | ------------------------- | | **TeX-Tokenwert** | **Dargestelltes Element** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | 379 | { | | 637 | } | | 2592 | | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | **Hinweis**: um das `\TeX` Makro zu beenden und zu verhindern, dass es das folgende `` Zeichen aufnimmt, haben wir ein Paar geschweifter Klammern verwendet `{}` direkt nach `\TeX`— die Tokens für `{` (379) und `}` (637) werden in der Tokenliste gespeichert. Eine weitere Möglichkeit ist die Verwendung eines „Kontroll-Leerzeichen“-Tokens `\\` das in der Tokenliste wie unten gezeigt erscheinen würde (in Fett): | | | | ----------------- | ------------------------- | | **TeX-Tokenwert** | **Dargestelltes Element** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | **4384** | **\\** | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | Beachten Sie, dass das `` Zeichen als *Zeichentoken* mit dem Wert $$256\times 10 + 32 = 2592$$ dargestellt wird, aber `\\` wird als ein einzelnes *Befehlstoken* (Wert 4384), der mithilfe der oben angegebenen Formeln berechnet wird: \\\begin{align\*} \\\text{curcs} & = 257 + \\\text{Zeichencode (ASCII)}\\\\\\\ & = 257 + 32\\\\\\\ &=289\\\\\\\ \\\text{Befehlstoken für} \\\left<\\\text{\\\\\\\space}\\\right> & = \\\text{curcs + 4095}\\\\\\\ & = 289+4095\\\\\\\ &=4384\\\\\\\ \\\end{align\*} Im Wesentlichen `\\mylist={einige \\TeX{}-Tokens hier}` bedeutet dies für TeX: Bitte durchsucht meine Eingabedatei, um die folgenden Zeichen/Befehle in Tokens umzuwandeln und sie für die spätere Verwendung zu speichern. TeX wird dem nachkommen und diese Tokens an einer Speicherstelle ablegen, auf die Sie zugreifen können, indem Sie `\\the\\mylist`, wobei TeX angewiesen wird, eine Kopie der Tokens einzufügen, die in Tokenregister `\\mylist`. TeX-Engines enthalten eine Reihe von primitiven Befehlen, die Tokenlisten explizit erzeugen und speichern — wie zum Beispiel `\\everyjob`, `\\everypar`, `\\mark`, und viele andere. [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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.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.