> 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/sv/fordjupade-artiklar/17-how-does-expandafter-work-a-detailed-macro-case-study.md).
# Hur fungerar \expandafter: en detaljerad fallstudie av ett makro
[Del 1](/latex/sv/fordjupade-artiklar/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/sv/fordjupade-artiklar/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/sv/fordjupade-artiklar/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/sv/fordjupade-artiklar/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/sv/fordjupade-artiklar/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/sv/fordjupade-artiklar/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Fallstudie: \\\expandafter exempel från The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Manual
Den $$\varepsilon\mathrm{\text{-}{\TeX}}$$ skriftsättningsmotorn härstammar från Knuths TeX-programvara och var ursprungligen avsedd som ett ”tillfälligt” steg mot utvecklingen av [Nya skriftsättningssystemet](https://en.wikipedia.org/wiki/New_Typesetting_System) (NTS), skrivet i programmeringsspråket Java. $$\varepsilon\mathrm{\text{-}{\TeX}}$$ utvecklades först i slutet av 1990-talet för att lägga till en uppsättning nya primitiva kommandon som ger ytterligare funktionalitet som inte fanns i Knuths originalprogram. Även om $$\varepsilon\mathrm{\text{-}{\TeX}}$$ har fått regelbundna uppdateringar sedan den första utgåvan används den i dag inte i någon större utsträckning som en fristående skriftsättningsmotor, även om dess innovationer har införlivats i senare generationer av TeX: pdfTeX, XeTeX och LuaTeX.
Den [$$\varepsilon\mathrm{\text{-}{\TeX}}$$ manual](http://mirror.ox.ac.uk/sites/ctan.org/systems/doc/etex/etex_man.pdf) innehåller ett belysande exempel på en makro som på ett smart sätt använder `\expandafter`:
```
\\def\\foo#1#2{\\number#1
\\ifnum#1<#2,
\\expandafter\\foo
\\expandafter{\\number\\numexpr#1+1\\expandafter}%
\\expandafter{\\number#2\\expandafter}%
\\fi}
```
`\foo` implementerar en loopmekanism, så att `\\foo{7}{13}` ger `7, 8, 9, 10, 11, 12, 13`; men, `\foo` använder inte någon *tilldelning till variabler* för att styra loopprocessen — vilket gör den till ett intressant makro att undersöka närmare.
### Lite bakgrund: uttryck och tilldelningar
Ett viktigt element i `\foo`s kod är dess användning av kommandot `\numexpr`, ett kommando ur en uppsättning av fyra besläktade primitiv som först infördes av $$\varepsilon\mathrm{\text{-}{\TeX}}$$: `\numexpr`, `\dimexpr`, `\glueexpr` och `\muexpr`. Deras syfte är att konstruera så kallade *uttryck* som möjliggör beräkning/manipulation av TeX-värden av typen number, dimen, glue eller muglue (respektive). Som diskuteras på sidorna 8–9 i The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Manual, en viktig egenskap hos *uttryck* är att deras utvärdering (beräkning) inte kräver att TeX utför några *tilldelningar*.
I programmeringstermer är tilldelning processen att sätta (tilldela) en variabel till att ha ett visst värde; till exempel att tilldela `\count` register `99` att innehålla värdet `12345` via `\\count99=12345`. Många andra typer av tilldelningar sker under TeX-bearbetning — såsom att tilldela tokenregister att innehålla en serie tokens, att tilldela boxregister att innehålla boxinnehåll och så vidare.
För att utföra en tilldelning, såsom `\\count99=12345`, behöver TeX agera (utföra) den interna kod som implementerar beteendet hos `\count` eller något annat primitivt kommando som utför någon form av tilldelning. Det finns dock tillfällen när TeX utför ren *expansion* och, vid dessa tillfällen, actioneras sådana tilldelningar inte —*vid den punkten i TeX:s bearbetning*. Exempel på denna situation inkluderar följande kommandon:
* `\\edef\\command {*token list*}` makrodefinitionskommandot ”expanderad definition” som expanderar tokens i *token lista* och lagrar resultaten som definitionen av `\\command`.
* `\\write *number* {*token list*}` expanderar tokens i `*token list*` och skriver ut dem till en fil som representeras av `*number*`.
* `\\directlua {*token list*}` detta LuaTeX-primitivkommando används för att överföra Lua-kod till den inbyggda Lua-tolken. Alla tokens i `*token list*` expanderas fullständigt innan de skickas till Lua-tolken för körning.
#### Snabbt exempel på \\\edef
Om vi skriver följande grundläggande makron:
```
\\def\\mycount{\\count99=12345}
\\edef\\mymacro{\\mycount}
```
`\edef` kommer att expandera `\\mycount` till dess beståndsdelstokens, men det går inte längre än så: inget av kommandona som finns i definitionen av `\\mymacro` kommer att actioneras: dvs. tilldelningen av `12345` till `\\count99` *sker inte vid denna punkt*; först när vi anropar `\\mymacro` kommer den tilldelningen att äga rum när TeX utför koden för att bearbeta `\count` primitivet. När TeX utför *aktiviteter som bara gäller expansion* kommer alla tilldelningar att utföras senare i TeX:s bearbetning, inte under själva expansionsprocessen.
#### Varför är tilldelningar av intresse här?
När man skriver kod för att utföra en loop — i vilket programmeringsspråk som helst — är det vanligt att ha en variabel avsedd att fungera som en ”loopräknare”: den används för att styra antalet gånger en loop körs. Loopning styrs vanligtvis genom att testa om den utsedda loopräknarvariabeln har nått ett visst värde — variabeln ökas (eller minskas) för varje iteration av loopen. Men att ändra en loopräknarvariabel innebär att tilldela den ett nytt värde, vilket för TeX vanligtvis kräver det primitiva kommandot `\advance` för att öka (eller minska) ett värde som lagras i ett `\count` register. Som vi har sett kan sådana tilldelningar (inklusive att öka variabler) inte ske under TeX:s rena expansionsprocess: makrot `\foo` kringgår skickligt denna begränsning.
### Tillbaka till att förklara \\\foo
Makrot `\foo` kan styra loopprocessen *utan* utan att behöva tilldela värden till några variabler: det styr hur ofta loopen sker med hjälp av data som uppstår vid expansion: datavärden som lagras i tillfälliga tokenlistor. Med vår kunskap om TeX:s användning (skapande) av tillfälliga tokenlistor kan vi titta närmare för att se exakt hur `\foo` uppnår sina resultat.
**Kom ihåg**: Vi arbetar oss igenom körningen av ett makro efter att den ursprungliga texten i dess definition — som finns i en fysisk `.tex` fil — har skannats (lästs in av TeX) och konverterats till en tokenlista som representerar makrodefinitionen. I grund och botten följer vi TeX:s bearbetning av dessa lagrade *tokens* medan den läser och bearbetar tokens i makrodefinitionen som finns någonstans i TeX:s minne. Alla blanktecken som ursprungligen fanns i TeX-koden för makrots definition (text inom `.tex` filen) har antingen absorberats medan TeX skannade texten efter kommandon (blanktecken som avgränsare), eller så har de konverterats till tokens, såsom blanktecknet efter kommat (`,`) i `\\ifnum#1<#2,` som uppstod genom konvertering av radslutstecknet (`\r`) till ett blanktecken.
Eftersom TeX-koden i `\foo` använder flera `\expandafter` kommandon, kommer vi att hjälpa vår förklaring genom att lägga till index till varje `\expandafter`, vilket anger vilken vi syftar på. Dessutom kommer vi att utöka notationen för tokens som bearbetas av `\expandafter` till $$\mathrm{T^i\_1}$$ och $$\mathrm{T^i\_2}$$, och representera tokens $$\mathrm{T\_1}$$ och $$\mathrm{T\_2}$$ för `\\expandafteri`: `\\expandafteri` $$\mathrm{T^i\_1T^i\_2}$$
Här är den kommenterade makrokoden:
```
\\def\\foo#1#2{\\number#1
\\ifnum#1<#2,
\\expandafter1\\foo
\\expandafter2{\\number\\numexpr#1+1\\expandafter3}%
\\expandafter4{\\number#2\\expandafter5}%
\\fi}
```
`\foo` börjar med `\\number#1` som använder det expanderbara kommandot `\number` för att omvandla det första argumentvärdet till dess sättningsrepresentation. The `\number` kommandot fungerar genom att generera en tillfällig tokenlista som innehåller teckentokens som representerar de enskilda siffror som ingår i det numeriska värde som `\number` arbetar med. Den tokenlistan blir TeX:s nästa inmatningskälla. Här läses den tokenlistan in och tokens skrivs ut för att sätta värdet av `#1`.
Nästa steg är att makrot utför testet `\\ifnum#1<#2` för att kontrollera om argumentet för `#1` är mindre än argumentet som skickas in för `#2`. Om så är fallet, skrivs en komma- (`,`) token ut (sätts) följt av lite blanksteg som uppstår från token som genererades från radbrytningstecknet efter kommat (`,`). Det blankstecknet genererades först när TeX läste denna rad från `.tex` -filen.
Makrot fortsätter sedan med att bearbeta detta nästa kodavsnitt, som är kärnan i dess funktion:
```
\\expandafter1\\foo
\\expandafter2{\\number\\numexpr#1+1\\expandafter3}%
\\expandafter4{\\number#2\\expandafter5}%
\\fi}
```
I grunden genererar denna kod en serie tillfälliga tokenlistor som resulterar i flera anrop till `\foo` makrot, och avslutas när if-testet `\\ifnum#1<#2` inte längre är sant. Men *hur* är loopningen kontrollerad eftersom inga tilldelningar sker: var är ”loopräknaren”?
Låt oss börja med att titta på koden `\\expandafter1\\foo\\expandafter2`. Observera att vi kommer att använda indexnotationen `token` (eller `(token)`) för att påminna oss om att här läser/bearbetar TeX numeriska tokenvärden (heltal).
Här har vi följande tokens som indata för `\expandafter1`:
* $$\mathrm{T^1\_1} =$$`\\footoken` som läses in och lagras för senare *återinsättning* tillbaka i inmatningen
* $$\mathrm{T^1\_2} =$$`\expandafter2 (token)` som expanderas
För `\expandafter2` har vi:
* $$\mathrm{T^2\_1} =$$`{token` som sparas för senare *återinsättning* tillbaka i inmatningen
* $$\mathrm{T^2\_2} =$$ `\\numbertoken` som expanderas
**Obs:**`\number` är ett expanderbart kommando vars syfte är att ”konvertera till tokens”: dvs. att konvertera en numerisk mängd till en serie teckentokens som representerar den mängden. När `\number` expanderas är det första som TeX gör att skanna inmatningen och leta efter heltal: en process som utlöser ytterligare expansion.
**Nyckeln till historien:** Här är `\number` agerar på *uttrycket* `\\numexpr#1+1` som beräknar värdet av `#1+1`. Resultatet av den beräkningen bearbetas av `\number` för att konvertera det till en tillfällig tokenlista som innehåller teckentokens som representerar värdet av `#1 + 1`. Den tillfälliga tokenlistan, genererad av `\number`, kommer så småningom att läsas in som det första argumentet till ytterligare ett anrop till `\foo`. I stället för att öka en loopräknare (via `\advance` och tilldelning) skapar användningen av `\numexpr` skapar ett nytt värde men utan att tilldelning behöver göras. Genom denna mekanism ökas variabeln som styr loopen (`\foo`s parameter `#1`) och iterationen genom loopen styrs och avslutas: ganska genialt!
Sedan, `\expandafter3` bearbetas, vilket ger:
* $$\mathrm{T^3\_1} =$$`}token` som sparas för senare *återinsättning* tillbaka i inmatningen
* $$\mathrm{T^3\_2} =$$`\\expandafter4 (token)`, som expanderas:
För `\\expandafter4` har vi:
* $$\mathrm{T^4\_1} =$$`{token` som sparas för senare *återinsättning* tillbaka i inmatningen
* $$\mathrm{T^4\_2} =$$`\\numbertoken` som expanderas och omvandlar `#2` till ytterligare en tillfällig tokenlista.
Slutligen,`\\expandafter5` expanderas:
* $$\mathrm{T^5\_1} =$$`}token` som sparas för senare *återinsättning* tillbaka i inmatningen
* $$\mathrm{T^5\_2} =$$`\\fitoken`, som är ett expanderbart kommando.
Expansionen av `\fi` avslutar effektivt `\ifnum` och stänger i praktiken denna iteration av makrot. TeX slutför nu återinsättningen av alla tokens som tillfälligt sparats av de flera `\expandafter` kommandona: detta genererar en serie tokenlistor med en enda token som härrör från de tokens som sparats av varje `\expandafter`. Dessutom har TeX också skapat tokenlistor genom åtgärden av `\number`.
### Sammanställning av tokenlistorna
I grunden genererar `\foo` makrot en sekvens av tokenlistor: du kan tänka på `\foo` som en ”tillverkningsanläggning” för tokenlistor. Dessa tokenlistor läses av TeX för att bli nästa inmatningskällor. Den smarta delen finns i en av de tidigare åtgärderna hos `\foo`:
```
\\expandafter1\\foo\\expandafter2
```
genom vilka `\foo` ordnar så att det anropar sig självt igen men med andra argument som lagras i tokenlistor konstruerade av `\number`. För att få dessa tokenlistor att tillsammans bete sig som ett makroanrop har klamrarna `{` och `}` alla sparats och återinförts i inmatningen (som tokenlistor med en enda token) genom åtgärderna av `\expandafter` kommandon.
[Del 1](/latex/sv/fordjupade-artiklar/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/sv/fordjupade-artiklar/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/sv/fordjupade-artiklar/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/sv/fordjupade-artiklar/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/sv/fordjupade-artiklar/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/sv/fordjupade-artiklar/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/sv/fordjupade-artiklar/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.