> 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/17-how-does-expandafter-work-a-detailed-macro-case-study.md). # Hvordan virker \expandafter: Et detaljeret makrocase-studie [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) ## Casestudie: \expandafter-eksempel fra The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Håndbog Den $$\varepsilon\mathrm{\text{-}{\TeX}}$$ sættermotor blev afledt af Knuths TeX-software og var oprindeligt tænkt som et “midlertidigt” skridt mod udviklingen af [Nyt sættersystem](https://en.wikipedia.org/wiki/New_Typesetting_System) (NTS), skrevet i programmeringssproget Java. $$\varepsilon\mathrm{\text{-}{\TeX}}$$ blev først udviklet i slutningen af 1990’erne for at tilføje en pakke af nye primitive kommandoer, som giver yderligere funktionalitet, der ikke findes i Knuths oprindelige program. Selv om $$\varepsilon\mathrm{\text{-}{\TeX}}$$ har fået periodiske opdateringer siden den første udgivelse, er den i dag ikke meget brugt som en selvstændig sættermotor, selv om dens innovationer er blevet optaget i senere generationer af TeX: pdfTeX, XeTeX og LuaTeX. Den [$$\varepsilon\mathrm{\text{-}{\TeX}}$$ håndbog](http://mirror.ox.ac.uk/sites/ctan.org/systems/doc/etex/etex_man.pdf) indeholder et oplysende eksempel på en makro, som gør klog brug af `\expandafter`: ``` \def\foo#1#2{\number#1 \ifnum#1<#2, \expandafter\foo \expandafter{\number\numexpr#1+1\expandafter}% \expandafter{\number#2\expandafter}% \fi} ``` `\foo` implementerer en løbemekanisme, således at `\foo{7}{13}` giver `7, 8, 9, 10, 11, 12, 13`; men `\foo` ikke bruger nogen *tildelinger til variabler* for at styre løbeprocessen — hvilket gør den til en interessant makro at udforske i noget detaljer. ### Noget baggrund: udtryk og tildelinger Et vigtigt element i `\foo`’s kode er dens brug af kommandoen `\numexpr`, en kommando fra et sæt på fire beslægtede primitiver, først introduceret af $$\varepsilon\mathrm{\text{-}{\TeX}}$$: `\numexpr`, `\dimexpr`, `\glueexpr` og `\muexpr`. Deres formål er at konstruere såkaldte *udtryk* , som gør det muligt at beregne/manipulere TeX-værdier af typen number, dimen, glue eller muglue (henholdsvis). Som omtalt på siderne 8–9 i The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Håndbog, er en vigtig egenskab ved *udtryk* er, at deres evaluering (beregning) ikke kræver, at TeX udfører nogen *tildelinger*. I programmeringstermer er tildeling processen, hvor en variabel sættes (tildeles) til at have en bestemt værdi; for eksempel at tildele `\count` register `99` til at indeholde værdien `12345` via `\count99=12345`. Mange andre typer tildelinger finder sted under TeX-behandling — såsom at tildele tokenregistre til at indeholde en række tokens, at tildele bokregistre til at indeholde boksindhold og så videre. For at udføre en tildeling, såsom `\count99=12345`, har TeX brug for at aktivere (udføre) den interne kode, som implementerer adfærden for `\count` eller en anden primitiv, som udfører en eller anden form for tildeling. Men der er tidspunkter, hvor TeX udfører ren *ekspansion* og på de tidspunkter bliver sådanne tildelinger ikke aktiveret —*på det tidspunkt i TeX’s behandling*. Eksempler på denne situation omfatter følgende kommandoer: * `\edef\command {*token list*}` kommandoen til makrodefinition med “udvidet definition”, som udvider tokens i *token list* og gemmer resultaterne som definitionen af `\command`. * `\write *number* {*token list*}` udvider tokens i `*token list*` og skriver dem ud i en fil repræsenteret af `*number*`. * `\directlua {*token list*}` denne LuaTeX-primitivkommando bruges til at overføre Lua-kode til den indbyggede Lua-fortolker. Alle tokens i `*token list*` udvides fuldt ud, før de sendes til Lua-fortolkeren til udførelse. #### Hurtigt eksempel på \edef Hvis vi skriver de følgende grundlæggende makroer: ``` \def\mycount{\count99=12345} \edef\mymacro{\mycount} ``` `\edef` vil udvide `\mycount` til dens bestanddelstokens, men det går ikke videre: ingen af de kommandoer, der er indeholdt i definitionen af `\mymacro` vil blive aktiveret: dvs. tildelingen af `12345` til `\count99` *sker ikke på dette tidspunkt*; kun når vi kalder `\mymacro` vil den tildeling finde sted, når TeX udfører koden til at behandle `\count` primitiven. Når TeX udfører *kun-ekspansionsaktiviteter* vil enhver tildeling blive aktiveret senere i TeX’s behandling, ikke under ekspansionsprocessen i sig selv. #### Hvorfor er tildelinger interessante her? Når man skriver kode til at udføre en løkke — i ethvert programmeringssprog — er det almindelig praksis at have en variabel udpeget til at fungere som en “løbetæller”: brugt til at styre antallet af gange, en løkke udføres. Løkning styres typisk ved at teste, om den udpegede løbetæller-variabel har nået en bestemt værdi — variablen øges (eller mindskes) for hver iteration af løkken. Men at ændre en løbetæller-variabel betyder at tildele den en ny værdi, hvilket for TeX normalt kræver den primitive kommando `\advance` til at øge (eller mindske) en værdi gemt i en `\count` register. Som vi har set, kan sådanne tildelinger (herunder at øge variabler) under TeX’s rene ekspansionsproces ikke finde sted: makroen `\foo` omgår elegant denne begrænsning. ### Tilbage til at forklare \foo Makroen `\foo` kan styre løbeprocessen *uden* at behøve at tildele værdier til nogen variabler: den styrer, hvor ofte løkken finder sted, ved hjælp af data, der opstår fra ekspansion: dataværdier gemt i midlertidige tokenlister. Ved hjælp af vores viden om TeX’s brug (oprettelse) af midlertidige tokenlister kan vi se nærmere på, hvordan `\foo` opnår sine resultater. **Husk**: Vi arbejder os gennem udførelsen af en makro efter den oprindelige tekst i dens definition — indeholdt i en fysisk `.tex` fil — er blevet scannet (læst ind af TeX) og konverteret til en tokenliste, der repræsenterer makrodefinitionen. I bund og grund følger vi TeX’s behandling af disse lagrede *tokens* mens den læser og behandler tokens i makrodefinitionen, som er indeholdt et sted i TeX’s hukommelse. Eventuelle mellemrumstegn, som oprindeligt var til stede i TeX-koden til makroens definition (tekst i `.tex` filen) vil være blevet opslugt, mens TeX scannede den tekst for kommandoer (mellemrum som afslutningstegn), eller de vil være blevet konverteret til tokens, såsom mellemrumstegnet efter kommaet (`,`) i `\ifnum#1<#2,` som opstod ved konvertering af linjeskifttegnet (`\r`) til et mellemrum. Fordi TeX-koden i `\foo` bruger flere `\expandafter` kommandoer, vil vi hjælpe vores forklaring ved at tilføje indekser til hver `\expandafter`, hvilket angiver, hvilken en vi henviser til. Derudover udvider vi notation for tokens, der behandles af `\expandafter` til $$\mathrm{T^i\_1}$$ og $$\mathrm{T^i\_2}$$, idet vi repræsenterer tokens $$\mathrm{T\_1}$$ og $$\mathrm{T\_2}$$ for `\expandafteri`: `\expandafteri` $$\mathrm{T^i\_1T^i\_2}$$ Her er den annoterede makrokode: ``` \def\foo#1#2{\number#1 \ifnum#1<#2, \expandafter1\foo \expandafter2{\number\numexpr#1+1\expandafter3}% \expandafter4{\number#2\expandafter5}% \fi} ``` `\foo` begynder med `\number#1` som bruger den ekspanderbare kommando `\number` til at omdanne den første arguments værdi til dens typograferede repræsentation. Kommandoen `\number` fungerer ved at generere en midlertidig tokenliste, der indeholder tegntokens, som repræsenterer de individuelle cifre i den numeriske værdi, som `\number` arbejder på. Den tokenliste bliver TeX’s næste inputkilde. Her bliver tokenlisten læst, og tokensene bliver outputtet for at satsætte værdien af `#1`. Dernæst udfører makroen testen `\ifnum#1<#2` for at kontrollere, om argumentet for `#1` er mindre end argumentet, der er sendt ind for `#2`. Hvis det er tilfældet, bliver et komma (`,`) token outputtet (satsat), efterfulgt af et mellemrum, der opstår fra tokenet, som blev genereret fra linjeskifttegnet efter kommaet (`,`). Dette mellemrumstegn blev først genereret, da TeX læste denne linje fra `.tex` filen. Makroen fortsætter ved at behandle dette næste afsnit af kode, som er kernen i dens virkemåde: ``` \expandafter1\foo \expandafter2{\number\numexpr#1+1\expandafter3}% \expandafter4{\number#2\expandafter5}% \fi} ``` I bund og grund genererer denne kode en række midlertidige tokenlister, som resulterer i flere kald til `\foo` makroen, og afslutter, når if-testen `\ifnum#1<#2` ikke længere er sand. Men *hvordan* styres løkken, når der ikke foretages nogen tildelinger: hvor er “løbetælleren”? Lad os begynde med at se på koden `\expandafter1\foo\expandafter2`. Bemærk, at vi vil bruge indeksnotationen `token` (eller `(token)`) for at minde os selv om, at TeX her læser/behandler numeriske (heltal) tokenværdier. Her har vi følgende tokens som input for `\expandafter1`: * $$\mathrm{T^1\_1} =$$`\footoken` som bliver læst ind og gemt til senere *genindsættelse* tilbage i inputtet * $$\mathrm{T^1\_2} =$$`\expandafter2 (token)` som bliver udvidet For `\expandafter2` har vi: * $$\mathrm{T^2\_1} =$$`{token` som gemmes til senere *genindsættelse* tilbage i inputtet * $$\mathrm{T^2\_2} =$$ `\numbertoken` som bliver udvidet **Bemærk:**`\number` er en ekspanderbar kommando, hvis formål er at “konvertere til tokens”: dvs. konvertere en numerisk størrelse til en række tegntokens, som repræsenterer denne størrelse. Når `\number` udvides, er det første, TeX gør, at scanne inputtet for heltal: en proces, som udløser yderligere udvidelse. **Nøglen til historien:** Her `\number` virker på *udtrykket* `\numexpr#1+1` som beregner værdien af `#1+1`. Resultatet af den beregning behandles af `\number` til at omdanne det til en midlertidig tokenliste, der indeholder tegntokens, som repræsenterer værdien af `#1 + 1`. Den midlertidige tokenliste, genereret af `\number`, vil til sidst blive læst ind som det første argument til endnu et kald af `\foo`. I stedet for at øge en løbetæller (via `\advance` og tildeling), skaber brugen af `\numexpr` en ny værdi, men uden at der er brug for tildeling. Via denne mekanisme bliver den variabel, der styrer løkken (`\foo`’s parameter `#1`) øget, og iterationen gennem løkken styres og afsluttes: ret genialt! Dernæst `\expandafter3` bliver behandlet, hvilket giver: * $$\mathrm{T^3\_1} =$$`}token` som gemmes til senere *genindsættelse* tilbage i inputtet * $$\mathrm{T^3\_2} =$$`\expandafter4 (token)`, som udvides: For `\expandafter4` har vi: * $$\mathrm{T^4\_1} =$$`{token` som gemmes til senere *genindsættelse* tilbage i inputtet * $$\mathrm{T^4\_2} =$$`\numbertoken` som udvides og omdanner `#2` til endnu en midlertidig tokenliste. Til sidst`\expandafter5` bliver udvidet: * $$\mathrm{T^5\_1} =$$`}token` som gemmes til senere *genindsættelse* tilbage i inputtet * $$\mathrm{T^5\_2} =$$`\fitoken`, som er en ekspanderbar kommando. Udvidelsen af `\fi` afslutter effektivt `\ifnum` og lukker i praksis denne iteration af makroen. TeX fuldfører nu genindsættelsen af alle de tokens, som midlertidigt blev gemt af de multiple `\expandafter` kommandoer: dette genererer en række tokenlister med enkelt-token, der stammer fra de tokens, som blev gemt af hver `\expandafter`. Derudover har TeX også oprettet tokenlister fra gennem handlingen af `\number`. ### Samling af tokenlisterne I bund og grund genererer `\foo` makroen en sekvens af tokenlister: man kan tænke på `\foo` som en tokenliste-“produktionsfacilitet”. Disse tokenlister læses af TeX for at blive de næste inputkilder. Den smarte del ligger i en af de tidligere handlinger i `\foo`: ``` \expandafter1\foo\expandafter2 ``` gennem hvilken `\foo` arrangerer at kalde sig selv igen, men med andre argumenter, der er gemt i tokenlister konstrueret af `\number`. For at få disse tokenlister til samlet at opføre sig som et makrokald, er klammerne `{` og `}` alle blevet gemt og genindsat i inputtet (som enkelt-tokenlister) af handlingerne i `\expandafter` kommandoerne. ![tokenlister genereret af \foo-makroen](/files/cabdd0bcd86f472289c0437471d72c5e77d8419f) [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/17-how-does-expandafter-work-a-detailed-macro-case-study.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.