> 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/22-how-tex-macros-actually-work-part-4.md). # Wie TeX-Makros eigentlich funktionieren: Teil 4 [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) ## Einführung und Überblick In den Teilen 1–3 haben wir einen tiefen Einblick in einige Hintergrunddetails auf niedriger Ebene genommen, um uns darauf vorzubereiten zu verstehen, wie TeX-Makros funktionieren. In diesem Artikel werden wir wieder etwas Luft holen, um einige grundlegende praktische Prinzipien von TeX-Makros zu überprüfen, als Vorbereitung auf einen weiteren tiefen Einblick in den Teilen 5 und 6. Im gesamten Artikel werden wir Beispielmakros zeigen, die mit dem primitiven TeX-Befehl definiert wurden `\def`: Wir werden nicht den vielleicht bekannteren LaTeX-Befehl verwenden `\newcommand`. Dafür gibt es einen sehr guten Grund: Unser Ziel ist es, die grundlegenden Prinzipien zu verstehen, die dem Makroverhalten von TeX zugrunde liegen; um das zu tun, müssen wir Kernbefehle verwenden *die in* der TeX-Software. LaTeX-Befehle, wie `\newcommand`, sind selbst Makros: Befehle mit spezifischem programmiertem Verhalten, die letztlich aus Schichten niedrigerer TeX-Primitive-Befehle aufgebaut sind. Um das grundlegende Verhalten von TeX besser zu verstehen, müssen wir TeX-Primitiven verwenden, nicht LaTeX-Makros. ### Wohin gehen wir? Im Wesentlichen arbeiten wir auf eine Erklärung von Makros als spezialisierte Form einer Tokenliste hin: Wenn Sie TeX anweisen, ein Makro zu definieren, erzeugt es eine Folge von Tokens (eine Tokenliste) und speichert sie in seinem Speicher, verknüpft mit einem von Ihnen definierten Namen. In den Teilen 5 und 6 werden wir uns die Makro-Tokenlisten etwas genauer ansehen, aber wenn Sie lieber von diesem Artikel abspringen möchten, um Hintergrundinformationen zu lesen, finden Sie diese in [Was ist eine TeX-Tokenliste?](/latex/de/ausfuhrliche-artikel/54-what-is-a-tex-token-list.md) Tokenlisten für Makros und ihre Parameter enthalten einige zusätzliche Besonderheiten, die wir im Detail durchgehen werden — und zwar anhand vieler Beispiele. Um das Makroverarbeitungsverhalten von TeX besser zu verstehen, gibt es wirklich einen Schlüsselfaktor zu merken: TeX denkt in der frühesten Phase der Eingabeverarbeitung nur an Zeichen; von da an geht es nur noch um Tokens! In diesem und den übrigen Artikeln dieser Reihe werden wir die Rolle untersuchen, die Tokens in TeX-Makros spielen. ## Die vier Bestandteile eines Makros ### Hinweis: Makroparameter und Makroargumente Bevor wir beginnen, lohnt es sich, uns an den Unterschied zwischen den *Parametern* und den *Argumente*eines Makros zu erinnern, da wir beide Begriffe im gesamten Artikel verwenden werden. Angenommen, Sie definieren ein Makro \foo ``` \def\foo#1#2{Dies ist #1, dies ist #2} ``` Die Konstrukte (Tokens) `#1`, `#2` (bis zu `#9`) werden als die *Parametern*des Makros bezeichnet: Stellen Sie sich sie als „Platzhalter“ für die tatsächlichen Daten vor, die Sie beim Aufruf des Makros verwenden werden: ``` \foo{alpha}{beta} ``` Hier sind `alpha` und `beta` die *Argumente* verwendet werden bei diesem Aufruf von \foo: Die Argumente eines Makros sind die tatsächlichen Werte, die in die Parameter-Platzhalter (`#1`, `#2`... `#9`) eingefügt werden, die Sie beim Definieren des Makros verwendet haben. ### Makrodefinition: hat 4 Elemente Wir beginnen mit dem, was vielleicht wie eine etwas formale Definition eines Makros aussieht, aber sie bietet einen nützlichen Rahmen für weitere Diskussionen. Jede Makrodefinition besteht aus 4 Teilen: ``` {} ``` wobei: * ``: eines von `\def`, `\edef`, `\gdef` oder `\xdef`; * ``: der Name, den Sie Ihrem Makrobefehl geben, wie etwa `\foo`; * ``: Dieser kann fehlen, aber wenn einer vorhanden ist, handelt es sich um eine Reihe von *Tokens* die vor dem `` des Makros erscheinen. Der `` kann Makroparameter (`#1`, `#2`... `#9`) und andere Tokentypen enthalten. Im Wesentlichen — und wie wir im Detail sehen werden — liefert der `` eine Art *Tokenvorlage* die TeX verwendet, um herauszufinden, welche Tokens der Benutzer als Argumente des Makros verwenden möchte: Wenn Sie ein Makro aufrufen, speist TeX die *Arguments* Tokens in das `` (das ebenfalls eine Tokenliste ist); * `{}`: Das ist der eigentliche Körper Ihres Makros: Es ist eine Folge von Tokens, in die die *Argumente* beim Verarbeiten (Erweitern) des Makros „eingesetzt“ werden. Die Argumente werden an die Stellen eingefügt, die durch die beim ursprünglichen Definieren verwendeten Makroparameter angegeben sind. **HINWEIS**: Im gesamten Zusammenhang nehmen wir an, dass `` von einem Leerzeichen mit der Kategoriecode 10 gefolgt wird, das als Trennzeichen dient, um den ``zu beenden. Wir *haben* das Leerzeichen nicht explizit in unserem Text/der Diskussion gezeigt, nehmen aber an, dass es vorhanden ist. Streng genommen sollten wir es etwa so darstellen: ``` {} ``` Wir werden jedoch die explizite Aufnahme eines `` Zeichens weglassen und seine Anwesenheit implizit annehmen. #### Hinweise zu {} Wir haben die Verwendung von zwei geschweiften Klammern gezeigt: `{` und `}` die den eigentlichen Körper Ihres Makro- ``umgeben (abgrenzen). Die Verwendung von `{` und `}` ist jedoch nur eine übernommene Konvention, denn was TeX tatsächlich erwartet, ist, dass der Text Ihres Makros `` mit einem Zeichen der Kategoriecode 1 („Gruppenbeginn“) beginnt und mit einem Zeichen der Kategoriecode 2 („Gruppenende“) endet. Konventionsgemäß sind dies die `{` und `}` -Zeichen bzw. -Zeichen. Sie können jedoch, wenn Sie möchten, beliebige Zeichenpaare dafür zuweisen. Zum Beispiel ``` \catcode`\(=1 \catcode`\)=2 ``` Jetzt können Sie Makros so definieren und verwenden: ``` \def\foo #1(Hallo, #1) \foo(Welt!) ``` Und Sie können weiterhin `{` und `}` verwenden, weil wir ihre Kategoriecodes nicht geändert haben — mehrere Zeichen können denselben Kategoriecode haben, und das tun sie auch, sodass Sie Makros weiterhin auf die übliche Weise definieren können: ``` \def\foo #1{Hallo, #1} \foo{Welt!} ``` ### und {} Die für unsere Diskussion relevantesten Bestandteile einer Makrodefinition sind `` und `{}`. Wenn Sie ein Makro definieren, ist der `` im Grunde eine strikte Tokenvorlage, die festlegt, wie das Makro verwendet werden soll. Wie erwähnt, `` kann leer sein, z. B. `\def\foo{Einige Texte}` wobei zwischen unserem Befehlsnamen (`\foo`) und der öffnenden geschweiften Klammer nichts erscheint `{` die hier den Beginn des ``. **Hinweis**: Einige Leser kennen vielleicht TeXs „hashquote“-Mechanismus (`#{`) aber darauf werden wir hier nicht eingehen. ### und Makro-Begrenzer Dieser spezielle Artikel ist nicht als vollständig umfassender Überblick über das Schreiben von Makros gedacht, aber es lohnt sich, eine kurze Auffrischung mit einigen Beispielen zu haben, die zeigen, dass der `` kompliziert werden kann, weil TeX erlaubt, `` zu enthalten: * **Makroparameter**: (`#1`, `#2`,... `#9`) die als „Platzhalter“ für Werte dienen, die der Benutzer beim Ausführen des Makros bereitstellt — die *Argumente*; * **Begrenzer-Tokens**: beliebige Tokens, die in/um die Parametertokens herum eingefügt werden und dazu dienen, die Grenze zwischen den Makroparametern festzulegen. Sie können sich diese Begrenzer als eine Art „Interpunktion“ vorstellen, die die `` eine „Tokenvorlage“ bilden, der Sie folgen müssen, wenn Sie das Makro verwenden. Begrenzer-Tokens werden nicht gesetzt. Was bedeutet das also tatsächlich — sehen wir uns einige Beispiele an. Der `` steht zwischen dem Namen des Makros und der linken geschweiften Klammer `{` der Makrodefinition. #### Begrenzer: Beispiel 1 Angenommen, wir definieren ein einfaches Makro `\foo` wie folgt: ``` \def\foo ABC{hallo, da} ``` * `` = `ABC` * Es gibt keine Parameter-Tokens (`#1`, `#2`,... `#9`) * Die Begrenzer sind die *drei Zeichentokens* `ABC` aber in diesem Beispiel sind sie etwas überflüssig und dienen nur als Beispiel. Die drei Zeichentokens `ABC` werden als Begrenzer behandelt: nicht als etwas, das gesetzt werden soll, sondern als „Interpunktion“, die beim Aufruf des Makros vorhanden sein muss — wenn Sie das Makro `\foo` verwenden, müssen Sie dieselben Begrenzer angeben, die bei der Definition vorhanden waren. Wenn Sie `\foo ABC` in Ihren Text eingeben, wird dadurch `hallo, da`gesetzt — die Zeichentokens `ABC` werden nicht gesetzt, aber TeX hat sehr sorgfältig überprüft, ob sie in Ihrem Aufruf von `\foo`vorhanden waren. TeX sucht nach diesen Begrenzerzeichen („Interpunktion“) und entfernt (absorbiert) sie, wie Sie im folgenden Overleaf-Bild sehen können: `ABC` wird nicht gesetzt: ![Overleaf beim Ausführen eines TeX-Makros](/files/cf67788fea326ab3f44a9b24f70ecb2b594fc4fc) Wenn Sie versuchen, `\foo` ohne die `ABC` Begrenzer wird TeX sich beschweren `Die Verwendung von \foo stimmt nicht mit seiner Definition überein.`: ![Anzeige eines TeX-Fehlers in Overleaf](/files/b1a0ed928d89b79b0838639d63f44644aa68d75b) Im obigen Beispiel erwartet TeX nach der Erkennung von `\foo` die drei Zeichentokens `ABC` aber das tut es nicht: Es sieht das Zeichentoken für `w` und erkennt sofort, dass etwas nicht stimmt. #### Begrenzer: Beispiel 2 Eine interessante und vielleicht überraschende Tatsache ist, dass Begrenzer beliebige Befehl-Tokens sein können — einschließlich Befehlen, die *noch nicht einmal definiert wurden*. Zum Beispiel könnten wir definieren `\foo` als: ``` \def\foo A\bob B\anne{Hallo \TeX{}} ``` * `` = `A\bob B\anne` * Es gibt keine Parameter-Tokens (`#1`, `#2`,... `#9`) * Die Begrenzer sind die Tokens `A\bob B\anne` aber auch hier sind sie in diesem Beispiel überflüssig und dienen nur Diskussionszwecken. Beachten Sie, dass `\bob` und `\anne` fiktive Befehle sind, die *nicht definiert wurden*— und das müssen sie auch nicht. Wenn Sie ein Makro aufrufen, prüft TeX das `` das vorhanden ist *in Ihrem Makroaufruf* und vergleicht es Token für Token mit der im Speicher *gespeicherten „Tokenvorlagen“-Version*— derjenigen, die zum Zeitpunkt der Makrodefinition erstellt wurde. TeX scannt die *die in Ihrem Makroaufruf verwendet werden* und wandelt einfach alle dort gefundenen Befehle in ihren numerischen Tokenwert um: Es versucht nicht, diese Befehle auszuführen, daher spielt es keine Rolle, dass `\bob` und `\anne` nie definiert wurden. TeX verwendet einfach die im Speicher gespeicherte Tokenvorlage als Leitfaden, damit es herausfinden kann, welche Tokens im `` Ihrer Makroaufrufe die eigentlichen Argumente sind, die in das ``. einfließen sollen. Wie Sie aus dem folgenden Overleaf-Bildausschnitt sehen können, wurde keiner der Zeichentokens (`Ein` und `B`) innerhalb von `A\bob B\anne` gesetzt und unsere undefinierten Befehle `\bob` und `\anne` verursachten keine Probleme. Alle diese Tokens wurden *absorbiert* von TeX, als es Ihre Verwendung von `\foo` mit der Definition (Tokenvorlage) von `\foo` (einer Tokenliste) im Speicher abglich. ![Overleaf beim Ausführen eines TeX-Makros](/files/c006160daec0244b69576ef721144b7effe5d1d2) #### Begrenzer: Beispiel 3 Sie können verschiedene Begrenzer (Zeichentokens, Befehlstokens) mit Makroparametern vermischen, wie in diesem Beispiel: ``` \def\foo A\bob#1B\anne#2\jane#3bye!{Hallo von \TeX{} an \#1=#1, \#2=#2 und \#3=#3} ``` * `` = `A\bob#1B\anne#2\jane#3bye!` * Es gibt 3 Makro-Parametertokens: `#1`, `#2`, `#3` * Diesmal sind die Parameter (`#1`, `#2`, `#3`) durch eine Kombination von Tokens begrenzt: `A\bob#1B\anne#2\jane#3bye!` Hier haben Sie TeX im Grunde eine Vorlage gegeben, die es sehr sorgfältig versuchen wird zuzuordnen und die es erwartet, wenn Sie `\foo`aufrufen: *Token für Token*, und es erwartet zuzuordnen (zu finden): * die beiden Tokens `Ein` und `\bob` bevor `#1` * die beiden Tokens `B` und `\anne` bevor `#2` * das Token `\jane` vor Parameter `#3` und *vier Zeichentokens* `b`, `und`,`e` und `!` nach `#3`. **Merke**: TeX denkt in Tokens, also `bye!` ist *vier Zeichentokens*. Es gibt zwei Möglichkeiten, wie wir dieses Makro verwenden können — wir könnten alle Argumente mit mehreren Tokens in geschweifte Klammern setzen, um eine Gruppe bereitzustellen: ``` \foo A\bob{Dies}B\anne{Das}\jane{Anderes}bye! ``` Allerdings ist das *nicht notwendig* weil unsere Makrodefinition Begrenzer hat, die eine Tokenvorlage bereitstellen. TeX kann diese Vorlage verwenden, um die Tokens für jedes Argument aus den rein aus Begrenzer-Tokens bestehenden Tokens herauszupicken. Wir können unser Makro so verwenden: ``` \foo A\bob DiesB\anne Das\jane Anderesbye! ``` und TeX kann die Argumente herauspicken, um dasselbe Ergebnis wie bei der Verwendung von Gruppen zu erzeugen `{...}`: ![Overleaf zeigt ein TeX-Makro mit Begrenzer-Ausführung](/files/0b3a69fb210c3411b059fc2de75fd186919c0a5e) Beachten Sie, wie TeX genau erkennen konnte, welche Tokens den Parametern entsprachen `#1` und `#3`: ![Overleaf zeigt ein TeX-Makro mit Begrenzer-Ausführung](/files/7a85cc41f6c2da447753ac1d4825da7a279e9873) #### Begrenzer: Beispiel 4 (es geht alles um Tokens, nicht um Zeichen!) Hier ist ein kurzes Beispiel, das zeigt, dass es bei der Arbeit mit Makros wichtig ist, sich zu erinnern, dass wir uns wirklich in der Welt der *Tokens* und **nicht** *Zeichen*… Wir definieren das folgende kurze Makro, bei dem A und B Zeichen sind, die als Begrenzer fungieren, und beide den Kategoriecode 11 haben. Das funktioniert problemlos: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hallo, #1} \foo AGrahamB \end{document} ``` und setzt `Hallo, Graham`. Wenn Sie jedoch den Kategoriecode von A oder B auf etwas anderes als 11 ändern, schlägt der Makroaufruf fehl. Angenommen, wir ändern den Kategoriecode von B auf 12, mit ``\catcode`B=12`` und versuchen, das Makro erneut aufzurufen, wie zuvor: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hallo, #1} \foo AGrahamB % Das funktioniert \catcode`\B=12\relax \foo AGrahamB \end{document} ``` Es schlägt mit einer etwas rätselhaften Fehlermeldung fehl: ``` Runaway argument? GrahamB \end {document} ! Datei endete, während \foo verwendet wurde. \par <*> main.tex Ich vermute, Sie haben ein `}' vergessen, wodurch ich über die Stelle hinaus gelesen habe, an der Sie wollten, dass ich stoppe. Ich werde versuchen, mich zu erholen; aber wenn der Fehler schwerwiegend ist, sollten Sie jetzt besser `E' oder `X' eingeben und Ihre Datei korrigieren. ! Notstopp. <*> main.tex *** (Auftrag abgebrochen, kein gültiges \end gefunden) ``` ![Overleaf zeigt einen TeX-Makrofehler](/files/c81f9f35acfc2e43f5867c4330ee54b63686d44e) Leider ist TeXs Standardvorschlag von ``Ich vermute, Sie haben ein `}' vergessen`` ist **falsch**, er wird nicht durch eine fehlende geschweifte Klammer verursacht (`}`). #### Was ist passiert? TeX versucht, den `\foo` Makro *Aufruf* mit dem `\foo` Makro *definition* abzugleichen, den es im Speicher gespeichert hat. Wenn Sie ein Makro aufrufen, das ein oder mehrere Argumente benötigt, muss TeX Ihre Verwendung des Makros untersuchen (scannen), um die *Argumente* zu ermitteln, die Sie diesem Makro liefern. Hier erwartet TeX, dass das Argument zwischen einem A (Kategoriecode 11) und einem B (Kategoriecode 11) eingeschlossen ist. Denken Sie daran: TeX denkt in *Tokens*, **nicht** *Zeichen*. Die Tokenwerte für A und B, $$\mathrm{T\_A}$$ und $$\mathrm{T\_B}$$ bzw., sind: $$\mathrm{T\_A = 256 \times 11 + 65 = 2881}$$ $$\mathrm{T\_B = 256 \times 11 + 66 =2882}$$ Während TeX seine Suche fortsetzt, sieht es jedoch das B *aber* jetzt hat es Kategoriecode 12, und das führt zu einem anderen Tokenwert: $$\mathrm{T'\_B= 256 \times 12 + 66 =3138}$$ In dem `\foo` Makrodefinition betrug der Tokenwert für B (als Begrenzer verwendet) 2882, aber TeX sieht jetzt einen Tokenwert von 3138: Es denkt, dass dies nur ein weiteres Token ist, das für die Verwendung in der *Arguments* an \foo `\foo`. So weit TeX betroffen ist, wurde das letzte Token des Arguments noch nicht gefunden, also holt es sich ein weiteres Token bei seiner Suche nach einem B mit Kategoriecode 11. Das ist der Punkt, an dem und der Grund, warum das Makro fehlschlägt: Bei seinem Versuch, das Argument zu finden, „überschießt“ TeX und beginnt, Tokens zu lesen, die Sie nicht als Teil des Arguments für den `\foo` Makroaufruf `Runaway argument?` werden. Was als Nächstes geschieht, hängt von den Tokens ab, die TeX nach dem B entdeckt — sie lösen verschiedene Fehler aus. `\end {document}` und stößt schnell auf das Ende der Datei, daher die Fehlermeldung: ``` ! Datei endete, während \foo verwendet wurde ``` ## Teil 5 Wie wir oben gesehen haben, kann der `` Abschnitt unserer Makrodefinition von extrem einfach bis hin zu einer komplexen Mischung aus Makroparametern reichen, die mit Zeichentokens und Befehlstokens, die als Begrenzer fungieren, durchsetzt sind. TeX ist in der Lage, die verschiedenen in `` enthaltenen Token-Kombinationen zu verarbeiten, um die an ein Makro übergebenen Argumente zu extrahieren — und zu erkennen, wann wir versuchen, ein Makro falsch zu verwenden. Wie es das macht, ist Gegenstand des nächsten Artikels der Reihe. [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/22-how-tex-macros-actually-work-part-4.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.