> 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Hoe werkt \expandafter: van basisprincipes tot het verkennen van de broncode van TeX [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) ## Inleiding We hebben nu de achtergrondonderwerpen behandeld die nodig zijn voor een volledige verkenning van `\expandafter`: * de basis van TeX-tokens en hoe ze worden berekend; * de principes achter TeX’ expansieproces; * TeX’ gebruik/aanmaak van tijdelijke tokenlijsten tijdens documentverwerking; * hoe TeX meerdere invoerbronnen gebruikt en ermee “jongleert” (inclusief tijdelijke tokenlijsten). In dit artikel brengen we deze onderwerpen/concepten samen om de mechanismen achter TeX’ `\expandafter` commando uit te leggen: kort gezegd hoe het werkt. ## En dus, om \expandafter Het idee achter `\expandafter` is om de expansie van een commando (token) af te dwingen voordat TeX dat normaal zou doen. Gegeven twee tokens, $$\mathrm{T\_1}$$ en $$\mathrm{T\_2}$$ de werking van `\expandafter` $$\mathrm{T\_1T\_2}$$ leidt ertoe dat TeX verwerkt $$\mathrm{T\_1}\text{<}$$expansie van $$\mathrm{T\_2}\text{>}$$, waarbij $$\text{<}\dots\text{>}$$ een lijst van tokens aanduidt. TeX expandeert $$\mathrm{T\_2}$$ van tevoren zodat token $$\mathrm{T\_1}$$ (bijv. een primitief of een macro) de tokens te zien krijgt, of erop kan reageren, die voortkomen uit de expansie van $$\mathrm{T\_2}$$. Als het token $$\mathrm{T\_2}$$ een niet-expandeerbaar item voorstelt, zoals een niet-actief teken of (de meeste) primitieve elementen, dan heeft de werking van `\expandafter` verandert niets: TeX zou tokens blijven verwerken $$\mathrm{T\_1T\_2}$$ op de normale manier. ### Inleiding tot het gebruik van \expandafter Als je `\expandafter`nog niet hebt gebruikt, hier is een voorbeeld van gebruik met het primitieve `\uppercase{...}`. Stel dat we de naam van ons hoofdinvoerbestand in hoofdletters wilden zetten. We kennen misschien de volgende TeX-primitieve commando’s: `.tex` invoerbestand in hoofdletters wilden zetten. We kennen misschien de volgende TeX-primitieve commando’s: * `\uppercase`: doet wat de naam al zegt, zet karaktertokens om naar hun equivalent in hoofdletters (waar dat bestaat); * `\jobname`: zoals we hebben gezien, expandeert tot de naam van het hoofdinvoerbestand `.tex` bestand. Stel dat ons TeX-bestand heet `mycode.tex` dan zouden we redelijkerwijs verwachten `\uppercase{\jobname}` te zetten `MYCODE`. Maar nee, het zet `mycode` in kleine letters. Wat ging er “fout”? Als we het algemene gebruik van `\uppercase` als ``` \uppercase{} ``` kunnen we zeggen dat `\uppercase` door `` en alleen zal werken (van hoofd-/kleine letters veranderen) op *karaktertokens* die het detecteert binnen de ``: alle niet-karaktertokens worden *genegeerd* omdat `\uppercase` niet “in” niet-karaktertokens zal kijken (expanderen) om te zien wat ze bevatten of voorstellen. Omdat een token simpelweg een gehele waarde is, hoeft `\uppercase` alleen door de tokenlijst te kijken om te controleren of de numerieke waarde van elk token in `` binnen het bereik valt van waarden die een karaktertoken aanduiden. Trouwens, `\uppercase` zal ook *de hoofd-/kleine lettervorm van actieve tekens veranderen* om een actief teken in hoofdletters te maken, dat, omdat het nog steeds actief is, ook gedefinieerd moet zijn; anders zal TeX een fout genereren: `Ongedefinieerde controlevolgorde`, maar we dwalen af... Bijvoorbeeld, zelfs als we een macro definiëren die gewoon tekst is ``` \def\foo{some lower-case text} ``` dan `\uppercase{\foo}` zet nog steeds `some lower-case text` en niet `SOME LOWER-CASE TEXT` zoals we zouden hopen, simpelweg omdat de werking van `\uppercase` niet probeert te bepalen wat `\foo` voorstelt: het ziet `\foo` als een commando-token en negeert het, net zoals het deed met `\jobname`. ### Hoe kunnen we dit oplossen? \expandafter biedt uitkomst Om een versie in hoofdletters van de bestandsnaam te zetten, moeten we `\uppercase{\jobname}` aanpassen door TeX te dwingen `\jobname` te vervangen door zijn expansie (een reeks karaktertokens) *voordat* `\uppercase` aan het werk gaat. Opnieuw wordt expansie gebruikt om het `\jobname` token (commando) te verwijderen en te vervangen door het resultaat van zijn expansie (een tokenlijst met karaktertokens). Dus, als we schrijven ``` \uppercase\expandafter{\jobname} ``` dan werkt het: `MYCODE` zou gezet worden. Wat er gebeurt is dat TeX begint met het verwerken van `\uppercase` en onmiddellijk controleert op het verplichte openingsaccoladekenmerk (`{`); echter, TeX detecteert een `\expandafter` commando dat ervoor zorgt dat het tijdelijk zijn “aandacht verlegt” naar het verwerken van `\expandafter{\jobname}`. Als we `\expandafter` $$\mathrm{T\_1T\_2}$$ met ons voorbeeld vergelijken `\expandafter{\jobname}` kunnen we zien * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\jobname`token Waar `{`token en `\jobname`token verwijzen naar de tokenwaarden die door TeX zijn berekend—de subscriptnotatie token wordt gebruikt om ons eraan te herinneren dat TeX in de wereld van gehele tokens werkt. Het schrijven van `\uppercase\expandafter{\jobname}` werkt omdat, in grote lijnen (details volgen), `\expandafter` TeX de volgende taken laat uitvoeren: 1. lees en sla de openings `{`token; 2. lees het volgende token: `\jobname`token. TeX herkent dat `\jobname`token een expandeerbaar commando voorstelt en het expandeert. `\jobname`token wordt vervangen door zijn expansie—een reeks karaktertokens; 3. nadat het `\jobname` commando heeft geëxpandeerd, plaatst TeX de `{`$$\_\mathrm{token}$$ “terug in de invoer” en gebruikt de tokenlijst die voortkomt uit de expansie van `\jobname` zodat TeX zal lezen `\uppercase{`token``tokenlijst (tekens)`}`, en dit levert ons gewenste resultaat op. Het volgende diagram laat zien hoe TeX verwerkt `\uppercase\expandafter{\jobname}`—lees de afbeelding van onder naar boven om de processtroom te volgen. ![Hoe \expandafter werkt](/files/4431ee8912833255ab7ec77fbc7e03bdad6c22d5) De volgende opmerkingen leggen de verschillende verwerkingsfasen uit. 1. TeX begint met het verwerken van `\uppercase` en controleert op het verplichte openingsaccoladekenmerk (`{`) maar detecteert een `\expandafter` opdracht moet interpreteren. 2. Als we `\expandafter` $$\mathrm{T\_1T\_2}$$ in onze invoer van `\expandafter{\jobname}` kunnen we zien $$\mathrm{T\_1} =$$`{`token en $$\mathrm{T\_2} =$$`\jobname`token. Merk op dat we hier de subscript token gebruiken om aan te geven dat TeX gehele tokenwaarden verwerkt. 3. `\expandafter` leest, en slaat vervolgens tijdelijk de `{`token op door die gehele tokenwaarde op te slaan in een interne variabele. Later zal TeX dat token opnieuw in de invoer invoegen, na verwerking van de `\jobname` opdracht moet interpreteren. 4. `\expandafter` leest TeX het volgende token, `\jobname`token, en expandeert het `\jobname` opdracht moet interpreteren. 5. De expansie van `\jobname` maakt een tijdelijke tokenlijst aan die een reeks karaktertokens bevat die de `.tex` bestandsnaam voorstellen. Merk op dat alle karaktertokens die door `\jobname` worden gegenereerd, worden berekend met categoricode 12. 6. Zodra `\jobname` is geëxpandeerd, voegt TeX het in stap 3 opgeslagen token opnieuw in (`{`token) en plaatst het terug in de invoer. TeX doet dat door nog een tokenlijst te maken die de *enkele* `{`token 7. TeX heeft nu klaar met het verwerken van `\expandafter`, wat resulteert in twee tokenlijsten die klaar zijn om als bronnen van TeX-invoer te worden gebruikt. TeX keert nu terug naar het verwerken van `\uppercase` maar heeft zijn invoer zo geconfigureerd dat de twee tokenlijsten gemaakt door `\expandafter` de bron van tokens worden voor `\uppercase`—die nu ziet `\uppercase{`token``tokenlijst (tekens)`}`. `\uppercase` nu een reeks karaktertokens ziet en ons gewenste resultaat kan produceren. 8. Nadat alle karaktertokens geproduceerd door `\jobname`, keert TeX terug naar het verkrijgen van tokens uit zijn vorige invoerbron (ons `.tex` bestand) vanwaar het het volgende token zal lezen: de afsluitende `}` vereist om de lijst met tokens te beëindigen die door `\uppercase`. ### \expandafter en interne tokenlijsten Tijdelijke tokenlijsten zijn een *essentieel* element van `\expandafter`’s verwerkingsgedrag: inzicht in het gebruik en bestaan van die tokenlijsten kan helpen verduidelijken hoe `\expandafter` zijn resultaten bereikt, vooral wanneer men probeert macro’s te schrijven of te begrijpen die gebruikmaken van meerdere opeenvolgende `\expandafter` commando’s om complexere vormen van tokenverwerking te bereiken: `\expandafter\expandafter\expandafter...` Een ander sleutelelement van `\expandafter`’s gedrag, vooral bij meerdere opeenvolgende `\expandafter` commando’s, is het gebruik van *recursie* (binnen de TeX-software zelf)—een onderwerp dat we later in dit artikel zullen bespreken. Om ons begrip van tijdelijke tokenlijsten verder te ondersteunen, bekijken we nog een voorbeeld van `\expandafter`, ditmaal met de `\the` opdracht moet interpreteren. #### \expandafter en interne tokenlijsten: voorbeeld 2 In dit voorbeeld zullen we zien hoe `\expandafter` kan worden gebruikt om tokens te beïnvloeden die zijn opgeslagen in een tokenregister via het `\toks` commando. Hier zijn de TeX-primitieven die we zullen gebruiken: * `**\count** *register*=*getal*`: een TeX-primitief dat wordt gebruikt om de waarde `*getal*` op de TeX-positie `*register*`; * `**\toks** *register*={*tokenlijst*}`: een TeX-primitief dat wordt gebruikt om `*tokenlijst*` op de tokenregisterpositie op te slaan `*register*`—een reeks tokens opslaand voor later gebruik; * `**\the** *token*`: een expandeerbaar TeX-primitief commando dat `*token*`, hoewel de exacte resultaten afhangen van de aard van het `*token*` dat wordt verwerkt. `\the` heeft een aantal toepassingen: waaronder het zetten van de waarde die is opgeslagen in een TeX-parameter of -variabele (bijv. een register). Andere toepassingen van `\the` omvatten het invoegen van een kopie van tokens die zijn opgeslagen in een tokenregister. Hier gebruiken we `\the` om de waarde te zetten die is opgeslagen in een `\count` register. We beginnen met de volgende TeX-code om de waarde op te slaan `12345` in TeX’ `\count` register `99`: ``` \count99=12345 ``` Als we de waarde willen zetten die is opgeslagen in `\count99` kunnen we `\the\count99` (of `\number\count99`). Vervolgens gebruiken we het `\toks` commando om enkele tokens op te slaan in tokenregister `99`: ``` \toks99={\the\count99 } ``` De lijst met tokens die is opgeslagen in tokenregister `99` zou het volgende bevatten: | | | | ------------------- | --------------------------------------------------------------------------------------------------------------- | | **TeX-tokenwaarde** | **Vertegenwoordigd item** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (tekencode 57 met categoricode 12) resulterend in een tokenwaarde van $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (tekencode 57 met categoricode 12), resulterend in een tokenwaarde van $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (tekencode 32 met categoricode 10), resulterend in een tokenwaarde van $$256 \times 10 + 32 = 2592$$ | Merk op dat de tokenlijst gemaakt door `\toks99` bevat *niet* de daadwerkelijke gegevenswaarde bevat die is opgeslagen in `\count99` omdat het `\toks` commando geen expansie uitvoert: het maakt simpelweg tokens aan en slaat ze op. In ons voorbeeld, `\the` wordt niet geëxpandeerd, dus verwerkt het `\count99`; hier `\the` wordt het slechts omgezet in een token (waarde 5382) en opgeslagen in de tokenlijst. Als we willen dat de `\toks99` tokenlijst tokens bevat die gegevens voorstellen die zijn opgeslagen in `\count99` dan zullen we een manier moeten hebben om die tokens aan te maken (beschikbaar te maken), zodat het `\toks` commando er toegang toe kan krijgen. En natuurlijk `\expandafter` kan dit voor ons doen. Als we schrijven: ``` \toks99=\expandafter{\the\count99 } ``` wordt de werking/verwerking van het `\toks` commando “in de wacht gezet” terwijl `\expandafter` de expansie van `\the` veroorzaakt (afdwingt), wat op zijn beurt werkt op `\count` om een tijdelijke tokenlijst te genereren die karaktertokens bevat die gegevens voorstellen die zijn opgeslagen in `\count99`. Een klein maar belangrijk punt is de `` teken na de cijfers `99`: dat `` teken fungeert als beëindiging van TeX’ scanproces wanneer het naar een numerieke waarde zoekt. Hier is de werking van `\expandafter` zeer vergelijkbaar met het `\jobname` voorbeeld. 1. Lees en sla de openings `{`token. 2. Lees het volgende token, `\the`token, dat een expandeerbaar commando voorstelt, dus TeX expandeert het. `\expandafter` dwingt de expansie af van `\the` dat vervolgens werkt op `\count99` om gegevens opgeslagen in `\count` register `99` (het getal 12345) om te zetten in een tijdelijke tokenlijst. Die lijst zal karaktertokens bevatten die de cijfers voorstellen `1`, `2`, `3`, `4` en `5`—karaktertokens met categoricode 12. 3. Nadat `\the`, TeX de `{`token “terug in de invoer” plaatst en de tokenlijst gebruikt die voortkomt uit `\the\count99` zodat TeX zal lezen `\toks99={`token``tokenlijst (tekens)`}` en dit levert ons gewenste resultaat op. Deze opeenvolging van gebeurtenissen wordt samengevat in het volgende diagram—lees de afbeelding van onder naar boven om de processtroom te volgen. ![Hoe \expandafter werkt](/files/a4a3ed0fb8ffac02d286eadcecef6af5390da06e) 1. TeX begint met het verwerken van `\toks`; het ziet het optionele `=` teken, en controleert vervolgens op het verplichte openingsaccoladekenmerk (`{`, of elk teken met categoricode 1) dat wordt gebruikt om het begin van een tokenlijst aan te geven. TeX detecteert echter een `\expandafter` commando en gaat in plaats daarvan verder met het uitvoeren daarvan. 2. Als we `\expandafter` $$\mathrm{T\_1T\_2}$$ in onze invoer van `\expandafter{\the\count99 }` kunnen we zien $$\mathrm{T\_1} =$$ `{`token en $$\mathrm{T\_2} =$$ `\thetoken`. 3. `\expandafter` leest, en slaat vervolgens tijdelijk de `{`token (TeX slaat die gehele tokenwaarde tijdelijk op in een interne variabele). Later zal TeX dat token opnieuw in de invoer invoegen, na verwerking van `\the` 4. `\expandafter` leest TeX het volgende token, `\the`token en het expandeert. 5. De expansie van `\the` maakt een tijdelijke tokenlijst door verwerking van `\count99`—die tokenlijst bevat een reeks karaktertokens die de gegevenswaarde voorstellen die is opgeslagen in de `\count` register `99`. 6. Zodra `\the` is geëxpandeerd, voegt TeX het in stap 3 opgeslagen token opnieuw in (`{`token) en plaatst dat token terug in de invoer. TeX doet dat door nog een tokenlijst te maken die de *enkele* token `{`token. 7. TeX heeft nu klaar met het verwerken van `\expandafter` en heeft twee tokenlijsten geproduceerd die klaar zijn om als volgende invoerbronnen te worden gebruikt. TeX keert terug naar het verwerken van `\toks99=` maar nu heeft TeX zijn invoer zo geconfigureerd dat de twee tokenlijsten gemaakt door `\expandafter` de bron van tokens worden voor `\toks`—die nu ziet `{`token``tokenlijst (tekens)`}`. `\toks` kan nu toegang krijgen tot, en opslaan, de reeks van 5 karaktertokens die de gegevenswaarde (`12345`) voorstellen die is opgeslagen in `\count99`: ons gewenste resultaat. 8. Nadat alle karaktertokens geproduceerd door `\the\count99`, keert TeX terug naar het verkrijgen van tokens uit zijn vorige invoerbron (ons `.tex` bestand) vanwaar het het volgende token zal lezen: de afsluitende `}` vereist om de lijst met tokens te beëindigen die moet worden opgeslagen door `\toks99={...}`. ## Hoe \expandafter echt werkt In deze sectie bekijken we TeX zelf op “laag niveau”: we verkennen de broncode/functies binnen TeX die het gedrag van `\expandafter`. Details worden uitgedrukt in pseudo-C-code, maar zouden toegankelijk moeten zijn voor iedereen die bekend is met andere programmeertalen. Het volgende geannoteerde diagram legt uit hoe TeX implementeert `\expandafter` als onderdeel van een grotere functie genaamd `expand()`—de kernfunctie die TeX’ expansieverwerking aanstuurt. Binnen de sectie die verantwoordelijk is voor de implementatie van `\expandafter` kunnen we zien [*recursief* gedrag](https://en.wikipedia.org/wiki/Recursion) waarbij een andere aanroep van de `expand()` functie wordt gebruikt om het tweede ingelezen token te verwerken, $$\mathrm{T\_2}$$, voor die gevallen waarin $$\mathrm{T\_2}$$ expandeerbaar is. Hoewel deze code in Knuths TeX-engine voorkomt, zijn de basisprincipes die dit diagram schetst van toepassing op alle TeX-engines. ![Hoe \expandafter werkt binnen TeX](/files/b36b20e9398dbcdbd4f795f3c82c5a89b366a2a9) De eerste taak van `expand()` is om te bepalen of het commando dat moet worden geëxpandeerd een macro of een primitief is, omdat macro’s een gespecialiseerd expansieproces hebben dat wordt afgehandeld door een functie genaamd `macrocall()`. Als het commando dat moet worden geëxpandeerd een primitief is, gebruikt de `expand()` functie de huidige commandocodewaarde (opgeslagen in globale variabele `curcmd`) om te identificeren welk specifiek primitief moet worden verwerkt. We kunnen deze details zien in een meer volledige lijst van `expand()`: ``` void expand(void) { //curcmd is een globale variabele if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Verwerk het commando \expandafter T1T2 { gettoken(); // Lees token T1 t = curtok; // Sla token T1 op in de lokale variabele t gettoken(); // Lees token T2 if(curcmd > 100) // Is token T2 uitbreidbaar? expand(); // Ja! T2 is uitbreidbaar: // voer de expansie van T2 uit door // een recursieve functieaanroep naar expand() te doen else backinput(); // T2 is niet uitbreidbaar: zet dat token // terug in de invoer om later opnieuw gelezen te worden curtok = t ; // Zet de globale variabele curtok terug naar de opgeslagen waarde van T1 backinput() ; // Zet token T1 terug in de invoer // vóór de tokens die voortkomen uit de expansie van T2 } break; // Code om andere uitbreidbare opdrachten te verwerken case “commando om naar tekst om te zetten”: // Een van \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Ze hebben dezelfde waarde van curcmd break; case \noexpand: // Onderdruk de expansie van het volgende token ... break; case \csname: // Maak een naam voor een controlesequentie. ... break; case \the: // Voeg enkele tokens in .... break; case “\if... testcommando” : // Verwerk een van TeX’ voorwaardelijke constructies: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case “\fi of \else”: // Beëindig de huidige voorwaardelijke constructie ... break; // enzovoort voor andere uitbreidbare primitieve commando's die worden ondersteund door // de TeX-engine } }else // Geen uitbreidbare primitieve: het is een macro { macrocall() } //... meer code verwijderd } ``` ### TeX’ liefde voor globale variabelen Misschien als weerspiegeling van zijn leeftijd en het tijdperk waarin het is ontworpen, maakt de broncode van TeX uitgebreid gebruik van zogenoemde [globale variabelen](https://en.wikipedia.org/wiki/Global_variable)—in feite zijn er honderden. Vanwege hun aard kunnen globale variabelen overal binnen de broncode van TeX worden gewijzigd/aangepast—wat voor Knuths TeX een enkel monolithisch bestand is van meer dan 25.000 regels code en honderden functies. Begrijpen hoe TeX werkt is niet altijd een gemakkelijke taak... Om te verwerken `\expandafter`, leest TeX tokens uit zijn huidige invoer met behulp van een functie genaamd `gettoken()` waarvan de werking is een token te maken en de waarde van verschillende belangrijke globale variabelen in te stellen die overal in de broncode van TeX worden gebruikt. Twee van zulke variabelen, bijgewerkt door de werking van `gettoken()`, worden gebruikt in de implementatie van `\expandafter`: * `curtok`: (huidige token) de gehele waarde van het zojuist gelezen token; * `curcmd`: (huidige commando-code) de commando-code van het commando (of teken) dat door het token wordt vertegenwoordigd `curtok`. Bij het verwerken van `\expandafter`$$\mathrm{T\_1T\_2}$$ leest TeX token $$\mathrm{T\_1}$$ en slaat zijn waarde tijdelijk (een geheel getal) op in een lokale variabele genaamd `t`. Vervolgens leest TeX $$\mathrm{T\_2}$$ en controleert of dat token een uitbreidbaar commando vertegenwoordigt—door te controleren of zijn commando-code (`curcmd`) > 100 is. Zo ja, dan moet TeX het commando dat wordt vertegenwoordigd door $$\mathrm{T\_2}$$ uitbreiden en doet het nog een aanroep naar de functie `expand()`: dit is een voorbeeld van *recursie* omdat het `expand()` functie zichzelf aanroept. Het besef van het recursieve karakter van expansie, vooral bij gebruik van `\expandafter`, kan helpen begrijpen hoe meerdere opeenvolgende `\expandafter` commando's—d.w\.z., `\expandafter\expandafter\expandafter...` hun effect bereiken. Als token $$\mathrm{T\_2}$$ uitbreidbaar is, vindt de expansie plaats en wanneer de recursieve aanroep naar `expand()` terugkeert, code binnen de implementatie van `\expandafter` voegt token opnieuw in $$\mathrm{T\_1}$$ in de invoer. De globale variabele `curtok` wordt opnieuw toegewezen aan de waarde van het opgeslagen token—opgeslagen in de lokale variabele `t`, wat de waarde is van token $$\mathrm{T\_1}$$—en er wordt een aanroep gedaan naar de functie `backinput().` #### De functie backinput() Zoals de naam al suggereert, zet deze functie een token “terug in de invoer”. Om dat te doen gebruikt TeX de huidige waarde van de globale variabele `curtok` om een tokenlijst te maken die één enkel token bevat (waarvan de gehele waarde wordt geleverd door `curtok`). TeX zorgt er ook voor dat zijn invoerafhandeling ervoor zorgt dat die lijst met één token op het juiste moment opnieuw door TeX wordt gelezen als onderdeel van de daaropvolgende invoerverwerking. Merk zorgvuldig op dat token $$\mathrm{T\_1}$$ opnieuw wordt ingevoegd *nadat de expansie is voltooid*, waardoor TeX dat opnieuw ingevoegde token zal lezen *voordat* wanneer het de tokens leest die voortkomen uit de expansie van $$\mathrm{T\_2}$$. ### Macro's verwerken: de macrocall()-functie Zoals eerder besproken, zijn alle macro's, samen met enkele primitieve commando's, uitbreidbaar en verloopt alle verwerking van expansie via de `expand()` functie. Echter, `expand()` zorgt ervoor om de `curcmd` (huidige commando)-waarde te gebruiken om onderscheid te maken tussen uitbreidbare primitieve commando's en macro's, omdat het macro-expansieproces wordt afgehandeld door een speciale functie genaamd `macrocall()`. Macro's hebben een gespecialiseerd expansieproces nodig omdat macroargumenten en scheidingsteken-tokens op een zeer specifieke en strikte manier moeten worden gezocht; daarom wordt dat proces gedelegeerd aan een functie die daarvoor is ontworpen: `macrocall()`. #### Macro-expansie versus macro-uitvoering Macro *expansie* is niet hetzelfde proces als macro *uitvoering*: expansie van een macro is het pre-uitvoeringsproces dat TeX uitvoert om de macro *gereed te maken voor uitvoering*. De “uitvoering” van een macro vindt plaats wanneer TeX actief tokens leest en verwerkt die in de definitie (vervangende tekst) van die macro en zijn argumenten (parameters) zijn opgenomen. #### Macro-expansie Om een macro uit te breiden controleert TeX eerst of de macro argumenten heeft; zo ja, `macrocall()` zeer zorgvuldig de invoer scant op zoek naar tokens die de argumenten van de macro zullen worden. Dat proces omvat het controleren van de invoer van de gebruiker op eventuele scheidingsteken-tokens die in de oorspronkelijke definitie van de macro zijn gebruikt—het patroon van tokens in een macroaanroep moet exact overeenkomen met het patroon van tokens in de opgeslagen definitie. Tokens die als scheidingstekens worden gebruikt, worden echter simpelweg door TeX verworpen: in feite zijn ze slechts een vorm van “interpunctie” die TeX gebruikt om de werkelijke tokens te bepalen die de argumenten van de macro zullen vormen—d.w\.z. tokens die de gebruiker bedoelt voor verwerking door de macro. Zie voor meer informatie over scheidingsteken-tokens [Hoe TeX-macro's echt werken](/latex/nl/meer-onderwerpen/22-how-tex-macros-actually-work-part-4.md). Voor elke parameter (`#1, #2...#9`) die aanwezig is in de oorspronkelijke definitie van de macro, scant TeX de daadwerkelijke macroaanroep om vast te stellen welke tokens die door de gebruiker zijn geleverd, bestemd zijn voor elke parameter (d.w\.z. de argumenten van de macro vormen). Dat proces levert een of meer mini-tokenlijsten op: één voor elk macroargument. Nadat eventuele macroargumenten zijn gedetecteerd en hun tokenlijsten zijn voorbereid, haalt TeX de definitie van de macro (vervangende tekst) op die in zijn geheugen is opgeslagen en richt het zijn invoerverwerking zo in dat, telkens wanneer TeX gereed is om meer tokens te lezen/verwerken, het die uit de vervangende tekst van de macro zal lezen en zo de macro uitvoert. Op het juiste moment, tijdens de macro-uitvoering, zullen tokenlijsten die de macroargumenten vertegenwoordigen, op de juiste plaats in de vervangende tekst van de macro worden ingevoegd. Nogmaals, expansie van een macrocommando betekent *verwijderen van* dat macrocommando (token) uit de invoer en *vervangen van* het door de tokenlijst die is opgeslagen als de vervangende tekst van de macro. Voor een diepgaande blik op TeX’ macroverwerking zie de zesdelige artikelreeks [Hoe werken TeX-macro's eigenlijk?](/latex/nl/meer-onderwerpen/01-a-six-part-series-how-do-tex-macros-actually-work.md) [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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.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.