> 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/nl/diepgaande-artikelen/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md). # Hoe werkt \expandafter: een introductie tot TeX-tokens [Deel 1](/latex/nl/diepgaande-artikelen/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Deel 2](/latex/nl/diepgaande-artikelen/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Deel 3](/latex/nl/diepgaande-artikelen/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Deel 4](/latex/nl/diepgaande-artikelen/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Deel 5](/latex/nl/diepgaande-artikelen/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Deel 6](/latex/nl/diepgaande-artikelen/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Achtergrond bij \expandafter: TeX-tokens en tokenlijsten Als eerste stap om te begrijpen hoe `\expandafter` echt werkt, bekijken we twee onderdelen van TeX die fundamenteel zijn voor de werking van `\expandafter`: TeX-tokens (gehele getallen) en tokenlijsten (lijsten van gehele getallen). Lezers die deze onderwerpen veel gedetailleerder willen verkennen, kunnen geïnteresseerd zijn in de volgende artikelen van Overleaf: * [Wat is een TeX-token?](/latex/nl/diepgaande-artikelen/53-what-is-a-tex-token.md) * [Wat is een TeX-tokenlijst?](/latex/nl/diepgaande-artikelen/54-what-is-a-tex-token-list.md)-[Hoe werken TeX-macro's eigenlijk?](/latex/nl/meer-onderwerpen/01-a-six-part-series-how-do-tex-macros-actually-work.md) ### Waar kwamen de tokendata vandaan? In dit artikel gebruiken we echte tokenwaarden die door TeX worden berekend—gegevens die normaal gesproken niet toegankelijk zijn voor gebruikers. Voor lezers die nieuwsgierig zijn naar hoe deze tokenwaardedata zijn verkregen, heeft Overleaf aangepaste builds van verschillende TeX-engines die we voor onderzoek gebruiken. Die engines zijn aangepast om informatie uit te voeren over TeX’ interne verwerkingsactiviteiten—en zo extra achtergrondmateriaal te bieden voor enkele van de artikelen die we produceren. Door numerieke tokenwaarden te tonen/bespreken, willen we details opnemen die hopelijk lezers helpen “TeX-tokens” beter te begrijpen, waardoor dit belangrijke concept iets minder ondoorzichtig aanvoelt. ## TeX-tokens 101 (en begrippen rond expansie) Wanneer TeX je invoerbestand verwerkt, leest het de tekst en zet het afzonderlijke tekens en tekenreeksen (commando's) om in zogeheten *tokens*. Een TeX-token is simpelweg een gehele waarde, berekend door TeX, die wordt gebruikt om gegevens te “coderen” die TeX moet opslaan over een item dat uit de huidige invoerbron is ingelezen. Zie tokens als kleine pakketjes informatie die de gegevens die TeX moet vastleggen bundelen, klaar om door te geven aan de volgende verwerkingsfase. Intern werkt TeX met die gehele tokenwaarden—het gebruikt niet de daadwerkelijke letters, symbolen, cijfers enz. die oorspronkelijk in je invoerbestand stonden: alles wordt omgezet in een token (een geheel getal) en TeX werkt daarmee. ## Hoe TeX tokenwaarden berekent Hier bekijken we tokenberekeningen die worden gebruikt in Knuths originele TeX, e-TeX en pdfTeX; voor andere TeX-engines, met name XeTeX en LuaTeX, moeten hun tokenberekeningen iets anders zijn om rekening te houden met het gebruik van Unicode, maar de rekenmethoden zijn vergelijkbaar met die hieronder beschreven. ### Teken-tokens (niet-actieve tekens) De berekening van tokenwaarden voor niet-actieve tekens is eenvoudig: $$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$ **Voorbeeld**: De letter A met [categoriecode](/latex/nl/meer-onderwerpen/43-table-of-tex-category-codes.md) 11, tekencode 65 wordt in TeX weergegeven als de teken-tokenwaarde $$256\times 11 + 65 = 2881$$. Je kunt in TeX-literatuur beschrijvingen tegenkomen waarin staat dat zodra TeX een teken heeft ingevoerd, de categoriecodewaarde daarvan “permanent gebonden” raakt aan dat teken: de bovenstaande berekening van tokenwaarden laat zien waarom dat zo is. Later in TeX’ verwerking kan het echter teken-tokens “uitpakken” om het samenstellende paar (tekencode, categoriecode) waaruit de token werd opgebouwd te onthullen—wanneer TeX dat “uitpakken” doet, verandert het nog steeds de categoriecode van dat teken niet, het gebruikt die informatie alleen tijdens de daaropvolgende verwerking. ### Commandotokens TeX’ invoerverwerking en tokengeneratie herkennen twee typen commando: * commando's die zijn opgebouwd uit een of meer tekens met categoriecode 11; * commando's van één teken waarbij de categoriecode van dat teken niet 11 is: zoals `\$` of `\#`. In beide gevallen laat TeX het eerste `\` teken weg en gebruikt het de tekencode van elk resterend teken om een geheel getal te berekenen dat TeX noemt `curcs` (**cur**rent **c**ontrol **s**reeks). TeX gebruikt vervolgens de waarde van `curcs` om een tokenwaarde voor het commando te berekenen. #### Commando's opgebouwd uit tekens met categoriecode 11 Stel dat ons commando (zonder het eerste `\` teken) is samengesteld uit een reeks tekens: $$\mathrm{C\_1C\_2C\_3...C\_N}$$ waar $$\mathrm{C}\_i$$ is de tekencode van elk teken—bijv. de tekencode van A is 65. TeX gebruikt alle tekencodes $$\mathrm{C}\_i$$ om het gehele getal te berekenen `curcs` (met behulp van een [hashfunctie](https://en.wikipedia.org/wiki/Hash_function)). Zodra TeX de waarde van `curcs` heeft berekend, telt het eenvoudig 4095 bij die waarde op, om de tokenwaarde te krijgen: $$\text{command token} = \text{curcs + 4095}$$ Merk op dat de variabele `curcs` een uiterst belangrijke rol speelt in TeX’ interne verwerkingsactiviteiten. #### Commando's van één teken Tokens om commando's zoals `\$`, `\#` enz. weer te geven zijn onderworpen aan een iets andere berekening: het gehele getal `curcs` is nu de eenvoudigere berekening: $$\text{curcs} = 257 + \text{character (ASCII) code}$$ Bijvoorbeeld, met `\$`, $$\text{curcs}=257 + 36 = 293$$. TeX telt opnieuw 4095 bij deze waarde op (met behulp van $$\text{command token} = \text{curcs} + 4095$$) wat resulteert in `\$` een tokenwaarde heeft $$293 + 4095 = 4388$$. Vergeleken met commando's die bestaan uit tekens met categoriecode 11, is het enige verschil hier de manier waarop TeX de waarde voor `curcs`. **Opmerking**: het gehele getal `curcs` wordt niet berekend voor teken-tokens: het staat altijd op 0 wanneer TeX teken-tokens aanmaakt of ermee werkt. #### Tokens van actieve tekens TeX kent het concept van zogenoemde *actieve tekens*: elk teken waaraan categoriecode 13 is toegewezen. Tokens voor deze speciale klasse tekens zijn onderworpen aan een andere berekening dan gewone tekens. Het mechanisme van actieve tekens stelt TeX in staat om in feite macro's van één teken te maken die je kunt gebruiken *zonder* zonder het actieve teken te moeten voorafgaan door een escape-teken (typisch `\`): het afzonderlijke teken zal zijn macrogedrag activeren. Het klassieke voorbeeld is het tilde-teken (\~) dat TeX/LaTeX gebruiken voor niet-afbrekende spaties, en dat als volgt kan worden gedefinieerd/geactiveerd: ``` \catcode`~=13 %wijs categoriecode 13 toe aan ~ \def~{\penalty100000\ } % definieer ~ om als macro te fungeren ``` Wanneer TeX vervolgens een `~` teken leest, zal het detecteren dat de categoriecode 13 is en het als een “mini-macro” verwerken. Om een token te berekenen dat een actief teken vertegenwoordigt, past TeX nog een variatie toe voor het berekenen van `curcs`: $$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$ Bijvoorbeeld: het teken \~ heeft tekencode 126, wat betekent dat de representatie van de tokenwaarde voor het actieve teken als volgt wordt berekend: $$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$ Merk op dat, net als commando's, tokens die actieve tekens vertegenwoordigen > 4095 zijn. ### Gevolgen/opmerkingen * Elk token waarvan de waarde groter is dan 4095, is onmiddellijk herkenbaar als een commandotoken—daardoor kan TeX heel gemakkelijk detecteren of een bepaald token een teken of een commando vertegenwoordigt. * Voor elke tokenwaarde kan TeX, wanneer nodig, dat token “uitpakken” om het teken (en zijn categoriecode) of het commando te onthullen dat oorspronkelijk aanwezig was in je `.tex` bestand, opgeslagen in een macrodefinitie of opgenomen in een andere tokenlijst. * De “tussenliggende” grootheid genaamd `curcs`—die TeX gebruikt om commandotokenwaarden te berekenen—speelt een belangrijke rol in TeX’ verwerking op laag niveau. `curcs` fungeert als een “indexwaarde” die TeX gebruikt om de huidige betekenis van een commando op te slaan/op te zoeken. Gegeven elk commandotoken, $$\mathrm{T}$$, trekt TeX eenvoudig 4095 af om de waarde van `curcs`: $$\text{curcs} = \mathrm{T}-4095$$ Terzijde: TeX slaat wel de voor mensen leesbare tekenreeks op waaruit een commandotoken wordt gegenereerd—dit is essentieel voor foutmeldingen en andere commando's zoals `\string` waarvan de expansie de voor mensen leesbare versie van een tokenwaarde is. Die voor mensen leesbare tekenreeksen die in TeX zijn opgeslagen, worden echter alleen gebruikt/uitgevoerd wanneer daarom wordt gevraagd: voor alle andere verwerking wordt de gehele tokenwaarde gebruikt. ## Naar enkele echte tokens kijken Om het begrip tokens iets minder ondoorzichtig te maken, definiëren we de volgende eenvoudige macro en bekijken we de tokens die TeX produceert: ``` \def\hello{Greetings, from \TeX. \hskip 10pt} ``` Voor de `\hello` macro, gebruikt TeX de tekens `h`, `e`, `l`, `l`, `of` om een waarde van 3745 te berekenen voor `curcs`; TeX telt vervolgens 4095 op om een tokenwaarde te creëren van $$3745 + 4095 = 7840$$ (voor Knuths TeX, e-TeX of pdfTeX). Nadat het een token heeft aangemaakt om `\hello`, de `\def` commando zorgt ervoor dat TeX de daaropvolgende tokens leest en ze gebruikt om een tokenlijst te creëren die wordt opgeslagen als het *definition* van de `\hello` commando. Die opgeslagen definitie (tokenlijst) kan vervolgens worden opgehaald wanneer je TeX vertelt om de `\hello` commando. De volgende tabel geeft de werkelijke tokenwaarden weer die zijn gemaakt voor elk item (teken, macro of primitief) in de `\hello` macrodefinitie—deze lijst van tokens (gehele getallen) is wat TeX in zijn geheugen opslaat (als datastructuur bekend als een [gekoppelde lijst](https://en.wikipedia.org/wiki/Linked_list)). Lezers die tokenlijsten gedetailleerder willen begrijpen, worden verwezen naar het Overleaf-artikel [Wat is een TeX-tokenlijst?](/latex/nl/diepgaande-artikelen/54-what-is-a-tex-token-list.md) | | | | ------------------- | ---------------------- | | **TeX-tokenwaarde** | **Weer te geven item** | | 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 | of | | 2925 | m | | 2592 | | | 5235 | \TeX | | 3118 | . | | 2592 | | | 7943 | \hskip | | 3121 | 1 | | 3120 | 0 | | 2928 | p | | 2932 | t | In de bovenstaande tokenlijst hebben de tekens categoriecodes 10, 11 of 12. Bijvoorbeeld: * tekens hebben categoriecode 10 en tekencode 32, wat een tokenwaarde geeft van $$256\times 10 + 32 = 2592$$ * `,` en `.` hebben categoriecode 12 en tekencodes 44 en 46 respectievelijk, wat de tokens oplevert: * token voor `,` $$= 256 \times 12 + 44 = 3116$$ * token voor `.` $$= 256\times 12+ 46 = 3118$$ Wanneer TeX vervolgens de tokenwaarde 7840 tegenkomt (die `\hello`) kan het, indien nodig, dat token “uitpakken” om `curcs` via de eenvoudige berekening $$\text{curcs} = \text{token value} - 4095$$ (zie hierboven). Met de waarde van `curcs` kan TeX zijn interne datatabellen raadplegen om vast te stellen dat commandotoken 7840 een macrocommando vertegenwoordigt. Daarnaast kan TeX, opnieuw via `curcs`, ook de opgeslagen definitie van `\hello`. Wanneer TeX token 7840 volledig moet verwerken, d.w\.z. om de `\hello` macro uit te voeren, heeft het token 7840 niet langer nodig: dat token heeft *zijn werk gedaan*—d.w\.z. het heeft TeX geactiveerd om de macro uit te voeren `\hello`. TeX kan token 7840 nu weggooien en de tokens ophalen die de definitie (tokenlijst) voorstellen die in het geheugen is opgeslagen. In feite is het `\hello` macrocommando (token 7840) is *verwijderd* uit TeX’ huidige invoerbron en *vervangen* door tokens uit de definitie van `\hello`. Wat we zojuist hebben beschreven is een vorm van *tokenexpansie*. De `\TeX` commando (tokenwaarde 5235 hierboven vermeld) gebruikt binnen `\hello` is zelf een macro die uit meer tokens is opgebouwd—dus de definitie ervan wordt ook opgeslagen als een tokenlijst: | | | | ------------------- | ---------------------- | | **TeX-tokenwaarde** | **Weer te geven item** | | 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 | Als we het `\hello` commando zouden vervangen door de volledige lijst tokens waaruit het is opgebouwd, inclusief de `\TeX` macro, dan zou het een vrij lange lijst zijn—oftewel, als we ook de *uitgebreid* het `\TeX` macro zouden uitbreiden, zouden we zien: ![Een lijst tokens opgeslagen in een TeX-macro](/files/3b3c87fbcccb78fba8cc6efab583de9912d1ab5f) In wezen zou de enkele tokenwaarde 7840 (voor `\hello`) bij volledige expansie in totaal 51 tokens (gehele getallen) produceren die tekens en primitieve commando's voorstellen. In de volgende lijst staat het teken of commando dat door elk token wordt weergegeven tussen haakjes “(...)”—deze worden niet rechtstreeks opgeslagen in TeX’ tokenlijsten en zijn bedoeld ter ondersteuning van de lezer: ``` 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) ``` Voor een menselijke lezer is dit slechts een reeks gehele getallen, maar voor TeX codeert het een grote hoeveelheid informatie. ## Lees tokens nu en sla ze op voor later Terwijl TeX je invoer leest, kan het voorkomen dat het de volledige verwerking van een bepaalde set tokens moet (of wordt opgedragen te) uitstellen. Als het hiertoe wordt geïnstrueerd, zal TeX, totdat het krijgt te horen te stoppen, tokens uit de invoer blijven creëren maar ze opslaan voor later gebruik—om ze vervolgens op te halen en te verwerken als onderdeel van zijn zetactiviteiten. Die opgeslagen tokens worden bewaard als zogenoemde *tokenlijsten* die in feite TeX’ enige (interne) opslagmechanisme voor tokendata zijn. We hebben al voorbeelden van tokenlijsten gezien—de `\hello` en `\TeX` hierboven vermelde macro's: de definities van die macro's worden in TeX’ geheugen opgeslagen als lijsten tokens. TeX zal zulke tokenlijsten alleen verwerken (activeren) wanneer je besluit die macro's aan te roepen. Onthoud ook dat elk token (gehele waarde) voldoende informatie codeert voor TeX om gemakkelijk te bepalen of elk token dat in een macrodefinitie is opgeslagen een teken of een commando vertegenwoordigt. ### Tokens opslaan met tokenregisters Een ander voorbeeld van tokenopslag is het expliciet aanmaken van lijsten tokens die worden opgeslagen in zogenoemde *tokenregisters*: speciale interne opslagruimten die TeX aan gebruikers biedt om tokenlijsten op te slaan. Het TeX-primitief `\toksdef` is een manier om tokenregisters te gebruiken; bijvoorbeeld, om tokenregister `100` te gebruiken en ernaar te verwijzen met het commando `\mylist`: ``` \toksdef\mylist=100 \mylist={enkele \TeX{}-tokens hier} ``` `\mylist` is in feite gewoon een naam die je toewijst aan een lijst tokens die is opgeslagen op registerlocatie `100`. Vergelijkbaar met een macrodefinitie, `\mylist` bevat de volgende tokenlijst: | | | | ------------------- | ---------------------- | | **TeX-tokenwaarde** | **Weer te geven item** | | 2931 | s | | 2927 | of | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | 379 | { | | 637 | } | | 2592 | | | 2932 | t | | 2927 | of | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | **Opmerking**: om de `\TeX` macro te beëindigen en te voorkomen dat deze de volgende `` teken opneemt, gebruikten we een paar accoladen `{}` direct na `\TeX`—de tokens voor `{` (379) en `}` (637) worden in de tokenlijst opgeslagen. Een andere optie is om een “control space”-token te gebruiken `\` dat in de tokenlijst zou verschijnen zoals hieronder getoond (vetgedrukt): | | | | ------------------- | ---------------------- | | **TeX-tokenwaarde** | **Weer te geven item** | | 2931 | s | | 2927 | of | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | **4384** | **\\** | | 2932 | t | | 2927 | of | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | Merk op dat de `` teken wordt weergegeven als een *tekentoken* met waarde $$256\times 10 + 32 = 2592$$ maar `\` wordt behandeld als een commando van één teken *commando-token* (waarde 4384), die wordt berekend met behulp van de hierboven gegeven formules: \begin{align\*} \text{curcs} & = 257 + \text{character (ASCII) code}\\\ & = 257 + 32\\\ &=289\\\ \text{command token for} \left<\text{\\\space}\right> & = \text{curcs + 4095}\\\ & = 289+4095\\\ &=4384\\\ \end{align\*} In wezen `\mylist={enkele \TeX{}-tokens hier}` zegt tegen TeX: scan alstublieft mijn invoerbestand om de volgende tekens/commando's om te zetten in tokens en sla ze op voor later gebruik. TeX zal daaraan voldoen en die tokens opslaan op een geheugenlocatie die je kunt openen door te schrijven `\the\mylist`, waarmee TeX wordt opgedragen een kopie in te voegen van de tokens in tokenregister `\mylist`. TeX-engines bevatten een aantal primitieve commando's die expliciet tokenlijsten genereren en opslaan—zoals `\everyjob`, `\everypar`, `\mark`, en vele andere. [Deel 1](/latex/nl/diepgaande-artikelen/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Deel 2](/latex/nl/diepgaande-artikelen/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Deel 3](/latex/nl/diepgaande-artikelen/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Deel 4](/latex/nl/diepgaande-artikelen/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Deel 5](/latex/nl/diepgaande-artikelen/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Deel 6](/latex/nl/diepgaande-artikelen/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/nl/diepgaande-artikelen/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.