> 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/53-what-is-a-tex-token.md).
# Was ist ein „TeX-Token“?
## Motivation für eine Artikelreihe über TeX-Token und verwandte Konzepte
Die Motivation und die verwendete Methodik zur Erstellung einer Artikelreihe über TeX-Token und verwandte Konzepte werden in diesem Artikel erörtert [Eine neue Artikelreihe: TeX-Token und verwandte Konzepte — aber warum (und wie)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Wie in jenem Artikel erwähnt, stützen wir uns in dieser gesamten Reihe bei unseren Diskussionen und Erklärungen auf Erkenntnisse, die wir durch einen eigens erstellten Build von Knuths ursprünglichem TeX-Programm gewonnen haben — und verwenden ihn, um eine Reihe von Artikeln zu erstellen, die einfache Beschreibungen und leicht nachvollziehbare Erklärungen zentraler TeX-Konzepte liefern soll.
## Einleitung: Was ist unser Ziel?
In diesem Artikel finden wir genau heraus, was ein TeX-Token ist, indem wir den Verarbeitungsweg von Zeichen in der Eingabedatei bis zur eigentlichen Erzeugung von TeX-Token nachverfolgen. In der Praxis ist das recht komplex, daher haben wir den Prozess auf seine wesentlichen Kernelemente reduziert und bemühen uns, ihn leicht nachvollziehbar und verständlich zu machen, ohne die technische Genauigkeit zu beeinträchtigen.
Wir beginnen mit der Einführung einiger wichtiger interner TeX-Konzepte: *Primitiven*, *Befehlscodes* und *Befehlsmodifikatoren*. Von dort aus verwenden wir ein sehr einfaches Makrobeispiel, um genau zu sehen, wie TeX den Befehl verarbeitet `\def` und das resultierende Token, das TeX zur Darstellung dieses Befehls erstellt.
Abschließend werfen wir einen kurzen Blick darauf, wie TeX Token erstellt, um Zeichen darzustellen, und wie eines Zeichens `\catcode` tatsächlich dauerhaft an ein Zeichen-Token gebunden wird — etwas, das in Büchern über TeX oft erwähnt wird, hier sehen wir jedoch genau, wie das erreicht wird.
Die folgende Grafik zeigt den Weg, den wir zusammenfassen werden — vom Eingabetext zu TeX-Token:
## Aber zuerst: Primitive und Befehlscodes
Jede TeX-Engine (Knuth-TeX, pdfTeX, XeTeX, LuaTeX) kennt eine Reihe eingebauter Befehle: die sogenannten *Primitiven*— die grundlegenden Bausteinbefehle, auf denen die Programmierbarkeit von TeX beruht. Sie heißen „Primitive“, weil sie im Gegensatz zu benutzerdefinierten Makros nicht aus anderen Befehlen aufgebaut sind und sich nicht weiter auf einfachere Anweisungen reduzieren lassen. Für Knuths TeX gibt es ungefähr 320 Primitive — wobei zu beachten ist, dass andere TeX-Engines wie pdfTeX, XeTeX und LuaTeX dem ursprünglichen Programm von Knuth neue Befehle hinzugefügt haben und Primitive enthalten, die in Knuths TeX-Software nicht vorhanden sind.
Intern weist TeX allen Befehlen eine numerische *Befehlscode* zu — ganz gleich, ob es sich um benutzerdefinierte Makros oder eingebaute Primitive handelt. Diese Befehlscodes sind für den TeX-Benutzer nicht zugänglich; sie gehören einfach zu den internen Mechanismen der TeX-Verarbeitung, sind aber nützlich, um sie für die spätere Diskussion über TeX-Token zu kennen.
Befehlsgruppen mit verwandter Funktionalität teilen sich denselben Befehlscode. Zum Beispiel werden die `\def`, `\gdef`, `\edef` und `\xdef` Primitive alle zur Definition von Makros verwendet und teilen sich im TeX von Knuth den Befehlscode 97. Offensichtlich erstellen diese 4 Makrodefinitionsbefehle Makros jeweils auf leicht unterschiedliche Weise; folglich braucht TeX bei der Verarbeitung eine Möglichkeit, sie voneinander zu unterscheiden.
Ein Befehlscode für sich allein (etwa 97) kann nicht sagen, welcher Makroerzeugungsbefehl gemeint ist; daher erhält jeder TeX-Befehl erwartungsgemäß eine zusätzliche Information namens seinem *Befehlsmodifikator* (siehe Beispiele unten).
### Befehlsmodifikatoren: zwei Typen
Befehlsmodifikatoren fallen in zwei Kategorien, die wir hier als „Typ 1“ und „Typ 2“ bezeichnen — TeX verwendet diese Terminologie nicht; es ist hier nur zweckmäßig, sie so zu nennen:
* **Typ 1**: Einfache Ganzzahlwerte, die TeX bei Bedarf verwenden kann, um zwischen Befehlen mit demselben Befehlscode zu unterscheiden.
* **Typ 2**: Ein Ganzzahlwert, der eine numerische Position im Speicher von TeX angibt und TeX mitteilt, wohin es gehen muss, um Informationen zu diesem Befehl nachzuschlagen. Das gilt beispielsweise für benutzerdefinierte Befehle (Makros), bei denen der Befehlsmodifikator TeX sagt, wo die Makrodefinition im Speicher abgelegt ist.
#### Typ-1-Befehlsmodifikatoren (ein Beispiel)
Wie erwähnt, gibt es im TeX von Knuth die vier primitiven Befehle zur Definition von Makros: `\def`, `\gdef`, `\edef`, `\xdef` Sie teilen sich alle den Befehlscode 97; unterschieden werden sie über ihre Befehlsmodifikatoren, die in der folgenden Tabelle aufgeführt sind:
| Befehl | Befehls
code
| Befehls
modifikator
|
| ------- | ---------------------- | ----------------------------- |
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
Als zweites Beispiel entschied sich Knuth, die Befehle `\openout`, `\write`, `\closeout`, `\special`, `\immediate` und `\setlanguage` als „Erweiterungen“ zu TeX zu implementieren, lediglich um zu zeigen, wie man TeX um neue Primitive erweitern kann. In diesem Fall teilen diese Befehle eigentlich keine „ähnliche Funktionalität“, abgesehen davon, dass Knuth beschlossen hat, sie zum Zweck der Erklärung der Erweiterung von TeX zusammenzufassen. Diese 6 Befehle werden als „Erweiterungen“ klassifiziert und mit dem Befehlscode 59 gruppiert, doch jeder besitzt einen passenden Befehlsmodifikator, um ihn von den anderen zu unterscheiden:
| Befehl | Befehls
code
| Befehls
modifikator
|
| -------------- | ---------------------- | ----------------------------- |
| `\openout` | 59 | 0 |
| `\write` | 59 | 1 |
| `\closeout` | 59 | 2 |
| `\special` | 59 | 3 |
| `\immediate` | 59 | 4 |
| `\setlanguage` | 59 | 5 |
#### Typ-2-Befehlsmodifikatoren (kurze Erklärung)
Obwohl alle Befehlsmodifikatoren Ganzzahlen sind, benötigen Typ-2-Modifikatoren etwas mehr Erklärung. Diese Befehlsmodifikatoren werden in TeX als „Zeiger“ bezeichnet, weil sie auf eine Speicherstelle verweisen, an der TeX zusätzliche Informationen zu diesem Befehl finden kann. Das mag etwas vage klingen, aber die Art und Weise, wie TeX diese Zeiger zum Nachschlagen von Informationen verwendet, ist recht vielfältig, und eine ausführlichere Erklärung würde vom eigentlichen Ziel dieses Artikels ablenken. Ein Beispiel mag helfen: Makros. Wenn ein Makrobefehl definiert wird, muss TeX den Ersetzungstext irgendwo im Speicher ablegen. Wie wir unten sehen werden, haben benutzerdefinierte Makros Befehlscodes zwischen 111 und 114, mit einem Befehlsmodifikator, der ein Zeiger in den Speicher ist und TeX mitteilt, wo der Ersetzungstext (die Makrodefinition) gespeichert ist.
### Befehlscodes: expandierbar und nicht expandierbar
Im Quellcode von Knuths TeX reichen die Befehlscodes von 0 bis 120 — beachten Sie, dass einige Codes innerhalb dieses Bereichs ausschließlich für spezielle interne Zwecke verwendet werden und nicht Befehlen zugewiesen sind, die für den Benutzer zugänglich sind. Es ist erwähnenswert, dass andere TeX-Engines wie pdfTeX, XeTeX und LuaTeX dem ursprünglichen Satz von Knuth neue Befehle hinzugefügt haben und daher mehr Primitive sowie entsprechende Befehlscodes enthalten; die hier dargestellten Grundsätze sind jedoch zentral für alle auf Knuths Quellcode basierenden TeX-Engines.
Die Gesamtheit der Befehlscodes ist in zwei Hauptgruppen unterteilt:
* *nicht expandierbare Befehle*: haben Befehlscodes kleiner oder gleich 100;
* *expandierbare Befehle*: haben Befehlscodes größer als 100, bis zu einem Maximalwert von 120. Der Bereich 101 bis 120 umfasst benutzerdefinierte Makros sowie Befehle wie `\csname`, `\expandafter` und `\the`.
Nicht expandierbare Befehle führen typischerweise eine Zuweisung eines Werts an einen internen Parameter durch oder erzeugen direkt Material, das gesetzt werden kann. Expandierbare Befehle „injizieren“ typischerweise einen Strom von Tokens in TeXs aktuelle Verarbeitung oder verändern die Reihenfolge der Tokenverarbeitung.
Wie oben erwähnt, erhalten alle Makros (benutzerdefinierte Befehle) Befehlscodes zwischen 111 und 114; die unterschiedlichen Werte spiegeln wider, ob das Makro definiert wurde als `\long`, `\outer`, beides oder keines von beidem. Hier ein Beispiel:
| Makrotyp | Beispiel | Kommentar |
| ----------------------- | ------------------------------ | ------------------------- |
| Nicht-long, nicht-outer | `\def\ohyeah{....}` | `\ohyeah` Befehlscode=111 |
| Long, nicht-outer | `\long\def\ohyeah{....}` | `\ohyeah` Befehlscode=112 |
| Nicht-long, outer | `\outer\def\ohyeah{....}` | `\ohyeah` Befehlscode=113 |
| Long outer | `\long\outer\def\ohyeah{....}` | `\ohyeah` Befehlscode=114 |
Zur Erinnerung an Befehlsmodifikatoren: Wenn ein Makro definiert wird, speichert TeX die Definition des Makros an einer bestimmten Speicherstelle; diese Stelle (ein Zeiger) wird zum Befehlsmodifikator für den Makrobefehl, der mit einem Befehlscode von 111 bis 114 gespeichert wird, je nachdem, wie er definiert wurde. Der tatsächliche Name, der einem benutzerdefinierten Makro gegeben wird, spielt eigentlich keine Rolle: Nach der Verarbeitung des Eingabetexts erhalten sie alle einen Befehlscode zwischen 111 und 114, und letztlich werden alle Befehle, die TeX aus Ihrer Eingabe liest, ob Primitive oder benutzerdefinierte Makros, schließlich in eine numerische Darstellung umgewandelt, die man ein *Token*.
## Die Reise vom Eingabetext zu TeX-Token
In diesem Abschnitt verwenden wir ein sehr einfaches Makrobeispiel, um genau zu sehen, wie TeX den Befehl verarbeitet `\def` um ein Token zu erzeugen, das den `\def` Befehl darstellt. Die detaillierte Verarbeitungsarbeit von TeX kann extrem komplex sein, daher verwenden wir keine Makroparameter oder Trennzeichen, weil das zusätzliche Komplexität schaffen und von unserer Reise ablenken würde.
Nehmen wir an, Ihre TeX-Eingabedatei enthält die folgende Zeile:
```latex
\def\ohyeah{Overleaf is cool!}
```
Wenn TeX beginnt, diese Eingabezeile zu verarbeiten, prüft es den `\catcode` jedes Zeichens und sieht, dass das erste Zeichen `\\` (erstes Zeichen von `\def`) `\\` hat `\catcode` 0, was bedeutet, dass es den Beginn einer *Steuersequenz*. Natürlich kann man jedem Zeichen `\catcode` 0 zuweisen, aber wir nehmen an, dass die üblichen Definitionen von Plain TeX oder LaTeX verwendet werden.
Genau genommen hat der Begriff *Steuersequenz* zwei Unterkategorien: *Steuerwort* und *Steuersymbol*:
* *Steuerwort*: eine Zeichenfolge mit `\catcode` Letter (11);
* *Steuersymbol*: ein einzelnes Zeichen, dessen `\catcode` ist *nicht* Letter (11) ist.
An diesem Punkt hat das `\\` Zeichen seine Aufgabe erfüllt und ist nun erledigt. Wenn ein Escape-Zeichen erkannt wird, beginnt TeX damit, alle nachfolgenden Zeichen in der Eingabe zu lesen, um ein Steuerwort oder ein Steuersymbol zu erkennen.
Nach dem ersten `\\`erkennt TeX sofort das `d`: ein Zeichen, dessen `\catcode` 11 ist, was TeX mitteilt, dass es den ersten Buchstaben eines *Steuerwort*Steuerworts gefunden hat. Es scannt weiter nachfolgende Zeichen, bis es schließlich ein Zeichen erkennt, das *nicht* hat `\catcode` Letter (11). Alle nachfolgenden Zeichen (nach dem ersten `\\`) mit `\catcode` 11 (Letter) werden als der Name eines Steuerworts betrachtet: also als der Name eines Befehls — vielleicht eines Makros oder eines Primitivs, aber TeX hat bislang keine Ahnung, um welchen Befehlstyp es sich handelt. An diesem Punkt ist es einfach eine Zeichenkette.
In unserem Beispiel scannt TeX also fröhlich weiter und prüft jedes Zeichen, bis es das erste `\\` von `\ohyeah` erreicht, das ebenfalls `\catcode` 0 hat. TeX erkennt, dass es zu weit gescannt hat, und gibt dieses `\\` wieder in den Textstrom zurück, sodass es beim weiteren Scannen des Textes als nächstes Zeichen erscheint. An diesem Punkt hat TeX eine Zeichenfolge identifiziert (`def`) von der es weiß, dass sie den Text eines Steuerworts aus drei Zeichen bildet, von denen jedes `\catcode` 11 (`d`, `e` und `f`) besitzt. Was TeX nun herausfinden muss, ist, was `def` bedeutet: Was soll es damit tun? Wie Sie vielleicht vermutet haben, muss TeX den Befehlscode und die Befehlskennzeichnung für `def` finden, damit es bestimmen kann, was mit diesem Befehl zu tun ist.
## Einen Hash daraus machen
Nachdem ein Steuerwort (`def`) erkannt wurde, besteht das Erste, was TeX tut, darin, die Zeichenfolge (`def` in unserem Beispiel) mithilfe einer sogenannten Hashfunktion in eine ganze Zahl umzuwandeln. Die Details müssen uns nicht allzu sehr beschäftigen; eine grobe Übersicht genügt. Im Wesentlichen betrachtet TeX jedes Zeichen des soeben erkannten Steuerworts und verwendet den ASCII-Codewert (bzw. den Unicode-Wert bei XeTeX/LuaTeX) jedes Zeichens, um eine Zahl zu berechnen, die man Hashwert nennt: einfach eine Ganzzahl.
Im Rahmen dieses Hash-Berechnungsprozesses prüft TeX außerdem, ob die Zeichenfolge des neu erkannten Steuerworts ihm bereits bekannt ist. Der für Menschen lesbare Text aller Befehle, ob Primitive oder benutzerdefinierte Makros, wird in einem internen Speicherbereich abgelegt, der *String-Pool*. TeX muss das tun, weil es möglicherweise den menschenlesbaren Namen eines Befehls ausgeben muss — beispielsweise wenn TeX einen Fehler melden und den Namen des fehlerhaften Befehls angeben soll. Zum Beispiel definiert unser Makro `\def\ohyeah{Overleaf is cool!}` einen neuen Befehl namens `\ohyeah` und TeX wird (zu einem späteren Zeitpunkt) nicht nur einen Hashwert für `ohyeah` (*ohne* das erste `\\` Zeichen) berechnen, sondern auch den Textzeichenfolgen-Form in menschenlesbarer Form speichern, falls sie für Fehlermeldungen (oder andere Aufgaben) benötigt wird.
Wenn Sie mehr Einzelheiten zu TeXs Verfahren zur Behandlung von Zeichenketten möchten, habe ich darüber auf meiner [persönlichen Blogseite](http://www.readytext.co.uk/?p=3590).
Das Endergebnis ist, dass die Zeichenfolge, die den Befehl darstellt, `def` in den numerischen Wert 1218 umgewandelt wird (das ist der tatsächlich von TeX berechnete Wert). An diesem Punkt sind die einzelnen Zeichen `d`, `e` und `f` nicht mehr Teil der Hauptgeschichte — sie wurden aus der Eingabe gelesen und haben ihre Aufgabe erfüllt: Von nun an geht es nur noch um Ganzzahlen und *Tokens*— wir werden gleich sehen, was ein Token eigentlich ist! Intern bezeichnet TeX diese Hashwertzahlen als den *aktuellen Steuersequenz* aber im Quellcode wird dieser Begriff zu einer Variablen mit dem Namen `curcs`. Der Quellcode von TeX ist voller sehr kurzer, oft recht kryptischer Variablennamen.
Aber was tut TeX *eigentlich* mit diesem frisch erzeugten Ganzzahlwert 1218? Wie findet TeX heraus, dass die ursprüngliche Zeichenfolge `def`, nun durch die Ganzzahl 1218 dargestellt, tatsächlich auf eine Anweisung zur Definition eines Makros verweist? Die Antwort ist, dass TeX so etwas wie einen internen „Aktenschrank“ besitzt, in dem es die aktuelle Bedeutung und den aktuellen Wert jedes Befehls speichert, den es gerade kennt — ganz gleich, ob dieser Befehl ein benutzerdefiniertes Makro oder ein eingebautes Primitiv ist. Der Grund, warum TeX sich die Mühe gemacht hat, `def` in den Hashwert 1218 umzuwandeln (nun gespeichert in der Variablen `curcs`) besteht darin, ihn zum Nachschlagen der *Bedeutung* von `def`. TeX wiederholt diese Hash-Berechnung natürlich für alle Steuerwörter, die es in der Eingabe erkennt — wobei unterschiedliche Steuerwörter selbstverständlich unterschiedliche Ganzzahlwerte aus der Hashfunktion liefern: genau das ist der Sinn der Sache.
TeXs interner „Aktenschrank“ heißt *Äquivalenztabelle* und ist das Thema des nächsten Abschnitts.
### Die Äquivalenztabelle konsultieren
Zur Wiederholung: Sehen wir uns an, was wir bisher gelernt haben:
* `\\` leitet den Beginn einer Steuersequenz ein (entweder einer *Steuersymbol* oder einer *Steuerwort*).
* Wenn das erste Zeichen nach dem `\\` hat `\catcode` 11 (Letter), dann ist es der Beginn eines *Steuerwort*.
* Für *Steuerworts* TeX scannt, um alle nachfolgenden Eingabezeichen zu prüfen, die `\catcode` 11 haben, und hört mit dem Scannen auf, sobald es das erste Zeichen findet, das *nicht* eine `\catcode` von 11 hat.
* Die Zeichenfolge der Eingabezeichen (nach dem `\\`) mit `\catcode` 11) gilt als *Steuerwort* die der Benutzer eingegeben hat: ein Befehl, der TeX auffordert, „etwas zu tun“.
* Um mit dem „Etwas tun“ zu beginnen, wandelt TeX die Zeichenfolge des Steuerworts in eine Ganzzahl um. Dafür verwendet es eine sogenannte Hashfunktion, die eine Ganzzahl ausgibt.
* Die Ganzzahl (der berechnete Hashwert) wird als *aktuellen Steuersequenz*bezeichnet, aber TeX verwendet dafür den kürzeren Namen `curcs`.
* In unserem Beispiel wird das Steuerwort `def` in den Wert 1218 umgewandelt — gespeichert in einer Variablen namens `curcs`: also, `curcs=1218`.
TeX muss nun herausfinden, was das neu erkannte *aktuellen Steuersequenz* tatsächlich bedeutet — was macht TeX damit?
#### Ein Hinweis zur Gruppierung: die Notwendigkeit, Informationen zu speichern und wiederherzustellen
Hier machen wir einen kleinen Umweg, um uns daran zu erinnern, dass TeX Informationen speichern und wiederherstellen kann: Es verfügt also über eine Art eingebautes „Gedächtnis“.
Jeder, der auch nur das einfachste Makro geschrieben hat, sollte TeXs Gruppierungsmechanismus kennen — zum Beispiel durch die Verwendung von `\def` um Makros innerhalb einer Gruppe zu erstellen. Wenn Sie nicht das Präfix `\global` vor `\def`-erstellten, innerhalb einer Gruppe definierten Makros setzen, bleibt der Wert oder die Bedeutung dieses Makros nur innerhalb dieser Gruppe (und der darunterliegenden) erhalten: Seine Definition geht verloren, wenn die Gruppe beendet ist. Wenn Sie beispielsweise ein einfaches Makro innerhalb einer Gruppe definieren, so:
```latex
{\def\foo{Hello}}
```
und versuchen, es zu verwenden `\foo` außerhalb der Gruppe
```latex
{\def\foo{Hello}}% \foo innerhalb einer Gruppe definiert (Hinweis: ohne \global)
\foo %<--- nicht mehr definiert, jetzt undefiniert
```
dann erhalten wir die allseits bekannte Fehlermeldung: `Undefinierte Steuersequenz`. `\foo` hat nur innerhalb der Gruppe (und ihrer Untergruppen), in der es definiert wurde, eine Bedeutung. Wenn Sie außerdem ein Makro innerhalb einer Gruppe neu definieren, kann der neue Wert verloren gehen, wenn die Gruppe endet, und die vorherige Bedeutung (die außerhalb der Gruppe bestand) wird wiederhergestellt.
```latex
\def\foo{Goodbye}
\foo\par% Gibt Goodbye aus
{\def\foo{Hello}% In einer Gruppe neu definiert:
{In der Gruppe der 2. Ebene: \foo\par}}% In der Gruppe der 2. Ebene verwendet: \foo gibt Hello aus
Außerhalb der Gruppe wird der alte Wert wiederhergestellt: \foo\par% Gibt Goodbye aus
```
Der Zweck dieser einfachen Beispiele ist zu zeigen, dass TeX über irgendeine Art von „Speichermechanismus“ oder „Gedächtnis“ verfügt, das die „Bedeutung“ von Befehlen speichert und wiederherstellt — und das tut es natürlich. Darauf haben wir im vorigen Abschnitt bereits hingewiesen: Dieser „Speichermechanismus“ oder „Aktenschrank“ ist eine große interne Tabelle namens *Äquivalenztabelle*. Darin speichert TeX die aktuelle Bedeutung bzw. die Werte aller Befehle, die es derzeit kennt — die eingebauten Primitive und die benutzerdefinierten Makros.
### Die Äquivalenztabelle: per Analogie
Um die Äquivalenztabelle zu erklären, gehen wir analog vor. Wir verwenden weiterhin das Bild eines Aktenschranks mit Tausenden kleiner Schubladen, jede mit einer eindeutigen Ganzzahl beschriftet. An dieser Stelle der Verarbeitung sagt TeX im Grunde:
„OK, ich habe diesen Ganzzahlwert 1218, den ich gerade berechnet und in einer Variablen namens `curcs`. Ich muss nun herausfinden, was er bedeutet: Dazu gehe ich und schaue in Schublade Nummer 1218 meines Aktenschranks, um zu sehen, was dort steht.“
TeX verwendet 1218, um die richtige Schublade zu finden, und dort entdeckt es einen kleinen Zettel, der drei Informationen enthält, deren Bezeichnungen die im Quellcode von TeX verwendeten Namen sind:
* **`eq_level:`** die Gruppierungsebene, auf der dieser Eintrag definiert wurde (Ebene 1 = global definiert). Wir haben die Auswirkungen der Gruppierung oben bereits in Aktion gesehen: Hier in der Äquivalenztabelle wird diese Information zur Gruppierungsebene gespeichert;
* **`eq_type:`** der Befehlscode für diesen Eintrag;
* **`equiv:`** aktueller „Wert“ dieses Eintrags — das kann eine einfache Ganzzahl sein, wie der oben erwähnte Befehlsmodifikator, oder ein Zeiger auf einen Speicherbereich; zum Beispiel die Speicheradresse für die Sammlung von Tokens, die eine Makrodefinition darstellen.
Unser Hashwert 1218 (gespeichert in der Variablen `curcs`) wurde also faktisch als *Schlüssel* verwendet, um auf eine Schublade zuzugreifen, die die aktuelle Bedeutung und den aktuellen Wert des Befehls enthält, den wir ursprünglich als Buchstabenfolge eingegeben haben `\def`.
Im Quellcode des TeX-Programms wird der `eq_type` für jeden Befehl mit einer Variablen namens `curcmd` und der Wert von `equiv` wird in einer Variablen namens `curchr`.
### Was sagt die Äquivalenztabelle über def aus?
Wie erwähnt, wird der für einen beliebigen Befehl berechnete Hashwert in einer Variablen namens `curcs`gespeichert; daher haben wir für `def` folgende Beziehung `curcs=1218`. Beim Blick auf die Position 1218 in der Äquivalenztabelle findet TeX die folgenden Informationen:
* `curcmd`=97. Dies ist der Befehlscode für `\def`;
* `curchr`=0. Dies ist der Befehlsmodifikator für `\def`.
`\def` ist ein primitives (eingebautes) TeX-Kommando, und sofern es irgendwo nicht neu definiert wurde, sollte die dritte und letzte Information lauten `eq_level=1` und zeigt damit an, dass die Bedeutung von `\def` global definiert ist und nicht auf eine niedrigere Gruppierungsebene beschränkt ist. Intern wird der Wert von `eq_level` der einem Befehl zugeordnet ist, im Gruppierungsmechanismus von TeX eine äußerst wichtige Rolle spielen, aber darauf werden wir nicht weiter eingehen.
Die folgende Grafik fasst die Erklärung zusammen, die wir erarbeitet haben:
## TeX-Token für Befehle
Nachdem wir uns durch die obigen Erklärungen gearbeitet haben, stellt sich heraus, dass die eigentliche Berechnung von TeX-Tokens für Steuersequenzen wirklich sehr einfach ist. TeX verwendet den Wert von `curcs` (1218) aus der Hashfunktion, um daraus eine einfache Ganzzahl zu erzeugen, die es ein *Token*Token `curcs` lautet:
```c
curtok = 4095 + curcs
```
TeX speichert den Wert des aktuellen Tokens (zuletzt berechnet) in einer Variablen namens `curtok`.
Zusammenfassend ist das TeX-Token, das den `\def` Befehls ist `4095 + 1218 = 5313`. Und das war's zu TeX-Tokens, die Befehlssequenzen darstellen: Es handelt sich einfach um eine Ganzzahl, die aus einem Hash-Tabellenwert plus 4095 berechnet wird.
## TeX-Tokens für Zeichen
Wenn TeX ein Token erzeugen muss, das ein Zeichen darstellt, verwendet es die folgende, ebenso einfache Berechnung:
```c
curtok = 256*catcode + (ASCII value of character)
```
Beachten Sie, dass für Unicode-fähige Engines wie LuaTeX leicht unterschiedliche Berechnungen verwendet werden.
Zum Beispiel ist das TeX-Token, das ein Leerzeichen darstellt, mit `\catcode` dem Catcode 10 und dem ASCII-Wert 32:
```c
256*10 + 32 = 2592
```
### Tokenlisten mit Zeichen
Wenn Sie eine einfache Tokenliste erstellen, zum Beispiel mit
```latex
\toks100={Hello}
```
wird TeX die folgende Tokenliste erzeugen und sie für die spätere Verwendung im Speicher ablegen:
* H→ 256 × 11 + 72 = 2888
* e→ 256 × 11 + 101 = 2917
* l→ 256 × 11 +108 = 2924
* l→ 256 × 11 +108 = 2924
* o→256 × 11 + 111 = 2927
Tief im Speicher von TeX verschafft das Tokenregister 100 Zugriff auf den Speicherort von „Hello“, gespeichert als 5 Tokenwerte: 2888, 2917, 2924, 2924, 2927. Beachten Sie, dass diese Tokens den ASCII-Code jedes Zeichens und den Wert seines `\catcode`an dem Punkt, an dem sie in Tokens umgewandelt werden (tokenisiert). Sobald Zeichen in Zeichen-Tokens umgewandelt wurden, ist der `\catcode` ihnen zugeordnete Wert dauerhaft und wird innerhalb der Tokens für die spätere Verwendung gespeichert, wenn der Benutzer zum Beispiel `\the\toks100`.
Wie erwähnt, wird ein Zeichen-Token berechnet aus `256*catcode + (ASCII value)` während ein Steuersequenz-Token berechnet wird aus `4095 + curcs` wobei `curcs` ist der Hashwert des Steuerworts (Textzeichenfolge eines vom Benutzer eingegebenen Befehls), das von TeX in der Eingabe erkannt wird. Es ist erwähnenswert, dass Zeichen-Token immer kleiner als 4095 sind. Daher kann TeX leicht feststellen, ob ein bestimmtes Token eine Steuersequenz (einen Befehl) oder ein Zeichen darstellt, und dann ermitteln, welche Steuersequenz bzw. welches Zeichen und `\catcode` Paar in dieses Token kodiert ist.
---
# 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/53-what-is-a-tex-token.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.