> 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/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Hvordan virker \expandafter: Fra grundlæggende principper til udforskning af TeX's kildekode [Del 1](/latex/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/da/dybtgaende-artikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/da/dybtgaende-artikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/da/dybtgaende-artikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Introduktion Vi har nu dækket de baggrundsemner, der er nødvendige for en fuldstændig gennemgang af `\expandafter`: * det grundlæggende om TeX-tokens, og hvordan de beregnes; * principperne bag TeX’s udvidelsesproces; * TeX’s brug/oprettelse af midlertidige tokenlister under dokumentbehandling; * hvordan TeX bruger og “jonglerer” med flere inputkilder (herunder midlertidige tokenlister). I denne artikel vil vi samle disse emner/konceptet for at forklare mekanismerne bag TeX’s `\expandafter` kommando: kort sagt, hvordan den virker. ## Og således, til \expandafter Ideen bag `\expandafter` er at tvinge udvidelse af en kommando (token), før TeX normalt ville gøre det. Givet to tokens, $$\mathrm{T\_1}$$ og $$\mathrm{T\_2}$$ handlingen af `\expandafter` $$\mathrm{T\_1T\_2}$$ resulterer i, at TeX behandler $$\mathrm{T\_1}\text{<}$$udvidelsen af $$\mathrm{T\_2}\text{>}$$, hvor $$\text{<}\dots\text{>}$$ angiver en liste af tokens. TeX udvider $$\mathrm{T\_2}$$ på forhånd, så token $$\mathrm{T\_1}$$ (f.eks. en primitiv eller en makro) får lov til at se, eller kan handle på, de tokens, der opstår ved udvidelsen af $$\mathrm{T\_2}$$. Hvis token $$\mathrm{T\_2}$$ repræsenterer et ikke-udvideligt element såsom et ikke-aktivt tegn eller (de fleste) primitiver, ændrer handlingen af `\expandafter` ændrer ikke noget: TeX ville fortsætte med at behandle tokens $$\mathrm{T\_1T\_2}$$ på normal vis. ### Introduktion til brug af \expandafter Hvis du ikke har brugt `\expandafter`, er her et eksempel på brugen af det sammen med primitiven `\uppercase{...}`. Antag, at vi ønskede at sætte navnet på vores hoved- `.tex` inputfil i store bogstaver. Vi kender måske følgende TeX-primitivkommandoer: * `\uppercase`: gør, som navnet antyder, og omdanner tegn-tokens til deres ækvivalent i store bogstaver (hvor det findes); * `\jobname`: som vi har set, udvides til at give navnet på den hoved- `.tex` filen. Antag, at vores TeX-fil hedder `mycode.tex` kunne vi med rimelighed forvente `\uppercase{\jobname}` at sætte i tryk `MYCODE`. Men nej, den sætter i tryk `mycode` i små bogstaver. Hvad gik “galt”? Hvis vi skriver den generelle brug af `\uppercase` som ``` \uppercase{} ``` kan vi sige, at `\uppercase` ser igennem `` og kun vil operere (ændre store/små bogstaver) på *tegn-tokens* den finder i ``: alle ikke-tegn-tokens bliver *ignoreret* fordi `\uppercase` ikke vil “se ind i” (udvide) ikke-tegn-tokens for at se, hvad de indeholder eller repræsenterer. Fordi en token blot er en heltalsværdi, behøver `\uppercase` bare at gennemgå tokenlisten for at kontrollere, om den numeriske værdi af hver token i `` falder inden for det interval af værdier, der angiver en tegn-token. I øvrigt, `\uppercase` vil også *ændre store/små bogstaver for aktive tegn* for at skabe et aktivt tegn i store bogstaver, som, fordi det stadig er aktivt, også skal være defineret; ellers vil TeX generere en fejl: `Udefineret kontrolsekvens`, men vi afviger... For eksempel, selv hvis vi definerer en makro, der blot er tekst ``` \def\foo{some lower-case text} ``` så `\uppercase{\foo}` sætter stadig i tryk `some lower-case text` og ikke `SOME LOWER-CASE TEXT` som vi ville håbe, ganske enkelt fordi handlingen af `\uppercase` forsøger ikke at fastslå, hvad `\foo` repræsenterer: den ser `\foo` som et kommando-token og ignorerer det, ligesom den gjorde med `\jobname`. ### Hvordan kan vi rette dette? \expandafter kommer til undsætning For at sætte en version af filnavnet i store bogstaver skal vi ændre `\uppercase{\jobname}` ved at tvinge TeX til at erstatte `\jobname` med dets udvidelse (en sekvens af tegn-tokens) *før* `\uppercase` går i gang. Endnu en gang bruges udvidelse til at fjerne `\jobname` tokenen (kommandoen) og erstatte den med resultatet af dens udvidelse (en tokenliste, der indeholder tegn-tokens). Så hvis vi skriver ``` \uppercase\expandafter{\jobname} ``` så virker det: `MYCODE` ville blive sat i tryk. Det, der sker, er, at TeX begynder at behandle `\uppercase` og kontrollerer straks efter det obligatoriske åbningsklamme-tegn (`{`); men TeX opdager en `\expandafter` kommando, som får den til midlertidigt at “aflede sin opmærksomhed” til at behandle `\expandafter{\jobname}`. Hvis vi sammenligner `\expandafter` $$\mathrm{T\_1T\_2}$$ med vores eksempel `\expandafter{\jobname}` kan vi se * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\jobname`token Hvor `{`token og `\jobname`token henviser til de tokenværdier, som TeX beregner—indeksnotationen token bruges for at minde os selv om, at TeX arbejder i en verden af heltalstokens. At skrive `\uppercase\expandafter{\jobname}` virker, fordi, i store træk (detaljer følger), `\expandafter` får TeX til at udføre følgende opgaver: 1. læs og gem det indledende `{`token; 2. læs den næste token: `\jobname`token. TeX genkender, at `\jobname`token repræsenterer en udvidelig kommando og udvider den. `\jobname`token erstattes med dens udvidelse—en række tegn-tokens; 3. efter udvidelsen af `\jobname` kommandoen lægger TeX `{`$$\_\mathrm{token}$$ “tilbage i inputtet” og bruger tokenlisten, der opstår ved udvidelsen af `\jobname` så TeX vil læse `\uppercase{`token``tokenliste (tegn)`}`, og dette giver det ønskede resultat. Følgende diagram viser, hvordan TeX behandler `\uppercase\expandafter{\jobname}`—læs grafikken nedefra og arbejd opad for at følge procesforløbet. ![Hvordan \expandafter virker](/files/9b901250091c460100b5aabb98cbb9da435b1906) Følgende noter forklarer de forskellige behandlingsstadier. 1. TeX begynder at behandle `\uppercase` og kontrollerer efter det obligatoriske åbningsklamme-tegn (`{`) men opdager en `\expandafter` kommandoen. 2. Hvis vi sammenligner `\expandafter` $$\mathrm{T\_1T\_2}$$ til vores input af `\expandafter{\jobname}` kan vi se $$\mathrm{T\_1} =$$`{`token og $$\mathrm{T\_2} =$$`\jobname`token. Bemærk, at vi her vil bruge indeks- token til at angive, at TeX behandler heltalstokenværdier. 3. `\expandafter` læser og gemmer derefter midlertidigt `{`token ved at gemme den heltalstokenværdi i en intern variabel. Senere vil TeX sætte den token ind i inputtet igen efter behandlingen af `\jobname` kommandoen. 4. `\expandafter` læser den næste token, `\jobname`token, og udvider `\jobname` kommandoen. 5. Udvidelsen af `\jobname` opretter en midlertidig tokenliste, som indeholder en sekvens af tegn-tokens, der repræsenterer `.tex` filnavnet. Bemærk, at alle tegn-tokens, der genereres af `\jobname` beregnes ved hjælp af kategori-kode 12. 6. Når først `\jobname` er blevet udvidet, sætter TeX tokenen, der blev gemt i trin 3 (`{`token) og sætter den tilbage i inputtet. Det gør TeX ved at oprette endnu en tokenliste, der indeholder det *enkelt* `{`token 7. TeX er nu færdig med at behandle `\expandafter`, hvilket resulterer i to tokenlister, der er klar til at blive brugt som kilder til TeX-input. TeX vender nu tilbage til at behandle `\uppercase` men har konfigureret sit input sådan, at de to tokenlister, der blev oprettet af `\expandafter` bliver kilden til tokens for `\uppercase`—som nu ser `\uppercase{`token``tokenliste (tegn)`}`. `\uppercase` nu ser en sekvens af tegn-tokens og kan frembringe det ønskede resultat. 8. Efter at have læst alle de tegn-tokens, der produceres af `\jobname`vender TeX tilbage til at hente tokens fra sin tidligere inputkilde (vores `.tex` fil), hvorfra den vil læse den næste token: den afsluttende `}` der er nødvendig for at afslutte listen af tokens, der skal behandles af `\uppercase`. ### \expandafter og interne tokenlister Midlertidige tokenlister er et *afgørende* element i `\expandafter`’s behandlingsadfærd: at forstå brugen og eksistensen af disse tokenlister kan hjælpe med at afklare, hvordan `\expandafter` opnår sine resultater, især når man forsøger at skrive eller forstå makroer, der bruger flere på hinanden følgende `\expandafter` kommandoer for at opnå mere komplekse former for tokenbehandling: `\expandafter\expandafter\expandafter...` Et andet nøgleelement i `\expandafter`’s adfærd, især med flere på hinanden følgende `\expandafter` kommandoer, er brugen af *rekursion* (inde i selve TeX-softwaren)—et emne, vi vil behandle senere i denne artikel. For yderligere at hjælpe vores forståelse af midlertidige tokenlister vil vi se på endnu et eksempel på `\expandafter`, denne gang med `\the` kommandoen. #### \expandafter og interne tokenlister: eksempel 2 I dette eksempel vil vi se, hvordan `\expandafter` kan bruges til at påvirke tokens, der er gemt i et tokenregister via `\toks` kommandoen. Her er de TeX-primitiver, vi vil bruge: * `**\count** *register*=*tal*`: en TeX-primitiv, der bruges til at gemme værdien `*tal*` i TeX-placeringen `*register*`; * `**\toks** *register*={*tokenliste*}`: en TeX-primitiv, der bruges til at gemme `*tokenliste*` i tokenregister-placeringen `*register*`—og dermed gemme en sekvens af tokens til senere brug; * `**\the** *token*`: en udvidelig TeX-primitivkommando, som behandler `*token*`, selv om de nøjagtige resultater afhænger af arten af den `*token*` der behandles. `\the` har en række anvendelser: blandt dem er at sætte den værdi i tryk, der er gemt i en TeX-parameter eller -variabel (f.eks. et register). Andre anvendelser af `\the` omfatter indsættelse af en kopi af tokens, der er gemt i et tokenregister. Her vil vi bruge `\the` til at sætte værdien, der er gemt i en `\count` register, i tryk. Vi starter med følgende TeX-kode for at gemme værdien `12345` i TeX’s `\count` register `99`: ``` \count99=12345 ``` Hvis vi vil sætte værdien, der er gemt i `\count99` kan vi bruge `\the\count99` (eller `\number\count99`). Dernæst vil vi bruge `\toks` kommandoen til at gemme nogle tokens i tokenregister `99`: ``` \toks99={\the\count99 } ``` Listen af tokens, der er gemt i tokenregister `99` ville indeholde følgende: | | | | ------------------ | --------------------------------------------------------------------------------------------------------------------- | | **TeX-tokenværdi** | **Repræsenteret element** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (tegnkode 57 med kategori-kode 12), hvilket resulterer i en tokenværdi på $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (tegnkode 57 med kategori-kode 12), hvilket resulterer i en tokenværdi på $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (tegnkode 32 med kategori-kode 10), hvilket resulterer i en tokenværdi på $$256 \times 10 + 32 = 2592$$ | Bemærk, at tokenlisten, der oprettes af `\toks99` gør *ikke* indeholder den faktiske dataværdi, der er gemt i `\count99` fordi `\toks` kommandoen ikke udfører udvidelse: den opretter blot tokens og gemmer dem. I vores eksempel, `\the` bliver ikke udvidet, så den behandler ikke `\count99`; her `\the` omdannes blot til en token (værdi 5382) og gemmes i tokenlisten. Hvis vi ønsker, at `\toks99` tokenlisten skal indeholde tokens, der repræsenterer data gemt i `\count99` har vi brug for en måde at skabe disse tokens (gøre dem tilgængelige) på, så `\toks` kommandoen kan få adgang til dem. Og selvfølgelig `\expandafter` kan gøre dette for os. Hvis vi skriver: ``` \toks99=\expandafter{\the\count99 } ``` handlingen/behandlingen af `\toks` kommandoen vil blive “sat på pause”, mens `\expandafter` forårsager (tvinger) udvidelse af `\the` som til gengæld virker på `\count` for at generere en midlertidig tokenliste, der indeholder tegn-tokens, som repræsenterer data gemt i `\count99`. Et lille, men vigtigt punkt er `` tegn efter cifrene `99`: det `` tegn fungerer som afslutning på TeX’s scanningproces, når den søger efter en numerisk værdi. Her er handlingen af `\expandafter` meget lig `\jobname` eksemplet. 1. Læs og gem den indledende `{`token. 2. Læs den næste token, `\the`token, som repræsenterer en udvidelig kommando, så TeX udvider den. `\expandafter` tvinger udvidelse af `\the` som derefter virker på `\count99` for at omdanne data, der er gemt i `\count` register `99` (tallet 12345) til en midlertidig tokenliste. Den liste vil indeholde tegn-tokens, der repræsenterer cifrene `1`, `2`, `3`, `4` og `5`—tegn-tokens med kategori-kode 12. 3. Efter udvidelse og behandling af `\the`, sætter TeX `{`token “tilbage i inputtet” og bruger tokenlisten, der opstår ved `\the\count99` så TeX vil læse `\toks99={`token``tokenliste (tegn)`}` og dette giver det ønskede resultat. Denne rækkefølge af hændelser er opsummeret i følgende diagram—læs grafikken nedefra og arbejd opad for at følge procesforløbet. ![Hvordan \expandafter virker](/files/7a041f51db8c360d6a41093838363b484defcacc) 1. TeX begynder at behandle `\toks`; den ser det valgfrie `=` tegn, og kontrollerer derefter det obligatoriske åbningsklamme-tegn (`{`, eller et hvilket som helst tegn med kategori-kode 1), som bruges til at angive starten på en tokenliste. Men TeX opdager en `\expandafter` kommando og fortsætter i stedet med at udføre den. 2. Hvis vi sammenligner `\expandafter` $$\mathrm{T\_1T\_2}$$ til vores input af `\expandafter{\the\count99 }` kan vi se $$\mathrm{T\_1} =$$ `{`token og $$\mathrm{T\_2} =$$ `\thetoken`. 3. `\expandafter` læser og gemmer derefter midlertidigt `{`token (TeX gemmer midlertidigt denne heltalstokenværdi i en intern variabel). Senere vil TeX sætte den token ind i inputtet igen efter behandlingen af `\the` 4. `\expandafter` læser den næste token, `\the`token og udvider den. 5. Udvidelsen af `\the` opretter en midlertidig tokenliste ud fra behandlingen af `\count99`—den tokenliste indeholder en sekvens af tegn-tokens, som repræsenterer dataværdien gemt i `\count` register `99`. 6. Når først `\the` er blevet udvidet, sætter TeX tokenen, der blev gemt i trin 3 (`{`token) og sætter den token tilbage i inputtet. Det gør TeX ved at oprette endnu en tokenliste, der indeholder det *enkelt* token `{`token. 7. TeX er nu færdig med at behandle `\expandafter` og har frembragt to tokenlister, klar til at blive brugt som de næste inputkilder. TeX vender tilbage til at behandle `\toks99=` men nu har TeX konfigureret sit input, så de to tokenlister, der blev oprettet af `\expandafter` bliver kilden til tokens for `\toks`—som nu ser `{`token``tokenliste (tegn)`}`. `\toks` kan få adgang til og gemme sekvensen af 5 tegn-tokens, som repræsenterer dataværdien (`12345`) gemt i `\count99`: vores ønskede resultat. 8. Efter at have læst alle de tegn-tokens, der produceres af `\the\count99`vender TeX tilbage til at hente tokens fra sin tidligere inputkilde (vores `.tex` fil), hvorfra den vil læse den næste token: den afsluttende `}` der er nødvendig for at afslutte listen af tokens, der skal gemmes af `\toks99={...}`. ## Hvordan \expandafter faktisk virker I dette afsnit vil vi tage et “lavniveau”-blik ind i selve TeX: vi undersøger kildekoden/funktionerne i TeX, som implementerer adfærden af `\expandafter`. Detaljerne er udtrykt i pseudo-C-kode, men bør være tilgængelige for enhver, der er fortrolig med andre programmeringssprog. Følgende annoterede diagram forklarer, hvordan TeX implementerer `\expandafter` som en del af en større funktion kaldet `expand()`—kernefunktionen, som driver TeX’s udvidelsesbehandling. Inden for sektionen, der er ansvarlig for implementeringen af `\expandafter` kan vi se [*rekursiv* adfærd](https://en.wikipedia.org/wiki/Recursion) hvor et andet kald til `expand()` funktionen bruges til at behandle den andet indlæste token, $$\mathrm{T\_2}$$, for de tilfælde hvor $$\mathrm{T\_2}$$ er udvidelig. Selvom denne kode forekommer i Knuths TeX-motor, er de grundlæggende principper, der skitseres af denne grafik, gældende for alle TeX-motorer. ![Hvordan \expandafter virker inde i TeX](/files/9f9933d6e261094f0eb4f29e1615249589a4bba8) Den første opgave for `expand()` er at afgøre, om kommandoen, der skal udvides, er en makro eller en primitiv, fordi makroer har en specialiseret udvidelsesproces, som håndteres af en funktion kaldet `macrocall()`. Hvis kommandoen, der skal udvides, er en primitiv, bruger `expand()` funktionen den aktuelle kommando-kodeværdi (gemt i den globale variabel `curcmd`) til at identificere, hvilken bestemt primitiv der skal behandles. Vi kan se disse detaljer i en mere komplet udskrift af `expand()`: ``` void expand(void) { //curcmd er en global variabel if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Behandl kommandoen \expandafter T1T2 { gettoken(); // Læs token T1 t = curtok; // Gem token T1 i den lokale variabel t gettoken(); // Læs token T2 if(curcmd > 100) // Er token T2 udvidelig? expand(); // Ja! T2 er udvidelig: // udfør udvidelse af T2 ved // at lave et rekursivt funktionskald til expand() else backinput(); // T2 er ikke udvidelig: læg den token // tilbage i inputtet, så den kan læses igen (senere) curtok = t ; // Gendan den globale variabel curtok til den gemte værdi af T1 backinput() ; // Læg token T1 tilbage i inputtet // foran de tokens, der opstår ved udvidelsen af T2 } break; // Kode til at behandle andre udvidelige kommandoer case “konverter til tekst”-kommando: // En hvilken som helst af \number, \string, \romannumeral, // \meaning, \fontname, \jobname // De deler den samme værdi af curcmd break; case \noexpand: // Undertryk udvidelsen af den næste token ... break; case \csname: // Opret et kontrolsekvensnavn. ... break; case \the: // Indsæt nogle tokens .... break; case “\if... test-kommando”: // Behandl en af TeX’s betingelser: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case “\fi eller \else”: // Afslut den aktuelle betingelse ... break; // osv. for enhver anden udvidelig primitiv kommando understøttet af // TeX-motoren } }else // Ikke en udvidelig primitiv: det er en makro { macrocall() } //... mere kode fjernet } ``` ### TeX’s kærlighed til globale variabler Måske afspejlende dens alder og den tid, den blev designet i, gør TeX’s kildekode omfattende brug af såkaldte [globale variabler](https://en.wikipedia.org/wiki/Global_variable)—faktisk er der hundredvis af dem. På grund af deres natur kan globale variabler ændres/modificeres fra hvor som helst i TeX-kildekoden—som for Knuths TeX er en enkelt monolitisk fil med over 25.000 linjer kode og hundredvis af funktioner. At forstå, hvordan TeX virker, er ikke altid nogen let opgave... For at behandle `\expandafter`, læser TeX tokens fra sit aktuelle input ved hjælp af en funktion kaldet `gettoken()` hvis handling er at oprette en token og sætte værdien af flere centrale globale variabler, der bruges gennem hele TeX’s kildekode. To sådanne variabler, opdateret af handlingen i `gettoken()`, bruges i implementeringen af `\expandafter`: * `curtok`: (aktuel token) heltalsværdien af den netop læste token; * `curcmd`: (aktuel kommandokode) kommandokoden for den kommando (eller karakter), som tokenen repræsenterer `curtok`. Når der behandles `\expandafter`$$\mathrm{T\_1T\_2}$$ læser TeX token $$\mathrm{T\_1}$$ og gemmer midlertidigt dens værdi (et heltal) i en lokal variabel kaldet `t`. Derefter læser TeX $$\mathrm{T\_2}$$ og kontrollerer, om denne token repræsenterer en udvidelig kommando—ved at tjekke om dens kommandokode (`curcmd`) er > 100. Hvis ja, skal TeX udvide kommandoen repræsenteret af $$\mathrm{T\_2}$$ og laver endnu et kald til funktionen `expand()`: dette er et eksempel på *rekursion* fordi `expand()` funktionen kalder sig selv. En bevidsthed om den rekursive natur af udvidelse, især når man bruger `\expandafter`, kan hjælpe med at forstå, hvordan flere på hinanden følgende `\expandafter` kommandoer—dvs., `\expandafter\expandafter\expandafter...` opnår deres virkninger. Hvis token $$\mathrm{T\_2}$$ er udvidelig, finder udvidelsen sted, og når det rekursive kald til `expand()` returnerer, vil kode i implementeringen af `\expandafter` indsætter token $$\mathrm{T\_1}$$ tilbage i inputtet. Den globale variabel `curtok` tildeles igen værdien af den gemte token—gemt i den lokale variabel `t`, som er værdien af token $$\mathrm{T\_1}$$—og der foretages et kald til funktionen `backinput().` #### Funktionen backinput() Som navnet antyder, lægger denne funktion en token “tilbage i inputtet”. For at gøre det bruger TeX den aktuelle værdi af den globale variabel `curtok` til at oprette en tokenliste, som indeholder en enkelt token (hvis heltalsværdi leveres af `curtok`). TeX indretter også sin inputhåndtering, så den enkelt-token-liste på det passende tidspunkt vil blive læst igen af TeX som en del af den efterfølgende inputbehandling. Bemærk nøje, at tokenen $$\mathrm{T\_1}$$ indsættes igen *efter at udvidelsen er færdig*, hvilket sikrer, at TeX vil læse den genindsatte token *før* når den læser de tokens, der opstår ved udvidelsen af $$\mathrm{T\_2}$$. ### Behandling af makroer: funktionen macrocall() Som tidligere nævnt er alle makroer, sammen med nogle primitive kommandoer, udvidelige, og al udvidelsesbehandling går gennem den `expand()` funktion. Dog `expand()` er omhyggelig med at bruge `curcmd` (aktuel kommando)-værdien til at skelne mellem udvidelige primitivkommandoer og makroer, fordi makroudvidelsesprocessen håndteres af en dedikeret funktion kaldet `macrocall()`. Makroer har brug for en specialiseret udvidelsesproces, fordi makroargumenter og skilletegns-tokens skal scannes på en meget bestemt og stringent måde; derfor delegeres denne proces til en funktion, der er designet til det: `macrocall()`. #### Makroudvidelse vs. makroudførelse Makro *udvidelse* er ikke den samme proces som makro *udførelse*: udvidelse af en makro er den før-udførelsesproces, TeX udfører for at gøre makroen *klar til udførelse*. “Udførelsen” af en makro sker, når TeX aktivt læser og behandler tokens indeholdt i makroens definition (erstatningstekst) og dens argumenter (parametre). #### Makroudvidelse For at udvide en makro tjekker TeX først, om makroen tager argumenter; hvis ja, `macrocall()` scanner TeX meget omhyggeligt inputtet for tokens, der er bestemt til at blive makroens argumenter. Den proces omfatter kontrol af brugerens input for eventuelle skilletegnstokens, der bruges i makroens oprindelige definition—mønstret af tokens, der bruges i et makrokald, skal præcist matche mønstret af tokens i den gemte definition. Tokens, der bruges som skilletegn, kasseres dog blot af TeX: de er i praksis bare en form for “tegnsætning”, som TeX bruger til at bestemme de faktiske tokens, der er bestemt til at blive makroens argumenter—dvs. tokens, som brugeren har til hensigt skal behandles af makroen. For mere information om skilletegnstokens, se [Hvordan TeX-makroer egentlig virker](/latex/da/flere-emner/22-how-tex-macros-actually-work-part-4.md). For hver parameter (`#1, #2...#9`) i makroens oprindelige definition scanner TeX det faktiske makrokald for at identificere, hvilke tokens brugeren har leveret, som er bestemt til hver parameter (dvs. udgør makroens argumenter). Den proces producerer en eller flere mini-tokenlister: én for hvert makroargument. Når eventuelle makroargumenter er blevet identificeret, og deres tokenlister er blevet forberedt, henter TeX makroens definition (erstatningstekst), der er gemt i dens hukommelse, og indretter sin inputbehandling sådan, at hver gang TeX er klar til at læse/behandle flere tokens, vil den læse dem fra makroens erstatningstekst og dermed udføre makroen. På det passende tidspunkt under makroudførelsen vil tokenlister, der repræsenterer makroargumenterne, blive indsat på den korrekte placering i makroens erstatningstekst. Endnu en gang betyder udvidelse af en makrokommando *at fjerne* den makrokommando (token) fra inputtet og *erstatte* den med tokenlisten, der er gemt som makroens erstatningstekst. For et dybdegående kig på TeX’s makrobehandling, se den seksdelte artikelserie [Hvordan virker TeX-makroer egentlig?](/latex/da/flere-emner/01-a-six-part-series-how-do-tex-macros-actually-work.md) [Del 1](/latex/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/da/dybtgaende-artikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/da/dybtgaende-artikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/da/dybtgaende-artikler/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/da/dybtgaende-artikler/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.