> 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/no/dybdeartikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md). # Hvordan fungerer \expandafter: En detaljert makrocase-studie [Del 1](/latex/no/dybdeartikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/no/dybdeartikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/no/dybdeartikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/no/dybdeartikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/no/dybdeartikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/no/dybdeartikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Kasusstudie: \expandafter eksempel fra The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Håndboken Den $$\varepsilon\mathrm{\text{-}{\TeX}}$$ settemotoren ble avledet fra Knuths TeX-programvare og var opprinnelig ment som et «midlertidig» steg mot utviklingen av den [Nytt typografisystem](https://en.wikipedia.org/wiki/New_Typesetting_System) (NTS), skrevet i programmeringsspråket Java. $$\varepsilon\mathrm{\text{-}{\TeX}}$$ ble først utviklet på slutten av 1990-tallet for å legge til en samling nye primitive kommandoer som gir ekstra funksjonalitet som ikke var tilgjengelig i Knuths opprinnelige program. Selv om $$\varepsilon\mathrm{\text{-}{\TeX}}$$ har fått periodiske oppdateringer siden den opprinnelige utgivelsen, brukes den i dag ikke mye som en frittstående settemotor, selv om nyvinningene har blitt innlemmet i senere generasjoner av TeX: pdfTeX, XeTeX og LuaTeX. Den [$$\varepsilon\mathrm{\text{-}{\TeX}}$$ manual](http://mirror.ox.ac.uk/sites/ctan.org/systems/doc/etex/etex_man.pdf) inneholder et opplysende eksempel på en makro som gjør smart bruk av `\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økkemekanisme, slik at `\foo{7}{13}` gir `7, 8, 9, 10, 11, 12, 13`; men, `\foo` bruker ingen *tilordninger til variabler* for å styre løkkeprosessen – noe som gjør den til en interessant makro å undersøke nærmere. ### Litt bakgrunn: uttrykk og tilordninger En viktig del av `\foo`sin kode er bruken av kommandoen `\numexpr`, en kommando fra et sett med fire beslektede primitiver først introdusert av $$\varepsilon\mathrm{\text{-}{\TeX}}$$: `\numexpr`, `\dimexpr`, `\glueexpr` og `\muexpr`. *uttrykk* som tillater beregning/manipulering av TeX-verdier av typen number, dimen, glue eller muglue (henholdsvis). Som diskutert på sidene 8–9 i The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Håndboken, er en viktig egenskap ved *uttrykk* er at evalueringen (beregningen) deres ikke krever at TeX utfører noen *tilordninger*. I programmeringstermer er tilordning prosessen med å sette (tilordne) en variabel til å ha en bestemt verdi; for eksempel å tilordne `\count` register `99` til å inneholde verdien `12345` via `\count99=12345`. Mange andre typer tilordning finner sted under TeX-behandling – som å tilordne tokenregistre til å inneholde en rekke tokens, tilordne boksregistre til å inneholde boksinnhold, og så videre. For å utføre en tilordning, slik som `\count99=12345`, må TeX aktivere (kjøre) den interne koden som implementerer oppførselen til `\count` eller et hvilket som helst annet primitiv som utfører en form for tilordning. Men det finnes tider når TeX utfører ren *utvidelse* og, i slike tilfeller, blir slike tilordninger ikke utført –*på det tidspunktet i TeXs behandling*. Eksempler på denne situasjonen inkluderer følgende kommandoer: * `\edef\command {*token list*}` kommandoen for makrodefinisjon «utvidet definisjon» som utvider tokens i *tokenliste* og lagrer resultatene som definisjonen av `\command`. * `\write *number* {*token list*}` utvider tokens i `*token list*` og skriver dem ut til en fil representert av `*number*`. * `\directlua {*token list*}` denne LuaTeX-primitive kommandoen brukes til å sende Lua-kode til den innebygde Lua-tolkeren. Alle tokens i `*token list*` blir fullt utvidet før de sendes til Lua-tolkeren for kjøring. #### Kort eksempel på \edef Hvis vi skriver følgende grunnleggende makroer: ``` \def\mycount{\count99=12345} \edef\mymacro{\mycount} ``` `\edef` vil utvide `\mycount` til sine bestanddeler tokens, men går ikke lenger: ingen av kommandoene som finnes i definisjonen av `\mymacro` vil bli utført: dvs. tilordningen av `12345` til `\count99` *skjer ikke på dette tidspunktet*; først når vi kaller `\mymacro` vil den tilordningen finne sted mens TeX kjører koden for å behandle `\count` primitivet. Når TeX utfører *kun-utvidelsesaktiviteter* vil eventuelle tilordninger bli utført senere i TeXs behandling, ikke under selve utvidelsesprosessen. #### Hvorfor er tilordninger av interesse her? Når man skriver kode for å utføre en løkke – i et hvilket som helst programmeringsspråk – er det vanlig å ha en variabel utpekt til å fungere som en «løkketeller»: brukt til å styre hvor mange ganger en løkke kjøres. Løkking styres vanligvis ved å teste om den utpekte løkketeller-variabelen har nådd en bestemt verdi – den variabelen økes (eller reduseres) for hver iterasjon av løkken. Men å endre en løkketeller-variabel betyr å tilordne den en ny verdi, noe som for TeX vanligvis krever den primitive kommandoen `\advance` for å øke (eller redusere) en verdi som er lagret i en `\count` register. Som vi har sett, kan slike tilordninger (inkludert å øke variabler) ikke finne sted under TeXs rene utvidelsesprosess: makroen `\foo` omgår dette problemet på en smart måte. ### Tilbake til forklaringen av \foo Makroen `\foo` er i stand til å styre løkkeprosessen *uten* uten å måtte tilordne verdier til noen variabler: den styrer hvor ofte løkken skjer ved hjelp av data som oppstår fra utvidelse: dataverdier lagret i midlertidige tokenlister. Ved å bruke vår kunnskap om TeXs bruk (opprettelse) av midlertidige tokenlister kan vi se nærmere på nøyaktig hvordan `\foo` oppnår resultatene sine. **Husk**: Vi går gjennom kjøringen av en makro etter at den opprinnelige teksten i definisjonen dens – som ligger i en fysisk `.tex` fil – er blitt skannet (lest inn av TeX) og konvertert til en tokenliste som representerer makrodefinisjonen. I hovedsak følger vi TeXs behandling av disse lagrede *tokens* mens den leser og behandler tokens i makrodefinisjonen som ligger et sted i TeXs minne. Eventuelle mellomromstegn som opprinnelig fantes i TeX-koden for makroens definisjon (tekst innenfor `.tex` filen) vil ha blitt absorbert mens TeX skannet teksten etter kommandoer (mellomrom som avgrensere), eller de vil ha blitt konvertert til tokens, som mellomromstegnet etter kommaet (`,`) i `\ifnum#1<#2,` som oppstod fra konverteringen av linjeslutttegnet (`\r`) til et mellomrom. Fordi TeX-koden i `\foo` bruker flere `\expandafter` kommandoer, skal vi hjelpe forklaringen vår ved å legge til indekser til hver `\expandafter`, som viser hvilken vi sikter til. I tillegg utvider vi notasjonen for tokens behandlet av `\expandafter` til $$\mathrm{T^i\_1}$$ og $$\mathrm{T^i\_2}$$, som representerer tokens $$\mathrm{T\_1}$$ og $$\mathrm{T\_2}$$ for `\expandafteri`: `\expandafteri` $$\mathrm{T^i\_1T^i\_2}$$ Her er den annoterte makrokoden: ``` \def\foo#1#2{\number#1 \ifnum#1<#2, \expandafter1\foo \expandafter2{\number\numexpr#1+1\expandafter3}% \expandafter4{\number#2\expandafter5}% \fi} ``` `\foo` starter med `\number#1` som bruker den utvidbare kommandoen `\number` for å konvertere verdien til det første argumentet til dens typografiske representasjon. Kommandoen `\number` virker ved å generere en midlertidig tokenliste som inneholder tegntokens som representerer de enkelte sifrene i den numeriske verdien som `\number` den opererer på. Den tokenlisten blir TeXs neste inndatakilde. Her leses den tokenlisten inn, og tokenene skrives ut for å sette opp verdien av `#1`. Deretter utfører makroen testen `\ifnum#1<#2` for å sjekke om argumentet for `#1` er mindre enn argumentet som ble sendt inn for `#2`.`,`) for å bli skrevet ut (satt) etterfulgt av noe mellomrom som oppstår fra tokenet som ble generert av linjeskifttegnet etter kommaet (`,`). Dette mellomromstegnet ble først generert da TeX leste denne linjen fra `.tex` filen. Makroen fortsetter ved å behandle denne neste delen av koden, som er kjernen i dens virkemåte: ``` \expandafter1\foo \expandafter2{\number\numexpr#1+1\expandafter3}% \expandafter4{\number#2\expandafter5}% \fi} ``` I hovedsak genererer denne koden en rekke midlertidige tokenlister som resulterer i flere kall til `\foo` makroen, og avsluttes når if-testen `\ifnum#1<#2` ikke lenger er sann. Men *hvordan* er løkkestyringen kontrollert fordi ingen tilordninger finner sted: hvor er «løkketelleren»? La oss begynne med å se på koden `\expandafter1\foo\expandafter2`. Merk at vi vil bruke indeksnotasjonen `token` (eller `(token)`) for å minne oss selv om at TeX her leser/behandler numeriske (heltalls-) tokenverdier. Her har vi følgende tokens som input for `\expandafter1`: * $$\mathrm{T^1\_1} =$$`\footoken` som leses inn og lagres for senere *innsetting på nytt* tilbake i inndataen * $$\mathrm{T^1\_2} =$$`\expandafter2 (token)` som utvides For `\expandafter2` har vi: * $$\mathrm{T^2\_1} =$$`{token` som lagres til senere *innsetting på nytt* tilbake i inndataen * $$\mathrm{T^2\_2} =$$ `\numbertoken` som utvides **Merk:**`\number` er en utvidbar kommando hvis formål er å «konvertere til tokens»: dvs. konvertere en numerisk størrelse til en serie tegn-tokens som representerer den størrelsen. Når `\number` utvides, er det første TeX gjør å skanne inputen etter heltall: en prosess som utløser videre utvidelse. **Nøkkelen til historien:** Her er `\number` virker på *uttrykket* `\numexpr#1+1` som beregner verdien av `#1+1`. `\number` for å konvertere det til en midlertidig tokenliste som inneholder tegntokens som representerer verdien av `#1 + 1`. `\number`, vil til slutt bli lest inn som det første argumentet til enda et kall til `\foo`. `\advance` I stedet for å øke en løkketeller (via `\numexpr` og tilordning), gjør bruken av`\foo`s parameter `#1`) økes, og iterasjonene gjennom løkken styres og avsluttes: ganske genialt! Deretter, `\expandafter3` behandles, noe som gir: * $$\mathrm{T^3\_1} =$$`}token` som lagres til senere *innsetting på nytt* tilbake i inndataen * $$\mathrm{T^3\_2} =$$`\expandafter4 (token)`, som utvides: For `\expandafter4` har vi: * $$\mathrm{T^4\_1} =$$`{token` som lagres til senere *innsetting på nytt* tilbake i inndataen * $$\mathrm{T^4\_2} =$$`\numbertoken` som utvides og konverterer `#2` til enda en midlertidig tokenliste. Til slutt,`\expandafter5` utvides: * $$\mathrm{T^5\_1} =$$`}token` som lagres til senere *innsetting på nytt* tilbake i inndataen * $$\mathrm{T^5\_2} =$$`\fitoken`, som er en utvidbar kommando. Utvidelsen av `\fi` avslutter i praksis `\ifnum` og avslutter i praksis denne iterasjonen av makroen. TeX fullfører nå gjeninnsettingen av alle tokenene som midlertidig ble lagret av de mange `\expandafter` kommandoene: dette genererer en rekke tokenlister med ett enkelt token, som stammer fra tokenene som ble lagret av hver `\expandafter`. I tillegg har TeX også opprettet tokenlister fra gjennom virkningen av `\number`. ### Sammenstilling av tokenlistene I hovedsak `\foo` makroen genererer en sekvens av tokenlister: du kan tenke på `\foo` som et «produksjonsanlegg» for tokenlister. Disse tokenlistene leses av TeX for å bli de neste inndatakildene. Den smarte delen ligger i en av de tidligere handlingene til `\foo`: ``` \expandafter1\foo\expandafter2 ``` hvorved `\foo` ordner makroen å kalle seg selv igjen, men med andre argumenter som er lagret i tokenlister konstruert av `\number`. For at disse tokenlistene samlet skal oppføre seg som et makrokall, er klammeparentesene `{` og `}` alle blitt lagret og satt inn igjen i inputen (som tokenlister med ett enkelt token) ved handlingene til `\expandafter` kommandoer. ![tokenlister generert av \foo-makroen](/files/df498aea0daaad0d244e4fc02f2ac8e6d7fc2295) [Del 1](/latex/no/dybdeartikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/no/dybdeartikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/no/dybdeartikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/no/dybdeartikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/no/dybdeartikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/no/dybdeartikler/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/no/dybdeartikler/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.